1 ;; GCC machine description for Hitachi H8/300
2 ;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 ;; 2001, 2002, 2003 Free Software Foundation, Inc.
5 ;; Contributed by Steve Chamberlain (sac@cygnus.com),
6 ;; Jim Wilson (wilson@cygnus.com), and Doug Evans (dje@cygnus.com).
8 ;; This file is part of GCC.
10 ;; GCC is free software; you can redistribute it and/or modify
11 ;; it under the terms of the GNU General Public License as published by
12 ;; the Free Software Foundation; either version 2, or (at your option)
15 ;; GCC is distributed in the hope that it will be useful,
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 ;; GNU General Public License for more details.
20 ;; You should have received a copy of the GNU General Public License
21 ;; along with GCC; see the file COPYING. If not, write to
22 ;; the Free Software Foundation, 59 Temple Place - Suite 330,
23 ;; Boston, MA 02111-1307, USA.
25 ;; We compute exact length on each instruction for most of the time.
26 ;; In some case, most notably bit operations that may involve memory
27 ;; operands, the lengths in this file are "worst case".
29 ;; On the H8/300H and H8S, adds/subs operate on the 32bit "er"
30 ;; registers. Right now GCC doesn't expose the "e" half to the
31 ;; compiler, so using add/subs for addhi and subhi is safe. Long
32 ;; term, we want to expose the "e" half to the compiler (gives us 8
33 ;; more 16bit registers). At that point addhi and subhi can't use
36 ;; There's currently no way to have an insv/extzv expander for the H8/300H
37 ;; because word_mode is different for the H8/300 and H8/300H.
39 ;; Shifts/rotates by small constants should be handled by special
40 ;; patterns so we get the length and cc status correct.
42 ;; Bitfield operations no longer accept memory operands. We need
43 ;; to add variants which operate on memory back to the MD.
45 ;; ??? Implement remaining bit ops available on the h8300
47 ;; ----------------------------------------------------------------------
49 ;; ----------------------------------------------------------------------
63 ;; ----------------------------------------------------------------------
65 ;; ----------------------------------------------------------------------
67 (define_attr "cpu" "h8300,h8300h"
68 (const (symbol_ref "cpu_type")))
70 (define_attr "type" "branch,arith"
71 (const_string "arith"))
73 ;; The size of instructions in bytes.
75 (define_attr "length" ""
76 (cond [(eq_attr "type" "branch")
77 (if_then_else (and (ge (minus (match_dup 0) (pc))
79 (le (minus (match_dup 0) (pc))
82 (if_then_else (and (eq_attr "cpu" "h8300h")
83 (and (ge (minus (pc) (match_dup 0))
85 (le (minus (pc) (match_dup 0))
91 ;; Condition code settings.
93 ;; none - insn does not affect cc
94 ;; none_0hit - insn does not affect cc but it does modify operand 0
95 ;; This attribute is used to keep track of when operand 0 changes.
96 ;; See the description of NOTICE_UPDATE_CC for more info.
97 ;; set_znv - insn sets z,n,v to usable values (like a tst insn); c is unknown.
98 ;; set_zn - insn sets z,n to usable values; v,c are unknown.
99 ;; compare - compare instruction
100 ;; clobber - value of cc is unknown
102 (define_attr "cc" "none,none_0hit,set_znv,set_zn,compare,clobber"
103 (const_string "clobber"))
105 ;; ----------------------------------------------------------------------
107 ;; ----------------------------------------------------------------------
111 (define_insn "pushqi1_h8300"
112 [(parallel [(set (reg:HI SP_REG)
113 (plus:HI (reg:HI SP_REG) (const_int -2)))
114 (set (mem:QI (plus:HI (reg:HI SP_REG) (const_int -1)))
115 (match_operand:QI 0 "register_operand" "r"))])]
117 && REGNO (operands[0]) != SP_REG"
119 [(set_attr "length" "2")
120 (set_attr "cc" "clobber")])
122 (define_insn "pushqi1_h8300hs"
123 [(parallel [(set (reg:SI SP_REG)
124 (plus:SI (reg:SI SP_REG) (const_int -4)))
125 (set (mem:QI (plus:SI (reg:SI SP_REG) (const_int -3)))
126 (match_operand:QI 0 "register_operand" "r"))])]
127 "(TARGET_H8300H || TARGET_H8300S)
128 && REGNO (operands[0]) != SP_REG"
129 "mov.w\\t%f0,@-er7\;subs\\t#2,er7"
130 [(set_attr "length" "4")
131 (set_attr "cc" "clobber")])
133 (define_expand "pushqi1"
134 [(use (match_operand:QI 0 "register_operand" ""))]
139 emit_insn (gen_pushqi1_h8300 (operands[0]));
141 emit_insn (gen_pushqi1_h8300hs (operands[0]));
145 (define_insn "*movqi_h8300"
146 [(set (match_operand:QI 0 "general_operand_dst" "=r,r ,<,r,r,m")
147 (match_operand:QI 1 "general_operand_src" " I,r>,r,n,m,r"))]
149 && (register_operand (operands[0], QImode)
150 || register_operand (operands[1], QImode))"
158 [(set_attr "length" "2,2,2,2,4,4")
159 (set_attr "cc" "set_zn,set_znv,set_znv,set_znv,set_znv,set_znv")])
161 (define_insn "*movqi_h8300hs"
162 [(set (match_operand:QI 0 "general_operand_dst" "=r,r ,<,r,r,m")
163 (match_operand:QI 1 "general_operand_src" " I,r>,r,n,m,r"))]
164 "(TARGET_H8300H || TARGET_H8300S)
165 && (register_operand (operands[0], QImode)
166 || register_operand (operands[1], QImode))"
174 [(set (attr "length")
175 (symbol_ref "compute_mov_length (operands)"))
176 (set_attr "cc" "set_zn,set_znv,set_znv,clobber,set_znv,set_znv")])
178 (define_expand "movqi"
179 [(set (match_operand:QI 0 "general_operand_dst" "")
180 (match_operand:QI 1 "general_operand_src" ""))]
184 /* One of the ops has to be in a register. */
185 if (!register_operand (operand0, QImode)
186 && !register_operand (operand1, QImode))
188 operands[1] = copy_to_mode_reg (QImode, operand1);
192 (define_insn "movstrictqi"
193 [(set (strict_low_part (match_operand:QI 0 "general_operand_dst" "+r,r,r,r"))
194 (match_operand:QI 1 "general_operand_src" "I,r,n,m"))]
201 [(set (attr "length")
202 (symbol_ref "compute_mov_length (operands)"))
203 (set_attr "cc" "set_zn,set_znv,set_znv,set_znv")])
207 (define_expand "pushhi1_h8300"
208 [(set (mem:HI (pre_dec:HI (reg:HI SP_REG)))
209 (match_operand:HI 0 "register_operand" ""))]
211 && REGNO (operands[0]) != SP_REG"
214 (define_insn "pushhi1_h8300hs"
215 [(parallel [(set (reg:SI SP_REG)
216 (plus:SI (reg:SI SP_REG) (const_int -4)))
217 (set (mem:HI (plus:SI (reg:SI SP_REG) (const_int -2)))
218 (match_operand:HI 0 "register_operand" "r"))])]
219 "(TARGET_H8300H || TARGET_H8300S)
220 && REGNO (operands[0]) != SP_REG"
221 "mov.w\\t%f0,@-er7\;subs\\t#2,er7"
222 [(set_attr "length" "4")
223 (set_attr "cc" "clobber")])
225 (define_expand "pushhi1"
226 [(use (match_operand:HI 0 "register_operand" ""))]
231 emit_insn (gen_pushhi1_h8300 (operands[0]));
233 emit_insn (gen_pushhi1_h8300hs (operands[0]));
237 (define_insn "*movhi_h8300"
238 [(set (match_operand:HI 0 "general_operand_dst" "=r,r,<,r,r,m")
239 (match_operand:HI 1 "general_operand_src" "I,r>,r,i,m,r"))]
241 && (register_operand (operands[0], HImode)
242 || register_operand (operands[1], HImode))
243 && !(GET_CODE (operands[0]) == MEM
244 && GET_CODE (XEXP (operands[0], 0)) == PRE_DEC
245 && GET_CODE (XEXP (XEXP (operands[0], 0), 0)) == REG
246 && GET_CODE (operands[1]) == REG
247 && REGNO (XEXP (XEXP (operands[0], 0), 0)) == REGNO (operands[1]))"
255 [(set (attr "length")
256 (symbol_ref "compute_mov_length (operands)"))
257 (set_attr "cc" "set_zn,set_znv,set_znv,set_znv,set_znv,set_znv")])
259 (define_insn "*movhi_h8300hs"
260 [(set (match_operand:HI 0 "general_operand_dst" "=r,r,<,r,r,m")
261 (match_operand:HI 1 "general_operand_src" "I,r>,r,i,m,r"))]
262 "(TARGET_H8300H || TARGET_H8300S)
263 && (register_operand (operands[0], HImode)
264 || register_operand (operands[1], HImode))"
272 [(set (attr "length")
273 (symbol_ref "compute_mov_length (operands)"))
274 (set_attr "cc" "set_zn,set_znv,set_znv,set_znv,set_znv,set_znv")])
276 (define_expand "movhi"
277 [(set (match_operand:HI 0 "general_operand_dst" "")
278 (match_operand:HI 1 "general_operand_src" ""))]
282 /* One of the ops has to be in a register. */
283 if (!register_operand (operand1, HImode)
284 && !register_operand (operand0, HImode))
286 operands[1] = copy_to_mode_reg (HImode, operand1);
290 (define_insn "movstricthi"
291 [(set (strict_low_part (match_operand:HI 0 "general_operand_dst" "+r,r,r,r"))
292 (match_operand:HI 1 "general_operand_src" "I,r,i,m"))]
299 [(set (attr "length")
300 (symbol_ref "compute_mov_length (operands)"))
301 (set_attr "cc" "set_zn,set_znv,set_znv,set_znv")])
305 (define_expand "movsi"
306 [(set (match_operand:SI 0 "general_operand_dst" "")
307 (match_operand:SI 1 "general_operand_src" ""))]
313 if (do_movsi (operands))
318 /* One of the ops has to be in a register. */
319 if (!register_operand (operand1, SImode)
320 && !register_operand (operand0, SImode))
322 operands[1] = copy_to_mode_reg (SImode, operand1);
327 (define_expand "movsf"
328 [(set (match_operand:SF 0 "general_operand_dst" "")
329 (match_operand:SF 1 "general_operand_src" ""))]
335 if (do_movsi (operands))
340 /* One of the ops has to be in a register. */
341 if (!register_operand (operand1, SFmode)
342 && !register_operand (operand0, SFmode))
344 operands[1] = copy_to_mode_reg (SFmode, operand1);
349 (define_insn "*movsi_h8300"
350 [(set (match_operand:SI 0 "general_operand_dst" "=r,r,r,o,<,r")
351 (match_operand:SI 1 "general_operand_src" "I,r,io,r,r,>"))]
353 && (register_operand (operands[0], SImode)
354 || register_operand (operands[1], SImode))"
357 unsigned int rn = -1;
358 switch (which_alternative)
361 return \"sub.w %e0,%e0\;sub.w %f0,%f0\";
363 if (REGNO (operands[0]) < REGNO (operands[1]))
364 return \"mov.w %e1,%e0\;mov.w %f1,%f0\";
366 return \"mov.w %f1,%f0\;mov.w %e1,%e0\";
368 /* Make sure we don't trample the register we index with. */
369 if (GET_CODE (operands[1]) == MEM)
371 rtx inside = XEXP (operands[1], 0);
376 else if (GET_CODE (inside) == PLUS)
378 rtx lhs = XEXP (inside, 0);
379 rtx rhs = XEXP (inside, 1);
380 if (REG_P (lhs)) rn = REGNO (lhs);
381 if (REG_P (rhs)) rn = REGNO (rhs);
384 if (rn == REGNO (operands[0]))
386 /* Move the second word first. */
387 return \"mov.w %f1,%f0\;mov.w %e1,%e0\";
391 if (GET_CODE (operands[1]) == CONST_INT)
393 /* If either half is zero, use sub.w to clear that
395 if ((INTVAL (operands[1]) & 0xffff) == 0)
396 return \"mov.w %e1,%e0\;sub.w %f0,%f0\";
397 if (((INTVAL (operands[1]) >> 16) & 0xffff) == 0)
398 return \"sub.w %e0,%e0\;mov.w %f1,%f0\";
399 /* If the upper half and the lower half are the same,
400 copy one half to the other. */
401 if ((INTVAL (operands[1]) & 0xffff)
402 == ((INTVAL (operands[1]) >> 16) & 0xffff))
403 return \"mov.w\\t%e1,%e0\;mov.w\\t%e0,%f0\";
405 return \"mov.w %e1,%e0\;mov.w %f1,%f0\";
408 return \"mov.w %e1,%e0\;mov.w %f1,%f0\";
410 return \"mov.w %f1,%T0\;mov.w %e1,%T0\";
412 return \"mov.w %T1,%e0\;mov.w %T1,%f0\";
417 [(set (attr "length")
418 (symbol_ref "compute_mov_length (operands)"))
419 (set_attr "cc" "clobber")])
421 (define_insn "*movsf_h8300"
422 [(set (match_operand:SF 0 "general_operand_dst" "=r,r,r,o,<,r")
423 (match_operand:SF 1 "general_operand_src" "G,r,io,r,r,>"))]
425 && (register_operand (operands[0], SFmode)
426 || register_operand (operands[1], SFmode))"
429 /* Copy of the movsi stuff. */
430 unsigned int rn = -1;
431 switch (which_alternative)
434 return \"sub.w %e0,%e0\;sub.w %f0,%f0\";
436 if (REGNO (operands[0]) < REGNO (operands[1]))
437 return \"mov.w %e1,%e0\;mov.w %f1,%f0\";
439 return \"mov.w %f1,%f0\;mov.w %e1,%e0\";
441 /* Make sure we don't trample the register we index with. */
442 if (GET_CODE (operands[1]) == MEM)
444 rtx inside = XEXP (operands[1], 0);
449 else if (GET_CODE (inside) == PLUS)
451 rtx lhs = XEXP (inside, 0);
452 rtx rhs = XEXP (inside, 1);
453 if (REG_P (lhs)) rn = REGNO (lhs);
454 if (REG_P (rhs)) rn = REGNO (rhs);
457 if (rn == REGNO (operands[0]))
458 /* Move the second word first. */
459 return \"mov.w %f1,%f0\;mov.w %e1,%e0\";
461 /* Move the first word first. */
462 return \"mov.w %e1,%e0\;mov.w %f1,%f0\";
465 return \"mov.w %e1,%e0\;mov.w %f1,%f0\";
467 return \"mov.w %f1,%T0\;mov.w %e1,%T0\";
469 return \"mov.w %T1,%e0\;mov.w %T1,%f0\";
474 [(set (attr "length")
475 (symbol_ref "compute_mov_length (operands)"))
476 (set_attr "cc" "clobber")])
478 (define_insn "*movsi_h8300hs"
479 [(set (match_operand:SI 0 "general_operand_dst" "=r,r,r,<,r,r,m,*a,*a,r")
480 (match_operand:SI 1 "general_operand_src" "I,r,i,r,>,m,r,I,r,*a"))]
481 "(TARGET_H8300S || TARGET_H8300H)
482 && (register_operand (operands[0], SImode)
483 || register_operand (operands[1], SImode))
484 && !(GET_CODE (operands[0]) == MEM
485 && GET_CODE (XEXP (operands[0], 0)) == PRE_DEC
486 && GET_CODE (XEXP (XEXP (operands[0], 0), 0)) == REG
487 && GET_CODE (operands[1]) == REG
488 && REGNO (XEXP (XEXP (operands[0], 0), 0)) == REGNO (operands[1]))"
491 switch (which_alternative)
494 return \"sub.l %S0,%S0\";
498 return \"clrmac\;ldmac %1,macl\";
500 return \"stmac macl,%0\";
502 if (GET_CODE (operands[1]) == CONST_INT)
504 int val = INTVAL (operands[1]);
506 /* Look for constants which can be made by adding an 8-bit
507 number to zero in one of the two low bytes. */
508 if (val == (val & 0xff))
510 operands[1] = GEN_INT ((char) val & 0xff);
511 return \"sub.l\\t%S0,%S0\;add.b\\t%1,%w0\";
514 if (val == (val & 0xff00))
516 operands[1] = GEN_INT ((char) (val >> 8) & 0xff);
517 return \"sub.l\\t%S0,%S0\;add.b\\t%1,%x0\";
520 /* Look for constants that can be obtained by subs, inc, and
522 switch (val & 0xffffffff)
525 return \"sub.l\\t%S0,%S0\;subs\\t#1,%S0\";
527 return \"sub.l\\t%S0,%S0\;subs\\t#2,%S0\";
529 return \"sub.l\\t%S0,%S0\;subs\\t#4,%S0\";
532 return \"sub.l\\t%S0,%S0\;dec.w\\t#1,%f0\";
534 return \"sub.l\\t%S0,%S0\;dec.w\\t#2,%f0\";
537 return \"sub.l\\t%S0,%S0\;dec.w\\t#1,%e0\";
539 return \"sub.l\\t%S0,%S0\;dec.w\\t#2,%e0\";
542 return \"sub.l\\t%S0,%S0\;inc.w\\t#1,%e0\";
544 return \"sub.l\\t%S0,%S0\;inc.w\\t#2,%e0\";
548 return \"mov.l %S1,%S0\";
550 [(set (attr "length")
551 (symbol_ref "compute_mov_length (operands)"))
552 (set_attr "cc" "set_zn,set_znv,clobber,set_znv,set_znv,set_znv,set_znv,none_0hit,none_0hit,set_znv")])
554 (define_insn "*movsf_h8300h"
555 [(set (match_operand:SF 0 "general_operand_dst" "=r,r,r,m,<,r")
556 (match_operand:SF 1 "general_operand_src" "G,r,im,r,r,>"))]
557 "(TARGET_H8300H || TARGET_H8300S)
558 && (register_operand (operands[0], SFmode)
559 || register_operand (operands[1], SFmode))"
567 [(set (attr "length")
568 (symbol_ref "compute_mov_length (operands)"))
569 (set_attr "cc" "set_zn,set_znv,set_znv,set_znv,set_znv,set_znv")])
571 ;; ----------------------------------------------------------------------
573 ;; ----------------------------------------------------------------------
576 [(set (cc0) (zero_extract:HI (match_operand:QI 0 "bit_memory_operand" "r,U")
578 (match_operand 1 "const_int_operand" "n,n")))]
581 [(set_attr "length" "2,4")
582 (set_attr "cc" "set_zn,set_zn")])
585 [(set (cc0) (zero_extract:HI (match_operand:HI 0 "register_operand" "r")
587 (match_operand 1 "const_int_operand" "n")))]
590 [(set_attr "length" "2")
591 (set_attr "cc" "set_zn")])
593 (define_insn "*tst_extzv_1_n"
595 (zero_extract:SI (match_operand:QI 0 "general_operand_src" "r,U,mn>")
597 (match_operand 1 "const_int_operand" "n,n,n")))
598 (clobber (match_scratch:QI 2 "=X,X,&r"))]
599 "(TARGET_H8300H || TARGET_H8300S)"
604 [(set_attr "length" "2,8,10")
605 (set_attr "cc" "set_zn,set_zn,set_zn")])
609 (zero_extract:SI (match_operand:QI 0 "general_operand" "")
611 (match_operand 1 "const_int_operand" "")))
612 (clobber (match_operand:QI 2 "register_operand" ""))]
613 "(TARGET_H8300H || TARGET_H8300S)
615 && !EXTRA_CONSTRAINT (operands[0], 'U')"
618 (parallel [(set (cc0) (zero_extract:SI (match_dup 2)
621 (clobber (scratch:QI))])]
625 [(set (cc0) (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
627 (match_operand 1 "const_int_operand" "n")))]
628 "(TARGET_H8300H || TARGET_H8300S)
629 && INTVAL (operands[1]) <= 15"
631 [(set_attr "length" "2")
632 (set_attr "cc" "set_zn")])
634 (define_insn_and_split "*tstsi_upper_bit"
636 (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
638 (match_operand 1 "const_int_operand" "n")))
639 (clobber (match_scratch:SI 2 "=&r"))]
640 "(TARGET_H8300H || TARGET_H8300S)
641 && INTVAL (operands[1]) >= 16"
643 "&& reload_completed"
645 (ior:SI (and:SI (match_dup 2)
647 (lshiftrt:SI (match_dup 0)
650 (zero_extract:SI (match_dup 2)
653 "operands[3] = GEN_INT (INTVAL (operands[1]) - 16);")
657 (and:HI (match_operand:HI 0 "register_operand" "r")
658 (match_operand:HI 1 "single_one_operand" "n")))]
662 operands[1] = GEN_INT (INTVAL (operands[1]) & 0xffff);
663 if (INTVAL (operands[1]) > 128)
665 operands[1] = GEN_INT (INTVAL (operands[1]) >> 8);
666 return \"btst\\t%V1,%t0\";
668 return \"btst\\t%V1,%s0\";
670 [(set_attr "length" "2")
671 (set_attr "cc" "set_zn")])
675 (and:SI (match_operand:SI 0 "register_operand" "r")
676 (match_operand:SI 1 "single_one_operand" "n")))]
677 "(TARGET_H8300H || TARGET_H8300S)
678 && (INTVAL (operands[1]) & 0xffff) != 0"
681 operands[1] = GEN_INT (INTVAL (operands[1]) & 0xffff);
682 if (INTVAL (operands[1]) > 128)
684 operands[1] = GEN_INT (INTVAL (operands[1]) >> 8);
685 return \"btst\\t%V1,%x0\";
687 return \"btst\\t%V1,%w0\";
689 [(set_attr "length" "2")
690 (set_attr "cc" "set_zn")])
693 [(set (cc0) (match_operand:QI 0 "register_operand" "r"))]
696 [(set_attr "length" "2")
697 (set_attr "cc" "set_znv")])
700 [(set (cc0) (match_operand:HI 0 "register_operand" "r"))]
703 [(set_attr "length" "2")
704 (set_attr "cc" "set_znv")])
708 (and:HI (match_operand:HI 0 "register_operand" "r")
712 [(set_attr "length" "2")
713 (set_attr "cc" "set_znv")])
716 [(set (cc0) (match_operand:SI 0 "register_operand" "r"))]
717 "TARGET_H8300H || TARGET_H8300S"
719 [(set_attr "length" "2")
720 (set_attr "cc" "set_znv")])
724 (and:SI (match_operand:SI 0 "register_operand" "r")
725 (const_int -65536)))]
728 [(set_attr "length" "2")
729 (set_attr "cc" "set_znv")])
733 (compare (match_operand:QI 0 "register_operand" "r")
734 (match_operand:QI 1 "nonmemory_operand" "rn")))]
737 [(set_attr "length" "2")
738 (set_attr "cc" "compare")])
740 (define_expand "cmphi"
742 (compare (match_operand:HI 0 "register_operand" "")
743 (match_operand:HI 1 "nonmemory_operand" "")))]
747 /* Force operand1 into a register if we're compiling
749 if (GET_CODE (operands[1]) != REG && TARGET_H8300)
750 operands[1] = force_reg (HImode, operands[1]);
753 (define_insn "*cmphi_h8300"
755 (compare (match_operand:HI 0 "register_operand" "r")
756 (match_operand:HI 1 "register_operand" "r")))]
759 [(set_attr "length" "2")
760 (set_attr "cc" "compare")])
762 (define_insn "*cmphi_h8300hs"
764 (compare (match_operand:HI 0 "register_operand" "r,r")
765 (match_operand:HI 1 "nonmemory_operand" "r,n")))]
766 "TARGET_H8300H || TARGET_H8300S"
768 [(set_attr "length" "2,4")
769 (set_attr "cc" "compare,compare")])
773 (compare (match_operand:SI 0 "register_operand" "r,r")
774 (match_operand:SI 1 "nonmemory_operand" "r,i")))]
775 "TARGET_H8300H || TARGET_H8300S"
777 [(set_attr "length" "2,6")
778 (set_attr "cc" "compare,compare")])
780 ;; ----------------------------------------------------------------------
782 ;; ----------------------------------------------------------------------
784 (define_insn "addqi3"
785 [(set (match_operand:QI 0 "register_operand" "=r")
786 (plus:QI (match_operand:QI 1 "register_operand" "%0")
787 (match_operand:QI 2 "nonmemory_operand" "rn")))]
790 [(set_attr "length" "2")
791 (set_attr "cc" "set_zn")])
793 (define_expand "addhi3"
794 [(set (match_operand:HI 0 "register_operand" "")
795 (plus:HI (match_operand:HI 1 "register_operand" "")
796 (match_operand:HI 2 "nonmemory_operand" "")))]
800 (define_insn "*addhi3_h8300"
801 [(set (match_operand:HI 0 "register_operand" "=r,r,r,r,r")
802 (plus:HI (match_operand:HI 1 "register_operand" "%0,0,0,0,0")
803 (match_operand:HI 2 "nonmemory_operand" "L,N,J,n,r")))]
809 add.b %s2,%s0\;addx %t2,%t0
811 [(set_attr "length" "2,2,2,4,2")
812 (set_attr "cc" "none_0hit,none_0hit,clobber,clobber,set_zn")])
814 ;; This splitter is very important to make the stack adjustment
815 ;; interrupt-safe. The combination of add.b and addx is unsafe!
817 ;; We apply this split after the peephole2 pass so that we won't end
818 ;; up creating too many adds/subs when a scratch register is
819 ;; available, which is actually a common case because stack unrolling
820 ;; tends to happen immediately after a function call.
823 [(set (match_operand:HI 0 "stack_pointer_operand" "")
824 (plus:HI (match_dup 0)
825 (match_operand 1 "const_int_gt_2_operand" "")))]
826 "TARGET_H8300 && flow2_completed"
828 "split_adds_subs (HImode, operands); DONE;")
831 [(match_scratch:HI 2 "r")
832 (set (match_operand:HI 0 "stack_pointer_operand" "")
833 (plus:HI (match_dup 0)
834 (match_operand:HI 1 "const_int_ge_8_operand" "")))]
839 (plus:HI (match_dup 0)
843 (define_insn "*addhi3_h8300hs"
844 [(set (match_operand:HI 0 "register_operand" "=r,r,r,r,r")
845 (plus:HI (match_operand:HI 1 "register_operand" "%0,0,0,0,0")
846 (match_operand:HI 2 "nonmemory_operand" "L,N,J,n,r")))]
847 "TARGET_H8300H || TARGET_H8300S"
854 [(set_attr "length" "2,2,2,4,2")
855 (set_attr "cc" "none_0hit,none_0hit,clobber,set_zn,set_zn")])
857 (define_insn "*addhi3_incdec"
858 [(set (match_operand:HI 0 "register_operand" "=r,r")
859 (unspec:HI [(match_operand:HI 1 "register_operand" "0,0")
860 (match_operand:HI 2 "incdec_operand" "M,O")]
862 "TARGET_H8300H || TARGET_H8300S"
866 [(set_attr "length" "2,2")
867 (set_attr "cc" "set_zn,set_zn")])
870 [(set (match_operand:HI 0 "register_operand" "")
871 (plus:HI (match_dup 0)
872 (match_operand:HI 1 "two_insn_adds_subs_operand" "")))]
875 "split_adds_subs (HImode, operands); DONE;")
877 (define_expand "addsi3"
878 [(set (match_operand:SI 0 "register_operand" "")
879 (plus:SI (match_operand:SI 1 "register_operand" "")
880 (match_operand:SI 2 "nonmemory_operand" "")))]
884 (define_insn "addsi_h8300"
885 [(set (match_operand:SI 0 "register_operand" "=r,r")
886 (plus:SI (match_operand:SI 1 "register_operand" "%0,0")
887 (match_operand:SI 2 "nonmemory_operand" "n,r")))]
889 "* return output_plussi (operands);"
890 [(set (attr "length")
891 (symbol_ref "compute_plussi_length (operands)"))
893 (symbol_ref "compute_plussi_cc (operands)"))])
895 (define_insn "addsi_h8300h"
896 [(set (match_operand:SI 0 "register_operand" "=r,r")
897 (plus:SI (match_operand:SI 1 "register_operand" "%0,0")
898 (match_operand:SI 2 "nonmemory_operand" "i,r")))]
899 "TARGET_H8300H || TARGET_H8300S"
900 "* return output_plussi (operands);"
901 [(set (attr "length")
902 (symbol_ref "compute_plussi_length (operands)"))
904 (symbol_ref "compute_plussi_cc (operands)"))])
906 (define_insn "*addsi3_incdec"
907 [(set (match_operand:SI 0 "register_operand" "=r,r")
908 (unspec:SI [(match_operand:SI 1 "register_operand" "0,0")
909 (match_operand:SI 2 "incdec_operand" "M,O")]
911 "TARGET_H8300H || TARGET_H8300S"
915 [(set_attr "length" "2,2")
916 (set_attr "cc" "set_zn,set_zn")])
919 [(set (match_operand:SI 0 "register_operand" "")
920 (plus:SI (match_dup 0)
921 (match_operand:SI 1 "two_insn_adds_subs_operand" "")))]
922 "TARGET_H8300H || TARGET_H8300S"
924 "split_adds_subs (SImode, operands); DONE;")
926 ;; ----------------------------------------------------------------------
927 ;; SUBTRACT INSTRUCTIONS
928 ;; ----------------------------------------------------------------------
930 (define_insn "subqi3"
931 [(set (match_operand:QI 0 "register_operand" "=r")
932 (minus:QI (match_operand:QI 1 "register_operand" "0")
933 (match_operand:QI 2 "register_operand" "r")))]
936 [(set_attr "length" "2")
937 (set_attr "cc" "set_zn")])
939 (define_expand "subhi3"
940 [(set (match_operand:HI 0 "register_operand" "")
941 (minus:HI (match_operand:HI 1 "general_operand" "")
942 (match_operand:HI 2 "nonmemory_operand" "")))]
947 [(set (match_operand:HI 0 "register_operand" "=r,&r")
948 (minus:HI (match_operand:HI 1 "general_operand" "0,0")
949 (match_operand:HI 2 "nonmemory_operand" "r,n")))]
953 add.b %E2,%s0\;addx %F2,%t0"
954 [(set_attr "length" "2,4")
955 (set_attr "cc" "set_zn,clobber")])
958 [(set (match_operand:HI 0 "register_operand" "=r,&r")
959 (minus:HI (match_operand:HI 1 "general_operand" "0,0")
960 (match_operand:HI 2 "nonmemory_operand" "r,n")))]
961 "TARGET_H8300H || TARGET_H8300S"
965 [(set_attr "length" "2,4")
966 (set_attr "cc" "set_zn,set_zn")])
968 (define_expand "subsi3"
969 [(set (match_operand:SI 0 "register_operand" "")
970 (minus:SI (match_operand:SI 1 "register_operand" "")
971 (match_operand:SI 2 "nonmemory_operand" "")))]
975 (define_insn "subsi3_h8300"
976 [(set (match_operand:SI 0 "register_operand" "=r")
977 (minus:SI (match_operand:SI 1 "register_operand" "0")
978 (match_operand:SI 2 "register_operand" "r")))]
980 "sub.w %f2,%f0\;subx %y2,%y0\;subx %z2,%z0"
981 [(set_attr "length" "6")
982 (set_attr "cc" "clobber")])
984 (define_insn "subsi3_h8300h"
985 [(set (match_operand:SI 0 "register_operand" "=r,r")
986 (minus:SI (match_operand:SI 1 "general_operand" "0,0")
987 (match_operand:SI 2 "nonmemory_operand" "r,i")))]
988 "TARGET_H8300H || TARGET_H8300S"
992 [(set_attr "length" "2,6")
993 (set_attr "cc" "set_zn,set_zn")])
995 ;; ----------------------------------------------------------------------
996 ;; MULTIPLY INSTRUCTIONS
997 ;; ----------------------------------------------------------------------
999 ;; Note that the H8/300 can only handle umulqihi3.
1001 (define_insn "mulqihi3"
1002 [(set (match_operand:HI 0 "register_operand" "=r")
1003 (mult:HI (sign_extend:HI (match_operand:QI 1 "register_operand" "%0"))
1004 (sign_extend:HI (match_operand:QI 2 "register_operand" "r"))))]
1005 "TARGET_H8300H || TARGET_H8300S"
1007 [(set_attr "length" "4")
1008 (set_attr "cc" "set_zn")])
1010 (define_insn "mulhisi3"
1011 [(set (match_operand:SI 0 "register_operand" "=r")
1012 (mult:SI (sign_extend:SI (match_operand:HI 1 "register_operand" "%0"))
1013 (sign_extend:SI (match_operand:HI 2 "register_operand" "r"))))]
1014 "TARGET_H8300H || TARGET_H8300S"
1016 [(set_attr "length" "4")
1017 (set_attr "cc" "set_zn")])
1019 (define_insn "umulqihi3"
1020 [(set (match_operand:HI 0 "register_operand" "=r")
1021 (mult:HI (zero_extend:HI (match_operand:QI 1 "register_operand" "%0"))
1022 (zero_extend:HI (match_operand:QI 2 "register_operand" "r"))))]
1025 [(set_attr "length" "2")
1026 (set_attr "cc" "none_0hit")])
1028 (define_insn "umulhisi3"
1029 [(set (match_operand:SI 0 "register_operand" "=r")
1030 (mult:SI (zero_extend:SI (match_operand:HI 1 "register_operand" "%0"))
1031 (zero_extend:SI (match_operand:HI 2 "register_operand" "r"))))]
1032 "TARGET_H8300H || TARGET_H8300S"
1034 [(set_attr "length" "2")
1035 (set_attr "cc" "none_0hit")])
1037 ;; This is a "bridge" instruction. Combine can't cram enough insns
1038 ;; together to crate a MAC instruction directly, but it can create
1039 ;; this instruction, which then allows combine to create the real
1042 ;; Unfortunately, if combine doesn't create a MAC instruction, this
1043 ;; insn must generate reasonably correct code. Egad.
1045 [(set (match_operand:SI 0 "register_operand" "=a")
1048 (mem:HI (post_inc:SI (match_operand:SI 1 "register_operand" "r"))))
1050 (mem:HI (post_inc:SI (match_operand:SI 2 "register_operand" "r"))))))]
1052 "clrmac\;mac @%2+,@%1+"
1053 [(set_attr "length" "6")
1054 (set_attr "cc" "none_0hit")])
1057 [(set (match_operand:SI 0 "register_operand" "=a")
1059 (sign_extend:SI (mem:HI
1060 (post_inc:SI (match_operand:SI 1 "register_operand" "r"))))
1061 (sign_extend:SI (mem:HI
1062 (post_inc:SI (match_operand:SI 2 "register_operand" "r")))))
1063 (match_operand:SI 3 "register_operand" "0")))]
1066 [(set_attr "length" "4")
1067 (set_attr "cc" "none_0hit")])
1069 ;; ----------------------------------------------------------------------
1070 ;; DIVIDE/MOD INSTRUCTIONS
1071 ;; ----------------------------------------------------------------------
1073 (define_insn "udivmodqi4"
1074 [(set (match_operand:QI 0 "register_operand" "=r")
1077 (match_operand:HI 1 "register_operand" "0")
1078 (zero_extend:HI (match_operand:QI 2 "register_operand" "r")))))
1079 (set (match_operand:QI 3 "register_operand" "=r")
1083 (zero_extend:HI (match_dup 2)))))]
1087 if (find_reg_note (insn, REG_UNUSED, operands[3]))
1088 return \"divxu.b\\t%X2,%T0\";
1090 return \"divxu.b\\t%X2,%T0\;mov.b\\t%t0,%s3\";
1092 [(set_attr "length" "4")
1093 (set_attr "cc" "clobber")])
1095 (define_insn "divmodqi4"
1096 [(set (match_operand:QI 0 "register_operand" "=r")
1099 (match_operand:HI 1 "register_operand" "0")
1100 (sign_extend:HI (match_operand:QI 2 "register_operand" "r")))))
1101 (set (match_operand:QI 3 "register_operand" "=r")
1105 (sign_extend:HI (match_dup 2)))))]
1106 "TARGET_H8300H || TARGET_H8300S"
1109 if (find_reg_note (insn, REG_UNUSED, operands[3]))
1110 return \"divxs.b\\t%X2,%T0\";
1112 return \"divxs.b\\t%X2,%T0\;mov.b\\t%t0,%s3\";
1114 [(set_attr "length" "6")
1115 (set_attr "cc" "clobber")])
1117 (define_insn "udivmodhi4"
1118 [(set (match_operand:HI 0 "register_operand" "=r")
1121 (match_operand:SI 1 "register_operand" "0")
1122 (zero_extend:SI (match_operand:HI 2 "register_operand" "r")))))
1123 (set (match_operand:HI 3 "register_operand" "=r")
1127 (zero_extend:SI (match_dup 2)))))]
1128 "TARGET_H8300H || TARGET_H8300S"
1131 if (find_reg_note (insn, REG_UNUSED, operands[3]))
1132 return \"divxu.w\\t%T2,%S0\";
1134 return \"divxu.w\\t%T2,%S0\;mov.w\\t%e0,%f3\";
1136 [(set_attr "length" "4")
1137 (set_attr "cc" "clobber")])
1139 (define_insn "divmodhi4"
1140 [(set (match_operand:HI 0 "register_operand" "=r")
1143 (match_operand:SI 1 "register_operand" "0")
1144 (sign_extend:SI (match_operand:HI 2 "register_operand" "r")))))
1145 (set (match_operand:HI 3 "register_operand" "=r")
1149 (sign_extend:SI (match_dup 2)))))]
1150 "TARGET_H8300H || TARGET_H8300S"
1153 if (find_reg_note (insn, REG_UNUSED, operands[3]))
1154 return \"divxs.w\\t%T2,%S0\";
1156 return \"divxs.w\\t%T2,%S0\;mov.w\\t%e0,%f3\";
1158 [(set_attr "length" "6")
1159 (set_attr "cc" "clobber")])
1161 ;; ----------------------------------------------------------------------
1163 ;; ----------------------------------------------------------------------
1166 [(set (match_operand:QI 0 "bit_operand" "=r,U")
1167 (and:QI (match_operand:QI 1 "bit_operand" "%0,0")
1168 (match_operand:QI 2 "nonmemory_operand" "rn,n")))]
1169 "register_operand (operands[0], QImode)
1170 || single_zero_operand (operands[2], QImode)"
1174 [(set_attr "length" "2,8")
1175 (set_attr "cc" "set_znv,none_0hit")])
1177 (define_expand "andqi3"
1178 [(set (match_operand:QI 0 "bit_operand" "")
1179 (and:QI (match_operand:QI 1 "bit_operand" "")
1180 (match_operand:QI 2 "nonmemory_operand" "")))]
1184 if (fix_bit_operand (operands, 0, AND))
1188 (define_expand "andhi3"
1189 [(set (match_operand:HI 0 "register_operand" "")
1190 (and:HI (match_operand:HI 1 "register_operand" "")
1191 (match_operand:HI 2 "nonmemory_operand" "")))]
1195 (define_insn "*andorqi3"
1196 [(set (match_operand:QI 0 "register_operand" "=r")
1197 (ior:QI (and:QI (match_operand:QI 2 "register_operand" "r")
1198 (match_operand:QI 3 "single_one_operand" "n"))
1199 (match_operand:QI 1 "register_operand" "0")))]
1201 "bld\\t%V3,%X2\;bor\\t%V3,%X0\;bst\\t%V3,%X0"
1202 [(set_attr "length" "6")
1203 (set_attr "cc" "clobber")])
1205 (define_insn "*andorhi3"
1206 [(set (match_operand:HI 0 "register_operand" "=r")
1207 (ior:HI (and:HI (match_operand:HI 2 "register_operand" "r")
1208 (match_operand:HI 3 "single_one_operand" "n"))
1209 (match_operand:HI 1 "register_operand" "0")))]
1213 operands[3] = GEN_INT (INTVAL (operands[3]) & 0xffff);
1214 if (INTVAL (operands[3]) > 128)
1216 operands[3] = GEN_INT (INTVAL (operands[3]) >> 8);
1217 return \"bld\\t%V3,%t2\;bor\\t%V3,%t0\;bst\\t%V3,%t0\";
1219 return \"bld\\t%V3,%s2\;bor\\t%V3,%s0\;bst\\t%V3,%s0\";
1221 [(set_attr "length" "6")
1222 (set_attr "cc" "clobber")])
1224 (define_insn "*andorsi3"
1225 [(set (match_operand:SI 0 "register_operand" "=r")
1226 (ior:SI (and:SI (match_operand:SI 2 "register_operand" "r")
1227 (match_operand:SI 3 "single_one_operand" "n"))
1228 (match_operand:SI 1 "register_operand" "0")))]
1229 "(INTVAL (operands[3]) & 0xffff) != 0"
1232 operands[3] = GEN_INT (INTVAL (operands[3]) & 0xffff);
1233 if (INTVAL (operands[3]) > 128)
1235 operands[3] = GEN_INT (INTVAL (operands[3]) >> 8);
1236 return \"bld\\t%V3,%x2\;bor\\t%V3,%x0\;bst\\t%V3,%x0\";
1238 return \"bld\\t%V3,%w2\;bor\\t%V3,%w0\;bst\\t%V3,%w0\";
1240 [(set_attr "length" "6")
1241 (set_attr "cc" "clobber")])
1243 (define_insn "*andorsi3_shift_8"
1244 [(set (match_operand:SI 0 "register_operand" "=r")
1245 (ior:SI (and:SI (ashift:SI (match_operand:SI 2 "register_operand" "r")
1248 (match_operand:SI 1 "register_operand" "0")))]
1251 [(set_attr "length" "2")
1252 (set_attr "cc" "clobber")])
1254 (define_expand "andsi3"
1255 [(set (match_operand:SI 0 "register_operand" "")
1256 (and:SI (match_operand:SI 1 "register_operand" "")
1257 (match_operand:SI 2 "nonmemory_operand" "")))]
1261 ;; ----------------------------------------------------------------------
1263 ;; ----------------------------------------------------------------------
1266 [(set (match_operand:QI 0 "bit_operand" "=r,U")
1267 (ior:QI (match_operand:QI 1 "bit_operand" "%0,0")
1268 (match_operand:QI 2 "nonmemory_operand" "rn,n")))]
1269 "register_operand (operands[0], QImode)
1270 || single_one_operand (operands[2], QImode)"
1274 [(set_attr "length" "2,8")
1275 (set_attr "cc" "set_znv,none_0hit")])
1277 (define_expand "iorqi3"
1278 [(set (match_operand:QI 0 "bit_operand" "")
1279 (ior:QI (match_operand:QI 1 "bit_operand" "")
1280 (match_operand:QI 2 "nonmemory_operand" "")))]
1284 if (fix_bit_operand (operands, 1, IOR))
1288 (define_expand "iorhi3"
1289 [(set (match_operand:HI 0 "register_operand" "")
1290 (ior:HI (match_operand:HI 1 "register_operand" "")
1291 (match_operand:HI 2 "nonmemory_operand" "")))]
1295 (define_expand "iorsi3"
1296 [(set (match_operand:SI 0 "register_operand" "")
1297 (ior:SI (match_operand:SI 1 "register_operand" "")
1298 (match_operand:SI 2 "nonmemory_operand" "")))]
1302 ;; ----------------------------------------------------------------------
1304 ;; ----------------------------------------------------------------------
1307 [(set (match_operand:QI 0 "bit_operand" "=r,U")
1308 (xor:QI (match_operand:QI 1 "bit_operand" "%0,0")
1309 (match_operand:QI 2 "nonmemory_operand" "rn,n")))]
1310 "register_operand (operands[0], QImode)
1311 || single_one_operand (operands[2], QImode)"
1315 [(set_attr "length" "2,8")
1316 (set_attr "cc" "set_znv,none_0hit")])
1318 (define_expand "xorqi3"
1319 [(set (match_operand:QI 0 "bit_operand" "")
1320 (xor:QI (match_operand:QI 1 "bit_operand" "")
1321 (match_operand:QI 2 "nonmemory_operand" "")))]
1325 if (fix_bit_operand (operands, 1, XOR))
1329 (define_expand "xorhi3"
1330 [(set (match_operand:HI 0 "register_operand" "")
1331 (xor:HI (match_operand:HI 1 "register_operand" "")
1332 (match_operand:HI 2 "nonmemory_operand" "")))]
1336 (define_expand "xorsi3"
1337 [(set (match_operand:SI 0 "register_operand" "")
1338 (xor:SI (match_operand:SI 1 "register_operand" "")
1339 (match_operand:SI 2 "nonmemory_operand" "")))]
1343 ;; ----------------------------------------------------------------------
1344 ;; {AND,IOR,XOR}{HI3,SI3} PATTERNS
1345 ;; ----------------------------------------------------------------------
1348 [(set (match_operand:HI 0 "register_operand" "=r")
1349 (match_operator:HI 3 "bit_operator"
1350 [(match_operand:HI 1 "register_operand" "%0")
1351 (match_operand:HI 2 "nonmemory_operand" "rn")]))]
1353 "* return output_logical_op (HImode, operands);"
1354 [(set (attr "length")
1355 (symbol_ref "compute_logical_op_length (HImode, operands)"))
1357 (symbol_ref "compute_logical_op_cc (HImode, operands)"))])
1360 [(set (match_operand:SI 0 "register_operand" "=r")
1361 (match_operator:SI 3 "bit_operator"
1362 [(match_operand:SI 1 "register_operand" "%0")
1363 (match_operand:SI 2 "nonmemory_operand" "rn")]))]
1365 "* return output_logical_op (SImode, operands);"
1366 [(set (attr "length")
1367 (symbol_ref "compute_logical_op_length (SImode, operands)"))
1369 (symbol_ref "compute_logical_op_cc (SImode, operands)"))])
1371 ;; ----------------------------------------------------------------------
1372 ;; NEGATION INSTRUCTIONS
1373 ;; ----------------------------------------------------------------------
1375 (define_insn "negqi2"
1376 [(set (match_operand:QI 0 "register_operand" "=r")
1377 (neg:QI (match_operand:QI 1 "register_operand" "0")))]
1380 [(set_attr "length" "2")
1381 (set_attr "cc" "set_zn")])
1383 (define_expand "neghi2"
1384 [(set (match_operand:HI 0 "register_operand" "")
1385 (neg:HI (match_operand:HI 1 "register_operand" "")))]
1391 emit_insn (gen_neghi2_h8300 (operands[0], operands[1]));
1396 (define_expand "neghi2_h8300"
1398 (not:HI (match_operand:HI 1 "register_operand" "")))
1399 (set (match_dup 2) (plus:HI (match_dup 2) (const_int 1)))
1400 (set (match_operand:HI 0 "register_operand" "")
1403 "operands[2] = gen_reg_rtx (HImode);")
1405 (define_insn "neghi2_h8300h"
1406 [(set (match_operand:HI 0 "register_operand" "=r")
1407 (neg:HI (match_operand:HI 1 "register_operand" "0")))]
1408 "TARGET_H8300H || TARGET_H8300S"
1410 [(set_attr "length" "2")
1411 (set_attr "cc" "set_zn")])
1413 (define_expand "negsi2"
1414 [(set (match_operand:SI 0 "register_operand" "")
1415 (neg:SI (match_operand:SI 1 "register_operand" "")))]
1421 emit_insn (gen_negsi2_h8300 (operands[0], operands[1]));
1426 (define_expand "negsi2_h8300"
1428 (not:SI (match_operand:SI 1 "register_operand" "")))
1429 (set (match_dup 2) (plus:SI (match_dup 2) (const_int 1)))
1430 (set (match_operand:SI 0 "register_operand" "")
1433 "operands[2] = gen_reg_rtx (SImode);")
1435 (define_insn "negsi2_h8300h"
1436 [(set (match_operand:SI 0 "register_operand" "=r")
1437 (neg:SI (match_operand:SI 1 "register_operand" "0")))]
1438 "TARGET_H8300H || TARGET_H8300S"
1440 [(set_attr "length" "2")
1441 (set_attr "cc" "set_zn")])
1443 (define_expand "negsf2"
1444 [(set (match_operand:SF 0 "register_operand" "")
1445 (neg:SF (match_operand:SF 1 "register_operand" "")))]
1449 (define_insn "*negsf2_h8300"
1450 [(set (match_operand:SF 0 "register_operand" "=r")
1451 (neg:SF (match_operand:SF 1 "register_operand" "0")))]
1454 [(set_attr "cc" "clobber")
1455 (set_attr "length" "2")])
1457 (define_insn "*negsf2_h8300hs"
1458 [(set (match_operand:SF 0 "register_operand" "=r")
1459 (neg:SF (match_operand:SF 1 "register_operand" "0")))]
1460 "TARGET_H8300H || TARGET_H8300S"
1461 "xor.w\\t#32768,%e0"
1462 [(set_attr "cc" "clobber")
1463 (set_attr "length" "4")])
1465 ;; ----------------------------------------------------------------------
1466 ;; ABSOLUTE VALUE INSTRUCTIONS
1467 ;; ----------------------------------------------------------------------
1469 (define_expand "abssf2"
1470 [(set (match_operand:SF 0 "register_operand" "")
1471 (abs:SF (match_operand:SF 1 "register_operand" "")))]
1475 (define_insn "*abssf2_h8300"
1476 [(set (match_operand:SF 0 "register_operand" "=r")
1477 (abs:SF (match_operand:SF 1 "register_operand" "0")))]
1480 [(set_attr "cc" "clobber")
1481 (set_attr "length" "2")])
1483 (define_insn "*abssf2_h8300hs"
1484 [(set (match_operand:SF 0 "register_operand" "=r")
1485 (abs:SF (match_operand:SF 1 "register_operand" "0")))]
1486 "TARGET_H8300H || TARGET_H8300S"
1487 "and.w\\t#32767,%e0"
1488 [(set_attr "cc" "clobber")
1489 (set_attr "length" "4")])
1491 ;; ----------------------------------------------------------------------
1493 ;; ----------------------------------------------------------------------
1495 (define_insn "one_cmplqi2"
1496 [(set (match_operand:QI 0 "register_operand" "=r")
1497 (not:QI (match_operand:QI 1 "register_operand" "0")))]
1500 [(set_attr "length" "2")
1501 (set_attr "cc" "set_znv")])
1503 (define_expand "one_cmplhi2"
1504 [(set (match_operand:HI 0 "register_operand" "=r")
1505 (not:HI (match_operand:HI 1 "register_operand" "0")))]
1510 [(set (match_operand:HI 0 "register_operand" "=r")
1511 (not:HI (match_operand:HI 1 "register_operand" "0")))]
1514 [(set_attr "cc" "clobber")
1515 (set_attr "length" "4")])
1518 [(set (match_operand:HI 0 "register_operand" "=r")
1519 (not:HI (match_operand:HI 1 "register_operand" "0")))]
1520 "TARGET_H8300H || TARGET_H8300S"
1522 [(set_attr "cc" "set_znv")
1523 (set_attr "length" "2")])
1525 (define_expand "one_cmplsi2"
1526 [(set (match_operand:SI 0 "register_operand" "=r")
1527 (not:SI (match_operand:SI 1 "register_operand" "0")))]
1532 [(set (match_operand:SI 0 "register_operand" "=r")
1533 (not:SI (match_operand:SI 1 "register_operand" "0")))]
1535 "not %w0\;not %x0\;not %y0\;not %z0"
1536 [(set_attr "cc" "clobber")
1537 (set_attr "length" "8")])
1540 [(set (match_operand:SI 0 "register_operand" "=r")
1541 (not:SI (match_operand:SI 1 "register_operand" "0")))]
1542 "TARGET_H8300H || TARGET_H8300S"
1544 [(set_attr "cc" "set_znv")
1545 (set_attr "length" "2")])
1547 ;; ----------------------------------------------------------------------
1548 ;; JUMP INSTRUCTIONS
1549 ;; ----------------------------------------------------------------------
1551 ;; Conditional jump instructions
1553 (define_expand "ble"
1555 (if_then_else (le (cc0)
1557 (label_ref (match_operand 0 "" ""))
1562 (define_expand "bleu"
1564 (if_then_else (leu (cc0)
1566 (label_ref (match_operand 0 "" ""))
1571 (define_expand "bge"
1573 (if_then_else (ge (cc0)
1575 (label_ref (match_operand 0 "" ""))
1580 (define_expand "bgeu"
1582 (if_then_else (geu (cc0)
1584 (label_ref (match_operand 0 "" ""))
1589 (define_expand "blt"
1591 (if_then_else (lt (cc0)
1593 (label_ref (match_operand 0 "" ""))
1598 (define_expand "bltu"
1600 (if_then_else (ltu (cc0)
1602 (label_ref (match_operand 0 "" ""))
1607 (define_expand "bgt"
1609 (if_then_else (gt (cc0)
1611 (label_ref (match_operand 0 "" ""))
1616 (define_expand "bgtu"
1618 (if_then_else (gtu (cc0)
1620 (label_ref (match_operand 0 "" ""))
1625 (define_expand "beq"
1627 (if_then_else (eq (cc0)
1629 (label_ref (match_operand 0 "" ""))
1634 (define_expand "bne"
1636 (if_then_else (ne (cc0)
1638 (label_ref (match_operand 0 "" ""))
1643 (define_insn "branch_true"
1645 (if_then_else (match_operator 1 "comparison_operator"
1646 [(cc0) (const_int 0)])
1647 (label_ref (match_operand 0 "" ""))
1652 if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0
1653 && (GET_CODE (operands[1]) == GT
1654 || GET_CODE (operands[1]) == GE
1655 || GET_CODE (operands[1]) == LE
1656 || GET_CODE (operands[1]) == LT))
1658 cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
1662 if (get_attr_length (insn) == 2)
1663 return \"b%j1 %l0\";
1664 else if (get_attr_length (insn) == 4)
1665 return \"b%j1 %l0:16\";
1667 return \"b%k1 .Lh8BR%=\;jmp @%l0\\n.Lh8BR%=:\";
1669 [(set_attr "type" "branch")
1670 (set_attr "cc" "none")])
1672 (define_insn "branch_false"
1674 (if_then_else (match_operator 1 "comparison_operator"
1675 [(cc0) (const_int 0)])
1677 (label_ref (match_operand 0 "" ""))))]
1681 if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0
1682 && (GET_CODE (operands[1]) == GT
1683 || GET_CODE (operands[1]) == GE
1684 || GET_CODE (operands[1]) == LE
1685 || GET_CODE (operands[1]) == LT))
1687 cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
1691 if (get_attr_length (insn) == 2)
1692 return \"b%k1 %l0\";
1693 else if (get_attr_length (insn) == 4)
1694 return \"b%k1 %l0:16\";
1696 return \"b%j1 .Lh8BR%=\;jmp @%l0\\n.Lh8BR%=:\";
1698 [(set_attr "type" "branch")
1699 (set_attr "cc" "none")])
1701 ;; Unconditional and other jump instructions.
1705 (label_ref (match_operand 0 "" "")))]
1709 if (get_attr_length (insn) == 2)
1711 else if (get_attr_length (insn) == 4)
1712 return \"bra %l0:16\";
1714 return \"jmp @%l0\";
1716 [(set_attr "type" "branch")
1717 (set_attr "cc" "none")])
1719 ;; This is a define expand, because pointers may be either 16 or 32 bits.
1721 (define_expand "tablejump"
1722 [(parallel [(set (pc) (match_operand 0 "register_operand" ""))
1723 (use (label_ref (match_operand 1 "" "")))])]
1727 (define_insn "tablejump_h8300"
1728 [(set (pc) (match_operand:HI 0 "register_operand" "r"))
1729 (use (label_ref (match_operand 1 "" "")))]
1732 [(set_attr "cc" "none")
1733 (set_attr "length" "2")])
1735 (define_insn "tablejump_h8300h"
1736 [(set (pc) (match_operand:SI 0 "register_operand" "r"))
1737 (use (label_ref (match_operand 1 "" "")))]
1738 "TARGET_H8300H || TARGET_H8300S"
1740 [(set_attr "cc" "none")
1741 (set_attr "length" "2")])
1743 (define_insn "tablejump_normal_mode"
1744 [(set (pc) (match_operand:HI 0 "register_operand" "r"))
1745 (use (label_ref (match_operand 1 "" "")))]
1746 "(TARGET_H8300H || TARGET_H8300S) && TARGET_NORMAL_MODE"
1748 [(set_attr "cc" "none")
1749 (set_attr "length" "2")])
1751 ;; This is a define expand, because pointers may be either 16 or 32 bits.
1753 (define_expand "indirect_jump"
1754 [(set (pc) (match_operand 0 "jump_address_operand" ""))]
1758 (define_insn "indirect_jump_h8300"
1759 [(set (pc) (match_operand:HI 0 "jump_address_operand" "Vr"))]
1762 [(set_attr "cc" "none")
1763 (set_attr "length" "2")])
1765 (define_insn "indirect_jump_h8300h"
1766 [(set (pc) (match_operand:SI 0 "jump_address_operand" "Vr"))]
1767 "TARGET_H8300H || TARGET_H8300S"
1769 [(set_attr "cc" "none")
1770 (set_attr "length" "2")])
1772 (define_insn "indirect_jump_normal_mode"
1773 [(set (pc) (match_operand:HI 0 "jump_address_operand" "Vr"))]
1774 "(TARGET_H8300H || TARGET_H8300S) && TARGET_NORMAL_MODE"
1776 [(set_attr "cc" "none")
1777 (set_attr "length" "2")])
1779 ;; Call subroutine with no return value.
1781 ;; ??? Even though we use HImode here, this works on the H8/300H and H8S.
1784 [(call (match_operand:QI 0 "call_insn_operand" "or")
1785 (match_operand:HI 1 "general_operand" "g"))]
1789 if (GET_CODE (XEXP (operands[0], 0)) == SYMBOL_REF
1790 && SYMBOL_REF_FLAG (XEXP (operands[0], 0)))
1791 return \"jsr\\t@%0:8\";
1793 return \"jsr\\t%0\";
1795 [(set_attr "cc" "clobber")
1796 (set (attr "length")
1797 (if_then_else (match_operand:QI 0 "small_call_insn_operand" "")
1801 ;; Call subroutine, returning value in operand 0
1802 ;; (which must be a hard register).
1804 ;; ??? Even though we use HImode here, this works on the H8/300H and H8S.
1806 (define_insn "call_value"
1807 [(set (match_operand 0 "" "=r")
1808 (call (match_operand:QI 1 "call_insn_operand" "or")
1809 (match_operand:HI 2 "general_operand" "g")))]
1813 if (GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF
1814 && SYMBOL_REF_FLAG (XEXP (operands[1], 0)))
1815 return \"jsr\\t@%1:8\";
1817 return \"jsr\\t%1\";
1819 [(set_attr "cc" "clobber")
1820 (set (attr "length")
1821 (if_then_else (match_operand:QI 0 "small_call_insn_operand" "")
1829 [(set_attr "cc" "none")
1830 (set_attr "length" "2")])
1832 ;; ----------------------------------------------------------------------
1833 ;; PROLOGUE/EPILOGUE-RELATED INSTRUCTIONS
1834 ;; ----------------------------------------------------------------------
1836 (define_expand "push_h8300"
1837 [(set (mem:HI (pre_dec:HI (reg:HI SP_REG)))
1838 (match_operand:HI 0 "register_operand" "=r"))]
1843 (define_expand "push_h8300hs"
1844 [(set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
1845 (match_operand:SI 0 "register_operand" "=r"))]
1846 "TARGET_H8300H && TARGET_H8300S"
1849 (define_expand "pop_h8300"
1850 [(set (match_operand:HI 0 "register_operand" "=r")
1851 (mem:HI (post_inc:HI (reg:HI SP_REG))))]
1855 (define_expand "pop_h8300hs"
1856 [(set (match_operand:SI 0 "register_operand" "=r")
1857 (mem:SI (post_inc:SI (reg:SI SP_REG))))]
1858 "TARGET_H8300H && TARGET_H8300S"
1861 (define_insn "stm_h8300s_2"
1863 [(set (reg:SI SP_REG)
1864 (plus:SI (reg:SI SP_REG) (const_int -8)))
1865 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -4)))
1866 (match_operand:SI 0 "register_operand" ""))
1867 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -8)))
1868 (match_operand:SI 1 "register_operand" ""))])]
1870 && ((REGNO (operands[0]) == 0 && REGNO (operands[1]) == 1)
1871 || (REGNO (operands[0]) == 2 && REGNO (operands[1]) == 3)
1872 || (REGNO (operands[0]) == 4 && REGNO (operands[1]) == 5))"
1873 "stm.l\\t%S0-%S1,@-er7"
1874 [(set_attr "cc" "none")
1875 (set_attr "length" "4")])
1877 (define_insn "stm_h8300s_3"
1879 [(set (reg:SI SP_REG)
1880 (plus:SI (reg:SI SP_REG) (const_int -12)))
1881 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -4)))
1882 (match_operand:SI 0 "register_operand" ""))
1883 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -8)))
1884 (match_operand:SI 1 "register_operand" ""))
1885 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -12)))
1886 (match_operand:SI 2 "register_operand" ""))])]
1888 && ((REGNO (operands[0]) == 0
1889 && REGNO (operands[1]) == 1
1890 && REGNO (operands[2]) == 2)
1891 || (REGNO (operands[0]) == 4
1892 && REGNO (operands[1]) == 5
1893 && REGNO (operands[2]) == 6))"
1894 "stm.l\\t%S0-%S2,@-er7"
1895 [(set_attr "cc" "none")
1896 (set_attr "length" "4")])
1898 (define_insn "stm_h8300s_4"
1900 [(set (reg:SI SP_REG)
1901 (plus:SI (reg:SI SP_REG) (const_int -16)))
1902 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -4)))
1903 (match_operand:SI 0 "register_operand" ""))
1904 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -8)))
1905 (match_operand:SI 1 "register_operand" ""))
1906 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -12)))
1907 (match_operand:SI 2 "register_operand" ""))
1908 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -16)))
1909 (match_operand:SI 3 "register_operand" ""))])]
1911 && REGNO (operands[0]) == 0
1912 && REGNO (operands[1]) == 1
1913 && REGNO (operands[2]) == 2
1914 && REGNO (operands[3]) == 3"
1915 "stm.l\\t%S0-%S3,@-er7"
1916 [(set_attr "cc" "none")
1917 (set_attr "length" "4")])
1919 (define_insn "ldm_h8300s_2"
1921 [(set (reg:SI SP_REG)
1922 (plus:SI (reg:SI SP_REG) (const_int 8)))
1923 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int 4)))
1924 (match_operand:SI 0 "register_operand" ""))
1925 (set (mem:SI (reg:SI SP_REG))
1926 (match_operand:SI 1 "register_operand" ""))])]
1928 && ((REGNO (operands[0]) == 0 && REGNO (operands[1]) == 1)
1929 || (REGNO (operands[0]) == 2 && REGNO (operands[1]) == 3)
1930 || (REGNO (operands[0]) == 4 && REGNO (operands[1]) == 5))"
1931 "ldm.l\\t@er7+,%S0-%S1"
1932 [(set_attr "cc" "none")
1933 (set_attr "length" "4")])
1935 (define_insn "ldm_h8300s_3"
1937 [(set (reg:SI SP_REG)
1938 (plus:SI (reg:SI SP_REG) (const_int 12)))
1939 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int 8)))
1940 (match_operand:SI 0 "register_operand" ""))
1941 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int 4)))
1942 (match_operand:SI 1 "register_operand" ""))
1943 (set (mem:SI (reg:SI SP_REG))
1944 (match_operand:SI 2 "register_operand" ""))])]
1946 && ((REGNO (operands[0]) == 0
1947 && REGNO (operands[1]) == 1
1948 && REGNO (operands[2]) == 2)
1949 || (REGNO (operands[0]) == 4
1950 && REGNO (operands[1]) == 5
1951 && REGNO (operands[2]) == 6))"
1952 "ldm.l\\t@er7+,%S0-%S2"
1953 [(set_attr "cc" "none")
1954 (set_attr "length" "4")])
1956 (define_insn "ldm_h8300s_4"
1958 [(set (reg:SI SP_REG)
1959 (plus:SI (reg:SI SP_REG) (const_int 16)))
1960 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int 12)))
1961 (match_operand:SI 0 "register_operand" ""))
1962 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int 8)))
1963 (match_operand:SI 1 "register_operand" ""))
1964 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int 4)))
1965 (match_operand:SI 2 "register_operand" ""))
1966 (set (mem:SI (reg:SI SP_REG))
1967 (match_operand:SI 3 "register_operand" ""))])]
1969 && REGNO (operands[0]) == 0
1970 && REGNO (operands[1]) == 1
1971 && REGNO (operands[2]) == 2
1972 && REGNO (operands[3]) == 3"
1973 "ldm.l\\t@er7+,%S0-%S3"
1974 [(set_attr "cc" "none")
1975 (set_attr "length" "4")])
1977 (define_expand "return"
1979 "h8300_can_use_return_insn_p ()"
1982 (define_insn "*return_1"
1987 if (h8300_current_function_interrupt_function_p ())
1992 [(set_attr "cc" "none")
1993 (set_attr "length" "2")])
1995 (define_expand "prologue"
1998 "h8300_expand_prologue (); DONE;")
2000 (define_expand "epilogue"
2003 "h8300_expand_epilogue ();")
2005 (define_insn "monitor_prologue"
2006 [(unspec_volatile [(const_int 0)] UNSPEC_MONITOR)]
2011 return \"subs\\t#2,r7\;mov.w\\tr0,@-r7\;stc\\tccr,r0l\;mov.b\tr0l,@(2,r7)\;mov.w\\t@r7+,r0\;orc\t#128,ccr\";
2012 else if (TARGET_H8300H)
2013 return \"mov.l\\ter0,@-er7\;stc\\tccr,r0l\;mov.b\\tr0l,@(4,er7)\;mov.l\\t@er7+,er0\;orc\\t#128,ccr\";
2014 else if (TARGET_H8300S)
2015 return \"stc\texr,@-er7\;mov.l\\ter0,@-er7\;stc\tccr,r0l\;mov.b\tr0l,@(6,er7)\;mov.l\\t@er7+,er0\;orc\t#128,ccr\";
2018 [(set_attr "length" "20")
2019 (set_attr "cc" "clobber")])
2021 ;; ----------------------------------------------------------------------
2022 ;; EXTEND INSTRUCTIONS
2023 ;; ----------------------------------------------------------------------
2025 (define_expand "zero_extendqihi2"
2026 [(set (match_operand:HI 0 "register_operand" "")
2027 (zero_extend:HI (match_operand:QI 1 "general_operand_src" "")))]
2031 (define_insn "*zero_extendqihi2_h8300"
2032 [(set (match_operand:HI 0 "register_operand" "=r,r")
2033 (zero_extend:HI (match_operand:QI 1 "general_operand_src" "0,g>")))]
2038 [(set_attr "length" "2,10")
2039 (set_attr "cc" "clobber,clobber")])
2041 (define_insn "*zero_extendqihi2_h8300hs"
2042 [(set (match_operand:HI 0 "register_operand" "=r,r")
2043 (zero_extend:HI (match_operand:QI 1 "general_operand_src" "0,g>")))]
2044 "TARGET_H8300H || TARGET_H8300S"
2048 [(set_attr "length" "2,10")
2049 (set_attr "cc" "set_znv,set_znv")])
2051 ;; Split the zero extension of a general operand (actually a memory
2052 ;; operand) into a load of the operand and the actual zero extension
2053 ;; so that 1) the length will be accurate, and 2) the zero extensions
2054 ;; appearing at the end of basic blocks may be merged.
2057 [(set (match_operand:HI 0 "register_operand" "")
2058 (zero_extend:HI (match_operand:QI 1 "general_operand_src" "")))]
2063 (zero_extend:HI (match_dup 2)))]
2064 "operands[2] = gen_rtx_REG (QImode, REGNO (operands[0]));")
2066 (define_expand "zero_extendqisi2"
2067 [(set (match_operand:SI 0 "register_operand" "")
2068 (zero_extend:SI (match_operand:QI 1 "general_operand_src" "")))]
2072 (define_insn "*zero_extendqisi2_h8300"
2073 [(set (match_operand:SI 0 "register_operand" "=r,r")
2074 (zero_extend:SI (match_operand:QI 1 "general_operand_src" "0,g>")))]
2077 mov.b #0,%x0\;sub.w %e0,%e0
2078 mov.b %R1,%w0\;mov.b #0,%x0\;sub.w %e0,%e0"
2079 [(set_attr "length" "4,8")
2080 (set_attr "cc" "clobber,clobber")])
2082 (define_insn "*zero_extendqisi2_h8300hs"
2083 [(set (match_operand:SI 0 "register_operand" "=r,r")
2084 (zero_extend:SI (match_operand:QI 1 "general_operand_src" "0,g>")))]
2085 "TARGET_H8300H || TARGET_H8300S"
2089 [(set (match_operand:SI 0 "register_operand" "")
2090 (zero_extend:SI (match_operand:QI 1 "general_operand_src" "")))]
2091 "(TARGET_H8300H || TARGET_H8300S)
2092 && reg_overlap_mentioned_p (operands[0], operands[1])
2093 && reload_completed"
2097 (zero_extend:HI (match_dup 2)))
2099 (zero_extend:SI (match_dup 3)))]
2100 "operands[2] = gen_lowpart (QImode, operands[0]);
2101 operands[3] = gen_lowpart (HImode, operands[0]);")
2104 [(set (match_operand:SI 0 "register_operand" "")
2105 (zero_extend:SI (match_operand:QI 1 "general_operand_src" "")))]
2106 "(TARGET_H8300H || TARGET_H8300S)
2107 && !reg_overlap_mentioned_p (operands[0], operands[1])
2108 && reload_completed"
2111 (set (strict_low_part (match_dup 2))
2113 "operands[2] = gen_rtx_REG (QImode, REGNO (operands[0]));")
2115 (define_expand "zero_extendhisi2"
2116 [(set (match_operand:SI 0 "register_operand" "")
2117 (zero_extend:SI (match_operand:HI 1 "register_operand" "")))]
2121 ;; %e prints the high part of a CONST_INT, not the low part. Arggh.
2122 (define_insn "*zero_extendhisi2_h8300"
2123 [(set (match_operand:SI 0 "register_operand" "=r,r,r")
2124 (zero_extend:SI (match_operand:HI 1 "general_operand_src" "0,i,g>")))]
2128 mov.w %f1,%f0\;sub.w %e0,%e0
2129 mov.w %e1,%f0\;sub.w %e0,%e0"
2130 [(set_attr "length" "2,4,6")
2131 (set_attr "cc" "clobber,clobber,clobber")])
2134 [(set (match_operand:SI 0 "register_operand" "=r")
2135 (zero_extend:SI (match_operand:HI 1 "register_operand" "0")))]
2136 "TARGET_H8300H || TARGET_H8300S"
2138 [(set_attr "length" "2")
2139 (set_attr "cc" "set_znv")])
2141 (define_expand "extendqihi2"
2142 [(set (match_operand:HI 0 "register_operand" "")
2143 (sign_extend:HI (match_operand:QI 1 "register_operand" "")))]
2148 [(set (match_operand:HI 0 "register_operand" "=r,r")
2149 (sign_extend:HI (match_operand:QI 1 "general_operand_src" "0,g>")))]
2152 bld #7,%s0\;subx %t0,%t0
2153 mov.b %R1,%s0\;bld #7,%s0\;subx %t0,%t0"
2154 [(set_attr "length" "4,8")
2155 (set_attr "cc" "clobber,clobber")])
2158 [(set (match_operand:HI 0 "register_operand" "=r")
2159 (sign_extend:HI (match_operand:QI 1 "register_operand" "0")))]
2160 "TARGET_H8300H || TARGET_H8300S"
2162 [(set_attr "length" "2")
2163 (set_attr "cc" "set_znv")])
2165 (define_expand "extendqisi2"
2166 [(set (match_operand:SI 0 "register_operand" "=r,r")
2167 (sign_extend:SI (match_operand:QI 1 "register_operand" "")))]
2171 (define_insn "*extendqisi2_h8300"
2172 [(set (match_operand:SI 0 "register_operand" "")
2173 (sign_extend:SI (match_operand:QI 1 "general_operand_src" "0,g>")))]
2176 bld #7,%w0\;subx %x0,%x0\;subx %y0,%y0\;subx %z0,%z0
2177 mov.b %R1,%w0\;bld #7,%w0\;subx %x0,%x0\;subx %y0,%y0\;subx %z0,%z0"
2178 [(set_attr "length" "8,12")
2179 (set_attr "cc" "clobber,clobber")])
2181 ;; The following pattern is needed because without the pattern, the
2182 ;; combiner would split (sign_extend:SI (reg:QI)) into into two 24-bit
2183 ;; shifts, one ashift and one ashiftrt.
2185 (define_insn_and_split "*extendqisi2_h8300hs"
2186 [(set (match_operand:SI 0 "register_operand" "=r")
2187 (sign_extend:SI (match_operand:QI 1 "register_operand" "0")))]
2188 "(TARGET_H8300H || TARGET_H8300S)"
2190 "&& reload_completed"
2192 (sign_extend:HI (match_dup 1)))
2194 (sign_extend:SI (match_dup 2)))]
2195 "operands[2] = gen_rtx_REG (HImode, REGNO (operands[0]));")
2197 (define_expand "extendhisi2"
2198 [(set (match_operand:SI 0 "register_operand" "")
2199 (sign_extend:SI (match_operand:HI 1 "register_operand" "")))]
2203 (define_insn "*extendhisi2_h8300"
2204 [(set (match_operand:SI 0 "register_operand" "=r,r")
2205 (sign_extend:SI (match_operand:HI 1 "general_operand_src" "0,g>")))]
2208 bld #7,%x0\;subx %y0,%y0\;subx %z0,%z0
2209 mov.w %T1,%f0\;bld #7,%x0\;subx %y0,%y0\;subx %z0,%z0"
2210 [(set_attr "length" "6,10")
2211 (set_attr "cc" "clobber,clobber")])
2214 [(set (match_operand:SI 0 "register_operand" "=r")
2215 (sign_extend:SI (match_operand:HI 1 "register_operand" "0")))]
2216 "TARGET_H8300H || TARGET_H8300S"
2218 [(set_attr "length" "2")
2219 (set_attr "cc" "set_znv")])
2221 ;; ----------------------------------------------------------------------
2223 ;; ----------------------------------------------------------------------
2225 ;; We make some attempt to provide real efficient shifting. One example is
2226 ;; doing an 8 bit shift of a 16 bit value by moving a byte reg into the other
2227 ;; reg and moving 0 into the former reg.
2229 ;; We also try to achieve this in a uniform way. IE: We don't try to achieve
2230 ;; this in both rtl and at insn emit time. Ideally, we'd use rtl as that would
2231 ;; give the optimizer more cracks at the code. However, we wish to do things
2232 ;; like optimizing shifting the sign bit to bit 0 by rotating the other way.
2233 ;; There is rtl to handle this (rotate + and), but the H8/300 doesn't handle
2234 ;; 16 bit rotates. Also, if we emit complicated rtl, combine may not be able
2235 ;; to detect cases it can optimize.
2237 ;; For these and other fuzzy reasons, I've decided to go the less pretty but
2238 ;; easier "do it at insn emit time" route.
2242 (define_expand "ashlqi3"
2243 [(set (match_operand:QI 0 "register_operand" "")
2244 (ashift:QI (match_operand:QI 1 "register_operand" "")
2245 (match_operand:QI 2 "nonmemory_operand" "")))]
2247 "expand_a_shift (QImode, ASHIFT, operands); DONE;")
2249 (define_expand "ashrqi3"
2250 [(set (match_operand:QI 0 "register_operand" "")
2251 (ashiftrt:QI (match_operand:QI 1 "register_operand" "")
2252 (match_operand:QI 2 "nonmemory_operand" "")))]
2254 "expand_a_shift (QImode, ASHIFTRT, operands); DONE;")
2256 (define_expand "lshrqi3"
2257 [(set (match_operand:QI 0 "register_operand" "")
2258 (lshiftrt:QI (match_operand:QI 1 "register_operand" "")
2259 (match_operand:QI 2 "nonmemory_operand" "")))]
2261 "expand_a_shift (QImode, LSHIFTRT, operands); DONE;")
2264 [(set (match_operand:QI 0 "register_operand" "=r,r")
2265 (match_operator:QI 3 "nshift_operator"
2266 [ (match_operand:QI 1 "register_operand" "0,0")
2267 (match_operand:QI 2 "nonmemory_operand" "R,rn")]))
2268 (clobber (match_scratch:QI 4 "=X,&r"))]
2270 "* return output_a_shift (operands);"
2271 [(set (attr "length")
2272 (symbol_ref "compute_a_shift_length (insn, operands)"))
2274 (symbol_ref "compute_a_shift_cc (insn, operands)"))])
2278 (define_expand "ashlhi3"
2279 [(set (match_operand:HI 0 "register_operand" "")
2280 (ashift:HI (match_operand:HI 1 "nonmemory_operand" "")
2281 (match_operand:QI 2 "nonmemory_operand" "")))]
2283 "expand_a_shift (HImode, ASHIFT, operands); DONE;")
2285 (define_expand "lshrhi3"
2286 [(set (match_operand:HI 0 "register_operand" "")
2287 (lshiftrt:HI (match_operand:HI 1 "general_operand" "")
2288 (match_operand:QI 2 "nonmemory_operand" "")))]
2290 "expand_a_shift (HImode, LSHIFTRT, operands); DONE;")
2292 (define_expand "ashrhi3"
2293 [(set (match_operand:HI 0 "register_operand" "")
2294 (ashiftrt:HI (match_operand:HI 1 "register_operand" "")
2295 (match_operand:QI 2 "nonmemory_operand" "")))]
2297 "expand_a_shift (HImode, ASHIFTRT, operands); DONE;")
2300 [(set (match_operand:HI 0 "register_operand" "=r,r")
2301 (match_operator:HI 3 "nshift_operator"
2302 [ (match_operand:HI 1 "register_operand" "0,0")
2303 (match_operand:QI 2 "nonmemory_operand" "S,rn")]))
2304 (clobber (match_scratch:QI 4 "=X,&r"))]
2306 "* return output_a_shift (operands);"
2307 [(set (attr "length")
2308 (symbol_ref "compute_a_shift_length (insn, operands)"))
2310 (symbol_ref "compute_a_shift_cc (insn, operands)"))])
2314 (define_expand "ashlsi3"
2315 [(set (match_operand:SI 0 "register_operand" "")
2316 (ashift:SI (match_operand:SI 1 "general_operand" "")
2317 (match_operand:QI 2 "nonmemory_operand" "")))]
2319 "expand_a_shift (SImode, ASHIFT, operands); DONE;")
2321 (define_expand "lshrsi3"
2322 [(set (match_operand:SI 0 "register_operand" "")
2323 (lshiftrt:SI (match_operand:SI 1 "general_operand" "")
2324 (match_operand:QI 2 "nonmemory_operand" "")))]
2326 "expand_a_shift (SImode, LSHIFTRT, operands); DONE;")
2328 (define_expand "ashrsi3"
2329 [(set (match_operand:SI 0 "register_operand" "")
2330 (ashiftrt:SI (match_operand:SI 1 "general_operand" "")
2331 (match_operand:QI 2 "nonmemory_operand" "")))]
2333 "expand_a_shift (SImode, ASHIFTRT, operands); DONE;")
2336 [(set (match_operand:SI 0 "register_operand" "=r,r")
2337 (match_operator:SI 3 "nshift_operator"
2338 [ (match_operand:SI 1 "register_operand" "0,0")
2339 (match_operand:QI 2 "nonmemory_operand" "T,rn")]))
2340 (clobber (match_scratch:QI 4 "=X,&r"))]
2342 "* return output_a_shift (operands);"
2343 [(set (attr "length")
2344 (symbol_ref "compute_a_shift_length (insn, operands)"))
2346 (symbol_ref "compute_a_shift_cc (insn, operands)"))])
2348 ;; Split a variable shift into a loop. If the register containing
2349 ;; the shift count dies, then we just use that register.
2353 [(set (match_operand 0 "register_operand" "")
2354 (match_operator 2 "nshift_operator"
2356 (match_operand:QI 1 "register_operand" "")]))
2357 (clobber (match_operand:QI 3 "register_operand" ""))])]
2359 && find_regno_note (insn, REG_DEAD, REGNO (operands[1]))"
2363 (if_then_else (le (cc0) (const_int 0))
2364 (label_ref (match_dup 5))
2369 (match_op_dup 2 [(match_dup 0) (const_int 1)]))
2370 (clobber (scratch:QI))])
2372 (plus:QI (match_dup 1) (const_int -1)))
2376 (if_then_else (ne (cc0) (const_int 0))
2377 (label_ref (match_dup 4))
2380 "operands[4] = gen_label_rtx ();
2381 operands[5] = gen_label_rtx ();")
2385 [(set (match_operand 0 "register_operand" "")
2386 (match_operator 2 "nshift_operator"
2388 (match_operand:QI 1 "register_operand" "")]))
2389 (clobber (match_operand:QI 3 "register_operand" ""))])]
2391 && !find_regno_note (insn, REG_DEAD, REGNO (operands[1]))"
2397 (if_then_else (le (cc0) (const_int 0))
2398 (label_ref (match_dup 5))
2403 (match_op_dup 2 [(match_dup 0) (const_int 1)]))
2404 (clobber (scratch:QI))])
2406 (plus:QI (match_dup 3) (const_int -1)))
2410 (if_then_else (ne (cc0) (const_int 0))
2411 (label_ref (match_dup 4))
2414 "operands[4] = gen_label_rtx ();
2415 operands[5] = gen_label_rtx ();")
2417 ;; ----------------------------------------------------------------------
2419 ;; ----------------------------------------------------------------------
2421 (define_expand "rotlqi3"
2422 [(set (match_operand:QI 0 "register_operand" "")
2423 (rotate:QI (match_operand:QI 1 "register_operand" "")
2424 (match_operand:QI 2 "nonmemory_operand" "")))]
2426 "if (expand_a_rotate (ROTATE, operands)) DONE; else FAIL;")
2428 (define_insn "*rotlqi3_1"
2429 [(set (match_operand:QI 0 "register_operand" "=r")
2430 (rotate:QI (match_operand:QI 1 "register_operand" "0")
2431 (match_operand:QI 2 "immediate_operand" "")))]
2433 "* return output_a_rotate (ROTATE, operands);"
2434 [(set (attr "length")
2435 (symbol_ref "compute_a_rotate_length (operands)"))
2436 (set_attr "cc" "clobber")])
2438 (define_expand "rotlhi3"
2439 [(set (match_operand:HI 0 "register_operand" "")
2440 (rotate:HI (match_operand:HI 1 "register_operand" "")
2441 (match_operand:QI 2 "nonmemory_operand" "")))]
2443 "if (expand_a_rotate (ROTATE, operands)) DONE; else FAIL;")
2445 (define_insn "*rotlhi3_1"
2446 [(set (match_operand:HI 0 "register_operand" "=r")
2447 (rotate:HI (match_operand:HI 1 "register_operand" "0")
2448 (match_operand:QI 2 "immediate_operand" "")))]
2450 "* return output_a_rotate (ROTATE, operands);"
2451 [(set (attr "length")
2452 (symbol_ref "compute_a_rotate_length (operands)"))
2453 (set_attr "cc" "clobber")])
2455 (define_expand "rotlsi3"
2456 [(set (match_operand:SI 0 "register_operand" "")
2457 (rotate:SI (match_operand:SI 1 "register_operand" "")
2458 (match_operand:QI 2 "nonmemory_operand" "")))]
2459 "TARGET_H8300H || TARGET_H8300S"
2460 "if (expand_a_rotate (ROTATE, operands)) DONE; else FAIL;")
2462 (define_insn "*rotlsi3_1"
2463 [(set (match_operand:SI 0 "register_operand" "=r")
2464 (rotate:SI (match_operand:SI 1 "register_operand" "0")
2465 (match_operand:QI 2 "immediate_operand" "")))]
2466 "TARGET_H8300H || TARGET_H8300S"
2467 "* return output_a_rotate (ROTATE, operands);"
2468 [(set (attr "length")
2469 (symbol_ref "compute_a_rotate_length (operands)"))
2470 (set_attr "cc" "clobber")])
2472 ;; -----------------------------------------------------------------
2474 ;; -----------------------------------------------------------------
2475 ;; The H8/300 has given 1/8th of its opcode space to bitfield
2476 ;; instructions so let's use them as well as we can.
2478 ;; You'll never believe all these patterns perform one basic action --
2479 ;; load a bit from the source, optionally invert the bit, then store it
2480 ;; in the destination (which is known to be zero).
2482 ;; Combine obviously need some work to better identify this situation and
2483 ;; canonicalize the form better.
2486 ;; Normal loads with a 16bit destination.
2490 [(set (match_operand:HI 0 "register_operand" "=&r")
2491 (zero_extract:HI (match_operand:HI 1 "register_operand" "r")
2493 (match_operand:HI 2 "immediate_operand" "n")))]
2495 "sub.w %0,%0\;bld %Z2,%Y1\;bst #0,%X0"
2496 [(set_attr "cc" "clobber")
2497 (set_attr "length" "6")])
2500 ;; Inverted loads with a 16bit destination.
2504 [(set (match_operand:HI 0 "register_operand" "=&r")
2505 (zero_extract:HI (xor:HI (match_operand:HI 1 "register_operand" "r")
2506 (match_operand:HI 3 "const_int_operand" "n"))
2508 (match_operand:HI 2 "const_int_operand" "n")))]
2510 && (1 << INTVAL (operands[2])) == INTVAL (operands[3])"
2511 "sub.w %0,%0\;bild %Z2,%Y1\;bst #0,%X0"
2512 [(set_attr "cc" "clobber")
2513 (set_attr "length" "8")])
2516 ;; Normal loads with a 32bit destination.
2519 (define_insn "*extzv_1_r_h8300"
2520 [(set (match_operand:SI 0 "register_operand" "=&r")
2521 (zero_extract:SI (match_operand:HI 1 "register_operand" "r")
2523 (match_operand 2 "const_int_operand" "n")))]
2525 && INTVAL (operands[2]) < 16"
2526 "* return output_simode_bld (0, operands);"
2527 [(set_attr "cc" "clobber")
2528 (set_attr "length" "8")])
2530 (define_insn "*extzv_1_r_h8300hs"
2531 [(set (match_operand:SI 0 "register_operand" "=r,r")
2532 (zero_extract:SI (match_operand:SI 1 "register_operand" "?0,r")
2534 (match_operand 2 "const_int_operand" "n,n")))]
2535 "(TARGET_H8300H || TARGET_H8300S)
2536 && INTVAL (operands[2]) < 16"
2537 "* return output_simode_bld (0, operands);"
2538 [(set_attr "cc" "set_znv,set_znv")
2539 (set_attr "length" "8,6")])
2542 ;; Inverted loads with a 32bit destination.
2545 (define_insn "*extzv_1_r_inv_h8300"
2546 [(set (match_operand:SI 0 "register_operand" "=&r")
2547 (zero_extract:SI (xor:HI (match_operand:HI 1 "register_operand" "r")
2548 (match_operand:HI 3 "const_int_operand" "n"))
2550 (match_operand 2 "const_int_operand" "n")))]
2552 && INTVAL (operands[2]) < 16
2553 && (1 << INTVAL (operands[2])) == INTVAL (operands[3])"
2554 "* return output_simode_bld (1, operands);"
2555 [(set_attr "cc" "clobber")
2556 (set_attr "length" "8")])
2558 (define_insn "*extzv_1_r_inv_h8300hs"
2559 [(set (match_operand:SI 0 "register_operand" "=r,r")
2560 (zero_extract:SI (xor:SI (match_operand:SI 1 "register_operand" "?0,r")
2561 (match_operand 3 "const_int_operand" "n,n"))
2563 (match_operand 2 "const_int_operand" "n,n")))]
2564 "(TARGET_H8300H || TARGET_H8300S)
2565 && INTVAL (operands[2]) < 16
2566 && (1 << INTVAL (operands[2])) == INTVAL (operands[3])"
2567 "* return output_simode_bld (1, operands);"
2568 [(set_attr "cc" "set_znv,set_znv")
2569 (set_attr "length" "8,6")])
2571 (define_expand "insv"
2572 [(set (zero_extract:HI (match_operand:HI 0 "general_operand" "")
2573 (match_operand:HI 1 "general_operand" "")
2574 (match_operand:HI 2 "general_operand" ""))
2575 (match_operand:HI 3 "general_operand" ""))]
2579 /* We only have single bit bit-field instructions. */
2580 if (INTVAL (operands[1]) != 1)
2583 /* For now, we don't allow memory operands. */
2584 if (GET_CODE (operands[0]) == MEM
2585 || GET_CODE (operands[3]) == MEM)
2590 [(set (zero_extract:HI (match_operand:HI 0 "register_operand" "+r")
2592 (match_operand:HI 1 "immediate_operand" "n"))
2593 (match_operand:HI 2 "register_operand" "r"))]
2595 "bld #0,%R2\;bst %Z1,%Y0 ; i1"
2596 [(set_attr "cc" "clobber")
2597 (set_attr "length" "4")])
2599 (define_expand "extzv"
2600 [(set (match_operand:HI 0 "register_operand" "")
2601 (zero_extract:HI (match_operand:HI 1 "bit_operand" "")
2602 (match_operand:HI 2 "general_operand" "")
2603 (match_operand:HI 3 "general_operand" "")))]
2607 /* We only have single bit bit-field instructions. */
2608 if (INTVAL (operands[2]) != 1)
2611 /* For now, we don't allow memory operands. */
2612 if (GET_CODE (operands[1]) == MEM)
2616 ;; BAND, BOR, and BXOR patterns
2619 [(set (match_operand:HI 0 "bit_operand" "=Ur")
2620 (match_operator:HI 4 "bit_operator"
2621 [(zero_extract:HI (match_operand:HI 1 "register_operand" "r")
2623 (match_operand:HI 2 "immediate_operand" "n"))
2624 (match_operand:HI 3 "bit_operand" "0")]))]
2626 "bld %Z2,%Y1\;b%c4 #0,%R0\;bst #0,%R0; bl1"
2627 [(set_attr "cc" "clobber")
2628 (set_attr "length" "6")])
2631 [(set (match_operand:HI 0 "bit_operand" "=Ur")
2632 (match_operator:HI 5 "bit_operator"
2633 [(zero_extract:HI (match_operand:HI 1 "register_operand" "r")
2635 (match_operand:HI 2 "immediate_operand" "n"))
2636 (zero_extract:HI (match_operand:HI 3 "register_operand" "r")
2638 (match_operand:HI 4 "immediate_operand" "n"))]))]
2640 "bld %Z2,%Y1\;b%c5 %Z4,%Y3\;bst #0,%R0; bl3"
2641 [(set_attr "cc" "clobber")
2642 (set_attr "length" "6")])
2644 ;; -----------------------------------------------------------------
2646 ;; -----------------------------------------------------------------
2650 (define_insn "*insv_si_1_n"
2651 [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+r")
2653 (match_operand:SI 1 "const_int_operand" "n"))
2654 (match_operand:SI 2 "register_operand" "r"))]
2655 "(TARGET_H8300H || TARGET_H8300S)
2656 && INTVAL (operands[1]) < 16"
2657 "bld\\t#0,%w2\;bst\\t%Z1,%Y0"
2658 [(set_attr "cc" "clobber")
2659 (set_attr "length" "4")])
2661 (define_insn "*insv_si_1_n_lshiftrt"
2662 [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+r")
2664 (match_operand:SI 1 "const_int_operand" "n"))
2665 (lshiftrt:SI (match_operand:SI 2 "register_operand" "r")
2666 (match_operand:SI 3 "const_int_operand" "n")))]
2667 "(TARGET_H8300H || TARGET_H8300S)
2668 && INTVAL (operands[1]) < 16
2669 && INTVAL (operands[3]) < 16"
2670 "bld\\t%Z3,%Y2\;bst\\t%Z1,%Y0"
2671 [(set_attr "cc" "clobber")
2672 (set_attr "length" "4")])
2674 (define_insn "*insv_si_1_n_lshiftrt_16"
2675 [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+r")
2677 (match_operand:SI 1 "const_int_operand" "n"))
2678 (lshiftrt:SI (match_operand:SI 2 "register_operand" "r")
2680 "(TARGET_H8300H || TARGET_H8300S)
2681 && INTVAL (operands[1]) < 16"
2682 "rotr.w\\t%e2\;rotl.w\\t%e2\;bst\\t%Z1,%Y0"
2683 [(set_attr "cc" "clobber")
2684 (set_attr "length" "6")])
2686 (define_insn "*insv_si_8_8"
2687 [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+r")
2690 (match_operand:SI 1 "register_operand" "r"))]
2691 "TARGET_H8300H || TARGET_H8300S"
2693 [(set_attr "cc" "clobber")
2694 (set_attr "length" "2")])
2696 (define_insn "*insv_si_8_8_lshiftrt_8"
2697 [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+r")
2700 (lshiftrt:SI (match_operand:SI 1 "register_operand" "r")
2702 "TARGET_H8300H || TARGET_H8300S"
2704 [(set_attr "cc" "clobber")
2705 (set_attr "length" "2")])
2709 (define_insn "*extzv_8_8"
2710 [(set (match_operand:SI 0 "register_operand" "=r,r")
2711 (zero_extract:SI (match_operand:SI 1 "register_operand" "?0,r")
2714 "TARGET_H8300H || TARGET_H8300S"
2716 mov.b\\t%x1,%w0\;extu.w\\t%f0\;extu.l\\t%S0
2717 sub.l\\t%S0,%S0\;mov.b\\t%x1,%w0"
2718 [(set_attr "cc" "set_znv,clobber")
2719 (set_attr "length" "6,4")])
2721 (define_insn "*extzv_8_16"
2722 [(set (match_operand:SI 0 "register_operand" "=r")
2723 (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
2726 "TARGET_H8300H || TARGET_H8300S"
2727 "mov.w\\t%e1,%f0\;extu.w\\t%f0\;extu.l\\t%S0"
2728 [(set_attr "cc" "set_znv")
2729 (set_attr "length" "6")])
2731 (define_insn "*extzv_16_8"
2732 [(set (match_operand:SI 0 "register_operand" "=r")
2733 (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
2736 (clobber (match_scratch:SI 2 "=&r"))]
2738 "mov.w\\t%e1,%f2\;mov.b\\t%x1,%w0\;mov.b\\t%w2,%x0\;extu.l\\t%S0"
2739 [(set_attr "length" "8")
2740 (set_attr "cc" "set_znv")])
2742 ;; Extract the exponent of a float.
2744 (define_insn_and_split "*extzv_8_23"
2745 [(set (match_operand:SI 0 "register_operand" "=r")
2746 (zero_extract:SI (match_operand:SI 1 "register_operand" "0")
2749 "(TARGET_H8300H || TARGET_H8300S)"
2751 "&& reload_completed"
2752 [(parallel [(set (match_dup 0)
2753 (ashift:SI (match_dup 0)
2755 (clobber (scratch:QI))])
2756 (parallel [(set (match_dup 0)
2757 (lshiftrt:SI (match_dup 0)
2759 (clobber (scratch:QI))])]
2764 ;; ((SImode) HImode) << 15
2766 (define_insn_and_split "*twoshifts_l16_r1"
2767 [(set (match_operand:SI 0 "register_operand" "=r")
2768 (and:SI (ashift:SI (match_operand:SI 1 "register_operand" "0")
2770 (const_int 2147450880)))]
2771 "(TARGET_H8300H || TARGET_H8300S)"
2773 "&& reload_completed"
2774 [(parallel [(set (match_dup 0)
2775 (ashift:SI (match_dup 0)
2777 (clobber (scratch:QI))])
2778 (parallel [(set (match_dup 0)
2779 (lshiftrt:SI (match_dup 0)
2781 (clobber (scratch:QI))])]
2784 ;; Transform (SImode << B) & 0xffff into (SImode) (HImode << B).
2786 (define_insn_and_split "*andsi3_ashift_n_lower"
2787 [(set (match_operand:SI 0 "register_operand" "=r,r")
2788 (and:SI (ashift:SI (match_operand:SI 1 "register_operand" "0,0")
2789 (match_operand:QI 2 "const_int_operand" "S,n"))
2790 (match_operand:SI 3 "const_int_operand" "n,n")))
2791 (clobber (match_scratch:QI 4 "=X,&r"))]
2792 "(TARGET_H8300H || TARGET_H8300S)
2793 && INTVAL (operands[2]) <= 15
2794 && INTVAL (operands[3]) == ((-1 << INTVAL (operands[2])) & 0xffff)"
2796 "&& reload_completed"
2797 [(parallel [(set (match_dup 5)
2798 (ashift:HI (match_dup 5)
2800 (clobber (match_dup 4))])
2802 (zero_extend:SI (match_dup 5)))]
2803 "operands[5] = gen_rtx_REG (HImode, REGNO (operands[0]));")
2805 ;; Accept (A >> 30) & 2 and the like.
2807 (define_insn "*andsi3_lshiftrt_n_sb"
2808 [(set (match_operand:SI 0 "register_operand" "=r")
2809 (and:SI (lshiftrt:SI (match_operand:SI 1 "register_operand" "0")
2810 (match_operand:SI 2 "const_int_operand" "n"))
2811 (match_operand:SI 3 "single_one_operand" "n")))]
2812 "(TARGET_H8300H || TARGET_H8300S)
2813 && exact_log2 (INTVAL (operands[3])) < 16
2814 && INTVAL (operands[2]) + exact_log2 (INTVAL (operands[3])) == 31"
2817 operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
2818 return \"shll.l\\t%S0\;xor.l\\t%S0,%S0\;bst\\t%Z3,%Y0\";
2820 [(set_attr "length" "8")
2821 (set_attr "cc" "clobber")])
2823 (define_insn_and_split "*andsi3_lshiftrt_9_sb"
2824 [(set (match_operand:SI 0 "register_operand" "=r")
2825 (and:SI (lshiftrt:SI (match_operand:SI 1 "register_operand" "0")
2827 (const_int 4194304)))]
2828 "(TARGET_H8300H || TARGET_H8300S)"
2830 "&& reload_completed"
2832 (and:SI (lshiftrt:SI (match_dup 0)
2835 (parallel [(set (match_dup 0)
2836 (ashift:SI (match_dup 0)
2838 (clobber (scratch:QI))])]
2843 (define_insn "*addsi3_upper"
2844 [(set (match_operand:SI 0 "register_operand" "=r")
2845 (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "r")
2847 (match_operand:SI 2 "register_operand" "0")))]
2848 "TARGET_H8300H || TARGET_H8300S"
2850 [(set_attr "length" "2")
2851 (set_attr "cc" "clobber")])
2853 (define_insn "*addsi3_lshiftrt_16_zexthi"
2854 [(set (match_operand:SI 0 "register_operand" "=r")
2855 (plus:SI (lshiftrt:SI (match_operand:SI 1 "register_operand" "r")
2857 (zero_extend:SI (match_operand:HI 2 "register_operand" "0"))))]
2858 "TARGET_H8300H || TARGET_H8300S"
2859 "add.w\\t%e1,%f0\;xor.w\\t%e0,%e0\;rotxl.w\\t%e0"
2860 [(set_attr "cc" "clobber")
2861 (set_attr "length" "6")])
2863 (define_insn_and_split "*addsi3_and_r_1"
2864 [(set (match_operand:SI 0 "register_operand" "=r")
2865 (plus:SI (and:SI (match_operand:SI 1 "register_operand" "r")
2867 (match_operand:SI 2 "register_operand" "0")))]
2868 "(TARGET_H8300H || TARGET_H8300S)"
2870 "&& reload_completed"
2872 (zero_extract:SI (match_dup 1)
2876 (if_then_else (eq (cc0)
2878 (label_ref (match_dup 3))
2881 (plus:SI (match_dup 2)
2884 "operands[3] = gen_label_rtx ();")
2886 (define_insn_and_split "*addsi3_and_not_r_1"
2887 [(set (match_operand:SI 0 "register_operand" "=r")
2888 (plus:SI (and:SI (not:SI (match_operand:SI 1 "register_operand" "r"))
2890 (match_operand:SI 2 "register_operand" "0")))]
2891 "(TARGET_H8300H || TARGET_H8300S)"
2893 "&& reload_completed"
2895 (zero_extract:SI (match_dup 1)
2899 (if_then_else (ne (cc0)
2901 (label_ref (match_dup 3))
2904 (plus:SI (match_dup 2)
2907 "operands[3] = gen_label_rtx ();")
2911 (define_insn "*ixorhi3_zext"
2912 [(set (match_operand:HI 0 "register_operand" "=r")
2913 (match_operator:HI 1 "iorxor_operator"
2914 [(zero_extend:HI (match_operand:QI 2 "register_operand" "r"))
2915 (match_operand:HI 3 "register_operand" "0")]))]
2918 [(set_attr "cc" "clobber")
2919 (set_attr "length" "2")])
2923 (define_insn "*ixorsi3_zext_qi"
2924 [(set (match_operand:SI 0 "register_operand" "=r")
2925 (match_operator:SI 1 "iorxor_operator"
2926 [(zero_extend:SI (match_operand:QI 2 "register_operand" "r"))
2927 (match_operand:SI 3 "register_operand" "0")]))]
2930 [(set_attr "cc" "clobber")
2931 (set_attr "length" "2")])
2933 (define_insn "*ixorsi3_zext_hi"
2934 [(set (match_operand:SI 0 "register_operand" "=r")
2935 (match_operator:SI 1 "iorxor_operator"
2936 [(zero_extend:SI (match_operand:HI 2 "register_operand" "r"))
2937 (match_operand:SI 3 "register_operand" "0")]))]
2938 "TARGET_H8300H || TARGET_H8300S"
2940 [(set_attr "cc" "clobber")
2941 (set_attr "length" "2")])
2943 (define_insn "*ixorsi3_ashift_16"
2944 [(set (match_operand:SI 0 "register_operand" "=r")
2945 (match_operator:SI 1 "iorxor_operator"
2946 [(ashift:SI (match_operand:SI 2 "register_operand" "r")
2948 (match_operand:SI 3 "register_operand" "0")]))]
2949 "TARGET_H8300H || TARGET_H8300S"
2951 [(set_attr "cc" "clobber")
2952 (set_attr "length" "2")])
2954 (define_insn "*ixorsi3_lshiftrt_16"
2955 [(set (match_operand:SI 0 "register_operand" "=r")
2956 (match_operator:SI 1 "iorxor_operator"
2957 [(lshiftrt:SI (match_operand:SI 2 "register_operand" "r")
2959 (match_operand:SI 3 "register_operand" "0")]))]
2960 "TARGET_H8300H || TARGET_H8300S"
2962 [(set_attr "cc" "clobber")
2963 (set_attr "length" "2")])
2967 (define_insn "*iorhi3_ashift_8"
2968 [(set (match_operand:HI 0 "register_operand" "=r")
2969 (ior:HI (ashift:HI (match_operand:HI 1 "register_operand" "r")
2971 (match_operand:HI 2 "register_operand" "0")))]
2974 [(set_attr "cc" "clobber")
2975 (set_attr "length" "2")])
2977 (define_insn "*iorhi3_lshiftrt_8"
2978 [(set (match_operand:HI 0 "register_operand" "=r")
2979 (ior:HI (lshiftrt:HI (match_operand:HI 1 "register_operand" "r")
2981 (match_operand:HI 2 "register_operand" "0")))]
2984 [(set_attr "cc" "clobber")
2985 (set_attr "length" "2")])
2987 (define_insn "*iorhi3_two_qi"
2988 [(set (match_operand:HI 0 "register_operand" "=r")
2989 (ior:HI (zero_extend:HI (match_operand:QI 1 "register_operand" "0"))
2990 (ashift:HI (match_operand:HI 2 "register_operand" "r")
2994 [(set_attr "cc" "clobber")
2995 (set_attr "length" "2")])
2997 (define_insn "*iorhi3_two_qi_mem"
2998 [(set (match_operand:HI 0 "register_operand" "=&r")
2999 (ior:HI (zero_extend:HI (match_operand:QI 1 "memory_operand" "m"))
3000 (ashift:HI (subreg:HI (match_operand:QI 2 "memory_operand" "m") 0)
3003 "mov.b\\t%X2,%t0\;mov.b\\t%X1,%s0"
3004 [(set_attr "cc" "clobber")
3005 (set_attr "length" "16")])
3008 [(set (match_operand:HI 0 "register_operand" "")
3009 (ior:HI (zero_extend:HI (match_operand:QI 1 "memory_operand" ""))
3010 (ashift:HI (subreg:HI (match_operand:QI 2 "memory_operand" "") 0)
3012 "(TARGET_H8300H || TARGET_H8300S)
3014 && byte_accesses_mergeable_p (XEXP (operands[2], 0), XEXP (operands[1], 0))"
3017 "operands[3] = gen_rtx_MEM (HImode, XEXP (operands[2], 0));")
3021 (define_insn "*iorsi3_two_hi"
3022 [(set (match_operand:SI 0 "register_operand" "=r")
3023 (ior:SI (zero_extend:SI (match_operand:HI 1 "register_operand" "0"))
3024 (ashift:SI (match_operand:SI 2 "register_operand" "r")
3026 "TARGET_H8300H || TARGET_H8300S"
3028 [(set_attr "cc" "clobber")
3029 (set_attr "length" "2")])
3031 (define_insn_and_split "*iorsi3_two_qi_zext"
3032 [(set (match_operand:SI 0 "register_operand" "=&r")
3033 (ior:SI (zero_extend:SI (match_operand:QI 1 "memory_operand" "m"))
3035 (and:SI (ashift:SI (subreg:SI (match_operand:QI 2 "memory_operand" "m") 0)
3037 (const_int 65280))))]
3038 "(TARGET_H8300H || TARGET_H8300S)"
3040 "&& reload_completed"
3042 (ior:HI (zero_extend:HI (match_dup 1))
3043 (ashift:HI (subreg:HI (match_dup 2) 0)
3046 (zero_extend:SI (match_dup 3)))]
3047 "operands[3] = gen_rtx_REG (HImode, REGNO (operands[0]));")
3049 (define_insn "*iorsi3_e2f"
3050 [(set (match_operand:SI 0 "register_operand" "=r")
3051 (ior:SI (and:SI (match_operand:SI 1 "register_operand" "0")
3053 (lshiftrt:SI (match_operand:SI 2 "register_operand" "r")
3055 "TARGET_H8300H || TARGET_H8300S"
3057 [(set_attr "length" "2")
3058 (set_attr "cc" "clobber")])
3060 (define_insn_and_split "*iorsi3_two_qi_sext"
3061 [(set (match_operand:SI 0 "register_operand" "=r")
3062 (ior:SI (zero_extend:SI (match_operand:QI 1 "register_operand" "0"))
3063 (ashift:SI (sign_extend:SI (match_operand:QI 2 "register_operand" "r"))
3065 "(TARGET_H8300H || TARGET_H8300S)"
3067 "&& reload_completed"
3069 (ior:HI (zero_extend:HI (match_dup 1))
3070 (ashift:HI (match_dup 4)
3073 (sign_extend:SI (match_dup 3)))]
3074 "operands[3] = gen_rtx_REG (HImode, REGNO (operands[0]));
3075 operands[4] = gen_rtx_REG (HImode, REGNO (operands[2]));")
3077 (define_insn "*iorsi3_w"
3078 [(set (match_operand:SI 0 "register_operand" "=r,&r")
3079 (ior:SI (and:SI (match_operand:SI 1 "register_operand" "0,0")
3081 (zero_extend:SI (match_operand:QI 2 "general_operand_src" "r,g>"))))]
3082 "TARGET_H8300H || TARGET_H8300S"
3084 [(set_attr "length" "2,8")
3085 (set_attr "cc" "clobber,clobber")])
3087 (define_insn "*iorsi3_ashift_31"
3088 [(set (match_operand:SI 0 "register_operand" "=&r")
3089 (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
3091 (match_operand:SI 2 "register_operand" "0")))]
3092 "TARGET_H8300H || TARGET_H8300S"
3093 "rotxl.l\\t%S0\;bor\\t#0,%w1\;rotxr.l\\t%S0"
3094 [(set_attr "length" "6")
3095 (set_attr "cc" "set_znv")])
3097 (define_insn "*iorsi3_and_ashift"
3098 [(set (match_operand:SI 0 "register_operand" "=r")
3099 (ior:SI (and:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
3100 (match_operand:SI 2 "const_int_operand" "n"))
3101 (match_operand:SI 3 "single_one_operand" "n"))
3102 (match_operand:SI 4 "register_operand" "0")))]
3103 "(TARGET_H8300H || TARGET_H8300S)
3104 && (INTVAL (operands[3]) & ~0xffff) == 0"
3107 rtx srcpos = GEN_INT (exact_log2 (INTVAL (operands[3]))
3108 - INTVAL (operands[2]));
3109 rtx dstpos = GEN_INT (exact_log2 (INTVAL (operands[3])));
3110 operands[2] = srcpos;
3111 operands[3] = dstpos;
3112 return \"bld\\t%Z2,%Y1\;bor\\t%Z3,%Y0\;bst\\t%Z3,%Y0\";
3114 [(set_attr "length" "6")
3115 (set_attr "cc" "clobber")])
3117 (define_insn "*iorsi3_and_lshiftrt"
3118 [(set (match_operand:SI 0 "register_operand" "=r")
3119 (ior:SI (and:SI (lshiftrt:SI (match_operand:SI 1 "register_operand" "r")
3120 (match_operand:SI 2 "const_int_operand" "n"))
3121 (match_operand:SI 3 "single_one_operand" "n"))
3122 (match_operand:SI 4 "register_operand" "0")))]
3123 "(TARGET_H8300H || TARGET_H8300S)
3124 && ((INTVAL (operands[3]) << INTVAL (operands[2])) & ~0xffff) == 0"
3127 rtx srcpos = GEN_INT (exact_log2 (INTVAL (operands[3]))
3128 + INTVAL (operands[2]));
3129 rtx dstpos = GEN_INT (exact_log2 (INTVAL (operands[3])));
3130 operands[2] = srcpos;
3131 operands[3] = dstpos;
3132 return \"bld\\t%Z2,%Y1\;bor\\t%Z3,%Y0\;bst\\t%Z3,%Y0\";
3134 [(set_attr "length" "6")
3135 (set_attr "cc" "clobber")])
3137 (define_insn "*iorsi3_zero_extract"
3138 [(set (match_operand:SI 0 "register_operand" "=r")
3139 (ior:SI (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
3141 (match_operand:SI 2 "const_int_operand" "n"))
3142 (match_operand:SI 3 "register_operand" "0")))]
3143 "(TARGET_H8300H || TARGET_H8300S)
3144 && INTVAL (operands[2]) < 16"
3145 "bld\\t%Z2,%Y1\;bor\\t#0,%w0\;bst\\t#0,%w0"
3146 [(set_attr "length" "6")
3147 (set_attr "cc" "clobber")])
3149 (define_insn "*iorsi3_and_lshiftrt_n_sb"
3150 [(set (match_operand:SI 0 "register_operand" "=r")
3151 (ior:SI (and:SI (lshiftrt:SI (match_operand:SI 1 "register_operand" "r")
3154 (match_operand:SI 2 "register_operand" "0")))]
3155 "(TARGET_H8300H || TARGET_H8300S)"
3156 "rotl.l\\t%S1\;rotr.l\\t%S1\;bor\\t#1,%w0\;bst\\t#1,%w0"
3157 [(set_attr "length" "8")
3158 (set_attr "cc" "clobber")])
3160 (define_insn "*iorsi3_and_lshiftrt_9_sb"
3161 [(set (match_operand:SI 0 "register_operand" "=r")
3162 (ior:SI (and:SI (lshiftrt:SI (match_operand:SI 1 "register_operand" "r")
3164 (const_int 4194304))
3165 (match_operand:SI 2 "register_operand" "0")))
3166 (clobber (match_scratch:HI 3 "=&r"))]
3167 "(TARGET_H8300H || TARGET_H8300S)"
3170 if (find_regno_note (insn, REG_DEAD, REGNO (operands[1])))
3171 return \"shll.l\\t%S1\;xor.w\\t%T3,%T3\;bst\\t#6,%s3\;or.w\\t%T3,%e0\";
3173 return \"rotl.l\\t%S1\;rotr.l\\t%S1\;xor.w\\t%T3,%T3\;bst\\t#6,%s3\;or.w\\t%T3,%e0\";
3175 [(set_attr "length" "10")
3176 (set_attr "cc" "clobber")])
3178 ;; Used to OR the exponent of a float.
3180 (define_insn "*iorsi3_shift"
3181 [(set (match_operand:SI 0 "register_operand" "=r")
3182 (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
3184 (match_operand:SI 2 "register_operand" "0")))
3185 (clobber (match_scratch:SI 3 "=&r"))]
3186 "TARGET_H8300H || TARGET_H8300S"
3191 [(set (match_operand:SI 0 "register_operand" "")
3192 (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "")
3195 (clobber (match_operand:SI 2 "register_operand" ""))])]
3196 "(TARGET_H8300H || TARGET_H8300S)
3198 && find_regno_note (insn, REG_DEAD, REGNO (operands[1]))
3199 && REGNO (operands[0]) != REGNO (operands[1])"
3200 [(parallel [(set (match_dup 3)
3201 (ashift:HI (match_dup 3)
3203 (clobber (scratch:QI))])
3205 (ior:SI (ashift:SI (match_dup 1)
3208 "operands[3] = gen_rtx_REG (HImode, REGNO (operands[1]));")
3212 [(set (match_operand:SI 0 "register_operand" "")
3213 (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "")
3216 (clobber (match_operand:SI 2 "register_operand" ""))])]
3217 "(TARGET_H8300H || TARGET_H8300S)
3219 && !(find_regno_note (insn, REG_DEAD, REGNO (operands[1]))
3220 && REGNO (operands[0]) != REGNO (operands[1]))"
3223 (parallel [(set (match_dup 3)
3224 (ashift:HI (match_dup 3)
3226 (clobber (scratch:QI))])
3228 (ior:SI (ashift:SI (match_dup 2)
3231 "operands[3] = gen_rtx_REG (HImode, REGNO (operands[2]));")
3233 (define_insn "*iorsi2_and_1_lshiftrt_1"
3234 [(set (match_operand:SI 0 "register_operand" "=r")
3235 (ior:SI (and:SI (match_operand:SI 1 "register_operand" "0")
3237 (lshiftrt:SI (match_dup 1)
3239 "TARGET_H8300H || TARGET_H8300S"
3240 "shlr.l\\t%S0\;bor\\t#0,%w0\;bst\\t#0,%w0"
3241 [(set_attr "length" "6")
3242 (set_attr "cc" "clobber")])
3244 (define_insn_and_split "*iorsi3_ashift_16_ashift_24"
3245 [(set (match_operand:SI 0 "register_operand" "=r")
3246 (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "0")
3248 (ashift:SI (match_operand:SI 2 "register_operand" "r")
3250 "(TARGET_H8300H || TARGET_H8300S)"
3252 "&& reload_completed"
3254 (ior:HI (ashift:HI (match_dup 4)
3257 (parallel [(set (match_dup 0)
3258 (ashift:SI (match_dup 0)
3260 (clobber (scratch:QI))])]
3261 "operands[3] = gen_rtx_REG (HImode, REGNO (operands[0]));
3262 operands[4] = gen_rtx_REG (HImode, REGNO (operands[2]));")
3264 (define_insn_and_split "*iorsi3_ashift_16_ashift_24_mem"
3265 [(set (match_operand:SI 0 "register_operand" "=&r")
3266 (ior:SI (and:SI (ashift:SI (subreg:SI (match_operand:QI 1 "memory_operand" "m") 0)
3268 (const_int 16711680))
3269 (ashift:SI (subreg:SI (match_operand:QI 2 "memory_operand" "m") 0)
3271 "(TARGET_H8300H || TARGET_H8300S)"
3273 "&& reload_completed"
3275 (ior:HI (zero_extend:HI (match_dup 1))
3276 (ashift:HI (subreg:HI (match_dup 2) 0)
3278 (parallel [(set (match_dup 0)
3279 (ashift:SI (match_dup 0)
3281 (clobber (scratch:QI))])]
3282 "operands[3] = gen_rtx_REG (HImode, REGNO (operands[0]));")
3284 ;; Used to add the exponent of a float.
3286 (define_insn "*addsi3_shift"
3287 [(set (match_operand:SI 0 "register_operand" "=r")
3288 (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "r")
3289 (const_int 8388608))
3290 (match_operand:SI 2 "register_operand" "0")))
3291 (clobber (match_scratch:SI 3 "=&r"))]
3292 "TARGET_H8300H || TARGET_H8300S"
3297 [(set (match_operand:SI 0 "register_operand" "")
3298 (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "")
3299 (const_int 8388608))
3301 (clobber (match_operand:SI 2 "register_operand" ""))])]
3302 "(TARGET_H8300H || TARGET_H8300S)
3304 && find_regno_note (insn, REG_DEAD, REGNO (operands[1]))
3305 && REGNO (operands[0]) != REGNO (operands[1])"
3306 [(parallel [(set (match_dup 3)
3307 (ashift:HI (match_dup 3)
3309 (clobber (scratch:QI))])
3311 (plus:SI (mult:SI (match_dup 1)
3314 "operands[3] = gen_rtx_REG (HImode, REGNO (operands[1]));")
3318 [(set (match_operand:SI 0 "register_operand" "")
3319 (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "")
3320 (const_int 8388608))
3322 (clobber (match_operand:SI 2 "register_operand" ""))])]
3323 "(TARGET_H8300H || TARGET_H8300S)
3325 && !(find_regno_note (insn, REG_DEAD, REGNO (operands[1]))
3326 && REGNO (operands[0]) != REGNO (operands[1]))"
3329 (parallel [(set (match_dup 3)
3330 (ashift:HI (match_dup 3)
3332 (clobber (scratch:QI))])
3334 (plus:SI (mult:SI (match_dup 2)
3337 "operands[3] = gen_rtx_REG (HImode, REGNO (operands[2]));")
3341 (define_insn_and_split "*ashiftsi_sextqi_7"
3342 [(set (match_operand:SI 0 "register_operand" "=r")
3343 (ashift:SI (sign_extend:SI (match_operand:QI 1 "register_operand" "0"))
3345 "(TARGET_H8300H || TARGET_H8300S)"
3347 "&& reload_completed"
3348 [(parallel [(set (match_dup 2)
3349 (ashift:HI (match_dup 2)
3351 (clobber (scratch:QI))])
3353 (sign_extend:SI (match_dup 2)))
3354 (parallel [(set (match_dup 0)
3355 (ashiftrt:SI (match_dup 0)
3357 (clobber (scratch:QI))])]
3358 "operands[2] = gen_rtx_REG (HImode, REGNO (operands[0]));")
3360 ;; Storing a part of HImode to QImode.
3363 [(set (match_operand:QI 0 "general_operand_dst" "=rm<")
3364 (subreg:QI (lshiftrt:HI (match_operand:HI 1 "register_operand" "r")
3368 [(set_attr "cc" "set_znv")
3369 (set_attr "length" "8")])
3371 ;; Storing a part of SImode to QImode.
3374 [(set (match_operand:QI 0 "general_operand_dst" "=rm<")
3375 (subreg:QI (lshiftrt:SI (match_operand:SI 1 "register_operand" "r")
3379 [(set_attr "cc" "set_znv")
3380 (set_attr "length" "8")])
3383 [(set (match_operand:QI 0 "general_operand_dst" "=rm<")
3384 (subreg:QI (lshiftrt:SI (match_operand:SI 1 "register_operand" "r")
3386 (clobber (match_scratch:SI 2 "=&r"))]
3387 "TARGET_H8300H || TARGET_H8300S"
3388 "mov.w\\t%e1,%f2\;mov.b\\t%w2,%R0"
3389 [(set_attr "cc" "set_znv")
3390 (set_attr "length" "10")])
3393 [(set (match_operand:QI 0 "general_operand_dst" "=rm<")
3394 (subreg:QI (lshiftrt:SI (match_operand:SI 1 "register_operand" "r")
3396 (clobber (match_scratch:SI 2 "=&r"))]
3397 "TARGET_H8300H || TARGET_H8300S"
3398 "mov.w\\t%e1,%f2\;mov.b\\t%x2,%R0"
3399 [(set_attr "cc" "set_znv")
3400 (set_attr "length" "10")])
3402 (define_insn_and_split ""
3404 (if_then_else (eq (zero_extract:SI (subreg:SI (match_operand:QI 0 "register_operand" "") 0)
3408 (label_ref (match_operand 1 "" ""))
3416 (if_then_else (ge (cc0)
3418 (label_ref (match_dup 1))
3422 (define_insn_and_split ""
3424 (if_then_else (ne (zero_extract:SI (subreg:SI (match_operand:QI 0 "register_operand" "") 0)
3428 (label_ref (match_operand 1 "" ""))
3436 (if_then_else (lt (cc0)
3438 (label_ref (match_dup 1))
3442 ;; -----------------------------------------------------------------
3443 ;; PEEPHOLE PATTERNS
3444 ;; -----------------------------------------------------------------
3446 ;; Convert (A >> B) & C to (A & 255) >> B if C == 255 >> B.
3450 [(set (match_operand:HI 0 "register_operand" "")
3451 (lshiftrt:HI (match_dup 0)
3452 (match_operand:HI 1 "const_int_operand" "")))
3453 (clobber (match_operand:HI 2 "" ""))])
3455 (and:HI (match_dup 0)
3456 (match_operand:HI 3 "const_int_operand" "")))]
3457 "INTVAL (operands[3]) == (255 >> INTVAL (operands[1]))"
3459 (and:HI (match_dup 0)
3463 (lshiftrt:HI (match_dup 0)
3465 (clobber (match_dup 2))])]
3468 ;; Convert (A << B) & C to (A & 255) << B if C == 255 << B.
3472 [(set (match_operand:HI 0 "register_operand" "")
3473 (ashift:HI (match_dup 0)
3474 (match_operand:HI 1 "const_int_operand" "")))
3475 (clobber (match_operand:HI 2 "" ""))])
3477 (and:HI (match_dup 0)
3478 (match_operand:HI 3 "const_int_operand" "")))]
3479 "INTVAL (operands[3]) == (255 << INTVAL (operands[1]))"
3481 (and:HI (match_dup 0)
3485 (ashift:HI (match_dup 0)
3487 (clobber (match_dup 2))])]
3490 ;; Convert (A >> B) & C to (A & 255) >> B if C == 255 >> B.
3494 [(set (match_operand:SI 0 "register_operand" "")
3495 (lshiftrt:SI (match_dup 0)
3496 (match_operand:SI 1 "const_int_operand" "")))
3497 (clobber (match_operand:SI 2 "" ""))])
3499 (and:SI (match_dup 0)
3500 (match_operand:SI 3 "const_int_operand" "")))]
3501 "INTVAL (operands[3]) == (255 >> INTVAL (operands[1]))"
3503 (and:SI (match_dup 0)
3507 (lshiftrt:SI (match_dup 0)
3509 (clobber (match_dup 2))])]
3512 ;; Convert (A << B) & C to (A & 255) << B if C == 255 << B.
3516 [(set (match_operand:SI 0 "register_operand" "")
3517 (ashift:SI (match_dup 0)
3518 (match_operand:SI 1 "const_int_operand" "")))
3519 (clobber (match_operand:SI 2 "" ""))])
3521 (and:SI (match_dup 0)
3522 (match_operand:SI 3 "const_int_operand" "")))]
3523 "INTVAL (operands[3]) == (255 << INTVAL (operands[1]))"
3525 (and:SI (match_dup 0)
3529 (ashift:SI (match_dup 0)
3531 (clobber (match_dup 2))])]
3534 ;; Convert (A >> B) & C to (A & 65535) >> B if C == 65535 >> B.
3538 [(set (match_operand:SI 0 "register_operand" "")
3539 (lshiftrt:SI (match_dup 0)
3540 (match_operand:SI 1 "const_int_operand" "")))
3541 (clobber (match_operand:SI 2 "" ""))])
3543 (and:SI (match_dup 0)
3544 (match_operand:SI 3 "const_int_operand" "")))]
3545 "INTVAL (operands[3]) == (65535 >> INTVAL (operands[1]))"
3547 (and:SI (match_dup 0)
3551 (lshiftrt:SI (match_dup 0)
3553 (clobber (match_dup 2))])]
3556 ;; Convert (A << B) & C to (A & 65535) << B if C == 65535 << B.
3560 [(set (match_operand:SI 0 "register_operand" "")
3561 (ashift:SI (match_dup 0)
3562 (match_operand:SI 1 "const_int_operand" "")))
3563 (clobber (match_operand:SI 2 "" ""))])
3565 (and:SI (match_dup 0)
3566 (match_operand:SI 3 "const_int_operand" "")))]
3567 "INTVAL (operands[3]) == (65535 << INTVAL (operands[1]))"
3569 (and:SI (match_dup 0)
3573 (ashift:SI (match_dup 0)
3575 (clobber (match_dup 2))])]
3578 ;; Convert a QImode push into an SImode push so that the
3579 ;; define_peephole2 below can cram multiple pushes into one stm.l.
3582 [(parallel [(set (reg:SI SP_REG)
3583 (plus:SI (reg:SI SP_REG) (const_int -4)))
3584 (set (mem:QI (plus:SI (reg:SI SP_REG) (const_int -3)))
3585 (match_operand:QI 0 "register_operand" ""))])]
3587 [(set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3589 "operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]));")
3591 ;; Convert a HImode push into an SImode push so that the
3592 ;; define_peephole2 below can cram multiple pushes into one stm.l.
3595 [(parallel [(set (reg:SI SP_REG)
3596 (plus:SI (reg:SI SP_REG) (const_int -4)))
3597 (set (mem:HI (plus:SI (reg:SI SP_REG) (const_int -2)))
3598 (match_operand:HI 0 "register_operand" ""))])]
3600 [(set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3602 "operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]));")
3604 ;; Cram four pushes into stm.l.
3607 [(set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3608 (match_operand:SI 0 "register_operand" ""))
3609 (set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3610 (match_operand:SI 1 "register_operand" ""))
3611 (set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3612 (match_operand:SI 2 "register_operand" ""))
3613 (set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3614 (match_operand:SI 3 "register_operand" ""))]
3616 && REGNO (operands[0]) == 0
3617 && REGNO (operands[1]) == 1
3618 && REGNO (operands[2]) == 2
3619 && REGNO (operands[3]) == 3"
3620 [(parallel [(set (reg:SI SP_REG)
3621 (plus:SI (reg:SI SP_REG)
3623 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -4)))
3625 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -8)))
3627 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -12)))
3629 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -16)))
3633 ;; Cram three pushes into stm.l.
3636 [(set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3637 (match_operand:SI 0 "register_operand" ""))
3638 (set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3639 (match_operand:SI 1 "register_operand" ""))
3640 (set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3641 (match_operand:SI 2 "register_operand" ""))]
3643 && ((REGNO (operands[0]) == 0
3644 && REGNO (operands[1]) == 1
3645 && REGNO (operands[2]) == 2)
3646 || (REGNO (operands[0]) == 4
3647 && REGNO (operands[1]) == 5
3648 && REGNO (operands[2]) == 6))"
3649 [(parallel [(set (reg:SI SP_REG)
3650 (plus:SI (reg:SI SP_REG)
3652 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -4)))
3654 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -8)))
3656 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -12)))
3660 ;; Cram two pushes into stm.l.
3663 [(set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3664 (match_operand:SI 0 "register_operand" ""))
3665 (set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3666 (match_operand:SI 1 "register_operand" ""))]
3668 && ((REGNO (operands[0]) == 0 && REGNO (operands[1]) == 1)
3669 || (REGNO (operands[0]) == 2 && REGNO (operands[1]) == 3)
3670 || (REGNO (operands[0]) == 4 && REGNO (operands[1]) == 5))"
3671 [(parallel [(set (reg:SI SP_REG)
3672 (plus:SI (reg:SI SP_REG)
3674 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -4)))
3676 (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -8)))
3683 ;; add.w r7,r0 (6 bytes)
3688 ;; adds #2,r0 (4 bytes)
3691 [(set (match_operand:HI 0 "register_operand" "")
3692 (match_operand:HI 1 "const_int_operand" ""))
3694 (plus:HI (match_dup 0)
3695 (match_operand:HI 2 "register_operand" "")))]
3696 "REG_P (operands[0]) && REG_P (operands[2])
3697 && REGNO (operands[0]) != REGNO (operands[2])
3698 && (CONST_OK_FOR_J (INTVAL (operands[1]))
3699 || CONST_OK_FOR_L (INTVAL (operands[1]))
3700 || CONST_OK_FOR_N (INTVAL (operands[1])))"
3704 (plus:HI (match_dup 0)
3712 ;; add.l er7,er0 (6 bytes)
3717 ;; adds #4,er0 (4 bytes)
3720 [(set (match_operand:SI 0 "register_operand" "")
3721 (match_operand:SI 1 "const_int_operand" ""))
3723 (plus:SI (match_dup 0)
3724 (match_operand:SI 2 "register_operand" "")))]
3725 "(TARGET_H8300H || TARGET_H8300S)
3726 && REG_P (operands[0]) && REG_P (operands[2])
3727 && REGNO (operands[0]) != REGNO (operands[2])
3728 && (CONST_OK_FOR_L (INTVAL (operands[1]))
3729 || CONST_OK_FOR_N (INTVAL (operands[1])))"
3733 (plus:SI (match_dup 0)
3740 ;; add.l #10,er0 (takes 8 bytes)
3746 ;; add.l er7,er0 (takes 6 bytes)
3749 [(set (match_operand:SI 0 "register_operand" "")
3750 (match_operand:SI 1 "register_operand" ""))
3752 (plus:SI (match_dup 0)
3753 (match_operand:SI 2 "const_int_operand" "")))]
3754 "(TARGET_H8300H || TARGET_H8300S)
3755 && REG_P (operands[0]) && REG_P (operands[1])
3756 && REGNO (operands[0]) != REGNO (operands[1])
3757 && !CONST_OK_FOR_L (INTVAL (operands[2]))
3758 && !CONST_OK_FOR_N (INTVAL (operands[2]))
3759 && ((INTVAL (operands[2]) & 0xff) == INTVAL (operands[2])
3760 || (INTVAL (operands[2]) & 0xff00) == INTVAL (operands[2])
3761 || INTVAL (operands[2]) == 0xffff
3762 || INTVAL (operands[2]) == 0xfffe)"
3766 (plus:SI (match_dup 0)
3782 [(set (match_operand:HI 0 "register_operand" "")
3783 (plus:HI (match_dup 0)
3784 (match_operand 1 "incdec_operand" "")))
3788 (if_then_else (match_operator 3 "eqne_operator"
3789 [(cc0) (const_int 0)])
3790 (label_ref (match_operand 2 "" ""))
3792 "TARGET_H8300H || TARGET_H8300S"
3793 [(set (match_operand:HI 0 "register_operand" "")
3794 (unspec:HI [(match_dup 0)
3800 (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
3801 (label_ref (match_dup 2))
3805 ;; The SImode version of the previous pattern.
3808 [(set (match_operand:SI 0 "register_operand" "")
3809 (plus:SI (match_dup 0)
3810 (match_operand 1 "incdec_operand" "")))
3814 (if_then_else (match_operator 3 "eqne_operator"
3815 [(cc0) (const_int 0)])
3816 (label_ref (match_operand 2 "" ""))
3818 "TARGET_H8300H || TARGET_H8300S"
3819 [(set (match_operand:SI 0 "register_operand" "")
3820 (unspec:SI [(match_dup 0)
3826 (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
3827 (label_ref (match_dup 2))
3832 [(parallel [(set (cc0)
3833 (zero_extract:SI (match_operand:QI 0 "register_operand" "")
3836 (clobber (scratch:QI))])
3838 (if_then_else (match_operator 1 "eqne_operator"
3839 [(cc0) (const_int 0)])
3840 (label_ref (match_operand 2 "" ""))
3842 "(TARGET_H8300H || TARGET_H8300S)"
3846 (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
3847 (label_ref (match_dup 2))
3849 "operands[3] = ((GET_CODE (operands[1]) == EQ)
3850 ? gen_rtx_GE (VOIDmode, cc0_rtx, const0_rtx)
3851 : gen_rtx_LT (VOIDmode, cc0_rtx, const0_rtx));")
3853 ;; The next three peephole2's will try to transform
3855 ;; mov.b A,r0l (or mov.l A,er0)
3862 ;; and.b #CST,r0l (if CST is not 255)
3865 [(set (match_operand:QI 0 "register_operand" "")
3866 (match_operand:QI 1 "general_operand" ""))
3867 (set (match_operand:SI 2 "register_operand" "")
3868 (and:SI (match_dup 2)
3870 "(TARGET_H8300H || TARGET_H8300S)
3871 && !reg_overlap_mentioned_p (operands[2], operands[1])
3872 && REGNO (operands[0]) == REGNO (operands[2])"
3875 (set (strict_low_part (match_dup 0))
3880 [(set (match_operand:SI 0 "register_operand" "")
3881 (match_operand:SI 1 "general_operand" ""))
3883 (and:SI (match_dup 0)
3885 "(TARGET_H8300H || TARGET_H8300S)
3886 && !reg_overlap_mentioned_p (operands[0], operands[1])
3887 && !(GET_CODE (operands[1]) == MEM && MEM_VOLATILE_P (operands[1]))"
3890 (set (strict_low_part (match_dup 2))
3892 "operands[2] = gen_lowpart (QImode, operands[0]);
3893 operands[3] = gen_lowpart (QImode, operands[1]);")
3896 [(set (match_operand 0 "register_operand" "")
3897 (match_operand 1 "general_operand" ""))
3898 (set (match_operand:SI 2 "register_operand" "")
3899 (and:SI (match_dup 2)
3900 (match_operand:SI 3 "const_int_qi_operand" "")))]
3901 "(TARGET_H8300H || TARGET_H8300S)
3902 && (GET_MODE (operands[0]) == QImode
3903 || GET_MODE (operands[0]) == HImode
3904 || GET_MODE (operands[0]) == SImode)
3905 && GET_MODE (operands[0]) == GET_MODE (operands[1])
3906 && REGNO (operands[0]) == REGNO (operands[2])
3907 && !reg_overlap_mentioned_p (operands[2], operands[1])
3908 && !(GET_MODE (operands[1]) != QImode
3909 && GET_CODE (operands[1]) == MEM
3910 && MEM_VOLATILE_P (operands[1]))"
3913 (set (strict_low_part (match_dup 4))
3916 (and:SI (match_dup 2)
3918 "operands[4] = gen_lowpart (QImode, operands[0]);
3919 operands[5] = gen_lowpart (QImode, operands[1]);
3920 operands[6] = GEN_INT (~0xff | INTVAL (operands[3]));")
3923 [(set (match_operand:SI 0 "register_operand" "")
3924 (match_operand:SI 1 "register_operand" ""))
3926 (and:SI (match_dup 0)
3927 (const_int 65280)))]
3928 "(TARGET_H8300H || TARGET_H8300S)
3929 && !reg_overlap_mentioned_p (operands[0], operands[1])"
3932 (set (zero_extract:SI (match_dup 0)
3935 (lshiftrt:SI (match_dup 1)
3939 ;; If a load of mem:SI is followed by an AND that turns off the upper
3940 ;; half, then we can load mem:HI instead.
3943 [(set (match_operand:SI 0 "register_operand" "")
3944 (match_operand:SI 1 "memory_operand" ""))
3946 (and:SI (match_dup 0)
3947 (match_operand:SI 2 "const_int_operand" "")))]
3948 "(TARGET_H8300H || TARGET_H8300S)
3949 && !MEM_VOLATILE_P (operands[1])
3950 && (INTVAL (operands[2]) & ~0xffff) == 0
3951 && INTVAL (operands[2]) != 255"
3955 (and:SI (match_dup 0)
3957 "operands[3] = gen_lowpart (HImode, operands[0]);
3958 operands[4] = gen_lowpart (HImode, operands[1]);")
3960 ;; (compare (reg:HI) (const_int)) takes 4 bytes, so we try to achieve
3961 ;; the equivalent with shorter sequences. Here is the summary. Cases
3962 ;; are grouped for each define_peephole2.
3964 ;; reg const_int use insn
3965 ;; --------------------------------------------------------
3966 ;; dead -2 eq/ne inc.l
3967 ;; dead -1 eq/ne inc.l
3968 ;; dead 1 eq/ne dec.l
3969 ;; dead 2 eq/ne dec.l
3971 ;; dead 1 geu/ltu shar.l
3972 ;; dead 3 (H8S) geu/ltu shar.l
3974 ;; ---- 255 geu/ltu mov.b
3988 (compare (match_operand:HI 0 "register_operand" "")
3989 (match_operand:HI 1 "incdec_operand" "")))
3991 (if_then_else (match_operator 3 "eqne_operator"
3992 [(cc0) (const_int 0)])
3993 (label_ref (match_operand 2 "" ""))
3995 "(TARGET_H8300H || TARGET_H8300S)
3996 && peep2_reg_dead_p (1, operands[0])"
3998 (unspec:HI [(match_dup 0)
4004 (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
4005 (label_ref (match_dup 2))
4007 "operands[4] = GEN_INT (- INTVAL (operands[1]));")
4021 (compare (match_operand:HI 0 "register_operand" "")
4022 (match_operand:HI 1 "const_int_operand" "")))
4024 (if_then_else (match_operator 2 "gtle_operator"
4025 [(cc0) (const_int 0)])
4026 (label_ref (match_operand 3 "" ""))
4028 "(TARGET_H8300H || TARGET_H8300S)
4029 && peep2_reg_dead_p (1, operands[0])
4030 && (INTVAL (operands[1]) == 1
4031 || (TARGET_H8300S && INTVAL (operands[1]) == 3))"
4032 [(parallel [(set (match_dup 0)
4033 (ashiftrt:HI (match_dup 0)
4035 (clobber (scratch:QI))])
4039 (if_then_else (match_dup 4)
4040 (label_ref (match_dup 3))
4042 "switch (GET_CODE (operands[2]))
4045 operands[4] = gen_rtx_NE (VOIDmode, cc0_rtx, const0_rtx);
4048 operands[4] = gen_rtx_EQ (VOIDmode, cc0_rtx, const0_rtx);
4051 operands[4] = operands[2];
4054 operands[5] = GEN_INT (exact_log2 (INTVAL (operands[1]) + 1));")
4068 (compare (match_operand:HI 0 "register_operand" "")
4071 (if_then_else (match_operator 1 "gtle_operator"
4072 [(cc0) (const_int 0)])
4073 (label_ref (match_operand 2 "" ""))
4075 "TARGET_H8300H || TARGET_H8300S"
4077 (and:HI (match_dup 0)
4080 (if_then_else (match_dup 3)
4081 (label_ref (match_dup 2))
4083 "switch (GET_CODE (operands[1]))
4086 operands[3] = gen_rtx_NE (VOIDmode, cc0_rtx, const0_rtx);
4089 operands[3] = gen_rtx_EQ (VOIDmode, cc0_rtx, const0_rtx);
4092 operands[3] = operands[1];
4096 ;; (compare (reg:SI) (const_int)) takes 6 bytes, so we try to achieve
4097 ;; the equivalent with shorter sequences. Here is the summary. Cases
4098 ;; are grouped for each define_peephole2.
4100 ;; reg const_int use insn
4101 ;; --------------------------------------------------------
4102 ;; live -2 eq/ne copy and inc.l
4103 ;; live -1 eq/ne copy and inc.l
4104 ;; live 1 eq/ne copy and dec.l
4105 ;; live 2 eq/ne copy and dec.l
4107 ;; dead -2 eq/ne inc.l
4108 ;; dead -1 eq/ne inc.l
4109 ;; dead 1 eq/ne dec.l
4110 ;; dead 2 eq/ne dec.l
4112 ;; dead -131072 eq/ne inc.w and test
4113 ;; dead -65536 eq/ne inc.w and test
4114 ;; dead 65536 eq/ne dec.w and test
4115 ;; dead 131072 eq/ne dec.w and test
4117 ;; dead 0x000000?? except 1 and 2 eq/ne xor.b and test
4118 ;; dead 0x0000??00 eq/ne xor.b and test
4119 ;; dead 0x0000ffff eq/ne not.w and test
4121 ;; dead 0xffffff?? except -1 and -2 eq/ne xor.b and not.l
4122 ;; dead 0xffff??ff eq/ne xor.b and not.l
4124 ;; live 1 geu/ltu copy and shar.l
4125 ;; live 3 (H8S) geu/ltu copy and shar.l
4127 ;; dead 1 geu/ltu shar.l
4128 ;; dead 3 (H8S) geu/ltu shar.l
4130 ;; dead 3 (H8/300H) geu/ltu and.b and test
4131 ;; dead 7 geu/ltu and.b and test
4132 ;; dead 15 geu/ltu and.b and test
4133 ;; dead 31 geu/ltu and.b and test
4134 ;; dead 63 geu/ltu and.b and test
4135 ;; dead 127 geu/ltu and.b and test
4136 ;; dead 255 geu/ltu and.b and test
4138 ;; dead 65535 geu/ltu mov.w
4140 ;; For a small constant, it is cheaper to actually do the subtraction
4141 ;; and then test the register.
4145 (compare (match_operand:SI 0 "register_operand" "")
4146 (match_operand:SI 1 "incdec_operand" "")))
4148 (if_then_else (match_operator 3 "eqne_operator"
4149 [(cc0) (const_int 0)])
4150 (label_ref (match_operand 2 "" ""))
4152 "(TARGET_H8300H || TARGET_H8300S)
4153 && peep2_reg_dead_p (1, operands[0])"
4155 (unspec:SI [(match_dup 0)
4161 (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
4162 (label_ref (match_dup 2))
4164 "operands[4] = GEN_INT (- INTVAL (operands[1]));")
4168 (compare (match_operand:SI 0 "register_operand" "")
4169 (match_operand:SI 1 "const_int_operand" "")))
4171 (if_then_else (match_operator 3 "eqne_operator"
4172 [(cc0) (const_int 0)])
4173 (label_ref (match_operand 2 "" ""))
4175 "(TARGET_H8300H || TARGET_H8300S)
4176 && peep2_reg_dead_p (1, operands[0])
4177 && (INTVAL (operands[1]) == -131072
4178 || INTVAL (operands[1]) == -65536
4179 || INTVAL (operands[1]) == 65536
4180 || INTVAL (operands[1]) == 131072)"
4182 (plus:SI (match_dup 0)
4187 (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
4188 (label_ref (match_dup 2))
4190 "operands[4] = GEN_INT (- INTVAL (operands[1]));")
4192 ;; For certain (in)equality comparisons against a constant, we can
4193 ;; XOR the register with the constant, and test the register against
4198 (compare (match_operand:SI 0 "register_operand" "")
4199 (match_operand:SI 1 "const_int_operand" "")))
4201 (if_then_else (match_operator 3 "eqne_operator"
4202 [(cc0) (const_int 0)])
4203 (label_ref (match_operand 2 "" ""))
4205 "(TARGET_H8300H || TARGET_H8300S)
4206 && peep2_reg_dead_p (1, operands[0])
4207 && ((INTVAL (operands[1]) & 0x00ff) == INTVAL (operands[1])
4208 || (INTVAL (operands[1]) & 0xff00) == INTVAL (operands[1])
4209 || INTVAL (operands[1]) == 0x0000ffff)
4210 && INTVAL (operands[1]) != 1
4211 && INTVAL (operands[1]) != 2"
4213 (xor:SI (match_dup 0)
4218 (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
4219 (label_ref (match_dup 2))
4225 (compare (match_operand:SI 0 "register_operand" "")
4226 (match_operand:SI 1 "const_int_operand" "")))
4228 (if_then_else (match_operator 3 "eqne_operator"
4229 [(cc0) (const_int 0)])
4230 (label_ref (match_operand 2 "" ""))
4232 "(TARGET_H8300H || TARGET_H8300S)
4233 && peep2_reg_dead_p (1, operands[0])
4234 && ((INTVAL (operands[1]) | 0x00ff) == -1
4235 || (INTVAL (operands[1]) | 0xff00) == -1)
4236 && INTVAL (operands[1]) != -1
4237 && INTVAL (operands[1]) != -2"
4239 (xor:SI (match_dup 0)
4242 (not:SI (match_dup 0)))
4246 (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
4247 (label_ref (match_dup 2))
4249 "operands[4] = GEN_INT (INTVAL (operands[1]) ^ -1);")
4262 ;; We avoid this transformation if we see more than one copy of the
4263 ;; same compare insn immediately before this one.
4266 [(match_scratch:SI 4 "r")
4268 (compare (match_operand:SI 0 "register_operand" "")
4269 (match_operand:SI 1 "const_int_operand" "")))
4271 (if_then_else (match_operator 2 "gtle_operator"
4272 [(cc0) (const_int 0)])
4273 (label_ref (match_operand 3 "" ""))
4275 "(TARGET_H8300H || TARGET_H8300S)
4276 && !peep2_reg_dead_p (1, operands[0])
4277 && (INTVAL (operands[1]) == 1
4278 || (TARGET_H8300S && INTVAL (operands[1]) == 3))
4279 && !same_cmp_preceding_p (insn)"
4282 (parallel [(set (match_dup 4)
4283 (ashiftrt:SI (match_dup 4)
4285 (clobber (scratch:QI))])
4289 (if_then_else (match_dup 5)
4290 (label_ref (match_dup 3))
4292 "switch (GET_CODE (operands[2]))
4295 operands[5] = gen_rtx_NE (VOIDmode, cc0_rtx, const0_rtx);
4298 operands[5] = gen_rtx_EQ (VOIDmode, cc0_rtx, const0_rtx);
4301 operands[5] = operands[2];
4304 operands[6] = GEN_INT (exact_log2 (INTVAL (operands[1]) + 1));")
4318 (compare (match_operand:SI 0 "register_operand" "")
4319 (match_operand:SI 1 "const_int_operand" "")))
4321 (if_then_else (match_operator 2 "gtle_operator"
4322 [(cc0) (const_int 0)])
4323 (label_ref (match_operand 3 "" ""))
4325 "(TARGET_H8300H || TARGET_H8300S)
4326 && peep2_reg_dead_p (1, operands[0])
4327 && (INTVAL (operands[1]) == 1
4328 || (TARGET_H8300S && INTVAL (operands[1]) == 3))"
4329 [(parallel [(set (match_dup 0)
4330 (ashiftrt:SI (match_dup 0)
4332 (clobber (scratch:QI))])
4336 (if_then_else (match_dup 4)
4337 (label_ref (match_dup 3))
4339 "switch (GET_CODE (operands[2]))
4342 operands[4] = gen_rtx_NE (VOIDmode, cc0_rtx, const0_rtx);
4345 operands[4] = gen_rtx_EQ (VOIDmode, cc0_rtx, const0_rtx);
4348 operands[4] = operands[2];
4351 operands[5] = GEN_INT (exact_log2 (INTVAL (operands[1]) + 1));")
4366 (compare (match_operand:SI 0 "register_operand" "")
4367 (match_operand:SI 1 "const_int_operand" "")))
4369 (if_then_else (match_operator 2 "gtle_operator"
4370 [(cc0) (const_int 0)])
4371 (label_ref (match_operand 3 "" ""))
4373 "(TARGET_H8300H || TARGET_H8300S)
4374 && peep2_reg_dead_p (1, operands[0])
4375 && ((TARGET_H8300H && INTVAL (operands[1]) == 3)
4376 || INTVAL (operands[1]) == 7
4377 || INTVAL (operands[1]) == 15
4378 || INTVAL (operands[1]) == 31
4379 || INTVAL (operands[1]) == 63
4380 || INTVAL (operands[1]) == 127
4381 || INTVAL (operands[1]) == 255)"
4383 (and:SI (match_dup 0)
4388 (if_then_else (match_dup 4)
4389 (label_ref (match_dup 3))
4391 "switch (GET_CODE (operands[2]))
4394 operands[4] = gen_rtx_NE (VOIDmode, cc0_rtx, const0_rtx);
4397 operands[4] = gen_rtx_EQ (VOIDmode, cc0_rtx, const0_rtx);
4400 operands[4] = operands[2];
4403 operands[5] = GEN_INT (~INTVAL (operands[1]));")
4405 ;; Transform A <= 65535 to (A & 0xffff0000) == 0.
4409 (compare (match_operand:SI 0 "register_operand" "")
4412 (if_then_else (match_operator 1 "gtle_operator"
4413 [(cc0) (const_int 0)])
4414 (label_ref (match_operand 2 "" ""))
4416 "TARGET_H8300H || TARGET_H8300S"
4418 (and:SI (match_dup 0)
4419 (const_int -65536)))
4421 (if_then_else (match_dup 3)
4422 (label_ref (match_dup 2))
4424 "switch (GET_CODE (operands[1]))
4427 operands[3] = gen_rtx_NE (VOIDmode, cc0_rtx, const0_rtx);
4430 operands[3] = gen_rtx_EQ (VOIDmode, cc0_rtx, const0_rtx);
4433 operands[3] = operands[1];
4437 ;; For constants like -1, -2, 1, 2, it is still cheaper to make a copy
4438 ;; of the register being tested, do the subtraction on the copy, and
4439 ;; then test the copy. We avoid this transformation if we see more
4440 ;; than one copy of the same compare insn.
4443 [(match_scratch:SI 4 "r")
4445 (compare (match_operand:SI 0 "register_operand" "")
4446 (match_operand:SI 1 "incdec_operand" "")))
4448 (if_then_else (match_operator 3 "eqne_operator"
4449 [(cc0) (const_int 0)])
4450 (label_ref (match_operand 2 "" ""))
4452 "(TARGET_H8300H || TARGET_H8300S)
4453 && !peep2_reg_dead_p (1, operands[0])
4454 && !rtx_equal_p (PATTERN (insn),
4455 PATTERN (next_nonnote_insn (next_nonnote_insn (insn))))"
4459 (unspec:SI [(match_dup 4)
4465 (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
4466 (label_ref (match_dup 2))
4468 "operands[5] = GEN_INT (- INTVAL (operands[1]));")
4470 ;; Narrow the mode of testing if possible.
4473 [(set (match_operand:HI 0 "register_operand" "")
4474 (and:HI (match_dup 0)
4475 (match_operand:HI 1 "const_int_qi_operand" "")))
4479 (if_then_else (match_operator 3 "eqne_operator"
4480 [(cc0) (const_int 0)])
4481 (label_ref (match_operand 2 "" ""))
4483 "peep2_reg_dead_p (2, operands[0])"
4485 (and:QI (match_dup 4)
4490 (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
4491 (label_ref (match_dup 2))
4493 "operands[4] = gen_rtx_REG (QImode, REGNO (operands[0]));
4494 operands[5] = gen_int_mode (INTVAL (operands[1]), QImode);")
4497 [(set (match_operand:SI 0 "register_operand" "")
4498 (and:SI (match_dup 0)
4499 (match_operand:SI 1 "const_int_qi_operand" "")))
4503 (if_then_else (match_operator 3 "eqne_operator"
4504 [(cc0) (const_int 0)])
4505 (label_ref (match_operand 2 "" ""))
4507 "peep2_reg_dead_p (2, operands[0])"
4509 (and:QI (match_dup 4)
4514 (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
4515 (label_ref (match_dup 2))
4517 "operands[4] = gen_rtx_REG (QImode, REGNO (operands[0]));
4518 operands[5] = gen_int_mode (INTVAL (operands[1]), QImode);")
4521 [(set (match_operand:SI 0 "register_operand" "")
4522 (and:SI (match_dup 0)
4523 (match_operand:SI 1 "const_int_hi_operand" "")))
4527 (if_then_else (match_operator 3 "eqne_operator"
4528 [(cc0) (const_int 0)])
4529 (label_ref (match_operand 2 "" ""))
4531 "peep2_reg_dead_p (2, operands[0])"
4533 (and:HI (match_dup 4)
4538 (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
4539 (label_ref (match_dup 2))
4541 "operands[4] = gen_rtx_REG (HImode, REGNO (operands[0]));
4542 operands[5] = gen_int_mode (INTVAL (operands[1]), HImode);")
4545 [(set (match_operand:SI 0 "register_operand" "")
4546 (and:SI (match_dup 0)
4547 (match_operand:SI 1 "const_int_qi_operand" "")))
4549 (xor:SI (match_dup 0)
4550 (match_operand:SI 2 "const_int_qi_operand" "")))
4554 (if_then_else (match_operator 4 "eqne_operator"
4555 [(cc0) (const_int 0)])
4556 (label_ref (match_operand 3 "" ""))
4558 "peep2_reg_dead_p (3, operands[0])
4559 && (~INTVAL (operands[1]) & INTVAL (operands[2])) == 0"
4561 (and:QI (match_dup 5)
4564 (xor:QI (match_dup 5)
4569 (if_then_else (match_op_dup 4 [(cc0) (const_int 0)])
4570 (label_ref (match_dup 3))
4572 "operands[5] = gen_rtx_REG (QImode, REGNO (operands[0]));
4573 operands[6] = gen_int_mode (INTVAL (operands[1]), QImode);
4574 operands[7] = gen_int_mode (INTVAL (operands[2]), QImode);")