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 Free Software Foundation, Inc.
4 ;; Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
6 ;; This file is part of GCC.
8 ;; GCC is free software; you can redistribute it and/or modify it
9 ;; under the terms of the GNU General Public License as published
10 ;; by the Free Software Foundation; either version 2, or (at your
11 ;; option) any later version.
13 ;; GCC is distributed in the hope that it will be useful, but WITHOUT
14 ;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 ;; or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 ;; License for more details.
18 ;; You should have received a copy of the GNU General Public License
19 ;; along with GCC; see the file COPYING. If not, write to the
20 ;; Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
21 ;; MA 02110-1301, USA.
23 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
30 [(UNSPEC_FRSP 0) ; frsp for POWER machines
31 (UNSPEC_TIE 5) ; tie stack contents and stack pointer
32 (UNSPEC_TOCPTR 6) ; address of a word pointing to the TOC
33 (UNSPEC_TOC 7) ; address of the TOC (more-or-less)
35 (UNSPEC_MV_CR_OV 9) ; move_from_CR_ov_bit
37 (UNSPEC_LD_MPIC 15) ; load_macho_picbase
38 (UNSPEC_MPIC_CORRECT 16) ; macho_correct_pic
41 (UNSPEC_MOVESI_FROM_CR 19)
42 (UNSPEC_MOVESI_TO_CR 20)
44 (UNSPEC_TLSDTPRELHA 22)
45 (UNSPEC_TLSDTPRELLO 23)
46 (UNSPEC_TLSGOTDTPREL 24)
48 (UNSPEC_TLSTPRELHA 26)
49 (UNSPEC_TLSTPRELLO 27)
50 (UNSPEC_TLSGOTTPREL 28)
52 (UNSPEC_FIX_TRUNC_TF 30) ; fadd, rounding towards zero
53 (UNSPEC_MV_CR_GT 31) ; move_from_CR_eq_bit
70 ;; UNSPEC_VOLATILE usage
75 (UNSPECV_LL 1) ; load-locked
76 (UNSPECV_SC 2) ; store-conditional
77 (UNSPECV_EH_RR 9) ; eh_reg_restore
80 ;; Define an insn type attribute. This is used in function unit delay
82 (define_attr "type" "integer,two,three,load,load_ext,load_ext_u,load_ext_ux,load_ux,load_u,store,store_ux,store_u,fpload,fpload_ux,fpload_u,fpstore,fpstore_ux,fpstore_u,vecload,vecstore,imul,imul2,imul3,lmul,idiv,ldiv,insert_word,branch,cmp,fast_compare,compare,delayed_compare,imul_compare,lmul_compare,fpcompare,cr_logical,delayed_cr,mfcr,mfcrf,mtcr,mfjmpr,mtjmpr,fp,fpsimple,dmul,sdiv,ddiv,ssqrt,dsqrt,jmpreg,brinc,vecsimple,veccomplex,vecdiv,veccmp,veccmpsimple,vecperm,vecfloat,vecfdiv,isync,sync,load_l,store_c"
83 (const_string "integer"))
86 ; '(pc)' in the following doesn't include the instruction itself; it is
87 ; calculated as if the instruction had zero size.
88 (define_attr "length" ""
89 (if_then_else (eq_attr "type" "branch")
90 (if_then_else (and (ge (minus (match_dup 0) (pc))
92 (lt (minus (match_dup 0) (pc))
98 ;; Processor type -- this attribute must exactly match the processor_type
99 ;; enumeration in rs6000.h.
101 (define_attr "cpu" "rios1,rios2,rs64a,mpccore,ppc403,ppc405,ppc440,ppc601,ppc603,ppc604,ppc604e,ppc620,ppc630,ppc750,ppc7400,ppc7450,ppc8540,power4,power5"
102 (const (symbol_ref "rs6000_cpu_attr")))
104 (automata_option "ndfa")
117 (include "power4.md")
118 (include "power5.md")
120 (include "predicates.md")
122 (include "darwin.md")
127 ; This mode macro allows :GPR to be used to indicate the allowable size
128 ; of whole values in GPRs.
129 (define_mode_macro GPR [SI (DI "TARGET_POWERPC64")])
131 ; Any supported integer mode.
132 (define_mode_macro INT [QI HI SI DI TI])
134 ; Any supported integer mode that fits in one register.
135 (define_mode_macro INT1 [QI HI SI (DI "TARGET_POWERPC64")])
137 ; extend modes for DImode
138 (define_mode_macro QHSI [QI HI SI])
140 ; SImode or DImode, even if DImode doesn't fit in GPRs.
141 (define_mode_macro SDI [SI DI])
143 ; The size of a pointer. Also, the size of the value that a record-condition
144 ; (one with a '.') will compare.
145 (define_mode_macro P [(SI "TARGET_32BIT") (DI "TARGET_64BIT")])
147 ; Any hardware-supported floating-point mode
148 (define_mode_macro FP [(SF "TARGET_HARD_FLOAT")
149 (DF "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)")
150 (TF "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
151 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128")])
153 ; Various instructions that come in SI and DI forms.
154 ; A generic w/d attribute, for things like cmpw/cmpd.
155 (define_mode_attr wd [(QI "b") (HI "h") (SI "w") (DI "d")])
158 (define_mode_attr dbits [(QI "56") (HI "48") (SI "32")])
161 ;; Start with fixed-point load and store insns. Here we put only the more
162 ;; complex forms. Basic data transfer is done later.
164 (define_expand "zero_extend<mode>di2"
165 [(set (match_operand:DI 0 "gpc_reg_operand" "")
166 (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" "")))]
170 (define_insn "*zero_extend<mode>di2_internal1"
171 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
172 (zero_extend:DI (match_operand:QHSI 1 "reg_or_mem_operand" "m,r")))]
176 rldicl %0,%1,0,<dbits>"
177 [(set_attr "type" "load,*")])
179 (define_insn "*zero_extend<mode>di2_internal2"
180 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
181 (compare:CC (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" "r,r"))
183 (clobber (match_scratch:DI 2 "=r,r"))]
186 rldicl. %2,%1,0,<dbits>
188 [(set_attr "type" "compare")
189 (set_attr "length" "4,8")])
192 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
193 (compare:CC (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" ""))
195 (clobber (match_scratch:DI 2 ""))]
196 "TARGET_POWERPC64 && reload_completed"
198 (zero_extend:DI (match_dup 1)))
200 (compare:CC (match_dup 2)
204 (define_insn "*zero_extend<mode>di2_internal3"
205 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
206 (compare:CC (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" "r,r"))
208 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
209 (zero_extend:DI (match_dup 1)))]
212 rldicl. %0,%1,0,<dbits>
214 [(set_attr "type" "compare")
215 (set_attr "length" "4,8")])
218 [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
219 (compare:CC (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" ""))
221 (set (match_operand:DI 0 "gpc_reg_operand" "")
222 (zero_extend:DI (match_dup 1)))]
223 "TARGET_POWERPC64 && reload_completed"
225 (zero_extend:DI (match_dup 1)))
227 (compare:CC (match_dup 0)
231 (define_insn "extendqidi2"
232 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
233 (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r")))]
238 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
239 (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
241 (clobber (match_scratch:DI 2 "=r,r"))]
246 [(set_attr "type" "compare")
247 (set_attr "length" "4,8")])
250 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
251 (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" ""))
253 (clobber (match_scratch:DI 2 ""))]
254 "TARGET_POWERPC64 && reload_completed"
256 (sign_extend:DI (match_dup 1)))
258 (compare:CC (match_dup 2)
263 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
264 (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
266 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
267 (sign_extend:DI (match_dup 1)))]
272 [(set_attr "type" "compare")
273 (set_attr "length" "4,8")])
276 [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
277 (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" ""))
279 (set (match_operand:DI 0 "gpc_reg_operand" "")
280 (sign_extend:DI (match_dup 1)))]
281 "TARGET_POWERPC64 && reload_completed"
283 (sign_extend:DI (match_dup 1)))
285 (compare:CC (match_dup 0)
289 (define_expand "extendhidi2"
290 [(set (match_operand:DI 0 "gpc_reg_operand" "")
291 (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "")))]
296 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
297 (sign_extend:DI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
302 [(set_attr "type" "load_ext,*")])
305 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
306 (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
308 (clobber (match_scratch:DI 2 "=r,r"))]
313 [(set_attr "type" "compare")
314 (set_attr "length" "4,8")])
317 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
318 (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" ""))
320 (clobber (match_scratch:DI 2 ""))]
321 "TARGET_POWERPC64 && reload_completed"
323 (sign_extend:DI (match_dup 1)))
325 (compare:CC (match_dup 2)
330 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
331 (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
333 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
334 (sign_extend:DI (match_dup 1)))]
339 [(set_attr "type" "compare")
340 (set_attr "length" "4,8")])
343 [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
344 (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" ""))
346 (set (match_operand:DI 0 "gpc_reg_operand" "")
347 (sign_extend:DI (match_dup 1)))]
348 "TARGET_POWERPC64 && reload_completed"
350 (sign_extend:DI (match_dup 1)))
352 (compare:CC (match_dup 0)
356 (define_expand "extendsidi2"
357 [(set (match_operand:DI 0 "gpc_reg_operand" "")
358 (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "")))]
363 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
364 (sign_extend:DI (match_operand:SI 1 "lwa_operand" "m,r")))]
369 [(set_attr "type" "load_ext,*")])
372 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
373 (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r,r"))
375 (clobber (match_scratch:DI 2 "=r,r"))]
380 [(set_attr "type" "compare")
381 (set_attr "length" "4,8")])
384 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
385 (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
387 (clobber (match_scratch:DI 2 ""))]
388 "TARGET_POWERPC64 && reload_completed"
390 (sign_extend:DI (match_dup 1)))
392 (compare:CC (match_dup 2)
397 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
398 (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r,r"))
400 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
401 (sign_extend:DI (match_dup 1)))]
406 [(set_attr "type" "compare")
407 (set_attr "length" "4,8")])
410 [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
411 (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
413 (set (match_operand:DI 0 "gpc_reg_operand" "")
414 (sign_extend:DI (match_dup 1)))]
415 "TARGET_POWERPC64 && reload_completed"
417 (sign_extend:DI (match_dup 1)))
419 (compare:CC (match_dup 0)
423 (define_expand "zero_extendqisi2"
424 [(set (match_operand:SI 0 "gpc_reg_operand" "")
425 (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "")))]
430 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
431 (zero_extend:SI (match_operand:QI 1 "reg_or_mem_operand" "m,r")))]
435 {rlinm|rlwinm} %0,%1,0,0xff"
436 [(set_attr "type" "load,*")])
439 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
440 (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
442 (clobber (match_scratch:SI 2 "=r,r"))]
445 {andil.|andi.} %2,%1,0xff
447 [(set_attr "type" "compare")
448 (set_attr "length" "4,8")])
451 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
452 (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" ""))
454 (clobber (match_scratch:SI 2 ""))]
457 (zero_extend:SI (match_dup 1)))
459 (compare:CC (match_dup 2)
464 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
465 (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
467 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
468 (zero_extend:SI (match_dup 1)))]
471 {andil.|andi.} %0,%1,0xff
473 [(set_attr "type" "compare")
474 (set_attr "length" "4,8")])
477 [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
478 (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" ""))
480 (set (match_operand:SI 0 "gpc_reg_operand" "")
481 (zero_extend:SI (match_dup 1)))]
484 (zero_extend:SI (match_dup 1)))
486 (compare:CC (match_dup 0)
490 (define_expand "extendqisi2"
491 [(use (match_operand:SI 0 "gpc_reg_operand" ""))
492 (use (match_operand:QI 1 "gpc_reg_operand" ""))]
497 emit_insn (gen_extendqisi2_ppc (operands[0], operands[1]));
498 else if (TARGET_POWER)
499 emit_insn (gen_extendqisi2_power (operands[0], operands[1]));
501 emit_insn (gen_extendqisi2_no_power (operands[0], operands[1]));
505 (define_insn "extendqisi2_ppc"
506 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
507 (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r")))]
512 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
513 (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
515 (clobber (match_scratch:SI 2 "=r,r"))]
520 [(set_attr "type" "compare")
521 (set_attr "length" "4,8")])
524 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
525 (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" ""))
527 (clobber (match_scratch:SI 2 ""))]
528 "TARGET_POWERPC && reload_completed"
530 (sign_extend:SI (match_dup 1)))
532 (compare:CC (match_dup 2)
537 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
538 (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
540 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
541 (sign_extend:SI (match_dup 1)))]
546 [(set_attr "type" "compare")
547 (set_attr "length" "4,8")])
550 [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
551 (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" ""))
553 (set (match_operand:SI 0 "gpc_reg_operand" "")
554 (sign_extend:SI (match_dup 1)))]
555 "TARGET_POWERPC && reload_completed"
557 (sign_extend:SI (match_dup 1)))
559 (compare:CC (match_dup 0)
563 (define_expand "extendqisi2_power"
564 [(parallel [(set (match_dup 2)
565 (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
567 (clobber (scratch:SI))])
568 (parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
569 (ashiftrt:SI (match_dup 2)
571 (clobber (scratch:SI))])]
574 { operands[1] = gen_lowpart (SImode, operands[1]);
575 operands[2] = gen_reg_rtx (SImode); }")
577 (define_expand "extendqisi2_no_power"
579 (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
581 (set (match_operand:SI 0 "gpc_reg_operand" "")
582 (ashiftrt:SI (match_dup 2)
584 "! TARGET_POWER && ! TARGET_POWERPC"
586 { operands[1] = gen_lowpart (SImode, operands[1]);
587 operands[2] = gen_reg_rtx (SImode); }")
589 (define_expand "zero_extendqihi2"
590 [(set (match_operand:HI 0 "gpc_reg_operand" "")
591 (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "")))]
596 [(set (match_operand:HI 0 "gpc_reg_operand" "=r,r")
597 (zero_extend:HI (match_operand:QI 1 "reg_or_mem_operand" "m,r")))]
601 {rlinm|rlwinm} %0,%1,0,0xff"
602 [(set_attr "type" "load,*")])
605 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
606 (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
608 (clobber (match_scratch:HI 2 "=r,r"))]
611 {andil.|andi.} %2,%1,0xff
613 [(set_attr "type" "compare")
614 (set_attr "length" "4,8")])
617 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
618 (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" ""))
620 (clobber (match_scratch:HI 2 ""))]
623 (zero_extend:HI (match_dup 1)))
625 (compare:CC (match_dup 2)
630 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
631 (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
633 (set (match_operand:HI 0 "gpc_reg_operand" "=r,r")
634 (zero_extend:HI (match_dup 1)))]
637 {andil.|andi.} %0,%1,0xff
639 [(set_attr "type" "compare")
640 (set_attr "length" "4,8")])
643 [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
644 (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" ""))
646 (set (match_operand:HI 0 "gpc_reg_operand" "")
647 (zero_extend:HI (match_dup 1)))]
650 (zero_extend:HI (match_dup 1)))
652 (compare:CC (match_dup 0)
656 (define_expand "extendqihi2"
657 [(use (match_operand:HI 0 "gpc_reg_operand" ""))
658 (use (match_operand:QI 1 "gpc_reg_operand" ""))]
663 emit_insn (gen_extendqihi2_ppc (operands[0], operands[1]));
664 else if (TARGET_POWER)
665 emit_insn (gen_extendqihi2_power (operands[0], operands[1]));
667 emit_insn (gen_extendqihi2_no_power (operands[0], operands[1]));
671 (define_insn "extendqihi2_ppc"
672 [(set (match_operand:HI 0 "gpc_reg_operand" "=r")
673 (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r")))]
678 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
679 (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
681 (clobber (match_scratch:HI 2 "=r,r"))]
686 [(set_attr "type" "compare")
687 (set_attr "length" "4,8")])
690 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
691 (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" ""))
693 (clobber (match_scratch:HI 2 ""))]
694 "TARGET_POWERPC && reload_completed"
696 (sign_extend:HI (match_dup 1)))
698 (compare:CC (match_dup 2)
703 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
704 (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
706 (set (match_operand:HI 0 "gpc_reg_operand" "=r,r")
707 (sign_extend:HI (match_dup 1)))]
712 [(set_attr "type" "compare")
713 (set_attr "length" "4,8")])
716 [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
717 (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" ""))
719 (set (match_operand:HI 0 "gpc_reg_operand" "")
720 (sign_extend:HI (match_dup 1)))]
721 "TARGET_POWERPC && reload_completed"
723 (sign_extend:HI (match_dup 1)))
725 (compare:CC (match_dup 0)
729 (define_expand "extendqihi2_power"
730 [(parallel [(set (match_dup 2)
731 (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
733 (clobber (scratch:SI))])
734 (parallel [(set (match_operand:HI 0 "gpc_reg_operand" "")
735 (ashiftrt:SI (match_dup 2)
737 (clobber (scratch:SI))])]
740 { operands[0] = gen_lowpart (SImode, operands[0]);
741 operands[1] = gen_lowpart (SImode, operands[1]);
742 operands[2] = gen_reg_rtx (SImode); }")
744 (define_expand "extendqihi2_no_power"
746 (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
748 (set (match_operand:HI 0 "gpc_reg_operand" "")
749 (ashiftrt:SI (match_dup 2)
751 "! TARGET_POWER && ! TARGET_POWERPC"
753 { operands[0] = gen_lowpart (SImode, operands[0]);
754 operands[1] = gen_lowpart (SImode, operands[1]);
755 operands[2] = gen_reg_rtx (SImode); }")
757 (define_expand "zero_extendhisi2"
758 [(set (match_operand:SI 0 "gpc_reg_operand" "")
759 (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "")))]
764 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
765 (zero_extend:SI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
769 {rlinm|rlwinm} %0,%1,0,0xffff"
770 [(set_attr "type" "load,*")])
773 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
774 (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
776 (clobber (match_scratch:SI 2 "=r,r"))]
779 {andil.|andi.} %2,%1,0xffff
781 [(set_attr "type" "compare")
782 (set_attr "length" "4,8")])
785 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
786 (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" ""))
788 (clobber (match_scratch:SI 2 ""))]
791 (zero_extend:SI (match_dup 1)))
793 (compare:CC (match_dup 2)
798 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
799 (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
801 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
802 (zero_extend:SI (match_dup 1)))]
805 {andil.|andi.} %0,%1,0xffff
807 [(set_attr "type" "compare")
808 (set_attr "length" "4,8")])
811 [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
812 (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" ""))
814 (set (match_operand:SI 0 "gpc_reg_operand" "")
815 (zero_extend:SI (match_dup 1)))]
818 (zero_extend:SI (match_dup 1)))
820 (compare:CC (match_dup 0)
824 (define_expand "extendhisi2"
825 [(set (match_operand:SI 0 "gpc_reg_operand" "")
826 (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "")))]
831 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
832 (sign_extend:SI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
837 [(set_attr "type" "load_ext,*")])
840 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
841 (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
843 (clobber (match_scratch:SI 2 "=r,r"))]
848 [(set_attr "type" "compare")
849 (set_attr "length" "4,8")])
852 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
853 (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" ""))
855 (clobber (match_scratch:SI 2 ""))]
858 (sign_extend:SI (match_dup 1)))
860 (compare:CC (match_dup 2)
865 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
866 (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
868 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
869 (sign_extend:SI (match_dup 1)))]
874 [(set_attr "type" "compare")
875 (set_attr "length" "4,8")])
878 [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
879 (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" ""))
881 (set (match_operand:SI 0 "gpc_reg_operand" "")
882 (sign_extend:SI (match_dup 1)))]
885 (sign_extend:SI (match_dup 1)))
887 (compare:CC (match_dup 0)
891 ;; Fixed-point arithmetic insns.
893 (define_expand "add<mode>3"
894 [(set (match_operand:SDI 0 "gpc_reg_operand" "")
895 (plus:SDI (match_operand:SDI 1 "gpc_reg_operand" "")
896 (match_operand:SDI 2 "reg_or_add_cint_operand" "")))]
900 if (<MODE>mode == DImode && ! TARGET_POWERPC64)
902 if (non_short_cint_operand (operands[2], DImode))
905 else if (GET_CODE (operands[2]) == CONST_INT
906 && ! add_operand (operands[2], <MODE>mode))
908 rtx tmp = ((no_new_pseudos || rtx_equal_p (operands[0], operands[1]))
909 ? operands[0] : gen_reg_rtx (<MODE>mode));
911 HOST_WIDE_INT val = INTVAL (operands[2]);
912 HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
913 HOST_WIDE_INT rest = trunc_int_for_mode (val - low, <MODE>mode);
915 if (<MODE>mode == DImode && !CONST_OK_FOR_LETTER_P (rest, 'L'))
918 /* The ordering here is important for the prolog expander.
919 When space is allocated from the stack, adding 'low' first may
920 produce a temporary deallocation (which would be bad). */
921 emit_insn (gen_add<mode>3 (tmp, operands[1], GEN_INT (rest)));
922 emit_insn (gen_add<mode>3 (operands[0], tmp, GEN_INT (low)));
927 ;; Discourage ai/addic because of carry but provide it in an alternative
928 ;; allowing register zero as source.
929 (define_insn "*add<mode>3_internal1"
930 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r,r,?r,r")
931 (plus:GPR (match_operand:GPR 1 "gpc_reg_operand" "%r,b,r,b")
932 (match_operand:GPR 2 "add_operand" "r,I,I,L")))]
936 {cal %0,%2(%1)|addi %0,%1,%2}
938 {cau|addis} %0,%1,%v2"
939 [(set_attr "length" "4,4,4,4")])
941 (define_insn "addsi3_high"
942 [(set (match_operand:SI 0 "gpc_reg_operand" "=b")
943 (plus:SI (match_operand:SI 1 "gpc_reg_operand" "b")
944 (high:SI (match_operand 2 "" ""))))]
945 "TARGET_MACHO && !TARGET_64BIT"
946 "{cau|addis} %0,%1,ha16(%2)"
947 [(set_attr "length" "4")])
949 (define_insn "*add<mode>3_internal2"
950 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
951 (compare:CC (plus:P (match_operand:P 1 "gpc_reg_operand" "%r,r,r,r")
952 (match_operand:P 2 "reg_or_short_operand" "r,I,r,I"))
954 (clobber (match_scratch:P 3 "=r,r,r,r"))]
958 {ai.|addic.} %3,%1,%2
961 [(set_attr "type" "fast_compare,compare,compare,compare")
962 (set_attr "length" "4,4,8,8")])
965 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
966 (compare:CC (plus:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
967 (match_operand:GPR 2 "reg_or_short_operand" ""))
969 (clobber (match_scratch:GPR 3 ""))]
972 (plus:GPR (match_dup 1)
975 (compare:CC (match_dup 3)
979 (define_insn "*add<mode>3_internal3"
980 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
981 (compare:CC (plus:P (match_operand:P 1 "gpc_reg_operand" "%r,r,r,r")
982 (match_operand:P 2 "reg_or_short_operand" "r,I,r,I"))
984 (set (match_operand:P 0 "gpc_reg_operand" "=r,r,r,r")
985 (plus:P (match_dup 1)
990 {ai.|addic.} %0,%1,%2
993 [(set_attr "type" "fast_compare,compare,compare,compare")
994 (set_attr "length" "4,4,8,8")])
997 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
998 (compare:CC (plus:P (match_operand:P 1 "gpc_reg_operand" "")
999 (match_operand:P 2 "reg_or_short_operand" ""))
1001 (set (match_operand:P 0 "gpc_reg_operand" "")
1002 (plus:P (match_dup 1) (match_dup 2)))]
1005 (plus:P (match_dup 1)
1008 (compare:CC (match_dup 0)
1012 ;; Split an add that we can't do in one insn into two insns, each of which
1013 ;; does one 16-bit part. This is used by combine. Note that the low-order
1014 ;; add should be last in case the result gets used in an address.
1017 [(set (match_operand:GPR 0 "gpc_reg_operand" "")
1018 (plus:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
1019 (match_operand:GPR 2 "non_add_cint_operand" "")))]
1021 [(set (match_dup 0) (plus:GPR (match_dup 1) (match_dup 3)))
1022 (set (match_dup 0) (plus:GPR (match_dup 0) (match_dup 4)))]
1025 HOST_WIDE_INT val = INTVAL (operands[2]);
1026 HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
1027 HOST_WIDE_INT rest = trunc_int_for_mode (val - low, <MODE>mode);
1029 operands[4] = GEN_INT (low);
1030 if (<MODE>mode == SImode || CONST_OK_FOR_LETTER_P (rest, 'L'))
1031 operands[3] = GEN_INT (rest);
1032 else if (! no_new_pseudos)
1034 operands[3] = gen_reg_rtx (DImode);
1035 emit_move_insn (operands[3], operands[2]);
1036 emit_insn (gen_adddi3 (operands[0], operands[1], operands[3]));
1043 (define_insn "one_cmpl<mode>2"
1044 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
1045 (not:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")))]
1050 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1051 (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
1053 (clobber (match_scratch:P 2 "=r,r"))]
1058 [(set_attr "type" "compare")
1059 (set_attr "length" "4,8")])
1062 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1063 (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" ""))
1065 (clobber (match_scratch:P 2 ""))]
1068 (not:P (match_dup 1)))
1070 (compare:CC (match_dup 2)
1075 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
1076 (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
1078 (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
1079 (not:P (match_dup 1)))]
1084 [(set_attr "type" "compare")
1085 (set_attr "length" "4,8")])
1088 [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
1089 (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" ""))
1091 (set (match_operand:P 0 "gpc_reg_operand" "")
1092 (not:P (match_dup 1)))]
1095 (not:P (match_dup 1)))
1097 (compare:CC (match_dup 0)
1102 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1103 (minus:SI (match_operand:SI 1 "reg_or_short_operand" "rI")
1104 (match_operand:SI 2 "gpc_reg_operand" "r")))]
1106 "{sf%I1|subf%I1c} %0,%2,%1")
1109 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r,r")
1110 (minus:GPR (match_operand:GPR 1 "reg_or_short_operand" "r,I")
1111 (match_operand:GPR 2 "gpc_reg_operand" "r,r")))]
1118 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1119 (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
1120 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
1122 (clobber (match_scratch:SI 3 "=r,r"))]
1125 {sf.|subfc.} %3,%2,%1
1127 [(set_attr "type" "compare")
1128 (set_attr "length" "4,8")])
1131 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1132 (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "r,r")
1133 (match_operand:P 2 "gpc_reg_operand" "r,r"))
1135 (clobber (match_scratch:P 3 "=r,r"))]
1140 [(set_attr "type" "fast_compare")
1141 (set_attr "length" "4,8")])
1144 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1145 (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "")
1146 (match_operand:P 2 "gpc_reg_operand" ""))
1148 (clobber (match_scratch:P 3 ""))]
1151 (minus:P (match_dup 1)
1154 (compare:CC (match_dup 3)
1159 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1160 (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
1161 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
1163 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
1164 (minus:SI (match_dup 1) (match_dup 2)))]
1167 {sf.|subfc.} %0,%2,%1
1169 [(set_attr "type" "compare")
1170 (set_attr "length" "4,8")])
1173 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1174 (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "r,r")
1175 (match_operand:P 2 "gpc_reg_operand" "r,r"))
1177 (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
1178 (minus:P (match_dup 1)
1184 [(set_attr "type" "fast_compare")
1185 (set_attr "length" "4,8")])
1188 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
1189 (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "")
1190 (match_operand:P 2 "gpc_reg_operand" ""))
1192 (set (match_operand:P 0 "gpc_reg_operand" "")
1193 (minus:P (match_dup 1)
1197 (minus:P (match_dup 1)
1200 (compare:CC (match_dup 0)
1204 (define_expand "sub<mode>3"
1205 [(set (match_operand:SDI 0 "gpc_reg_operand" "")
1206 (minus:SDI (match_operand:SDI 1 "reg_or_short_operand" "")
1207 (match_operand:SDI 2 "reg_or_sub_cint_operand" "")))]
1211 if (GET_CODE (operands[2]) == CONST_INT)
1213 emit_insn (gen_add<mode>3 (operands[0], operands[1],
1214 negate_rtx (<MODE>mode, operands[2])));
1219 ;; For SMIN, SMAX, UMIN, and UMAX, we use DEFINE_EXPAND's that involve a doz[i]
1220 ;; instruction and some auxiliary computations. Then we just have a single
1221 ;; DEFINE_INSN for doz[i] and the define_splits to make them if made by
1224 (define_expand "sminsi3"
1226 (if_then_else:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
1227 (match_operand:SI 2 "reg_or_short_operand" ""))
1229 (minus:SI (match_dup 2) (match_dup 1))))
1230 (set (match_operand:SI 0 "gpc_reg_operand" "")
1231 (minus:SI (match_dup 2) (match_dup 3)))]
1232 "TARGET_POWER || TARGET_ISEL"
1237 operands[2] = force_reg (SImode, operands[2]);
1238 rs6000_emit_minmax (operands[0], SMIN, operands[1], operands[2]);
1242 operands[3] = gen_reg_rtx (SImode);
1246 [(set (match_operand:SI 0 "gpc_reg_operand" "")
1247 (smin:SI (match_operand:SI 1 "gpc_reg_operand" "")
1248 (match_operand:SI 2 "reg_or_short_operand" "")))
1249 (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
1252 (if_then_else:SI (gt:SI (match_dup 1) (match_dup 2))
1254 (minus:SI (match_dup 2) (match_dup 1))))
1255 (set (match_dup 0) (minus:SI (match_dup 2) (match_dup 3)))]
1258 (define_expand "smaxsi3"
1260 (if_then_else:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
1261 (match_operand:SI 2 "reg_or_short_operand" ""))
1263 (minus:SI (match_dup 2) (match_dup 1))))
1264 (set (match_operand:SI 0 "gpc_reg_operand" "")
1265 (plus:SI (match_dup 3) (match_dup 1)))]
1266 "TARGET_POWER || TARGET_ISEL"
1271 operands[2] = force_reg (SImode, operands[2]);
1272 rs6000_emit_minmax (operands[0], SMAX, operands[1], operands[2]);
1275 operands[3] = gen_reg_rtx (SImode);
1279 [(set (match_operand:SI 0 "gpc_reg_operand" "")
1280 (smax:SI (match_operand:SI 1 "gpc_reg_operand" "")
1281 (match_operand:SI 2 "reg_or_short_operand" "")))
1282 (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
1285 (if_then_else:SI (gt:SI (match_dup 1) (match_dup 2))
1287 (minus:SI (match_dup 2) (match_dup 1))))
1288 (set (match_dup 0) (plus:SI (match_dup 3) (match_dup 1)))]
1291 (define_expand "uminsi3"
1292 [(set (match_dup 3) (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
1294 (set (match_dup 4) (xor:SI (match_operand:SI 2 "gpc_reg_operand" "")
1296 (set (match_dup 3) (if_then_else:SI (gt (match_dup 3) (match_dup 4))
1298 (minus:SI (match_dup 4) (match_dup 3))))
1299 (set (match_operand:SI 0 "gpc_reg_operand" "")
1300 (minus:SI (match_dup 2) (match_dup 3)))]
1301 "TARGET_POWER || TARGET_ISEL"
1306 rs6000_emit_minmax (operands[0], UMIN, operands[1], operands[2]);
1309 operands[3] = gen_reg_rtx (SImode);
1310 operands[4] = gen_reg_rtx (SImode);
1311 operands[5] = GEN_INT (-2147483647 - 1);
1314 (define_expand "umaxsi3"
1315 [(set (match_dup 3) (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
1317 (set (match_dup 4) (xor:SI (match_operand:SI 2 "gpc_reg_operand" "")
1319 (set (match_dup 3) (if_then_else:SI (gt (match_dup 3) (match_dup 4))
1321 (minus:SI (match_dup 4) (match_dup 3))))
1322 (set (match_operand:SI 0 "gpc_reg_operand" "")
1323 (plus:SI (match_dup 3) (match_dup 1)))]
1324 "TARGET_POWER || TARGET_ISEL"
1329 rs6000_emit_minmax (operands[0], UMAX, operands[1], operands[2]);
1332 operands[3] = gen_reg_rtx (SImode);
1333 operands[4] = gen_reg_rtx (SImode);
1334 operands[5] = GEN_INT (-2147483647 - 1);
1338 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1339 (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r")
1340 (match_operand:SI 2 "reg_or_short_operand" "rI"))
1342 (minus:SI (match_dup 2) (match_dup 1))))]
1347 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1349 (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r,r")
1350 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
1352 (minus:SI (match_dup 2) (match_dup 1)))
1354 (clobber (match_scratch:SI 3 "=r,r"))]
1359 [(set_attr "type" "delayed_compare")
1360 (set_attr "length" "4,8")])
1363 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1365 (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "")
1366 (match_operand:SI 2 "reg_or_short_operand" ""))
1368 (minus:SI (match_dup 2) (match_dup 1)))
1370 (clobber (match_scratch:SI 3 ""))]
1371 "TARGET_POWER && reload_completed"
1373 (if_then_else:SI (gt (match_dup 1) (match_dup 2))
1375 (minus:SI (match_dup 2) (match_dup 1))))
1377 (compare:CC (match_dup 3)
1382 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1384 (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r,r")
1385 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
1387 (minus:SI (match_dup 2) (match_dup 1)))
1389 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
1390 (if_then_else:SI (gt (match_dup 1) (match_dup 2))
1392 (minus:SI (match_dup 2) (match_dup 1))))]
1397 [(set_attr "type" "delayed_compare")
1398 (set_attr "length" "4,8")])
1401 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
1403 (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "")
1404 (match_operand:SI 2 "reg_or_short_operand" ""))
1406 (minus:SI (match_dup 2) (match_dup 1)))
1408 (set (match_operand:SI 0 "gpc_reg_operand" "")
1409 (if_then_else:SI (gt (match_dup 1) (match_dup 2))
1411 (minus:SI (match_dup 2) (match_dup 1))))]
1412 "TARGET_POWER && reload_completed"
1414 (if_then_else:SI (gt (match_dup 1) (match_dup 2))
1416 (minus:SI (match_dup 2) (match_dup 1))))
1418 (compare:CC (match_dup 0)
1422 ;; We don't need abs with condition code because such comparisons should
1424 (define_expand "abssi2"
1425 [(set (match_operand:SI 0 "gpc_reg_operand" "")
1426 (abs:SI (match_operand:SI 1 "gpc_reg_operand" "")))]
1432 emit_insn (gen_abssi2_isel (operands[0], operands[1]));
1435 else if (! TARGET_POWER)
1437 emit_insn (gen_abssi2_nopower (operands[0], operands[1]));
1442 (define_insn "*abssi2_power"
1443 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1444 (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
1448 (define_insn_and_split "abssi2_isel"
1449 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1450 (abs:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
1451 (clobber (match_scratch:SI 2 "=&b"))
1452 (clobber (match_scratch:CC 3 "=y"))]
1455 "&& reload_completed"
1456 [(set (match_dup 2) (neg:SI (match_dup 1)))
1458 (compare:CC (match_dup 1)
1461 (if_then_else:SI (ge (match_dup 3)
1467 (define_insn_and_split "abssi2_nopower"
1468 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,r")
1469 (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,0")))
1470 (clobber (match_scratch:SI 2 "=&r,&r"))]
1471 "! TARGET_POWER && ! TARGET_ISEL"
1473 "&& reload_completed"
1474 [(set (match_dup 2) (ashiftrt:SI (match_dup 1) (const_int 31)))
1475 (set (match_dup 0) (xor:SI (match_dup 2) (match_dup 1)))
1476 (set (match_dup 0) (minus:SI (match_dup 0) (match_dup 2)))]
1479 (define_insn "*nabs_power"
1480 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1481 (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r"))))]
1485 (define_insn_and_split "*nabs_nopower"
1486 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,r")
1487 (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,0"))))
1488 (clobber (match_scratch:SI 2 "=&r,&r"))]
1491 "&& reload_completed"
1492 [(set (match_dup 2) (ashiftrt:SI (match_dup 1) (const_int 31)))
1493 (set (match_dup 0) (xor:SI (match_dup 2) (match_dup 1)))
1494 (set (match_dup 0) (minus:SI (match_dup 2) (match_dup 0)))]
1497 (define_expand "neg<mode>2"
1498 [(set (match_operand:SDI 0 "gpc_reg_operand" "")
1499 (neg:SDI (match_operand:SDI 1 "gpc_reg_operand" "")))]
1503 (define_insn "*neg<mode>2_internal"
1504 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
1505 (neg:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")))]
1510 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1511 (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
1513 (clobber (match_scratch:P 2 "=r,r"))]
1518 [(set_attr "type" "fast_compare")
1519 (set_attr "length" "4,8")])
1522 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1523 (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" ""))
1525 (clobber (match_scratch:P 2 ""))]
1528 (neg:P (match_dup 1)))
1530 (compare:CC (match_dup 2)
1535 [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
1536 (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
1538 (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
1539 (neg:P (match_dup 1)))]
1544 [(set_attr "type" "fast_compare")
1545 (set_attr "length" "4,8")])
1548 [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
1549 (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" ""))
1551 (set (match_operand:P 0 "gpc_reg_operand" "")
1552 (neg:P (match_dup 1)))]
1555 (neg:P (match_dup 1)))
1557 (compare:CC (match_dup 0)
1561 (define_insn "clz<mode>2"
1562 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
1563 (clz:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")))]
1565 "{cntlz|cntlz<wd>} %0,%1")
1567 (define_expand "ctz<mode>2"
1569 (neg:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")))
1570 (parallel [(set (match_dup 3) (and:GPR (match_dup 1)
1572 (clobber (scratch:CC))])
1573 (set (match_dup 4) (clz:GPR (match_dup 3)))
1574 (set (match_operand:GPR 0 "gpc_reg_operand" "=r")
1575 (minus:GPR (match_dup 5) (match_dup 4)))]
1578 operands[2] = gen_reg_rtx (<MODE>mode);
1579 operands[3] = gen_reg_rtx (<MODE>mode);
1580 operands[4] = gen_reg_rtx (<MODE>mode);
1581 operands[5] = GEN_INT (GET_MODE_BITSIZE (<MODE>mode) - 1);
1584 (define_expand "ffs<mode>2"
1586 (neg:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")))
1587 (parallel [(set (match_dup 3) (and:GPR (match_dup 1)
1589 (clobber (scratch:CC))])
1590 (set (match_dup 4) (clz:GPR (match_dup 3)))
1591 (set (match_operand:GPR 0 "gpc_reg_operand" "=r")
1592 (minus:GPR (match_dup 5) (match_dup 4)))]
1595 operands[2] = gen_reg_rtx (<MODE>mode);
1596 operands[3] = gen_reg_rtx (<MODE>mode);
1597 operands[4] = gen_reg_rtx (<MODE>mode);
1598 operands[5] = GEN_INT (GET_MODE_BITSIZE (<MODE>mode));
1601 (define_expand "popcount<mode>2"
1603 (unspec:GPR [(match_operand:GPR 1 "gpc_reg_operand" "r")]
1606 (mult:GPR (match_dup 2) (match_dup 4)))
1607 (set (match_operand:GPR 0 "gpc_reg_operand" "=r")
1608 (lshiftrt:GPR (match_dup 3) (match_dup 5)))]
1611 operands[2] = gen_reg_rtx (<MODE>mode);
1612 operands[3] = gen_reg_rtx (<MODE>mode);
1613 operands[4] = force_reg (<MODE>mode,
1614 <MODE>mode == SImode
1615 ? GEN_INT (0x01010101)
1616 : GEN_INT ((HOST_WIDE_INT)
1617 0x01010101 << 32 | 0x01010101));
1618 operands[5] = GEN_INT (GET_MODE_BITSIZE (<MODE>mode) - 8);
1621 (define_insn "popcntb<mode>2"
1622 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
1623 (unspec:GPR [(match_operand:GPR 1 "gpc_reg_operand" "r")]
1628 (define_expand "mulsi3"
1629 [(use (match_operand:SI 0 "gpc_reg_operand" ""))
1630 (use (match_operand:SI 1 "gpc_reg_operand" ""))
1631 (use (match_operand:SI 2 "reg_or_short_operand" ""))]
1636 emit_insn (gen_mulsi3_mq (operands[0], operands[1], operands[2]));
1638 emit_insn (gen_mulsi3_no_mq (operands[0], operands[1], operands[2]));
1642 (define_insn "mulsi3_mq"
1643 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
1644 (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
1645 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
1646 (clobber (match_scratch:SI 3 "=q,q"))]
1649 {muls|mullw} %0,%1,%2
1650 {muli|mulli} %0,%1,%2"
1652 (cond [(match_operand:SI 2 "s8bit_cint_operand" "")
1653 (const_string "imul3")
1654 (match_operand:SI 2 "short_cint_operand" "")
1655 (const_string "imul2")]
1656 (const_string "imul")))])
1658 (define_insn "mulsi3_no_mq"
1659 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
1660 (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
1661 (match_operand:SI 2 "reg_or_short_operand" "r,I")))]
1664 {muls|mullw} %0,%1,%2
1665 {muli|mulli} %0,%1,%2"
1667 (cond [(match_operand:SI 2 "s8bit_cint_operand" "")
1668 (const_string "imul3")
1669 (match_operand:SI 2 "short_cint_operand" "")
1670 (const_string "imul2")]
1671 (const_string "imul")))])
1673 (define_insn "*mulsi3_mq_internal1"
1674 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1675 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
1676 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
1678 (clobber (match_scratch:SI 3 "=r,r"))
1679 (clobber (match_scratch:SI 4 "=q,q"))]
1682 {muls.|mullw.} %3,%1,%2
1684 [(set_attr "type" "imul_compare")
1685 (set_attr "length" "4,8")])
1688 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1689 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
1690 (match_operand:SI 2 "gpc_reg_operand" ""))
1692 (clobber (match_scratch:SI 3 ""))
1693 (clobber (match_scratch:SI 4 ""))]
1694 "TARGET_POWER && reload_completed"
1695 [(parallel [(set (match_dup 3)
1696 (mult:SI (match_dup 1) (match_dup 2)))
1697 (clobber (match_dup 4))])
1699 (compare:CC (match_dup 3)
1703 (define_insn "*mulsi3_no_mq_internal1"
1704 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1705 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
1706 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
1708 (clobber (match_scratch:SI 3 "=r,r"))]
1711 {muls.|mullw.} %3,%1,%2
1713 [(set_attr "type" "imul_compare")
1714 (set_attr "length" "4,8")])
1717 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1718 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
1719 (match_operand:SI 2 "gpc_reg_operand" ""))
1721 (clobber (match_scratch:SI 3 ""))]
1722 "! TARGET_POWER && reload_completed"
1724 (mult:SI (match_dup 1) (match_dup 2)))
1726 (compare:CC (match_dup 3)
1730 (define_insn "*mulsi3_mq_internal2"
1731 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1732 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
1733 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
1735 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
1736 (mult:SI (match_dup 1) (match_dup 2)))
1737 (clobber (match_scratch:SI 4 "=q,q"))]
1740 {muls.|mullw.} %0,%1,%2
1742 [(set_attr "type" "imul_compare")
1743 (set_attr "length" "4,8")])
1746 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
1747 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
1748 (match_operand:SI 2 "gpc_reg_operand" ""))
1750 (set (match_operand:SI 0 "gpc_reg_operand" "")
1751 (mult:SI (match_dup 1) (match_dup 2)))
1752 (clobber (match_scratch:SI 4 ""))]
1753 "TARGET_POWER && reload_completed"
1754 [(parallel [(set (match_dup 0)
1755 (mult:SI (match_dup 1) (match_dup 2)))
1756 (clobber (match_dup 4))])
1758 (compare:CC (match_dup 0)
1762 (define_insn "*mulsi3_no_mq_internal2"
1763 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1764 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
1765 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
1767 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
1768 (mult:SI (match_dup 1) (match_dup 2)))]
1771 {muls.|mullw.} %0,%1,%2
1773 [(set_attr "type" "imul_compare")
1774 (set_attr "length" "4,8")])
1777 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
1778 (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
1779 (match_operand:SI 2 "gpc_reg_operand" ""))
1781 (set (match_operand:SI 0 "gpc_reg_operand" "")
1782 (mult:SI (match_dup 1) (match_dup 2)))]
1783 "! TARGET_POWER && reload_completed"
1785 (mult:SI (match_dup 1) (match_dup 2)))
1787 (compare:CC (match_dup 0)
1791 ;; Operand 1 is divided by operand 2; quotient goes to operand
1792 ;; 0 and remainder to operand 3.
1793 ;; ??? At some point, see what, if anything, we can do about if (x % y == 0).
1795 (define_expand "divmodsi4"
1796 [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
1797 (div:SI (match_operand:SI 1 "gpc_reg_operand" "")
1798 (match_operand:SI 2 "gpc_reg_operand" "")))
1799 (set (match_operand:SI 3 "register_operand" "")
1800 (mod:SI (match_dup 1) (match_dup 2)))])]
1801 "TARGET_POWER || (! TARGET_POWER && ! TARGET_POWERPC)"
1804 if (! TARGET_POWER && ! TARGET_POWERPC)
1806 emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
1807 emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
1808 emit_insn (gen_divss_call ());
1809 emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
1810 emit_move_insn (operands[3], gen_rtx_REG (SImode, 4));
1815 (define_insn "*divmodsi4_internal"
1816 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1817 (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
1818 (match_operand:SI 2 "gpc_reg_operand" "r")))
1819 (set (match_operand:SI 3 "register_operand" "=q")
1820 (mod:SI (match_dup 1) (match_dup 2)))]
1823 [(set_attr "type" "idiv")])
1825 (define_expand "udiv<mode>3"
1826 [(set (match_operand:GPR 0 "gpc_reg_operand" "")
1827 (udiv:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
1828 (match_operand:GPR 2 "gpc_reg_operand" "")))]
1829 "TARGET_POWERPC || (! TARGET_POWER && ! TARGET_POWERPC)"
1832 if (! TARGET_POWER && ! TARGET_POWERPC)
1834 emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
1835 emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
1836 emit_insn (gen_quous_call ());
1837 emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
1840 else if (TARGET_POWER)
1842 emit_insn (gen_udivsi3_mq (operands[0], operands[1], operands[2]));
1847 (define_insn "udivsi3_mq"
1848 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1849 (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "r")
1850 (match_operand:SI 2 "gpc_reg_operand" "r")))
1851 (clobber (match_scratch:SI 3 "=q"))]
1852 "TARGET_POWERPC && TARGET_POWER"
1854 [(set_attr "type" "idiv")])
1856 (define_insn "*udivsi3_no_mq"
1857 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
1858 (udiv:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")
1859 (match_operand:GPR 2 "gpc_reg_operand" "r")))]
1860 "TARGET_POWERPC && ! TARGET_POWER"
1862 [(set_attr "type" "idiv")])
1864 ;; For powers of two we can do srai/aze for divide and then adjust for
1865 ;; modulus. If it isn't a power of two, FAIL on POWER so divmodsi4 will be
1866 ;; used; for PowerPC, force operands into register and do a normal divide;
1867 ;; for AIX common-mode, use quoss call on register operands.
1868 (define_expand "div<mode>3"
1869 [(set (match_operand:GPR 0 "gpc_reg_operand" "")
1870 (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
1871 (match_operand:GPR 2 "reg_or_cint_operand" "")))]
1875 if (GET_CODE (operands[2]) == CONST_INT
1876 && INTVAL (operands[2]) > 0
1877 && exact_log2 (INTVAL (operands[2])) >= 0)
1879 else if (TARGET_POWERPC)
1881 operands[2] = force_reg (SImode, operands[2]);
1884 emit_insn (gen_divsi3_mq (operands[0], operands[1], operands[2]));
1888 else if (TARGET_POWER)
1892 emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
1893 emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
1894 emit_insn (gen_quoss_call ());
1895 emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
1900 (define_insn "divsi3_mq"
1901 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1902 (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
1903 (match_operand:SI 2 "gpc_reg_operand" "r")))
1904 (clobber (match_scratch:SI 3 "=q"))]
1905 "TARGET_POWERPC && TARGET_POWER"
1907 [(set_attr "type" "idiv")])
1909 (define_insn "*div<mode>3_no_mq"
1910 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
1911 (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")
1912 (match_operand:GPR 2 "gpc_reg_operand" "r")))]
1913 "TARGET_POWERPC && ! TARGET_POWER"
1915 [(set_attr "type" "idiv")])
1917 (define_expand "mod<mode>3"
1918 [(use (match_operand:GPR 0 "gpc_reg_operand" ""))
1919 (use (match_operand:GPR 1 "gpc_reg_operand" ""))
1920 (use (match_operand:GPR 2 "reg_or_cint_operand" ""))]
1928 if (GET_CODE (operands[2]) != CONST_INT
1929 || INTVAL (operands[2]) <= 0
1930 || (i = exact_log2 (INTVAL (operands[2]))) < 0)
1933 temp1 = gen_reg_rtx (<MODE>mode);
1934 temp2 = gen_reg_rtx (<MODE>mode);
1936 emit_insn (gen_div<mode>3 (temp1, operands[1], operands[2]));
1937 emit_insn (gen_ashl<mode>3 (temp2, temp1, GEN_INT (i)));
1938 emit_insn (gen_sub<mode>3 (operands[0], operands[1], temp2));
1943 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
1944 (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")
1945 (match_operand:GPR 2 "exact_log2_cint_operand" "N")))]
1947 "{srai|sra<wd>i} %0,%1,%p2\;{aze|addze} %0,%0"
1948 [(set_attr "type" "two")
1949 (set_attr "length" "8")])
1952 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1953 (compare:CC (div:P (match_operand:P 1 "gpc_reg_operand" "r,r")
1954 (match_operand:P 2 "exact_log2_cint_operand" "N,N"))
1956 (clobber (match_scratch:P 3 "=r,r"))]
1959 {srai|sra<wd>i} %3,%1,%p2\;{aze.|addze.} %3,%3
1961 [(set_attr "type" "compare")
1962 (set_attr "length" "8,12")])
1965 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1966 (compare:CC (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
1967 (match_operand:GPR 2 "exact_log2_cint_operand"
1970 (clobber (match_scratch:GPR 3 ""))]
1973 (div:<MODE> (match_dup 1) (match_dup 2)))
1975 (compare:CC (match_dup 3)
1980 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1981 (compare:CC (div:P (match_operand:P 1 "gpc_reg_operand" "r,r")
1982 (match_operand:P 2 "exact_log2_cint_operand" "N,N"))
1984 (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
1985 (div:P (match_dup 1) (match_dup 2)))]
1988 {srai|sra<wd>i} %0,%1,%p2\;{aze.|addze.} %0,%0
1990 [(set_attr "type" "compare")
1991 (set_attr "length" "8,12")])
1994 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
1995 (compare:CC (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
1996 (match_operand:GPR 2 "exact_log2_cint_operand"
1999 (set (match_operand:GPR 0 "gpc_reg_operand" "")
2000 (div:GPR (match_dup 1) (match_dup 2)))]
2003 (div:<MODE> (match_dup 1) (match_dup 2)))
2005 (compare:CC (match_dup 0)
2010 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2013 (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
2015 (zero_extend:DI (match_operand:SI 4 "register_operand" "2")))
2016 (match_operand:SI 3 "gpc_reg_operand" "r")))
2017 (set (match_operand:SI 2 "register_operand" "=*q")
2020 (zero_extend:DI (match_dup 1)) (const_int 32))
2021 (zero_extend:DI (match_dup 4)))
2025 [(set_attr "type" "idiv")])
2027 ;; To do unsigned divide we handle the cases of the divisor looking like a
2028 ;; negative number. If it is a constant that is less than 2**31, we don't
2029 ;; have to worry about the branches. So make a few subroutines here.
2031 ;; First comes the normal case.
2032 (define_expand "udivmodsi4_normal"
2033 [(set (match_dup 4) (const_int 0))
2034 (parallel [(set (match_operand:SI 0 "" "")
2035 (udiv:SI (plus:DI (ashift:DI (zero_extend:DI (match_dup 4))
2037 (zero_extend:DI (match_operand:SI 1 "" "")))
2038 (match_operand:SI 2 "" "")))
2039 (set (match_operand:SI 3 "" "")
2040 (umod:SI (plus:DI (ashift:DI (zero_extend:DI (match_dup 4))
2042 (zero_extend:DI (match_dup 1)))
2046 { operands[4] = gen_reg_rtx (SImode); }")
2048 ;; This handles the branches.
2049 (define_expand "udivmodsi4_tests"
2050 [(set (match_operand:SI 0 "" "") (const_int 0))
2051 (set (match_operand:SI 3 "" "") (match_operand:SI 1 "" ""))
2052 (set (match_dup 5) (compare:CCUNS (match_dup 1) (match_operand:SI 2 "" "")))
2053 (set (pc) (if_then_else (ltu (match_dup 5) (const_int 0))
2054 (label_ref (match_operand:SI 4 "" "")) (pc)))
2055 (set (match_dup 0) (const_int 1))
2056 (set (match_dup 3) (minus:SI (match_dup 1) (match_dup 2)))
2057 (set (match_dup 6) (compare:CC (match_dup 2) (const_int 0)))
2058 (set (pc) (if_then_else (lt (match_dup 6) (const_int 0))
2059 (label_ref (match_dup 4)) (pc)))]
2062 { operands[5] = gen_reg_rtx (CCUNSmode);
2063 operands[6] = gen_reg_rtx (CCmode);
2066 (define_expand "udivmodsi4"
2067 [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
2068 (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "")
2069 (match_operand:SI 2 "reg_or_cint_operand" "")))
2070 (set (match_operand:SI 3 "gpc_reg_operand" "")
2071 (umod:SI (match_dup 1) (match_dup 2)))])]
2079 if (! TARGET_POWERPC)
2081 emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
2082 emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
2083 emit_insn (gen_divus_call ());
2084 emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
2085 emit_move_insn (operands[3], gen_rtx_REG (SImode, 4));
2092 if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) < 0)
2094 operands[2] = force_reg (SImode, operands[2]);
2095 label = gen_label_rtx ();
2096 emit (gen_udivmodsi4_tests (operands[0], operands[1], operands[2],
2097 operands[3], label));
2100 operands[2] = force_reg (SImode, operands[2]);
2102 emit (gen_udivmodsi4_normal (operands[0], operands[1], operands[2],
2110 ;; AIX architecture-independent common-mode multiply (DImode),
2111 ;; divide/modulus, and quotient subroutine calls. Input operands in R3 and
2112 ;; R4; results in R3 and sometimes R4; link register always clobbered by bla
2113 ;; instruction; R0 sometimes clobbered; also, MQ sometimes clobbered but
2114 ;; assumed unused if generating common-mode, so ignore.
2115 (define_insn "mulh_call"
2118 (lshiftrt:DI (mult:DI (sign_extend:DI (reg:SI 3))
2119 (sign_extend:DI (reg:SI 4)))
2121 (clobber (match_scratch:SI 0 "=l"))]
2122 "! TARGET_POWER && ! TARGET_POWERPC"
2124 [(set_attr "type" "imul")])
2126 (define_insn "mull_call"
2128 (mult:DI (sign_extend:DI (reg:SI 3))
2129 (sign_extend:DI (reg:SI 4))))
2130 (clobber (match_scratch:SI 0 "=l"))
2131 (clobber (reg:SI 0))]
2132 "! TARGET_POWER && ! TARGET_POWERPC"
2134 [(set_attr "type" "imul")])
2136 (define_insn "divss_call"
2138 (div:SI (reg:SI 3) (reg:SI 4)))
2140 (mod:SI (reg:SI 3) (reg:SI 4)))
2141 (clobber (match_scratch:SI 0 "=l"))
2142 (clobber (reg:SI 0))]
2143 "! TARGET_POWER && ! TARGET_POWERPC"
2145 [(set_attr "type" "idiv")])
2147 (define_insn "divus_call"
2149 (udiv:SI (reg:SI 3) (reg:SI 4)))
2151 (umod:SI (reg:SI 3) (reg:SI 4)))
2152 (clobber (match_scratch:SI 0 "=l"))
2153 (clobber (reg:SI 0))
2154 (clobber (match_scratch:CC 1 "=x"))
2155 (clobber (reg:CC 69))]
2156 "! TARGET_POWER && ! TARGET_POWERPC"
2158 [(set_attr "type" "idiv")])
2160 (define_insn "quoss_call"
2162 (div:SI (reg:SI 3) (reg:SI 4)))
2163 (clobber (match_scratch:SI 0 "=l"))]
2164 "! TARGET_POWER && ! TARGET_POWERPC"
2166 [(set_attr "type" "idiv")])
2168 (define_insn "quous_call"
2170 (udiv:SI (reg:SI 3) (reg:SI 4)))
2171 (clobber (match_scratch:SI 0 "=l"))
2172 (clobber (reg:SI 0))
2173 (clobber (match_scratch:CC 1 "=x"))
2174 (clobber (reg:CC 69))]
2175 "! TARGET_POWER && ! TARGET_POWERPC"
2177 [(set_attr "type" "idiv")])
2179 ;; Logical instructions
2180 ;; The logical instructions are mostly combined by using match_operator,
2181 ;; but the plain AND insns are somewhat different because there is no
2182 ;; plain 'andi' (only 'andi.'), no plain 'andis', and there are all
2183 ;; those rotate-and-mask operations. Thus, the AND insns come first.
2185 (define_insn "andsi3"
2186 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
2187 (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r")
2188 (match_operand:SI 2 "and_operand" "?r,T,K,L")))
2189 (clobber (match_scratch:CC 3 "=X,X,x,x"))]
2193 {rlinm|rlwinm} %0,%1,0,%m2,%M2
2194 {andil.|andi.} %0,%1,%b2
2195 {andiu.|andis.} %0,%1,%u2"
2196 [(set_attr "type" "*,*,compare,compare")])
2198 ;; Note to set cr's other than cr0 we do the and immediate and then
2199 ;; the test again -- this avoids a mfcr which on the higher end
2200 ;; machines causes an execution serialization
2202 (define_insn "*andsi3_internal2"
2203 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2204 (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2205 (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2207 (clobber (match_scratch:SI 3 "=r,r,r,r,r,r,r,r"))
2208 (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2212 {andil.|andi.} %3,%1,%b2
2213 {andiu.|andis.} %3,%1,%u2
2214 {rlinm.|rlwinm.} %3,%1,0,%m2,%M2
2219 [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2220 (set_attr "length" "4,4,4,4,8,8,8,8")])
2222 (define_insn "*andsi3_internal3"
2223 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2224 (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2225 (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2227 (clobber (match_scratch:SI 3 "=r,r,r,r,r,r,r,r"))
2228 (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2232 {andil.|andi.} %3,%1,%b2
2233 {andiu.|andis.} %3,%1,%u2
2234 {rlinm.|rlwinm.} %3,%1,0,%m2,%M2
2239 [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2240 (set_attr "length" "8,4,4,4,8,8,8,8")])
2243 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2244 (compare:CC (and:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2245 (match_operand:GPR 2 "and_operand" ""))
2247 (clobber (match_scratch:GPR 3 ""))
2248 (clobber (match_scratch:CC 4 ""))]
2250 [(parallel [(set (match_dup 3)
2251 (and:<MODE> (match_dup 1)
2253 (clobber (match_dup 4))])
2255 (compare:CC (match_dup 3)
2259 ;; We don't have a 32 bit "and. rt,ra,rb" for ppc64. cr is set from the
2260 ;; whole 64 bit reg, and we don't know what is in the high 32 bits.
2263 [(set (match_operand:CC 0 "cc_reg_operand" "")
2264 (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
2265 (match_operand:SI 2 "gpc_reg_operand" ""))
2267 (clobber (match_scratch:SI 3 ""))
2268 (clobber (match_scratch:CC 4 ""))]
2269 "TARGET_POWERPC64 && reload_completed"
2270 [(parallel [(set (match_dup 3)
2271 (and:SI (match_dup 1)
2273 (clobber (match_dup 4))])
2275 (compare:CC (match_dup 3)
2279 (define_insn "*andsi3_internal4"
2280 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2281 (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2282 (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2284 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r,r,r,r")
2285 (and:SI (match_dup 1)
2287 (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2291 {andil.|andi.} %0,%1,%b2
2292 {andiu.|andis.} %0,%1,%u2
2293 {rlinm.|rlwinm.} %0,%1,0,%m2,%M2
2298 [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2299 (set_attr "length" "4,4,4,4,8,8,8,8")])
2301 (define_insn "*andsi3_internal5"
2302 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2303 (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2304 (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2306 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r,r,r,r")
2307 (and:SI (match_dup 1)
2309 (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2313 {andil.|andi.} %0,%1,%b2
2314 {andiu.|andis.} %0,%1,%u2
2315 {rlinm.|rlwinm.} %0,%1,0,%m2,%M2
2320 [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2321 (set_attr "length" "8,4,4,4,8,8,8,8")])
2324 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2325 (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
2326 (match_operand:SI 2 "and_operand" ""))
2328 (set (match_operand:SI 0 "gpc_reg_operand" "")
2329 (and:SI (match_dup 1)
2331 (clobber (match_scratch:CC 4 ""))]
2333 [(parallel [(set (match_dup 0)
2334 (and:SI (match_dup 1)
2336 (clobber (match_dup 4))])
2338 (compare:CC (match_dup 0)
2343 [(set (match_operand:CC 3 "cc_reg_operand" "")
2344 (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
2345 (match_operand:SI 2 "gpc_reg_operand" ""))
2347 (set (match_operand:SI 0 "gpc_reg_operand" "")
2348 (and:SI (match_dup 1)
2350 (clobber (match_scratch:CC 4 ""))]
2351 "TARGET_POWERPC64 && reload_completed"
2352 [(parallel [(set (match_dup 0)
2353 (and:SI (match_dup 1)
2355 (clobber (match_dup 4))])
2357 (compare:CC (match_dup 0)
2361 ;; Handle the PowerPC64 rlwinm corner case
2363 (define_insn_and_split "*andsi3_internal6"
2364 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2365 (and:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2366 (match_operand:SI 2 "mask_operand_wrap" "i")))]
2371 (and:SI (rotate:SI (match_dup 1) (match_dup 3))
2374 (rotate:SI (match_dup 0) (match_dup 5)))]
2377 int mb = extract_MB (operands[2]);
2378 int me = extract_ME (operands[2]);
2379 operands[3] = GEN_INT (me + 1);
2380 operands[5] = GEN_INT (32 - (me + 1));
2381 operands[4] = GEN_INT (~((HOST_WIDE_INT) -1 << (33 + me - mb)));
2383 [(set_attr "length" "8")])
2385 (define_expand "iorsi3"
2386 [(set (match_operand:SI 0 "gpc_reg_operand" "")
2387 (ior:SI (match_operand:SI 1 "gpc_reg_operand" "")
2388 (match_operand:SI 2 "reg_or_logical_cint_operand" "")))]
2392 if (GET_CODE (operands[2]) == CONST_INT
2393 && ! logical_operand (operands[2], SImode))
2395 HOST_WIDE_INT value = INTVAL (operands[2]);
2396 rtx tmp = ((no_new_pseudos || rtx_equal_p (operands[0], operands[1]))
2397 ? operands[0] : gen_reg_rtx (SImode));
2399 emit_insn (gen_iorsi3 (tmp, operands[1],
2400 GEN_INT (value & (~ (HOST_WIDE_INT) 0xffff))));
2401 emit_insn (gen_iorsi3 (operands[0], tmp, GEN_INT (value & 0xffff)));
2406 (define_expand "xorsi3"
2407 [(set (match_operand:SI 0 "gpc_reg_operand" "")
2408 (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
2409 (match_operand:SI 2 "reg_or_logical_cint_operand" "")))]
2413 if (GET_CODE (operands[2]) == CONST_INT
2414 && ! logical_operand (operands[2], SImode))
2416 HOST_WIDE_INT value = INTVAL (operands[2]);
2417 rtx tmp = ((no_new_pseudos || rtx_equal_p (operands[0], operands[1]))
2418 ? operands[0] : gen_reg_rtx (SImode));
2420 emit_insn (gen_xorsi3 (tmp, operands[1],
2421 GEN_INT (value & (~ (HOST_WIDE_INT) 0xffff))));
2422 emit_insn (gen_xorsi3 (operands[0], tmp, GEN_INT (value & 0xffff)));
2427 (define_insn "*boolsi3_internal1"
2428 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
2429 (match_operator:SI 3 "boolean_or_operator"
2430 [(match_operand:SI 1 "gpc_reg_operand" "%r,r,r")
2431 (match_operand:SI 2 "logical_operand" "r,K,L")]))]
2435 {%q3il|%q3i} %0,%1,%b2
2436 {%q3iu|%q3is} %0,%1,%u2")
2438 (define_insn "*boolsi3_internal2"
2439 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
2440 (compare:CC (match_operator:SI 4 "boolean_or_operator"
2441 [(match_operand:SI 1 "gpc_reg_operand" "%r,r")
2442 (match_operand:SI 2 "gpc_reg_operand" "r,r")])
2444 (clobber (match_scratch:SI 3 "=r,r"))]
2449 [(set_attr "type" "compare")
2450 (set_attr "length" "4,8")])
2453 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2454 (compare:CC (match_operator:SI 4 "boolean_operator"
2455 [(match_operand:SI 1 "gpc_reg_operand" "")
2456 (match_operand:SI 2 "gpc_reg_operand" "")])
2458 (clobber (match_scratch:SI 3 ""))]
2459 "TARGET_32BIT && reload_completed"
2460 [(set (match_dup 3) (match_dup 4))
2462 (compare:CC (match_dup 3)
2466 (define_insn "*boolsi3_internal3"
2467 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
2468 (compare:CC (match_operator:SI 4 "boolean_operator"
2469 [(match_operand:SI 1 "gpc_reg_operand" "%r,r")
2470 (match_operand:SI 2 "gpc_reg_operand" "r,r")])
2472 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2478 [(set_attr "type" "compare")
2479 (set_attr "length" "4,8")])
2482 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2483 (compare:CC (match_operator:SI 4 "boolean_operator"
2484 [(match_operand:SI 1 "gpc_reg_operand" "")
2485 (match_operand:SI 2 "gpc_reg_operand" "")])
2487 (set (match_operand:SI 0 "gpc_reg_operand" "")
2489 "TARGET_32BIT && reload_completed"
2490 [(set (match_dup 0) (match_dup 4))
2492 (compare:CC (match_dup 0)
2496 ;; Split a logical operation that we can't do in one insn into two insns,
2497 ;; each of which does one 16-bit part. This is used by combine.
2500 [(set (match_operand:SI 0 "gpc_reg_operand" "")
2501 (match_operator:SI 3 "boolean_or_operator"
2502 [(match_operand:SI 1 "gpc_reg_operand" "")
2503 (match_operand:SI 2 "non_logical_cint_operand" "")]))]
2505 [(set (match_dup 0) (match_dup 4))
2506 (set (match_dup 0) (match_dup 5))]
2510 i = GEN_INT (INTVAL (operands[2]) & (~ (HOST_WIDE_INT) 0xffff));
2511 operands[4] = gen_rtx_fmt_ee (GET_CODE (operands[3]), SImode,
2513 i = GEN_INT (INTVAL (operands[2]) & 0xffff);
2514 operands[5] = gen_rtx_fmt_ee (GET_CODE (operands[3]), SImode,
2518 (define_insn "*boolcsi3_internal1"
2519 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2520 (match_operator:SI 3 "boolean_operator"
2521 [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
2522 (match_operand:SI 2 "gpc_reg_operand" "r")]))]
2526 (define_insn "*boolcsi3_internal2"
2527 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
2528 (compare:CC (match_operator:SI 4 "boolean_operator"
2529 [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r,r"))
2530 (match_operand:SI 2 "gpc_reg_operand" "r,r")])
2532 (clobber (match_scratch:SI 3 "=r,r"))]
2537 [(set_attr "type" "compare")
2538 (set_attr "length" "4,8")])
2541 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2542 (compare:CC (match_operator:SI 4 "boolean_operator"
2543 [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
2544 (match_operand:SI 2 "gpc_reg_operand" "")])
2546 (clobber (match_scratch:SI 3 ""))]
2547 "TARGET_32BIT && reload_completed"
2548 [(set (match_dup 3) (match_dup 4))
2550 (compare:CC (match_dup 3)
2554 (define_insn "*boolcsi3_internal3"
2555 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
2556 (compare:CC (match_operator:SI 4 "boolean_operator"
2557 [(not:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r"))
2558 (match_operand:SI 2 "gpc_reg_operand" "r,r")])
2560 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2566 [(set_attr "type" "compare")
2567 (set_attr "length" "4,8")])
2570 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2571 (compare:CC (match_operator:SI 4 "boolean_operator"
2572 [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
2573 (match_operand:SI 2 "gpc_reg_operand" "")])
2575 (set (match_operand:SI 0 "gpc_reg_operand" "")
2577 "TARGET_32BIT && reload_completed"
2578 [(set (match_dup 0) (match_dup 4))
2580 (compare:CC (match_dup 0)
2584 (define_insn "*boolccsi3_internal1"
2585 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2586 (match_operator:SI 3 "boolean_operator"
2587 [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
2588 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))]))]
2592 (define_insn "*boolccsi3_internal2"
2593 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
2594 (compare:CC (match_operator:SI 4 "boolean_operator"
2595 [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r,r"))
2596 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r,r"))])
2598 (clobber (match_scratch:SI 3 "=r,r"))]
2603 [(set_attr "type" "compare")
2604 (set_attr "length" "4,8")])
2607 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2608 (compare:CC (match_operator:SI 4 "boolean_operator"
2609 [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
2610 (not:SI (match_operand:SI 2 "gpc_reg_operand" ""))])
2612 (clobber (match_scratch:SI 3 ""))]
2613 "TARGET_32BIT && reload_completed"
2614 [(set (match_dup 3) (match_dup 4))
2616 (compare:CC (match_dup 3)
2620 (define_insn "*boolccsi3_internal3"
2621 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
2622 (compare:CC (match_operator:SI 4 "boolean_operator"
2623 [(not:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r"))
2624 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r,r"))])
2626 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2632 [(set_attr "type" "compare")
2633 (set_attr "length" "4,8")])
2636 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2637 (compare:CC (match_operator:SI 4 "boolean_operator"
2638 [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
2639 (not:SI (match_operand:SI 2 "gpc_reg_operand" ""))])
2641 (set (match_operand:SI 0 "gpc_reg_operand" "")
2643 "TARGET_32BIT && reload_completed"
2644 [(set (match_dup 0) (match_dup 4))
2646 (compare:CC (match_dup 0)
2650 ;; maskir insn. We need four forms because things might be in arbitrary
2651 ;; orders. Don't define forms that only set CR fields because these
2652 ;; would modify an input register.
2654 (define_insn "*maskir_internal1"
2655 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2656 (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
2657 (match_operand:SI 1 "gpc_reg_operand" "0"))
2658 (and:SI (match_dup 2)
2659 (match_operand:SI 3 "gpc_reg_operand" "r"))))]
2663 (define_insn "*maskir_internal2"
2664 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2665 (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
2666 (match_operand:SI 1 "gpc_reg_operand" "0"))
2667 (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
2672 (define_insn "*maskir_internal3"
2673 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2674 (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "r")
2675 (match_operand:SI 3 "gpc_reg_operand" "r"))
2676 (and:SI (not:SI (match_dup 2))
2677 (match_operand:SI 1 "gpc_reg_operand" "0"))))]
2681 (define_insn "*maskir_internal4"
2682 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2683 (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
2684 (match_operand:SI 2 "gpc_reg_operand" "r"))
2685 (and:SI (not:SI (match_dup 2))
2686 (match_operand:SI 1 "gpc_reg_operand" "0"))))]
2690 (define_insn "*maskir_internal5"
2691 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
2693 (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2694 (match_operand:SI 1 "gpc_reg_operand" "0,0"))
2695 (and:SI (match_dup 2)
2696 (match_operand:SI 3 "gpc_reg_operand" "r,r")))
2698 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2699 (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
2700 (and:SI (match_dup 2) (match_dup 3))))]
2705 [(set_attr "type" "compare")
2706 (set_attr "length" "4,8")])
2709 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
2711 (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" ""))
2712 (match_operand:SI 1 "gpc_reg_operand" ""))
2713 (and:SI (match_dup 2)
2714 (match_operand:SI 3 "gpc_reg_operand" "")))
2716 (set (match_operand:SI 0 "gpc_reg_operand" "")
2717 (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
2718 (and:SI (match_dup 2) (match_dup 3))))]
2719 "TARGET_POWER && reload_completed"
2721 (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
2722 (and:SI (match_dup 2) (match_dup 3))))
2724 (compare:CC (match_dup 0)
2728 (define_insn "*maskir_internal6"
2729 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
2731 (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2732 (match_operand:SI 1 "gpc_reg_operand" "0,0"))
2733 (and:SI (match_operand:SI 3 "gpc_reg_operand" "r,r")
2736 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2737 (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
2738 (and:SI (match_dup 3) (match_dup 2))))]
2743 [(set_attr "type" "compare")
2744 (set_attr "length" "4,8")])
2747 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
2749 (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" ""))
2750 (match_operand:SI 1 "gpc_reg_operand" ""))
2751 (and:SI (match_operand:SI 3 "gpc_reg_operand" "")
2754 (set (match_operand:SI 0 "gpc_reg_operand" "")
2755 (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
2756 (and:SI (match_dup 3) (match_dup 2))))]
2757 "TARGET_POWER && reload_completed"
2759 (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
2760 (and:SI (match_dup 3) (match_dup 2))))
2762 (compare:CC (match_dup 0)
2766 (define_insn "*maskir_internal7"
2767 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
2769 (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "r,r")
2770 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
2771 (and:SI (not:SI (match_dup 2))
2772 (match_operand:SI 1 "gpc_reg_operand" "0,0")))
2774 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2775 (ior:SI (and:SI (match_dup 2) (match_dup 3))
2776 (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
2781 [(set_attr "type" "compare")
2782 (set_attr "length" "4,8")])
2785 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
2787 (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "")
2788 (match_operand:SI 3 "gpc_reg_operand" ""))
2789 (and:SI (not:SI (match_dup 2))
2790 (match_operand:SI 1 "gpc_reg_operand" "")))
2792 (set (match_operand:SI 0 "gpc_reg_operand" "")
2793 (ior:SI (and:SI (match_dup 2) (match_dup 3))
2794 (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
2795 "TARGET_POWER && reload_completed"
2797 (ior:SI (and:SI (match_dup 2) (match_dup 3))
2798 (and:SI (not:SI (match_dup 2)) (match_dup 1))))
2800 (compare:CC (match_dup 0)
2804 (define_insn "*maskir_internal8"
2805 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
2807 (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "r,r")
2808 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2809 (and:SI (not:SI (match_dup 2))
2810 (match_operand:SI 1 "gpc_reg_operand" "0,0")))
2812 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2813 (ior:SI (and:SI (match_dup 3) (match_dup 2))
2814 (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
2819 [(set_attr "type" "compare")
2820 (set_attr "length" "4,8")])
2823 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
2825 (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "")
2826 (match_operand:SI 2 "gpc_reg_operand" ""))
2827 (and:SI (not:SI (match_dup 2))
2828 (match_operand:SI 1 "gpc_reg_operand" "")))
2830 (set (match_operand:SI 0 "gpc_reg_operand" "")
2831 (ior:SI (and:SI (match_dup 3) (match_dup 2))
2832 (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
2833 "TARGET_POWER && reload_completed"
2835 (ior:SI (and:SI (match_dup 3) (match_dup 2))
2836 (and:SI (not:SI (match_dup 2)) (match_dup 1))))
2838 (compare:CC (match_dup 0)
2842 ;; Rotate and shift insns, in all their variants. These support shifts,
2843 ;; field inserts and extracts, and various combinations thereof.
2844 (define_expand "insv"
2845 [(set (zero_extract (match_operand 0 "gpc_reg_operand" "")
2846 (match_operand:SI 1 "const_int_operand" "")
2847 (match_operand:SI 2 "const_int_operand" ""))
2848 (match_operand 3 "gpc_reg_operand" ""))]
2852 /* Do not handle 16/8 bit structures that fit in HI/QI modes directly, since
2853 the (SUBREG:SI (REG:HI xxx)) that is otherwise generated can confuse the
2854 compiler if the address of the structure is taken later. */
2855 if (GET_CODE (operands[0]) == SUBREG
2856 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (operands[0]))) < UNITS_PER_WORD))
2859 if (TARGET_POWERPC64 && GET_MODE (operands[0]) == DImode)
2860 emit_insn (gen_insvdi (operands[0], operands[1], operands[2], operands[3]));
2862 emit_insn (gen_insvsi (operands[0], operands[1], operands[2], operands[3]));
2866 (define_insn "insvsi"
2867 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
2868 (match_operand:SI 1 "const_int_operand" "i")
2869 (match_operand:SI 2 "const_int_operand" "i"))
2870 (match_operand:SI 3 "gpc_reg_operand" "r"))]
2874 int start = INTVAL (operands[2]) & 31;
2875 int size = INTVAL (operands[1]) & 31;
2877 operands[4] = GEN_INT (32 - start - size);
2878 operands[1] = GEN_INT (start + size - 1);
2879 return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
2881 [(set_attr "type" "insert_word")])
2883 (define_insn "*insvsi_internal1"
2884 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
2885 (match_operand:SI 1 "const_int_operand" "i")
2886 (match_operand:SI 2 "const_int_operand" "i"))
2887 (rotate:SI (match_operand:SI 3 "gpc_reg_operand" "r")
2888 (match_operand:SI 4 "const_int_operand" "i")))]
2889 "(32 - (INTVAL (operands[4]) & 31)) >= INTVAL (operands[1])"
2892 int shift = INTVAL (operands[4]) & 31;
2893 int start = INTVAL (operands[2]) & 31;
2894 int size = INTVAL (operands[1]) & 31;
2896 operands[4] = GEN_INT (shift - start - size);
2897 operands[1] = GEN_INT (start + size - 1);
2898 return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
2900 [(set_attr "type" "insert_word")])
2902 (define_insn "*insvsi_internal2"
2903 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
2904 (match_operand:SI 1 "const_int_operand" "i")
2905 (match_operand:SI 2 "const_int_operand" "i"))
2906 (ashiftrt:SI (match_operand:SI 3 "gpc_reg_operand" "r")
2907 (match_operand:SI 4 "const_int_operand" "i")))]
2908 "(32 - (INTVAL (operands[4]) & 31)) >= INTVAL (operands[1])"
2911 int shift = INTVAL (operands[4]) & 31;
2912 int start = INTVAL (operands[2]) & 31;
2913 int size = INTVAL (operands[1]) & 31;
2915 operands[4] = GEN_INT (32 - shift - start - size);
2916 operands[1] = GEN_INT (start + size - 1);
2917 return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
2919 [(set_attr "type" "insert_word")])
2921 (define_insn "*insvsi_internal3"
2922 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
2923 (match_operand:SI 1 "const_int_operand" "i")
2924 (match_operand:SI 2 "const_int_operand" "i"))
2925 (lshiftrt:SI (match_operand:SI 3 "gpc_reg_operand" "r")
2926 (match_operand:SI 4 "const_int_operand" "i")))]
2927 "(32 - (INTVAL (operands[4]) & 31)) >= INTVAL (operands[1])"
2930 int shift = INTVAL (operands[4]) & 31;
2931 int start = INTVAL (operands[2]) & 31;
2932 int size = INTVAL (operands[1]) & 31;
2934 operands[4] = GEN_INT (32 - shift - start - size);
2935 operands[1] = GEN_INT (start + size - 1);
2936 return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
2938 [(set_attr "type" "insert_word")])
2940 (define_insn "*insvsi_internal4"
2941 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
2942 (match_operand:SI 1 "const_int_operand" "i")
2943 (match_operand:SI 2 "const_int_operand" "i"))
2944 (zero_extract:SI (match_operand:SI 3 "gpc_reg_operand" "r")
2945 (match_operand:SI 4 "const_int_operand" "i")
2946 (match_operand:SI 5 "const_int_operand" "i")))]
2947 "INTVAL (operands[4]) >= INTVAL (operands[1])"
2950 int extract_start = INTVAL (operands[5]) & 31;
2951 int extract_size = INTVAL (operands[4]) & 31;
2952 int insert_start = INTVAL (operands[2]) & 31;
2953 int insert_size = INTVAL (operands[1]) & 31;
2955 /* Align extract field with insert field */
2956 operands[5] = GEN_INT (extract_start + extract_size - insert_start - insert_size);
2957 operands[1] = GEN_INT (insert_start + insert_size - 1);
2958 return \"{rlimi|rlwimi} %0,%3,%h5,%h2,%h1\";
2960 [(set_attr "type" "insert_word")])
2962 ;; combine patterns for rlwimi
2963 (define_insn "*insvsi_internal5"
2964 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2965 (ior:SI (and:SI (match_operand:SI 4 "gpc_reg_operand" "0")
2966 (match_operand:SI 1 "mask_operand" "i"))
2967 (and:SI (lshiftrt:SI (match_operand:SI 3 "gpc_reg_operand" "r")
2968 (match_operand:SI 2 "const_int_operand" "i"))
2969 (match_operand:SI 5 "mask_operand" "i"))))]
2970 "TARGET_POWERPC && INTVAL(operands[1]) == ~INTVAL(operands[5])"
2973 int me = extract_ME(operands[5]);
2974 int mb = extract_MB(operands[5]);
2975 operands[4] = GEN_INT(32 - INTVAL(operands[2]));
2976 operands[2] = GEN_INT(mb);
2977 operands[1] = GEN_INT(me);
2978 return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
2980 [(set_attr "type" "insert_word")])
2982 (define_insn "*insvsi_internal6"
2983 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2984 (ior:SI (and:SI (lshiftrt:SI (match_operand:SI 3 "gpc_reg_operand" "r")
2985 (match_operand:SI 2 "const_int_operand" "i"))
2986 (match_operand:SI 5 "mask_operand" "i"))
2987 (and:SI (match_operand:SI 4 "gpc_reg_operand" "0")
2988 (match_operand:SI 1 "mask_operand" "i"))))]
2989 "TARGET_POWERPC && INTVAL(operands[1]) == ~INTVAL(operands[5])"
2992 int me = extract_ME(operands[5]);
2993 int mb = extract_MB(operands[5]);
2994 operands[4] = GEN_INT(32 - INTVAL(operands[2]));
2995 operands[2] = GEN_INT(mb);
2996 operands[1] = GEN_INT(me);
2997 return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
2999 [(set_attr "type" "insert_word")])
3001 (define_insn "insvdi"
3002 [(set (zero_extract:DI (match_operand:DI 0 "gpc_reg_operand" "+r")
3003 (match_operand:SI 1 "const_int_operand" "i")
3004 (match_operand:SI 2 "const_int_operand" "i"))
3005 (match_operand:DI 3 "gpc_reg_operand" "r"))]
3009 int start = INTVAL (operands[2]) & 63;
3010 int size = INTVAL (operands[1]) & 63;
3012 operands[1] = GEN_INT (64 - start - size);
3013 return \"rldimi %0,%3,%H1,%H2\";
3016 (define_insn "*insvdi_internal2"
3017 [(set (zero_extract:DI (match_operand:DI 0 "gpc_reg_operand" "+r")
3018 (match_operand:SI 1 "const_int_operand" "i")
3019 (match_operand:SI 2 "const_int_operand" "i"))
3020 (ashiftrt:DI (match_operand:DI 3 "gpc_reg_operand" "r")
3021 (match_operand:SI 4 "const_int_operand" "i")))]
3023 && insvdi_rshift_rlwimi_p (operands[1], operands[2], operands[4])"
3026 int shift = INTVAL (operands[4]) & 63;
3027 int start = (INTVAL (operands[2]) & 63) - 32;
3028 int size = INTVAL (operands[1]) & 63;
3030 operands[4] = GEN_INT (64 - shift - start - size);
3031 operands[2] = GEN_INT (start);
3032 operands[1] = GEN_INT (start + size - 1);
3033 return \"rlwimi %0,%3,%h4,%h2,%h1\";
3036 (define_insn "*insvdi_internal3"
3037 [(set (zero_extract:DI (match_operand:DI 0 "gpc_reg_operand" "+r")
3038 (match_operand:SI 1 "const_int_operand" "i")
3039 (match_operand:SI 2 "const_int_operand" "i"))
3040 (lshiftrt:DI (match_operand:DI 3 "gpc_reg_operand" "r")
3041 (match_operand:SI 4 "const_int_operand" "i")))]
3043 && insvdi_rshift_rlwimi_p (operands[1], operands[2], operands[4])"
3046 int shift = INTVAL (operands[4]) & 63;
3047 int start = (INTVAL (operands[2]) & 63) - 32;
3048 int size = INTVAL (operands[1]) & 63;
3050 operands[4] = GEN_INT (64 - shift - start - size);
3051 operands[2] = GEN_INT (start);
3052 operands[1] = GEN_INT (start + size - 1);
3053 return \"rlwimi %0,%3,%h4,%h2,%h1\";
3056 (define_expand "extzv"
3057 [(set (match_operand 0 "gpc_reg_operand" "")
3058 (zero_extract (match_operand 1 "gpc_reg_operand" "")
3059 (match_operand:SI 2 "const_int_operand" "")
3060 (match_operand:SI 3 "const_int_operand" "")))]
3064 /* Do not handle 16/8 bit structures that fit in HI/QI modes directly, since
3065 the (SUBREG:SI (REG:HI xxx)) that is otherwise generated can confuse the
3066 compiler if the address of the structure is taken later. */
3067 if (GET_CODE (operands[0]) == SUBREG
3068 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (operands[0]))) < UNITS_PER_WORD))
3071 if (TARGET_POWERPC64 && GET_MODE (operands[1]) == DImode)
3072 emit_insn (gen_extzvdi (operands[0], operands[1], operands[2], operands[3]));
3074 emit_insn (gen_extzvsi (operands[0], operands[1], operands[2], operands[3]));
3078 (define_insn "extzvsi"
3079 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3080 (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r")
3081 (match_operand:SI 2 "const_int_operand" "i")
3082 (match_operand:SI 3 "const_int_operand" "i")))]
3086 int start = INTVAL (operands[3]) & 31;
3087 int size = INTVAL (operands[2]) & 31;
3089 if (start + size >= 32)
3090 operands[3] = const0_rtx;
3092 operands[3] = GEN_INT (start + size);
3093 return \"{rlinm|rlwinm} %0,%1,%3,%s2,31\";
3096 (define_insn "*extzvsi_internal1"
3097 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3098 (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3099 (match_operand:SI 2 "const_int_operand" "i,i")
3100 (match_operand:SI 3 "const_int_operand" "i,i"))
3102 (clobber (match_scratch:SI 4 "=r,r"))]
3106 int start = INTVAL (operands[3]) & 31;
3107 int size = INTVAL (operands[2]) & 31;
3109 /* Force split for non-cc0 compare. */
3110 if (which_alternative == 1)
3113 /* If the bit-field being tested fits in the upper or lower half of a
3114 word, it is possible to use andiu. or andil. to test it. This is
3115 useful because the condition register set-use delay is smaller for
3116 andi[ul]. than for rlinm. This doesn't work when the starting bit
3117 position is 0 because the LT and GT bits may be set wrong. */
3119 if ((start > 0 && start + size <= 16) || start >= 16)
3121 operands[3] = GEN_INT (((1 << (16 - (start & 15)))
3122 - (1 << (16 - (start & 15) - size))));
3124 return \"{andiu.|andis.} %4,%1,%3\";
3126 return \"{andil.|andi.} %4,%1,%3\";
3129 if (start + size >= 32)
3130 operands[3] = const0_rtx;
3132 operands[3] = GEN_INT (start + size);
3133 return \"{rlinm.|rlwinm.} %4,%1,%3,%s2,31\";
3135 [(set_attr "type" "compare")
3136 (set_attr "length" "4,8")])
3139 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3140 (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "")
3141 (match_operand:SI 2 "const_int_operand" "")
3142 (match_operand:SI 3 "const_int_operand" ""))
3144 (clobber (match_scratch:SI 4 ""))]
3147 (zero_extract:SI (match_dup 1) (match_dup 2)
3150 (compare:CC (match_dup 4)
3154 (define_insn "*extzvsi_internal2"
3155 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
3156 (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3157 (match_operand:SI 2 "const_int_operand" "i,i")
3158 (match_operand:SI 3 "const_int_operand" "i,i"))
3160 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3161 (zero_extract:SI (match_dup 1) (match_dup 2) (match_dup 3)))]
3165 int start = INTVAL (operands[3]) & 31;
3166 int size = INTVAL (operands[2]) & 31;
3168 /* Force split for non-cc0 compare. */
3169 if (which_alternative == 1)
3172 /* Since we are using the output value, we can't ignore any need for
3173 a shift. The bit-field must end at the LSB. */
3174 if (start >= 16 && start + size == 32)
3176 operands[3] = GEN_INT ((1 << size) - 1);
3177 return \"{andil.|andi.} %0,%1,%3\";
3180 if (start + size >= 32)
3181 operands[3] = const0_rtx;
3183 operands[3] = GEN_INT (start + size);
3184 return \"{rlinm.|rlwinm.} %0,%1,%3,%s2,31\";
3186 [(set_attr "type" "compare")
3187 (set_attr "length" "4,8")])
3190 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
3191 (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "")
3192 (match_operand:SI 2 "const_int_operand" "")
3193 (match_operand:SI 3 "const_int_operand" ""))
3195 (set (match_operand:SI 0 "gpc_reg_operand" "")
3196 (zero_extract:SI (match_dup 1) (match_dup 2) (match_dup 3)))]
3199 (zero_extract:SI (match_dup 1) (match_dup 2) (match_dup 3)))
3201 (compare:CC (match_dup 0)
3205 (define_insn "extzvdi"
3206 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
3207 (zero_extract:DI (match_operand:DI 1 "gpc_reg_operand" "r")
3208 (match_operand:SI 2 "const_int_operand" "i")
3209 (match_operand:SI 3 "const_int_operand" "i")))]
3213 int start = INTVAL (operands[3]) & 63;
3214 int size = INTVAL (operands[2]) & 63;
3216 if (start + size >= 64)
3217 operands[3] = const0_rtx;
3219 operands[3] = GEN_INT (start + size);
3220 operands[2] = GEN_INT (64 - size);
3221 return \"rldicl %0,%1,%3,%2\";
3224 (define_insn "*extzvdi_internal1"
3225 [(set (match_operand:CC 0 "gpc_reg_operand" "=x")
3226 (compare:CC (zero_extract:DI (match_operand:DI 1 "gpc_reg_operand" "r")
3227 (match_operand:SI 2 "const_int_operand" "i")
3228 (match_operand:SI 3 "const_int_operand" "i"))
3230 (clobber (match_scratch:DI 4 "=r"))]
3234 int start = INTVAL (operands[3]) & 63;
3235 int size = INTVAL (operands[2]) & 63;
3237 if (start + size >= 64)
3238 operands[3] = const0_rtx;
3240 operands[3] = GEN_INT (start + size);
3241 operands[2] = GEN_INT (64 - size);
3242 return \"rldicl. %4,%1,%3,%2\";
3244 [(set_attr "type" "compare")])
3246 (define_insn "*extzvdi_internal2"
3247 [(set (match_operand:CC 4 "gpc_reg_operand" "=x")
3248 (compare:CC (zero_extract:DI (match_operand:DI 1 "gpc_reg_operand" "r")
3249 (match_operand:SI 2 "const_int_operand" "i")
3250 (match_operand:SI 3 "const_int_operand" "i"))
3252 (set (match_operand:DI 0 "gpc_reg_operand" "=r")
3253 (zero_extract:DI (match_dup 1) (match_dup 2) (match_dup 3)))]
3257 int start = INTVAL (operands[3]) & 63;
3258 int size = INTVAL (operands[2]) & 63;
3260 if (start + size >= 64)
3261 operands[3] = const0_rtx;
3263 operands[3] = GEN_INT (start + size);
3264 operands[2] = GEN_INT (64 - size);
3265 return \"rldicl. %0,%1,%3,%2\";
3267 [(set_attr "type" "compare")])
3269 (define_insn "rotlsi3"
3270 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3271 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
3272 (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
3274 "{rl%I2nm|rlw%I2nm} %0,%1,%h2,0xffffffff")
3276 (define_insn "*rotlsi3_internal2"
3277 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3278 (compare:CC (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3279 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri"))
3281 (clobber (match_scratch:SI 3 "=r,r"))]
3284 {rl%I2nm.|rlw%I2nm.} %3,%1,%h2,0xffffffff
3286 [(set_attr "type" "delayed_compare")
3287 (set_attr "length" "4,8")])
3290 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3291 (compare:CC (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
3292 (match_operand:SI 2 "reg_or_cint_operand" ""))
3294 (clobber (match_scratch:SI 3 ""))]
3297 (rotate:SI (match_dup 1) (match_dup 2)))
3299 (compare:CC (match_dup 3)
3303 (define_insn "*rotlsi3_internal3"
3304 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
3305 (compare:CC (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3306 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri"))
3308 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3309 (rotate:SI (match_dup 1) (match_dup 2)))]
3312 {rl%I2nm.|rlw%I2nm.} %0,%1,%h2,0xffffffff
3314 [(set_attr "type" "delayed_compare")
3315 (set_attr "length" "4,8")])
3318 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
3319 (compare:CC (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
3320 (match_operand:SI 2 "reg_or_cint_operand" ""))
3322 (set (match_operand:SI 0 "gpc_reg_operand" "")
3323 (rotate:SI (match_dup 1) (match_dup 2)))]
3326 (rotate:SI (match_dup 1) (match_dup 2)))
3328 (compare:CC (match_dup 0)
3332 (define_insn "*rotlsi3_internal4"
3333 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3334 (and:SI (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
3335 (match_operand:SI 2 "reg_or_cint_operand" "ri"))
3336 (match_operand:SI 3 "mask_operand" "n")))]
3338 "{rl%I2nm|rlw%I2nm} %0,%1,%h2,%m3,%M3")
3340 (define_insn "*rotlsi3_internal5"
3341 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3343 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3344 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri"))
3345 (match_operand:SI 3 "mask_operand" "n,n"))
3347 (clobber (match_scratch:SI 4 "=r,r"))]
3350 {rl%I2nm.|rlw%I2nm.} %4,%1,%h2,%m3,%M3
3352 [(set_attr "type" "delayed_compare")
3353 (set_attr "length" "4,8")])
3356 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3358 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
3359 (match_operand:SI 2 "reg_or_cint_operand" ""))
3360 (match_operand:SI 3 "mask_operand" ""))
3362 (clobber (match_scratch:SI 4 ""))]
3365 (and:SI (rotate:SI (match_dup 1)
3369 (compare:CC (match_dup 4)
3373 (define_insn "*rotlsi3_internal6"
3374 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
3376 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3377 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri"))
3378 (match_operand:SI 3 "mask_operand" "n,n"))
3380 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3381 (and:SI (rotate:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
3384 {rl%I2nm.|rlw%I2nm.} %0,%1,%h2,%m3,%M3
3386 [(set_attr "type" "delayed_compare")
3387 (set_attr "length" "4,8")])
3390 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
3392 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
3393 (match_operand:SI 2 "reg_or_cint_operand" ""))
3394 (match_operand:SI 3 "mask_operand" ""))
3396 (set (match_operand:SI 0 "gpc_reg_operand" "")
3397 (and:SI (rotate:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
3400 (and:SI (rotate:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
3402 (compare:CC (match_dup 0)
3406 (define_insn "*rotlsi3_internal7"
3407 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3410 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
3411 (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0)))]
3413 "{rl%I2nm|rlw%I2nm} %0,%1,%h2,0xff")
3415 (define_insn "*rotlsi3_internal8"
3416 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3417 (compare:CC (zero_extend:SI
3419 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3420 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri")) 0))
3422 (clobber (match_scratch:SI 3 "=r,r"))]
3425 {rl%I2nm.|rlw%I2nm.} %3,%1,%h2,0xff
3427 [(set_attr "type" "delayed_compare")
3428 (set_attr "length" "4,8")])
3431 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3432 (compare:CC (zero_extend:SI
3434 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
3435 (match_operand:SI 2 "reg_or_cint_operand" "")) 0))
3437 (clobber (match_scratch:SI 3 ""))]
3440 (zero_extend:SI (subreg:QI
3441 (rotate:SI (match_dup 1)
3444 (compare:CC (match_dup 3)
3448 (define_insn "*rotlsi3_internal9"
3449 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
3450 (compare:CC (zero_extend:SI
3452 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3453 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri")) 0))
3455 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3456 (zero_extend:SI (subreg:QI (rotate:SI (match_dup 1) (match_dup 2)) 0)))]
3459 {rl%I2nm.|rlw%I2nm.} %0,%1,%h2,0xff
3461 [(set_attr "type" "delayed_compare")
3462 (set_attr "length" "4,8")])
3465 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
3466 (compare:CC (zero_extend:SI
3468 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
3469 (match_operand:SI 2 "reg_or_cint_operand" "")) 0))
3471 (set (match_operand:SI 0 "gpc_reg_operand" "")
3472 (zero_extend:SI (subreg:QI (rotate:SI (match_dup 1) (match_dup 2)) 0)))]
3475 (zero_extend:SI (subreg:QI (rotate:SI (match_dup 1) (match_dup 2)) 0)))
3477 (compare:CC (match_dup 0)
3481 (define_insn "*rotlsi3_internal10"
3482 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3485 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
3486 (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0)))]
3488 "{rl%I2nm|rlw%I2nm} %0,%1,%h2,0xffff")
3490 (define_insn "*rotlsi3_internal11"
3491 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3492 (compare:CC (zero_extend:SI
3494 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3495 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri")) 0))
3497 (clobber (match_scratch:SI 3 "=r,r"))]
3500 {rl%I2nm.|rlw%I2nm.} %3,%1,%h2,0xffff
3502 [(set_attr "type" "delayed_compare")
3503 (set_attr "length" "4,8")])
3506 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3507 (compare:CC (zero_extend:SI
3509 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
3510 (match_operand:SI 2 "reg_or_cint_operand" "")) 0))
3512 (clobber (match_scratch:SI 3 ""))]
3515 (zero_extend:SI (subreg:HI
3516 (rotate:SI (match_dup 1)
3519 (compare:CC (match_dup 3)
3523 (define_insn "*rotlsi3_internal12"
3524 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
3525 (compare:CC (zero_extend:SI
3527 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3528 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri")) 0))
3530 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3531 (zero_extend:SI (subreg:HI (rotate:SI (match_dup 1) (match_dup 2)) 0)))]
3534 {rl%I2nm.|rlw%I2nm.} %0,%1,%h2,0xffff
3536 [(set_attr "type" "delayed_compare")
3537 (set_attr "length" "4,8")])
3540 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
3541 (compare:CC (zero_extend:SI
3543 (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "")
3544 (match_operand:SI 2 "reg_or_cint_operand" "")) 0))
3546 (set (match_operand:SI 0 "gpc_reg_operand" "")
3547 (zero_extend:SI (subreg:HI (rotate:SI (match_dup 1) (match_dup 2)) 0)))]
3550 (zero_extend:SI (subreg:HI (rotate:SI (match_dup 1) (match_dup 2)) 0)))
3552 (compare:CC (match_dup 0)
3556 ;; Note that we use "sle." instead of "sl." so that we can set
3557 ;; SHIFT_COUNT_TRUNCATED.
3559 (define_expand "ashlsi3"
3560 [(use (match_operand:SI 0 "gpc_reg_operand" ""))
3561 (use (match_operand:SI 1 "gpc_reg_operand" ""))
3562 (use (match_operand:SI 2 "reg_or_cint_operand" ""))]
3567 emit_insn (gen_ashlsi3_power (operands[0], operands[1], operands[2]));
3569 emit_insn (gen_ashlsi3_no_power (operands[0], operands[1], operands[2]));
3573 (define_insn "ashlsi3_power"
3574 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3575 (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3576 (match_operand:SI 2 "reg_or_cint_operand" "r,i")))
3577 (clobber (match_scratch:SI 3 "=q,X"))]
3581 {sli|slwi} %0,%1,%h2")
3583 (define_insn "ashlsi3_no_power"
3584 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3585 (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
3586 (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
3588 "{sl|slw}%I2 %0,%1,%h2")
3591 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
3592 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
3593 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
3595 (clobber (match_scratch:SI 3 "=r,r,r,r"))
3596 (clobber (match_scratch:SI 4 "=q,X,q,X"))]
3600 {sli.|slwi.} %3,%1,%h2
3603 [(set_attr "type" "delayed_compare")
3604 (set_attr "length" "4,4,8,8")])
3607 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3608 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "")
3609 (match_operand:SI 2 "reg_or_cint_operand" ""))
3611 (clobber (match_scratch:SI 3 ""))
3612 (clobber (match_scratch:SI 4 ""))]
3613 "TARGET_POWER && reload_completed"
3614 [(parallel [(set (match_dup 3)
3615 (ashift:SI (match_dup 1) (match_dup 2)))
3616 (clobber (match_dup 4))])
3618 (compare:CC (match_dup 3)
3623 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3624 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3625 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri"))
3627 (clobber (match_scratch:SI 3 "=r,r"))]
3628 "! TARGET_POWER && TARGET_32BIT"
3630 {sl|slw}%I2. %3,%1,%h2
3632 [(set_attr "type" "delayed_compare")
3633 (set_attr "length" "4,8")])
3636 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3637 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "")
3638 (match_operand:SI 2 "reg_or_cint_operand" ""))
3640 (clobber (match_scratch:SI 3 ""))]
3641 "! TARGET_POWER && TARGET_32BIT && reload_completed"
3643 (ashift:SI (match_dup 1) (match_dup 2)))
3645 (compare:CC (match_dup 3)
3650 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
3651 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
3652 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
3654 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
3655 (ashift:SI (match_dup 1) (match_dup 2)))
3656 (clobber (match_scratch:SI 4 "=q,X,q,X"))]
3660 {sli.|slwi.} %0,%1,%h2
3663 [(set_attr "type" "delayed_compare")
3664 (set_attr "length" "4,4,8,8")])
3667 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
3668 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "")
3669 (match_operand:SI 2 "reg_or_cint_operand" ""))
3671 (set (match_operand:SI 0 "gpc_reg_operand" "")
3672 (ashift:SI (match_dup 1) (match_dup 2)))
3673 (clobber (match_scratch:SI 4 ""))]
3674 "TARGET_POWER && reload_completed"
3675 [(parallel [(set (match_dup 0)
3676 (ashift:SI (match_dup 1) (match_dup 2)))
3677 (clobber (match_dup 4))])
3679 (compare:CC (match_dup 0)
3684 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
3685 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3686 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri"))
3688 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3689 (ashift:SI (match_dup 1) (match_dup 2)))]
3690 "! TARGET_POWER && TARGET_32BIT"
3692 {sl|slw}%I2. %0,%1,%h2
3694 [(set_attr "type" "delayed_compare")
3695 (set_attr "length" "4,8")])
3698 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
3699 (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "")
3700 (match_operand:SI 2 "reg_or_cint_operand" ""))
3702 (set (match_operand:SI 0 "gpc_reg_operand" "")
3703 (ashift:SI (match_dup 1) (match_dup 2)))]
3704 "! TARGET_POWER && TARGET_32BIT && reload_completed"
3706 (ashift:SI (match_dup 1) (match_dup 2)))
3708 (compare:CC (match_dup 0)
3712 (define_insn "rlwinm"
3713 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3714 (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
3715 (match_operand:SI 2 "const_int_operand" "i"))
3716 (match_operand:SI 3 "mask_operand" "n")))]
3717 "includes_lshift_p (operands[2], operands[3])"
3718 "{rlinm|rlwinm} %0,%1,%h2,%m3,%M3")
3721 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3723 (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3724 (match_operand:SI 2 "const_int_operand" "i,i"))
3725 (match_operand:SI 3 "mask_operand" "n,n"))
3727 (clobber (match_scratch:SI 4 "=r,r"))]
3728 "includes_lshift_p (operands[2], operands[3])"
3730 {rlinm.|rlwinm.} %4,%1,%h2,%m3,%M3
3732 [(set_attr "type" "delayed_compare")
3733 (set_attr "length" "4,8")])
3736 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3738 (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "")
3739 (match_operand:SI 2 "const_int_operand" ""))
3740 (match_operand:SI 3 "mask_operand" ""))
3742 (clobber (match_scratch:SI 4 ""))]
3743 "includes_lshift_p (operands[2], operands[3]) && reload_completed"
3745 (and:SI (ashift:SI (match_dup 1) (match_dup 2))
3748 (compare:CC (match_dup 4)
3753 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
3755 (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3756 (match_operand:SI 2 "const_int_operand" "i,i"))
3757 (match_operand:SI 3 "mask_operand" "n,n"))
3759 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3760 (and:SI (ashift:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
3761 "includes_lshift_p (operands[2], operands[3])"
3763 {rlinm.|rlwinm.} %0,%1,%h2,%m3,%M3
3765 [(set_attr "type" "delayed_compare")
3766 (set_attr "length" "4,8")])
3769 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
3771 (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "")
3772 (match_operand:SI 2 "const_int_operand" ""))
3773 (match_operand:SI 3 "mask_operand" ""))
3775 (set (match_operand:SI 0 "gpc_reg_operand" "")
3776 (and:SI (ashift:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
3777 "includes_lshift_p (operands[2], operands[3]) && reload_completed"
3779 (and:SI (ashift:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
3781 (compare:CC (match_dup 0)
3785 ;; The AIX assembler mis-handles "sri x,x,0", so write that case as
3787 (define_expand "lshrsi3"
3788 [(use (match_operand:SI 0 "gpc_reg_operand" ""))
3789 (use (match_operand:SI 1 "gpc_reg_operand" ""))
3790 (use (match_operand:SI 2 "reg_or_cint_operand" ""))]
3795 emit_insn (gen_lshrsi3_power (operands[0], operands[1], operands[2]));
3797 emit_insn (gen_lshrsi3_no_power (operands[0], operands[1], operands[2]));
3801 (define_insn "lshrsi3_power"
3802 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
3803 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r")
3804 (match_operand:SI 2 "reg_or_cint_operand" "r,O,i")))
3805 (clobber (match_scratch:SI 3 "=q,X,X"))]
3810 {s%A2i|s%A2wi} %0,%1,%h2")
3812 (define_insn "lshrsi3_no_power"
3813 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3814 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3815 (match_operand:SI 2 "reg_or_cint_operand" "O,ri")))]
3819 {sr|srw}%I2 %0,%1,%h2")
3822 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,?y,?y,?y")
3823 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r,r,r")
3824 (match_operand:SI 2 "reg_or_cint_operand" "r,O,i,r,O,i"))
3826 (clobber (match_scratch:SI 3 "=r,X,r,r,X,r"))
3827 (clobber (match_scratch:SI 4 "=q,X,X,q,X,X"))]
3832 {s%A2i.|s%A2wi.} %3,%1,%h2
3836 [(set_attr "type" "delayed_compare")
3837 (set_attr "length" "4,4,4,8,8,8")])
3840 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3841 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
3842 (match_operand:SI 2 "reg_or_cint_operand" ""))
3844 (clobber (match_scratch:SI 3 ""))
3845 (clobber (match_scratch:SI 4 ""))]
3846 "TARGET_POWER && reload_completed"
3847 [(parallel [(set (match_dup 3)
3848 (lshiftrt:SI (match_dup 1) (match_dup 2)))
3849 (clobber (match_dup 4))])
3851 (compare:CC (match_dup 3)
3856 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
3857 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
3858 (match_operand:SI 2 "reg_or_cint_operand" "O,ri,O,ri"))
3860 (clobber (match_scratch:SI 3 "=X,r,X,r"))]
3861 "! TARGET_POWER && TARGET_32BIT"
3864 {sr|srw}%I2. %3,%1,%h2
3867 [(set_attr "type" "delayed_compare")
3868 (set_attr "length" "4,4,8,8")])
3871 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3872 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
3873 (match_operand:SI 2 "reg_or_cint_operand" ""))
3875 (clobber (match_scratch:SI 3 ""))]
3876 "! TARGET_POWER && TARGET_32BIT && reload_completed"
3878 (lshiftrt:SI (match_dup 1) (match_dup 2)))
3880 (compare:CC (match_dup 3)
3885 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,?y,?y,?y")
3886 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r,r,r")
3887 (match_operand:SI 2 "reg_or_cint_operand" "r,O,i,r,O,i"))
3889 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r,r")
3890 (lshiftrt:SI (match_dup 1) (match_dup 2)))
3891 (clobber (match_scratch:SI 4 "=q,X,X,q,X,X"))]
3896 {s%A2i.|s%A2wi.} %0,%1,%h2
3900 [(set_attr "type" "delayed_compare")
3901 (set_attr "length" "4,4,4,8,8,8")])
3904 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
3905 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
3906 (match_operand:SI 2 "reg_or_cint_operand" ""))
3908 (set (match_operand:SI 0 "gpc_reg_operand" "")
3909 (lshiftrt:SI (match_dup 1) (match_dup 2)))
3910 (clobber (match_scratch:SI 4 ""))]
3911 "TARGET_POWER && reload_completed"
3912 [(parallel [(set (match_dup 0)
3913 (lshiftrt:SI (match_dup 1) (match_dup 2)))
3914 (clobber (match_dup 4))])
3916 (compare:CC (match_dup 0)
3921 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
3922 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
3923 (match_operand:SI 2 "reg_or_cint_operand" "O,ri,O,ri"))
3925 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
3926 (lshiftrt:SI (match_dup 1) (match_dup 2)))]
3927 "! TARGET_POWER && TARGET_32BIT"
3930 {sr|srw}%I2. %0,%1,%h2
3933 [(set_attr "type" "delayed_compare")
3934 (set_attr "length" "4,4,8,8")])
3937 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
3938 (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
3939 (match_operand:SI 2 "reg_or_cint_operand" ""))
3941 (set (match_operand:SI 0 "gpc_reg_operand" "")
3942 (lshiftrt:SI (match_dup 1) (match_dup 2)))]
3943 "! TARGET_POWER && TARGET_32BIT && reload_completed"
3945 (lshiftrt:SI (match_dup 1) (match_dup 2)))
3947 (compare:CC (match_dup 0)
3952 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3953 (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
3954 (match_operand:SI 2 "const_int_operand" "i"))
3955 (match_operand:SI 3 "mask_operand" "n")))]
3956 "includes_rshift_p (operands[2], operands[3])"
3957 "{rlinm|rlwinm} %0,%1,%s2,%m3,%M3")
3960 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3962 (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3963 (match_operand:SI 2 "const_int_operand" "i,i"))
3964 (match_operand:SI 3 "mask_operand" "n,n"))
3966 (clobber (match_scratch:SI 4 "=r,r"))]
3967 "includes_rshift_p (operands[2], operands[3])"
3969 {rlinm.|rlwinm.} %4,%1,%s2,%m3,%M3
3971 [(set_attr "type" "delayed_compare")
3972 (set_attr "length" "4,8")])
3975 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3977 (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
3978 (match_operand:SI 2 "const_int_operand" ""))
3979 (match_operand:SI 3 "mask_operand" ""))
3981 (clobber (match_scratch:SI 4 ""))]
3982 "includes_rshift_p (operands[2], operands[3]) && reload_completed"
3984 (and:SI (lshiftrt:SI (match_dup 1) (match_dup 2))
3987 (compare:CC (match_dup 4)
3992 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
3994 (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3995 (match_operand:SI 2 "const_int_operand" "i,i"))
3996 (match_operand:SI 3 "mask_operand" "n,n"))
3998 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3999 (and:SI (lshiftrt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
4000 "includes_rshift_p (operands[2], operands[3])"
4002 {rlinm.|rlwinm.} %0,%1,%s2,%m3,%M3
4004 [(set_attr "type" "delayed_compare")
4005 (set_attr "length" "4,8")])
4008 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
4010 (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4011 (match_operand:SI 2 "const_int_operand" ""))
4012 (match_operand:SI 3 "mask_operand" ""))
4014 (set (match_operand:SI 0 "gpc_reg_operand" "")
4015 (and:SI (lshiftrt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
4016 "includes_rshift_p (operands[2], operands[3]) && reload_completed"
4018 (and:SI (lshiftrt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
4020 (compare:CC (match_dup 0)
4025 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4028 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
4029 (match_operand:SI 2 "const_int_operand" "i")) 0)))]
4030 "includes_rshift_p (operands[2], GEN_INT (255))"
4031 "{rlinm|rlwinm} %0,%1,%s2,0xff")
4034 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
4038 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4039 (match_operand:SI 2 "const_int_operand" "i,i")) 0))
4041 (clobber (match_scratch:SI 3 "=r,r"))]
4042 "includes_rshift_p (operands[2], GEN_INT (255))"
4044 {rlinm.|rlwinm.} %3,%1,%s2,0xff
4046 [(set_attr "type" "delayed_compare")
4047 (set_attr "length" "4,8")])
4050 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
4054 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4055 (match_operand:SI 2 "const_int_operand" "")) 0))
4057 (clobber (match_scratch:SI 3 ""))]
4058 "includes_rshift_p (operands[2], GEN_INT (255)) && reload_completed"
4060 (zero_extend:SI (subreg:QI
4061 (lshiftrt:SI (match_dup 1)
4064 (compare:CC (match_dup 3)
4069 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
4073 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4074 (match_operand:SI 2 "const_int_operand" "i,i")) 0))
4076 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
4077 (zero_extend:SI (subreg:QI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))]
4078 "includes_rshift_p (operands[2], GEN_INT (255))"
4080 {rlinm.|rlwinm.} %0,%1,%s2,0xff
4082 [(set_attr "type" "delayed_compare")
4083 (set_attr "length" "4,8")])
4086 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
4090 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4091 (match_operand:SI 2 "const_int_operand" "")) 0))
4093 (set (match_operand:SI 0 "gpc_reg_operand" "")
4094 (zero_extend:SI (subreg:QI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))]
4095 "includes_rshift_p (operands[2], GEN_INT (255)) && reload_completed"
4097 (zero_extend:SI (subreg:QI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))
4099 (compare:CC (match_dup 0)
4104 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4107 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
4108 (match_operand:SI 2 "const_int_operand" "i")) 0)))]
4109 "includes_rshift_p (operands[2], GEN_INT (65535))"
4110 "{rlinm|rlwinm} %0,%1,%s2,0xffff")
4113 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
4117 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4118 (match_operand:SI 2 "const_int_operand" "i,i")) 0))
4120 (clobber (match_scratch:SI 3 "=r,r"))]
4121 "includes_rshift_p (operands[2], GEN_INT (65535))"
4123 {rlinm.|rlwinm.} %3,%1,%s2,0xffff
4125 [(set_attr "type" "delayed_compare")
4126 (set_attr "length" "4,8")])
4129 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
4133 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4134 (match_operand:SI 2 "const_int_operand" "")) 0))
4136 (clobber (match_scratch:SI 3 ""))]
4137 "includes_rshift_p (operands[2], GEN_INT (65535)) && reload_completed"
4139 (zero_extend:SI (subreg:HI
4140 (lshiftrt:SI (match_dup 1)
4143 (compare:CC (match_dup 3)
4148 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
4152 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4153 (match_operand:SI 2 "const_int_operand" "i,i")) 0))
4155 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
4156 (zero_extend:SI (subreg:HI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))]
4157 "includes_rshift_p (operands[2], GEN_INT (65535))"
4159 {rlinm.|rlwinm.} %0,%1,%s2,0xffff
4161 [(set_attr "type" "delayed_compare")
4162 (set_attr "length" "4,8")])
4165 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
4169 (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4170 (match_operand:SI 2 "const_int_operand" "")) 0))
4172 (set (match_operand:SI 0 "gpc_reg_operand" "")
4173 (zero_extend:SI (subreg:HI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))]
4174 "includes_rshift_p (operands[2], GEN_INT (65535)) && reload_completed"
4176 (zero_extend:SI (subreg:HI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))
4178 (compare:CC (match_dup 0)
4183 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
4185 (match_operand:SI 1 "gpc_reg_operand" "r"))
4186 (ashiftrt:SI (match_operand:SI 2 "gpc_reg_operand" "r")
4192 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
4194 (match_operand:SI 1 "gpc_reg_operand" "r"))
4195 (lshiftrt:SI (match_operand:SI 2 "gpc_reg_operand" "r")
4201 [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
4203 (match_operand:SI 1 "gpc_reg_operand" "r"))
4204 (zero_extract:SI (match_operand:SI 2 "gpc_reg_operand" "r")
4210 (define_expand "ashrsi3"
4211 [(set (match_operand:SI 0 "gpc_reg_operand" "")
4212 (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4213 (match_operand:SI 2 "reg_or_cint_operand" "")))]
4218 emit_insn (gen_ashrsi3_power (operands[0], operands[1], operands[2]));
4220 emit_insn (gen_ashrsi3_no_power (operands[0], operands[1], operands[2]));
4224 (define_insn "ashrsi3_power"
4225 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
4226 (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4227 (match_operand:SI 2 "reg_or_cint_operand" "r,i")))
4228 (clobber (match_scratch:SI 3 "=q,X"))]
4232 {srai|srawi} %0,%1,%h2")
4234 (define_insn "ashrsi3_no_power"
4235 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4236 (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
4237 (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
4239 "{sra|sraw}%I2 %0,%1,%h2")
4242 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
4243 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
4244 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
4246 (clobber (match_scratch:SI 3 "=r,r,r,r"))
4247 (clobber (match_scratch:SI 4 "=q,X,q,X"))]
4251 {srai.|srawi.} %3,%1,%h2
4254 [(set_attr "type" "delayed_compare")
4255 (set_attr "length" "4,4,8,8")])
4258 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
4259 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4260 (match_operand:SI 2 "reg_or_cint_operand" ""))
4262 (clobber (match_scratch:SI 3 ""))
4263 (clobber (match_scratch:SI 4 ""))]
4264 "TARGET_POWER && reload_completed"
4265 [(parallel [(set (match_dup 3)
4266 (ashiftrt:SI (match_dup 1) (match_dup 2)))
4267 (clobber (match_dup 4))])
4269 (compare:CC (match_dup 3)
4274 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
4275 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4276 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri"))
4278 (clobber (match_scratch:SI 3 "=r,r"))]
4281 {sra|sraw}%I2. %3,%1,%h2
4283 [(set_attr "type" "delayed_compare")
4284 (set_attr "length" "4,8")])
4287 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
4288 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4289 (match_operand:SI 2 "reg_or_cint_operand" ""))
4291 (clobber (match_scratch:SI 3 ""))]
4292 "! TARGET_POWER && reload_completed"
4294 (ashiftrt:SI (match_dup 1) (match_dup 2)))
4296 (compare:CC (match_dup 3)
4301 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
4302 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
4303 (match_operand:SI 2 "reg_or_cint_operand" "r,i,r,i"))
4305 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
4306 (ashiftrt:SI (match_dup 1) (match_dup 2)))
4307 (clobber (match_scratch:SI 4 "=q,X,q,X"))]
4311 {srai.|srawi.} %0,%1,%h2
4314 [(set_attr "type" "delayed_compare")
4315 (set_attr "length" "4,4,8,8")])
4318 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
4319 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4320 (match_operand:SI 2 "reg_or_cint_operand" ""))
4322 (set (match_operand:SI 0 "gpc_reg_operand" "")
4323 (ashiftrt:SI (match_dup 1) (match_dup 2)))
4324 (clobber (match_scratch:SI 4 ""))]
4325 "TARGET_POWER && reload_completed"
4326 [(parallel [(set (match_dup 0)
4327 (ashiftrt:SI (match_dup 1) (match_dup 2)))
4328 (clobber (match_dup 4))])
4330 (compare:CC (match_dup 0)
4335 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
4336 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
4337 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri"))
4339 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
4340 (ashiftrt:SI (match_dup 1) (match_dup 2)))]
4343 {sra|sraw}%I2. %0,%1,%h2
4345 [(set_attr "type" "delayed_compare")
4346 (set_attr "length" "4,8")])
4349 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
4350 (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
4351 (match_operand:SI 2 "reg_or_cint_operand" ""))
4353 (set (match_operand:SI 0 "gpc_reg_operand" "")
4354 (ashiftrt:SI (match_dup 1) (match_dup 2)))]
4355 "! TARGET_POWER && reload_completed"
4357 (ashiftrt:SI (match_dup 1) (match_dup 2)))
4359 (compare:CC (match_dup 0)
4363 ;; Floating-point insns, excluding normal data motion.
4365 ;; PowerPC has a full set of single-precision floating point instructions.
4367 ;; For the POWER architecture, we pretend that we have both SFmode and
4368 ;; DFmode insns, while, in fact, all fp insns are actually done in double.
4369 ;; The only conversions we will do will be when storing to memory. In that
4370 ;; case, we will use the "frsp" instruction before storing.
4372 ;; Note that when we store into a single-precision memory location, we need to
4373 ;; use the frsp insn first. If the register being stored isn't dead, we
4374 ;; need a scratch register for the frsp. But this is difficult when the store
4375 ;; is done by reload. It is not incorrect to do the frsp on the register in
4376 ;; this case, we just lose precision that we would have otherwise gotten but
4377 ;; is not guaranteed. Perhaps this should be tightened up at some point.
4379 (define_expand "extendsfdf2"
4380 [(set (match_operand:DF 0 "gpc_reg_operand" "")
4381 (float_extend:DF (match_operand:SF 1 "reg_or_none500mem_operand" "")))]
4382 "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)"
4385 (define_insn_and_split "*extendsfdf2_fpr"
4386 [(set (match_operand:DF 0 "gpc_reg_operand" "=f,?f,f")
4387 (float_extend:DF (match_operand:SF 1 "reg_or_mem_operand" "0,f,m")))]
4388 "TARGET_HARD_FLOAT && TARGET_FPRS"
4393 "&& reload_completed && REG_P (operands[1]) && REGNO (operands[0]) == REGNO (operands[1])"
4396 emit_note (NOTE_INSN_DELETED);
4399 [(set_attr "type" "fp,fp,fpload")])
4401 (define_expand "truncdfsf2"
4402 [(set (match_operand:SF 0 "gpc_reg_operand" "")
4403 (float_truncate:SF (match_operand:DF 1 "gpc_reg_operand" "")))]
4404 "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)"
4407 (define_insn "*truncdfsf2_fpr"
4408 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4409 (float_truncate:SF (match_operand:DF 1 "gpc_reg_operand" "f")))]
4410 "TARGET_HARD_FLOAT && TARGET_FPRS"
4412 [(set_attr "type" "fp")])
4414 (define_insn "aux_truncdfsf2"
4415 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4416 (unspec:SF [(match_operand:SF 1 "gpc_reg_operand" "f")] UNSPEC_FRSP))]
4417 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS"
4419 [(set_attr "type" "fp")])
4421 (define_expand "negsf2"
4422 [(set (match_operand:SF 0 "gpc_reg_operand" "")
4423 (neg:SF (match_operand:SF 1 "gpc_reg_operand" "")))]
4427 (define_insn "*negsf2"
4428 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4429 (neg:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
4430 "TARGET_HARD_FLOAT && TARGET_FPRS"
4432 [(set_attr "type" "fp")])
4434 (define_expand "abssf2"
4435 [(set (match_operand:SF 0 "gpc_reg_operand" "")
4436 (abs:SF (match_operand:SF 1 "gpc_reg_operand" "")))]
4440 (define_insn "*abssf2"
4441 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4442 (abs:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
4443 "TARGET_HARD_FLOAT && TARGET_FPRS"
4445 [(set_attr "type" "fp")])
4448 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4449 (neg:SF (abs:SF (match_operand:SF 1 "gpc_reg_operand" "f"))))]
4450 "TARGET_HARD_FLOAT && TARGET_FPRS"
4452 [(set_attr "type" "fp")])
4454 (define_expand "addsf3"
4455 [(set (match_operand:SF 0 "gpc_reg_operand" "")
4456 (plus:SF (match_operand:SF 1 "gpc_reg_operand" "")
4457 (match_operand:SF 2 "gpc_reg_operand" "")))]
4462 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4463 (plus:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
4464 (match_operand:SF 2 "gpc_reg_operand" "f")))]
4465 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS"
4467 [(set_attr "type" "fp")])
4470 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4471 (plus:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
4472 (match_operand:SF 2 "gpc_reg_operand" "f")))]
4473 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS"
4474 "{fa|fadd} %0,%1,%2"
4475 [(set_attr "type" "fp")])
4477 (define_expand "subsf3"
4478 [(set (match_operand:SF 0 "gpc_reg_operand" "")
4479 (minus:SF (match_operand:SF 1 "gpc_reg_operand" "")
4480 (match_operand:SF 2 "gpc_reg_operand" "")))]
4485 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4486 (minus:SF (match_operand:SF 1 "gpc_reg_operand" "f")
4487 (match_operand:SF 2 "gpc_reg_operand" "f")))]
4488 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS"
4490 [(set_attr "type" "fp")])
4493 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4494 (minus:SF (match_operand:SF 1 "gpc_reg_operand" "f")
4495 (match_operand:SF 2 "gpc_reg_operand" "f")))]
4496 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS"
4497 "{fs|fsub} %0,%1,%2"
4498 [(set_attr "type" "fp")])
4500 (define_expand "mulsf3"
4501 [(set (match_operand:SF 0 "gpc_reg_operand" "")
4502 (mult:SF (match_operand:SF 1 "gpc_reg_operand" "")
4503 (match_operand:SF 2 "gpc_reg_operand" "")))]
4508 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4509 (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
4510 (match_operand:SF 2 "gpc_reg_operand" "f")))]
4511 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS"
4513 [(set_attr "type" "fp")])
4516 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4517 (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
4518 (match_operand:SF 2 "gpc_reg_operand" "f")))]
4519 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS"
4520 "{fm|fmul} %0,%1,%2"
4521 [(set_attr "type" "dmul")])
4524 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4525 (unspec:SF [(match_operand:SF 1 "gpc_reg_operand" "f")] UNSPEC_FRES))]
4526 "TARGET_PPC_GFXOPT && flag_finite_math_only"
4528 [(set_attr "type" "fp")])
4530 (define_expand "divsf3"
4531 [(set (match_operand:SF 0 "gpc_reg_operand" "")
4532 (div:SF (match_operand:SF 1 "gpc_reg_operand" "")
4533 (match_operand:SF 2 "gpc_reg_operand" "")))]
4536 if (swdiv && !optimize_size && TARGET_PPC_GFXOPT
4537 && flag_finite_math_only && !flag_trapping_math)
4539 rs6000_emit_swdivsf (operands[0], operands[1], operands[2]);
4545 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4546 (div:SF (match_operand:SF 1 "gpc_reg_operand" "f")
4547 (match_operand:SF 2 "gpc_reg_operand" "f")))]
4548 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS"
4550 [(set_attr "type" "sdiv")])
4553 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4554 (div:SF (match_operand:SF 1 "gpc_reg_operand" "f")
4555 (match_operand:SF 2 "gpc_reg_operand" "f")))]
4556 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS"
4557 "{fd|fdiv} %0,%1,%2"
4558 [(set_attr "type" "ddiv")])
4561 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4562 (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
4563 (match_operand:SF 2 "gpc_reg_operand" "f"))
4564 (match_operand:SF 3 "gpc_reg_operand" "f")))]
4565 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD"
4566 "fmadds %0,%1,%2,%3"
4567 [(set_attr "type" "fp")])
4570 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4571 (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
4572 (match_operand:SF 2 "gpc_reg_operand" "f"))
4573 (match_operand:SF 3 "gpc_reg_operand" "f")))]
4574 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD"
4575 "{fma|fmadd} %0,%1,%2,%3"
4576 [(set_attr "type" "dmul")])
4579 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4580 (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
4581 (match_operand:SF 2 "gpc_reg_operand" "f"))
4582 (match_operand:SF 3 "gpc_reg_operand" "f")))]
4583 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD"
4584 "fmsubs %0,%1,%2,%3"
4585 [(set_attr "type" "fp")])
4588 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4589 (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
4590 (match_operand:SF 2 "gpc_reg_operand" "f"))
4591 (match_operand:SF 3 "gpc_reg_operand" "f")))]
4592 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD"
4593 "{fms|fmsub} %0,%1,%2,%3"
4594 [(set_attr "type" "dmul")])
4597 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4598 (neg:SF (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
4599 (match_operand:SF 2 "gpc_reg_operand" "f"))
4600 (match_operand:SF 3 "gpc_reg_operand" "f"))))]
4601 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
4602 && HONOR_SIGNED_ZEROS (SFmode)"
4603 "fnmadds %0,%1,%2,%3"
4604 [(set_attr "type" "fp")])
4607 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4608 (minus:SF (mult:SF (neg:SF (match_operand:SF 1 "gpc_reg_operand" "f"))
4609 (match_operand:SF 2 "gpc_reg_operand" "f"))
4610 (match_operand:SF 3 "gpc_reg_operand" "f")))]
4611 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
4612 && ! HONOR_SIGNED_ZEROS (SFmode)"
4613 "fnmadds %0,%1,%2,%3"
4614 [(set_attr "type" "fp")])
4617 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4618 (neg:SF (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
4619 (match_operand:SF 2 "gpc_reg_operand" "f"))
4620 (match_operand:SF 3 "gpc_reg_operand" "f"))))]
4621 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD"
4622 "{fnma|fnmadd} %0,%1,%2,%3"
4623 [(set_attr "type" "dmul")])
4626 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4627 (minus:SF (mult:SF (neg:SF (match_operand:SF 1 "gpc_reg_operand" "f"))
4628 (match_operand:SF 2 "gpc_reg_operand" "f"))
4629 (match_operand:SF 3 "gpc_reg_operand" "f")))]
4630 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
4631 && ! HONOR_SIGNED_ZEROS (SFmode)"
4632 "{fnma|fnmadd} %0,%1,%2,%3"
4633 [(set_attr "type" "dmul")])
4636 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4637 (neg:SF (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
4638 (match_operand:SF 2 "gpc_reg_operand" "f"))
4639 (match_operand:SF 3 "gpc_reg_operand" "f"))))]
4640 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
4641 && HONOR_SIGNED_ZEROS (SFmode)"
4642 "fnmsubs %0,%1,%2,%3"
4643 [(set_attr "type" "fp")])
4646 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4647 (minus:SF (match_operand:SF 3 "gpc_reg_operand" "f")
4648 (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
4649 (match_operand:SF 2 "gpc_reg_operand" "f"))))]
4650 "TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
4651 && ! HONOR_SIGNED_ZEROS (SFmode)"
4652 "fnmsubs %0,%1,%2,%3"
4653 [(set_attr "type" "fp")])
4656 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4657 (neg:SF (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
4658 (match_operand:SF 2 "gpc_reg_operand" "f"))
4659 (match_operand:SF 3 "gpc_reg_operand" "f"))))]
4660 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD"
4661 "{fnms|fnmsub} %0,%1,%2,%3"
4662 [(set_attr "type" "dmul")])
4665 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4666 (minus:SF (match_operand:SF 3 "gpc_reg_operand" "f")
4667 (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
4668 (match_operand:SF 2 "gpc_reg_operand" "f"))))]
4669 "! TARGET_POWERPC && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
4670 && ! HONOR_SIGNED_ZEROS (SFmode)"
4671 "{fnms|fnmsub} %0,%1,%2,%3"
4672 [(set_attr "type" "fp")])
4674 (define_expand "sqrtsf2"
4675 [(set (match_operand:SF 0 "gpc_reg_operand" "")
4676 (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "")))]
4677 "(TARGET_PPC_GPOPT || TARGET_POWER2) && TARGET_HARD_FLOAT && TARGET_FPRS"
4681 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4682 (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
4683 "TARGET_PPC_GPOPT && TARGET_HARD_FLOAT && TARGET_FPRS"
4685 [(set_attr "type" "ssqrt")])
4688 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4689 (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
4690 "TARGET_POWER2 && TARGET_HARD_FLOAT && TARGET_FPRS"
4692 [(set_attr "type" "dsqrt")])
4694 (define_expand "copysignsf3"
4696 (abs:SF (match_operand:SF 1 "gpc_reg_operand" "")))
4698 (neg:SF (abs:SF (match_dup 1))))
4699 (set (match_operand:SF 0 "gpc_reg_operand" "")
4700 (if_then_else:SF (ge (match_operand:SF 2 "gpc_reg_operand" "")
4704 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS
4705 && !HONOR_NANS (SFmode) && !HONOR_SIGNED_ZEROS (SFmode)"
4707 operands[3] = gen_reg_rtx (SFmode);
4708 operands[4] = gen_reg_rtx (SFmode);
4709 operands[5] = CONST0_RTX (SFmode);
4712 (define_expand "copysigndf3"
4714 (abs:DF (match_operand:DF 1 "gpc_reg_operand" "")))
4716 (neg:DF (abs:DF (match_dup 1))))
4717 (set (match_operand:DF 0 "gpc_reg_operand" "")
4718 (if_then_else:DF (ge (match_operand:DF 2 "gpc_reg_operand" "")
4722 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS
4723 && !HONOR_NANS (DFmode) && !HONOR_SIGNED_ZEROS (DFmode)"
4725 operands[3] = gen_reg_rtx (DFmode);
4726 operands[4] = gen_reg_rtx (DFmode);
4727 operands[5] = CONST0_RTX (DFmode);
4730 ;; For MIN, MAX, and conditional move, we use DEFINE_EXPAND's that involve a
4731 ;; fsel instruction and some auxiliary computations. Then we just have a
4732 ;; single DEFINE_INSN for fsel and the define_splits to make them if made by
4734 (define_expand "smaxsf3"
4735 [(set (match_operand:SF 0 "gpc_reg_operand" "")
4736 (if_then_else:SF (ge (match_operand:SF 1 "gpc_reg_operand" "")
4737 (match_operand:SF 2 "gpc_reg_operand" ""))
4740 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && !flag_trapping_math"
4741 "{ rs6000_emit_minmax (operands[0], SMAX, operands[1], operands[2]); DONE;}")
4743 (define_expand "sminsf3"
4744 [(set (match_operand:SF 0 "gpc_reg_operand" "")
4745 (if_then_else:SF (ge (match_operand:SF 1 "gpc_reg_operand" "")
4746 (match_operand:SF 2 "gpc_reg_operand" ""))
4749 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && !flag_trapping_math"
4750 "{ rs6000_emit_minmax (operands[0], SMIN, operands[1], operands[2]); DONE;}")
4753 [(set (match_operand:SF 0 "gpc_reg_operand" "")
4754 (match_operator:SF 3 "min_max_operator"
4755 [(match_operand:SF 1 "gpc_reg_operand" "")
4756 (match_operand:SF 2 "gpc_reg_operand" "")]))]
4757 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && !flag_trapping_math"
4760 { rs6000_emit_minmax (operands[0], GET_CODE (operands[3]),
4761 operands[1], operands[2]);
4765 (define_expand "movsicc"
4766 [(set (match_operand:SI 0 "gpc_reg_operand" "")
4767 (if_then_else:SI (match_operand 1 "comparison_operator" "")
4768 (match_operand:SI 2 "gpc_reg_operand" "")
4769 (match_operand:SI 3 "gpc_reg_operand" "")))]
4773 if (rs6000_emit_cmove (operands[0], operands[1], operands[2], operands[3]))
4779 ;; We use the BASE_REGS for the isel input operands because, if rA is
4780 ;; 0, the value of 0 is placed in rD upon truth. Similarly for rB
4781 ;; because we may switch the operands and rB may end up being rA.
4783 ;; We need 2 patterns: an unsigned and a signed pattern. We could
4784 ;; leave out the mode in operand 4 and use one pattern, but reload can
4785 ;; change the mode underneath our feet and then gets confused trying
4786 ;; to reload the value.
4787 (define_insn "isel_signed"
4788 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4790 (match_operator 1 "comparison_operator"
4791 [(match_operand:CC 4 "cc_reg_operand" "y")
4793 (match_operand:SI 2 "gpc_reg_operand" "b")
4794 (match_operand:SI 3 "gpc_reg_operand" "b")))]
4797 { return output_isel (operands); }"
4798 [(set_attr "length" "4")])
4800 (define_insn "isel_unsigned"
4801 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4803 (match_operator 1 "comparison_operator"
4804 [(match_operand:CCUNS 4 "cc_reg_operand" "y")
4806 (match_operand:SI 2 "gpc_reg_operand" "b")
4807 (match_operand:SI 3 "gpc_reg_operand" "b")))]
4810 { return output_isel (operands); }"
4811 [(set_attr "length" "4")])
4813 (define_expand "movsfcc"
4814 [(set (match_operand:SF 0 "gpc_reg_operand" "")
4815 (if_then_else:SF (match_operand 1 "comparison_operator" "")
4816 (match_operand:SF 2 "gpc_reg_operand" "")
4817 (match_operand:SF 3 "gpc_reg_operand" "")))]
4818 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS"
4821 if (rs6000_emit_cmove (operands[0], operands[1], operands[2], operands[3]))
4827 (define_insn "*fselsfsf4"
4828 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4829 (if_then_else:SF (ge (match_operand:SF 1 "gpc_reg_operand" "f")
4830 (match_operand:SF 4 "zero_fp_constant" "F"))
4831 (match_operand:SF 2 "gpc_reg_operand" "f")
4832 (match_operand:SF 3 "gpc_reg_operand" "f")))]
4833 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS"
4835 [(set_attr "type" "fp")])
4837 (define_insn "*fseldfsf4"
4838 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
4839 (if_then_else:SF (ge (match_operand:DF 1 "gpc_reg_operand" "f")
4840 (match_operand:DF 4 "zero_fp_constant" "F"))
4841 (match_operand:SF 2 "gpc_reg_operand" "f")
4842 (match_operand:SF 3 "gpc_reg_operand" "f")))]
4843 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS"
4845 [(set_attr "type" "fp")])
4847 (define_expand "negdf2"
4848 [(set (match_operand:DF 0 "gpc_reg_operand" "")
4849 (neg:DF (match_operand:DF 1 "gpc_reg_operand" "")))]
4850 "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)"
4853 (define_insn "*negdf2_fpr"
4854 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
4855 (neg:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
4856 "TARGET_HARD_FLOAT && TARGET_FPRS"
4858 [(set_attr "type" "fp")])
4860 (define_expand "absdf2"
4861 [(set (match_operand:DF 0 "gpc_reg_operand" "")
4862 (abs:DF (match_operand:DF 1 "gpc_reg_operand" "")))]
4863 "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)"
4866 (define_insn "*absdf2_fpr"
4867 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
4868 (abs:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
4869 "TARGET_HARD_FLOAT && TARGET_FPRS"
4871 [(set_attr "type" "fp")])
4873 (define_insn "*nabsdf2_fpr"
4874 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
4875 (neg:DF (abs:DF (match_operand:DF 1 "gpc_reg_operand" "f"))))]
4876 "TARGET_HARD_FLOAT && TARGET_FPRS"
4878 [(set_attr "type" "fp")])
4880 (define_expand "adddf3"
4881 [(set (match_operand:DF 0 "gpc_reg_operand" "")
4882 (plus:DF (match_operand:DF 1 "gpc_reg_operand" "")
4883 (match_operand:DF 2 "gpc_reg_operand" "")))]
4884 "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)"
4887 (define_insn "*adddf3_fpr"
4888 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
4889 (plus:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
4890 (match_operand:DF 2 "gpc_reg_operand" "f")))]
4891 "TARGET_HARD_FLOAT && TARGET_FPRS"
4892 "{fa|fadd} %0,%1,%2"
4893 [(set_attr "type" "fp")])
4895 (define_expand "subdf3"
4896 [(set (match_operand:DF 0 "gpc_reg_operand" "")
4897 (minus:DF (match_operand:DF 1 "gpc_reg_operand" "")
4898 (match_operand:DF 2 "gpc_reg_operand" "")))]
4899 "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)"
4902 (define_insn "*subdf3_fpr"
4903 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
4904 (minus:DF (match_operand:DF 1 "gpc_reg_operand" "f")
4905 (match_operand:DF 2 "gpc_reg_operand" "f")))]
4906 "TARGET_HARD_FLOAT && TARGET_FPRS"
4907 "{fs|fsub} %0,%1,%2"
4908 [(set_attr "type" "fp")])
4910 (define_expand "muldf3"
4911 [(set (match_operand:DF 0 "gpc_reg_operand" "")
4912 (mult:DF (match_operand:DF 1 "gpc_reg_operand" "")
4913 (match_operand:DF 2 "gpc_reg_operand" "")))]
4914 "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)"
4917 (define_insn "*muldf3_fpr"
4918 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
4919 (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
4920 (match_operand:DF 2 "gpc_reg_operand" "f")))]
4921 "TARGET_HARD_FLOAT && TARGET_FPRS"
4922 "{fm|fmul} %0,%1,%2"
4923 [(set_attr "type" "dmul")])
4926 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
4927 (unspec:DF [(match_operand:DF 1 "gpc_reg_operand" "f")] UNSPEC_FRES))]
4928 "TARGET_POPCNTB && flag_finite_math_only"
4930 [(set_attr "type" "fp")])
4932 (define_expand "divdf3"
4933 [(set (match_operand:DF 0 "gpc_reg_operand" "")
4934 (div:DF (match_operand:DF 1 "gpc_reg_operand" "")
4935 (match_operand:DF 2 "gpc_reg_operand" "")))]
4936 "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)"
4938 if (swdiv && !optimize_size && TARGET_POPCNTB
4939 && flag_finite_math_only && !flag_trapping_math)
4941 rs6000_emit_swdivdf (operands[0], operands[1], operands[2]);
4946 (define_insn "*divdf3_fpr"
4947 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
4948 (div:DF (match_operand:DF 1 "gpc_reg_operand" "f")
4949 (match_operand:DF 2 "gpc_reg_operand" "f")))]
4950 "TARGET_HARD_FLOAT && TARGET_FPRS"
4951 "{fd|fdiv} %0,%1,%2"
4952 [(set_attr "type" "ddiv")])
4955 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
4956 (plus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
4957 (match_operand:DF 2 "gpc_reg_operand" "f"))
4958 (match_operand:DF 3 "gpc_reg_operand" "f")))]
4959 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD"
4960 "{fma|fmadd} %0,%1,%2,%3"
4961 [(set_attr "type" "dmul")])
4964 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
4965 (minus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
4966 (match_operand:DF 2 "gpc_reg_operand" "f"))
4967 (match_operand:DF 3 "gpc_reg_operand" "f")))]
4968 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD"
4969 "{fms|fmsub} %0,%1,%2,%3"
4970 [(set_attr "type" "dmul")])
4973 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
4974 (neg:DF (plus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
4975 (match_operand:DF 2 "gpc_reg_operand" "f"))
4976 (match_operand:DF 3 "gpc_reg_operand" "f"))))]
4977 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
4978 && HONOR_SIGNED_ZEROS (DFmode)"
4979 "{fnma|fnmadd} %0,%1,%2,%3"
4980 [(set_attr "type" "dmul")])
4983 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
4984 (minus:DF (mult:DF (neg:DF (match_operand:DF 1 "gpc_reg_operand" "f"))
4985 (match_operand:DF 2 "gpc_reg_operand" "f"))
4986 (match_operand:DF 3 "gpc_reg_operand" "f")))]
4987 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
4988 && ! HONOR_SIGNED_ZEROS (DFmode)"
4989 "{fnma|fnmadd} %0,%1,%2,%3"
4990 [(set_attr "type" "dmul")])
4993 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
4994 (neg:DF (minus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
4995 (match_operand:DF 2 "gpc_reg_operand" "f"))
4996 (match_operand:DF 3 "gpc_reg_operand" "f"))))]
4997 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
4998 && HONOR_SIGNED_ZEROS (DFmode)"
4999 "{fnms|fnmsub} %0,%1,%2,%3"
5000 [(set_attr "type" "dmul")])
5003 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5004 (minus:DF (match_operand:DF 3 "gpc_reg_operand" "f")
5005 (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
5006 (match_operand:DF 2 "gpc_reg_operand" "f"))))]
5007 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_FUSED_MADD
5008 && ! HONOR_SIGNED_ZEROS (DFmode)"
5009 "{fnms|fnmsub} %0,%1,%2,%3"
5010 [(set_attr "type" "dmul")])
5012 (define_insn "sqrtdf2"
5013 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5014 (sqrt:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
5015 "(TARGET_PPC_GPOPT || TARGET_POWER2) && TARGET_HARD_FLOAT && TARGET_FPRS"
5017 [(set_attr "type" "dsqrt")])
5019 ;; The conditional move instructions allow us to perform max and min
5020 ;; operations even when
5022 (define_expand "smaxdf3"
5023 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5024 (if_then_else:DF (ge (match_operand:DF 1 "gpc_reg_operand" "")
5025 (match_operand:DF 2 "gpc_reg_operand" ""))
5028 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && !flag_trapping_math"
5029 "{ rs6000_emit_minmax (operands[0], SMAX, operands[1], operands[2]); DONE;}")
5031 (define_expand "smindf3"
5032 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5033 (if_then_else:DF (ge (match_operand:DF 1 "gpc_reg_operand" "")
5034 (match_operand:DF 2 "gpc_reg_operand" ""))
5037 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && !flag_trapping_math"
5038 "{ rs6000_emit_minmax (operands[0], SMIN, operands[1], operands[2]); DONE;}")
5041 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5042 (match_operator:DF 3 "min_max_operator"
5043 [(match_operand:DF 1 "gpc_reg_operand" "")
5044 (match_operand:DF 2 "gpc_reg_operand" "")]))]
5045 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && !flag_trapping_math"
5048 { rs6000_emit_minmax (operands[0], GET_CODE (operands[3]),
5049 operands[1], operands[2]);
5053 (define_expand "movdfcc"
5054 [(set (match_operand:DF 0 "gpc_reg_operand" "")
5055 (if_then_else:DF (match_operand 1 "comparison_operator" "")
5056 (match_operand:DF 2 "gpc_reg_operand" "")
5057 (match_operand:DF 3 "gpc_reg_operand" "")))]
5058 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS"
5061 if (rs6000_emit_cmove (operands[0], operands[1], operands[2], operands[3]))
5067 (define_insn "*fseldfdf4"
5068 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5069 (if_then_else:DF (ge (match_operand:DF 1 "gpc_reg_operand" "f")
5070 (match_operand:DF 4 "zero_fp_constant" "F"))
5071 (match_operand:DF 2 "gpc_reg_operand" "f")
5072 (match_operand:DF 3 "gpc_reg_operand" "f")))]
5073 "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS"
5075 [(set_attr "type" "fp")])
5077 (define_insn "*fselsfdf4"
5078 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5079 (if_then_else:DF (ge (match_operand:SF 1 "gpc_reg_operand" "f")
5080 (match_operand:SF 4 "zero_fp_constant" "F"))
5081 (match_operand:DF 2 "gpc_reg_operand" "f")
5082 (match_operand:DF 3 "gpc_reg_operand" "f")))]
5085 [(set_attr "type" "fp")])
5087 ;; Conversions to and from floating-point.
5089 (define_expand "fixuns_truncsfsi2"
5090 [(set (match_operand:SI 0 "gpc_reg_operand" "")
5091 (unsigned_fix:SI (match_operand:SF 1 "gpc_reg_operand" "")))]
5092 "TARGET_HARD_FLOAT && !TARGET_FPRS"
5095 (define_expand "fix_truncsfsi2"
5096 [(set (match_operand:SI 0 "gpc_reg_operand" "")
5097 (fix:SI (match_operand:SF 1 "gpc_reg_operand" "")))]
5098 "TARGET_HARD_FLOAT && !TARGET_FPRS"
5101 ; For each of these conversions, there is a define_expand, a define_insn
5102 ; with a '#' template, and a define_split (with C code). The idea is
5103 ; to allow constant folding with the template of the define_insn,
5104 ; then to have the insns split later (between sched1 and final).
5106 (define_expand "floatsidf2"
5107 [(parallel [(set (match_operand:DF 0 "gpc_reg_operand" "")
5108 (float:DF (match_operand:SI 1 "gpc_reg_operand" "")))
5111 (clobber (match_dup 4))
5112 (clobber (match_dup 5))
5113 (clobber (match_dup 6))])]
5114 "TARGET_HARD_FLOAT && TARGET_FPRS"
5117 if (TARGET_E500_DOUBLE)
5119 emit_insn (gen_spe_floatsidf2 (operands[0], operands[1]));
5122 if (TARGET_POWERPC64)
5124 rtx mem = assign_stack_temp (DImode, GET_MODE_SIZE (DImode), 0);
5125 rtx t1 = gen_reg_rtx (DImode);
5126 rtx t2 = gen_reg_rtx (DImode);
5127 emit_insn (gen_floatsidf_ppc64 (operands[0], operands[1], mem, t1, t2));
5131 operands[2] = force_reg (SImode, GEN_INT (0x43300000));
5132 operands[3] = force_reg (DFmode, CONST_DOUBLE_ATOF (\"4503601774854144\", DFmode));
5133 operands[4] = assign_stack_temp (DFmode, GET_MODE_SIZE (DFmode), 0);
5134 operands[5] = gen_reg_rtx (DFmode);
5135 operands[6] = gen_reg_rtx (SImode);
5138 (define_insn_and_split "*floatsidf2_internal"
5139 [(set (match_operand:DF 0 "gpc_reg_operand" "=&f")
5140 (float:DF (match_operand:SI 1 "gpc_reg_operand" "r")))
5141 (use (match_operand:SI 2 "gpc_reg_operand" "r"))
5142 (use (match_operand:DF 3 "gpc_reg_operand" "f"))
5143 (clobber (match_operand:DF 4 "memory_operand" "=o"))
5144 (clobber (match_operand:DF 5 "gpc_reg_operand" "=&f"))
5145 (clobber (match_operand:SI 6 "gpc_reg_operand" "=&r"))]
5146 "! TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS"
5148 "&& (!no_new_pseudos || offsettable_nonstrict_memref_p (operands[4]))"
5152 rtx lowword, highword;
5153 gcc_assert (MEM_P (operands[4]));
5154 highword = adjust_address (operands[4], SImode, 0);
5155 lowword = adjust_address (operands[4], SImode, 4);
5156 if (! WORDS_BIG_ENDIAN)
5159 tmp = highword; highword = lowword; lowword = tmp;
5162 emit_insn (gen_xorsi3 (operands[6], operands[1],
5163 GEN_INT (~ (HOST_WIDE_INT) 0x7fffffff)));
5164 emit_move_insn (lowword, operands[6]);
5165 emit_move_insn (highword, operands[2]);
5166 emit_move_insn (operands[5], operands[4]);
5167 emit_insn (gen_subdf3 (operands[0], operands[5], operands[3]));
5170 [(set_attr "length" "24")])
5172 (define_expand "floatunssisf2"
5173 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5174 (unsigned_float:SF (match_operand:SI 1 "gpc_reg_operand" "")))]
5175 "TARGET_HARD_FLOAT && !TARGET_FPRS"
5178 (define_expand "floatunssidf2"
5179 [(parallel [(set (match_operand:DF 0 "gpc_reg_operand" "")
5180 (unsigned_float:DF (match_operand:SI 1 "gpc_reg_operand" "")))
5183 (clobber (match_dup 4))
5184 (clobber (match_dup 5))])]
5185 "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)"
5188 if (TARGET_E500_DOUBLE)
5190 emit_insn (gen_spe_floatunssidf2 (operands[0], operands[1]));
5193 if (TARGET_POWERPC64)
5195 rtx mem = assign_stack_temp (DImode, GET_MODE_SIZE (DImode), 0);
5196 rtx t1 = gen_reg_rtx (DImode);
5197 rtx t2 = gen_reg_rtx (DImode);
5198 emit_insn (gen_floatunssidf_ppc64 (operands[0], operands[1], mem,
5203 operands[2] = force_reg (SImode, GEN_INT (0x43300000));
5204 operands[3] = force_reg (DFmode, CONST_DOUBLE_ATOF (\"4503599627370496\", DFmode));
5205 operands[4] = assign_stack_temp (DFmode, GET_MODE_SIZE (DFmode), 0);
5206 operands[5] = gen_reg_rtx (DFmode);
5209 (define_insn_and_split "*floatunssidf2_internal"
5210 [(set (match_operand:DF 0 "gpc_reg_operand" "=&f")
5211 (unsigned_float:DF (match_operand:SI 1 "gpc_reg_operand" "r")))
5212 (use (match_operand:SI 2 "gpc_reg_operand" "r"))
5213 (use (match_operand:DF 3 "gpc_reg_operand" "f"))
5214 (clobber (match_operand:DF 4 "memory_operand" "=o"))
5215 (clobber (match_operand:DF 5 "gpc_reg_operand" "=&f"))]
5216 "! TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS"
5218 "&& (!no_new_pseudos || offsettable_nonstrict_memref_p (operands[4]))"
5222 rtx lowword, highword;
5223 gcc_assert (MEM_P (operands[4]));
5224 highword = adjust_address (operands[4], SImode, 0);
5225 lowword = adjust_address (operands[4], SImode, 4);
5226 if (! WORDS_BIG_ENDIAN)
5229 tmp = highword; highword = lowword; lowword = tmp;
5232 emit_move_insn (lowword, operands[1]);
5233 emit_move_insn (highword, operands[2]);
5234 emit_move_insn (operands[5], operands[4]);
5235 emit_insn (gen_subdf3 (operands[0], operands[5], operands[3]));
5238 [(set_attr "length" "20")])
5240 (define_expand "fix_truncdfsi2"
5241 [(parallel [(set (match_operand:SI 0 "fix_trunc_dest_operand" "")
5242 (fix:SI (match_operand:DF 1 "gpc_reg_operand" "")))
5243 (clobber (match_dup 2))
5244 (clobber (match_dup 3))])]
5245 "(TARGET_POWER2 || TARGET_POWERPC)
5246 && TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)"
5249 if (TARGET_E500_DOUBLE)
5251 emit_insn (gen_spe_fix_truncdfsi2 (operands[0], operands[1]));
5254 operands[2] = gen_reg_rtx (DImode);
5255 if (TARGET_PPC_GFXOPT)
5257 rtx orig_dest = operands[0];
5258 if (! memory_operand (orig_dest, GET_MODE (orig_dest)))
5259 operands[0] = assign_stack_temp (SImode, GET_MODE_SIZE (SImode), 0);
5260 emit_insn (gen_fix_truncdfsi2_internal_gfxopt (operands[0], operands[1],
5262 if (operands[0] != orig_dest)
5263 emit_move_insn (orig_dest, operands[0]);
5266 operands[3] = assign_stack_temp (DImode, GET_MODE_SIZE (DImode), 0);
5269 (define_insn_and_split "*fix_truncdfsi2_internal"
5270 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
5271 (fix:SI (match_operand:DF 1 "gpc_reg_operand" "f")))
5272 (clobber (match_operand:DI 2 "gpc_reg_operand" "=f"))
5273 (clobber (match_operand:DI 3 "memory_operand" "=o"))]
5274 "(TARGET_POWER2 || TARGET_POWERPC) && TARGET_HARD_FLOAT && TARGET_FPRS"
5276 "&& (!no_new_pseudos || offsettable_nonstrict_memref_p (operands[3]))"
5281 gcc_assert (MEM_P (operands[3]));
5282 lowword = adjust_address (operands[3], SImode, WORDS_BIG_ENDIAN ? 4 : 0);
5284 emit_insn (gen_fctiwz (operands[2], operands[1]));
5285 emit_move_insn (operands[3], operands[2]);
5286 emit_move_insn (operands[0], lowword);
5289 [(set_attr "length" "16")])
5291 (define_insn_and_split "fix_truncdfsi2_internal_gfxopt"
5292 [(set (match_operand:SI 0 "memory_operand" "=Z")
5293 (fix:SI (match_operand:DF 1 "gpc_reg_operand" "f")))
5294 (clobber (match_operand:DI 2 "gpc_reg_operand" "=f"))]
5295 "(TARGET_POWER2 || TARGET_POWERPC) && TARGET_HARD_FLOAT && TARGET_FPRS
5296 && TARGET_PPC_GFXOPT"
5302 emit_insn (gen_fctiwz (operands[2], operands[1]));
5303 emit_insn (gen_stfiwx (operands[0], operands[2]));
5306 [(set_attr "length" "16")])
5308 ; Here, we use (set (reg) (unspec:DI [(fix:SI ...)] UNSPEC_FCTIWZ))
5309 ; rather than (set (subreg:SI (reg)) (fix:SI ...))
5310 ; because the first makes it clear that operand 0 is not live
5311 ; before the instruction.
5312 (define_insn "fctiwz"
5313 [(set (match_operand:DI 0 "gpc_reg_operand" "=f")
5314 (unspec:DI [(fix:SI (match_operand:DF 1 "gpc_reg_operand" "f"))]
5316 "(TARGET_POWER2 || TARGET_POWERPC) && TARGET_HARD_FLOAT && TARGET_FPRS"
5317 "{fcirz|fctiwz} %0,%1"
5318 [(set_attr "type" "fp")])
5320 ; An UNSPEC is used so we don't have to support SImode in FP registers.
5321 (define_insn "stfiwx"
5322 [(set (match_operand:SI 0 "memory_operand" "=Z")
5323 (unspec:SI [(match_operand:DI 1 "gpc_reg_operand" "f")]
5327 [(set_attr "type" "fpstore")])
5329 (define_expand "floatsisf2"
5330 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5331 (float:SF (match_operand:SI 1 "gpc_reg_operand" "")))]
5332 "TARGET_HARD_FLOAT && !TARGET_FPRS"
5335 (define_insn "floatdidf2"
5336 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5337 (float:DF (match_operand:DI 1 "gpc_reg_operand" "*f")))]
5338 "TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS"
5340 [(set_attr "type" "fp")])
5342 (define_insn_and_split "floatsidf_ppc64"
5343 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5344 (float:DF (match_operand:SI 1 "gpc_reg_operand" "r")))
5345 (clobber (match_operand:DI 2 "memory_operand" "=o"))
5346 (clobber (match_operand:DI 3 "gpc_reg_operand" "=r"))
5347 (clobber (match_operand:DI 4 "gpc_reg_operand" "=f"))]
5348 "TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS"
5351 [(set (match_dup 3) (sign_extend:DI (match_dup 1)))
5352 (set (match_dup 2) (match_dup 3))
5353 (set (match_dup 4) (match_dup 2))
5354 (set (match_dup 0) (float:DF (match_dup 4)))]
5357 (define_insn_and_split "floatunssidf_ppc64"
5358 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
5359 (unsigned_float:DF (match_operand:SI 1 "gpc_reg_operand" "r")))
5360 (clobber (match_operand:DI 2 "memory_operand" "=o"))
5361 (clobber (match_operand:DI 3 "gpc_reg_operand" "=r"))
5362 (clobber (match_operand:DI 4 "gpc_reg_operand" "=f"))]
5363 "TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS"
5366 [(set (match_dup 3) (zero_extend:DI (match_dup 1)))
5367 (set (match_dup 2) (match_dup 3))
5368 (set (match_dup 4) (match_dup 2))
5369 (set (match_dup 0) (float:DF (match_dup 4)))]
5372 (define_insn "fix_truncdfdi2"
5373 [(set (match_operand:DI 0 "gpc_reg_operand" "=*f")
5374 (fix:DI (match_operand:DF 1 "gpc_reg_operand" "f")))]
5375 "TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS"
5377 [(set_attr "type" "fp")])
5379 (define_expand "floatdisf2"
5380 [(set (match_operand:SF 0 "gpc_reg_operand" "")
5381 (float:SF (match_operand:DI 1 "gpc_reg_operand" "")))]
5382 "TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS"
5385 rtx val = operands[1];
5386 if (!flag_unsafe_math_optimizations)
5388 rtx label = gen_label_rtx ();
5389 val = gen_reg_rtx (DImode);
5390 emit_insn (gen_floatdisf2_internal2 (val, operands[1], label));
5393 emit_insn (gen_floatdisf2_internal1 (operands[0], val));
5397 ;; This is not IEEE compliant if rounding mode is "round to nearest".
5398 ;; If the DI->DF conversion is inexact, then it's possible to suffer
5399 ;; from double rounding.
5400 (define_insn_and_split "floatdisf2_internal1"
5401 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
5402 (float:SF (match_operand:DI 1 "gpc_reg_operand" "*f")))
5403 (clobber (match_scratch:DF 2 "=f"))]
5404 "TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS"
5406 "&& reload_completed"
5408 (float:DF (match_dup 1)))
5410 (float_truncate:SF (match_dup 2)))]
5413 ;; Twiddles bits to avoid double rounding.
5414 ;; Bits that might be truncated when converting to DFmode are replaced
5415 ;; by a bit that won't be lost at that stage, but is below the SFmode
5416 ;; rounding position.
5417 (define_expand "floatdisf2_internal2"
5418 [(set (match_dup 3) (ashiftrt:DI (match_operand:DI 1 "" "")
5420 (parallel [(set (match_operand:DI 0 "" "") (and:DI (match_dup 1)
5422 (clobber (scratch:CC))])
5423 (set (match_dup 3) (plus:DI (match_dup 3)
5425 (set (match_dup 0) (plus:DI (match_dup 0)
5427 (set (match_dup 4) (compare:CCUNS (match_dup 3)
5429 (set (match_dup 0) (ior:DI (match_dup 0)
5431 (parallel [(set (match_dup 0) (and:DI (match_dup 0)
5433 (clobber (scratch:CC))])
5434 (set (pc) (if_then_else (geu (match_dup 4) (const_int 0))
5435 (label_ref (match_operand:DI 2 "" ""))
5437 (set (match_dup 0) (match_dup 1))]
5438 "TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS"
5441 operands[3] = gen_reg_rtx (DImode);
5442 operands[4] = gen_reg_rtx (CCUNSmode);
5445 ;; Define the DImode operations that can be done in a small number
5446 ;; of instructions. The & constraints are to prevent the register
5447 ;; allocator from allocating registers that overlap with the inputs
5448 ;; (for example, having an input in 7,8 and an output in 6,7). We
5449 ;; also allow for the output being the same as one of the inputs.
5451 (define_insn "*adddi3_noppc64"
5452 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,&r,r,r")
5453 (plus:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,0,0")
5454 (match_operand:DI 2 "reg_or_short_operand" "r,I,r,I")))]
5455 "! TARGET_POWERPC64"
5458 if (WORDS_BIG_ENDIAN)
5459 return (GET_CODE (operands[2])) != CONST_INT
5460 ? \"{a|addc} %L0,%L1,%L2\;{ae|adde} %0,%1,%2\"
5461 : \"{ai|addic} %L0,%L1,%2\;{a%G2e|add%G2e} %0,%1\";
5463 return (GET_CODE (operands[2])) != CONST_INT
5464 ? \"{a|addc} %0,%1,%2\;{ae|adde} %L0,%L1,%L2\"
5465 : \"{ai|addic} %0,%1,%2\;{a%G2e|add%G2e} %L0,%L1\";
5467 [(set_attr "type" "two")
5468 (set_attr "length" "8")])
5470 (define_insn "*subdi3_noppc64"
5471 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,&r,r,r,r")
5472 (minus:DI (match_operand:DI 1 "reg_or_short_operand" "r,I,0,r,I")
5473 (match_operand:DI 2 "gpc_reg_operand" "r,r,r,0,0")))]
5474 "! TARGET_POWERPC64"
5477 if (WORDS_BIG_ENDIAN)
5478 return (GET_CODE (operands[1]) != CONST_INT)
5479 ? \"{sf|subfc} %L0,%L2,%L1\;{sfe|subfe} %0,%2,%1\"
5480 : \"{sfi|subfic} %L0,%L2,%1\;{sf%G1e|subf%G1e} %0,%2\";
5482 return (GET_CODE (operands[1]) != CONST_INT)
5483 ? \"{sf|subfc} %0,%2,%1\;{sfe|subfe} %L0,%L2,%L1\"
5484 : \"{sfi|subfic} %0,%2,%1\;{sf%G1e|subf%G1e} %L0,%L2\";
5486 [(set_attr "type" "two")
5487 (set_attr "length" "8")])
5489 (define_insn "*negdi2_noppc64"
5490 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
5491 (neg:DI (match_operand:DI 1 "gpc_reg_operand" "r,0")))]
5492 "! TARGET_POWERPC64"
5495 return (WORDS_BIG_ENDIAN)
5496 ? \"{sfi|subfic} %L0,%L1,0\;{sfze|subfze} %0,%1\"
5497 : \"{sfi|subfic} %0,%1,0\;{sfze|subfze} %L0,%L1\";
5499 [(set_attr "type" "two")
5500 (set_attr "length" "8")])
5502 (define_expand "mulsidi3"
5503 [(set (match_operand:DI 0 "gpc_reg_operand" "")
5504 (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
5505 (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
5506 "! TARGET_POWERPC64"
5509 if (! TARGET_POWER && ! TARGET_POWERPC)
5511 emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
5512 emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
5513 emit_insn (gen_mull_call ());
5514 if (WORDS_BIG_ENDIAN)
5515 emit_move_insn (operands[0], gen_rtx_REG (DImode, 3));
5518 emit_move_insn (operand_subword (operands[0], 0, 0, DImode),
5519 gen_rtx_REG (SImode, 3));
5520 emit_move_insn (operand_subword (operands[0], 1, 0, DImode),
5521 gen_rtx_REG (SImode, 4));
5525 else if (TARGET_POWER)
5527 emit_insn (gen_mulsidi3_mq (operands[0], operands[1], operands[2]));
5532 (define_insn "mulsidi3_mq"
5533 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
5534 (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
5535 (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))
5536 (clobber (match_scratch:SI 3 "=q"))]
5538 "mul %0,%1,%2\;mfmq %L0"
5539 [(set_attr "type" "imul")
5540 (set_attr "length" "8")])
5542 (define_insn "*mulsidi3_no_mq"
5543 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r")
5544 (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
5545 (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
5546 "TARGET_POWERPC && ! TARGET_POWER && ! TARGET_POWERPC64"
5549 return (WORDS_BIG_ENDIAN)
5550 ? \"mulhw %0,%1,%2\;mullw %L0,%1,%2\"
5551 : \"mulhw %L0,%1,%2\;mullw %0,%1,%2\";
5553 [(set_attr "type" "imul")
5554 (set_attr "length" "8")])
5557 [(set (match_operand:DI 0 "gpc_reg_operand" "")
5558 (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
5559 (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
5560 "TARGET_POWERPC && ! TARGET_POWERPC64 && reload_completed"
5563 (lshiftrt:DI (mult:DI (sign_extend:DI (match_dup 1))
5564 (sign_extend:DI (match_dup 2)))
5567 (mult:SI (match_dup 1)
5571 int endian = (WORDS_BIG_ENDIAN == 0);
5572 operands[3] = operand_subword (operands[0], endian, 0, DImode);
5573 operands[4] = operand_subword (operands[0], 1 - endian, 0, DImode);
5576 (define_expand "umulsidi3"
5577 [(set (match_operand:DI 0 "gpc_reg_operand" "")
5578 (mult:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
5579 (zero_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
5580 "TARGET_POWERPC && ! TARGET_POWERPC64"
5585 emit_insn (gen_umulsidi3_mq (operands[0], operands[1], operands[2]));
5590 (define_insn "umulsidi3_mq"
5591 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r")
5592 (mult:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
5593 (zero_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))
5594 (clobber (match_scratch:SI 3 "=q"))]
5595 "TARGET_POWERPC && TARGET_POWER"
5598 return (WORDS_BIG_ENDIAN)
5599 ? \"mulhwu %0,%1,%2\;mullw %L0,%1,%2\"
5600 : \"mulhwu %L0,%1,%2\;mullw %0,%1,%2\";
5602 [(set_attr "type" "imul")
5603 (set_attr "length" "8")])
5605 (define_insn "*umulsidi3_no_mq"
5606 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r")
5607 (mult:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
5608 (zero_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
5609 "TARGET_POWERPC && ! TARGET_POWER && ! TARGET_POWERPC64"
5612 return (WORDS_BIG_ENDIAN)
5613 ? \"mulhwu %0,%1,%2\;mullw %L0,%1,%2\"
5614 : \"mulhwu %L0,%1,%2\;mullw %0,%1,%2\";
5616 [(set_attr "type" "imul")
5617 (set_attr "length" "8")])
5620 [(set (match_operand:DI 0 "gpc_reg_operand" "")
5621 (mult:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
5622 (zero_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
5623 "TARGET_POWERPC && ! TARGET_POWERPC64 && reload_completed"
5626 (lshiftrt:DI (mult:DI (zero_extend:DI (match_dup 1))
5627 (zero_extend:DI (match_dup 2)))
5630 (mult:SI (match_dup 1)
5634 int endian = (WORDS_BIG_ENDIAN == 0);
5635 operands[3] = operand_subword (operands[0], endian, 0, DImode);
5636 operands[4] = operand_subword (operands[0], 1 - endian, 0, DImode);
5639 (define_expand "smulsi3_highpart"
5640 [(set (match_operand:SI 0 "gpc_reg_operand" "")
5642 (lshiftrt:DI (mult:DI (sign_extend:DI
5643 (match_operand:SI 1 "gpc_reg_operand" "%r"))
5645 (match_operand:SI 2 "gpc_reg_operand" "r")))
5650 if (! TARGET_POWER && ! TARGET_POWERPC)
5652 emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
5653 emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
5654 emit_insn (gen_mulh_call ());
5655 emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
5658 else if (TARGET_POWER)
5660 emit_insn (gen_smulsi3_highpart_mq (operands[0], operands[1], operands[2]));
5665 (define_insn "smulsi3_highpart_mq"
5666 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
5668 (lshiftrt:DI (mult:DI (sign_extend:DI
5669 (match_operand:SI 1 "gpc_reg_operand" "%r"))
5671 (match_operand:SI 2 "gpc_reg_operand" "r")))
5673 (clobber (match_scratch:SI 3 "=q"))]
5676 [(set_attr "type" "imul")])
5678 (define_insn "*smulsi3_highpart_no_mq"
5679 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
5681 (lshiftrt:DI (mult:DI (sign_extend:DI
5682 (match_operand:SI 1 "gpc_reg_operand" "%r"))
5684 (match_operand:SI 2 "gpc_reg_operand" "r")))
5686 "TARGET_POWERPC && ! TARGET_POWER"
5688 [(set_attr "type" "imul")])
5690 (define_expand "umulsi3_highpart"
5691 [(set (match_operand:SI 0 "gpc_reg_operand" "")
5693 (lshiftrt:DI (mult:DI (zero_extend:DI
5694 (match_operand:SI 1 "gpc_reg_operand" ""))
5696 (match_operand:SI 2 "gpc_reg_operand" "")))
5703 emit_insn (gen_umulsi3_highpart_mq (operands[0], operands[1], operands[2]));
5708 (define_insn "umulsi3_highpart_mq"
5709 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
5711 (lshiftrt:DI (mult:DI (zero_extend:DI
5712 (match_operand:SI 1 "gpc_reg_operand" "%r"))
5714 (match_operand:SI 2 "gpc_reg_operand" "r")))
5716 (clobber (match_scratch:SI 3 "=q"))]
5717 "TARGET_POWERPC && TARGET_POWER"
5719 [(set_attr "type" "imul")])
5721 (define_insn "*umulsi3_highpart_no_mq"
5722 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
5724 (lshiftrt:DI (mult:DI (zero_extend:DI
5725 (match_operand:SI 1 "gpc_reg_operand" "%r"))
5727 (match_operand:SI 2 "gpc_reg_operand" "r")))
5729 "TARGET_POWERPC && ! TARGET_POWER"
5731 [(set_attr "type" "imul")])
5733 ;; If operands 0 and 2 are in the same register, we have a problem. But
5734 ;; operands 0 and 1 (the usual case) can be in the same register. That's
5735 ;; why we have the strange constraints below.
5736 (define_insn "ashldi3_power"
5737 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,&r")
5738 (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,0,r")
5739 (match_operand:SI 2 "reg_or_cint_operand" "M,i,r,r")))
5740 (clobber (match_scratch:SI 3 "=X,q,q,q"))]
5743 {sli|slwi} %0,%L1,%h2\;{cal %L0,0(0)|li %L0,0}
5744 sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2
5745 sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2
5746 sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2"
5747 [(set_attr "length" "8")])
5749 (define_insn "lshrdi3_power"
5750 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,&r")
5751 (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,0,r")
5752 (match_operand:SI 2 "reg_or_cint_operand" "M,i,r,r")))
5753 (clobber (match_scratch:SI 3 "=X,q,q,q"))]
5756 {s%A2i|s%A2wi} %L0,%1,%h2\;{cal %0,0(0)|li %0,0}
5757 sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2
5758 sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2
5759 sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2"
5760 [(set_attr "length" "8")])
5762 ;; Shift by a variable amount is too complex to be worth open-coding. We
5763 ;; just handle shifts by constants.
5764 (define_insn "ashrdi3_power"
5765 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
5766 (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
5767 (match_operand:SI 2 "const_int_operand" "M,i")))
5768 (clobber (match_scratch:SI 3 "=X,q"))]
5771 {srai|srawi} %0,%1,31\;{srai|srawi} %L0,%1,%h2
5772 sraiq %0,%1,%h2\;srliq %L0,%L1,%h2"
5773 [(set_attr "length" "8")])
5775 (define_insn "ashrdi3_no_power"
5776 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,&r")
5777 (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
5778 (match_operand:SI 2 "const_int_operand" "M,i")))]
5779 "TARGET_32BIT && !TARGET_POWERPC64 && !TARGET_POWER && WORDS_BIG_ENDIAN"
5781 {srai|srawi} %0,%1,31\;{srai|srawi} %L0,%1,%h2
5782 {sri|srwi} %L0,%L1,%h2\;insrwi %L0,%1,%h2,0\;{srai|srawi} %0,%1,%h2"
5783 [(set_attr "type" "two,three")
5784 (set_attr "length" "8,12")])
5786 (define_insn "*ashrdisi3_noppc64"
5787 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
5788 (subreg:SI (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
5789 (const_int 32)) 4))]
5790 "TARGET_32BIT && !TARGET_POWERPC64"
5793 if (REGNO (operands[0]) == REGNO (operands[1]))
5796 return \"mr %0,%1\";
5798 [(set_attr "length" "4")])
5801 ;; PowerPC64 DImode operations.
5803 (define_insn_and_split "absdi2"
5804 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
5805 (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,0")))
5806 (clobber (match_scratch:DI 2 "=&r,&r"))]
5809 "&& reload_completed"
5810 [(set (match_dup 2) (ashiftrt:DI (match_dup 1) (const_int 63)))
5811 (set (match_dup 0) (xor:DI (match_dup 2) (match_dup 1)))
5812 (set (match_dup 0) (minus:DI (match_dup 0) (match_dup 2)))]
5815 (define_insn_and_split "*nabsdi2"
5816 [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
5817 (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,0"))))
5818 (clobber (match_scratch:DI 2 "=&r,&r"))]
5821 "&& reload_completed"
5822 [(set (match_dup 2) (ashiftrt:DI (match_dup 1) (const_int 63)))
5823 (set (match_dup 0) (xor:DI (match_dup 2) (match_dup 1)))
5824 (set (match_dup 0) (minus:DI (match_dup 2) (match_dup 0)))]
5827 (define_insn "muldi3"
5828 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
5829 (mult:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
5830 (match_operand:DI 2 "gpc_reg_operand" "r")))]
5833 [(set_attr "type" "lmul")])
5835 (define_insn "*muldi3_internal1"
5836 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
5837 (compare:CC (mult:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r")
5838 (match_operand:DI 2 "gpc_reg_operand" "r,r"))
5840 (clobber (match_scratch:DI 3 "=r,r"))]
5845 [(set_attr "type" "lmul_compare")
5846 (set_attr "length" "4,8")])
5849 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
5850 (compare:CC (mult:DI (match_operand:DI 1 "gpc_reg_operand" "")
5851 (match_operand:DI 2 "gpc_reg_operand" ""))
5853 (clobber (match_scratch:DI 3 ""))]
5854 "TARGET_POWERPC64 && reload_completed"
5856 (mult:DI (match_dup 1) (match_dup 2)))
5858 (compare:CC (match_dup 3)
5862 (define_insn "*muldi3_internal2"
5863 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
5864 (compare:CC (mult:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r")
5865 (match_operand:DI 2 "gpc_reg_operand" "r,r"))
5867 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
5868 (mult:DI (match_dup 1) (match_dup 2)))]
5873 [(set_attr "type" "lmul_compare")
5874 (set_attr "length" "4,8")])
5877 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
5878 (compare:CC (mult:DI (match_operand:DI 1 "gpc_reg_operand" "")
5879 (match_operand:DI 2 "gpc_reg_operand" ""))
5881 (set (match_operand:DI 0 "gpc_reg_operand" "")
5882 (mult:DI (match_dup 1) (match_dup 2)))]
5883 "TARGET_POWERPC64 && reload_completed"
5885 (mult:DI (match_dup 1) (match_dup 2)))
5887 (compare:CC (match_dup 0)
5891 (define_insn "smuldi3_highpart"
5892 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
5894 (lshiftrt:TI (mult:TI (sign_extend:TI
5895 (match_operand:DI 1 "gpc_reg_operand" "%r"))
5897 (match_operand:DI 2 "gpc_reg_operand" "r")))
5901 [(set_attr "type" "lmul")])
5903 (define_insn "umuldi3_highpart"
5904 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
5906 (lshiftrt:TI (mult:TI (zero_extend:TI
5907 (match_operand:DI 1 "gpc_reg_operand" "%r"))
5909 (match_operand:DI 2 "gpc_reg_operand" "r")))
5913 [(set_attr "type" "lmul")])
5915 (define_insn "rotldi3"
5916 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
5917 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r")
5918 (match_operand:DI 2 "reg_or_cint_operand" "ri")))]
5920 "rld%I2cl %0,%1,%H2,0")
5922 (define_insn "*rotldi3_internal2"
5923 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
5924 (compare:CC (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
5925 (match_operand:DI 2 "reg_or_cint_operand" "ri,ri"))
5927 (clobber (match_scratch:DI 3 "=r,r"))]
5930 rld%I2cl. %3,%1,%H2,0
5932 [(set_attr "type" "delayed_compare")
5933 (set_attr "length" "4,8")])
5936 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
5937 (compare:CC (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
5938 (match_operand:DI 2 "reg_or_cint_operand" ""))
5940 (clobber (match_scratch:DI 3 ""))]
5941 "TARGET_POWERPC64 && reload_completed"
5943 (rotate:DI (match_dup 1) (match_dup 2)))
5945 (compare:CC (match_dup 3)
5949 (define_insn "*rotldi3_internal3"
5950 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
5951 (compare:CC (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
5952 (match_operand:DI 2 "reg_or_cint_operand" "ri,ri"))
5954 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
5955 (rotate:DI (match_dup 1) (match_dup 2)))]
5958 rld%I2cl. %0,%1,%H2,0
5960 [(set_attr "type" "delayed_compare")
5961 (set_attr "length" "4,8")])
5964 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
5965 (compare:CC (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
5966 (match_operand:DI 2 "reg_or_cint_operand" ""))
5968 (set (match_operand:DI 0 "gpc_reg_operand" "")
5969 (rotate:DI (match_dup 1) (match_dup 2)))]
5970 "TARGET_POWERPC64 && reload_completed"
5972 (rotate:DI (match_dup 1) (match_dup 2)))
5974 (compare:CC (match_dup 0)
5978 (define_insn "*rotldi3_internal4"
5979 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
5980 (and:DI (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r")
5981 (match_operand:DI 2 "reg_or_cint_operand" "ri"))
5982 (match_operand:DI 3 "mask64_operand" "n")))]
5984 "rld%I2c%B3 %0,%1,%H2,%S3")
5986 (define_insn "*rotldi3_internal5"
5987 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
5989 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
5990 (match_operand:DI 2 "reg_or_cint_operand" "ri,ri"))
5991 (match_operand:DI 3 "mask64_operand" "n,n"))
5993 (clobber (match_scratch:DI 4 "=r,r"))]
5996 rld%I2c%B3. %4,%1,%H2,%S3
5998 [(set_attr "type" "delayed_compare")
5999 (set_attr "length" "4,8")])
6002 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
6004 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
6005 (match_operand:DI 2 "reg_or_cint_operand" ""))
6006 (match_operand:DI 3 "mask64_operand" ""))
6008 (clobber (match_scratch:DI 4 ""))]
6009 "TARGET_POWERPC64 && reload_completed"
6011 (and:DI (rotate:DI (match_dup 1)
6015 (compare:CC (match_dup 4)
6019 (define_insn "*rotldi3_internal6"
6020 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
6022 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6023 (match_operand:DI 2 "reg_or_cint_operand" "ri,ri"))
6024 (match_operand:DI 3 "mask64_operand" "n,n"))
6026 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6027 (and:DI (rotate:DI (match_dup 1) (match_dup 2)) (match_dup 3)))]
6030 rld%I2c%B3. %0,%1,%H2,%S3
6032 [(set_attr "type" "delayed_compare")
6033 (set_attr "length" "4,8")])
6036 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
6038 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
6039 (match_operand:DI 2 "reg_or_cint_operand" ""))
6040 (match_operand:DI 3 "mask64_operand" ""))
6042 (set (match_operand:DI 0 "gpc_reg_operand" "")
6043 (and:DI (rotate:DI (match_dup 1) (match_dup 2)) (match_dup 3)))]
6044 "TARGET_POWERPC64 && reload_completed"
6046 (and:DI (rotate:DI (match_dup 1) (match_dup 2)) (match_dup 3)))
6048 (compare:CC (match_dup 0)
6052 (define_insn "*rotldi3_internal7"
6053 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
6056 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r")
6057 (match_operand:DI 2 "reg_or_cint_operand" "ri")) 0)))]
6059 "rld%I2cl %0,%1,%H2,56")
6061 (define_insn "*rotldi3_internal8"
6062 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
6063 (compare:CC (zero_extend:DI
6065 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6066 (match_operand:DI 2 "reg_or_cint_operand" "ri,ri")) 0))
6068 (clobber (match_scratch:DI 3 "=r,r"))]
6071 rld%I2cl. %3,%1,%H2,56
6073 [(set_attr "type" "delayed_compare")
6074 (set_attr "length" "4,8")])
6077 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
6078 (compare:CC (zero_extend:DI
6080 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
6081 (match_operand:DI 2 "reg_or_cint_operand" "")) 0))
6083 (clobber (match_scratch:DI 3 ""))]
6084 "TARGET_POWERPC64 && reload_completed"
6086 (zero_extend:DI (subreg:QI
6087 (rotate:DI (match_dup 1)
6090 (compare:CC (match_dup 3)
6094 (define_insn "*rotldi3_internal9"
6095 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
6096 (compare:CC (zero_extend:DI
6098 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6099 (match_operand:DI 2 "reg_or_cint_operand" "ri,ri")) 0))
6101 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6102 (zero_extend:DI (subreg:QI (rotate:DI (match_dup 1) (match_dup 2)) 0)))]
6105 rld%I2cl. %0,%1,%H2,56
6107 [(set_attr "type" "delayed_compare")
6108 (set_attr "length" "4,8")])
6111 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
6112 (compare:CC (zero_extend:DI
6114 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
6115 (match_operand:DI 2 "reg_or_cint_operand" "")) 0))
6117 (set (match_operand:DI 0 "gpc_reg_operand" "")
6118 (zero_extend:DI (subreg:QI (rotate:DI (match_dup 1) (match_dup 2)) 0)))]
6119 "TARGET_POWERPC64 && reload_completed"
6121 (zero_extend:DI (subreg:QI (rotate:DI (match_dup 1) (match_dup 2)) 0)))
6123 (compare:CC (match_dup 0)
6127 (define_insn "*rotldi3_internal10"
6128 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
6131 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r")
6132 (match_operand:DI 2 "reg_or_cint_operand" "ri")) 0)))]
6134 "rld%I2cl %0,%1,%H2,48")
6136 (define_insn "*rotldi3_internal11"
6137 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
6138 (compare:CC (zero_extend:DI
6140 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6141 (match_operand:DI 2 "reg_or_cint_operand" "ri,ri")) 0))
6143 (clobber (match_scratch:DI 3 "=r,r"))]
6146 rld%I2cl. %3,%1,%H2,48
6148 [(set_attr "type" "delayed_compare")
6149 (set_attr "length" "4,8")])
6152 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
6153 (compare:CC (zero_extend:DI
6155 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
6156 (match_operand:DI 2 "reg_or_cint_operand" "")) 0))
6158 (clobber (match_scratch:DI 3 ""))]
6159 "TARGET_POWERPC64 && reload_completed"
6161 (zero_extend:DI (subreg:HI
6162 (rotate:DI (match_dup 1)
6165 (compare:CC (match_dup 3)
6169 (define_insn "*rotldi3_internal12"
6170 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
6171 (compare:CC (zero_extend:DI
6173 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6174 (match_operand:DI 2 "reg_or_cint_operand" "ri,ri")) 0))
6176 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6177 (zero_extend:DI (subreg:HI (rotate:DI (match_dup 1) (match_dup 2)) 0)))]
6180 rld%I2cl. %0,%1,%H2,48
6182 [(set_attr "type" "delayed_compare")
6183 (set_attr "length" "4,8")])
6186 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
6187 (compare:CC (zero_extend:DI
6189 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
6190 (match_operand:DI 2 "reg_or_cint_operand" "")) 0))
6192 (set (match_operand:DI 0 "gpc_reg_operand" "")
6193 (zero_extend:DI (subreg:HI (rotate:DI (match_dup 1) (match_dup 2)) 0)))]
6194 "TARGET_POWERPC64 && reload_completed"
6196 (zero_extend:DI (subreg:HI (rotate:DI (match_dup 1) (match_dup 2)) 0)))
6198 (compare:CC (match_dup 0)
6202 (define_insn "*rotldi3_internal13"
6203 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
6206 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r")
6207 (match_operand:DI 2 "reg_or_cint_operand" "ri")) 0)))]
6209 "rld%I2cl %0,%1,%H2,32")
6211 (define_insn "*rotldi3_internal14"
6212 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
6213 (compare:CC (zero_extend:DI
6215 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6216 (match_operand:DI 2 "reg_or_cint_operand" "ri,ri")) 0))
6218 (clobber (match_scratch:DI 3 "=r,r"))]
6221 rld%I2cl. %3,%1,%H2,32
6223 [(set_attr "type" "delayed_compare")
6224 (set_attr "length" "4,8")])
6227 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
6228 (compare:CC (zero_extend:DI
6230 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
6231 (match_operand:DI 2 "reg_or_cint_operand" "")) 0))
6233 (clobber (match_scratch:DI 3 ""))]
6234 "TARGET_POWERPC64 && reload_completed"
6236 (zero_extend:DI (subreg:SI
6237 (rotate:DI (match_dup 1)
6240 (compare:CC (match_dup 3)
6244 (define_insn "*rotldi3_internal15"
6245 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
6246 (compare:CC (zero_extend:DI
6248 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6249 (match_operand:DI 2 "reg_or_cint_operand" "ri,ri")) 0))
6251 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6252 (zero_extend:DI (subreg:SI (rotate:DI (match_dup 1) (match_dup 2)) 0)))]
6255 rld%I2cl. %0,%1,%H2,32
6257 [(set_attr "type" "delayed_compare")
6258 (set_attr "length" "4,8")])
6261 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
6262 (compare:CC (zero_extend:DI
6264 (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "")
6265 (match_operand:DI 2 "reg_or_cint_operand" "")) 0))
6267 (set (match_operand:DI 0 "gpc_reg_operand" "")
6268 (zero_extend:DI (subreg:SI (rotate:DI (match_dup 1) (match_dup 2)) 0)))]
6269 "TARGET_POWERPC64 && reload_completed"
6271 (zero_extend:DI (subreg:SI (rotate:DI (match_dup 1) (match_dup 2)) 0)))
6273 (compare:CC (match_dup 0)
6277 (define_expand "ashldi3"
6278 [(set (match_operand:DI 0 "gpc_reg_operand" "")
6279 (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
6280 (match_operand:SI 2 "reg_or_cint_operand" "")))]
6281 "TARGET_POWERPC64 || TARGET_POWER"
6284 if (TARGET_POWERPC64)
6286 else if (TARGET_POWER)
6288 emit_insn (gen_ashldi3_power (operands[0], operands[1], operands[2]));
6295 (define_insn "*ashldi3_internal1"
6296 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
6297 (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r")
6298 (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
6302 (define_insn "*ashldi3_internal2"
6303 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
6304 (compare:CC (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6305 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri"))
6307 (clobber (match_scratch:DI 3 "=r,r"))]
6312 [(set_attr "type" "delayed_compare")
6313 (set_attr "length" "4,8")])
6316 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
6317 (compare:CC (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
6318 (match_operand:SI 2 "reg_or_cint_operand" ""))
6320 (clobber (match_scratch:DI 3 ""))]
6321 "TARGET_POWERPC64 && reload_completed"
6323 (ashift:DI (match_dup 1) (match_dup 2)))
6325 (compare:CC (match_dup 3)
6329 (define_insn "*ashldi3_internal3"
6330 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
6331 (compare:CC (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6332 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri"))
6334 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6335 (ashift:DI (match_dup 1) (match_dup 2)))]
6340 [(set_attr "type" "delayed_compare")
6341 (set_attr "length" "4,8")])
6344 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
6345 (compare:CC (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
6346 (match_operand:SI 2 "reg_or_cint_operand" ""))
6348 (set (match_operand:DI 0 "gpc_reg_operand" "")
6349 (ashift:DI (match_dup 1) (match_dup 2)))]
6350 "TARGET_POWERPC64 && reload_completed"
6352 (ashift:DI (match_dup 1) (match_dup 2)))
6354 (compare:CC (match_dup 0)
6358 (define_insn "*ashldi3_internal4"
6359 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
6360 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r")
6361 (match_operand:SI 2 "const_int_operand" "i"))
6362 (match_operand:DI 3 "const_int_operand" "n")))]
6363 "TARGET_POWERPC64 && includes_rldic_lshift_p (operands[2], operands[3])"
6364 "rldic %0,%1,%H2,%W3")
6366 (define_insn "ashldi3_internal5"
6367 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
6369 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6370 (match_operand:SI 2 "const_int_operand" "i,i"))
6371 (match_operand:DI 3 "const_int_operand" "n,n"))
6373 (clobber (match_scratch:DI 4 "=r,r"))]
6374 "TARGET_64BIT && includes_rldic_lshift_p (operands[2], operands[3])"
6376 rldic. %4,%1,%H2,%W3
6378 [(set_attr "type" "delayed_compare")
6379 (set_attr "length" "4,8")])
6382 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
6384 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
6385 (match_operand:SI 2 "const_int_operand" ""))
6386 (match_operand:DI 3 "const_int_operand" ""))
6388 (clobber (match_scratch:DI 4 ""))]
6389 "TARGET_POWERPC64 && reload_completed
6390 && includes_rldic_lshift_p (operands[2], operands[3])"
6392 (and:DI (ashift:DI (match_dup 1) (match_dup 2))
6395 (compare:CC (match_dup 4)
6399 (define_insn "*ashldi3_internal6"
6400 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
6402 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6403 (match_operand:SI 2 "const_int_operand" "i,i"))
6404 (match_operand:DI 3 "const_int_operand" "n,n"))
6406 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6407 (and:DI (ashift:DI (match_dup 1) (match_dup 2)) (match_dup 3)))]
6408 "TARGET_64BIT && includes_rldic_lshift_p (operands[2], operands[3])"
6410 rldic. %0,%1,%H2,%W3
6412 [(set_attr "type" "delayed_compare")
6413 (set_attr "length" "4,8")])
6416 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
6418 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
6419 (match_operand:SI 2 "const_int_operand" ""))
6420 (match_operand:DI 3 "const_int_operand" ""))
6422 (set (match_operand:DI 0 "gpc_reg_operand" "")
6423 (and:DI (ashift:DI (match_dup 1) (match_dup 2)) (match_dup 3)))]
6424 "TARGET_POWERPC64 && reload_completed
6425 && includes_rldic_lshift_p (operands[2], operands[3])"
6427 (and:DI (ashift:DI (match_dup 1) (match_dup 2))
6430 (compare:CC (match_dup 0)
6434 (define_insn "*ashldi3_internal7"
6435 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
6436 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r")
6437 (match_operand:SI 2 "const_int_operand" "i"))
6438 (match_operand:DI 3 "mask64_operand" "n")))]
6439 "TARGET_POWERPC64 && includes_rldicr_lshift_p (operands[2], operands[3])"
6440 "rldicr %0,%1,%H2,%S3")
6442 (define_insn "ashldi3_internal8"
6443 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
6445 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6446 (match_operand:SI 2 "const_int_operand" "i,i"))
6447 (match_operand:DI 3 "mask64_operand" "n,n"))
6449 (clobber (match_scratch:DI 4 "=r,r"))]
6450 "TARGET_64BIT && includes_rldicr_lshift_p (operands[2], operands[3])"
6452 rldicr. %4,%1,%H2,%S3
6454 [(set_attr "type" "delayed_compare")
6455 (set_attr "length" "4,8")])
6458 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
6460 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
6461 (match_operand:SI 2 "const_int_operand" ""))
6462 (match_operand:DI 3 "mask64_operand" ""))
6464 (clobber (match_scratch:DI 4 ""))]
6465 "TARGET_POWERPC64 && reload_completed
6466 && includes_rldicr_lshift_p (operands[2], operands[3])"
6468 (and:DI (ashift:DI (match_dup 1) (match_dup 2))
6471 (compare:CC (match_dup 4)
6475 (define_insn "*ashldi3_internal9"
6476 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
6478 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6479 (match_operand:SI 2 "const_int_operand" "i,i"))
6480 (match_operand:DI 3 "mask64_operand" "n,n"))
6482 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6483 (and:DI (ashift:DI (match_dup 1) (match_dup 2)) (match_dup 3)))]
6484 "TARGET_64BIT && includes_rldicr_lshift_p (operands[2], operands[3])"
6486 rldicr. %0,%1,%H2,%S3
6488 [(set_attr "type" "delayed_compare")
6489 (set_attr "length" "4,8")])
6492 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
6494 (and:DI (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
6495 (match_operand:SI 2 "const_int_operand" ""))
6496 (match_operand:DI 3 "mask64_operand" ""))
6498 (set (match_operand:DI 0 "gpc_reg_operand" "")
6499 (and:DI (ashift:DI (match_dup 1) (match_dup 2)) (match_dup 3)))]
6500 "TARGET_POWERPC64 && reload_completed
6501 && includes_rldicr_lshift_p (operands[2], operands[3])"
6503 (and:DI (ashift:DI (match_dup 1) (match_dup 2))
6506 (compare:CC (match_dup 0)
6510 (define_expand "lshrdi3"
6511 [(set (match_operand:DI 0 "gpc_reg_operand" "")
6512 (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
6513 (match_operand:SI 2 "reg_or_cint_operand" "")))]
6514 "TARGET_POWERPC64 || TARGET_POWER"
6517 if (TARGET_POWERPC64)
6519 else if (TARGET_POWER)
6521 emit_insn (gen_lshrdi3_power (operands[0], operands[1], operands[2]));
6528 (define_insn "*lshrdi3_internal1"
6529 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
6530 (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
6531 (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
6535 (define_insn "*lshrdi3_internal2"
6536 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
6537 (compare:CC (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6538 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri"))
6540 (clobber (match_scratch:DI 3 "=r,r"))]
6545 [(set_attr "type" "delayed_compare")
6546 (set_attr "length" "4,8")])
6549 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
6550 (compare:CC (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
6551 (match_operand:SI 2 "reg_or_cint_operand" ""))
6553 (clobber (match_scratch:DI 3 ""))]
6554 "TARGET_POWERPC64 && reload_completed"
6556 (lshiftrt:DI (match_dup 1) (match_dup 2)))
6558 (compare:CC (match_dup 3)
6562 (define_insn "*lshrdi3_internal3"
6563 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
6564 (compare:CC (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6565 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri"))
6567 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6568 (lshiftrt:DI (match_dup 1) (match_dup 2)))]
6573 [(set_attr "type" "delayed_compare")
6574 (set_attr "length" "4,8")])
6577 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
6578 (compare:CC (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
6579 (match_operand:SI 2 "reg_or_cint_operand" ""))
6581 (set (match_operand:DI 0 "gpc_reg_operand" "")
6582 (lshiftrt:DI (match_dup 1) (match_dup 2)))]
6583 "TARGET_POWERPC64 && reload_completed"
6585 (lshiftrt:DI (match_dup 1) (match_dup 2)))
6587 (compare:CC (match_dup 0)
6591 (define_expand "ashrdi3"
6592 [(set (match_operand:DI 0 "gpc_reg_operand" "")
6593 (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
6594 (match_operand:SI 2 "reg_or_cint_operand" "")))]
6598 if (TARGET_POWERPC64)
6600 else if (TARGET_POWER && GET_CODE (operands[2]) == CONST_INT)
6602 emit_insn (gen_ashrdi3_power (operands[0], operands[1], operands[2]));
6605 else if (TARGET_32BIT && GET_CODE (operands[2]) == CONST_INT
6606 && WORDS_BIG_ENDIAN)
6608 emit_insn (gen_ashrdi3_no_power (operands[0], operands[1], operands[2]));
6615 (define_insn "*ashrdi3_internal1"
6616 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
6617 (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
6618 (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
6620 "srad%I2 %0,%1,%H2")
6622 (define_insn "*ashrdi3_internal2"
6623 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
6624 (compare:CC (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6625 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri"))
6627 (clobber (match_scratch:DI 3 "=r,r"))]
6632 [(set_attr "type" "delayed_compare")
6633 (set_attr "length" "4,8")])
6636 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
6637 (compare:CC (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
6638 (match_operand:SI 2 "reg_or_cint_operand" ""))
6640 (clobber (match_scratch:DI 3 ""))]
6641 "TARGET_POWERPC64 && reload_completed"
6643 (ashiftrt:DI (match_dup 1) (match_dup 2)))
6645 (compare:CC (match_dup 3)
6649 (define_insn "*ashrdi3_internal3"
6650 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
6651 (compare:CC (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
6652 (match_operand:SI 2 "reg_or_cint_operand" "ri,ri"))
6654 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6655 (ashiftrt:DI (match_dup 1) (match_dup 2)))]
6660 [(set_attr "type" "delayed_compare")
6661 (set_attr "length" "4,8")])
6664 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
6665 (compare:CC (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
6666 (match_operand:SI 2 "reg_or_cint_operand" ""))
6668 (set (match_operand:DI 0 "gpc_reg_operand" "")
6669 (ashiftrt:DI (match_dup 1) (match_dup 2)))]
6670 "TARGET_POWERPC64 && reload_completed"
6672 (ashiftrt:DI (match_dup 1) (match_dup 2)))
6674 (compare:CC (match_dup 0)
6678 (define_insn "anddi3"
6679 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,r,r,r")
6680 (and:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r,r,r,r")
6681 (match_operand:DI 2 "and64_2_operand" "?r,S,T,K,J,t")))
6682 (clobber (match_scratch:CC 3 "=X,X,X,x,x,X"))]
6686 rldic%B2 %0,%1,0,%S2
6687 rlwinm %0,%1,0,%m2,%M2
6691 [(set_attr "type" "*,*,*,compare,compare,*")
6692 (set_attr "length" "4,4,4,4,4,8")])
6695 [(set (match_operand:DI 0 "gpc_reg_operand" "")
6696 (and:DI (match_operand:DI 1 "gpc_reg_operand" "")
6697 (match_operand:DI 2 "mask64_2_operand" "")))
6698 (clobber (match_scratch:CC 3 ""))]
6700 && (fixed_regs[CR0_REGNO] || !logical_operand (operands[2], DImode))
6701 && !mask_operand (operands[2], DImode)
6702 && !mask64_operand (operands[2], DImode)"
6704 (and:DI (rotate:DI (match_dup 1)
6708 (and:DI (rotate:DI (match_dup 0)
6712 build_mask64_2_operands (operands[2], &operands[4]);
6715 (define_insn "*anddi3_internal2"
6716 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,x,x,?y,?y,?y,??y,??y,?y")
6717 (compare:CC (and:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r,r,r,r,r")
6718 (match_operand:DI 2 "and64_2_operand" "r,S,T,K,J,t,r,S,T,K,J,t"))
6720 (clobber (match_scratch:DI 3 "=r,r,r,r,r,r,r,r,r,r,r,r"))
6721 (clobber (match_scratch:CC 4 "=X,X,X,X,X,X,X,X,X,x,x,X"))]
6725 rldic%B2. %3,%1,0,%S2
6726 rlwinm. %3,%1,0,%m2,%M2
6736 [(set_attr "type" "compare,delayed_compare,delayed_compare,compare,compare,delayed_compare,delayed_compare,compare,compare,compare,compare,compare")
6737 (set_attr "length" "4,4,4,4,4,8,8,8,8,8,8,12")])
6740 [(set (match_operand:CC 0 "cc_reg_operand" "")
6741 (compare:CC (and:DI (match_operand:DI 1 "gpc_reg_operand" "")
6742 (match_operand:DI 2 "mask64_2_operand" ""))
6744 (clobber (match_scratch:DI 3 ""))
6745 (clobber (match_scratch:CC 4 ""))]
6746 "TARGET_64BIT && reload_completed
6747 && (fixed_regs[CR0_REGNO] || !logical_operand (operands[2], DImode))
6748 && !mask_operand (operands[2], DImode)
6749 && !mask64_operand (operands[2], DImode)"
6751 (and:DI (rotate:DI (match_dup 1)
6754 (parallel [(set (match_dup 0)
6755 (compare:CC (and:DI (rotate:DI (match_dup 3)
6759 (clobber (match_dup 3))])]
6762 build_mask64_2_operands (operands[2], &operands[5]);
6765 (define_insn "*anddi3_internal3"
6766 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,x,x,x,?y,?y,?y,??y,??y,?y")
6767 (compare:CC (and:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r,r,r,r,r")
6768 (match_operand:DI 2 "and64_2_operand" "r,S,T,K,J,t,r,S,T,K,J,t"))
6770 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,r,r,r,r,r,r,r,r,r")
6771 (and:DI (match_dup 1) (match_dup 2)))
6772 (clobber (match_scratch:CC 4 "=X,X,X,X,X,X,X,X,X,x,x,X"))]
6776 rldic%B2. %0,%1,0,%S2
6777 rlwinm. %0,%1,0,%m2,%M2
6787 [(set_attr "type" "compare,delayed_compare,delayed_compare,compare,compare,delayed_compare,delayed_compare,compare,compare,compare,compare,compare")
6788 (set_attr "length" "4,4,4,4,4,8,8,8,8,8,8,12")])
6791 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
6792 (compare:CC (and:DI (match_operand:DI 1 "gpc_reg_operand" "")
6793 (match_operand:DI 2 "and64_2_operand" ""))
6795 (set (match_operand:DI 0 "gpc_reg_operand" "")
6796 (and:DI (match_dup 1) (match_dup 2)))
6797 (clobber (match_scratch:CC 4 ""))]
6798 "TARGET_64BIT && reload_completed"
6799 [(parallel [(set (match_dup 0)
6800 (and:DI (match_dup 1) (match_dup 2)))
6801 (clobber (match_dup 4))])
6803 (compare:CC (match_dup 0)
6808 [(set (match_operand:CC 3 "cc_reg_operand" "")
6809 (compare:CC (and:DI (match_operand:DI 1 "gpc_reg_operand" "")
6810 (match_operand:DI 2 "mask64_2_operand" ""))
6812 (set (match_operand:DI 0 "gpc_reg_operand" "")
6813 (and:DI (match_dup 1) (match_dup 2)))
6814 (clobber (match_scratch:CC 4 ""))]
6815 "TARGET_64BIT && reload_completed
6816 && (fixed_regs[CR0_REGNO] || !logical_operand (operands[2], DImode))
6817 && !mask_operand (operands[2], DImode)
6818 && !mask64_operand (operands[2], DImode)"
6820 (and:DI (rotate:DI (match_dup 1)
6823 (parallel [(set (match_dup 3)
6824 (compare:CC (and:DI (rotate:DI (match_dup 0)
6829 (and:DI (rotate:DI (match_dup 0)
6834 build_mask64_2_operands (operands[2], &operands[5]);
6837 (define_expand "iordi3"
6838 [(set (match_operand:DI 0 "gpc_reg_operand" "")
6839 (ior:DI (match_operand:DI 1 "gpc_reg_operand" "")
6840 (match_operand:DI 2 "reg_or_logical_cint_operand" "")))]
6844 if (non_logical_cint_operand (operands[2], DImode))
6846 HOST_WIDE_INT value;
6847 rtx tmp = ((no_new_pseudos || rtx_equal_p (operands[0], operands[1]))
6848 ? operands[0] : gen_reg_rtx (DImode));
6850 if (GET_CODE (operands[2]) == CONST_INT)
6852 value = INTVAL (operands[2]);
6853 emit_insn (gen_iordi3 (tmp, operands[1],
6854 GEN_INT (value & (~ (HOST_WIDE_INT) 0xffff))));
6858 value = CONST_DOUBLE_LOW (operands[2]);
6859 emit_insn (gen_iordi3 (tmp, operands[1],
6860 immed_double_const (value
6861 & (~ (HOST_WIDE_INT) 0xffff),
6865 emit_insn (gen_iordi3 (operands[0], tmp, GEN_INT (value & 0xffff)));
6870 (define_expand "xordi3"
6871 [(set (match_operand:DI 0 "gpc_reg_operand" "")
6872 (xor:DI (match_operand:DI 1 "gpc_reg_operand" "")
6873 (match_operand:DI 2 "reg_or_logical_cint_operand" "")))]
6877 if (non_logical_cint_operand (operands[2], DImode))
6879 HOST_WIDE_INT value;
6880 rtx tmp = ((no_new_pseudos || rtx_equal_p (operands[0], operands[1]))
6881 ? operands[0] : gen_reg_rtx (DImode));
6883 if (GET_CODE (operands[2]) == CONST_INT)
6885 value = INTVAL (operands[2]);
6886 emit_insn (gen_xordi3 (tmp, operands[1],
6887 GEN_INT (value & (~ (HOST_WIDE_INT) 0xffff))));
6891 value = CONST_DOUBLE_LOW (operands[2]);
6892 emit_insn (gen_xordi3 (tmp, operands[1],
6893 immed_double_const (value
6894 & (~ (HOST_WIDE_INT) 0xffff),
6898 emit_insn (gen_xordi3 (operands[0], tmp, GEN_INT (value & 0xffff)));
6903 (define_insn "*booldi3_internal1"
6904 [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r")
6905 (match_operator:DI 3 "boolean_or_operator"
6906 [(match_operand:DI 1 "gpc_reg_operand" "%r,r,r")
6907 (match_operand:DI 2 "logical_operand" "r,K,JF")]))]
6914 (define_insn "*booldi3_internal2"
6915 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
6916 (compare:CC (match_operator:DI 4 "boolean_or_operator"
6917 [(match_operand:DI 1 "gpc_reg_operand" "%r,r")
6918 (match_operand:DI 2 "gpc_reg_operand" "r,r")])
6920 (clobber (match_scratch:DI 3 "=r,r"))]
6925 [(set_attr "type" "compare")
6926 (set_attr "length" "4,8")])
6929 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
6930 (compare:CC (match_operator:DI 4 "boolean_operator"
6931 [(match_operand:DI 1 "gpc_reg_operand" "")
6932 (match_operand:DI 2 "gpc_reg_operand" "")])
6934 (clobber (match_scratch:DI 3 ""))]
6935 "TARGET_POWERPC64 && reload_completed"
6936 [(set (match_dup 3) (match_dup 4))
6938 (compare:CC (match_dup 3)
6942 (define_insn "*booldi3_internal3"
6943 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
6944 (compare:CC (match_operator:DI 4 "boolean_operator"
6945 [(match_operand:DI 1 "gpc_reg_operand" "%r,r")
6946 (match_operand:DI 2 "gpc_reg_operand" "r,r")])
6948 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
6954 [(set_attr "type" "compare")
6955 (set_attr "length" "4,8")])
6958 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
6959 (compare:CC (match_operator:DI 4 "boolean_operator"
6960 [(match_operand:DI 1 "gpc_reg_operand" "")
6961 (match_operand:DI 2 "gpc_reg_operand" "")])
6963 (set (match_operand:DI 0 "gpc_reg_operand" "")
6965 "TARGET_POWERPC64 && reload_completed"
6966 [(set (match_dup 0) (match_dup 4))
6968 (compare:CC (match_dup 0)
6972 ;; Split a logical operation that we can't do in one insn into two insns,
6973 ;; each of which does one 16-bit part. This is used by combine.
6976 [(set (match_operand:DI 0 "gpc_reg_operand" "")
6977 (match_operator:DI 3 "boolean_or_operator"
6978 [(match_operand:DI 1 "gpc_reg_operand" "")
6979 (match_operand:DI 2 "non_logical_cint_operand" "")]))]
6981 [(set (match_dup 0) (match_dup 4))
6982 (set (match_dup 0) (match_dup 5))]
6987 if (GET_CODE (operands[2]) == CONST_DOUBLE)
6989 HOST_WIDE_INT value = CONST_DOUBLE_LOW (operands[2]);
6990 i3 = immed_double_const (value & (~ (HOST_WIDE_INT) 0xffff),
6992 i4 = GEN_INT (value & 0xffff);
6996 i3 = GEN_INT (INTVAL (operands[2])
6997 & (~ (HOST_WIDE_INT) 0xffff));
6998 i4 = GEN_INT (INTVAL (operands[2]) & 0xffff);
7000 operands[4] = gen_rtx_fmt_ee (GET_CODE (operands[3]), DImode,
7002 operands[5] = gen_rtx_fmt_ee (GET_CODE (operands[3]), DImode,
7006 (define_insn "*boolcdi3_internal1"
7007 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
7008 (match_operator:DI 3 "boolean_operator"
7009 [(not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
7010 (match_operand:DI 2 "gpc_reg_operand" "r")]))]
7014 (define_insn "*boolcdi3_internal2"
7015 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
7016 (compare:CC (match_operator:DI 4 "boolean_operator"
7017 [(not:DI (match_operand:DI 1 "gpc_reg_operand" "r,r"))
7018 (match_operand:DI 2 "gpc_reg_operand" "r,r")])
7020 (clobber (match_scratch:DI 3 "=r,r"))]
7025 [(set_attr "type" "compare")
7026 (set_attr "length" "4,8")])
7029 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
7030 (compare:CC (match_operator:DI 4 "boolean_operator"
7031 [(not:DI (match_operand:DI 1 "gpc_reg_operand" ""))
7032 (match_operand:DI 2 "gpc_reg_operand" "")])
7034 (clobber (match_scratch:DI 3 ""))]
7035 "TARGET_POWERPC64 && reload_completed"
7036 [(set (match_dup 3) (match_dup 4))
7038 (compare:CC (match_dup 3)
7042 (define_insn "*boolcdi3_internal3"
7043 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
7044 (compare:CC (match_operator:DI 4 "boolean_operator"
7045 [(not:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r"))
7046 (match_operand:DI 2 "gpc_reg_operand" "r,r")])
7048 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
7054 [(set_attr "type" "compare")
7055 (set_attr "length" "4,8")])
7058 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
7059 (compare:CC (match_operator:DI 4 "boolean_operator"
7060 [(not:DI (match_operand:DI 1 "gpc_reg_operand" ""))
7061 (match_operand:DI 2 "gpc_reg_operand" "")])
7063 (set (match_operand:DI 0 "gpc_reg_operand" "")
7065 "TARGET_POWERPC64 && reload_completed"
7066 [(set (match_dup 0) (match_dup 4))
7068 (compare:CC (match_dup 0)
7072 (define_insn "*boolccdi3_internal1"
7073 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
7074 (match_operator:DI 3 "boolean_operator"
7075 [(not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
7076 (not:DI (match_operand:DI 2 "gpc_reg_operand" "r"))]))]
7080 (define_insn "*boolccdi3_internal2"
7081 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
7082 (compare:CC (match_operator:DI 4 "boolean_operator"
7083 [(not:DI (match_operand:DI 1 "gpc_reg_operand" "r,r"))
7084 (not:DI (match_operand:DI 2 "gpc_reg_operand" "r,r"))])
7086 (clobber (match_scratch:DI 3 "=r,r"))]
7091 [(set_attr "type" "compare")
7092 (set_attr "length" "4,8")])
7095 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
7096 (compare:CC (match_operator:DI 4 "boolean_operator"
7097 [(not:DI (match_operand:DI 1 "gpc_reg_operand" ""))
7098 (not:DI (match_operand:DI 2 "gpc_reg_operand" ""))])
7100 (clobber (match_scratch:DI 3 ""))]
7101 "TARGET_POWERPC64 && reload_completed"
7102 [(set (match_dup 3) (match_dup 4))
7104 (compare:CC (match_dup 3)
7108 (define_insn "*boolccdi3_internal3"
7109 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
7110 (compare:CC (match_operator:DI 4 "boolean_operator"
7111 [(not:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r"))
7112 (not:DI (match_operand:DI 2 "gpc_reg_operand" "r,r"))])
7114 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
7120 [(set_attr "type" "compare")
7121 (set_attr "length" "4,8")])
7124 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
7125 (compare:CC (match_operator:DI 4 "boolean_operator"
7126 [(not:DI (match_operand:DI 1 "gpc_reg_operand" ""))
7127 (not:DI (match_operand:DI 2 "gpc_reg_operand" ""))])
7129 (set (match_operand:DI 0 "gpc_reg_operand" "")
7131 "TARGET_POWERPC64 && reload_completed"
7132 [(set (match_dup 0) (match_dup 4))
7134 (compare:CC (match_dup 0)
7138 ;; Now define ways of moving data around.
7140 ;; Set up a register with a value from the GOT table
7142 (define_expand "movsi_got"
7143 [(set (match_operand:SI 0 "gpc_reg_operand" "")
7144 (unspec:SI [(match_operand:SI 1 "got_operand" "")
7145 (match_dup 2)] UNSPEC_MOVSI_GOT))]
7146 "DEFAULT_ABI == ABI_V4 && flag_pic == 1"
7149 if (GET_CODE (operands[1]) == CONST)
7151 rtx offset = const0_rtx;
7152 HOST_WIDE_INT value;
7154 operands[1] = eliminate_constant_term (XEXP (operands[1], 0), &offset);
7155 value = INTVAL (offset);
7158 rtx tmp = (no_new_pseudos ? operands[0] : gen_reg_rtx (Pmode));
7159 emit_insn (gen_movsi_got (tmp, operands[1]));
7160 emit_insn (gen_addsi3 (operands[0], tmp, offset));
7165 operands[2] = rs6000_got_register (operands[1]);
7168 (define_insn "*movsi_got_internal"
7169 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
7170 (unspec:SI [(match_operand:SI 1 "got_no_const_operand" "")
7171 (match_operand:SI 2 "gpc_reg_operand" "b")]
7173 "DEFAULT_ABI == ABI_V4 && flag_pic == 1"
7174 "{l|lwz} %0,%a1@got(%2)"
7175 [(set_attr "type" "load")])
7177 ;; Used by sched, shorten_branches and final when the GOT pseudo reg
7178 ;; didn't get allocated to a hard register.
7180 [(set (match_operand:SI 0 "gpc_reg_operand" "")
7181 (unspec:SI [(match_operand:SI 1 "got_no_const_operand" "")
7182 (match_operand:SI 2 "memory_operand" "")]
7184 "DEFAULT_ABI == ABI_V4
7186 && (reload_in_progress || reload_completed)"
7187 [(set (match_dup 0) (match_dup 2))
7188 (set (match_dup 0) (unspec:SI [(match_dup 1)(match_dup 0)]
7192 ;; For SI, we special-case integers that can't be loaded in one insn. We
7193 ;; do the load 16-bits at a time. We could do this by loading from memory,
7194 ;; and this is even supposed to be faster, but it is simpler not to get
7195 ;; integers in the TOC.
7196 (define_insn "movsi_low"
7197 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
7198 (mem:SI (lo_sum:SI (match_operand:SI 1 "gpc_reg_operand" "b")
7199 (match_operand 2 "" ""))))]
7200 "TARGET_MACHO && ! TARGET_64BIT"
7201 "{l|lwz} %0,lo16(%2)(%1)"
7202 [(set_attr "type" "load")
7203 (set_attr "length" "4")])
7205 (define_insn "*movsi_internal1"
7206 [(set (match_operand:SI 0 "rs6000_nonimmediate_operand" "=r,r,r,m,r,r,r,r,r,*q,*c*l,*h,*h")
7207 (match_operand:SI 1 "input_operand" "r,U,m,r,I,L,n,R,*h,r,r,r,0"))]
7208 "gpc_reg_operand (operands[0], SImode)
7209 || gpc_reg_operand (operands[1], SImode)"
7213 {l%U1%X1|lwz%U1%X1} %0,%1
7214 {st%U0%X0|stw%U0%X0} %1,%0
7224 [(set_attr "type" "*,*,load,store,*,*,*,*,mfjmpr,*,mtjmpr,*,*")
7225 (set_attr "length" "4,4,4,4,4,4,8,4,4,4,4,4,4")])
7227 ;; Split a load of a large constant into the appropriate two-insn
7231 [(set (match_operand:SI 0 "gpc_reg_operand" "")
7232 (match_operand:SI 1 "const_int_operand" ""))]
7233 "(unsigned HOST_WIDE_INT) (INTVAL (operands[1]) + 0x8000) >= 0x10000
7234 && (INTVAL (operands[1]) & 0xffff) != 0"
7238 (ior:SI (match_dup 0)
7241 { rtx tem = rs6000_emit_set_const (operands[0], SImode, operands[1], 2);
7243 if (tem == operands[0])
7249 (define_insn "*mov<mode>_internal2"
7250 [(set (match_operand:CC 2 "cc_reg_operand" "=y,x,?y")
7251 (compare:CC (match_operand:P 1 "gpc_reg_operand" "0,r,r")
7253 (set (match_operand:P 0 "gpc_reg_operand" "=r,r,r") (match_dup 1))]
7256 {cmpi|cmp<wd>i} %2,%0,0
7259 [(set_attr "type" "cmp,compare,cmp")
7260 (set_attr "length" "4,4,8")])
7263 [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
7264 (compare:CC (match_operand:P 1 "gpc_reg_operand" "")
7266 (set (match_operand:P 0 "gpc_reg_operand" "") (match_dup 1))]
7268 [(set (match_dup 0) (match_dup 1))
7270 (compare:CC (match_dup 0)
7274 (define_insn "*movhi_internal"
7275 [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,m,r,r,*q,*c*l,*h")
7276 (match_operand:HI 1 "input_operand" "r,m,r,i,*h,r,r,0"))]
7277 "gpc_reg_operand (operands[0], HImode)
7278 || gpc_reg_operand (operands[1], HImode)"
7288 [(set_attr "type" "*,load,store,*,mfjmpr,*,mtjmpr,*")])
7290 (define_expand "mov<mode>"
7291 [(set (match_operand:INT 0 "general_operand" "")
7292 (match_operand:INT 1 "any_operand" ""))]
7294 "{ rs6000_emit_move (operands[0], operands[1], <MODE>mode); DONE; }")
7296 (define_insn "*movqi_internal"
7297 [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,m,r,r,*q,*c*l,*h")
7298 (match_operand:QI 1 "input_operand" "r,m,r,i,*h,r,r,0"))]
7299 "gpc_reg_operand (operands[0], QImode)
7300 || gpc_reg_operand (operands[1], QImode)"
7310 [(set_attr "type" "*,load,store,*,mfjmpr,*,mtjmpr,*")])
7312 ;; Here is how to move condition codes around. When we store CC data in
7313 ;; an integer register or memory, we store just the high-order 4 bits.
7314 ;; This lets us not shift in the most common case of CR0.
7315 (define_expand "movcc"
7316 [(set (match_operand:CC 0 "nonimmediate_operand" "")
7317 (match_operand:CC 1 "nonimmediate_operand" ""))]
7321 (define_insn "*movcc_internal1"
7322 [(set (match_operand:CC 0 "nonimmediate_operand" "=y,x,?y,r,r,r,r,q,cl,r,m")
7323 (match_operand:CC 1 "nonimmediate_operand" "y,r,r,x,y,r,h,r,r,m,r"))]
7324 "register_operand (operands[0], CCmode)
7325 || register_operand (operands[1], CCmode)"
7329 {rlinm|rlwinm} %1,%1,%F0,0xffffffff\;mtcrf %R0,%1\;{rlinm|rlwinm} %1,%1,%f0,0xffffffff
7331 mfcr %0%Q1\;{rlinm|rlwinm} %0,%0,%f1,0xf0000000
7336 {l%U1%X1|lwz%U1%X1} %0,%1
7337 {st%U0%U1|stw%U0%U1} %1,%0"
7339 (cond [(eq_attr "alternative" "0")
7340 (const_string "cr_logical")
7341 (eq_attr "alternative" "1,2")
7342 (const_string "mtcr")
7343 (eq_attr "alternative" "5,7")
7344 (const_string "integer")
7345 (eq_attr "alternative" "6")
7346 (const_string "mfjmpr")
7347 (eq_attr "alternative" "8")
7348 (const_string "mtjmpr")
7349 (eq_attr "alternative" "9")
7350 (const_string "load")
7351 (eq_attr "alternative" "10")
7352 (const_string "store")
7353 (ne (symbol_ref "TARGET_MFCRF") (const_int 0))
7354 (const_string "mfcrf")
7356 (const_string "mfcr")))
7357 (set_attr "length" "4,4,12,4,8,4,4,4,4,4,4")])
7359 ;; For floating-point, we normally deal with the floating-point registers
7360 ;; unless -msoft-float is used. The sole exception is that parameter passing
7361 ;; can produce floating-point values in fixed-point registers. Unless the
7362 ;; value is a simple constant or already in memory, we deal with this by
7363 ;; allocating memory and copying the value explicitly via that memory location.
7364 (define_expand "movsf"
7365 [(set (match_operand:SF 0 "nonimmediate_operand" "")
7366 (match_operand:SF 1 "any_operand" ""))]
7368 "{ rs6000_emit_move (operands[0], operands[1], SFmode); DONE; }")
7371 [(set (match_operand:SF 0 "gpc_reg_operand" "")
7372 (match_operand:SF 1 "const_double_operand" ""))]
7374 && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
7375 || (GET_CODE (operands[0]) == SUBREG
7376 && GET_CODE (SUBREG_REG (operands[0])) == REG
7377 && REGNO (SUBREG_REG (operands[0])) <= 31))"
7378 [(set (match_dup 2) (match_dup 3))]
7384 REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
7385 REAL_VALUE_TO_TARGET_SINGLE (rv, l);
7387 if (! TARGET_POWERPC64)
7388 operands[2] = operand_subword (operands[0], 0, 0, SFmode);
7390 operands[2] = gen_lowpart (SImode, operands[0]);
7392 operands[3] = gen_int_mode (l, SImode);
7395 (define_insn "*movsf_hardfloat"
7396 [(set (match_operand:SF 0 "nonimmediate_operand" "=!r,!r,m,f,f,m,!cl,!q,!r,!h,!r,!r")
7397 (match_operand:SF 1 "input_operand" "r,m,r,f,m,f,r,r,h,0,G,Fn"))]
7398 "(gpc_reg_operand (operands[0], SFmode)
7399 || gpc_reg_operand (operands[1], SFmode))
7400 && (TARGET_HARD_FLOAT && TARGET_FPRS)"
7403 {l%U1%X1|lwz%U1%X1} %0,%1
7404 {st%U0%X0|stw%U0%X0} %1,%0
7414 [(set_attr "type" "*,load,store,fp,fpload,fpstore,*,mtjmpr,*,*,*,*")
7415 (set_attr "length" "4,4,4,4,4,4,4,4,4,4,4,8")])
7417 (define_insn "*movsf_softfloat"
7418 [(set (match_operand:SF 0 "nonimmediate_operand" "=r,cl,q,r,r,m,r,r,r,r,r,*h")
7419 (match_operand:SF 1 "input_operand" "r,r,r,h,m,r,I,L,R,G,Fn,0"))]
7420 "(gpc_reg_operand (operands[0], SFmode)
7421 || gpc_reg_operand (operands[1], SFmode))
7422 && (TARGET_SOFT_FLOAT || !TARGET_FPRS)"
7428 {l%U1%X1|lwz%U1%X1} %0,%1
7429 {st%U0%X0|stw%U0%X0} %1,%0
7436 [(set_attr "type" "*,mtjmpr,*,*,load,store,*,*,*,*,*,*")
7437 (set_attr "length" "4,4,4,4,4,4,4,4,4,4,8,4")])
7440 (define_expand "movdf"
7441 [(set (match_operand:DF 0 "nonimmediate_operand" "")
7442 (match_operand:DF 1 "any_operand" ""))]
7444 "{ rs6000_emit_move (operands[0], operands[1], DFmode); DONE; }")
7447 [(set (match_operand:DF 0 "gpc_reg_operand" "")
7448 (match_operand:DF 1 "const_int_operand" ""))]
7449 "! TARGET_POWERPC64 && reload_completed
7450 && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
7451 || (GET_CODE (operands[0]) == SUBREG
7452 && GET_CODE (SUBREG_REG (operands[0])) == REG
7453 && REGNO (SUBREG_REG (operands[0])) <= 31))"
7454 [(set (match_dup 2) (match_dup 4))
7455 (set (match_dup 3) (match_dup 1))]
7458 int endian = (WORDS_BIG_ENDIAN == 0);
7459 HOST_WIDE_INT value = INTVAL (operands[1]);
7461 operands[2] = operand_subword (operands[0], endian, 0, DFmode);
7462 operands[3] = operand_subword (operands[0], 1 - endian, 0, DFmode);
7463 #if HOST_BITS_PER_WIDE_INT == 32
7464 operands[4] = (value & 0x80000000) ? constm1_rtx : const0_rtx;
7466 operands[4] = GEN_INT (value >> 32);
7467 operands[1] = GEN_INT (((value & 0xffffffff) ^ 0x80000000) - 0x80000000);
7472 [(set (match_operand:DF 0 "gpc_reg_operand" "")
7473 (match_operand:DF 1 "const_double_operand" ""))]
7474 "! TARGET_POWERPC64 && reload_completed
7475 && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
7476 || (GET_CODE (operands[0]) == SUBREG
7477 && GET_CODE (SUBREG_REG (operands[0])) == REG
7478 && REGNO (SUBREG_REG (operands[0])) <= 31))"
7479 [(set (match_dup 2) (match_dup 4))
7480 (set (match_dup 3) (match_dup 5))]
7483 int endian = (WORDS_BIG_ENDIAN == 0);
7487 REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
7488 REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
7490 operands[2] = operand_subword (operands[0], endian, 0, DFmode);
7491 operands[3] = operand_subword (operands[0], 1 - endian, 0, DFmode);
7492 operands[4] = gen_int_mode (l[endian], SImode);
7493 operands[5] = gen_int_mode (l[1 - endian], SImode);
7497 [(set (match_operand:DF 0 "gpc_reg_operand" "")
7498 (match_operand:DF 1 "easy_fp_constant" ""))]
7499 "TARGET_POWERPC64 && reload_completed
7500 && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
7501 || (GET_CODE (operands[0]) == SUBREG
7502 && GET_CODE (SUBREG_REG (operands[0])) == REG
7503 && REGNO (SUBREG_REG (operands[0])) <= 31))"
7504 [(set (match_dup 2) (match_dup 3))]
7507 int endian = (WORDS_BIG_ENDIAN == 0);
7510 #if HOST_BITS_PER_WIDE_INT >= 64
7514 REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
7515 REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
7517 operands[2] = gen_lowpart (DImode, operands[0]);
7518 /* HIGHPART is lower memory address when WORDS_BIG_ENDIAN. */
7519 #if HOST_BITS_PER_WIDE_INT >= 64
7520 val = ((HOST_WIDE_INT)(unsigned long)l[endian] << 32
7521 | ((HOST_WIDE_INT)(unsigned long)l[1 - endian]));
7523 operands[3] = gen_int_mode (val, DImode);
7525 operands[3] = immed_double_const (l[1 - endian], l[endian], DImode);
7529 ;; Don't have reload use general registers to load a constant. First,
7530 ;; it might not work if the output operand is the equivalent of
7531 ;; a non-offsettable memref, but also it is less efficient than loading
7532 ;; the constant into an FP register, since it will probably be used there.
7533 ;; The "??" is a kludge until we can figure out a more reasonable way
7534 ;; of handling these non-offsettable values.
7535 (define_insn "*movdf_hardfloat32"
7536 [(set (match_operand:DF 0 "nonimmediate_operand" "=!r,??r,m,f,f,m,!r,!r,!r")
7537 (match_operand:DF 1 "input_operand" "r,m,r,f,m,f,G,H,F"))]
7538 "! TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS
7539 && (gpc_reg_operand (operands[0], DFmode)
7540 || gpc_reg_operand (operands[1], DFmode))"
7543 switch (which_alternative)
7548 /* We normally copy the low-numbered register first. However, if
7549 the first register operand 0 is the same as the second register
7550 of operand 1, we must copy in the opposite order. */
7551 if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
7552 return \"mr %L0,%L1\;mr %0,%1\";
7554 return \"mr %0,%1\;mr %L0,%L1\";
7556 if (GET_CODE (operands[1]) == MEM
7557 && (rs6000_legitimate_offset_address_p (DFmode, XEXP (operands[1], 0),
7558 reload_completed || reload_in_progress)
7559 || rs6000_legitimate_small_data_p (DFmode, XEXP (operands[1], 0))
7560 || GET_CODE (XEXP (operands[1], 0)) == REG
7561 || GET_CODE (XEXP (operands[1], 0)) == LO_SUM
7562 || GET_CODE (XEXP (operands[1], 0)) == PRE_INC
7563 || GET_CODE (XEXP (operands[1], 0)) == PRE_DEC))
7565 /* If the low-address word is used in the address, we must load
7566 it last. Otherwise, load it first. Note that we cannot have
7567 auto-increment in that case since the address register is
7568 known to be dead. */
7569 if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
7571 return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
7573 return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\";
7579 addreg = find_addr_reg (XEXP (operands[1], 0));
7580 if (refers_to_regno_p (REGNO (operands[0]),
7581 REGNO (operands[0]) + 1,
7584 output_asm_insn (\"{cal|la} %0,4(%0)\", &addreg);
7585 output_asm_insn (\"{lx|lwzx} %L0,%1\", operands);
7586 output_asm_insn (\"{cal|la} %0,-4(%0)\", &addreg);
7587 return \"{lx|lwzx} %0,%1\";
7591 output_asm_insn (\"{lx|lwzx} %0,%1\", operands);
7592 output_asm_insn (\"{cal|la} %0,4(%0)\", &addreg);
7593 output_asm_insn (\"{lx|lwzx} %L0,%1\", operands);
7594 output_asm_insn (\"{cal|la} %0,-4(%0)\", &addreg);
7599 if (GET_CODE (operands[0]) == MEM
7600 && (rs6000_legitimate_offset_address_p (DFmode, XEXP (operands[0], 0),
7601 reload_completed || reload_in_progress)
7602 || rs6000_legitimate_small_data_p (DFmode, XEXP (operands[0], 0))
7603 || GET_CODE (XEXP (operands[0], 0)) == REG
7604 || GET_CODE (XEXP (operands[0], 0)) == LO_SUM
7605 || GET_CODE (XEXP (operands[0], 0)) == PRE_INC
7606 || GET_CODE (XEXP (operands[0], 0)) == PRE_DEC))
7607 return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\";
7612 addreg = find_addr_reg (XEXP (operands[0], 0));
7613 output_asm_insn (\"{stx|stwx} %1,%0\", operands);
7614 output_asm_insn (\"{cal|la} %0,4(%0)\", &addreg);
7615 output_asm_insn (\"{stx|stwx} %L1,%0\", operands);
7616 output_asm_insn (\"{cal|la} %0,-4(%0)\", &addreg);
7620 return \"fmr %0,%1\";
7622 return \"lfd%U1%X1 %0,%1\";
7624 return \"stfd%U0%X0 %1,%0\";
7631 [(set_attr "type" "two,load,store,fp,fpload,fpstore,*,*,*")
7632 (set_attr "length" "8,16,16,4,4,4,8,12,16")])
7634 (define_insn "*movdf_softfloat32"
7635 [(set (match_operand:DF 0 "nonimmediate_operand" "=r,r,m,r,r,r")
7636 (match_operand:DF 1 "input_operand" "r,m,r,G,H,F"))]
7637 "! TARGET_POWERPC64 && (TARGET_SOFT_FLOAT || TARGET_E500_SINGLE)
7638 && (gpc_reg_operand (operands[0], DFmode)
7639 || gpc_reg_operand (operands[1], DFmode))"
7642 switch (which_alternative)
7647 /* We normally copy the low-numbered register first. However, if
7648 the first register operand 0 is the same as the second register of
7649 operand 1, we must copy in the opposite order. */
7650 if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
7651 return \"mr %L0,%L1\;mr %0,%1\";
7653 return \"mr %0,%1\;mr %L0,%L1\";
7655 /* If the low-address word is used in the address, we must load
7656 it last. Otherwise, load it first. Note that we cannot have
7657 auto-increment in that case since the address register is
7658 known to be dead. */
7659 if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
7661 return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
7663 return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\";
7665 return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\";
7672 [(set_attr "type" "two,load,store,*,*,*")
7673 (set_attr "length" "8,8,8,8,12,16")])
7675 ; ld/std require word-aligned displacements -> 'Y' constraint.
7676 ; List Y->r and r->Y before r->r for reload.
7677 (define_insn "*movdf_hardfloat64"
7678 [(set (match_operand:DF 0 "nonimmediate_operand" "=Y,r,!r,f,f,m,!cl,!r,!h,!r,!r,!r")
7679 (match_operand:DF 1 "input_operand" "r,Y,r,f,m,f,r,h,0,G,H,F"))]
7680 "TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS
7681 && (gpc_reg_operand (operands[0], DFmode)
7682 || gpc_reg_operand (operands[1], DFmode))"
7696 [(set_attr "type" "*,load,store,fp,fpload,fpstore,mtjmpr,*,*,*,*,*")
7697 (set_attr "length" "4,4,4,4,4,4,4,4,4,8,12,16")])
7699 (define_insn "*movdf_softfloat64"
7700 [(set (match_operand:DF 0 "nonimmediate_operand" "=r,Y,r,cl,r,r,r,r,*h")
7701 (match_operand:DF 1 "input_operand" "Y,r,r,r,h,G,H,F,0"))]
7702 "TARGET_POWERPC64 && (TARGET_SOFT_FLOAT || !TARGET_FPRS)
7703 && (gpc_reg_operand (operands[0], DFmode)
7704 || gpc_reg_operand (operands[1], DFmode))"
7715 [(set_attr "type" "load,store,*,*,*,*,*,*,*")
7716 (set_attr "length" "4,4,4,4,4,8,12,16,4")])
7718 (define_expand "movtf"
7719 [(set (match_operand:TF 0 "general_operand" "")
7720 (match_operand:TF 1 "any_operand" ""))]
7721 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
7722 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
7723 "{ rs6000_emit_move (operands[0], operands[1], TFmode); DONE; }")
7725 ; It's important to list the o->f and f->o moves before f->f because
7726 ; otherwise reload, given m->f, will try to pick f->f and reload it,
7727 ; which doesn't make progress. Likewise r->Y must be before r->r.
7728 (define_insn_and_split "*movtf_internal"
7729 [(set (match_operand:TF 0 "nonimmediate_operand" "=o,f,f,r,Y,r")
7730 (match_operand:TF 1 "input_operand" "f,o,f,YGHF,r,r"))]
7731 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
7732 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128
7733 && (gpc_reg_operand (operands[0], TFmode)
7734 || gpc_reg_operand (operands[1], TFmode))"
7736 "&& reload_completed"
7738 { rs6000_split_multireg_move (operands[0], operands[1]); DONE; }
7739 [(set_attr "length" "8,8,8,20,20,16")])
7741 (define_expand "extenddftf2"
7742 [(parallel [(set (match_operand:TF 0 "nonimmediate_operand" "")
7743 (float_extend:TF (match_operand:DF 1 "input_operand" "")))
7744 (use (match_dup 2))])]
7745 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
7746 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
7748 operands[2] = CONST0_RTX (DFmode);
7751 (define_insn_and_split "*extenddftf2_internal"
7752 [(set (match_operand:TF 0 "nonimmediate_operand" "=o,f,&f,r")
7753 (float_extend:TF (match_operand:DF 1 "input_operand" "fr,mf,mf,rmGHF")))
7754 (use (match_operand:DF 2 "zero_reg_mem_operand" "rf,m,f,n"))]
7755 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
7756 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
7758 "&& reload_completed"
7761 const int lo_word = FLOAT_WORDS_BIG_ENDIAN ? GET_MODE_SIZE (DFmode) : 0;
7762 const int hi_word = FLOAT_WORDS_BIG_ENDIAN ? 0 : GET_MODE_SIZE (DFmode);
7763 emit_move_insn (simplify_gen_subreg (DFmode, operands[0], TFmode, hi_word),
7765 emit_move_insn (simplify_gen_subreg (DFmode, operands[0], TFmode, lo_word),
7770 (define_expand "extendsftf2"
7771 [(set (match_operand:TF 0 "nonimmediate_operand" "")
7772 (float_extend:TF (match_operand:SF 1 "gpc_reg_operand" "")))]
7773 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
7774 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
7776 rtx tmp = gen_reg_rtx (DFmode);
7777 emit_insn (gen_extendsfdf2 (tmp, operands[1]));
7778 emit_insn (gen_extenddftf2 (operands[0], tmp));
7782 (define_expand "trunctfdf2"
7783 [(set (match_operand:DF 0 "gpc_reg_operand" "")
7784 (float_truncate:DF (match_operand:TF 1 "gpc_reg_operand" "")))]
7785 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
7786 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
7789 (define_insn_and_split "trunctfdf2_internal1"
7790 [(set (match_operand:DF 0 "gpc_reg_operand" "=f,?f")
7791 (float_truncate:DF (match_operand:TF 1 "gpc_reg_operand" "0,f")))]
7792 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN) && !TARGET_XL_COMPAT
7793 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
7797 "&& reload_completed && REGNO (operands[0]) == REGNO (operands[1])"
7800 emit_note (NOTE_INSN_DELETED);
7803 [(set_attr "type" "fp")])
7805 (define_insn "trunctfdf2_internal2"
7806 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
7807 (float_truncate:DF (match_operand:TF 1 "gpc_reg_operand" "f")))]
7808 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN) && TARGET_XL_COMPAT
7809 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
7811 [(set_attr "type" "fp")])
7813 (define_insn_and_split "trunctfsf2"
7814 [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
7815 (float_truncate:SF (match_operand:TF 1 "gpc_reg_operand" "f")))
7816 (clobber (match_scratch:DF 2 "=f"))]
7817 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
7818 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
7820 "&& reload_completed"
7822 (float_truncate:DF (match_dup 1)))
7824 (float_truncate:SF (match_dup 2)))]
7827 (define_expand "floatsitf2"
7828 [(set (match_operand:TF 0 "gpc_reg_operand" "=f")
7829 (float:TF (match_operand:SI 1 "gpc_reg_operand" "r")))]
7830 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
7831 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
7833 rtx tmp = gen_reg_rtx (DFmode);
7834 expand_float (tmp, operands[1], false);
7835 emit_insn (gen_extenddftf2 (operands[0], tmp));
7839 ; fadd, but rounding towards zero.
7840 ; This is probably not the optimal code sequence.
7841 (define_insn "fix_trunc_helper"
7842 [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
7843 (unspec:DF [(match_operand:TF 1 "gpc_reg_operand" "f")]
7844 UNSPEC_FIX_TRUNC_TF))
7845 (clobber (match_operand:DF 2 "gpc_reg_operand" "=&f"))]
7846 "TARGET_HARD_FLOAT && TARGET_FPRS"
7847 "mffs %2\n\tmtfsb1 31\n\tmtfsb0 30\n\tfadd %0,%1,%L1\n\tmtfsf 1,%2"
7848 [(set_attr "type" "fp")
7849 (set_attr "length" "20")])
7851 (define_expand "fix_trunctfsi2"
7852 [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
7853 (fix:SI (match_operand:TF 1 "gpc_reg_operand" "")))
7854 (clobber (match_dup 2))
7855 (clobber (match_dup 3))
7856 (clobber (match_dup 4))
7857 (clobber (match_dup 5))])]
7858 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
7859 && (TARGET_POWER2 || TARGET_POWERPC)
7860 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
7862 operands[2] = gen_reg_rtx (DFmode);
7863 operands[3] = gen_reg_rtx (DFmode);
7864 operands[4] = gen_reg_rtx (DImode);
7865 operands[5] = assign_stack_temp (DImode, GET_MODE_SIZE (DImode), 0);
7868 (define_insn_and_split "*fix_trunctfsi2_internal"
7869 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
7870 (fix:SI (match_operand:TF 1 "gpc_reg_operand" "f")))
7871 (clobber (match_operand:DF 2 "gpc_reg_operand" "=f"))
7872 (clobber (match_operand:DF 3 "gpc_reg_operand" "=&f"))
7873 (clobber (match_operand:DI 4 "gpc_reg_operand" "=f"))
7874 (clobber (match_operand:DI 5 "memory_operand" "=o"))]
7875 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
7876 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
7878 "&& (!no_new_pseudos || offsettable_nonstrict_memref_p (operands[5]))"
7882 emit_insn (gen_fix_trunc_helper (operands[2], operands[1], operands[3]));
7884 gcc_assert (MEM_P (operands[5]));
7885 lowword = adjust_address (operands[5], SImode, WORDS_BIG_ENDIAN ? 4 : 0);
7887 emit_insn (gen_fctiwz (operands[4], operands[2]));
7888 emit_move_insn (operands[5], operands[4]);
7889 emit_move_insn (operands[0], lowword);
7893 (define_insn "negtf2"
7894 [(set (match_operand:TF 0 "gpc_reg_operand" "=f")
7895 (neg:TF (match_operand:TF 1 "gpc_reg_operand" "f")))]
7896 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
7897 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
7900 if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
7901 return \"fneg %L0,%L1\;fneg %0,%1\";
7903 return \"fneg %0,%1\;fneg %L0,%L1\";
7905 [(set_attr "type" "fp")
7906 (set_attr "length" "8")])
7908 (define_expand "abstf2"
7909 [(set (match_operand:TF 0 "gpc_reg_operand" "=f")
7910 (abs:TF (match_operand:TF 1 "gpc_reg_operand" "f")))]
7911 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
7912 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
7915 rtx label = gen_label_rtx ();
7916 emit_insn (gen_abstf2_internal (operands[0], operands[1], label));
7921 (define_expand "abstf2_internal"
7922 [(set (match_operand:TF 0 "gpc_reg_operand" "=f")
7923 (match_operand:TF 1 "gpc_reg_operand" "f"))
7924 (set (match_dup 3) (match_dup 5))
7925 (set (match_dup 5) (abs:DF (match_dup 5)))
7926 (set (match_dup 4) (compare:CCFP (match_dup 3) (match_dup 5)))
7927 (set (pc) (if_then_else (eq (match_dup 4) (const_int 0))
7928 (label_ref (match_operand 2 "" ""))
7930 (set (match_dup 6) (neg:DF (match_dup 6)))]
7931 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
7932 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
7935 const int hi_word = FLOAT_WORDS_BIG_ENDIAN ? 0 : GET_MODE_SIZE (DFmode);
7936 const int lo_word = FLOAT_WORDS_BIG_ENDIAN ? GET_MODE_SIZE (DFmode) : 0;
7937 operands[3] = gen_reg_rtx (DFmode);
7938 operands[4] = gen_reg_rtx (CCFPmode);
7939 operands[5] = simplify_gen_subreg (DFmode, operands[0], TFmode, hi_word);
7940 operands[6] = simplify_gen_subreg (DFmode, operands[0], TFmode, lo_word);
7943 ;; Next come the multi-word integer load and store and the load and store
7946 ; List r->r after r->"o<>", otherwise reload will try to reload a
7947 ; non-offsettable address by using r->r which won't make progress.
7948 (define_insn "*movdi_internal32"
7949 [(set (match_operand:DI 0 "nonimmediate_operand" "=o<>,r,r,*f,*f,m,r")
7950 (match_operand:DI 1 "input_operand" "r,r,m,f,m,f,IJKnGHF"))]
7952 && (gpc_reg_operand (operands[0], DImode)
7953 || gpc_reg_operand (operands[1], DImode))"
7962 [(set_attr "type" "load,*,store,fp,fpload,fpstore,*")])
7965 [(set (match_operand:DI 0 "gpc_reg_operand" "")
7966 (match_operand:DI 1 "const_int_operand" ""))]
7967 "! TARGET_POWERPC64 && reload_completed"
7968 [(set (match_dup 2) (match_dup 4))
7969 (set (match_dup 3) (match_dup 1))]
7972 HOST_WIDE_INT value = INTVAL (operands[1]);
7973 operands[2] = operand_subword_force (operands[0], WORDS_BIG_ENDIAN == 0,
7975 operands[3] = operand_subword_force (operands[0], WORDS_BIG_ENDIAN != 0,
7977 #if HOST_BITS_PER_WIDE_INT == 32
7978 operands[4] = (value & 0x80000000) ? constm1_rtx : const0_rtx;
7980 operands[4] = GEN_INT (value >> 32);
7981 operands[1] = GEN_INT (((value & 0xffffffff) ^ 0x80000000) - 0x80000000);
7986 [(set (match_operand:DI 0 "nonimmediate_operand" "")
7987 (match_operand:DI 1 "input_operand" ""))]
7988 "reload_completed && !TARGET_POWERPC64
7989 && gpr_or_gpr_p (operands[0], operands[1])"
7991 { rs6000_split_multireg_move (operands[0], operands[1]); DONE; })
7993 (define_insn "*movdi_internal64"
7994 [(set (match_operand:DI 0 "nonimmediate_operand" "=r,r,m,r,r,r,r,*f,*f,m,r,*h,*h")
7995 (match_operand:DI 1 "input_operand" "r,m,r,I,L,nF,R,f,m,f,*h,r,0"))]
7997 && (gpc_reg_operand (operands[0], DImode)
7998 || gpc_reg_operand (operands[1], DImode))"
8013 [(set_attr "type" "*,load,store,*,*,*,*,fp,fpload,fpstore,mfjmpr,mtjmpr,*")
8014 (set_attr "length" "4,4,4,4,4,20,4,4,4,4,4,4,4")])
8016 ;; immediate value valid for a single instruction hiding in a const_double
8018 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
8019 (match_operand:DI 1 "const_double_operand" "F"))]
8020 "HOST_BITS_PER_WIDE_INT == 32 && TARGET_POWERPC64
8021 && GET_CODE (operands[1]) == CONST_DOUBLE
8022 && num_insns_constant (operands[1], DImode) == 1"
8025 return ((unsigned HOST_WIDE_INT)
8026 (CONST_DOUBLE_LOW (operands[1]) + 0x8000) < 0x10000)
8027 ? \"li %0,%1\" : \"lis %0,%v1\";
8030 ;; Generate all one-bits and clear left or right.
8031 ;; Use (and:DI (rotate:DI ...)) to avoid anddi3 unnecessary clobber.
8033 [(set (match_operand:DI 0 "gpc_reg_operand" "")
8034 (match_operand:DI 1 "mask64_operand" ""))]
8035 "TARGET_POWERPC64 && num_insns_constant (operands[1], DImode) > 1"
8036 [(set (match_dup 0) (const_int -1))
8038 (and:DI (rotate:DI (match_dup 0)
8043 ;; Split a load of a large constant into the appropriate five-instruction
8044 ;; sequence. Handle anything in a constant number of insns.
8045 ;; When non-easy constants can go in the TOC, this should use
8046 ;; easy_fp_constant predicate.
8048 [(set (match_operand:DI 0 "gpc_reg_operand" "")
8049 (match_operand:DI 1 "const_int_operand" ""))]
8050 "TARGET_POWERPC64 && num_insns_constant (operands[1], DImode) > 1"
8051 [(set (match_dup 0) (match_dup 2))
8052 (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 3)))]
8054 { rtx tem = rs6000_emit_set_const (operands[0], DImode, operands[1], 5);
8056 if (tem == operands[0])
8063 [(set (match_operand:DI 0 "gpc_reg_operand" "")
8064 (match_operand:DI 1 "const_double_operand" ""))]
8065 "TARGET_POWERPC64 && num_insns_constant (operands[1], DImode) > 1"
8066 [(set (match_dup 0) (match_dup 2))
8067 (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 3)))]
8069 { rtx tem = rs6000_emit_set_const (operands[0], DImode, operands[1], 5);
8071 if (tem == operands[0])
8077 ;; TImode is similar, except that we usually want to compute the address into
8078 ;; a register and use lsi/stsi (the exception is during reload). MQ is also
8079 ;; clobbered in stsi for POWER, so we need a SCRATCH for it.
8081 ;; We say that MQ is clobbered in the last alternative because the first
8082 ;; alternative would never get used otherwise since it would need a reload
8083 ;; while the 2nd alternative would not. We put memory cases first so they
8084 ;; are preferred. Otherwise, we'd try to reload the output instead of
8085 ;; giving the SCRATCH mq.
8087 (define_insn "*movti_power"
8088 [(set (match_operand:TI 0 "reg_or_mem_operand" "=Q,m,????r,????r,????r,r")
8089 (match_operand:TI 1 "input_operand" "r,r,r,Q,m,n"))
8090 (clobber (match_scratch:SI 2 "=q,q#X,X,X,X,X"))]
8091 "TARGET_POWER && ! TARGET_POWERPC64
8092 && (gpc_reg_operand (operands[0], TImode) || gpc_reg_operand (operands[1], TImode))"
8095 switch (which_alternative)
8102 return \"{stsi|stswi} %1,%P0,16\";
8107 /* If the address is not used in the output, we can use lsi. Otherwise,
8108 fall through to generating four loads. */
8110 && ! reg_overlap_mentioned_p (operands[0], operands[1]))
8111 return \"{lsi|lswi} %0,%P1,16\";
8112 /* ... fall through ... */
8118 [(set_attr "type" "store,store,*,load,load,*")])
8120 (define_insn "*movti_string"
8121 [(set (match_operand:TI 0 "reg_or_mem_operand" "=Q,o<>,????r,????r,????r,r")
8122 (match_operand:TI 1 "input_operand" "r,r,r,Q,m,n"))]
8123 "! TARGET_POWER && ! TARGET_POWERPC64
8124 && (gpc_reg_operand (operands[0], TImode) || gpc_reg_operand (operands[1], TImode))"
8127 switch (which_alternative)
8133 return \"{stsi|stswi} %1,%P0,16\";
8138 /* If the address is not used in the output, we can use lsi. Otherwise,
8139 fall through to generating four loads. */
8141 && ! reg_overlap_mentioned_p (operands[0], operands[1]))
8142 return \"{lsi|lswi} %0,%P1,16\";
8143 /* ... fall through ... */
8149 [(set_attr "type" "store,store,*,load,load,*")])
8151 (define_insn "*movti_ppc64"
8152 [(set (match_operand:TI 0 "nonimmediate_operand" "=r,o<>,r")
8153 (match_operand:TI 1 "input_operand" "r,r,m"))]
8154 "TARGET_POWERPC64 && (gpc_reg_operand (operands[0], TImode)
8155 || gpc_reg_operand (operands[1], TImode))"
8157 [(set_attr "type" "*,load,store")])
8160 [(set (match_operand:TI 0 "gpc_reg_operand" "")
8161 (match_operand:TI 1 "const_double_operand" ""))]
8163 [(set (match_dup 2) (match_dup 4))
8164 (set (match_dup 3) (match_dup 5))]
8167 operands[2] = operand_subword_force (operands[0], WORDS_BIG_ENDIAN == 0,
8169 operands[3] = operand_subword_force (operands[0], WORDS_BIG_ENDIAN != 0,
8171 if (GET_CODE (operands[1]) == CONST_DOUBLE)
8173 operands[4] = GEN_INT (CONST_DOUBLE_HIGH (operands[1]));
8174 operands[5] = GEN_INT (CONST_DOUBLE_LOW (operands[1]));
8176 else if (GET_CODE (operands[1]) == CONST_INT)
8178 operands[4] = GEN_INT (- (INTVAL (operands[1]) < 0));
8179 operands[5] = operands[1];
8186 [(set (match_operand:TI 0 "nonimmediate_operand" "")
8187 (match_operand:TI 1 "input_operand" ""))]
8189 && gpr_or_gpr_p (operands[0], operands[1])"
8191 { rs6000_split_multireg_move (operands[0], operands[1]); DONE; })
8193 (define_expand "load_multiple"
8194 [(match_par_dup 3 [(set (match_operand:SI 0 "" "")
8195 (match_operand:SI 1 "" ""))
8196 (use (match_operand:SI 2 "" ""))])]
8197 "TARGET_STRING && !TARGET_POWERPC64"
8205 /* Support only loading a constant number of fixed-point registers from
8206 memory and only bother with this if more than two; the machine
8207 doesn't support more than eight. */
8208 if (GET_CODE (operands[2]) != CONST_INT
8209 || INTVAL (operands[2]) <= 2
8210 || INTVAL (operands[2]) > 8
8211 || GET_CODE (operands[1]) != MEM
8212 || GET_CODE (operands[0]) != REG
8213 || REGNO (operands[0]) >= 32)
8216 count = INTVAL (operands[2]);
8217 regno = REGNO (operands[0]);
8219 operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count));
8220 op1 = replace_equiv_address (operands[1],
8221 force_reg (SImode, XEXP (operands[1], 0)));
8223 for (i = 0; i < count; i++)
8224 XVECEXP (operands[3], 0, i)
8225 = gen_rtx_SET (VOIDmode, gen_rtx_REG (SImode, regno + i),
8226 adjust_address_nv (op1, SImode, i * 4));
8229 (define_insn "*ldmsi8"
8230 [(match_parallel 0 "load_multiple_operation"
8231 [(set (match_operand:SI 2 "gpc_reg_operand" "")
8232 (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
8233 (set (match_operand:SI 3 "gpc_reg_operand" "")
8234 (mem:SI (plus:SI (match_dup 1) (const_int 4))))
8235 (set (match_operand:SI 4 "gpc_reg_operand" "")
8236 (mem:SI (plus:SI (match_dup 1) (const_int 8))))
8237 (set (match_operand:SI 5 "gpc_reg_operand" "")
8238 (mem:SI (plus:SI (match_dup 1) (const_int 12))))
8239 (set (match_operand:SI 6 "gpc_reg_operand" "")
8240 (mem:SI (plus:SI (match_dup 1) (const_int 16))))
8241 (set (match_operand:SI 7 "gpc_reg_operand" "")
8242 (mem:SI (plus:SI (match_dup 1) (const_int 20))))
8243 (set (match_operand:SI 8 "gpc_reg_operand" "")
8244 (mem:SI (plus:SI (match_dup 1) (const_int 24))))
8245 (set (match_operand:SI 9 "gpc_reg_operand" "")
8246 (mem:SI (plus:SI (match_dup 1) (const_int 28))))])]
8247 "TARGET_STRING && XVECLEN (operands[0], 0) == 8"
8249 { return rs6000_output_load_multiple (operands); }"
8250 [(set_attr "type" "load")
8251 (set_attr "length" "32")])
8253 (define_insn "*ldmsi7"
8254 [(match_parallel 0 "load_multiple_operation"
8255 [(set (match_operand:SI 2 "gpc_reg_operand" "")
8256 (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
8257 (set (match_operand:SI 3 "gpc_reg_operand" "")
8258 (mem:SI (plus:SI (match_dup 1) (const_int 4))))
8259 (set (match_operand:SI 4 "gpc_reg_operand" "")
8260 (mem:SI (plus:SI (match_dup 1) (const_int 8))))
8261 (set (match_operand:SI 5 "gpc_reg_operand" "")
8262 (mem:SI (plus:SI (match_dup 1) (const_int 12))))
8263 (set (match_operand:SI 6 "gpc_reg_operand" "")
8264 (mem:SI (plus:SI (match_dup 1) (const_int 16))))
8265 (set (match_operand:SI 7 "gpc_reg_operand" "")
8266 (mem:SI (plus:SI (match_dup 1) (const_int 20))))
8267 (set (match_operand:SI 8 "gpc_reg_operand" "")
8268 (mem:SI (plus:SI (match_dup 1) (const_int 24))))])]
8269 "TARGET_STRING && XVECLEN (operands[0], 0) == 7"
8271 { return rs6000_output_load_multiple (operands); }"
8272 [(set_attr "type" "load")
8273 (set_attr "length" "32")])
8275 (define_insn "*ldmsi6"
8276 [(match_parallel 0 "load_multiple_operation"
8277 [(set (match_operand:SI 2 "gpc_reg_operand" "")
8278 (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
8279 (set (match_operand:SI 3 "gpc_reg_operand" "")
8280 (mem:SI (plus:SI (match_dup 1) (const_int 4))))
8281 (set (match_operand:SI 4 "gpc_reg_operand" "")
8282 (mem:SI (plus:SI (match_dup 1) (const_int 8))))
8283 (set (match_operand:SI 5 "gpc_reg_operand" "")
8284 (mem:SI (plus:SI (match_dup 1) (const_int 12))))
8285 (set (match_operand:SI 6 "gpc_reg_operand" "")
8286 (mem:SI (plus:SI (match_dup 1) (const_int 16))))
8287 (set (match_operand:SI 7 "gpc_reg_operand" "")
8288 (mem:SI (plus:SI (match_dup 1) (const_int 20))))])]
8289 "TARGET_STRING && XVECLEN (operands[0], 0) == 6"
8291 { return rs6000_output_load_multiple (operands); }"
8292 [(set_attr "type" "load")
8293 (set_attr "length" "32")])
8295 (define_insn "*ldmsi5"
8296 [(match_parallel 0 "load_multiple_operation"
8297 [(set (match_operand:SI 2 "gpc_reg_operand" "")
8298 (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
8299 (set (match_operand:SI 3 "gpc_reg_operand" "")
8300 (mem:SI (plus:SI (match_dup 1) (const_int 4))))
8301 (set (match_operand:SI 4 "gpc_reg_operand" "")
8302 (mem:SI (plus:SI (match_dup 1) (const_int 8))))
8303 (set (match_operand:SI 5 "gpc_reg_operand" "")
8304 (mem:SI (plus:SI (match_dup 1) (const_int 12))))
8305 (set (match_operand:SI 6 "gpc_reg_operand" "")
8306 (mem:SI (plus:SI (match_dup 1) (const_int 16))))])]
8307 "TARGET_STRING && XVECLEN (operands[0], 0) == 5"
8309 { return rs6000_output_load_multiple (operands); }"
8310 [(set_attr "type" "load")
8311 (set_attr "length" "32")])
8313 (define_insn "*ldmsi4"
8314 [(match_parallel 0 "load_multiple_operation"
8315 [(set (match_operand:SI 2 "gpc_reg_operand" "")
8316 (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
8317 (set (match_operand:SI 3 "gpc_reg_operand" "")
8318 (mem:SI (plus:SI (match_dup 1) (const_int 4))))
8319 (set (match_operand:SI 4 "gpc_reg_operand" "")
8320 (mem:SI (plus:SI (match_dup 1) (const_int 8))))
8321 (set (match_operand:SI 5 "gpc_reg_operand" "")
8322 (mem:SI (plus:SI (match_dup 1) (const_int 12))))])]
8323 "TARGET_STRING && XVECLEN (operands[0], 0) == 4"
8325 { return rs6000_output_load_multiple (operands); }"
8326 [(set_attr "type" "load")
8327 (set_attr "length" "32")])
8329 (define_insn "*ldmsi3"
8330 [(match_parallel 0 "load_multiple_operation"
8331 [(set (match_operand:SI 2 "gpc_reg_operand" "")
8332 (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
8333 (set (match_operand:SI 3 "gpc_reg_operand" "")
8334 (mem:SI (plus:SI (match_dup 1) (const_int 4))))
8335 (set (match_operand:SI 4 "gpc_reg_operand" "")
8336 (mem:SI (plus:SI (match_dup 1) (const_int 8))))])]
8337 "TARGET_STRING && XVECLEN (operands[0], 0) == 3"
8339 { return rs6000_output_load_multiple (operands); }"
8340 [(set_attr "type" "load")
8341 (set_attr "length" "32")])
8343 (define_expand "store_multiple"
8344 [(match_par_dup 3 [(set (match_operand:SI 0 "" "")
8345 (match_operand:SI 1 "" ""))
8346 (clobber (scratch:SI))
8347 (use (match_operand:SI 2 "" ""))])]
8348 "TARGET_STRING && !TARGET_POWERPC64"
8357 /* Support only storing a constant number of fixed-point registers to
8358 memory and only bother with this if more than two; the machine
8359 doesn't support more than eight. */
8360 if (GET_CODE (operands[2]) != CONST_INT
8361 || INTVAL (operands[2]) <= 2
8362 || INTVAL (operands[2]) > 8
8363 || GET_CODE (operands[0]) != MEM
8364 || GET_CODE (operands[1]) != REG
8365 || REGNO (operands[1]) >= 32)
8368 count = INTVAL (operands[2]);
8369 regno = REGNO (operands[1]);
8371 operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count + 1));
8372 to = force_reg (SImode, XEXP (operands[0], 0));
8373 op0 = replace_equiv_address (operands[0], to);
8375 XVECEXP (operands[3], 0, 0)
8376 = gen_rtx_SET (VOIDmode, adjust_address_nv (op0, SImode, 0), operands[1]);
8377 XVECEXP (operands[3], 0, 1) = gen_rtx_CLOBBER (VOIDmode,
8378 gen_rtx_SCRATCH (SImode));
8380 for (i = 1; i < count; i++)
8381 XVECEXP (operands[3], 0, i + 1)
8382 = gen_rtx_SET (VOIDmode,
8383 adjust_address_nv (op0, SImode, i * 4),
8384 gen_rtx_REG (SImode, regno + i));
8387 (define_insn "*store_multiple_power"
8388 [(match_parallel 0 "store_multiple_operation"
8389 [(set (match_operand:SI 1 "indirect_operand" "=Q")
8390 (match_operand:SI 2 "gpc_reg_operand" "r"))
8391 (clobber (match_scratch:SI 3 "=q"))])]
8392 "TARGET_STRING && TARGET_POWER"
8393 "{stsi|stswi} %2,%P1,%O0"
8394 [(set_attr "type" "store")])
8396 (define_insn "*stmsi8"
8397 [(match_parallel 0 "store_multiple_operation"
8398 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
8399 (match_operand:SI 2 "gpc_reg_operand" "r"))
8400 (clobber (match_scratch:SI 3 "X"))
8401 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
8402 (match_operand:SI 4 "gpc_reg_operand" "r"))
8403 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
8404 (match_operand:SI 5 "gpc_reg_operand" "r"))
8405 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
8406 (match_operand:SI 6 "gpc_reg_operand" "r"))
8407 (set (mem:SI (plus:SI (match_dup 1) (const_int 16)))
8408 (match_operand:SI 7 "gpc_reg_operand" "r"))
8409 (set (mem:SI (plus:SI (match_dup 1) (const_int 20)))
8410 (match_operand:SI 8 "gpc_reg_operand" "r"))
8411 (set (mem:SI (plus:SI (match_dup 1) (const_int 24)))
8412 (match_operand:SI 9 "gpc_reg_operand" "r"))
8413 (set (mem:SI (plus:SI (match_dup 1) (const_int 28)))
8414 (match_operand:SI 10 "gpc_reg_operand" "r"))])]
8415 "TARGET_STRING && !TARGET_POWER && XVECLEN (operands[0], 0) == 9"
8416 "{stsi|stswi} %2,%1,%O0"
8417 [(set_attr "type" "store")])
8419 (define_insn "*stmsi7"
8420 [(match_parallel 0 "store_multiple_operation"
8421 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
8422 (match_operand:SI 2 "gpc_reg_operand" "r"))
8423 (clobber (match_scratch:SI 3 "X"))
8424 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
8425 (match_operand:SI 4 "gpc_reg_operand" "r"))
8426 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
8427 (match_operand:SI 5 "gpc_reg_operand" "r"))
8428 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
8429 (match_operand:SI 6 "gpc_reg_operand" "r"))
8430 (set (mem:SI (plus:SI (match_dup 1) (const_int 16)))
8431 (match_operand:SI 7 "gpc_reg_operand" "r"))
8432 (set (mem:SI (plus:SI (match_dup 1) (const_int 20)))
8433 (match_operand:SI 8 "gpc_reg_operand" "r"))
8434 (set (mem:SI (plus:SI (match_dup 1) (const_int 24)))
8435 (match_operand:SI 9 "gpc_reg_operand" "r"))])]
8436 "TARGET_STRING && !TARGET_POWER && XVECLEN (operands[0], 0) == 8"
8437 "{stsi|stswi} %2,%1,%O0"
8438 [(set_attr "type" "store")])
8440 (define_insn "*stmsi6"
8441 [(match_parallel 0 "store_multiple_operation"
8442 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
8443 (match_operand:SI 2 "gpc_reg_operand" "r"))
8444 (clobber (match_scratch:SI 3 "X"))
8445 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
8446 (match_operand:SI 4 "gpc_reg_operand" "r"))
8447 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
8448 (match_operand:SI 5 "gpc_reg_operand" "r"))
8449 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
8450 (match_operand:SI 6 "gpc_reg_operand" "r"))
8451 (set (mem:SI (plus:SI (match_dup 1) (const_int 16)))
8452 (match_operand:SI 7 "gpc_reg_operand" "r"))
8453 (set (mem:SI (plus:SI (match_dup 1) (const_int 20)))
8454 (match_operand:SI 8 "gpc_reg_operand" "r"))])]
8455 "TARGET_STRING && !TARGET_POWER && XVECLEN (operands[0], 0) == 7"
8456 "{stsi|stswi} %2,%1,%O0"
8457 [(set_attr "type" "store")])
8459 (define_insn "*stmsi5"
8460 [(match_parallel 0 "store_multiple_operation"
8461 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
8462 (match_operand:SI 2 "gpc_reg_operand" "r"))
8463 (clobber (match_scratch:SI 3 "X"))
8464 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
8465 (match_operand:SI 4 "gpc_reg_operand" "r"))
8466 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
8467 (match_operand:SI 5 "gpc_reg_operand" "r"))
8468 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
8469 (match_operand:SI 6 "gpc_reg_operand" "r"))
8470 (set (mem:SI (plus:SI (match_dup 1) (const_int 16)))
8471 (match_operand:SI 7 "gpc_reg_operand" "r"))])]
8472 "TARGET_STRING && !TARGET_POWER && XVECLEN (operands[0], 0) == 6"
8473 "{stsi|stswi} %2,%1,%O0"
8474 [(set_attr "type" "store")])
8476 (define_insn "*stmsi4"
8477 [(match_parallel 0 "store_multiple_operation"
8478 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
8479 (match_operand:SI 2 "gpc_reg_operand" "r"))
8480 (clobber (match_scratch:SI 3 "X"))
8481 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
8482 (match_operand:SI 4 "gpc_reg_operand" "r"))
8483 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
8484 (match_operand:SI 5 "gpc_reg_operand" "r"))
8485 (set (mem:SI (plus:SI (match_dup 1) (const_int 12)))
8486 (match_operand:SI 6 "gpc_reg_operand" "r"))])]
8487 "TARGET_STRING && !TARGET_POWER && XVECLEN (operands[0], 0) == 5"
8488 "{stsi|stswi} %2,%1,%O0"
8489 [(set_attr "type" "store")])
8491 (define_insn "*stmsi3"
8492 [(match_parallel 0 "store_multiple_operation"
8493 [(set (mem:SI (match_operand:SI 1 "gpc_reg_operand" "b"))
8494 (match_operand:SI 2 "gpc_reg_operand" "r"))
8495 (clobber (match_scratch:SI 3 "X"))
8496 (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
8497 (match_operand:SI 4 "gpc_reg_operand" "r"))
8498 (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
8499 (match_operand:SI 5 "gpc_reg_operand" "r"))])]
8500 "TARGET_STRING && !TARGET_POWER && XVECLEN (operands[0], 0) == 4"
8501 "{stsi|stswi} %2,%1,%O0"
8502 [(set_attr "type" "store")])
8504 (define_expand "setmemsi"
8505 [(parallel [(set (match_operand:BLK 0 "" "")
8506 (match_operand 2 "const_int_operand" ""))
8507 (use (match_operand:SI 1 "" ""))
8508 (use (match_operand:SI 3 "" ""))])]
8512 /* If value to set is not zero, use the library routine. */
8513 if (operands[2] != const0_rtx)
8516 if (expand_block_clear (operands))
8522 ;; String/block move insn.
8523 ;; Argument 0 is the destination
8524 ;; Argument 1 is the source
8525 ;; Argument 2 is the length
8526 ;; Argument 3 is the alignment
8528 (define_expand "movmemsi"
8529 [(parallel [(set (match_operand:BLK 0 "" "")
8530 (match_operand:BLK 1 "" ""))
8531 (use (match_operand:SI 2 "" ""))
8532 (use (match_operand:SI 3 "" ""))])]
8536 if (expand_block_move (operands))
8542 ;; Move up to 32 bytes at a time. The fixed registers are needed because the
8543 ;; register allocator doesn't have a clue about allocating 8 word registers.
8544 ;; rD/rS = r5 is preferred, efficient form.
8545 (define_expand "movmemsi_8reg"
8546 [(parallel [(set (match_operand 0 "" "")
8547 (match_operand 1 "" ""))
8548 (use (match_operand 2 "" ""))
8549 (use (match_operand 3 "" ""))
8550 (clobber (reg:SI 5))
8551 (clobber (reg:SI 6))
8552 (clobber (reg:SI 7))
8553 (clobber (reg:SI 8))
8554 (clobber (reg:SI 9))
8555 (clobber (reg:SI 10))
8556 (clobber (reg:SI 11))
8557 (clobber (reg:SI 12))
8558 (clobber (match_scratch:SI 4 ""))])]
8563 [(set (mem:BLK (match_operand:SI 0 "gpc_reg_operand" "b"))
8564 (mem:BLK (match_operand:SI 1 "gpc_reg_operand" "b")))
8565 (use (match_operand:SI 2 "immediate_operand" "i"))
8566 (use (match_operand:SI 3 "immediate_operand" "i"))
8567 (clobber (match_operand:SI 4 "gpc_reg_operand" "=r"))
8568 (clobber (reg:SI 6))
8569 (clobber (reg:SI 7))
8570 (clobber (reg:SI 8))
8571 (clobber (reg:SI 9))
8572 (clobber (reg:SI 10))
8573 (clobber (reg:SI 11))
8574 (clobber (reg:SI 12))
8575 (clobber (match_scratch:SI 5 "=q"))]
8576 "TARGET_STRING && TARGET_POWER
8577 && ((INTVAL (operands[2]) > 24 && INTVAL (operands[2]) < 32)
8578 || INTVAL (operands[2]) == 0)
8579 && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 12)
8580 && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 12)
8581 && REGNO (operands[4]) == 5"
8582 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
8583 [(set_attr "type" "load")
8584 (set_attr "length" "8")])
8587 [(set (mem:BLK (match_operand:P 0 "gpc_reg_operand" "b"))
8588 (mem:BLK (match_operand:P 1 "gpc_reg_operand" "b")))
8589 (use (match_operand:SI 2 "immediate_operand" "i"))
8590 (use (match_operand:SI 3 "immediate_operand" "i"))
8591 (clobber (match_operand:SI 4 "gpc_reg_operand" "=r"))
8592 (clobber (reg:SI 6))
8593 (clobber (reg:SI 7))
8594 (clobber (reg:SI 8))
8595 (clobber (reg:SI 9))
8596 (clobber (reg:SI 10))
8597 (clobber (reg:SI 11))
8598 (clobber (reg:SI 12))
8599 (clobber (match_scratch:SI 5 "X"))]
8600 "TARGET_STRING && ! TARGET_POWER
8601 && ((INTVAL (operands[2]) > 24 && INTVAL (operands[2]) < 32)
8602 || INTVAL (operands[2]) == 0)
8603 && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 12)
8604 && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 12)
8605 && REGNO (operands[4]) == 5"
8606 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
8607 [(set_attr "type" "load")
8608 (set_attr "length" "8")])
8610 ;; Move up to 24 bytes at a time. The fixed registers are needed because the
8611 ;; register allocator doesn't have a clue about allocating 6 word registers.
8612 ;; rD/rS = r5 is preferred, efficient form.
8613 (define_expand "movmemsi_6reg"
8614 [(parallel [(set (match_operand 0 "" "")
8615 (match_operand 1 "" ""))
8616 (use (match_operand 2 "" ""))
8617 (use (match_operand 3 "" ""))
8618 (clobber (reg:SI 5))
8619 (clobber (reg:SI 6))
8620 (clobber (reg:SI 7))
8621 (clobber (reg:SI 8))
8622 (clobber (reg:SI 9))
8623 (clobber (reg:SI 10))
8624 (clobber (match_scratch:SI 4 ""))])]
8629 [(set (mem:BLK (match_operand:SI 0 "gpc_reg_operand" "b"))
8630 (mem:BLK (match_operand:SI 1 "gpc_reg_operand" "b")))
8631 (use (match_operand:SI 2 "immediate_operand" "i"))
8632 (use (match_operand:SI 3 "immediate_operand" "i"))
8633 (clobber (match_operand:SI 4 "gpc_reg_operand" "=r"))
8634 (clobber (reg:SI 6))
8635 (clobber (reg:SI 7))
8636 (clobber (reg:SI 8))
8637 (clobber (reg:SI 9))
8638 (clobber (reg:SI 10))
8639 (clobber (match_scratch:SI 5 "=q"))]
8640 "TARGET_STRING && TARGET_POWER
8641 && INTVAL (operands[2]) > 16 && INTVAL (operands[2]) <= 24
8642 && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 10)
8643 && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 10)
8644 && REGNO (operands[4]) == 5"
8645 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
8646 [(set_attr "type" "load")
8647 (set_attr "length" "8")])
8650 [(set (mem:BLK (match_operand:P 0 "gpc_reg_operand" "b"))
8651 (mem:BLK (match_operand:P 1 "gpc_reg_operand" "b")))
8652 (use (match_operand:SI 2 "immediate_operand" "i"))
8653 (use (match_operand:SI 3 "immediate_operand" "i"))
8654 (clobber (match_operand:SI 4 "gpc_reg_operand" "=r"))
8655 (clobber (reg:SI 6))
8656 (clobber (reg:SI 7))
8657 (clobber (reg:SI 8))
8658 (clobber (reg:SI 9))
8659 (clobber (reg:SI 10))
8660 (clobber (match_scratch:SI 5 "X"))]
8661 "TARGET_STRING && ! TARGET_POWER
8662 && INTVAL (operands[2]) > 16 && INTVAL (operands[2]) <= 32
8663 && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 10)
8664 && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 10)
8665 && REGNO (operands[4]) == 5"
8666 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
8667 [(set_attr "type" "load")
8668 (set_attr "length" "8")])
8670 ;; Move up to 16 bytes at a time, using 4 fixed registers to avoid spill
8671 ;; problems with TImode.
8672 ;; rD/rS = r5 is preferred, efficient form.
8673 (define_expand "movmemsi_4reg"
8674 [(parallel [(set (match_operand 0 "" "")
8675 (match_operand 1 "" ""))
8676 (use (match_operand 2 "" ""))
8677 (use (match_operand 3 "" ""))
8678 (clobber (reg:SI 5))
8679 (clobber (reg:SI 6))
8680 (clobber (reg:SI 7))
8681 (clobber (reg:SI 8))
8682 (clobber (match_scratch:SI 4 ""))])]
8687 [(set (mem:BLK (match_operand:SI 0 "gpc_reg_operand" "b"))
8688 (mem:BLK (match_operand:SI 1 "gpc_reg_operand" "b")))
8689 (use (match_operand:SI 2 "immediate_operand" "i"))
8690 (use (match_operand:SI 3 "immediate_operand" "i"))
8691 (clobber (match_operand:SI 4 "gpc_reg_operand" "=r"))
8692 (clobber (reg:SI 6))
8693 (clobber (reg:SI 7))
8694 (clobber (reg:SI 8))
8695 (clobber (match_scratch:SI 5 "=q"))]
8696 "TARGET_STRING && TARGET_POWER
8697 && INTVAL (operands[2]) > 8 && INTVAL (operands[2]) <= 16
8698 && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 8)
8699 && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 8)
8700 && REGNO (operands[4]) == 5"
8701 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
8702 [(set_attr "type" "load")
8703 (set_attr "length" "8")])
8706 [(set (mem:BLK (match_operand:P 0 "gpc_reg_operand" "b"))
8707 (mem:BLK (match_operand:P 1 "gpc_reg_operand" "b")))
8708 (use (match_operand:SI 2 "immediate_operand" "i"))
8709 (use (match_operand:SI 3 "immediate_operand" "i"))
8710 (clobber (match_operand:SI 4 "gpc_reg_operand" "=r"))
8711 (clobber (reg:SI 6))
8712 (clobber (reg:SI 7))
8713 (clobber (reg:SI 8))
8714 (clobber (match_scratch:SI 5 "X"))]
8715 "TARGET_STRING && ! TARGET_POWER
8716 && INTVAL (operands[2]) > 8 && INTVAL (operands[2]) <= 16
8717 && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 8)
8718 && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 8)
8719 && REGNO (operands[4]) == 5"
8720 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
8721 [(set_attr "type" "load")
8722 (set_attr "length" "8")])
8724 ;; Move up to 8 bytes at a time.
8725 (define_expand "movmemsi_2reg"
8726 [(parallel [(set (match_operand 0 "" "")
8727 (match_operand 1 "" ""))
8728 (use (match_operand 2 "" ""))
8729 (use (match_operand 3 "" ""))
8730 (clobber (match_scratch:DI 4 ""))
8731 (clobber (match_scratch:SI 5 ""))])]
8732 "TARGET_STRING && ! TARGET_POWERPC64"
8736 [(set (mem:BLK (match_operand:SI 0 "gpc_reg_operand" "b"))
8737 (mem:BLK (match_operand:SI 1 "gpc_reg_operand" "b")))
8738 (use (match_operand:SI 2 "immediate_operand" "i"))
8739 (use (match_operand:SI 3 "immediate_operand" "i"))
8740 (clobber (match_scratch:DI 4 "=&r"))
8741 (clobber (match_scratch:SI 5 "=q"))]
8742 "TARGET_STRING && TARGET_POWER && ! TARGET_POWERPC64
8743 && INTVAL (operands[2]) > 4 && INTVAL (operands[2]) <= 8"
8744 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
8745 [(set_attr "type" "load")
8746 (set_attr "length" "8")])
8749 [(set (mem:BLK (match_operand:SI 0 "gpc_reg_operand" "b"))
8750 (mem:BLK (match_operand:SI 1 "gpc_reg_operand" "b")))
8751 (use (match_operand:SI 2 "immediate_operand" "i"))
8752 (use (match_operand:SI 3 "immediate_operand" "i"))
8753 (clobber (match_scratch:DI 4 "=&r"))
8754 (clobber (match_scratch:SI 5 "X"))]
8755 "TARGET_STRING && ! TARGET_POWER && ! TARGET_POWERPC64
8756 && INTVAL (operands[2]) > 4 && INTVAL (operands[2]) <= 8"
8757 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
8758 [(set_attr "type" "load")
8759 (set_attr "length" "8")])
8761 ;; Move up to 4 bytes at a time.
8762 (define_expand "movmemsi_1reg"
8763 [(parallel [(set (match_operand 0 "" "")
8764 (match_operand 1 "" ""))
8765 (use (match_operand 2 "" ""))
8766 (use (match_operand 3 "" ""))
8767 (clobber (match_scratch:SI 4 ""))
8768 (clobber (match_scratch:SI 5 ""))])]
8773 [(set (mem:BLK (match_operand:SI 0 "gpc_reg_operand" "b"))
8774 (mem:BLK (match_operand:SI 1 "gpc_reg_operand" "b")))
8775 (use (match_operand:SI 2 "immediate_operand" "i"))
8776 (use (match_operand:SI 3 "immediate_operand" "i"))
8777 (clobber (match_scratch:SI 4 "=&r"))
8778 (clobber (match_scratch:SI 5 "=q"))]
8779 "TARGET_STRING && TARGET_POWER
8780 && INTVAL (operands[2]) > 0 && INTVAL (operands[2]) <= 4"
8781 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
8782 [(set_attr "type" "load")
8783 (set_attr "length" "8")])
8786 [(set (mem:BLK (match_operand:P 0 "gpc_reg_operand" "b"))
8787 (mem:BLK (match_operand:P 1 "gpc_reg_operand" "b")))
8788 (use (match_operand:SI 2 "immediate_operand" "i"))
8789 (use (match_operand:SI 3 "immediate_operand" "i"))
8790 (clobber (match_scratch:SI 4 "=&r"))
8791 (clobber (match_scratch:SI 5 "X"))]
8792 "TARGET_STRING && ! TARGET_POWER
8793 && INTVAL (operands[2]) > 0 && INTVAL (operands[2]) <= 4"
8794 "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
8795 [(set_attr "type" "load")
8796 (set_attr "length" "8")])
8798 ;; Define insns that do load or store with update. Some of these we can
8799 ;; get by using pre-decrement or pre-increment, but the hardware can also
8800 ;; do cases where the increment is not the size of the object.
8802 ;; In all these cases, we use operands 0 and 1 for the register being
8803 ;; incremented because those are the operands that local-alloc will
8804 ;; tie and these are the pair most likely to be tieable (and the ones
8805 ;; that will benefit the most).
8807 (define_insn "*movdi_update1"
8808 [(set (match_operand:DI 3 "gpc_reg_operand" "=r,r")
8809 (mem:DI (plus:DI (match_operand:DI 1 "gpc_reg_operand" "0,0")
8810 (match_operand:DI 2 "reg_or_aligned_short_operand" "r,I"))))
8811 (set (match_operand:DI 0 "gpc_reg_operand" "=b,b")
8812 (plus:DI (match_dup 1) (match_dup 2)))]
8813 "TARGET_POWERPC64 && TARGET_UPDATE"
8817 [(set_attr "type" "load_ux,load_u")])
8819 (define_insn "movdi_<mode>_update"
8820 [(set (mem:DI (plus:P (match_operand:P 1 "gpc_reg_operand" "0,0")
8821 (match_operand:P 2 "reg_or_aligned_short_operand" "r,I")))
8822 (match_operand:DI 3 "gpc_reg_operand" "r,r"))
8823 (set (match_operand:P 0 "gpc_reg_operand" "=b,b")
8824 (plus:P (match_dup 1) (match_dup 2)))]
8825 "TARGET_POWERPC64 && TARGET_UPDATE"
8829 [(set_attr "type" "store_ux,store_u")])
8831 (define_insn "*movsi_update1"
8832 [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
8833 (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
8834 (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
8835 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
8836 (plus:SI (match_dup 1) (match_dup 2)))]
8839 {lux|lwzux} %3,%0,%2
8840 {lu|lwzu} %3,%2(%0)"
8841 [(set_attr "type" "load_ux,load_u")])
8843 (define_insn "*movsi_update2"
8844 [(set (match_operand:DI 3 "gpc_reg_operand" "=r")
8846 (mem:SI (plus:DI (match_operand:DI 1 "gpc_reg_operand" "0")
8847 (match_operand:DI 2 "gpc_reg_operand" "r")))))
8848 (set (match_operand:DI 0 "gpc_reg_operand" "=b")
8849 (plus:DI (match_dup 1) (match_dup 2)))]
8852 [(set_attr "type" "load_ext_ux")])
8854 (define_insn "movsi_update"
8855 [(set (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
8856 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
8857 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8858 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
8859 (plus:SI (match_dup 1) (match_dup 2)))]
8862 {stux|stwux} %3,%0,%2
8863 {stu|stwu} %3,%2(%0)"
8864 [(set_attr "type" "store_ux,store_u")])
8866 (define_insn "*movhi_update1"
8867 [(set (match_operand:HI 3 "gpc_reg_operand" "=r,r")
8868 (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
8869 (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
8870 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
8871 (plus:SI (match_dup 1) (match_dup 2)))]
8876 [(set_attr "type" "load_ux,load_u")])
8878 (define_insn "*movhi_update2"
8879 [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
8881 (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
8882 (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
8883 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
8884 (plus:SI (match_dup 1) (match_dup 2)))]
8889 [(set_attr "type" "load_ux,load_u")])
8891 (define_insn "*movhi_update3"
8892 [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
8894 (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
8895 (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
8896 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
8897 (plus:SI (match_dup 1) (match_dup 2)))]
8902 [(set_attr "type" "load_ext_ux,load_ext_u")])
8904 (define_insn "*movhi_update4"
8905 [(set (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
8906 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
8907 (match_operand:HI 3 "gpc_reg_operand" "r,r"))
8908 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
8909 (plus:SI (match_dup 1) (match_dup 2)))]
8914 [(set_attr "type" "store_ux,store_u")])
8916 (define_insn "*movqi_update1"
8917 [(set (match_operand:QI 3 "gpc_reg_operand" "=r,r")
8918 (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
8919 (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
8920 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
8921 (plus:SI (match_dup 1) (match_dup 2)))]
8926 [(set_attr "type" "load_ux,load_u")])
8928 (define_insn "*movqi_update2"
8929 [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
8931 (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
8932 (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
8933 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
8934 (plus:SI (match_dup 1) (match_dup 2)))]
8939 [(set_attr "type" "load_ux,load_u")])
8941 (define_insn "*movqi_update3"
8942 [(set (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
8943 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
8944 (match_operand:QI 3 "gpc_reg_operand" "r,r"))
8945 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
8946 (plus:SI (match_dup 1) (match_dup 2)))]
8951 [(set_attr "type" "store_ux,store_u")])
8953 (define_insn "*movsf_update1"
8954 [(set (match_operand:SF 3 "gpc_reg_operand" "=f,f")
8955 (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
8956 (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
8957 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
8958 (plus:SI (match_dup 1) (match_dup 2)))]
8959 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_UPDATE"
8963 [(set_attr "type" "fpload_ux,fpload_u")])
8965 (define_insn "*movsf_update2"
8966 [(set (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
8967 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
8968 (match_operand:SF 3 "gpc_reg_operand" "f,f"))
8969 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
8970 (plus:SI (match_dup 1) (match_dup 2)))]
8971 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_UPDATE"
8975 [(set_attr "type" "fpstore_ux,fpstore_u")])
8977 (define_insn "*movsf_update3"
8978 [(set (match_operand:SF 3 "gpc_reg_operand" "=r,r")
8979 (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
8980 (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
8981 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
8982 (plus:SI (match_dup 1) (match_dup 2)))]
8983 "(TARGET_SOFT_FLOAT || !TARGET_FPRS) && TARGET_UPDATE"
8985 {lux|lwzux} %3,%0,%2
8986 {lu|lwzu} %3,%2(%0)"
8987 [(set_attr "type" "load_ux,load_u")])
8989 (define_insn "*movsf_update4"
8990 [(set (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
8991 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
8992 (match_operand:SF 3 "gpc_reg_operand" "r,r"))
8993 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
8994 (plus:SI (match_dup 1) (match_dup 2)))]
8995 "(TARGET_SOFT_FLOAT || !TARGET_FPRS) && TARGET_UPDATE"
8997 {stux|stwux} %3,%0,%2
8998 {stu|stwu} %3,%2(%0)"
8999 [(set_attr "type" "store_ux,store_u")])
9001 (define_insn "*movdf_update1"
9002 [(set (match_operand:DF 3 "gpc_reg_operand" "=f,f")
9003 (mem:DF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
9004 (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
9005 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
9006 (plus:SI (match_dup 1) (match_dup 2)))]
9007 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_UPDATE"
9011 [(set_attr "type" "fpload_ux,fpload_u")])
9013 (define_insn "*movdf_update2"
9014 [(set (mem:DF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
9015 (match_operand:SI 2 "reg_or_short_operand" "r,I")))
9016 (match_operand:DF 3 "gpc_reg_operand" "f,f"))
9017 (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
9018 (plus:SI (match_dup 1) (match_dup 2)))]
9019 "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_UPDATE"
9023 [(set_attr "type" "fpstore_ux,fpstore_u")])
9025 ;; Peephole to convert two consecutive FP loads or stores into lfq/stfq.
9027 (define_insn "*lfq_power2"
9028 [(set (match_operand:V2DF 0 "gpc_reg_operand" "=f")
9029 (match_operand:V2DF 1 "memory_operand" ""))]
9031 && TARGET_HARD_FLOAT && TARGET_FPRS"
9035 [(set (match_operand:DF 0 "gpc_reg_operand" "")
9036 (match_operand:DF 1 "memory_operand" ""))
9037 (set (match_operand:DF 2 "gpc_reg_operand" "")
9038 (match_operand:DF 3 "memory_operand" ""))]
9040 && TARGET_HARD_FLOAT && TARGET_FPRS
9041 && registers_ok_for_quad_peep (operands[0], operands[2])
9042 && mems_ok_for_quad_peep (operands[1], operands[3])"
9045 "operands[1] = widen_memory_access (operands[1], V2DFmode, 0);
9046 operands[0] = gen_rtx_REG (V2DFmode, REGNO (operands[0]));")
9048 (define_insn "*stfq_power2"
9049 [(set (match_operand:V2DF 0 "memory_operand" "")
9050 (match_operand:V2DF 1 "gpc_reg_operand" "f"))]
9052 && TARGET_HARD_FLOAT && TARGET_FPRS"
9057 [(set (match_operand:DF 0 "memory_operand" "")
9058 (match_operand:DF 1 "gpc_reg_operand" ""))
9059 (set (match_operand:DF 2 "memory_operand" "")
9060 (match_operand:DF 3 "gpc_reg_operand" ""))]
9062 && TARGET_HARD_FLOAT && TARGET_FPRS
9063 && registers_ok_for_quad_peep (operands[1], operands[3])
9064 && mems_ok_for_quad_peep (operands[0], operands[2])"
9067 "operands[0] = widen_memory_access (operands[0], V2DFmode, 0);
9068 operands[1] = gen_rtx_REG (V2DFmode, REGNO (operands[1]));")
9070 ;; after inserting conditional returns we can sometimes have
9071 ;; unnecessary register moves. Unfortunately we cannot have a
9072 ;; modeless peephole here, because some single SImode sets have early
9073 ;; clobber outputs. Although those sets expand to multi-ppc-insn
9074 ;; sequences, using get_attr_length here will smash the operands
9075 ;; array. Neither is there an early_cobbler_p predicate.
9077 [(set (match_operand:DF 0 "gpc_reg_operand" "")
9078 (match_operand:DF 1 "any_operand" ""))
9079 (set (match_operand:DF 2 "gpc_reg_operand" "")
9081 "peep2_reg_dead_p (2, operands[0])"
9082 [(set (match_dup 2) (match_dup 1))])
9085 [(set (match_operand:SF 0 "gpc_reg_operand" "")
9086 (match_operand:SF 1 "any_operand" ""))
9087 (set (match_operand:SF 2 "gpc_reg_operand" "")
9089 "peep2_reg_dead_p (2, operands[0])"
9090 [(set (match_dup 2) (match_dup 1))])
9095 ;; "b" output constraint here and on tls_ld to support tls linker optimization.
9096 (define_insn "tls_gd_32"
9097 [(set (match_operand:SI 0 "gpc_reg_operand" "=b")
9098 (unspec:SI [(match_operand:SI 1 "gpc_reg_operand" "b")
9099 (match_operand:SI 2 "rs6000_tls_symbol_ref" "")]
9101 "HAVE_AS_TLS && !TARGET_64BIT"
9102 "addi %0,%1,%2@got@tlsgd")
9104 (define_insn "tls_gd_64"
9105 [(set (match_operand:DI 0 "gpc_reg_operand" "=b")
9106 (unspec:DI [(match_operand:DI 1 "gpc_reg_operand" "b")
9107 (match_operand:DI 2 "rs6000_tls_symbol_ref" "")]
9109 "HAVE_AS_TLS && TARGET_64BIT"
9110 "addi %0,%1,%2@got@tlsgd")
9112 (define_insn "tls_ld_32"
9113 [(set (match_operand:SI 0 "gpc_reg_operand" "=b")
9114 (unspec:SI [(match_operand:SI 1 "gpc_reg_operand" "b")]
9116 "HAVE_AS_TLS && !TARGET_64BIT"
9117 "addi %0,%1,%&@got@tlsld")
9119 (define_insn "tls_ld_64"
9120 [(set (match_operand:DI 0 "gpc_reg_operand" "=b")
9121 (unspec:DI [(match_operand:DI 1 "gpc_reg_operand" "b")]
9123 "HAVE_AS_TLS && TARGET_64BIT"
9124 "addi %0,%1,%&@got@tlsld")
9126 (define_insn "tls_dtprel_32"
9127 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9128 (unspec:SI [(match_operand:SI 1 "gpc_reg_operand" "b")
9129 (match_operand:SI 2 "rs6000_tls_symbol_ref" "")]
9131 "HAVE_AS_TLS && !TARGET_64BIT"
9132 "addi %0,%1,%2@dtprel")
9134 (define_insn "tls_dtprel_64"
9135 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
9136 (unspec:DI [(match_operand:DI 1 "gpc_reg_operand" "b")
9137 (match_operand:DI 2 "rs6000_tls_symbol_ref" "")]
9139 "HAVE_AS_TLS && TARGET_64BIT"
9140 "addi %0,%1,%2@dtprel")
9142 (define_insn "tls_dtprel_ha_32"
9143 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9144 (unspec:SI [(match_operand:SI 1 "gpc_reg_operand" "b")
9145 (match_operand:SI 2 "rs6000_tls_symbol_ref" "")]
9146 UNSPEC_TLSDTPRELHA))]
9147 "HAVE_AS_TLS && !TARGET_64BIT"
9148 "addis %0,%1,%2@dtprel@ha")
9150 (define_insn "tls_dtprel_ha_64"
9151 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
9152 (unspec:DI [(match_operand:DI 1 "gpc_reg_operand" "b")
9153 (match_operand:DI 2 "rs6000_tls_symbol_ref" "")]
9154 UNSPEC_TLSDTPRELHA))]
9155 "HAVE_AS_TLS && TARGET_64BIT"
9156 "addis %0,%1,%2@dtprel@ha")
9158 (define_insn "tls_dtprel_lo_32"
9159 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9160 (unspec:SI [(match_operand:SI 1 "gpc_reg_operand" "b")
9161 (match_operand:SI 2 "rs6000_tls_symbol_ref" "")]
9162 UNSPEC_TLSDTPRELLO))]
9163 "HAVE_AS_TLS && !TARGET_64BIT"
9164 "addi %0,%1,%2@dtprel@l")
9166 (define_insn "tls_dtprel_lo_64"
9167 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
9168 (unspec:DI [(match_operand:DI 1 "gpc_reg_operand" "b")
9169 (match_operand:DI 2 "rs6000_tls_symbol_ref" "")]
9170 UNSPEC_TLSDTPRELLO))]
9171 "HAVE_AS_TLS && TARGET_64BIT"
9172 "addi %0,%1,%2@dtprel@l")
9174 (define_insn "tls_got_dtprel_32"
9175 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9176 (unspec:SI [(match_operand:SI 1 "gpc_reg_operand" "b")
9177 (match_operand:SI 2 "rs6000_tls_symbol_ref" "")]
9178 UNSPEC_TLSGOTDTPREL))]
9179 "HAVE_AS_TLS && !TARGET_64BIT"
9180 "lwz %0,%2@got@dtprel(%1)")
9182 (define_insn "tls_got_dtprel_64"
9183 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
9184 (unspec:DI [(match_operand:DI 1 "gpc_reg_operand" "b")
9185 (match_operand:DI 2 "rs6000_tls_symbol_ref" "")]
9186 UNSPEC_TLSGOTDTPREL))]
9187 "HAVE_AS_TLS && TARGET_64BIT"
9188 "ld %0,%2@got@dtprel(%1)")
9190 (define_insn "tls_tprel_32"
9191 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9192 (unspec:SI [(match_operand:SI 1 "gpc_reg_operand" "b")
9193 (match_operand:SI 2 "rs6000_tls_symbol_ref" "")]
9195 "HAVE_AS_TLS && !TARGET_64BIT"
9196 "addi %0,%1,%2@tprel")
9198 (define_insn "tls_tprel_64"
9199 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
9200 (unspec:DI [(match_operand:DI 1 "gpc_reg_operand" "b")
9201 (match_operand:DI 2 "rs6000_tls_symbol_ref" "")]
9203 "HAVE_AS_TLS && TARGET_64BIT"
9204 "addi %0,%1,%2@tprel")
9206 (define_insn "tls_tprel_ha_32"
9207 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9208 (unspec:SI [(match_operand:SI 1 "gpc_reg_operand" "b")
9209 (match_operand:SI 2 "rs6000_tls_symbol_ref" "")]
9210 UNSPEC_TLSTPRELHA))]
9211 "HAVE_AS_TLS && !TARGET_64BIT"
9212 "addis %0,%1,%2@tprel@ha")
9214 (define_insn "tls_tprel_ha_64"
9215 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
9216 (unspec:DI [(match_operand:DI 1 "gpc_reg_operand" "b")
9217 (match_operand:DI 2 "rs6000_tls_symbol_ref" "")]
9218 UNSPEC_TLSTPRELHA))]
9219 "HAVE_AS_TLS && TARGET_64BIT"
9220 "addis %0,%1,%2@tprel@ha")
9222 (define_insn "tls_tprel_lo_32"
9223 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9224 (unspec:SI [(match_operand:SI 1 "gpc_reg_operand" "b")
9225 (match_operand:SI 2 "rs6000_tls_symbol_ref" "")]
9226 UNSPEC_TLSTPRELLO))]
9227 "HAVE_AS_TLS && !TARGET_64BIT"
9228 "addi %0,%1,%2@tprel@l")
9230 (define_insn "tls_tprel_lo_64"
9231 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
9232 (unspec:DI [(match_operand:DI 1 "gpc_reg_operand" "b")
9233 (match_operand:DI 2 "rs6000_tls_symbol_ref" "")]
9234 UNSPEC_TLSTPRELLO))]
9235 "HAVE_AS_TLS && TARGET_64BIT"
9236 "addi %0,%1,%2@tprel@l")
9238 ;; "b" output constraint here and on tls_tls input to support linker tls
9239 ;; optimization. The linker may edit the instructions emitted by a
9240 ;; tls_got_tprel/tls_tls pair to addis,addi.
9241 (define_insn "tls_got_tprel_32"
9242 [(set (match_operand:SI 0 "gpc_reg_operand" "=b")
9243 (unspec:SI [(match_operand:SI 1 "gpc_reg_operand" "b")
9244 (match_operand:SI 2 "rs6000_tls_symbol_ref" "")]
9245 UNSPEC_TLSGOTTPREL))]
9246 "HAVE_AS_TLS && !TARGET_64BIT"
9247 "lwz %0,%2@got@tprel(%1)")
9249 (define_insn "tls_got_tprel_64"
9250 [(set (match_operand:DI 0 "gpc_reg_operand" "=b")
9251 (unspec:DI [(match_operand:DI 1 "gpc_reg_operand" "b")
9252 (match_operand:DI 2 "rs6000_tls_symbol_ref" "")]
9253 UNSPEC_TLSGOTTPREL))]
9254 "HAVE_AS_TLS && TARGET_64BIT"
9255 "ld %0,%2@got@tprel(%1)")
9257 (define_insn "tls_tls_32"
9258 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9259 (unspec:SI [(match_operand:SI 1 "gpc_reg_operand" "b")
9260 (match_operand:SI 2 "rs6000_tls_symbol_ref" "")]
9262 "HAVE_AS_TLS && !TARGET_64BIT"
9265 (define_insn "tls_tls_64"
9266 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
9267 (unspec:DI [(match_operand:DI 1 "gpc_reg_operand" "b")
9268 (match_operand:DI 2 "rs6000_tls_symbol_ref" "")]
9270 "HAVE_AS_TLS && TARGET_64BIT"
9273 ;; Next come insns related to the calling sequence.
9275 ;; First, an insn to allocate new stack space for dynamic use (e.g., alloca).
9276 ;; We move the back-chain and decrement the stack pointer.
9278 (define_expand "allocate_stack"
9279 [(set (match_operand 0 "gpc_reg_operand" "=r")
9280 (minus (reg 1) (match_operand 1 "reg_or_short_operand" "")))
9282 (minus (reg 1) (match_dup 1)))]
9285 { rtx chain = gen_reg_rtx (Pmode);
9286 rtx stack_bot = gen_rtx_MEM (Pmode, stack_pointer_rtx);
9289 emit_move_insn (chain, stack_bot);
9291 /* Check stack bounds if necessary. */
9292 if (current_function_limit_stack)
9295 available = expand_binop (Pmode, sub_optab,
9296 stack_pointer_rtx, stack_limit_rtx,
9297 NULL_RTX, 1, OPTAB_WIDEN);
9298 emit_insn (gen_cond_trap (LTU, available, operands[1], const0_rtx));
9301 if (GET_CODE (operands[1]) != CONST_INT
9302 || INTVAL (operands[1]) < -32767
9303 || INTVAL (operands[1]) > 32768)
9305 neg_op0 = gen_reg_rtx (Pmode);
9307 emit_insn (gen_negsi2 (neg_op0, operands[1]));
9309 emit_insn (gen_negdi2 (neg_op0, operands[1]));
9312 neg_op0 = GEN_INT (- INTVAL (operands[1]));
9315 emit_insn ((* ((TARGET_32BIT) ? gen_movsi_update : gen_movdi_di_update))
9316 (stack_pointer_rtx, stack_pointer_rtx, neg_op0, chain));
9320 emit_insn ((* ((TARGET_32BIT) ? gen_addsi3 : gen_adddi3))
9321 (stack_pointer_rtx, stack_pointer_rtx, neg_op0));
9322 emit_move_insn (gen_rtx_MEM (Pmode, stack_pointer_rtx), chain);
9325 emit_move_insn (operands[0], virtual_stack_dynamic_rtx);
9329 ;; These patterns say how to save and restore the stack pointer. We need not
9330 ;; save the stack pointer at function level since we are careful to
9331 ;; preserve the backchain. At block level, we have to restore the backchain
9332 ;; when we restore the stack pointer.
9334 ;; For nonlocal gotos, we must save both the stack pointer and its
9335 ;; backchain and restore both. Note that in the nonlocal case, the
9336 ;; save area is a memory location.
9338 (define_expand "save_stack_function"
9339 [(match_operand 0 "any_operand" "")
9340 (match_operand 1 "any_operand" "")]
9344 (define_expand "restore_stack_function"
9345 [(match_operand 0 "any_operand" "")
9346 (match_operand 1 "any_operand" "")]
9350 (define_expand "restore_stack_block"
9351 [(use (match_operand 0 "register_operand" ""))
9352 (set (match_dup 2) (match_dup 3))
9353 (set (match_dup 0) (match_operand 1 "register_operand" ""))
9354 (set (match_dup 3) (match_dup 2))]
9358 operands[2] = gen_reg_rtx (Pmode);
9359 operands[3] = gen_rtx_MEM (Pmode, operands[0]);
9362 (define_expand "save_stack_nonlocal"
9363 [(match_operand 0 "memory_operand" "")
9364 (match_operand 1 "register_operand" "")]
9368 rtx temp = gen_reg_rtx (Pmode);
9369 int units_per_word = (TARGET_32BIT) ? 4 : 8;
9371 /* Copy the backchain to the first word, sp to the second. */
9372 emit_move_insn (temp, gen_rtx_MEM (Pmode, operands[1]));
9373 emit_move_insn (adjust_address_nv (operands[0], Pmode, 0), temp);
9374 emit_move_insn (adjust_address_nv (operands[0], Pmode, units_per_word),
9379 (define_expand "restore_stack_nonlocal"
9380 [(match_operand 0 "register_operand" "")
9381 (match_operand 1 "memory_operand" "")]
9385 rtx temp = gen_reg_rtx (Pmode);
9386 int units_per_word = (TARGET_32BIT) ? 4 : 8;
9388 /* Restore the backchain from the first word, sp from the second. */
9389 emit_move_insn (temp,
9390 adjust_address_nv (operands[1], Pmode, 0));
9391 emit_move_insn (operands[0],
9392 adjust_address_nv (operands[1], Pmode, units_per_word));
9393 emit_move_insn (gen_rtx_MEM (Pmode, operands[0]), temp);
9397 ;; TOC register handling.
9399 ;; Code to initialize the TOC register...
9401 (define_insn "load_toc_aix_si"
9402 [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9403 (unspec:SI [(const_int 0)] UNSPEC_TOC))
9405 "DEFAULT_ABI == ABI_AIX && TARGET_32BIT"
9409 ASM_GENERATE_INTERNAL_LABEL (buf, \"LCTOC\", 1);
9410 operands[1] = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
9411 operands[2] = gen_rtx_REG (Pmode, 2);
9412 return \"{l|lwz} %0,%1(%2)\";
9414 [(set_attr "type" "load")])
9416 (define_insn "load_toc_aix_di"
9417 [(parallel [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
9418 (unspec:DI [(const_int 0)] UNSPEC_TOC))
9420 "DEFAULT_ABI == ABI_AIX && TARGET_64BIT"
9424 #ifdef TARGET_RELOCATABLE
9425 ASM_GENERATE_INTERNAL_LABEL (buf, \"LCTOC\",
9426 !TARGET_MINIMAL_TOC || TARGET_RELOCATABLE);
9428 ASM_GENERATE_INTERNAL_LABEL (buf, \"LCTOC\", 1);
9431 strcat (buf, \"@toc\");
9432 operands[1] = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
9433 operands[2] = gen_rtx_REG (Pmode, 2);
9434 return \"ld %0,%1(%2)\";
9436 [(set_attr "type" "load")])
9438 (define_insn "load_toc_v4_pic_si"
9439 [(set (match_operand:SI 0 "register_operand" "=l")
9440 (unspec:SI [(const_int 0)] UNSPEC_TOC))]
9441 "DEFAULT_ABI == ABI_V4 && flag_pic == 1 && TARGET_32BIT"
9442 "bl _GLOBAL_OFFSET_TABLE_@local-4"
9443 [(set_attr "type" "branch")
9444 (set_attr "length" "4")])
9446 (define_insn "load_toc_v4_PIC_1"
9447 [(set (match_operand:SI 0 "register_operand" "=l")
9448 (match_operand:SI 1 "immediate_operand" "s"))
9449 (use (unspec [(match_dup 1)] UNSPEC_TOC))]
9450 "TARGET_ELF && DEFAULT_ABI != ABI_AIX
9451 && (flag_pic == 2 || (flag_pic && TARGET_SECURE_PLT))"
9452 "bcl 20,31,%1\\n%1:"
9453 [(set_attr "type" "branch")
9454 (set_attr "length" "4")])
9456 (define_insn "load_toc_v4_PIC_1b"
9457 [(set (match_operand:SI 0 "register_operand" "=l")
9458 (unspec:SI [(match_operand:SI 1 "immediate_operand" "s")]
9460 "TARGET_ELF && DEFAULT_ABI != ABI_AIX && flag_pic == 2"
9461 "bcl 20,31,$+8\\n\\t.long %1-$"
9462 [(set_attr "type" "branch")
9463 (set_attr "length" "8")])
9465 (define_insn "load_toc_v4_PIC_2"
9466 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9467 (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "b")
9468 (minus:SI (match_operand:SI 2 "immediate_operand" "s")
9469 (match_operand:SI 3 "immediate_operand" "s")))))]
9470 "TARGET_ELF && DEFAULT_ABI != ABI_AIX && flag_pic == 2"
9471 "{l|lwz} %0,%2-%3(%1)"
9472 [(set_attr "type" "load")])
9474 (define_insn "load_toc_v4_PIC_3b"
9475 [(set (match_operand:SI 0 "gpc_reg_operand" "=b")
9476 (plus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9478 (minus:SI (match_operand:SI 2 "symbol_ref_operand" "s")
9479 (match_operand:SI 3 "symbol_ref_operand" "s")))))]
9480 "TARGET_ELF && TARGET_SECURE_PLT && DEFAULT_ABI != ABI_AIX && flag_pic"
9481 "{cau|addis} %0,%1,%2-%3@ha")
9483 (define_insn "load_toc_v4_PIC_3c"
9484 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9485 (lo_sum:SI (match_operand:SI 1 "gpc_reg_operand" "b")
9486 (minus:SI (match_operand:SI 2 "symbol_ref_operand" "s")
9487 (match_operand:SI 3 "symbol_ref_operand" "s"))))]
9488 "TARGET_ELF && TARGET_SECURE_PLT && DEFAULT_ABI != ABI_AIX && flag_pic"
9489 "{cal|addi} %0,%1,%2-%3@l")
9491 ;; If the TOC is shared over a translation unit, as happens with all
9492 ;; the kinds of PIC that we support, we need to restore the TOC
9493 ;; pointer only when jumping over units of translation.
9494 ;; On Darwin, we need to reload the picbase.
9496 (define_expand "builtin_setjmp_receiver"
9497 [(use (label_ref (match_operand 0 "" "")))]
9498 "(DEFAULT_ABI == ABI_V4 && flag_pic == 1)
9499 || (TARGET_TOC && TARGET_MINIMAL_TOC)
9500 || (DEFAULT_ABI == ABI_DARWIN && flag_pic)"
9504 if (DEFAULT_ABI == ABI_DARWIN)
9506 const char *picbase = machopic_function_base_name ();
9507 rtx picrtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (picbase));
9508 rtx picreg = gen_rtx_REG (Pmode, RS6000_PIC_OFFSET_TABLE_REGNUM);
9512 ASM_GENERATE_INTERNAL_LABEL(tmplab, \"LSJR\",
9513 CODE_LABEL_NUMBER (operands[0]));
9514 tmplabrtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (tmplab));
9516 emit_insn (gen_load_macho_picbase (picreg, tmplabrtx));
9517 emit_insn (gen_macho_correct_pic (picreg, picreg, picrtx, tmplabrtx));
9521 rs6000_emit_load_toc_table (FALSE);
9525 ;; Elf specific ways of loading addresses for non-PIC code.
9526 ;; The output of this could be r0, but we make a very strong
9527 ;; preference for a base register because it will usually
9529 (define_insn "elf_high"
9530 [(set (match_operand:SI 0 "gpc_reg_operand" "=b*r")
9531 (high:SI (match_operand 1 "" "")))]
9532 "TARGET_ELF && ! TARGET_64BIT"
9533 "{liu|lis} %0,%1@ha")
9535 (define_insn "elf_low"
9536 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
9537 (lo_sum:SI (match_operand:SI 1 "gpc_reg_operand" "b,!*r")
9538 (match_operand 2 "" "")))]
9539 "TARGET_ELF && ! TARGET_64BIT"
9541 {cal|la} %0,%2@l(%1)
9542 {ai|addic} %0,%1,%K2")
9544 ;; A function pointer under AIX is a pointer to a data area whose first word
9545 ;; contains the actual address of the function, whose second word contains a
9546 ;; pointer to its TOC, and whose third word contains a value to place in the
9547 ;; static chain register (r11). Note that if we load the static chain, our
9548 ;; "trampoline" need not have any executable code.
9550 (define_expand "call_indirect_aix32"
9552 (mem:SI (match_operand:SI 0 "gpc_reg_operand" "")))
9553 (set (mem:SI (plus:SI (reg:SI 1) (const_int 20)))
9556 (mem:SI (plus:SI (match_dup 0)
9559 (mem:SI (plus:SI (match_dup 0)
9561 (parallel [(call (mem:SI (match_dup 2))
9562 (match_operand 1 "" ""))
9566 (mem:SI (plus:SI (reg:SI 1) (const_int 20))))
9567 (clobber (scratch:SI))])]
9570 { operands[2] = gen_reg_rtx (SImode); }")
9572 (define_expand "call_indirect_aix64"
9574 (mem:DI (match_operand:DI 0 "gpc_reg_operand" "")))
9575 (set (mem:DI (plus:DI (reg:DI 1) (const_int 40)))
9578 (mem:DI (plus:DI (match_dup 0)
9581 (mem:DI (plus:DI (match_dup 0)
9583 (parallel [(call (mem:SI (match_dup 2))
9584 (match_operand 1 "" ""))
9588 (mem:DI (plus:DI (reg:DI 1) (const_int 40))))
9589 (clobber (scratch:SI))])]
9592 { operands[2] = gen_reg_rtx (DImode); }")
9594 (define_expand "call_value_indirect_aix32"
9596 (mem:SI (match_operand:SI 1 "gpc_reg_operand" "")))
9597 (set (mem:SI (plus:SI (reg:SI 1) (const_int 20)))
9600 (mem:SI (plus:SI (match_dup 1)
9603 (mem:SI (plus:SI (match_dup 1)
9605 (parallel [(set (match_operand 0 "" "")
9606 (call (mem:SI (match_dup 3))
9607 (match_operand 2 "" "")))
9611 (mem:SI (plus:SI (reg:SI 1) (const_int 20))))
9612 (clobber (scratch:SI))])]
9615 { operands[3] = gen_reg_rtx (SImode); }")
9617 (define_expand "call_value_indirect_aix64"
9619 (mem:DI (match_operand:DI 1 "gpc_reg_operand" "")))
9620 (set (mem:DI (plus:DI (reg:DI 1) (const_int 40)))
9623 (mem:DI (plus:DI (match_dup 1)
9626 (mem:DI (plus:DI (match_dup 1)
9628 (parallel [(set (match_operand 0 "" "")
9629 (call (mem:SI (match_dup 3))
9630 (match_operand 2 "" "")))
9634 (mem:DI (plus:DI (reg:DI 1) (const_int 40))))
9635 (clobber (scratch:SI))])]
9638 { operands[3] = gen_reg_rtx (DImode); }")
9640 ;; Now the definitions for the call and call_value insns
9641 (define_expand "call"
9642 [(parallel [(call (mem:SI (match_operand 0 "address_operand" ""))
9643 (match_operand 1 "" ""))
9644 (use (match_operand 2 "" ""))
9645 (clobber (scratch:SI))])]
9650 if (MACHOPIC_INDIRECT)
9651 operands[0] = machopic_indirect_call_target (operands[0]);
9654 gcc_assert (GET_CODE (operands[0]) == MEM);
9655 gcc_assert (GET_CODE (operands[1]) == CONST_INT);
9657 operands[0] = XEXP (operands[0], 0);
9659 if (DEFAULT_ABI == ABI_V4 && TARGET_SECURE_PLT
9661 && GET_CODE (operands[0]) == SYMBOL_REF
9662 && !SYMBOL_REF_LOCAL_P (operands[0]))
9668 gen_rtx_CALL (VOIDmode,
9669 gen_rtx_MEM (SImode, operands[0]),
9671 gen_rtx_USE (VOIDmode, operands[2]),
9672 gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (SImode)));
9673 call = emit_call_insn (gen_rtx_PARALLEL (VOIDmode, tmp));
9674 use_reg (&CALL_INSN_FUNCTION_USAGE (call), pic_offset_table_rtx);
9678 if (GET_CODE (operands[0]) != SYMBOL_REF
9679 || (DEFAULT_ABI == ABI_AIX && !SYMBOL_REF_FUNCTION_P (operands[0]))
9680 || (DEFAULT_ABI != ABI_DARWIN && (INTVAL (operands[2]) & CALL_LONG) != 0))
9682 if (INTVAL (operands[2]) & CALL_LONG)
9683 operands[0] = rs6000_longcall_ref (operands[0]);
9685 switch (DEFAULT_ABI)
9689 operands[0] = force_reg (Pmode, operands[0]);
9693 /* AIX function pointers are really pointers to a three word
9695 emit_call_insn (TARGET_32BIT
9696 ? gen_call_indirect_aix32 (force_reg (SImode,
9699 : gen_call_indirect_aix64 (force_reg (DImode,
9710 (define_expand "call_value"
9711 [(parallel [(set (match_operand 0 "" "")
9712 (call (mem:SI (match_operand 1 "address_operand" ""))
9713 (match_operand 2 "" "")))
9714 (use (match_operand 3 "" ""))
9715 (clobber (scratch:SI))])]
9720 if (MACHOPIC_INDIRECT)
9721 operands[1] = machopic_indirect_call_target (operands[1]);
9724 gcc_assert (GET_CODE (operands[1]) == MEM);
9725 gcc_assert (GET_CODE (operands[2]) == CONST_INT);
9727 operands[1] = XEXP (operands[1], 0);
9729 if (DEFAULT_ABI == ABI_V4 && TARGET_SECURE_PLT
9731 && GET_CODE (operands[1]) == SYMBOL_REF
9732 && !SYMBOL_REF_LOCAL_P (operands[1]))
9738 gen_rtx_SET (VOIDmode,
9740 gen_rtx_CALL (VOIDmode,
9741 gen_rtx_MEM (SImode,
9744 gen_rtx_USE (VOIDmode, operands[3]),
9745 gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (SImode)));
9746 call = emit_call_insn (gen_rtx_PARALLEL (VOIDmode, tmp));
9747 use_reg (&CALL_INSN_FUNCTION_USAGE (call), pic_offset_table_rtx);
9751 if (GET_CODE (operands[1]) != SYMBOL_REF
9752 || (DEFAULT_ABI == ABI_AIX && !SYMBOL_REF_FUNCTION_P (operands[1]))
9753 || (DEFAULT_ABI != ABI_DARWIN && (INTVAL (operands[3]) & CALL_LONG) != 0))
9755 if (INTVAL (operands[3]) & CALL_LONG)
9756 operands[1] = rs6000_longcall_ref (operands[1]);
9758 switch (DEFAULT_ABI)
9762 operands[1] = force_reg (Pmode, operands[1]);
9766 /* AIX function pointers are really pointers to a three word
9768 emit_call_insn (TARGET_32BIT
9769 ? gen_call_value_indirect_aix32 (operands[0],
9773 : gen_call_value_indirect_aix64 (operands[0],
9785 ;; Call to function in current module. No TOC pointer reload needed.
9786 ;; Operand2 is nonzero if we are using the V.4 calling sequence and
9787 ;; either the function was not prototyped, or it was prototyped as a
9788 ;; variable argument function. It is > 0 if FP registers were passed
9789 ;; and < 0 if they were not.
9791 (define_insn "*call_local32"
9792 [(call (mem:SI (match_operand:SI 0 "current_file_function_operand" "s,s"))
9793 (match_operand 1 "" "g,g"))
9794 (use (match_operand:SI 2 "immediate_operand" "O,n"))
9795 (clobber (match_scratch:SI 3 "=l,l"))]
9796 "(INTVAL (operands[2]) & CALL_LONG) == 0"
9799 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
9800 output_asm_insn (\"crxor 6,6,6\", operands);
9802 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
9803 output_asm_insn (\"creqv 6,6,6\", operands);
9805 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"bl %z0@local\" : \"bl %z0\";
9807 [(set_attr "type" "branch")
9808 (set_attr "length" "4,8")])
9810 (define_insn "*call_local64"
9811 [(call (mem:SI (match_operand:DI 0 "current_file_function_operand" "s,s"))
9812 (match_operand 1 "" "g,g"))
9813 (use (match_operand:SI 2 "immediate_operand" "O,n"))
9814 (clobber (match_scratch:SI 3 "=l,l"))]
9815 "TARGET_64BIT && (INTVAL (operands[2]) & CALL_LONG) == 0"
9818 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
9819 output_asm_insn (\"crxor 6,6,6\", operands);
9821 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
9822 output_asm_insn (\"creqv 6,6,6\", operands);
9824 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"bl %z0@local\" : \"bl %z0\";
9826 [(set_attr "type" "branch")
9827 (set_attr "length" "4,8")])
9829 (define_insn "*call_value_local32"
9830 [(set (match_operand 0 "" "")
9831 (call (mem:SI (match_operand:SI 1 "current_file_function_operand" "s,s"))
9832 (match_operand 2 "" "g,g")))
9833 (use (match_operand:SI 3 "immediate_operand" "O,n"))
9834 (clobber (match_scratch:SI 4 "=l,l"))]
9835 "(INTVAL (operands[3]) & CALL_LONG) == 0"
9838 if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
9839 output_asm_insn (\"crxor 6,6,6\", operands);
9841 else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
9842 output_asm_insn (\"creqv 6,6,6\", operands);
9844 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"bl %z1@local\" : \"bl %z1\";
9846 [(set_attr "type" "branch")
9847 (set_attr "length" "4,8")])
9850 (define_insn "*call_value_local64"
9851 [(set (match_operand 0 "" "")
9852 (call (mem:SI (match_operand:DI 1 "current_file_function_operand" "s,s"))
9853 (match_operand 2 "" "g,g")))
9854 (use (match_operand:SI 3 "immediate_operand" "O,n"))
9855 (clobber (match_scratch:SI 4 "=l,l"))]
9856 "TARGET_64BIT && (INTVAL (operands[3]) & CALL_LONG) == 0"
9859 if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
9860 output_asm_insn (\"crxor 6,6,6\", operands);
9862 else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
9863 output_asm_insn (\"creqv 6,6,6\", operands);
9865 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"bl %z1@local\" : \"bl %z1\";
9867 [(set_attr "type" "branch")
9868 (set_attr "length" "4,8")])
9870 ;; Call to function which may be in another module. Restore the TOC
9871 ;; pointer (r2) after the call unless this is System V.
9872 ;; Operand2 is nonzero if we are using the V.4 calling sequence and
9873 ;; either the function was not prototyped, or it was prototyped as a
9874 ;; variable argument function. It is > 0 if FP registers were passed
9875 ;; and < 0 if they were not.
9877 (define_insn "*call_indirect_nonlocal_aix32"
9878 [(call (mem:SI (match_operand:SI 0 "register_operand" "c,*l"))
9879 (match_operand 1 "" "g,g"))
9883 (mem:SI (plus:SI (reg:SI 1) (const_int 20))))
9884 (clobber (match_scratch:SI 2 "=l,l"))]
9885 "TARGET_32BIT && DEFAULT_ABI == ABI_AIX"
9886 "b%T0l\;{l|lwz} 2,20(1)"
9887 [(set_attr "type" "jmpreg")
9888 (set_attr "length" "8")])
9890 (define_insn "*call_nonlocal_aix32"
9891 [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "s"))
9892 (match_operand 1 "" "g"))
9893 (use (match_operand:SI 2 "immediate_operand" "O"))
9894 (clobber (match_scratch:SI 3 "=l"))]
9896 && DEFAULT_ABI == ABI_AIX
9897 && (INTVAL (operands[2]) & CALL_LONG) == 0"
9899 [(set_attr "type" "branch")
9900 (set_attr "length" "8")])
9902 (define_insn "*call_indirect_nonlocal_aix64"
9903 [(call (mem:SI (match_operand:DI 0 "register_operand" "c,*l"))
9904 (match_operand 1 "" "g,g"))
9908 (mem:DI (plus:DI (reg:DI 1) (const_int 40))))
9909 (clobber (match_scratch:SI 2 "=l,l"))]
9910 "TARGET_64BIT && DEFAULT_ABI == ABI_AIX"
9912 [(set_attr "type" "jmpreg")
9913 (set_attr "length" "8")])
9915 (define_insn "*call_nonlocal_aix64"
9916 [(call (mem:SI (match_operand:DI 0 "symbol_ref_operand" "s"))
9917 (match_operand 1 "" "g"))
9918 (use (match_operand:SI 2 "immediate_operand" "O"))
9919 (clobber (match_scratch:SI 3 "=l"))]
9921 && DEFAULT_ABI == ABI_AIX
9922 && (INTVAL (operands[2]) & CALL_LONG) == 0"
9924 [(set_attr "type" "branch")
9925 (set_attr "length" "8")])
9927 (define_insn "*call_value_indirect_nonlocal_aix32"
9928 [(set (match_operand 0 "" "")
9929 (call (mem:SI (match_operand:SI 1 "register_operand" "c,*l"))
9930 (match_operand 2 "" "g,g")))
9934 (mem:SI (plus:SI (reg:SI 1) (const_int 20))))
9935 (clobber (match_scratch:SI 3 "=l,l"))]
9936 "TARGET_32BIT && DEFAULT_ABI == ABI_AIX"
9937 "b%T1l\;{l|lwz} 2,20(1)"
9938 [(set_attr "type" "jmpreg")
9939 (set_attr "length" "8")])
9941 (define_insn "*call_value_nonlocal_aix32"
9942 [(set (match_operand 0 "" "")
9943 (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "s"))
9944 (match_operand 2 "" "g")))
9945 (use (match_operand:SI 3 "immediate_operand" "O"))
9946 (clobber (match_scratch:SI 4 "=l"))]
9948 && DEFAULT_ABI == ABI_AIX
9949 && (INTVAL (operands[3]) & CALL_LONG) == 0"
9951 [(set_attr "type" "branch")
9952 (set_attr "length" "8")])
9954 (define_insn "*call_value_indirect_nonlocal_aix64"
9955 [(set (match_operand 0 "" "")
9956 (call (mem:SI (match_operand:DI 1 "register_operand" "c,*l"))
9957 (match_operand 2 "" "g,g")))
9961 (mem:DI (plus:DI (reg:DI 1) (const_int 40))))
9962 (clobber (match_scratch:SI 3 "=l,l"))]
9963 "TARGET_64BIT && DEFAULT_ABI == ABI_AIX"
9965 [(set_attr "type" "jmpreg")
9966 (set_attr "length" "8")])
9968 (define_insn "*call_value_nonlocal_aix64"
9969 [(set (match_operand 0 "" "")
9970 (call (mem:SI (match_operand:DI 1 "symbol_ref_operand" "s"))
9971 (match_operand 2 "" "g")))
9972 (use (match_operand:SI 3 "immediate_operand" "O"))
9973 (clobber (match_scratch:SI 4 "=l"))]
9975 && DEFAULT_ABI == ABI_AIX
9976 && (INTVAL (operands[3]) & CALL_LONG) == 0"
9978 [(set_attr "type" "branch")
9979 (set_attr "length" "8")])
9981 ;; A function pointer under System V is just a normal pointer
9982 ;; operands[0] is the function pointer
9983 ;; operands[1] is the stack size to clean up
9984 ;; operands[2] is the value FUNCTION_ARG returns for the VOID argument
9985 ;; which indicates how to set cr1
9987 (define_insn "*call_indirect_nonlocal_sysv"
9988 [(call (mem:SI (match_operand:SI 0 "register_operand" "c,*l,c,*l"))
9989 (match_operand 1 "" "g,g,g,g"))
9990 (use (match_operand:SI 2 "immediate_operand" "O,O,n,n"))
9991 (clobber (match_scratch:SI 3 "=l,l,l,l"))]
9992 "DEFAULT_ABI == ABI_V4
9993 || DEFAULT_ABI == ABI_DARWIN"
9995 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
9996 output_asm_insn ("crxor 6,6,6", operands);
9998 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
9999 output_asm_insn ("creqv 6,6,6", operands);
10003 [(set_attr "type" "jmpreg,jmpreg,jmpreg,jmpreg")
10004 (set_attr "length" "4,4,8,8")])
10006 (define_insn "*call_nonlocal_sysv"
10007 [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "s,s"))
10008 (match_operand 1 "" "g,g"))
10009 (use (match_operand:SI 2 "immediate_operand" "O,n"))
10010 (clobber (match_scratch:SI 3 "=l,l"))]
10011 "(DEFAULT_ABI == ABI_DARWIN
10012 || (DEFAULT_ABI == ABI_V4
10013 && (INTVAL (operands[2]) & CALL_LONG) == 0))"
10015 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
10016 output_asm_insn ("crxor 6,6,6", operands);
10018 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
10019 output_asm_insn ("creqv 6,6,6", operands);
10022 return output_call(insn, operands, 0, 2);
10024 if (DEFAULT_ABI == ABI_V4 && flag_pic)
10026 if (TARGET_SECURE_PLT && flag_pic == 2)
10027 /* The magic 32768 offset here and in the other sysv call insns
10028 corresponds to the offset of r30 in .got2, as given by LCTOC1.
10029 See sysv4.h:toc_section. */
10030 return "bl %z0+32768@plt";
10032 return "bl %z0@plt";
10038 [(set_attr "type" "branch,branch")
10039 (set_attr "length" "4,8")])
10041 (define_insn "*call_value_indirect_nonlocal_sysv"
10042 [(set (match_operand 0 "" "")
10043 (call (mem:SI (match_operand:SI 1 "register_operand" "c,*l,c,*l"))
10044 (match_operand 2 "" "g,g,g,g")))
10045 (use (match_operand:SI 3 "immediate_operand" "O,O,n,n"))
10046 (clobber (match_scratch:SI 4 "=l,l,l,l"))]
10047 "DEFAULT_ABI == ABI_V4
10048 || DEFAULT_ABI == ABI_DARWIN"
10050 if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
10051 output_asm_insn ("crxor 6,6,6", operands);
10053 else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
10054 output_asm_insn ("creqv 6,6,6", operands);
10058 [(set_attr "type" "jmpreg,jmpreg,jmpreg,jmpreg")
10059 (set_attr "length" "4,4,8,8")])
10061 (define_insn "*call_value_nonlocal_sysv"
10062 [(set (match_operand 0 "" "")
10063 (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "s,s"))
10064 (match_operand 2 "" "g,g")))
10065 (use (match_operand:SI 3 "immediate_operand" "O,n"))
10066 (clobber (match_scratch:SI 4 "=l,l"))]
10067 "(DEFAULT_ABI == ABI_DARWIN
10068 || (DEFAULT_ABI == ABI_V4
10069 && (INTVAL (operands[3]) & CALL_LONG) == 0))"
10071 if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
10072 output_asm_insn ("crxor 6,6,6", operands);
10074 else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
10075 output_asm_insn ("creqv 6,6,6", operands);
10078 return output_call(insn, operands, 1, 3);
10080 if (DEFAULT_ABI == ABI_V4 && flag_pic)
10082 if (TARGET_SECURE_PLT && flag_pic == 2)
10083 return "bl %z1+32768@plt";
10085 return "bl %z1@plt";
10091 [(set_attr "type" "branch,branch")
10092 (set_attr "length" "4,8")])
10094 ;; Call subroutine returning any type.
10095 (define_expand "untyped_call"
10096 [(parallel [(call (match_operand 0 "" "")
10098 (match_operand 1 "" "")
10099 (match_operand 2 "" "")])]
10105 emit_call_insn (GEN_CALL (operands[0], const0_rtx, const0_rtx, const0_rtx));
10107 for (i = 0; i < XVECLEN (operands[2], 0); i++)
10109 rtx set = XVECEXP (operands[2], 0, i);
10110 emit_move_insn (SET_DEST (set), SET_SRC (set));
10113 /* The optimizer does not know that the call sets the function value
10114 registers we stored in the result block. We avoid problems by
10115 claiming that all hard registers are used and clobbered at this
10117 emit_insn (gen_blockage ());
10122 ;; sibling call patterns
10123 (define_expand "sibcall"
10124 [(parallel [(call (mem:SI (match_operand 0 "address_operand" ""))
10125 (match_operand 1 "" ""))
10126 (use (match_operand 2 "" ""))
10127 (use (match_operand 3 "" ""))
10133 if (MACHOPIC_INDIRECT)
10134 operands[0] = machopic_indirect_call_target (operands[0]);
10137 gcc_assert (GET_CODE (operands[0]) == MEM);
10138 gcc_assert (GET_CODE (operands[1]) == CONST_INT);
10140 operands[0] = XEXP (operands[0], 0);
10141 operands[3] = gen_reg_rtx (SImode);
10145 ;; this and similar patterns must be marked as using LR, otherwise
10146 ;; dataflow will try to delete the store into it. This is true
10147 ;; even when the actual reg to jump to is in CTR, when LR was
10148 ;; saved and restored around the PIC-setting BCL.
10149 (define_insn "*sibcall_local32"
10150 [(call (mem:SI (match_operand:SI 0 "current_file_function_operand" "s,s"))
10151 (match_operand 1 "" "g,g"))
10152 (use (match_operand:SI 2 "immediate_operand" "O,n"))
10153 (use (match_operand:SI 3 "register_operand" "l,l"))
10155 "(INTVAL (operands[2]) & CALL_LONG) == 0"
10158 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
10159 output_asm_insn (\"crxor 6,6,6\", operands);
10161 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
10162 output_asm_insn (\"creqv 6,6,6\", operands);
10164 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"b %z0@local\" : \"b %z0\";
10166 [(set_attr "type" "branch")
10167 (set_attr "length" "4,8")])
10169 (define_insn "*sibcall_local64"
10170 [(call (mem:SI (match_operand:DI 0 "current_file_function_operand" "s,s"))
10171 (match_operand 1 "" "g,g"))
10172 (use (match_operand:SI 2 "immediate_operand" "O,n"))
10173 (use (match_operand:SI 3 "register_operand" "l,l"))
10175 "TARGET_64BIT && (INTVAL (operands[2]) & CALL_LONG) == 0"
10178 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
10179 output_asm_insn (\"crxor 6,6,6\", operands);
10181 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
10182 output_asm_insn (\"creqv 6,6,6\", operands);
10184 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"b %z0@local\" : \"b %z0\";
10186 [(set_attr "type" "branch")
10187 (set_attr "length" "4,8")])
10189 (define_insn "*sibcall_value_local32"
10190 [(set (match_operand 0 "" "")
10191 (call (mem:SI (match_operand:SI 1 "current_file_function_operand" "s,s"))
10192 (match_operand 2 "" "g,g")))
10193 (use (match_operand:SI 3 "immediate_operand" "O,n"))
10194 (use (match_operand:SI 4 "register_operand" "l,l"))
10196 "(INTVAL (operands[3]) & CALL_LONG) == 0"
10199 if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
10200 output_asm_insn (\"crxor 6,6,6\", operands);
10202 else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
10203 output_asm_insn (\"creqv 6,6,6\", operands);
10205 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"b %z1@local\" : \"b %z1\";
10207 [(set_attr "type" "branch")
10208 (set_attr "length" "4,8")])
10211 (define_insn "*sibcall_value_local64"
10212 [(set (match_operand 0 "" "")
10213 (call (mem:SI (match_operand:DI 1 "current_file_function_operand" "s,s"))
10214 (match_operand 2 "" "g,g")))
10215 (use (match_operand:SI 3 "immediate_operand" "O,n"))
10216 (use (match_operand:SI 4 "register_operand" "l,l"))
10218 "TARGET_64BIT && (INTVAL (operands[3]) & CALL_LONG) == 0"
10221 if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
10222 output_asm_insn (\"crxor 6,6,6\", operands);
10224 else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
10225 output_asm_insn (\"creqv 6,6,6\", operands);
10227 return (DEFAULT_ABI == ABI_V4 && flag_pic) ? \"b %z1@local\" : \"b %z1\";
10229 [(set_attr "type" "branch")
10230 (set_attr "length" "4,8")])
10232 (define_insn "*sibcall_nonlocal_aix32"
10233 [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "s"))
10234 (match_operand 1 "" "g"))
10235 (use (match_operand:SI 2 "immediate_operand" "O"))
10236 (use (match_operand:SI 3 "register_operand" "l"))
10239 && DEFAULT_ABI == ABI_AIX
10240 && (INTVAL (operands[2]) & CALL_LONG) == 0"
10242 [(set_attr "type" "branch")
10243 (set_attr "length" "4")])
10245 (define_insn "*sibcall_nonlocal_aix64"
10246 [(call (mem:SI (match_operand:DI 0 "symbol_ref_operand" "s"))
10247 (match_operand 1 "" "g"))
10248 (use (match_operand:SI 2 "immediate_operand" "O"))
10249 (use (match_operand:SI 3 "register_operand" "l"))
10252 && DEFAULT_ABI == ABI_AIX
10253 && (INTVAL (operands[2]) & CALL_LONG) == 0"
10255 [(set_attr "type" "branch")
10256 (set_attr "length" "4")])
10258 (define_insn "*sibcall_value_nonlocal_aix32"
10259 [(set (match_operand 0 "" "")
10260 (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "s"))
10261 (match_operand 2 "" "g")))
10262 (use (match_operand:SI 3 "immediate_operand" "O"))
10263 (use (match_operand:SI 4 "register_operand" "l"))
10266 && DEFAULT_ABI == ABI_AIX
10267 && (INTVAL (operands[3]) & CALL_LONG) == 0"
10269 [(set_attr "type" "branch")
10270 (set_attr "length" "4")])
10272 (define_insn "*sibcall_value_nonlocal_aix64"
10273 [(set (match_operand 0 "" "")
10274 (call (mem:SI (match_operand:DI 1 "symbol_ref_operand" "s"))
10275 (match_operand 2 "" "g")))
10276 (use (match_operand:SI 3 "immediate_operand" "O"))
10277 (use (match_operand:SI 4 "register_operand" "l"))
10280 && DEFAULT_ABI == ABI_AIX
10281 && (INTVAL (operands[3]) & CALL_LONG) == 0"
10283 [(set_attr "type" "branch")
10284 (set_attr "length" "4")])
10286 (define_insn "*sibcall_nonlocal_sysv"
10287 [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "s,s"))
10288 (match_operand 1 "" ""))
10289 (use (match_operand 2 "immediate_operand" "O,n"))
10290 (use (match_operand:SI 3 "register_operand" "l,l"))
10292 "(DEFAULT_ABI == ABI_DARWIN
10293 || DEFAULT_ABI == ABI_V4)
10294 && (INTVAL (operands[2]) & CALL_LONG) == 0"
10297 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
10298 output_asm_insn (\"crxor 6,6,6\", operands);
10300 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
10301 output_asm_insn (\"creqv 6,6,6\", operands);
10303 if (DEFAULT_ABI == ABI_V4 && flag_pic)
10305 if (TARGET_SECURE_PLT && flag_pic == 2)
10306 return \"b %z0+32768@plt\";
10308 return \"b %z0@plt\";
10313 [(set_attr "type" "branch,branch")
10314 (set_attr "length" "4,8")])
10316 (define_expand "sibcall_value"
10317 [(parallel [(set (match_operand 0 "register_operand" "")
10318 (call (mem:SI (match_operand 1 "address_operand" ""))
10319 (match_operand 2 "" "")))
10320 (use (match_operand 3 "" ""))
10321 (use (match_operand 4 "" ""))
10327 if (MACHOPIC_INDIRECT)
10328 operands[1] = machopic_indirect_call_target (operands[1]);
10331 gcc_assert (GET_CODE (operands[1]) == MEM);
10332 gcc_assert (GET_CODE (operands[2]) == CONST_INT);
10334 operands[1] = XEXP (operands[1], 0);
10335 operands[4] = gen_reg_rtx (SImode);
10339 (define_insn "*sibcall_value_nonlocal_sysv"
10340 [(set (match_operand 0 "" "")
10341 (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "s,s"))
10342 (match_operand 2 "" "")))
10343 (use (match_operand:SI 3 "immediate_operand" "O,n"))
10344 (use (match_operand:SI 4 "register_operand" "l,l"))
10346 "(DEFAULT_ABI == ABI_DARWIN
10347 || DEFAULT_ABI == ABI_V4)
10348 && (INTVAL (operands[3]) & CALL_LONG) == 0"
10351 if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
10352 output_asm_insn (\"crxor 6,6,6\", operands);
10354 else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
10355 output_asm_insn (\"creqv 6,6,6\", operands);
10357 if (DEFAULT_ABI == ABI_V4 && flag_pic)
10359 if (TARGET_SECURE_PLT && flag_pic == 2)
10360 return \"b %z1+32768@plt\";
10362 return \"b %z1@plt\";
10367 [(set_attr "type" "branch,branch")
10368 (set_attr "length" "4,8")])
10370 (define_expand "sibcall_epilogue"
10371 [(use (const_int 0))]
10372 "TARGET_SCHED_PROLOG"
10375 rs6000_emit_epilogue (TRUE);
10379 ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
10380 ;; all of memory. This blocks insns from being moved across this point.
10382 (define_insn "blockage"
10383 [(unspec_volatile [(const_int 0)] UNSPECV_BLOCK)]
10387 ;; Compare insns are next. Note that the RS/6000 has two types of compares,
10388 ;; signed & unsigned, and one type of branch.
10390 ;; Start with the DEFINE_EXPANDs to generate the rtl for compares, scc
10391 ;; insns, and branches. We store the operands of compares until we see
10393 (define_expand "cmp<mode>"
10395 (compare (match_operand:GPR 0 "gpc_reg_operand" "")
10396 (match_operand:GPR 1 "reg_or_short_operand" "")))]
10400 /* Take care of the possibility that operands[1] might be negative but
10401 this might be a logical operation. That insn doesn't exist. */
10402 if (GET_CODE (operands[1]) == CONST_INT
10403 && INTVAL (operands[1]) < 0)
10404 operands[1] = force_reg (<MODE>mode, operands[1]);
10406 rs6000_compare_op0 = operands[0];
10407 rs6000_compare_op1 = operands[1];
10408 rs6000_compare_fp_p = 0;
10412 (define_expand "cmp<mode>"
10413 [(set (cc0) (compare (match_operand:FP 0 "gpc_reg_operand" "")
10414 (match_operand:FP 1 "gpc_reg_operand" "")))]
10418 rs6000_compare_op0 = operands[0];
10419 rs6000_compare_op1 = operands[1];
10420 rs6000_compare_fp_p = 1;
10424 (define_expand "beq"
10425 [(use (match_operand 0 "" ""))]
10427 "{ rs6000_emit_cbranch (EQ, operands[0]); DONE; }")
10429 (define_expand "bne"
10430 [(use (match_operand 0 "" ""))]
10432 "{ rs6000_emit_cbranch (NE, operands[0]); DONE; }")
10434 (define_expand "bge"
10435 [(use (match_operand 0 "" ""))]
10437 "{ rs6000_emit_cbranch (GE, operands[0]); DONE; }")
10439 (define_expand "bgt"
10440 [(use (match_operand 0 "" ""))]
10442 "{ rs6000_emit_cbranch (GT, operands[0]); DONE; }")
10444 (define_expand "ble"
10445 [(use (match_operand 0 "" ""))]
10447 "{ rs6000_emit_cbranch (LE, operands[0]); DONE; }")
10449 (define_expand "blt"
10450 [(use (match_operand 0 "" ""))]
10452 "{ rs6000_emit_cbranch (LT, operands[0]); DONE; }")
10454 (define_expand "bgeu"
10455 [(use (match_operand 0 "" ""))]
10457 "{ rs6000_emit_cbranch (GEU, operands[0]); DONE; }")
10459 (define_expand "bgtu"
10460 [(use (match_operand 0 "" ""))]
10462 "{ rs6000_emit_cbranch (GTU, operands[0]); DONE; }")
10464 (define_expand "bleu"
10465 [(use (match_operand 0 "" ""))]
10467 "{ rs6000_emit_cbranch (LEU, operands[0]); DONE; }")
10469 (define_expand "bltu"
10470 [(use (match_operand 0 "" ""))]
10472 "{ rs6000_emit_cbranch (LTU, operands[0]); DONE; }")
10474 (define_expand "bunordered"
10475 [(use (match_operand 0 "" ""))]
10476 "! (TARGET_HARD_FLOAT && TARGET_E500 && !TARGET_FPRS)"
10477 "{ rs6000_emit_cbranch (UNORDERED, operands[0]); DONE; }")
10479 (define_expand "bordered"
10480 [(use (match_operand 0 "" ""))]
10481 "! (TARGET_HARD_FLOAT && TARGET_E500 && !TARGET_FPRS)"
10482 "{ rs6000_emit_cbranch (ORDERED, operands[0]); DONE; }")
10484 (define_expand "buneq"
10485 [(use (match_operand 0 "" ""))]
10487 "{ rs6000_emit_cbranch (UNEQ, operands[0]); DONE; }")
10489 (define_expand "bunge"
10490 [(use (match_operand 0 "" ""))]
10492 "{ rs6000_emit_cbranch (UNGE, operands[0]); DONE; }")
10494 (define_expand "bungt"
10495 [(use (match_operand 0 "" ""))]
10497 "{ rs6000_emit_cbranch (UNGT, operands[0]); DONE; }")
10499 (define_expand "bunle"
10500 [(use (match_operand 0 "" ""))]
10502 "{ rs6000_emit_cbranch (UNLE, operands[0]); DONE; }")
10504 (define_expand "bunlt"
10505 [(use (match_operand 0 "" ""))]
10507 "{ rs6000_emit_cbranch (UNLT, operands[0]); DONE; }")
10509 (define_expand "bltgt"
10510 [(use (match_operand 0 "" ""))]
10512 "{ rs6000_emit_cbranch (LTGT, operands[0]); DONE; }")
10514 ;; For SNE, we would prefer that the xor/abs sequence be used for integers.
10515 ;; For SEQ, likewise, except that comparisons with zero should be done
10516 ;; with an scc insns. However, due to the order that combine see the
10517 ;; resulting insns, we must, in fact, allow SEQ for integers. Fail in
10518 ;; the cases we don't want to handle.
10519 (define_expand "seq"
10520 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10522 "{ rs6000_emit_sCOND (EQ, operands[0]); DONE; }")
10524 (define_expand "sne"
10525 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10529 if (! rs6000_compare_fp_p)
10532 rs6000_emit_sCOND (NE, operands[0]);
10536 ;; A >= 0 is best done the portable way for A an integer.
10537 (define_expand "sge"
10538 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10542 if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
10545 rs6000_emit_sCOND (GE, operands[0]);
10549 ;; A > 0 is best done using the portable sequence, so fail in that case.
10550 (define_expand "sgt"
10551 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10555 if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
10558 rs6000_emit_sCOND (GT, operands[0]);
10562 ;; A <= 0 is best done the portable way for A an integer.
10563 (define_expand "sle"
10564 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10568 if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
10571 rs6000_emit_sCOND (LE, operands[0]);
10575 ;; A < 0 is best done in the portable way for A an integer.
10576 (define_expand "slt"
10577 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10581 if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
10584 rs6000_emit_sCOND (LT, operands[0]);
10588 (define_expand "sgeu"
10589 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10591 "{ rs6000_emit_sCOND (GEU, operands[0]); DONE; }")
10593 (define_expand "sgtu"
10594 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10596 "{ rs6000_emit_sCOND (GTU, operands[0]); DONE; }")
10598 (define_expand "sleu"
10599 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10601 "{ rs6000_emit_sCOND (LEU, operands[0]); DONE; }")
10603 (define_expand "sltu"
10604 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10606 "{ rs6000_emit_sCOND (LTU, operands[0]); DONE; }")
10608 (define_expand "sunordered"
10609 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10610 "! (TARGET_HARD_FLOAT && TARGET_E500 && !TARGET_FPRS)"
10611 "{ rs6000_emit_sCOND (UNORDERED, operands[0]); DONE; }")
10613 (define_expand "sordered"
10614 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10615 "! (TARGET_HARD_FLOAT && TARGET_E500 && !TARGET_FPRS)"
10616 "{ rs6000_emit_sCOND (ORDERED, operands[0]); DONE; }")
10618 (define_expand "suneq"
10619 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10621 "{ rs6000_emit_sCOND (UNEQ, operands[0]); DONE; }")
10623 (define_expand "sunge"
10624 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10626 "{ rs6000_emit_sCOND (UNGE, operands[0]); DONE; }")
10628 (define_expand "sungt"
10629 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10631 "{ rs6000_emit_sCOND (UNGT, operands[0]); DONE; }")
10633 (define_expand "sunle"
10634 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10636 "{ rs6000_emit_sCOND (UNLE, operands[0]); DONE; }")
10638 (define_expand "sunlt"
10639 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10641 "{ rs6000_emit_sCOND (UNLT, operands[0]); DONE; }")
10643 (define_expand "sltgt"
10644 [(clobber (match_operand:SI 0 "gpc_reg_operand" ""))]
10646 "{ rs6000_emit_sCOND (LTGT, operands[0]); DONE; }")
10648 (define_expand "stack_protect_set"
10649 [(match_operand 0 "memory_operand" "")
10650 (match_operand 1 "memory_operand" "")]
10653 #ifdef TARGET_THREAD_SSP_OFFSET
10654 rtx tlsreg = gen_rtx_REG (Pmode, TARGET_64BIT ? 13 : 2);
10655 rtx addr = gen_rtx_PLUS (Pmode, tlsreg, GEN_INT (TARGET_THREAD_SSP_OFFSET));
10656 operands[1] = gen_rtx_MEM (Pmode, addr);
10659 emit_insn (gen_stack_protect_setdi (operands[0], operands[1]));
10661 emit_insn (gen_stack_protect_setsi (operands[0], operands[1]));
10665 (define_insn "stack_protect_setsi"
10666 [(set (match_operand:SI 0 "memory_operand" "=m")
10667 (unspec:SI [(match_operand:SI 1 "memory_operand" "m")] UNSPEC_SP_SET))
10668 (set (match_scratch:SI 2 "=&r") (const_int 0))]
10670 "{l%U1%X1|lwz%U1%X1} %2,%1\;{st%U0%X0|stw%U0%X0} %2,%0\;{lil|li} %2,0"
10671 [(set_attr "type" "three")
10672 (set_attr "length" "12")])
10674 (define_insn "stack_protect_setdi"
10675 [(set (match_operand:DI 0 "memory_operand" "=m")
10676 (unspec:DI [(match_operand:DI 1 "memory_operand" "m")] UNSPEC_SP_SET))
10677 (set (match_scratch:DI 2 "=&r") (const_int 0))]
10679 "ld%U1%X1 %2,%1\;std%U0%X0 %2,%0\;{lil|li} %2,0"
10680 [(set_attr "type" "three")
10681 (set_attr "length" "12")])
10683 (define_expand "stack_protect_test"
10684 [(match_operand 0 "memory_operand" "")
10685 (match_operand 1 "memory_operand" "")
10686 (match_operand 2 "" "")]
10689 #ifdef TARGET_THREAD_SSP_OFFSET
10690 rtx tlsreg = gen_rtx_REG (Pmode, TARGET_64BIT ? 13 : 2);
10691 rtx addr = gen_rtx_PLUS (Pmode, tlsreg, GEN_INT (TARGET_THREAD_SSP_OFFSET));
10692 operands[1] = gen_rtx_MEM (Pmode, addr);
10694 rs6000_compare_op0 = operands[0];
10695 rs6000_compare_op1 = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, operands[1]),
10697 rs6000_compare_fp_p = 0;
10698 emit_jump_insn (gen_beq (operands[2]));
10702 (define_insn "stack_protect_testsi"
10703 [(set (match_operand:CCEQ 0 "cc_reg_operand" "=x,?y")
10704 (unspec:CCEQ [(match_operand:SI 1 "memory_operand" "m,m")
10705 (match_operand:SI 2 "memory_operand" "m,m")]
10707 (set (match_scratch:SI 4 "=r,r") (const_int 0))
10708 (clobber (match_scratch:SI 3 "=&r,&r"))]
10711 {l%U1%X1|lwz%U1%X1} %3,%1\;{l%U2%X2|lwz%U2%X2} %4,%2\;xor. %3,%3,%4\;{lil|li} %4,0
10712 {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"
10713 [(set_attr "length" "16,20")])
10715 (define_insn "stack_protect_testdi"
10716 [(set (match_operand:CCEQ 0 "cc_reg_operand" "=x,?y")
10717 (unspec:CCEQ [(match_operand:DI 1 "memory_operand" "m,m")
10718 (match_operand:DI 2 "memory_operand" "m,m")]
10720 (set (match_scratch:DI 4 "=r,r") (const_int 0))
10721 (clobber (match_scratch:DI 3 "=&r,&r"))]
10724 ld%U1%X1 %3,%1\;ld%U2%X2 %4,%2\;xor. %3,%3,%4\;{lil|li} %4,0
10725 ld%U1%X1 %3,%1\;ld%U2%X2 %4,%2\;cmpld %0,%3,%4\;{lil|li} %3,0\;{lil|li} %4,0"
10726 [(set_attr "length" "16,20")])
10729 ;; Here are the actual compare insns.
10730 (define_insn "*cmp<mode>_internal1"
10731 [(set (match_operand:CC 0 "cc_reg_operand" "=y")
10732 (compare:CC (match_operand:GPR 1 "gpc_reg_operand" "r")
10733 (match_operand:GPR 2 "reg_or_short_operand" "rI")))]
10735 "{cmp%I2|cmp<wd>%I2} %0,%1,%2"
10736 [(set_attr "type" "cmp")])
10738 ;; If we are comparing a register for equality with a large constant,
10739 ;; we can do this with an XOR followed by a compare. But this is profitable
10740 ;; only if the large constant is only used for the comparison (and in this
10741 ;; case we already have a register to reuse as scratch).
10743 ;; For 64-bit registers, we could only do so if the constant's bit 15 is clear:
10744 ;; otherwise we'd need to XOR with FFFFFFFF????0000 which is not available.
10747 [(set (match_operand:SI 0 "register_operand")
10748 (match_operand:SI 1 "logical_operand" ""))
10749 (set (match_dup 0) (match_operator:SI 3 "boolean_or_operator"
10751 (match_operand:SI 2 "logical_operand" "")]))
10752 (set (match_operand:CC 4 "cc_reg_operand" "")
10753 (compare:CC (match_operand:SI 5 "gpc_reg_operand" "")
10756 (if_then_else (match_operator 6 "equality_operator"
10757 [(match_dup 4) (const_int 0)])
10758 (match_operand 7 "" "")
10759 (match_operand 8 "" "")))]
10760 "peep2_reg_dead_p (3, operands[0])
10761 && peep2_reg_dead_p (4, operands[4])"
10762 [(set (match_dup 0) (xor:SI (match_dup 5) (match_dup 9)))
10763 (set (match_dup 4) (compare:CC (match_dup 0) (match_dup 10)))
10764 (set (pc) (if_then_else (match_dup 6) (match_dup 7) (match_dup 8)))]
10767 /* Get the constant we are comparing against, and see what it looks like
10768 when sign-extended from 16 to 32 bits. Then see what constant we could
10769 XOR with SEXTC to get the sign-extended value. */
10770 rtx cnst = simplify_const_binary_operation (GET_CODE (operands[3]),
10772 operands[1], operands[2]);
10773 HOST_WIDE_INT c = INTVAL (cnst);
10774 HOST_WIDE_INT sextc = ((c & 0xffff) ^ 0x8000) - 0x8000;
10775 HOST_WIDE_INT xorv = c ^ sextc;
10777 operands[9] = GEN_INT (xorv);
10778 operands[10] = GEN_INT (sextc);
10781 (define_insn "*cmpsi_internal2"
10782 [(set (match_operand:CCUNS 0 "cc_reg_operand" "=y")
10783 (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "r")
10784 (match_operand:SI 2 "reg_or_u_short_operand" "rK")))]
10786 "{cmpl%I2|cmplw%I2} %0,%1,%b2"
10787 [(set_attr "type" "cmp")])
10789 (define_insn "*cmpdi_internal2"
10790 [(set (match_operand:CCUNS 0 "cc_reg_operand" "=y")
10791 (compare:CCUNS (match_operand:DI 1 "gpc_reg_operand" "r")
10792 (match_operand:DI 2 "reg_or_u_short_operand" "rK")))]
10794 "cmpld%I2 %0,%1,%b2"
10795 [(set_attr "type" "cmp")])
10797 ;; The following two insns don't exist as single insns, but if we provide
10798 ;; them, we can swap an add and compare, which will enable us to overlap more
10799 ;; of the required delay between a compare and branch. We generate code for
10800 ;; them by splitting.
10803 [(set (match_operand:CC 3 "cc_reg_operand" "=y")
10804 (compare:CC (match_operand:SI 1 "gpc_reg_operand" "r")
10805 (match_operand:SI 2 "short_cint_operand" "i")))
10806 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
10807 (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "i")))]
10810 [(set_attr "length" "8")])
10813 [(set (match_operand:CCUNS 3 "cc_reg_operand" "=y")
10814 (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "r")
10815 (match_operand:SI 2 "u_short_cint_operand" "i")))
10816 (set (match_operand:SI 0 "gpc_reg_operand" "=r")
10817 (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "i")))]
10820 [(set_attr "length" "8")])
10823 [(set (match_operand:CC 3 "cc_reg_operand" "")
10824 (compare:CC (match_operand:SI 1 "gpc_reg_operand" "")
10825 (match_operand:SI 2 "short_cint_operand" "")))
10826 (set (match_operand:SI 0 "gpc_reg_operand" "")
10827 (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "")))]
10829 [(set (match_dup 3) (compare:CC (match_dup 1) (match_dup 2)))
10830 (set (match_dup 0) (plus:SI (match_dup 1) (match_dup 4)))])
10833 [(set (match_operand:CCUNS 3 "cc_reg_operand" "")
10834 (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "")
10835 (match_operand:SI 2 "u_short_cint_operand" "")))
10836 (set (match_operand:SI 0 "gpc_reg_operand" "")
10837 (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "")))]
10839 [(set (match_dup 3) (compare:CCUNS (match_dup 1) (match_dup 2)))
10840 (set (match_dup 0) (plus:SI (match_dup 1) (match_dup 4)))])
10842 (define_insn "*cmpsf_internal1"
10843 [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
10844 (compare:CCFP (match_operand:SF 1 "gpc_reg_operand" "f")
10845 (match_operand:SF 2 "gpc_reg_operand" "f")))]
10846 "TARGET_HARD_FLOAT && TARGET_FPRS"
10848 [(set_attr "type" "fpcompare")])
10850 (define_insn "*cmpdf_internal1"
10851 [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
10852 (compare:CCFP (match_operand:DF 1 "gpc_reg_operand" "f")
10853 (match_operand:DF 2 "gpc_reg_operand" "f")))]
10854 "TARGET_HARD_FLOAT && TARGET_FPRS"
10856 [(set_attr "type" "fpcompare")])
10858 ;; Only need to compare second words if first words equal
10859 (define_insn "*cmptf_internal1"
10860 [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
10861 (compare:CCFP (match_operand:TF 1 "gpc_reg_operand" "f")
10862 (match_operand:TF 2 "gpc_reg_operand" "f")))]
10863 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN) && !TARGET_XL_COMPAT
10864 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
10865 "fcmpu %0,%1,%2\;bne %0,$+8\;fcmpu %0,%L1,%L2"
10866 [(set_attr "type" "fpcompare")
10867 (set_attr "length" "12")])
10869 (define_insn_and_split "*cmptf_internal2"
10870 [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
10871 (compare:CCFP (match_operand:TF 1 "gpc_reg_operand" "f")
10872 (match_operand:TF 2 "gpc_reg_operand" "f")))
10873 (clobber (match_scratch:DF 3 "=f"))
10874 (clobber (match_scratch:DF 4 "=f"))
10875 (clobber (match_scratch:DF 5 "=f"))
10876 (clobber (match_scratch:DF 6 "=f"))
10877 (clobber (match_scratch:DF 7 "=f"))
10878 (clobber (match_scratch:DF 8 "=f"))
10879 (clobber (match_scratch:DF 9 "=f"))
10880 (clobber (match_scratch:DF 10 "=f"))]
10881 "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN) && TARGET_XL_COMPAT
10882 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
10884 "&& reload_completed"
10885 [(set (match_dup 3) (match_dup 13))
10886 (set (match_dup 4) (match_dup 14))
10887 (set (match_dup 9) (abs:DF (match_dup 5)))
10888 (set (match_dup 0) (compare:CCFP (match_dup 9) (match_dup 3)))
10889 (set (pc) (if_then_else (ne (match_dup 0) (const_int 0))
10890 (label_ref (match_dup 11))
10892 (set (match_dup 0) (compare:CCFP (match_dup 5) (match_dup 7)))
10893 (set (pc) (label_ref (match_dup 12)))
10895 (set (match_dup 10) (minus:DF (match_dup 5) (match_dup 7)))
10896 (set (match_dup 9) (minus:DF (match_dup 6) (match_dup 8)))
10897 (set (match_dup 9) (plus:DF (match_dup 10) (match_dup 9)))
10898 (set (match_dup 0) (compare:CCFP (match_dup 7) (match_dup 4)))
10901 REAL_VALUE_TYPE rv;
10902 const int lo_word = FLOAT_WORDS_BIG_ENDIAN ? GET_MODE_SIZE (DFmode) : 0;
10903 const int hi_word = FLOAT_WORDS_BIG_ENDIAN ? 0 : GET_MODE_SIZE (DFmode);
10905 operands[5] = simplify_gen_subreg (DFmode, operands[1], TFmode, hi_word);
10906 operands[6] = simplify_gen_subreg (DFmode, operands[1], TFmode, lo_word);
10907 operands[7] = simplify_gen_subreg (DFmode, operands[2], TFmode, hi_word);
10908 operands[8] = simplify_gen_subreg (DFmode, operands[2], TFmode, lo_word);
10909 operands[11] = gen_label_rtx ();
10910 operands[12] = gen_label_rtx ();
10912 operands[13] = force_const_mem (DFmode,
10913 CONST_DOUBLE_FROM_REAL_VALUE (rv, DFmode));
10914 operands[14] = force_const_mem (DFmode,
10915 CONST_DOUBLE_FROM_REAL_VALUE (dconst0,
10919 operands[13] = gen_const_mem (DFmode,
10920 create_TOC_reference (XEXP (operands[13], 0)));
10921 operands[14] = gen_const_mem (DFmode,
10922 create_TOC_reference (XEXP (operands[14], 0)));
10923 set_mem_alias_set (operands[13], get_TOC_alias_set ());
10924 set_mem_alias_set (operands[14], get_TOC_alias_set ());
10928 ;; Now we have the scc insns. We can do some combinations because of the
10929 ;; way the machine works.
10931 ;; Note that this is probably faster if we can put an insn between the
10932 ;; mfcr and rlinm, but this is tricky. Let's leave it for now. In most
10933 ;; cases the insns below which don't use an intermediate CR field will
10934 ;; be used instead.
10936 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
10937 (match_operator:SI 1 "scc_comparison_operator"
10938 [(match_operand 2 "cc_reg_operand" "y")
10941 "mfcr %0%Q2\;{rlinm|rlwinm} %0,%0,%J1,1"
10942 [(set (attr "type")
10943 (cond [(ne (symbol_ref "TARGET_MFCRF") (const_int 0))
10944 (const_string "mfcrf")
10946 (const_string "mfcr")))
10947 (set_attr "length" "8")])
10949 ;; Same as above, but get the GT bit.
10950 (define_insn "move_from_CR_gt_bit"
10951 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
10952 (unspec:SI [(match_operand 1 "cc_reg_operand" "y")] UNSPEC_MV_CR_GT))]
10954 "mfcr %0\;{rlinm|rlwinm} %0,%0,%D1,31,31"
10955 [(set_attr "type" "mfcr")
10956 (set_attr "length" "8")])
10958 ;; Same as above, but get the OV/ORDERED bit.
10959 (define_insn "move_from_CR_ov_bit"
10960 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
10961 (unspec:SI [(match_operand 1 "cc_reg_operand" "y")] UNSPEC_MV_CR_OV))]
10963 "mfcr %0\;{rlinm|rlwinm} %0,%0,%t1,1"
10964 [(set_attr "type" "mfcr")
10965 (set_attr "length" "8")])
10968 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
10969 (match_operator:DI 1 "scc_comparison_operator"
10970 [(match_operand 2 "cc_reg_operand" "y")
10973 "mfcr %0%Q2\;{rlinm|rlwinm} %0,%0,%J1,1"
10974 [(set (attr "type")
10975 (cond [(ne (symbol_ref "TARGET_MFCRF") (const_int 0))
10976 (const_string "mfcrf")
10978 (const_string "mfcr")))
10979 (set_attr "length" "8")])
10982 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
10983 (compare:CC (match_operator:SI 1 "scc_comparison_operator"
10984 [(match_operand 2 "cc_reg_operand" "y,y")
10987 (set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
10988 (match_op_dup 1 [(match_dup 2) (const_int 0)]))]
10991 mfcr %3%Q2\;{rlinm.|rlwinm.} %3,%3,%J1,1
10993 [(set_attr "type" "delayed_compare")
10994 (set_attr "length" "8,16")])
10997 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
10998 (compare:CC (match_operator:SI 1 "scc_comparison_operator"
10999 [(match_operand 2 "cc_reg_operand" "")
11002 (set (match_operand:SI 3 "gpc_reg_operand" "")
11003 (match_op_dup 1 [(match_dup 2) (const_int 0)]))]
11004 "TARGET_32BIT && reload_completed"
11005 [(set (match_dup 3)
11006 (match_op_dup 1 [(match_dup 2) (const_int 0)]))
11008 (compare:CC (match_dup 3)
11013 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
11014 (ashift:SI (match_operator:SI 1 "scc_comparison_operator"
11015 [(match_operand 2 "cc_reg_operand" "y")
11017 (match_operand:SI 3 "const_int_operand" "n")))]
11021 int is_bit = ccr_bit (operands[1], 1);
11022 int put_bit = 31 - (INTVAL (operands[3]) & 31);
11025 if (is_bit >= put_bit)
11026 count = is_bit - put_bit;
11028 count = 32 - (put_bit - is_bit);
11030 operands[4] = GEN_INT (count);
11031 operands[5] = GEN_INT (put_bit);
11033 return \"mfcr %0%Q2\;{rlinm|rlwinm} %0,%0,%4,%5,%5\";
11035 [(set (attr "type")
11036 (cond [(ne (symbol_ref "TARGET_MFCRF") (const_int 0))
11037 (const_string "mfcrf")
11039 (const_string "mfcr")))
11040 (set_attr "length" "8")])
11043 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
11045 (ashift:SI (match_operator:SI 1 "scc_comparison_operator"
11046 [(match_operand 2 "cc_reg_operand" "y,y")
11048 (match_operand:SI 3 "const_int_operand" "n,n"))
11050 (set (match_operand:SI 4 "gpc_reg_operand" "=r,r")
11051 (ashift:SI (match_op_dup 1 [(match_dup 2) (const_int 0)])
11056 int is_bit = ccr_bit (operands[1], 1);
11057 int put_bit = 31 - (INTVAL (operands[3]) & 31);
11060 /* Force split for non-cc0 compare. */
11061 if (which_alternative == 1)
11064 if (is_bit >= put_bit)
11065 count = is_bit - put_bit;
11067 count = 32 - (put_bit - is_bit);
11069 operands[5] = GEN_INT (count);
11070 operands[6] = GEN_INT (put_bit);
11072 return \"mfcr %4%Q2\;{rlinm.|rlwinm.} %4,%4,%5,%6,%6\";
11074 [(set_attr "type" "delayed_compare")
11075 (set_attr "length" "8,16")])
11078 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
11080 (ashift:SI (match_operator:SI 1 "scc_comparison_operator"
11081 [(match_operand 2 "cc_reg_operand" "")
11083 (match_operand:SI 3 "const_int_operand" ""))
11085 (set (match_operand:SI 4 "gpc_reg_operand" "")
11086 (ashift:SI (match_op_dup 1 [(match_dup 2) (const_int 0)])
11089 [(set (match_dup 4)
11090 (ashift:SI (match_op_dup 1 [(match_dup 2) (const_int 0)])
11093 (compare:CC (match_dup 4)
11097 ;; There is a 3 cycle delay between consecutive mfcr instructions
11098 ;; so it is useful to combine 2 scc instructions to use only one mfcr.
11101 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
11102 (match_operator:SI 1 "scc_comparison_operator"
11103 [(match_operand 2 "cc_reg_operand" "y")
11105 (set (match_operand:SI 3 "gpc_reg_operand" "=r")
11106 (match_operator:SI 4 "scc_comparison_operator"
11107 [(match_operand 5 "cc_reg_operand" "y")
11109 "REGNO (operands[2]) != REGNO (operands[5])"
11110 "mfcr %3\;{rlinm|rlwinm} %0,%3,%J1,1\;{rlinm|rlwinm} %3,%3,%J4,1"
11111 [(set_attr "type" "mfcr")
11112 (set_attr "length" "12")])
11115 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
11116 (match_operator:DI 1 "scc_comparison_operator"
11117 [(match_operand 2 "cc_reg_operand" "y")
11119 (set (match_operand:DI 3 "gpc_reg_operand" "=r")
11120 (match_operator:DI 4 "scc_comparison_operator"
11121 [(match_operand 5 "cc_reg_operand" "y")
11123 "TARGET_POWERPC64 && REGNO (operands[2]) != REGNO (operands[5])"
11124 "mfcr %3\;{rlinm|rlwinm} %0,%3,%J1,1\;{rlinm|rlwinm} %3,%3,%J4,1"
11125 [(set_attr "type" "mfcr")
11126 (set_attr "length" "12")])
11128 ;; There are some scc insns that can be done directly, without a compare.
11129 ;; These are faster because they don't involve the communications between
11130 ;; the FXU and branch units. In fact, we will be replacing all of the
11131 ;; integer scc insns here or in the portable methods in emit_store_flag.
11133 ;; Also support (neg (scc ..)) since that construct is used to replace
11134 ;; branches, (plus (scc ..) ..) since that construct is common and
11135 ;; takes no more insns than scc, and (and (neg (scc ..)) ..) in the
11136 ;; cases where it is no more expensive than (neg (scc ..)).
11138 ;; Have reload force a constant into a register for the simple insns that
11139 ;; otherwise won't accept constants. We do this because it is faster than
11140 ;; the cmp/mfcr sequence we would otherwise generate.
11142 (define_mode_attr scc_eq_op2 [(SI "rKLI")
11145 (define_insn_and_split "*eq<mode>"
11146 [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
11147 (eq:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")
11148 (match_operand:GPR 2 "scc_eq_operand" "<scc_eq_op2>")))]
11152 [(set (match_dup 0)
11153 (clz:GPR (match_dup 3)))
11155 (lshiftrt:GPR (match_dup 0) (match_dup 4)))]
11157 if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) != 0)
11159 /* Use output operand as intermediate. */
11160 operands[3] = operands[0];
11162 if (logical_operand (operands[2], <MODE>mode))
11163 emit_insn (gen_rtx_SET (VOIDmode, operands[3],
11164 gen_rtx_XOR (<MODE>mode,
11165 operands[1], operands[2])));
11167 emit_insn (gen_rtx_SET (VOIDmode, operands[3],
11168 gen_rtx_PLUS (<MODE>mode, operands[1],
11169 negate_rtx (<MODE>mode,
11173 operands[3] = operands[1];
11175 operands[4] = GEN_INT (exact_log2 (GET_MODE_BITSIZE (<MODE>mode)));
11178 (define_insn_and_split "*eq<mode>_compare"
11179 [(set (match_operand:CC 3 "cc_reg_operand" "=y")
11181 (eq:P (match_operand:P 1 "gpc_reg_operand" "=r")
11182 (match_operand:P 2 "scc_eq_operand" "<scc_eq_op2>"))
11184 (set (match_operand:P 0 "gpc_reg_operand" "=r")
11185 (eq:P (match_dup 1) (match_dup 2)))]
11189 [(set (match_dup 0)
11190 (clz:P (match_dup 4)))
11191 (parallel [(set (match_dup 3)
11192 (compare:CC (lshiftrt:P (match_dup 0) (match_dup 5))
11195 (lshiftrt:P (match_dup 0) (match_dup 5)))])]
11197 if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) != 0)
11199 /* Use output operand as intermediate. */
11200 operands[4] = operands[0];
11202 if (logical_operand (operands[2], <MODE>mode))
11203 emit_insn (gen_rtx_SET (VOIDmode, operands[4],
11204 gen_rtx_XOR (<MODE>mode,
11205 operands[1], operands[2])));
11207 emit_insn (gen_rtx_SET (VOIDmode, operands[4],
11208 gen_rtx_PLUS (<MODE>mode, operands[1],
11209 negate_rtx (<MODE>mode,
11213 operands[4] = operands[1];
11215 operands[5] = GEN_INT (exact_log2 (GET_MODE_BITSIZE (<MODE>mode)));
11218 ;; We have insns of the form shown by the first define_insn below. If
11219 ;; there is something inside the comparison operation, we must split it.
11221 [(set (match_operand:SI 0 "gpc_reg_operand" "")
11222 (plus:SI (match_operator 1 "comparison_operator"
11223 [(match_operand:SI 2 "" "")
11224 (match_operand:SI 3
11225 "reg_or_cint_operand" "")])
11226 (match_operand:SI 4 "gpc_reg_operand" "")))
11227 (clobber (match_operand:SI 5 "register_operand" ""))]
11228 "! gpc_reg_operand (operands[2], SImode)"
11229 [(set (match_dup 5) (match_dup 2))
11230 (set (match_dup 2) (plus:SI (match_op_dup 1 [(match_dup 2) (match_dup 3)])
11233 (define_insn "*plus_eqsi"
11234 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r,&r,&r,&r")
11235 (plus:SI (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
11236 (match_operand:SI 2 "scc_eq_operand" "r,O,K,L,I"))
11237 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r")))]
11238 "TARGET_32BIT && optimize_size"
11240 xor %0,%1,%2\;{sfi|subfic} %0,%0,0\;{aze|addze} %0,%3
11241 {sfi|subfic} %0,%1,0\;{aze|addze} %0,%3
11242 {xoril|xori} %0,%1,%b2\;{sfi|subfic} %0,%0,0\;{aze|addze} %0,%3
11243 {xoriu|xoris} %0,%1,%u2\;{sfi|subfic} %0,%0,0\;{aze|addze} %0,%3
11244 {sfi|subfic} %0,%1,%2\;{sfi|subfic} %0,%0,0\;{aze|addze} %0,%3"
11245 [(set_attr "type" "three,two,three,three,three")
11246 (set_attr "length" "12,8,12,12,12")])
11248 (define_insn "*compare_plus_eqsi"
11249 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,x,?y,?y,?y,?y,?y")
11252 (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r,r,r")
11253 (match_operand:SI 2 "scc_eq_operand" "r,O,K,L,I,r,O,K,L,I"))
11254 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r,r,r,r,r,r"))
11256 (clobber (match_scratch:SI 4 "=&r,&r,&r,&r,&r,&r,&r,&r,&r,&r"))]
11257 "TARGET_32BIT && optimize_size"
11259 xor %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
11260 {sfi|subfic} %4,%1,0\;{aze.|addze.} %4,%3
11261 {xoril|xori} %4,%1,%b2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
11262 {xoriu|xoris} %4,%1,%u2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
11263 {sfi|subfic} %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
11269 [(set_attr "type" "compare")
11270 (set_attr "length" "12,8,12,12,12,16,12,16,16,16")])
11273 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
11276 (eq:SI (match_operand:SI 1 "gpc_reg_operand" "")
11277 (match_operand:SI 2 "scc_eq_operand" ""))
11278 (match_operand:SI 3 "gpc_reg_operand" ""))
11280 (clobber (match_scratch:SI 4 ""))]
11281 "TARGET_32BIT && optimize_size && reload_completed"
11282 [(set (match_dup 4)
11283 (plus:SI (eq:SI (match_dup 1)
11287 (compare:CC (match_dup 4)
11291 (define_insn "*plus_eqsi_compare"
11292 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,x,x,x,?y,?y,?y,?y,?y")
11295 (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r,r,r")
11296 (match_operand:SI 2 "scc_eq_operand" "r,O,K,L,I,r,O,K,L,I"))
11297 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r,r,r,r,r,r"))
11299 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r,&r,&r,&r,&r,&r,&r,&r,&r")
11300 (plus:SI (eq:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
11301 "TARGET_32BIT && optimize_size"
11303 xor %0,%1,%2\;{sfi|subfic} %0,%0,0\;{aze.|addze.} %0,%3
11304 {sfi|subfic} %0,%1,0\;{aze.|addze.} %0,%3
11305 {xoril|xori} %0,%1,%b2\;{sfi|subfic} %0,%0,0\;{aze.|addze.} %0,%3
11306 {xoriu|xoris} %0,%1,%u2\;{sfi|subfic} %0,%0,0\;{aze.|addze.} %0,%3
11307 {sfi|subfic} %0,%1,%2\;{sfi|subfic} %0,%0,0\;{aze.|addze.} %0,%3
11313 [(set_attr "type" "compare")
11314 (set_attr "length" "12,8,12,12,12,16,12,16,16,16")])
11317 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
11320 (eq:SI (match_operand:SI 1 "gpc_reg_operand" "")
11321 (match_operand:SI 2 "scc_eq_operand" ""))
11322 (match_operand:SI 3 "gpc_reg_operand" ""))
11324 (set (match_operand:SI 0 "gpc_reg_operand" "")
11325 (plus:SI (eq:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
11326 "TARGET_32BIT && optimize_size && reload_completed"
11327 [(set (match_dup 0)
11328 (plus:SI (eq:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
11330 (compare:CC (match_dup 0)
11334 (define_insn "*neg_eq0<mode>"
11335 [(set (match_operand:P 0 "gpc_reg_operand" "=r")
11336 (neg:P (eq:P (match_operand:P 1 "gpc_reg_operand" "r")
11339 "{ai|addic} %0,%1,-1\;{sfe|subfe} %0,%0,%0"
11340 [(set_attr "type" "two")
11341 (set_attr "length" "8")])
11343 (define_insn_and_split "*neg_eq<mode>"
11344 [(set (match_operand:P 0 "gpc_reg_operand" "=r")
11345 (neg:P (eq:P (match_operand:P 1 "gpc_reg_operand" "%r")
11346 (match_operand:P 2 "scc_eq_operand" "<scc_eq_op2>"))))]
11350 [(set (match_dup 0) (neg:P (eq:P (match_dup 3) (const_int 0))))]
11352 if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) != 0)
11354 /* Use output operand as intermediate. */
11355 operands[3] = operands[0];
11357 if (logical_operand (operands[2], <MODE>mode))
11358 emit_insn (gen_rtx_SET (VOIDmode, operands[3],
11359 gen_rtx_XOR (<MODE>mode,
11360 operands[1], operands[2])));
11362 emit_insn (gen_rtx_SET (VOIDmode, operands[3],
11363 gen_rtx_PLUS (<MODE>mode, operands[1],
11364 negate_rtx (<MODE>mode,
11368 operands[3] = operands[1];
11371 ;; Simplify (ne X (const_int 0)) on the PowerPC. No need to on the Power,
11372 ;; since it nabs/sr is just as fast.
11373 (define_insn "*ne0si"
11374 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r")
11375 (lshiftrt:SI (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
11377 (clobber (match_scratch:SI 2 "=&r"))]
11378 "! TARGET_POWER && TARGET_32BIT && !TARGET_ISEL"
11379 "{ai|addic} %2,%1,-1\;{sfe|subfe} %0,%2,%1"
11380 [(set_attr "type" "two")
11381 (set_attr "length" "8")])
11383 (define_insn "*ne0di"
11384 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
11385 (lshiftrt:DI (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r")))
11387 (clobber (match_scratch:DI 2 "=&r"))]
11389 "addic %2,%1,-1\;subfe %0,%2,%1"
11390 [(set_attr "type" "two")
11391 (set_attr "length" "8")])
11393 ;; This is what (plus (ne X (const_int 0)) Y) looks like.
11394 (define_insn "*plus_ne0si"
11395 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
11396 (plus:SI (lshiftrt:SI
11397 (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
11399 (match_operand:SI 2 "gpc_reg_operand" "r")))
11400 (clobber (match_scratch:SI 3 "=&r"))]
11402 "{ai|addic} %3,%1,-1\;{aze|addze} %0,%2"
11403 [(set_attr "type" "two")
11404 (set_attr "length" "8")])
11406 (define_insn "*plus_ne0di"
11407 [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
11408 (plus:DI (lshiftrt:DI
11409 (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r")))
11411 (match_operand:DI 2 "gpc_reg_operand" "r")))
11412 (clobber (match_scratch:DI 3 "=&r"))]
11414 "addic %3,%1,-1\;addze %0,%2"
11415 [(set_attr "type" "two")
11416 (set_attr "length" "8")])
11418 (define_insn "*compare_plus_ne0si"
11419 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
11421 (plus:SI (lshiftrt:SI
11422 (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")))
11424 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
11426 (clobber (match_scratch:SI 3 "=&r,&r"))
11427 (clobber (match_scratch:SI 4 "=X,&r"))]
11430 {ai|addic} %3,%1,-1\;{aze.|addze.} %3,%2
11432 [(set_attr "type" "compare")
11433 (set_attr "length" "8,12")])
11436 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
11438 (plus:SI (lshiftrt:SI
11439 (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "")))
11441 (match_operand:SI 2 "gpc_reg_operand" ""))
11443 (clobber (match_scratch:SI 3 ""))
11444 (clobber (match_scratch:SI 4 ""))]
11445 "TARGET_32BIT && reload_completed"
11446 [(parallel [(set (match_dup 3)
11447 (plus:SI (lshiftrt:SI (neg:SI (abs:SI (match_dup 1)))
11450 (clobber (match_dup 4))])
11452 (compare:CC (match_dup 3)
11456 (define_insn "*compare_plus_ne0di"
11457 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
11459 (plus:DI (lshiftrt:DI
11460 (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")))
11462 (match_operand:DI 2 "gpc_reg_operand" "r,r"))
11464 (clobber (match_scratch:DI 3 "=&r,&r"))]
11467 addic %3,%1,-1\;addze. %3,%2
11469 [(set_attr "type" "compare")
11470 (set_attr "length" "8,12")])
11473 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
11475 (plus:DI (lshiftrt:DI
11476 (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "")))
11478 (match_operand:DI 2 "gpc_reg_operand" ""))
11480 (clobber (match_scratch:DI 3 ""))]
11481 "TARGET_64BIT && reload_completed"
11482 [(set (match_dup 3)
11483 (plus:DI (lshiftrt:DI (neg:DI (abs:DI (match_dup 1)))
11487 (compare:CC (match_dup 3)
11491 (define_insn "*plus_ne0si_compare"
11492 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
11494 (plus:SI (lshiftrt:SI
11495 (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")))
11497 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
11499 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
11500 (plus:SI (lshiftrt:SI (neg:SI (abs:SI (match_dup 1))) (const_int 31))
11502 (clobber (match_scratch:SI 3 "=&r,&r"))]
11505 {ai|addic} %3,%1,-1\;{aze.|addze.} %0,%2
11507 [(set_attr "type" "compare")
11508 (set_attr "length" "8,12")])
11511 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
11513 (plus:SI (lshiftrt:SI
11514 (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "")))
11516 (match_operand:SI 2 "gpc_reg_operand" ""))
11518 (set (match_operand:SI 0 "gpc_reg_operand" "")
11519 (plus:SI (lshiftrt:SI (neg:SI (abs:SI (match_dup 1))) (const_int 31))
11521 (clobber (match_scratch:SI 3 ""))]
11522 "TARGET_32BIT && reload_completed"
11523 [(parallel [(set (match_dup 0)
11524 (plus:SI (lshiftrt:SI (neg:SI (abs:SI (match_dup 1))) (const_int 31))
11526 (clobber (match_dup 3))])
11528 (compare:CC (match_dup 0)
11532 (define_insn "*plus_ne0di_compare"
11533 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
11535 (plus:DI (lshiftrt:DI
11536 (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")))
11538 (match_operand:DI 2 "gpc_reg_operand" "r,r"))
11540 (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
11541 (plus:DI (lshiftrt:DI (neg:DI (abs:DI (match_dup 1))) (const_int 63))
11543 (clobber (match_scratch:DI 3 "=&r,&r"))]
11546 addic %3,%1,-1\;addze. %0,%2
11548 [(set_attr "type" "compare")
11549 (set_attr "length" "8,12")])
11552 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
11554 (plus:DI (lshiftrt:DI
11555 (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "")))
11557 (match_operand:DI 2 "gpc_reg_operand" ""))
11559 (set (match_operand:DI 0 "gpc_reg_operand" "")
11560 (plus:DI (lshiftrt:DI (neg:DI (abs:DI (match_dup 1))) (const_int 63))
11562 (clobber (match_scratch:DI 3 ""))]
11563 "TARGET_64BIT && reload_completed"
11564 [(parallel [(set (match_dup 0)
11565 (plus:DI (lshiftrt:DI (neg:DI (abs:DI (match_dup 1))) (const_int 63))
11567 (clobber (match_dup 3))])
11569 (compare:CC (match_dup 0)
11574 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
11575 (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
11576 (match_operand:SI 2 "reg_or_short_operand" "r,O")))
11577 (clobber (match_scratch:SI 3 "=r,X"))]
11580 doz %3,%2,%1\;{sfi|subfic} %0,%3,0\;{ae|adde} %0,%0,%3
11581 {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{sri|srwi} %0,%0,31"
11582 [(set_attr "length" "12")])
11585 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,?y,?y")
11587 (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
11588 (match_operand:SI 2 "reg_or_short_operand" "r,O,r,O"))
11590 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
11591 (le:SI (match_dup 1) (match_dup 2)))
11592 (clobber (match_scratch:SI 3 "=r,X,r,X"))]
11595 doz %3,%2,%1\;{sfi|subfic} %0,%3,0\;{ae.|adde.} %0,%0,%3
11596 {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{sri.|srwi.} %0,%0,31
11599 [(set_attr "type" "compare,delayed_compare,compare,delayed_compare")
11600 (set_attr "length" "12,12,16,16")])
11603 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
11605 (le:SI (match_operand:SI 1 "gpc_reg_operand" "")
11606 (match_operand:SI 2 "reg_or_short_operand" ""))
11608 (set (match_operand:SI 0 "gpc_reg_operand" "")
11609 (le:SI (match_dup 1) (match_dup 2)))
11610 (clobber (match_scratch:SI 3 ""))]
11611 "TARGET_POWER && reload_completed"
11612 [(parallel [(set (match_dup 0)
11613 (le:SI (match_dup 1) (match_dup 2)))
11614 (clobber (match_dup 3))])
11616 (compare:CC (match_dup 0)
11621 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r")
11622 (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
11623 (match_operand:SI 2 "reg_or_short_operand" "r,O"))
11624 (match_operand:SI 3 "gpc_reg_operand" "r,r")))]
11627 doz %0,%2,%1\;{sfi|subfic} %0,%0,0\;{aze|addze} %0,%3
11628 {srai|srawi} %0,%1,31\;{sf|subfc} %0,%1,%0\;{aze|addze} %0,%3"
11629 [(set_attr "length" "12")])
11632 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
11634 (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
11635 (match_operand:SI 2 "reg_or_short_operand" "r,O,r,O"))
11636 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r"))
11638 (clobber (match_scratch:SI 4 "=&r,&r,&r,&r"))]
11641 doz %4,%2,%1\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
11642 {srai|srawi} %4,%1,31\;{sf|subfc} %4,%1,%4\;{aze.|addze.} %4,%3
11645 [(set_attr "type" "compare")
11646 (set_attr "length" "12,12,16,16")])
11649 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
11651 (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "")
11652 (match_operand:SI 2 "reg_or_short_operand" ""))
11653 (match_operand:SI 3 "gpc_reg_operand" ""))
11655 (clobber (match_scratch:SI 4 ""))]
11656 "TARGET_POWER && reload_completed"
11657 [(set (match_dup 4)
11658 (plus:SI (le:SI (match_dup 1) (match_dup 2))
11661 (compare:CC (match_dup 4)
11666 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,?y,?y")
11668 (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
11669 (match_operand:SI 2 "reg_or_short_operand" "r,O,r,O"))
11670 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r"))
11672 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r,&r,&r")
11673 (plus:SI (le:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
11676 doz %0,%2,%1\;{sfi|subfic} %0,%0,0\;{aze.|addze.} %0,%3
11677 {srai|srawi} %0,%1,31\;{sf|subfc} %0,%1,%0\;{aze.|addze.} %0,%3
11680 [(set_attr "type" "compare")
11681 (set_attr "length" "12,12,16,16")])
11684 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
11686 (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "")
11687 (match_operand:SI 2 "reg_or_short_operand" ""))
11688 (match_operand:SI 3 "gpc_reg_operand" ""))
11690 (set (match_operand:SI 0 "gpc_reg_operand" "")
11691 (plus:SI (le:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
11692 "TARGET_POWER && reload_completed"
11693 [(set (match_dup 0)
11694 (plus:SI (le:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
11696 (compare:CC (match_dup 0)
11701 [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
11702 (neg:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
11703 (match_operand:SI 2 "reg_or_short_operand" "r,O"))))]
11706 doz %0,%2,%1\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
11707 {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{srai|srawi} %0,%0,31"
11708 [(set_attr "length" "12")])
11710 (define_insn "*leu<mode>"
11711 [(set (match_operand:P 0 "gpc_reg_operand" "=r")
11712 (leu:P (match_operand:P 1 "gpc_reg_operand" "r")
11713 (match_operand:P 2 "reg_or_short_operand" "rI")))]
11715 "{sf%I2|subf%I2c} %0,%1,%2\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0"
11716 [(set_attr "type" "three")
11717 (set_attr "length" "12")])
11719 (define_insn "*leu<mode>_compare"
11720 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
11722 (leu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
11723 (match_operand:P 2 "reg_or_short_operand" "rI,rI"))
11725 (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
11726 (leu:P (match_dup 1) (match_dup 2)))]
11729 {sf%I2|subf%I2c} %0,%1,%2\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0
11731 [(set_attr "type" "compare")
11732 (set_attr "length" "12,16")])
11735 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
11737 (leu:P (match_operand:P 1 "gpc_reg_operand" "")
11738 (match_operand:P 2 "reg_or_short_operand" ""))
11740 (set (match_operand:P 0 "gpc_reg_operand" "")
11741 (leu:P (match_dup 1) (match_dup 2)))]
11743 [(set (match_dup 0)
11744 (leu:P (match_dup 1) (match_dup 2)))
11746 (compare:CC (match_dup 0)
11750 (define_insn "*plus_leu<mode>"
11751 [(set (match_operand:P 0 "gpc_reg_operand" "=&r")
11752 (plus:P (leu:P (match_operand:P 1 "gpc_reg_operand" "r")
11753 (match_operand:P 2 "reg_or_short_operand" "rI"))
11754 (match_operand:P 3 "gpc_reg_operand" "r")))]
11756 "{sf%I2|subf%I2c} %0,%1,%2\;{aze|addze} %0,%3"
11757 [(set_attr "type" "two")
11758 (set_attr "length" "8")])
11761 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
11763 (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
11764 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
11765 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
11767 (clobber (match_scratch:SI 4 "=&r,&r"))]
11770 {sf%I2|subf%I2c} %4,%1,%2\;{aze.|addze.} %4,%3
11772 [(set_attr "type" "compare")
11773 (set_attr "length" "8,12")])
11776 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
11778 (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "")
11779 (match_operand:SI 2 "reg_or_short_operand" ""))
11780 (match_operand:SI 3 "gpc_reg_operand" ""))
11782 (clobber (match_scratch:SI 4 ""))]
11783 "TARGET_32BIT && reload_completed"
11784 [(set (match_dup 4)
11785 (plus:SI (leu:SI (match_dup 1) (match_dup 2))
11788 (compare:CC (match_dup 4)
11793 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
11795 (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
11796 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
11797 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
11799 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r")
11800 (plus:SI (leu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
11803 {sf%I2|subf%I2c} %0,%1,%2\;{aze.|addze.} %0,%3
11805 [(set_attr "type" "compare")
11806 (set_attr "length" "8,12")])
11809 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
11811 (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "")
11812 (match_operand:SI 2 "reg_or_short_operand" ""))
11813 (match_operand:SI 3 "gpc_reg_operand" ""))
11815 (set (match_operand:SI 0 "gpc_reg_operand" "")
11816 (plus:SI (leu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
11817 "TARGET_32BIT && reload_completed"
11818 [(set (match_dup 0)
11819 (plus:SI (leu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
11821 (compare:CC (match_dup 0)
11825 (define_insn "*neg_leu<mode>"
11826 [(set (match_operand:P 0 "gpc_reg_operand" "=r")
11827 (neg:P (leu:P (match_operand:P 1 "gpc_reg_operand" "r")
11828 (match_operand:P 2 "reg_or_short_operand" "rI"))))]
11830 "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;nand %0,%0,%0"
11831 [(set_attr "type" "three")
11832 (set_attr "length" "12")])
11834 (define_insn "*and_neg_leu<mode>"
11835 [(set (match_operand:P 0 "gpc_reg_operand" "=&r")
11837 (leu:P (match_operand:P 1 "gpc_reg_operand" "r")
11838 (match_operand:P 2 "reg_or_short_operand" "rI")))
11839 (match_operand:P 3 "gpc_reg_operand" "r")))]
11841 "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;andc %0,%3,%0"
11842 [(set_attr "type" "three")
11843 (set_attr "length" "12")])
11846 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
11849 (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
11850 (match_operand:SI 2 "reg_or_short_operand" "rI,rI")))
11851 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
11853 (clobber (match_scratch:SI 4 "=&r,&r"))]
11856 {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4
11858 [(set_attr "type" "compare")
11859 (set_attr "length" "12,16")])
11862 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
11865 (leu:SI (match_operand:SI 1 "gpc_reg_operand" "")
11866 (match_operand:SI 2 "reg_or_short_operand" "")))
11867 (match_operand:SI 3 "gpc_reg_operand" ""))
11869 (clobber (match_scratch:SI 4 ""))]
11870 "TARGET_32BIT && reload_completed"
11871 [(set (match_dup 4)
11872 (and:SI (neg:SI (leu:SI (match_dup 1) (match_dup 2)))
11875 (compare:CC (match_dup 4)
11880 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
11883 (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
11884 (match_operand:SI 2 "reg_or_short_operand" "rI,rI")))
11885 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
11887 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r")
11888 (and:SI (neg:SI (leu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))]
11891 {sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;andc. %0,%3,%0
11893 [(set_attr "type" "compare")
11894 (set_attr "length" "12,16")])
11897 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
11900 (leu:SI (match_operand:SI 1 "gpc_reg_operand" "")
11901 (match_operand:SI 2 "reg_or_short_operand" "")))
11902 (match_operand:SI 3 "gpc_reg_operand" ""))
11904 (set (match_operand:SI 0 "gpc_reg_operand" "")
11905 (and:SI (neg:SI (leu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))]
11906 "TARGET_32BIT && reload_completed"
11907 [(set (match_dup 0)
11908 (and:SI (neg:SI (leu:SI (match_dup 1) (match_dup 2)))
11911 (compare:CC (match_dup 0)
11916 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
11917 (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
11918 (match_operand:SI 2 "reg_or_short_operand" "rI")))]
11920 "doz%I2 %0,%1,%2\;nabs %0,%0\;{sri|srwi} %0,%0,31"
11921 [(set_attr "length" "12")])
11924 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
11926 (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
11927 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
11929 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
11930 (lt:SI (match_dup 1) (match_dup 2)))]
11933 doz%I2 %0,%1,%2\;nabs %0,%0\;{sri.|srwi.} %0,%0,31
11935 [(set_attr "type" "delayed_compare")
11936 (set_attr "length" "12,16")])
11939 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
11941 (lt:SI (match_operand:SI 1 "gpc_reg_operand" "")
11942 (match_operand:SI 2 "reg_or_short_operand" ""))
11944 (set (match_operand:SI 0 "gpc_reg_operand" "")
11945 (lt:SI (match_dup 1) (match_dup 2)))]
11946 "TARGET_POWER && reload_completed"
11947 [(set (match_dup 0)
11948 (lt:SI (match_dup 1) (match_dup 2)))
11950 (compare:CC (match_dup 0)
11955 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r")
11956 (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
11957 (match_operand:SI 2 "reg_or_short_operand" "rI"))
11958 (match_operand:SI 3 "gpc_reg_operand" "r")))]
11960 "doz%I2 %0,%1,%2\;{ai|addic} %0,%0,-1\;{aze|addze} %0,%3"
11961 [(set_attr "length" "12")])
11964 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
11966 (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
11967 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
11968 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
11970 (clobber (match_scratch:SI 4 "=&r,&r"))]
11973 doz%I2 %4,%1,%2\;{ai|addic} %4,%4,-1\;{aze.|addze.} %4,%3
11975 [(set_attr "type" "compare")
11976 (set_attr "length" "12,16")])
11979 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
11981 (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "")
11982 (match_operand:SI 2 "reg_or_short_operand" ""))
11983 (match_operand:SI 3 "gpc_reg_operand" ""))
11985 (clobber (match_scratch:SI 4 ""))]
11986 "TARGET_POWER && reload_completed"
11987 [(set (match_dup 4)
11988 (plus:SI (lt:SI (match_dup 1) (match_dup 2))
11991 (compare:CC (match_dup 4)
11996 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
11998 (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
11999 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
12000 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
12002 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r")
12003 (plus:SI (lt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
12006 doz%I2 %0,%1,%2\;{ai|addic} %0,%0,-1\;{aze.|addze.} %0,%3
12008 [(set_attr "type" "compare")
12009 (set_attr "length" "12,16")])
12012 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
12014 (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "")
12015 (match_operand:SI 2 "reg_or_short_operand" ""))
12016 (match_operand:SI 3 "gpc_reg_operand" ""))
12018 (set (match_operand:SI 0 "gpc_reg_operand" "")
12019 (plus:SI (lt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
12020 "TARGET_POWER && reload_completed"
12021 [(set (match_dup 0)
12022 (plus:SI (lt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
12024 (compare:CC (match_dup 0)
12029 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
12030 (neg:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
12031 (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
12033 "doz%I2 %0,%1,%2\;nabs %0,%0\;{srai|srawi} %0,%0,31"
12034 [(set_attr "length" "12")])
12036 (define_insn_and_split "*ltu<mode>"
12037 [(set (match_operand:P 0 "gpc_reg_operand" "=r,r")
12038 (ltu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
12039 (match_operand:P 2 "reg_or_neg_short_operand" "r,P")))]
12043 [(set (match_dup 0) (neg:P (ltu:P (match_dup 1) (match_dup 2))))
12044 (set (match_dup 0) (neg:P (match_dup 0)))]
12047 (define_insn_and_split "*ltu<mode>_compare"
12048 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
12050 (ltu:P (match_operand:P 1 "gpc_reg_operand" "r,r,r,r")
12051 (match_operand:P 2 "reg_or_neg_short_operand" "r,P,r,P"))
12053 (set (match_operand:P 0 "gpc_reg_operand" "=r,r,r,r")
12054 (ltu:P (match_dup 1) (match_dup 2)))]
12058 [(set (match_dup 0) (neg:P (ltu:P (match_dup 1) (match_dup 2))))
12059 (parallel [(set (match_dup 3)
12060 (compare:CC (neg:P (match_dup 0)) (const_int 0)))
12061 (set (match_dup 0) (neg:P (match_dup 0)))])]
12064 (define_insn_and_split "*plus_ltu<mode>"
12065 [(set (match_operand:P 0 "gpc_reg_operand" "=&r,r")
12066 (plus:P (ltu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
12067 (match_operand:P 2 "reg_or_neg_short_operand" "r,P"))
12068 (match_operand:P 3 "reg_or_short_operand" "rI,rI")))]
12071 "&& !reg_overlap_mentioned_p (operands[0], operands[3])"
12072 [(set (match_dup 0) (neg:P (ltu:P (match_dup 1) (match_dup 2))))
12073 (set (match_dup 0) (minus:P (match_dup 3) (match_dup 0)))]
12076 (define_insn_and_split "*plus_ltu<mode>_compare"
12077 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,?y,?y")
12079 (plus:P (ltu:P (match_operand:P 1 "gpc_reg_operand" "r,r,r,r")
12080 (match_operand:P 2 "reg_or_neg_short_operand" "r,P,r,P"))
12081 (match_operand:P 3 "gpc_reg_operand" "r,r,r,r"))
12083 (set (match_operand:P 0 "gpc_reg_operand" "=&r,&r,&r,&r")
12084 (plus:P (ltu:P (match_dup 1) (match_dup 2)) (match_dup 3)))]
12087 "&& !reg_overlap_mentioned_p (operands[0], operands[3])"
12088 [(set (match_dup 0) (neg:P (ltu:P (match_dup 1) (match_dup 2))))
12089 (parallel [(set (match_dup 4)
12090 (compare:CC (minus:P (match_dup 3) (match_dup 0))
12092 (set (match_dup 0) (minus:P (match_dup 3) (match_dup 0)))])]
12095 (define_insn "*neg_ltu<mode>"
12096 [(set (match_operand:P 0 "gpc_reg_operand" "=r,r")
12097 (neg:P (ltu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
12098 (match_operand:P 2 "reg_or_neg_short_operand" "r,P"))))]
12101 {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0
12102 {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0"
12103 [(set_attr "type" "two")
12104 (set_attr "length" "8")])
12107 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
12108 (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
12109 (match_operand:SI 2 "reg_or_short_operand" "rI")))
12110 (clobber (match_scratch:SI 3 "=r"))]
12112 "doz%I2 %3,%1,%2\;{sfi|subfic} %0,%3,0\;{ae|adde} %0,%0,%3"
12113 [(set_attr "length" "12")])
12116 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
12118 (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
12119 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
12121 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
12122 (ge:SI (match_dup 1) (match_dup 2)))
12123 (clobber (match_scratch:SI 3 "=r,r"))]
12126 doz%I2 %3,%1,%2\;{sfi|subfic} %0,%3,0\;{ae.|adde.} %0,%0,%3
12128 [(set_attr "type" "compare")
12129 (set_attr "length" "12,16")])
12132 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
12134 (ge:SI (match_operand:SI 1 "gpc_reg_operand" "")
12135 (match_operand:SI 2 "reg_or_short_operand" ""))
12137 (set (match_operand:SI 0 "gpc_reg_operand" "")
12138 (ge:SI (match_dup 1) (match_dup 2)))
12139 (clobber (match_scratch:SI 3 ""))]
12140 "TARGET_POWER && reload_completed"
12141 [(parallel [(set (match_dup 0)
12142 (ge:SI (match_dup 1) (match_dup 2)))
12143 (clobber (match_dup 3))])
12145 (compare:CC (match_dup 0)
12150 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r")
12151 (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
12152 (match_operand:SI 2 "reg_or_short_operand" "rI"))
12153 (match_operand:SI 3 "gpc_reg_operand" "r")))]
12155 "doz%I2 %0,%1,%2\;{sfi|subfic} %0,%0,0\;{aze|addze} %0,%3"
12156 [(set_attr "length" "12")])
12159 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
12161 (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
12162 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
12163 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
12165 (clobber (match_scratch:SI 4 "=&r,&r"))]
12168 doz%I2 %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
12170 [(set_attr "type" "compare")
12171 (set_attr "length" "12,16")])
12174 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
12176 (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "")
12177 (match_operand:SI 2 "reg_or_short_operand" ""))
12178 (match_operand:SI 3 "gpc_reg_operand" ""))
12180 (clobber (match_scratch:SI 4 ""))]
12181 "TARGET_POWER && reload_completed"
12182 [(set (match_dup 4)
12183 (plus:SI (ge:SI (match_dup 1) (match_dup 2))
12186 (compare:CC (match_dup 4)
12191 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
12193 (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
12194 (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
12195 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
12197 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r")
12198 (plus:SI (ge:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
12201 doz%I2 %0,%1,%2\;{sfi|subfic} %0,%0,0\;{aze.|addze.} %0,%3
12203 [(set_attr "type" "compare")
12204 (set_attr "length" "12,16")])
12207 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
12209 (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "")
12210 (match_operand:SI 2 "reg_or_short_operand" ""))
12211 (match_operand:SI 3 "gpc_reg_operand" ""))
12213 (set (match_operand:SI 0 "gpc_reg_operand" "")
12214 (plus:SI (ge:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
12215 "TARGET_POWER && reload_completed"
12216 [(set (match_dup 0)
12217 (plus:SI (ge:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
12219 (compare:CC (match_dup 0)
12224 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
12225 (neg:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
12226 (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
12228 "doz%I2 %0,%1,%2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0"
12229 [(set_attr "length" "12")])
12231 (define_insn "*geu<mode>"
12232 [(set (match_operand:P 0 "gpc_reg_operand" "=r,r")
12233 (geu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
12234 (match_operand:P 2 "reg_or_neg_short_operand" "r,P")))]
12237 {sf|subfc} %0,%2,%1\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0
12238 {ai|addic} %0,%1,%n2\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0"
12239 [(set_attr "type" "three")
12240 (set_attr "length" "12")])
12242 (define_insn "*geu<mode>_compare"
12243 [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
12245 (geu:P (match_operand:P 1 "gpc_reg_operand" "r,r,r,r")
12246 (match_operand:P 2 "reg_or_neg_short_operand" "r,P,r,P"))
12248 (set (match_operand:P 0 "gpc_reg_operand" "=r,r,r,r")
12249 (geu:P (match_dup 1) (match_dup 2)))]
12252 {sf|subfc} %0,%2,%1\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0
12253 {ai|addic} %0,%1,%n2\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0
12256 [(set_attr "type" "compare")
12257 (set_attr "length" "12,12,16,16")])
12260 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
12262 (geu:P (match_operand:P 1 "gpc_reg_operand" "")
12263 (match_operand:P 2 "reg_or_neg_short_operand" ""))
12265 (set (match_operand:P 0 "gpc_reg_operand" "")
12266 (geu:P (match_dup 1) (match_dup 2)))]
12268 [(set (match_dup 0)
12269 (geu:P (match_dup 1) (match_dup 2)))
12271 (compare:CC (match_dup 0)
12275 (define_insn "*plus_geu<mode>"
12276 [(set (match_operand:P 0 "gpc_reg_operand" "=&r,&r")
12277 (plus:P (geu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
12278 (match_operand:P 2 "reg_or_neg_short_operand" "r,P"))
12279 (match_operand:P 3 "gpc_reg_operand" "r,r")))]
12282 {sf|subfc} %0,%2,%1\;{aze|addze} %0,%3
12283 {ai|addic} %0,%1,%n2\;{aze|addze} %0,%3"
12284 [(set_attr "type" "two")
12285 (set_attr "length" "8")])
12288 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
12290 (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
12291 (match_operand:SI 2 "reg_or_neg_short_operand" "r,P,r,P"))
12292 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r"))
12294 (clobber (match_scratch:SI 4 "=&r,&r,&r,&r"))]
12297 {sf|subfc} %4,%2,%1\;{aze.|addze.} %4,%3
12298 {ai|addic} %4,%1,%n2\;{aze.|addze.} %4,%3
12301 [(set_attr "type" "compare")
12302 (set_attr "length" "8,8,12,12")])
12305 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
12307 (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "")
12308 (match_operand:SI 2 "reg_or_neg_short_operand" ""))
12309 (match_operand:SI 3 "gpc_reg_operand" ""))
12311 (clobber (match_scratch:SI 4 ""))]
12312 "TARGET_32BIT && reload_completed"
12313 [(set (match_dup 4)
12314 (plus:SI (geu:SI (match_dup 1) (match_dup 2))
12317 (compare:CC (match_dup 4)
12322 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,?y,?y")
12324 (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
12325 (match_operand:SI 2 "reg_or_neg_short_operand" "r,P,r,P"))
12326 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r"))
12328 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r,&r,&r")
12329 (plus:SI (geu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
12332 {sf|subfc} %0,%2,%1\;{aze.|addze.} %0,%3
12333 {ai|addic} %0,%1,%n2\;{aze.|addze.} %0,%3
12336 [(set_attr "type" "compare")
12337 (set_attr "length" "8,8,12,12")])
12340 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
12342 (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "")
12343 (match_operand:SI 2 "reg_or_neg_short_operand" ""))
12344 (match_operand:SI 3 "gpc_reg_operand" ""))
12346 (set (match_operand:SI 0 "gpc_reg_operand" "")
12347 (plus:SI (geu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
12348 "TARGET_32BIT && reload_completed"
12349 [(set (match_dup 0)
12350 (plus:SI (geu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
12352 (compare:CC (match_dup 0)
12356 (define_insn "*neg_geu<mode>"
12357 [(set (match_operand:P 0 "gpc_reg_operand" "=r,r")
12358 (neg:P (geu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
12359 (match_operand:P 2 "reg_or_short_operand" "r,I"))))]
12362 {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;nand %0,%0,%0
12363 {sfi|subfic} %0,%1,-1\;{a%I2|add%I2c} %0,%0,%2\;{sfe|subfe} %0,%0,%0"
12364 [(set_attr "type" "three")
12365 (set_attr "length" "12")])
12367 (define_insn "*and_neg_geu<mode>"
12368 [(set (match_operand:P 0 "gpc_reg_operand" "=&r,&r")
12370 (geu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
12371 (match_operand:P 2 "reg_or_neg_short_operand" "r,P")))
12372 (match_operand:P 3 "gpc_reg_operand" "r,r")))]
12375 {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;andc %0,%3,%0
12376 {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0\;andc %0,%3,%0"
12377 [(set_attr "type" "three")
12378 (set_attr "length" "12")])
12381 [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
12384 (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
12385 (match_operand:SI 2 "reg_or_neg_short_operand" "r,P,r,P")))
12386 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r"))
12388 (clobber (match_scratch:SI 4 "=&r,&r,&r,&r"))]
12391 {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4
12392 {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4
12395 [(set_attr "type" "compare")
12396 (set_attr "length" "12,12,16,16")])
12399 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
12402 (geu:SI (match_operand:SI 1 "gpc_reg_operand" "")
12403 (match_operand:SI 2 "reg_or_neg_short_operand" "")))
12404 (match_operand:SI 3 "gpc_reg_operand" ""))
12406 (clobber (match_scratch:SI 4 ""))]
12407 "TARGET_32BIT && reload_completed"
12408 [(set (match_dup 4)
12409 (and:SI (neg:SI (geu:SI (match_dup 1) (match_dup 2)))
12412 (compare:CC (match_dup 4)
12417 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,?y,?y")
12420 (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
12421 (match_operand:SI 2 "reg_or_neg_short_operand" "r,P,r,P")))
12422 (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r"))
12424 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r,&r,&r")
12425 (and:SI (neg:SI (geu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))]
12428 {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;andc. %0,%3,%0
12429 {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0\;andc. %0,%3,%0
12432 [(set_attr "type" "compare")
12433 (set_attr "length" "12,12,16,16")])
12436 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
12439 (geu:SI (match_operand:SI 1 "gpc_reg_operand" "")
12440 (match_operand:SI 2 "reg_or_neg_short_operand" "")))
12441 (match_operand:SI 3 "gpc_reg_operand" ""))
12443 (set (match_operand:SI 0 "gpc_reg_operand" "")
12444 (and:SI (neg:SI (geu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))]
12445 "TARGET_32BIT && reload_completed"
12446 [(set (match_dup 0)
12447 (and:SI (neg:SI (geu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))
12449 (compare:CC (match_dup 0)
12454 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
12455 (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
12456 (match_operand:SI 2 "reg_or_short_operand" "r")))]
12458 "doz %0,%2,%1\;nabs %0,%0\;{sri|srwi} %0,%0,31"
12459 [(set_attr "length" "12")])
12462 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
12464 (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
12465 (match_operand:SI 2 "reg_or_short_operand" "r,r"))
12467 (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
12468 (gt:SI (match_dup 1) (match_dup 2)))]
12471 doz %0,%2,%1\;nabs %0,%0\;{sri.|srwi.} %0,%0,31
12473 [(set_attr "type" "delayed_compare")
12474 (set_attr "length" "12,16")])
12477 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
12479 (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
12480 (match_operand:SI 2 "reg_or_short_operand" ""))
12482 (set (match_operand:SI 0 "gpc_reg_operand" "")
12483 (gt:SI (match_dup 1) (match_dup 2)))]
12484 "TARGET_POWER && reload_completed"
12485 [(set (match_dup 0)
12486 (gt:SI (match_dup 1) (match_dup 2)))
12488 (compare:CC (match_dup 0)
12492 (define_insn "*plus_gt0<mode>"
12493 [(set (match_operand:P 0 "gpc_reg_operand" "=&r")
12494 (plus:P (gt:P (match_operand:P 1 "gpc_reg_operand" "r")
12496 (match_operand:P 2 "gpc_reg_operand" "r")))]
12498 "{a|addc} %0,%1,%1\;{sfe|subfe} %0,%1,%0\;{aze|addze} %0,%2"
12499 [(set_attr "type" "three")
12500 (set_attr "length" "12")])
12503 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
12505 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
12507 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
12509 (clobber (match_scratch:SI 3 "=&r,&r"))]
12512 {a|addc} %3,%1,%1\;{sfe|subfe} %3,%1,%3\;{aze.|addze.} %3,%2
12514 [(set_attr "type" "compare")
12515 (set_attr "length" "12,16")])
12518 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
12520 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
12522 (match_operand:SI 2 "gpc_reg_operand" ""))
12524 (clobber (match_scratch:SI 3 ""))]
12525 "TARGET_32BIT && reload_completed"
12526 [(set (match_dup 3)
12527 (plus:SI (gt:SI (match_dup 1) (const_int 0))
12530 (compare:CC (match_dup 3)
12535 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
12537 (plus:DI (gt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
12539 (match_operand:DI 2 "gpc_reg_operand" "r,r"))
12541 (clobber (match_scratch:DI 3 "=&r,&r"))]
12544 addc %3,%1,%1\;subfe %3,%1,%3\;addze. %3,%2
12546 [(set_attr "type" "compare")
12547 (set_attr "length" "12,16")])
12550 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
12552 (plus:DI (gt:DI (match_operand:DI 1 "gpc_reg_operand" "")
12554 (match_operand:DI 2 "gpc_reg_operand" ""))
12556 (clobber (match_scratch:DI 3 ""))]
12557 "TARGET_64BIT && reload_completed"
12558 [(set (match_dup 3)
12559 (plus:DI (gt:DI (match_dup 1) (const_int 0))
12562 (compare:CC (match_dup 3)
12567 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
12569 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
12571 (match_operand:SI 2 "gpc_reg_operand" "r,r"))
12573 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r")
12574 (plus:SI (gt:SI (match_dup 1) (const_int 0)) (match_dup 2)))]
12577 {a|addc} %0,%1,%1\;{sfe|subfe} %0,%1,%0\;{aze.|addze.} %0,%2
12579 [(set_attr "type" "compare")
12580 (set_attr "length" "12,16")])
12583 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
12585 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
12587 (match_operand:SI 2 "gpc_reg_operand" ""))
12589 (set (match_operand:SI 0 "gpc_reg_operand" "")
12590 (plus:SI (gt:SI (match_dup 1) (const_int 0)) (match_dup 2)))]
12591 "TARGET_32BIT && reload_completed"
12592 [(set (match_dup 0)
12593 (plus:SI (gt:SI (match_dup 1) (const_int 0)) (match_dup 2)))
12595 (compare:CC (match_dup 0)
12600 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
12602 (plus:DI (gt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
12604 (match_operand:DI 2 "gpc_reg_operand" "r,r"))
12606 (set (match_operand:DI 0 "gpc_reg_operand" "=&r,&r")
12607 (plus:DI (gt:DI (match_dup 1) (const_int 0)) (match_dup 2)))]
12610 addc %0,%1,%1\;subfe %0,%1,%0\;addze. %0,%2
12612 [(set_attr "type" "compare")
12613 (set_attr "length" "12,16")])
12616 [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
12618 (plus:DI (gt:DI (match_operand:DI 1 "gpc_reg_operand" "")
12620 (match_operand:DI 2 "gpc_reg_operand" ""))
12622 (set (match_operand:DI 0 "gpc_reg_operand" "")
12623 (plus:DI (gt:DI (match_dup 1) (const_int 0)) (match_dup 2)))]
12624 "TARGET_64BIT && reload_completed"
12625 [(set (match_dup 0)
12626 (plus:DI (gt:DI (match_dup 1) (const_int 0)) (match_dup 2)))
12628 (compare:CC (match_dup 0)
12633 [(set (match_operand:SI 0 "gpc_reg_operand" "=&r")
12634 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
12635 (match_operand:SI 2 "reg_or_short_operand" "r"))
12636 (match_operand:SI 3 "gpc_reg_operand" "r")))]
12638 "doz %0,%2,%1\;{ai|addic} %0,%0,-1\;{aze|addze} %0,%3"
12639 [(set_attr "length" "12")])
12642 [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
12644 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
12645 (match_operand:SI 2 "reg_or_short_operand" "r,r"))
12646 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
12648 (clobber (match_scratch:SI 4 "=&r,&r"))]
12651 doz %4,%2,%1\;{ai|addic} %4,%4,-1\;{aze.|addze.} %4,%3
12653 [(set_attr "type" "compare")
12654 (set_attr "length" "12,16")])
12657 [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
12659 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
12660 (match_operand:SI 2 "reg_or_short_operand" ""))
12661 (match_operand:SI 3 "gpc_reg_operand" ""))
12663 (clobber (match_scratch:SI 4 ""))]
12664 "TARGET_POWER && reload_completed"
12665 [(set (match_dup 4)
12666 (plus:SI (gt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
12668 (compare:CC (match_dup 4)
12673 [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
12675 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
12676 (match_operand:SI 2 "reg_or_short_operand" "r,r"))
12677 (match_operand:SI 3 "gpc_reg_operand" "r,r"))
12679 (set (match_operand:SI 0 "gpc_reg_operand" "=&r,&r")
12680 (plus:SI (gt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
12683 doz %0,%2,%1\;{ai|addic} %0,%0,-1\;{aze.|addze.} %0,%3
12685 [(set_attr "type" "compare")
12686 (set_attr "length" "12,16")])
12689 [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
12691 (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
12692 (match_operand:SI 2 "reg_or_short_operand" ""))
12693 (match_operand:SI 3 "gpc_reg_operand" ""))
12695 (set (match_operand:SI 0 "gpc_reg_operand" "")
12696 (plus:SI (gt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
12697 "TARGET_POWER && reload_completed"
12698 [(set (match_dup 0)
12699 (plus:SI (gt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
12701 (compare:CC (match_dup 0)
12706 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
12707 (neg:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
12708 (match_operand:SI 2 "reg_or_short_operand" "r"))))]
12710 "doz %0,%2,%1\;nabs %0,%0\;{srai|srawi} %0,%0,31"
12711 [(set_attr "length" "12")])
12713 (define_insn_and_split "*gtu<mode>"
12714 [(set (match_operand:P 0 "gpc_reg_operand" "=r")
12715 (gtu:P (match_operand:P 1 "gpc_reg_operand" "r")
12716 (match_operand:P 2 "reg_or_short_operand" "rI")))]
12720 [(set (match_dup 0) (neg:P (gtu:P (match_dup 1) (match_dup 2))))
12721 (set (match_dup 0) (neg:P (match_dup 0)))]
12724 (define_insn_and_split "*gtu<mode>_compare"
12725 [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
12727 (gtu:P (match_operand:P 1 "gpc_reg_operand" "r,r")
12728 (match_operand:P 2 "reg_or_short_operand" "rI,rI"))
12730 (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
12731 (gtu:P (match_dup 1) (match_dup 2)))]
12735 [(set (match_dup 0) (neg:P (gtu:P (match_dup 1) (match_dup 2))))
12736 (parallel [(set (match_dup 3)
12737 (compare:CC (neg:P (match_dup 0)) (const_int 0)))
12738 (set (match_dup 0) (neg:P (match_dup 0)))])]
12741 (define_insn_and_split "*plus_gtu<mode>"
12742 [(set (match_operand:P 0 "gpc_reg_operand" "=&r")
12743 (plus:P (gtu:P (match_operand:P 1 "gpc_reg_operand" "r")
12744 (match_operand:P 2 "reg_or_short_operand" "rI"))
12745 (match_operand:P 3 "reg_or_short_operand" "rI")))]
12748 "&& !reg_overlap_mentioned_p (operands[0], operands[3])"
12749 [(set (match_dup 0) (neg:P (gtu:P (match_dup 1) (match_dup 2))))
12750 (set (match_dup 0) (minus:P (match_dup 3) (match_dup 0)))]
12753 (define_insn_and_split "*plus_gtu<mode>_compare"
12754 [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,?y,?y")
12756 (plus:P (gtu:P (match_operand:P 1 "gpc_reg_operand" "r,r,r,r")
12757 (match_operand:P 2 "reg_or_short_operand" "I,r,I,r"))
12758 (match_operand:P 3 "gpc_reg_operand" "r,r,r,r"))
12760 (set (match_operand:P 0 "gpc_reg_operand" "=&r,&r,&r,&r")
12761 (plus:P (gtu:P (match_dup 1) (match_dup 2)) (match_dup 3)))]
12764 "&& !reg_overlap_mentioned_p (operands[0], operands[3])"
12765 [(set (match_dup 0) (neg:P (gtu:P (match_dup 1) (match_dup 2))))
12766 (parallel [(set (match_dup 4)
12767 (compare:CC (minus:P (match_dup 3) (match_dup 0))
12769 (set (match_dup 0) (minus:P (match_dup 3) (match_dup 0)))])]
12772 (define_insn "*neg_gtu<mode>"
12773 [(set (match_operand:P 0 "gpc_reg_operand" "=r")
12774 (neg:P (gtu:P (match_operand:P 1 "gpc_reg_operand" "r")
12775 (match_operand:P 2 "reg_or_short_operand" "rI"))))]
12777 "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0"
12778 [(set_attr "type" "two")
12779 (set_attr "length" "8")])
12782 ;; Define both directions of branch and return. If we need a reload
12783 ;; register, we'd rather use CR0 since it is much easier to copy a
12784 ;; register CC value to there.
12788 (if_then_else (match_operator 1 "branch_comparison_operator"
12790 "cc_reg_operand" "y")
12792 (label_ref (match_operand 0 "" ""))
12797 return output_cbranch (operands[1], \"%l0\", 0, insn);
12799 [(set_attr "type" "branch")])
12803 (if_then_else (match_operator 0 "branch_comparison_operator"
12805 "cc_reg_operand" "y")
12812 return output_cbranch (operands[0], NULL, 0, insn);
12814 [(set_attr "type" "branch")
12815 (set_attr "length" "4")])
12819 (if_then_else (match_operator 1 "branch_comparison_operator"
12821 "cc_reg_operand" "y")
12824 (label_ref (match_operand 0 "" ""))))]
12828 return output_cbranch (operands[1], \"%l0\", 1, insn);
12830 [(set_attr "type" "branch")])
12834 (if_then_else (match_operator 0 "branch_comparison_operator"
12836 "cc_reg_operand" "y")
12843 return output_cbranch (operands[0], NULL, 1, insn);
12845 [(set_attr "type" "branch")
12846 (set_attr "length" "4")])
12848 ;; Logic on condition register values.
12850 ; This pattern matches things like
12851 ; (set (reg:CCEQ 68) (compare:CCEQ (ior:SI (gt:SI (reg:CCFP 68) (const_int 0))
12852 ; (eq:SI (reg:CCFP 68) (const_int 0)))
12854 ; which are generated by the branch logic.
12855 ; Prefer destructive operations where BT = BB (for crXX BT,BA,BB)
12857 (define_insn "*cceq_ior_compare"
12858 [(set (match_operand:CCEQ 0 "cc_reg_operand" "=y,?y")
12859 (compare:CCEQ (match_operator:SI 1 "boolean_operator"
12860 [(match_operator:SI 2
12861 "branch_positive_comparison_operator"
12863 "cc_reg_operand" "y,y")
12865 (match_operator:SI 4
12866 "branch_positive_comparison_operator"
12868 "cc_reg_operand" "0,y")
12872 "cr%q1 %E0,%j2,%j4"
12873 [(set_attr "type" "cr_logical,delayed_cr")])
12875 ; Why is the constant -1 here, but 1 in the previous pattern?
12876 ; Because ~1 has all but the low bit set.
12878 [(set (match_operand:CCEQ 0 "cc_reg_operand" "=y,?y")
12879 (compare:CCEQ (match_operator:SI 1 "boolean_or_operator"
12880 [(not:SI (match_operator:SI 2
12881 "branch_positive_comparison_operator"
12883 "cc_reg_operand" "y,y")
12885 (match_operator:SI 4
12886 "branch_positive_comparison_operator"
12888 "cc_reg_operand" "0,y")
12892 "cr%q1 %E0,%j2,%j4"
12893 [(set_attr "type" "cr_logical,delayed_cr")])
12895 (define_insn "*cceq_rev_compare"
12896 [(set (match_operand:CCEQ 0 "cc_reg_operand" "=y,?y")
12897 (compare:CCEQ (match_operator:SI 1
12898 "branch_positive_comparison_operator"
12900 "cc_reg_operand" "0,y")
12904 "{crnor %E0,%j1,%j1|crnot %E0,%j1}"
12905 [(set_attr "type" "cr_logical,delayed_cr")])
12907 ;; If we are comparing the result of two comparisons, this can be done
12908 ;; using creqv or crxor.
12910 (define_insn_and_split ""
12911 [(set (match_operand:CCEQ 0 "cc_reg_operand" "=y")
12912 (compare:CCEQ (match_operator 1 "branch_comparison_operator"
12913 [(match_operand 2 "cc_reg_operand" "y")
12915 (match_operator 3 "branch_comparison_operator"
12916 [(match_operand 4 "cc_reg_operand" "y")
12921 [(set (match_dup 0) (compare:CCEQ (xor:SI (match_dup 1) (match_dup 3))
12925 int positive_1, positive_2;
12927 positive_1 = branch_positive_comparison_operator (operands[1],
12928 GET_MODE (operands[1]));
12929 positive_2 = branch_positive_comparison_operator (operands[3],
12930 GET_MODE (operands[3]));
12933 operands[1] = gen_rtx_fmt_ee (rs6000_reverse_condition (GET_MODE (operands[2]),
12934 GET_CODE (operands[1])),
12936 operands[2], const0_rtx);
12937 else if (GET_MODE (operands[1]) != SImode)
12938 operands[1] = gen_rtx_fmt_ee (GET_CODE (operands[1]), SImode,
12939 operands[2], const0_rtx);
12942 operands[3] = gen_rtx_fmt_ee (rs6000_reverse_condition (GET_MODE (operands[4]),
12943 GET_CODE (operands[3])),
12945 operands[4], const0_rtx);
12946 else if (GET_MODE (operands[3]) != SImode)
12947 operands[3] = gen_rtx_fmt_ee (GET_CODE (operands[3]), SImode,
12948 operands[4], const0_rtx);
12950 if (positive_1 == positive_2)
12952 operands[1] = gen_rtx_NOT (SImode, operands[1]);
12953 operands[5] = constm1_rtx;
12957 operands[5] = const1_rtx;
12961 ;; Unconditional branch and return.
12963 (define_insn "jump"
12965 (label_ref (match_operand 0 "" "")))]
12968 [(set_attr "type" "branch")])
12970 (define_insn "return"
12974 [(set_attr "type" "jmpreg")])
12976 (define_expand "indirect_jump"
12977 [(set (pc) (match_operand 0 "register_operand" ""))])
12979 (define_insn "*indirect_jump<mode>"
12980 [(set (pc) (match_operand:P 0 "register_operand" "c,*l"))]
12985 [(set_attr "type" "jmpreg")])
12987 ;; Table jump for switch statements:
12988 (define_expand "tablejump"
12989 [(use (match_operand 0 "" ""))
12990 (use (label_ref (match_operand 1 "" "")))]
12995 emit_jump_insn (gen_tablejumpsi (operands[0], operands[1]));
12997 emit_jump_insn (gen_tablejumpdi (operands[0], operands[1]));
13001 (define_expand "tablejumpsi"
13002 [(set (match_dup 3)
13003 (plus:SI (match_operand:SI 0 "" "")
13005 (parallel [(set (pc) (match_dup 3))
13006 (use (label_ref (match_operand 1 "" "")))])]
13009 { operands[0] = force_reg (SImode, operands[0]);
13010 operands[2] = force_reg (SImode, gen_rtx_LABEL_REF (SImode, operands[1]));
13011 operands[3] = gen_reg_rtx (SImode);
13014 (define_expand "tablejumpdi"
13015 [(set (match_dup 4)
13016 (sign_extend:DI (match_operand:SI 0 "lwa_operand" "rm")))
13018 (plus:DI (match_dup 4)
13020 (parallel [(set (pc) (match_dup 3))
13021 (use (label_ref (match_operand 1 "" "")))])]
13024 { operands[2] = force_reg (DImode, gen_rtx_LABEL_REF (DImode, operands[1]));
13025 operands[3] = gen_reg_rtx (DImode);
13026 operands[4] = gen_reg_rtx (DImode);
13029 (define_insn "*tablejump<mode>_internal1"
13031 (match_operand:P 0 "register_operand" "c,*l"))
13032 (use (label_ref (match_operand 1 "" "")))]
13037 [(set_attr "type" "jmpreg")])
13042 "{cror 0,0,0|nop}")
13044 ;; Define the subtract-one-and-jump insns, starting with the template
13045 ;; so loop.c knows what to generate.
13047 (define_expand "doloop_end"
13048 [(use (match_operand 0 "" "")) ; loop pseudo
13049 (use (match_operand 1 "" "")) ; iterations; zero if unknown
13050 (use (match_operand 2 "" "")) ; max iterations
13051 (use (match_operand 3 "" "")) ; loop level
13052 (use (match_operand 4 "" ""))] ; label
13056 /* Only use this on innermost loops. */
13057 if (INTVAL (operands[3]) > 1)
13061 if (GET_MODE (operands[0]) != DImode)
13063 emit_jump_insn (gen_ctrdi (operands[0], operands[4]));
13067 if (GET_MODE (operands[0]) != SImode)
13069 emit_jump_insn (gen_ctrsi (operands[0], operands[4]));
13074 (define_expand "ctr<mode>"
13075 [(parallel [(set (pc)
13076 (if_then_else (ne (match_operand:P 0 "register_operand" "")
13078 (label_ref (match_operand 1 "" ""))
13081 (plus:P (match_dup 0)
13083 (clobber (match_scratch:CC 2 ""))
13084 (clobber (match_scratch:P 3 ""))])]
13088 ;; We need to be able to do this for any operand, including MEM, or we
13089 ;; will cause reload to blow up since we don't allow output reloads on
13091 ;; For the length attribute to be calculated correctly, the
13092 ;; label MUST be operand 0.
13094 (define_insn "*ctr<mode>_internal1"
13096 (if_then_else (ne (match_operand:P 1 "register_operand" "c,*r,*r,*r")
13098 (label_ref (match_operand 0 "" ""))
13100 (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*q*c*l")
13101 (plus:P (match_dup 1)
13103 (clobber (match_scratch:CC 3 "=X,&x,&x,&x"))
13104 (clobber (match_scratch:P 4 "=X,X,&r,r"))]
13108 if (which_alternative != 0)
13110 else if (get_attr_length (insn) == 4)
13111 return \"{bdn|bdnz} %l0\";
13113 return \"bdz $+8\;b %l0\";
13115 [(set_attr "type" "branch")
13116 (set_attr "length" "*,12,16,16")])
13118 (define_insn "*ctr<mode>_internal2"
13120 (if_then_else (ne (match_operand:P 1 "register_operand" "c,*r,*r,*r")
13123 (label_ref (match_operand 0 "" ""))))
13124 (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*q*c*l")
13125 (plus:P (match_dup 1)
13127 (clobber (match_scratch:CC 3 "=X,&x,&x,&x"))
13128 (clobber (match_scratch:P 4 "=X,X,&r,r"))]
13132 if (which_alternative != 0)
13134 else if (get_attr_length (insn) == 4)
13135 return \"bdz %l0\";
13137 return \"{bdn|bdnz} $+8\;b %l0\";
13139 [(set_attr "type" "branch")
13140 (set_attr "length" "*,12,16,16")])
13142 ;; Similar but use EQ
13144 (define_insn "*ctr<mode>_internal5"
13146 (if_then_else (eq (match_operand:P 1 "register_operand" "c,*r,*r,*r")
13148 (label_ref (match_operand 0 "" ""))
13150 (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*q*c*l")
13151 (plus:P (match_dup 1)
13153 (clobber (match_scratch:CC 3 "=X,&x,&x,&x"))
13154 (clobber (match_scratch:P 4 "=X,X,&r,r"))]
13158 if (which_alternative != 0)
13160 else if (get_attr_length (insn) == 4)
13161 return \"bdz %l0\";
13163 return \"{bdn|bdnz} $+8\;b %l0\";
13165 [(set_attr "type" "branch")
13166 (set_attr "length" "*,12,16,16")])
13168 (define_insn "*ctr<mode>_internal6"
13170 (if_then_else (eq (match_operand:P 1 "register_operand" "c,*r,*r,*r")
13173 (label_ref (match_operand 0 "" ""))))
13174 (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*q*c*l")
13175 (plus:P (match_dup 1)
13177 (clobber (match_scratch:CC 3 "=X,&x,&x,&x"))
13178 (clobber (match_scratch:P 4 "=X,X,&r,r"))]
13182 if (which_alternative != 0)
13184 else if (get_attr_length (insn) == 4)
13185 return \"{bdn|bdnz} %l0\";
13187 return \"bdz $+8\;b %l0\";
13189 [(set_attr "type" "branch")
13190 (set_attr "length" "*,12,16,16")])
13192 ;; Now the splitters if we could not allocate the CTR register
13196 (if_then_else (match_operator 2 "comparison_operator"
13197 [(match_operand:P 1 "gpc_reg_operand" "")
13199 (match_operand 5 "" "")
13200 (match_operand 6 "" "")))
13201 (set (match_operand:P 0 "gpc_reg_operand" "")
13202 (plus:P (match_dup 1) (const_int -1)))
13203 (clobber (match_scratch:CC 3 ""))
13204 (clobber (match_scratch:P 4 ""))]
13206 [(parallel [(set (match_dup 3)
13207 (compare:CC (plus:P (match_dup 1)
13211 (plus:P (match_dup 1)
13213 (set (pc) (if_then_else (match_dup 7)
13217 { operands[7] = gen_rtx_fmt_ee (GET_CODE (operands[2]), VOIDmode,
13218 operands[3], const0_rtx); }")
13222 (if_then_else (match_operator 2 "comparison_operator"
13223 [(match_operand:P 1 "gpc_reg_operand" "")
13225 (match_operand 5 "" "")
13226 (match_operand 6 "" "")))
13227 (set (match_operand:P 0 "nonimmediate_operand" "")
13228 (plus:P (match_dup 1) (const_int -1)))
13229 (clobber (match_scratch:CC 3 ""))
13230 (clobber (match_scratch:P 4 ""))]
13231 "reload_completed && ! gpc_reg_operand (operands[0], SImode)"
13232 [(parallel [(set (match_dup 3)
13233 (compare:CC (plus:P (match_dup 1)
13237 (plus:P (match_dup 1)
13241 (set (pc) (if_then_else (match_dup 7)
13245 { operands[7] = gen_rtx_fmt_ee (GET_CODE (operands[2]), VOIDmode,
13246 operands[3], const0_rtx); }")
13248 (define_insn "trap"
13249 [(trap_if (const_int 1) (const_int 0))]
13253 (define_expand "conditional_trap"
13254 [(trap_if (match_operator 0 "trap_comparison_operator"
13255 [(match_dup 2) (match_dup 3)])
13256 (match_operand 1 "const_int_operand" ""))]
13258 "if (rs6000_compare_fp_p || operands[1] != const0_rtx) FAIL;
13259 operands[2] = rs6000_compare_op0;
13260 operands[3] = rs6000_compare_op1;")
13263 [(trap_if (match_operator 0 "trap_comparison_operator"
13264 [(match_operand:GPR 1 "register_operand" "r")
13265 (match_operand:GPR 2 "reg_or_short_operand" "rI")])
13268 "{t|t<wd>}%V0%I2 %1,%2")
13270 ;; Insns related to generating the function prologue and epilogue.
13272 (define_expand "prologue"
13273 [(use (const_int 0))]
13274 "TARGET_SCHED_PROLOG"
13277 rs6000_emit_prologue ();
13281 (define_insn "*movesi_from_cr_one"
13282 [(match_parallel 0 "mfcr_operation"
13283 [(set (match_operand:SI 1 "gpc_reg_operand" "=r")
13284 (unspec:SI [(match_operand:CC 2 "cc_reg_operand" "y")
13285 (match_operand 3 "immediate_operand" "n")]
13286 UNSPEC_MOVESI_FROM_CR))])]
13292 for (i = 0; i < XVECLEN (operands[0], 0); i++)
13294 mask = INTVAL (XVECEXP (SET_SRC (XVECEXP (operands[0], 0, i)), 0, 1));
13295 operands[4] = GEN_INT (mask);
13296 output_asm_insn (\"mfcr %1,%4\", operands);
13300 [(set_attr "type" "mfcrf")])
13302 (define_insn "movesi_from_cr"
13303 [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
13304 (unspec:SI [(reg:CC 68) (reg:CC 69) (reg:CC 70) (reg:CC 71)
13305 (reg:CC 72) (reg:CC 73) (reg:CC 74) (reg:CC 75)]
13306 UNSPEC_MOVESI_FROM_CR))]
13309 [(set_attr "type" "mfcr")])
13311 (define_insn "*stmw"
13312 [(match_parallel 0 "stmw_operation"
13313 [(set (match_operand:SI 1 "memory_operand" "=m")
13314 (match_operand:SI 2 "gpc_reg_operand" "r"))])]
13316 "{stm|stmw} %2,%1")
13318 (define_insn "*save_fpregs_<mode>"
13319 [(match_parallel 0 "any_parallel_operand"
13320 [(clobber (match_operand:P 1 "register_operand" "=l"))
13321 (use (match_operand:P 2 "call_operand" "s"))
13322 (set (match_operand:DF 3 "memory_operand" "=m")
13323 (match_operand:DF 4 "gpc_reg_operand" "f"))])]
13326 [(set_attr "type" "branch")
13327 (set_attr "length" "4")])
13329 ; These are to explain that changes to the stack pointer should
13330 ; not be moved over stores to stack memory.
13331 (define_insn "stack_tie"
13332 [(set (match_operand:BLK 0 "memory_operand" "+m")
13333 (unspec:BLK [(match_dup 0)] UNSPEC_TIE))]
13336 [(set_attr "length" "0")])
13339 (define_expand "epilogue"
13340 [(use (const_int 0))]
13341 "TARGET_SCHED_PROLOG"
13344 rs6000_emit_epilogue (FALSE);
13348 ; On some processors, doing the mtcrf one CC register at a time is
13349 ; faster (like on the 604e). On others, doing them all at once is
13350 ; faster; for instance, on the 601 and 750.
13352 (define_expand "movsi_to_cr_one"
13353 [(set (match_operand:CC 0 "cc_reg_operand" "=y")
13354 (unspec:CC [(match_operand:SI 1 "gpc_reg_operand" "r")
13355 (match_dup 2)] UNSPEC_MOVESI_TO_CR))]
13357 "operands[2] = GEN_INT (1 << (75 - REGNO (operands[0])));")
13359 (define_insn "*movsi_to_cr"
13360 [(match_parallel 0 "mtcrf_operation"
13361 [(set (match_operand:CC 1 "cc_reg_operand" "=y")
13362 (unspec:CC [(match_operand:SI 2 "gpc_reg_operand" "r")
13363 (match_operand 3 "immediate_operand" "n")]
13364 UNSPEC_MOVESI_TO_CR))])]
13370 for (i = 0; i < XVECLEN (operands[0], 0); i++)
13371 mask |= INTVAL (XVECEXP (SET_SRC (XVECEXP (operands[0], 0, i)), 0, 1));
13372 operands[4] = GEN_INT (mask);
13373 return \"mtcrf %4,%2\";
13375 [(set_attr "type" "mtcr")])
13377 (define_insn "*mtcrfsi"
13378 [(set (match_operand:CC 0 "cc_reg_operand" "=y")
13379 (unspec:CC [(match_operand:SI 1 "gpc_reg_operand" "r")
13380 (match_operand 2 "immediate_operand" "n")]
13381 UNSPEC_MOVESI_TO_CR))]
13382 "GET_CODE (operands[0]) == REG
13383 && CR_REGNO_P (REGNO (operands[0]))
13384 && GET_CODE (operands[2]) == CONST_INT
13385 && INTVAL (operands[2]) == 1 << (75 - REGNO (operands[0]))"
13387 [(set_attr "type" "mtcr")])
13389 ; The load-multiple instructions have similar properties.
13390 ; Note that "load_multiple" is a name known to the machine-independent
13391 ; code that actually corresponds to the powerpc load-string.
13393 (define_insn "*lmw"
13394 [(match_parallel 0 "lmw_operation"
13395 [(set (match_operand:SI 1 "gpc_reg_operand" "=r")
13396 (match_operand:SI 2 "memory_operand" "m"))])]
13400 (define_insn "*return_internal_<mode>"
13402 (use (match_operand:P 0 "register_operand" "lc"))]
13405 [(set_attr "type" "jmpreg")])
13407 ; FIXME: This would probably be somewhat simpler if the Cygnus sibcall
13408 ; stuff was in GCC. Oh, and "any_parallel_operand" is a bit flexible...
13410 (define_insn "*return_and_restore_fpregs_<mode>"
13411 [(match_parallel 0 "any_parallel_operand"
13413 (use (match_operand:P 1 "register_operand" "l"))
13414 (use (match_operand:P 2 "call_operand" "s"))
13415 (set (match_operand:DF 3 "gpc_reg_operand" "=f")
13416 (match_operand:DF 4 "memory_operand" "m"))])]
13420 ; This is used in compiling the unwind routines.
13421 (define_expand "eh_return"
13422 [(use (match_operand 0 "general_operand" ""))]
13427 emit_insn (gen_eh_set_lr_si (operands[0]));
13429 emit_insn (gen_eh_set_lr_di (operands[0]));
13433 ; We can't expand this before we know where the link register is stored.
13434 (define_insn "eh_set_lr_<mode>"
13435 [(unspec_volatile [(match_operand:P 0 "register_operand" "r")]
13437 (clobber (match_scratch:P 1 "=&b"))]
13442 [(unspec_volatile [(match_operand 0 "register_operand" "")] UNSPECV_EH_RR)
13443 (clobber (match_scratch 1 ""))]
13448 rs6000_emit_eh_reg_restore (operands[0], operands[1]);
13452 (define_insn "prefetch"
13453 [(prefetch (match_operand 0 "indexed_or_indirect_address" "a")
13454 (match_operand:SI 1 "const_int_operand" "n")
13455 (match_operand:SI 2 "const_int_operand" "n"))]
13459 if (GET_CODE (operands[0]) == REG)
13460 return INTVAL (operands[1]) ? \"dcbtst 0,%0\" : \"dcbt 0,%0\";
13461 return INTVAL (operands[1]) ? \"dcbtst %a0\" : \"dcbt %a0\";
13463 [(set_attr "type" "load")])
13466 (include "sync.md")
13467 (include "altivec.md")