]> git.ipfire.org Git - thirdparty/gcc.git/blob - gcc/config/rs6000/rs6000.md
projects / thirdparty / gcc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add parens around expression.
[thirdparty/gcc.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 ])
105
106 ;;
107 ;; UNSPEC_VOLATILE usage
108 ;;
109
110 (define_constants
111 [(UNSPECV_BLOCK 0)
112 (UNSPECV_LL 1) ; load-locked
113 (UNSPECV_SC 2) ; store-conditional
114 (UNSPECV_EH_RR 9) ; eh_reg_restore
115 ])
116 \f
117 ;; Define an insn type attribute. This is used in function unit delay
118 ;; computations.
119 (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"
120 (const_string "integer"))
121
122 ;; Define floating point instruction sub-types for use with Xfpu.md
123 (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"))
124
125 ;; Length (in bytes).
126 ; '(pc)' in the following doesn't include the instruction itself; it is
127 ; calculated as if the instruction had zero size.
128 (define_attr "length" ""
129 (if_then_else (eq_attr "type" "branch")
130 (if_then_else (and (ge (minus (match_dup 0) (pc))
131 (const_int -32768))
132 (lt (minus (match_dup 0) (pc))
133 (const_int 32764)))
134 (const_int 4)
135 (const_int 8))
136 (const_int 4)))
137
138 ;; Processor type -- this attribute must exactly match the processor_type
139 ;; enumeration in rs6000.h.
140
141 (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,cell"
142 (const (symbol_ref "rs6000_cpu_attr")))
143
144
145 ;; If this instruction is microcoded on the CELL processor
146 ; The default for load extended, the recorded instructions and rotate/shifts by a variable is always microcoded
147 (define_attr "cell_micro" "not,conditional,always"
148 (if_then_else (eq_attr "type" "compare,delayed_compare,imul_compare,lmul_compare,load_ext,load_ext_ux,var_shift_rotate,var_delayed_compare")
149 (const_string "always")
150 (const_string "not")))
151
152 (automata_option "ndfa")
153
154 (include "rios1.md")
155 (include "rios2.md")
156 (include "rs64.md")
157 (include "mpc.md")
158 (include "40x.md")
159 (include "440.md")
160 (include "603.md")
161 (include "6xx.md")
162 (include "7xx.md")
163 (include "7450.md")
164 (include "8540.md")
165 (include "e300c2c3.md")
166 (include "e500mc.md")
167 (include "power4.md")
168 (include "power5.md")
169 (include "power6.md")
170 (include "cell.md")
171 (include "xfpu.md")
172
173 (include "predicates.md")
174 (include "constraints.md")
175
176 (include "darwin.md")
177
178 \f
179 ;; Mode iterators
180
181 ; This mode iterator allows :GPR to be used to indicate the allowable size
182 ; of whole values in GPRs.
183 (define_mode_iterator GPR [SI (DI "TARGET_POWERPC64")])
184
185 ; Any supported integer mode.
186 (define_mode_iterator INT [QI HI SI DI TI])
187
188 ; Any supported integer mode that fits in one register.
189 (define_mode_iterator INT1 [QI HI SI (DI "TARGET_POWERPC64")])
190
191 ; extend modes for DImode
192 (define_mode_iterator QHSI [QI HI SI])
193
194 ; SImode or DImode, even if DImode doesn't fit in GPRs.
195 (define_mode_iterator SDI [SI DI])
196
197 ; The size of a pointer. Also, the size of the value that a record-condition
198 ; (one with a '.') will compare.
199 (define_mode_iterator P [(SI "TARGET_32BIT") (DI "TARGET_64BIT")])
200
201 ; Any hardware-supported floating-point mode
202 (define_mode_iterator FP [
203 (SF "TARGET_HARD_FLOAT
204 && ((TARGET_FPRS && TARGET_SINGLE_FLOAT) || TARGET_E500_SINGLE)")
205 (DF "TARGET_HARD_FLOAT
206 && ((TARGET_FPRS && TARGET_DOUBLE_FLOAT) || TARGET_E500_DOUBLE)")
207 (TF "!TARGET_IEEEQUAD
208 && TARGET_HARD_FLOAT
209 && (TARGET_FPRS || TARGET_E500_DOUBLE)
210 && TARGET_LONG_DOUBLE_128")
211 (DD "TARGET_DFP")
212 (TD "TARGET_DFP")])
213
214 ; Various instructions that come in SI and DI forms.
215 ; A generic w/d attribute, for things like cmpw/cmpd.
216 (define_mode_attr wd [(QI "b") (HI "h") (SI "w") (DI "d")])
217
218 ; DImode bits
219 (define_mode_attr dbits [(QI "56") (HI "48") (SI "32")])
220
221 \f
222 ;; Start with fixed-point load and store insns. Here we put only the more
223 ;; complex forms. Basic data transfer is done later.
224
225 (define_expand "zero_extend<mode>di2"
226 [(set (match_operand:DI 0 "gpc_reg_operand" "")
227 (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" "")))]
228 "TARGET_POWERPC64"
229 "")
230
231 (define_insn "*zero_extend<mode>di2_internal1"
232 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
233 (zero_extend:DI (match_operand:QHSI 1 "reg_or_mem_operand" "m,r")))]
234 "TARGET_POWERPC64"
235 "@
236 l<wd>z%U1%X1 %0,%1
237 rldicl %0,%1,0,<dbits>"
238 [(set_attr "type" "load,*")])
239
240 (define_insn "*zero_extend<mode>di2_internal2"
241 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
242 (compare:CC (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" "r,r"))
243 (const_int 0)))
244 (clobber (match_scratch:DI 2 "=r,r"))]
245 "TARGET_64BIT"
246 "@
247 rldicl. %2,%1,0,<dbits>
248 #"
249 [(set_attr "type" "compare")
250 (set_attr "length" "4,8")])
251
252 (define_split
253 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
254 (compare:CC (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" ""))
255 (const_int 0)))
256 (clobber (match_scratch:DI 2 ""))]
257 "TARGET_POWERPC64 && reload_completed"
258 [(set (match_dup 2)
259 (zero_extend:DI (match_dup 1)))
260 (set (match_dup 0)
261 (compare:CC (match_dup 2)
262 (const_int 0)))]
263 "")
264
265 (define_insn "*zero_extend<mode>di2_internal3"
266 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
267 (compare:CC (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" "r,r"))
268 (const_int 0)))
269 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
270 (zero_extend:DI (match_dup 1)))]
271 "TARGET_64BIT"
272 "@
273 rldicl. %0,%1,0,<dbits>
274 #"
275 [(set_attr "type" "compare")
276 (set_attr "length" "4,8")])
277
278 (define_split
279 [(set (match_operand:CC 2 "cc_reg_not_micro_cr0_operand" "")
280 (compare:CC (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" ""))
281 (const_int 0)))
282 (set (match_operand:DI 0 "gpc_reg_operand" "")
283 (zero_extend:DI (match_dup 1)))]
284 "TARGET_POWERPC64 && reload_completed"
285 [(set (match_dup 0)
286 (zero_extend:DI (match_dup 1)))
287 (set (match_dup 2)
288 (compare:CC (match_dup 0)
289 (const_int 0)))]
290 "")
291
292 (define_insn "extendqidi2"
293 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
294 (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r")))]
295 "TARGET_POWERPC64"
296 "extsb %0,%1"
297 [(set_attr "type" "exts")])
298
299 (define_insn ""
300 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
301 (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
302 (const_int 0)))
303 (clobber (match_scratch:DI 2 "=r,r"))]
304 "TARGET_64BIT"
305 "@
306 extsb. %2,%1
307 #"
308 [(set_attr "type" "compare")
309 (set_attr "length" "4,8")])
310
311 (define_split
312 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
313 (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" ""))
314 (const_int 0)))
315 (clobber (match_scratch:DI 2 ""))]
316 "TARGET_POWERPC64 && reload_completed"
317 [(set (match_dup 2)
318 (sign_extend:DI (match_dup 1)))
319 (set (match_dup 0)
320 (compare:CC (match_dup 2)
321 (const_int 0)))]
322 "")
323
324 (define_insn ""
325 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
326 (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
327 (const_int 0)))
328 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
329 (sign_extend:DI (match_dup 1)))]
330 "TARGET_64BIT"
331 "@
332 extsb. %0,%1
333 #"
334 [(set_attr "type" "compare")
335 (set_attr "length" "4,8")])
336
337 (define_split
338 [(set (match_operand:CC 2 "cc_reg_not_micro_cr0_operand" "")
339 (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" ""))
340 (const_int 0)))
341 (set (match_operand:DI 0 "gpc_reg_operand" "")
342 (sign_extend:DI (match_dup 1)))]
343 "TARGET_POWERPC64 && reload_completed"
344 [(set (match_dup 0)
345 (sign_extend:DI (match_dup 1)))
346 (set (match_dup 2)
347 (compare:CC (match_dup 0)
348 (const_int 0)))]
349 "")
350
351 (define_expand "extendhidi2"
352 [(set (match_operand:DI 0 "gpc_reg_operand" "")
353 (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "")))]
354 "TARGET_POWERPC64"
355 "")
356
357 (define_insn ""
358 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
359 (sign_extend:DI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
360 "TARGET_POWERPC64 && rs6000_gen_cell_microcode"
361 "@
362 lha%U1%X1 %0,%1
363 extsh %0,%1"
364 [(set_attr "type" "load_ext,exts")])
365
366 (define_insn ""
367 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
368 (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r")))]
369 "TARGET_POWERPC64 && !rs6000_gen_cell_microcode"
370 "extsh %0,%1"
371 [(set_attr "type" "exts")])
372
373 (define_insn ""
374 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
375 (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
376 (const_int 0)))
377 (clobber (match_scratch:DI 2 "=r,r"))]
378 "TARGET_64BIT"
379 "@
380 extsh. %2,%1
381 #"
382 [(set_attr "type" "compare")
383 (set_attr "length" "4,8")])
384
385 (define_split
386 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
387 (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" ""))
388 (const_int 0)))
389 (clobber (match_scratch:DI 2 ""))]
390 "TARGET_POWERPC64 && reload_completed"
391 [(set (match_dup 2)
392 (sign_extend:DI (match_dup 1)))
393 (set (match_dup 0)
394 (compare:CC (match_dup 2)
395 (const_int 0)))]
396 "")
397
398 (define_insn ""
399 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
400 (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
401 (const_int 0)))
402 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
403 (sign_extend:DI (match_dup 1)))]
404 "TARGET_64BIT"
405 "@
406 extsh. %0,%1
407 #"
408 [(set_attr "type" "compare")
409 (set_attr "length" "4,8")])
410
411 (define_split
412 [(set (match_operand:CC 2 "cc_reg_not_micro_cr0_operand" "")
413 (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" ""))
414 (const_int 0)))
415 (set (match_operand:DI 0 "gpc_reg_operand" "")
416 (sign_extend:DI (match_dup 1)))]
417 "TARGET_POWERPC64 && reload_completed"
418 [(set (match_dup 0)
419 (sign_extend:DI (match_dup 1)))
420 (set (match_dup 2)
421 (compare:CC (match_dup 0)
422 (const_int 0)))]
423 "")
424
425 (define_expand "extendsidi2"
426 [(set (match_operand:DI 0 "gpc_reg_operand" "")
427 (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "")))]
428 "TARGET_POWERPC64"
429 "")
430
431 (define_insn ""
432 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
433 (sign_extend:DI (match_operand:SI 1 "lwa_operand" "m,r")))]
434 "TARGET_POWERPC64 && rs6000_gen_cell_microcode"
435 "@
436 lwa%U1%X1 %0,%1
437 extsw %0,%1"
438 [(set_attr "type" "load_ext,exts")])
439
440 (define_insn ""
441 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
442 (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r")))]
443 "TARGET_POWERPC64 && !rs6000_gen_cell_microcode"
444 "extsw %0,%1"
445 [(set_attr "type" "exts")])
446
447 (define_insn ""
448 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
449 (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r,r"))
450 (const_int 0)))
451 (clobber (match_scratch:DI 2 "=r,r"))]
452 "TARGET_64BIT"
453 "@
454 extsw. %2,%1
455 #"
456 [(set_attr "type" "compare")
457 (set_attr "length" "4,8")])
458
459 (define_split
460 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
461 (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
462 (const_int 0)))
463 (clobber (match_scratch:DI 2 ""))]
464 "TARGET_POWERPC64 && reload_completed"
465 [(set (match_dup 2)
466 (sign_extend:DI (match_dup 1)))
467 (set (match_dup 0)
468 (compare:CC (match_dup 2)
469 (const_int 0)))]
470 "")
471
472 (define_insn ""
473 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
474 (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r,r"))
475 (const_int 0)))
476 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
477 (sign_extend:DI (match_dup 1)))]
478 "TARGET_64BIT"
479 "@
480 extsw. %0,%1
481 #"
482 [(set_attr "type" "compare")
483 (set_attr "length" "4,8")])
484
485 (define_split
486 [(set (match_operand:CC 2 "cc_reg_not_micro_cr0_operand" "")
487 (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
488 (const_int 0)))
489 (set (match_operand:DI 0 "gpc_reg_operand" "")
490 (sign_extend:DI (match_dup 1)))]
491 "TARGET_POWERPC64 && reload_completed"
492 [(set (match_dup 0)
493 (sign_extend:DI (match_dup 1)))
494 (set (match_dup 2)
495 (compare:CC (match_dup 0)
496 (const_int 0)))]
497 "")
498
499 (define_expand "zero_extendqisi2"
500 [(set (match_operand:SI 0 "gpc_reg_operand" "")
501 (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "")))]
502 ""
503 "")
504
505 (define_insn ""
506 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
507 (zero_extend:SI (match_operand:QI 1 "reg_or_mem_operand" "m,r")))]
508 ""
509 "@
510 lbz%U1%X1 %0,%1
511 {rlinm|rlwinm} %0,%1,0,0xff"
512 [(set_attr "type" "load,*")])
513
514 (define_insn ""
515 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
516 (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
517 (const_int 0)))
518 (clobber (match_scratch:SI 2 "=r,r"))]
519 ""
520 "@
521 {andil.|andi.} %2,%1,0xff
522 #"
523 [(set_attr "type" "compare")
524 (set_attr "length" "4,8")])
525
526 (define_split
527 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
528 (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" ""))
529 (const_int 0)))
530 (clobber (match_scratch:SI 2 ""))]
531 "reload_completed"
532 [(set (match_dup 2)
533 (zero_extend:SI (match_dup 1)))
534 (set (match_dup 0)
535 (compare:CC (match_dup 2)
536 (const_int 0)))]
537 "")
538
539 (define_insn ""
540 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
541 (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
542 (const_int 0)))
543 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
544 (zero_extend:SI (match_dup 1)))]
545 ""
546 "@
547 {andil.|andi.} %0,%1,0xff
548 #"
549 [(set_attr "type" "compare")
550 (set_attr "length" "4,8")])
551
552 (define_split
553 [(set (match_operand:CC 2 "cc_reg_not_micro_cr0_operand" "")
554 (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" ""))
555 (const_int 0)))
556 (set (match_operand:SI 0 "gpc_reg_operand" "")
557 (zero_extend:SI (match_dup 1)))]
558 "reload_completed"
559 [(set (match_dup 0)
560 (zero_extend:SI (match_dup 1)))
561 (set (match_dup 2)
562 (compare:CC (match_dup 0)
563 (const_int 0)))]
564 "")
565
566 (define_expand "extendqisi2"
567 [(use (match_operand:SI 0 "gpc_reg_operand" ""))
568 (use (match_operand:QI 1 "gpc_reg_operand" ""))]
569 ""
570 "
571 {
572 if (TARGET_POWERPC)
573 emit_insn (gen_extendqisi2_ppc (operands[0], operands[1]));
574 else if (TARGET_POWER)
575 emit_insn (gen_extendqisi2_power (operands[0], operands[1]));
576 else
577 emit_insn (gen_extendqisi2_no_power (operands[0], operands[1]));
578 DONE;
579 }")
580
581 (define_insn "extendqisi2_ppc"
582 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
583 (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r")))]
584 "TARGET_POWERPC"
585 "extsb %0,%1"
586 [(set_attr "type" "exts")])
587
588 (define_insn ""
589 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
590 (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
591 (const_int 0)))
592 (clobber (match_scratch:SI 2 "=r,r"))]
593 "TARGET_POWERPC"
594 "@
595 extsb. %2,%1
596 #"
597 [(set_attr "type" "compare")
598 (set_attr "length" "4,8")])
599
600 (define_split
601 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
602 (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" ""))
603 (const_int 0)))
604 (clobber (match_scratch:SI 2 ""))]
605 "TARGET_POWERPC && reload_completed"
606 [(set (match_dup 2)
607 (sign_extend:SI (match_dup 1)))
608 (set (match_dup 0)
609 (compare:CC (match_dup 2)
610 (const_int 0)))]
611 "")
612
613 (define_insn ""
614 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
615 (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
616 (const_int 0)))
617 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
618 (sign_extend:SI (match_dup 1)))]
619 "TARGET_POWERPC"
620 "@
621 extsb. %0,%1
622 #"
623 [(set_attr "type" "compare")
624 (set_attr "length" "4,8")])
625
626 (define_split
627 [(set (match_operand:CC 2 "cc_reg_not_micro_cr0_operand" "")
628 (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" ""))
629 (const_int 0)))
630 (set (match_operand:SI 0 "gpc_reg_operand" "")
631 (sign_extend:SI (match_dup 1)))]
632 "TARGET_POWERPC && reload_completed"
633 [(set (match_dup 0)
634 (sign_extend:SI (match_dup 1)))
635 (set (match_dup 2)
636 (compare:CC (match_dup 0)
637 (const_int 0)))]
638 "")
639
640 (define_expand "extendqisi2_power"
641 [(parallel [(set (match_dup 2)
642 (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
643 (const_int 24)))
644 (clobber (scratch:SI))])
645 (parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
646 (ashiftrt:SI (match_dup 2)
647 (const_int 24)))
648 (clobber (scratch:SI))])]
649 "TARGET_POWER"
650 "
651 { operands[1] = gen_lowpart (SImode, operands[1]);
652 operands[2] = gen_reg_rtx (SImode); }")
653
654 (define_expand "extendqisi2_no_power"
655 [(set (match_dup 2)
656 (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
657 (const_int 24)))
658 (set (match_operand:SI 0 "gpc_reg_operand" "")
659 (ashiftrt:SI (match_dup 2)
660 (const_int 24)))]
661 "! TARGET_POWER && ! TARGET_POWERPC"
662 "
663 { operands[1] = gen_lowpart (SImode, operands[1]);
664 operands[2] = gen_reg_rtx (SImode); }")
665
666 (define_expand "zero_extendqihi2"
667 [(set (match_operand:HI 0 "gpc_reg_operand" "")
668 (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "")))]
669 ""
670 "")
671
672 (define_insn ""
673 [(set (match_operand:HI 0 "gpc_reg_operand" "=r,r")
674 (zero_extend:HI (match_operand:QI 1 "reg_or_mem_operand" "m,r")))]
675 ""
676 "@
677 lbz%U1%X1 %0,%1
678 {rlinm|rlwinm} %0,%1,0,0xff"
679 [(set_attr "type" "load,*")])
680
681 (define_insn ""
682 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
683 (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
684 (const_int 0)))
685 (clobber (match_scratch:HI 2 "=r,r"))]
686 ""
687 "@
688 {andil.|andi.} %2,%1,0xff
689 #"
690 [(set_attr "type" "compare")
691 (set_attr "length" "4,8")])
692
693 (define_split
694 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
695 (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" ""))
696 (const_int 0)))
697 (clobber (match_scratch:HI 2 ""))]
698 "reload_completed"
699 [(set (match_dup 2)
700 (zero_extend:HI (match_dup 1)))
701 (set (match_dup 0)
702 (compare:CC (match_dup 2)
703 (const_int 0)))]
704 "")
705
706 (define_insn ""
707 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
708 (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
709 (const_int 0)))
710 (set (match_operand:HI 0 "gpc_reg_operand" "=r,r")
711 (zero_extend:HI (match_dup 1)))]
712 ""
713 "@
714 {andil.|andi.} %0,%1,0xff
715 #"
716 [(set_attr "type" "compare")
717 (set_attr "length" "4,8")])
718
719 (define_split
720 [(set (match_operand:CC 2 "cc_reg_not_micro_cr0_operand" "")
721 (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" ""))
722 (const_int 0)))
723 (set (match_operand:HI 0 "gpc_reg_operand" "")
724 (zero_extend:HI (match_dup 1)))]
725 "reload_completed"
726 [(set (match_dup 0)
727 (zero_extend:HI (match_dup 1)))
728 (set (match_dup 2)
729 (compare:CC (match_dup 0)
730 (const_int 0)))]
731 "")
732
733 (define_expand "extendqihi2"
734 [(use (match_operand:HI 0 "gpc_reg_operand" ""))
735 (use (match_operand:QI 1 "gpc_reg_operand" ""))]
736 ""
737 "
738 {
739 if (TARGET_POWERPC)
740 emit_insn (gen_extendqihi2_ppc (operands[0], operands[1]));
741 else if (TARGET_POWER)
742 emit_insn (gen_extendqihi2_power (operands[0], operands[1]));
743 else
744 emit_insn (gen_extendqihi2_no_power (operands[0], operands[1]));
745 DONE;
746 }")
747
748 (define_insn "extendqihi2_ppc"
749 [(set (match_operand:HI 0 "gpc_reg_operand" "=r")
750 (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r")))]
751 "TARGET_POWERPC"
752 "extsb %0,%1"
753 [(set_attr "type" "exts")])
754
755 (define_insn ""
756 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
757 (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
758 (const_int 0)))
759 (clobber (match_scratch:HI 2 "=r,r"))]
760 "TARGET_POWERPC"
761 "@
762 extsb. %2,%1
763 #"
764 [(set_attr "type" "compare")
765 (set_attr "length" "4,8")])
766
767 (define_split
768 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
769 (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" ""))
770 (const_int 0)))
771 (clobber (match_scratch:HI 2 ""))]
772 "TARGET_POWERPC && reload_completed"
773 [(set (match_dup 2)
774 (sign_extend:HI (match_dup 1)))
775 (set (match_dup 0)
776 (compare:CC (match_dup 2)
777 (const_int 0)))]
778 "")
779
780 (define_insn ""
781 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
782 (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
783 (const_int 0)))
784 (set (match_operand:HI 0 "gpc_reg_operand" "=r,r")
785 (sign_extend:HI (match_dup 1)))]
786 "TARGET_POWERPC"
787 "@
788 extsb. %0,%1
789 #"
790 [(set_attr "type" "compare")
791 (set_attr "length" "4,8")])
792
793 (define_split
794 [(set (match_operand:CC 2 "cc_reg_not_micro_cr0_operand" "")
795 (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" ""))
796 (const_int 0)))
797 (set (match_operand:HI 0 "gpc_reg_operand" "")
798 (sign_extend:HI (match_dup 1)))]
799 "TARGET_POWERPC && reload_completed"
800 [(set (match_dup 0)
801 (sign_extend:HI (match_dup 1)))
802 (set (match_dup 2)
803 (compare:CC (match_dup 0)
804 (const_int 0)))]
805 "")
806
807 (define_expand "extendqihi2_power"
808 [(parallel [(set (match_dup 2)
809 (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
810 (const_int 24)))
811 (clobber (scratch:SI))])
812 (parallel [(set (match_operand:HI 0 "gpc_reg_operand" "")
813 (ashiftrt:SI (match_dup 2)
814 (const_int 24)))
815 (clobber (scratch:SI))])]
816 "TARGET_POWER"
817 "
818 { operands[0] = gen_lowpart (SImode, operands[0]);
819 operands[1] = gen_lowpart (SImode, operands[1]);
820 operands[2] = gen_reg_rtx (SImode); }")
821
822 (define_expand "extendqihi2_no_power"
823 [(set (match_dup 2)
824 (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
825 (const_int 24)))
826 (set (match_operand:HI 0 "gpc_reg_operand" "")
827 (ashiftrt:SI (match_dup 2)
828 (const_int 24)))]
829 "! TARGET_POWER && ! TARGET_POWERPC"
830 "
831 { operands[0] = gen_lowpart (SImode, operands[0]);
832 operands[1] = gen_lowpart (SImode, operands[1]);
833 operands[2] = gen_reg_rtx (SImode); }")
834
835 (define_expand "zero_extendhisi2"
836 [(set (match_operand:SI 0 "gpc_reg_operand" "")
837 (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "")))]
838 ""
839 "")
840
841 (define_insn ""
842 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
843 (zero_extend:SI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
844 ""
845 "@
846 lhz%U1%X1 %0,%1
847 {rlinm|rlwinm} %0,%1,0,0xffff"
848 [(set_attr "type" "load,*")])
849
850 (define_insn ""
851 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
852 (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
853 (const_int 0)))
854 (clobber (match_scratch:SI 2 "=r,r"))]
855 ""
856 "@
857 {andil.|andi.} %2,%1,0xffff
858 #"
859 [(set_attr "type" "compare")
860 (set_attr "length" "4,8")])
861
862 (define_split
863 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
864 (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" ""))
865 (const_int 0)))
866 (clobber (match_scratch:SI 2 ""))]
867 "reload_completed"
868 [(set (match_dup 2)
869 (zero_extend:SI (match_dup 1)))
870 (set (match_dup 0)
871 (compare:CC (match_dup 2)
872 (const_int 0)))]
873 "")
874
875 (define_insn ""
876 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
877 (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
878 (const_int 0)))
879 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
880 (zero_extend:SI (match_dup 1)))]
881 ""
882 "@
883 {andil.|andi.} %0,%1,0xffff
884 #"
885 [(set_attr "type" "compare")
886 (set_attr "length" "4,8")])
887
888 (define_split
889 [(set (match_operand:CC 2 "cc_reg_not_micro_cr0_operand" "")
890 (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" ""))
891 (const_int 0)))
892 (set (match_operand:SI 0 "gpc_reg_operand" "")
893 (zero_extend:SI (match_dup 1)))]
894 "reload_completed"
895 [(set (match_dup 0)
896 (zero_extend:SI (match_dup 1)))
897 (set (match_dup 2)
898 (compare:CC (match_dup 0)
899 (const_int 0)))]
900 "")
901
902 (define_expand "extendhisi2"
903 [(set (match_operand:SI 0 "gpc_reg_operand" "")
904 (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "")))]
905 ""
906 "")
907
908 (define_insn ""
909 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
910 (sign_extend:SI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
911 "rs6000_gen_cell_microcode"
912 "@
913 lha%U1%X1 %0,%1
914 {exts|extsh} %0,%1"
915 [(set_attr "type" "load_ext,exts")])
916
917 (define_insn ""
918 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
919 (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r")))]
920 "!rs6000_gen_cell_microcode"
921 "{exts|extsh} %0,%1"
922 [(set_attr "type" "exts")])
923
924 (define_insn ""
925 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
926 (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
927 (const_int 0)))
928 (clobber (match_scratch:SI 2 "=r,r"))]
929 ""
930 "@
931 {exts.|extsh.} %2,%1
932 #"
933 [(set_attr "type" "compare")
934 (set_attr "length" "4,8")])
935
936 (define_split
937 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
938 (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" ""))
939 (const_int 0)))
940 (clobber (match_scratch:SI 2 ""))]
941 "reload_completed"
942 [(set (match_dup 2)
943 (sign_extend:SI (match_dup 1)))
944 (set (match_dup 0)
945 (compare:CC (match_dup 2)
946 (const_int 0)))]
947 "")
948
949 (define_insn ""
950 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
951 (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
952 (const_int 0)))
953 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
954 (sign_extend:SI (match_dup 1)))]
955 ""
956 "@
957 {exts.|extsh.} %0,%1
958 #"
959 [(set_attr "type" "compare")
960 (set_attr "length" "4,8")])
961 \f
962 ;; IBM 405, 440 and 464 half-word multiplication operations.
963
964 (define_insn "*macchwc"
965 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
966 (compare:CC (plus:SI (mult:SI (ashiftrt:SI
967 (match_operand:SI 2 "gpc_reg_operand" "r")
968 (const_int 16))
969 (sign_extend:SI
970 (match_operand:HI 1 "gpc_reg_operand" "r")))
971 (match_operand:SI 4 "gpc_reg_operand" "0"))
972 (const_int 0)))
973 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
974 (plus:SI (mult:SI (ashiftrt:SI
975 (match_dup 2)
976 (const_int 16))
977 (sign_extend:SI
978 (match_dup 1)))
979 (match_dup 4)))]
980 "TARGET_MULHW"
981 "macchw. %0, %1, %2"
982 [(set_attr "type" "imul3")])
983
984 (define_insn "*macchw"
985 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
986 (plus:SI (mult:SI (ashiftrt:SI
987 (match_operand:SI 2 "gpc_reg_operand" "r")
988 (const_int 16))
989 (sign_extend:SI
990 (match_operand:HI 1 "gpc_reg_operand" "r")))
991 (match_operand:SI 3 "gpc_reg_operand" "0")))]
992 "TARGET_MULHW"
993 "macchw %0, %1, %2"
994 [(set_attr "type" "imul3")])
995
996 (define_insn "*macchwuc"
997 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
998 (compare:CC (plus:SI (mult:SI (lshiftrt:SI
999 (match_operand:SI 2 "gpc_reg_operand" "r")
1000 (const_int 16))
1001 (zero_extend:SI
1002 (match_operand:HI 1 "gpc_reg_operand" "r")))
1003 (match_operand:SI 4 "gpc_reg_operand" "0"))
1004 (const_int 0)))
1005 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1006 (plus:SI (mult:SI (lshiftrt:SI
1007 (match_dup 2)
1008 (const_int 16))
1009 (zero_extend:SI
1010 (match_dup 1)))
1011 (match_dup 4)))]
1012 "TARGET_MULHW"
1013 "macchwu. %0, %1, %2"
1014 [(set_attr "type" "imul3")])
1015
1016 (define_insn "*macchwu"
1017 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1018 (plus:SI (mult:SI (lshiftrt:SI
1019 (match_operand:SI 2 "gpc_reg_operand" "r")
1020 (const_int 16))
1021 (zero_extend:SI
1022 (match_operand:HI 1 "gpc_reg_operand" "r")))
1023 (match_operand:SI 3 "gpc_reg_operand" "0")))]
1024 "TARGET_MULHW"
1025 "macchwu %0, %1, %2"
1026 [(set_attr "type" "imul3")])
1027
1028 (define_insn "*machhwc"
1029 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1030 (compare:CC (plus:SI (mult:SI (ashiftrt:SI
1031 (match_operand:SI 1 "gpc_reg_operand" "%r")
1032 (const_int 16))
1033 (ashiftrt:SI
1034 (match_operand:SI 2 "gpc_reg_operand" "r")
1035 (const_int 16)))
1036 (match_operand:SI 4 "gpc_reg_operand" "0"))
1037 (const_int 0)))
1038 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1039 (plus:SI (mult:SI (ashiftrt:SI
1040 (match_dup 1)
1041 (const_int 16))
1042 (ashiftrt:SI
1043 (match_dup 2)
1044 (const_int 16)))
1045 (match_dup 4)))]
1046 "TARGET_MULHW"
1047 "machhw. %0, %1, %2"
1048 [(set_attr "type" "imul3")])
1049
1050 (define_insn "*machhw"
1051 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1052 (plus:SI (mult:SI (ashiftrt:SI
1053 (match_operand:SI 1 "gpc_reg_operand" "%r")
1054 (const_int 16))
1055 (ashiftrt:SI
1056 (match_operand:SI 2 "gpc_reg_operand" "r")
1057 (const_int 16)))
1058 (match_operand:SI 3 "gpc_reg_operand" "0")))]
1059 "TARGET_MULHW"
1060 "machhw %0, %1, %2"
1061 [(set_attr "type" "imul3")])
1062
1063 (define_insn "*machhwuc"
1064 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1065 (compare:CC (plus:SI (mult:SI (lshiftrt:SI
1066 (match_operand:SI 1 "gpc_reg_operand" "%r")
1067 (const_int 16))
1068 (lshiftrt:SI
1069 (match_operand:SI 2 "gpc_reg_operand" "r")
1070 (const_int 16)))
1071 (match_operand:SI 4 "gpc_reg_operand" "0"))
1072 (const_int 0)))
1073 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1074 (plus:SI (mult:SI (lshiftrt:SI
1075 (match_dup 1)
1076 (const_int 16))
1077 (lshiftrt:SI
1078 (match_dup 2)
1079 (const_int 16)))
1080 (match_dup 4)))]
1081 "TARGET_MULHW"
1082 "machhwu. %0, %1, %2"
1083 [(set_attr "type" "imul3")])
1084
1085 (define_insn "*machhwu"
1086 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1087 (plus:SI (mult:SI (lshiftrt:SI
1088 (match_operand:SI 1 "gpc_reg_operand" "%r")
1089 (const_int 16))
1090 (lshiftrt:SI
1091 (match_operand:SI 2 "gpc_reg_operand" "r")
1092 (const_int 16)))
1093 (match_operand:SI 3 "gpc_reg_operand" "0")))]
1094 "TARGET_MULHW"
1095 "machhwu %0, %1, %2"
1096 [(set_attr "type" "imul3")])
1097
1098 (define_insn "*maclhwc"
1099 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1100 (compare:CC (plus:SI (mult:SI (sign_extend:SI
1101 (match_operand:HI 1 "gpc_reg_operand" "%r"))
1102 (sign_extend:SI
1103 (match_operand:HI 2 "gpc_reg_operand" "r")))
1104 (match_operand:SI 4 "gpc_reg_operand" "0"))
1105 (const_int 0)))
1106 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1107 (plus:SI (mult:SI (sign_extend:SI
1108 (match_dup 1))
1109 (sign_extend:SI
1110 (match_dup 2)))
1111 (match_dup 4)))]
1112 "TARGET_MULHW"
1113 "maclhw. %0, %1, %2"
1114 [(set_attr "type" "imul3")])
1115
1116 (define_insn "*maclhw"
1117 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1118 (plus:SI (mult:SI (sign_extend:SI
1119 (match_operand:HI 1 "gpc_reg_operand" "%r"))
1120 (sign_extend:SI
1121 (match_operand:HI 2 "gpc_reg_operand" "r")))
1122 (match_operand:SI 3 "gpc_reg_operand" "0")))]
1123 "TARGET_MULHW"
1124 "maclhw %0, %1, %2"
1125 [(set_attr "type" "imul3")])
1126
1127 (define_insn "*maclhwuc"
1128 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1129 (compare:CC (plus:SI (mult:SI (zero_extend:SI
1130 (match_operand:HI 1 "gpc_reg_operand" "%r"))
1131 (zero_extend:SI
1132 (match_operand:HI 2 "gpc_reg_operand" "r")))
1133 (match_operand:SI 4 "gpc_reg_operand" "0"))
1134 (const_int 0)))
1135 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1136 (plus:SI (mult:SI (zero_extend:SI
1137 (match_dup 1))
1138 (zero_extend:SI
1139 (match_dup 2)))
1140 (match_dup 4)))]
1141 "TARGET_MULHW"
1142 "maclhwu. %0, %1, %2"
1143 [(set_attr "type" "imul3")])
1144
1145 (define_insn "*maclhwu"
1146 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1147 (plus:SI (mult:SI (zero_extend:SI
1148 (match_operand:HI 1 "gpc_reg_operand" "%r"))
1149 (zero_extend:SI
1150 (match_operand:HI 2 "gpc_reg_operand" "r")))
1151 (match_operand:SI 3 "gpc_reg_operand" "0")))]
1152 "TARGET_MULHW"
1153 "maclhwu %0, %1, %2"
1154 [(set_attr "type" "imul3")])
1155
1156 (define_insn "*nmacchwc"
1157 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1158 (compare:CC (minus:SI (match_operand:SI 4 "gpc_reg_operand" "0")
1159 (mult:SI (ashiftrt:SI
1160 (match_operand:SI 2 "gpc_reg_operand" "r")
1161 (const_int 16))
1162 (sign_extend:SI
1163 (match_operand:HI 1 "gpc_reg_operand" "r"))))
1164 (const_int 0)))
1165 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1166 (minus:SI (match_dup 4)
1167 (mult:SI (ashiftrt:SI
1168 (match_dup 2)
1169 (const_int 16))
1170 (sign_extend:SI
1171 (match_dup 1)))))]
1172 "TARGET_MULHW"
1173 "nmacchw. %0, %1, %2"
1174 [(set_attr "type" "imul3")])
1175
1176 (define_insn "*nmacchw"
1177 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1178 (minus:SI (match_operand:SI 3 "gpc_reg_operand" "0")
1179 (mult:SI (ashiftrt:SI
1180 (match_operand:SI 2 "gpc_reg_operand" "r")
1181 (const_int 16))
1182 (sign_extend:SI
1183 (match_operand:HI 1 "gpc_reg_operand" "r")))))]
1184 "TARGET_MULHW"
1185 "nmacchw %0, %1, %2"
1186 [(set_attr "type" "imul3")])
1187
1188 (define_insn "*nmachhwc"
1189 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1190 (compare:CC (minus:SI (match_operand:SI 4 "gpc_reg_operand" "0")
1191 (mult:SI (ashiftrt:SI
1192 (match_operand:SI 1 "gpc_reg_operand" "%r")
1193 (const_int 16))
1194 (ashiftrt:SI
1195 (match_operand:SI 2 "gpc_reg_operand" "r")
1196 (const_int 16))))
1197 (const_int 0)))
1198 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1199 (minus:SI (match_dup 4)
1200 (mult:SI (ashiftrt:SI
1201 (match_dup 1)
1202 (const_int 16))
1203 (ashiftrt:SI
1204 (match_dup 2)
1205 (const_int 16)))))]
1206 "TARGET_MULHW"
1207 "nmachhw. %0, %1, %2"
1208 [(set_attr "type" "imul3")])
1209
1210 (define_insn "*nmachhw"
1211 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1212 (minus:SI (match_operand:SI 3 "gpc_reg_operand" "0")
1213 (mult:SI (ashiftrt:SI
1214 (match_operand:SI 1 "gpc_reg_operand" "%r")
1215 (const_int 16))
1216 (ashiftrt:SI
1217 (match_operand:SI 2 "gpc_reg_operand" "r")
1218 (const_int 16)))))]
1219 "TARGET_MULHW"
1220 "nmachhw %0, %1, %2"
1221 [(set_attr "type" "imul3")])
1222
1223 (define_insn "*nmaclhwc"
1224 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1225 (compare:CC (minus:SI (match_operand:SI 4 "gpc_reg_operand" "0")
1226 (mult:SI (sign_extend:SI
1227 (match_operand:HI 1 "gpc_reg_operand" "%r"))
1228 (sign_extend:SI
1229 (match_operand:HI 2 "gpc_reg_operand" "r"))))
1230 (const_int 0)))
1231 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1232 (minus:SI (match_dup 4)
1233 (mult:SI (sign_extend:SI
1234 (match_dup 1))
1235 (sign_extend:SI
1236 (match_dup 2)))))]
1237 "TARGET_MULHW"
1238 "nmaclhw. %0, %1, %2"
1239 [(set_attr "type" "imul3")])
1240
1241 (define_insn "*nmaclhw"
1242 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1243 (minus:SI (match_operand:SI 3 "gpc_reg_operand" "0")
1244 (mult:SI (sign_extend:SI
1245 (match_operand:HI 1 "gpc_reg_operand" "%r"))
1246 (sign_extend:SI
1247 (match_operand:HI 2 "gpc_reg_operand" "r")))))]
1248 "TARGET_MULHW"
1249 "nmaclhw %0, %1, %2"
1250 [(set_attr "type" "imul3")])
1251
1252 (define_insn "*mulchwc"
1253 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1254 (compare:CC (mult:SI (ashiftrt:SI
1255 (match_operand:SI 2 "gpc_reg_operand" "r")
1256 (const_int 16))
1257 (sign_extend:SI
1258 (match_operand:HI 1 "gpc_reg_operand" "r")))
1259 (const_int 0)))
1260 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1261 (mult:SI (ashiftrt:SI
1262 (match_dup 2)
1263 (const_int 16))
1264 (sign_extend:SI
1265 (match_dup 1))))]
1266 "TARGET_MULHW"
1267 "mulchw. %0, %1, %2"
1268 [(set_attr "type" "imul3")])
1269
1270 (define_insn "*mulchw"
1271 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1272 (mult:SI (ashiftrt:SI
1273 (match_operand:SI 2 "gpc_reg_operand" "r")
1274 (const_int 16))
1275 (sign_extend:SI
1276 (match_operand:HI 1 "gpc_reg_operand" "r"))))]
1277 "TARGET_MULHW"
1278 "mulchw %0, %1, %2"
1279 [(set_attr "type" "imul3")])
1280
1281 (define_insn "*mulchwuc"
1282 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1283 (compare:CC (mult:SI (lshiftrt:SI
1284 (match_operand:SI 2 "gpc_reg_operand" "r")
1285 (const_int 16))
1286 (zero_extend:SI
1287 (match_operand:HI 1 "gpc_reg_operand" "r")))
1288 (const_int 0)))
1289 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1290 (mult:SI (lshiftrt:SI
1291 (match_dup 2)
1292 (const_int 16))
1293 (zero_extend:SI
1294 (match_dup 1))))]
1295 "TARGET_MULHW"
1296 "mulchwu. %0, %1, %2"
1297 [(set_attr "type" "imul3")])
1298
1299 (define_insn "*mulchwu"
1300 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1301 (mult:SI (lshiftrt:SI
1302 (match_operand:SI 2 "gpc_reg_operand" "r")
1303 (const_int 16))
1304 (zero_extend:SI
1305 (match_operand:HI 1 "gpc_reg_operand" "r"))))]
1306 "TARGET_MULHW"
1307 "mulchwu %0, %1, %2"
1308 [(set_attr "type" "imul3")])
1309
1310 (define_insn "*mulhhwc"
1311 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1312 (compare:CC (mult:SI (ashiftrt:SI
1313 (match_operand:SI 1 "gpc_reg_operand" "%r")
1314 (const_int 16))
1315 (ashiftrt:SI
1316 (match_operand:SI 2 "gpc_reg_operand" "r")
1317 (const_int 16)))
1318 (const_int 0)))
1319 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1320 (mult:SI (ashiftrt:SI
1321 (match_dup 1)
1322 (const_int 16))
1323 (ashiftrt:SI
1324 (match_dup 2)
1325 (const_int 16))))]
1326 "TARGET_MULHW"
1327 "mulhhw. %0, %1, %2"
1328 [(set_attr "type" "imul3")])
1329
1330 (define_insn "*mulhhw"
1331 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1332 (mult:SI (ashiftrt:SI
1333 (match_operand:SI 1 "gpc_reg_operand" "%r")
1334 (const_int 16))
1335 (ashiftrt:SI
1336 (match_operand:SI 2 "gpc_reg_operand" "r")
1337 (const_int 16))))]
1338 "TARGET_MULHW"
1339 "mulhhw %0, %1, %2"
1340 [(set_attr "type" "imul3")])
1341
1342 (define_insn "*mulhhwuc"
1343 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1344 (compare:CC (mult:SI (lshiftrt:SI
1345 (match_operand:SI 1 "gpc_reg_operand" "%r")
1346 (const_int 16))
1347 (lshiftrt:SI
1348 (match_operand:SI 2 "gpc_reg_operand" "r")
1349 (const_int 16)))
1350 (const_int 0)))
1351 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1352 (mult:SI (lshiftrt:SI
1353 (match_dup 1)
1354 (const_int 16))
1355 (lshiftrt:SI
1356 (match_dup 2)
1357 (const_int 16))))]
1358 "TARGET_MULHW"
1359 "mulhhwu. %0, %1, %2"
1360 [(set_attr "type" "imul3")])
1361
1362 (define_insn "*mulhhwu"
1363 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1364 (mult:SI (lshiftrt:SI
1365 (match_operand:SI 1 "gpc_reg_operand" "%r")
1366 (const_int 16))
1367 (lshiftrt:SI
1368 (match_operand:SI 2 "gpc_reg_operand" "r")
1369 (const_int 16))))]
1370 "TARGET_MULHW"
1371 "mulhhwu %0, %1, %2"
1372 [(set_attr "type" "imul3")])
1373
1374 (define_insn "*mullhwc"
1375 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1376 (compare:CC (mult:SI (sign_extend:SI
1377 (match_operand:HI 1 "gpc_reg_operand" "%r"))
1378 (sign_extend:SI
1379 (match_operand:HI 2 "gpc_reg_operand" "r")))
1380 (const_int 0)))
1381 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1382 (mult:SI (sign_extend:SI
1383 (match_dup 1))
1384 (sign_extend:SI
1385 (match_dup 2))))]
1386 "TARGET_MULHW"
1387 "mullhw. %0, %1, %2"
1388 [(set_attr "type" "imul3")])
1389
1390 (define_insn "*mullhw"
1391 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1392 (mult:SI (sign_extend:SI
1393 (match_operand:HI 1 "gpc_reg_operand" "%r"))
1394 (sign_extend:SI
1395 (match_operand:HI 2 "gpc_reg_operand" "r"))))]
1396 "TARGET_MULHW"
1397 "mullhw %0, %1, %2"
1398 [(set_attr "type" "imul3")])
1399
1400 (define_insn "*mullhwuc"
1401 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1402 (compare:CC (mult:SI (zero_extend:SI
1403 (match_operand:HI 1 "gpc_reg_operand" "%r"))
1404 (zero_extend:SI
1405 (match_operand:HI 2 "gpc_reg_operand" "r")))
1406 (const_int 0)))
1407 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1408 (mult:SI (zero_extend:SI
1409 (match_dup 1))
1410 (zero_extend:SI
1411 (match_dup 2))))]
1412 "TARGET_MULHW"
1413 "mullhwu. %0, %1, %2"
1414 [(set_attr "type" "imul3")])
1415
1416 (define_insn "*mullhwu"
1417 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1418 (mult:SI (zero_extend:SI
1419 (match_operand:HI 1 "gpc_reg_operand" "%r"))
1420 (zero_extend:SI
1421 (match_operand:HI 2 "gpc_reg_operand" "r"))))]
1422 "TARGET_MULHW"
1423 "mullhwu %0, %1, %2"
1424 [(set_attr "type" "imul3")])
1425 \f
1426 ;; IBM 405, 440 and 464 string-search dlmzb instruction support.
1427 (define_insn "dlmzb"
1428 [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1429 (unspec:CC [(match_operand:SI 1 "gpc_reg_operand" "r")
1430 (match_operand:SI 2 "gpc_reg_operand" "r")]
1431 UNSPEC_DLMZB_CR))
1432 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1433 (unspec:SI [(match_dup 1)
1434 (match_dup 2)]
1435 UNSPEC_DLMZB))]
1436 "TARGET_DLMZB"
1437 "dlmzb. %0, %1, %2")
1438
1439 (define_expand "strlensi"
1440 [(set (match_operand:SI 0 "gpc_reg_operand" "")
1441 (unspec:SI [(match_operand:BLK 1 "general_operand" "")
1442 (match_operand:QI 2 "const_int_operand" "")
1443 (match_operand 3 "const_int_operand" "")]
1444 UNSPEC_DLMZB_STRLEN))
1445 (clobber (match_scratch:CC 4 "=x"))]
1446 "TARGET_DLMZB && WORDS_BIG_ENDIAN && !optimize_size"
1447 {
1448 rtx result = operands[0];
1449 rtx src = operands[1];
1450 rtx search_char = operands[2];
1451 rtx align = operands[3];
1452 rtx addr, scratch_string, word1, word2, scratch_dlmzb;
1453 rtx loop_label, end_label, mem, cr0, cond;
1454 if (search_char != const0_rtx
1455 || GET_CODE (align) != CONST_INT
1456 || INTVAL (align) < 8)
1457 FAIL;
1458 word1 = gen_reg_rtx (SImode);
1459 word2 = gen_reg_rtx (SImode);
1460 scratch_dlmzb = gen_reg_rtx (SImode);
1461 scratch_string = gen_reg_rtx (Pmode);
1462 loop_label = gen_label_rtx ();
1463 end_label = gen_label_rtx ();
1464 addr = force_reg (Pmode, XEXP (src, 0));
1465 emit_move_insn (scratch_string, addr);
1466 emit_label (loop_label);
1467 mem = change_address (src, SImode, scratch_string);
1468 emit_move_insn (word1, mem);
1469 emit_move_insn (word2, adjust_address (mem, SImode, 4));
1470 cr0 = gen_rtx_REG (CCmode, CR0_REGNO);
1471 emit_insn (gen_dlmzb (scratch_dlmzb, word1, word2, cr0));
1472 cond = gen_rtx_NE (VOIDmode, cr0, const0_rtx);
1473 emit_jump_insn (gen_rtx_SET (VOIDmode,
1474 pc_rtx,
1475 gen_rtx_IF_THEN_ELSE (VOIDmode,
1476 cond,
1477 gen_rtx_LABEL_REF
1478 (VOIDmode,
1479 end_label),
1480 pc_rtx)));
1481 emit_insn (gen_addsi3 (scratch_string, scratch_string, GEN_INT (8)));
1482 emit_jump_insn (gen_rtx_SET (VOIDmode,
1483 pc_rtx,
1484 gen_rtx_LABEL_REF (VOIDmode, loop_label)));
1485 emit_barrier ();
1486 emit_label (end_label);
1487 emit_insn (gen_addsi3 (scratch_string, scratch_string, scratch_dlmzb));
1488 emit_insn (gen_subsi3 (result, scratch_string, addr));
1489 emit_insn (gen_subsi3 (result, result, const1_rtx));
1490 DONE;
1491 })
1492 \f
1493 (define_split
1494 [(set (match_operand:CC 2 "cc_reg_not_micro_cr0_operand" "")
1495 (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" ""))
1496 (const_int 0)))
1497 (set (match_operand:SI 0 "gpc_reg_operand" "")
1498 (sign_extend:SI (match_dup 1)))]
1499 "reload_completed"
1500 [(set (match_dup 0)
1501 (sign_extend:SI (match_dup 1)))
1502 (set (match_dup 2)
1503 (compare:CC (match_dup 0)
1504 (const_int 0)))]
1505 "")
1506
1507 ;; Fixed-point arithmetic insns.
1508
1509 (define_expand "add<mode>3"
1510 [(set (match_operand:SDI 0 "gpc_reg_operand" "")
1511 (plus:SDI (match_operand:SDI 1 "gpc_reg_operand" "")
1512 (match_operand:SDI 2 "reg_or_add_cint_operand" "")))]
1513 ""
1514 {
1515 if (<MODE>mode == DImode && ! TARGET_POWERPC64)
1516 {
1517 if (non_short_cint_operand (operands[2], DImode))
1518 FAIL;
1519 }
1520 else if (GET_CODE (operands[2]) == CONST_INT
1521 && ! add_operand (operands[2], <MODE>mode))
1522 {
1523 rtx tmp = ((!can_create_pseudo_p ()
1524 || rtx_equal_p (operands[0], operands[1]))
1525 ? operands[0] : gen_reg_rtx (<MODE>mode));
1526
1527 HOST_WIDE_INT val = INTVAL (operands[2]);
1528 HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
1529 HOST_WIDE_INT rest = trunc_int_for_mode (val - low, <MODE>mode);
1530
1531 if (<MODE>mode == DImode && !satisfies_constraint_L (GEN_INT (rest)))
1532 FAIL;
1533
1534 /* The ordering here is important for the prolog expander.
1535 When space is allocated from the stack, adding 'low' first may
1536 produce a temporary deallocation (which would be bad). */
1537 emit_insn (gen_add<mode>3 (tmp, operands[1], GEN_INT (rest)));
1538 emit_insn (gen_add<mode>3 (operands[0], tmp, GEN_INT (low)));
1539 DONE;
1540 }
1541 })
1542
1543 ;; Discourage ai/addic because of carry but provide it in an alternative
1544 ;; allowing register zero as source.
1545 (define_insn "*add<mode>3_internal1"
1546 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r,r,?r,r")
1547 (plus:GPR (match_operand:GPR 1 "gpc_reg_operand" "%r,b,r,b")
1548 (match_operand:GPR 2 "add_operand" "r,I,I,L")))]
1549 "!DECIMAL_FLOAT_MODE_P (GET_MODE (operands[0])) && !DECIMAL_FLOAT_MODE_P (GET_MODE (operands[1]))"
1550 "@
1551 {cax|add} %0,%1,%2
1552 {cal %0,%2(%1)|addi %0,%1,%2}
1553 {ai|addic} %0,%1,%2
1554 {cau|addis} %0,%1,%v2"
1555 [(set_attr "length" "4,4,4,4")])
1556
1557 (define_insn "addsi3_high"
1558 [(set (match_operand:SI 0 "gpc_reg_operand" "=b")
1559 (plus:SI (match_operand:SI 1 "gpc_reg_operand" "b")
1560 (high:SI (match_operand 2 "" ""))))]
1561 "TARGET_MACHO && !TARGET_64BIT"
1562 "{cau|addis} %0,%1,ha16(%2)"
1563 [(set_attr "length" "4")])
1564
1565 (define_insn "*add<mode>3_internal2"
1566 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
1567 (compare:CC (plus:P (match_operand:P 1 "gpc_reg_operand" "%r,r,r,r")
1568 (match_operand:P 2 "reg_or_short_operand" "r,I,r,I"))
1569 (const_int 0)))
1570 (clobber (match_scratch:P 3 "=r,r,r,r"))]
1571 ""
1572 "@
1573 {cax.|add.} %3,%1,%2
1574 {ai.|addic.} %3,%1,%2
1575 #
1576 #"
1577 [(set_attr "type" "fast_compare,compare,compare,compare")
1578 (set_attr "length" "4,4,8,8")])
1579
1580 (define_split
1581 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1582 (compare:CC (plus:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
1583 (match_operand:GPR 2 "reg_or_short_operand" ""))
1584 (const_int 0)))
1585 (clobber (match_scratch:GPR 3 ""))]
1586 "reload_completed"
1587 [(set (match_dup 3)
1588 (plus:GPR (match_dup 1)
1589 (match_dup 2)))
1590 (set (match_dup 0)
1591 (compare:CC (match_dup 3)
1592 (const_int 0)))]
1593 "")
1594
1595 (define_insn "*add<mode>3_internal3"
1596 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
1597 (compare:CC (plus:P (match_operand:P 1 "gpc_reg_operand" "%r,r,r,r")
1598 (match_operand:P 2 "reg_or_short_operand" "r,I,r,I"))
1599 (const_int 0)))
1600 (set (match_operand:P 0 "gpc_reg_operand" "=r,r,r,r")
1601 (plus:P (match_dup 1)
1602 (match_dup 2)))]
1603 ""
1604 "@
1605 {cax.|add.} %0,%1,%2
1606 {ai.|addic.} %0,%1,%2
1607 #
1608 #"
1609 [(set_attr "type" "fast_compare,compare,compare,compare")
1610 (set_attr "length" "4,4,8,8")])
1611
1612 (define_split
1613 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
1614 (compare:CC (plus:P (match_operand:P 1 "gpc_reg_operand" "")
1615 (match_operand:P 2 "reg_or_short_operand" ""))
1616 (const_int 0)))
1617 (set (match_operand:P 0 "gpc_reg_operand" "")
1618 (plus:P (match_dup 1) (match_dup 2)))]
1619 "reload_completed"
1620 [(set (match_dup 0)
1621 (plus:P (match_dup 1)
1622 (match_dup 2)))
1623 (set (match_dup 3)
1624 (compare:CC (match_dup 0)
1625 (const_int 0)))]
1626 "")
1627
1628 ;; Split an add that we can't do in one insn into two insns, each of which
1629 ;; does one 16-bit part. This is used by combine. Note that the low-order
1630 ;; add should be last in case the result gets used in an address.
1631
1632 (define_split
1633 [(set (match_operand:GPR 0 "gpc_reg_operand" "")
1634 (plus:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
1635 (match_operand:GPR 2 "non_add_cint_operand" "")))]
1636 ""
1637 [(set (match_dup 0) (plus:GPR (match_dup 1) (match_dup 3)))
1638 (set (match_dup 0) (plus:GPR (match_dup 0) (match_dup 4)))]
1639 {
1640 HOST_WIDE_INT val = INTVAL (operands[2]);
1641 HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
1642 HOST_WIDE_INT rest = trunc_int_for_mode (val - low, <MODE>mode);
1643
1644 operands[4] = GEN_INT (low);
1645 if (<MODE>mode == SImode || satisfies_constraint_L (GEN_INT (rest)))
1646 operands[3] = GEN_INT (rest);
1647 else if (can_create_pseudo_p ())
1648 {
1649 operands[3] = gen_reg_rtx (DImode);
1650 emit_move_insn (operands[3], operands[2]);
1651 emit_insn (gen_adddi3 (operands[0], operands[1], operands[3]));
1652 DONE;
1653 }
1654 else
1655 FAIL;
1656 })
1657
1658 (define_insn "one_cmpl<mode>2"
1659 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
1660 (not:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")))]
1661 ""
1662 "nor %0,%1,%1")
1663
1664 (define_insn ""
1665 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1666 (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
1667 (const_int 0)))
1668 (clobber (match_scratch:P 2 "=r,r"))]
1669 ""
1670 "@
1671 nor. %2,%1,%1
1672 #"
1673 [(set_attr "type" "compare")
1674 (set_attr "length" "4,8")])
1675
1676 (define_split
1677 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
1678 (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" ""))
1679 (const_int 0)))
1680 (clobber (match_scratch:P 2 ""))]
1681 "reload_completed"
1682 [(set (match_dup 2)
1683 (not:P (match_dup 1)))
1684 (set (match_dup 0)
1685 (compare:CC (match_dup 2)
1686 (const_int 0)))]
1687 "")
1688
1689 (define_insn ""
1690 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
1691 (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
1692 (const_int 0)))
1693 (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
1694 (not:P (match_dup 1)))]
1695 ""
1696 "@
1697 nor. %0,%1,%1
1698 #"
1699 [(set_attr "type" "compare")
1700 (set_attr "length" "4,8")])
1701
1702 (define_split
1703 [(set (match_operand:CC 2 "cc_reg_not_micro_cr0_operand" "")
1704 (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" ""))
1705 (const_int 0)))
1706 (set (match_operand:P 0 "gpc_reg_operand" "")
1707 (not:P (match_dup 1)))]
1708 "reload_completed"
1709 [(set (match_dup 0)
1710 (not:P (match_dup 1)))
1711 (set (match_dup 2)
1712 (compare:CC (match_dup 0)
1713 (const_int 0)))]
1714 "")
1715
1716 (define_insn ""
1717 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1718 (minus:SI (match_operand:SI 1 "reg_or_short_operand" "rI")
1719 (match_operand:SI 2 "gpc_reg_operand" "r")))]
1720 "! TARGET_POWERPC"
1721 "{sf%I1|subf%I1c} %0,%2,%1")
1722
1723 (define_insn ""
1724 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r,r")
1725 (minus:GPR (match_operand:GPR 1 "reg_or_short_operand" "r,I")
1726 (match_operand:GPR 2 "gpc_reg_operand" "r,r")))]
1727 "TARGET_POWERPC"
1728 "@
1729 subf %0,%2,%1
1730 subfic %0,%2,%1")
1731
1732 (define_insn ""
1733 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1734 (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
1735 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
1736 (const_int 0)))
1737 (clobber (match_scratch:SI 3 "=r,r"))]
1738 "! TARGET_POWERPC"
1739 "@
1740 {sf.|subfc.} %3,%2,%1
1741 #"
1742 [(set_attr "type" "compare")
1743 (set_attr "length" "4,8")])
1744
1745 (define_insn ""
1746 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1747 (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "r,r")
1748 (match_operand:P 2 "gpc_reg_operand" "r,r"))
1749 (const_int 0)))
1750 (clobber (match_scratch:P 3 "=r,r"))]
1751 "TARGET_POWERPC"
1752 "@
1753 subf. %3,%2,%1
1754 #"
1755 [(set_attr "type" "fast_compare")
1756 (set_attr "length" "4,8")])
1757
1758 (define_split
1759 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1760 (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "")
1761 (match_operand:P 2 "gpc_reg_operand" ""))
1762 (const_int 0)))
1763 (clobber (match_scratch:P 3 ""))]
1764 "reload_completed"
1765 [(set (match_dup 3)
1766 (minus:P (match_dup 1)
1767 (match_dup 2)))
1768 (set (match_dup 0)
1769 (compare:CC (match_dup 3)
1770 (const_int 0)))]
1771 "")
1772
1773 (define_insn ""
1774 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1775 (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
1776 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
1777 (const_int 0)))
1778 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
1779 (minus:SI (match_dup 1) (match_dup 2)))]
1780 "! TARGET_POWERPC"
1781 "@
1782 {sf.|subfc.} %0,%2,%1
1783 #"
1784 [(set_attr "type" "compare")
1785 (set_attr "length" "4,8")])
1786
1787 (define_insn ""
1788 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1789 (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "r,r")
1790 (match_operand:P 2 "gpc_reg_operand" "r,r"))
1791 (const_int 0)))
1792 (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
1793 (minus:P (match_dup 1)
1794 (match_dup 2)))]
1795 "TARGET_POWERPC"
1796 "@
1797 subf. %0,%2,%1
1798 #"
1799 [(set_attr "type" "fast_compare")
1800 (set_attr "length" "4,8")])
1801
1802 (define_split
1803 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
1804 (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "")
1805 (match_operand:P 2 "gpc_reg_operand" ""))
1806 (const_int 0)))
1807 (set (match_operand:P 0 "gpc_reg_operand" "")
1808 (minus:P (match_dup 1)
1809 (match_dup 2)))]
1810 "reload_completed"
1811 [(set (match_dup 0)
1812 (minus:P (match_dup 1)
1813 (match_dup 2)))
1814 (set (match_dup 3)
1815 (compare:CC (match_dup 0)
1816 (const_int 0)))]
1817 "")
1818
1819 (define_expand "sub<mode>3"
1820 [(set (match_operand:SDI 0 "gpc_reg_operand" "")
1821 (minus:SDI (match_operand:SDI 1 "reg_or_short_operand" "")
1822 (match_operand:SDI 2 "reg_or_sub_cint_operand" "")))]
1823 ""
1824 "
1825 {
1826 if (GET_CODE (operands[2]) == CONST_INT)
1827 {
1828 emit_insn (gen_add<mode>3 (operands[0], operands[1],
1829 negate_rtx (<MODE>mode, operands[2])));
1830 DONE;
1831 }
1832 }")
1833
1834 ;; For SMIN, SMAX, UMIN, and UMAX, we use DEFINE_EXPAND's that involve a doz[i]
1835 ;; instruction and some auxiliary computations. Then we just have a single
1836 ;; DEFINE_INSN for doz[i] and the define_splits to make them if made by
1837 ;; combine.
1838
1839 (define_expand "sminsi3"
1840 [(set (match_dup 3)
1841 (if_then_else:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
1842 (match_operand:SI 2 "reg_or_short_operand" ""))
1843 (const_int 0)
1844 (minus:SI (match_dup 2) (match_dup 1))))
1845 (set (match_operand:SI 0 "gpc_reg_operand" "")
1846 (minus:SI (match_dup 2) (match_dup 3)))]
1847 "TARGET_POWER || TARGET_ISEL"
1848 "
1849 {
1850 if (TARGET_ISEL)
1851 {
1852 operands[2] = force_reg (SImode, operands[2]);
1853 rs6000_emit_minmax (operands[0], SMIN, operands[1], operands[2]);
1854 DONE;
1855 }
1856
1857 operands[3] = gen_reg_rtx (SImode);
1858 }")
1859
1860 (define_split
1861 [(set (match_operand:SI 0 "gpc_reg_operand" "")
1862 (smin:SI (match_operand:SI 1 "gpc_reg_operand" "")
1863 (match_operand:SI 2 "reg_or_short_operand" "")))
1864 (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
1865 "TARGET_POWER"
1866 [(set (match_dup 3)
1867 (if_then_else:SI (gt:SI (match_dup 1) (match_dup 2))
1868 (const_int 0)
1869 (minus:SI (match_dup 2) (match_dup 1))))
1870 (set (match_dup 0) (minus:SI (match_dup 2) (match_dup 3)))]
1871 "")
1872
1873 (define_expand "smaxsi3"
1874 [(set (match_dup 3)
1875 (if_then_else:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
1876 (match_operand:SI 2 "reg_or_short_operand" ""))
1877 (const_int 0)
1878 (minus:SI (match_dup 2) (match_dup 1))))
1879 (set (match_operand:SI 0 "gpc_reg_operand" "")
1880 (plus:SI (match_dup 3) (match_dup 1)))]
1881 "TARGET_POWER || TARGET_ISEL"
1882 "
1883 {
1884 if (TARGET_ISEL)
1885 {
1886 operands[2] = force_reg (SImode, operands[2]);
1887 rs6000_emit_minmax (operands[0], SMAX, operands[1], operands[2]);
1888 DONE;
1889 }
1890 operands[3] = gen_reg_rtx (SImode);
1891 }")
1892
1893 (define_split
1894 [(set (match_operand:SI 0 "gpc_reg_operand" "")
1895 (smax:SI (match_operand:SI 1 "gpc_reg_operand" "")
1896 (match_operand:SI 2 "reg_or_short_operand" "")))
1897 (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
1898 "TARGET_POWER"
1899 [(set (match_dup 3)
1900 (if_then_else:SI (gt:SI (match_dup 1) (match_dup 2))
1901 (const_int 0)
1902 (minus:SI (match_dup 2) (match_dup 1))))
1903 (set (match_dup 0) (plus:SI (match_dup 3) (match_dup 1)))]
1904 "")
1905
1906 (define_expand "uminsi3"
1907 [(set (match_dup 3) (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
1908 (match_dup 5)))
1909 (set (match_dup 4) (xor:SI (match_operand:SI 2 "gpc_reg_operand" "")
1910 (match_dup 5)))
1911 (set (match_dup 3) (if_then_else:SI (gt (match_dup 3) (match_dup 4))
1912 (const_int 0)
1913 (minus:SI (match_dup 4) (match_dup 3))))
1914 (set (match_operand:SI 0 "gpc_reg_operand" "")
1915 (minus:SI (match_dup 2) (match_dup 3)))]
1916 "TARGET_POWER || TARGET_ISEL"
1917 "
1918 {
1919 if (TARGET_ISEL)
1920 {
1921 rs6000_emit_minmax (operands[0], UMIN, operands[1], operands[2]);
1922 DONE;
1923 }
1924 operands[3] = gen_reg_rtx (SImode);
1925 operands[4] = gen_reg_rtx (SImode);
1926 operands[5] = GEN_INT (-2147483647 - 1);
1927 }")
1928
1929 (define_expand "umaxsi3"
1930 [(set (match_dup 3) (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
1931 (match_dup 5)))
1932 (set (match_dup 4) (xor:SI (match_operand:SI 2 "gpc_reg_operand" "")
1933 (match_dup 5)))
1934 (set (match_dup 3) (if_then_else:SI (gt (match_dup 3) (match_dup 4))
1935 (const_int 0)
1936 (minus:SI (match_dup 4) (match_dup 3))))
1937 (set (match_operand:SI 0 "gpc_reg_operand" "")
1938 (plus:SI (match_dup 3) (match_dup 1)))]
1939 "TARGET_POWER || TARGET_ISEL"
1940 "
1941 {
1942 if (TARGET_ISEL)
1943 {
1944 rs6000_emit_minmax (operands[0], UMAX, operands[1], operands[2]);
1945 DONE;
1946 }
1947 operands[3] = gen_reg_rtx (SImode);
1948 operands[4] = gen_reg_rtx (SImode);
1949 operands[5] = GEN_INT (-2147483647 - 1);
1950 }")
1951
1952 (define_insn ""
1953 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1954 (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r")
1955 (match_operand:SI 2 "reg_or_short_operand" "rI"))
1956 (const_int 0)
1957 (minus:SI (match_dup 2) (match_dup 1))))]
1958 "TARGET_POWER"
1959 "doz%I2 %0,%1,%2")
1960
1961 (define_insn ""
1962 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1963 (compare:CC
1964 (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r,r")
1965 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
1966 (const_int 0)
1967 (minus:SI (match_dup 2) (match_dup 1)))
1968 (const_int 0)))
1969 (clobber (match_scratch:SI 3 "=r,r"))]
1970 "TARGET_POWER"
1971 "@
1972 doz%I2. %3,%1,%2
1973 #"
1974 [(set_attr "type" "delayed_compare")
1975 (set_attr "length" "4,8")])
1976
1977 (define_split
1978 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1979 (compare:CC
1980 (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "")
1981 (match_operand:SI 2 "reg_or_short_operand" ""))
1982 (const_int 0)
1983 (minus:SI (match_dup 2) (match_dup 1)))
1984 (const_int 0)))
1985 (clobber (match_scratch:SI 3 ""))]
1986 "TARGET_POWER && reload_completed"
1987 [(set (match_dup 3)
1988 (if_then_else:SI (gt (match_dup 1) (match_dup 2))
1989 (const_int 0)
1990 (minus:SI (match_dup 2) (match_dup 1))))
1991 (set (match_dup 0)
1992 (compare:CC (match_dup 3)
1993 (const_int 0)))]
1994 "")
1995
1996 (define_insn ""
1997 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1998 (compare:CC
1999 (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r,r")
2000 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
2001 (const_int 0)
2002 (minus:SI (match_dup 2) (match_dup 1)))
2003 (const_int 0)))
2004 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2005 (if_then_else:SI (gt (match_dup 1) (match_dup 2))
2006 (const_int 0)
2007 (minus:SI (match_dup 2) (match_dup 1))))]
2008 "TARGET_POWER"
2009 "@
2010 doz%I2. %0,%1,%2
2011 #"
2012 [(set_attr "type" "delayed_compare")
2013 (set_attr "length" "4,8")])
2014
2015 (define_split
2016 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2017 (compare:CC
2018 (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "")
2019 (match_operand:SI 2 "reg_or_short_operand" ""))
2020 (const_int 0)
2021 (minus:SI (match_dup 2) (match_dup 1)))
2022 (const_int 0)))
2023 (set (match_operand:SI 0 "gpc_reg_operand" "")
2024 (if_then_else:SI (gt (match_dup 1) (match_dup 2))
2025 (const_int 0)
2026 (minus:SI (match_dup 2) (match_dup 1))))]
2027 "TARGET_POWER && reload_completed"
2028 [(set (match_dup 0)
2029 (if_then_else:SI (gt (match_dup 1) (match_dup 2))
2030 (const_int 0)
2031 (minus:SI (match_dup 2) (match_dup 1))))
2032 (set (match_dup 3)
2033 (compare:CC (match_dup 0)
2034 (const_int 0)))]
2035 "")
2036
2037 ;; We don't need abs with condition code because such comparisons should
2038 ;; never be done.
2039 (define_expand "abssi2"
2040 [(set (match_operand:SI 0 "gpc_reg_operand" "")
2041 (abs:SI (match_operand:SI 1 "gpc_reg_operand" "")))]
2042 ""
2043 "
2044 {
2045 if (TARGET_ISEL)
2046 {
2047 emit_insn (gen_abssi2_isel (operands[0], operands[1]));
2048 DONE;
2049 }
2050 else if (! TARGET_POWER)
2051 {
2052 emit_insn (gen_abssi2_nopower (operands[0], operands[1]));
2053 DONE;
2054 }
2055 }")
2056
2057 (define_insn "*abssi2_power"
2058 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2059 (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
2060 "TARGET_POWER"
2061 "abs %0,%1")
2062
2063 (define_insn_and_split "abssi2_isel"
2064 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2065 (abs:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
2066 (clobber (match_scratch:SI 2 "=&b"))
2067 (clobber (match_scratch:CC 3 "=y"))]
2068 "TARGET_ISEL"
2069 "#"
2070 "&& reload_completed"
2071 [(set (match_dup 2) (neg:SI (match_dup 1)))
2072 (set (match_dup 3)
2073 (compare:CC (match_dup 1)
2074 (const_int 0)))
2075 (set (match_dup 0)
2076 (if_then_else:SI (ge (match_dup 3)
2077 (const_int 0))
2078 (match_dup 1)
2079 (match_dup 2)))]
2080 "")
2081
2082 (define_insn_and_split "abssi2_nopower"
2083 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,r")
2084 (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,0")))
2085 (clobber (match_scratch:SI 2 "=&r,&r"))]
2086 "! TARGET_POWER && ! TARGET_ISEL"
2087 "#"
2088 "&& reload_completed"
2089 [(set (match_dup 2) (ashiftrt:SI (match_dup 1) (const_int 31)))
2090 (set (match_dup 0) (xor:SI (match_dup 2) (match_dup 1)))
2091 (set (match_dup 0) (minus:SI (match_dup 0) (match_dup 2)))]
2092 "")
2093
2094 (define_insn "*nabs_power"
2095 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2096 (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r"))))]
2097 "TARGET_POWER"
2098 "nabs %0,%1")
2099
2100 (define_insn_and_split "*nabs_nopower"
2101 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,r")
2102 (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,0"))))
2103 (clobber (match_scratch:SI 2 "=&r,&r"))]
2104 "! TARGET_POWER"
2105 "#"
2106 "&& reload_completed"
2107 [(set (match_dup 2) (ashiftrt:SI (match_dup 1) (const_int 31)))
2108 (set (match_dup 0) (xor:SI (match_dup 2) (match_dup 1)))
2109 (set (match_dup 0) (minus:SI (match_dup 2) (match_dup 0)))]
2110 "")
2111
2112 (define_expand "neg<mode>2"
2113 [(set (match_operand:SDI 0 "gpc_reg_operand" "")
2114 (neg:SDI (match_operand:SDI 1 "gpc_reg_operand" "")))]
2115 ""
2116 "")
2117
2118 (define_insn "*neg<mode>2_internal"
2119 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2120 (neg:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")))]
2121 ""
2122 "neg %0,%1")
2123
2124 (define_insn ""
2125 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
2126 (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
2127 (const_int 0)))
2128 (clobber (match_scratch:P 2 "=r,r"))]
2129 ""
2130 "@
2131 neg. %2,%1
2132 #"
2133 [(set_attr "type" "fast_compare")
2134 (set_attr "length" "4,8")])
2135
2136 (define_split
2137 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2138 (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" ""))
2139 (const_int 0)))
2140 (clobber (match_scratch:P 2 ""))]
2141 "reload_completed"
2142 [(set (match_dup 2)
2143 (neg:P (match_dup 1)))
2144 (set (match_dup 0)
2145 (compare:CC (match_dup 2)
2146 (const_int 0)))]
2147 "")
2148
2149 (define_insn ""
2150 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
2151 (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
2152 (const_int 0)))
2153 (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
2154 (neg:P (match_dup 1)))]
2155 ""
2156 "@
2157 neg. %0,%1
2158 #"
2159 [(set_attr "type" "fast_compare")
2160 (set_attr "length" "4,8")])
2161
2162 (define_split
2163 [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
2164 (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" ""))
2165 (const_int 0)))
2166 (set (match_operand:P 0 "gpc_reg_operand" "")
2167 (neg:P (match_dup 1)))]
2168 "reload_completed"
2169 [(set (match_dup 0)
2170 (neg:P (match_dup 1)))
2171 (set (match_dup 2)
2172 (compare:CC (match_dup 0)
2173 (const_int 0)))]
2174 "")
2175
2176 (define_insn "clz<mode>2"
2177 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2178 (clz:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")))]
2179 ""
2180 "{cntlz|cntlz<wd>} %0,%1"
2181 [(set_attr "type" "cntlz")])
2182
2183 (define_expand "ctz<mode>2"
2184 [(set (match_dup 2)
2185 (neg:GPR (match_operand:GPR 1 "gpc_reg_operand" "")))
2186 (parallel [(set (match_dup 3) (and:GPR (match_dup 1)
2187 (match_dup 2)))
2188 (clobber (scratch:CC))])
2189 (set (match_dup 4) (clz:GPR (match_dup 3)))
2190 (set (match_operand:GPR 0 "gpc_reg_operand" "")
2191 (minus:GPR (match_dup 5) (match_dup 4)))]
2192 ""
2193 {
2194 operands[2] = gen_reg_rtx (<MODE>mode);
2195 operands[3] = gen_reg_rtx (<MODE>mode);
2196 operands[4] = gen_reg_rtx (<MODE>mode);
2197 operands[5] = GEN_INT (GET_MODE_BITSIZE (<MODE>mode) - 1);
2198 })
2199
2200 (define_expand "ffs<mode>2"
2201 [(set (match_dup 2)
2202 (neg:GPR (match_operand:GPR 1 "gpc_reg_operand" "")))
2203 (parallel [(set (match_dup 3) (and:GPR (match_dup 1)
2204 (match_dup 2)))
2205 (clobber (scratch:CC))])
2206 (set (match_dup 4) (clz:GPR (match_dup 3)))
2207 (set (match_operand:GPR 0 "gpc_reg_operand" "")
2208 (minus:GPR (match_dup 5) (match_dup 4)))]
2209 ""
2210 {
2211 operands[2] = gen_reg_rtx (<MODE>mode);
2212 operands[3] = gen_reg_rtx (<MODE>mode);
2213 operands[4] = gen_reg_rtx (<MODE>mode);
2214 operands[5] = GEN_INT (GET_MODE_BITSIZE (<MODE>mode));
2215 })
2216
2217 (define_insn "popcntb<mode>2"
2218 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2219 (unspec:GPR [(match_operand:GPR 1 "gpc_reg_operand" "r")]
2220 UNSPEC_POPCNTB))]
2221 "TARGET_POPCNTB"
2222 "popcntb %0,%1")
2223
2224 (define_expand "popcount<mode>2"
2225 [(set (match_operand:GPR 0 "gpc_reg_operand" "")
2226 (popcount:GPR (match_operand:GPR 1 "gpc_reg_operand" "")))]
2227 "TARGET_POPCNTB"
2228 {
2229 rs6000_emit_popcount (operands[0], operands[1]);
2230 DONE;
2231 })
2232
2233 (define_expand "parity<mode>2"
2234 [(set (match_operand:GPR 0 "gpc_reg_operand" "")
2235 (parity:GPR (match_operand:GPR 1 "gpc_reg_operand" "")))]
2236 "TARGET_POPCNTB"
2237 {
2238 rs6000_emit_parity (operands[0], operands[1]);
2239 DONE;
2240 })
2241
2242 (define_insn "bswapsi2"
2243 [(set (match_operand:SI 0 "reg_or_mem_operand" "=r,Z,&r")
2244 (bswap:SI (match_operand:SI 1 "reg_or_mem_operand" "Z,r,r")))]
2245 ""
2246 "@
2247 {lbrx|lwbrx} %0,%y1
2248 {stbrx|stwbrx} %1,%y0
2249 #"
2250 [(set_attr "length" "4,4,12")])
2251
2252 (define_split
2253 [(set (match_operand:SI 0 "gpc_reg_operand" "")
2254 (bswap:SI (match_operand:SI 1 "gpc_reg_operand" "")))]
2255 "reload_completed"
2256 [(set (match_dup 0)
2257 (rotate:SI (match_dup 1) (const_int 8)))
2258 (set (zero_extract:SI (match_dup 0)
2259 (const_int 8)
2260 (const_int 0))
2261 (match_dup 1))
2262 (set (zero_extract:SI (match_dup 0)
2263 (const_int 8)
2264 (const_int 16))
2265 (rotate:SI (match_dup 1)
2266 (const_int 16)))]
2267 "")
2268
2269 (define_expand "mulsi3"
2270 [(use (match_operand:SI 0 "gpc_reg_operand" ""))
2271 (use (match_operand:SI 1 "gpc_reg_operand" ""))
2272 (use (match_operand:SI 2 "reg_or_short_operand" ""))]
2273 ""
2274 "
2275 {
2276 if (TARGET_POWER)
2277 emit_insn (gen_mulsi3_mq (operands[0], operands[1], operands[2]));
2278 else
2279 emit_insn (gen_mulsi3_no_mq (operands[0], operands[1], operands[2]));
2280 DONE;
2281 }")
2282
2283 (define_insn "mulsi3_mq"
2284 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2285 (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2286 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
2287 (clobber (match_scratch:SI 3 "=q,q"))]
2288 "TARGET_POWER"
2289 "@
2290 {muls|mullw} %0,%1,%2
2291 {muli|mulli} %0,%1,%2"
2292 [(set (attr "type")
2293 (cond [(match_operand:SI 2 "s8bit_cint_operand" "")
2294 (const_string "imul3")
2295 (match_operand:SI 2 "short_cint_operand" "")
2296 (const_string "imul2")]
2297 (const_string "imul")))])
2298
2299 (define_insn "mulsi3_no_mq"
2300 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2301 (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2302 (match_operand:SI 2 "reg_or_short_operand" "r,I")))]
2303 "! TARGET_POWER"
2304 "@
2305 {muls|mullw} %0,%1,%2
2306 {muli|mulli} %0,%1,%2"
2307 [(set (attr "type")
2308 (cond [(match_operand:SI 2 "s8bit_cint_operand" "")
2309 (const_string "imul3")
2310 (match_operand:SI 2 "short_cint_operand" "")
2311 (const_string "imul2")]
2312 (const_string "imul")))])
2313
2314 (define_insn "*mulsi3_mq_internal1"
2315 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
2316 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2317 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2318 (const_int 0)))
2319 (clobber (match_scratch:SI 3 "=r,r"))
2320 (clobber (match_scratch:SI 4 "=q,q"))]
2321 "TARGET_POWER"
2322 "@
2323 {muls.|mullw.} %3,%1,%2
2324 #"
2325 [(set_attr "type" "imul_compare")
2326 (set_attr "length" "4,8")])
2327
2328 (define_split
2329 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2330 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
2331 (match_operand:SI 2 "gpc_reg_operand" ""))
2332 (const_int 0)))
2333 (clobber (match_scratch:SI 3 ""))
2334 (clobber (match_scratch:SI 4 ""))]
2335 "TARGET_POWER && reload_completed"
2336 [(parallel [(set (match_dup 3)
2337 (mult:SI (match_dup 1) (match_dup 2)))
2338 (clobber (match_dup 4))])
2339 (set (match_dup 0)
2340 (compare:CC (match_dup 3)
2341 (const_int 0)))]
2342 "")
2343
2344 (define_insn "*mulsi3_no_mq_internal1"
2345 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
2346 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2347 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2348 (const_int 0)))
2349 (clobber (match_scratch:SI 3 "=r,r"))]
2350 "! TARGET_POWER"
2351 "@
2352 {muls.|mullw.} %3,%1,%2
2353 #"
2354 [(set_attr "type" "imul_compare")
2355 (set_attr "length" "4,8")])
2356
2357 (define_split
2358 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
2359 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
2360 (match_operand:SI 2 "gpc_reg_operand" ""))
2361 (const_int 0)))
2362 (clobber (match_scratch:SI 3 ""))]
2363 "! TARGET_POWER && reload_completed"
2364 [(set (match_dup 3)
2365 (mult:SI (match_dup 1) (match_dup 2)))
2366 (set (match_dup 0)
2367 (compare:CC (match_dup 3)
2368 (const_int 0)))]
2369 "")
2370
2371 (define_insn "*mulsi3_mq_internal2"
2372 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
2373 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2374 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2375 (const_int 0)))
2376 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2377 (mult:SI (match_dup 1) (match_dup 2)))
2378 (clobber (match_scratch:SI 4 "=q,q"))]
2379 "TARGET_POWER"
2380 "@
2381 {muls.|mullw.} %0,%1,%2
2382 #"
2383 [(set_attr "type" "imul_compare")
2384 (set_attr "length" "4,8")])
2385
2386 (define_split
2387 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2388 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
2389 (match_operand:SI 2 "gpc_reg_operand" ""))
2390 (const_int 0)))
2391 (set (match_operand:SI 0 "gpc_reg_operand" "")
2392 (mult:SI (match_dup 1) (match_dup 2)))
2393 (clobber (match_scratch:SI 4 ""))]
2394 "TARGET_POWER && reload_completed"
2395 [(parallel [(set (match_dup 0)
2396 (mult:SI (match_dup 1) (match_dup 2)))
2397 (clobber (match_dup 4))])
2398 (set (match_dup 3)
2399 (compare:CC (match_dup 0)
2400 (const_int 0)))]
2401 "")
2402
2403 (define_insn "*mulsi3_no_mq_internal2"
2404 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
2405 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2406 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2407 (const_int 0)))
2408 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2409 (mult:SI (match_dup 1) (match_dup 2)))]
2410 "! TARGET_POWER"
2411 "@
2412 {muls.|mullw.} %0,%1,%2
2413 #"
2414 [(set_attr "type" "imul_compare")
2415 (set_attr "length" "4,8")])
2416
2417 (define_split
2418 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
2419 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
2420 (match_operand:SI 2 "gpc_reg_operand" ""))
2421 (const_int 0)))
2422 (set (match_operand:SI 0 "gpc_reg_operand" "")
2423 (mult:SI (match_dup 1) (match_dup 2)))]
2424 "! TARGET_POWER && reload_completed"
2425 [(set (match_dup 0)
2426 (mult:SI (match_dup 1) (match_dup 2)))
2427 (set (match_dup 3)
2428 (compare:CC (match_dup 0)
2429 (const_int 0)))]
2430 "")
2431
2432 ;; Operand 1 is divided by operand 2; quotient goes to operand
2433 ;; 0 and remainder to operand 3.
2434 ;; ??? At some point, see what, if anything, we can do about if (x % y == 0).
2435
2436 (define_expand "divmodsi4"
2437 [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
2438 (div:SI (match_operand:SI 1 "gpc_reg_operand" "")
2439 (match_operand:SI 2 "gpc_reg_operand" "")))
2440 (set (match_operand:SI 3 "register_operand" "")
2441 (mod:SI (match_dup 1) (match_dup 2)))])]
2442 "TARGET_POWER || (! TARGET_POWER && ! TARGET_POWERPC)"
2443 "
2444 {
2445 if (! TARGET_POWER && ! TARGET_POWERPC)
2446 {
2447 emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
2448 emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
2449 emit_insn (gen_divss_call ());
2450 emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
2451 emit_move_insn (operands[3], gen_rtx_REG (SImode, 4));
2452 DONE;
2453 }
2454 }")
2455
2456 (define_insn "*divmodsi4_internal"
2457 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2458 (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2459 (match_operand:SI 2 "gpc_reg_operand" "r")))
2460 (set (match_operand:SI 3 "register_operand" "=q")
2461 (mod:SI (match_dup 1) (match_dup 2)))]
2462 "TARGET_POWER"
2463 "divs %0,%1,%2"
2464 [(set_attr "type" "idiv")])
2465
2466 (define_expand "udiv<mode>3"
2467 [(set (match_operand:GPR 0 "gpc_reg_operand" "")
2468 (udiv:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2469 (match_operand:GPR 2 "gpc_reg_operand" "")))]
2470 "TARGET_POWERPC || (! TARGET_POWER && ! TARGET_POWERPC)"
2471 "
2472 {
2473 if (! TARGET_POWER && ! TARGET_POWERPC)
2474 {
2475 emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
2476 emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
2477 emit_insn (gen_quous_call ());
2478 emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
2479 DONE;
2480 }
2481 else if (TARGET_POWER)
2482 {
2483 emit_insn (gen_udivsi3_mq (operands[0], operands[1], operands[2]));
2484 DONE;
2485 }
2486 }")
2487
2488 (define_insn "udivsi3_mq"
2489 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2490 (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2491 (match_operand:SI 2 "gpc_reg_operand" "r")))
2492 (clobber (match_scratch:SI 3 "=q"))]
2493 "TARGET_POWERPC && TARGET_POWER"
2494 "divwu %0,%1,%2"
2495 [(set_attr "type" "idiv")])
2496
2497 (define_insn "*udivsi3_no_mq"
2498 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2499 (udiv:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")
2500 (match_operand:GPR 2 "gpc_reg_operand" "r")))]
2501 "TARGET_POWERPC && ! TARGET_POWER"
2502 "div<wd>u %0,%1,%2"
2503 [(set (attr "type")
2504 (cond [(match_operand:SI 0 "" "")
2505 (const_string "idiv")]
2506 (const_string "ldiv")))])
2507
2508
2509 ;; For powers of two we can do srai/aze for divide and then adjust for
2510 ;; modulus. If it isn't a power of two, FAIL on POWER so divmodsi4 will be
2511 ;; used; for PowerPC, force operands into register and do a normal divide;
2512 ;; for AIX common-mode, use quoss call on register operands.
2513 (define_expand "div<mode>3"
2514 [(set (match_operand:GPR 0 "gpc_reg_operand" "")
2515 (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2516 (match_operand:GPR 2 "reg_or_cint_operand" "")))]
2517 ""
2518 "
2519 {
2520 if (GET_CODE (operands[2]) == CONST_INT
2521 && INTVAL (operands[2]) > 0
2522 && exact_log2 (INTVAL (operands[2])) >= 0)
2523 ;
2524 else if (TARGET_POWERPC)
2525 {
2526 operands[2] = force_reg (<MODE>mode, operands[2]);
2527 if (TARGET_POWER)
2528 {
2529 emit_insn (gen_divsi3_mq (operands[0], operands[1], operands[2]));
2530 DONE;
2531 }
2532 }
2533 else if (TARGET_POWER)
2534 FAIL;
2535 else
2536 {
2537 emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
2538 emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
2539 emit_insn (gen_quoss_call ());
2540 emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
2541 DONE;
2542 }
2543 }")
2544
2545 (define_insn "divsi3_mq"
2546 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2547 (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2548 (match_operand:SI 2 "gpc_reg_operand" "r")))
2549 (clobber (match_scratch:SI 3 "=q"))]
2550 "TARGET_POWERPC && TARGET_POWER"
2551 "divw %0,%1,%2"
2552 [(set_attr "type" "idiv")])
2553
2554 (define_insn "*div<mode>3_no_mq"
2555 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2556 (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")
2557 (match_operand:GPR 2 "gpc_reg_operand" "r")))]
2558 "TARGET_POWERPC && ! TARGET_POWER"
2559 "div<wd> %0,%1,%2"
2560 [(set (attr "type")
2561 (cond [(match_operand:SI 0 "" "")
2562 (const_string "idiv")]
2563 (const_string "ldiv")))])
2564
2565 (define_expand "mod<mode>3"
2566 [(use (match_operand:GPR 0 "gpc_reg_operand" ""))
2567 (use (match_operand:GPR 1 "gpc_reg_operand" ""))
2568 (use (match_operand:GPR 2 "reg_or_cint_operand" ""))]
2569 ""
2570 "
2571 {
2572 int i;
2573 rtx temp1;
2574 rtx temp2;
2575
2576 if (GET_CODE (operands[2]) != CONST_INT
2577 || INTVAL (operands[2]) <= 0
2578 || (i = exact_log2 (INTVAL (operands[2]))) < 0)
2579 FAIL;
2580
2581 temp1 = gen_reg_rtx (<MODE>mode);
2582 temp2 = gen_reg_rtx (<MODE>mode);
2583
2584 emit_insn (gen_div<mode>3 (temp1, operands[1], operands[2]));
2585 emit_insn (gen_ashl<mode>3 (temp2, temp1, GEN_INT (i)));
2586 emit_insn (gen_sub<mode>3 (operands[0], operands[1], temp2));
2587 DONE;
2588 }")
2589
2590 (define_insn ""
2591 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2592 (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")
2593 (match_operand:GPR 2 "exact_log2_cint_operand" "N")))]
2594 ""
2595 "{srai|sra<wd>i} %0,%1,%p2\;{aze|addze} %0,%0"
2596 [(set_attr "type" "two")
2597 (set_attr "length" "8")])
2598
2599 (define_insn ""
2600 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
2601 (compare:CC (div:P (match_operand:P 1 "gpc_reg_operand" "r,r")
2602 (match_operand:P 2 "exact_log2_cint_operand" "N,N"))
2603 (const_int 0)))
2604 (clobber (match_scratch:P 3 "=r,r"))]
2605 ""
2606 "@
2607 {srai|sra<wd>i} %3,%1,%p2\;{aze.|addze.} %3,%3
2608 #"
2609 [(set_attr "type" "compare")
2610 (set_attr "length" "8,12")
2611 (set_attr "cell_micro" "not")])
2612
2613 (define_split
2614 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2615 (compare:CC (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2616 (match_operand:GPR 2 "exact_log2_cint_operand"
2617 ""))
2618 (const_int 0)))
2619 (clobber (match_scratch:GPR 3 ""))]
2620 "reload_completed"
2621 [(set (match_dup 3)
2622 (div:<MODE> (match_dup 1) (match_dup 2)))
2623 (set (match_dup 0)
2624 (compare:CC (match_dup 3)
2625 (const_int 0)))]
2626 "")
2627
2628 (define_insn ""
2629 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
2630 (compare:CC (div:P (match_operand:P 1 "gpc_reg_operand" "r,r")
2631 (match_operand:P 2 "exact_log2_cint_operand" "N,N"))
2632 (const_int 0)))
2633 (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
2634 (div:P (match_dup 1) (match_dup 2)))]
2635 ""
2636 "@
2637 {srai|sra<wd>i} %0,%1,%p2\;{aze.|addze.} %0,%0
2638 #"
2639 [(set_attr "type" "compare")
2640 (set_attr "length" "8,12")
2641 (set_attr "cell_micro" "not")])
2642
2643 (define_split
2644 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2645 (compare:CC (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2646 (match_operand:GPR 2 "exact_log2_cint_operand"
2647 ""))
2648 (const_int 0)))
2649 (set (match_operand:GPR 0 "gpc_reg_operand" "")
2650 (div:GPR (match_dup 1) (match_dup 2)))]
2651 "reload_completed"
2652 [(set (match_dup 0)
2653 (div:<MODE> (match_dup 1) (match_dup 2)))
2654 (set (match_dup 3)
2655 (compare:CC (match_dup 0)
2656 (const_int 0)))]
2657 "")
2658
2659 (define_insn ""
2660 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2661 (udiv:SI
2662 (plus:DI (ashift:DI
2663 (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
2664 (const_int 32))
2665 (zero_extend:DI (match_operand:SI 4 "register_operand" "2")))
2666 (match_operand:SI 3 "gpc_reg_operand" "r")))
2667 (set (match_operand:SI 2 "register_operand" "=*q")
2668 (umod:SI
2669 (plus:DI (ashift:DI
2670 (zero_extend:DI (match_dup 1)) (const_int 32))
2671 (zero_extend:DI (match_dup 4)))
2672 (match_dup 3)))]
2673 "TARGET_POWER"
2674 "div %0,%1,%3"
2675 [(set_attr "type" "idiv")])
2676
2677 ;; To do unsigned divide we handle the cases of the divisor looking like a
2678 ;; negative number. If it is a constant that is less than 2**31, we don't
2679 ;; have to worry about the branches. So make a few subroutines here.
2680 ;;
2681 ;; First comes the normal case.
2682 (define_expand "udivmodsi4_normal"
2683 [(set (match_dup 4) (const_int 0))
2684 (parallel [(set (match_operand:SI 0 "" "")
2685 (udiv:SI (plus:DI (ashift:DI (zero_extend:DI (match_dup 4))
2686 (const_int 32))
2687 (zero_extend:DI (match_operand:SI 1 "" "")))
2688 (match_operand:SI 2 "" "")))
2689 (set (match_operand:SI 3 "" "")
2690 (umod:SI (plus:DI (ashift:DI (zero_extend:DI (match_dup 4))
2691 (const_int 32))
2692 (zero_extend:DI (match_dup 1)))
2693 (match_dup 2)))])]
2694 "TARGET_POWER"
2695 "
2696 { operands[4] = gen_reg_rtx (SImode); }")
2697
2698 ;; This handles the branches.
2699 (define_expand "udivmodsi4_tests"
2700 [(set (match_operand:SI 0 "" "") (const_int 0))
2701 (set (match_operand:SI 3 "" "") (match_operand:SI 1 "" ""))
2702 (set (match_dup 5) (compare:CCUNS (match_dup 1) (match_operand:SI 2 "" "")))
2703 (set (pc) (if_then_else (ltu (match_dup 5) (const_int 0))
2704 (label_ref (match_operand:SI 4 "" "")) (pc)))
2705 (set (match_dup 0) (const_int 1))
2706 (set (match_dup 3) (minus:SI (match_dup 1) (match_dup 2)))
2707 (set (match_dup 6) (compare:CC (match_dup 2) (const_int 0)))
2708 (set (pc) (if_then_else (lt (match_dup 6) (const_int 0))
2709 (label_ref (match_dup 4)) (pc)))]
2710 "TARGET_POWER"
2711 "
2712 { operands[5] = gen_reg_rtx (CCUNSmode);
2713 operands[6] = gen_reg_rtx (CCmode);
2714 }")
2715
2716 (define_expand "udivmodsi4"
2717 [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
2718 (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "")
2719 (match_operand:SI 2 "reg_or_cint_operand" "")))
2720 (set (match_operand:SI 3 "gpc_reg_operand" "")
2721 (umod:SI (match_dup 1) (match_dup 2)))])]
2722 ""
2723 "
2724 {
2725 rtx label = 0;
2726
2727 if (! TARGET_POWER)
2728 {
2729 if (! TARGET_POWERPC)
2730 {
2731 emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
2732 emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
2733 emit_insn (gen_divus_call ());
2734 emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
2735 emit_move_insn (operands[3], gen_rtx_REG (SImode, 4));
2736 DONE;
2737 }
2738 else
2739 FAIL;
2740 }
2741
2742 if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) < 0)
2743 {
2744 operands[2] = force_reg (SImode, operands[2]);
2745 label = gen_label_rtx ();
2746 emit (gen_udivmodsi4_tests (operands[0], operands[1], operands[2],
2747 operands[3], label));
2748 }
2749 else
2750 operands[2] = force_reg (SImode, operands[2]);
2751
2752 emit (gen_udivmodsi4_normal (operands[0], operands[1], operands[2],
2753 operands[3]));
2754 if (label)
2755 emit_label (label);
2756
2757 DONE;
2758 }")
2759
2760 ;; AIX architecture-independent common-mode multiply (DImode),
2761 ;; divide/modulus, and quotient subroutine calls. Input operands in R3 and
2762 ;; R4; results in R3 and sometimes R4; link register always clobbered by bla
2763 ;; instruction; R0 sometimes clobbered; also, MQ sometimes clobbered but
2764 ;; assumed unused if generating common-mode, so ignore.
2765 (define_insn "mulh_call"
2766 [(set (reg:SI 3)
2767 (truncate:SI
2768 (lshiftrt:DI (mult:DI (sign_extend:DI (reg:SI 3))
2769 (sign_extend:DI (reg:SI 4)))
2770 (const_int 32))))
2771 (clobber (reg:SI LR_REGNO))]
2772 "! TARGET_POWER && ! TARGET_POWERPC"
2773 "bla __mulh"
2774 [(set_attr "type" "imul")])
2775
2776 (define_insn "mull_call"
2777 [(set (reg:DI 3)
2778 (mult:DI (sign_extend:DI (reg:SI 3))
2779 (sign_extend:DI (reg:SI 4))))
2780 (clobber (reg:SI LR_REGNO))
2781 (clobber (reg:SI 0))]
2782 "! TARGET_POWER && ! TARGET_POWERPC"
2783 "bla __mull"
2784 [(set_attr "type" "imul")])
2785
2786 (define_insn "divss_call"
2787 [(set (reg:SI 3)
2788 (div:SI (reg:SI 3) (reg:SI 4)))
2789 (set (reg:SI 4)
2790 (mod:SI (reg:SI 3) (reg:SI 4)))
2791 (clobber (reg:SI LR_REGNO))
2792 (clobber (reg:SI 0))]
2793 "! TARGET_POWER && ! TARGET_POWERPC"
2794 "bla __divss"
2795 [(set_attr "type" "idiv")])
2796
2797 (define_insn "divus_call"
2798 [(set (reg:SI 3)
2799 (udiv:SI (reg:SI 3) (reg:SI 4)))
2800 (set (reg:SI 4)
2801 (umod:SI (reg:SI 3) (reg:SI 4)))
2802 (clobber (reg:SI LR_REGNO))
2803 (clobber (reg:SI 0))
2804 (clobber (match_scratch:CC 0 "=x"))
2805 (clobber (reg:CC CR1_REGNO))]
2806 "! TARGET_POWER && ! TARGET_POWERPC"
2807 "bla __divus"
2808 [(set_attr "type" "idiv")])
2809
2810 (define_insn "quoss_call"
2811 [(set (reg:SI 3)
2812 (div:SI (reg:SI 3) (reg:SI 4)))
2813 (clobber (reg:SI LR_REGNO))]
2814 "! TARGET_POWER && ! TARGET_POWERPC"
2815 "bla __quoss"
2816 [(set_attr "type" "idiv")])
2817
2818 (define_insn "quous_call"
2819 [(set (reg:SI 3)
2820 (udiv:SI (reg:SI 3) (reg:SI 4)))
2821 (clobber (reg:SI LR_REGNO))
2822 (clobber (reg:SI 0))
2823 (clobber (match_scratch:CC 0 "=x"))
2824 (clobber (reg:CC CR1_REGNO))]
2825 "! TARGET_POWER && ! TARGET_POWERPC"
2826 "bla __quous"
2827 [(set_attr "type" "idiv")])
2828 \f
2829 ;; Logical instructions
2830 ;; The logical instructions are mostly combined by using match_operator,
2831 ;; but the plain AND insns are somewhat different because there is no
2832 ;; plain 'andi' (only 'andi.'), no plain 'andis', and there are all
2833 ;; those rotate-and-mask operations. Thus, the AND insns come first.
2834
2835 (define_expand "andsi3"
2836 [(parallel
2837 [(set (match_operand:SI 0 "gpc_reg_operand" "")
2838 (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
2839 (match_operand:SI 2 "and_operand" "")))
2840 (clobber (match_scratch:CC 3 ""))])]
2841 ""
2842 "")
2843
2844 (define_insn "andsi3_mc"
2845 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
2846 (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r")
2847 (match_operand:SI 2 "and_operand" "?r,T,K,L")))
2848 (clobber (match_scratch:CC 3 "=X,X,x,x"))]
2849 "rs6000_gen_cell_microcode"
2850 "@
2851 and %0,%1,%2
2852 {rlinm|rlwinm} %0,%1,0,%m2,%M2
2853 {andil.|andi.} %0,%1,%b2
2854 {andiu.|andis.} %0,%1,%u2"
2855 [(set_attr "type" "*,*,compare,compare")])
2856
2857 (define_insn "andsi3_nomc"
2858 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2859 (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2860 (match_operand:SI 2 "and_operand" "?r,T")))
2861 (clobber (match_scratch:CC 3 "=X,X"))]
2862 "!rs6000_gen_cell_microcode"
2863 "@
2864 and %0,%1,%2
2865 {rlinm|rlwinm} %0,%1,0,%m2,%M2")
2866
2867 (define_insn "andsi3_internal0_nomc"
2868 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2869 (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2870 (match_operand:SI 2 "and_operand" "?r,T")))]
2871 "!rs6000_gen_cell_microcode"
2872 "@
2873 and %0,%1,%2
2874 {rlinm|rlwinm} %0,%1,0,%m2,%M2")
2875
2876
2877 ;; Note to set cr's other than cr0 we do the and immediate and then
2878 ;; the test again -- this avoids a mfcr which on the higher end
2879 ;; machines causes an execution serialization
2880
2881 (define_insn "*andsi3_internal2_mc"
2882 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2883 (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2884 (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2885 (const_int 0)))
2886 (clobber (match_scratch:SI 3 "=r,r,r,r,r,r,r,r"))
2887 (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2888 "TARGET_32BIT && rs6000_gen_cell_microcode"
2889 "@
2890 and. %3,%1,%2
2891 {andil.|andi.} %3,%1,%b2
2892 {andiu.|andis.} %3,%1,%u2
2893 {rlinm.|rlwinm.} %3,%1,0,%m2,%M2
2894 #
2895 #
2896 #
2897 #"
2898 [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2899 (set_attr "length" "4,4,4,4,8,8,8,8")])
2900
2901 (define_insn "*andsi3_internal3_mc"
2902 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2903 (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2904 (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2905 (const_int 0)))
2906 (clobber (match_scratch:SI 3 "=r,r,r,r,r,r,r,r"))
2907 (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2908 "TARGET_64BIT && rs6000_gen_cell_microcode"
2909 "@
2910 #
2911 {andil.|andi.} %3,%1,%b2
2912 {andiu.|andis.} %3,%1,%u2
2913 {rlinm.|rlwinm.} %3,%1,0,%m2,%M2
2914 #
2915 #
2916 #
2917 #"
2918 [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2919 (set_attr "length" "8,4,4,4,8,8,8,8")])
2920
2921 (define_split
2922 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
2923 (compare:CC (and:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2924 (match_operand:GPR 2 "and_operand" ""))
2925 (const_int 0)))
2926 (clobber (match_scratch:GPR 3 ""))
2927 (clobber (match_scratch:CC 4 ""))]
2928 "reload_completed"
2929 [(parallel [(set (match_dup 3)
2930 (and:<MODE> (match_dup 1)
2931 (match_dup 2)))
2932 (clobber (match_dup 4))])
2933 (set (match_dup 0)
2934 (compare:CC (match_dup 3)
2935 (const_int 0)))]
2936 "")
2937
2938 ;; We don't have a 32 bit "and. rt,ra,rb" for ppc64. cr is set from the
2939 ;; whole 64 bit reg, and we don't know what is in the high 32 bits.
2940
2941 (define_split
2942 [(set (match_operand:CC 0 "cc_reg_operand" "")
2943 (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
2944 (match_operand:SI 2 "gpc_reg_operand" ""))
2945 (const_int 0)))
2946 (clobber (match_scratch:SI 3 ""))
2947 (clobber (match_scratch:CC 4 ""))]
2948 "TARGET_POWERPC64 && reload_completed"
2949 [(parallel [(set (match_dup 3)
2950 (and:SI (match_dup 1)
2951 (match_dup 2)))
2952 (clobber (match_dup 4))])
2953 (set (match_dup 0)
2954 (compare:CC (match_dup 3)
2955 (const_int 0)))]
2956 "")
2957
2958 (define_insn "*andsi3_internal4"
2959 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2960 (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2961 (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2962 (const_int 0)))
2963 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r,r,r,r")
2964 (and:SI (match_dup 1)
2965 (match_dup 2)))
2966 (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2967 "TARGET_32BIT && rs6000_gen_cell_microcode"
2968 "@
2969 and. %0,%1,%2
2970 {andil.|andi.} %0,%1,%b2
2971 {andiu.|andis.} %0,%1,%u2
2972 {rlinm.|rlwinm.} %0,%1,0,%m2,%M2
2973 #
2974 #
2975 #
2976 #"
2977 [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2978 (set_attr "length" "4,4,4,4,8,8,8,8")])
2979
2980 (define_insn "*andsi3_internal5_mc"
2981 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2982 (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2983 (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2984 (const_int 0)))
2985 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r,r,r,r")
2986 (and:SI (match_dup 1)
2987 (match_dup 2)))
2988 (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2989 "TARGET_64BIT && rs6000_gen_cell_microcode"
2990 "@
2991 #
2992 {andil.|andi.} %0,%1,%b2
2993 {andiu.|andis.} %0,%1,%u2
2994 {rlinm.|rlwinm.} %0,%1,0,%m2,%M2
2995 #
2996 #
2997 #
2998 #"
2999 [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
3000 (set_attr "length" "8,4,4,4,8,8,8,8")])
3001
3002 (define_split
3003 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
3004 (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
3005 (match_operand:SI 2 "and_operand" ""))
3006 (const_int 0)))
3007 (set (match_operand:SI 0 "gpc_reg_operand" "")
3008 (and:SI (match_dup 1)
3009 (match_dup 2)))
3010 (clobber (match_scratch:CC 4 ""))]
3011 "reload_completed"
3012 [(parallel [(set (match_dup 0)
3013 (and:SI (match_dup 1)
3014 (match_dup 2)))
3015 (clobber (match_dup 4))])
3016 (set (match_dup 3)
3017 (compare:CC (match_dup 0)
3018 (const_int 0)))]
3019 "")
3020
3021 (define_split
3022 [(set (match_operand:CC 3 "cc_reg_operand" "")
3023 (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
3024 (match_operand:SI 2 "gpc_reg_operand" ""))
3025 (const_int 0)))
3026 (set (match_operand:SI 0 "gpc_reg_operand" "")
3027 (and:SI (match_dup 1)
3028 (match_dup 2)))
3029 (clobber (match_scratch:CC 4 ""))]
3030 "TARGET_POWERPC64 && reload_completed"
3031 [(parallel [(set (match_dup 0)
3032 (and:SI (match_dup 1)
3033 (match_dup 2)))
3034 (clobber (match_dup 4))])
3035 (set (match_dup 3)
3036 (compare:CC (match_dup 0)
3037 (const_int 0)))]
3038 "")
3039
3040 ;; Handle the PowerPC64 rlwinm corner case
3041
3042 (define_insn_and_split "*andsi3_internal6"
3043 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3044 (and:SI (match_operand:SI 1 "gpc_reg_operand" "r")
3045 (match_operand:SI 2 "mask_operand_wrap" "i")))]
3046 "TARGET_POWERPC64"
3047 "#"
3048 "TARGET_POWERPC64"
3049 [(set (match_dup 0)
3050 (and:SI (rotate:SI (match_dup 1) (match_dup 3))
3051 (match_dup 4)))
3052 (set (match_dup 0)
3053 (rotate:SI (match_dup 0) (match_dup 5)))]
3054 "
3055 {
3056 int mb = extract_MB (operands[2]);
3057 int me = extract_ME (operands[2]);
3058 operands[3] = GEN_INT (me + 1);
3059 operands[5] = GEN_INT (32 - (me + 1));
3060 operands[4] = GEN_INT (~((HOST_WIDE_INT) -1 << (33 + me - mb)));
3061 }"
3062 [(set_attr "length" "8")])
3063
3064 (define_expand "iorsi3"
3065 [(set (match_operand:SI 0 "gpc_reg_operand" "")
3066 (ior:SI (match_operand:SI 1 "gpc_reg_operand" "")
3067 (match_operand:SI 2 "reg_or_logical_cint_operand" "")))]
3068 ""
3069 "
3070 {
3071 if (GET_CODE (operands[2]) == CONST_INT
3072 && ! logical_operand (operands[2], SImode))
3073 {
3074 HOST_WIDE_INT value = INTVAL (operands[2]);
3075 rtx tmp = ((!can_create_pseudo_p ()
3076 || rtx_equal_p (operands[0], operands[1]))
3077 ? operands[0] : gen_reg_rtx (SImode));
3078
3079 emit_insn (gen_iorsi3 (tmp, operands[1],
3080 GEN_INT (value & (~ (HOST_WIDE_INT) 0xffff))));
3081 emit_insn (gen_iorsi3 (operands[0], tmp, GEN_INT (value & 0xffff)));
3082 DONE;
3083 }
3084 }")
3085
3086 (define_expand "xorsi3"
3087 [(set (match_operand:SI 0 "gpc_reg_operand" "")
3088 (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
3089 (match_operand:SI 2 "reg_or_logical_cint_operand" "")))]
3090 ""
3091 "
3092 {
3093 if (GET_CODE (operands[2]) == CONST_INT
3094 && ! logical_operand (operands[2], SImode))
3095 {
3096 HOST_WIDE_INT value = INTVAL (operands[2]);
3097 rtx tmp = ((!can_create_pseudo_p ()
3098 || rtx_equal_p (operands[0], operands[1]))
3099 ? operands[0] : gen_reg_rtx (SImode));
3100
3101 emit_insn (gen_xorsi3 (tmp, operands[1],
3102 GEN_INT (value & (~ (HOST_WIDE_INT) 0xffff))));
3103 emit_insn (gen_xorsi3 (operands[0], tmp, GEN_INT (value & 0xffff)));
3104 DONE;
3105 }
3106 }")
3107
3108 (define_insn "*boolsi3_internal1"
3109 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
3110 (match_operator:SI 3 "boolean_or_operator"
3111 [(match_operand:SI 1 "gpc_reg_operand" "%r,r,r")
3112 (match_operand:SI 2 "logical_operand" "r,K,L")]))]
3113 ""
3114 "@
3115 %q3 %0,%1,%2
3116 {%q3il|%q3i} %0,%1,%b2
3117 {%q3iu|%q3is} %0,%1,%u2")
3118
3119 (define_insn "*boolsi3_internal2"
3120 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3121 (compare:CC (match_operator:SI 4 "boolean_or_operator"
3122 [(match_operand:SI 1 "gpc_reg_operand" "%r,r")
3123 (match_operand:SI 2 "gpc_reg_operand" "r,r")])
3124 (const_int 0)))
3125 (clobber (match_scratch:SI 3 "=r,r"))]
3126 "TARGET_32BIT"
3127 "@
3128 %q4. %3,%1,%2
3129 #"
3130 [(set_attr "type" "compare")
3131 (set_attr "length" "4,8")])
3132
3133 (define_split
3134 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
3135 (compare:CC (match_operator:SI 4 "boolean_operator"
3136 [(match_operand:SI 1 "gpc_reg_operand" "")
3137 (match_operand:SI 2 "gpc_reg_operand" "")])
3138 (const_int 0)))
3139 (clobber (match_scratch:SI 3 ""))]
3140 "TARGET_32BIT && reload_completed"
3141 [(set (match_dup 3) (match_dup 4))
3142 (set (match_dup 0)
3143 (compare:CC (match_dup 3)
3144 (const_int 0)))]
3145 "")
3146
3147 (define_insn "*boolsi3_internal3"
3148 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
3149 (compare:CC (match_operator:SI 4 "boolean_operator"
3150 [(match_operand:SI 1 "gpc_reg_operand" "%r,r")
3151 (match_operand:SI 2 "gpc_reg_operand" "r,r")])
3152 (const_int 0)))
3153 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3154 (match_dup 4))]
3155 "TARGET_32BIT"
3156 "@
3157 %q4. %0,%1,%2
3158 #"
3159 [(set_attr "type" "compare")
3160 (set_attr "length" "4,8")])
3161
3162 (define_split
3163 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
3164 (compare:CC (match_operator:SI 4 "boolean_operator"
3165 [(match_operand:SI 1 "gpc_reg_operand" "")
3166 (match_operand:SI 2 "gpc_reg_operand" "")])
3167 (const_int 0)))
3168 (set (match_operand:SI 0 "gpc_reg_operand" "")
3169 (match_dup 4))]
3170 "TARGET_32BIT && reload_completed"
3171 [(set (match_dup 0) (match_dup 4))
3172 (set (match_dup 3)
3173 (compare:CC (match_dup 0)
3174 (const_int 0)))]
3175 "")
3176
3177 ;; Split a logical operation that we can't do in one insn into two insns,
3178 ;; each of which does one 16-bit part. This is used by combine.
3179
3180 (define_split
3181 [(set (match_operand:SI 0 "gpc_reg_operand" "")
3182 (match_operator:SI 3 "boolean_or_operator"
3183 [(match_operand:SI 1 "gpc_reg_operand" "")
3184 (match_operand:SI 2 "non_logical_cint_operand" "")]))]
3185 ""
3186 [(set (match_dup 0) (match_dup 4))
3187 (set (match_dup 0) (match_dup 5))]
3188 "
3189 {
3190 rtx i;
3191 i = GEN_INT (INTVAL (operands[2]) & (~ (HOST_WIDE_INT) 0xffff));
3192 operands[4] = gen_rtx_fmt_ee (GET_CODE (operands[3]), SImode,
3193 operands[1], i);
3194 i = GEN_INT (INTVAL (operands[2]) & 0xffff);
3195 operands[5] = gen_rtx_fmt_ee (GET_CODE (operands[3]), SImode,
3196 operands[0], i);
3197 }")
3198
3199 (define_insn "*boolcsi3_internal1"
3200 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3201 (match_operator:SI 3 "boolean_operator"
3202 [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
3203 (match_operand:SI 2 "gpc_reg_operand" "r")]))]
3204 ""
3205 "%q3 %0,%2,%1")
3206
3207 (define_insn "*boolcsi3_internal2"
3208 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3209 (compare:CC (match_operator:SI 4 "boolean_operator"
3210 [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r,r"))
3211 (match_operand:SI 2 "gpc_reg_operand" "r,r")])
3212 (const_int 0)))
3213 (clobber (match_scratch:SI 3 "=r,r"))]
3214 "TARGET_32BIT"
3215 "@
3216 %q4. %3,%2,%1
3217 #"
3218 [(set_attr "type" "compare")
3219 (set_attr "length" "4,8")])
3220
3221 (define_split
3222 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
3223 (compare:CC (match_operator:SI 4 "boolean_operator"
3224 [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
3225 (match_operand:SI 2 "gpc_reg_operand" "")])
3226 (const_int 0)))
3227 (clobber (match_scratch:SI 3 ""))]
3228 "TARGET_32BIT && reload_completed"
3229 [(set (match_dup 3) (match_dup 4))
3230 (set (match_dup 0)
3231 (compare:CC (match_dup 3)
3232 (const_int 0)))]
3233 "")
3234
3235 (define_insn "*boolcsi3_internal3"
3236 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
3237 (compare:CC (match_operator:SI 4 "boolean_operator"
3238 [(not:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r"))
3239 (match_operand:SI 2 "gpc_reg_operand" "r,r")])
3240 (const_int 0)))
3241 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3242 (match_dup 4))]
3243 "TARGET_32BIT"
3244 "@
3245 %q4. %0,%2,%1
3246 #"
3247 [(set_attr "type" "compare")
3248 (set_attr "length" "4,8")])
3249
3250 (define_split
3251 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
3252 (compare:CC (match_operator:SI 4 "boolean_operator"
3253 [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
3254 (match_operand:SI 2 "gpc_reg_operand" "")])
3255 (const_int 0)))
3256 (set (match_operand:SI 0 "gpc_reg_operand" "")
3257 (match_dup 4))]
3258 "TARGET_32BIT && reload_completed"
3259 [(set (match_dup 0) (match_dup 4))
3260 (set (match_dup 3)
3261 (compare:CC (match_dup 0)
3262 (const_int 0)))]
3263 "")
3264
3265 (define_insn "*boolccsi3_internal1"
3266 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3267 (match_operator:SI 3 "boolean_operator"
3268 [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
3269 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))]))]
3270 ""
3271 "%q3 %0,%1,%2")
3272
3273 (define_insn "*boolccsi3_internal2"
3274 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3275 (compare:CC (match_operator:SI 4 "boolean_operator"
3276 [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r,r"))
3277 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r,r"))])
3278 (const_int 0)))
3279 (clobber (match_scratch:SI 3 "=r,r"))]
3280 "TARGET_32BIT"
3281 "@
3282 %q4. %3,%1,%2
3283 #"
3284 [(set_attr "type" "compare")
3285 (set_attr "length" "4,8")])
3286
3287 (define_split
3288 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
3289 (compare:CC (match_operator:SI 4 "boolean_operator"
3290 [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
3291 (not:SI (match_operand:SI 2 "gpc_reg_operand" ""))])
3292 (const_int 0)))
3293 (clobber (match_scratch:SI 3 ""))]
3294 "TARGET_32BIT && reload_completed"
3295 [(set (match_dup 3) (match_dup 4))
3296 (set (match_dup 0)
3297 (compare:CC (match_dup 3)
3298 (const_int 0)))]
3299 "")
3300
3301 (define_insn "*boolccsi3_internal3"
3302 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
3303 (compare:CC (match_operator:SI 4 "boolean_operator"
3304 [(not:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r"))
3305 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r,r"))])
3306 (const_int 0)))
3307 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3308 (match_dup 4))]
3309 "TARGET_32BIT"
3310 "@
3311 %q4. %0,%1,%2
3312 #"
3313 [(set_attr "type" "compare")
3314 (set_attr "length" "4,8")])
3315
3316 (define_split
3317 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
3318 (compare:CC (match_operator:SI 4 "boolean_operator"
3319 [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
3320 (not:SI (match_operand:SI 2 "gpc_reg_operand" ""))])
3321 (const_int 0)))
3322 (set (match_operand:SI 0 "gpc_reg_operand" "")
3323 (match_dup 4))]
3324 "TARGET_32BIT && reload_completed"
3325 [(set (match_dup 0) (match_dup 4))
3326 (set (match_dup 3)
3327 (compare:CC (match_dup 0)
3328 (const_int 0)))]
3329 "")
3330
3331 ;; maskir insn. We need four forms because things might be in arbitrary
3332 ;; orders. Don't define forms that only set CR fields because these
3333 ;; would modify an input register.
3334
3335 (define_insn "*maskir_internal1"
3336 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3337 (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
3338 (match_operand:SI 1 "gpc_reg_operand" "0"))
3339 (and:SI (match_dup 2)
3340 (match_operand:SI 3 "gpc_reg_operand" "r"))))]
3341 "TARGET_POWER"
3342 "maskir %0,%3,%2")
3343
3344 (define_insn "*maskir_internal2"
3345 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3346 (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
3347 (match_operand:SI 1 "gpc_reg_operand" "0"))
3348 (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3349 (match_dup 2))))]
3350 "TARGET_POWER"
3351 "maskir %0,%3,%2")
3352
3353 (define_insn "*maskir_internal3"
3354 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3355 (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "r")
3356 (match_operand:SI 3 "gpc_reg_operand" "r"))
3357 (and:SI (not:SI (match_dup 2))
3358 (match_operand:SI 1 "gpc_reg_operand" "0"))))]
3359 "TARGET_POWER"
3360 "maskir %0,%3,%2")
3361
3362 (define_insn "*maskir_internal4"
3363 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3364 (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3365 (match_operand:SI 2 "gpc_reg_operand" "r"))
3366 (and:SI (not:SI (match_dup 2))
3367 (match_operand:SI 1 "gpc_reg_operand" "0"))))]
3368 "TARGET_POWER"
3369 "maskir %0,%3,%2")
3370
3371 (define_insn "*maskir_internal5"
3372 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
3373 (compare:CC
3374 (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r,r"))
3375 (match_operand:SI 1 "gpc_reg_operand" "0,0"))
3376 (and:SI (match_dup 2)
3377 (match_operand:SI 3 "gpc_reg_operand" "r,r")))
3378 (const_int 0)))
3379 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3380 (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
3381 (and:SI (match_dup 2) (match_dup 3))))]
3382 "TARGET_POWER"
3383 "@
3384 maskir. %0,%3,%2
3385 #"
3386 [(set_attr "type" "compare")
3387 (set_attr "length" "4,8")])
3388
3389 (define_split
3390 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
3391 (compare:CC
3392 (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" ""))
3393 (match_operand:SI 1 "gpc_reg_operand" ""))
3394 (and:SI (match_dup 2)
3395 (match_operand:SI 3 "gpc_reg_operand" "")))
3396 (const_int 0)))
3397 (set (match_operand:SI 0 "gpc_reg_operand" "")
3398 (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
3399 (and:SI (match_dup 2) (match_dup 3))))]
3400 "TARGET_POWER && reload_completed"
3401 [(set (match_dup 0)
3402 (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
3403 (and:SI (match_dup 2) (match_dup 3))))
3404 (set (match_dup 4)
3405 (compare:CC (match_dup 0)
3406 (const_int 0)))]
3407 "")
3408
3409 (define_insn "*maskir_internal6"
3410 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
3411 (compare:CC
3412 (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r,r"))
3413 (match_operand:SI 1 "gpc_reg_operand" "0,0"))
3414 (and:SI (match_operand:SI 3 "gpc_reg_operand" "r,r")
3415 (match_dup 2)))
3416 (const_int 0)))
3417 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3418 (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
3419 (and:SI (match_dup 3) (match_dup 2))))]
3420 "TARGET_POWER"
3421 "@
3422 maskir. %0,%3,%2
3423 #"
3424 [(set_attr "type" "compare")
3425 (set_attr "length" "4,8")])
3426
3427 (define_split
3428 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
3429 (compare:CC
3430 (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" ""))
3431 (match_operand:SI 1 "gpc_reg_operand" ""))
3432 (and:SI (match_operand:SI 3 "gpc_reg_operand" "")
3433 (match_dup 2)))
3434 (const_int 0)))
3435 (set (match_operand:SI 0 "gpc_reg_operand" "")
3436 (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
3437 (and:SI (match_dup 3) (match_dup 2))))]
3438 "TARGET_POWER && reload_completed"
3439 [(set (match_dup 0)
3440 (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
3441 (and:SI (match_dup 3) (match_dup 2))))
3442 (set (match_dup 4)
3443 (compare:CC (match_dup 0)
3444 (const_int 0)))]
3445 "")
3446
3447 (define_insn "*maskir_internal7"
3448 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
3449 (compare:CC
3450 (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "r,r")
3451 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
3452 (and:SI (not:SI (match_dup 2))
3453 (match_operand:SI 1 "gpc_reg_operand" "0,0")))
3454 (const_int 0)))
3455 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3456 (ior:SI (and:SI (match_dup 2) (match_dup 3))
3457 (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
3458 "TARGET_POWER"
3459 "@
3460 maskir. %0,%3,%2
3461 #"
3462 [(set_attr "type" "compare")
3463 (set_attr "length" "4,8")])
3464
3465 (define_split
3466 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
3467 (compare:CC
3468 (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "")
3469 (match_operand:SI 3 "gpc_reg_operand" ""))
3470 (and:SI (not:SI (match_dup 2))
3471 (match_operand:SI 1 "gpc_reg_operand" "")))
3472 (const_int 0)))
3473 (set (match_operand:SI 0 "gpc_reg_operand" "")
3474 (ior:SI (and:SI (match_dup 2) (match_dup 3))
3475 (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
3476 "TARGET_POWER && reload_completed"
3477 [(set (match_dup 0)
3478 (ior:SI (and:SI (match_dup 2) (match_dup 3))
3479 (and:SI (not:SI (match_dup 2)) (match_dup 1))))
3480 (set (match_dup 4)
3481 (compare:CC (match_dup 0)
3482 (const_int 0)))]
3483 "")
3484
3485 (define_insn "*maskir_internal8"
3486 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
3487 (compare:CC
3488 (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "r,r")
3489 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
3490 (and:SI (not:SI (match_dup 2))
3491 (match_operand:SI 1 "gpc_reg_operand" "0,0")))
3492 (const_int 0)))
3493 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3494 (ior:SI (and:SI (match_dup 3) (match_dup 2))
3495 (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
3496 "TARGET_POWER"
3497 "@
3498 maskir. %0,%3,%2
3499 #"
3500 [(set_attr "type" "compare")
3501 (set_attr "length" "4,8")])
3502
3503 (define_split
3504 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
3505 (compare:CC
3506 (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "")
3507 (match_operand:SI 2 "gpc_reg_operand" ""))
3508 (and:SI (not:SI (match_dup 2))
3509 (match_operand:SI 1 "gpc_reg_operand" "")))
3510 (const_int 0)))
3511 (set (match_operand:SI 0 "gpc_reg_operand" "")
3512 (ior:SI (and:SI (match_dup 3) (match_dup 2))
3513 (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
3514 "TARGET_POWER && reload_completed"
3515 [(set (match_dup 0)
3516 (ior:SI (and:SI (match_dup 3) (match_dup 2))
3517 (and:SI (not:SI (match_dup 2)) (match_dup 1))))
3518 (set (match_dup 4)
3519 (compare:CC (match_dup 0)
3520 (const_int 0)))]
3521 "")
3522 \f
3523 ;; Rotate and shift insns, in all their variants. These support shifts,
3524 ;; field inserts and extracts, and various combinations thereof.
3525 (define_expand "insv"
3526 [(set (zero_extract (match_operand 0 "gpc_reg_operand" "")
3527 (match_operand:SI 1 "const_int_operand" "")
3528 (match_operand:SI 2 "const_int_operand" ""))
3529 (match_operand 3 "gpc_reg_operand" ""))]
3530 ""
3531 "
3532 {
3533 /* Do not handle 16/8 bit structures that fit in HI/QI modes directly, since
3534 the (SUBREG:SI (REG:HI xxx)) that is otherwise generated can confuse the
3535 compiler if the address of the structure is taken later. Likewise, do
3536 not handle invalid E500 subregs. */
3537 if (GET_CODE (operands[0]) == SUBREG
3538 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (operands[0]))) < UNITS_PER_WORD
3539 || ((TARGET_E500_DOUBLE || TARGET_SPE)
3540 && invalid_e500_subreg (operands[0], GET_MODE (operands[0])))))
3541 FAIL;
3542
3543 if (TARGET_POWERPC64 && GET_MODE (operands[0]) == DImode)
3544 emit_insn (gen_insvdi (operands[0], operands[1], operands[2], operands[3]));
3545 else
3546 emit_insn (gen_insvsi (operands[0], operands[1], operands[2], operands[3]));
3547 DONE;
3548 }")
3549
3550 (define_insn "insvsi"
3551 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
3552 (match_operand:SI 1 "const_int_operand" "i")
3553 (match_operand:SI 2 "const_int_operand" "i"))
3554 (match_operand:SI 3 "gpc_reg_operand" "r"))]
3555 ""
3556 "*
3557 {
3558 int start = INTVAL (operands[2]) & 31;
3559 int size = INTVAL (operands[1]) & 31;
3560
3561 operands[4] = GEN_INT (32 - start - size);
3562 operands[1] = GEN_INT (start + size - 1);
3563 return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
3564 }"
3565 [(set_attr "type" "insert_word")])
3566
3567 (define_insn "*insvsi_internal1"
3568 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
3569 (match_operand:SI 1 "const_int_operand" "i")
3570 (match_operand:SI 2 "const_int_operand" "i"))
3571 (rotate:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3572 (match_operand:SI 4 "const_int_operand" "i")))]
3573 "(32 - (INTVAL (operands[4]) & 31)) >= INTVAL (operands[1])"
3574 "*
3575 {
3576 int shift = INTVAL (operands[4]) & 31;
3577 int start = INTVAL (operands[2]) & 31;
3578 int size = INTVAL (operands[1]) & 31;
3579
3580 operands[4] = GEN_INT (shift - start - size);
3581 operands[1] = GEN_INT (start + size - 1);
3582 return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
3583 }"
3584 [(set_attr "type" "insert_word")])
3585
3586 (define_insn "*insvsi_internal2"
3587 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
3588 (match_operand:SI 1 "const_int_operand" "i")
3589 (match_operand:SI 2 "const_int_operand" "i"))
3590 (ashiftrt:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3591 (match_operand:SI 4 "const_int_operand" "i")))]
3592 "(32 - (INTVAL (operands[4]) & 31)) >= INTVAL (operands[1])"
3593 "*
3594 {
3595 int shift = INTVAL (operands[4]) & 31;
3596 int start = INTVAL (operands[2]) & 31;
3597 int size = INTVAL (operands[1]) & 31;
3598
3599 operands[4] = GEN_INT (32 - shift - start - size);
3600 operands[1] = GEN_INT (start + size - 1);
3601 return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
3602 }"
3603 [(set_attr "type" "insert_word")])
3604
3605 (define_insn "*insvsi_internal3"
3606 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
3607 (match_operand:SI 1 "const_int_operand" "i")
3608 (match_operand:SI 2 "const_int_operand" "i"))
3609 (lshiftrt:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3610 (match_operand:SI 4 "const_int_operand" "i")))]
3611 "(32 - (INTVAL (operands[4]) & 31)) >= INTVAL (operands[1])"
3612 "*
3613 {
3614 int shift = INTVAL (operands[4]) & 31;
3615 int start = INTVAL (operands[2]) & 31;
3616 int size = INTVAL (operands[1]) & 31;
3617
3618 operands[4] = GEN_INT (32 - shift - start - size);
3619 operands[1] = GEN_INT (start + size - 1);
3620 return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
3621 }"
3622 [(set_attr "type" "insert_word")])
3623
3624 (define_insn "*insvsi_internal4"
3625 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
3626 (match_operand:SI 1 "const_int_operand" "i")
3627 (match_operand:SI 2 "const_int_operand" "i"))
3628 (zero_extract:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3629 (match_operand:SI 4 "const_int_operand" "i")
3630 (match_operand:SI 5 "const_int_operand" "i")))]
3631 "INTVAL (operands[4]) >= INTVAL (operands[1])"
3632 "*
3633 {
3634 int extract_start = INTVAL (operands[5]) & 31;
3635 int extract_size = INTVAL (operands[4]) & 31;
3636 int insert_start = INTVAL (operands[2]) & 31;
3637 int insert_size = INTVAL (operands[1]) & 31;
3638
3639 /* Align extract field with insert field */
3640 operands[5] = GEN_INT (extract_start + extract_size - insert_start - insert_size);
3641 operands[1] = GEN_INT (insert_start + insert_size - 1);
3642 return \"{rlimi|rlwimi} %0,%3,%h5,%h2,%h1\";
3643 }"
3644 [(set_attr "type" "insert_word")])
3645
3646 ;; combine patterns for rlwimi
3647 (define_insn "*insvsi_internal5"
3648 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3649 (ior:SI (and:SI (match_operand:SI 4 "gpc_reg_operand" "0")
3650 (match_operand:SI 1 "mask_operand" "i"))
3651 (and:SI (lshiftrt:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3652 (match_operand:SI 2 "const_int_operand" "i"))
3653 (match_operand:SI 5 "mask_operand" "i"))))]
3654 "TARGET_POWERPC && INTVAL(operands[1]) == ~INTVAL(operands[5])"
3655 "*
3656 {
3657 int me = extract_ME(operands[5]);
3658 int mb = extract_MB(operands[5]);
3659 operands[4] = GEN_INT(32 - INTVAL(operands[2]));
3660 operands[2] = GEN_INT(mb);
3661 operands[1] = GEN_INT(me);
3662 return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
3663 }"
3664 [(set_attr "type" "insert_word")])
3665
3666 (define_insn "*insvsi_internal6"
3667 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3668 (ior:SI (and:SI (lshiftrt:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3669 (match_operand:SI 2 "const_int_operand" "i"))
3670 (match_operand:SI 5 "mask_operand" "i"))
3671 (and:SI (match_operand:SI 4 "gpc_reg_operand" "0")
3672 (match_operand:SI 1 "mask_operand" "i"))))]
3673 "TARGET_POWERPC && INTVAL(operands[1]) == ~INTVAL(operands[5])"
3674 "*
3675 {
3676 int me = extract_ME(operands[5]);
3677 int mb = extract_MB(operands[5]);
3678 operands[4] = GEN_INT(32 - INTVAL(operands[2]));
3679 operands[2] = GEN_INT(mb);
3680 operands[1] = GEN_INT(me);
3681 return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
3682 }"
3683 [(set_attr "type" "insert_word")])
3684
3685 (define_insn "insvdi"
3686 [(set (zero_extract:DI (match_operand:DI 0 "gpc_reg_operand" "+r")
3687 (match_operand:SI 1 "const_int_operand" "i")
3688 (match_operand:SI 2 "const_int_operand" "i"))
3689 (match_operand:DI 3 "gpc_reg_operand" "r"))]
3690 "TARGET_POWERPC64"
3691 "*
3692 {
3693 int start = INTVAL (operands[2]) & 63;
3694 int size = INTVAL (operands[1]) & 63;
3695
3696 operands[1] = GEN_INT (64 - start - size);
3697 return \"rldimi %0,%3,%H1,%H2\";
3698 }"
3699 [(set_attr "type" "insert_dword")])
3700
3701 (define_insn "*insvdi_internal2"
3702 [(set (zero_extract:DI (match_operand:DI 0 "gpc_reg_operand" "+r")
3703 (match_operand:SI 1 "const_int_operand" "i")
3704 (match_operand:SI 2 "const_int_operand" "i"))
3705 (ashiftrt:DI (match_operand:DI 3 "gpc_reg_operand" "r")
3706 (match_operand:SI 4 "const_int_operand" "i")))]
3707 "TARGET_POWERPC64
3708 && insvdi_rshift_rlwimi_p (operands[1], operands[2], operands[4])"
3709 "*
3710 {
3711 int shift = INTVAL (operands[4]) & 63;
3712 int start = (INTVAL (operands[2]) & 63) - 32;
3713 int size = INTVAL (operands[1]) & 63;
3714
3715 operands[4] = GEN_INT (64 - shift - start - size);
3716 operands[2] = GEN_INT (start);
3717 operands[1] = GEN_INT (start + size - 1);
3718 return \"rlwimi %0,%3,%h4,%h2,%h1\";
3719 }")
3720
3721 (define_insn "*insvdi_internal3"
3722 [(set (zero_extract:DI (match_operand:DI 0 "gpc_reg_operand" "+r")
3723 (match_operand:SI 1 "const_int_operand" "i")
3724 (match_operand:SI 2 "const_int_operand" "i"))
3725 (lshiftrt:DI (match_operand:DI 3 "gpc_reg_operand" "r")
3726 (match_operand:SI 4 "const_int_operand" "i")))]
3727 "TARGET_POWERPC64
3728 && insvdi_rshift_rlwimi_p (operands[1], operands[2], operands[4])"
3729 "*
3730 {
3731 int shift = INTVAL (operands[4]) & 63;
3732 int start = (INTVAL (operands[2]) & 63) - 32;
3733 int size = INTVAL (operands[1]) & 63;
3734
3735 operands[4] = GEN_INT (64 - shift - start - size);
3736 operands[2] = GEN_INT (start);
3737 operands[1] = GEN_INT (start + size - 1);
3738 return \"rlwimi %0,%3,%h4,%h2,%h1\";
3739 }")
3740
3741 (define_expand "extzv"
3742 [(set (match_operand 0 "gpc_reg_operand" "")
3743 (zero_extract (match_operand 1 "gpc_reg_operand" "")
3744 (match_operand:SI 2 "const_int_operand" "")
3745 (match_operand:SI 3 "const_int_operand" "")))]
3746 ""
3747 "
3748 {
3749 /* Do not handle 16/8 bit structures that fit in HI/QI modes directly, since
3750 the (SUBREG:SI (REG:HI xxx)) that is otherwise generated can confuse the
3751 compiler if the address of the structure is taken later. */
3752 if (GET_CODE (operands[0]) == SUBREG
3753 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (operands[0]))) < UNITS_PER_WORD))
3754 FAIL;
3755
3756 if (TARGET_POWERPC64 && GET_MODE (operands[1]) == DImode)
3757 emit_insn (gen_extzvdi (operands[0], operands[1], operands[2], operands[3]));
3758 else
3759 emit_insn (gen_extzvsi (operands[0], operands[1], operands[2], operands[3]));
3760 DONE;
3761 }")
3762
3763 (define_insn "extzvsi"
3764 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3765 (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r")
3766 (match_operand:SI 2 "const_int_operand" "i")
3767 (match_operand:SI 3 "const_int_operand" "i")))]
3768 ""
3769 "*
3770 {
3771 int start = INTVAL (operands[3]) & 31;
3772 int size = INTVAL (operands[2]) & 31;
3773
3774 if (start + size >= 32)
3775 operands[3] = const0_rtx;
3776 else
3777 operands[3] = GEN_INT (start + size);
3778 return \"{rlinm|rlwinm} %0,%1,%3,%s2,31\";
3779 }")
3780
3781 (define_insn "*extzvsi_internal1"
3782 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3783 (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3784 (match_operand:SI 2 "const_int_operand" "i,i")
3785 (match_operand:SI 3 "const_int_operand" "i,i"))
3786 (const_int 0)))
3787 (clobber (match_scratch:SI 4 "=r,r"))]
3788 ""
3789 "*
3790 {
3791 int start = INTVAL (operands[3]) & 31;
3792 int size = INTVAL (operands[2]) & 31;
3793
3794 /* Force split for non-cc0 compare. */
3795 if (which_alternative == 1)
3796 return \"#\";
3797
3798 /* If the bit-field being tested fits in the upper or lower half of a
3799 word, it is possible to use andiu. or andil. to test it. This is
3800 useful because the condition register set-use delay is smaller for
3801 andi[ul]. than for rlinm. This doesn't work when the starting bit
3802 position is 0 because the LT and GT bits may be set wrong. */
3803
3804 if ((start > 0 && start + size <= 16) || start >= 16)
3805 {
3806 operands[3] = GEN_INT (((1 << (16 - (start & 15)))
3807 - (1 << (16 - (start & 15) - size))));
3808 if (start < 16)
3809 return \"{andiu.|andis.} %4,%1,%3\";
3810 else
3811 return \"{andil.|andi.} %4,%1,%3\";
3812 }
3813
3814 if (start + size >= 32)
3815 operands[3] = const0_rtx;
3816 else
3817 operands[3] = GEN_INT (start + size);
3818 return \"{rlinm.|rlwinm.} %4,%1,%3,%s2,31\";
3819 }"
3820 [(set_attr "type" "delayed_compare")
3821 (set_attr "length" "4,8")])
3822
3823 (define_split
3824 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
3825 (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "")
3826 (match_operand:SI 2 "const_int_operand" "")
3827 (match_operand:SI 3 "const_int_operand" ""))
3828 (const_int 0)))
3829 (clobber (match_scratch:SI 4 ""))]
3830 "reload_completed"
3831 [(set (match_dup 4)
3832 (zero_extract:SI (match_dup 1) (match_dup 2)
3833 (match_dup 3)))
3834 (set (match_dup 0)
3835 (compare:CC (match_dup 4)
3836 (const_int 0)))]
3837 "")
3838
3839 (define_insn "*extzvsi_internal2"
3840 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
3841 (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3842 (match_operand:SI 2 "const_int_operand" "i,i")
3843 (match_operand:SI 3 "const_int_operand" "i,i"))
3844 (const_int 0)))
3845 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3846 (zero_extract:SI (match_dup 1) (match_dup 2) (match_dup 3)))]
3847 ""
3848 "*
3849 {
3850 int start = INTVAL (operands[3]) & 31;
3851 int size = INTVAL (operands[2]) & 31;
3852
3853 /* Force split for non-cc0 compare. */
3854 if (which_alternative == 1)
3855 return \"#\";
3856
3857 /* Since we are using the output value, we can't ignore any need for
3858 a shift. The bit-field must end at the LSB. */
3859 if (start >= 16 && start + size == 32)
3860 {
3861 operands[3] = GEN_INT ((1 << size) - 1);
3862 return \"{andil.|andi.} %0,%1,%3\";
3863 }
3864
3865 if (start + size >= 32)
3866 operands[3] = const0_rtx;
3867 else
3868 operands[3] = GEN_INT (start + size);
3869 return \"{rlinm.|rlwinm.} %0,%1,%3,%s2,31\";
3870 }"
3871 [(set_attr "type" "delayed_compare")
3872 (set_attr "length" "4,8")])
3873
3874 (define_split
3875 [(set (match_operand:CC 4 "cc_reg_not_micro_cr0_operand" "")
3876 (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "")
3877 (match_operand:SI 2 "const_int_operand" "")
3878 (match_operand:SI 3 "const_int_operand" ""))
3879 (const_int 0)))
3880 (set (match_operand:SI 0 "gpc_reg_operand" "")
3881 (zero_extract:SI (match_dup 1) (match_dup 2) (match_dup 3)))]
3882 "reload_completed"
3883 [(set (match_dup 0)
3884 (zero_extract:SI (match_dup 1) (match_dup 2) (match_dup 3)))
3885 (set (match_dup 4)
3886 (compare:CC (match_dup 0)
3887 (const_int 0)))]
3888 "")
3889
3890 (define_insn "extzvdi"
3891 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
3892 (zero_extract:DI (match_operand:DI 1 "gpc_reg_operand" "r")
3893 (match_operand:SI 2 "const_int_operand" "i")
3894 (match_operand:SI 3 "const_int_operand" "i")))]
3895 "TARGET_POWERPC64"
3896 "*
3897 {
3898 int start = INTVAL (operands[3]) & 63;
3899 int size = INTVAL (operands[2]) & 63;
3900
3901 if (start + size >= 64)
3902 operands[3] = const0_rtx;
3903 else
3904 operands[3] = GEN_INT (start + size);
3905 operands[2] = GEN_INT (64 - size);
3906 return \"rldicl %0,%1,%3,%2\";
3907 }")
3908
3909 (define_insn "*extzvdi_internal1"
3910 [(set (match_operand:CC 0 "gpc_reg_operand" "=x")
3911 (compare:CC (zero_extract:DI (match_operand:DI 1 "gpc_reg_operand" "r")
3912 (match_operand:SI 2 "const_int_operand" "i")
3913 (match_operand:SI 3 "const_int_operand" "i"))
3914 (const_int 0)))
3915 (clobber (match_scratch:DI 4 "=r"))]
3916 "TARGET_64BIT && rs6000_gen_cell_microcode"
3917 "*
3918 {
3919 int start = INTVAL (operands[3]) & 63;
3920 int size = INTVAL (operands[2]) & 63;
3921
3922 if (start + size >= 64)
3923 operands[3] = const0_rtx;
3924 else
3925 operands[3] = GEN_INT (start + size);
3926 operands[2] = GEN_INT (64 - size);
3927 return \"rldicl. %4,%1,%3,%2\";
3928 }"
3929 [(set_attr "type" "compare")])
3930
3931 (define_insn "*extzvdi_internal2"
3932 [(set (match_operand:CC 4 "gpc_reg_operand" "=x")
3933 (compare:CC (zero_extract:DI (match_operand:DI 1 "gpc_reg_operand" "r")
3934 (match_operand:SI 2 "const_int_operand" "i")
3935 (match_operand:SI 3 "const_int_operand" "i"))
3936 (const_int 0)))
3937 (set (match_operand:DI 0 "gpc_reg_operand" "=r")
3938 (zero_extract:DI (match_dup 1) (match_dup 2) (match_dup 3)))]
3939 "TARGET_64BIT && rs6000_gen_cell_microcode"
3940 "*
3941 {
3942 int start = INTVAL (operands[3]) & 63;
3943 int size = INTVAL (operands[2]) & 63;
3944
3945 if (start + size >= 64)
3946 operands[3] = const0_rtx;
3947 else
3948 operands[3] = GEN_INT (start + size);
3949 operands[2] = GEN_INT (64 - size);
3950 return \"rldicl. %0,%1,%3,%2\";
3951 }"
3952 [(set_attr "type" "compare")])
3953
3954 (define_insn "rotlsi3"
3955 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3956 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3957 (match_operand:SI 2 "reg_or_cint_operand" "r,i")))]
3958 ""
3959 "@
3960 {rlnm|rlwnm} %0,%1,%2,0xffffffff
3961 {rlinm|rlwinm} %0,%1,%h2,0xffffffff"
3962 [(set_attr "type" "var_shift_rotate,integer")])
3963
3964 (define_insn "*rotlsi3_internal2"
3965 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
3966 (compare:CC (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
3967 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
3968 (const_int 0)))
3969 (clobber (match_scratch:SI 3 "=r,r,r,r"))]
3970 ""
3971 "@
3972 {rlnm.|rlwnm.} %3,%1,%2,0xffffffff
3973 {rlinm.|rlwinm.} %3,%1,%h2,0xffffffff
3974 #
3975 #"
3976 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
3977 (set_attr "length" "4,4,8,8")])
3978
3979 (define_split
3980 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
3981 (compare:CC (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
3982 (match_operand:SI 2 "reg_or_cint_operand" ""))
3983 (const_int 0)))
3984 (clobber (match_scratch:SI 3 ""))]
3985 "reload_completed"
3986 [(set (match_dup 3)
3987 (rotate:SI (match_dup 1) (match_dup 2)))
3988 (set (match_dup 0)
3989 (compare:CC (match_dup 3)
3990 (const_int 0)))]
3991 "")
3992
3993 (define_insn "*rotlsi3_internal3"
3994 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
3995 (compare:CC (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
3996 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
3997 (const_int 0)))
3998 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
3999 (rotate:SI (match_dup 1) (match_dup 2)))]
4000 ""
4001 "@
4002 {rlnm.|rlwnm.} %0,%1,%2,0xffffffff
4003 {rlinm.|rlwinm.} %0,%1,%h2,0xffffffff
4004 #
4005 #"
4006 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
4007 (set_attr "length" "4,4,8,8")])
4008
4009 (define_split
4010 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
4011 (compare:CC (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
4012 (match_operand:SI 2 "reg_or_cint_operand" ""))
4013 (const_int 0)))
4014 (set (match_operand:SI 0 "gpc_reg_operand" "")
4015 (rotate:SI (match_dup 1) (match_dup 2)))]
4016 "reload_completed"
4017 [(set (match_dup 0)
4018 (rotate:SI (match_dup 1) (match_dup 2)))
4019 (set (match_dup 3)
4020 (compare:CC (match_dup 0)
4021 (const_int 0)))]
4022 "")
4023
4024 (define_insn "*rotlsi3_internal4"
4025 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
4026 (and:SI (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4027 (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
4028 (match_operand:SI 3 "mask_operand" "n,n")))]
4029 ""
4030 "@
4031 {rlnm|rlwnm} %0,%1,%2,%m3,%M3
4032 {rlinm|rlwinm} %0,%1,%h2,%m3,%M3"
4033 [(set_attr "type" "var_shift_rotate,integer")])
4034
4035 (define_insn "*rotlsi3_internal5"
4036 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
4037 (compare:CC (and:SI
4038 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
4039 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
4040 (match_operand:SI 3 "mask_operand" "n,n,n,n"))
4041 (const_int 0)))
4042 (clobber (match_scratch:SI 4 "=r,r,r,r"))]
4043 ""
4044 "@
4045 {rlnm.|rlwnm.} %4,%1,%2,%m3,%M3
4046 {rlinm.|rlwinm.} %4,%1,%h2,%m3,%M3
4047 #
4048 #"
4049 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
4050 (set_attr "length" "4,4,8,8")])
4051
4052 (define_split
4053 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
4054 (compare:CC (and:SI
4055 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
4056 (match_operand:SI 2 "reg_or_cint_operand" ""))
4057 (match_operand:SI 3 "mask_operand" ""))
4058 (const_int 0)))
4059 (clobber (match_scratch:SI 4 ""))]
4060 "reload_completed"
4061 [(set (match_dup 4)
4062 (and:SI (rotate:SI (match_dup 1)
4063 (match_dup 2))
4064 (match_dup 3)))
4065 (set (match_dup 0)
4066 (compare:CC (match_dup 4)
4067 (const_int 0)))]
4068 "")
4069
4070 (define_insn "*rotlsi3_internal6"
4071 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,?y,?y")
4072 (compare:CC (and:SI
4073 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
4074 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
4075 (match_operand:SI 3 "mask_operand" "n,n,n,n"))
4076 (const_int 0)))
4077 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
4078 (and:SI (rotate:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
4079 ""
4080 "@
4081 {rlnm.|rlwnm.} %0,%1,%2,%m3,%M3
4082 {rlinm.|rlwinm.} %0,%1,%h2,%m3,%M3
4083 #
4084 #"
4085 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
4086 (set_attr "length" "4,4,8,8")])
4087
4088 (define_split
4089 [(set (match_operand:CC 4 "cc_reg_not_micro_cr0_operand" "")
4090 (compare:CC (and:SI
4091 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
4092 (match_operand:SI 2 "reg_or_cint_operand" ""))
4093 (match_operand:SI 3 "mask_operand" ""))
4094 (const_int 0)))
4095 (set (match_operand:SI 0 "gpc_reg_operand" "")
4096 (and:SI (rotate:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
4097 "reload_completed"
4098 [(set (match_dup 0)
4099 (and:SI (rotate:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
4100 (set (match_dup 4)
4101 (compare:CC (match_dup 0)
4102 (const_int 0)))]
4103 "")
4104
4105 (define_insn "*rotlsi3_internal7"
4106 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4107 (zero_extend:SI
4108 (subreg:QI
4109 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
4110 (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0)))]
4111 ""
4112 "{rl%I2nm|rlw%I2nm} %0,%1,%h2,0xff"
4113 [(set (attr "cell_micro")
4114 (if_then_else (match_operand:SI 2 "const_int_operand" "")
4115 (const_string "not")
4116 (const_string "always")))])
4117
4118 (define_insn "*rotlsi3_internal8"
4119 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
4120 (compare:CC (zero_extend:SI
4121 (subreg:QI
4122 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
4123 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i")) 0))
4124 (const_int 0)))
4125 (clobber (match_scratch:SI 3 "=r,r,r,r"))]
4126 ""
4127 "@
4128 {rlnm.|rlwnm.} %3,%1,%2,0xff
4129 {rlinm.|rlwinm.} %3,%1,%h2,0xff
4130 #
4131 #"
4132 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
4133 (set_attr "length" "4,4,8,8")])
4134
4135 (define_split
4136 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
4137 (compare:CC (zero_extend:SI
4138 (subreg:QI
4139 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
4140 (match_operand:SI 2 "reg_or_cint_operand" "")) 0))
4141 (const_int 0)))
4142 (clobber (match_scratch:SI 3 ""))]
4143 "reload_completed"
4144 [(set (match_dup 3)
4145 (zero_extend:SI (subreg:QI
4146 (rotate:SI (match_dup 1)
4147 (match_dup 2)) 0)))
4148 (set (match_dup 0)
4149 (compare:CC (match_dup 3)
4150 (const_int 0)))]
4151 "")
4152
4153 (define_insn "*rotlsi3_internal9"
4154 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
4155 (compare:CC (zero_extend:SI
4156 (subreg:QI
4157 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
4158 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i")) 0))
4159 (const_int 0)))
4160 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
4161 (zero_extend:SI (subreg:QI (rotate:SI (match_dup 1) (match_dup 2)) 0)))]
4162 ""
4163 "@
4164 {rlnm.|rlwnm.} %0,%1,%2,0xff
4165 {rlinm.|rlwinm.} %0,%1,%h2,0xff
4166 #
4167 #"
4168 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
4169 (set_attr "length" "4,4,8,8")])
4170
4171 (define_split
4172 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
4173 (compare:CC (zero_extend:SI
4174 (subreg:QI
4175 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
4176 (match_operand:SI 2 "reg_or_cint_operand" "")) 0))
4177 (const_int 0)))
4178 (set (match_operand:SI 0 "gpc_reg_operand" "")
4179 (zero_extend:SI (subreg:QI (rotate:SI (match_dup 1) (match_dup 2)) 0)))]
4180 "reload_completed"
4181 [(set (match_dup 0)
4182 (zero_extend:SI (subreg:QI (rotate:SI (match_dup 1) (match_dup 2)) 0)))
4183 (set (match_dup 3)
4184 (compare:CC (match_dup 0)
4185 (const_int 0)))]
4186 "")
4187
4188 (define_insn "*rotlsi3_internal10"
4189 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
4190 (zero_extend:SI
4191 (subreg:HI
4192 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4193 (match_operand:SI 2 "reg_or_cint_operand" "r,i")) 0)))]
4194 ""
4195 "@
4196 {rlnm|rlwnm} %0,%1,%2,0xffff
4197 {rlinm|rlwinm} %0,%1,%h2,0xffff"
4198 [(set_attr "type" "var_shift_rotate,integer")])
4199
4200
4201 (define_insn "*rotlsi3_internal11"
4202 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
4203 (compare:CC (zero_extend:SI
4204 (subreg:HI
4205 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
4206 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i")) 0))
4207 (const_int 0)))
4208 (clobber (match_scratch:SI 3 "=r,r,r,r"))]
4209 ""
4210 "@
4211 {rlnm.|rlwnm.} %3,%1,%2,0xffff
4212 {rlinm.|rlwinm.} %3,%1,%h2,0xffff
4213 #
4214 #"
4215 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
4216 (set_attr "length" "4,4,8,8")])
4217
4218 (define_split
4219 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
4220 (compare:CC (zero_extend:SI
4221 (subreg:HI
4222 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
4223 (match_operand:SI 2 "reg_or_cint_operand" "")) 0))
4224 (const_int 0)))
4225 (clobber (match_scratch:SI 3 ""))]
4226 "reload_completed"
4227 [(set (match_dup 3)
4228 (zero_extend:SI (subreg:HI
4229 (rotate:SI (match_dup 1)
4230 (match_dup 2)) 0)))
4231 (set (match_dup 0)
4232 (compare:CC (match_dup 3)
4233 (const_int 0)))]
4234 "")
4235
4236 (define_insn "*rotlsi3_internal12"
4237 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
4238 (compare:CC (zero_extend:SI
4239 (subreg:HI
4240 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
4241 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i")) 0))
4242 (const_int 0)))
4243 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
4244 (zero_extend:SI (subreg:HI (rotate:SI (match_dup 1) (match_dup 2)) 0)))]
4245 ""
4246 "@
4247 {rlnm.|rlwnm.} %0,%1,%2,0xffff
4248 {rlinm.|rlwinm.} %0,%1,%h2,0xffff
4249 #
4250 #"
4251 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
4252 (set_attr "length" "4,4,8,8")])
4253
4254 (define_split
4255 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
4256 (compare:CC (zero_extend:SI
4257 (subreg:HI
4258 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
4259 (match_operand:SI 2 "reg_or_cint_operand" "")) 0))
4260 (const_int 0)))
4261 (set (match_operand:SI 0 "gpc_reg_operand" "")
4262 (zero_extend:SI (subreg:HI (rotate:SI (match_dup 1) (match_dup 2)) 0)))]
4263 "reload_completed"
4264 [(set (match_dup 0)
4265 (zero_extend:SI (subreg:HI (rotate:SI (match_dup 1) (match_dup 2)) 0)))
4266 (set (match_dup 3)
4267 (compare:CC (match_dup 0)
4268 (const_int 0)))]
4269 "")
4270
4271 ;; Note that we use "sle." instead of "sl." so that we can set
4272 ;; SHIFT_COUNT_TRUNCATED.
4273
4274 (define_expand "ashlsi3"
4275 [(use (match_operand:SI 0 "gpc_reg_operand" ""))
4276 (use (match_operand:SI 1 "gpc_reg_operand" ""))
4277 (use (match_operand:SI 2 "reg_or_cint_operand" ""))]
4278 ""
4279 "
4280 {
4281 if (TARGET_POWER)
4282 emit_insn (gen_ashlsi3_power (operands[0], operands[1], operands[2]));
4283 else
4284 emit_insn (gen_ashlsi3_no_power (operands[0], operands[1], operands[2]));
4285 DONE;
4286 }")
4287
4288 (define_insn "ashlsi3_power"
4289 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
4290 (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4291 (match_operand:SI 2 "reg_or_cint_operand" "r,i")))
4292 (clobber (match_scratch:SI 3 "=q,X"))]
4293 "TARGET_POWER"
4294 "@
4295 sle %0,%1,%2
4296 {sli|slwi} %0,%1,%h2")
4297
4298 (define_insn "ashlsi3_no_power"
4299 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
4300 (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4301 (match_operand:SI 2 "reg_or_cint_operand" "r,i")))]
4302 "! TARGET_POWER"
4303 "@
4304 {sl|slw} %0,%1,%2
4305 {sli|slwi} %0,%1,%h2"
4306 [(set_attr "type" "var_shift_rotate,shift")])
4307
4308 (define_insn ""
4309 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
4310 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
4311 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
4312 (const_int 0)))
4313 (clobber (match_scratch:SI 3 "=r,r,r,r"))
4314 (clobber (match_scratch:SI 4 "=q,X,q,X"))]
4315 "TARGET_POWER"
4316 "@
4317 sle. %3,%1,%2
4318 {sli.|slwi.} %3,%1,%h2
4319 #
4320 #"
4321 [(set_attr "type" "delayed_compare")
4322 (set_attr "length" "4,4,8,8")])
4323
4324 (define_split
4325 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
4326 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "")
4327 (match_operand:SI 2 "reg_or_cint_operand" ""))
4328 (const_int 0)))
4329 (clobber (match_scratch:SI 3 ""))
4330 (clobber (match_scratch:SI 4 ""))]
4331 "TARGET_POWER && reload_completed"
4332 [(parallel [(set (match_dup 3)
4333 (ashift:SI (match_dup 1) (match_dup 2)))
4334 (clobber (match_dup 4))])
4335 (set (match_dup 0)
4336 (compare:CC (match_dup 3)
4337 (const_int 0)))]
4338 "")
4339
4340 (define_insn ""
4341 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
4342 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
4343 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
4344 (const_int 0)))
4345 (clobber (match_scratch:SI 3 "=r,r,r,r"))]
4346 "! TARGET_POWER && TARGET_32BIT"
4347 "@
4348 {sl.|slw.} %3,%1,%2
4349 {sli.|slwi.} %3,%1,%h2
4350 #
4351 #"
4352 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
4353 (set_attr "length" "4,4,8,8")])
4354
4355 (define_split
4356 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
4357 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "")
4358 (match_operand:SI 2 "reg_or_cint_operand" ""))
4359 (const_int 0)))
4360 (clobber (match_scratch:SI 3 ""))]
4361 "! TARGET_POWER && TARGET_32BIT && reload_completed"
4362 [(set (match_dup 3)
4363 (ashift:SI (match_dup 1) (match_dup 2)))
4364 (set (match_dup 0)
4365 (compare:CC (match_dup 3)
4366 (const_int 0)))]
4367 "")
4368
4369 (define_insn ""
4370 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
4371 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
4372 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
4373 (const_int 0)))
4374 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
4375 (ashift:SI (match_dup 1) (match_dup 2)))
4376 (clobber (match_scratch:SI 4 "=q,X,q,X"))]
4377 "TARGET_POWER"
4378 "@
4379 sle. %0,%1,%2
4380 {sli.|slwi.} %0,%1,%h2
4381 #
4382 #"
4383 [(set_attr "type" "delayed_compare")
4384 (set_attr "length" "4,4,8,8")])
4385
4386 (define_split
4387 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
4388 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "")
4389 (match_operand:SI 2 "reg_or_cint_operand" ""))
4390 (const_int 0)))
4391 (set (match_operand:SI 0 "gpc_reg_operand" "")
4392 (ashift:SI (match_dup 1) (match_dup 2)))
4393 (clobber (match_scratch:SI 4 ""))]
4394 "TARGET_POWER && reload_completed"
4395 [(parallel [(set (match_dup 0)
4396 (ashift:SI (match_dup 1) (match_dup 2)))
4397 (clobber (match_dup 4))])
4398 (set (match_dup 3)
4399 (compare:CC (match_dup 0)
4400 (const_int 0)))]
4401 "")
4402
4403 (define_insn ""
4404 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
4405 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
4406 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
4407 (const_int 0)))
4408 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
4409 (ashift:SI (match_dup 1) (match_dup 2)))]
4410 "! TARGET_POWER && TARGET_32BIT"
4411 "@
4412 {sl.|slw.} %0,%1,%2
4413 {sli.|slwi.} %0,%1,%h2
4414 #
4415 #"
4416 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
4417 (set_attr "length" "4,4,8,8")])
4418
4419 (define_split
4420 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
4421 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "")
4422 (match_operand:SI 2 "reg_or_cint_operand" ""))
4423 (const_int 0)))
4424 (set (match_operand:SI 0 "gpc_reg_operand" "")
4425 (ashift:SI (match_dup 1) (match_dup 2)))]
4426 "! TARGET_POWER && TARGET_32BIT && reload_completed"
4427 [(set (match_dup 0)
4428 (ashift:SI (match_dup 1) (match_dup 2)))
4429 (set (match_dup 3)
4430 (compare:CC (match_dup 0)
4431 (const_int 0)))]
4432 "")
4433
4434 (define_insn "rlwinm"
4435 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4436 (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
4437 (match_operand:SI 2 "const_int_operand" "i"))
4438 (match_operand:SI 3 "mask_operand" "n")))]
4439 "includes_lshift_p (operands[2], operands[3])"
4440 "{rlinm|rlwinm} %0,%1,%h2,%m3,%M3")
4441
4442 (define_insn ""
4443 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
4444 (compare:CC
4445 (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4446 (match_operand:SI 2 "const_int_operand" "i,i"))
4447 (match_operand:SI 3 "mask_operand" "n,n"))
4448 (const_int 0)))
4449 (clobber (match_scratch:SI 4 "=r,r"))]
4450 "includes_lshift_p (operands[2], operands[3])"
4451 "@
4452 {rlinm.|rlwinm.} %4,%1,%h2,%m3,%M3
4453 #"
4454 [(set_attr "type" "delayed_compare")
4455 (set_attr "length" "4,8")])
4456
4457 (define_split
4458 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
4459 (compare:CC
4460 (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "")
4461 (match_operand:SI 2 "const_int_operand" ""))
4462 (match_operand:SI 3 "mask_operand" ""))
4463 (const_int 0)))
4464 (clobber (match_scratch:SI 4 ""))]
4465 "includes_lshift_p (operands[2], operands[3]) && reload_completed"
4466 [(set (match_dup 4)
4467 (and:SI (ashift:SI (match_dup 1) (match_dup 2))
4468 (match_dup 3)))
4469 (set (match_dup 0)
4470 (compare:CC (match_dup 4)
4471 (const_int 0)))]
4472 "")
4473
4474 (define_insn ""
4475 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
4476 (compare:CC
4477 (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4478 (match_operand:SI 2 "const_int_operand" "i,i"))
4479 (match_operand:SI 3 "mask_operand" "n,n"))
4480 (const_int 0)))
4481 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
4482 (and:SI (ashift:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
4483 "includes_lshift_p (operands[2], operands[3])"
4484 "@
4485 {rlinm.|rlwinm.} %0,%1,%h2,%m3,%M3
4486 #"
4487 [(set_attr "type" "delayed_compare")
4488 (set_attr "length" "4,8")])
4489
4490 (define_split
4491 [(set (match_operand:CC 4 "cc_reg_not_micro_cr0_operand" "")
4492 (compare:CC
4493 (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "")
4494 (match_operand:SI 2 "const_int_operand" ""))
4495 (match_operand:SI 3 "mask_operand" ""))
4496 (const_int 0)))
4497 (set (match_operand:SI 0 "gpc_reg_operand" "")
4498 (and:SI (ashift:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
4499 "includes_lshift_p (operands[2], operands[3]) && reload_completed"
4500 [(set (match_dup 0)
4501 (and:SI (ashift:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
4502 (set (match_dup 4)
4503 (compare:CC (match_dup 0)
4504 (const_int 0)))]
4505 "")
4506
4507 ;; The AIX assembler mis-handles "sri x,x,0", so write that case as
4508 ;; "sli x,x,0".
4509 (define_expand "lshrsi3"
4510 [(use (match_operand:SI 0 "gpc_reg_operand" ""))
4511 (use (match_operand:SI 1 "gpc_reg_operand" ""))
4512 (use (match_operand:SI 2 "reg_or_cint_operand" ""))]
4513 ""
4514 "
4515 {
4516 if (TARGET_POWER)
4517 emit_insn (gen_lshrsi3_power (operands[0], operands[1], operands[2]));
4518 else
4519 emit_insn (gen_lshrsi3_no_power (operands[0], operands[1], operands[2]));
4520 DONE;
4521 }")
4522
4523 (define_insn "lshrsi3_power"
4524 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
4525 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r")
4526 (match_operand:SI 2 "reg_or_cint_operand" "r,O,i")))
4527 (clobber (match_scratch:SI 3 "=q,X,X"))]
4528 "TARGET_POWER"
4529 "@
4530 sre %0,%1,%2
4531 mr %0,%1
4532 {s%A2i|s%A2wi} %0,%1,%h2")
4533
4534 (define_insn "lshrsi3_no_power"
4535 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
4536 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r")
4537 (match_operand:SI 2 "reg_or_cint_operand" "O,r,i")))]
4538 "! TARGET_POWER"
4539 "@
4540 mr %0,%1
4541 {sr|srw} %0,%1,%2
4542 {sri|srwi} %0,%1,%h2"
4543 [(set_attr "type" "integer,var_shift_rotate,shift")])
4544
4545 (define_insn ""
4546 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,?y,?y,?y")
4547 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r,r,r")
4548 (match_operand:SI 2 "reg_or_cint_operand" "r,O,i,r,O,i"))
4549 (const_int 0)))
4550 (clobber (match_scratch:SI 3 "=r,X,r,r,X,r"))
4551 (clobber (match_scratch:SI 4 "=q,X,X,q,X,X"))]
4552 "TARGET_POWER"
4553 "@
4554 sre. %3,%1,%2
4555 mr. %1,%1
4556 {s%A2i.|s%A2wi.} %3,%1,%h2
4557 #
4558 #
4559 #"
4560 [(set_attr "type" "delayed_compare")
4561 (set_attr "length" "4,4,4,8,8,8")])
4562
4563 (define_split
4564 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
4565 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4566 (match_operand:SI 2 "reg_or_cint_operand" ""))
4567 (const_int 0)))
4568 (clobber (match_scratch:SI 3 ""))
4569 (clobber (match_scratch:SI 4 ""))]
4570 "TARGET_POWER && reload_completed"
4571 [(parallel [(set (match_dup 3)
4572 (lshiftrt:SI (match_dup 1) (match_dup 2)))
4573 (clobber (match_dup 4))])
4574 (set (match_dup 0)
4575 (compare:CC (match_dup 3)
4576 (const_int 0)))]
4577 "")
4578
4579 (define_insn ""
4580 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,?y,?y,?y")
4581 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r,r,r")
4582 (match_operand:SI 2 "reg_or_cint_operand" "O,r,i,O,r,i"))
4583 (const_int 0)))
4584 (clobber (match_scratch:SI 3 "=X,r,r,X,r,r"))]
4585 "! TARGET_POWER && TARGET_32BIT"
4586 "@
4587 mr. %1,%1
4588 {sr.|srw.} %3,%1,%2
4589 {sri.|srwi.} %3,%1,%h2
4590 #
4591 #
4592 #"
4593 [(set_attr "type" "delayed_compare,var_delayed_compare,delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
4594 (set_attr "length" "4,4,4,8,8,8")])
4595
4596 (define_split
4597 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
4598 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4599 (match_operand:SI 2 "reg_or_cint_operand" ""))
4600 (const_int 0)))
4601 (clobber (match_scratch:SI 3 ""))]
4602 "! TARGET_POWER && TARGET_32BIT && reload_completed"
4603 [(set (match_dup 3)
4604 (lshiftrt:SI (match_dup 1) (match_dup 2)))
4605 (set (match_dup 0)
4606 (compare:CC (match_dup 3)
4607 (const_int 0)))]
4608 "")
4609
4610 (define_insn ""
4611 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,?y,?y,?y")
4612 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r,r,r")
4613 (match_operand:SI 2 "reg_or_cint_operand" "r,O,i,r,O,i"))
4614 (const_int 0)))
4615 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r,r")
4616 (lshiftrt:SI (match_dup 1) (match_dup 2)))
4617 (clobber (match_scratch:SI 4 "=q,X,X,q,X,X"))]
4618 "TARGET_POWER"
4619 "@
4620 sre. %0,%1,%2
4621 mr. %0,%1
4622 {s%A2i.|s%A2wi.} %0,%1,%h2
4623 #
4624 #
4625 #"
4626 [(set_attr "type" "delayed_compare")
4627 (set_attr "length" "4,4,4,8,8,8")])
4628
4629 (define_split
4630 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
4631 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4632 (match_operand:SI 2 "reg_or_cint_operand" ""))
4633 (const_int 0)))
4634 (set (match_operand:SI 0 "gpc_reg_operand" "")
4635 (lshiftrt:SI (match_dup 1) (match_dup 2)))
4636 (clobber (match_scratch:SI 4 ""))]
4637 "TARGET_POWER && reload_completed"
4638 [(parallel [(set (match_dup 0)
4639 (lshiftrt:SI (match_dup 1) (match_dup 2)))
4640 (clobber (match_dup 4))])
4641 (set (match_dup 3)
4642 (compare:CC (match_dup 0)
4643 (const_int 0)))]
4644 "")
4645
4646 (define_insn ""
4647 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,?y,?y,?y")
4648 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r,r,r")
4649 (match_operand:SI 2 "reg_or_cint_operand" "O,r,i,O,r,i"))
4650 (const_int 0)))
4651 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r,r")
4652 (lshiftrt:SI (match_dup 1) (match_dup 2)))]
4653 "! TARGET_POWER && TARGET_32BIT"
4654 "@
4655 mr. %0,%1
4656 {sr.|srw.} %0,%1,%2
4657 {sri.|srwi.} %0,%1,%h2
4658 #
4659 #
4660 #"
4661 [(set_attr "type" "delayed_compare,var_delayed_compare,delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
4662 (set_attr "length" "4,4,4,8,8,8")])
4663
4664 (define_split
4665 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
4666 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4667 (match_operand:SI 2 "reg_or_cint_operand" ""))
4668 (const_int 0)))
4669 (set (match_operand:SI 0 "gpc_reg_operand" "")
4670 (lshiftrt:SI (match_dup 1) (match_dup 2)))]
4671 "! TARGET_POWER && TARGET_32BIT && reload_completed"
4672 [(set (match_dup 0)
4673 (lshiftrt:SI (match_dup 1) (match_dup 2)))
4674 (set (match_dup 3)
4675 (compare:CC (match_dup 0)
4676 (const_int 0)))]
4677 "")
4678
4679 (define_insn ""
4680 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4681 (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
4682 (match_operand:SI 2 "const_int_operand" "i"))
4683 (match_operand:SI 3 "mask_operand" "n")))]
4684 "includes_rshift_p (operands[2], operands[3])"
4685 "{rlinm|rlwinm} %0,%1,%s2,%m3,%M3")
4686
4687 (define_insn ""
4688 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
4689 (compare:CC
4690 (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4691 (match_operand:SI 2 "const_int_operand" "i,i"))
4692 (match_operand:SI 3 "mask_operand" "n,n"))
4693 (const_int 0)))
4694 (clobber (match_scratch:SI 4 "=r,r"))]
4695 "includes_rshift_p (operands[2], operands[3])"
4696 "@
4697 {rlinm.|rlwinm.} %4,%1,%s2,%m3,%M3
4698 #"
4699 [(set_attr "type" "delayed_compare")
4700 (set_attr "length" "4,8")])
4701
4702 (define_split
4703 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
4704 (compare:CC
4705 (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4706 (match_operand:SI 2 "const_int_operand" ""))
4707 (match_operand:SI 3 "mask_operand" ""))
4708 (const_int 0)))
4709 (clobber (match_scratch:SI 4 ""))]
4710 "includes_rshift_p (operands[2], operands[3]) && reload_completed"
4711 [(set (match_dup 4)
4712 (and:SI (lshiftrt:SI (match_dup 1) (match_dup 2))
4713 (match_dup 3)))
4714 (set (match_dup 0)
4715 (compare:CC (match_dup 4)
4716 (const_int 0)))]
4717 "")
4718
4719 (define_insn ""
4720 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
4721 (compare:CC
4722 (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4723 (match_operand:SI 2 "const_int_operand" "i,i"))
4724 (match_operand:SI 3 "mask_operand" "n,n"))
4725 (const_int 0)))
4726 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
4727 (and:SI (lshiftrt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
4728 "includes_rshift_p (operands[2], operands[3])"
4729 "@
4730 {rlinm.|rlwinm.} %0,%1,%s2,%m3,%M3
4731 #"
4732 [(set_attr "type" "delayed_compare")
4733 (set_attr "length" "4,8")])
4734
4735 (define_split
4736 [(set (match_operand:CC 4 "cc_reg_not_micro_cr0_operand" "")
4737 (compare:CC
4738 (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4739 (match_operand:SI 2 "const_int_operand" ""))
4740 (match_operand:SI 3 "mask_operand" ""))
4741 (const_int 0)))
4742 (set (match_operand:SI 0 "gpc_reg_operand" "")
4743 (and:SI (lshiftrt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
4744 "includes_rshift_p (operands[2], operands[3]) && reload_completed"
4745 [(set (match_dup 0)
4746 (and:SI (lshiftrt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
4747 (set (match_dup 4)
4748 (compare:CC (match_dup 0)
4749 (const_int 0)))]
4750 "")
4751
4752 (define_insn ""
4753 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4754 (zero_extend:SI
4755 (subreg:QI
4756 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
4757 (match_operand:SI 2 "const_int_operand" "i")) 0)))]
4758 "includes_rshift_p (operands[2], GEN_INT (255))"
4759 "{rlinm|rlwinm} %0,%1,%s2,0xff")
4760
4761 (define_insn ""
4762 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
4763 (compare:CC
4764 (zero_extend:SI
4765 (subreg:QI
4766 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4767 (match_operand:SI 2 "const_int_operand" "i,i")) 0))
4768 (const_int 0)))
4769 (clobber (match_scratch:SI 3 "=r,r"))]
4770 "includes_rshift_p (operands[2], GEN_INT (255))"
4771 "@
4772 {rlinm.|rlwinm.} %3,%1,%s2,0xff
4773 #"
4774 [(set_attr "type" "delayed_compare")
4775 (set_attr "length" "4,8")])
4776
4777 (define_split
4778 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
4779 (compare:CC
4780 (zero_extend:SI
4781 (subreg:QI
4782 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4783 (match_operand:SI 2 "const_int_operand" "")) 0))
4784 (const_int 0)))
4785 (clobber (match_scratch:SI 3 ""))]
4786 "includes_rshift_p (operands[2], GEN_INT (255)) && reload_completed"
4787 [(set (match_dup 3)
4788 (zero_extend:SI (subreg:QI
4789 (lshiftrt:SI (match_dup 1)
4790 (match_dup 2)) 0)))
4791 (set (match_dup 0)
4792 (compare:CC (match_dup 3)
4793 (const_int 0)))]
4794 "")
4795
4796 (define_insn ""
4797 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
4798 (compare:CC
4799 (zero_extend:SI
4800 (subreg:QI
4801 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4802 (match_operand:SI 2 "const_int_operand" "i,i")) 0))
4803 (const_int 0)))
4804 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
4805 (zero_extend:SI (subreg:QI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))]
4806 "includes_rshift_p (operands[2], GEN_INT (255))"
4807 "@
4808 {rlinm.|rlwinm.} %0,%1,%s2,0xff
4809 #"
4810 [(set_attr "type" "delayed_compare")
4811 (set_attr "length" "4,8")])
4812
4813 (define_split
4814 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
4815 (compare:CC
4816 (zero_extend:SI
4817 (subreg:QI
4818 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4819 (match_operand:SI 2 "const_int_operand" "")) 0))
4820 (const_int 0)))
4821 (set (match_operand:SI 0 "gpc_reg_operand" "")
4822 (zero_extend:SI (subreg:QI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))]
4823 "includes_rshift_p (operands[2], GEN_INT (255)) && reload_completed"
4824 [(set (match_dup 0)
4825 (zero_extend:SI (subreg:QI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))
4826 (set (match_dup 3)
4827 (compare:CC (match_dup 0)
4828 (const_int 0)))]
4829 "")
4830
4831 (define_insn ""
4832 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4833 (zero_extend:SI
4834 (subreg:HI
4835 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
4836 (match_operand:SI 2 "const_int_operand" "i")) 0)))]
4837 "includes_rshift_p (operands[2], GEN_INT (65535))"
4838 "{rlinm|rlwinm} %0,%1,%s2,0xffff")
4839
4840 (define_insn ""
4841 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
4842 (compare:CC
4843 (zero_extend:SI
4844 (subreg:HI
4845 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4846 (match_operand:SI 2 "const_int_operand" "i,i")) 0))
4847 (const_int 0)))
4848 (clobber (match_scratch:SI 3 "=r,r"))]
4849 "includes_rshift_p (operands[2], GEN_INT (65535))"
4850 "@
4851 {rlinm.|rlwinm.} %3,%1,%s2,0xffff
4852 #"
4853 [(set_attr "type" "delayed_compare")
4854 (set_attr "length" "4,8")])
4855
4856 (define_split
4857 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
4858 (compare:CC
4859 (zero_extend:SI
4860 (subreg:HI
4861 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4862 (match_operand:SI 2 "const_int_operand" "")) 0))
4863 (const_int 0)))
4864 (clobber (match_scratch:SI 3 ""))]
4865 "includes_rshift_p (operands[2], GEN_INT (65535)) && reload_completed"
4866 [(set (match_dup 3)
4867 (zero_extend:SI (subreg:HI
4868 (lshiftrt:SI (match_dup 1)
4869 (match_dup 2)) 0)))
4870 (set (match_dup 0)
4871 (compare:CC (match_dup 3)
4872 (const_int 0)))]
4873 "")
4874
4875 (define_insn ""
4876 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
4877 (compare:CC
4878 (zero_extend:SI
4879 (subreg:HI
4880 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4881 (match_operand:SI 2 "const_int_operand" "i,i")) 0))
4882 (const_int 0)))
4883 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
4884 (zero_extend:SI (subreg:HI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))]
4885 "includes_rshift_p (operands[2], GEN_INT (65535))"
4886 "@
4887 {rlinm.|rlwinm.} %0,%1,%s2,0xffff
4888 #"
4889 [(set_attr "type" "delayed_compare")
4890 (set_attr "length" "4,8")])
4891
4892 (define_split
4893 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
4894 (compare:CC
4895 (zero_extend:SI
4896 (subreg:HI
4897 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4898 (match_operand:SI 2 "const_int_operand" "")) 0))
4899 (const_int 0)))
4900 (set (match_operand:SI 0 "gpc_reg_operand" "")
4901 (zero_extend:SI (subreg:HI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))]
4902 "includes_rshift_p (operands[2], GEN_INT (65535)) && reload_completed"
4903 [(set (match_dup 0)
4904 (zero_extend:SI (subreg:HI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))
4905 (set (match_dup 3)
4906 (compare:CC (match_dup 0)
4907 (const_int 0)))]
4908 "")
4909
4910 (define_insn ""
4911 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
4912 (const_int 1)
4913 (match_operand:SI 1 "gpc_reg_operand" "r"))
4914 (ashiftrt:SI (match_operand:SI 2 "gpc_reg_operand" "r")
4915 (const_int 31)))]
4916 "TARGET_POWER"
4917 "rrib %0,%1,%2")
4918
4919 (define_insn ""
4920 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
4921 (const_int 1)
4922 (match_operand:SI 1 "gpc_reg_operand" "r"))
4923 (lshiftrt:SI (match_operand:SI 2 "gpc_reg_operand" "r")
4924 (const_int 31)))]
4925 "TARGET_POWER"
4926 "rrib %0,%1,%2")
4927
4928 (define_insn ""
4929 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
4930 (const_int 1)
4931 (match_operand:SI 1 "gpc_reg_operand" "r"))
4932 (zero_extract:SI (match_operand:SI 2 "gpc_reg_operand" "r")
4933 (const_int 1)
4934 (const_int 0)))]
4935 "TARGET_POWER"
4936 "rrib %0,%1,%2")
4937
4938 (define_expand "ashrsi3"
4939 [(set (match_operand:SI 0 "gpc_reg_operand" "")
4940 (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4941 (match_operand:SI 2 "reg_or_cint_operand" "")))]
4942 ""
4943 "
4944 {
4945 if (TARGET_POWER)
4946 emit_insn (gen_ashrsi3_power (operands[0], operands[1], operands[2]));
4947 else
4948 emit_insn (gen_ashrsi3_no_power (operands[0], operands[1], operands[2]));
4949 DONE;
4950 }")
4951
4952 (define_insn "ashrsi3_power"
4953 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
4954 (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4955 (match_operand:SI 2 "reg_or_cint_operand" "r,i")))
4956 (clobber (match_scratch:SI 3 "=q,X"))]
4957 "TARGET_POWER"
4958 "@
4959 srea %0,%1,%2
4960 {srai|srawi} %0,%1,%h2"
4961 [(set_attr "type" "shift")])
4962
4963 (define_insn "ashrsi3_no_power"
4964 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
4965 (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4966 (match_operand:SI 2 "reg_or_cint_operand" "r,i")))]
4967 "! TARGET_POWER"
4968 "@
4969 {sra|sraw} %0,%1,%2
4970 {srai|srawi} %0,%1,%h2"
4971 [(set_attr "type" "var_shift_rotate,shift")])
4972
4973 (define_insn ""
4974 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
4975 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
4976 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
4977 (const_int 0)))
4978 (clobber (match_scratch:SI 3 "=r,r,r,r"))
4979 (clobber (match_scratch:SI 4 "=q,X,q,X"))]
4980 "TARGET_POWER"
4981 "@
4982 srea. %3,%1,%2
4983 {srai.|srawi.} %3,%1,%h2
4984 #
4985 #"
4986 [(set_attr "type" "delayed_compare")
4987 (set_attr "length" "4,4,8,8")])
4988
4989 (define_split
4990 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
4991 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4992 (match_operand:SI 2 "reg_or_cint_operand" ""))
4993 (const_int 0)))
4994 (clobber (match_scratch:SI 3 ""))
4995 (clobber (match_scratch:SI 4 ""))]
4996 "TARGET_POWER && reload_completed"
4997 [(parallel [(set (match_dup 3)
4998 (ashiftrt:SI (match_dup 1) (match_dup 2)))
4999 (clobber (match_dup 4))])
5000 (set (match_dup 0)
5001 (compare:CC (match_dup 3)
5002 (const_int 0)))]
5003 "")
5004
5005 (define_insn ""
5006 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
5007 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
5008 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
5009 (const_int 0)))
5010 (clobber (match_scratch:SI 3 "=r,r,r,r"))]
5011 "! TARGET_POWER"
5012 "@
5013 {sra.|sraw.} %3,%1,%2
5014 {srai.|srawi.} %3,%1,%h2
5015 #
5016 #"
5017 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
5018 (set_attr "length" "4,4,8,8")])
5019
5020 (define_split
5021 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
5022 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
5023 (match_operand:SI 2 "reg_or_cint_operand" ""))
5024 (const_int 0)))
5025 (clobber (match_scratch:SI 3 ""))]
5026 "! TARGET_POWER && reload_completed"
5027 [(set (match_dup 3)
5028 (ashiftrt:SI (match_dup 1) (match_dup 2)))
5029 (set (match_dup 0)
5030 (compare:CC (match_dup 3)
5031 (const_int 0)))]
5032 "")
5033
5034 (define_insn ""
5035 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
5036 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
5037 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
5038 (const_int 0)))
5039 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
5040 (ashiftrt:SI (match_dup 1) (match_dup 2)))
5041 (clobber (match_scratch:SI 4 "=q,X,q,X"))]
5042 "TARGET_POWER"
5043 "@
5044 srea. %0,%1,%2
5045 {srai.|srawi.} %0,%1,%h2
5046 #
5047 #"
5048 [(set_attr "type" "delayed_compare")
5049 (set_attr "length" "4,4,8,8")])
5050
5051 (define_split
5052 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
5053 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
5054 (match_operand:SI 2 "reg_or_cint_operand" ""))
5055 (const_int 0)))
5056 (set (match_operand:SI 0 "gpc_reg_operand" "")
5057 (ashiftrt:SI (match_dup 1) (match_dup 2)))
5058 (clobber (match_scratch:SI 4 ""))]
5059 "TARGET_POWER && reload_completed"
5060 [(parallel [(set (match_dup 0)
5061 (ashiftrt:SI (match_dup 1) (match_dup 2)))
5062 (clobber (match_dup 4))])
5063 (set (match_dup 3)
5064 (compare:CC (match_dup 0)
5065 (const_int 0)))]
5066 "")
5067
5068 (define_insn ""
5069 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
5070 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
5071 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
5072 (const_int 0)))
5073 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
5074 (ashiftrt:SI (match_dup 1) (match_dup 2)))]
5075 "! TARGET_POWER"
5076 "@
5077 {sra.|sraw.} %0,%1,%2
5078 {srai.|srawi.} %0,%1,%h2
5079 #
5080 #"
5081 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
5082 (set_attr "length" "4,4,8,8")])
5083 \f
5084 (define_split
5085 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
5086 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
5087 (match_operand:SI 2 "reg_or_cint_operand" ""))
5088 (const_int 0)))
5089 (set (match_operand:SI 0 "gpc_reg_operand" "")
5090 (ashiftrt:SI (match_dup 1) (match_dup 2)))]
5091 "! TARGET_POWER && reload_completed"
5092 [(set (match_dup 0)
5093 (ashiftrt:SI (match_dup 1) (match_dup 2)))
5094 (set (match_dup 3)
5095 (compare:CC (match_dup 0)
5096 (const_int 0)))]
5097 "")
5098
5099 ;; Floating-point insns, excluding normal data motion.
5100 ;;
5101 ;; PowerPC has a full set of single-precision floating point instructions.
5102 ;;
5103 ;; For the POWER architecture, we pretend that we have both SFmode and
5104 ;; DFmode insns, while, in fact, all fp insns are actually done in double.
5105 ;; The only conversions we will do will be when storing to memory. In that
5106 ;; case, we will use the "frsp" instruction before storing.
5107 ;;
5108 ;; Note that when we store into a single-precision memory location, we need to
5109 ;; use the frsp insn first. If the register being stored isn't dead, we
5110 ;; need a scratch register for the frsp. But this is difficult when the store
5111 ;; is done by reload. It is not incorrect to do the frsp on the register in
5112 ;; this case, we just lose precision that we would have otherwise gotten but
5113 ;; is not guaranteed. Perhaps this should be tightened up at some point.
5114
5115 (define_expand "extendsfdf2"
5116 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5117 (float_extend:DF (match_operand:SF 1 "reg_or_none500mem_operand" "")))]
5118 "TARGET_HARD_FLOAT && ((TARGET_FPRS && TARGET_DOUBLE_FLOAT) || TARGET_E500_DOUBLE)"
5119 "")
5120
5121 (define_insn_and_split "*extendsfdf2_fpr"
5122 [(set (match_operand:DF 0 "gpc_reg_operand" "=f,?f,f")
5123 (float_extend:DF (match_operand:SF 1 "reg_or_mem_operand" "0,f,m")))]
5124 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
5125 "@
5126 #
5127 fmr %0,%1
5128 lfs%U1%X1 %0,%1"
5129 "&& reload_completed && REG_P (operands[1]) && REGNO (operands[0]) == REGNO (operands[1])"
5130 [(const_int 0)]
5131 {
5132 emit_note (NOTE_INSN_DELETED);
5133 DONE;
5134 }
5135 [(set_attr "type" "fp,fp,fpload")])
5136
5137 (define_expand "truncdfsf2"
5138 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5139 (float_truncate:SF (match_operand:DF 1 "gpc_reg_operand" "")))]
5140 "TARGET_HARD_FLOAT && ((TARGET_FPRS && TARGET_DOUBLE_FLOAT) || TARGET_E500_DOUBLE)"
5141 "")
5142
5143 (define_insn "*truncdfsf2_fpr"
5144 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5145 (float_truncate:SF (match_operand:DF 1 "gpc_reg_operand" "f")))]
5146 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
5147 "frsp %0,%1"
5148 [(set_attr "type" "fp")])
5149
5150 (define_insn "aux_truncdfsf2"
5151 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5152 (unspec:SF [(match_operand:SF 1 "gpc_reg_operand" "f")] UNSPEC_FRSP))]
5153 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS"
5154 "frsp %0,%1"
5155 [(set_attr "type" "fp")])
5156
5157 (define_expand "negsf2"
5158 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5159 (neg:SF (match_operand:SF 1 "gpc_reg_operand" "")))]
5160 "TARGET_HARD_FLOAT && TARGET_SINGLE_FLOAT"
5161 "")
5162
5163 (define_insn "*negsf2"
5164 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5165 (neg:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
5166 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT"
5167 "fneg %0,%1"
5168 [(set_attr "type" "fp")])
5169
5170 (define_expand "abssf2"
5171 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5172 (abs:SF (match_operand:SF 1 "gpc_reg_operand" "")))]
5173 "TARGET_HARD_FLOAT && TARGET_SINGLE_FLOAT"
5174 "")
5175
5176 (define_insn "*abssf2"
5177 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5178 (abs:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
5179 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT"
5180 "fabs %0,%1"
5181 [(set_attr "type" "fp")])
5182
5183 (define_insn ""
5184 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5185 (neg:SF (abs:SF (match_operand:SF 1 "gpc_reg_operand" "f"))))]
5186 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT"
5187 "fnabs %0,%1"
5188 [(set_attr "type" "fp")])
5189
5190 (define_expand "addsf3"
5191 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5192 (plus:SF (match_operand:SF 1 "gpc_reg_operand" "")
5193 (match_operand:SF 2 "gpc_reg_operand" "")))]
5194 "TARGET_HARD_FLOAT && TARGET_SINGLE_FLOAT"
5195 "")
5196
5197 (define_insn ""
5198 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5199 (plus:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
5200 (match_operand:SF 2 "gpc_reg_operand" "f")))]
5201 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT"
5202 "fadds %0,%1,%2"
5203 [(set_attr "type" "fp")
5204 (set_attr "fp_type" "fp_addsub_s")])
5205
5206 (define_insn ""
5207 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5208 (plus:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
5209 (match_operand:SF 2 "gpc_reg_operand" "f")))]
5210 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS"
5211 "{fa|fadd} %0,%1,%2"
5212 [(set_attr "type" "fp")])
5213
5214 (define_expand "subsf3"
5215 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5216 (minus:SF (match_operand:SF 1 "gpc_reg_operand" "")
5217 (match_operand:SF 2 "gpc_reg_operand" "")))]
5218 "TARGET_HARD_FLOAT && TARGET_SINGLE_FLOAT"
5219 "")
5220
5221 (define_insn ""
5222 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5223 (minus:SF (match_operand:SF 1 "gpc_reg_operand" "f")
5224 (match_operand:SF 2 "gpc_reg_operand" "f")))]
5225 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT"
5226 "fsubs %0,%1,%2"
5227 [(set_attr "type" "fp")
5228 (set_attr "fp_type" "fp_addsub_s")])
5229
5230 (define_insn ""
5231 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5232 (minus:SF (match_operand:SF 1 "gpc_reg_operand" "f")
5233 (match_operand:SF 2 "gpc_reg_operand" "f")))]
5234 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS"
5235 "{fs|fsub} %0,%1,%2"
5236 [(set_attr "type" "fp")])
5237
5238 (define_expand "mulsf3"
5239 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5240 (mult:SF (match_operand:SF 1 "gpc_reg_operand" "")
5241 (match_operand:SF 2 "gpc_reg_operand" "")))]
5242 "TARGET_HARD_FLOAT && TARGET_SINGLE_FLOAT"
5243 "")
5244
5245 (define_insn ""
5246 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5247 (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
5248 (match_operand:SF 2 "gpc_reg_operand" "f")))]
5249 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT"
5250 "fmuls %0,%1,%2"
5251 [(set_attr "type" "fp")
5252 (set_attr "fp_type" "fp_mul_s")])
5253
5254 (define_insn ""
5255 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5256 (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
5257 (match_operand:SF 2 "gpc_reg_operand" "f")))]
5258 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS"
5259 "{fm|fmul} %0,%1,%2"
5260 [(set_attr "type" "dmul")])
5261
5262 (define_expand "divsf3"
5263 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5264 (div:SF (match_operand:SF 1 "gpc_reg_operand" "")
5265 (match_operand:SF 2 "gpc_reg_operand" "")))]
5266 "TARGET_HARD_FLOAT && TARGET_SINGLE_FLOAT && !TARGET_SIMPLE_FPU"
5267 "")
5268
5269 (define_insn ""
5270 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5271 (div:SF (match_operand:SF 1 "gpc_reg_operand" "f")
5272 (match_operand:SF 2 "gpc_reg_operand" "f")))]
5273 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS
5274 && TARGET_SINGLE_FLOAT && !TARGET_SIMPLE_FPU"
5275 "fdivs %0,%1,%2"
5276 [(set_attr "type" "sdiv")])
5277
5278 (define_insn ""
5279 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5280 (div:SF (match_operand:SF 1 "gpc_reg_operand" "f")
5281 (match_operand:SF 2 "gpc_reg_operand" "f")))]
5282 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS
5283 && TARGET_SINGLE_FLOAT && !TARGET_SIMPLE_FPU"
5284 "{fd|fdiv} %0,%1,%2"
5285 [(set_attr "type" "ddiv")])
5286
5287 (define_expand "recipsf3"
5288 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5289 (unspec:SF [(match_operand:SF 1 "gpc_reg_operand" "f")
5290 (match_operand:SF 2 "gpc_reg_operand" "f")]
5291 UNSPEC_FRES))]
5292 "TARGET_RECIP && TARGET_HARD_FLOAT && TARGET_PPC_GFXOPT && !optimize_size
5293 && flag_finite_math_only && !flag_trapping_math"
5294 {
5295 rs6000_emit_swdivsf (operands[0], operands[1], operands[2]);
5296 DONE;
5297 })
5298
5299 (define_insn "fres"
5300 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5301 (unspec:SF [(match_operand:SF 1 "gpc_reg_operand" "f")] UNSPEC_FRES))]
5302 "TARGET_PPC_GFXOPT && flag_finite_math_only"
5303 "fres %0,%1"
5304 [(set_attr "type" "fp")])
5305
5306 (define_insn ""
5307 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5308 (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
5309 (match_operand:SF 2 "gpc_reg_operand" "f"))
5310 (match_operand:SF 3 "gpc_reg_operand" "f")))]
5311 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS
5312 && TARGET_SINGLE_FLOAT && TARGET_FUSED_MADD"
5313 "fmadds %0,%1,%2,%3"
5314 [(set_attr "type" "fp")
5315 (set_attr "fp_type" "fp_maddsub_s")])
5316
5317 (define_insn ""
5318 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5319 (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
5320 (match_operand:SF 2 "gpc_reg_operand" "f"))
5321 (match_operand:SF 3 "gpc_reg_operand" "f")))]
5322 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD"
5323 "{fma|fmadd} %0,%1,%2,%3"
5324 [(set_attr "type" "dmul")])
5325
5326 (define_insn ""
5327 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5328 (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
5329 (match_operand:SF 2 "gpc_reg_operand" "f"))
5330 (match_operand:SF 3 "gpc_reg_operand" "f")))]
5331 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS
5332 && TARGET_SINGLE_FLOAT && TARGET_FUSED_MADD"
5333 "fmsubs %0,%1,%2,%3"
5334 [(set_attr "type" "fp")
5335 (set_attr "fp_type" "fp_maddsub_s")])
5336
5337 (define_insn ""
5338 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5339 (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
5340 (match_operand:SF 2 "gpc_reg_operand" "f"))
5341 (match_operand:SF 3 "gpc_reg_operand" "f")))]
5342 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD"
5343 "{fms|fmsub} %0,%1,%2,%3"
5344 [(set_attr "type" "dmul")])
5345
5346 (define_insn ""
5347 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5348 (neg:SF (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
5349 (match_operand:SF 2 "gpc_reg_operand" "f"))
5350 (match_operand:SF 3 "gpc_reg_operand" "f"))))]
5351 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
5352 && TARGET_SINGLE_FLOAT && HONOR_SIGNED_ZEROS (SFmode)"
5353 "fnmadds %0,%1,%2,%3"
5354 [(set_attr "type" "fp")
5355 (set_attr "fp_type" "fp_maddsub_s")])
5356
5357 (define_insn ""
5358 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5359 (minus:SF (mult:SF (neg:SF (match_operand:SF 1 "gpc_reg_operand" "f"))
5360 (match_operand:SF 2 "gpc_reg_operand" "f"))
5361 (match_operand:SF 3 "gpc_reg_operand" "f")))]
5362 "TARGET_POWERPC && TARGET_SINGLE_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
5363 && ! HONOR_SIGNED_ZEROS (SFmode)"
5364 "fnmadds %0,%1,%2,%3"
5365 [(set_attr "type" "fp")
5366 (set_attr "fp_type" "fp_maddsub_s")])
5367
5368 (define_insn ""
5369 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5370 (neg:SF (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
5371 (match_operand:SF 2 "gpc_reg_operand" "f"))
5372 (match_operand:SF 3 "gpc_reg_operand" "f"))))]
5373 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD"
5374 "{fnma|fnmadd} %0,%1,%2,%3"
5375 [(set_attr "type" "dmul")])
5376
5377 (define_insn ""
5378 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5379 (minus:SF (mult:SF (neg:SF (match_operand:SF 1 "gpc_reg_operand" "f"))
5380 (match_operand:SF 2 "gpc_reg_operand" "f"))
5381 (match_operand:SF 3 "gpc_reg_operand" "f")))]
5382 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
5383 && ! HONOR_SIGNED_ZEROS (SFmode)"
5384 "{fnma|fnmadd} %0,%1,%2,%3"
5385 [(set_attr "type" "dmul")])
5386
5387 (define_insn ""
5388 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5389 (neg:SF (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
5390 (match_operand:SF 2 "gpc_reg_operand" "f"))
5391 (match_operand:SF 3 "gpc_reg_operand" "f"))))]
5392 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
5393 && TARGET_SINGLE_FLOAT && HONOR_SIGNED_ZEROS (SFmode)"
5394 "fnmsubs %0,%1,%2,%3"
5395 [(set_attr "type" "fp")
5396 (set_attr "fp_type" "fp_maddsub_s")])
5397
5398 (define_insn ""
5399 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5400 (minus:SF (match_operand:SF 3 "gpc_reg_operand" "f")
5401 (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
5402 (match_operand:SF 2 "gpc_reg_operand" "f"))))]
5403 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
5404 && TARGET_SINGLE_FLOAT && ! HONOR_SIGNED_ZEROS (SFmode)"
5405 "fnmsubs %0,%1,%2,%3"
5406 [(set_attr "type" "fp")
5407 (set_attr "fp_type" "fp_maddsub_s")])
5408
5409 (define_insn ""
5410 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5411 (neg:SF (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
5412 (match_operand:SF 2 "gpc_reg_operand" "f"))
5413 (match_operand:SF 3 "gpc_reg_operand" "f"))))]
5414 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD"
5415 "{fnms|fnmsub} %0,%1,%2,%3"
5416 [(set_attr "type" "dmul")])
5417
5418 (define_insn ""
5419 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5420 (minus:SF (match_operand:SF 3 "gpc_reg_operand" "f")
5421 (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
5422 (match_operand:SF 2 "gpc_reg_operand" "f"))))]
5423 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
5424 && ! HONOR_SIGNED_ZEROS (SFmode)"
5425 "{fnms|fnmsub} %0,%1,%2,%3"
5426 [(set_attr "type" "dmul")])
5427
5428 (define_expand "sqrtsf2"
5429 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5430 (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "")))]
5431 "(TARGET_PPC_GPOPT || TARGET_POWER2 || TARGET_XILINX_FPU)
5432 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT
5433 && !TARGET_SIMPLE_FPU"
5434 "")
5435
5436 (define_insn ""
5437 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5438 (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
5439 "(TARGET_PPC_GPOPT || TARGET_XILINX_FPU) && TARGET_HARD_FLOAT
5440 && TARGET_FPRS && TARGET_SINGLE_FLOAT && !TARGET_SIMPLE_FPU"
5441 "fsqrts %0,%1"
5442 [(set_attr "type" "ssqrt")])
5443
5444 (define_insn ""
5445 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5446 (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
5447 "TARGET_POWER2 && TARGET_HARD_FLOAT && TARGET_FPRS
5448 && TARGET_SINGLE_FLOAT && !TARGET_SIMPLE_FPU"
5449 "fsqrt %0,%1"
5450 [(set_attr "type" "dsqrt")])
5451
5452 (define_expand "rsqrtsf2"
5453 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5454 (unspec:SF [(match_operand:SF 1 "gpc_reg_operand" "f")]
5455 UNSPEC_RSQRT))]
5456 "TARGET_RECIP && TARGET_HARD_FLOAT && TARGET_PPC_GFXOPT && !optimize_size
5457 && flag_finite_math_only && !flag_trapping_math"
5458 {
5459 rs6000_emit_swrsqrtsf (operands[0], operands[1]);
5460 DONE;
5461 })
5462
5463 (define_insn "*rsqrt_internal1"
5464 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5465 (unspec:SF [(match_operand:SF 1 "gpc_reg_operand" "f")]
5466 UNSPEC_RSQRT))]
5467 "TARGET_HARD_FLOAT && TARGET_PPC_GFXOPT"
5468 "frsqrte %0,%1"
5469 [(set_attr "type" "fp")])
5470
5471 (define_expand "copysignsf3"
5472 [(set (match_dup 3)
5473 (abs:SF (match_operand:SF 1 "gpc_reg_operand" "")))
5474 (set (match_dup 4)
5475 (neg:SF (abs:SF (match_dup 1))))
5476 (set (match_operand:SF 0 "gpc_reg_operand" "")
5477 (if_then_else:SF (ge (match_operand:SF 2 "gpc_reg_operand" "")
5478 (match_dup 5))
5479 (match_dup 3)
5480 (match_dup 4)))]
5481 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT
5482 && !HONOR_NANS (SFmode) && !HONOR_SIGNED_ZEROS (SFmode)"
5483 {
5484 operands[3] = gen_reg_rtx (SFmode);
5485 operands[4] = gen_reg_rtx (SFmode);
5486 operands[5] = CONST0_RTX (SFmode);
5487 })
5488
5489 (define_expand "copysigndf3"
5490 [(set (match_dup 3)
5491 (abs:DF (match_operand:DF 1 "gpc_reg_operand" "")))
5492 (set (match_dup 4)
5493 (neg:DF (abs:DF (match_dup 1))))
5494 (set (match_operand:DF 0 "gpc_reg_operand" "")
5495 (if_then_else:DF (ge (match_operand:DF 2 "gpc_reg_operand" "")
5496 (match_dup 5))
5497 (match_dup 3)
5498 (match_dup 4)))]
5499 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT
5500 && !HONOR_NANS (DFmode) && !HONOR_SIGNED_ZEROS (DFmode)"
5501 {
5502 operands[3] = gen_reg_rtx (DFmode);
5503 operands[4] = gen_reg_rtx (DFmode);
5504 operands[5] = CONST0_RTX (DFmode);
5505 })
5506
5507 ;; For MIN, MAX, and conditional move, we use DEFINE_EXPAND's that involve a
5508 ;; fsel instruction and some auxiliary computations. Then we just have a
5509 ;; single DEFINE_INSN for fsel and the define_splits to make them if made by
5510 ;; combine.
5511 (define_expand "smaxsf3"
5512 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5513 (if_then_else:SF (ge (match_operand:SF 1 "gpc_reg_operand" "")
5514 (match_operand:SF 2 "gpc_reg_operand" ""))
5515 (match_dup 1)
5516 (match_dup 2)))]
5517 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS
5518 && TARGET_SINGLE_FLOAT && !flag_trapping_math"
5519 "{ rs6000_emit_minmax (operands[0], SMAX, operands[1], operands[2]); DONE;}")
5520
5521 (define_expand "sminsf3"
5522 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5523 (if_then_else:SF (ge (match_operand:SF 1 "gpc_reg_operand" "")
5524 (match_operand:SF 2 "gpc_reg_operand" ""))
5525 (match_dup 2)
5526 (match_dup 1)))]
5527 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS
5528 && TARGET_SINGLE_FLOAT && !flag_trapping_math"
5529 "{ rs6000_emit_minmax (operands[0], SMIN, operands[1], operands[2]); DONE;}")
5530
5531 (define_split
5532 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5533 (match_operator:SF 3 "min_max_operator"
5534 [(match_operand:SF 1 "gpc_reg_operand" "")
5535 (match_operand:SF 2 "gpc_reg_operand" "")]))]
5536 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS
5537 && TARGET_SINGLE_FLOAT && !flag_trapping_math"
5538 [(const_int 0)]
5539 "
5540 { rs6000_emit_minmax (operands[0], GET_CODE (operands[3]),
5541 operands[1], operands[2]);
5542 DONE;
5543 }")
5544
5545 (define_expand "movsicc"
5546 [(set (match_operand:SI 0 "gpc_reg_operand" "")
5547 (if_then_else:SI (match_operand 1 "comparison_operator" "")
5548 (match_operand:SI 2 "gpc_reg_operand" "")
5549 (match_operand:SI 3 "gpc_reg_operand" "")))]
5550 "TARGET_ISEL"
5551 "
5552 {
5553 if (rs6000_emit_cmove (operands[0], operands[1], operands[2], operands[3]))
5554 DONE;
5555 else
5556 FAIL;
5557 }")
5558
5559 ;; We use the BASE_REGS for the isel input operands because, if rA is
5560 ;; 0, the value of 0 is placed in rD upon truth. Similarly for rB
5561 ;; because we may switch the operands and rB may end up being rA.
5562 ;;
5563 ;; We need 2 patterns: an unsigned and a signed pattern. We could
5564 ;; leave out the mode in operand 4 and use one pattern, but reload can
5565 ;; change the mode underneath our feet and then gets confused trying
5566 ;; to reload the value.
5567 (define_insn "isel_signed"
5568 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
5569 (if_then_else:SI
5570 (match_operator 1 "comparison_operator"
5571 [(match_operand:CC 4 "cc_reg_operand" "y")
5572 (const_int 0)])
5573 (match_operand:SI 2 "gpc_reg_operand" "b")
5574 (match_operand:SI 3 "gpc_reg_operand" "b")))]
5575 "TARGET_ISEL"
5576 "*
5577 { return output_isel (operands); }"
5578 [(set_attr "length" "4")])
5579
5580 (define_insn "isel_unsigned"
5581 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
5582 (if_then_else:SI
5583 (match_operator 1 "comparison_operator"
5584 [(match_operand:CCUNS 4 "cc_reg_operand" "y")
5585 (const_int 0)])
5586 (match_operand:SI 2 "gpc_reg_operand" "b")
5587 (match_operand:SI 3 "gpc_reg_operand" "b")))]
5588 "TARGET_ISEL"
5589 "*
5590 { return output_isel (operands); }"
5591 [(set_attr "length" "4")])
5592
5593 (define_expand "movsfcc"
5594 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5595 (if_then_else:SF (match_operand 1 "comparison_operator" "")
5596 (match_operand:SF 2 "gpc_reg_operand" "")
5597 (match_operand:SF 3 "gpc_reg_operand" "")))]
5598 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT"
5599 "
5600 {
5601 if (rs6000_emit_cmove (operands[0], operands[1], operands[2], operands[3]))
5602 DONE;
5603 else
5604 FAIL;
5605 }")
5606
5607 (define_insn "*fselsfsf4"
5608 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5609 (if_then_else:SF (ge (match_operand:SF 1 "gpc_reg_operand" "f")
5610 (match_operand:SF 4 "zero_fp_constant" "F"))
5611 (match_operand:SF 2 "gpc_reg_operand" "f")
5612 (match_operand:SF 3 "gpc_reg_operand" "f")))]
5613 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT"
5614 "fsel %0,%1,%2,%3"
5615 [(set_attr "type" "fp")])
5616
5617 (define_insn "*fseldfsf4"
5618 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5619 (if_then_else:SF (ge (match_operand:DF 1 "gpc_reg_operand" "f")
5620 (match_operand:DF 4 "zero_fp_constant" "F"))
5621 (match_operand:SF 2 "gpc_reg_operand" "f")
5622 (match_operand:SF 3 "gpc_reg_operand" "f")))]
5623 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT && TARGET_SINGLE_FLOAT"
5624 "fsel %0,%1,%2,%3"
5625 [(set_attr "type" "fp")])
5626
5627 (define_expand "negdf2"
5628 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5629 (neg:DF (match_operand:DF 1 "gpc_reg_operand" "")))]
5630 "TARGET_HARD_FLOAT && ((TARGET_FPRS && TARGET_DOUBLE_FLOAT) || TARGET_E500_DOUBLE)"
5631 "")
5632
5633 (define_insn "*negdf2_fpr"
5634 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5635 (neg:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
5636 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
5637 "fneg %0,%1"
5638 [(set_attr "type" "fp")])
5639
5640 (define_expand "absdf2"
5641 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5642 (abs:DF (match_operand:DF 1 "gpc_reg_operand" "")))]
5643 "TARGET_HARD_FLOAT && ((TARGET_FPRS && TARGET_DOUBLE_FLOAT) || TARGET_E500_DOUBLE)"
5644 "")
5645
5646 (define_insn "*absdf2_fpr"
5647 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5648 (abs:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
5649 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
5650 "fabs %0,%1"
5651 [(set_attr "type" "fp")])
5652
5653 (define_insn "*nabsdf2_fpr"
5654 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5655 (neg:DF (abs:DF (match_operand:DF 1 "gpc_reg_operand" "f"))))]
5656 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
5657 "fnabs %0,%1"
5658 [(set_attr "type" "fp")])
5659
5660 (define_expand "adddf3"
5661 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5662 (plus:DF (match_operand:DF 1 "gpc_reg_operand" "")
5663 (match_operand:DF 2 "gpc_reg_operand" "")))]
5664 "TARGET_HARD_FLOAT && ((TARGET_FPRS && TARGET_DOUBLE_FLOAT) || TARGET_E500_DOUBLE)"
5665 "")
5666
5667 (define_insn "*adddf3_fpr"
5668 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5669 (plus:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
5670 (match_operand:DF 2 "gpc_reg_operand" "f")))]
5671 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
5672 "{fa|fadd} %0,%1,%2"
5673 [(set_attr "type" "fp")
5674 (set_attr "fp_type" "fp_addsub_d")])
5675
5676 (define_expand "subdf3"
5677 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5678 (minus:DF (match_operand:DF 1 "gpc_reg_operand" "")
5679 (match_operand:DF 2 "gpc_reg_operand" "")))]
5680 "TARGET_HARD_FLOAT && ((TARGET_FPRS && TARGET_DOUBLE_FLOAT) || TARGET_E500_DOUBLE)"
5681 "")
5682
5683 (define_insn "*subdf3_fpr"
5684 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5685 (minus:DF (match_operand:DF 1 "gpc_reg_operand" "f")
5686 (match_operand:DF 2 "gpc_reg_operand" "f")))]
5687 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
5688 "{fs|fsub} %0,%1,%2"
5689 [(set_attr "type" "fp")
5690 (set_attr "fp_type" "fp_addsub_d")])
5691
5692 (define_expand "muldf3"
5693 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5694 (mult:DF (match_operand:DF 1 "gpc_reg_operand" "")
5695 (match_operand:DF 2 "gpc_reg_operand" "")))]
5696 "TARGET_HARD_FLOAT && ((TARGET_FPRS && TARGET_DOUBLE_FLOAT) || TARGET_E500_DOUBLE)"
5697 "")
5698
5699 (define_insn "*muldf3_fpr"
5700 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5701 (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
5702 (match_operand:DF 2 "gpc_reg_operand" "f")))]
5703 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
5704 "{fm|fmul} %0,%1,%2"
5705 [(set_attr "type" "dmul")
5706 (set_attr "fp_type" "fp_mul_d")])
5707
5708 (define_expand "divdf3"
5709 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5710 (div:DF (match_operand:DF 1 "gpc_reg_operand" "")
5711 (match_operand:DF 2 "gpc_reg_operand" "")))]
5712 "TARGET_HARD_FLOAT
5713 && ((TARGET_FPRS && TARGET_DOUBLE_FLOAT) || TARGET_E500_DOUBLE)
5714 && !TARGET_SIMPLE_FPU"
5715 "")
5716
5717 (define_insn "*divdf3_fpr"
5718 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5719 (div:DF (match_operand:DF 1 "gpc_reg_operand" "f")
5720 (match_operand:DF 2 "gpc_reg_operand" "f")))]
5721 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT && !TARGET_SIMPLE_FPU"
5722 "{fd|fdiv} %0,%1,%2"
5723 [(set_attr "type" "ddiv")])
5724
5725 (define_expand "recipdf3"
5726 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5727 (unspec:DF [(match_operand:DF 1 "gpc_reg_operand" "f")
5728 (match_operand:DF 2 "gpc_reg_operand" "f")]
5729 UNSPEC_FRES))]
5730 "TARGET_RECIP && TARGET_HARD_FLOAT && TARGET_POPCNTB && !optimize_size
5731 && flag_finite_math_only && !flag_trapping_math"
5732 {
5733 rs6000_emit_swdivdf (operands[0], operands[1], operands[2]);
5734 DONE;
5735 })
5736
5737 (define_insn "fred"
5738 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5739 (unspec:DF [(match_operand:DF 1 "gpc_reg_operand" "f")] UNSPEC_FRES))]
5740 "TARGET_POPCNTB && flag_finite_math_only"
5741 "fre %0,%1"
5742 [(set_attr "type" "fp")])
5743
5744 (define_insn ""
5745 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5746 (plus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
5747 (match_operand:DF 2 "gpc_reg_operand" "f"))
5748 (match_operand:DF 3 "gpc_reg_operand" "f")))]
5749 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD && TARGET_DOUBLE_FLOAT"
5750 "{fma|fmadd} %0,%1,%2,%3"
5751 [(set_attr "type" "dmul")
5752 (set_attr "fp_type" "fp_maddsub_d")])
5753
5754 (define_insn ""
5755 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5756 (minus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
5757 (match_operand:DF 2 "gpc_reg_operand" "f"))
5758 (match_operand:DF 3 "gpc_reg_operand" "f")))]
5759 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD && TARGET_DOUBLE_FLOAT"
5760 "{fms|fmsub} %0,%1,%2,%3"
5761 [(set_attr "type" "dmul")
5762 (set_attr "fp_type" "fp_maddsub_d")])
5763
5764 (define_insn ""
5765 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5766 (neg:DF (plus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
5767 (match_operand:DF 2 "gpc_reg_operand" "f"))
5768 (match_operand:DF 3 "gpc_reg_operand" "f"))))]
5769 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD && TARGET_DOUBLE_FLOAT
5770 && HONOR_SIGNED_ZEROS (DFmode)"
5771 "{fnma|fnmadd} %0,%1,%2,%3"
5772 [(set_attr "type" "dmul")
5773 (set_attr "fp_type" "fp_maddsub_d")])
5774
5775 (define_insn ""
5776 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5777 (minus:DF (mult:DF (neg:DF (match_operand:DF 1 "gpc_reg_operand" "f"))
5778 (match_operand:DF 2 "gpc_reg_operand" "f"))
5779 (match_operand:DF 3 "gpc_reg_operand" "f")))]
5780 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD && TARGET_DOUBLE_FLOAT
5781 && ! HONOR_SIGNED_ZEROS (DFmode)"
5782 "{fnma|fnmadd} %0,%1,%2,%3"
5783 [(set_attr "type" "dmul")
5784 (set_attr "fp_type" "fp_maddsub_d")])
5785
5786 (define_insn ""
5787 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5788 (neg:DF (minus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
5789 (match_operand:DF 2 "gpc_reg_operand" "f"))
5790 (match_operand:DF 3 "gpc_reg_operand" "f"))))]
5791 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD && TARGET_DOUBLE_FLOAT
5792 && HONOR_SIGNED_ZEROS (DFmode)"
5793 "{fnms|fnmsub} %0,%1,%2,%3"
5794 [(set_attr "type" "dmul")
5795 (set_attr "fp_type" "fp_maddsub_d")])
5796
5797 (define_insn ""
5798 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5799 (minus:DF (match_operand:DF 3 "gpc_reg_operand" "f")
5800 (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
5801 (match_operand:DF 2 "gpc_reg_operand" "f"))))]
5802 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD && TARGET_DOUBLE_FLOAT
5803 && ! HONOR_SIGNED_ZEROS (DFmode)"
5804 "{fnms|fnmsub} %0,%1,%2,%3"
5805 [(set_attr "type" "dmul")
5806 (set_attr "fp_type" "fp_maddsub_d")])
5807
5808 (define_insn "sqrtdf2"
5809 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5810 (sqrt:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
5811 "(TARGET_PPC_GPOPT || TARGET_POWER2) && TARGET_HARD_FLOAT && TARGET_FPRS
5812 && TARGET_DOUBLE_FLOAT"
5813 "fsqrt %0,%1"
5814 [(set_attr "type" "dsqrt")])
5815
5816 ;; The conditional move instructions allow us to perform max and min
5817 ;; operations even when
5818
5819 (define_expand "smaxdf3"
5820 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5821 (if_then_else:DF (ge (match_operand:DF 1 "gpc_reg_operand" "")
5822 (match_operand:DF 2 "gpc_reg_operand" ""))
5823 (match_dup 1)
5824 (match_dup 2)))]
5825 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT
5826 && !flag_trapping_math"
5827 "{ rs6000_emit_minmax (operands[0], SMAX, operands[1], operands[2]); DONE;}")
5828
5829 (define_expand "smindf3"
5830 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5831 (if_then_else:DF (ge (match_operand:DF 1 "gpc_reg_operand" "")
5832 (match_operand:DF 2 "gpc_reg_operand" ""))
5833 (match_dup 2)
5834 (match_dup 1)))]
5835 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT
5836 && !flag_trapping_math"
5837 "{ rs6000_emit_minmax (operands[0], SMIN, operands[1], operands[2]); DONE;}")
5838
5839 (define_split
5840 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5841 (match_operator:DF 3 "min_max_operator"
5842 [(match_operand:DF 1 "gpc_reg_operand" "")
5843 (match_operand:DF 2 "gpc_reg_operand" "")]))]
5844 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT
5845 && !flag_trapping_math"
5846 [(const_int 0)]
5847 "
5848 { rs6000_emit_minmax (operands[0], GET_CODE (operands[3]),
5849 operands[1], operands[2]);
5850 DONE;
5851 }")
5852
5853 (define_expand "movdfcc"
5854 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5855 (if_then_else:DF (match_operand 1 "comparison_operator" "")
5856 (match_operand:DF 2 "gpc_reg_operand" "")
5857 (match_operand:DF 3 "gpc_reg_operand" "")))]
5858 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
5859 "
5860 {
5861 if (rs6000_emit_cmove (operands[0], operands[1], operands[2], operands[3]))
5862 DONE;
5863 else
5864 FAIL;
5865 }")
5866
5867 (define_insn "*fseldfdf4"
5868 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5869 (if_then_else:DF (ge (match_operand:DF 1 "gpc_reg_operand" "f")
5870 (match_operand:DF 4 "zero_fp_constant" "F"))
5871 (match_operand:DF 2 "gpc_reg_operand" "f")
5872 (match_operand:DF 3 "gpc_reg_operand" "f")))]
5873 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
5874 "fsel %0,%1,%2,%3"
5875 [(set_attr "type" "fp")])
5876
5877 (define_insn "*fselsfdf4"
5878 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5879 (if_then_else:DF (ge (match_operand:SF 1 "gpc_reg_operand" "f")
5880 (match_operand:SF 4 "zero_fp_constant" "F"))
5881 (match_operand:DF 2 "gpc_reg_operand" "f")
5882 (match_operand:DF 3 "gpc_reg_operand" "f")))]
5883 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT && TARGET_SINGLE_FLOAT"
5884 "fsel %0,%1,%2,%3"
5885 [(set_attr "type" "fp")])
5886 \f
5887 ;; Conversions to and from floating-point.
5888
5889 (define_expand "fixuns_truncsfsi2"
5890 [(set (match_operand:SI 0 "gpc_reg_operand" "")
5891 (unsigned_fix:SI (match_operand:SF 1 "gpc_reg_operand" "")))]
5892 "TARGET_HARD_FLOAT && !TARGET_FPRS && TARGET_SINGLE_FLOAT"
5893 "")
5894
5895 (define_expand "fix_truncsfsi2"
5896 [(set (match_operand:SI 0 "gpc_reg_operand" "")
5897 (fix:SI (match_operand:SF 1 "gpc_reg_operand" "")))]
5898 "TARGET_HARD_FLOAT && !TARGET_FPRS && TARGET_SINGLE_FLOAT"
5899 "")
5900
5901 ; For each of these conversions, there is a define_expand, a define_insn
5902 ; with a '#' template, and a define_split (with C code). The idea is
5903 ; to allow constant folding with the template of the define_insn,
5904 ; then to have the insns split later (between sched1 and final).
5905
5906 (define_expand "floatsidf2"
5907 [(parallel [(set (match_operand:DF 0 "gpc_reg_operand" "")
5908 (float:DF (match_operand:SI 1 "gpc_reg_operand" "")))
5909 (use (match_dup 2))
5910 (use (match_dup 3))
5911 (clobber (match_dup 4))
5912 (clobber (match_dup 5))
5913 (clobber (match_dup 6))])]
5914 "TARGET_HARD_FLOAT
5915 && ((TARGET_FPRS && TARGET_DOUBLE_FLOAT) || TARGET_E500_DOUBLE)"
5916 "
5917 {
5918 if (TARGET_E500_DOUBLE)
5919 {
5920 emit_insn (gen_spe_floatsidf2 (operands[0], operands[1]));
5921 DONE;
5922 }
5923 if (TARGET_POWERPC64)
5924 {
5925 rtx x = convert_to_mode (DImode, operands[1], 0);
5926 emit_insn (gen_floatdidf2 (operands[0], x));
5927 DONE;
5928 }
5929
5930 operands[2] = force_reg (SImode, GEN_INT (0x43300000));
5931 operands[3] = force_reg (DFmode, CONST_DOUBLE_ATOF (\"4503601774854144\", DFmode));
5932 operands[4] = assign_stack_temp (DFmode, GET_MODE_SIZE (DFmode), 0);
5933 operands[5] = gen_reg_rtx (DFmode);
5934 operands[6] = gen_reg_rtx (SImode);
5935 }")
5936
5937 (define_insn_and_split "*floatsidf2_internal"
5938 [(set (match_operand:DF 0 "gpc_reg_operand" "=&f")
5939 (float:DF (match_operand:SI 1 "gpc_reg_operand" "r")))
5940 (use (match_operand:SI 2 "gpc_reg_operand" "r"))
5941 (use (match_operand:DF 3 "gpc_reg_operand" "f"))
5942 (clobber (match_operand:DF 4 "offsettable_mem_operand" "=o"))
5943 (clobber (match_operand:DF 5 "gpc_reg_operand" "=&f"))
5944 (clobber (match_operand:SI 6 "gpc_reg_operand" "=&r"))]
5945 "! TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
5946 "#"
5947 "&& (can_create_pseudo_p () || offsettable_nonstrict_memref_p (operands[4]))"
5948 [(pc)]
5949 "
5950 {
5951 rtx lowword, highword;
5952 gcc_assert (MEM_P (operands[4]));
5953 highword = adjust_address (operands[4], SImode, 0);
5954 lowword = adjust_address (operands[4], SImode, 4);
5955 if (! WORDS_BIG_ENDIAN)
5956 {
5957 rtx tmp;
5958 tmp = highword; highword = lowword; lowword = tmp;
5959 }
5960
5961 emit_insn (gen_xorsi3 (operands[6], operands[1],
5962 GEN_INT (~ (HOST_WIDE_INT) 0x7fffffff)));
5963 emit_move_insn (lowword, operands[6]);
5964 emit_move_insn (highword, operands[2]);
5965 emit_move_insn (operands[5], operands[4]);
5966 emit_insn (gen_subdf3 (operands[0], operands[5], operands[3]));
5967 DONE;
5968 }"
5969 [(set_attr "length" "24")])
5970
5971 (define_expand "floatunssisf2"
5972 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5973 (unsigned_float:SF (match_operand:SI 1 "gpc_reg_operand" "")))]
5974 "TARGET_HARD_FLOAT && !TARGET_FPRS && TARGET_SINGLE_FLOAT"
5975 "")
5976
5977 (define_expand "floatunssidf2"
5978 [(parallel [(set (match_operand:DF 0 "gpc_reg_operand" "")
5979 (unsigned_float:DF (match_operand:SI 1 "gpc_reg_operand" "")))
5980 (use (match_dup 2))
5981 (use (match_dup 3))
5982 (clobber (match_dup 4))
5983 (clobber (match_dup 5))])]
5984 "TARGET_HARD_FLOAT && ((TARGET_FPRS && TARGET_DOUBLE_FLOAT) || TARGET_E500_DOUBLE)"
5985 "
5986 {
5987 if (TARGET_E500_DOUBLE)
5988 {
5989 emit_insn (gen_spe_floatunssidf2 (operands[0], operands[1]));
5990 DONE;
5991 }
5992 if (TARGET_POWERPC64)
5993 {
5994 rtx x = convert_to_mode (DImode, operands[1], 1);
5995 emit_insn (gen_floatdidf2 (operands[0], x));
5996 DONE;
5997 }
5998
5999 operands[2] = force_reg (SImode, GEN_INT (0x43300000));
6000 operands[3] = force_reg (DFmode, CONST_DOUBLE_ATOF (\"4503599627370496\", DFmode));
6001 operands[4] = assign_stack_temp (DFmode, GET_MODE_SIZE (DFmode), 0);
6002 operands[5] = gen_reg_rtx (DFmode);
6003 }")
6004
6005 (define_insn_and_split "*floatunssidf2_internal"
6006 [(set (match_operand:DF 0 "gpc_reg_operand" "=&f")
6007 (unsigned_float:DF (match_operand:SI 1 "gpc_reg_operand" "r")))
6008 (use (match_operand:SI 2 "gpc_reg_operand" "r"))
6009 (use (match_operand:DF 3 "gpc_reg_operand" "f"))
6010 (clobber (match_operand:DF 4 "offsettable_mem_operand" "=o"))
6011 (clobber (match_operand:DF 5 "gpc_reg_operand" "=&f"))]
6012 "! TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
6013 "#"
6014 "&& (can_create_pseudo_p () || offsettable_nonstrict_memref_p (operands[4]))"
6015 [(pc)]
6016 "
6017 {
6018 rtx lowword, highword;
6019 gcc_assert (MEM_P (operands[4]));
6020 highword = adjust_address (operands[4], SImode, 0);
6021 lowword = adjust_address (operands[4], SImode, 4);
6022 if (! WORDS_BIG_ENDIAN)
6023 {
6024 rtx tmp;
6025 tmp = highword; highword = lowword; lowword = tmp;
6026 }
6027
6028 emit_move_insn (lowword, operands[1]);
6029 emit_move_insn (highword, operands[2]);
6030 emit_move_insn (operands[5], operands[4]);
6031 emit_insn (gen_subdf3 (operands[0], operands[5], operands[3]));
6032 DONE;
6033 }"
6034 [(set_attr "length" "20")])
6035
6036 (define_expand "fix_truncdfsi2"
6037 [(parallel [(set (match_operand:SI 0 "fix_trunc_dest_operand" "")
6038 (fix:SI (match_operand:DF 1 "gpc_reg_operand" "")))
6039 (clobber (match_dup 2))
6040 (clobber (match_dup 3))])]
6041 "(TARGET_POWER2 || TARGET_POWERPC)
6042 && TARGET_HARD_FLOAT && ((TARGET_FPRS && TARGET_DOUBLE_FLOAT) || TARGET_E500_DOUBLE)"
6043 "
6044 {
6045 if (TARGET_E500_DOUBLE)
6046 {
6047 emit_insn (gen_spe_fix_truncdfsi2 (operands[0], operands[1]));
6048 DONE;
6049 }
6050 operands[2] = gen_reg_rtx (DImode);
6051 if (TARGET_POWERPC64 && TARGET_MFPGPR && TARGET_HARD_FLOAT && TARGET_FPRS
6052 && gpc_reg_operand(operands[0], GET_MODE (operands[0])))
6053 {
6054 operands[3] = gen_reg_rtx (DImode);
6055 emit_insn (gen_fix_truncdfsi2_mfpgpr (operands[0], operands[1],
6056 operands[2], operands[3]));
6057 DONE;
6058 }
6059 if (TARGET_PPC_GFXOPT)
6060 {
6061 rtx orig_dest = operands[0];
6062 if (! memory_operand (orig_dest, GET_MODE (orig_dest)))
6063 operands[0] = assign_stack_temp (SImode, GET_MODE_SIZE (SImode), 0);
6064 emit_insn (gen_fix_truncdfsi2_internal_gfxopt (operands[0], operands[1],
6065 operands[2]));
6066 if (operands[0] != orig_dest)
6067 emit_move_insn (orig_dest, operands[0]);
6068 DONE;
6069 }
6070 operands[3] = assign_stack_temp (DImode, GET_MODE_SIZE (DImode), 0);
6071 }")
6072
6073 (define_insn_and_split "*fix_truncdfsi2_internal"
6074 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
6075 (fix:SI (match_operand:DF 1 "gpc_reg_operand" "f")))
6076 (clobber (match_operand:DI 2 "gpc_reg_operand" "=f"))
6077 (clobber (match_operand:DI 3 "offsettable_mem_operand" "=o"))]
6078 "(TARGET_POWER2 || TARGET_POWERPC) && TARGET_HARD_FLOAT && TARGET_FPRS
6079 && TARGET_DOUBLE_FLOAT"
6080 "#"
6081 "&& (can_create_pseudo_p () || offsettable_nonstrict_memref_p (operands[3]))"
6082 [(pc)]
6083 "
6084 {
6085 rtx lowword;
6086 gcc_assert (MEM_P (operands[3]));
6087 lowword = adjust_address (operands[3], SImode, WORDS_BIG_ENDIAN ? 4 : 0);
6088
6089 emit_insn (gen_fctiwz (operands[2], operands[1]));
6090 emit_move_insn (operands[3], operands[2]);
6091 emit_move_insn (operands[0], lowword);
6092 DONE;
6093 }"
6094 [(set_attr "length" "16")])
6095
6096 (define_insn_and_split "fix_truncdfsi2_internal_gfxopt"
6097 [(set (match_operand:SI 0 "memory_operand" "=Z")
6098 (fix:SI (match_operand:DF 1 "gpc_reg_operand" "f")))
6099 (clobber (match_operand:DI 2 "gpc_reg_operand" "=f"))]
6100 "(TARGET_POWER2 || TARGET_POWERPC) && TARGET_HARD_FLOAT && TARGET_FPRS
6101 && TARGET_DOUBLE_FLOAT
6102 && TARGET_PPC_GFXOPT"
6103 "#"
6104 "&& 1"
6105 [(pc)]
6106 "
6107 {
6108 emit_insn (gen_fctiwz (operands[2], operands[1]));
6109 emit_insn (gen_stfiwx (operands[0], operands[2]));
6110 DONE;
6111 }"
6112 [(set_attr "length" "16")])
6113
6114 (define_insn_and_split "fix_truncdfsi2_mfpgpr"
6115 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
6116 (fix:SI (match_operand:DF 1 "gpc_reg_operand" "f")))
6117 (clobber (match_operand:DI 2 "gpc_reg_operand" "=f"))
6118 (clobber (match_operand:DI 3 "gpc_reg_operand" "=r"))]
6119 "TARGET_POWERPC64 && TARGET_MFPGPR && TARGET_HARD_FLOAT && TARGET_FPRS
6120 && TARGET_DOUBLE_FLOAT"
6121 "#"
6122 "&& 1"
6123 [(set (match_dup 2) (unspec:DI [(fix:SI (match_dup 1))] UNSPEC_FCTIWZ))
6124 (set (match_dup 3) (match_dup 2))
6125 (set (match_dup 0) (subreg:SI (match_dup 3) 4))]
6126 ""
6127 [(set_attr "length" "12")])
6128
6129 ; Here, we use (set (reg) (unspec:DI [(fix:SI ...)] UNSPEC_FCTIWZ))
6130 ; rather than (set (subreg:SI (reg)) (fix:SI ...))
6131 ; because the first makes it clear that operand 0 is not live
6132 ; before the instruction.
6133 (define_insn "fctiwz"
6134 [(set (match_operand:DI 0 "gpc_reg_operand" "=f")
6135 (unspec:DI [(fix:SI (match_operand:DF 1 "gpc_reg_operand" "f"))]
6136 UNSPEC_FCTIWZ))]
6137 "(TARGET_POWER2 || TARGET_POWERPC) && TARGET_HARD_FLOAT && TARGET_FPRS
6138 && TARGET_DOUBLE_FLOAT"
6139 "{fcirz|fctiwz} %0,%1"
6140 [(set_attr "type" "fp")])
6141
6142 (define_insn "btruncdf2"
6143 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
6144 (unspec:DF [(match_operand:DF 1 "gpc_reg_operand" "f")] UNSPEC_FRIZ))]
6145 "TARGET_FPRND && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
6146 "friz %0,%1"
6147 [(set_attr "type" "fp")])
6148
6149 (define_insn "btruncsf2"
6150 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
6151 (unspec:SF [(match_operand:SF 1 "gpc_reg_operand" "f")] UNSPEC_FRIZ))]
6152 "TARGET_FPRND && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT "
6153 "friz %0,%1"
6154 [(set_attr "type" "fp")])
6155
6156 (define_insn "ceildf2"
6157 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
6158 (unspec:DF [(match_operand:DF 1 "gpc_reg_operand" "f")] UNSPEC_FRIP))]
6159 "TARGET_FPRND && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
6160 "frip %0,%1"
6161 [(set_attr "type" "fp")])
6162
6163 (define_insn "ceilsf2"
6164 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
6165 (unspec:SF [(match_operand:SF 1 "gpc_reg_operand" "f")] UNSPEC_FRIP))]
6166 "TARGET_FPRND && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT "
6167 "frip %0,%1"
6168 [(set_attr "type" "fp")])
6169
6170 (define_insn "floordf2"
6171 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
6172 (unspec:DF [(match_operand:DF 1 "gpc_reg_operand" "f")] UNSPEC_FRIM))]
6173 "TARGET_FPRND && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
6174 "frim %0,%1"
6175 [(set_attr "type" "fp")])
6176
6177 (define_insn "floorsf2"
6178 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
6179 (unspec:SF [(match_operand:SF 1 "gpc_reg_operand" "f")] UNSPEC_FRIM))]
6180 "TARGET_FPRND && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT "
6181 "frim %0,%1"
6182 [(set_attr "type" "fp")])
6183
6184 (define_insn "rounddf2"
6185 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
6186 (unspec:DF [(match_operand:DF 1 "gpc_reg_operand" "f")] UNSPEC_FRIN))]
6187 "TARGET_FPRND && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
6188 "frin %0,%1"
6189 [(set_attr "type" "fp")])
6190
6191 (define_insn "roundsf2"
6192 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
6193 (unspec:SF [(match_operand:SF 1 "gpc_reg_operand" "f")] UNSPEC_FRIN))]
6194 "TARGET_FPRND && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT "
6195 "frin %0,%1"
6196 [(set_attr "type" "fp")])
6197
6198 ; An UNSPEC is used so we don't have to support SImode in FP registers.
6199 (define_insn "stfiwx"
6200 [(set (match_operand:SI 0 "memory_operand" "=Z")
6201 (unspec:SI [(match_operand:DI 1 "gpc_reg_operand" "f")]
6202 UNSPEC_STFIWX))]
6203 "TARGET_PPC_GFXOPT"
6204 "stfiwx %1,%y0"
6205 [(set_attr "type" "fpstore")])
6206
6207 (define_expand "floatsisf2"
6208 [(set (match_operand:SF 0 "gpc_reg_operand" "")
6209 (float:SF (match_operand:SI 1 "gpc_reg_operand" "")))]
6210 "TARGET_HARD_FLOAT && !TARGET_FPRS"
6211 "")
6212
6213 (define_insn "floatdidf2"
6214 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
6215 (float:DF (match_operand:DI 1 "gpc_reg_operand" "!f#r")))]
6216 "(TARGET_POWERPC64 || TARGET_XILINX_FPU) && TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT && TARGET_FPRS"
6217 "fcfid %0,%1"
6218 [(set_attr "type" "fp")])
6219
6220 (define_insn "fix_truncdfdi2"
6221 [(set (match_operand:DI 0 "gpc_reg_operand" "=!f#r")
6222 (fix:DI (match_operand:DF 1 "gpc_reg_operand" "f")))]
6223 "(TARGET_POWERPC64 || TARGET_XILINX_FPU) && TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT && TARGET_FPRS"
6224 "fctidz %0,%1"
6225 [(set_attr "type" "fp")])
6226
6227 (define_expand "floatdisf2"
6228 [(set (match_operand:SF 0 "gpc_reg_operand" "")
6229 (float:SF (match_operand:DI 1 "gpc_reg_operand" "")))]
6230 "TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT "
6231 "
6232 {
6233 rtx val = operands[1];
6234 if (!flag_unsafe_math_optimizations)
6235 {
6236 rtx label = gen_label_rtx ();
6237 val = gen_reg_rtx (DImode);
6238 emit_insn (gen_floatdisf2_internal2 (val, operands[1], label));
6239 emit_label (label);
6240 }
6241 emit_insn (gen_floatdisf2_internal1 (operands[0], val));
6242 DONE;
6243 }")
6244
6245 ;; This is not IEEE compliant if rounding mode is "round to nearest".
6246 ;; If the DI->DF conversion is inexact, then it's possible to suffer
6247 ;; from double rounding.
6248 (define_insn_and_split "floatdisf2_internal1"
6249 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
6250 (float:SF (match_operand:DI 1 "gpc_reg_operand" "!f#r")))
6251 (clobber (match_scratch:DF 2 "=f"))]
6252 "TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT"
6253 "#"
6254 "&& reload_completed"
6255 [(set (match_dup 2)
6256 (float:DF (match_dup 1)))
6257 (set (match_dup 0)
6258 (float_truncate:SF (match_dup 2)))]
6259 "")
6260
6261 ;; Twiddles bits to avoid double rounding.
6262 ;; Bits that might be truncated when converting to DFmode are replaced
6263 ;; by a bit that won't be lost at that stage, but is below the SFmode
6264 ;; rounding position.
6265 (define_expand "floatdisf2_internal2"
6266 [(set (match_dup 3) (ashiftrt:DI (match_operand:DI 1 "" "")
6267 (const_int 53)))
6268 (parallel [(set (match_operand:DI 0 "" "") (and:DI (match_dup 1)
6269 (const_int 2047)))
6270 (clobber (scratch:CC))])
6271 (set (match_dup 3) (plus:DI (match_dup 3)
6272 (const_int 1)))
6273 (set (match_dup 0) (plus:DI (match_dup 0)
6274 (const_int 2047)))
6275 (set (match_dup 4) (compare:CCUNS (match_dup 3)
6276 (const_int 2)))
6277 (set (match_dup 0) (ior:DI (match_dup 0)
6278 (match_dup 1)))
6279 (parallel [(set (match_dup 0) (and:DI (match_dup 0)
6280 (const_int -2048)))
6281 (clobber (scratch:CC))])
6282 (set (pc) (if_then_else (geu (match_dup 4) (const_int 0))
6283 (label_ref (match_operand:DI 2 "" ""))
6284 (pc)))
6285 (set (match_dup 0) (match_dup 1))]
6286 "TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT"
6287 "
6288 {
6289 operands[3] = gen_reg_rtx (DImode);
6290 operands[4] = gen_reg_rtx (CCUNSmode);
6291 }")
6292 \f
6293 ;; Define the DImode operations that can be done in a small number
6294 ;; of instructions. The & constraints are to prevent the register
6295 ;; allocator from allocating registers that overlap with the inputs
6296 ;; (for example, having an input in 7,8 and an output in 6,7). We
6297 ;; also allow for the output being the same as one of the inputs.
6298
6299 (define_insn "*adddi3_noppc64"
6300 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,&r,r,r")
6301 (plus:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,0,0")
6302 (match_operand:DI 2 "reg_or_short_operand" "r,I,r,I")))]
6303 "! TARGET_POWERPC64"
6304 "*
6305 {
6306 if (WORDS_BIG_ENDIAN)
6307 return (GET_CODE (operands[2])) != CONST_INT
6308 ? \"{a|addc} %L0,%L1,%L2\;{ae|adde} %0,%1,%2\"
6309 : \"{ai|addic} %L0,%L1,%2\;{a%G2e|add%G2e} %0,%1\";
6310 else
6311 return (GET_CODE (operands[2])) != CONST_INT
6312 ? \"{a|addc} %0,%1,%2\;{ae|adde} %L0,%L1,%L2\"
6313 : \"{ai|addic} %0,%1,%2\;{a%G2e|add%G2e} %L0,%L1\";
6314 }"
6315 [(set_attr "type" "two")
6316 (set_attr "length" "8")])
6317
6318 (define_insn "*subdi3_noppc64"
6319 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,&r,r,r,r")
6320 (minus:DI (match_operand:DI 1 "reg_or_short_operand" "r,I,0,r,I")
6321 (match_operand:DI 2 "gpc_reg_operand" "r,r,r,0,0")))]
6322 "! TARGET_POWERPC64"
6323 "*
6324 {
6325 if (WORDS_BIG_ENDIAN)
6326 return (GET_CODE (operands[1]) != CONST_INT)
6327 ? \"{sf|subfc} %L0,%L2,%L1\;{sfe|subfe} %0,%2,%1\"
6328 : \"{sfi|subfic} %L0,%L2,%1\;{sf%G1e|subf%G1e} %0,%2\";
6329 else
6330 return (GET_CODE (operands[1]) != CONST_INT)
6331 ? \"{sf|subfc} %0,%2,%1\;{sfe|subfe} %L0,%L2,%L1\"
6332 : \"{sfi|subfic} %0,%2,%1\;{sf%G1e|subf%G1e} %L0,%L2\";
6333 }"
6334 [(set_attr "type" "two")
6335 (set_attr "length" "8")])
6336
6337 (define_insn "*negdi2_noppc64"
6338 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
6339 (neg:DI (match_operand:DI 1 "gpc_reg_operand" "r,0")))]
6340 "! TARGET_POWERPC64"
6341 "*
6342 {
6343 return (WORDS_BIG_ENDIAN)
6344 ? \"{sfi|subfic} %L0,%L1,0\;{sfze|subfze} %0,%1\"
6345 : \"{sfi|subfic} %0,%1,0\;{sfze|subfze} %L0,%L1\";
6346 }"
6347 [(set_attr "type" "two")
6348 (set_attr "length" "8")])
6349
6350 (define_expand "mulsidi3"
6351 [(set (match_operand:DI 0 "gpc_reg_operand" "")
6352 (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
6353 (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
6354 "! TARGET_POWERPC64"
6355 "
6356 {
6357 if (! TARGET_POWER && ! TARGET_POWERPC)
6358 {
6359 emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
6360 emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
6361 emit_insn (gen_mull_call ());
6362 if (WORDS_BIG_ENDIAN)
6363 emit_move_insn (operands[0], gen_rtx_REG (DImode, 3));
6364 else
6365 {
6366 emit_move_insn (operand_subword (operands[0], 0, 0, DImode),
6367 gen_rtx_REG (SImode, 3));
6368 emit_move_insn (operand_subword (operands[0], 1, 0, DImode),
6369 gen_rtx_REG (SImode, 4));
6370 }
6371 DONE;
6372 }
6373 else if (TARGET_POWER)
6374 {
6375 emit_insn (gen_mulsidi3_mq (operands[0], operands[1], operands[2]));
6376 DONE;
6377 }
6378 }")
6379
6380 (define_insn "mulsidi3_mq"
6381 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
6382 (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
6383 (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))
6384 (clobber (match_scratch:SI 3 "=q"))]
6385 "TARGET_POWER"
6386 "mul %0,%1,%2\;mfmq %L0"
6387 [(set_attr "type" "imul")
6388 (set_attr "length" "8")])
6389
6390 (define_insn "*mulsidi3_no_mq"
6391 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r")
6392 (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
6393 (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
6394 "TARGET_POWERPC && ! TARGET_POWER && ! TARGET_POWERPC64"
6395 "*
6396 {
6397 return (WORDS_BIG_ENDIAN)
6398 ? \"mulhw %0,%1,%2\;mullw %L0,%1,%2\"
6399 : \"mulhw %L0,%1,%2\;mullw %0,%1,%2\";
6400 }"
6401 [(set_attr "type" "imul")
6402 (set_attr "length" "8")])
6403
6404 (define_split
6405 [(set (match_operand:DI 0 "gpc_reg_operand" "")
6406 (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
6407 (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
6408 "TARGET_POWERPC && ! TARGET_POWERPC64 && reload_completed"
6409 [(set (match_dup 3)
6410 (truncate:SI
6411 (lshiftrt:DI (mult:DI (sign_extend:DI (match_dup 1))
6412 (sign_extend:DI (match_dup 2)))
6413 (const_int 32))))
6414 (set (match_dup 4)
6415 (mult:SI (match_dup 1)
6416 (match_dup 2)))]
6417 "
6418 {
6419 int endian = (WORDS_BIG_ENDIAN == 0);
6420 operands[3] = operand_subword (operands[0], endian, 0, DImode);
6421 operands[4] = operand_subword (operands[0], 1 - endian, 0, DImode);
6422 }")
6423
6424 (define_expand "umulsidi3"
6425 [(set (match_operand:DI 0 "gpc_reg_operand" "")
6426 (mult:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
6427 (zero_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
6428 "TARGET_POWERPC && ! TARGET_POWERPC64"
6429 "
6430 {
6431 if (TARGET_POWER)
6432 {
6433 emit_insn (gen_umulsidi3_mq (operands[0], operands[1], operands[2]));
6434 DONE;
6435 }
6436 }")
6437
6438 (define_insn "umulsidi3_mq"
6439 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r")
6440 (mult:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
6441 (zero_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))
6442 (clobber (match_scratch:SI 3 "=q"))]
6443 "TARGET_POWERPC && TARGET_POWER"
6444 "*
6445 {
6446 return (WORDS_BIG_ENDIAN)
6447 ? \"mulhwu %0,%1,%2\;mullw %L0,%1,%2\"
6448 : \"mulhwu %L0,%1,%2\;mullw %0,%1,%2\";
6449 }"
6450 [(set_attr "type" "imul")
6451 (set_attr "length" "8")])
6452
6453 (define_insn "*umulsidi3_no_mq"
6454 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r")
6455 (mult:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
6456 (zero_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
6457 "TARGET_POWERPC && ! TARGET_POWER && ! TARGET_POWERPC64"
6458 "*
6459 {
6460 return (WORDS_BIG_ENDIAN)
6461 ? \"mulhwu %0,%1,%2\;mullw %L0,%1,%2\"
6462 : \"mulhwu %L0,%1,%2\;mullw %0,%1,%2\";
6463 }"
6464 [(set_attr "type" "imul")
6465 (set_attr "length" "8")])
6466
6467 (define_split
6468 [(set (match_operand:DI 0 "gpc_reg_operand" "")
6469 (mult:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
6470 (zero_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
6471 "TARGET_POWERPC && ! TARGET_POWERPC64 && reload_completed"
6472 [(set (match_dup 3)
6473 (truncate:SI
6474 (lshiftrt:DI (mult:DI (zero_extend:DI (match_dup 1))
6475 (zero_extend:DI (match_dup 2)))
6476 (const_int 32))))
6477 (set (match_dup 4)
6478 (mult:SI (match_dup 1)
6479 (match_dup 2)))]
6480 "
6481 {
6482 int endian = (WORDS_BIG_ENDIAN == 0);
6483 operands[3] = operand_subword (operands[0], endian, 0, DImode);
6484 operands[4] = operand_subword (operands[0], 1 - endian, 0, DImode);
6485 }")
6486
6487 (define_expand "smulsi3_highpart"
6488 [(set (match_operand:SI 0 "gpc_reg_operand" "")
6489 (truncate:SI
6490 (lshiftrt:DI (mult:DI (sign_extend:DI
6491 (match_operand:SI 1 "gpc_reg_operand" ""))
6492 (sign_extend:DI
6493 (match_operand:SI 2 "gpc_reg_operand" "")))
6494 (const_int 32))))]
6495 ""
6496 "
6497 {
6498 if (! TARGET_POWER && ! TARGET_POWERPC)
6499 {
6500 emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
6501 emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
6502 emit_insn (gen_mulh_call ());
6503 emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
6504 DONE;
6505 }
6506 else if (TARGET_POWER)
6507 {
6508 emit_insn (gen_smulsi3_highpart_mq (operands[0], operands[1], operands[2]));
6509 DONE;
6510 }
6511 }")
6512
6513 (define_insn "smulsi3_highpart_mq"
6514 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
6515 (truncate:SI
6516 (lshiftrt:DI (mult:DI (sign_extend:DI
6517 (match_operand:SI 1 "gpc_reg_operand" "%r"))
6518 (sign_extend:DI
6519 (match_operand:SI 2 "gpc_reg_operand" "r")))
6520 (const_int 32))))
6521 (clobber (match_scratch:SI 3 "=q"))]
6522 "TARGET_POWER"
6523 "mul %0,%1,%2"
6524 [(set_attr "type" "imul")])
6525
6526 (define_insn "*smulsi3_highpart_no_mq"
6527 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
6528 (truncate:SI
6529 (lshiftrt:DI (mult:DI (sign_extend:DI
6530 (match_operand:SI 1 "gpc_reg_operand" "%r"))
6531 (sign_extend:DI
6532 (match_operand:SI 2 "gpc_reg_operand" "r")))
6533 (const_int 32))))]
6534 "TARGET_POWERPC && ! TARGET_POWER"
6535 "mulhw %0,%1,%2"
6536 [(set_attr "type" "imul")])
6537
6538 (define_expand "umulsi3_highpart"
6539 [(set (match_operand:SI 0 "gpc_reg_operand" "")
6540 (truncate:SI
6541 (lshiftrt:DI (mult:DI (zero_extend:DI
6542 (match_operand:SI 1 "gpc_reg_operand" ""))
6543 (zero_extend:DI
6544 (match_operand:SI 2 "gpc_reg_operand" "")))
6545 (const_int 32))))]
6546 "TARGET_POWERPC"
6547 "
6548 {
6549 if (TARGET_POWER)
6550 {
6551 emit_insn (gen_umulsi3_highpart_mq (operands[0], operands[1], operands[2]));
6552 DONE;
6553 }
6554 }")
6555
6556 (define_insn "umulsi3_highpart_mq"
6557 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
6558 (truncate:SI
6559 (lshiftrt:DI (mult:DI (zero_extend:DI
6560 (match_operand:SI 1 "gpc_reg_operand" "%r"))
6561 (zero_extend:DI
6562 (match_operand:SI 2 "gpc_reg_operand" "r")))
6563 (const_int 32))))
6564 (clobber (match_scratch:SI 3 "=q"))]
6565 "TARGET_POWERPC && TARGET_POWER"
6566 "mulhwu %0,%1,%2"
6567 [(set_attr "type" "imul")])
6568
6569 (define_insn "*umulsi3_highpart_no_mq"
6570 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
6571 (truncate:SI
6572 (lshiftrt:DI (mult:DI (zero_extend:DI
6573 (match_operand:SI 1 "gpc_reg_operand" "%r"))
6574 (zero_extend:DI
6575 (match_operand:SI 2 "gpc_reg_operand" "r")))
6576 (const_int 32))))]
6577 "TARGET_POWERPC && ! TARGET_POWER"
6578 "mulhwu %0,%1,%2"
6579 [(set_attr "type" "imul")])
6580
6581 ;; If operands 0 and 2 are in the same register, we have a problem. But
6582 ;; operands 0 and 1 (the usual case) can be in the same register. That's
6583 ;; why we have the strange constraints below.
6584 (define_insn "ashldi3_power"
6585 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,&r")
6586 (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,0,r")
6587 (match_operand:SI 2 "reg_or_cint_operand" "M,i,r,r")))
6588 (clobber (match_scratch:SI 3 "=X,q,q,q"))]
6589 "TARGET_POWER"
6590 "@
6591 {sli|slwi} %0,%L1,%h2\;{cal %L0,0(0)|li %L0,0}
6592 sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2
6593 sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2
6594 sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2"
6595 [(set_attr "length" "8")])
6596
6597 (define_insn "lshrdi3_power"
6598 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,&r")
6599 (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,0,r")
6600 (match_operand:SI 2 "reg_or_cint_operand" "M,i,r,r")))
6601 (clobber (match_scratch:SI 3 "=X,q,q,q"))]
6602 "TARGET_POWER"
6603 "@
6604 {s%A2i|s%A2wi} %L0,%1,%h2\;{cal %0,0(0)|li %0,0}
6605 sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2
6606 sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2
6607 sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2"
6608 [(set_attr "length" "8")])
6609
6610 ;; Shift by a variable amount is too complex to be worth open-coding. We
6611 ;; just handle shifts by constants.
6612 (define_insn "ashrdi3_power"
6613 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
6614 (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6615 (match_operand:SI 2 "const_int_operand" "M,i")))
6616 (clobber (match_scratch:SI 3 "=X,q"))]
6617 "TARGET_POWER"
6618 "@
6619 {srai|srawi} %0,%1,31\;{srai|srawi} %L0,%1,%h2
6620 sraiq %0,%1,%h2\;srliq %L0,%L1,%h2"
6621 [(set_attr "type" "shift")
6622 (set_attr "length" "8")])
6623
6624 (define_insn "ashrdi3_no_power"
6625 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,&r")
6626 (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6627 (match_operand:SI 2 "const_int_operand" "M,i")))]
6628 "TARGET_32BIT && !TARGET_POWERPC64 && !TARGET_POWER && WORDS_BIG_ENDIAN"
6629 "@
6630 {srai|srawi} %0,%1,31\;{srai|srawi} %L0,%1,%h2
6631 {sri|srwi} %L0,%L1,%h2\;insrwi %L0,%1,%h2,0\;{srai|srawi} %0,%1,%h2"
6632 [(set_attr "type" "two,three")
6633 (set_attr "length" "8,12")])
6634
6635 (define_insn "*ashrdisi3_noppc64"
6636 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
6637 (subreg:SI (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
6638 (const_int 32)) 4))]
6639 "TARGET_32BIT && !TARGET_POWERPC64"
6640 "*
6641 {
6642 if (REGNO (operands[0]) == REGNO (operands[1]))
6643 return \"\";
6644 else
6645 return \"mr %0,%1\";
6646 }"
6647 [(set_attr "length" "4")])
6648
6649 \f
6650 ;; PowerPC64 DImode operations.
6651
6652 (define_insn_and_split "absdi2"
6653 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
6654 (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,0")))
6655 (clobber (match_scratch:DI 2 "=&r,&r"))]
6656 "TARGET_POWERPC64"
6657 "#"
6658 "&& reload_completed"
6659 [(set (match_dup 2) (ashiftrt:DI (match_dup 1) (const_int 63)))
6660 (set (match_dup 0) (xor:DI (match_dup 2) (match_dup 1)))
6661 (set (match_dup 0) (minus:DI (match_dup 0) (match_dup 2)))]
6662 "")
6663
6664 (define_insn_and_split "*nabsdi2"
6665 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
6666 (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,0"))))
6667 (clobber (match_scratch:DI 2 "=&r,&r"))]
6668 "TARGET_POWERPC64"
6669 "#"
6670 "&& reload_completed"
6671 [(set (match_dup 2) (ashiftrt:DI (match_dup 1) (const_int 63)))
6672 (set (match_dup 0) (xor:DI (match_dup 2) (match_dup 1)))
6673 (set (match_dup 0) (minus:DI (match_dup 2) (match_dup 0)))]
6674 "")
6675
6676 (define_insn "muldi3"
6677 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6678 (mult:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r")
6679 (match_operand:DI 2 "reg_or_short_operand" "r,I")))]
6680 "TARGET_POWERPC64"
6681 "@
6682 mulld %0,%1,%2
6683 mulli %0,%1,%2"
6684 [(set (attr "type")
6685 (cond [(match_operand:SI 2 "s8bit_cint_operand" "")
6686 (const_string "imul3")
6687 (match_operand:SI 2 "short_cint_operand" "")
6688 (const_string "imul2")]
6689 (const_string "lmul")))])
6690
6691 (define_insn "*muldi3_internal1"
6692 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
6693 (compare:CC (mult:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r")
6694 (match_operand:DI 2 "gpc_reg_operand" "r,r"))
6695 (const_int 0)))
6696 (clobber (match_scratch:DI 3 "=r,r"))]
6697 "TARGET_POWERPC64"
6698 "@
6699 mulld. %3,%1,%2
6700 #"
6701 [(set_attr "type" "lmul_compare")
6702 (set_attr "length" "4,8")])
6703
6704 (define_split
6705 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
6706 (compare:CC (mult:DI (match_operand:DI 1 "gpc_reg_operand" "")
6707 (match_operand:DI 2 "gpc_reg_operand" ""))
6708 (const_int 0)))
6709 (clobber (match_scratch:DI 3 ""))]
6710 "TARGET_POWERPC64 && reload_completed"
6711 [(set (match_dup 3)
6712 (mult:DI (match_dup 1) (match_dup 2)))
6713 (set (match_dup 0)
6714 (compare:CC (match_dup 3)
6715 (const_int 0)))]
6716 "")
6717
6718 (define_insn "*muldi3_internal2"
6719 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
6720 (compare:CC (mult:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r")
6721 (match_operand:DI 2 "gpc_reg_operand" "r,r"))
6722 (const_int 0)))
6723 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6724 (mult:DI (match_dup 1) (match_dup 2)))]
6725 "TARGET_POWERPC64"
6726 "@
6727 mulld. %0,%1,%2
6728 #"
6729 [(set_attr "type" "lmul_compare")
6730 (set_attr "length" "4,8")])
6731
6732 (define_split
6733 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
6734 (compare:CC (mult:DI (match_operand:DI 1 "gpc_reg_operand" "")
6735 (match_operand:DI 2 "gpc_reg_operand" ""))
6736 (const_int 0)))
6737 (set (match_operand:DI 0 "gpc_reg_operand" "")
6738 (mult:DI (match_dup 1) (match_dup 2)))]
6739 "TARGET_POWERPC64 && reload_completed"
6740 [(set (match_dup 0)
6741 (mult:DI (match_dup 1) (match_dup 2)))
6742 (set (match_dup 3)
6743 (compare:CC (match_dup 0)
6744 (const_int 0)))]
6745 "")
6746
6747 (define_insn "smuldi3_highpart"
6748 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
6749 (truncate:DI
6750 (lshiftrt:TI (mult:TI (sign_extend:TI
6751 (match_operand:DI 1 "gpc_reg_operand" "%r"))
6752 (sign_extend:TI
6753 (match_operand:DI 2 "gpc_reg_operand" "r")))
6754 (const_int 64))))]
6755 "TARGET_POWERPC64"
6756 "mulhd %0,%1,%2"
6757 [(set_attr "type" "lmul")])
6758
6759 (define_insn "umuldi3_highpart"
6760 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
6761 (truncate:DI
6762 (lshiftrt:TI (mult:TI (zero_extend:TI
6763 (match_operand:DI 1 "gpc_reg_operand" "%r"))
6764 (zero_extend:TI
6765 (match_operand:DI 2 "gpc_reg_operand" "r")))
6766 (const_int 64))))]
6767 "TARGET_POWERPC64"
6768 "mulhdu %0,%1,%2"
6769 [(set_attr "type" "lmul")])
6770
6771 (define_insn "rotldi3"
6772 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6773 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6774 (match_operand:DI 2 "reg_or_cint_operand" "r,i")))]
6775 "TARGET_POWERPC64"
6776 "@
6777 rldcl %0,%1,%2,0
6778 rldicl %0,%1,%H2,0"
6779 [(set_attr "type" "var_shift_rotate,integer")])
6780
6781 (define_insn "*rotldi3_internal2"
6782 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
6783 (compare:CC (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
6784 (match_operand:DI 2 "reg_or_cint_operand" "r,i,r,i"))
6785 (const_int 0)))
6786 (clobber (match_scratch:DI 3 "=r,r,r,r"))]
6787 "TARGET_64BIT"
6788 "@
6789 rldcl. %3,%1,%2,0
6790 rldicl. %3,%1,%H2,0
6791 #
6792 #"
6793 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
6794 (set_attr "length" "4,4,8,8")])
6795
6796 (define_split
6797 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
6798 (compare:CC (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
6799 (match_operand:DI 2 "reg_or_cint_operand" ""))
6800 (const_int 0)))
6801 (clobber (match_scratch:DI 3 ""))]
6802 "TARGET_POWERPC64 && reload_completed"
6803 [(set (match_dup 3)
6804 (rotate:DI (match_dup 1) (match_dup 2)))
6805 (set (match_dup 0)
6806 (compare:CC (match_dup 3)
6807 (const_int 0)))]
6808 "")
6809
6810 (define_insn "*rotldi3_internal3"
6811 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
6812 (compare:CC (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
6813 (match_operand:DI 2 "reg_or_cint_operand" "r,i,r,i"))
6814 (const_int 0)))
6815 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,r")
6816 (rotate:DI (match_dup 1) (match_dup 2)))]
6817 "TARGET_64BIT"
6818 "@
6819 rldcl. %0,%1,%2,0
6820 rldicl. %0,%1,%H2,0
6821 #
6822 #"
6823 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
6824 (set_attr "length" "4,4,8,8")])
6825
6826 (define_split
6827 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
6828 (compare:CC (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
6829 (match_operand:DI 2 "reg_or_cint_operand" ""))
6830 (const_int 0)))
6831 (set (match_operand:DI 0 "gpc_reg_operand" "")
6832 (rotate:DI (match_dup 1) (match_dup 2)))]
6833 "TARGET_POWERPC64 && reload_completed"
6834 [(set (match_dup 0)
6835 (rotate:DI (match_dup 1) (match_dup 2)))
6836 (set (match_dup 3)
6837 (compare:CC (match_dup 0)
6838 (const_int 0)))]
6839 "")
6840
6841 (define_insn "*rotldi3_internal4"
6842 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6843 (and:DI (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6844 (match_operand:DI 2 "reg_or_cint_operand" "r,i"))
6845 (match_operand:DI 3 "mask64_operand" "n,n")))]
6846 "TARGET_POWERPC64"
6847 "@
6848 rldc%B3 %0,%1,%2,%S3
6849 rldic%B3 %0,%1,%H2,%S3"
6850 [(set_attr "type" "var_shift_rotate,integer")])
6851
6852 (define_insn "*rotldi3_internal5"
6853 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
6854 (compare:CC (and:DI
6855 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
6856 (match_operand:DI 2 "reg_or_cint_operand" "r,i,r,i"))
6857 (match_operand:DI 3 "mask64_operand" "n,n,n,n"))
6858 (const_int 0)))
6859 (clobber (match_scratch:DI 4 "=r,r,r,r"))]
6860 "TARGET_64BIT"
6861 "@
6862 rldc%B3. %4,%1,%2,%S3
6863 rldic%B3. %4,%1,%H2,%S3
6864 #
6865 #"
6866 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
6867 (set_attr "length" "4,4,8,8")])
6868
6869 (define_split
6870 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
6871 (compare:CC (and:DI
6872 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
6873 (match_operand:DI 2 "reg_or_cint_operand" ""))
6874 (match_operand:DI 3 "mask64_operand" ""))
6875 (const_int 0)))
6876 (clobber (match_scratch:DI 4 ""))]
6877 "TARGET_POWERPC64 && reload_completed"
6878 [(set (match_dup 4)
6879 (and:DI (rotate:DI (match_dup 1)
6880 (match_dup 2))
6881 (match_dup 3)))
6882 (set (match_dup 0)
6883 (compare:CC (match_dup 4)
6884 (const_int 0)))]
6885 "")
6886
6887 (define_insn "*rotldi3_internal6"
6888 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,?y,?y")
6889 (compare:CC (and:DI
6890 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
6891 (match_operand:DI 2 "reg_or_cint_operand" "r,i,r,i"))
6892 (match_operand:DI 3 "mask64_operand" "n,n,n,n"))
6893 (const_int 0)))
6894 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,r")
6895 (and:DI (rotate:DI (match_dup 1) (match_dup 2)) (match_dup 3)))]
6896 "TARGET_64BIT"
6897 "@
6898 rldc%B3. %0,%1,%2,%S3
6899 rldic%B3. %0,%1,%H2,%S3
6900 #
6901 #"
6902 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
6903 (set_attr "length" "4,4,8,8")])
6904
6905 (define_split
6906 [(set (match_operand:CC 4 "cc_reg_not_micro_cr0_operand" "")
6907 (compare:CC (and:DI
6908 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
6909 (match_operand:DI 2 "reg_or_cint_operand" ""))
6910 (match_operand:DI 3 "mask64_operand" ""))
6911 (const_int 0)))
6912 (set (match_operand:DI 0 "gpc_reg_operand" "")
6913 (and:DI (rotate:DI (match_dup 1) (match_dup 2)) (match_dup 3)))]
6914 "TARGET_POWERPC64 && reload_completed"
6915 [(set (match_dup 0)
6916 (and:DI (rotate:DI (match_dup 1) (match_dup 2)) (match_dup 3)))
6917 (set (match_dup 4)
6918 (compare:CC (match_dup 0)
6919 (const_int 0)))]
6920 "")
6921
6922 (define_insn "*rotldi3_internal7"
6923 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6924 (zero_extend:DI
6925 (subreg:QI
6926 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6927 (match_operand:DI 2 "reg_or_cint_operand" "r,i")) 0)))]
6928 "TARGET_POWERPC64"
6929 "@
6930 rldcl %0,%1,%2,56
6931 rldicl %0,%1,%H2,56"
6932 [(set_attr "type" "var_shift_rotate,integer")])
6933
6934 (define_insn "*rotldi3_internal8"
6935 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
6936 (compare:CC (zero_extend:DI
6937 (subreg:QI
6938 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
6939 (match_operand:DI 2 "reg_or_cint_operand" "r,i,r,i")) 0))
6940 (const_int 0)))
6941 (clobber (match_scratch:DI 3 "=r,r,r,r"))]
6942 "TARGET_64BIT"
6943 "@
6944 rldcl. %3,%1,%2,56
6945 rldicl. %3,%1,%H2,56
6946 #
6947 #"
6948 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
6949 (set_attr "length" "4,4,8,8")])
6950
6951 (define_split
6952 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
6953 (compare:CC (zero_extend:DI
6954 (subreg:QI
6955 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
6956 (match_operand:DI 2 "reg_or_cint_operand" "")) 0))
6957 (const_int 0)))
6958 (clobber (match_scratch:DI 3 ""))]
6959 "TARGET_POWERPC64 && reload_completed"
6960 [(set (match_dup 3)
6961 (zero_extend:DI (subreg:QI
6962 (rotate:DI (match_dup 1)
6963 (match_dup 2)) 0)))
6964 (set (match_dup 0)
6965 (compare:CC (match_dup 3)
6966 (const_int 0)))]
6967 "")
6968
6969 (define_insn "*rotldi3_internal9"
6970 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
6971 (compare:CC (zero_extend:DI
6972 (subreg:QI
6973 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
6974 (match_operand:DI 2 "reg_or_cint_operand" "r,i,r,i")) 0))
6975 (const_int 0)))
6976 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,r")
6977 (zero_extend:DI (subreg:QI (rotate:DI (match_dup 1) (match_dup 2)) 0)))]
6978 "TARGET_64BIT"
6979 "@
6980 rldcl. %0,%1,%2,56
6981 rldicl. %0,%1,%H2,56
6982 #
6983 #"
6984 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
6985 (set_attr "length" "4,4,8,8")])
6986
6987 (define_split
6988 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
6989 (compare:CC (zero_extend:DI
6990 (subreg:QI
6991 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
6992 (match_operand:DI 2 "reg_or_cint_operand" "")) 0))
6993 (const_int 0)))
6994 (set (match_operand:DI 0 "gpc_reg_operand" "")
6995 (zero_extend:DI (subreg:QI (rotate:DI (match_dup 1) (match_dup 2)) 0)))]
6996 "TARGET_POWERPC64 && reload_completed"
6997 [(set (match_dup 0)
6998 (zero_extend:DI (subreg:QI (rotate:DI (match_dup 1) (match_dup 2)) 0)))
6999 (set (match_dup 3)
7000 (compare:CC (match_dup 0)
7001 (const_int 0)))]
7002 "")
7003
7004 (define_insn "*rotldi3_internal10"
7005 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
7006 (zero_extend:DI
7007 (subreg:HI
7008 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
7009 (match_operand:DI 2 "reg_or_cint_operand" "r,i")) 0)))]
7010 "TARGET_POWERPC64"
7011 "@
7012 rldcl %0,%1,%2,48
7013 rldicl %0,%1,%H2,48"
7014 [(set_attr "type" "var_shift_rotate,integer")])
7015
7016 (define_insn "*rotldi3_internal11"
7017 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
7018 (compare:CC (zero_extend:DI
7019 (subreg:HI
7020 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
7021 (match_operand:DI 2 "reg_or_cint_operand" "r,i,r,i")) 0))
7022 (const_int 0)))
7023 (clobber (match_scratch:DI 3 "=r,r,r,r"))]
7024 "TARGET_64BIT"
7025 "@
7026 rldcl. %3,%1,%2,48
7027 rldicl. %3,%1,%H2,48
7028 #
7029 #"
7030 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
7031 (set_attr "length" "4,4,8,8")])
7032
7033 (define_split
7034 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
7035 (compare:CC (zero_extend:DI
7036 (subreg:HI
7037 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
7038 (match_operand:DI 2 "reg_or_cint_operand" "")) 0))
7039 (const_int 0)))
7040 (clobber (match_scratch:DI 3 ""))]
7041 "TARGET_POWERPC64 && reload_completed"
7042 [(set (match_dup 3)
7043 (zero_extend:DI (subreg:HI
7044 (rotate:DI (match_dup 1)
7045 (match_dup 2)) 0)))
7046 (set (match_dup 0)
7047 (compare:CC (match_dup 3)
7048 (const_int 0)))]
7049 "")
7050
7051 (define_insn "*rotldi3_internal12"
7052 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
7053 (compare:CC (zero_extend:DI
7054 (subreg:HI
7055 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
7056 (match_operand:DI 2 "reg_or_cint_operand" "r,i,r,i")) 0))
7057 (const_int 0)))
7058 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,r")
7059 (zero_extend:DI (subreg:HI (rotate:DI (match_dup 1) (match_dup 2)) 0)))]
7060 "TARGET_64BIT"
7061 "@
7062 rldcl. %0,%1,%2,48
7063 rldicl. %0,%1,%H2,48
7064 #
7065 #"
7066 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
7067 (set_attr "length" "4,4,8,8")])
7068
7069 (define_split
7070 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
7071 (compare:CC (zero_extend:DI
7072 (subreg:HI
7073 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
7074 (match_operand:DI 2 "reg_or_cint_operand" "")) 0))
7075 (const_int 0)))
7076 (set (match_operand:DI 0 "gpc_reg_operand" "")
7077 (zero_extend:DI (subreg:HI (rotate:DI (match_dup 1) (match_dup 2)) 0)))]
7078 "TARGET_POWERPC64 && reload_completed"
7079 [(set (match_dup 0)
7080 (zero_extend:DI (subreg:HI (rotate:DI (match_dup 1) (match_dup 2)) 0)))
7081 (set (match_dup 3)
7082 (compare:CC (match_dup 0)
7083 (const_int 0)))]
7084 "")
7085
7086 (define_insn "*rotldi3_internal13"
7087 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
7088 (zero_extend:DI
7089 (subreg:SI
7090 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
7091 (match_operand:DI 2 "reg_or_cint_operand" "r,i")) 0)))]
7092 "TARGET_POWERPC64"
7093 "@
7094 rldcl %0,%1,%2,32
7095 rldicl %0,%1,%H2,32"
7096 [(set_attr "type" "var_shift_rotate,integer")])
7097
7098 (define_insn "*rotldi3_internal14"
7099 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
7100 (compare:CC (zero_extend:DI
7101 (subreg:SI
7102 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
7103 (match_operand:DI 2 "reg_or_cint_operand" "r,i,r,i")) 0))
7104 (const_int 0)))
7105 (clobber (match_scratch:DI 3 "=r,r,r,r"))]
7106 "TARGET_64BIT"
7107 "@
7108 rldcl. %3,%1,%2,32
7109 rldicl. %3,%1,%H2,32
7110 #
7111 #"
7112 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
7113 (set_attr "length" "4,4,8,8")])
7114
7115 (define_split
7116 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
7117 (compare:CC (zero_extend:DI
7118 (subreg:SI
7119 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
7120 (match_operand:DI 2 "reg_or_cint_operand" "")) 0))
7121 (const_int 0)))
7122 (clobber (match_scratch:DI 3 ""))]
7123 "TARGET_POWERPC64 && reload_completed"
7124 [(set (match_dup 3)
7125 (zero_extend:DI (subreg:SI
7126 (rotate:DI (match_dup 1)
7127 (match_dup 2)) 0)))
7128 (set (match_dup 0)
7129 (compare:CC (match_dup 3)
7130 (const_int 0)))]
7131 "")
7132
7133 (define_insn "*rotldi3_internal15"
7134 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
7135 (compare:CC (zero_extend:DI
7136 (subreg:SI
7137 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
7138 (match_operand:DI 2 "reg_or_cint_operand" "r,i,r,i")) 0))
7139 (const_int 0)))
7140 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,r")
7141 (zero_extend:DI (subreg:SI (rotate:DI (match_dup 1) (match_dup 2)) 0)))]
7142 "TARGET_64BIT"
7143 "@
7144 rldcl. %0,%1,%2,32
7145 rldicl. %0,%1,%H2,32
7146 #
7147 #"
7148 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
7149 (set_attr "length" "4,4,8,8")])
7150
7151 (define_split
7152 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
7153 (compare:CC (zero_extend:DI
7154 (subreg:SI
7155 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
7156 (match_operand:DI 2 "reg_or_cint_operand" "")) 0))
7157 (const_int 0)))
7158 (set (match_operand:DI 0 "gpc_reg_operand" "")
7159 (zero_extend:DI (subreg:SI (rotate:DI (match_dup 1) (match_dup 2)) 0)))]
7160 "TARGET_POWERPC64 && reload_completed"
7161 [(set (match_dup 0)
7162 (zero_extend:DI (subreg:SI (rotate:DI (match_dup 1) (match_dup 2)) 0)))
7163 (set (match_dup 3)
7164 (compare:CC (match_dup 0)
7165 (const_int 0)))]
7166 "")
7167
7168 (define_expand "ashldi3"
7169 [(set (match_operand:DI 0 "gpc_reg_operand" "")
7170 (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
7171 (match_operand:SI 2 "reg_or_cint_operand" "")))]
7172 "TARGET_POWERPC64 || TARGET_POWER"
7173 "
7174 {
7175 if (TARGET_POWERPC64)
7176 ;
7177 else if (TARGET_POWER)
7178 {
7179 emit_insn (gen_ashldi3_power (operands[0], operands[1], operands[2]));
7180 DONE;
7181 }
7182 else
7183 FAIL;
7184 }")
7185
7186 (define_insn "*ashldi3_internal1"
7187 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
7188 (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
7189 (match_operand:SI 2 "reg_or_cint_operand" "r,i")))]
7190 "TARGET_POWERPC64"
7191 "@
7192 sld %0,%1,%2
7193 sldi %0,%1,%H2"
7194 [(set_attr "type" "var_shift_rotate,shift")])
7195
7196 (define_insn "*ashldi3_internal2"
7197 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
7198 (compare:CC (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
7199 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
7200 (const_int 0)))
7201 (clobber (match_scratch:DI 3 "=r,r,r,r"))]
7202 "TARGET_64BIT"
7203 "@
7204 sld. %3,%1,%2
7205 sldi. %3,%1,%H2
7206 #
7207 #"
7208 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
7209 (set_attr "length" "4,4,8,8")])
7210
7211 (define_split
7212 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
7213 (compare:CC (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
7214 (match_operand:SI 2 "reg_or_cint_operand" ""))
7215 (const_int 0)))
7216 (clobber (match_scratch:DI 3 ""))]
7217 "TARGET_POWERPC64 && reload_completed"
7218 [(set (match_dup 3)
7219 (ashift:DI (match_dup 1) (match_dup 2)))
7220 (set (match_dup 0)
7221 (compare:CC (match_dup 3)
7222 (const_int 0)))]
7223 "")
7224
7225 (define_insn "*ashldi3_internal3"
7226 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
7227 (compare:CC (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
7228 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
7229 (const_int 0)))
7230 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,r")
7231 (ashift:DI (match_dup 1) (match_dup 2)))]
7232 "TARGET_64BIT"
7233 "@
7234 sld. %0,%1,%2
7235 sldi. %0,%1,%H2
7236 #
7237 #"
7238 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
7239 (set_attr "length" "4,4,8,8")])
7240
7241 (define_split
7242 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
7243 (compare:CC (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
7244 (match_operand:SI 2 "reg_or_cint_operand" ""))
7245 (const_int 0)))
7246 (set (match_operand:DI 0 "gpc_reg_operand" "")
7247 (ashift:DI (match_dup 1) (match_dup 2)))]
7248 "TARGET_POWERPC64 && reload_completed"
7249 [(set (match_dup 0)
7250 (ashift:DI (match_dup 1) (match_dup 2)))
7251 (set (match_dup 3)
7252 (compare:CC (match_dup 0)
7253 (const_int 0)))]
7254 "")
7255
7256 (define_insn "*ashldi3_internal4"
7257 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
7258 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r")
7259 (match_operand:SI 2 "const_int_operand" "i"))
7260 (match_operand:DI 3 "const_int_operand" "n")))]
7261 "TARGET_POWERPC64 && includes_rldic_lshift_p (operands[2], operands[3])"
7262 "rldic %0,%1,%H2,%W3")
7263
7264 (define_insn "ashldi3_internal5"
7265 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
7266 (compare:CC
7267 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
7268 (match_operand:SI 2 "const_int_operand" "i,i"))
7269 (match_operand:DI 3 "const_int_operand" "n,n"))
7270 (const_int 0)))
7271 (clobber (match_scratch:DI 4 "=r,r"))]
7272 "TARGET_64BIT && includes_rldic_lshift_p (operands[2], operands[3])"
7273 "@
7274 rldic. %4,%1,%H2,%W3
7275 #"
7276 [(set_attr "type" "compare")
7277 (set_attr "length" "4,8")])
7278
7279 (define_split
7280 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
7281 (compare:CC
7282 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
7283 (match_operand:SI 2 "const_int_operand" ""))
7284 (match_operand:DI 3 "const_int_operand" ""))
7285 (const_int 0)))
7286 (clobber (match_scratch:DI 4 ""))]
7287 "TARGET_POWERPC64 && reload_completed
7288 && includes_rldic_lshift_p (operands[2], operands[3])"
7289 [(set (match_dup 4)
7290 (and:DI (ashift:DI (match_dup 1) (match_dup 2))
7291 (match_dup 3)))
7292 (set (match_dup 0)
7293 (compare:CC (match_dup 4)
7294 (const_int 0)))]
7295 "")
7296
7297 (define_insn "*ashldi3_internal6"
7298 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
7299 (compare:CC
7300 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
7301 (match_operand:SI 2 "const_int_operand" "i,i"))
7302 (match_operand:DI 3 "const_int_operand" "n,n"))
7303 (const_int 0)))
7304 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
7305 (and:DI (ashift:DI (match_dup 1) (match_dup 2)) (match_dup 3)))]
7306 "TARGET_64BIT && includes_rldic_lshift_p (operands[2], operands[3])"
7307 "@
7308 rldic. %0,%1,%H2,%W3
7309 #"
7310 [(set_attr "type" "compare")
7311 (set_attr "length" "4,8")])
7312
7313 (define_split
7314 [(set (match_operand:CC 4 "cc_reg_not_micro_cr0_operand" "")
7315 (compare:CC
7316 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
7317 (match_operand:SI 2 "const_int_operand" ""))
7318 (match_operand:DI 3 "const_int_operand" ""))
7319 (const_int 0)))
7320 (set (match_operand:DI 0 "gpc_reg_operand" "")
7321 (and:DI (ashift:DI (match_dup 1) (match_dup 2)) (match_dup 3)))]
7322 "TARGET_POWERPC64 && reload_completed
7323 && includes_rldic_lshift_p (operands[2], operands[3])"
7324 [(set (match_dup 0)
7325 (and:DI (ashift:DI (match_dup 1) (match_dup 2))
7326 (match_dup 3)))
7327 (set (match_dup 4)
7328 (compare:CC (match_dup 0)
7329 (const_int 0)))]
7330 "")
7331
7332 (define_insn "*ashldi3_internal7"
7333 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
7334 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r")
7335 (match_operand:SI 2 "const_int_operand" "i"))
7336 (match_operand:DI 3 "mask64_operand" "n")))]
7337 "TARGET_POWERPC64 && includes_rldicr_lshift_p (operands[2], operands[3])"
7338 "rldicr %0,%1,%H2,%S3")
7339
7340 (define_insn "ashldi3_internal8"
7341 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
7342 (compare:CC
7343 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
7344 (match_operand:SI 2 "const_int_operand" "i,i"))
7345 (match_operand:DI 3 "mask64_operand" "n,n"))
7346 (const_int 0)))
7347 (clobber (match_scratch:DI 4 "=r,r"))]
7348 "TARGET_64BIT && includes_rldicr_lshift_p (operands[2], operands[3])"
7349 "@
7350 rldicr. %4,%1,%H2,%S3
7351 #"
7352 [(set_attr "type" "compare")
7353 (set_attr "length" "4,8")])
7354
7355 (define_split
7356 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
7357 (compare:CC
7358 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
7359 (match_operand:SI 2 "const_int_operand" ""))
7360 (match_operand:DI 3 "mask64_operand" ""))
7361 (const_int 0)))
7362 (clobber (match_scratch:DI 4 ""))]
7363 "TARGET_POWERPC64 && reload_completed
7364 && includes_rldicr_lshift_p (operands[2], operands[3])"
7365 [(set (match_dup 4)
7366 (and:DI (ashift:DI (match_dup 1) (match_dup 2))
7367 (match_dup 3)))
7368 (set (match_dup 0)
7369 (compare:CC (match_dup 4)
7370 (const_int 0)))]
7371 "")
7372
7373 (define_insn "*ashldi3_internal9"
7374 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
7375 (compare:CC
7376 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
7377 (match_operand:SI 2 "const_int_operand" "i,i"))
7378 (match_operand:DI 3 "mask64_operand" "n,n"))
7379 (const_int 0)))
7380 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
7381 (and:DI (ashift:DI (match_dup 1) (match_dup 2)) (match_dup 3)))]
7382 "TARGET_64BIT && includes_rldicr_lshift_p (operands[2], operands[3])"
7383 "@
7384 rldicr. %0,%1,%H2,%S3
7385 #"
7386 [(set_attr "type" "compare")
7387 (set_attr "length" "4,8")])
7388
7389 (define_split
7390 [(set (match_operand:CC 4 "cc_reg_not_micro_cr0_operand" "")
7391 (compare:CC
7392 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
7393 (match_operand:SI 2 "const_int_operand" ""))
7394 (match_operand:DI 3 "mask64_operand" ""))
7395 (const_int 0)))
7396 (set (match_operand:DI 0 "gpc_reg_operand" "")
7397 (and:DI (ashift:DI (match_dup 1) (match_dup 2)) (match_dup 3)))]
7398 "TARGET_POWERPC64 && reload_completed
7399 && includes_rldicr_lshift_p (operands[2], operands[3])"
7400 [(set (match_dup 0)
7401 (and:DI (ashift:DI (match_dup 1) (match_dup 2))
7402 (match_dup 3)))
7403 (set (match_dup 4)
7404 (compare:CC (match_dup 0)
7405 (const_int 0)))]
7406 "")
7407
7408 (define_expand "lshrdi3"
7409 [(set (match_operand:DI 0 "gpc_reg_operand" "")
7410 (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
7411 (match_operand:SI 2 "reg_or_cint_operand" "")))]
7412 "TARGET_POWERPC64 || TARGET_POWER"
7413 "
7414 {
7415 if (TARGET_POWERPC64)
7416 ;
7417 else if (TARGET_POWER)
7418 {
7419 emit_insn (gen_lshrdi3_power (operands[0], operands[1], operands[2]));
7420 DONE;
7421 }
7422 else
7423 FAIL;
7424 }")
7425
7426 (define_insn "*lshrdi3_internal1"
7427 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
7428 (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
7429 (match_operand:SI 2 "reg_or_cint_operand" "r,i")))]
7430 "TARGET_POWERPC64"
7431 "@
7432 srd %0,%1,%2
7433 srdi %0,%1,%H2"
7434 [(set_attr "type" "var_shift_rotate,shift")])
7435
7436 (define_insn "*lshrdi3_internal2"
7437 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
7438 (compare:CC (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
7439 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
7440 (const_int 0)))
7441 (clobber (match_scratch:DI 3 "=r,r,r,r"))]
7442 "TARGET_64BIT "
7443 "@
7444 srd. %3,%1,%2
7445 srdi. %3,%1,%H2
7446 #
7447 #"
7448 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
7449 (set_attr "length" "4,4,8,8")])
7450
7451 (define_split
7452 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
7453 (compare:CC (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
7454 (match_operand:SI 2 "reg_or_cint_operand" ""))
7455 (const_int 0)))
7456 (clobber (match_scratch:DI 3 ""))]
7457 "TARGET_POWERPC64 && reload_completed"
7458 [(set (match_dup 3)
7459 (lshiftrt:DI (match_dup 1) (match_dup 2)))
7460 (set (match_dup 0)
7461 (compare:CC (match_dup 3)
7462 (const_int 0)))]
7463 "")
7464
7465 (define_insn "*lshrdi3_internal3"
7466 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
7467 (compare:CC (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
7468 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
7469 (const_int 0)))
7470 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,r")
7471 (lshiftrt:DI (match_dup 1) (match_dup 2)))]
7472 "TARGET_64BIT"
7473 "@
7474 srd. %0,%1,%2
7475 srdi. %0,%1,%H2
7476 #
7477 #"
7478 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
7479 (set_attr "length" "4,4,8,8")])
7480
7481 (define_split
7482 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
7483 (compare:CC (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
7484 (match_operand:SI 2 "reg_or_cint_operand" ""))
7485 (const_int 0)))
7486 (set (match_operand:DI 0 "gpc_reg_operand" "")
7487 (lshiftrt:DI (match_dup 1) (match_dup 2)))]
7488 "TARGET_POWERPC64 && reload_completed"
7489 [(set (match_dup 0)
7490 (lshiftrt:DI (match_dup 1) (match_dup 2)))
7491 (set (match_dup 3)
7492 (compare:CC (match_dup 0)
7493 (const_int 0)))]
7494 "")
7495
7496 (define_expand "ashrdi3"
7497 [(set (match_operand:DI 0 "gpc_reg_operand" "")
7498 (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
7499 (match_operand:SI 2 "reg_or_cint_operand" "")))]
7500 "WORDS_BIG_ENDIAN"
7501 "
7502 {
7503 if (TARGET_POWERPC64)
7504 ;
7505 else if (TARGET_POWER && GET_CODE (operands[2]) == CONST_INT)
7506 {
7507 emit_insn (gen_ashrdi3_power (operands[0], operands[1], operands[2]));
7508 DONE;
7509 }
7510 else if (TARGET_32BIT && GET_CODE (operands[2]) == CONST_INT
7511 && WORDS_BIG_ENDIAN)
7512 {
7513 emit_insn (gen_ashrdi3_no_power (operands[0], operands[1], operands[2]));
7514 DONE;
7515 }
7516 else
7517 FAIL;
7518 }")
7519
7520 (define_insn "*ashrdi3_internal1"
7521 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
7522 (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
7523 (match_operand:SI 2 "reg_or_cint_operand" "r,i")))]
7524 "TARGET_POWERPC64"
7525 "@
7526 srad %0,%1,%2
7527 sradi %0,%1,%H2"
7528 [(set_attr "type" "var_shift_rotate,shift")])
7529
7530 (define_insn "*ashrdi3_internal2"
7531 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
7532 (compare:CC (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
7533 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
7534 (const_int 0)))
7535 (clobber (match_scratch:DI 3 "=r,r,r,r"))]
7536 "TARGET_64BIT"
7537 "@
7538 srad. %3,%1,%2
7539 sradi. %3,%1,%H2
7540 #
7541 #"
7542 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
7543 (set_attr "length" "4,4,8,8")])
7544
7545 (define_split
7546 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
7547 (compare:CC (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
7548 (match_operand:SI 2 "reg_or_cint_operand" ""))
7549 (const_int 0)))
7550 (clobber (match_scratch:DI 3 ""))]
7551 "TARGET_POWERPC64 && reload_completed"
7552 [(set (match_dup 3)
7553 (ashiftrt:DI (match_dup 1) (match_dup 2)))
7554 (set (match_dup 0)
7555 (compare:CC (match_dup 3)
7556 (const_int 0)))]
7557 "")
7558
7559 (define_insn "*ashrdi3_internal3"
7560 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
7561 (compare:CC (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,r,r")
7562 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
7563 (const_int 0)))
7564 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,r")
7565 (ashiftrt:DI (match_dup 1) (match_dup 2)))]
7566 "TARGET_64BIT"
7567 "@
7568 srad. %0,%1,%2
7569 sradi. %0,%1,%H2
7570 #
7571 #"
7572 [(set_attr "type" "var_delayed_compare,delayed_compare,var_delayed_compare,delayed_compare")
7573 (set_attr "length" "4,4,8,8")])
7574
7575 (define_split
7576 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
7577 (compare:CC (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
7578 (match_operand:SI 2 "reg_or_cint_operand" ""))
7579 (const_int 0)))
7580 (set (match_operand:DI 0 "gpc_reg_operand" "")
7581 (ashiftrt:DI (match_dup 1) (match_dup 2)))]
7582 "TARGET_POWERPC64 && reload_completed"
7583 [(set (match_dup 0)
7584 (ashiftrt:DI (match_dup 1) (match_dup 2)))
7585 (set (match_dup 3)
7586 (compare:CC (match_dup 0)
7587 (const_int 0)))]
7588 "")
7589
7590 (define_expand "anddi3"
7591 [(parallel
7592 [(set (match_operand:DI 0 "gpc_reg_operand" "")
7593 (and:DI (match_operand:DI 1 "gpc_reg_operand" "")
7594 (match_operand:DI 2 "and64_2_operand" "")))
7595 (clobber (match_scratch:CC 3 ""))])]
7596 "TARGET_POWERPC64"
7597 "")
7598
7599 (define_insn "anddi3_mc"
7600 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,r,r,r")
7601 (and:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r,r,r,r")
7602 (match_operand:DI 2 "and64_2_operand" "?r,S,T,K,J,t")))
7603 (clobber (match_scratch:CC 3 "=X,X,X,x,x,X"))]
7604 "TARGET_POWERPC64 && rs6000_gen_cell_microcode"
7605 "@
7606 and %0,%1,%2
7607 rldic%B2 %0,%1,0,%S2
7608 rlwinm %0,%1,0,%m2,%M2
7609 andi. %0,%1,%b2
7610 andis. %0,%1,%u2
7611 #"
7612 [(set_attr "type" "*,*,*,compare,compare,*")
7613 (set_attr "length" "4,4,4,4,4,8")])
7614
7615 (define_insn "anddi3_nomc"
7616 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,r")
7617 (and:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r,r")
7618 (match_operand:DI 2 "and64_2_operand" "?r,S,T,t")))
7619 (clobber (match_scratch:CC 3 "=X,X,X,X"))]
7620 "TARGET_POWERPC64 && !rs6000_gen_cell_microcode"
7621 "@
7622 and %0,%1,%2
7623 rldic%B2 %0,%1,0,%S2
7624 rlwinm %0,%1,0,%m2,%M2
7625 #"
7626 [(set_attr "length" "4,4,4,8")])
7627
7628 (define_split
7629 [(set (match_operand:DI 0 "gpc_reg_operand" "")
7630 (and:DI (match_operand:DI 1 "gpc_reg_operand" "")
7631 (match_operand:DI 2 "mask64_2_operand" "")))
7632 (clobber (match_scratch:CC 3 ""))]
7633 "TARGET_POWERPC64
7634 && (fixed_regs[CR0_REGNO] || !logical_operand (operands[2], DImode))
7635 && !mask_operand (operands[2], DImode)
7636 && !mask64_operand (operands[2], DImode)"
7637 [(set (match_dup 0)
7638 (and:DI (rotate:DI (match_dup 1)
7639 (match_dup 4))
7640 (match_dup 5)))
7641 (set (match_dup 0)
7642 (and:DI (rotate:DI (match_dup 0)
7643 (match_dup 6))
7644 (match_dup 7)))]
7645 {
7646 build_mask64_2_operands (operands[2], &operands[4]);
7647 })
7648
7649 (define_insn "*anddi3_internal2_mc"
7650 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,x,x,?y,?y,?y,??y,??y,?y")
7651 (compare:CC (and:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r,r,r,r,r")
7652 (match_operand:DI 2 "and64_2_operand" "r,S,T,K,J,t,r,S,T,K,J,t"))
7653 (const_int 0)))
7654 (clobber (match_scratch:DI 3 "=r,r,r,r,r,r,r,r,r,r,r,r"))
7655 (clobber (match_scratch:CC 4 "=X,X,X,X,X,X,X,X,X,x,x,X"))]
7656 "TARGET_64BIT && rs6000_gen_cell_microcode"
7657 "@
7658 and. %3,%1,%2
7659 rldic%B2. %3,%1,0,%S2
7660 rlwinm. %3,%1,0,%m2,%M2
7661 andi. %3,%1,%b2
7662 andis. %3,%1,%u2
7663 #
7664 #
7665 #
7666 #
7667 #
7668 #
7669 #"
7670 [(set_attr "type" "compare,compare,delayed_compare,compare,compare,compare,compare,compare,compare,compare,compare,compare")
7671 (set_attr "length" "4,4,4,4,4,8,8,8,8,8,8,12")])
7672
7673 (define_split
7674 [(set (match_operand:CC 0 "cc_reg_operand" "")
7675 (compare:CC (and:DI (match_operand:DI 1 "gpc_reg_operand" "")
7676 (match_operand:DI 2 "mask64_2_operand" ""))
7677 (const_int 0)))
7678 (clobber (match_scratch:DI 3 ""))
7679 (clobber (match_scratch:CC 4 ""))]
7680 "TARGET_64BIT && reload_completed
7681 && (fixed_regs[CR0_REGNO] || !logical_operand (operands[2], DImode))
7682 && !mask_operand (operands[2], DImode)
7683 && !mask64_operand (operands[2], DImode)"
7684 [(set (match_dup 3)
7685 (and:DI (rotate:DI (match_dup 1)
7686 (match_dup 5))
7687 (match_dup 6)))
7688 (parallel [(set (match_dup 0)
7689 (compare:CC (and:DI (rotate:DI (match_dup 3)
7690 (match_dup 7))
7691 (match_dup 8))
7692 (const_int 0)))
7693 (clobber (match_dup 3))])]
7694 "
7695 {
7696 build_mask64_2_operands (operands[2], &operands[5]);
7697 }")
7698
7699 (define_insn "*anddi3_internal3_mc"
7700 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,x,x,x,?y,?y,?y,??y,??y,?y")
7701 (compare:CC (and:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r,r,r,r,r")
7702 (match_operand:DI 2 "and64_2_operand" "r,S,T,K,J,t,r,S,T,K,J,t"))
7703 (const_int 0)))
7704 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,r,r,r,r,r,r,r,r,r")
7705 (and:DI (match_dup 1) (match_dup 2)))
7706 (clobber (match_scratch:CC 4 "=X,X,X,X,X,X,X,X,X,x,x,X"))]
7707 "TARGET_64BIT && rs6000_gen_cell_microcode"
7708 "@
7709 and. %0,%1,%2
7710 rldic%B2. %0,%1,0,%S2
7711 rlwinm. %0,%1,0,%m2,%M2
7712 andi. %0,%1,%b2
7713 andis. %0,%1,%u2
7714 #
7715 #
7716 #
7717 #
7718 #
7719 #
7720 #"
7721 [(set_attr "type" "compare,compare,delayed_compare,compare,compare,compare,compare,compare,compare,compare,compare,compare")
7722 (set_attr "length" "4,4,4,4,4,8,8,8,8,8,8,12")])
7723
7724 (define_split
7725 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
7726 (compare:CC (and:DI (match_operand:DI 1 "gpc_reg_operand" "")
7727 (match_operand:DI 2 "and64_2_operand" ""))
7728 (const_int 0)))
7729 (set (match_operand:DI 0 "gpc_reg_operand" "")
7730 (and:DI (match_dup 1) (match_dup 2)))
7731 (clobber (match_scratch:CC 4 ""))]
7732 "TARGET_64BIT && reload_completed"
7733 [(parallel [(set (match_dup 0)
7734 (and:DI (match_dup 1) (match_dup 2)))
7735 (clobber (match_dup 4))])
7736 (set (match_dup 3)
7737 (compare:CC (match_dup 0)
7738 (const_int 0)))]
7739 "")
7740
7741 (define_split
7742 [(set (match_operand:CC 3 "cc_reg_operand" "")
7743 (compare:CC (and:DI (match_operand:DI 1 "gpc_reg_operand" "")
7744 (match_operand:DI 2 "mask64_2_operand" ""))
7745 (const_int 0)))
7746 (set (match_operand:DI 0 "gpc_reg_operand" "")
7747 (and:DI (match_dup 1) (match_dup 2)))
7748 (clobber (match_scratch:CC 4 ""))]
7749 "TARGET_64BIT && reload_completed
7750 && (fixed_regs[CR0_REGNO] || !logical_operand (operands[2], DImode))
7751 && !mask_operand (operands[2], DImode)
7752 && !mask64_operand (operands[2], DImode)"
7753 [(set (match_dup 0)
7754 (and:DI (rotate:DI (match_dup 1)
7755 (match_dup 5))
7756 (match_dup 6)))
7757 (parallel [(set (match_dup 3)
7758 (compare:CC (and:DI (rotate:DI (match_dup 0)
7759 (match_dup 7))
7760 (match_dup 8))
7761 (const_int 0)))
7762 (set (match_dup 0)
7763 (and:DI (rotate:DI (match_dup 0)
7764 (match_dup 7))
7765 (match_dup 8)))])]
7766 "
7767 {
7768 build_mask64_2_operands (operands[2], &operands[5]);
7769 }")
7770
7771 (define_expand "iordi3"
7772 [(set (match_operand:DI 0 "gpc_reg_operand" "")
7773 (ior:DI (match_operand:DI 1 "gpc_reg_operand" "")
7774 (match_operand:DI 2 "reg_or_logical_cint_operand" "")))]
7775 "TARGET_POWERPC64"
7776 "
7777 {
7778 if (non_logical_cint_operand (operands[2], DImode))
7779 {
7780 HOST_WIDE_INT value;
7781 rtx tmp = ((!can_create_pseudo_p ()
7782 || rtx_equal_p (operands[0], operands[1]))
7783 ? operands[0] : gen_reg_rtx (DImode));
7784
7785 if (GET_CODE (operands[2]) == CONST_INT)
7786 {
7787 value = INTVAL (operands[2]);
7788 emit_insn (gen_iordi3 (tmp, operands[1],
7789 GEN_INT (value & (~ (HOST_WIDE_INT) 0xffff))));
7790 }
7791 else
7792 {
7793 value = CONST_DOUBLE_LOW (operands[2]);
7794 emit_insn (gen_iordi3 (tmp, operands[1],
7795 immed_double_const (value
7796 & (~ (HOST_WIDE_INT) 0xffff),
7797 0, DImode)));
7798 }
7799
7800 emit_insn (gen_iordi3 (operands[0], tmp, GEN_INT (value & 0xffff)));
7801 DONE;
7802 }
7803 }")
7804
7805 (define_expand "xordi3"
7806 [(set (match_operand:DI 0 "gpc_reg_operand" "")
7807 (xor:DI (match_operand:DI 1 "gpc_reg_operand" "")
7808 (match_operand:DI 2 "reg_or_logical_cint_operand" "")))]
7809 "TARGET_POWERPC64"
7810 "
7811 {
7812 if (non_logical_cint_operand (operands[2], DImode))
7813 {
7814 HOST_WIDE_INT value;
7815 rtx tmp = ((!can_create_pseudo_p ()
7816 || rtx_equal_p (operands[0], operands[1]))
7817 ? operands[0] : gen_reg_rtx (DImode));
7818
7819 if (GET_CODE (operands[2]) == CONST_INT)
7820 {
7821 value = INTVAL (operands[2]);
7822 emit_insn (gen_xordi3 (tmp, operands[1],
7823 GEN_INT (value & (~ (HOST_WIDE_INT) 0xffff))));
7824 }
7825 else
7826 {
7827 value = CONST_DOUBLE_LOW (operands[2]);
7828 emit_insn (gen_xordi3 (tmp, operands[1],
7829 immed_double_const (value
7830 & (~ (HOST_WIDE_INT) 0xffff),
7831 0, DImode)));
7832 }
7833
7834 emit_insn (gen_xordi3 (operands[0], tmp, GEN_INT (value & 0xffff)));
7835 DONE;
7836 }
7837 }")
7838
7839 (define_insn "*booldi3_internal1"
7840 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r")
7841 (match_operator:DI 3 "boolean_or_operator"
7842 [(match_operand:DI 1 "gpc_reg_operand" "%r,r,r")
7843 (match_operand:DI 2 "logical_operand" "r,K,JF")]))]
7844 "TARGET_POWERPC64"
7845 "@
7846 %q3 %0,%1,%2
7847 %q3i %0,%1,%b2
7848 %q3is %0,%1,%u2")
7849
7850 (define_insn "*booldi3_internal2"
7851 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
7852 (compare:CC (match_operator:DI 4 "boolean_or_operator"
7853 [(match_operand:DI 1 "gpc_reg_operand" "%r,r")
7854 (match_operand:DI 2 "gpc_reg_operand" "r,r")])
7855 (const_int 0)))
7856 (clobber (match_scratch:DI 3 "=r,r"))]
7857 "TARGET_64BIT"
7858 "@
7859 %q4. %3,%1,%2
7860 #"
7861 [(set_attr "type" "compare")
7862 (set_attr "length" "4,8")])
7863
7864 (define_split
7865 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
7866 (compare:CC (match_operator:DI 4 "boolean_operator"
7867 [(match_operand:DI 1 "gpc_reg_operand" "")
7868 (match_operand:DI 2 "gpc_reg_operand" "")])
7869 (const_int 0)))
7870 (clobber (match_scratch:DI 3 ""))]
7871 "TARGET_POWERPC64 && reload_completed"
7872 [(set (match_dup 3) (match_dup 4))
7873 (set (match_dup 0)
7874 (compare:CC (match_dup 3)
7875 (const_int 0)))]
7876 "")
7877
7878 (define_insn "*booldi3_internal3"
7879 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
7880 (compare:CC (match_operator:DI 4 "boolean_or_operator"
7881 [(match_operand:DI 1 "gpc_reg_operand" "%r,r")
7882 (match_operand:DI 2 "gpc_reg_operand" "r,r")])
7883 (const_int 0)))
7884 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
7885 (match_dup 4))]
7886 "TARGET_64BIT"
7887 "@
7888 %q4. %0,%1,%2
7889 #"
7890 [(set_attr "type" "compare")
7891 (set_attr "length" "4,8")])
7892
7893 (define_split
7894 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
7895 (compare:CC (match_operator:DI 4 "boolean_operator"
7896 [(match_operand:DI 1 "gpc_reg_operand" "")
7897 (match_operand:DI 2 "gpc_reg_operand" "")])
7898 (const_int 0)))
7899 (set (match_operand:DI 0 "gpc_reg_operand" "")
7900 (match_dup 4))]
7901 "TARGET_POWERPC64 && reload_completed"
7902 [(set (match_dup 0) (match_dup 4))
7903 (set (match_dup 3)
7904 (compare:CC (match_dup 0)
7905 (const_int 0)))]
7906 "")
7907
7908 ;; Split a logical operation that we can't do in one insn into two insns,
7909 ;; each of which does one 16-bit part. This is used by combine.
7910
7911 (define_split
7912 [(set (match_operand:DI 0 "gpc_reg_operand" "")
7913 (match_operator:DI 3 "boolean_or_operator"
7914 [(match_operand:DI 1 "gpc_reg_operand" "")
7915 (match_operand:DI 2 "non_logical_cint_operand" "")]))]
7916 "TARGET_POWERPC64"
7917 [(set (match_dup 0) (match_dup 4))
7918 (set (match_dup 0) (match_dup 5))]
7919 "
7920 {
7921 rtx i3,i4;
7922
7923 if (GET_CODE (operands[2]) == CONST_DOUBLE)
7924 {
7925 HOST_WIDE_INT value = CONST_DOUBLE_LOW (operands[2]);
7926 i3 = immed_double_const (value & (~ (HOST_WIDE_INT) 0xffff),
7927 0, DImode);
7928 i4 = GEN_INT (value & 0xffff);
7929 }
7930 else
7931 {
7932 i3 = GEN_INT (INTVAL (operands[2])
7933 & (~ (HOST_WIDE_INT) 0xffff));
7934 i4 = GEN_INT (INTVAL (operands[2]) & 0xffff);
7935 }
7936 operands[4] = gen_rtx_fmt_ee (GET_CODE (operands[3]), DImode,
7937 operands[1], i3);
7938 operands[5] = gen_rtx_fmt_ee (GET_CODE (operands[3]), DImode,
7939 operands[0], i4);
7940 }")
7941
7942 (define_insn "*boolcdi3_internal1"
7943 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
7944 (match_operator:DI 3 "boolean_operator"
7945 [(not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
7946 (match_operand:DI 2 "gpc_reg_operand" "r")]))]
7947 "TARGET_POWERPC64"
7948 "%q3 %0,%2,%1")
7949
7950 (define_insn "*boolcdi3_internal2"
7951 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
7952 (compare:CC (match_operator:DI 4 "boolean_operator"
7953 [(not:DI (match_operand:DI 1 "gpc_reg_operand" "r,r"))
7954 (match_operand:DI 2 "gpc_reg_operand" "r,r")])
7955 (const_int 0)))
7956 (clobber (match_scratch:DI 3 "=r,r"))]
7957 "TARGET_64BIT"
7958 "@
7959 %q4. %3,%2,%1
7960 #"
7961 [(set_attr "type" "compare")
7962 (set_attr "length" "4,8")])
7963
7964 (define_split
7965 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
7966 (compare:CC (match_operator:DI 4 "boolean_operator"
7967 [(not:DI (match_operand:DI 1 "gpc_reg_operand" ""))
7968 (match_operand:DI 2 "gpc_reg_operand" "")])
7969 (const_int 0)))
7970 (clobber (match_scratch:DI 3 ""))]
7971 "TARGET_POWERPC64 && reload_completed"
7972 [(set (match_dup 3) (match_dup 4))
7973 (set (match_dup 0)
7974 (compare:CC (match_dup 3)
7975 (const_int 0)))]
7976 "")
7977
7978 (define_insn "*boolcdi3_internal3"
7979 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
7980 (compare:CC (match_operator:DI 4 "boolean_operator"
7981 [(not:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r"))
7982 (match_operand:DI 2 "gpc_reg_operand" "r,r")])
7983 (const_int 0)))
7984 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
7985 (match_dup 4))]
7986 "TARGET_64BIT"
7987 "@
7988 %q4. %0,%2,%1
7989 #"
7990 [(set_attr "type" "compare")
7991 (set_attr "length" "4,8")])
7992
7993 (define_split
7994 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
7995 (compare:CC (match_operator:DI 4 "boolean_operator"
7996 [(not:DI (match_operand:DI 1 "gpc_reg_operand" ""))
7997 (match_operand:DI 2 "gpc_reg_operand" "")])
7998 (const_int 0)))
7999 (set (match_operand:DI 0 "gpc_reg_operand" "")
8000 (match_dup 4))]
8001 "TARGET_POWERPC64 && reload_completed"
8002 [(set (match_dup 0) (match_dup 4))
8003 (set (match_dup 3)
8004 (compare:CC (match_dup 0)
8005 (const_int 0)))]
8006 "")
8007
8008 (define_insn "*boolccdi3_internal1"
8009 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
8010 (match_operator:DI 3 "boolean_operator"
8011 [(not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
8012 (not:DI (match_operand:DI 2 "gpc_reg_operand" "r"))]))]
8013 "TARGET_POWERPC64"
8014 "%q3 %0,%1,%2")
8015
8016 (define_insn "*boolccdi3_internal2"
8017 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
8018 (compare:CC (match_operator:DI 4 "boolean_operator"
8019 [(not:DI (match_operand:DI 1 "gpc_reg_operand" "r,r"))
8020 (not:DI (match_operand:DI 2 "gpc_reg_operand" "r,r"))])
8021 (const_int 0)))
8022 (clobber (match_scratch:DI 3 "=r,r"))]
8023 "TARGET_64BIT"
8024 "@
8025 %q4. %3,%1,%2
8026 #"
8027 [(set_attr "type" "compare")
8028 (set_attr "length" "4,8")])
8029
8030 (define_split
8031 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
8032 (compare:CC (match_operator:DI 4 "boolean_operator"
8033 [(not:DI (match_operand:DI 1 "gpc_reg_operand" ""))
8034 (not:DI (match_operand:DI 2 "gpc_reg_operand" ""))])
8035 (const_int 0)))
8036 (clobber (match_scratch:DI 3 ""))]
8037 "TARGET_POWERPC64 && reload_completed"
8038 [(set (match_dup 3) (match_dup 4))
8039 (set (match_dup 0)
8040 (compare:CC (match_dup 3)
8041 (const_int 0)))]
8042 "")
8043
8044 (define_insn "*boolccdi3_internal3"
8045 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
8046 (compare:CC (match_operator:DI 4 "boolean_operator"
8047 [(not:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r"))
8048 (not:DI (match_operand:DI 2 "gpc_reg_operand" "r,r"))])
8049 (const_int 0)))
8050 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
8051 (match_dup 4))]
8052 "TARGET_64BIT"
8053 "@
8054 %q4. %0,%1,%2
8055 #"
8056 [(set_attr "type" "compare")
8057 (set_attr "length" "4,8")])
8058
8059 (define_split
8060 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
8061 (compare:CC (match_operator:DI 4 "boolean_operator"
8062 [(not:DI (match_operand:DI 1 "gpc_reg_operand" ""))
8063 (not:DI (match_operand:DI 2 "gpc_reg_operand" ""))])
8064 (const_int 0)))
8065 (set (match_operand:DI 0 "gpc_reg_operand" "")
8066 (match_dup 4))]
8067 "TARGET_POWERPC64 && reload_completed"
8068 [(set (match_dup 0) (match_dup 4))
8069 (set (match_dup 3)
8070 (compare:CC (match_dup 0)
8071 (const_int 0)))]
8072 "")
8073 \f
8074 ;; Now define ways of moving data around.
8075
8076 ;; Set up a register with a value from the GOT table
8077
8078 (define_expand "movsi_got"
8079 [(set (match_operand:SI 0 "gpc_reg_operand" "")
8080 (unspec:SI [(match_operand:SI 1 "got_operand" "")
8081 (match_dup 2)] UNSPEC_MOVSI_GOT))]
8082 "DEFAULT_ABI == ABI_V4 && flag_pic == 1"
8083 "
8084 {
8085 if (GET_CODE (operands[1]) == CONST)
8086 {
8087 rtx offset = const0_rtx;
8088 HOST_WIDE_INT value;
8089
8090 operands[1] = eliminate_constant_term (XEXP (operands[1], 0), &offset);
8091 value = INTVAL (offset);
8092 if (value != 0)
8093 {
8094 rtx tmp = (!can_create_pseudo_p ()
8095 ? operands[0]
8096 : gen_reg_rtx (Pmode));
8097 emit_insn (gen_movsi_got (tmp, operands[1]));
8098 emit_insn (gen_addsi3 (operands[0], tmp, offset));
8099 DONE;
8100 }
8101 }
8102
8103 operands[2] = rs6000_got_register (operands[1]);
8104 }")
8105
8106 (define_insn "*movsi_got_internal"
8107 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8108 (unspec:SI [(match_operand:SI 1 "got_no_const_operand" "")
8109 (match_operand:SI 2 "gpc_reg_operand" "b")]
8110 UNSPEC_MOVSI_GOT))]
8111 "DEFAULT_ABI == ABI_V4 && flag_pic == 1"
8112 "{l|lwz} %0,%a1@got(%2)"
8113 [(set_attr "type" "load")])
8114
8115 ;; Used by sched, shorten_branches and final when the GOT pseudo reg
8116 ;; didn't get allocated to a hard register.
8117 (define_split
8118 [(set (match_operand:SI 0 "gpc_reg_operand" "")
8119 (unspec:SI [(match_operand:SI 1 "got_no_const_operand" "")
8120 (match_operand:SI 2 "memory_operand" "")]
8121 UNSPEC_MOVSI_GOT))]
8122 "DEFAULT_ABI == ABI_V4
8123 && flag_pic == 1
8124 && (reload_in_progress || reload_completed)"
8125 [(set (match_dup 0) (match_dup 2))
8126 (set (match_dup 0) (unspec:SI [(match_dup 1)(match_dup 0)]
8127 UNSPEC_MOVSI_GOT))]
8128 "")
8129
8130 ;; For SI, we special-case integers that can't be loaded in one insn. We
8131 ;; do the load 16-bits at a time. We could do this by loading from memory,
8132 ;; and this is even supposed to be faster, but it is simpler not to get
8133 ;; integers in the TOC.
8134 (define_insn "movsi_low"
8135 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8136 (mem:SI (lo_sum:SI (match_operand:SI 1 "gpc_reg_operand" "b")
8137 (match_operand 2 "" ""))))]
8138 "TARGET_MACHO && ! TARGET_64BIT"
8139 "{l|lwz} %0,lo16(%2)(%1)"
8140 [(set_attr "type" "load")
8141 (set_attr "length" "4")])
8142
8143 (define_insn "*movsi_internal1"
8144 [(set (match_operand:SI 0 "rs6000_nonimmediate_operand" "=r,r,r,m,r,r,r,r,r,*q,*c*l,*h,*h")
8145 (match_operand:SI 1 "input_operand" "r,U,m,r,I,L,n,R,*h,r,r,r,0"))]
8146 "!TARGET_SINGLE_FPU &&
8147 (gpc_reg_operand (operands[0], SImode) || gpc_reg_operand (operands[1], SImode))"
8148 "@
8149 mr %0,%1
8150 {cal|la} %0,%a1
8151 {l%U1%X1|lwz%U1%X1} %0,%1
8152 {st%U0%X0|stw%U0%X0} %1,%0
8153 {lil|li} %0,%1
8154 {liu|lis} %0,%v1
8155 #
8156 {cal|la} %0,%a1
8157 mf%1 %0
8158 mt%0 %1
8159 mt%0 %1
8160 mt%0 %1
8161 {cror 0,0,0|nop}"
8162 [(set_attr "type" "*,*,load,store,*,*,*,*,mfjmpr,*,mtjmpr,*,*")
8163 (set_attr "length" "4,4,4,4,4,4,8,4,4,4,4,4,4")])
8164
8165 (define_insn "*movsi_internal1_single"
8166 [(set (match_operand:SI 0 "rs6000_nonimmediate_operand" "=r,r,r,m,r,r,r,r,r,*q,*c*l,*h,*h,m,*f")
8167 (match_operand:SI 1 "input_operand" "r,U,m,r,I,L,n,R,*h,r,r,r,0,f,m"))]
8168 "TARGET_SINGLE_FPU &&
8169 (gpc_reg_operand (operands[0], SImode) || gpc_reg_operand (operands[1], SImode))"
8170 "@
8171 mr %0,%1
8172 {cal|la} %0,%a1
8173 {l%U1%X1|lwz%U1%X1} %0,%1
8174 {st%U0%X0|stw%U0%X0} %1,%0
8175 {lil|li} %0,%1
8176 {liu|lis} %0,%v1
8177 #
8178 {cal|la} %0,%a1
8179 mf%1 %0
8180 mt%0 %1
8181 mt%0 %1
8182 mt%0 %1
8183 {cror 0,0,0|nop}
8184 stfs%U0%X0 %1, %0
8185 lfs%U1%X1 %0, %1"
8186 [(set_attr "type" "*,*,load,store,*,*,*,*,mfjmpr,*,mtjmpr,*,*,*,*")
8187 (set_attr "length" "4,4,4,4,4,4,8,4,4,4,4,4,4,4,4")])
8188
8189 ;; Split a load of a large constant into the appropriate two-insn
8190 ;; sequence.
8191
8192 (define_split
8193 [(set (match_operand:SI 0 "gpc_reg_operand" "")
8194 (match_operand:SI 1 "const_int_operand" ""))]
8195 "(unsigned HOST_WIDE_INT) (INTVAL (operands[1]) + 0x8000) >= 0x10000
8196 && (INTVAL (operands[1]) & 0xffff) != 0"
8197 [(set (match_dup 0)
8198 (match_dup 2))
8199 (set (match_dup 0)
8200 (ior:SI (match_dup 0)
8201 (match_dup 3)))]
8202 "
8203 { rtx tem = rs6000_emit_set_const (operands[0], SImode, operands[1], 2);
8204
8205 if (tem == operands[0])
8206 DONE;
8207 else
8208 FAIL;
8209 }")
8210
8211 (define_insn "*mov<mode>_internal2"
8212 [(set (match_operand:CC 2 "cc_reg_operand" "=y,x,?y")
8213 (compare:CC (match_operand:P 1 "gpc_reg_operand" "0,r,r")
8214 (const_int 0)))
8215 (set (match_operand:P 0 "gpc_reg_operand" "=r,r,r") (match_dup 1))]
8216 ""
8217 "@
8218 {cmpi|cmp<wd>i} %2,%0,0
8219 mr. %0,%1
8220 #"
8221 [(set_attr "type" "cmp,compare,cmp")
8222 (set_attr "length" "4,4,8")])
8223
8224 (define_split
8225 [(set (match_operand:CC 2 "cc_reg_not_micro_cr0_operand" "")
8226 (compare:CC (match_operand:P 1 "gpc_reg_operand" "")
8227 (const_int 0)))
8228 (set (match_operand:P 0 "gpc_reg_operand" "") (match_dup 1))]
8229 "reload_completed"
8230 [(set (match_dup 0) (match_dup 1))
8231 (set (match_dup 2)
8232 (compare:CC (match_dup 0)
8233 (const_int 0)))]
8234 "")
8235 \f
8236 (define_insn "*movhi_internal"
8237 [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,m,r,r,*q,*c*l,*h")
8238 (match_operand:HI 1 "input_operand" "r,m,r,i,*h,r,r,0"))]
8239 "gpc_reg_operand (operands[0], HImode)
8240 || gpc_reg_operand (operands[1], HImode)"
8241 "@
8242 mr %0,%1
8243 lhz%U1%X1 %0,%1
8244 sth%U0%X0 %1,%0
8245 {lil|li} %0,%w1
8246 mf%1 %0
8247 mt%0 %1
8248 mt%0 %1
8249 {cror 0,0,0|nop}"
8250 [(set_attr "type" "*,load,store,*,mfjmpr,*,mtjmpr,*")])
8251
8252 (define_expand "mov<mode>"
8253 [(set (match_operand:INT 0 "general_operand" "")
8254 (match_operand:INT 1 "any_operand" ""))]
8255 ""
8256 "{ rs6000_emit_move (operands[0], operands[1], <MODE>mode); DONE; }")
8257
8258 (define_insn "*movqi_internal"
8259 [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,m,r,r,*q,*c*l,*h")
8260 (match_operand:QI 1 "input_operand" "r,m,r,i,*h,r,r,0"))]
8261 "gpc_reg_operand (operands[0], QImode)
8262 || gpc_reg_operand (operands[1], QImode)"
8263 "@
8264 mr %0,%1
8265 lbz%U1%X1 %0,%1
8266 stb%U0%X0 %1,%0
8267 {lil|li} %0,%1
8268 mf%1 %0
8269 mt%0 %1
8270 mt%0 %1
8271 {cror 0,0,0|nop}"
8272 [(set_attr "type" "*,load,store,*,mfjmpr,*,mtjmpr,*")])
8273 \f
8274 ;; Here is how to move condition codes around. When we store CC data in
8275 ;; an integer register or memory, we store just the high-order 4 bits.
8276 ;; This lets us not shift in the most common case of CR0.
8277 (define_expand "movcc"
8278 [(set (match_operand:CC 0 "nonimmediate_operand" "")
8279 (match_operand:CC 1 "nonimmediate_operand" ""))]
8280 ""
8281 "")
8282
8283 (define_insn "*movcc_internal1"
8284 [(set (match_operand:CC 0 "nonimmediate_operand" "=y,x,?y,y,r,r,r,r,r,q,cl,r,m")
8285 (match_operand:CC 1 "general_operand" "y,r,r,O,x,y,r,I,h,r,r,m,r"))]
8286 "register_operand (operands[0], CCmode)
8287 || register_operand (operands[1], CCmode)"
8288 "@
8289 mcrf %0,%1
8290 mtcrf 128,%1
8291 {rlinm|rlwinm} %1,%1,%F0,0xffffffff\;mtcrf %R0,%1\;{rlinm|rlwinm} %1,%1,%f0,0xffffffff
8292 crxor %0,%0,%0
8293 mfcr %0%Q1
8294 mfcr %0%Q1\;{rlinm|rlwinm} %0,%0,%f1,0xf0000000
8295 mr %0,%1
8296 {lil|li} %0,%1
8297 mf%1 %0
8298 mt%0 %1
8299 mt%0 %1
8300 {l%U1%X1|lwz%U1%X1} %0,%1
8301 {st%U0%U1|stw%U0%U1} %1,%0"
8302 [(set (attr "type")
8303 (cond [(eq_attr "alternative" "0,3")
8304 (const_string "cr_logical")
8305 (eq_attr "alternative" "1,2")
8306 (const_string "mtcr")
8307 (eq_attr "alternative" "6,7,9")
8308 (const_string "integer")
8309 (eq_attr "alternative" "8")
8310 (const_string "mfjmpr")
8311 (eq_attr "alternative" "10")
8312 (const_string "mtjmpr")
8313 (eq_attr "alternative" "11")
8314 (const_string "load")
8315 (eq_attr "alternative" "12")
8316 (const_string "store")
8317 (ne (symbol_ref "TARGET_MFCRF") (const_int 0))
8318 (const_string "mfcrf")
8319 ]
8320 (const_string "mfcr")))
8321 (set_attr "length" "4,4,12,4,4,8,4,4,4,4,4,4,4")])
8322 \f
8323 ;; For floating-point, we normally deal with the floating-point registers
8324 ;; unless -msoft-float is used. The sole exception is that parameter passing
8325 ;; can produce floating-point values in fixed-point registers. Unless the
8326 ;; value is a simple constant or already in memory, we deal with this by
8327 ;; allocating memory and copying the value explicitly via that memory location.
8328 (define_expand "movsf"
8329 [(set (match_operand:SF 0 "nonimmediate_operand" "")
8330 (match_operand:SF 1 "any_operand" ""))]
8331 ""
8332 "{ rs6000_emit_move (operands[0], operands[1], SFmode); DONE; }")
8333
8334 (define_split
8335 [(set (match_operand:SF 0 "gpc_reg_operand" "")
8336 (match_operand:SF 1 "const_double_operand" ""))]
8337 "reload_completed
8338 && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
8339 || (GET_CODE (operands[0]) == SUBREG
8340 && GET_CODE (SUBREG_REG (operands[0])) == REG
8341 && REGNO (SUBREG_REG (operands[0])) <= 31))"
8342 [(set (match_dup 2) (match_dup 3))]
8343 "
8344 {
8345 long l;
8346 REAL_VALUE_TYPE rv;
8347
8348 REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
8349 REAL_VALUE_TO_TARGET_SINGLE (rv, l);
8350
8351 if (! TARGET_POWERPC64)
8352 operands[2] = operand_subword (operands[0], 0, 0, SFmode);
8353 else
8354 operands[2] = gen_lowpart (SImode, operands[0]);
8355
8356 operands[3] = gen_int_mode (l, SImode);
8357 }")
8358
8359 (define_insn "*movsf_hardfloat"
8360 [(set (match_operand:SF 0 "nonimmediate_operand" "=!r,!r,m,f,f,m,*c*l,*q,!r,*h,!r,!r")
8361 (match_operand:SF 1 "input_operand" "r,m,r,f,m,f,r,r,h,0,G,Fn"))]
8362 "(gpc_reg_operand (operands[0], SFmode)
8363 || gpc_reg_operand (operands[1], SFmode))
8364 && (TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT)"
8365 "@
8366 mr %0,%1
8367 {l%U1%X1|lwz%U1%X1} %0,%1
8368 {st%U0%X0|stw%U0%X0} %1,%0
8369 fmr %0,%1
8370 lfs%U1%X1 %0,%1
8371 stfs%U0%X0 %1,%0
8372 mt%0 %1
8373 mt%0 %1
8374 mf%1 %0
8375 {cror 0,0,0|nop}
8376 #
8377 #"
8378 [(set_attr "type" "*,load,store,fp,fpload,fpstore,mtjmpr,*,mfjmpr,*,*,*")
8379 (set_attr "length" "4,4,4,4,4,4,4,4,4,4,4,8")])
8380
8381 (define_insn "*movsf_softfloat"
8382 [(set (match_operand:SF 0 "nonimmediate_operand" "=r,cl,q,r,r,m,r,r,r,r,r,*h")
8383 (match_operand:SF 1 "input_operand" "r,r,r,h,m,r,I,L,R,G,Fn,0"))]
8384 "(gpc_reg_operand (operands[0], SFmode)
8385 || gpc_reg_operand (operands[1], SFmode))
8386 && (TARGET_SOFT_FLOAT || !TARGET_FPRS)"
8387 "@
8388 mr %0,%1
8389 mt%0 %1
8390 mt%0 %1
8391 mf%1 %0
8392 {l%U1%X1|lwz%U1%X1} %0,%1
8393 {st%U0%X0|stw%U0%X0} %1,%0
8394 {lil|li} %0,%1
8395 {liu|lis} %0,%v1
8396 {cal|la} %0,%a1
8397 #
8398 #
8399 {cror 0,0,0|nop}"
8400 [(set_attr "type" "*,mtjmpr,*,mfjmpr,load,store,*,*,*,*,*,*")
8401 (set_attr "length" "4,4,4,4,4,4,4,4,4,4,8,4")])
8402
8403 \f
8404 (define_expand "movdf"
8405 [(set (match_operand:DF 0 "nonimmediate_operand" "")
8406 (match_operand:DF 1 "any_operand" ""))]
8407 ""
8408 "{ rs6000_emit_move (operands[0], operands[1], DFmode); DONE; }")
8409
8410 (define_split
8411 [(set (match_operand:DF 0 "gpc_reg_operand" "")
8412 (match_operand:DF 1 "const_int_operand" ""))]
8413 "! TARGET_POWERPC64 && reload_completed
8414 && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
8415 || (GET_CODE (operands[0]) == SUBREG
8416 && GET_CODE (SUBREG_REG (operands[0])) == REG
8417 && REGNO (SUBREG_REG (operands[0])) <= 31))"
8418 [(set (match_dup 2) (match_dup 4))
8419 (set (match_dup 3) (match_dup 1))]
8420 "
8421 {
8422 int endian = (WORDS_BIG_ENDIAN == 0);
8423 HOST_WIDE_INT value = INTVAL (operands[1]);
8424
8425 operands[2] = operand_subword (operands[0], endian, 0, DFmode);
8426 operands[3] = operand_subword (operands[0], 1 - endian, 0, DFmode);
8427 #if HOST_BITS_PER_WIDE_INT == 32
8428 operands[4] = (value & 0x80000000) ? constm1_rtx : const0_rtx;
8429 #else
8430 operands[4] = GEN_INT (value >> 32);
8431 operands[1] = GEN_INT (((value & 0xffffffff) ^ 0x80000000) - 0x80000000);
8432 #endif
8433 }")
8434
8435 (define_split
8436 [(set (match_operand:DF 0 "gpc_reg_operand" "")
8437 (match_operand:DF 1 "const_double_operand" ""))]
8438 "! TARGET_POWERPC64 && reload_completed
8439 && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
8440 || (GET_CODE (operands[0]) == SUBREG
8441 && GET_CODE (SUBREG_REG (operands[0])) == REG
8442 && REGNO (SUBREG_REG (operands[0])) <= 31))"
8443 [(set (match_dup 2) (match_dup 4))
8444 (set (match_dup 3) (match_dup 5))]
8445 "
8446 {
8447 int endian = (WORDS_BIG_ENDIAN == 0);
8448 long l[2];
8449 REAL_VALUE_TYPE rv;
8450
8451 REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
8452 REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
8453
8454 operands[2] = operand_subword (operands[0], endian, 0, DFmode);
8455 operands[3] = operand_subword (operands[0], 1 - endian, 0, DFmode);
8456 operands[4] = gen_int_mode (l[endian], SImode);
8457 operands[5] = gen_int_mode (l[1 - endian], SImode);
8458 }")
8459
8460 (define_split
8461 [(set (match_operand:DF 0 "gpc_reg_operand" "")
8462 (match_operand:DF 1 "const_double_operand" ""))]
8463 "TARGET_POWERPC64 && reload_completed
8464 && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
8465 || (GET_CODE (operands[0]) == SUBREG
8466 && GET_CODE (SUBREG_REG (operands[0])) == REG
8467 && REGNO (SUBREG_REG (operands[0])) <= 31))"
8468 [(set (match_dup 2) (match_dup 3))]
8469 "
8470 {
8471 int endian = (WORDS_BIG_ENDIAN == 0);
8472 long l[2];
8473 REAL_VALUE_TYPE rv;
8474 #if HOST_BITS_PER_WIDE_INT >= 64
8475 HOST_WIDE_INT val;
8476 #endif
8477
8478 REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
8479 REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
8480
8481 operands[2] = gen_lowpart (DImode, operands[0]);
8482 /* HIGHPART is lower memory address when WORDS_BIG_ENDIAN. */
8483 #if HOST_BITS_PER_WIDE_INT >= 64
8484 val = ((HOST_WIDE_INT)(unsigned long)l[endian] << 32
8485 | ((HOST_WIDE_INT)(unsigned long)l[1 - endian]));
8486
8487 operands[3] = gen_int_mode (val, DImode);
8488 #else
8489 operands[3] = immed_double_const (l[1 - endian], l[endian], DImode);
8490 #endif
8491 }")
8492
8493 ;; Don't have reload use general registers to load a constant. First,
8494 ;; it might not work if the output operand is the equivalent of
8495 ;; a non-offsettable memref, but also it is less efficient than loading
8496 ;; the constant into an FP register, since it will probably be used there.
8497 ;; The "??" is a kludge until we can figure out a more reasonable way
8498 ;; of handling these non-offsettable values.
8499 (define_insn "*movdf_hardfloat32"
8500 [(set (match_operand:DF 0 "nonimmediate_operand" "=!r,??r,m,f,f,m,!r,!r,!r")
8501 (match_operand:DF 1 "input_operand" "r,m,r,f,m,f,G,H,F"))]
8502 "! TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT
8503 && (gpc_reg_operand (operands[0], DFmode)
8504 || gpc_reg_operand (operands[1], DFmode))"
8505 "*
8506 {
8507 switch (which_alternative)
8508 {
8509 default:
8510 gcc_unreachable ();
8511 case 0:
8512 /* We normally copy the low-numbered register first. However, if
8513 the first register operand 0 is the same as the second register
8514 of operand 1, we must copy in the opposite order. */
8515 if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
8516 return \"mr %L0,%L1\;mr %0,%1\";
8517 else
8518 return \"mr %0,%1\;mr %L0,%L1\";
8519 case 1:
8520 if (rs6000_offsettable_memref_p (operands[1])
8521 || (GET_CODE (operands[1]) == MEM
8522 && (GET_CODE (XEXP (operands[1], 0)) == LO_SUM
8523 || GET_CODE (XEXP (operands[1], 0)) == PRE_INC
8524 || GET_CODE (XEXP (operands[1], 0)) == PRE_DEC
8525 || GET_CODE (XEXP (operands[1], 0)) == PRE_MODIFY)))
8526 {
8527 /* If the low-address word is used in the address, we must load
8528 it last. Otherwise, load it first. Note that we cannot have
8529 auto-increment in that case since the address register is
8530 known to be dead. */
8531 if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
8532 operands[1], 0))
8533 return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
8534 else
8535 return \"{l%U1%X1|lwz%U1%X1} %0,%1\;{l|lwz} %L0,%L1\";
8536 }
8537 else
8538 {
8539 rtx addreg;
8540
8541 addreg = find_addr_reg (XEXP (operands[1], 0));
8542 if (refers_to_regno_p (REGNO (operands[0]),
8543 REGNO (operands[0]) + 1,
8544 operands[1], 0))
8545 {
8546 output_asm_insn (\"{cal|la} %0,4(%0)\", &addreg);
8547 output_asm_insn (\"{l%X1|lwz%X1} %L0,%1\", operands);
8548 output_asm_insn (\"{cal|la} %0,-4(%0)\", &addreg);
8549 return \"{l%X1|lwz%X1} %0,%1\";
8550 }
8551 else
8552 {
8553 output_asm_insn (\"{l%X1|lwz%X1} %0,%1\", operands);
8554 output_asm_insn (\"{cal|la} %0,4(%0)\", &addreg);
8555 output_asm_insn (\"{l%X1|lwz%X1} %L0,%1\", operands);
8556 output_asm_insn (\"{cal|la} %0,-4(%0)\", &addreg);
8557 return \"\";
8558 }
8559 }
8560 case 2:
8561 if (rs6000_offsettable_memref_p (operands[0])
8562 || (GET_CODE (operands[0]) == MEM
8563 && (GET_CODE (XEXP (operands[0], 0)) == LO_SUM
8564 || GET_CODE (XEXP (operands[0], 0)) == PRE_INC
8565 || GET_CODE (XEXP (operands[0], 0)) == PRE_DEC
8566 || GET_CODE (XEXP (operands[0], 0)) == PRE_MODIFY)))
8567 return \"{st%U0%X0|stw%U0%X0} %1,%0\;{st|stw} %L1,%L0\";
8568 else
8569 {
8570 rtx addreg;
8571
8572 addreg = find_addr_reg (XEXP (operands[0], 0));
8573 output_asm_insn (\"{st%X0|stw%X0} %1,%0\", operands);
8574 output_asm_insn (\"{cal|la} %0,4(%0)\", &addreg);
8575 output_asm_insn (\"{st%X0|stw%X0} %L1,%0\", operands);
8576 output_asm_insn (\"{cal|la} %0,-4(%0)\", &addreg);
8577 return \"\";
8578 }
8579 case 3:
8580 return \"fmr %0,%1\";
8581 case 4:
8582 return \"lfd%U1%X1 %0,%1\";
8583 case 5:
8584 return \"stfd%U0%X0 %1,%0\";
8585 case 6:
8586 case 7:
8587 case 8:
8588 return \"#\";
8589 }
8590 }"
8591 [(set_attr "type" "two,load,store,fp,fpload,fpstore,*,*,*")
8592 (set_attr "length" "8,16,16,4,4,4,8,12,16")])
8593
8594 (define_insn "*movdf_softfloat32"
8595 [(set (match_operand:DF 0 "nonimmediate_operand" "=r,r,m,r,r,r")
8596 (match_operand:DF 1 "input_operand" "r,m,r,G,H,F"))]
8597 "! TARGET_POWERPC64
8598 && ((TARGET_FPRS && !TARGET_DOUBLE_FLOAT)
8599 || TARGET_SOFT_FLOAT || TARGET_E500_SINGLE)
8600 && (gpc_reg_operand (operands[0], DFmode)
8601 || gpc_reg_operand (operands[1], DFmode))"
8602 "*
8603 {
8604 switch (which_alternative)
8605 {
8606 default:
8607 gcc_unreachable ();
8608 case 0:
8609 /* We normally copy the low-numbered register first. However, if
8610 the first register operand 0 is the same as the second register of
8611 operand 1, we must copy in the opposite order. */
8612 if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
8613 return \"mr %L0,%L1\;mr %0,%1\";
8614 else
8615 return \"mr %0,%1\;mr %L0,%L1\";
8616 case 1:
8617 /* If the low-address word is used in the address, we must load
8618 it last. Otherwise, load it first. Note that we cannot have
8619 auto-increment in that case since the address register is
8620 known to be dead. */
8621 if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
8622 operands[1], 0))
8623 return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
8624 else
8625 return \"{l%U1%X1|lwz%U1%X1} %0,%1\;{l|lwz} %L0,%L1\";
8626 case 2:
8627 return \"{st%U0%X0|stw%U0%X0} %1,%0\;{st|stw} %L1,%L0\";
8628 case 3:
8629 case 4:
8630 case 5:
8631 return \"#\";
8632 }
8633 }"
8634 [(set_attr "type" "two,load,store,*,*,*")
8635 (set_attr "length" "8,8,8,8,12,16")])
8636
8637 ; ld/std require word-aligned displacements -> 'Y' constraint.
8638 ; List Y->r and r->Y before r->r for reload.
8639 (define_insn "*movdf_hardfloat64_mfpgpr"
8640 [(set (match_operand:DF 0 "nonimmediate_operand" "=Y,r,!r,f,f,m,*c*l,!r,*h,!r,!r,!r,r,f")
8641 (match_operand:DF 1 "input_operand" "r,Y,r,f,m,f,r,h,0,G,H,F,f,r"))]
8642 "TARGET_POWERPC64 && TARGET_MFPGPR && TARGET_HARD_FLOAT && TARGET_FPRS
8643 && TARGET_DOUBLE_FLOAT
8644 && (gpc_reg_operand (operands[0], DFmode)
8645 || gpc_reg_operand (operands[1], DFmode))"
8646 "@
8647 std%U0%X0 %1,%0
8648 ld%U1%X1 %0,%1
8649 mr %0,%1
8650 fmr %0,%1
8651 lfd%U1%X1 %0,%1
8652 stfd%U0%X0 %1,%0
8653 mt%0 %1
8654 mf%1 %0
8655 {cror 0,0,0|nop}
8656 #
8657 #
8658 #
8659 mftgpr %0,%1
8660 mffgpr %0,%1"
8661 [(set_attr "type" "store,load,*,fp,fpload,fpstore,mtjmpr,mfjmpr,*,*,*,*,mftgpr,mffgpr")
8662 (set_attr "length" "4,4,4,4,4,4,4,4,4,8,12,16,4,4")])
8663
8664 ; ld/std require word-aligned displacements -> 'Y' constraint.
8665 ; List Y->r and r->Y before r->r for reload.
8666 (define_insn "*movdf_hardfloat64"
8667 [(set (match_operand:DF 0 "nonimmediate_operand" "=Y,r,!r,f,f,m,*c*l,!r,*h,!r,!r,!r")
8668 (match_operand:DF 1 "input_operand" "r,Y,r,f,m,f,r,h,0,G,H,F"))]
8669 "TARGET_POWERPC64 && !TARGET_MFPGPR && TARGET_HARD_FLOAT && TARGET_FPRS
8670 && TARGET_DOUBLE_FLOAT
8671 && (gpc_reg_operand (operands[0], DFmode)
8672 || gpc_reg_operand (operands[1], DFmode))"
8673 "@
8674 std%U0%X0 %1,%0
8675 ld%U1%X1 %0,%1
8676 mr %0,%1
8677 fmr %0,%1
8678 lfd%U1%X1 %0,%1
8679 stfd%U0%X0 %1,%0
8680 mt%0 %1
8681 mf%1 %0
8682 {cror 0,0,0|nop}
8683 #
8684 #
8685 #"
8686 [(set_attr "type" "store,load,*,fp,fpload,fpstore,mtjmpr,mfjmpr,*,*,*,*")
8687 (set_attr "length" "4,4,4,4,4,4,4,4,4,8,12,16")])
8688
8689 (define_insn "*movdf_softfloat64"
8690 [(set (match_operand:DF 0 "nonimmediate_operand" "=r,Y,r,cl,r,r,r,r,*h")
8691 (match_operand:DF 1 "input_operand" "Y,r,r,r,h,G,H,F,0"))]
8692 "TARGET_POWERPC64 && (TARGET_SOFT_FLOAT || !TARGET_FPRS)
8693 && (gpc_reg_operand (operands[0], DFmode)
8694 || gpc_reg_operand (operands[1], DFmode))"
8695 "@
8696 ld%U1%X1 %0,%1
8697 std%U0%X0 %1,%0
8698 mr %0,%1
8699 mt%0 %1
8700 mf%1 %0
8701 #
8702 #
8703 #
8704 {cror 0,0,0|nop}"
8705 [(set_attr "type" "load,store,*,mtjmpr,mfjmpr,*,*,*,*")
8706 (set_attr "length" "4,4,4,4,4,8,12,16,4")])
8707 \f
8708 (define_expand "movtf"
8709 [(set (match_operand:TF 0 "general_operand" "")
8710 (match_operand:TF 1 "any_operand" ""))]
8711 "!TARGET_IEEEQUAD && TARGET_LONG_DOUBLE_128"
8712 "{ rs6000_emit_move (operands[0], operands[1], TFmode); DONE; }")
8713
8714 ; It's important to list the o->f and f->o moves before f->f because
8715 ; otherwise reload, given m->f, will try to pick f->f and reload it,
8716 ; which doesn't make progress. Likewise r->Y must be before r->r.
8717 (define_insn_and_split "*movtf_internal"
8718 [(set (match_operand:TF 0 "nonimmediate_operand" "=o,f,f,r,Y,r")
8719 (match_operand:TF 1 "input_operand" "f,o,f,YGHF,r,r"))]
8720 "!TARGET_IEEEQUAD
8721 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128
8722 && (gpc_reg_operand (operands[0], TFmode)
8723 || gpc_reg_operand (operands[1], TFmode))"
8724 "#"
8725 "&& reload_completed"
8726 [(pc)]
8727 { rs6000_split_multireg_move (operands[0], operands[1]); DONE; }
8728 [(set_attr "length" "8,8,8,20,20,16")])
8729
8730 (define_insn_and_split "*movtf_softfloat"
8731 [(set (match_operand:TF 0 "rs6000_nonimmediate_operand" "=r,Y,r")
8732 (match_operand:TF 1 "input_operand" "YGHF,r,r"))]
8733 "!TARGET_IEEEQUAD
8734 && (TARGET_SOFT_FLOAT || !TARGET_FPRS) && TARGET_LONG_DOUBLE_128
8735 && (gpc_reg_operand (operands[0], TFmode)
8736 || gpc_reg_operand (operands[1], TFmode))"
8737 "#"
8738 "&& reload_completed"
8739 [(pc)]
8740 { rs6000_split_multireg_move (operands[0], operands[1]); DONE; }
8741 [(set_attr "length" "20,20,16")])
8742
8743 (define_expand "extenddftf2"
8744 [(set (match_operand:TF 0 "nonimmediate_operand" "")
8745 (float_extend:TF (match_operand:DF 1 "input_operand" "")))]
8746 "!TARGET_IEEEQUAD
8747 && TARGET_HARD_FLOAT
8748 && (TARGET_FPRS || TARGET_E500_DOUBLE)
8749 && TARGET_LONG_DOUBLE_128"
8750 {
8751 if (TARGET_E500_DOUBLE)
8752 emit_insn (gen_spe_extenddftf2 (operands[0], operands[1]));
8753 else
8754 emit_insn (gen_extenddftf2_fprs (operands[0], operands[1]));
8755 DONE;
8756 })
8757
8758 (define_expand "extenddftf2_fprs"
8759 [(parallel [(set (match_operand:TF 0 "nonimmediate_operand" "")
8760 (float_extend:TF (match_operand:DF 1 "input_operand" "")))
8761 (use (match_dup 2))])]
8762 "!TARGET_IEEEQUAD
8763 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT
8764 && TARGET_LONG_DOUBLE_128"
8765 {
8766 operands[2] = CONST0_RTX (DFmode);
8767 /* Generate GOT reference early for SVR4 PIC. */
8768 if (DEFAULT_ABI == ABI_V4 && flag_pic)
8769 operands[2] = validize_mem (force_const_mem (DFmode, operands[2]));
8770 })
8771
8772 (define_insn_and_split "*extenddftf2_internal"
8773 [(set (match_operand:TF 0 "nonimmediate_operand" "=o,f,&f,r")
8774 (float_extend:TF (match_operand:DF 1 "input_operand" "fr,mf,mf,rmGHF")))
8775 (use (match_operand:DF 2 "zero_reg_mem_operand" "rf,m,f,n"))]
8776 "!TARGET_IEEEQUAD
8777 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT
8778 && TARGET_LONG_DOUBLE_128"
8779 "#"
8780 "&& reload_completed"
8781 [(pc)]
8782 {
8783 const int lo_word = FLOAT_WORDS_BIG_ENDIAN ? GET_MODE_SIZE (DFmode) : 0;
8784 const int hi_word = FLOAT_WORDS_BIG_ENDIAN ? 0 : GET_MODE_SIZE (DFmode);
8785 emit_move_insn (simplify_gen_subreg (DFmode, operands[0], TFmode, hi_word),
8786 operands[1]);
8787 emit_move_insn (simplify_gen_subreg (DFmode, operands[0], TFmode, lo_word),
8788 operands[2]);
8789 DONE;
8790 })
8791
8792 (define_expand "extendsftf2"
8793 [(set (match_operand:TF 0 "nonimmediate_operand" "")
8794 (float_extend:TF (match_operand:SF 1 "gpc_reg_operand" "")))]
8795 "!TARGET_IEEEQUAD
8796 && TARGET_HARD_FLOAT
8797 && (TARGET_FPRS || TARGET_E500_DOUBLE)
8798 && TARGET_LONG_DOUBLE_128"
8799 {
8800 rtx tmp = gen_reg_rtx (DFmode);
8801 emit_insn (gen_extendsfdf2 (tmp, operands[1]));
8802 emit_insn (gen_extenddftf2 (operands[0], tmp));
8803 DONE;
8804 })
8805
8806 (define_expand "trunctfdf2"
8807 [(set (match_operand:DF 0 "gpc_reg_operand" "")
8808 (float_truncate:DF (match_operand:TF 1 "gpc_reg_operand" "")))]
8809 "!TARGET_IEEEQUAD
8810 && TARGET_HARD_FLOAT
8811 && (TARGET_FPRS || TARGET_E500_DOUBLE)
8812 && TARGET_LONG_DOUBLE_128"
8813 "")
8814
8815 (define_insn_and_split "trunctfdf2_internal1"
8816 [(set (match_operand:DF 0 "gpc_reg_operand" "=f,?f")
8817 (float_truncate:DF (match_operand:TF 1 "gpc_reg_operand" "0,f")))]
8818 "!TARGET_IEEEQUAD && !TARGET_XL_COMPAT
8819 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
8820 "@
8821 #
8822 fmr %0,%1"
8823 "&& reload_completed && REGNO (operands[0]) == REGNO (operands[1])"
8824 [(const_int 0)]
8825 {
8826 emit_note (NOTE_INSN_DELETED);
8827 DONE;
8828 }
8829 [(set_attr "type" "fp")])
8830
8831 (define_insn "trunctfdf2_internal2"
8832 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
8833 (float_truncate:DF (match_operand:TF 1 "gpc_reg_operand" "f")))]
8834 "!TARGET_IEEEQUAD && TARGET_XL_COMPAT
8835 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT
8836 && TARGET_LONG_DOUBLE_128"
8837 "fadd %0,%1,%L1"
8838 [(set_attr "type" "fp")
8839 (set_attr "fp_type" "fp_addsub_d")])
8840
8841 (define_expand "trunctfsf2"
8842 [(set (match_operand:SF 0 "gpc_reg_operand" "")
8843 (float_truncate:SF (match_operand:TF 1 "gpc_reg_operand" "")))]
8844 "!TARGET_IEEEQUAD
8845 && TARGET_HARD_FLOAT
8846 && (TARGET_FPRS || TARGET_E500_DOUBLE)
8847 && TARGET_LONG_DOUBLE_128"
8848 {
8849 if (TARGET_E500_DOUBLE)
8850 emit_insn (gen_spe_trunctfsf2 (operands[0], operands[1]));
8851 else
8852 emit_insn (gen_trunctfsf2_fprs (operands[0], operands[1]));
8853 DONE;
8854 })
8855
8856 (define_insn_and_split "trunctfsf2_fprs"
8857 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
8858 (float_truncate:SF (match_operand:TF 1 "gpc_reg_operand" "f")))
8859 (clobber (match_scratch:DF 2 "=f"))]
8860 "!TARGET_IEEEQUAD
8861 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT
8862 && TARGET_LONG_DOUBLE_128"
8863 "#"
8864 "&& reload_completed"
8865 [(set (match_dup 2)
8866 (float_truncate:DF (match_dup 1)))
8867 (set (match_dup 0)
8868 (float_truncate:SF (match_dup 2)))]
8869 "")
8870
8871 (define_expand "floatsitf2"
8872 [(set (match_operand:TF 0 "gpc_reg_operand" "")
8873 (float:TF (match_operand:SI 1 "gpc_reg_operand" "")))]
8874 "!TARGET_IEEEQUAD
8875 && TARGET_HARD_FLOAT
8876 && (TARGET_FPRS || TARGET_E500_DOUBLE)
8877 && TARGET_LONG_DOUBLE_128"
8878 {
8879 rtx tmp = gen_reg_rtx (DFmode);
8880 expand_float (tmp, operands[1], false);
8881 emit_insn (gen_extenddftf2 (operands[0], tmp));
8882 DONE;
8883 })
8884
8885 ; fadd, but rounding towards zero.
8886 ; This is probably not the optimal code sequence.
8887 (define_insn "fix_trunc_helper"
8888 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
8889 (unspec:DF [(match_operand:TF 1 "gpc_reg_operand" "f")]
8890 UNSPEC_FIX_TRUNC_TF))
8891 (clobber (match_operand:DF 2 "gpc_reg_operand" "=&f"))]
8892 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
8893 "mffs %2\n\tmtfsb1 31\n\tmtfsb0 30\n\tfadd %0,%1,%L1\n\tmtfsf 1,%2"
8894 [(set_attr "type" "fp")
8895 (set_attr "length" "20")])
8896
8897 (define_expand "fix_trunctfsi2"
8898 [(set (match_operand:SI 0 "gpc_reg_operand" "")
8899 (fix:SI (match_operand:TF 1 "gpc_reg_operand" "")))]
8900 "!TARGET_IEEEQUAD
8901 && (TARGET_POWER2 || TARGET_POWERPC)
8902 && TARGET_HARD_FLOAT
8903 && (TARGET_FPRS || TARGET_E500_DOUBLE)
8904 && TARGET_LONG_DOUBLE_128"
8905 {
8906 if (TARGET_E500_DOUBLE)
8907 emit_insn (gen_spe_fix_trunctfsi2 (operands[0], operands[1]));
8908 else
8909 emit_insn (gen_fix_trunctfsi2_fprs (operands[0], operands[1]));
8910 DONE;
8911 })
8912
8913 (define_expand "fix_trunctfsi2_fprs"
8914 [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
8915 (fix:SI (match_operand:TF 1 "gpc_reg_operand" "")))
8916 (clobber (match_dup 2))
8917 (clobber (match_dup 3))
8918 (clobber (match_dup 4))
8919 (clobber (match_dup 5))])]
8920 "!TARGET_IEEEQUAD
8921 && (TARGET_POWER2 || TARGET_POWERPC)
8922 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
8923 {
8924 operands[2] = gen_reg_rtx (DFmode);
8925 operands[3] = gen_reg_rtx (DFmode);
8926 operands[4] = gen_reg_rtx (DImode);
8927 operands[5] = assign_stack_temp (DImode, GET_MODE_SIZE (DImode), 0);
8928 })
8929
8930 (define_insn_and_split "*fix_trunctfsi2_internal"
8931 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8932 (fix:SI (match_operand:TF 1 "gpc_reg_operand" "f")))
8933 (clobber (match_operand:DF 2 "gpc_reg_operand" "=f"))
8934 (clobber (match_operand:DF 3 "gpc_reg_operand" "=&f"))
8935 (clobber (match_operand:DI 4 "gpc_reg_operand" "=f"))
8936 (clobber (match_operand:DI 5 "offsettable_mem_operand" "=o"))]
8937 "!TARGET_IEEEQUAD
8938 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
8939 "#"
8940 "&& (can_create_pseudo_p () || offsettable_nonstrict_memref_p (operands[5]))"
8941 [(pc)]
8942 {
8943 rtx lowword;
8944 emit_insn (gen_fix_trunc_helper (operands[2], operands[1], operands[3]));
8945
8946 gcc_assert (MEM_P (operands[5]));
8947 lowword = adjust_address (operands[5], SImode, WORDS_BIG_ENDIAN ? 4 : 0);
8948
8949 emit_insn (gen_fctiwz (operands[4], operands[2]));
8950 emit_move_insn (operands[5], operands[4]);
8951 emit_move_insn (operands[0], lowword);
8952 DONE;
8953 })
8954
8955 (define_expand "negtf2"
8956 [(set (match_operand:TF 0 "gpc_reg_operand" "")
8957 (neg:TF (match_operand:TF 1 "gpc_reg_operand" "")))]
8958 "!TARGET_IEEEQUAD
8959 && TARGET_HARD_FLOAT
8960 && (TARGET_FPRS || TARGET_E500_DOUBLE)
8961 && TARGET_LONG_DOUBLE_128"
8962 "")
8963
8964 (define_insn "negtf2_internal"
8965 [(set (match_operand:TF 0 "gpc_reg_operand" "=f")
8966 (neg:TF (match_operand:TF 1 "gpc_reg_operand" "f")))]
8967 "!TARGET_IEEEQUAD
8968 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
8969 "*
8970 {
8971 if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
8972 return \"fneg %L0,%L1\;fneg %0,%1\";
8973 else
8974 return \"fneg %0,%1\;fneg %L0,%L1\";
8975 }"
8976 [(set_attr "type" "fp")
8977 (set_attr "length" "8")])
8978
8979 (define_expand "abstf2"
8980 [(set (match_operand:TF 0 "gpc_reg_operand" "")
8981 (abs:TF (match_operand:TF 1 "gpc_reg_operand" "")))]
8982 "!TARGET_IEEEQUAD
8983 && TARGET_HARD_FLOAT
8984 && (TARGET_FPRS || TARGET_E500_DOUBLE)
8985 && TARGET_LONG_DOUBLE_128"
8986 "
8987 {
8988 rtx label = gen_label_rtx ();
8989 if (TARGET_E500_DOUBLE)
8990 {
8991 if (flag_finite_math_only && !flag_trapping_math)
8992 emit_insn (gen_spe_abstf2_tst (operands[0], operands[1], label));
8993 else
8994 emit_insn (gen_spe_abstf2_cmp (operands[0], operands[1], label));
8995 }
8996 else
8997 emit_insn (gen_abstf2_internal (operands[0], operands[1], label));
8998 emit_label (label);
8999 DONE;
9000 }")
9001
9002 (define_expand "abstf2_internal"
9003 [(set (match_operand:TF 0 "gpc_reg_operand" "")
9004 (match_operand:TF 1 "gpc_reg_operand" ""))
9005 (set (match_dup 3) (match_dup 5))
9006 (set (match_dup 5) (abs:DF (match_dup 5)))
9007 (set (match_dup 4) (compare:CCFP (match_dup 3) (match_dup 5)))
9008 (set (pc) (if_then_else (eq (match_dup 4) (const_int 0))
9009 (label_ref (match_operand 2 "" ""))
9010 (pc)))
9011 (set (match_dup 6) (neg:DF (match_dup 6)))]
9012 "!TARGET_IEEEQUAD
9013 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT
9014 && TARGET_LONG_DOUBLE_128"
9015 "
9016 {
9017 const int hi_word = FLOAT_WORDS_BIG_ENDIAN ? 0 : GET_MODE_SIZE (DFmode);
9018 const int lo_word = FLOAT_WORDS_BIG_ENDIAN ? GET_MODE_SIZE (DFmode) : 0;
9019 operands[3] = gen_reg_rtx (DFmode);
9020 operands[4] = gen_reg_rtx (CCFPmode);
9021 operands[5] = simplify_gen_subreg (DFmode, operands[0], TFmode, hi_word);
9022 operands[6] = simplify_gen_subreg (DFmode, operands[0], TFmode, lo_word);
9023 }")
9024 \f
9025 ;; Next come the multi-word integer load and store and the load and store
9026 ;; multiple insns.
9027
9028 ; List r->r after r->"o<>", otherwise reload will try to reload a
9029 ; non-offsettable address by using r->r which won't make progress.
9030 (define_insn "*movdi_internal32"
9031 [(set (match_operand:DI 0 "rs6000_nonimmediate_operand" "=o<>,r,r,*f,*f,m,r")
9032 (match_operand:DI 1 "input_operand" "r,r,m,f,m,f,IJKnGHF"))]
9033 "! TARGET_POWERPC64
9034 && (gpc_reg_operand (operands[0], DImode)
9035 || gpc_reg_operand (operands[1], DImode))"
9036 "@
9037 #
9038 #
9039 #
9040 fmr %0,%1
9041 lfd%U1%X1 %0,%1
9042 stfd%U0%X0 %1,%0
9043 #"
9044 [(set_attr "type" "load,*,store,fp,fpload,fpstore,*")])
9045
9046 (define_split
9047 [(set (match_operand:DI 0 "gpc_reg_operand" "")
9048 (match_operand:DI 1 "const_int_operand" ""))]
9049 "! TARGET_POWERPC64 && reload_completed"
9050 [(set (match_dup 2) (match_dup 4))
9051 (set (match_dup 3) (match_dup 1))]
9052 "
9053 {
9054 HOST_WIDE_INT value = INTVAL (operands[1]);
9055 operands[2] = operand_subword_force (operands[0], WORDS_BIG_ENDIAN == 0,
9056 DImode);
9057 operands[3] = operand_subword_force (operands[0], WORDS_BIG_ENDIAN != 0,
9058 DImode);
9059 #if HOST_BITS_PER_WIDE_INT == 32
9060 operands[4] = (value & 0x80000000) ? constm1_rtx : const0_rtx;
9061 #else
9062 operands[4] = GEN_INT (value >> 32);
9063 operands[1] = GEN_INT (((value & 0xffffffff) ^ 0x80000000) - 0x80000000);
9064 #endif
9065 }")
9066
9067 (define_split
9068 [(set (match_operand:DI 0 "rs6000_nonimmediate_operand" "")
9069 (match_operand:DI 1 "input_operand" ""))]
9070 "reload_completed && !TARGET_POWERPC64
9071 && gpr_or_gpr_p (operands[0], operands[1])"
9072 [(pc)]
9073 { rs6000_split_multireg_move (operands[0], operands[1]); DONE; })
9074
9075 (define_insn "*movdi_mfpgpr"
9076 [(set (match_operand:DI 0 "nonimmediate_operand" "=r,r,m,r,r,r,r,*f,*f,m,r,*h,*h,r,*f")
9077 (match_operand:DI 1 "input_operand" "r,m,r,I,L,nF,R,f,m,f,*h,r,0,*f,r"))]
9078 "TARGET_POWERPC64 && TARGET_MFPGPR && TARGET_HARD_FLOAT && TARGET_FPRS
9079 && (gpc_reg_operand (operands[0], DImode)
9080 || gpc_reg_operand (operands[1], DImode))"
9081 "@
9082 mr %0,%1
9083 ld%U1%X1 %0,%1
9084 std%U0%X0 %1,%0
9085 li %0,%1
9086 lis %0,%v1
9087 #
9088 {cal|la} %0,%a1
9089 fmr %0,%1
9090 lfd%U1%X1 %0,%1
9091 stfd%U0%X0 %1,%0
9092 mf%1 %0
9093 mt%0 %1
9094 {cror 0,0,0|nop}
9095 mftgpr %0,%1
9096 mffgpr %0,%1"
9097 [(set_attr "type" "*,load,store,*,*,*,*,fp,fpload,fpstore,mfjmpr,mtjmpr,*,mftgpr,mffgpr")
9098 (set_attr "length" "4,4,4,4,4,20,4,4,4,4,4,4,4,4,4")])
9099
9100 (define_insn "*movdi_internal64"
9101 [(set (match_operand:DI 0 "nonimmediate_operand" "=r,r,m,r,r,r,r,*f,*f,m,r,*h,*h")
9102 (match_operand:DI 1 "input_operand" "r,m,r,I,L,nF,R,f,m,f,*h,r,0"))]
9103 "TARGET_POWERPC64 && (!TARGET_MFPGPR || !TARGET_HARD_FLOAT || !TARGET_FPRS)
9104 && (gpc_reg_operand (operands[0], DImode)
9105 || gpc_reg_operand (operands[1], DImode))"
9106 "@
9107 mr %0,%1
9108 ld%U1%X1 %0,%1
9109 std%U0%X0 %1,%0
9110 li %0,%1
9111 lis %0,%v1
9112 #
9113 {cal|la} %0,%a1
9114 fmr %0,%1
9115 lfd%U1%X1 %0,%1
9116 stfd%U0%X0 %1,%0
9117 mf%1 %0
9118 mt%0 %1
9119 {cror 0,0,0|nop}"
9120 [(set_attr "type" "*,load,store,*,*,*,*,fp,fpload,fpstore,mfjmpr,mtjmpr,*")
9121 (set_attr "length" "4,4,4,4,4,20,4,4,4,4,4,4,4")])
9122
9123 ;; immediate value valid for a single instruction hiding in a const_double
9124 (define_insn ""
9125 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
9126 (match_operand:DI 1 "const_double_operand" "F"))]
9127 "HOST_BITS_PER_WIDE_INT == 32 && TARGET_POWERPC64
9128 && GET_CODE (operands[1]) == CONST_DOUBLE
9129 && num_insns_constant (operands[1], DImode) == 1"
9130 "*
9131 {
9132 return ((unsigned HOST_WIDE_INT)
9133 (CONST_DOUBLE_LOW (operands[1]) + 0x8000) < 0x10000)
9134 ? \"li %0,%1\" : \"lis %0,%v1\";
9135 }")
9136
9137 ;; Generate all one-bits and clear left or right.
9138 ;; Use (and:DI (rotate:DI ...)) to avoid anddi3 unnecessary clobber.
9139 (define_split
9140 [(set (match_operand:DI 0 "gpc_reg_operand" "")
9141 (match_operand:DI 1 "mask64_operand" ""))]
9142 "TARGET_POWERPC64 && num_insns_constant (operands[1], DImode) > 1"
9143 [(set (match_dup 0) (const_int -1))
9144 (set (match_dup 0)
9145 (and:DI (rotate:DI (match_dup 0)
9146 (const_int 0))
9147 (match_dup 1)))]
9148 "")
9149
9150 ;; Split a load of a large constant into the appropriate five-instruction
9151 ;; sequence. Handle anything in a constant number of insns.
9152 ;; When non-easy constants can go in the TOC, this should use
9153 ;; easy_fp_constant predicate.
9154 (define_split
9155 [(set (match_operand:DI 0 "gpc_reg_operand" "")
9156 (match_operand:DI 1 "const_int_operand" ""))]
9157 "TARGET_POWERPC64 && num_insns_constant (operands[1], DImode) > 1"
9158 [(set (match_dup 0) (match_dup 2))
9159 (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 3)))]
9160 "
9161 { rtx tem = rs6000_emit_set_const (operands[0], DImode, operands[1], 5);
9162
9163 if (tem == operands[0])
9164 DONE;
9165 else
9166 FAIL;
9167 }")
9168
9169 (define_split
9170 [(set (match_operand:DI 0 "gpc_reg_operand" "")
9171 (match_operand:DI 1 "const_double_operand" ""))]
9172 "TARGET_POWERPC64 && num_insns_constant (operands[1], DImode) > 1"
9173 [(set (match_dup 0) (match_dup 2))
9174 (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 3)))]
9175 "
9176 { rtx tem = rs6000_emit_set_const (operands[0], DImode, operands[1], 5);
9177
9178 if (tem == operands[0])
9179 DONE;
9180 else
9181 FAIL;
9182 }")
9183 \f
9184 ;; TImode is similar, except that we usually want to compute the address into
9185 ;; a register and use lsi/stsi (the exception is during reload). MQ is also
9186 ;; clobbered in stsi for POWER, so we need a SCRATCH for it.
9187
9188 ;; We say that MQ is clobbered in the last alternative because the first
9189 ;; alternative would never get used otherwise since it would need a reload
9190 ;; while the 2nd alternative would not. We put memory cases first so they
9191 ;; are preferred. Otherwise, we'd try to reload the output instead of
9192 ;; giving the SCRATCH mq.
9193
9194 (define_insn "*movti_power"
9195 [(set (match_operand:TI 0 "reg_or_mem_operand" "=Q,m,????r,????r,????r,r")
9196 (match_operand:TI 1 "input_operand" "r,r,r,Q,m,n"))
9197 (clobber (match_scratch:SI 2 "=q,q#X,X,X,X,X"))]
9198 "TARGET_POWER && ! TARGET_POWERPC64
9199 && (gpc_reg_operand (operands[0], TImode) || gpc_reg_operand (operands[1], TImode))"
9200 "*
9201 {
9202 switch (which_alternative)
9203 {
9204 default:
9205 gcc_unreachable ();
9206
9207 case 0:
9208 if (TARGET_STRING)
9209 return \"{stsi|stswi} %1,%P0,16\";
9210 case 1:
9211 case 2:
9212 return \"#\";
9213 case 3:
9214 /* If the address is not used in the output, we can use lsi. Otherwise,
9215 fall through to generating four loads. */
9216 if (TARGET_STRING
9217 && ! reg_overlap_mentioned_p (operands[0], operands[1]))
9218 return \"{lsi|lswi} %0,%P1,16\";
9219 /* ... fall through ... */
9220 case 4:
9221 case 5:
9222 return \"#\";
9223 }
9224 }"
9225 [(set_attr "type" "store,store,*,load,load,*")])
9226
9227 (define_insn "*movti_string"
9228 [(set (match_operand:TI 0 "reg_or_mem_operand" "=Q,o<>,????r,????r,????r,r")
9229 (match_operand:TI 1 "input_operand" "r,r,r,Q,m,n"))]
9230 "! TARGET_POWER && ! TARGET_POWERPC64
9231 && (gpc_reg_operand (operands[0], TImode) || gpc_reg_operand (operands[1], TImode))"
9232 "*
9233 {
9234 switch (which_alternative)
9235 {
9236 default:
9237 gcc_unreachable ();
9238 case 0:
9239 if (TARGET_STRING)
9240 return \"{stsi|stswi} %1,%P0,16\";
9241 case 1:
9242 case 2:
9243 return \"#\";
9244 case 3:
9245 /* If the address is not used in the output, we can use lsi. Otherwise,
9246 fall through to generating four loads. */
9247 if (TARGET_STRING
9248 && ! reg_overlap_mentioned_p (operands[0], operands[1]))
9249 return \"{lsi|lswi} %0,%P1,16\";
9250 /* ... fall through ... */
9251 case 4:
9252 case 5:
9253 return \"#\";
9254 }
9255 }"
9256 [(set_attr "type" "store_ux,store_ux,*,load_ux,load_ux,*")
9257 (set (attr "cell_micro") (if_then_else (eq (symbol_ref "TARGET_STRING") (const_int 1))
9258 (const_string "always")
9259 (const_string "conditional")))])
9260
9261 (define_insn "*movti_ppc64"
9262 [(set (match_operand:TI 0 "nonimmediate_operand" "=r,o<>,r")
9263 (match_operand:TI 1 "input_operand" "r,r,m"))]
9264 "TARGET_POWERPC64 && (gpc_reg_operand (operands[0], TImode)
9265 || gpc_reg_operand (operands[1], TImode))"
9266 "#"
9267 [(set_attr "type" "*,store,load")])
9268
9269 (define_split
9270 [(set (match_operand:TI 0 "gpc_reg_operand" "")
9271 (match_operand:TI 1 "const_double_operand" ""))]
9272 "TARGET_POWERPC64"
9273 [(set (match_dup 2) (match_dup 4))
9274 (set (match_dup 3) (match_dup 5))]
9275 "
9276 {
9277 operands[2] = operand_subword_force (operands[0], WORDS_BIG_ENDIAN == 0,
9278 TImode);
9279 operands[3] = operand_subword_force (operands[0], WORDS_BIG_ENDIAN != 0,
9280 TImode);
9281 if (GET_CODE (operands[1]) == CONST_DOUBLE)
9282 {
9283 operands[4] = GEN_INT (CONST_DOUBLE_HIGH (operands[1]));
9284 operands[5] = GEN_INT (CONST_DOUBLE_LOW (operands[1]));
9285 }
9286 else if (GET_CODE (operands[1]) == CONST_INT)
9287 {
9288 operands[4] = GEN_INT (- (INTVAL (operands[1]) < 0));
9289 operands[5] = operands[1];
9290 }
9291 else
9292 FAIL;
9293 }")
9294
9295 (define_split
9296 [(set (match_operand:TI 0 "nonimmediate_operand" "")
9297 (match_operand:TI 1 "input_operand" ""))]
9298 "reload_completed
9299 && gpr_or_gpr_p (operands[0], operands[1])"
9300 [(pc)]
9301 { rs6000_split_multireg_move (operands[0], operands[1]); DONE; })
9302 \f
9303 (define_expand "load_multiple"
9304 [(match_par_dup 3 [(set (match_operand:SI 0 "" "")
9305 (match_operand:SI 1 "" ""))
9306 (use (match_operand:SI 2 "" ""))])]
9307 "TARGET_STRING && !TARGET_POWERPC64"
9308 "
9309 {
9310 int regno;
9311 int count;
9312 rtx op1;
9313 int i;
9314
9315 /* Support only loading a constant number of fixed-point registers from
9316 memory and only bother with this if more than two; the machine
9317 doesn't support more than eight. */
9318 if (GET_CODE (operands[2]) != CONST_INT
9319 || INTVAL (operands[2]) <= 2
9320 || INTVAL (operands[2]) > 8
9321 || GET_CODE (operands[1]) != MEM
9322 || GET_CODE (operands[0]) != REG
9323 || REGNO (operands[0]) >= 32)
9324 FAIL;
9325
9326 count = INTVAL (operands[2]);
9327 regno = REGNO (operands[0]);
9328
9329 operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count));
9330 op1 = replace_equiv_address (operands[1],
9331 force_reg (SImode, XEXP (operands[1], 0)));
9332
9333 for (i = 0; i < count; i++)
9334 XVECEXP (operands[3], 0, i)
9335 = gen_rtx_SET (VOIDmode, gen_rtx_REG (SImode, regno + i),
9336 adjust_address_nv (op1, SImode, i * 4));
9337 }")
9338
9339 (define_insn "*ldmsi8"
9340 [(match_parallel 0 "load_multiple_operation"
9341 [(set (match_operand:SI 2 "gpc_reg_operand" "")
9342 (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
9343 (set (match_operand:SI 3 "gpc_reg_operand" "")
9344 (mem:SI (plus:SI (match_dup 1) (const_int 4))))
9345 (set (match_operand:SI 4 "gpc_reg_operand" "")
9346 (mem:SI (plus:SI (match_dup 1) (const_int 8))))
9347 (set (match_operand:SI 5 "gpc_reg_operand" "")
9348 (mem:SI (plus:SI (match_dup 1) (const_int 12))))
9349 (set (match_operand:SI 6 "gpc_reg_operand" "")
9350 (mem:SI (plus:SI (match_dup 1) (const_int 16))))
9351 (set (match_operand:SI 7 "gpc_reg_operand" "")
9352 (mem:SI (plus:SI (match_dup 1) (const_int 20))))
9353 (set (match_operand:SI 8 "gpc_reg_operand" "")
9354 (mem:SI (plus:SI (match_dup 1) (const_int 24))))
9355 (set (match_operand:SI 9 "gpc_reg_operand" "")
9356 (mem:SI (plus:SI (match_dup 1) (const_int 28))))])]
9357 "TARGET_STRING && XVECLEN (operands[0], 0) == 8"
9358 "*
9359 { return rs6000_output_load_multiple (operands); }"
9360 [(set_attr "type" "load_ux")
9361 (set_attr "length" "32")])
9362
9363 (define_insn "*ldmsi7"
9364 [(match_parallel 0 "load_multiple_operation"
9365 [(set (match_operand:SI 2 "gpc_reg_operand" "")
9366 (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
9367 (set (match_operand:SI 3 "gpc_reg_operand" "")
9368 (mem:SI (plus:SI (match_dup 1) (const_int 4))))
9369 (set (match_operand:SI 4 "gpc_reg_operand" "")
9370 (mem:SI (plus:SI (match_dup 1) (const_int 8))))
9371 (set (match_operand:SI 5 "gpc_reg_operand" "")
9372 (mem:SI (plus:SI (match_dup 1) (const_int 12))))
9373 (set (match_operand:SI 6 "gpc_reg_operand" "")
9374 (mem:SI (plus:SI (match_dup 1) (const_int 16))))
9375 (set (match_operand:SI 7 "gpc_reg_operand" "")
9376 (mem:SI (plus:SI (match_dup 1) (const_int 20))))
9377 (set (match_operand:SI 8 "gpc_reg_operand" "")
9378 (mem:SI (plus:SI (match_dup 1) (const_int 24))))])]
9379 "TARGET_STRING && XVECLEN (operands[0], 0) == 7"
9380 "*
9381 { return rs6000_output_load_multiple (operands); }"
9382 [(set_attr "type" "load_ux")
9383 (set_attr "length" "32")])
9384
9385 (define_insn "*ldmsi6"
9386 [(match_parallel 0 "load_multiple_operation"
9387 [(set (match_operand:SI 2 "gpc_reg_operand" "")
9388 (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
9389 (set (match_operand:SI 3 "gpc_reg_operand" "")
9390 (mem:SI (plus:SI (match_dup 1) (const_int 4))))
9391 (set (match_operand:SI 4 "gpc_reg_operand" "")
9392 (mem:SI (plus:SI (match_dup 1) (const_int 8))))
9393 (set (match_operand:SI 5 "gpc_reg_operand" "")
9394 (mem:SI (plus:SI (match_dup 1) (const_int 12))))
9395 (set (match_operand:SI 6 "gpc_reg_operand" "")
9396 (mem:SI (plus:SI (match_dup 1) (const_int 16))))
9397 (set (match_operand:SI 7 "gpc_reg_operand" "")
9398 (mem:SI (plus:SI (match_dup 1) (const_int 20))))])]
9399 "TARGET_STRING && XVECLEN (operands[0], 0) == 6"
9400 "*
9401 { return rs6000_output_load_multiple (operands); }"
9402 [(set_attr "type" "load_ux")
9403 (set_attr "length" "32")])
9404
9405 (define_insn "*ldmsi5"
9406 [(match_parallel 0 "load_multiple_operation"
9407 [(set (match_operand:SI 2 "gpc_reg_operand" "")
9408 (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
9409 (set (match_operand:SI 3 "gpc_reg_operand" "")
9410 (mem:SI (plus:SI (match_dup 1) (const_int 4))))
9411 (set (match_operand:SI 4 "gpc_reg_operand" "")
9412 (mem:SI (plus:SI (match_dup 1) (const_int 8))))
9413 (set (match_operand:SI 5 "gpc_reg_operand" "")
9414 (mem:SI (plus:SI (match_dup 1) (const_int 12))))
9415 (set (match_operand:SI 6 "gpc_reg_operand" "")
9416 (mem:SI (plus:SI (match_dup 1) (const_int 16))))])]
9417 "TARGET_STRING && XVECLEN (operands[0], 0) == 5"
9418 "*
9419 { return rs6000_output_load_multiple (operands); }"
9420 [(set_attr "type" "load_ux")
9421 (set_attr "length" "32")])
9422
9423 (define_insn "*ldmsi4"
9424 [(match_parallel 0 "load_multiple_operation"
9425 [(set (match_operand:SI 2 "gpc_reg_operand" "")
9426 (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
9427 (set (match_operand:SI 3 "gpc_reg_operand" "")
9428 (mem:SI (plus:SI (match_dup 1) (const_int 4))))
9429 (set (match_operand:SI 4 "gpc_reg_operand" "")
9430 (mem:SI (plus:SI (match_dup 1) (const_int 8))))
9431 (set (match_operand:SI 5 "gpc_reg_operand" "")
9432 (mem:SI (plus:SI (match_dup 1) (const_int 12))))])]
9433 "TARGET_STRING && XVECLEN (operands[0], 0) == 4"
9434 "*
9435 { return rs6000_output_load_multiple (operands); }"
9436 [(set_attr "type" "load_ux")
9437 (set_attr "length" "32")])
9438
9439 (define_insn "*ldmsi3"
9440 [(match_parallel 0 "load_multiple_operation"
9441 [(set (match_operand:SI 2 "gpc_reg_operand" "")
9442 (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
9443 (set (match_operand:SI 3 "gpc_reg_operand" "")
9444 (mem:SI (plus:SI (match_dup 1) (const_int 4))))
9445 (set (match_operand:SI 4 "gpc_reg_operand" "")
9446 (mem:SI (plus:SI (match_dup 1) (const_int 8))))])]
9447 "TARGET_STRING && XVECLEN (operands[0], 0) == 3"
9448 "*
9449 { return rs6000_output_load_multiple (operands); }"
9450 [(set_attr "type" "load_ux")
9451 (set_attr "length" "32")])
9452
9453 (define_expand "store_multiple"
9454 [(match_par_dup 3 [(set (match_operand:SI 0 "" "")
9455 (match_operand:SI 1 "" ""))
9456 (clobber (scratch:SI))
9457 (use (match_operand:SI 2 "" ""))])]
9458 "TARGET_STRING && !TARGET_POWERPC64"
9459 "
9460 {
9461 int regno;
9462 int count;
9463 rtx to;
9464 rtx op0;
9465 int i;
9466
9467 /* Support only storing a constant number of fixed-point registers to
9468 memory and only bother with this if more than two; the machine
9469 doesn't support more than eight. */
9470 if (GET_CODE (operands[2]) != CONST_INT
9471 || INTVAL (operands[2]) <= 2
9472 || INTVAL (operands[2]) > 8
9473 || GET_CODE (operands[0]) != MEM
9474 || GET_CODE (operands[1]) != REG
9475 || REGNO (operands[1]) >= 32)
9476 FAIL;
9477
9478 count = INTVAL (operands[2]);
9479 regno = REGNO (operands[1]);
9480
9481 operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count + 1));
9482 to = force_reg (SImode, XEXP (operands[0], 0));
9483 op0 = replace_equiv_address (operands[0], to);
9484
9485 XVECEXP (operands[3], 0, 0)
9486 = gen_rtx_SET (VOIDmode, adjust_address_nv (op0, SImode, 0), operands[1]);
9487 XVECEXP (operands[3], 0, 1) = gen_rtx_CLOBBER (VOIDmode,
9488 gen_rtx_SCRATCH (SImode));
9489
9490 for (i = 1; i < count; i++)
9491 XVECEXP (operands[3], 0, i + 1)
9492 = gen_rtx_SET (VOIDmode,
9493 adjust_address_nv (op0, SImode, i * 4),
9494 gen_rtx_REG (SImode, regno + i));
9495 }")
9496
9497 (define_insn "*stmsi8"
9498 [(match_parallel 0 "store_multiple_operation"
9499 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
9500 (match_operand:SI 2 "gpc_reg_operand" "r"))
9501 (clobber (match_scratch:SI 3 "=X"))
9502 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
9503 (match_operand:SI 4 "gpc_reg_operand" "r"))
9504 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
9505 (match_operand:SI 5 "gpc_reg_operand" "r"))
9506 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
9507 (match_operand:SI 6 "gpc_reg_operand" "r"))
9508 (set (mem:SI (plus:SI (match_dup 1) (const_int 16)))
9509 (match_operand:SI 7 "gpc_reg_operand" "r"))
9510 (set (mem:SI (plus:SI (match_dup 1) (const_int 20)))
9511 (match_operand:SI 8 "gpc_reg_operand" "r"))
9512 (set (mem:SI (plus:SI (match_dup 1) (const_int 24)))
9513 (match_operand:SI 9 "gpc_reg_operand" "r"))
9514 (set (mem:SI (plus:SI (match_dup 1) (const_int 28)))
9515 (match_operand:SI 10 "gpc_reg_operand" "r"))])]
9516 "TARGET_STRING && !TARGET_POWER && XVECLEN (operands[0], 0) == 9"
9517 "{stsi|stswi} %2,%1,%O0"
9518 [(set_attr "type" "store_ux")
9519 (set_attr "cell_micro" "always")])
9520
9521 (define_insn "*stmsi7"
9522 [(match_parallel 0 "store_multiple_operation"
9523 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
9524 (match_operand:SI 2 "gpc_reg_operand" "r"))
9525 (clobber (match_scratch:SI 3 "=X"))
9526 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
9527 (match_operand:SI 4 "gpc_reg_operand" "r"))
9528 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
9529 (match_operand:SI 5 "gpc_reg_operand" "r"))
9530 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
9531 (match_operand:SI 6 "gpc_reg_operand" "r"))
9532 (set (mem:SI (plus:SI (match_dup 1) (const_int 16)))
9533 (match_operand:SI 7 "gpc_reg_operand" "r"))
9534 (set (mem:SI (plus:SI (match_dup 1) (const_int 20)))
9535 (match_operand:SI 8 "gpc_reg_operand" "r"))
9536 (set (mem:SI (plus:SI (match_dup 1) (const_int 24)))
9537 (match_operand:SI 9 "gpc_reg_operand" "r"))])]
9538 "TARGET_STRING && !TARGET_POWER && XVECLEN (operands[0], 0) == 8"
9539 "{stsi|stswi} %2,%1,%O0"
9540 [(set_attr "type" "store_ux")
9541 (set_attr "cell_micro" "always")])
9542
9543 (define_insn "*stmsi6"
9544 [(match_parallel 0 "store_multiple_operation"
9545 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
9546 (match_operand:SI 2 "gpc_reg_operand" "r"))
9547 (clobber (match_scratch:SI 3 "=X"))
9548 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
9549 (match_operand:SI 4 "gpc_reg_operand" "r"))
9550 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
9551 (match_operand:SI 5 "gpc_reg_operand" "r"))
9552 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
9553 (match_operand:SI 6 "gpc_reg_operand" "r"))
9554 (set (mem:SI (plus:SI (match_dup 1) (const_int 16)))
9555 (match_operand:SI 7 "gpc_reg_operand" "r"))
9556 (set (mem:SI (plus:SI (match_dup 1) (const_int 20)))
9557 (match_operand:SI 8 "gpc_reg_operand" "r"))])]
9558 "TARGET_STRING && !TARGET_POWER && XVECLEN (operands[0], 0) == 7"
9559 "{stsi|stswi} %2,%1,%O0"
9560 [(set_attr "type" "store_ux")
9561 (set_attr "cell_micro" "always")])
9562
9563 (define_insn "*stmsi5"
9564 [(match_parallel 0 "store_multiple_operation"
9565 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
9566 (match_operand:SI 2 "gpc_reg_operand" "r"))
9567 (clobber (match_scratch:SI 3 "=X"))
9568 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
9569 (match_operand:SI 4 "gpc_reg_operand" "r"))
9570 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
9571 (match_operand:SI 5 "gpc_reg_operand" "r"))
9572 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
9573 (match_operand:SI 6 "gpc_reg_operand" "r"))
9574 (set (mem:SI (plus:SI (match_dup 1) (const_int 16)))
9575 (match_operand:SI 7 "gpc_reg_operand" "r"))])]
9576 "TARGET_STRING && !TARGET_POWER && XVECLEN (operands[0], 0) == 6"
9577 "{stsi|stswi} %2,%1,%O0"
9578 [(set_attr "type" "store_ux")
9579 (set_attr "cell_micro" "always")])
9580
9581 (define_insn "*stmsi4"
9582 [(match_parallel 0 "store_multiple_operation"
9583 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
9584 (match_operand:SI 2 "gpc_reg_operand" "r"))
9585 (clobber (match_scratch:SI 3 "=X"))
9586 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
9587 (match_operand:SI 4 "gpc_reg_operand" "r"))
9588 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
9589 (match_operand:SI 5 "gpc_reg_operand" "r"))
9590 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
9591 (match_operand:SI 6 "gpc_reg_operand" "r"))])]
9592 "TARGET_STRING && !TARGET_POWER && XVECLEN (operands[0], 0) == 5"
9593 "{stsi|stswi} %2,%1,%O0"
9594 [(set_attr "type" "store_ux")
9595 (set_attr "cell_micro" "always")])
9596
9597 (define_insn "*stmsi3"
9598 [(match_parallel 0 "store_multiple_operation"
9599 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
9600 (match_operand:SI 2 "gpc_reg_operand" "r"))
9601 (clobber (match_scratch:SI 3 "=X"))
9602 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
9603 (match_operand:SI 4 "gpc_reg_operand" "r"))
9604 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
9605 (match_operand:SI 5 "gpc_reg_operand" "r"))])]
9606 "TARGET_STRING && !TARGET_POWER && XVECLEN (operands[0], 0) == 4"
9607 "{stsi|stswi} %2,%1,%O0"
9608 [(set_attr "type" "store_ux")
9609 (set_attr "cell_micro" "always")])
9610
9611 (define_insn "*stmsi8_power"
9612 [(match_parallel 0 "store_multiple_operation"
9613 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
9614 (match_operand:SI 2 "gpc_reg_operand" "r"))
9615 (clobber (match_scratch:SI 3 "=q"))
9616 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
9617 (match_operand:SI 4 "gpc_reg_operand" "r"))
9618 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
9619 (match_operand:SI 5 "gpc_reg_operand" "r"))
9620 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
9621 (match_operand:SI 6 "gpc_reg_operand" "r"))
9622 (set (mem:SI (plus:SI (match_dup 1) (const_int 16)))
9623 (match_operand:SI 7 "gpc_reg_operand" "r"))
9624 (set (mem:SI (plus:SI (match_dup 1) (const_int 20)))
9625 (match_operand:SI 8 "gpc_reg_operand" "r"))
9626 (set (mem:SI (plus:SI (match_dup 1) (const_int 24)))
9627 (match_operand:SI 9 "gpc_reg_operand" "r"))
9628 (set (mem:SI (plus:SI (match_dup 1) (const_int 28)))
9629 (match_operand:SI 10 "gpc_reg_operand" "r"))])]
9630 "TARGET_STRING && TARGET_POWER && XVECLEN (operands[0], 0) == 9"
9631 "{stsi|stswi} %2,%1,%O0"
9632 [(set_attr "type" "store_ux")
9633 (set_attr "cell_micro" "always")])
9634
9635 (define_insn "*stmsi7_power"
9636 [(match_parallel 0 "store_multiple_operation"
9637 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
9638 (match_operand:SI 2 "gpc_reg_operand" "r"))
9639 (clobber (match_scratch:SI 3 "=q"))
9640 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
9641 (match_operand:SI 4 "gpc_reg_operand" "r"))
9642 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
9643 (match_operand:SI 5 "gpc_reg_operand" "r"))
9644 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
9645 (match_operand:SI 6 "gpc_reg_operand" "r"))
9646 (set (mem:SI (plus:SI (match_dup 1) (const_int 16)))
9647 (match_operand:SI 7 "gpc_reg_operand" "r"))
9648 (set (mem:SI (plus:SI (match_dup 1) (const_int 20)))
9649 (match_operand:SI 8 "gpc_reg_operand" "r"))
9650 (set (mem:SI (plus:SI (match_dup 1) (const_int 24)))
9651 (match_operand:SI 9 "gpc_reg_operand" "r"))])]
9652 "TARGET_STRING && TARGET_POWER && XVECLEN (operands[0], 0) == 8"
9653 "{stsi|stswi} %2,%1,%O0"
9654 [(set_attr "type" "store_ux")
9655 (set_attr "cell_micro" "always")])
9656
9657 (define_insn "*stmsi6_power"
9658 [(match_parallel 0 "store_multiple_operation"
9659 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
9660 (match_operand:SI 2 "gpc_reg_operand" "r"))
9661 (clobber (match_scratch:SI 3 "=q"))
9662 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
9663 (match_operand:SI 4 "gpc_reg_operand" "r"))
9664 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
9665 (match_operand:SI 5 "gpc_reg_operand" "r"))
9666 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
9667 (match_operand:SI 6 "gpc_reg_operand" "r"))
9668 (set (mem:SI (plus:SI (match_dup 1) (const_int 16)))
9669 (match_operand:SI 7 "gpc_reg_operand" "r"))
9670 (set (mem:SI (plus:SI (match_dup 1) (const_int 20)))
9671 (match_operand:SI 8 "gpc_reg_operand" "r"))])]
9672 "TARGET_STRING && TARGET_POWER && XVECLEN (operands[0], 0) == 7"
9673 "{stsi|stswi} %2,%1,%O0"
9674 [(set_attr "type" "store_ux")
9675 (set_attr "cell_micro" "always")])
9676
9677 (define_insn "*stmsi5_power"
9678 [(match_parallel 0 "store_multiple_operation"
9679 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
9680 (match_operand:SI 2 "gpc_reg_operand" "r"))
9681 (clobber (match_scratch:SI 3 "=q"))
9682 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
9683 (match_operand:SI 4 "gpc_reg_operand" "r"))
9684 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
9685 (match_operand:SI 5 "gpc_reg_operand" "r"))
9686 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
9687 (match_operand:SI 6 "gpc_reg_operand" "r"))
9688 (set (mem:SI (plus:SI (match_dup 1) (const_int 16)))
9689 (match_operand:SI 7 "gpc_reg_operand" "r"))])]
9690 "TARGET_STRING && TARGET_POWER && XVECLEN (operands[0], 0) == 6"
9691 "{stsi|stswi} %2,%1,%O0"
9692 [(set_attr "type" "store_ux")
9693 (set_attr "cell_micro" "always")])
9694
9695 (define_insn "*stmsi4_power"
9696 [(match_parallel 0 "store_multiple_operation"
9697 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
9698 (match_operand:SI 2 "gpc_reg_operand" "r"))
9699 (clobber (match_scratch:SI 3 "=q"))
9700 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
9701 (match_operand:SI 4 "gpc_reg_operand" "r"))
9702 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
9703 (match_operand:SI 5 "gpc_reg_operand" "r"))
9704 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
9705 (match_operand:SI 6 "gpc_reg_operand" "r"))])]
9706 "TARGET_STRING && TARGET_POWER && XVECLEN (operands[0], 0) == 5"
9707 "{stsi|stswi} %2,%1,%O0"
9708 [(set_attr "type" "store_ux")
9709 (set_attr "cell_micro" "always")])
9710
9711 (define_insn "*stmsi3_power"
9712 [(match_parallel 0 "store_multiple_operation"
9713 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
9714 (match_operand:SI 2 "gpc_reg_operand" "r"))
9715 (clobber (match_scratch:SI 3 "=q"))
9716 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
9717 (match_operand:SI 4 "gpc_reg_operand" "r"))
9718 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
9719 (match_operand:SI 5 "gpc_reg_operand" "r"))])]
9720 "TARGET_STRING && TARGET_POWER && XVECLEN (operands[0], 0) == 4"
9721 "{stsi|stswi} %2,%1,%O0"
9722 [(set_attr "type" "store_ux")
9723 (set_attr "cell_micro" "always")])
9724 \f
9725 (define_expand "setmemsi"
9726 [(parallel [(set (match_operand:BLK 0 "" "")
9727 (match_operand 2 "const_int_operand" ""))
9728 (use (match_operand:SI 1 "" ""))
9729 (use (match_operand:SI 3 "" ""))])]
9730 ""
9731 "
9732 {
9733 /* If value to set is not zero, use the library routine. */
9734 if (operands[2] != const0_rtx)
9735 FAIL;
9736
9737 if (expand_block_clear (operands))
9738 DONE;
9739 else
9740 FAIL;
9741 }")
9742
9743 ;; String/block move insn.
9744 ;; Argument 0 is the destination
9745 ;; Argument 1 is the source
9746 ;; Argument 2 is the length
9747 ;; Argument 3 is the alignment
9748
9749 (define_expand "movmemsi"
9750 [(parallel [(set (match_operand:BLK 0 "" "")
9751 (match_operand:BLK 1 "" ""))
9752 (use (match_operand:SI 2 "" ""))
9753 (use (match_operand:SI 3 "" ""))])]
9754 ""
9755 "
9756 {
9757 if (expand_block_move (operands))
9758 DONE;
9759 else
9760 FAIL;
9761 }")
9762
9763 ;; Move up to 32 bytes at a time. The fixed registers are needed because the
9764 ;; register allocator doesn't have a clue about allocating 8 word registers.
9765 ;; rD/rS = r5 is preferred, efficient form.
9766 (define_expand "movmemsi_8reg"
9767 [(parallel [(set (match_operand 0 "" "")
9768 (match_operand 1 "" ""))
9769 (use (match_operand 2 "" ""))
9770 (use (match_operand 3 "" ""))
9771 (clobber (reg:SI 5))
9772 (clobber (reg:SI 6))
9773 (clobber (reg:SI 7))
9774 (clobber (reg:SI 8))
9775 (clobber (reg:SI 9))
9776 (clobber (reg:SI 10))
9777 (clobber (reg:SI 11))
9778 (clobber (reg:SI 12))
9779 (clobber (match_scratch:SI 4 ""))])]
9780 "TARGET_STRING"
9781 "")
9782
9783 (define_insn ""
9784 [(set (mem:BLK (match_operand:SI 0 "gpc_reg_operand" "b"))
9785 (mem:BLK (match_operand:SI 1 "gpc_reg_operand" "b")))
9786 (use (match_operand:SI 2 "immediate_operand" "i"))
9787 (use (match_operand:SI 3 "immediate_operand" "i"))
9788 (clobber (match_operand:SI 4 "gpc_reg_operand" "=&r"))
9789 (clobber (reg:SI 6))
9790 (clobber (reg:SI 7))
9791 (clobber (reg:SI 8))
9792 (clobber (reg:SI 9))
9793 (clobber (reg:SI 10))
9794 (clobber (reg:SI 11))
9795 (clobber (reg:SI 12))
9796 (clobber (match_scratch:SI 5 "=q"))]
9797 "TARGET_STRING && TARGET_POWER
9798 && ((INTVAL (operands[2]) > 24 && INTVAL (operands[2]) < 32)
9799 || INTVAL (operands[2]) == 0)
9800 && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 12)
9801 && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 12)
9802 && REGNO (operands[4]) == 5"
9803 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
9804 [(set_attr "type" "store_ux")
9805 (set_attr "cell_micro" "always")
9806 (set_attr "length" "8")])
9807
9808 (define_insn ""
9809 [(set (mem:BLK (match_operand:P 0 "gpc_reg_operand" "b"))
9810 (mem:BLK (match_operand:P 1 "gpc_reg_operand" "b")))
9811 (use (match_operand:SI 2 "immediate_operand" "i"))
9812 (use (match_operand:SI 3 "immediate_operand" "i"))
9813 (clobber (match_operand:SI 4 "gpc_reg_operand" "=&r"))
9814 (clobber (reg:SI 6))
9815 (clobber (reg:SI 7))
9816 (clobber (reg:SI 8))
9817 (clobber (reg:SI 9))
9818 (clobber (reg:SI 10))
9819 (clobber (reg:SI 11))
9820 (clobber (reg:SI 12))
9821 (clobber (match_scratch:SI 5 "=X"))]
9822 "TARGET_STRING && ! TARGET_POWER
9823 && ((INTVAL (operands[2]) > 24 && INTVAL (operands[2]) < 32)
9824 || INTVAL (operands[2]) == 0)
9825 && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 12)
9826 && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 12)
9827 && REGNO (operands[4]) == 5"
9828 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
9829 [(set_attr "type" "store_ux")
9830 (set_attr "cell_micro" "always")
9831 (set_attr "length" "8")])
9832
9833 ;; Move up to 24 bytes at a time. The fixed registers are needed because the
9834 ;; register allocator doesn't have a clue about allocating 6 word registers.
9835 ;; rD/rS = r5 is preferred, efficient form.
9836 (define_expand "movmemsi_6reg"
9837 [(parallel [(set (match_operand 0 "" "")
9838 (match_operand 1 "" ""))
9839 (use (match_operand 2 "" ""))
9840 (use (match_operand 3 "" ""))
9841 (clobber (reg:SI 5))
9842 (clobber (reg:SI 6))
9843 (clobber (reg:SI 7))
9844 (clobber (reg:SI 8))
9845 (clobber (reg:SI 9))
9846 (clobber (reg:SI 10))
9847 (clobber (match_scratch:SI 4 ""))])]
9848 "TARGET_STRING"
9849 "")
9850
9851 (define_insn ""
9852 [(set (mem:BLK (match_operand:SI 0 "gpc_reg_operand" "b"))
9853 (mem:BLK (match_operand:SI 1 "gpc_reg_operand" "b")))
9854 (use (match_operand:SI 2 "immediate_operand" "i"))
9855 (use (match_operand:SI 3 "immediate_operand" "i"))
9856 (clobber (match_operand:SI 4 "gpc_reg_operand" "=&r"))
9857 (clobber (reg:SI 6))
9858 (clobber (reg:SI 7))
9859 (clobber (reg:SI 8))
9860 (clobber (reg:SI 9))
9861 (clobber (reg:SI 10))
9862 (clobber (match_scratch:SI 5 "=q"))]
9863 "TARGET_STRING && TARGET_POWER
9864 && INTVAL (operands[2]) > 16 && INTVAL (operands[2]) <= 24
9865 && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 10)
9866 && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 10)
9867 && REGNO (operands[4]) == 5"
9868 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
9869 [(set_attr "type" "store_ux")
9870 (set_attr "cell_micro" "always")
9871 (set_attr "length" "8")])
9872
9873 (define_insn ""
9874 [(set (mem:BLK (match_operand:P 0 "gpc_reg_operand" "b"))
9875 (mem:BLK (match_operand:P 1 "gpc_reg_operand" "b")))
9876 (use (match_operand:SI 2 "immediate_operand" "i"))
9877 (use (match_operand:SI 3 "immediate_operand" "i"))
9878 (clobber (match_operand:SI 4 "gpc_reg_operand" "=&r"))
9879 (clobber (reg:SI 6))
9880 (clobber (reg:SI 7))
9881 (clobber (reg:SI 8))
9882 (clobber (reg:SI 9))
9883 (clobber (reg:SI 10))
9884 (clobber (match_scratch:SI 5 "=X"))]
9885 "TARGET_STRING && ! TARGET_POWER
9886 && INTVAL (operands[2]) > 16 && INTVAL (operands[2]) <= 32
9887 && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 10)
9888 && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 10)
9889 && REGNO (operands[4]) == 5"
9890 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
9891 [(set_attr "type" "store_ux")
9892 (set_attr "cell_micro" "always")
9893 (set_attr "length" "8")])
9894
9895 ;; Move up to 16 bytes at a time, using 4 fixed registers to avoid spill
9896 ;; problems with TImode.
9897 ;; rD/rS = r5 is preferred, efficient form.
9898 (define_expand "movmemsi_4reg"
9899 [(parallel [(set (match_operand 0 "" "")
9900 (match_operand 1 "" ""))
9901 (use (match_operand 2 "" ""))
9902 (use (match_operand 3 "" ""))
9903 (clobber (reg:SI 5))
9904 (clobber (reg:SI 6))
9905 (clobber (reg:SI 7))
9906 (clobber (reg:SI 8))
9907 (clobber (match_scratch:SI 4 ""))])]
9908 "TARGET_STRING"
9909 "")
9910
9911 (define_insn ""
9912 [(set (mem:BLK (match_operand:SI 0 "gpc_reg_operand" "b"))
9913 (mem:BLK (match_operand:SI 1 "gpc_reg_operand" "b")))
9914 (use (match_operand:SI 2 "immediate_operand" "i"))
9915 (use (match_operand:SI 3 "immediate_operand" "i"))
9916 (clobber (match_operand:SI 4 "gpc_reg_operand" "=&r"))
9917 (clobber (reg:SI 6))
9918 (clobber (reg:SI 7))
9919 (clobber (reg:SI 8))
9920 (clobber (match_scratch:SI 5 "=q"))]
9921 "TARGET_STRING && TARGET_POWER
9922 && INTVAL (operands[2]) > 8 && INTVAL (operands[2]) <= 16
9923 && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 8)
9924 && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 8)
9925 && REGNO (operands[4]) == 5"
9926 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
9927 [(set_attr "type" "store_ux")
9928 (set_attr "cell_micro" "always")
9929 (set_attr "length" "8")])
9930
9931 (define_insn ""
9932 [(set (mem:BLK (match_operand:P 0 "gpc_reg_operand" "b"))
9933 (mem:BLK (match_operand:P 1 "gpc_reg_operand" "b")))
9934 (use (match_operand:SI 2 "immediate_operand" "i"))
9935 (use (match_operand:SI 3 "immediate_operand" "i"))
9936 (clobber (match_operand:SI 4 "gpc_reg_operand" "=&r"))
9937 (clobber (reg:SI 6))
9938 (clobber (reg:SI 7))
9939 (clobber (reg:SI 8))
9940 (clobber (match_scratch:SI 5 "=X"))]
9941 "TARGET_STRING && ! TARGET_POWER
9942 && INTVAL (operands[2]) > 8 && INTVAL (operands[2]) <= 16
9943 && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 8)
9944 && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 8)
9945 && REGNO (operands[4]) == 5"
9946 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
9947 [(set_attr "type" "store_ux")
9948 (set_attr "cell_micro" "always")
9949 (set_attr "length" "8")])
9950
9951 ;; Move up to 8 bytes at a time.
9952 (define_expand "movmemsi_2reg"
9953 [(parallel [(set (match_operand 0 "" "")
9954 (match_operand 1 "" ""))
9955 (use (match_operand 2 "" ""))
9956 (use (match_operand 3 "" ""))
9957 (clobber (match_scratch:DI 4 ""))
9958 (clobber (match_scratch:SI 5 ""))])]
9959 "TARGET_STRING && ! TARGET_POWERPC64"
9960 "")
9961
9962 (define_insn ""
9963 [(set (mem:BLK (match_operand:SI 0 "gpc_reg_operand" "b"))
9964 (mem:BLK (match_operand:SI 1 "gpc_reg_operand" "b")))
9965 (use (match_operand:SI 2 "immediate_operand" "i"))
9966 (use (match_operand:SI 3 "immediate_operand" "i"))
9967 (clobber (match_scratch:DI 4 "=&r"))
9968 (clobber (match_scratch:SI 5 "=q"))]
9969 "TARGET_STRING && TARGET_POWER && ! TARGET_POWERPC64
9970 && INTVAL (operands[2]) > 4 && INTVAL (operands[2]) <= 8"
9971 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
9972 [(set_attr "type" "store_ux")
9973 (set_attr "cell_micro" "always")
9974 (set_attr "length" "8")])
9975
9976 (define_insn ""
9977 [(set (mem:BLK (match_operand:SI 0 "gpc_reg_operand" "b"))
9978 (mem:BLK (match_operand:SI 1 "gpc_reg_operand" "b")))
9979 (use (match_operand:SI 2 "immediate_operand" "i"))
9980 (use (match_operand:SI 3 "immediate_operand" "i"))
9981 (clobber (match_scratch:DI 4 "=&r"))
9982 (clobber (match_scratch:SI 5 "=X"))]
9983 "TARGET_STRING && ! TARGET_POWER && ! TARGET_POWERPC64
9984 && INTVAL (operands[2]) > 4 && INTVAL (operands[2]) <= 8"
9985 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
9986 [(set_attr "type" "store_ux")
9987 (set_attr "cell_micro" "always")
9988 (set_attr "length" "8")])
9989
9990 ;; Move up to 4 bytes at a time.
9991 (define_expand "movmemsi_1reg"
9992 [(parallel [(set (match_operand 0 "" "")
9993 (match_operand 1 "" ""))
9994 (use (match_operand 2 "" ""))
9995 (use (match_operand 3 "" ""))
9996 (clobber (match_scratch:SI 4 ""))
9997 (clobber (match_scratch:SI 5 ""))])]
9998 "TARGET_STRING"
9999 "")
10000
10001 (define_insn ""
10002 [(set (mem:BLK (match_operand:SI 0 "gpc_reg_operand" "b"))
10003 (mem:BLK (match_operand:SI 1 "gpc_reg_operand" "b")))
10004 (use (match_operand:SI 2 "immediate_operand" "i"))
10005 (use (match_operand:SI 3 "immediate_operand" "i"))
10006 (clobber (match_scratch:SI 4 "=&r"))
10007 (clobber (match_scratch:SI 5 "=q"))]
10008 "TARGET_STRING && TARGET_POWER
10009 && INTVAL (operands[2]) > 0 && INTVAL (operands[2]) <= 4"
10010 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
10011 [(set_attr "type" "store_ux")
10012 (set_attr "cell_micro" "always")
10013 (set_attr "length" "8")])
10014
10015 (define_insn ""
10016 [(set (mem:BLK (match_operand:P 0 "gpc_reg_operand" "b"))
10017 (mem:BLK (match_operand:P 1 "gpc_reg_operand" "b")))
10018 (use (match_operand:SI 2 "immediate_operand" "i"))
10019 (use (match_operand:SI 3 "immediate_operand" "i"))
10020 (clobber (match_scratch:SI 4 "=&r"))
10021 (clobber (match_scratch:SI 5 "=X"))]
10022 "TARGET_STRING && ! TARGET_POWER
10023 && INTVAL (operands[2]) > 0 && INTVAL (operands[2]) <= 4"
10024 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
10025 [(set_attr "type" "store_ux")
10026 (set_attr "cell_micro" "always")
10027 (set_attr "length" "8")])
10028 \f
10029 ;; Define insns that do load or store with update. Some of these we can
10030 ;; get by using pre-decrement or pre-increment, but the hardware can also
10031 ;; do cases where the increment is not the size of the object.
10032 ;;
10033 ;; In all these cases, we use operands 0 and 1 for the register being
10034 ;; incremented because those are the operands that local-alloc will
10035 ;; tie and these are the pair most likely to be tieable (and the ones
10036 ;; that will benefit the most).
10037
10038 (define_insn "*movdi_update1"
10039 [(set (match_operand:DI 3 "gpc_reg_operand" "=r,r")
10040 (mem:DI (plus:DI (match_operand:DI 1 "gpc_reg_operand" "0,0")
10041 (match_operand:DI 2 "reg_or_aligned_short_operand" "r,I"))))
10042 (set (match_operand:DI 0 "gpc_reg_operand" "=b,b")
10043 (plus:DI (match_dup 1) (match_dup 2)))]
10044 "TARGET_POWERPC64 && TARGET_UPDATE
10045 && (!avoiding_indexed_address_p (DImode)
10046 || !gpc_reg_operand (operands[2], DImode))"
10047 "@
10048 ldux %3,%0,%2
10049 ldu %3,%2(%0)"
10050 [(set_attr "type" "load_ux,load_u")])
10051
10052 (define_insn "movdi_<mode>_update"
10053 [(set (mem:DI (plus:P (match_operand:P 1 "gpc_reg_operand" "0,0")
10054 (match_operand:P 2 "reg_or_aligned_short_operand" "r,I")))
10055 (match_operand:DI 3 "gpc_reg_operand" "r,r"))
10056 (set (match_operand:P 0 "gpc_reg_operand" "=b,b")
10057 (plus:P (match_dup 1) (match_dup 2)))]
10058 "TARGET_POWERPC64 && TARGET_UPDATE
10059 && (!avoiding_indexed_address_p (Pmode)
10060 || !gpc_reg_operand (operands[2], Pmode)
10061 || (REG_P (operands[0])
10062 && REGNO (operands[0]) == STACK_POINTER_REGNUM))"
10063 "@
10064 stdux %3,%0,%2
10065 stdu %3,%2(%0)"
10066 [(set_attr "type" "store_ux,store_u")])
10067
10068 ;; This pattern is only conditional on TARGET_POWERPC64, as it is
10069 ;; needed for stack allocation, even if the user passes -mno-update.
10070 (define_insn "movdi_<mode>_update_stack"
10071 [(set (mem:DI (plus:P (match_operand:P 1 "gpc_reg_operand" "0,0")
10072 (match_operand:P 2 "reg_or_aligned_short_operand" "r,I")))
10073 (match_operand:DI 3 "gpc_reg_operand" "r,r"))
10074 (set (match_operand:P 0 "gpc_reg_operand" "=b,b")
10075 (plus:P (match_dup 1) (match_dup 2)))]
10076 "TARGET_POWERPC64"
10077 "@
10078 stdux %3,%0,%2
10079 stdu %3,%2(%0)"
10080 [(set_attr "type" "store_ux,store_u")])
10081
10082 (define_insn "*movsi_update1"
10083 [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
10084 (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10085 (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
10086 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10087 (plus:SI (match_dup 1) (match_dup 2)))]
10088 "TARGET_UPDATE
10089 && (!avoiding_indexed_address_p (SImode)
10090 || !gpc_reg_operand (operands[2], SImode))"
10091 "@
10092 {lux|lwzux} %3,%0,%2
10093 {lu|lwzu} %3,%2(%0)"
10094 [(set_attr "type" "load_ux,load_u")])
10095
10096 (define_insn "*movsi_update2"
10097 [(set (match_operand:DI 3 "gpc_reg_operand" "=r")
10098 (sign_extend:DI
10099 (mem:SI (plus:DI (match_operand:DI 1 "gpc_reg_operand" "0")
10100 (match_operand:DI 2 "gpc_reg_operand" "r")))))
10101 (set (match_operand:DI 0 "gpc_reg_operand" "=b")
10102 (plus:DI (match_dup 1) (match_dup 2)))]
10103 "TARGET_POWERPC64 && rs6000_gen_cell_microcode
10104 && !avoiding_indexed_address_p (DImode)"
10105 "lwaux %3,%0,%2"
10106 [(set_attr "type" "load_ext_ux")])
10107
10108 (define_insn "movsi_update"
10109 [(set (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10110 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
10111 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
10112 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10113 (plus:SI (match_dup 1) (match_dup 2)))]
10114 "TARGET_UPDATE
10115 && (!avoiding_indexed_address_p (SImode)
10116 || !gpc_reg_operand (operands[2], SImode)
10117 || (REG_P (operands[0])
10118 && REGNO (operands[0]) == STACK_POINTER_REGNUM))"
10119 "@
10120 {stux|stwux} %3,%0,%2
10121 {stu|stwu} %3,%2(%0)"
10122 [(set_attr "type" "store_ux,store_u")])
10123
10124 ;; This is an unconditional pattern; needed for stack allocation, even
10125 ;; if the user passes -mno-update.
10126 (define_insn "movsi_update_stack"
10127 [(set (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10128 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
10129 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
10130 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10131 (plus:SI (match_dup 1) (match_dup 2)))]
10132 ""
10133 "@
10134 {stux|stwux} %3,%0,%2
10135 {stu|stwu} %3,%2(%0)"
10136 [(set_attr "type" "store_ux,store_u")])
10137
10138 (define_insn "*movhi_update1"
10139 [(set (match_operand:HI 3 "gpc_reg_operand" "=r,r")
10140 (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10141 (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
10142 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10143 (plus:SI (match_dup 1) (match_dup 2)))]
10144 "TARGET_UPDATE
10145 && (!avoiding_indexed_address_p (SImode)
10146 || !gpc_reg_operand (operands[2], SImode))"
10147 "@
10148 lhzux %3,%0,%2
10149 lhzu %3,%2(%0)"
10150 [(set_attr "type" "load_ux,load_u")])
10151
10152 (define_insn "*movhi_update2"
10153 [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
10154 (zero_extend:SI
10155 (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10156 (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
10157 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10158 (plus:SI (match_dup 1) (match_dup 2)))]
10159 "TARGET_UPDATE
10160 && (!avoiding_indexed_address_p (SImode)
10161 || !gpc_reg_operand (operands[2], SImode))"
10162 "@
10163 lhzux %3,%0,%2
10164 lhzu %3,%2(%0)"
10165 [(set_attr "type" "load_ux,load_u")])
10166
10167 (define_insn "*movhi_update3"
10168 [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
10169 (sign_extend:SI
10170 (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10171 (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
10172 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10173 (plus:SI (match_dup 1) (match_dup 2)))]
10174 "TARGET_UPDATE && rs6000_gen_cell_microcode
10175 && (!avoiding_indexed_address_p (SImode)
10176 || !gpc_reg_operand (operands[2], SImode))"
10177 "@
10178 lhaux %3,%0,%2
10179 lhau %3,%2(%0)"
10180 [(set_attr "type" "load_ext_ux,load_ext_u")])
10181
10182 (define_insn "*movhi_update4"
10183 [(set (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10184 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
10185 (match_operand:HI 3 "gpc_reg_operand" "r,r"))
10186 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10187 (plus:SI (match_dup 1) (match_dup 2)))]
10188 "TARGET_UPDATE
10189 && (!avoiding_indexed_address_p (SImode)
10190 || !gpc_reg_operand (operands[2], SImode))"
10191 "@
10192 sthux %3,%0,%2
10193 sthu %3,%2(%0)"
10194 [(set_attr "type" "store_ux,store_u")])
10195
10196 (define_insn "*movqi_update1"
10197 [(set (match_operand:QI 3 "gpc_reg_operand" "=r,r")
10198 (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10199 (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
10200 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10201 (plus:SI (match_dup 1) (match_dup 2)))]
10202 "TARGET_UPDATE
10203 && (!avoiding_indexed_address_p (SImode)
10204 || !gpc_reg_operand (operands[2], SImode))"
10205 "@
10206 lbzux %3,%0,%2
10207 lbzu %3,%2(%0)"
10208 [(set_attr "type" "load_ux,load_u")])
10209
10210 (define_insn "*movqi_update2"
10211 [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
10212 (zero_extend:SI
10213 (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10214 (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
10215 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10216 (plus:SI (match_dup 1) (match_dup 2)))]
10217 "TARGET_UPDATE
10218 && (!avoiding_indexed_address_p (SImode)
10219 || !gpc_reg_operand (operands[2], SImode))"
10220 "@
10221 lbzux %3,%0,%2
10222 lbzu %3,%2(%0)"
10223 [(set_attr "type" "load_ux,load_u")])
10224
10225 (define_insn "*movqi_update3"
10226 [(set (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10227 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
10228 (match_operand:QI 3 "gpc_reg_operand" "r,r"))
10229 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10230 (plus:SI (match_dup 1) (match_dup 2)))]
10231 "TARGET_UPDATE
10232 && (!avoiding_indexed_address_p (SImode)
10233 || !gpc_reg_operand (operands[2], SImode))"
10234 "@
10235 stbux %3,%0,%2
10236 stbu %3,%2(%0)"
10237 [(set_attr "type" "store_ux,store_u")])
10238
10239 (define_insn "*movsf_update1"
10240 [(set (match_operand:SF 3 "gpc_reg_operand" "=f,f")
10241 (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10242 (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
10243 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10244 (plus:SI (match_dup 1) (match_dup 2)))]
10245 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT && TARGET_UPDATE
10246 && (!avoiding_indexed_address_p (SImode)
10247 || !gpc_reg_operand (operands[2], SImode))"
10248 "@
10249 lfsux %3,%0,%2
10250 lfsu %3,%2(%0)"
10251 [(set_attr "type" "fpload_ux,fpload_u")])
10252
10253 (define_insn "*movsf_update2"
10254 [(set (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10255 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
10256 (match_operand:SF 3 "gpc_reg_operand" "f,f"))
10257 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10258 (plus:SI (match_dup 1) (match_dup 2)))]
10259 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT && TARGET_UPDATE
10260 && (!avoiding_indexed_address_p (SImode)
10261 || !gpc_reg_operand (operands[2], SImode))"
10262 "@
10263 stfsux %3,%0,%2
10264 stfsu %3,%2(%0)"
10265 [(set_attr "type" "fpstore_ux,fpstore_u")])
10266
10267 (define_insn "*movsf_update3"
10268 [(set (match_operand:SF 3 "gpc_reg_operand" "=r,r")
10269 (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10270 (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
10271 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10272 (plus:SI (match_dup 1) (match_dup 2)))]
10273 "(TARGET_SOFT_FLOAT || !TARGET_FPRS) && TARGET_UPDATE
10274 && (!avoiding_indexed_address_p (SImode)
10275 || !gpc_reg_operand (operands[2], SImode))"
10276 "@
10277 {lux|lwzux} %3,%0,%2
10278 {lu|lwzu} %3,%2(%0)"
10279 [(set_attr "type" "load_ux,load_u")])
10280
10281 (define_insn "*movsf_update4"
10282 [(set (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10283 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
10284 (match_operand:SF 3 "gpc_reg_operand" "r,r"))
10285 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10286 (plus:SI (match_dup 1) (match_dup 2)))]
10287 "(TARGET_SOFT_FLOAT || !TARGET_FPRS) && TARGET_UPDATE
10288 && (!avoiding_indexed_address_p (SImode)
10289 || !gpc_reg_operand (operands[2], SImode))"
10290 "@
10291 {stux|stwux} %3,%0,%2
10292 {stu|stwu} %3,%2(%0)"
10293 [(set_attr "type" "store_ux,store_u")])
10294
10295 (define_insn "*movdf_update1"
10296 [(set (match_operand:DF 3 "gpc_reg_operand" "=f,f")
10297 (mem:DF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10298 (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
10299 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10300 (plus:SI (match_dup 1) (match_dup 2)))]
10301 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT && TARGET_UPDATE
10302 && (!avoiding_indexed_address_p (SImode)
10303 || !gpc_reg_operand (operands[2], SImode))"
10304 "@
10305 lfdux %3,%0,%2
10306 lfdu %3,%2(%0)"
10307 [(set_attr "type" "fpload_ux,fpload_u")])
10308
10309 (define_insn "*movdf_update2"
10310 [(set (mem:DF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
10311 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
10312 (match_operand:DF 3 "gpc_reg_operand" "f,f"))
10313 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
10314 (plus:SI (match_dup 1) (match_dup 2)))]
10315 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT && TARGET_UPDATE
10316 && (!avoiding_indexed_address_p (SImode)
10317 || !gpc_reg_operand (operands[2], SImode))"
10318 "@
10319 stfdux %3,%0,%2
10320 stfdu %3,%2(%0)"
10321 [(set_attr "type" "fpstore_ux,fpstore_u")])
10322
10323 ;; Peephole to convert two consecutive FP loads or stores into lfq/stfq.
10324
10325 (define_insn "*lfq_power2"
10326 [(set (match_operand:V2DF 0 "gpc_reg_operand" "=f")
10327 (match_operand:V2DF 1 "memory_operand" ""))]
10328 "TARGET_POWER2
10329 && TARGET_HARD_FLOAT && TARGET_FPRS"
10330 "lfq%U1%X1 %0,%1")
10331
10332 (define_peephole2
10333 [(set (match_operand:DF 0 "gpc_reg_operand" "")
10334 (match_operand:DF 1 "memory_operand" ""))
10335 (set (match_operand:DF 2 "gpc_reg_operand" "")
10336 (match_operand:DF 3 "memory_operand" ""))]
10337 "TARGET_POWER2
10338 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT
10339 && registers_ok_for_quad_peep (operands[0], operands[2])
10340 && mems_ok_for_quad_peep (operands[1], operands[3])"
10341 [(set (match_dup 0)
10342 (match_dup 1))]
10343 "operands[1] = widen_memory_access (operands[1], V2DFmode, 0);
10344 operands[0] = gen_rtx_REG (V2DFmode, REGNO (operands[0]));")
10345
10346 (define_insn "*stfq_power2"
10347 [(set (match_operand:V2DF 0 "memory_operand" "")
10348 (match_operand:V2DF 1 "gpc_reg_operand" "f"))]
10349 "TARGET_POWER2
10350 && TARGET_HARD_FLOAT && TARGET_FPRS"
10351 "stfq%U0%X0 %1,%0")
10352
10353
10354 (define_peephole2
10355 [(set (match_operand:DF 0 "memory_operand" "")
10356 (match_operand:DF 1 "gpc_reg_operand" ""))
10357 (set (match_operand:DF 2 "memory_operand" "")
10358 (match_operand:DF 3 "gpc_reg_operand" ""))]
10359 "TARGET_POWER2
10360 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT
10361 && registers_ok_for_quad_peep (operands[1], operands[3])
10362 && mems_ok_for_quad_peep (operands[0], operands[2])"
10363 [(set (match_dup 0)
10364 (match_dup 1))]
10365 "operands[0] = widen_memory_access (operands[0], V2DFmode, 0);
10366 operands[1] = gen_rtx_REG (V2DFmode, REGNO (operands[1]));")
10367
10368 ;; After inserting conditional returns we can sometimes have
10369 ;; unnecessary register moves. Unfortunately we cannot have a
10370 ;; modeless peephole here, because some single SImode sets have early
10371 ;; clobber outputs. Although those sets expand to multi-ppc-insn
10372 ;; sequences, using get_attr_length here will smash the operands
10373 ;; array. Neither is there an early_cobbler_p predicate.
10374 ;; Disallow subregs for E500 so we don't munge frob_di_df_2.
10375 (define_peephole2
10376 [(set (match_operand:DF 0 "gpc_reg_operand" "")
10377 (match_operand:DF 1 "any_operand" ""))
10378 (set (match_operand:DF 2 "gpc_reg_operand" "")
10379 (match_dup 0))]
10380 "!(TARGET_E500_DOUBLE && GET_CODE (operands[2]) == SUBREG)
10381 && peep2_reg_dead_p (2, operands[0])"
10382 [(set (match_dup 2) (match_dup 1))])
10383
10384 (define_peephole2
10385 [(set (match_operand:SF 0 "gpc_reg_operand" "")
10386 (match_operand:SF 1 "any_operand" ""))
10387 (set (match_operand:SF 2 "gpc_reg_operand" "")
10388 (match_dup 0))]
10389 "peep2_reg_dead_p (2, operands[0])"
10390 [(set (match_dup 2) (match_dup 1))])
10391
10392 \f
10393 ;; TLS support.
10394
10395 ;; Mode attributes for different ABIs.
10396 (define_mode_iterator TLSmode [(SI "! TARGET_64BIT") (DI "TARGET_64BIT")])
10397 (define_mode_attr tls_abi_suffix [(SI "32") (DI "64")])
10398 (define_mode_attr tls_sysv_suffix [(SI "si") (DI "di")])
10399 (define_mode_attr tls_insn_suffix [(SI "wz") (DI "d")])
10400
10401 (define_insn_and_split "tls_gd_aix<TLSmode:tls_abi_suffix>"
10402 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=b")
10403 (call (mem:TLSmode (match_operand:TLSmode 3 "symbol_ref_operand" "s"))
10404 (match_operand 4 "" "g")))
10405 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")
10406 (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")]
10407 UNSPEC_TLSGD)
10408 (clobber (reg:SI LR_REGNO))]
10409 "HAVE_AS_TLS && DEFAULT_ABI == ABI_AIX"
10410 "addi %0,%1,%2@got@tlsgd\;bl %z3\;%."
10411 "&& TARGET_TLS_MARKERS"
10412 [(set (match_dup 0)
10413 (unspec:TLSmode [(match_dup 1)
10414 (match_dup 2)]
10415 UNSPEC_TLSGD))
10416 (parallel [(set (match_dup 0)
10417 (call (mem:TLSmode (match_dup 3))
10418 (match_dup 4)))
10419 (unspec:TLSmode [(match_dup 2)] UNSPEC_TLSGD)
10420 (clobber (reg:SI LR_REGNO))])]
10421 ""
10422 [(set_attr "type" "two")
10423 (set_attr "length" "12")])
10424
10425 (define_insn_and_split "tls_gd_sysv<TLSmode:tls_sysv_suffix>"
10426 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=b")
10427 (call (mem:TLSmode (match_operand:TLSmode 3 "symbol_ref_operand" "s"))
10428 (match_operand 4 "" "g")))
10429 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")
10430 (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")]
10431 UNSPEC_TLSGD)
10432 (clobber (reg:SI LR_REGNO))]
10433 "HAVE_AS_TLS && DEFAULT_ABI == ABI_V4"
10434 {
10435 if (flag_pic)
10436 {
10437 if (TARGET_SECURE_PLT && flag_pic == 2)
10438 return "addi %0,%1,%2@got@tlsgd\;bl %z3+32768@plt";
10439 else
10440 return "addi %0,%1,%2@got@tlsgd\;bl %z3@plt";
10441 }
10442 else
10443 return "addi %0,%1,%2@got@tlsgd\;bl %z3";
10444 }
10445 "&& TARGET_TLS_MARKERS"
10446 [(set (match_dup 0)
10447 (unspec:TLSmode [(match_dup 1)
10448 (match_dup 2)]
10449 UNSPEC_TLSGD))
10450 (parallel [(set (match_dup 0)
10451 (call (mem:TLSmode (match_dup 3))
10452 (match_dup 4)))
10453 (unspec:TLSmode [(match_dup 2)] UNSPEC_TLSGD)
10454 (clobber (reg:SI LR_REGNO))])]
10455 ""
10456 [(set_attr "type" "two")
10457 (set_attr "length" "8")])
10458
10459 (define_insn "*tls_gd<TLSmode:tls_abi_suffix>"
10460 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=b")
10461 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")
10462 (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")]
10463 UNSPEC_TLSGD))]
10464 "HAVE_AS_TLS && TARGET_TLS_MARKERS"
10465 "addi %0,%1,%2@got@tlsgd"
10466 [(set_attr "length" "4")])
10467
10468 (define_insn "*tls_gd_call_aix<TLSmode:tls_abi_suffix>"
10469 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=b")
10470 (call (mem:TLSmode (match_operand:TLSmode 1 "symbol_ref_operand" "s"))
10471 (match_operand 2 "" "g")))
10472 (unspec:TLSmode [(match_operand:TLSmode 3 "rs6000_tls_symbol_ref" "")]
10473 UNSPEC_TLSGD)
10474 (clobber (reg:SI LR_REGNO))]
10475 "HAVE_AS_TLS && DEFAULT_ABI == ABI_AIX && TARGET_TLS_MARKERS"
10476 "bl %z1(%3@tlsgd)\;%."
10477 [(set_attr "type" "branch")
10478 (set_attr "length" "8")])
10479
10480 (define_insn "*tls_gd_call_sysv<TLSmode:tls_abi_suffix>"
10481 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=b")
10482 (call (mem:TLSmode (match_operand:TLSmode 1 "symbol_ref_operand" "s"))
10483 (match_operand 2 "" "g")))
10484 (unspec:TLSmode [(match_operand:TLSmode 3 "rs6000_tls_symbol_ref" "")]
10485 UNSPEC_TLSGD)
10486 (clobber (reg:SI LR_REGNO))]
10487 "HAVE_AS_TLS && DEFAULT_ABI == ABI_V4 && TARGET_TLS_MARKERS"
10488 {
10489 if (flag_pic)
10490 {
10491 if (TARGET_SECURE_PLT && flag_pic == 2)
10492 return "bl %z1+32768(%3@tlsgd)@plt";
10493 return "bl %z1(%3@tlsgd)@plt";
10494 }
10495 return "bl %z1(%3@tlsgd)";
10496 }
10497 [(set_attr "type" "branch")
10498 (set_attr "length" "4")])
10499
10500 (define_insn_and_split "tls_ld_aix<TLSmode:tls_abi_suffix>"
10501 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=b")
10502 (call (mem:TLSmode (match_operand:TLSmode 2 "symbol_ref_operand" "s"))
10503 (match_operand 3 "" "g")))
10504 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")]
10505 UNSPEC_TLSLD)
10506 (clobber (reg:SI LR_REGNO))]
10507 "HAVE_AS_TLS && DEFAULT_ABI == ABI_AIX"
10508 "addi %0,%1,%&@got@tlsld\;bl %z2\;%."
10509 "&& TARGET_TLS_MARKERS"
10510 [(set (match_dup 0)
10511 (unspec:TLSmode [(match_dup 1)]
10512 UNSPEC_TLSLD))
10513 (parallel [(set (match_dup 0)
10514 (call (mem:TLSmode (match_dup 2))
10515 (match_dup 3)))
10516 (unspec:TLSmode [(const_int 0)] UNSPEC_TLSLD)
10517 (clobber (reg:SI LR_REGNO))])]
10518 ""
10519 [(set_attr "length" "12")])
10520
10521 (define_insn_and_split "tls_ld_sysv<TLSmode:tls_sysv_suffix>"
10522 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=b")
10523 (call (mem:TLSmode (match_operand:TLSmode 2 "symbol_ref_operand" "s"))
10524 (match_operand 3 "" "g")))
10525 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")]
10526 UNSPEC_TLSLD)
10527 (clobber (reg:SI LR_REGNO))]
10528 "HAVE_AS_TLS && DEFAULT_ABI == ABI_V4"
10529 {
10530 if (flag_pic)
10531 {
10532 if (TARGET_SECURE_PLT && flag_pic == 2)
10533 return "addi %0,%1,%&@got@tlsld\;bl %z2+32768@plt";
10534 else
10535 return "addi %0,%1,%&@got@tlsld\;bl %z2@plt";
10536 }
10537 else
10538 return "addi %0,%1,%&@got@tlsld\;bl %z2";
10539 }
10540 "&& TARGET_TLS_MARKERS"
10541 [(set (match_dup 0)
10542 (unspec:TLSmode [(match_dup 1)]
10543 UNSPEC_TLSLD))
10544 (parallel [(set (match_dup 0)
10545 (call (mem:TLSmode (match_dup 2))
10546 (match_dup 3)))
10547 (unspec:TLSmode [(const_int 0)] UNSPEC_TLSLD)
10548 (clobber (reg:SI LR_REGNO))])]
10549 ""
10550 [(set_attr "length" "8")])
10551
10552 (define_insn "*tls_ld<TLSmode:tls_abi_suffix>"
10553 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=b")
10554 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")]
10555 UNSPEC_TLSLD))]
10556 "HAVE_AS_TLS && TARGET_TLS_MARKERS"
10557 "addi %0,%1,%&@got@tlsld"
10558 [(set_attr "length" "4")])
10559
10560 (define_insn "*tls_ld_call_aix<TLSmode:tls_abi_suffix>"
10561 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=b")
10562 (call (mem:TLSmode (match_operand:TLSmode 1 "symbol_ref_operand" "s"))
10563 (match_operand 2 "" "g")))
10564 (unspec:TLSmode [(const_int 0)] UNSPEC_TLSLD)
10565 (clobber (reg:SI LR_REGNO))]
10566 "HAVE_AS_TLS && DEFAULT_ABI == ABI_AIX && TARGET_TLS_MARKERS"
10567 "bl %z1(%&@tlsld)\;%."
10568 [(set_attr "type" "branch")
10569 (set_attr "length" "8")])
10570
10571 (define_insn "*tls_ld_call_sysv<TLSmode:tls_abi_suffix>"
10572 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=b")
10573 (call (mem:TLSmode (match_operand:TLSmode 1 "symbol_ref_operand" "s"))
10574 (match_operand 2 "" "g")))
10575 (unspec:TLSmode [(const_int 0)] UNSPEC_TLSLD)
10576 (clobber (reg:SI LR_REGNO))]
10577 "HAVE_AS_TLS && DEFAULT_ABI == ABI_V4 && TARGET_TLS_MARKERS"
10578 {
10579 if (flag_pic)
10580 {
10581 if (TARGET_SECURE_PLT && flag_pic == 2)
10582 return "bl %z1+32768(%&@tlsld)@plt";
10583 return "bl %z1(%&@tlsld)@plt";
10584 }
10585 return "bl %z1(%&@tlsld)";
10586 }
10587 [(set_attr "type" "branch")
10588 (set_attr "length" "4")])
10589
10590 (define_insn "tls_dtprel_<TLSmode:tls_abi_suffix>"
10591 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=r")
10592 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")
10593 (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")]
10594 UNSPEC_TLSDTPREL))]
10595 "HAVE_AS_TLS"
10596 "addi %0,%1,%2@dtprel")
10597
10598 (define_insn "tls_dtprel_ha_<TLSmode:tls_abi_suffix>"
10599 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=r")
10600 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")
10601 (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")]
10602 UNSPEC_TLSDTPRELHA))]
10603 "HAVE_AS_TLS"
10604 "addis %0,%1,%2@dtprel@ha")
10605
10606 (define_insn "tls_dtprel_lo_<TLSmode:tls_abi_suffix>"
10607 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=r")
10608 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")
10609 (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")]
10610 UNSPEC_TLSDTPRELLO))]
10611 "HAVE_AS_TLS"
10612 "addi %0,%1,%2@dtprel@l")
10613
10614 (define_insn "tls_got_dtprel_<TLSmode:tls_abi_suffix>"
10615 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=r")
10616 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")
10617 (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")]
10618 UNSPEC_TLSGOTDTPREL))]
10619 "HAVE_AS_TLS"
10620 "l<TLSmode:tls_insn_suffix> %0,%2@got@dtprel(%1)")
10621
10622 (define_insn "tls_tprel_<TLSmode:tls_abi_suffix>"
10623 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=r")
10624 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")
10625 (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")]
10626 UNSPEC_TLSTPREL))]
10627 "HAVE_AS_TLS"
10628 "addi %0,%1,%2@tprel")
10629
10630 (define_insn "tls_tprel_ha_<TLSmode:tls_abi_suffix>"
10631 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=r")
10632 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")
10633 (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")]
10634 UNSPEC_TLSTPRELHA))]
10635 "HAVE_AS_TLS"
10636 "addis %0,%1,%2@tprel@ha")
10637
10638 (define_insn "tls_tprel_lo_<TLSmode:tls_abi_suffix>"
10639 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=r")
10640 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")
10641 (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")]
10642 UNSPEC_TLSTPRELLO))]
10643 "HAVE_AS_TLS"
10644 "addi %0,%1,%2@tprel@l")
10645
10646 ;; "b" output constraint here and on tls_tls input to support linker tls
10647 ;; optimization. The linker may edit the instructions emitted by a
10648 ;; tls_got_tprel/tls_tls pair to addis,addi.
10649 (define_insn "tls_got_tprel_<TLSmode:tls_abi_suffix>"
10650 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=b")
10651 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")
10652 (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")]
10653 UNSPEC_TLSGOTTPREL))]
10654 "HAVE_AS_TLS"
10655 "l<TLSmode:tls_insn_suffix> %0,%2@got@tprel(%1)")
10656
10657 (define_insn "tls_tls_<TLSmode:tls_abi_suffix>"
10658 [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=r")
10659 (unspec:TLSmode [(match_operand:TLSmode 1 "gpc_reg_operand" "b")
10660 (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")]
10661 UNSPEC_TLSTLS))]
10662 "HAVE_AS_TLS"
10663 "add %0,%1,%2@tls")
10664
10665 \f
10666 ;; Next come insns related to the calling sequence.
10667 ;;
10668 ;; First, an insn to allocate new stack space for dynamic use (e.g., alloca).
10669 ;; We move the back-chain and decrement the stack pointer.
10670
10671 (define_expand "allocate_stack"
10672 [(set (match_operand 0 "gpc_reg_operand" "")
10673 (minus (reg 1) (match_operand 1 "reg_or_short_operand" "")))
10674 (set (reg 1)
10675 (minus (reg 1) (match_dup 1)))]
10676 ""
10677 "
10678 { rtx chain = gen_reg_rtx (Pmode);
10679 rtx stack_bot = gen_rtx_MEM (Pmode, stack_pointer_rtx);
10680 rtx neg_op0;
10681 rtx insn, par, set, mem;
10682
10683 emit_move_insn (chain, stack_bot);
10684
10685 /* Check stack bounds if necessary. */
10686 if (crtl->limit_stack)
10687 {
10688 rtx available;
10689 available = expand_binop (Pmode, sub_optab,
10690 stack_pointer_rtx, stack_limit_rtx,
10691 NULL_RTX, 1, OPTAB_WIDEN);
10692 emit_insn (gen_cond_trap (LTU, available, operands[1], const0_rtx));
10693 }
10694
10695 if (GET_CODE (operands[1]) != CONST_INT
10696 || INTVAL (operands[1]) < -32767
10697 || INTVAL (operands[1]) > 32768)
10698 {
10699 neg_op0 = gen_reg_rtx (Pmode);
10700 if (TARGET_32BIT)
10701 emit_insn (gen_negsi2 (neg_op0, operands[1]));
10702 else
10703 emit_insn (gen_negdi2 (neg_op0, operands[1]));
10704 }
10705 else
10706 neg_op0 = GEN_INT (- INTVAL (operands[1]));
10707
10708 insn = emit_insn ((* ((TARGET_32BIT) ? gen_movsi_update_stack
10709 : gen_movdi_di_update_stack))
10710 (stack_pointer_rtx, stack_pointer_rtx, neg_op0,
10711 chain));
10712 /* Since we didn't use gen_frame_mem to generate the MEM, grab
10713 it now and set the alias set/attributes. The above gen_*_update
10714 calls will generate a PARALLEL with the MEM set being the first
10715 operation. */
10716 par = PATTERN (insn);
10717 gcc_assert (GET_CODE (par) == PARALLEL);
10718 set = XVECEXP (par, 0, 0);
10719 gcc_assert (GET_CODE (set) == SET);
10720 mem = SET_DEST (set);
10721 gcc_assert (MEM_P (mem));
10722 MEM_NOTRAP_P (mem) = 1;
10723 set_mem_alias_set (mem, get_frame_alias_set ());
10724
10725 emit_move_insn (operands[0], virtual_stack_dynamic_rtx);
10726 DONE;
10727 }")
10728
10729 ;; These patterns say how to save and restore the stack pointer. We need not
10730 ;; save the stack pointer at function level since we are careful to
10731 ;; preserve the backchain. At block level, we have to restore the backchain
10732 ;; when we restore the stack pointer.
10733 ;;
10734 ;; For nonlocal gotos, we must save both the stack pointer and its
10735 ;; backchain and restore both. Note that in the nonlocal case, the
10736 ;; save area is a memory location.
10737
10738 (define_expand "save_stack_function"
10739 [(match_operand 0 "any_operand" "")
10740 (match_operand 1 "any_operand" "")]
10741 ""
10742 "DONE;")
10743
10744 (define_expand "restore_stack_function"
10745 [(match_operand 0 "any_operand" "")
10746 (match_operand 1 "any_operand" "")]
10747 ""
10748 "DONE;")
10749
10750 ;; Adjust stack pointer (op0) to a new value (op1).
10751 ;; First copy old stack backchain to new location, and ensure that the
10752 ;; scheduler won't reorder the sp assignment before the backchain write.
10753 (define_expand "restore_stack_block"
10754 [(set (match_dup 2) (match_dup 3))
10755 (set (match_dup 4) (match_dup 2))
10756 (set (match_dup 5) (unspec:BLK [(match_dup 5)] UNSPEC_TIE))
10757 (set (match_operand 0 "register_operand" "")
10758 (match_operand 1 "register_operand" ""))]
10759 ""
10760 "
10761 {
10762 operands[1] = force_reg (Pmode, operands[1]);
10763 operands[2] = gen_reg_rtx (Pmode);
10764 operands[3] = gen_frame_mem (Pmode, operands[0]);
10765 operands[4] = gen_frame_mem (Pmode, operands[1]);
10766 operands[5] = gen_frame_mem (BLKmode, operands[0]);
10767 }")
10768
10769 (define_expand "save_stack_nonlocal"
10770 [(set (match_dup 3) (match_dup 4))
10771 (set (match_operand 0 "memory_operand" "") (match_dup 3))
10772 (set (match_dup 2) (match_operand 1 "register_operand" ""))]
10773 ""
10774 "
10775 {
10776 int units_per_word = (TARGET_32BIT) ? 4 : 8;
10777
10778 /* Copy the backchain to the first word, sp to the second. */
10779 operands[0] = adjust_address_nv (operands[0], Pmode, 0);
10780 operands[2] = adjust_address_nv (operands[0], Pmode, units_per_word);
10781 operands[3] = gen_reg_rtx (Pmode);
10782 operands[4] = gen_frame_mem (Pmode, operands[1]);
10783 }")
10784
10785 (define_expand "restore_stack_nonlocal"
10786 [(set (match_dup 2) (match_operand 1 "memory_operand" ""))
10787 (set (match_dup 3) (match_dup 4))
10788 (set (match_dup 5) (match_dup 2))
10789 (set (match_dup 6) (unspec:BLK [(match_dup 6)] UNSPEC_TIE))
10790 (set (match_operand 0 "register_operand" "") (match_dup 3))]
10791 ""
10792 "
10793 {
10794 int units_per_word = (TARGET_32BIT) ? 4 : 8;
10795
10796 /* Restore the backchain from the first word, sp from the second. */
10797 operands[2] = gen_reg_rtx (Pmode);
10798 operands[3] = gen_reg_rtx (Pmode);
10799 operands[1] = adjust_address_nv (operands[1], Pmode, 0);
10800 operands[4] = adjust_address_nv (operands[1], Pmode, units_per_word);
10801 operands[5] = gen_frame_mem (Pmode, operands[3]);
10802 operands[6] = gen_frame_mem (BLKmode, operands[0]);
10803 }")
10804 \f
10805 ;; TOC register handling.
10806
10807 ;; Code to initialize the TOC register...
10808
10809 (define_insn "load_toc_aix_si"
10810 [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
10811 (unspec:SI [(const_int 0)] UNSPEC_TOC))
10812 (use (reg:SI 2))])]
10813 "DEFAULT_ABI == ABI_AIX && TARGET_32BIT"
10814 "*
10815 {
10816 char buf[30];
10817 ASM_GENERATE_INTERNAL_LABEL (buf, \"LCTOC\", 1);
10818 operands[1] = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
10819 operands[2] = gen_rtx_REG (Pmode, 2);
10820 return \"{l|lwz} %0,%1(%2)\";
10821 }"
10822 [(set_attr "type" "load")])
10823
10824 (define_insn "load_toc_aix_di"
10825 [(parallel [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
10826 (unspec:DI [(const_int 0)] UNSPEC_TOC))
10827 (use (reg:DI 2))])]
10828 "DEFAULT_ABI == ABI_AIX && TARGET_64BIT"
10829 "*
10830 {
10831 char buf[30];
10832 #ifdef TARGET_RELOCATABLE
10833 ASM_GENERATE_INTERNAL_LABEL (buf, \"LCTOC\",
10834 !TARGET_MINIMAL_TOC || TARGET_RELOCATABLE);
10835 #else
10836 ASM_GENERATE_INTERNAL_LABEL (buf, \"LCTOC\", 1);
10837 #endif
10838 if (TARGET_ELF)
10839 strcat (buf, \"@toc\");
10840 operands[1] = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
10841 operands[2] = gen_rtx_REG (Pmode, 2);
10842 return \"ld %0,%1(%2)\";
10843 }"
10844 [(set_attr "type" "load")])
10845
10846 (define_insn "load_toc_v4_pic_si"
10847 [(set (reg:SI LR_REGNO)
10848 (unspec:SI [(const_int 0)] UNSPEC_TOC))]
10849 "DEFAULT_ABI == ABI_V4 && flag_pic == 1 && TARGET_32BIT"
10850 "bl _GLOBAL_OFFSET_TABLE_@local-4"
10851 [(set_attr "type" "branch")
10852 (set_attr "length" "4")])
10853
10854 (define_insn "load_toc_v4_PIC_1"
10855 [(set (reg:SI LR_REGNO)
10856 (match_operand:SI 0 "immediate_operand" "s"))
10857 (use (unspec [(match_dup 0)] UNSPEC_TOC))]
10858 "TARGET_ELF && DEFAULT_ABI != ABI_AIX
10859 && (flag_pic == 2 || (flag_pic && TARGET_SECURE_PLT))"
10860 "bcl 20,31,%0\\n%0:"
10861 [(set_attr "type" "branch")
10862 (set_attr "length" "4")])
10863
10864 (define_insn "load_toc_v4_PIC_1b"
10865 [(set (reg:SI LR_REGNO)
10866 (unspec:SI [(match_operand:SI 0 "immediate_operand" "s")]
10867 UNSPEC_TOCPTR))]
10868 "TARGET_ELF && DEFAULT_ABI != ABI_AIX && flag_pic == 2"
10869 "bcl 20,31,$+8\\n\\t.long %0-$"
10870 [(set_attr "type" "branch")
10871 (set_attr "length" "8")])
10872
10873 (define_insn "load_toc_v4_PIC_2"
10874 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
10875 (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "b")
10876 (minus:SI (match_operand:SI 2 "immediate_operand" "s")
10877 (match_operand:SI 3 "immediate_operand" "s")))))]
10878 "TARGET_ELF && DEFAULT_ABI != ABI_AIX && flag_pic == 2"
10879 "{l|lwz} %0,%2-%3(%1)"
10880 [(set_attr "type" "load")])
10881
10882 (define_insn "load_toc_v4_PIC_3b"
10883 [(set (match_operand:SI 0 "gpc_reg_operand" "=b")
10884 (plus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
10885 (high:SI
10886 (minus:SI (match_operand:SI 2 "symbol_ref_operand" "s")
10887 (match_operand:SI 3 "symbol_ref_operand" "s")))))]
10888 "TARGET_ELF && TARGET_SECURE_PLT && DEFAULT_ABI != ABI_AIX && flag_pic"
10889 "{cau|addis} %0,%1,%2-%3@ha")
10890
10891 (define_insn "load_toc_v4_PIC_3c"
10892 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
10893 (lo_sum:SI (match_operand:SI 1 "gpc_reg_operand" "b")
10894 (minus:SI (match_operand:SI 2 "symbol_ref_operand" "s")
10895 (match_operand:SI 3 "symbol_ref_operand" "s"))))]
10896 "TARGET_ELF && TARGET_SECURE_PLT && DEFAULT_ABI != ABI_AIX && flag_pic"
10897 "{cal|addi} %0,%1,%2-%3@l")
10898
10899 ;; If the TOC is shared over a translation unit, as happens with all
10900 ;; the kinds of PIC that we support, we need to restore the TOC
10901 ;; pointer only when jumping over units of translation.
10902 ;; On Darwin, we need to reload the picbase.
10903
10904 (define_expand "builtin_setjmp_receiver"
10905 [(use (label_ref (match_operand 0 "" "")))]
10906 "(DEFAULT_ABI == ABI_V4 && flag_pic == 1)
10907 || (TARGET_TOC && TARGET_MINIMAL_TOC)
10908 || (DEFAULT_ABI == ABI_DARWIN && flag_pic)"
10909 "
10910 {
10911 #if TARGET_MACHO
10912 if (DEFAULT_ABI == ABI_DARWIN)
10913 {
10914 rtx picrtx = gen_rtx_SYMBOL_REF (Pmode, MACHOPIC_FUNCTION_BASE_NAME);
10915 rtx picreg = gen_rtx_REG (Pmode, RS6000_PIC_OFFSET_TABLE_REGNUM);
10916 rtx tmplabrtx;
10917 char tmplab[20];
10918
10919 crtl->uses_pic_offset_table = 1;
10920 ASM_GENERATE_INTERNAL_LABEL(tmplab, \"LSJR\",
10921 CODE_LABEL_NUMBER (operands[0]));
10922 tmplabrtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (tmplab));
10923
10924 emit_insn (gen_load_macho_picbase (tmplabrtx));
10925 emit_move_insn (picreg, gen_rtx_REG (Pmode, LR_REGNO));
10926 emit_insn (gen_macho_correct_pic (picreg, picreg, picrtx, tmplabrtx));
10927 }
10928 else
10929 #endif
10930 rs6000_emit_load_toc_table (FALSE);
10931 DONE;
10932 }")
10933
10934 ;; Elf specific ways of loading addresses for non-PIC code.
10935 ;; The output of this could be r0, but we make a very strong
10936 ;; preference for a base register because it will usually
10937 ;; be needed there.
10938 (define_insn "elf_high"
10939 [(set (match_operand:SI 0 "gpc_reg_operand" "=b*r")
10940 (high:SI (match_operand 1 "" "")))]
10941 "TARGET_ELF && ! TARGET_64BIT"
10942 "{liu|lis} %0,%1@ha")
10943
10944 (define_insn "elf_low"
10945 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
10946 (lo_sum:SI (match_operand:SI 1 "gpc_reg_operand" "b,!*r")
10947 (match_operand 2 "" "")))]
10948 "TARGET_ELF && ! TARGET_64BIT"
10949 "@
10950 {cal|la} %0,%2@l(%1)
10951 {ai|addic} %0,%1,%K2")
10952 \f
10953 ;; A function pointer under AIX is a pointer to a data area whose first word
10954 ;; contains the actual address of the function, whose second word contains a
10955 ;; pointer to its TOC, and whose third word contains a value to place in the
10956 ;; static chain register (r11). Note that if we load the static chain, our
10957 ;; "trampoline" need not have any executable code.
10958
10959 (define_expand "call_indirect_aix32"
10960 [(set (match_dup 2)
10961 (mem:SI (match_operand:SI 0 "gpc_reg_operand" "")))
10962 (set (mem:SI (plus:SI (reg:SI 1) (const_int 20)))
10963 (reg:SI 2))
10964 (set (reg:SI 11)
10965 (mem:SI (plus:SI (match_dup 0)
10966 (const_int 8))))
10967 (parallel [(call (mem:SI (match_dup 2))
10968 (match_operand 1 "" ""))
10969 (use (mem:SI (plus:SI (match_dup 0) (const_int 4))))
10970 (use (reg:SI 11))
10971 (use (mem:SI (plus:SI (reg:SI 1) (const_int 20))))
10972 (clobber (reg:SI LR_REGNO))])]
10973 "TARGET_32BIT"
10974 "
10975 { operands[2] = gen_reg_rtx (SImode); }")
10976
10977 (define_expand "call_indirect_aix64"
10978 [(set (match_dup 2)
10979 (mem:DI (match_operand:DI 0 "gpc_reg_operand" "")))
10980 (set (mem:DI (plus:DI (reg:DI 1) (const_int 40)))
10981 (reg:DI 2))
10982 (set (reg:DI 11)
10983 (mem:DI (plus:DI (match_dup 0)
10984 (const_int 16))))
10985 (parallel [(call (mem:SI (match_dup 2))
10986 (match_operand 1 "" ""))
10987 (use (mem:DI (plus:DI (match_dup 0) (const_int 8))))
10988 (use (reg:DI 11))
10989 (use (mem:DI (plus:DI (reg:DI 1) (const_int 40))))
10990 (clobber (reg:SI LR_REGNO))])]
10991 "TARGET_64BIT"
10992 "
10993 { operands[2] = gen_reg_rtx (DImode); }")
10994
10995 (define_expand "call_value_indirect_aix32"
10996 [(set (match_dup 3)
10997 (mem:SI (match_operand:SI 1 "gpc_reg_operand" "")))
10998 (set (mem:SI (plus:SI (reg:SI 1) (const_int 20)))
10999 (reg:SI 2))
11000 (set (reg:SI 11)
11001 (mem:SI (plus:SI (match_dup 1)
11002 (const_int 8))))
11003 (parallel [(set (match_operand 0 "" "")
11004 (call (mem:SI (match_dup 3))
11005 (match_operand 2 "" "")))
11006 (use (mem:SI (plus:SI (match_dup 1) (const_int 4))))
11007 (use (reg:SI 11))
11008 (use (mem:SI (plus:SI (reg:SI 1) (const_int 20))))
11009 (clobber (reg:SI LR_REGNO))])]
11010 "TARGET_32BIT"
11011 "
11012 { operands[3] = gen_reg_rtx (SImode); }")
11013
11014 (define_expand "call_value_indirect_aix64"
11015 [(set (match_dup 3)
11016 (mem:DI (match_operand:DI 1 "gpc_reg_operand" "")))
11017 (set (mem:DI (plus:DI (reg:DI 1) (const_int 40)))
11018 (reg:DI 2))
11019 (set (reg:DI 11)
11020 (mem:DI (plus:DI (match_dup 1)
11021 (const_int 16))))
11022 (parallel [(set (match_operand 0 "" "")
11023 (call (mem:SI (match_dup 3))
11024 (match_operand 2 "" "")))
11025 (use (mem:DI (plus:DI (match_dup 1) (const_int 8))))
11026 (use (reg:DI 11))
11027 (use (mem:DI (plus:DI (reg:DI 1) (const_int 40))))
11028 (clobber (reg:SI LR_REGNO))])]
11029 "TARGET_64BIT"
11030 "
11031 { operands[3] = gen_reg_rtx (DImode); }")
11032
11033 ;; Now the definitions for the call and call_value insns
11034 (define_expand "call"
11035 [(parallel [(call (mem:SI (match_operand 0 "address_operand" ""))
11036 (match_operand 1 "" ""))
11037 (use (match_operand 2 "" ""))
11038 (clobber (reg:SI LR_REGNO))])]
11039 ""
11040 "
11041 {
11042 #if TARGET_MACHO
11043 if (MACHOPIC_INDIRECT)
11044 operands[0] = machopic_indirect_call_target (operands[0]);
11045 #endif
11046
11047 gcc_assert (GET_CODE (operands[0]) == MEM);
11048 gcc_assert (GET_CODE (operands[1]) == CONST_INT);
11049
11050 operands[0] = XEXP (operands[0], 0);
11051
11052 if (GET_CODE (operands[0]) != SYMBOL_REF
11053 || (DEFAULT_ABI == ABI_AIX && !SYMBOL_REF_FUNCTION_P (operands[0]))
11054 || (DEFAULT_ABI != ABI_DARWIN && (INTVAL (operands[2]) & CALL_LONG) != 0))
11055 {
11056 if (INTVAL (operands[2]) & CALL_LONG)
11057 operands[0] = rs6000_longcall_ref (operands[0]);
11058
11059 switch (DEFAULT_ABI)
11060 {
11061 case ABI_V4:
11062 case ABI_DARWIN:
11063 operands[0] = force_reg (Pmode, operands[0]);
11064 break;
11065
11066 case ABI_AIX:
11067 /* AIX function pointers are really pointers to a three word
11068 area. */
11069 emit_call_insn (TARGET_32BIT
11070 ? gen_call_indirect_aix32 (force_reg (SImode,
11071 operands[0]),
11072 operands[1])
11073 : gen_call_indirect_aix64 (force_reg (DImode,
11074 operands[0]),
11075 operands[1]));
11076 DONE;
11077
11078 default:
11079 gcc_unreachable ();
11080 }
11081 }
11082 }")
11083
11084 (define_expand "call_value"
11085 [(parallel [(set (match_operand 0 "" "")
11086 (call (mem:SI (match_operand 1 "address_operand" ""))
11087 (match_operand 2 "" "")))
11088 (use (match_operand 3 "" ""))
11089 (clobber (reg:SI LR_REGNO))])]
11090 ""
11091 "
11092 {
11093 #if TARGET_MACHO
11094 if (MACHOPIC_INDIRECT)
11095 operands[1] = machopic_indirect_call_target (operands[1]);
11096 #endif
11097
11098 gcc_assert (GET_CODE (operands[1]) == MEM);
11099 gcc_assert (GET_CODE (operands[2]) == CONST_INT);
11100
11101 operands[1] = XEXP (operands[1], 0);
11102
11103 if (GET_CODE (operands[1]) != SYMBOL_REF
11104 || (DEFAULT_ABI == ABI_AIX && !SYMBOL_REF_FUNCTION_P (operands[1]))
11105 || (DEFAULT_ABI != ABI_DARWIN && (INTVAL (operands[3]) & CALL_LONG) != 0))
11106 {
11107 if (INTVAL (operands[3]) & CALL_LONG)
11108 operands[1] = rs6000_longcall_ref (operands[1]);
11109
11110 switch (DEFAULT_ABI)
11111 {
11112 case ABI_V4:
11113 case ABI_DARWIN:
11114 operands[1] = force_reg (Pmode, operands[1]);
11115 break;
11116
11117 case ABI_AIX:
11118 /* AIX function pointers are really pointers to a three word
11119 area. */
11120 emit_call_insn (TARGET_32BIT
11121 ? gen_call_value_indirect_aix32 (operands[0],
11122 force_reg (SImode,
11123 operands[1]),
11124 operands[2])
11125 : gen_call_value_indirect_aix64 (operands[0],
11126 force_reg (DImode,
11127 operands[1]),
11128 operands[2]));
11129 DONE;
11130
11131 default:
11132 gcc_unreachable ();
11133 }
11134 }
11135 }")
11136
11137 ;; Call to function in current module. No TOC pointer reload needed.
11138 ;; Operand2 is nonzero if we are using the V.4 calling sequence and
11139 ;; either the function was not prototyped, or it was prototyped as a
11140 ;; variable argument function. It is > 0 if FP registers were passed
11141 ;; and < 0 if they were not.
11142
11143 (define_insn "*call_local32"
11144 [(call (mem:SI (match_operand:SI 0 "current_file_function_operand" "s,s"))
11145 (match_operand 1 "" "g,g"))
11146 (use (match_operand:SI 2 "immediate_operand" "O,n"))
11147 (clobber (reg:SI LR_REGNO))]
11148 "(INTVAL (operands[2]) & CALL_LONG) == 0"
11149 "*
11150 {
11151 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
11152 output_asm_insn (\"crxor 6,6,6\", operands);
11153
11154 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
11155 output_asm_insn (\"creqv 6,6,6\", operands);
11156
11157 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"bl %z0@local\" : \"bl %z0\";
11158 }"
11159 [(set_attr "type" "branch")
11160 (set_attr "length" "4,8")])
11161
11162 (define_insn "*call_local64"
11163 [(call (mem:SI (match_operand:DI 0 "current_file_function_operand" "s,s"))
11164 (match_operand 1 "" "g,g"))
11165 (use (match_operand:SI 2 "immediate_operand" "O,n"))
11166 (clobber (reg:SI LR_REGNO))]
11167 "TARGET_64BIT && (INTVAL (operands[2]) & CALL_LONG) == 0"
11168 "*
11169 {
11170 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
11171 output_asm_insn (\"crxor 6,6,6\", operands);
11172
11173 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
11174 output_asm_insn (\"creqv 6,6,6\", operands);
11175
11176 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"bl %z0@local\" : \"bl %z0\";
11177 }"
11178 [(set_attr "type" "branch")
11179 (set_attr "length" "4,8")])
11180
11181 (define_insn "*call_value_local32"
11182 [(set (match_operand 0 "" "")
11183 (call (mem:SI (match_operand:SI 1 "current_file_function_operand" "s,s"))
11184 (match_operand 2 "" "g,g")))
11185 (use (match_operand:SI 3 "immediate_operand" "O,n"))
11186 (clobber (reg:SI LR_REGNO))]
11187 "(INTVAL (operands[3]) & CALL_LONG) == 0"
11188 "*
11189 {
11190 if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
11191 output_asm_insn (\"crxor 6,6,6\", operands);
11192
11193 else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
11194 output_asm_insn (\"creqv 6,6,6\", operands);
11195
11196 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"bl %z1@local\" : \"bl %z1\";
11197 }"
11198 [(set_attr "type" "branch")
11199 (set_attr "length" "4,8")])
11200
11201
11202 (define_insn "*call_value_local64"
11203 [(set (match_operand 0 "" "")
11204 (call (mem:SI (match_operand:DI 1 "current_file_function_operand" "s,s"))
11205 (match_operand 2 "" "g,g")))
11206 (use (match_operand:SI 3 "immediate_operand" "O,n"))
11207 (clobber (reg:SI LR_REGNO))]
11208 "TARGET_64BIT && (INTVAL (operands[3]) & CALL_LONG) == 0"
11209 "*
11210 {
11211 if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
11212 output_asm_insn (\"crxor 6,6,6\", operands);
11213
11214 else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
11215 output_asm_insn (\"creqv 6,6,6\", operands);
11216
11217 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"bl %z1@local\" : \"bl %z1\";
11218 }"
11219 [(set_attr "type" "branch")
11220 (set_attr "length" "4,8")])
11221
11222 ;; Call to function which may be in another module. Restore the TOC
11223 ;; pointer (r2) after the call unless this is System V.
11224 ;; Operand2 is nonzero if we are using the V.4 calling sequence and
11225 ;; either the function was not prototyped, or it was prototyped as a
11226 ;; variable argument function. It is > 0 if FP registers were passed
11227 ;; and < 0 if they were not.
11228
11229 (define_insn_and_split "*call_indirect_nonlocal_aix32_internal"
11230 [(call (mem:SI (match_operand:SI 0 "register_operand" "c,*l"))
11231 (match_operand 1 "" "g,g"))
11232 (use (mem:SI (plus:SI (match_operand:SI 2 "register_operand" "b,b") (const_int 4))))
11233 (use (reg:SI 11))
11234 (use (mem:SI (plus:SI (reg:SI 1) (const_int 20))))
11235 (clobber (reg:SI LR_REGNO))]
11236 "TARGET_32BIT && DEFAULT_ABI == ABI_AIX"
11237 "#"
11238 "&& reload_completed"
11239 [(set (reg:SI 2)
11240 (mem:SI (plus:SI (match_dup 2) (const_int 4))))
11241 (parallel [(call (mem:SI (match_dup 0))
11242 (match_dup 1))
11243 (use (reg:SI 2))
11244 (use (reg:SI 11))
11245 (set (reg:SI 2)
11246 (mem:SI (plus:SI (reg:SI 1) (const_int 20))))
11247 (clobber (reg:SI LR_REGNO))])]
11248 ""
11249 [(set_attr "type" "jmpreg")
11250 (set_attr "length" "12")])
11251
11252 (define_insn "*call_indirect_nonlocal_aix32"
11253 [(call (mem:SI (match_operand:SI 0 "register_operand" "c,*l"))
11254 (match_operand 1 "" "g,g"))
11255 (use (reg:SI 2))
11256 (use (reg:SI 11))
11257 (set (reg:SI 2)
11258 (mem:SI (plus:SI (reg:SI 1) (const_int 20))))
11259 (clobber (reg:SI LR_REGNO))]
11260 "TARGET_32BIT && DEFAULT_ABI == ABI_AIX && reload_completed"
11261 "b%T0l\;{l|lwz} 2,20(1)"
11262 [(set_attr "type" "jmpreg")
11263 (set_attr "length" "8")])
11264
11265 (define_insn "*call_nonlocal_aix32"
11266 [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "s"))
11267 (match_operand 1 "" "g"))
11268 (use (match_operand:SI 2 "immediate_operand" "O"))
11269 (clobber (reg:SI LR_REGNO))]
11270 "TARGET_32BIT
11271 && DEFAULT_ABI == ABI_AIX
11272 && (INTVAL (operands[2]) & CALL_LONG) == 0"
11273 "bl %z0\;%."
11274 [(set_attr "type" "branch")
11275 (set_attr "length" "8")])
11276
11277 (define_insn_and_split "*call_indirect_nonlocal_aix64_internal"
11278 [(call (mem:SI (match_operand:DI 0 "register_operand" "c,*l"))
11279 (match_operand 1 "" "g,g"))
11280 (use (mem:DI (plus:DI (match_operand:DI 2 "register_operand" "b,b")
11281 (const_int 8))))
11282 (use (reg:DI 11))
11283 (use (mem:DI (plus:DI (reg:DI 1) (const_int 40))))
11284 (clobber (reg:SI LR_REGNO))]
11285 "TARGET_64BIT && DEFAULT_ABI == ABI_AIX"
11286 "#"
11287 "&& reload_completed"
11288 [(set (reg:DI 2)
11289 (mem:DI (plus:DI (match_dup 2) (const_int 8))))
11290 (parallel [(call (mem:SI (match_dup 0))
11291 (match_dup 1))
11292 (use (reg:DI 2))
11293 (use (reg:DI 11))
11294 (set (reg:DI 2)
11295 (mem:DI (plus:DI (reg:DI 1) (const_int 40))))
11296 (clobber (reg:SI LR_REGNO))])]
11297 ""
11298 [(set_attr "type" "jmpreg")
11299 (set_attr "length" "12")])
11300
11301 (define_insn "*call_indirect_nonlocal_aix64"
11302 [(call (mem:SI (match_operand:DI 0 "register_operand" "c,*l"))
11303 (match_operand 1 "" "g,g"))
11304 (use (reg:DI 2))
11305 (use (reg:DI 11))
11306 (set (reg:DI 2)
11307 (mem:DI (plus:DI (reg:DI 1) (const_int 40))))
11308 (clobber (reg:SI LR_REGNO))]
11309 "TARGET_64BIT && DEFAULT_ABI == ABI_AIX && reload_completed"
11310 "b%T0l\;ld 2,40(1)"
11311 [(set_attr "type" "jmpreg")
11312 (set_attr "length" "8")])
11313
11314 (define_insn "*call_nonlocal_aix64"
11315 [(call (mem:SI (match_operand:DI 0 "symbol_ref_operand" "s"))
11316 (match_operand 1 "" "g"))
11317 (use (match_operand:SI 2 "immediate_operand" "O"))
11318 (clobber (reg:SI LR_REGNO))]
11319 "TARGET_64BIT
11320 && DEFAULT_ABI == ABI_AIX
11321 && (INTVAL (operands[2]) & CALL_LONG) == 0"
11322 "bl %z0\;%."
11323 [(set_attr "type" "branch")
11324 (set_attr "length" "8")])
11325
11326 (define_insn_and_split "*call_value_indirect_nonlocal_aix32_internal"
11327 [(set (match_operand 0 "" "")
11328 (call (mem:SI (match_operand:SI 1 "register_operand" "c,*l"))
11329 (match_operand 2 "" "g,g")))
11330 (use (mem:SI (plus:SI (match_operand:SI 3 "register_operand" "b,b")
11331 (const_int 4))))
11332 (use (reg:SI 11))
11333 (use (mem:SI (plus:SI (reg:SI 1) (const_int 20))))
11334 (clobber (reg:SI LR_REGNO))]
11335 "TARGET_32BIT && DEFAULT_ABI == ABI_AIX"
11336 "#"
11337 "&& reload_completed"
11338 [(set (reg:SI 2)
11339 (mem:SI (plus:SI (match_dup 3) (const_int 4))))
11340 (parallel [(set (match_dup 0) (call (mem:SI (match_dup 1))
11341 (match_dup 2)))
11342 (use (reg:SI 2))
11343 (use (reg:SI 11))
11344 (set (reg:SI 2)
11345 (mem:SI (plus:SI (reg:SI 1) (const_int 20))))
11346 (clobber (reg:SI LR_REGNO))])]
11347 ""
11348 [(set_attr "type" "jmpreg")
11349 (set_attr "length" "12")])
11350
11351 (define_insn "*call_value_indirect_nonlocal_aix32"
11352 [(set (match_operand 0 "" "")
11353 (call (mem:SI (match_operand:SI 1 "register_operand" "c,*l"))
11354 (match_operand 2 "" "g,g")))
11355 (use (reg:SI 2))
11356 (use (reg:SI 11))
11357 (set (reg:SI 2)
11358 (mem:SI (plus:SI (reg:SI 1) (const_int 20))))
11359 (clobber (reg:SI LR_REGNO))]
11360 "TARGET_32BIT && DEFAULT_ABI == ABI_AIX && reload_completed"
11361 "b%T1l\;{l|lwz} 2,20(1)"
11362 [(set_attr "type" "jmpreg")
11363 (set_attr "length" "8")])
11364
11365 (define_insn "*call_value_nonlocal_aix32"
11366 [(set (match_operand 0 "" "")
11367 (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "s"))
11368 (match_operand 2 "" "g")))
11369 (use (match_operand:SI 3 "immediate_operand" "O"))
11370 (clobber (reg:SI LR_REGNO))]
11371 "TARGET_32BIT
11372 && DEFAULT_ABI == ABI_AIX
11373 && (INTVAL (operands[3]) & CALL_LONG) == 0"
11374 "bl %z1\;%."
11375 [(set_attr "type" "branch")
11376 (set_attr "length" "8")])
11377
11378 (define_insn_and_split "*call_value_indirect_nonlocal_aix64_internal"
11379 [(set (match_operand 0 "" "")
11380 (call (mem:SI (match_operand:DI 1 "register_operand" "c,*l"))
11381 (match_operand 2 "" "g,g")))
11382 (use (mem:DI (plus:DI (match_operand:DI 3 "register_operand" "b,b")
11383 (const_int 8))))
11384 (use (reg:DI 11))
11385 (use (mem:DI (plus:DI (reg:DI 1) (const_int 40))))
11386 (clobber (reg:SI LR_REGNO))]
11387 "TARGET_64BIT && DEFAULT_ABI == ABI_AIX"
11388 "#"
11389 "&& reload_completed"
11390 [(set (reg:DI 2)
11391 (mem:DI (plus:DI (match_dup 3) (const_int 8))))
11392 (parallel [(set (match_dup 0) (call (mem:SI (match_dup 1))
11393 (match_dup 2)))
11394 (use (reg:DI 2))
11395 (use (reg:DI 11))
11396 (set (reg:DI 2)
11397 (mem:DI (plus:DI (reg:DI 1) (const_int 40))))
11398 (clobber (reg:SI LR_REGNO))])]
11399 ""
11400 [(set_attr "type" "jmpreg")
11401 (set_attr "length" "12")])
11402
11403 (define_insn "*call_value_indirect_nonlocal_aix64"
11404 [(set (match_operand 0 "" "")
11405 (call (mem:SI (match_operand:DI 1 "register_operand" "c,*l"))
11406 (match_operand 2 "" "g,g")))
11407 (use (reg:DI 2))
11408 (use (reg:DI 11))
11409 (set (reg:DI 2)
11410 (mem:DI (plus:DI (reg:DI 1) (const_int 40))))
11411 (clobber (reg:SI LR_REGNO))]
11412 "TARGET_64BIT && DEFAULT_ABI == ABI_AIX && reload_completed"
11413 "b%T1l\;ld 2,40(1)"
11414 [(set_attr "type" "jmpreg")
11415 (set_attr "length" "8")])
11416
11417 (define_insn "*call_value_nonlocal_aix64"
11418 [(set (match_operand 0 "" "")
11419 (call (mem:SI (match_operand:DI 1 "symbol_ref_operand" "s"))
11420 (match_operand 2 "" "g")))
11421 (use (match_operand:SI 3 "immediate_operand" "O"))
11422 (clobber (reg:SI LR_REGNO))]
11423 "TARGET_64BIT
11424 && DEFAULT_ABI == ABI_AIX
11425 && (INTVAL (operands[3]) & CALL_LONG) == 0"
11426 "bl %z1\;%."
11427 [(set_attr "type" "branch")
11428 (set_attr "length" "8")])
11429
11430 ;; A function pointer under System V is just a normal pointer
11431 ;; operands[0] is the function pointer
11432 ;; operands[1] is the stack size to clean up
11433 ;; operands[2] is the value FUNCTION_ARG returns for the VOID argument
11434 ;; which indicates how to set cr1
11435
11436 (define_insn "*call_indirect_nonlocal_sysv<mode>"
11437 [(call (mem:SI (match_operand:P 0 "register_operand" "c,*l,c,*l"))
11438 (match_operand 1 "" "g,g,g,g"))
11439 (use (match_operand:SI 2 "immediate_operand" "O,O,n,n"))
11440 (clobber (reg:SI LR_REGNO))]
11441 "DEFAULT_ABI == ABI_V4
11442 || DEFAULT_ABI == ABI_DARWIN"
11443 {
11444 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
11445 output_asm_insn ("crxor 6,6,6", operands);
11446
11447 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
11448 output_asm_insn ("creqv 6,6,6", operands);
11449
11450 return "b%T0l";
11451 }
11452 [(set_attr "type" "jmpreg,jmpreg,jmpreg,jmpreg")
11453 (set_attr "length" "4,4,8,8")])
11454
11455 (define_insn_and_split "*call_nonlocal_sysv<mode>"
11456 [(call (mem:SI (match_operand:P 0 "symbol_ref_operand" "s,s"))
11457 (match_operand 1 "" "g,g"))
11458 (use (match_operand:SI 2 "immediate_operand" "O,n"))
11459 (clobber (reg:SI LR_REGNO))]
11460 "(DEFAULT_ABI == ABI_DARWIN
11461 || (DEFAULT_ABI == ABI_V4
11462 && (INTVAL (operands[2]) & CALL_LONG) == 0))"
11463 {
11464 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
11465 output_asm_insn ("crxor 6,6,6", operands);
11466
11467 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
11468 output_asm_insn ("creqv 6,6,6", operands);
11469
11470 #if TARGET_MACHO
11471 return output_call(insn, operands, 0, 2);
11472 #else
11473 if (DEFAULT_ABI == ABI_V4 && flag_pic)
11474 {
11475 gcc_assert (!TARGET_SECURE_PLT);
11476 return "bl %z0@plt";
11477 }
11478 else
11479 return "bl %z0";
11480 #endif
11481 }
11482 "DEFAULT_ABI == ABI_V4
11483 && TARGET_SECURE_PLT && flag_pic && !SYMBOL_REF_LOCAL_P (operands[0])
11484 && (INTVAL (operands[2]) & CALL_LONG) == 0"
11485 [(parallel [(call (mem:SI (match_dup 0))
11486 (match_dup 1))
11487 (use (match_dup 2))
11488 (use (match_dup 3))
11489 (clobber (reg:SI LR_REGNO))])]
11490 {
11491 operands[3] = pic_offset_table_rtx;
11492 }
11493 [(set_attr "type" "branch,branch")
11494 (set_attr "length" "4,8")])
11495
11496 (define_insn "*call_nonlocal_sysv_secure<mode>"
11497 [(call (mem:SI (match_operand:P 0 "symbol_ref_operand" "s,s"))
11498 (match_operand 1 "" "g,g"))
11499 (use (match_operand:SI 2 "immediate_operand" "O,n"))
11500 (use (match_operand:SI 3 "register_operand" "r,r"))
11501 (clobber (reg:SI LR_REGNO))]
11502 "(DEFAULT_ABI == ABI_V4
11503 && TARGET_SECURE_PLT && flag_pic && !SYMBOL_REF_LOCAL_P (operands[0])
11504 && (INTVAL (operands[2]) & CALL_LONG) == 0)"
11505 {
11506 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
11507 output_asm_insn ("crxor 6,6,6", operands);
11508
11509 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
11510 output_asm_insn ("creqv 6,6,6", operands);
11511
11512 if (flag_pic == 2)
11513 /* The magic 32768 offset here and in the other sysv call insns
11514 corresponds to the offset of r30 in .got2, as given by LCTOC1.
11515 See sysv4.h:toc_section. */
11516 return "bl %z0+32768@plt";
11517 else
11518 return "bl %z0@plt";
11519 }
11520 [(set_attr "type" "branch,branch")
11521 (set_attr "length" "4,8")])
11522
11523 (define_insn "*call_value_indirect_nonlocal_sysv<mode>"
11524 [(set (match_operand 0 "" "")
11525 (call (mem:SI (match_operand:P 1 "register_operand" "c,*l,c,*l"))
11526 (match_operand 2 "" "g,g,g,g")))
11527 (use (match_operand:SI 3 "immediate_operand" "O,O,n,n"))
11528 (clobber (reg:SI LR_REGNO))]
11529 "DEFAULT_ABI == ABI_V4
11530 || DEFAULT_ABI == ABI_DARWIN"
11531 {
11532 if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
11533 output_asm_insn ("crxor 6,6,6", operands);
11534
11535 else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
11536 output_asm_insn ("creqv 6,6,6", operands);
11537
11538 return "b%T1l";
11539 }
11540 [(set_attr "type" "jmpreg,jmpreg,jmpreg,jmpreg")
11541 (set_attr "length" "4,4,8,8")])
11542
11543 (define_insn_and_split "*call_value_nonlocal_sysv<mode>"
11544 [(set (match_operand 0 "" "")
11545 (call (mem:SI (match_operand:P 1 "symbol_ref_operand" "s,s"))
11546 (match_operand 2 "" "g,g")))
11547 (use (match_operand:SI 3 "immediate_operand" "O,n"))
11548 (clobber (reg:SI LR_REGNO))]
11549 "(DEFAULT_ABI == ABI_DARWIN
11550 || (DEFAULT_ABI == ABI_V4
11551 && (INTVAL (operands[3]) & CALL_LONG) == 0))"
11552 {
11553 if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
11554 output_asm_insn ("crxor 6,6,6", operands);
11555
11556 else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
11557 output_asm_insn ("creqv 6,6,6", operands);
11558
11559 #if TARGET_MACHO
11560 return output_call(insn, operands, 1, 3);
11561 #else
11562 if (DEFAULT_ABI == ABI_V4 && flag_pic)
11563 {
11564 gcc_assert (!TARGET_SECURE_PLT);
11565 return "bl %z1@plt";
11566 }
11567 else
11568 return "bl %z1";
11569 #endif
11570 }
11571 "DEFAULT_ABI == ABI_V4
11572 && TARGET_SECURE_PLT && flag_pic && !SYMBOL_REF_LOCAL_P (operands[1])
11573 && (INTVAL (operands[3]) & CALL_LONG) == 0"
11574 [(parallel [(set (match_dup 0)
11575 (call (mem:SI (match_dup 1))
11576 (match_dup 2)))
11577 (use (match_dup 3))
11578 (use (match_dup 4))
11579 (clobber (reg:SI LR_REGNO))])]
11580 {
11581 operands[4] = pic_offset_table_rtx;
11582 }
11583 [(set_attr "type" "branch,branch")
11584 (set_attr "length" "4,8")])
11585
11586 (define_insn "*call_value_nonlocal_sysv_secure<mode>"
11587 [(set (match_operand 0 "" "")
11588 (call (mem:SI (match_operand:P 1 "symbol_ref_operand" "s,s"))
11589 (match_operand 2 "" "g,g")))
11590 (use (match_operand:SI 3 "immediate_operand" "O,n"))
11591 (use (match_operand:SI 4 "register_operand" "r,r"))
11592 (clobber (reg:SI LR_REGNO))]
11593 "(DEFAULT_ABI == ABI_V4
11594 && TARGET_SECURE_PLT && flag_pic && !SYMBOL_REF_LOCAL_P (operands[1])
11595 && (INTVAL (operands[3]) & CALL_LONG) == 0)"
11596 {
11597 if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
11598 output_asm_insn ("crxor 6,6,6", operands);
11599
11600 else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
11601 output_asm_insn ("creqv 6,6,6", operands);
11602
11603 if (flag_pic == 2)
11604 return "bl %z1+32768@plt";
11605 else
11606 return "bl %z1@plt";
11607 }
11608 [(set_attr "type" "branch,branch")
11609 (set_attr "length" "4,8")])
11610
11611 ;; Call subroutine returning any type.
11612 (define_expand "untyped_call"
11613 [(parallel [(call (match_operand 0 "" "")
11614 (const_int 0))
11615 (match_operand 1 "" "")
11616 (match_operand 2 "" "")])]
11617 ""
11618 "
11619 {
11620 int i;
11621
11622 emit_call_insn (GEN_CALL (operands[0], const0_rtx, const0_rtx, const0_rtx));
11623
11624 for (i = 0; i < XVECLEN (operands[2], 0); i++)
11625 {
11626 rtx set = XVECEXP (operands[2], 0, i);
11627 emit_move_insn (SET_DEST (set), SET_SRC (set));
11628 }
11629
11630 /* The optimizer does not know that the call sets the function value
11631 registers we stored in the result block. We avoid problems by
11632 claiming that all hard registers are used and clobbered at this
11633 point. */
11634 emit_insn (gen_blockage ());
11635
11636 DONE;
11637 }")
11638
11639 ;; sibling call patterns
11640 (define_expand "sibcall"
11641 [(parallel [(call (mem:SI (match_operand 0 "address_operand" ""))
11642 (match_operand 1 "" ""))
11643 (use (match_operand 2 "" ""))
11644 (use (reg:SI LR_REGNO))
11645 (return)])]
11646 ""
11647 "
11648 {
11649 #if TARGET_MACHO
11650 if (MACHOPIC_INDIRECT)
11651 operands[0] = machopic_indirect_call_target (operands[0]);
11652 #endif
11653
11654 gcc_assert (GET_CODE (operands[0]) == MEM);
11655 gcc_assert (GET_CODE (operands[1]) == CONST_INT);
11656
11657 operands[0] = XEXP (operands[0], 0);
11658 }")
11659
11660 ;; this and similar patterns must be marked as using LR, otherwise
11661 ;; dataflow will try to delete the store into it. This is true
11662 ;; even when the actual reg to jump to is in CTR, when LR was
11663 ;; saved and restored around the PIC-setting BCL.
11664 (define_insn "*sibcall_local32"
11665 [(call (mem:SI (match_operand:SI 0 "current_file_function_operand" "s,s"))
11666 (match_operand 1 "" "g,g"))
11667 (use (match_operand:SI 2 "immediate_operand" "O,n"))
11668 (use (reg:SI LR_REGNO))
11669 (return)]
11670 "(INTVAL (operands[2]) & CALL_LONG) == 0"
11671 "*
11672 {
11673 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
11674 output_asm_insn (\"crxor 6,6,6\", operands);
11675
11676 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
11677 output_asm_insn (\"creqv 6,6,6\", operands);
11678
11679 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"b %z0@local\" : \"b %z0\";
11680 }"
11681 [(set_attr "type" "branch")
11682 (set_attr "length" "4,8")])
11683
11684 (define_insn "*sibcall_local64"
11685 [(call (mem:SI (match_operand:DI 0 "current_file_function_operand" "s,s"))
11686 (match_operand 1 "" "g,g"))
11687 (use (match_operand:SI 2 "immediate_operand" "O,n"))
11688 (use (reg:SI LR_REGNO))
11689 (return)]
11690 "TARGET_64BIT && (INTVAL (operands[2]) & CALL_LONG) == 0"
11691 "*
11692 {
11693 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
11694 output_asm_insn (\"crxor 6,6,6\", operands);
11695
11696 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
11697 output_asm_insn (\"creqv 6,6,6\", operands);
11698
11699 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"b %z0@local\" : \"b %z0\";
11700 }"
11701 [(set_attr "type" "branch")
11702 (set_attr "length" "4,8")])
11703
11704 (define_insn "*sibcall_value_local32"
11705 [(set (match_operand 0 "" "")
11706 (call (mem:SI (match_operand:SI 1 "current_file_function_operand" "s,s"))
11707 (match_operand 2 "" "g,g")))
11708 (use (match_operand:SI 3 "immediate_operand" "O,n"))
11709 (use (reg:SI LR_REGNO))
11710 (return)]
11711 "(INTVAL (operands[3]) & CALL_LONG) == 0"
11712 "*
11713 {
11714 if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
11715 output_asm_insn (\"crxor 6,6,6\", operands);
11716
11717 else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
11718 output_asm_insn (\"creqv 6,6,6\", operands);
11719
11720 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"b %z1@local\" : \"b %z1\";
11721 }"
11722 [(set_attr "type" "branch")
11723 (set_attr "length" "4,8")])
11724
11725
11726 (define_insn "*sibcall_value_local64"
11727 [(set (match_operand 0 "" "")
11728 (call (mem:SI (match_operand:DI 1 "current_file_function_operand" "s,s"))
11729 (match_operand 2 "" "g,g")))
11730 (use (match_operand:SI 3 "immediate_operand" "O,n"))
11731 (use (reg:SI LR_REGNO))
11732 (return)]
11733 "TARGET_64BIT && (INTVAL (operands[3]) & CALL_LONG) == 0"
11734 "*
11735 {
11736 if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
11737 output_asm_insn (\"crxor 6,6,6\", operands);
11738
11739 else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
11740 output_asm_insn (\"creqv 6,6,6\", operands);
11741
11742 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"b %z1@local\" : \"b %z1\";
11743 }"
11744 [(set_attr "type" "branch")
11745 (set_attr "length" "4,8")])
11746
11747 (define_insn "*sibcall_nonlocal_aix32"
11748 [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "s"))
11749 (match_operand 1 "" "g"))
11750 (use (match_operand:SI 2 "immediate_operand" "O"))
11751 (use (reg:SI LR_REGNO))
11752 (return)]
11753 "TARGET_32BIT
11754 && DEFAULT_ABI == ABI_AIX
11755 && (INTVAL (operands[2]) & CALL_LONG) == 0"
11756 "b %z0"
11757 [(set_attr "type" "branch")
11758 (set_attr "length" "4")])
11759
11760 (define_insn "*sibcall_nonlocal_aix64"
11761 [(call (mem:SI (match_operand:DI 0 "symbol_ref_operand" "s"))
11762 (match_operand 1 "" "g"))
11763 (use (match_operand:SI 2 "immediate_operand" "O"))
11764 (use (reg:SI LR_REGNO))
11765 (return)]
11766 "TARGET_64BIT
11767 && DEFAULT_ABI == ABI_AIX
11768 && (INTVAL (operands[2]) & CALL_LONG) == 0"
11769 "b %z0"
11770 [(set_attr "type" "branch")
11771 (set_attr "length" "4")])
11772
11773 (define_insn "*sibcall_value_nonlocal_aix32"
11774 [(set (match_operand 0 "" "")
11775 (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "s"))
11776 (match_operand 2 "" "g")))
11777 (use (match_operand:SI 3 "immediate_operand" "O"))
11778 (use (reg:SI LR_REGNO))
11779 (return)]
11780 "TARGET_32BIT
11781 && DEFAULT_ABI == ABI_AIX
11782 && (INTVAL (operands[3]) & CALL_LONG) == 0"
11783 "b %z1"
11784 [(set_attr "type" "branch")
11785 (set_attr "length" "4")])
11786
11787 (define_insn "*sibcall_value_nonlocal_aix64"
11788 [(set (match_operand 0 "" "")
11789 (call (mem:SI (match_operand:DI 1 "symbol_ref_operand" "s"))
11790 (match_operand 2 "" "g")))
11791 (use (match_operand:SI 3 "immediate_operand" "O"))
11792 (use (reg:SI LR_REGNO))
11793 (return)]
11794 "TARGET_64BIT
11795 && DEFAULT_ABI == ABI_AIX
11796 && (INTVAL (operands[3]) & CALL_LONG) == 0"
11797 "b %z1"
11798 [(set_attr "type" "branch")
11799 (set_attr "length" "4")])
11800
11801 (define_insn "*sibcall_nonlocal_sysv<mode>"
11802 [(call (mem:SI (match_operand:P 0 "symbol_ref_operand" "s,s"))
11803 (match_operand 1 "" ""))
11804 (use (match_operand 2 "immediate_operand" "O,n"))
11805 (use (reg:SI LR_REGNO))
11806 (return)]
11807 "(DEFAULT_ABI == ABI_DARWIN
11808 || DEFAULT_ABI == ABI_V4)
11809 && (INTVAL (operands[2]) & CALL_LONG) == 0"
11810 "*
11811 {
11812 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
11813 output_asm_insn (\"crxor 6,6,6\", operands);
11814
11815 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
11816 output_asm_insn (\"creqv 6,6,6\", operands);
11817
11818 if (DEFAULT_ABI == ABI_V4 && flag_pic)
11819 {
11820 gcc_assert (!TARGET_SECURE_PLT);
11821 return \"b %z0@plt\";
11822 }
11823 else
11824 return \"b %z0\";
11825 }"
11826 [(set_attr "type" "branch,branch")
11827 (set_attr "length" "4,8")])
11828
11829 (define_expand "sibcall_value"
11830 [(parallel [(set (match_operand 0 "register_operand" "")
11831 (call (mem:SI (match_operand 1 "address_operand" ""))
11832 (match_operand 2 "" "")))
11833 (use (match_operand 3 "" ""))
11834 (use (reg:SI LR_REGNO))
11835 (return)])]
11836 ""
11837 "
11838 {
11839 #if TARGET_MACHO
11840 if (MACHOPIC_INDIRECT)
11841 operands[1] = machopic_indirect_call_target (operands[1]);
11842 #endif
11843
11844 gcc_assert (GET_CODE (operands[1]) == MEM);
11845 gcc_assert (GET_CODE (operands[2]) == CONST_INT);
11846
11847 operands[1] = XEXP (operands[1], 0);
11848 }")
11849
11850 (define_insn "*sibcall_value_nonlocal_sysv<mode>"
11851 [(set (match_operand 0 "" "")
11852 (call (mem:SI (match_operand:P 1 "symbol_ref_operand" "s,s"))
11853 (match_operand 2 "" "")))
11854 (use (match_operand:SI 3 "immediate_operand" "O,n"))
11855 (use (reg:SI LR_REGNO))
11856 (return)]
11857 "(DEFAULT_ABI == ABI_DARWIN
11858 || DEFAULT_ABI == ABI_V4)
11859 && (INTVAL (operands[3]) & CALL_LONG) == 0"
11860 "*
11861 {
11862 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
11863 output_asm_insn (\"crxor 6,6,6\", operands);
11864
11865 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
11866 output_asm_insn (\"creqv 6,6,6\", operands);
11867
11868 if (DEFAULT_ABI == ABI_V4 && flag_pic)
11869 {
11870 gcc_assert (!TARGET_SECURE_PLT);
11871 return \"b %z1@plt\";
11872 }
11873 else
11874 return \"b %z1\";
11875 }"
11876 [(set_attr "type" "branch,branch")
11877 (set_attr "length" "4,8")])
11878
11879 (define_expand "sibcall_epilogue"
11880 [(use (const_int 0))]
11881 "TARGET_SCHED_PROLOG"
11882 "
11883 {
11884 rs6000_emit_epilogue (TRUE);
11885 DONE;
11886 }")
11887
11888 ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
11889 ;; all of memory. This blocks insns from being moved across this point.
11890
11891 (define_insn "blockage"
11892 [(unspec_volatile [(const_int 0)] UNSPECV_BLOCK)]
11893 ""
11894 "")
11895 \f
11896 ;; Compare insns are next. Note that the RS/6000 has two types of compares,
11897 ;; signed & unsigned, and one type of branch.
11898 ;;
11899 ;; Start with the DEFINE_EXPANDs to generate the rtl for compares, scc
11900 ;; insns, and branches. We store the operands of compares until we see
11901 ;; how it is used.
11902 (define_expand "cmp<mode>"
11903 [(set (cc0)
11904 (compare (match_operand:GPR 0 "gpc_reg_operand" "")
11905 (match_operand:GPR 1 "reg_or_short_operand" "")))]
11906 ""
11907 "
11908 {
11909 /* Take care of the possibility that operands[1] might be negative but
11910 this might be a logical operation. That insn doesn't exist. */
11911 if (GET_CODE (operands[1]) == CONST_INT
11912 && INTVAL (operands[1]) < 0)
11913 operands[1] = force_reg (<MODE>mode, operands[1]);
11914
11915 rs6000_compare_op0 = operands[0];
11916 rs6000_compare_op1 = operands[1];
11917 rs6000_compare_fp_p = 0;
11918 DONE;
11919 }")
11920
11921 (define_expand "cmp<mode>"
11922 [(set (cc0) (compare (match_operand:FP 0 "gpc_reg_operand" "")
11923 (match_operand:FP 1 "gpc_reg_operand" "")))]
11924 ""
11925 "
11926 {
11927 rs6000_compare_op0 = operands[0];
11928 rs6000_compare_op1 = operands[1];
11929 rs6000_compare_fp_p = 1;
11930 DONE;
11931 }")
11932
11933 (define_expand "beq"
11934 [(use (match_operand 0 "" ""))]
11935 ""
11936 "{ rs6000_emit_cbranch (EQ, operands[0]); DONE; }")
11937
11938 (define_expand "bne"
11939 [(use (match_operand 0 "" ""))]
11940 ""
11941 "{ rs6000_emit_cbranch (NE, operands[0]); DONE; }")
11942
11943 (define_expand "bge"
11944 [(use (match_operand 0 "" ""))]
11945 ""
11946 "{ rs6000_emit_cbranch (GE, operands[0]); DONE; }")
11947
11948 (define_expand "bgt"
11949 [(use (match_operand 0 "" ""))]
11950 ""
11951 "{ rs6000_emit_cbranch (GT, operands[0]); DONE; }")
11952
11953 (define_expand "ble"
11954 [(use (match_operand 0 "" ""))]
11955 ""
11956 "{ rs6000_emit_cbranch (LE, operands[0]); DONE; }")
11957
11958 (define_expand "blt"
11959 [(use (match_operand 0 "" ""))]
11960 ""
11961 "{ rs6000_emit_cbranch (LT, operands[0]); DONE; }")
11962
11963 (define_expand "bgeu"
11964 [(use (match_operand 0 "" ""))]
11965 ""
11966 "{ rs6000_emit_cbranch (GEU, operands[0]); DONE; }")
11967
11968 (define_expand "bgtu"
11969 [(use (match_operand 0 "" ""))]
11970 ""
11971 "{ rs6000_emit_cbranch (GTU, operands[0]); DONE; }")
11972
11973 (define_expand "bleu"
11974 [(use (match_operand 0 "" ""))]
11975 ""
11976 "{ rs6000_emit_cbranch (LEU, operands[0]); DONE; }")
11977
11978 (define_expand "bltu"
11979 [(use (match_operand 0 "" ""))]
11980 ""
11981 "{ rs6000_emit_cbranch (LTU, operands[0]); DONE; }")
11982
11983 (define_expand "bunordered"
11984 [(use (match_operand 0 "" ""))]
11985 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
11986 "{ rs6000_emit_cbranch (UNORDERED, operands[0]); DONE; }")
11987
11988 (define_expand "bordered"
11989 [(use (match_operand 0 "" ""))]
11990 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
11991 "{ rs6000_emit_cbranch (ORDERED, operands[0]); DONE; }")
11992
11993 (define_expand "buneq"
11994 [(use (match_operand 0 "" ""))]
11995 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
11996 "{ rs6000_emit_cbranch (UNEQ, operands[0]); DONE; }")
11997
11998 (define_expand "bunge"
11999 [(use (match_operand 0 "" ""))]
12000 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
12001 "{ rs6000_emit_cbranch (UNGE, operands[0]); DONE; }")
12002
12003 (define_expand "bungt"
12004 [(use (match_operand 0 "" ""))]
12005 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
12006 "{ rs6000_emit_cbranch (UNGT, operands[0]); DONE; }")
12007
12008 (define_expand "bunle"
12009 [(use (match_operand 0 "" ""))]
12010 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
12011 "{ rs6000_emit_cbranch (UNLE, operands[0]); DONE; }")
12012
12013 (define_expand "bunlt"
12014 [(use (match_operand 0 "" ""))]
12015 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
12016 "{ rs6000_emit_cbranch (UNLT, operands[0]); DONE; }")
12017
12018 (define_expand "bltgt"
12019 [(use (match_operand 0 "" ""))]
12020 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
12021 "{ rs6000_emit_cbranch (LTGT, operands[0]); DONE; }")
12022
12023 ;; For SNE, we would prefer that the xor/abs sequence be used for integers.
12024 ;; For SEQ, likewise, except that comparisons with zero should be done
12025 ;; with an scc insns. However, due to the order that combine see the
12026 ;; resulting insns, we must, in fact, allow SEQ for integers. Fail in
12027 ;; the cases we don't want to handle.
12028 (define_expand "seq"
12029 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12030 ""
12031 "{ rs6000_emit_sCOND (EQ, operands[0]); DONE; }")
12032
12033 (define_expand "sne"
12034 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12035 ""
12036 "
12037 {
12038 if (! rs6000_compare_fp_p)
12039 FAIL;
12040
12041 rs6000_emit_sCOND (NE, operands[0]);
12042 DONE;
12043 }")
12044
12045 ;; A >= 0 is best done the portable way for A an integer.
12046 (define_expand "sge"
12047 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12048 ""
12049 "
12050 {
12051 if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
12052 FAIL;
12053
12054 rs6000_emit_sCOND (GE, operands[0]);
12055 DONE;
12056 }")
12057
12058 ;; A > 0 is best done using the portable sequence, so fail in that case.
12059 (define_expand "sgt"
12060 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12061 ""
12062 "
12063 {
12064 if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
12065 FAIL;
12066
12067 rs6000_emit_sCOND (GT, operands[0]);
12068 DONE;
12069 }")
12070
12071 ;; A <= 0 is best done the portable way for A an integer.
12072 (define_expand "sle"
12073 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12074 ""
12075 "
12076 {
12077 if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
12078 FAIL;
12079
12080 rs6000_emit_sCOND (LE, operands[0]);
12081 DONE;
12082 }")
12083
12084 ;; A < 0 is best done in the portable way for A an integer.
12085 (define_expand "slt"
12086 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12087 ""
12088 "
12089 {
12090 if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
12091 FAIL;
12092
12093 rs6000_emit_sCOND (LT, operands[0]);
12094 DONE;
12095 }")
12096
12097 (define_expand "sgeu"
12098 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12099 ""
12100 "{ rs6000_emit_sCOND (GEU, operands[0]); DONE; }")
12101
12102 (define_expand "sgtu"
12103 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12104 ""
12105 "{ rs6000_emit_sCOND (GTU, operands[0]); DONE; }")
12106
12107 (define_expand "sleu"
12108 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12109 ""
12110 "{ rs6000_emit_sCOND (LEU, operands[0]); DONE; }")
12111
12112 (define_expand "sltu"
12113 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12114 ""
12115 "{ rs6000_emit_sCOND (LTU, operands[0]); DONE; }")
12116
12117 (define_expand "sunordered"
12118 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12119 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
12120 "{ rs6000_emit_sCOND (UNORDERED, operands[0]); DONE; }")
12121
12122 (define_expand "sordered"
12123 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12124 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
12125 "{ rs6000_emit_sCOND (ORDERED, operands[0]); DONE; }")
12126
12127 (define_expand "suneq"
12128 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12129 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
12130 "{ rs6000_emit_sCOND (UNEQ, operands[0]); DONE; }")
12131
12132 (define_expand "sunge"
12133 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12134 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
12135 "{ rs6000_emit_sCOND (UNGE, operands[0]); DONE; }")
12136
12137 (define_expand "sungt"
12138 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12139 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
12140 "{ rs6000_emit_sCOND (UNGT, operands[0]); DONE; }")
12141
12142 (define_expand "sunle"
12143 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12144 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
12145 "{ rs6000_emit_sCOND (UNLE, operands[0]); DONE; }")
12146
12147 (define_expand "sunlt"
12148 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12149 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
12150 "{ rs6000_emit_sCOND (UNLT, operands[0]); DONE; }")
12151
12152 (define_expand "sltgt"
12153 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
12154 "! (TARGET_HARD_FLOAT && !TARGET_FPRS)"
12155 "{ rs6000_emit_sCOND (LTGT, operands[0]); DONE; }")
12156
12157 (define_expand "stack_protect_set"
12158 [(match_operand 0 "memory_operand" "")
12159 (match_operand 1 "memory_operand" "")]
12160 ""
12161 {
12162 #ifdef TARGET_THREAD_SSP_OFFSET
12163 rtx tlsreg = gen_rtx_REG (Pmode, TARGET_64BIT ? 13 : 2);
12164 rtx addr = gen_rtx_PLUS (Pmode, tlsreg, GEN_INT (TARGET_THREAD_SSP_OFFSET));
12165 operands[1] = gen_rtx_MEM (Pmode, addr);
12166 #endif
12167 if (TARGET_64BIT)
12168 emit_insn (gen_stack_protect_setdi (operands[0], operands[1]));
12169 else
12170 emit_insn (gen_stack_protect_setsi (operands[0], operands[1]));
12171 DONE;
12172 })
12173
12174 (define_insn "stack_protect_setsi"
12175 [(set (match_operand:SI 0 "memory_operand" "=m")
12176 (unspec:SI [(match_operand:SI 1 "memory_operand" "m")] UNSPEC_SP_SET))
12177 (set (match_scratch:SI 2 "=&r") (const_int 0))]
12178 "TARGET_32BIT"
12179 "{l%U1%X1|lwz%U1%X1} %2,%1\;{st%U0%X0|stw%U0%X0} %2,%0\;{lil|li} %2,0"
12180 [(set_attr "type" "three")
12181 (set_attr "length" "12")])
12182
12183 (define_insn "stack_protect_setdi"
12184 [(set (match_operand:DI 0 "memory_operand" "=m")
12185 (unspec:DI [(match_operand:DI 1 "memory_operand" "m")] UNSPEC_SP_SET))
12186 (set (match_scratch:DI 2 "=&r") (const_int 0))]
12187 "TARGET_64BIT"
12188 "ld%U1%X1 %2,%1\;std%U0%X0 %2,%0\;{lil|li} %2,0"
12189 [(set_attr "type" "three")
12190 (set_attr "length" "12")])
12191
12192 (define_expand "stack_protect_test"
12193 [(match_operand 0 "memory_operand" "")
12194 (match_operand 1 "memory_operand" "")
12195 (match_operand 2 "" "")]
12196 ""
12197 {
12198 #ifdef TARGET_THREAD_SSP_OFFSET
12199 rtx tlsreg = gen_rtx_REG (Pmode, TARGET_64BIT ? 13 : 2);
12200 rtx addr = gen_rtx_PLUS (Pmode, tlsreg, GEN_INT (TARGET_THREAD_SSP_OFFSET));
12201 operands[1] = gen_rtx_MEM (Pmode, addr);
12202 #endif
12203 rs6000_compare_op0 = operands[0];
12204 rs6000_compare_op1 = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, operands[1]),
12205 UNSPEC_SP_TEST);
12206 rs6000_compare_fp_p = 0;
12207 emit_jump_insn (gen_beq (operands[2]));
12208 DONE;
12209 })
12210
12211 (define_insn "stack_protect_testsi"
12212 [(set (match_operand:CCEQ 0 "cc_reg_operand" "=x,?y")
12213 (unspec:CCEQ [(match_operand:SI 1 "memory_operand" "m,m")
12214 (match_operand:SI 2 "memory_operand" "m,m")]
12215 UNSPEC_SP_TEST))
12216 (set (match_scratch:SI 4 "=r,r") (const_int 0))
12217 (clobber (match_scratch:SI 3 "=&r,&r"))]
12218 "TARGET_32BIT"
12219 "@
12220 {l%U1%X1|lwz%U1%X1} %3,%1\;{l%U2%X2|lwz%U2%X2} %4,%2\;xor. %3,%3,%4\;{lil|li} %4,0
12221 {l%U1%X1|lwz%U1%X1} %3,%1\;{l%U2%X2|lwz%U2%X2} %4,%2\;{cmpl|cmplw} %0,%3,%4\;{lil|li} %3,0\;{lil|li} %4,0"
12222 [(set_attr "length" "16,20")])
12223
12224 (define_insn "stack_protect_testdi"
12225 [(set (match_operand:CCEQ 0 "cc_reg_operand" "=x,?y")
12226 (unspec:CCEQ [(match_operand:DI 1 "memory_operand" "m,m")
12227 (match_operand:DI 2 "memory_operand" "m,m")]
12228 UNSPEC_SP_TEST))
12229 (set (match_scratch:DI 4 "=r,r") (const_int 0))
12230 (clobber (match_scratch:DI 3 "=&r,&r"))]
12231 "TARGET_64BIT"
12232 "@
12233 ld%U1%X1 %3,%1\;ld%U2%X2 %4,%2\;xor. %3,%3,%4\;{lil|li} %4,0
12234 ld%U1%X1 %3,%1\;ld%U2%X2 %4,%2\;cmpld %0,%3,%4\;{lil|li} %3,0\;{lil|li} %4,0"
12235 [(set_attr "length" "16,20")])
12236
12237 \f
12238 ;; Here are the actual compare insns.
12239 (define_insn "*cmp<mode>_internal1"
12240 [(set (match_operand:CC 0 "cc_reg_operand" "=y")
12241 (compare:CC (match_operand:GPR 1 "gpc_reg_operand" "r")
12242 (match_operand:GPR 2 "reg_or_short_operand" "rI")))]
12243 ""
12244 "{cmp%I2|cmp<wd>%I2} %0,%1,%2"
12245 [(set_attr "type" "cmp")])
12246
12247 ;; If we are comparing a register for equality with a large constant,
12248 ;; we can do this with an XOR followed by a compare. But this is profitable
12249 ;; only if the large constant is only used for the comparison (and in this
12250 ;; case we already have a register to reuse as scratch).
12251 ;;
12252 ;; For 64-bit registers, we could only do so if the constant's bit 15 is clear:
12253 ;; otherwise we'd need to XOR with FFFFFFFF????0000 which is not available.
12254
12255 (define_peephole2
12256 [(set (match_operand:SI 0 "register_operand")
12257 (match_operand:SI 1 "logical_const_operand" ""))
12258 (set (match_dup 0) (match_operator:SI 3 "boolean_or_operator"
12259 [(match_dup 0)
12260 (match_operand:SI 2 "logical_const_operand" "")]))
12261 (set (match_operand:CC 4 "cc_reg_operand" "")
12262 (compare:CC (match_operand:SI 5 "gpc_reg_operand" "")
12263 (match_dup 0)))
12264 (set (pc)
12265 (if_then_else (match_operator 6 "equality_operator"
12266 [(match_dup 4) (const_int 0)])
12267 (match_operand 7 "" "")
12268 (match_operand 8 "" "")))]
12269 "peep2_reg_dead_p (3, operands[0])
12270 && peep2_reg_dead_p (4, operands[4])"
12271 [(set (match_dup 0) (xor:SI (match_dup 5) (match_dup 9)))
12272 (set (match_dup 4) (compare:CC (match_dup 0) (match_dup 10)))
12273 (set (pc) (if_then_else (match_dup 6) (match_dup 7) (match_dup 8)))]
12274
12275 {
12276 /* Get the constant we are comparing against, and see what it looks like
12277 when sign-extended from 16 to 32 bits. Then see what constant we could
12278 XOR with SEXTC to get the sign-extended value. */
12279 rtx cnst = simplify_const_binary_operation (GET_CODE (operands[3]),
12280 SImode,
12281 operands[1], operands[2]);
12282 HOST_WIDE_INT c = INTVAL (cnst);
12283 HOST_WIDE_INT sextc = ((c & 0xffff) ^ 0x8000) - 0x8000;
12284 HOST_WIDE_INT xorv = c ^ sextc;
12285
12286 operands[9] = GEN_INT (xorv);
12287 operands[10] = GEN_INT (sextc);
12288 })
12289
12290 (define_insn "*cmpsi_internal2"
12291 [(set (match_operand:CCUNS 0 "cc_reg_operand" "=y")
12292 (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "r")
12293 (match_operand:SI 2 "reg_or_u_short_operand" "rK")))]
12294 ""
12295 "{cmpl%I2|cmplw%I2} %0,%1,%b2"
12296 [(set_attr "type" "cmp")])
12297
12298 (define_insn "*cmpdi_internal2"
12299 [(set (match_operand:CCUNS 0 "cc_reg_operand" "=y")
12300 (compare:CCUNS (match_operand:DI 1 "gpc_reg_operand" "r")
12301 (match_operand:DI 2 "reg_or_u_short_operand" "rK")))]
12302 ""
12303 "cmpld%I2 %0,%1,%b2"
12304 [(set_attr "type" "cmp")])
12305
12306 ;; The following two insns don't exist as single insns, but if we provide
12307 ;; them, we can swap an add and compare, which will enable us to overlap more
12308 ;; of the required delay between a compare and branch. We generate code for
12309 ;; them by splitting.
12310
12311 (define_insn ""
12312 [(set (match_operand:CC 3 "cc_reg_operand" "=y")
12313 (compare:CC (match_operand:SI 1 "gpc_reg_operand" "r")
12314 (match_operand:SI 2 "short_cint_operand" "i")))
12315 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
12316 (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "i")))]
12317 ""
12318 "#"
12319 [(set_attr "length" "8")])
12320
12321 (define_insn ""
12322 [(set (match_operand:CCUNS 3 "cc_reg_operand" "=y")
12323 (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "r")
12324 (match_operand:SI 2 "u_short_cint_operand" "i")))
12325 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
12326 (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "i")))]
12327 ""
12328 "#"
12329 [(set_attr "length" "8")])
12330
12331 (define_split
12332 [(set (match_operand:CC 3 "cc_reg_operand" "")
12333 (compare:CC (match_operand:SI 1 "gpc_reg_operand" "")
12334 (match_operand:SI 2 "short_cint_operand" "")))
12335 (set (match_operand:SI 0 "gpc_reg_operand" "")
12336 (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "")))]
12337 ""
12338 [(set (match_dup 3) (compare:CC (match_dup 1) (match_dup 2)))
12339 (set (match_dup 0) (plus:SI (match_dup 1) (match_dup 4)))])
12340
12341 (define_split
12342 [(set (match_operand:CCUNS 3 "cc_reg_operand" "")
12343 (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "")
12344 (match_operand:SI 2 "u_short_cint_operand" "")))
12345 (set (match_operand:SI 0 "gpc_reg_operand" "")
12346 (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "")))]
12347 ""
12348 [(set (match_dup 3) (compare:CCUNS (match_dup 1) (match_dup 2)))
12349 (set (match_dup 0) (plus:SI (match_dup 1) (match_dup 4)))])
12350
12351 (define_insn "*cmpsf_internal1"
12352 [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
12353 (compare:CCFP (match_operand:SF 1 "gpc_reg_operand" "f")
12354 (match_operand:SF 2 "gpc_reg_operand" "f")))]
12355 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT"
12356 "fcmpu %0,%1,%2"
12357 [(set_attr "type" "fpcompare")])
12358
12359 (define_insn "*cmpdf_internal1"
12360 [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
12361 (compare:CCFP (match_operand:DF 1 "gpc_reg_operand" "f")
12362 (match_operand:DF 2 "gpc_reg_operand" "f")))]
12363 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
12364 "fcmpu %0,%1,%2"
12365 [(set_attr "type" "fpcompare")])
12366
12367 ;; Only need to compare second words if first words equal
12368 (define_insn "*cmptf_internal1"
12369 [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
12370 (compare:CCFP (match_operand:TF 1 "gpc_reg_operand" "f")
12371 (match_operand:TF 2 "gpc_reg_operand" "f")))]
12372 "!TARGET_IEEEQUAD && !TARGET_XL_COMPAT
12373 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT && TARGET_LONG_DOUBLE_128"
12374 "fcmpu %0,%1,%2\;bne %0,$+8\;fcmpu %0,%L1,%L2"
12375 [(set_attr "type" "fpcompare")
12376 (set_attr "length" "12")])
12377
12378 (define_insn_and_split "*cmptf_internal2"
12379 [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
12380 (compare:CCFP (match_operand:TF 1 "gpc_reg_operand" "f")
12381 (match_operand:TF 2 "gpc_reg_operand" "f")))
12382 (clobber (match_scratch:DF 3 "=f"))
12383 (clobber (match_scratch:DF 4 "=f"))
12384 (clobber (match_scratch:DF 5 "=f"))
12385 (clobber (match_scratch:DF 6 "=f"))
12386 (clobber (match_scratch:DF 7 "=f"))
12387 (clobber (match_scratch:DF 8 "=f"))
12388 (clobber (match_scratch:DF 9 "=f"))
12389 (clobber (match_scratch:DF 10 "=f"))]
12390 "!TARGET_IEEEQUAD && TARGET_XL_COMPAT
12391 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT && TARGET_LONG_DOUBLE_128"
12392 "#"
12393 "&& reload_completed"
12394 [(set (match_dup 3) (match_dup 13))
12395 (set (match_dup 4) (match_dup 14))
12396 (set (match_dup 9) (abs:DF (match_dup 5)))
12397 (set (match_dup 0) (compare:CCFP (match_dup 9) (match_dup 3)))
12398 (set (pc) (if_then_else (ne (match_dup 0) (const_int 0))
12399 (label_ref (match_dup 11))
12400 (pc)))
12401 (set (match_dup 0) (compare:CCFP (match_dup 5) (match_dup 7)))
12402 (set (pc) (label_ref (match_dup 12)))
12403 (match_dup 11)
12404 (set (match_dup 10) (minus:DF (match_dup 5) (match_dup 7)))
12405 (set (match_dup 9) (minus:DF (match_dup 6) (match_dup 8)))
12406 (set (match_dup 9) (plus:DF (match_dup 10) (match_dup 9)))
12407 (set (match_dup 0) (compare:CCFP (match_dup 7) (match_dup 4)))
12408 (match_dup 12)]
12409 {
12410 REAL_VALUE_TYPE rv;
12411 const int lo_word = FLOAT_WORDS_BIG_ENDIAN ? GET_MODE_SIZE (DFmode) : 0;
12412 const int hi_word = FLOAT_WORDS_BIG_ENDIAN ? 0 : GET_MODE_SIZE (DFmode);
12413
12414 operands[5] = simplify_gen_subreg (DFmode, operands[1], TFmode, hi_word);
12415 operands[6] = simplify_gen_subreg (DFmode, operands[1], TFmode, lo_word);
12416 operands[7] = simplify_gen_subreg (DFmode, operands[2], TFmode, hi_word);
12417 operands[8] = simplify_gen_subreg (DFmode, operands[2], TFmode, lo_word);
12418 operands[11] = gen_label_rtx ();
12419 operands[12] = gen_label_rtx ();
12420 real_inf (&rv);
12421 operands[13] = force_const_mem (DFmode,
12422 CONST_DOUBLE_FROM_REAL_VALUE (rv, DFmode));
12423 operands[14] = force_const_mem (DFmode,
12424 CONST_DOUBLE_FROM_REAL_VALUE (dconst0,
12425 DFmode));
12426 if (TARGET_TOC)
12427 {
12428 operands[13] = gen_const_mem (DFmode,
12429 create_TOC_reference (XEXP (operands[13], 0)));
12430 operands[14] = gen_const_mem (DFmode,
12431 create_TOC_reference (XEXP (operands[14], 0)));
12432 set_mem_alias_set (operands[13], get_TOC_alias_set ());
12433 set_mem_alias_set (operands[14], get_TOC_alias_set ());
12434 }
12435 })
12436 \f
12437 ;; Now we have the scc insns. We can do some combinations because of the
12438 ;; way the machine works.
12439 ;;
12440 ;; Note that this is probably faster if we can put an insn between the
12441 ;; mfcr and rlinm, but this is tricky. Let's leave it for now. In most
12442 ;; cases the insns below which don't use an intermediate CR field will
12443 ;; be used instead.
12444 (define_insn ""
12445 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
12446 (match_operator:SI 1 "scc_comparison_operator"
12447 [(match_operand 2 "cc_reg_operand" "y")
12448 (const_int 0)]))]
12449 ""
12450 "mfcr %0%Q2\;{rlinm|rlwinm} %0,%0,%J1,1"
12451 [(set (attr "type")
12452 (cond [(ne (symbol_ref "TARGET_MFCRF") (const_int 0))
12453 (const_string "mfcrf")
12454 ]
12455 (const_string "mfcr")))
12456 (set_attr "length" "8")])
12457
12458 ;; Same as above, but get the GT bit.
12459 (define_insn "move_from_CR_gt_bit"
12460 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
12461 (unspec:SI [(match_operand 1 "cc_reg_operand" "y")] UNSPEC_MV_CR_GT))]
12462 "TARGET_HARD_FLOAT && !TARGET_FPRS"
12463 "mfcr %0\;{rlinm|rlwinm} %0,%0,%D1,31,31"
12464 [(set_attr "type" "mfcr")
12465 (set_attr "length" "8")])
12466
12467 ;; Same as above, but get the OV/ORDERED bit.
12468 (define_insn "move_from_CR_ov_bit"
12469 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
12470 (unspec:SI [(match_operand 1 "cc_reg_operand" "y")] UNSPEC_MV_CR_OV))]
12471 "TARGET_ISEL"
12472 "mfcr %0\;{rlinm|rlwinm} %0,%0,%t1,1"
12473 [(set_attr "type" "mfcr")
12474 (set_attr "length" "8")])
12475
12476 (define_insn ""
12477 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
12478 (match_operator:DI 1 "scc_comparison_operator"
12479 [(match_operand 2 "cc_reg_operand" "y")
12480 (const_int 0)]))]
12481 "TARGET_POWERPC64"
12482 "mfcr %0%Q2\;{rlinm|rlwinm} %0,%0,%J1,1"
12483 [(set (attr "type")
12484 (cond [(ne (symbol_ref "TARGET_MFCRF") (const_int 0))
12485 (const_string "mfcrf")
12486 ]
12487 (const_string "mfcr")))
12488 (set_attr "length" "8")])
12489
12490 (define_insn ""
12491 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
12492 (compare:CC (match_operator:SI 1 "scc_comparison_operator"
12493 [(match_operand 2 "cc_reg_operand" "y,y")
12494 (const_int 0)])
12495 (const_int 0)))
12496 (set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
12497 (match_op_dup 1 [(match_dup 2) (const_int 0)]))]
12498 "TARGET_32BIT"
12499 "@
12500 mfcr %3%Q2\;{rlinm.|rlwinm.} %3,%3,%J1,1
12501 #"
12502 [(set_attr "type" "delayed_compare")
12503 (set_attr "length" "8,16")])
12504
12505 (define_split
12506 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
12507 (compare:CC (match_operator:SI 1 "scc_comparison_operator"
12508 [(match_operand 2 "cc_reg_operand" "")
12509 (const_int 0)])
12510 (const_int 0)))
12511 (set (match_operand:SI 3 "gpc_reg_operand" "")
12512 (match_op_dup 1 [(match_dup 2) (const_int 0)]))]
12513 "TARGET_32BIT && reload_completed"
12514 [(set (match_dup 3)
12515 (match_op_dup 1 [(match_dup 2) (const_int 0)]))
12516 (set (match_dup 0)
12517 (compare:CC (match_dup 3)
12518 (const_int 0)))]
12519 "")
12520
12521 (define_insn ""
12522 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
12523 (ashift:SI (match_operator:SI 1 "scc_comparison_operator"
12524 [(match_operand 2 "cc_reg_operand" "y")
12525 (const_int 0)])
12526 (match_operand:SI 3 "const_int_operand" "n")))]
12527 ""
12528 "*
12529 {
12530 int is_bit = ccr_bit (operands[1], 1);
12531 int put_bit = 31 - (INTVAL (operands[3]) & 31);
12532 int count;
12533
12534 if (is_bit >= put_bit)
12535 count = is_bit - put_bit;
12536 else
12537 count = 32 - (put_bit - is_bit);
12538
12539 operands[4] = GEN_INT (count);
12540 operands[5] = GEN_INT (put_bit);
12541
12542 return \"mfcr %0%Q2\;{rlinm|rlwinm} %0,%0,%4,%5,%5\";
12543 }"
12544 [(set (attr "type")
12545 (cond [(ne (symbol_ref "TARGET_MFCRF") (const_int 0))
12546 (const_string "mfcrf")
12547 ]
12548 (const_string "mfcr")))
12549 (set_attr "length" "8")])
12550
12551 (define_insn ""
12552 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
12553 (compare:CC
12554 (ashift:SI (match_operator:SI 1 "scc_comparison_operator"
12555 [(match_operand 2 "cc_reg_operand" "y,y")
12556 (const_int 0)])
12557 (match_operand:SI 3 "const_int_operand" "n,n"))
12558 (const_int 0)))
12559 (set (match_operand:SI 4 "gpc_reg_operand" "=r,r")
12560 (ashift:SI (match_op_dup 1 [(match_dup 2) (const_int 0)])
12561 (match_dup 3)))]
12562 ""
12563 "*
12564 {
12565 int is_bit = ccr_bit (operands[1], 1);
12566 int put_bit = 31 - (INTVAL (operands[3]) & 31);
12567 int count;
12568
12569 /* Force split for non-cc0 compare. */
12570 if (which_alternative == 1)
12571 return \"#\";
12572
12573 if (is_bit >= put_bit)
12574 count = is_bit - put_bit;
12575 else
12576 count = 32 - (put_bit - is_bit);
12577
12578 operands[5] = GEN_INT (count);
12579 operands[6] = GEN_INT (put_bit);
12580
12581 return \"mfcr %4%Q2\;{rlinm.|rlwinm.} %4,%4,%5,%6,%6\";
12582 }"
12583 [(set_attr "type" "delayed_compare")
12584 (set_attr "length" "8,16")])
12585
12586 (define_split
12587 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
12588 (compare:CC
12589 (ashift:SI (match_operator:SI 1 "scc_comparison_operator"
12590 [(match_operand 2 "cc_reg_operand" "")
12591 (const_int 0)])
12592 (match_operand:SI 3 "const_int_operand" ""))
12593 (const_int 0)))
12594 (set (match_operand:SI 4 "gpc_reg_operand" "")
12595 (ashift:SI (match_op_dup 1 [(match_dup 2) (const_int 0)])
12596 (match_dup 3)))]
12597 "reload_completed"
12598 [(set (match_dup 4)
12599 (ashift:SI (match_op_dup 1 [(match_dup 2) (const_int 0)])
12600 (match_dup 3)))
12601 (set (match_dup 0)
12602 (compare:CC (match_dup 4)
12603 (const_int 0)))]
12604 "")
12605
12606 ;; There is a 3 cycle delay between consecutive mfcr instructions
12607 ;; so it is useful to combine 2 scc instructions to use only one mfcr.
12608
12609 (define_peephole
12610 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
12611 (match_operator:SI 1 "scc_comparison_operator"
12612 [(match_operand 2 "cc_reg_operand" "y")
12613 (const_int 0)]))
12614 (set (match_operand:SI 3 "gpc_reg_operand" "=r")
12615 (match_operator:SI 4 "scc_comparison_operator"
12616 [(match_operand 5 "cc_reg_operand" "y")
12617 (const_int 0)]))]
12618 "REGNO (operands[2]) != REGNO (operands[5])"
12619 "mfcr %3\;{rlinm|rlwinm} %0,%3,%J1,1\;{rlinm|rlwinm} %3,%3,%J4,1"
12620 [(set_attr "type" "mfcr")
12621 (set_attr "length" "12")])
12622
12623 (define_peephole
12624 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
12625 (match_operator:DI 1 "scc_comparison_operator"
12626 [(match_operand 2 "cc_reg_operand" "y")
12627 (const_int 0)]))
12628 (set (match_operand:DI 3 "gpc_reg_operand" "=r")
12629 (match_operator:DI 4 "scc_comparison_operator"
12630 [(match_operand 5 "cc_reg_operand" "y")
12631 (const_int 0)]))]
12632 "TARGET_POWERPC64 && REGNO (operands[2]) != REGNO (operands[5])"
12633 "mfcr %3\;{rlinm|rlwinm} %0,%3,%J1,1\;{rlinm|rlwinm} %3,%3,%J4,1"
12634 [(set_attr "type" "mfcr")
12635 (set_attr "length" "12")])
12636
12637 ;; There are some scc insns that can be done directly, without a compare.
12638 ;; These are faster because they don't involve the communications between
12639 ;; the FXU and branch units. In fact, we will be replacing all of the
12640 ;; integer scc insns here or in the portable methods in emit_store_flag.
12641 ;;
12642 ;; Also support (neg (scc ..)) since that construct is used to replace
12643 ;; branches, (plus (scc ..) ..) since that construct is common and
12644 ;; takes no more insns than scc, and (and (neg (scc ..)) ..) in the
12645 ;; cases where it is no more expensive than (neg (scc ..)).
12646
12647 ;; Have reload force a constant into a register for the simple insns that
12648 ;; otherwise won't accept constants. We do this because it is faster than
12649 ;; the cmp/mfcr sequence we would otherwise generate.
12650
12651 (define_mode_attr scc_eq_op2 [(SI "rKLI")
12652 (DI "rKJI")])
12653
12654 (define_insn_and_split "*eq<mode>"
12655 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
12656 (eq:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")
12657 (match_operand:GPR 2 "scc_eq_operand" "<scc_eq_op2>")))]
12658 "!TARGET_POWER"
12659 "#"
12660 "!TARGET_POWER"
12661 [(set (match_dup 0)
12662 (clz:GPR (match_dup 3)))
12663 (set (match_dup 0)
12664 (lshiftrt:GPR (match_dup 0) (match_dup 4)))]
12665 {
12666 if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) != 0)
12667 {
12668 /* Use output operand as intermediate. */
12669 operands[3] = operands[0];
12670
12671 if (logical_operand (operands[2], <MODE>mode))
12672 emit_insn (gen_rtx_SET (VOIDmode, operands[3],
12673 gen_rtx_XOR (<MODE>mode,
12674 operands[1], operands[2])));
12675 else
12676 emit_insn (gen_rtx_SET (VOIDmode, operands[3],
12677 gen_rtx_PLUS (<MODE>mode, operands[1],
12678 negate_rtx (<MODE>mode,
12679 operands[2]))));
12680 }
12681 else
12682 operands[3] = operands[1];
12683
12684 operands[4] = GEN_INT (exact_log2 (GET_MODE_BITSIZE (<MODE>mode)));
12685 })
12686
12687 (define_insn_and_split "*eq<mode>_compare"
12688 [(set (match_operand:CC 3 "cc_reg_operand" "=y")
12689 (compare:CC
12690 (eq:P (match_operand:P 1 "gpc_reg_operand" "=r")
12691 (match_operand:P 2 "scc_eq_operand" "<scc_eq_op2>"))
12692 (const_int 0)))
12693 (set (match_operand:P 0 "gpc_reg_operand" "=r")
12694 (eq:P (match_dup 1) (match_dup 2)))]
12695 "!TARGET_POWER && optimize_size"
12696 "#"
12697 "!TARGET_POWER && optimize_size"
12698 [(set (match_dup 0)
12699 (clz:P (match_dup 4)))
12700 (parallel [(set (match_dup 3)
12701 (compare:CC (lshiftrt:P (match_dup 0) (match_dup 5))
12702 (const_int 0)))
12703 (set (match_dup 0)
12704 (lshiftrt:P (match_dup 0) (match_dup 5)))])]
12705 {
12706 if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) != 0)
12707 {
12708 /* Use output operand as intermediate. */
12709 operands[4] = operands[0];
12710
12711 if (logical_operand (operands[2], <MODE>mode))
12712 emit_insn (gen_rtx_SET (VOIDmode, operands[4],
12713 gen_rtx_XOR (<MODE>mode,
12714 operands[1], operands[2])));
12715 else
12716 emit_insn (gen_rtx_SET (VOIDmode, operands[4],
12717 gen_rtx_PLUS (<MODE>mode, operands[1],
12718 negate_rtx (<MODE>mode,
12719 operands[2]))));
12720 }
12721 else
12722 operands[4] = operands[1];
12723
12724 operands[5] = GEN_INT (exact_log2 (GET_MODE_BITSIZE (<MODE>mode)));
12725 })
12726
12727 (define_insn "*eqsi_power"
12728 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
12729 (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
12730 (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,L,I")))
12731 (clobber (match_scratch:SI 3 "=r,&r,r,r,r"))]
12732 "TARGET_POWER"
12733 "@
12734 xor %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
12735 {sfi|subfic} %3,%1,0\;{ae|adde} %0,%3,%1
12736 {xoril|xori} %0,%1,%b2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
12737 {xoriu|xoris} %0,%1,%u2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
12738 {sfi|subfic} %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0"
12739 [(set_attr "type" "three,two,three,three,three")
12740 (set_attr "length" "12,8,12,12,12")])
12741
12742 ;; We have insns of the form shown by the first define_insn below. If
12743 ;; there is something inside the comparison operation, we must split it.
12744 (define_split
12745 [(set (match_operand:SI 0 "gpc_reg_operand" "")
12746 (plus:SI (match_operator 1 "comparison_operator"
12747 [(match_operand:SI 2 "" "")
12748 (match_operand:SI 3
12749 "reg_or_cint_operand" "")])
12750 (match_operand:SI 4 "gpc_reg_operand" "")))
12751 (clobber (match_operand:SI 5 "register_operand" ""))]
12752 "! gpc_reg_operand (operands[2], SImode)"
12753 [(set (match_dup 5) (match_dup 2))
12754 (set (match_dup 2) (plus:SI (match_op_dup 1 [(match_dup 2) (match_dup 3)])
12755 (match_dup 4)))])
12756
12757 (define_insn "*plus_eqsi"
12758 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r,&r,&r,&r")
12759 (plus:SI (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
12760 (match_operand:SI 2 "scc_eq_operand" "r,O,K,L,I"))
12761 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r")))]
12762 "TARGET_32BIT"
12763 "@
12764 xor %0,%1,%2\;{sfi|subfic} %0,%0,0\;{aze|addze} %0,%3
12765 {sfi|subfic} %0,%1,0\;{aze|addze} %0,%3
12766 {xoril|xori} %0,%1,%b2\;{sfi|subfic} %0,%0,0\;{aze|addze} %0,%3
12767 {xoriu|xoris} %0,%1,%u2\;{sfi|subfic} %0,%0,0\;{aze|addze} %0,%3
12768 {sfi|subfic} %0,%1,%2\;{sfi|subfic} %0,%0,0\;{aze|addze} %0,%3"
12769 [(set_attr "type" "three,two,three,three,three")
12770 (set_attr "length" "12,8,12,12,12")])
12771
12772 (define_insn "*compare_plus_eqsi"
12773 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,x,?y,?y,?y,?y,?y")
12774 (compare:CC
12775 (plus:SI
12776 (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r,r,r")
12777 (match_operand:SI 2 "scc_eq_operand" "r,O,K,L,I,r,O,K,L,I"))
12778 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r,r,r,r,r,r"))
12779 (const_int 0)))
12780 (clobber (match_scratch:SI 4 "=&r,&r,&r,&r,&r,&r,&r,&r,&r,&r"))]
12781 "TARGET_32BIT && optimize_size"
12782 "@
12783 xor %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
12784 {sfi|subfic} %4,%1,0\;{aze.|addze.} %4,%3
12785 {xoril|xori} %4,%1,%b2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
12786 {xoriu|xoris} %4,%1,%u2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
12787 {sfi|subfic} %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
12788 #
12789 #
12790 #
12791 #
12792 #"
12793 [(set_attr "type" "compare")
12794 (set_attr "length" "12,8,12,12,12,16,12,16,16,16")])
12795
12796 (define_split
12797 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
12798 (compare:CC
12799 (plus:SI
12800 (eq:SI (match_operand:SI 1 "gpc_reg_operand" "")
12801 (match_operand:SI 2 "scc_eq_operand" ""))
12802 (match_operand:SI 3 "gpc_reg_operand" ""))
12803 (const_int 0)))
12804 (clobber (match_scratch:SI 4 ""))]
12805 "TARGET_32BIT && optimize_size && reload_completed"
12806 [(set (match_dup 4)
12807 (plus:SI (eq:SI (match_dup 1)
12808 (match_dup 2))
12809 (match_dup 3)))
12810 (set (match_dup 0)
12811 (compare:CC (match_dup 4)
12812 (const_int 0)))]
12813 "")
12814
12815 (define_insn "*plus_eqsi_compare"
12816 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,x,x,x,?y,?y,?y,?y,?y")
12817 (compare:CC
12818 (plus:SI
12819 (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r,r,r")
12820 (match_operand:SI 2 "scc_eq_operand" "r,O,K,L,I,r,O,K,L,I"))
12821 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r,r,r,r,r,r"))
12822 (const_int 0)))
12823 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r,&r,&r,&r,&r,&r,&r,&r,&r")
12824 (plus:SI (eq:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
12825 "TARGET_32BIT && optimize_size"
12826 "@
12827 xor %0,%1,%2\;{sfi|subfic} %0,%0,0\;{aze.|addze.} %0,%3
12828 {sfi|subfic} %0,%1,0\;{aze.|addze.} %0,%3
12829 {xoril|xori} %0,%1,%b2\;{sfi|subfic} %0,%0,0\;{aze.|addze.} %0,%3
12830 {xoriu|xoris} %0,%1,%u2\;{sfi|subfic} %0,%0,0\;{aze.|addze.} %0,%3
12831 {sfi|subfic} %0,%1,%2\;{sfi|subfic} %0,%0,0\;{aze.|addze.} %0,%3
12832 #
12833 #
12834 #
12835 #
12836 #"
12837 [(set_attr "type" "compare")
12838 (set_attr "length" "12,8,12,12,12,16,12,16,16,16")])
12839
12840 (define_split
12841 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
12842 (compare:CC
12843 (plus:SI
12844 (eq:SI (match_operand:SI 1 "gpc_reg_operand" "")
12845 (match_operand:SI 2 "scc_eq_operand" ""))
12846 (match_operand:SI 3 "gpc_reg_operand" ""))
12847 (const_int 0)))
12848 (set (match_operand:SI 0 "gpc_reg_operand" "")
12849 (plus:SI (eq:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
12850 "TARGET_32BIT && optimize_size && reload_completed"
12851 [(set (match_dup 0)
12852 (plus:SI (eq:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
12853 (set (match_dup 4)
12854 (compare:CC (match_dup 0)
12855 (const_int 0)))]
12856 "")
12857
12858 (define_insn "*neg_eq0<mode>"
12859 [(set (match_operand:P 0 "gpc_reg_operand" "=r")
12860 (neg:P (eq:P (match_operand:P 1 "gpc_reg_operand" "r")
12861 (const_int 0))))]
12862 ""
12863 "{ai|addic} %0,%1,-1\;{sfe|subfe} %0,%0,%0"
12864 [(set_attr "type" "two")
12865 (set_attr "length" "8")])
12866
12867 (define_insn_and_split "*neg_eq<mode>"
12868 [(set (match_operand:P 0 "gpc_reg_operand" "=r")
12869 (neg:P (eq:P (match_operand:P 1 "gpc_reg_operand" "%r")
12870 (match_operand:P 2 "scc_eq_operand" "<scc_eq_op2>"))))]
12871 ""
12872 "#"
12873 ""
12874 [(set (match_dup 0) (neg:P (eq:P (match_dup 3) (const_int 0))))]
12875 {
12876 if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) != 0)
12877 {
12878 /* Use output operand as intermediate. */
12879 operands[3] = operands[0];
12880
12881 if (logical_operand (operands[2], <MODE>mode))
12882 emit_insn (gen_rtx_SET (VOIDmode, operands[3],
12883 gen_rtx_XOR (<MODE>mode,
12884 operands[1], operands[2])));
12885 else
12886 emit_insn (gen_rtx_SET (VOIDmode, operands[3],
12887 gen_rtx_PLUS (<MODE>mode, operands[1],
12888 negate_rtx (<MODE>mode,
12889 operands[2]))));
12890 }
12891 else
12892 operands[3] = operands[1];
12893 })
12894
12895 ;; Simplify (ne X (const_int 0)) on the PowerPC. No need to on the Power,
12896 ;; since it nabs/sr is just as fast.
12897 (define_insn "*ne0si"
12898 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r")
12899 (lshiftrt:SI (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
12900 (const_int 31)))
12901 (clobber (match_scratch:SI 2 "=&r"))]
12902 "! TARGET_POWER && TARGET_32BIT && !TARGET_ISEL"
12903 "{ai|addic} %2,%1,-1\;{sfe|subfe} %0,%2,%1"
12904 [(set_attr "type" "two")
12905 (set_attr "length" "8")])
12906
12907 (define_insn "*ne0di"
12908 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
12909 (lshiftrt:DI (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r")))
12910 (const_int 63)))
12911 (clobber (match_scratch:DI 2 "=&r"))]
12912 "TARGET_64BIT"
12913 "addic %2,%1,-1\;subfe %0,%2,%1"
12914 [(set_attr "type" "two")
12915 (set_attr "length" "8")])
12916
12917 ;; This is what (plus (ne X (const_int 0)) Y) looks like.
12918 (define_insn "*plus_ne0si"
12919 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
12920 (plus:SI (lshiftrt:SI
12921 (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
12922 (const_int 31))
12923 (match_operand:SI 2 "gpc_reg_operand" "r")))
12924 (clobber (match_scratch:SI 3 "=&r"))]
12925 "TARGET_32BIT"
12926 "{ai|addic} %3,%1,-1\;{aze|addze} %0,%2"
12927 [(set_attr "type" "two")
12928 (set_attr "length" "8")])
12929
12930 (define_insn "*plus_ne0di"
12931 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
12932 (plus:DI (lshiftrt:DI
12933 (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r")))
12934 (const_int 63))
12935 (match_operand:DI 2 "gpc_reg_operand" "r")))
12936 (clobber (match_scratch:DI 3 "=&r"))]
12937 "TARGET_64BIT"
12938 "addic %3,%1,-1\;addze %0,%2"
12939 [(set_attr "type" "two")
12940 (set_attr "length" "8")])
12941
12942 (define_insn "*compare_plus_ne0si"
12943 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
12944 (compare:CC
12945 (plus:SI (lshiftrt:SI
12946 (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")))
12947 (const_int 31))
12948 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
12949 (const_int 0)))
12950 (clobber (match_scratch:SI 3 "=&r,&r"))
12951 (clobber (match_scratch:SI 4 "=X,&r"))]
12952 "TARGET_32BIT"
12953 "@
12954 {ai|addic} %3,%1,-1\;{aze.|addze.} %3,%2
12955 #"
12956 [(set_attr "type" "compare")
12957 (set_attr "length" "8,12")])
12958
12959 (define_split
12960 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
12961 (compare:CC
12962 (plus:SI (lshiftrt:SI
12963 (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "")))
12964 (const_int 31))
12965 (match_operand:SI 2 "gpc_reg_operand" ""))
12966 (const_int 0)))
12967 (clobber (match_scratch:SI 3 ""))
12968 (clobber (match_scratch:SI 4 ""))]
12969 "TARGET_32BIT && reload_completed"
12970 [(parallel [(set (match_dup 3)
12971 (plus:SI (lshiftrt:SI (neg:SI (abs:SI (match_dup 1)))
12972 (const_int 31))
12973 (match_dup 2)))
12974 (clobber (match_dup 4))])
12975 (set (match_dup 0)
12976 (compare:CC (match_dup 3)
12977 (const_int 0)))]
12978 "")
12979
12980 (define_insn "*compare_plus_ne0di"
12981 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
12982 (compare:CC
12983 (plus:DI (lshiftrt:DI
12984 (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")))
12985 (const_int 63))
12986 (match_operand:DI 2 "gpc_reg_operand" "r,r"))
12987 (const_int 0)))
12988 (clobber (match_scratch:DI 3 "=&r,&r"))]
12989 "TARGET_64BIT"
12990 "@
12991 addic %3,%1,-1\;addze. %3,%2
12992 #"
12993 [(set_attr "type" "compare")
12994 (set_attr "length" "8,12")])
12995
12996 (define_split
12997 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
12998 (compare:CC
12999 (plus:DI (lshiftrt:DI
13000 (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "")))
13001 (const_int 63))
13002 (match_operand:DI 2 "gpc_reg_operand" ""))
13003 (const_int 0)))
13004 (clobber (match_scratch:DI 3 ""))]
13005 "TARGET_64BIT && reload_completed"
13006 [(set (match_dup 3)
13007 (plus:DI (lshiftrt:DI (neg:DI (abs:DI (match_dup 1)))
13008 (const_int 63))
13009 (match_dup 2)))
13010 (set (match_dup 0)
13011 (compare:CC (match_dup 3)
13012 (const_int 0)))]
13013 "")
13014
13015 (define_insn "*plus_ne0si_compare"
13016 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
13017 (compare:CC
13018 (plus:SI (lshiftrt:SI
13019 (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")))
13020 (const_int 31))
13021 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
13022 (const_int 0)))
13023 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
13024 (plus:SI (lshiftrt:SI (neg:SI (abs:SI (match_dup 1))) (const_int 31))
13025 (match_dup 2)))
13026 (clobber (match_scratch:SI 3 "=&r,&r"))]
13027 "TARGET_32BIT"
13028 "@
13029 {ai|addic} %3,%1,-1\;{aze.|addze.} %0,%2
13030 #"
13031 [(set_attr "type" "compare")
13032 (set_attr "length" "8,12")])
13033
13034 (define_split
13035 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
13036 (compare:CC
13037 (plus:SI (lshiftrt:SI
13038 (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "")))
13039 (const_int 31))
13040 (match_operand:SI 2 "gpc_reg_operand" ""))
13041 (const_int 0)))
13042 (set (match_operand:SI 0 "gpc_reg_operand" "")
13043 (plus:SI (lshiftrt:SI (neg:SI (abs:SI (match_dup 1))) (const_int 31))
13044 (match_dup 2)))
13045 (clobber (match_scratch:SI 3 ""))]
13046 "TARGET_32BIT && reload_completed"
13047 [(parallel [(set (match_dup 0)
13048 (plus:SI (lshiftrt:SI (neg:SI (abs:SI (match_dup 1))) (const_int 31))
13049 (match_dup 2)))
13050 (clobber (match_dup 3))])
13051 (set (match_dup 4)
13052 (compare:CC (match_dup 0)
13053 (const_int 0)))]
13054 "")
13055
13056 (define_insn "*plus_ne0di_compare"
13057 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
13058 (compare:CC
13059 (plus:DI (lshiftrt:DI
13060 (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")))
13061 (const_int 63))
13062 (match_operand:DI 2 "gpc_reg_operand" "r,r"))
13063 (const_int 0)))
13064 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
13065 (plus:DI (lshiftrt:DI (neg:DI (abs:DI (match_dup 1))) (const_int 63))
13066 (match_dup 2)))
13067 (clobber (match_scratch:DI 3 "=&r,&r"))]
13068 "TARGET_64BIT"
13069 "@
13070 addic %3,%1,-1\;addze. %0,%2
13071 #"
13072 [(set_attr "type" "compare")
13073 (set_attr "length" "8,12")])
13074
13075 (define_split
13076 [(set (match_operand:CC 4 "cc_reg_not_micro_cr0_operand" "")
13077 (compare:CC
13078 (plus:DI (lshiftrt:DI
13079 (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "")))
13080 (const_int 63))
13081 (match_operand:DI 2 "gpc_reg_operand" ""))
13082 (const_int 0)))
13083 (set (match_operand:DI 0 "gpc_reg_operand" "")
13084 (plus:DI (lshiftrt:DI (neg:DI (abs:DI (match_dup 1))) (const_int 63))
13085 (match_dup 2)))
13086 (clobber (match_scratch:DI 3 ""))]
13087 "TARGET_64BIT && reload_completed"
13088 [(parallel [(set (match_dup 0)
13089 (plus:DI (lshiftrt:DI (neg:DI (abs:DI (match_dup 1))) (const_int 63))
13090 (match_dup 2)))
13091 (clobber (match_dup 3))])
13092 (set (match_dup 4)
13093 (compare:CC (match_dup 0)
13094 (const_int 0)))]
13095 "")
13096
13097 (define_insn ""
13098 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
13099 (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
13100 (match_operand:SI 2 "reg_or_short_operand" "r,O")))
13101 (clobber (match_scratch:SI 3 "=r,X"))]
13102 "TARGET_POWER"
13103 "@
13104 doz %3,%2,%1\;{sfi|subfic} %0,%3,0\;{ae|adde} %0,%0,%3
13105 {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{sri|srwi} %0,%0,31"
13106 [(set_attr "length" "12")])
13107
13108 (define_insn ""
13109 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,?y,?y")
13110 (compare:CC
13111 (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
13112 (match_operand:SI 2 "reg_or_short_operand" "r,O,r,O"))
13113 (const_int 0)))
13114 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
13115 (le:SI (match_dup 1) (match_dup 2)))
13116 (clobber (match_scratch:SI 3 "=r,X,r,X"))]
13117 "TARGET_POWER"
13118 "@
13119 doz %3,%2,%1\;{sfi|subfic} %0,%3,0\;{ae.|adde.} %0,%0,%3
13120 {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{sri.|srwi.} %0,%0,31
13121 #
13122 #"
13123 [(set_attr "type" "compare,delayed_compare,compare,delayed_compare")
13124 (set_attr "length" "12,12,16,16")])
13125
13126 (define_split
13127 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
13128 (compare:CC
13129 (le:SI (match_operand:SI 1 "gpc_reg_operand" "")
13130 (match_operand:SI 2 "reg_or_short_operand" ""))
13131 (const_int 0)))
13132 (set (match_operand:SI 0 "gpc_reg_operand" "")
13133 (le:SI (match_dup 1) (match_dup 2)))
13134 (clobber (match_scratch:SI 3 ""))]
13135 "TARGET_POWER && reload_completed"
13136 [(parallel [(set (match_dup 0)
13137 (le:SI (match_dup 1) (match_dup 2)))
13138 (clobber (match_dup 3))])
13139 (set (match_dup 4)
13140 (compare:CC (match_dup 0)
13141 (const_int 0)))]
13142 "")
13143
13144 (define_insn ""
13145 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r")
13146 (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
13147 (match_operand:SI 2 "reg_or_short_operand" "r,O"))
13148 (match_operand:SI 3 "gpc_reg_operand" "r,r")))]
13149 "TARGET_POWER"
13150 "@
13151 doz %0,%2,%1\;{sfi|subfic} %0,%0,0\;{aze|addze} %0,%3
13152 {srai|srawi} %0,%1,31\;{sf|subfc} %0,%1,%0\;{aze|addze} %0,%3"
13153 [(set_attr "length" "12")])
13154
13155 (define_insn ""
13156 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
13157 (compare:CC
13158 (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
13159 (match_operand:SI 2 "reg_or_short_operand" "r,O,r,O"))
13160 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r"))
13161 (const_int 0)))
13162 (clobber (match_scratch:SI 4 "=&r,&r,&r,&r"))]
13163 "TARGET_POWER"
13164 "@
13165 doz %4,%2,%1\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
13166 {srai|srawi} %4,%1,31\;{sf|subfc} %4,%1,%4\;{aze.|addze.} %4,%3
13167 #
13168 #"
13169 [(set_attr "type" "compare")
13170 (set_attr "length" "12,12,16,16")])
13171
13172 (define_split
13173 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
13174 (compare:CC
13175 (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "")
13176 (match_operand:SI 2 "reg_or_short_operand" ""))
13177 (match_operand:SI 3 "gpc_reg_operand" ""))
13178 (const_int 0)))
13179 (clobber (match_scratch:SI 4 ""))]
13180 "TARGET_POWER && reload_completed"
13181 [(set (match_dup 4)
13182 (plus:SI (le:SI (match_dup 1) (match_dup 2))
13183 (match_dup 3)))
13184 (set (match_dup 0)
13185 (compare:CC (match_dup 4)
13186 (const_int 0)))]
13187 "")
13188
13189 (define_insn ""
13190 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,?y,?y")
13191 (compare:CC
13192 (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
13193 (match_operand:SI 2 "reg_or_short_operand" "r,O,r,O"))
13194 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r"))
13195 (const_int 0)))
13196 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r,&r,&r")
13197 (plus:SI (le:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
13198 "TARGET_POWER"
13199 "@
13200 doz %0,%2,%1\;{sfi|subfic} %0,%0,0\;{aze.|addze.} %0,%3
13201 {srai|srawi} %0,%1,31\;{sf|subfc} %0,%1,%0\;{aze.|addze.} %0,%3
13202 #
13203 #"
13204 [(set_attr "type" "compare")
13205 (set_attr "length" "12,12,16,16")])
13206
13207 (define_split
13208 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
13209 (compare:CC
13210 (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "")
13211 (match_operand:SI 2 "reg_or_short_operand" ""))
13212 (match_operand:SI 3 "gpc_reg_operand" ""))
13213 (const_int 0)))
13214 (set (match_operand:SI 0 "gpc_reg_operand" "")
13215 (plus:SI (le:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
13216 "TARGET_POWER && reload_completed"
13217 [(set (match_dup 0)
13218 (plus:SI (le:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
13219 (set (match_dup 4)
13220 (compare:CC (match_dup 0)
13221 (const_int 0)))]
13222 "")
13223
13224 (define_insn ""
13225 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
13226 (neg:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
13227 (match_operand:SI 2 "reg_or_short_operand" "r,O"))))]
13228 "TARGET_POWER"
13229 "@
13230 doz %0,%2,%1\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
13231 {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{srai|srawi} %0,%0,31"
13232 [(set_attr "length" "12")])
13233
13234 (define_insn "*leu<mode>"
13235 [(set (match_operand:P 0 "gpc_reg_operand" "=r")
13236 (leu:P (match_operand:P 1 "gpc_reg_operand" "r")
13237 (match_operand:P 2 "reg_or_short_operand" "rI")))]
13238 ""
13239 "{sf%I2|subf%I2c} %0,%1,%2\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0"
13240 [(set_attr "type" "three")
13241 (set_attr "length" "12")])
13242
13243 (define_insn "*leu<mode>_compare"
13244 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
13245 (compare:CC
13246 (leu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
13247 (match_operand:P 2 "reg_or_short_operand" "rI,rI"))
13248 (const_int 0)))
13249 (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
13250 (leu:P (match_dup 1) (match_dup 2)))]
13251 ""
13252 "@
13253 {sf%I2|subf%I2c} %0,%1,%2\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0
13254 #"
13255 [(set_attr "type" "compare")
13256 (set_attr "length" "12,16")])
13257
13258 (define_split
13259 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
13260 (compare:CC
13261 (leu:P (match_operand:P 1 "gpc_reg_operand" "")
13262 (match_operand:P 2 "reg_or_short_operand" ""))
13263 (const_int 0)))
13264 (set (match_operand:P 0 "gpc_reg_operand" "")
13265 (leu:P (match_dup 1) (match_dup 2)))]
13266 "reload_completed"
13267 [(set (match_dup 0)
13268 (leu:P (match_dup 1) (match_dup 2)))
13269 (set (match_dup 3)
13270 (compare:CC (match_dup 0)
13271 (const_int 0)))]
13272 "")
13273
13274 (define_insn "*plus_leu<mode>"
13275 [(set (match_operand:P 0 "gpc_reg_operand" "=&r")
13276 (plus:P (leu:P (match_operand:P 1 "gpc_reg_operand" "r")
13277 (match_operand:P 2 "reg_or_short_operand" "rI"))
13278 (match_operand:P 3 "gpc_reg_operand" "r")))]
13279 ""
13280 "{sf%I2|subf%I2c} %0,%1,%2\;{aze|addze} %0,%3"
13281 [(set_attr "type" "two")
13282 (set_attr "length" "8")])
13283
13284 (define_insn ""
13285 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
13286 (compare:CC
13287 (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
13288 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
13289 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
13290 (const_int 0)))
13291 (clobber (match_scratch:SI 4 "=&r,&r"))]
13292 "TARGET_32BIT"
13293 "@
13294 {sf%I2|subf%I2c} %4,%1,%2\;{aze.|addze.} %4,%3
13295 #"
13296 [(set_attr "type" "compare")
13297 (set_attr "length" "8,12")])
13298
13299 (define_split
13300 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
13301 (compare:CC
13302 (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "")
13303 (match_operand:SI 2 "reg_or_short_operand" ""))
13304 (match_operand:SI 3 "gpc_reg_operand" ""))
13305 (const_int 0)))
13306 (clobber (match_scratch:SI 4 ""))]
13307 "TARGET_32BIT && reload_completed"
13308 [(set (match_dup 4)
13309 (plus:SI (leu:SI (match_dup 1) (match_dup 2))
13310 (match_dup 3)))
13311 (set (match_dup 0)
13312 (compare:CC (match_dup 4)
13313 (const_int 0)))]
13314 "")
13315
13316 (define_insn ""
13317 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
13318 (compare:CC
13319 (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
13320 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
13321 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
13322 (const_int 0)))
13323 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r")
13324 (plus:SI (leu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
13325 "TARGET_32BIT"
13326 "@
13327 {sf%I2|subf%I2c} %0,%1,%2\;{aze.|addze.} %0,%3
13328 #"
13329 [(set_attr "type" "compare")
13330 (set_attr "length" "8,12")])
13331
13332 (define_split
13333 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
13334 (compare:CC
13335 (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "")
13336 (match_operand:SI 2 "reg_or_short_operand" ""))
13337 (match_operand:SI 3 "gpc_reg_operand" ""))
13338 (const_int 0)))
13339 (set (match_operand:SI 0 "gpc_reg_operand" "")
13340 (plus:SI (leu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
13341 "TARGET_32BIT && reload_completed"
13342 [(set (match_dup 0)
13343 (plus:SI (leu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
13344 (set (match_dup 4)
13345 (compare:CC (match_dup 0)
13346 (const_int 0)))]
13347 "")
13348
13349 (define_insn "*neg_leu<mode>"
13350 [(set (match_operand:P 0 "gpc_reg_operand" "=r")
13351 (neg:P (leu:P (match_operand:P 1 "gpc_reg_operand" "r")
13352 (match_operand:P 2 "reg_or_short_operand" "rI"))))]
13353 ""
13354 "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;nand %0,%0,%0"
13355 [(set_attr "type" "three")
13356 (set_attr "length" "12")])
13357
13358 (define_insn "*and_neg_leu<mode>"
13359 [(set (match_operand:P 0 "gpc_reg_operand" "=&r")
13360 (and:P (neg:P
13361 (leu:P (match_operand:P 1 "gpc_reg_operand" "r")
13362 (match_operand:P 2 "reg_or_short_operand" "rI")))
13363 (match_operand:P 3 "gpc_reg_operand" "r")))]
13364 ""
13365 "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;andc %0,%3,%0"
13366 [(set_attr "type" "three")
13367 (set_attr "length" "12")])
13368
13369 (define_insn ""
13370 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
13371 (compare:CC
13372 (and:SI (neg:SI
13373 (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
13374 (match_operand:SI 2 "reg_or_short_operand" "rI,rI")))
13375 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
13376 (const_int 0)))
13377 (clobber (match_scratch:SI 4 "=&r,&r"))]
13378 "TARGET_32BIT"
13379 "@
13380 {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4
13381 #"
13382 [(set_attr "type" "compare")
13383 (set_attr "length" "12,16")])
13384
13385 (define_split
13386 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
13387 (compare:CC
13388 (and:SI (neg:SI
13389 (leu:SI (match_operand:SI 1 "gpc_reg_operand" "")
13390 (match_operand:SI 2 "reg_or_short_operand" "")))
13391 (match_operand:SI 3 "gpc_reg_operand" ""))
13392 (const_int 0)))
13393 (clobber (match_scratch:SI 4 ""))]
13394 "TARGET_32BIT && reload_completed"
13395 [(set (match_dup 4)
13396 (and:SI (neg:SI (leu:SI (match_dup 1) (match_dup 2)))
13397 (match_dup 3)))
13398 (set (match_dup 0)
13399 (compare:CC (match_dup 4)
13400 (const_int 0)))]
13401 "")
13402
13403 (define_insn ""
13404 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
13405 (compare:CC
13406 (and:SI (neg:SI
13407 (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
13408 (match_operand:SI 2 "reg_or_short_operand" "rI,rI")))
13409 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
13410 (const_int 0)))
13411 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r")
13412 (and:SI (neg:SI (leu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))]
13413 "TARGET_32BIT"
13414 "@
13415 {sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;andc. %0,%3,%0
13416 #"
13417 [(set_attr "type" "compare")
13418 (set_attr "length" "12,16")])
13419
13420 (define_split
13421 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
13422 (compare:CC
13423 (and:SI (neg:SI
13424 (leu:SI (match_operand:SI 1 "gpc_reg_operand" "")
13425 (match_operand:SI 2 "reg_or_short_operand" "")))
13426 (match_operand:SI 3 "gpc_reg_operand" ""))
13427 (const_int 0)))
13428 (set (match_operand:SI 0 "gpc_reg_operand" "")
13429 (and:SI (neg:SI (leu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))]
13430 "TARGET_32BIT && reload_completed"
13431 [(set (match_dup 0)
13432 (and:SI (neg:SI (leu:SI (match_dup 1) (match_dup 2)))
13433 (match_dup 3)))
13434 (set (match_dup 4)
13435 (compare:CC (match_dup 0)
13436 (const_int 0)))]
13437 "")
13438
13439 (define_insn ""
13440 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
13441 (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
13442 (match_operand:SI 2 "reg_or_short_operand" "rI")))]
13443 "TARGET_POWER"
13444 "doz%I2 %0,%1,%2\;nabs %0,%0\;{sri|srwi} %0,%0,31"
13445 [(set_attr "length" "12")])
13446
13447 (define_insn ""
13448 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
13449 (compare:CC
13450 (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
13451 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
13452 (const_int 0)))
13453 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
13454 (lt:SI (match_dup 1) (match_dup 2)))]
13455 "TARGET_POWER"
13456 "@
13457 doz%I2 %0,%1,%2\;nabs %0,%0\;{sri.|srwi.} %0,%0,31
13458 #"
13459 [(set_attr "type" "delayed_compare")
13460 (set_attr "length" "12,16")])
13461
13462 (define_split
13463 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
13464 (compare:CC
13465 (lt:SI (match_operand:SI 1 "gpc_reg_operand" "")
13466 (match_operand:SI 2 "reg_or_short_operand" ""))
13467 (const_int 0)))
13468 (set (match_operand:SI 0 "gpc_reg_operand" "")
13469 (lt:SI (match_dup 1) (match_dup 2)))]
13470 "TARGET_POWER && reload_completed"
13471 [(set (match_dup 0)
13472 (lt:SI (match_dup 1) (match_dup 2)))
13473 (set (match_dup 3)
13474 (compare:CC (match_dup 0)
13475 (const_int 0)))]
13476 "")
13477
13478 (define_insn ""
13479 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r")
13480 (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
13481 (match_operand:SI 2 "reg_or_short_operand" "rI"))
13482 (match_operand:SI 3 "gpc_reg_operand" "r")))]
13483 "TARGET_POWER"
13484 "doz%I2 %0,%1,%2\;{ai|addic} %0,%0,-1\;{aze|addze} %0,%3"
13485 [(set_attr "length" "12")])
13486
13487 (define_insn ""
13488 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
13489 (compare:CC
13490 (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
13491 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
13492 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
13493 (const_int 0)))
13494 (clobber (match_scratch:SI 4 "=&r,&r"))]
13495 "TARGET_POWER"
13496 "@
13497 doz%I2 %4,%1,%2\;{ai|addic} %4,%4,-1\;{aze.|addze.} %4,%3
13498 #"
13499 [(set_attr "type" "compare")
13500 (set_attr "length" "12,16")])
13501
13502 (define_split
13503 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
13504 (compare:CC
13505 (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "")
13506 (match_operand:SI 2 "reg_or_short_operand" ""))
13507 (match_operand:SI 3 "gpc_reg_operand" ""))
13508 (const_int 0)))
13509 (clobber (match_scratch:SI 4 ""))]
13510 "TARGET_POWER && reload_completed"
13511 [(set (match_dup 4)
13512 (plus:SI (lt:SI (match_dup 1) (match_dup 2))
13513 (match_dup 3)))
13514 (set (match_dup 0)
13515 (compare:CC (match_dup 4)
13516 (const_int 0)))]
13517 "")
13518
13519 (define_insn ""
13520 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
13521 (compare:CC
13522 (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
13523 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
13524 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
13525 (const_int 0)))
13526 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r")
13527 (plus:SI (lt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
13528 "TARGET_POWER"
13529 "@
13530 doz%I2 %0,%1,%2\;{ai|addic} %0,%0,-1\;{aze.|addze.} %0,%3
13531 #"
13532 [(set_attr "type" "compare")
13533 (set_attr "length" "12,16")])
13534
13535 (define_split
13536 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
13537 (compare:CC
13538 (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "")
13539 (match_operand:SI 2 "reg_or_short_operand" ""))
13540 (match_operand:SI 3 "gpc_reg_operand" ""))
13541 (const_int 0)))
13542 (set (match_operand:SI 0 "gpc_reg_operand" "")
13543 (plus:SI (lt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
13544 "TARGET_POWER && reload_completed"
13545 [(set (match_dup 0)
13546 (plus:SI (lt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
13547 (set (match_dup 4)
13548 (compare:CC (match_dup 0)
13549 (const_int 0)))]
13550 "")
13551
13552 (define_insn ""
13553 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
13554 (neg:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
13555 (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
13556 "TARGET_POWER"
13557 "doz%I2 %0,%1,%2\;nabs %0,%0\;{srai|srawi} %0,%0,31"
13558 [(set_attr "length" "12")])
13559
13560 (define_insn_and_split "*ltu<mode>"
13561 [(set (match_operand:P 0 "gpc_reg_operand" "=r,r")
13562 (ltu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
13563 (match_operand:P 2 "reg_or_neg_short_operand" "r,P")))]
13564 ""
13565 "#"
13566 ""
13567 [(set (match_dup 0) (neg:P (ltu:P (match_dup 1) (match_dup 2))))
13568 (set (match_dup 0) (neg:P (match_dup 0)))]
13569 "")
13570
13571 (define_insn_and_split "*ltu<mode>_compare"
13572 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
13573 (compare:CC
13574 (ltu:P (match_operand:P 1 "gpc_reg_operand" "r,r,r,r")
13575 (match_operand:P 2 "reg_or_neg_short_operand" "r,P,r,P"))
13576 (const_int 0)))
13577 (set (match_operand:P 0 "gpc_reg_operand" "=r,r,r,r")
13578 (ltu:P (match_dup 1) (match_dup 2)))]
13579 ""
13580 "#"
13581 ""
13582 [(set (match_dup 0) (neg:P (ltu:P (match_dup 1) (match_dup 2))))
13583 (parallel [(set (match_dup 3)
13584 (compare:CC (neg:P (match_dup 0)) (const_int 0)))
13585 (set (match_dup 0) (neg:P (match_dup 0)))])]
13586 "")
13587
13588 (define_insn_and_split "*plus_ltu<mode>"
13589 [(set (match_operand:P 0 "gpc_reg_operand" "=&r,r")
13590 (plus:P (ltu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
13591 (match_operand:P 2 "reg_or_neg_short_operand" "r,P"))
13592 (match_operand:P 3 "reg_or_short_operand" "rI,rI")))]
13593 ""
13594 "#"
13595 "&& !reg_overlap_mentioned_p (operands[0], operands[3])"
13596 [(set (match_dup 0) (neg:P (ltu:P (match_dup 1) (match_dup 2))))
13597 (set (match_dup 0) (minus:P (match_dup 3) (match_dup 0)))]
13598 "")
13599
13600 (define_insn_and_split "*plus_ltu<mode>_compare"
13601 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,?y,?y")
13602 (compare:CC
13603 (plus:P (ltu:P (match_operand:P 1 "gpc_reg_operand" "r,r,r,r")
13604 (match_operand:P 2 "reg_or_neg_short_operand" "r,P,r,P"))
13605 (match_operand:P 3 "gpc_reg_operand" "r,r,r,r"))
13606 (const_int 0)))
13607 (set (match_operand:P 0 "gpc_reg_operand" "=&r,&r,&r,&r")
13608 (plus:P (ltu:P (match_dup 1) (match_dup 2)) (match_dup 3)))]
13609 ""
13610 "#"
13611 "&& !reg_overlap_mentioned_p (operands[0], operands[3])"
13612 [(set (match_dup 0) (neg:P (ltu:P (match_dup 1) (match_dup 2))))
13613 (parallel [(set (match_dup 4)
13614 (compare:CC (minus:P (match_dup 3) (match_dup 0))
13615 (const_int 0)))
13616 (set (match_dup 0) (minus:P (match_dup 3) (match_dup 0)))])]
13617 "")
13618
13619 (define_insn "*neg_ltu<mode>"
13620 [(set (match_operand:P 0 "gpc_reg_operand" "=r,r")
13621 (neg:P (ltu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
13622 (match_operand:P 2 "reg_or_neg_short_operand" "r,P"))))]
13623 ""
13624 "@
13625 {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0
13626 {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0"
13627 [(set_attr "type" "two")
13628 (set_attr "length" "8")])
13629
13630 (define_insn ""
13631 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
13632 (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
13633 (match_operand:SI 2 "reg_or_short_operand" "rI")))
13634 (clobber (match_scratch:SI 3 "=r"))]
13635 "TARGET_POWER"
13636 "doz%I2 %3,%1,%2\;{sfi|subfic} %0,%3,0\;{ae|adde} %0,%0,%3"
13637 [(set_attr "length" "12")])
13638
13639 (define_insn ""
13640 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
13641 (compare:CC
13642 (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
13643 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
13644 (const_int 0)))
13645 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
13646 (ge:SI (match_dup 1) (match_dup 2)))
13647 (clobber (match_scratch:SI 3 "=r,r"))]
13648 "TARGET_POWER"
13649 "@
13650 doz%I2 %3,%1,%2\;{sfi|subfic} %0,%3,0\;{ae.|adde.} %0,%0,%3
13651 #"
13652 [(set_attr "type" "compare")
13653 (set_attr "length" "12,16")])
13654
13655 (define_split
13656 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
13657 (compare:CC
13658 (ge:SI (match_operand:SI 1 "gpc_reg_operand" "")
13659 (match_operand:SI 2 "reg_or_short_operand" ""))
13660 (const_int 0)))
13661 (set (match_operand:SI 0 "gpc_reg_operand" "")
13662 (ge:SI (match_dup 1) (match_dup 2)))
13663 (clobber (match_scratch:SI 3 ""))]
13664 "TARGET_POWER && reload_completed"
13665 [(parallel [(set (match_dup 0)
13666 (ge:SI (match_dup 1) (match_dup 2)))
13667 (clobber (match_dup 3))])
13668 (set (match_dup 4)
13669 (compare:CC (match_dup 0)
13670 (const_int 0)))]
13671 "")
13672
13673 (define_insn ""
13674 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r")
13675 (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
13676 (match_operand:SI 2 "reg_or_short_operand" "rI"))
13677 (match_operand:SI 3 "gpc_reg_operand" "r")))]
13678 "TARGET_POWER"
13679 "doz%I2 %0,%1,%2\;{sfi|subfic} %0,%0,0\;{aze|addze} %0,%3"
13680 [(set_attr "length" "12")])
13681
13682 (define_insn ""
13683 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
13684 (compare:CC
13685 (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
13686 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
13687 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
13688 (const_int 0)))
13689 (clobber (match_scratch:SI 4 "=&r,&r"))]
13690 "TARGET_POWER"
13691 "@
13692 doz%I2 %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
13693 #"
13694 [(set_attr "type" "compare")
13695 (set_attr "length" "12,16")])
13696
13697 (define_split
13698 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
13699 (compare:CC
13700 (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "")
13701 (match_operand:SI 2 "reg_or_short_operand" ""))
13702 (match_operand:SI 3 "gpc_reg_operand" ""))
13703 (const_int 0)))
13704 (clobber (match_scratch:SI 4 ""))]
13705 "TARGET_POWER && reload_completed"
13706 [(set (match_dup 4)
13707 (plus:SI (ge:SI (match_dup 1) (match_dup 2))
13708 (match_dup 3)))
13709 (set (match_dup 0)
13710 (compare:CC (match_dup 4)
13711 (const_int 0)))]
13712 "")
13713
13714 (define_insn ""
13715 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
13716 (compare:CC
13717 (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
13718 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
13719 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
13720 (const_int 0)))
13721 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r")
13722 (plus:SI (ge:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
13723 "TARGET_POWER"
13724 "@
13725 doz%I2 %0,%1,%2\;{sfi|subfic} %0,%0,0\;{aze.|addze.} %0,%3
13726 #"
13727 [(set_attr "type" "compare")
13728 (set_attr "length" "12,16")])
13729
13730 (define_split
13731 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
13732 (compare:CC
13733 (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "")
13734 (match_operand:SI 2 "reg_or_short_operand" ""))
13735 (match_operand:SI 3 "gpc_reg_operand" ""))
13736 (const_int 0)))
13737 (set (match_operand:SI 0 "gpc_reg_operand" "")
13738 (plus:SI (ge:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
13739 "TARGET_POWER && reload_completed"
13740 [(set (match_dup 0)
13741 (plus:SI (ge:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
13742 (set (match_dup 4)
13743 (compare:CC (match_dup 0)
13744 (const_int 0)))]
13745 "")
13746
13747 (define_insn ""
13748 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
13749 (neg:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
13750 (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
13751 "TARGET_POWER"
13752 "doz%I2 %0,%1,%2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0"
13753 [(set_attr "length" "12")])
13754
13755 (define_insn "*geu<mode>"
13756 [(set (match_operand:P 0 "gpc_reg_operand" "=r,r")
13757 (geu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
13758 (match_operand:P 2 "reg_or_neg_short_operand" "r,P")))]
13759 ""
13760 "@
13761 {sf|subfc} %0,%2,%1\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0
13762 {ai|addic} %0,%1,%n2\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0"
13763 [(set_attr "type" "three")
13764 (set_attr "length" "12")])
13765
13766 (define_insn "*geu<mode>_compare"
13767 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
13768 (compare:CC
13769 (geu:P (match_operand:P 1 "gpc_reg_operand" "r,r,r,r")
13770 (match_operand:P 2 "reg_or_neg_short_operand" "r,P,r,P"))
13771 (const_int 0)))
13772 (set (match_operand:P 0 "gpc_reg_operand" "=r,r,r,r")
13773 (geu:P (match_dup 1) (match_dup 2)))]
13774 ""
13775 "@
13776 {sf|subfc} %0,%2,%1\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0
13777 {ai|addic} %0,%1,%n2\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0
13778 #
13779 #"
13780 [(set_attr "type" "compare")
13781 (set_attr "length" "12,12,16,16")])
13782
13783 (define_split
13784 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
13785 (compare:CC
13786 (geu:P (match_operand:P 1 "gpc_reg_operand" "")
13787 (match_operand:P 2 "reg_or_neg_short_operand" ""))
13788 (const_int 0)))
13789 (set (match_operand:P 0 "gpc_reg_operand" "")
13790 (geu:P (match_dup 1) (match_dup 2)))]
13791 "reload_completed"
13792 [(set (match_dup 0)
13793 (geu:P (match_dup 1) (match_dup 2)))
13794 (set (match_dup 3)
13795 (compare:CC (match_dup 0)
13796 (const_int 0)))]
13797 "")
13798
13799 (define_insn "*plus_geu<mode>"
13800 [(set (match_operand:P 0 "gpc_reg_operand" "=&r,&r")
13801 (plus:P (geu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
13802 (match_operand:P 2 "reg_or_neg_short_operand" "r,P"))
13803 (match_operand:P 3 "gpc_reg_operand" "r,r")))]
13804 ""
13805 "@
13806 {sf|subfc} %0,%2,%1\;{aze|addze} %0,%3
13807 {ai|addic} %0,%1,%n2\;{aze|addze} %0,%3"
13808 [(set_attr "type" "two")
13809 (set_attr "length" "8")])
13810
13811 (define_insn ""
13812 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
13813 (compare:CC
13814 (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
13815 (match_operand:SI 2 "reg_or_neg_short_operand" "r,P,r,P"))
13816 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r"))
13817 (const_int 0)))
13818 (clobber (match_scratch:SI 4 "=&r,&r,&r,&r"))]
13819 "TARGET_32BIT"
13820 "@
13821 {sf|subfc} %4,%2,%1\;{aze.|addze.} %4,%3
13822 {ai|addic} %4,%1,%n2\;{aze.|addze.} %4,%3
13823 #
13824 #"
13825 [(set_attr "type" "compare")
13826 (set_attr "length" "8,8,12,12")])
13827
13828 (define_split
13829 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
13830 (compare:CC
13831 (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "")
13832 (match_operand:SI 2 "reg_or_neg_short_operand" ""))
13833 (match_operand:SI 3 "gpc_reg_operand" ""))
13834 (const_int 0)))
13835 (clobber (match_scratch:SI 4 ""))]
13836 "TARGET_32BIT && reload_completed"
13837 [(set (match_dup 4)
13838 (plus:SI (geu:SI (match_dup 1) (match_dup 2))
13839 (match_dup 3)))
13840 (set (match_dup 0)
13841 (compare:CC (match_dup 4)
13842 (const_int 0)))]
13843 "")
13844
13845 (define_insn ""
13846 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,?y,?y")
13847 (compare:CC
13848 (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
13849 (match_operand:SI 2 "reg_or_neg_short_operand" "r,P,r,P"))
13850 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r"))
13851 (const_int 0)))
13852 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r,&r,&r")
13853 (plus:SI (geu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
13854 "TARGET_32BIT"
13855 "@
13856 {sf|subfc} %0,%2,%1\;{aze.|addze.} %0,%3
13857 {ai|addic} %0,%1,%n2\;{aze.|addze.} %0,%3
13858 #
13859 #"
13860 [(set_attr "type" "compare")
13861 (set_attr "length" "8,8,12,12")])
13862
13863 (define_split
13864 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
13865 (compare:CC
13866 (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "")
13867 (match_operand:SI 2 "reg_or_neg_short_operand" ""))
13868 (match_operand:SI 3 "gpc_reg_operand" ""))
13869 (const_int 0)))
13870 (set (match_operand:SI 0 "gpc_reg_operand" "")
13871 (plus:SI (geu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
13872 "TARGET_32BIT && reload_completed"
13873 [(set (match_dup 0)
13874 (plus:SI (geu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
13875 (set (match_dup 4)
13876 (compare:CC (match_dup 0)
13877 (const_int 0)))]
13878 "")
13879
13880 (define_insn "*neg_geu<mode>"
13881 [(set (match_operand:P 0 "gpc_reg_operand" "=r,r")
13882 (neg:P (geu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
13883 (match_operand:P 2 "reg_or_short_operand" "r,I"))))]
13884 ""
13885 "@
13886 {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;nand %0,%0,%0
13887 {sfi|subfic} %0,%1,-1\;{a%I2|add%I2c} %0,%0,%2\;{sfe|subfe} %0,%0,%0"
13888 [(set_attr "type" "three")
13889 (set_attr "length" "12")])
13890
13891 (define_insn "*and_neg_geu<mode>"
13892 [(set (match_operand:P 0 "gpc_reg_operand" "=&r,&r")
13893 (and:P (neg:P
13894 (geu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
13895 (match_operand:P 2 "reg_or_neg_short_operand" "r,P")))
13896 (match_operand:P 3 "gpc_reg_operand" "r,r")))]
13897 ""
13898 "@
13899 {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;andc %0,%3,%0
13900 {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0\;andc %0,%3,%0"
13901 [(set_attr "type" "three")
13902 (set_attr "length" "12")])
13903
13904 (define_insn ""
13905 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
13906 (compare:CC
13907 (and:SI (neg:SI
13908 (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
13909 (match_operand:SI 2 "reg_or_neg_short_operand" "r,P,r,P")))
13910 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r"))
13911 (const_int 0)))
13912 (clobber (match_scratch:SI 4 "=&r,&r,&r,&r"))]
13913 "TARGET_32BIT"
13914 "@
13915 {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4
13916 {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4
13917 #
13918 #"
13919 [(set_attr "type" "compare")
13920 (set_attr "length" "12,12,16,16")])
13921
13922 (define_split
13923 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
13924 (compare:CC
13925 (and:SI (neg:SI
13926 (geu:SI (match_operand:SI 1 "gpc_reg_operand" "")
13927 (match_operand:SI 2 "reg_or_neg_short_operand" "")))
13928 (match_operand:SI 3 "gpc_reg_operand" ""))
13929 (const_int 0)))
13930 (clobber (match_scratch:SI 4 ""))]
13931 "TARGET_32BIT && reload_completed"
13932 [(set (match_dup 4)
13933 (and:SI (neg:SI (geu:SI (match_dup 1) (match_dup 2)))
13934 (match_dup 3)))
13935 (set (match_dup 0)
13936 (compare:CC (match_dup 4)
13937 (const_int 0)))]
13938 "")
13939
13940 (define_insn ""
13941 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,?y,?y")
13942 (compare:CC
13943 (and:SI (neg:SI
13944 (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
13945 (match_operand:SI 2 "reg_or_neg_short_operand" "r,P,r,P")))
13946 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r"))
13947 (const_int 0)))
13948 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r,&r,&r")
13949 (and:SI (neg:SI (geu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))]
13950 "TARGET_32BIT"
13951 "@
13952 {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;andc. %0,%3,%0
13953 {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0\;andc. %0,%3,%0
13954 #
13955 #"
13956 [(set_attr "type" "compare")
13957 (set_attr "length" "12,12,16,16")])
13958
13959 (define_split
13960 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
13961 (compare:CC
13962 (and:SI (neg:SI
13963 (geu:SI (match_operand:SI 1 "gpc_reg_operand" "")
13964 (match_operand:SI 2 "reg_or_neg_short_operand" "")))
13965 (match_operand:SI 3 "gpc_reg_operand" ""))
13966 (const_int 0)))
13967 (set (match_operand:SI 0 "gpc_reg_operand" "")
13968 (and:SI (neg:SI (geu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))]
13969 "TARGET_32BIT && reload_completed"
13970 [(set (match_dup 0)
13971 (and:SI (neg:SI (geu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))
13972 (set (match_dup 4)
13973 (compare:CC (match_dup 0)
13974 (const_int 0)))]
13975 "")
13976
13977 (define_insn ""
13978 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
13979 (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
13980 (match_operand:SI 2 "reg_or_short_operand" "r")))]
13981 "TARGET_POWER"
13982 "doz %0,%2,%1\;nabs %0,%0\;{sri|srwi} %0,%0,31"
13983 [(set_attr "length" "12")])
13984
13985 (define_insn ""
13986 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
13987 (compare:CC
13988 (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
13989 (match_operand:SI 2 "reg_or_short_operand" "r,r"))
13990 (const_int 0)))
13991 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
13992 (gt:SI (match_dup 1) (match_dup 2)))]
13993 "TARGET_POWER"
13994 "@
13995 doz %0,%2,%1\;nabs %0,%0\;{sri.|srwi.} %0,%0,31
13996 #"
13997 [(set_attr "type" "delayed_compare")
13998 (set_attr "length" "12,16")])
13999
14000 (define_split
14001 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
14002 (compare:CC
14003 (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
14004 (match_operand:SI 2 "reg_or_short_operand" ""))
14005 (const_int 0)))
14006 (set (match_operand:SI 0 "gpc_reg_operand" "")
14007 (gt:SI (match_dup 1) (match_dup 2)))]
14008 "TARGET_POWER && reload_completed"
14009 [(set (match_dup 0)
14010 (gt:SI (match_dup 1) (match_dup 2)))
14011 (set (match_dup 3)
14012 (compare:CC (match_dup 0)
14013 (const_int 0)))]
14014 "")
14015
14016 (define_insn "*plus_gt0<mode>"
14017 [(set (match_operand:P 0 "gpc_reg_operand" "=&r")
14018 (plus:P (gt:P (match_operand:P 1 "gpc_reg_operand" "r")
14019 (const_int 0))
14020 (match_operand:P 2 "gpc_reg_operand" "r")))]
14021 ""
14022 "{a|addc} %0,%1,%1\;{sfe|subfe} %0,%1,%0\;{aze|addze} %0,%2"
14023 [(set_attr "type" "three")
14024 (set_attr "length" "12")])
14025
14026 (define_insn ""
14027 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
14028 (compare:CC
14029 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
14030 (const_int 0))
14031 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
14032 (const_int 0)))
14033 (clobber (match_scratch:SI 3 "=&r,&r"))]
14034 "TARGET_32BIT"
14035 "@
14036 {a|addc} %3,%1,%1\;{sfe|subfe} %3,%1,%3\;{aze.|addze.} %3,%2
14037 #"
14038 [(set_attr "type" "compare")
14039 (set_attr "length" "12,16")])
14040
14041 (define_split
14042 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
14043 (compare:CC
14044 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
14045 (const_int 0))
14046 (match_operand:SI 2 "gpc_reg_operand" ""))
14047 (const_int 0)))
14048 (clobber (match_scratch:SI 3 ""))]
14049 "TARGET_32BIT && reload_completed"
14050 [(set (match_dup 3)
14051 (plus:SI (gt:SI (match_dup 1) (const_int 0))
14052 (match_dup 2)))
14053 (set (match_dup 0)
14054 (compare:CC (match_dup 3)
14055 (const_int 0)))]
14056 "")
14057
14058 (define_insn ""
14059 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
14060 (compare:CC
14061 (plus:DI (gt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
14062 (const_int 0))
14063 (match_operand:DI 2 "gpc_reg_operand" "r,r"))
14064 (const_int 0)))
14065 (clobber (match_scratch:DI 3 "=&r,&r"))]
14066 "TARGET_64BIT"
14067 "@
14068 addc %3,%1,%1\;subfe %3,%1,%3\;addze. %3,%2
14069 #"
14070 [(set_attr "type" "compare")
14071 (set_attr "length" "12,16")])
14072
14073 (define_split
14074 [(set (match_operand:CC 0 "cc_reg_not_micro_cr0_operand" "")
14075 (compare:CC
14076 (plus:DI (gt:DI (match_operand:DI 1 "gpc_reg_operand" "")
14077 (const_int 0))
14078 (match_operand:DI 2 "gpc_reg_operand" ""))
14079 (const_int 0)))
14080 (clobber (match_scratch:DI 3 ""))]
14081 "TARGET_64BIT && reload_completed"
14082 [(set (match_dup 3)
14083 (plus:DI (gt:DI (match_dup 1) (const_int 0))
14084 (match_dup 2)))
14085 (set (match_dup 0)
14086 (compare:CC (match_dup 3)
14087 (const_int 0)))]
14088 "")
14089
14090 (define_insn ""
14091 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
14092 (compare:CC
14093 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
14094 (const_int 0))
14095 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
14096 (const_int 0)))
14097 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r")
14098 (plus:SI (gt:SI (match_dup 1) (const_int 0)) (match_dup 2)))]
14099 "TARGET_32BIT"
14100 "@
14101 {a|addc} %0,%1,%1\;{sfe|subfe} %0,%1,%0\;{aze.|addze.} %0,%2
14102 #"
14103 [(set_attr "type" "compare")
14104 (set_attr "length" "12,16")])
14105
14106 (define_split
14107 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
14108 (compare:CC
14109 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
14110 (const_int 0))
14111 (match_operand:SI 2 "gpc_reg_operand" ""))
14112 (const_int 0)))
14113 (set (match_operand:SI 0 "gpc_reg_operand" "")
14114 (plus:SI (gt:SI (match_dup 1) (const_int 0)) (match_dup 2)))]
14115 "TARGET_32BIT && reload_completed"
14116 [(set (match_dup 0)
14117 (plus:SI (gt:SI (match_dup 1) (const_int 0)) (match_dup 2)))
14118 (set (match_dup 3)
14119 (compare:CC (match_dup 0)
14120 (const_int 0)))]
14121 "")
14122
14123 (define_insn ""
14124 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
14125 (compare:CC
14126 (plus:DI (gt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
14127 (const_int 0))
14128 (match_operand:DI 2 "gpc_reg_operand" "r,r"))
14129 (const_int 0)))
14130 (set (match_operand:DI 0 "gpc_reg_operand" "=&r,&r")
14131 (plus:DI (gt:DI (match_dup 1) (const_int 0)) (match_dup 2)))]
14132 "TARGET_64BIT"
14133 "@
14134 addc %0,%1,%1\;subfe %0,%1,%0\;addze. %0,%2
14135 #"
14136 [(set_attr "type" "compare")
14137 (set_attr "length" "12,16")])
14138
14139 (define_split
14140 [(set (match_operand:CC 3 "cc_reg_not_micro_cr0_operand" "")
14141 (compare:CC
14142 (plus:DI (gt:DI (match_operand:DI 1 "gpc_reg_operand" "")
14143 (const_int 0))
14144 (match_operand:DI 2 "gpc_reg_operand" ""))
14145 (const_int 0)))
14146 (set (match_operand:DI 0 "gpc_reg_operand" "")
14147 (plus:DI (gt:DI (match_dup 1) (const_int 0)) (match_dup 2)))]
14148 "TARGET_64BIT && reload_completed"
14149 [(set (match_dup 0)
14150 (plus:DI (gt:DI (match_dup 1) (const_int 0)) (match_dup 2)))
14151 (set (match_dup 3)
14152 (compare:CC (match_dup 0)
14153 (const_int 0)))]
14154 "")
14155
14156 (define_insn ""
14157 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r")
14158 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
14159 (match_operand:SI 2 "reg_or_short_operand" "r"))
14160 (match_operand:SI 3 "gpc_reg_operand" "r")))]
14161 "TARGET_POWER"
14162 "doz %0,%2,%1\;{ai|addic} %0,%0,-1\;{aze|addze} %0,%3"
14163 [(set_attr "length" "12")])
14164
14165 (define_insn ""
14166 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
14167 (compare:CC
14168 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
14169 (match_operand:SI 2 "reg_or_short_operand" "r,r"))
14170 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
14171 (const_int 0)))
14172 (clobber (match_scratch:SI 4 "=&r,&r"))]
14173 "TARGET_POWER"
14174 "@
14175 doz %4,%2,%1\;{ai|addic} %4,%4,-1\;{aze.|addze.} %4,%3
14176 #"
14177 [(set_attr "type" "compare")
14178 (set_attr "length" "12,16")])
14179
14180 (define_split
14181 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
14182 (compare:CC
14183 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
14184 (match_operand:SI 2 "reg_or_short_operand" ""))
14185 (match_operand:SI 3 "gpc_reg_operand" ""))
14186 (const_int 0)))
14187 (clobber (match_scratch:SI 4 ""))]
14188 "TARGET_POWER && reload_completed"
14189 [(set (match_dup 4)
14190 (plus:SI (gt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
14191 (set (match_dup 0)
14192 (compare:CC (match_dup 4)
14193 (const_int 0)))]
14194 "")
14195
14196 (define_insn ""
14197 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
14198 (compare:CC
14199 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
14200 (match_operand:SI 2 "reg_or_short_operand" "r,r"))
14201 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
14202 (const_int 0)))
14203 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r")
14204 (plus:SI (gt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
14205 "TARGET_POWER"
14206 "@
14207 doz %0,%2,%1\;{ai|addic} %0,%0,-1\;{aze.|addze.} %0,%3
14208 #"
14209 [(set_attr "type" "compare")
14210 (set_attr "length" "12,16")])
14211
14212 (define_split
14213 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
14214 (compare:CC
14215 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
14216 (match_operand:SI 2 "reg_or_short_operand" ""))
14217 (match_operand:SI 3 "gpc_reg_operand" ""))
14218 (const_int 0)))
14219 (set (match_operand:SI 0 "gpc_reg_operand" "")
14220 (plus:SI (gt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
14221 "TARGET_POWER && reload_completed"
14222 [(set (match_dup 0)
14223 (plus:SI (gt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
14224 (set (match_dup 4)
14225 (compare:CC (match_dup 0)
14226 (const_int 0)))]
14227 "")
14228
14229 (define_insn ""
14230 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
14231 (neg:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
14232 (match_operand:SI 2 "reg_or_short_operand" "r"))))]
14233 "TARGET_POWER"
14234 "doz %0,%2,%1\;nabs %0,%0\;{srai|srawi} %0,%0,31"
14235 [(set_attr "length" "12")])
14236
14237 (define_insn_and_split "*gtu<mode>"
14238 [(set (match_operand:P 0 "gpc_reg_operand" "=r")
14239 (gtu:P (match_operand:P 1 "gpc_reg_operand" "r")
14240 (match_operand:P 2 "reg_or_short_operand" "rI")))]
14241 ""
14242 "#"
14243 ""
14244 [(set (match_dup 0) (neg:P (gtu:P (match_dup 1) (match_dup 2))))
14245 (set (match_dup 0) (neg:P (match_dup 0)))]
14246 "")
14247
14248 (define_insn_and_split "*gtu<mode>_compare"
14249 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
14250 (compare:CC
14251 (gtu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
14252 (match_operand:P 2 "reg_or_short_operand" "rI,rI"))
14253 (const_int 0)))
14254 (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
14255 (gtu:P (match_dup 1) (match_dup 2)))]
14256 ""
14257 "#"
14258 ""
14259 [(set (match_dup 0) (neg:P (gtu:P (match_dup 1) (match_dup 2))))
14260 (parallel [(set (match_dup 3)
14261 (compare:CC (neg:P (match_dup 0)) (const_int 0)))
14262 (set (match_dup 0) (neg:P (match_dup 0)))])]
14263 "")
14264
14265 (define_insn_and_split "*plus_gtu<mode>"
14266 [(set (match_operand:P 0 "gpc_reg_operand" "=&r")
14267 (plus:P (gtu:P (match_operand:P 1 "gpc_reg_operand" "r")
14268 (match_operand:P 2 "reg_or_short_operand" "rI"))
14269 (match_operand:P 3 "reg_or_short_operand" "rI")))]
14270 ""
14271 "#"
14272 "&& !reg_overlap_mentioned_p (operands[0], operands[3])"
14273 [(set (match_dup 0) (neg:P (gtu:P (match_dup 1) (match_dup 2))))
14274 (set (match_dup 0) (minus:P (match_dup 3) (match_dup 0)))]
14275 "")
14276
14277 (define_insn_and_split "*plus_gtu<mode>_compare"
14278 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,?y,?y")
14279 (compare:CC
14280 (plus:P (gtu:P (match_operand:P 1 "gpc_reg_operand" "r,r,r,r")
14281 (match_operand:P 2 "reg_or_short_operand" "I,r,I,r"))
14282 (match_operand:P 3 "gpc_reg_operand" "r,r,r,r"))
14283 (const_int 0)))
14284 (set (match_operand:P 0 "gpc_reg_operand" "=&r,&r,&r,&r")
14285 (plus:P (gtu:P (match_dup 1) (match_dup 2)) (match_dup 3)))]
14286 ""
14287 "#"
14288 "&& !reg_overlap_mentioned_p (operands[0], operands[3])"
14289 [(set (match_dup 0) (neg:P (gtu:P (match_dup 1) (match_dup 2))))
14290 (parallel [(set (match_dup 4)
14291 (compare:CC (minus:P (match_dup 3) (match_dup 0))
14292 (const_int 0)))
14293 (set (match_dup 0) (minus:P (match_dup 3) (match_dup 0)))])]
14294 "")
14295
14296 (define_insn "*neg_gtu<mode>"
14297 [(set (match_operand:P 0 "gpc_reg_operand" "=r")
14298 (neg:P (gtu:P (match_operand:P 1 "gpc_reg_operand" "r")
14299 (match_operand:P 2 "reg_or_short_operand" "rI"))))]
14300 ""
14301 "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0"
14302 [(set_attr "type" "two")
14303 (set_attr "length" "8")])
14304
14305 \f
14306 ;; Define both directions of branch and return. If we need a reload
14307 ;; register, we'd rather use CR0 since it is much easier to copy a
14308 ;; register CC value to there.
14309
14310 (define_insn ""
14311 [(set (pc)
14312 (if_then_else (match_operator 1 "branch_comparison_operator"
14313 [(match_operand 2
14314 "cc_reg_operand" "y")
14315 (const_int 0)])
14316 (label_ref (match_operand 0 "" ""))
14317 (pc)))]
14318 ""
14319 "*
14320 {
14321 return output_cbranch (operands[1], \"%l0\", 0, insn);
14322 }"
14323 [(set_attr "type" "branch")])
14324
14325 (define_insn ""
14326 [(set (pc)
14327 (if_then_else (match_operator 0 "branch_comparison_operator"
14328 [(match_operand 1
14329 "cc_reg_operand" "y")
14330 (const_int 0)])
14331 (return)
14332 (pc)))]
14333 "direct_return ()"
14334 "*
14335 {
14336 return output_cbranch (operands[0], NULL, 0, insn);
14337 }"
14338 [(set_attr "type" "jmpreg")
14339 (set_attr "length" "4")])
14340
14341 (define_insn ""
14342 [(set (pc)
14343 (if_then_else (match_operator 1 "branch_comparison_operator"
14344 [(match_operand 2
14345 "cc_reg_operand" "y")
14346 (const_int 0)])
14347 (pc)
14348 (label_ref (match_operand 0 "" ""))))]
14349 ""
14350 "*
14351 {
14352 return output_cbranch (operands[1], \"%l0\", 1, insn);
14353 }"
14354 [(set_attr "type" "branch")])
14355
14356 (define_insn ""
14357 [(set (pc)
14358 (if_then_else (match_operator 0 "branch_comparison_operator"
14359 [(match_operand 1
14360 "cc_reg_operand" "y")
14361 (const_int 0)])
14362 (pc)
14363 (return)))]
14364 "direct_return ()"
14365 "*
14366 {
14367 return output_cbranch (operands[0], NULL, 1, insn);
14368 }"
14369 [(set_attr "type" "jmpreg")
14370 (set_attr "length" "4")])
14371
14372 ;; Logic on condition register values.
14373
14374 ; This pattern matches things like
14375 ; (set (reg:CCEQ 68) (compare:CCEQ (ior:SI (gt:SI (reg:CCFP 68) (const_int 0))
14376 ; (eq:SI (reg:CCFP 68) (const_int 0)))
14377 ; (const_int 1)))
14378 ; which are generated by the branch logic.
14379 ; Prefer destructive operations where BT = BB (for crXX BT,BA,BB)
14380
14381 (define_insn "*cceq_ior_compare"
14382 [(set (match_operand:CCEQ 0 "cc_reg_operand" "=y,?y")
14383 (compare:CCEQ (match_operator:SI 1 "boolean_operator"
14384 [(match_operator:SI 2
14385 "branch_positive_comparison_operator"
14386 [(match_operand 3
14387 "cc_reg_operand" "y,y")
14388 (const_int 0)])
14389 (match_operator:SI 4
14390 "branch_positive_comparison_operator"
14391 [(match_operand 5
14392 "cc_reg_operand" "0,y")
14393 (const_int 0)])])
14394 (const_int 1)))]
14395 ""
14396 "cr%q1 %E0,%j2,%j4"
14397 [(set_attr "type" "cr_logical,delayed_cr")])
14398
14399 ; Why is the constant -1 here, but 1 in the previous pattern?
14400 ; Because ~1 has all but the low bit set.
14401 (define_insn ""
14402 [(set (match_operand:CCEQ 0 "cc_reg_operand" "=y,?y")
14403 (compare:CCEQ (match_operator:SI 1 "boolean_or_operator"
14404 [(not:SI (match_operator:SI 2
14405 "branch_positive_comparison_operator"
14406 [(match_operand 3
14407 "cc_reg_operand" "y,y")
14408 (const_int 0)]))
14409 (match_operator:SI 4
14410 "branch_positive_comparison_operator"
14411 [(match_operand 5
14412 "cc_reg_operand" "0,y")
14413 (const_int 0)])])
14414 (const_int -1)))]
14415 ""
14416 "cr%q1 %E0,%j2,%j4"
14417 [(set_attr "type" "cr_logical,delayed_cr")])
14418
14419 (define_insn "*cceq_rev_compare"
14420 [(set (match_operand:CCEQ 0 "cc_reg_operand" "=y,?y")
14421 (compare:CCEQ (match_operator:SI 1
14422 "branch_positive_comparison_operator"
14423 [(match_operand 2
14424 "cc_reg_operand" "0,y")
14425 (const_int 0)])
14426 (const_int 0)))]
14427 ""
14428 "{crnor %E0,%j1,%j1|crnot %E0,%j1}"
14429 [(set_attr "type" "cr_logical,delayed_cr")])
14430
14431 ;; If we are comparing the result of two comparisons, this can be done
14432 ;; using creqv or crxor.
14433
14434 (define_insn_and_split ""
14435 [(set (match_operand:CCEQ 0 "cc_reg_operand" "=y")
14436 (compare:CCEQ (match_operator 1 "branch_comparison_operator"
14437 [(match_operand 2 "cc_reg_operand" "y")
14438 (const_int 0)])
14439 (match_operator 3 "branch_comparison_operator"
14440 [(match_operand 4 "cc_reg_operand" "y")
14441 (const_int 0)])))]
14442 ""
14443 "#"
14444 ""
14445 [(set (match_dup 0) (compare:CCEQ (xor:SI (match_dup 1) (match_dup 3))
14446 (match_dup 5)))]
14447 "
14448 {
14449 int positive_1, positive_2;
14450
14451 positive_1 = branch_positive_comparison_operator (operands[1],
14452 GET_MODE (operands[1]));
14453 positive_2 = branch_positive_comparison_operator (operands[3],
14454 GET_MODE (operands[3]));
14455
14456 if (! positive_1)
14457 operands[1] = gen_rtx_fmt_ee (rs6000_reverse_condition (GET_MODE (operands[2]),
14458 GET_CODE (operands[1])),
14459 SImode,
14460 operands[2], const0_rtx);
14461 else if (GET_MODE (operands[1]) != SImode)
14462 operands[1] = gen_rtx_fmt_ee (GET_CODE (operands[1]), SImode,
14463 operands[2], const0_rtx);
14464
14465 if (! positive_2)
14466 operands[3] = gen_rtx_fmt_ee (rs6000_reverse_condition (GET_MODE (operands[4]),
14467 GET_CODE (operands[3])),
14468 SImode,
14469 operands[4], const0_rtx);
14470 else if (GET_MODE (operands[3]) != SImode)
14471 operands[3] = gen_rtx_fmt_ee (GET_CODE (operands[3]), SImode,
14472 operands[4], const0_rtx);
14473
14474 if (positive_1 == positive_2)
14475 {
14476 operands[1] = gen_rtx_NOT (SImode, operands[1]);
14477 operands[5] = constm1_rtx;
14478 }
14479 else
14480 {
14481 operands[5] = const1_rtx;
14482 }
14483 }")
14484
14485 ;; Unconditional branch and return.
14486
14487 (define_insn "jump"
14488 [(set (pc)
14489 (label_ref (match_operand 0 "" "")))]
14490 ""
14491 "b %l0"
14492 [(set_attr "type" "branch")])
14493
14494 (define_insn "return"
14495 [(return)]
14496 "direct_return ()"
14497 "{br|blr}"
14498 [(set_attr "type" "jmpreg")])
14499
14500 (define_expand "indirect_jump"
14501 [(set (pc) (match_operand 0 "register_operand" ""))])
14502
14503 (define_insn "*indirect_jump<mode>"
14504 [(set (pc) (match_operand:P 0 "register_operand" "c,*l"))]
14505 ""
14506 "@
14507 bctr
14508 {br|blr}"
14509 [(set_attr "type" "jmpreg")])
14510
14511 ;; Table jump for switch statements:
14512 (define_expand "tablejump"
14513 [(use (match_operand 0 "" ""))
14514 (use (label_ref (match_operand 1 "" "")))]
14515 ""
14516 "
14517 {
14518 if (TARGET_32BIT)
14519 emit_jump_insn (gen_tablejumpsi (operands[0], operands[1]));
14520 else
14521 emit_jump_insn (gen_tablejumpdi (operands[0], operands[1]));
14522 DONE;
14523 }")
14524
14525 (define_expand "tablejumpsi"
14526 [(set (match_dup 3)
14527 (plus:SI (match_operand:SI 0 "" "")
14528 (match_dup 2)))
14529 (parallel [(set (pc) (match_dup 3))
14530 (use (label_ref (match_operand 1 "" "")))])]
14531 "TARGET_32BIT"
14532 "
14533 { operands[0] = force_reg (SImode, operands[0]);
14534 operands[2] = force_reg (SImode, gen_rtx_LABEL_REF (SImode, operands[1]));
14535 operands[3] = gen_reg_rtx (SImode);
14536 }")
14537
14538 (define_expand "tablejumpdi"
14539 [(set (match_dup 4)
14540 (sign_extend:DI (match_operand:SI 0 "lwa_operand" "")))
14541 (set (match_dup 3)
14542 (plus:DI (match_dup 4)
14543 (match_dup 2)))
14544 (parallel [(set (pc) (match_dup 3))
14545 (use (label_ref (match_operand 1 "" "")))])]
14546 "TARGET_64BIT"
14547 "
14548 { operands[2] = force_reg (DImode, gen_rtx_LABEL_REF (DImode, operands[1]));
14549 operands[3] = gen_reg_rtx (DImode);
14550 operands[4] = gen_reg_rtx (DImode);
14551 }")
14552
14553 (define_insn "*tablejump<mode>_internal1"
14554 [(set (pc)
14555 (match_operand:P 0 "register_operand" "c,*l"))
14556 (use (label_ref (match_operand 1 "" "")))]
14557 ""
14558 "@
14559 bctr
14560 {br|blr}"
14561 [(set_attr "type" "jmpreg")])
14562
14563 (define_insn "nop"
14564 [(const_int 0)]
14565 ""
14566 "{cror 0,0,0|nop}")
14567 \f
14568 ;; Define the subtract-one-and-jump insns, starting with the template
14569 ;; so loop.c knows what to generate.
14570
14571 (define_expand "doloop_end"
14572 [(use (match_operand 0 "" "")) ; loop pseudo
14573 (use (match_operand 1 "" "")) ; iterations; zero if unknown
14574 (use (match_operand 2 "" "")) ; max iterations
14575 (use (match_operand 3 "" "")) ; loop level
14576 (use (match_operand 4 "" ""))] ; label
14577 ""
14578 "
14579 {
14580 /* Only use this on innermost loops. */
14581 if (INTVAL (operands[3]) > 1)
14582 FAIL;
14583 if (TARGET_64BIT)
14584 {
14585 if (GET_MODE (operands[0]) != DImode)
14586 FAIL;
14587 emit_jump_insn (gen_ctrdi (operands[0], operands[4]));
14588 }
14589 else
14590 {
14591 if (GET_MODE (operands[0]) != SImode)
14592 FAIL;
14593 emit_jump_insn (gen_ctrsi (operands[0], operands[4]));
14594 }
14595 DONE;
14596 }")
14597
14598 (define_expand "ctr<mode>"
14599 [(parallel [(set (pc)
14600 (if_then_else (ne (match_operand:P 0 "register_operand" "")
14601 (const_int 1))
14602 (label_ref (match_operand 1 "" ""))
14603 (pc)))
14604 (set (match_dup 0)
14605 (plus:P (match_dup 0)
14606 (const_int -1)))
14607 (clobber (match_scratch:CC 2 ""))
14608 (clobber (match_scratch:P 3 ""))])]
14609 ""
14610 "")
14611
14612 ;; We need to be able to do this for any operand, including MEM, or we
14613 ;; will cause reload to blow up since we don't allow output reloads on
14614 ;; JUMP_INSNs.
14615 ;; For the length attribute to be calculated correctly, the
14616 ;; label MUST be operand 0.
14617
14618 (define_insn "*ctr<mode>_internal1"
14619 [(set (pc)
14620 (if_then_else (ne (match_operand:P 1 "register_operand" "c,*r,*r,*r")
14621 (const_int 1))
14622 (label_ref (match_operand 0 "" ""))
14623 (pc)))
14624 (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*q*c*l")
14625 (plus:P (match_dup 1)
14626 (const_int -1)))
14627 (clobber (match_scratch:CC 3 "=X,&x,&x,&x"))
14628 (clobber (match_scratch:P 4 "=X,X,&r,r"))]
14629 ""
14630 "*
14631 {
14632 if (which_alternative != 0)
14633 return \"#\";
14634 else if (get_attr_length (insn) == 4)
14635 return \"{bdn|bdnz} %l0\";
14636 else
14637 return \"bdz $+8\;b %l0\";
14638 }"
14639 [(set_attr "type" "branch")
14640 (set_attr "length" "*,12,16,16")])
14641
14642 (define_insn "*ctr<mode>_internal2"
14643 [(set (pc)
14644 (if_then_else (ne (match_operand:P 1 "register_operand" "c,*r,*r,*r")
14645 (const_int 1))
14646 (pc)
14647 (label_ref (match_operand 0 "" ""))))
14648 (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*q*c*l")
14649 (plus:P (match_dup 1)
14650 (const_int -1)))
14651 (clobber (match_scratch:CC 3 "=X,&x,&x,&x"))
14652 (clobber (match_scratch:P 4 "=X,X,&r,r"))]
14653 ""
14654 "*
14655 {
14656 if (which_alternative != 0)
14657 return \"#\";
14658 else if (get_attr_length (insn) == 4)
14659 return \"bdz %l0\";
14660 else
14661 return \"{bdn|bdnz} $+8\;b %l0\";
14662 }"
14663 [(set_attr "type" "branch")
14664 (set_attr "length" "*,12,16,16")])
14665
14666 ;; Similar but use EQ
14667
14668 (define_insn "*ctr<mode>_internal5"
14669 [(set (pc)
14670 (if_then_else (eq (match_operand:P 1 "register_operand" "c,*r,*r,*r")
14671 (const_int 1))
14672 (label_ref (match_operand 0 "" ""))
14673 (pc)))
14674 (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*q*c*l")
14675 (plus:P (match_dup 1)
14676 (const_int -1)))
14677 (clobber (match_scratch:CC 3 "=X,&x,&x,&x"))
14678 (clobber (match_scratch:P 4 "=X,X,&r,r"))]
14679 ""
14680 "*
14681 {
14682 if (which_alternative != 0)
14683 return \"#\";
14684 else if (get_attr_length (insn) == 4)
14685 return \"bdz %l0\";
14686 else
14687 return \"{bdn|bdnz} $+8\;b %l0\";
14688 }"
14689 [(set_attr "type" "branch")
14690 (set_attr "length" "*,12,16,16")])
14691
14692 (define_insn "*ctr<mode>_internal6"
14693 [(set (pc)
14694 (if_then_else (eq (match_operand:P 1 "register_operand" "c,*r,*r,*r")
14695 (const_int 1))
14696 (pc)
14697 (label_ref (match_operand 0 "" ""))))
14698 (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*q*c*l")
14699 (plus:P (match_dup 1)
14700 (const_int -1)))
14701 (clobber (match_scratch:CC 3 "=X,&x,&x,&x"))
14702 (clobber (match_scratch:P 4 "=X,X,&r,r"))]
14703 ""
14704 "*
14705 {
14706 if (which_alternative != 0)
14707 return \"#\";
14708 else if (get_attr_length (insn) == 4)
14709 return \"{bdn|bdnz} %l0\";
14710 else
14711 return \"bdz $+8\;b %l0\";
14712 }"
14713 [(set_attr "type" "branch")
14714 (set_attr "length" "*,12,16,16")])
14715
14716 ;; Now the splitters if we could not allocate the CTR register
14717
14718 (define_split
14719 [(set (pc)
14720 (if_then_else (match_operator 2 "comparison_operator"
14721 [(match_operand:P 1 "gpc_reg_operand" "")
14722 (const_int 1)])
14723 (match_operand 5 "" "")
14724 (match_operand 6 "" "")))
14725 (set (match_operand:P 0 "gpc_reg_operand" "")
14726 (plus:P (match_dup 1) (const_int -1)))
14727 (clobber (match_scratch:CC 3 ""))
14728 (clobber (match_scratch:P 4 ""))]
14729 "reload_completed"
14730 [(parallel [(set (match_dup 3)
14731 (compare:CC (plus:P (match_dup 1)
14732 (const_int -1))
14733 (const_int 0)))
14734 (set (match_dup 0)
14735 (plus:P (match_dup 1)
14736 (const_int -1)))])
14737 (set (pc) (if_then_else (match_dup 7)
14738 (match_dup 5)
14739 (match_dup 6)))]
14740 "
14741 { operands[7] = gen_rtx_fmt_ee (GET_CODE (operands[2]), VOIDmode,
14742 operands[3], const0_rtx); }")
14743
14744 (define_split
14745 [(set (pc)
14746 (if_then_else (match_operator 2 "comparison_operator"
14747 [(match_operand:P 1 "gpc_reg_operand" "")
14748 (const_int 1)])
14749 (match_operand 5 "" "")
14750 (match_operand 6 "" "")))
14751 (set (match_operand:P 0 "nonimmediate_operand" "")
14752 (plus:P (match_dup 1) (const_int -1)))
14753 (clobber (match_scratch:CC 3 ""))
14754 (clobber (match_scratch:P 4 ""))]
14755 "reload_completed && ! gpc_reg_operand (operands[0], SImode)"
14756 [(parallel [(set (match_dup 3)
14757 (compare:CC (plus:P (match_dup 1)
14758 (const_int -1))
14759 (const_int 0)))
14760 (set (match_dup 4)
14761 (plus:P (match_dup 1)
14762 (const_int -1)))])
14763 (set (match_dup 0)
14764 (match_dup 4))
14765 (set (pc) (if_then_else (match_dup 7)
14766 (match_dup 5)
14767 (match_dup 6)))]
14768 "
14769 { operands[7] = gen_rtx_fmt_ee (GET_CODE (operands[2]), VOIDmode,
14770 operands[3], const0_rtx); }")
14771 \f
14772 (define_insn "trap"
14773 [(trap_if (const_int 1) (const_int 0))]
14774 ""
14775 "{t 31,0,0|trap}"
14776 [(set_attr "type" "trap")])
14777
14778 (define_expand "conditional_trap"
14779 [(trap_if (match_operator 0 "trap_comparison_operator"
14780 [(match_dup 2) (match_dup 3)])
14781 (match_operand 1 "const_int_operand" ""))]
14782 ""
14783 "if (rs6000_compare_fp_p || operands[1] != const0_rtx) FAIL;
14784 operands[2] = rs6000_compare_op0;
14785 operands[3] = rs6000_compare_op1;")
14786
14787 (define_insn ""
14788 [(trap_if (match_operator 0 "trap_comparison_operator"
14789 [(match_operand:GPR 1 "register_operand" "r")
14790 (match_operand:GPR 2 "reg_or_short_operand" "rI")])
14791 (const_int 0))]
14792 ""
14793 "{t|t<wd>}%V0%I2 %1,%2"
14794 [(set_attr "type" "trap")])
14795 \f
14796 ;; Insns related to generating the function prologue and epilogue.
14797
14798 (define_expand "prologue"
14799 [(use (const_int 0))]
14800 "TARGET_SCHED_PROLOG"
14801 "
14802 {
14803 rs6000_emit_prologue ();
14804 DONE;
14805 }")
14806
14807 (define_insn "*movesi_from_cr_one"
14808 [(match_parallel 0 "mfcr_operation"
14809 [(set (match_operand:SI 1 "gpc_reg_operand" "=r")
14810 (unspec:SI [(match_operand:CC 2 "cc_reg_operand" "y")
14811 (match_operand 3 "immediate_operand" "n")]
14812 UNSPEC_MOVESI_FROM_CR))])]
14813 "TARGET_MFCRF"
14814 "*
14815 {
14816 int mask = 0;
14817 int i;
14818 for (i = 0; i < XVECLEN (operands[0], 0); i++)
14819 {
14820 mask = INTVAL (XVECEXP (SET_SRC (XVECEXP (operands[0], 0, i)), 0, 1));
14821 operands[4] = GEN_INT (mask);
14822 output_asm_insn (\"mfcr %1,%4\", operands);
14823 }
14824 return \"\";
14825 }"
14826 [(set_attr "type" "mfcrf")])
14827
14828 (define_insn "movesi_from_cr"
14829 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
14830 (unspec:SI [(reg:CC CR0_REGNO) (reg:CC CR1_REGNO)
14831 (reg:CC CR2_REGNO) (reg:CC CR3_REGNO)
14832 (reg:CC CR4_REGNO) (reg:CC CR5_REGNO)
14833 (reg:CC CR6_REGNO) (reg:CC CR7_REGNO)]
14834 UNSPEC_MOVESI_FROM_CR))]
14835 ""
14836 "mfcr %0"
14837 [(set_attr "type" "mfcr")])
14838
14839 (define_insn "*stmw"
14840 [(match_parallel 0 "stmw_operation"
14841 [(set (match_operand:SI 1 "memory_operand" "=m")
14842 (match_operand:SI 2 "gpc_reg_operand" "r"))])]
14843 "TARGET_MULTIPLE"
14844 "{stm|stmw} %2,%1"
14845 [(set_attr "type" "store_ux")])
14846
14847 (define_insn "*save_gpregs_<mode>"
14848 [(match_parallel 0 "any_parallel_operand"
14849 [(clobber (reg:P 65))
14850 (use (match_operand:P 1 "symbol_ref_operand" "s"))
14851 (use (match_operand:P 2 "gpc_reg_operand" "r"))
14852 (set (match_operand:P 3 "memory_operand" "=m")
14853 (match_operand:P 4 "gpc_reg_operand" "r"))])]
14854 ""
14855 "bl %z1"
14856 [(set_attr "type" "branch")
14857 (set_attr "length" "4")])
14858
14859 (define_insn "*save_fpregs_<mode>"
14860 [(match_parallel 0 "any_parallel_operand"
14861 [(clobber (reg:P 65))
14862 (use (match_operand:P 1 "symbol_ref_operand" "s"))
14863 (use (match_operand:P 2 "gpc_reg_operand" "r"))
14864 (set (match_operand:DF 3 "memory_operand" "=m")
14865 (match_operand:DF 4 "gpc_reg_operand" "f"))])]
14866 ""
14867 "bl %z1"
14868 [(set_attr "type" "branch")
14869 (set_attr "length" "4")])
14870
14871 ; These are to explain that changes to the stack pointer should
14872 ; not be moved over stores to stack memory.
14873 (define_insn "stack_tie"
14874 [(set (match_operand:BLK 0 "memory_operand" "+m")
14875 (unspec:BLK [(match_dup 0)] UNSPEC_TIE))]
14876 ""
14877 ""
14878 [(set_attr "length" "0")])
14879
14880
14881 (define_expand "epilogue"
14882 [(use (const_int 0))]
14883 "TARGET_SCHED_PROLOG"
14884 "
14885 {
14886 rs6000_emit_epilogue (FALSE);
14887 DONE;
14888 }")
14889
14890 ; On some processors, doing the mtcrf one CC register at a time is
14891 ; faster (like on the 604e). On others, doing them all at once is
14892 ; faster; for instance, on the 601 and 750.
14893
14894 (define_expand "movsi_to_cr_one"
14895 [(set (match_operand:CC 0 "cc_reg_operand" "")
14896 (unspec:CC [(match_operand:SI 1 "gpc_reg_operand" "")
14897 (match_dup 2)] UNSPEC_MOVESI_TO_CR))]
14898 ""
14899 "operands[2] = GEN_INT (1 << (75 - REGNO (operands[0])));")
14900
14901 (define_insn "*movsi_to_cr"
14902 [(match_parallel 0 "mtcrf_operation"
14903 [(set (match_operand:CC 1 "cc_reg_operand" "=y")
14904 (unspec:CC [(match_operand:SI 2 "gpc_reg_operand" "r")
14905 (match_operand 3 "immediate_operand" "n")]
14906 UNSPEC_MOVESI_TO_CR))])]
14907 ""
14908 "*
14909 {
14910 int mask = 0;
14911 int i;
14912 for (i = 0; i < XVECLEN (operands[0], 0); i++)
14913 mask |= INTVAL (XVECEXP (SET_SRC (XVECEXP (operands[0], 0, i)), 0, 1));
14914 operands[4] = GEN_INT (mask);
14915 return \"mtcrf %4,%2\";
14916 }"
14917 [(set_attr "type" "mtcr")])
14918
14919 (define_insn "*mtcrfsi"
14920 [(set (match_operand:CC 0 "cc_reg_operand" "=y")
14921 (unspec:CC [(match_operand:SI 1 "gpc_reg_operand" "r")
14922 (match_operand 2 "immediate_operand" "n")]
14923 UNSPEC_MOVESI_TO_CR))]
14924 "GET_CODE (operands[0]) == REG
14925 && CR_REGNO_P (REGNO (operands[0]))
14926 && GET_CODE (operands[2]) == CONST_INT
14927 && INTVAL (operands[2]) == 1 << (75 - REGNO (operands[0]))"
14928 "mtcrf %R0,%1"
14929 [(set_attr "type" "mtcr")])
14930
14931 ; The load-multiple instructions have similar properties.
14932 ; Note that "load_multiple" is a name known to the machine-independent
14933 ; code that actually corresponds to the PowerPC load-string.
14934
14935 (define_insn "*lmw"
14936 [(match_parallel 0 "lmw_operation"
14937 [(set (match_operand:SI 1 "gpc_reg_operand" "=r")
14938 (match_operand:SI 2 "memory_operand" "m"))])]
14939 "TARGET_MULTIPLE"
14940 "{lm|lmw} %1,%2"
14941 [(set_attr "type" "load_ux")
14942 (set_attr "cell_micro" "always")])
14943
14944 (define_insn "*return_internal_<mode>"
14945 [(return)
14946 (use (match_operand:P 0 "register_operand" "lc"))]
14947 ""
14948 "b%T0"
14949 [(set_attr "type" "jmpreg")])
14950
14951 ; FIXME: This would probably be somewhat simpler if the Cygnus sibcall
14952 ; stuff was in GCC. Oh, and "any_parallel_operand" is a bit flexible...
14953
14954 (define_insn "*restore_gpregs_<mode>"
14955 [(match_parallel 0 "any_parallel_operand"
14956 [(clobber (match_operand:P 1 "register_operand" "=l"))
14957 (use (match_operand:P 2 "symbol_ref_operand" "s"))
14958 (use (match_operand:P 3 "gpc_reg_operand" "r"))
14959 (set (match_operand:P 4 "gpc_reg_operand" "=r")
14960 (match_operand:P 5 "memory_operand" "m"))])]
14961 ""
14962 "bl %z2"
14963 [(set_attr "type" "branch")
14964 (set_attr "length" "4")])
14965
14966 (define_insn "*return_and_restore_gpregs_<mode>"
14967 [(match_parallel 0 "any_parallel_operand"
14968 [(return)
14969 (clobber (match_operand:P 1 "register_operand" "=l"))
14970 (use (match_operand:P 2 "symbol_ref_operand" "s"))
14971 (use (match_operand:P 3 "gpc_reg_operand" "r"))
14972 (set (match_operand:P 4 "gpc_reg_operand" "=r")
14973 (match_operand:P 5 "memory_operand" "m"))])]
14974 ""
14975 "b %z2"
14976 [(set_attr "type" "branch")
14977 (set_attr "length" "4")])
14978
14979 (define_insn "*return_and_restore_fpregs_<mode>"
14980 [(match_parallel 0 "any_parallel_operand"
14981 [(return)
14982 (clobber (match_operand:P 1 "register_operand" "=l"))
14983 (use (match_operand:P 2 "symbol_ref_operand" "s"))
14984 (use (match_operand:P 3 "gpc_reg_operand" "r"))
14985 (set (match_operand:DF 4 "gpc_reg_operand" "=f")
14986 (match_operand:DF 5 "memory_operand" "m"))])]
14987 ""
14988 "b %z2"
14989 [(set_attr "type" "branch")
14990 (set_attr "length" "4")])
14991
14992 ; This is used in compiling the unwind routines.
14993 (define_expand "eh_return"
14994 [(use (match_operand 0 "general_operand" ""))]
14995 ""
14996 "
14997 {
14998 if (TARGET_32BIT)
14999 emit_insn (gen_eh_set_lr_si (operands[0]));
15000 else
15001 emit_insn (gen_eh_set_lr_di (operands[0]));
15002 DONE;
15003 }")
15004
15005 ; We can't expand this before we know where the link register is stored.
15006 (define_insn "eh_set_lr_<mode>"
15007 [(unspec_volatile [(match_operand:P 0 "register_operand" "r")]
15008 UNSPECV_EH_RR)
15009 (clobber (match_scratch:P 1 "=&b"))]
15010 ""
15011 "#")
15012
15013 (define_split
15014 [(unspec_volatile [(match_operand 0 "register_operand" "")] UNSPECV_EH_RR)
15015 (clobber (match_scratch 1 ""))]
15016 "reload_completed"
15017 [(const_int 0)]
15018 "
15019 {
15020 rs6000_emit_eh_reg_restore (operands[0], operands[1]);
15021 DONE;
15022 }")
15023
15024 (define_insn "prefetch"
15025 [(prefetch (match_operand 0 "indexed_or_indirect_address" "a")
15026 (match_operand:SI 1 "const_int_operand" "n")
15027 (match_operand:SI 2 "const_int_operand" "n"))]
15028 "TARGET_POWERPC"
15029 "*
15030 {
15031 if (GET_CODE (operands[0]) == REG)
15032 return INTVAL (operands[1]) ? \"dcbtst 0,%0\" : \"dcbt 0,%0\";
15033 return INTVAL (operands[1]) ? \"dcbtst %a0\" : \"dcbt %a0\";
15034 }"
15035 [(set_attr "type" "load")])
15036 \f
15037
15038 (include "sync.md")
15039 (include "altivec.md")
15040 (include "spe.md")
15041 (include "dfp.md")
15042 (include "paired.md")
Mirror of https://gcc.gnu.org/git/gcc.git