gcc/config/h8300/h8300.md

   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.
   4
   5 ;;   Contributed by Steve Chamberlain (sac@cygnus.com),
   6 ;;   Jim Wilson (wilson@cygnus.com), and Doug Evans (dje@cygnus.com).
   7
   8 ;; This file is part of GCC.
   9
  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)
  13 ;; any later version.
  14
  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.
  19
  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.
  24
  25 ;; Some of the extend instructions accept a general_operand_src, which
  26 ;; allows all the normal memory addressing modes.  The length computations
  27 ;; don't take this into account.  The lengths in the MD file should be
  28 ;; "worst case" and then be adjusted to their correct values by
  29 ;; h8300_adjust_insn_length.
  30
  31 ;; On the H8/300H and H8S, adds/subs operate on the 32bit "er"
  32 ;; registers.  Right now GCC doesn't expose the "e" half to the
  33 ;; compiler, so using add/subs for addhi and subhi is safe.  Long
  34 ;; term, we want to expose the "e" half to the compiler (gives us 8
  35 ;; more 16bit registers).  At that point addhi and subhi can't use
  36 ;; adds/subs.
  37
  38 ;; There's currently no way to have an insv/extzv expander for the H8/300H
  39 ;; because word_mode is different for the H8/300 and H8/300H.
  40
  41 ;; Shifts/rotates by small constants should be handled by special
  42 ;; patterns so we get the length and cc status correct.
  43
  44 ;; Bitfield operations no longer accept memory operands.  We need
  45 ;; to add variants which operate on memory back to the MD.
  46
  47 ;; ??? Implement remaining bit ops available on the h8300
  48
  49 ;; ----------------------------------------------------------------------
  50 ;; CONSTANTS
  51 ;; ----------------------------------------------------------------------
  52
  53 (define_constants
  54   [(UNSPEC_INCDEC       0)
  55    (UNSPEC_MONITOR      1)])
  56
  57 (define_constants
  58   [(SC_REG       3)
  59    (FP_REG       6)
  60    (SP_REG       7)
  61    (MAC_REG      8)
  62    (AP_REG       9)
  63    (RAP_REG     10)])
  64
  65 ;; ----------------------------------------------------------------------
  66 ;; ATTRIBUTES
  67 ;; ----------------------------------------------------------------------
  68
  69 (define_attr "cpu" "h8300,h8300h"
  70   (const (symbol_ref "cpu_type")))
  71
  72 (define_attr "type" "branch,arith"
  73   (const_string "arith"))
  74
  75 ;; The size of instructions in bytes.
  76
  77 (define_attr "length" ""
  78   (cond [(eq_attr "type" "branch")
  79          (if_then_else (and (ge (minus (match_dup 0) (pc))
  80                                 (const_int -126))
  81                             (le (minus (match_dup 0) (pc))
  82                                 (const_int 126)))
  83                        (const_int 2)
  84                        (if_then_else (and (eq_attr "cpu" "h8300h")
  85                                           (and (ge (minus (pc) (match_dup 0))
  86                                                    (const_int -32000))
  87                                                (le (minus (pc) (match_dup 0))
  88                                                    (const_int 32000))))
  89                                      (const_int 4)
  90                                      (const_int 6)))]
  91         (const_int 200)))
  92
  93 ;; The necessity of instruction length adjustment.
  94
  95 (define_attr "adjust_length" "yes,no"
  96   (cond [(eq_attr "type" "branch") (const_string "no")]
  97         (const_string "yes")))
  98
  99 ;; Condition code settings.
 100 ;;
 101 ;; none - insn does not affect cc
 102 ;; none_0hit - insn does not affect cc but it does modify operand 0
 103 ;;      This attribute is used to keep track of when operand 0 changes.
 104 ;;      See the description of NOTICE_UPDATE_CC for more info.
 105 ;; set_znv - insn sets z,n,v to usable values (like a tst insn); c is unknown.
 106 ;; set_zn  - insn sets z,n to usable values; v,c are unknown.
 107 ;; compare - compare instruction
 108 ;; clobber - value of cc is unknown
 109
 110 (define_attr "cc" "none,none_0hit,set_znv,set_zn,compare,clobber"
 111   (const_string "clobber"))
 112 \f
 113 ;; ----------------------------------------------------------------------
 114 ;; MOVE INSTRUCTIONS
 115 ;; ----------------------------------------------------------------------
 116
 117 ;; movqi
 118
 119 (define_insn "pushqi1_h8300"
 120   [(parallel [(set (reg:HI SP_REG)
 121                    (plus:HI (reg:HI SP_REG) (const_int -2)))
 122               (set (mem:QI (plus:HI (reg:HI SP_REG) (const_int -1)))
 123                    (match_operand:QI 0 "register_operand" "r"))])]
 124   "TARGET_H8300
 125    && REGNO (operands[0]) != SP_REG"
 126   "mov.w\\t%T0,@-r7"
 127   [(set_attr "length" "2")
 128    (set_attr "cc" "clobber")])
 129
 130 (define_insn "pushqi1_h8300hs"
 131   [(parallel [(set (reg:SI SP_REG)
 132                    (plus:SI (reg:SI SP_REG) (const_int -4)))
 133               (set (mem:QI (plus:SI (reg:SI SP_REG) (const_int -3)))
 134                    (match_operand:QI 0 "register_operand" "r"))])]
 135   "(TARGET_H8300H || TARGET_H8300S)
 136    && REGNO (operands[0]) != SP_REG"
 137   "mov.l\\t%S0,@-er7"
 138   [(set_attr "length" "4")
 139    (set_attr "cc" "clobber")])
 140
 141 (define_expand "pushqi1"
 142   [(use (match_operand:QI 0 "register_operand" ""))]
 143   ""
 144   "
 145 {
 146   if (TARGET_H8300)
 147     emit_insn (gen_pushqi1_h8300 (operands[0]));
 148   else
 149     emit_insn (gen_pushqi1_h8300hs (operands[0]));
 150   DONE;
 151 }")
 152
 153 (define_insn ""
 154   [(set (match_operand:QI 0 "general_operand_dst" "=r,r ,<,r,r,m")
 155         (match_operand:QI 1 "general_operand_src" " I,r>,r,n,m,r"))]
 156   "TARGET_H8300
 157    && (register_operand (operands[0], QImode)
 158        || register_operand (operands[1], QImode))"
 159   "@
 160    sub.b        %X0,%X0
 161    mov.b        %R1,%X0
 162    mov.b        %X1,%R0
 163    mov.b        %R1,%X0
 164    mov.b        %R1,%X0
 165    mov.b        %X1,%R0"
 166   [(set_attr "length" "2,2,2,2,4,4")
 167    (set_attr "cc" "set_zn,set_znv,set_znv,set_znv,set_znv,set_znv")])
 168
 169 (define_insn ""
 170   [(set (match_operand:QI 0 "general_operand_dst" "=r,r ,<,r,r,m")
 171         (match_operand:QI 1 "general_operand_src" " I,r>,r,n,m,r"))]
 172   "(TARGET_H8300H || TARGET_H8300S)
 173    && (register_operand (operands[0], QImode)
 174        || register_operand (operands[1], QImode))"
 175   "@
 176    sub.b        %X0,%X0
 177    mov.b        %R1,%X0
 178    mov.b        %X1,%R0
 179    mov.b        %R1,%X0
 180    mov.b        %R1,%X0
 181    mov.b        %X1,%R0"
 182   [(set_attr "length" "2,2,2,2,8,8")
 183    (set_attr "cc" "set_zn,set_znv,set_znv,clobber,set_znv,set_znv")])
 184
 185 (define_expand "movqi"
 186   [(set (match_operand:QI 0 "general_operand_dst" "")
 187         (match_operand:QI 1 "general_operand_src" ""))]
 188   ""
 189   "
 190 {
 191   /* One of the ops has to be in a register.  */
 192   if (!register_operand (operand0, QImode)
 193       && !register_operand (operand1, QImode))
 194     {
 195       operands[1] = copy_to_mode_reg (QImode, operand1);
 196     }
 197 }")
 198
 199 (define_insn "movstrictqi"
 200   [(set (strict_low_part (match_operand:QI 0 "general_operand_dst" "+r,r,r,r"))
 201                          (match_operand:QI 1 "general_operand_src" "I,r,n,m"))]
 202   ""
 203   "@
 204    sub.b        %X0,%X0
 205    mov.b        %X1,%X0
 206    mov.b        %R1,%X0
 207    mov.b        %R1,%X0"
 208   [(set_attr_alternative "length"
 209      [(const_int 2) (const_int 2) (const_int 2)
 210       (if_then_else (eq_attr "cpu" "h8300") (const_int 4) (const_int 8))])
 211    (set_attr "cc" "set_zn,set_znv,set_znv,set_znv")])
 212
 213 ;; movhi
 214
 215 (define_expand "pushhi1_h8300"
 216   [(set (mem:HI (pre_dec:HI (reg:HI SP_REG)))
 217         (match_operand:HI 0 "register_operand" ""))]
 218   "TARGET_H8300
 219    && REGNO (operands[0]) != SP_REG"
 220   "")
 221
 222 (define_insn "pushhi1_h8300hs"
 223   [(parallel [(set (reg:SI SP_REG)
 224                    (plus:SI (reg:SI SP_REG) (const_int -4)))
 225               (set (mem:HI (plus:SI (reg:SI SP_REG) (const_int -2)))
 226                    (match_operand:HI 0 "register_operand" "r"))])]
 227   "(TARGET_H8300H || TARGET_H8300S)
 228    && REGNO (operands[0]) != SP_REG"
 229   "mov.l\\t%S0,@-er7"
 230   [(set_attr "length" "4")
 231    (set_attr "cc" "clobber")])
 232
 233 (define_expand "pushhi1"
 234   [(use (match_operand:HI 0 "register_operand" ""))]
 235   ""
 236   "
 237 {
 238   if (TARGET_H8300)
 239     emit_insn (gen_pushhi1_h8300 (operands[0]));
 240   else
 241     emit_insn (gen_pushhi1_h8300hs (operands[0]));
 242   DONE;
 243 }")
 244
 245 (define_insn ""
 246   [(set (match_operand:HI 0 "general_operand_dst" "=r,r,<,r,r,m")
 247         (match_operand:HI 1 "general_operand_src" "I,r>,r,i,m,r"))]
 248   "TARGET_H8300
 249    && (register_operand (operands[0], HImode)
 250        || register_operand (operands[1], HImode))
 251    && !(GET_CODE (operands[0]) == MEM
 252         && GET_CODE (XEXP (operands[0], 0)) == PRE_DEC
 253         && GET_CODE (XEXP (XEXP (operands[0], 0), 0)) == REG
 254         && GET_CODE (operands[1]) == REG
 255         && REGNO (XEXP (XEXP (operands[0], 0), 0)) == REGNO (operands[1]))"
 256   "@
 257    sub.w        %T0,%T0
 258    mov.w        %T1,%T0
 259    mov.w        %T1,%T0
 260    mov.w        %T1,%T0
 261    mov.w        %T1,%T0
 262    mov.w        %T1,%T0"
 263   [(set_attr "length" "2,2,2,4,4,4")
 264    (set_attr "cc" "set_zn,set_znv,set_znv,set_znv,set_znv,set_znv")])
 265
 266 (define_insn ""
 267   [(set (match_operand:HI 0 "general_operand_dst" "=r,r,<,r,r,m")
 268         (match_operand:HI 1 "general_operand_src" "I,r>,r,i,m,r"))]
 269   "(TARGET_H8300H || TARGET_H8300S)
 270    && (register_operand (operands[0], HImode)
 271        || register_operand (operands[1], HImode))"
 272   "@
 273    sub.w        %T0,%T0
 274    mov.w        %T1,%T0
 275    mov.w        %T1,%T0
 276    mov.w        %T1,%T0
 277    mov.w        %T1,%T0
 278    mov.w        %T1,%T0"
 279   [(set_attr "length" "2,2,2,4,8,8")
 280    (set_attr "cc" "set_zn,set_znv,set_znv,set_znv,set_znv,set_znv")])
 281
 282 (define_expand "movhi"
 283   [(set (match_operand:HI 0 "general_operand_dst" "")
 284         (match_operand:HI 1 "general_operand_src" ""))]
 285   ""
 286   "
 287 {
 288   /* One of the ops has to be in a register.  */
 289   if (!register_operand (operand1, HImode)
 290       && !register_operand (operand0, HImode))
 291     {
 292       operands[1] = copy_to_mode_reg (HImode, operand1);
 293     }
 294 }")
 295
 296 (define_insn "movstricthi"
 297   [(set (strict_low_part (match_operand:HI 0 "general_operand_dst" "+r,r,r,r"))
 298                          (match_operand:HI 1 "general_operand_src" "I,r,i,m"))]
 299   ""
 300   "@
 301    sub.w        %T0,%T0
 302    mov.w        %T1,%T0
 303    mov.w        %T1,%T0
 304    mov.w        %T1,%T0"
 305   [(set_attr_alternative "length"
 306      [(const_int 2) (const_int 2) (const_int 4)
 307       (if_then_else (eq_attr "cpu" "h8300") (const_int 4) (const_int 8))])
 308    (set_attr "cc" "set_zn,set_znv,set_znv,set_znv")])
 309
 310 ;; movsi
 311
 312 (define_expand "movsi"
 313   [(set (match_operand:SI 0 "general_operand_dst" "")
 314         (match_operand:SI 1 "general_operand_src" ""))]
 315   ""
 316   "
 317 {
 318   if (TARGET_H8300)
 319     {
 320       if (do_movsi (operands))
 321         DONE;
 322     }
 323   else
 324     {
 325       /* One of the ops has to be in a register.  */
 326       if (!register_operand (operand1, SImode)
 327           && !register_operand (operand0, SImode))
 328         {
 329           operands[1] = copy_to_mode_reg (SImode, operand1);
 330         }
 331     }
 332 }")
 333
 334 (define_expand "movsf"
 335   [(set (match_operand:SF 0 "general_operand_dst" "")
 336         (match_operand:SF 1 "general_operand_src" ""))]
 337   ""
 338   "
 339 {
 340   if (TARGET_H8300)
 341     {
 342       if (do_movsi (operands))
 343         DONE;
 344     }
 345   else
 346     {
 347       /* One of the ops has to be in a register.  */
 348       if (!register_operand (operand1, SFmode)
 349           && !register_operand (operand0, SFmode))
 350         {
 351           operands[1] = copy_to_mode_reg (SFmode, operand1);
 352         }
 353     }
 354 }")
 355
 356 (define_insn "movsi_h8300"
 357   [(set (match_operand:SI 0 "general_operand_dst" "=r,r,r,o,<,r")
 358         (match_operand:SI 1 "general_operand_src" "I,r,io,r,r,>"))]
 359   "TARGET_H8300
 360    && (register_operand (operands[0], SImode)
 361        || register_operand (operands[1], SImode))"
 362   "*
 363 {
 364   unsigned int rn = -1;
 365   switch (which_alternative)
 366     {
 367     case 0:
 368       return \"sub.w    %e0,%e0\;sub.w  %f0,%f0\";
 369     case 1:
 370       if (REGNO (operands[0]) < REGNO (operands[1]))
 371         return \"mov.w  %e1,%e0\;mov.w  %f1,%f0\";
 372       else
 373         return \"mov.w  %f1,%f0\;mov.w  %e1,%e0\";
 374     case 2:
 375       /* Make sure we don't trample the register we index with.  */
 376       if (GET_CODE (operands[1]) == MEM)
 377         {
 378           rtx inside = XEXP (operands[1], 0);
 379           if (REG_P (inside))
 380             {
 381               rn = REGNO (inside);
 382             }
 383           else if (GET_CODE (inside) == PLUS)
 384             {
 385               rtx lhs = XEXP (inside, 0);
 386               rtx rhs = XEXP (inside, 1);
 387               if (REG_P (lhs)) rn = REGNO (lhs);
 388               if (REG_P (rhs)) rn = REGNO (rhs);
 389             }
 390         }
 391       if (rn == REGNO (operands[0]))
 392         {
 393           /* Move the second word first.  */
 394           return \"mov.w        %f1,%f0\;mov.w  %e1,%e0\";
 395         }
 396       else
 397         {
 398           /* See if either half is zero.  If so, use sub.w to clear
 399              that half.  */
 400           if (GET_CODE (operands[1]) == CONST_INT)
 401             {
 402               if ((INTVAL (operands[1]) & 0xffff) == 0)
 403                 return \"mov.w  %e1,%e0\;sub.w  %f0,%f0\";
 404               if (((INTVAL (operands[1]) >> 16) & 0xffff) == 0)
 405                 return \"sub.w  %e0,%e0\;mov.w  %f1,%f0\";
 406             }
 407           return \"mov.w        %e1,%e0\;mov.w  %f1,%f0\";
 408         }
 409     case 3:
 410       return \"mov.w    %e1,%e0\;mov.w  %f1,%f0\";
 411     case 4:
 412       return \"mov.w    %f1,%T0\;mov.w  %e1,%T0\";
 413     case 5:
 414       return \"mov.w    %T1,%e0\;mov.w  %T1,%f0\";
 415     default:
 416       abort ();
 417     }
 418 }"
 419   [(set_attr "length" "4,4,8,8,4,4")
 420    (set_attr "cc" "clobber")])
 421
 422 (define_insn "movsf_h8300"
 423   [(set (match_operand:SF 0 "general_operand_dst" "=r,r,r,o,<,r")
 424         (match_operand:SF 1 "general_operand_src" "I,r,io,r,r,>"))]
 425   "TARGET_H8300
 426    && (register_operand (operands[0], SFmode)
 427        || register_operand (operands[1], SFmode))"
 428   "*
 429 {
 430   /* Copy of the movsi stuff.  */
 431   unsigned int rn = -1;
 432   switch (which_alternative)
 433     {
 434     case 0:
 435       return \"sub.w    %e0,%e0\;sub.w  %f0,%f0\";
 436     case 1:
 437       if (REGNO (operands[0]) < REGNO (operands[1]))
 438         return \"mov.w  %e1,%e0\;mov.w  %f1,%f0\";
 439       else
 440         return \"mov.w  %f1,%f0\;mov.w  %e1,%e0\";
 441     case 2:
 442       /* Make sure we don't trample the register we index with.  */
 443       if (GET_CODE (operands[1]) == MEM)
 444         {
 445           rtx inside = XEXP (operands[1], 0);
 446           if (REG_P (inside))
 447             {
 448               rn = REGNO (inside);
 449             }
 450           else if (GET_CODE (inside) == PLUS)
 451             {
 452               rtx lhs = XEXP (inside, 0);
 453               rtx rhs = XEXP (inside, 1);
 454               if (REG_P (lhs)) rn = REGNO (lhs);
 455               if (REG_P (rhs)) rn = REGNO (rhs);
 456             }
 457         }
 458       if (rn == REGNO (operands[0]))
 459         /* Move the second word first.  */
 460         return \"mov.w  %f1,%f0\;mov.w  %e1,%e0\";
 461       else
 462         /* Move the first word first.  */
 463         return \"mov.w  %e1,%e0\;mov.w  %f1,%f0\";
 464
 465     case 3:
 466       return \"mov.w    %e1,%e0\;mov.w  %f1,%f0\";
 467     case 4:
 468       return \"mov.w    %f1,%T0\;mov.w  %e1,%T0\";
 469     case 5:
 470       return \"mov.w    %T1,%e0\;mov.w  %T1,%f0\";
 471     default:
 472       abort ();
 473     }
 474 }"
 475   [(set_attr "length" "4,4,8,8,4,4")
 476    (set_attr "cc" "clobber")])
 477
 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]))"
 489   "*
 490 {
 491   switch (which_alternative)
 492     {
 493     case 0:
 494       return \"sub.l    %S0,%S0\";
 495     case 7:
 496       return \"clrmac\";
 497     case 8:
 498       return \"clrmac\;ldmac %1,macl\";
 499     case 9:
 500       return \"stmac    macl,%0\";
 501     default:
 502       if (GET_CODE (operands[1]) == CONST_INT)
 503         {
 504           int val = INTVAL (operands[1]);
 505
 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))
 509             {
 510               operands[1] = GEN_INT ((char) val & 0xff);
 511               return \"sub.l\\t%S0,%S0\;add.b\\t%1,%w0\";
 512             }
 513
 514           if (val == (val & 0xff00))
 515             {
 516               operands[1] = GEN_INT ((char) (val >> 8) & 0xff);
 517               return \"sub.l\\t%S0,%S0\;add.b\\t%1,%x0\";
 518             }
 519
 520           /* Look for constants that can be obtained by subs, inc, and
 521              dec to 0.  */
 522           switch (val & 0xffffffff)
 523             {
 524             case 0xffffffff:
 525               return \"sub.l\\t%S0,%S0\;subs\\t#1,%S0\";
 526             case 0xfffffffe:
 527               return \"sub.l\\t%S0,%S0\;subs\\t#2,%S0\";
 528             case 0xfffffffc:
 529               return \"sub.l\\t%S0,%S0\;subs\\t#4,%S0\";
 530
 531             case 0x0000ffff:
 532               return \"sub.l\\t%S0,%S0\;dec.w\\t#1,%f0\";
 533             case 0x0000fffe:
 534               return \"sub.l\\t%S0,%S0\;dec.w\\t#2,%f0\";
 535
 536             case 0xffff0000:
 537               return \"sub.l\\t%S0,%S0\;dec.w\\t#1,%e0\";
 538             case 0xfffe0000:
 539               return \"sub.l\\t%S0,%S0\;dec.w\\t#2,%e0\";
 540
 541             case 0x00010000:
 542               return \"sub.l\\t%S0,%S0\;inc.w\\t#1,%e0\";
 543             case 0x00020000:
 544               return \"sub.l\\t%S0,%S0\;inc.w\\t#2,%e0\";
 545             }
 546         }
 547     }
 548    return \"mov.l       %S1,%S0\";
 549 }"
 550   [(set_attr "length" "2,2,6,4,4,10,10,2,6,4")
 551    (set_attr "cc" "set_zn,set_znv,clobber,set_znv,set_znv,set_znv,set_znv,none_0hit,none_0hit,set_znv")])
 552
 553 (define_insn "movsf_h8300h"
 554   [(set (match_operand:SF 0 "general_operand_dst" "=r,r,r,m,<,r")
 555         (match_operand:SF 1 "general_operand_src" "I,r,im,r,r,>"))]
 556   "(TARGET_H8300H || TARGET_H8300S)
 557    && (register_operand (operands[0], SFmode)
 558        || register_operand (operands[1], SFmode))"
 559   "@
 560    sub.l        %S0,%S0
 561    mov.l        %S1,%S0
 562    mov.l        %S1,%S0
 563    mov.l        %S1,%S0
 564    mov.l        %S1,%S0
 565    mov.l        %S1,%S0"
 566   [(set_attr "length" "2,2,10,10,4,4")
 567    (set_attr "cc" "set_zn,set_znv,set_znv,set_znv,set_znv,set_znv")])
 568 \f
 569 ;; ----------------------------------------------------------------------
 570 ;; TEST INSTRUCTIONS
 571 ;; ----------------------------------------------------------------------
 572
 573 (define_insn ""
 574   [(set (cc0) (zero_extract:HI (match_operand:QI 0 "bit_memory_operand" "r,U")
 575                                (const_int 1)
 576                                (match_operand 1 "const_int_operand" "n,n")))]
 577   "TARGET_H8300"
 578   "btst %Z1,%Y0"
 579   [(set_attr "length" "2,4")
 580    (set_attr "cc" "set_zn,set_zn")])
 581
 582 (define_insn ""
 583   [(set (cc0) (zero_extract:HI (match_operand:HI 0 "register_operand" "r")
 584                                (const_int 1)
 585                                (match_operand 1 "const_int_operand" "n")))]
 586   "TARGET_H8300"
 587   "btst %Z1,%Y0"
 588   [(set_attr "length" "2")
 589    (set_attr "cc" "set_zn")])
 590
 591 (define_insn "*tst_extzv_1_n"
 592   [(set (cc0)
 593         (zero_extract:SI (match_operand:QI 0 "general_operand_src" "r,U,mn>")
 594                          (const_int 1)
 595                          (match_operand 1 "const_int_operand" "n,n,n")))
 596    (clobber (match_scratch:QI 2 "=X,X,&r"))]
 597   "(TARGET_H8300H || TARGET_H8300S)"
 598   "@
 599    btst\\t%Z1,%Y0
 600    btst\\t%Z1,%Y0
 601    #"
 602   [(set_attr "length" "2,8,10")
 603    (set_attr "cc" "set_zn,set_zn,set_zn")])
 604
 605 (define_split
 606   [(set (cc0)
 607         (zero_extract:SI (match_operand:QI 0 "general_operand" "")
 608                          (const_int 1)
 609                          (match_operand 1 "const_int_operand" "")))
 610    (clobber (match_operand:QI 2 "register_operand" ""))]
 611   "(TARGET_H8300H || TARGET_H8300S)
 612    && reload_completed
 613    && !EXTRA_CONSTRAINT (operands[0], 'U')"
 614   [(set (match_dup 2)
 615         (match_dup 0))
 616    (parallel [(set (cc0) (zero_extract:SI (match_dup 2)
 617                                           (const_int 1)
 618                                           (match_dup 1)))
 619               (clobber (scratch:QI))])]
 620   "")
 621
 622 (define_insn ""
 623   [(set (cc0) (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
 624                                (const_int 1)
 625                                (match_operand 1 "const_int_operand" "n")))]
 626   "(TARGET_H8300H || TARGET_H8300S)
 627    && INTVAL (operands[1]) <= 15"
 628   "btst %Z1,%Y0"
 629   [(set_attr "length" "2")
 630    (set_attr "cc" "set_zn")])
 631
 632 (define_insn_and_split "*tstsi_upper_bit"
 633   [(set (cc0)
 634         (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
 635                          (const_int 1)
 636                          (match_operand 1 "const_int_operand" "n")))
 637    (clobber (match_scratch:SI 2 "=&r"))]
 638   "(TARGET_H8300H || TARGET_H8300S)
 639    && INTVAL (operands[1]) >= 16"
 640   "#"
 641   "&& reload_completed"
 642   [(set (match_dup 2)
 643         (ior:SI (and:SI (match_dup 2)
 644                         (const_int -65536))
 645                 (lshiftrt:SI (match_dup 0)
 646                              (const_int 16))))
 647    (set (cc0)
 648         (zero_extract:SI (match_dup 2)
 649                          (const_int 1)
 650                          (match_dup 3)))]
 651   "operands[3] = GEN_INT (INTVAL (operands[1]) - 16);")
 652
 653 (define_insn ""
 654   [(set (cc0)
 655         (and:HI (match_operand:HI 0 "register_operand" "r")
 656                 (match_operand:HI 1 "single_one_operand" "n")))]
 657   ""
 658   "*
 659 {
 660   operands[1] = GEN_INT (INTVAL (operands[1]) & 0xffff);
 661   if (INTVAL (operands[1]) > 128)
 662     {
 663       operands[1] = GEN_INT (INTVAL (operands[1]) >> 8);
 664       return \"btst\\t%V1,%t0\";
 665     }
 666   return \"btst\\t%V1,%s0\";
 667 }"
 668   [(set_attr "length" "2")
 669    (set_attr "cc" "set_zn")])
 670
 671 (define_insn ""
 672   [(set (cc0)
 673         (and:SI (match_operand:SI 0 "register_operand" "r")
 674                 (match_operand:SI 1 "single_one_operand" "n")))]
 675   "(TARGET_H8300H || TARGET_H8300S)
 676    && (INTVAL (operands[1]) & 0xffff) != 0"
 677   "*
 678 {
 679   operands[1] = GEN_INT (INTVAL (operands[1]) & 0xffff);
 680   if (INTVAL (operands[1]) > 128)
 681     {
 682       operands[1] = GEN_INT (INTVAL (operands[1]) >> 8);
 683       return \"btst\\t%V1,%x0\";
 684     }
 685   return \"btst\\t%V1,%w0\";
 686 }"
 687   [(set_attr "length" "2")
 688    (set_attr "cc" "set_zn")])
 689
 690 (define_insn "tstqi"
 691   [(set (cc0) (match_operand:QI 0 "register_operand" "r"))]
 692   ""
 693   "mov.b        %X0,%X0"
 694   [(set_attr "length" "2")
 695    (set_attr "cc" "set_znv")])
 696
 697 (define_insn "tsthi"
 698   [(set (cc0) (match_operand:HI 0 "register_operand" "r"))]
 699   ""
 700   "mov.w        %T0,%T0"
 701   [(set_attr "length" "2")
 702    (set_attr "cc" "set_znv")])
 703
 704 (define_insn ""
 705   [(set (cc0)
 706         (and:HI (match_operand:HI 0 "register_operand" "r")
 707                 (const_int -256)))]
 708   ""
 709   "mov.b        %t0,%t0"
 710   [(set_attr "length" "2")
 711    (set_attr "cc" "set_znv")])
 712
 713 (define_insn "tstsi"
 714   [(set (cc0) (match_operand:SI 0 "register_operand" "r"))]
 715   "TARGET_H8300H || TARGET_H8300S"
 716   "mov.l        %S0,%S0"
 717   [(set_attr "length" "2")
 718    (set_attr "cc" "set_znv")])
 719
 720 (define_insn ""
 721   [(set (cc0)
 722         (and:SI (match_operand:SI 0 "register_operand" "r")
 723                 (const_int -65536)))]
 724   ""
 725   "mov.w        %e0,%e0"
 726   [(set_attr "length" "2")
 727    (set_attr "cc" "set_znv")])
 728
 729 (define_insn "cmpqi"
 730   [(set (cc0)
 731         (compare (match_operand:QI 0 "register_operand" "r")
 732                  (match_operand:QI 1 "nonmemory_operand" "rn")))]
 733   ""
 734   "cmp.b        %X1,%X0"
 735   [(set_attr "length" "2")
 736    (set_attr "cc" "compare")])
 737
 738 (define_expand "cmphi"
 739   [(set (cc0)
 740         (compare (match_operand:HI 0 "register_operand" "")
 741                  (match_operand:HI 1 "nonmemory_operand" "")))]
 742   ""
 743   "
 744 {
 745   /* Force operand1 into a register if we're compiling
 746      for the H8/300.  */
 747   if (GET_CODE (operands[1]) != REG && TARGET_H8300)
 748     operands[1] = force_reg (HImode, operands[1]);
 749 }")
 750
 751 (define_insn "*cmphi_h8300"
 752   [(set (cc0)
 753         (compare (match_operand:HI 0 "register_operand" "r")
 754                  (match_operand:HI 1 "register_operand" "r")))]
 755   "TARGET_H8300"
 756   "cmp.w        %T1,%T0"
 757   [(set_attr "length" "2")
 758    (set_attr "cc" "compare")])
 759
 760 (define_insn "*cmphi_h8300hs"
 761   [(set (cc0)
 762         (compare (match_operand:HI 0 "register_operand" "r,r")
 763                  (match_operand:HI 1 "nonmemory_operand" "r,n")))]
 764   "TARGET_H8300H || TARGET_H8300S"
 765   "cmp.w        %T1,%T0"
 766   [(set_attr "length" "2,4")
 767    (set_attr "cc" "compare,compare")])
 768
 769 (define_insn "cmpsi"
 770   [(set (cc0)
 771         (compare (match_operand:SI 0 "register_operand" "r,r")
 772                  (match_operand:SI 1 "nonmemory_operand" "r,i")))]
 773   "TARGET_H8300H || TARGET_H8300S"
 774   "cmp.l        %S1,%S0"
 775   [(set_attr "length" "2,6")
 776    (set_attr "cc" "compare,compare")])
 777 \f
 778 ;; ----------------------------------------------------------------------
 779 ;; ADD INSTRUCTIONS
 780 ;; ----------------------------------------------------------------------
 781
 782 (define_insn "addqi3"
 783   [(set (match_operand:QI 0 "register_operand" "=r")
 784         (plus:QI (match_operand:QI 1 "register_operand" "%0")
 785                  (match_operand:QI 2 "nonmemory_operand" "rn")))]
 786   ""
 787   "add.b        %X2,%X0"
 788   [(set_attr "length" "2")
 789    (set_attr "cc" "set_zn")])
 790
 791 (define_expand "addhi3"
 792   [(set (match_operand:HI 0 "register_operand" "")
 793         (plus:HI (match_operand:HI 1 "register_operand" "")
 794                  (match_operand:HI 2 "nonmemory_operand" "")))]
 795   ""
 796   "")
 797
 798 (define_insn "*addhi3_h8300"
 799   [(set (match_operand:HI 0 "register_operand" "=r,r,r,r,r")
 800         (plus:HI (match_operand:HI 1 "register_operand" "%0,0,0,0,0")
 801                  (match_operand:HI 2 "nonmemory_operand" "L,N,J,n,r")))]
 802   "TARGET_H8300"
 803   "@
 804    adds %2,%T0
 805    subs %G2,%T0
 806    add.b        %t2,%t0
 807    add.b        %s2,%s0\;addx   %t2,%t0
 808    add.w        %T2,%T0"
 809   [(set_attr "length" "2,2,2,4,2")
 810    (set_attr "cc" "none_0hit,none_0hit,clobber,clobber,set_zn")])
 811
 812 ;; This splitter is very important to make the stack adjustment
 813 ;; interrupt-safe.  The combination of add.b and addx is unsafe!
 814 ;;
 815 ;; We apply this split after the peephole2 pass so that we won't end
 816 ;; up creating too many adds/subs when a scratch register is
 817 ;; available, which is actually a common case because stack unrolling
 818 ;; tends to happen immediately after a function call.
 819
 820 (define_split
 821   [(set (match_operand:HI 0 "stack_pointer_operand" "")
 822         (plus:HI (match_dup 0)
 823                  (match_operand 1 "const_int_gt_2_operand" "")))]
 824   "TARGET_H8300 && flow2_completed"
 825   [(const_int 0)]
 826   "split_adds_subs (HImode, operands); DONE;")
 827
 828 (define_peephole2
 829   [(match_scratch:HI 2 "r")
 830    (set (match_operand:HI 0 "stack_pointer_operand" "")
 831         (plus:HI (match_dup 0)
 832                  (match_operand:HI 1 "const_int_ge_8_operand" "")))]
 833   "TARGET_H8300"
 834   [(set (match_dup 2)
 835         (match_dup 1))
 836    (set (match_dup 0)
 837         (plus:HI (match_dup 0)
 838                  (match_dup 2)))]
 839   "")
 840
 841 (define_insn "*addhi3_h8300hs"
 842   [(set (match_operand:HI 0 "register_operand" "=r,r,r,r,r")
 843         (plus:HI (match_operand:HI 1 "register_operand" "%0,0,0,0,0")
 844                  (match_operand:HI 2 "nonmemory_operand" "L,N,J,n,r")))]
 845   "TARGET_H8300H || TARGET_H8300S"
 846   "@
 847    adds %2,%S0
 848    subs %G2,%S0
 849    add.b        %t2,%t0
 850    add.w        %T2,%T0
 851    add.w        %T2,%T0"
 852   [(set_attr "length" "2,2,2,4,2")
 853    (set_attr "cc" "none_0hit,none_0hit,clobber,set_zn,set_zn")])
 854
 855 (define_insn "*addhi3_incdec"
 856   [(set (match_operand:HI 0 "register_operand" "=r,r")
 857         (unspec:HI [(match_operand:HI 1 "register_operand" "0,0")
 858                     (match_operand:HI 2 "incdec_operand" "M,O")]
 859                    UNSPEC_INCDEC))]
 860   "TARGET_H8300H || TARGET_H8300S"
 861   "@
 862    inc.w        %2,%T0
 863    dec.w        %G2,%T0"
 864   [(set_attr "length" "2,2")
 865    (set_attr "cc" "set_zn,set_zn")])
 866
 867 (define_split
 868   [(set (match_operand:HI 0 "register_operand" "")
 869         (plus:HI (match_dup 0)
 870                  (match_operand:HI 1 "two_insn_adds_subs_operand" "")))]
 871   ""
 872   [(const_int 0)]
 873   "split_adds_subs (HImode, operands); DONE;")
 874
 875 (define_expand "addsi3"
 876   [(set (match_operand:SI 0 "register_operand" "")
 877         (plus:SI (match_operand:SI 1 "register_operand" "")
 878                  (match_operand:SI 2 "nonmemory_operand" "")))]
 879   ""
 880   "")
 881
 882 (define_insn "addsi_h8300"
 883   [(set (match_operand:SI 0 "register_operand" "=r,r")
 884         (plus:SI (match_operand:SI 1 "register_operand" "%0,0")
 885                  (match_operand:SI 2 "nonmemory_operand" "n,r")))]
 886   "TARGET_H8300"
 887   "* return output_plussi (operands);"
 888   [(set (attr "length")
 889         (symbol_ref "compute_plussi_length (operands)"))
 890    (set (attr "cc")
 891         (symbol_ref "compute_plussi_cc (operands)"))])
 892
 893 (define_insn "addsi_h8300h"
 894   [(set (match_operand:SI 0 "register_operand" "=r,r")
 895         (plus:SI (match_operand:SI 1 "register_operand" "%0,0")
 896                  (match_operand:SI 2 "nonmemory_operand" "i,r")))]
 897   "TARGET_H8300H || TARGET_H8300S"
 898   "* return output_plussi (operands);"
 899   [(set (attr "length")
 900         (symbol_ref "compute_plussi_length (operands)"))
 901    (set (attr "cc")
 902         (symbol_ref "compute_plussi_cc (operands)"))])
 903
 904 (define_insn "*addsi3_incdec"
 905   [(set (match_operand:SI 0 "register_operand" "=r,r")
 906         (unspec:SI [(match_operand:SI 1 "register_operand" "0,0")
 907                     (match_operand:SI 2 "incdec_operand" "M,O")]
 908                    UNSPEC_INCDEC))]
 909   "TARGET_H8300H || TARGET_H8300S"
 910   "@
 911    inc.l        %2,%S0
 912    dec.l        %G2,%S0"
 913   [(set_attr "length" "2,2")
 914    (set_attr "cc" "set_zn,set_zn")])
 915
 916 (define_split
 917   [(set (match_operand:SI 0 "register_operand" "")
 918         (plus:SI (match_dup 0)
 919                  (match_operand:SI 1 "two_insn_adds_subs_operand" "")))]
 920   "TARGET_H8300H || TARGET_H8300S"
 921   [(const_int 0)]
 922   "split_adds_subs (SImode, operands); DONE;")
 923
 924 ;; ----------------------------------------------------------------------
 925 ;; SUBTRACT INSTRUCTIONS
 926 ;; ----------------------------------------------------------------------
 927
 928 (define_insn "subqi3"
 929   [(set (match_operand:QI 0 "register_operand" "=r")
 930         (minus:QI (match_operand:QI 1 "register_operand" "0")
 931                   (match_operand:QI 2 "register_operand" "r")))]
 932   ""
 933   "sub.b        %X2,%X0"
 934   [(set_attr "length" "2")
 935    (set_attr "cc" "set_zn")])
 936
 937 (define_expand "subhi3"
 938   [(set (match_operand:HI 0 "register_operand" "")
 939         (minus:HI (match_operand:HI 1 "general_operand" "")
 940                   (match_operand:HI 2 "nonmemory_operand" "")))]
 941   ""
 942   "")
 943
 944 (define_insn ""
 945   [(set (match_operand:HI 0 "register_operand" "=r,&r")
 946         (minus:HI (match_operand:HI 1 "general_operand" "0,0")
 947                   (match_operand:HI 2 "nonmemory_operand" "r,n")))]
 948   "TARGET_H8300"
 949   "@
 950    sub.w        %T2,%T0
 951    add.b        %E2,%s0\;addx   %F2,%t0"
 952   [(set_attr "length" "2,4")
 953    (set_attr "cc" "set_zn,clobber")])
 954
 955 (define_insn ""
 956   [(set (match_operand:HI 0 "register_operand" "=r,&r")
 957         (minus:HI (match_operand:HI 1 "general_operand" "0,0")
 958                   (match_operand:HI 2 "nonmemory_operand" "r,n")))]
 959   "TARGET_H8300H || TARGET_H8300S"
 960   "@
 961    sub.w        %T2,%T0
 962    sub.w        %T2,%T0"
 963   [(set_attr "length" "2,4")
 964    (set_attr "cc" "set_zn,set_zn")])
 965
 966 (define_expand "subsi3"
 967   [(set (match_operand:SI 0 "register_operand" "")
 968         (minus:SI (match_operand:SI 1 "register_operand" "")
 969                   (match_operand:SI 2 "nonmemory_operand" "")))]
 970   ""
 971   "")
 972
 973 (define_insn "subsi3_h8300"
 974   [(set (match_operand:SI 0 "register_operand" "=r")
 975         (minus:SI (match_operand:SI 1 "register_operand" "0")
 976                   (match_operand:SI 2 "register_operand" "r")))]
 977   "TARGET_H8300"
 978   "sub.w        %f2,%f0\;subx   %y2,%y0\;subx   %z2,%z0"
 979   [(set_attr "length" "6")
 980    (set_attr "cc" "clobber")])
 981
 982 (define_insn "subsi3_h8300h"
 983   [(set (match_operand:SI 0 "register_operand" "=r,r")
 984         (minus:SI (match_operand:SI 1 "general_operand" "0,0")
 985                   (match_operand:SI 2 "nonmemory_operand" "r,i")))]
 986   "TARGET_H8300H || TARGET_H8300S"
 987   "@
 988    sub.l        %S2,%S0
 989    sub.l        %S2,%S0"
 990   [(set_attr "length" "2,6")
 991    (set_attr "cc" "set_zn,set_zn")])
 992 \f
 993 ;; ----------------------------------------------------------------------
 994 ;; MULTIPLY INSTRUCTIONS
 995 ;; ----------------------------------------------------------------------
 996
 997 ;; Note that the H8/300 can only handle umulqihi3.
 998
 999 (define_insn "mulqihi3"
1000   [(set (match_operand:HI 0 "register_operand" "=r")
1001         (mult:HI (sign_extend:HI (match_operand:QI 1 "register_operand" "%0"))
1002                  (sign_extend:HI (match_operand:QI 2 "register_operand" "r"))))]
1003   "TARGET_H8300H || TARGET_H8300S"
1004   "mulxs.b      %X2,%T0"
1005   [(set_attr "length" "4")
1006    (set_attr "cc" "set_zn")])
1007
1008 (define_insn "mulhisi3"
1009   [(set (match_operand:SI 0 "register_operand" "=r")
1010         (mult:SI (sign_extend:SI (match_operand:HI 1 "register_operand" "%0"))
1011                  (sign_extend:SI (match_operand:HI 2 "register_operand" "r"))))]
1012   "TARGET_H8300H || TARGET_H8300S"
1013   "mulxs.w      %T2,%S0"
1014   [(set_attr "length" "4")
1015    (set_attr "cc" "set_zn")])
1016
1017 (define_insn "umulqihi3"
1018   [(set (match_operand:HI 0 "register_operand" "=r")
1019         (mult:HI (zero_extend:HI (match_operand:QI 1 "register_operand" "%0"))
1020                  (zero_extend:HI (match_operand:QI 2 "register_operand" "r"))))]
1021   ""
1022   "mulxu        %X2,%T0"
1023   [(set_attr "length" "2")
1024    (set_attr "cc" "none_0hit")])
1025
1026 (define_insn "umulhisi3"
1027   [(set (match_operand:SI 0 "register_operand" "=r")
1028         (mult:SI (zero_extend:SI (match_operand:HI 1 "register_operand" "%0"))
1029                  (zero_extend:SI (match_operand:HI 2 "register_operand" "r"))))]
1030   "TARGET_H8300H || TARGET_H8300S"
1031   "mulxu.w      %T2,%S0"
1032   [(set_attr "length" "2")
1033    (set_attr "cc" "none_0hit")])
1034
1035 ;; This is a "bridge" instruction.  Combine can't cram enough insns
1036 ;; together to crate a MAC instruction directly, but it can create
1037 ;; this instruction, which then allows combine to create the real
1038 ;; MAC insn.
1039 ;;
1040 ;; Unfortunately, if combine doesn't create a MAC instruction, this
1041 ;; insn must generate reasonably correct code.  Egad.
1042 (define_insn ""
1043   [(set (match_operand:SI 0 "register_operand" "=a")
1044         (mult:SI
1045           (sign_extend:SI
1046             (mem:HI (post_inc:SI (match_operand:SI 1 "register_operand" "r"))))
1047           (sign_extend:SI
1048             (mem:HI (post_inc:SI (match_operand:SI 2 "register_operand" "r"))))))]
1049   "TARGET_MAC"
1050   "clrmac\;mac  @%2+,@%1+"
1051   [(set_attr "length" "6")
1052    (set_attr "cc" "none_0hit")])
1053
1054 (define_insn ""
1055   [(set (match_operand:SI 0 "register_operand" "=a")
1056         (plus:SI (mult:SI
1057           (sign_extend:SI (mem:HI
1058             (post_inc:SI (match_operand:SI 1 "register_operand" "r"))))
1059           (sign_extend:SI (mem:HI
1060             (post_inc:SI (match_operand:SI 2 "register_operand" "r")))))
1061               (match_operand:SI 3 "register_operand" "0")))]
1062   "TARGET_MAC"
1063   "mac  @%2+,@%1+"
1064   [(set_attr "length" "4")
1065    (set_attr "cc" "none_0hit")])
1066
1067 ;; ----------------------------------------------------------------------
1068 ;; DIVIDE/MOD INSTRUCTIONS
1069 ;; ----------------------------------------------------------------------
1070
1071 (define_insn "udivmodqi4"
1072   [(set (match_operand:QI 0 "register_operand" "=r")
1073         (truncate:QI
1074           (udiv:HI
1075             (match_operand:HI 1 "register_operand" "0")
1076             (zero_extend:HI (match_operand:QI 2 "register_operand" "r")))))
1077    (set (match_operand:QI 3 "register_operand" "=r")
1078         (truncate:QI
1079           (umod:HI
1080             (match_dup 1)
1081             (zero_extend:HI (match_dup 2)))))]
1082   ""
1083   "*
1084 {
1085   if (find_reg_note (insn, REG_UNUSED, operands[3]))
1086     return \"divxu.b\\t%X2,%T0\";
1087   else
1088     return \"divxu.b\\t%X2,%T0\;mov.b\\t%t0,%s3\";
1089 }"
1090   [(set_attr "length" "4")
1091    (set_attr "cc" "clobber")])
1092
1093 (define_insn "divmodqi4"
1094   [(set (match_operand:QI 0 "register_operand" "=r")
1095         (truncate:QI
1096           (div:HI
1097             (match_operand:HI 1 "register_operand" "0")
1098             (sign_extend:HI (match_operand:QI 2 "register_operand" "r")))))
1099    (set (match_operand:QI 3 "register_operand" "=r")
1100         (truncate:QI
1101           (mod:HI
1102             (match_dup 1)
1103             (sign_extend:HI (match_dup 2)))))]
1104   "TARGET_H8300H || TARGET_H8300S"
1105   "*
1106 {
1107   if (find_reg_note (insn, REG_UNUSED, operands[3]))
1108     return \"divxs.b\\t%X2,%T0\";
1109   else
1110     return \"divxs.b\\t%X2,%T0\;mov.b\\t%t0,%s3\";
1111 }"
1112   [(set_attr "length" "6")
1113    (set_attr "cc" "clobber")])
1114
1115 (define_insn "udivmodhi4"
1116   [(set (match_operand:HI 0 "register_operand" "=r")
1117         (truncate:HI
1118           (udiv:SI
1119             (match_operand:SI 1 "register_operand" "0")
1120             (zero_extend:SI (match_operand:HI 2 "register_operand" "r")))))
1121    (set (match_operand:HI 3 "register_operand" "=r")
1122         (truncate:HI
1123           (umod:SI
1124             (match_dup 1)
1125             (zero_extend:SI (match_dup 2)))))]
1126   "TARGET_H8300H || TARGET_H8300S"
1127   "*
1128 {
1129   if (find_reg_note (insn, REG_UNUSED, operands[3]))
1130     return \"divxu.w\\t%T2,%S0\";
1131   else
1132     return \"divxu.w\\t%T2,%S0\;mov.w\\t%e0,%f3\";
1133 }"
1134   [(set_attr "length" "4")
1135    (set_attr "cc" "clobber")])
1136
1137 (define_insn "divmodhi4"
1138   [(set (match_operand:HI 0 "register_operand" "=r")
1139         (truncate:HI
1140           (div:SI
1141             (match_operand:SI 1 "register_operand" "0")
1142             (sign_extend:SI (match_operand:HI 2 "register_operand" "r")))))
1143    (set (match_operand:HI 3 "register_operand" "=r")
1144         (truncate:HI
1145           (mod:SI
1146             (match_dup 1)
1147             (sign_extend:SI (match_dup 2)))))]
1148   "TARGET_H8300H || TARGET_H8300S"
1149   "*
1150 {
1151   if (find_reg_note (insn, REG_UNUSED, operands[3]))
1152     return \"divxs.w\\t%T2,%S0\";
1153   else
1154     return \"divxs.w\\t%T2,%S0\;mov.w\\t%e0,%f3\";
1155 }"
1156   [(set_attr "length" "6")
1157    (set_attr "cc" "clobber")])
1158 \f
1159 ;; ----------------------------------------------------------------------
1160 ;; AND INSTRUCTIONS
1161 ;; ----------------------------------------------------------------------
1162
1163 (define_insn ""
1164   [(set (match_operand:QI 0 "bit_operand" "=r,U")
1165         (and:QI (match_operand:QI 1 "bit_operand" "%0,0")
1166                 (match_operand:QI 2 "nonmemory_operand" "rn,n")))]
1167   "register_operand (operands[0], QImode)
1168    || single_zero_operand (operands[2], QImode)"
1169   "@
1170    and  %X2,%X0
1171    bclr %W2,%R0"
1172   [(set_attr "length" "2,8")
1173    (set_attr "adjust_length" "no")
1174    (set_attr "cc" "set_znv,none_0hit")])
1175
1176 (define_expand "andqi3"
1177   [(set (match_operand:QI 0 "bit_operand" "")
1178         (and:QI (match_operand:QI 1 "bit_operand" "")
1179                 (match_operand:QI 2 "nonmemory_operand" "")))]
1180   ""
1181   "
1182 {
1183   if (fix_bit_operand (operands, 0, AND))
1184     DONE;
1185 }")
1186
1187 (define_expand "andhi3"
1188   [(set (match_operand:HI 0 "register_operand" "")
1189         (and:HI (match_operand:HI 1 "register_operand" "")
1190                 (match_operand:HI 2 "nonmemory_operand" "")))]
1191   ""
1192   "")
1193
1194 (define_insn "*andorqi3"
1195   [(set (match_operand:QI 0 "register_operand" "=r")
1196         (ior:QI (and:QI (match_operand:QI 2 "register_operand" "r")
1197                         (match_operand:QI 3 "single_one_operand" "n"))
1198                 (match_operand:QI 1 "register_operand" "0")))]
1199   ""
1200   "bld\\t%V3,%X2\;bor\\t%V3,%X0\;bst\\t%V3,%X0"
1201   [(set_attr "length" "6")
1202    (set_attr "cc" "clobber")])
1203
1204 (define_insn "*andorhi3"
1205   [(set (match_operand:HI 0 "register_operand" "=r")
1206         (ior:HI (and:HI (match_operand:HI 2 "register_operand" "r")
1207                         (match_operand:HI 3 "single_one_operand" "n"))
1208                 (match_operand:HI 1 "register_operand" "0")))]
1209   ""
1210   "*
1211 {
1212   operands[3] = GEN_INT (INTVAL (operands[3]) & 0xffff);
1213   if (INTVAL (operands[3]) > 128)
1214     {
1215       operands[3] = GEN_INT (INTVAL (operands[3]) >> 8);
1216       return \"bld\\t%V3,%t2\;bor\\t%V3,%t0\;bst\\t%V3,%t0\";
1217     }
1218   return \"bld\\t%V3,%s2\;bor\\t%V3,%s0\;bst\\t%V3,%s0\";
1219 }"
1220   [(set_attr "length" "6")
1221    (set_attr "cc" "clobber")])
1222
1223 (define_insn "*andorsi3"
1224   [(set (match_operand:SI 0 "register_operand" "=r")
1225         (ior:SI (and:SI (match_operand:SI 2 "register_operand" "r")
1226                         (match_operand:SI 3 "single_one_operand" "n"))
1227                 (match_operand:SI 1 "register_operand" "0")))]
1228   "(INTVAL (operands[3]) & 0xffff) != 0"
1229   "*
1230 {
1231   operands[3] = GEN_INT (INTVAL (operands[3]) & 0xffff);
1232   if (INTVAL (operands[3]) > 128)
1233     {
1234       operands[3] = GEN_INT (INTVAL (operands[3]) >> 8);
1235       return \"bld\\t%V3,%x2\;bor\\t%V3,%x0\;bst\\t%V3,%x0\";
1236     }
1237   return \"bld\\t%V3,%w2\;bor\\t%V3,%w0\;bst\\t%V3,%w0\";
1238 }"
1239   [(set_attr "length" "6")
1240    (set_attr "cc" "clobber")])
1241
1242 (define_insn "*andorsi3_shift_8"
1243   [(set (match_operand:SI 0 "register_operand" "=r")
1244         (ior:SI (and:SI (ashift:SI (match_operand:SI 2 "register_operand" "r")
1245                                    (const_int 8))
1246                         (const_int 65280))
1247                 (match_operand:SI 1 "register_operand" "0")))]
1248   ""
1249   "or.b\\t%w2,%x0"
1250   [(set_attr "length" "2")
1251    (set_attr "cc" "clobber")])
1252
1253 (define_expand "andsi3"
1254   [(set (match_operand:SI 0 "register_operand" "")
1255         (and:SI (match_operand:SI 1 "register_operand" "")
1256                 (match_operand:SI 2 "nonmemory_operand" "")))]
1257   ""
1258   "")
1259
1260 ;; ----------------------------------------------------------------------
1261 ;; OR INSTRUCTIONS
1262 ;; ----------------------------------------------------------------------
1263
1264 (define_insn ""
1265   [(set (match_operand:QI 0 "bit_operand" "=r,U")
1266         (ior:QI (match_operand:QI 1 "bit_operand" "%0,0")
1267                 (match_operand:QI 2 "nonmemory_operand" "rn,n")))]
1268   "register_operand (operands[0], QImode)
1269    || single_one_operand (operands[2], QImode)"
1270   "@
1271    or\\t%X2,%X0
1272    bset\\t%V2,%R0"
1273   [(set_attr "length" "2,8")
1274    (set_attr "adjust_length" "no")
1275    (set_attr "cc" "set_znv,none_0hit")])
1276
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" "")))]
1281   ""
1282   "
1283 {
1284   if (fix_bit_operand (operands, 1, IOR))
1285     DONE;
1286 }")
1287
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" "")))]
1292   ""
1293   "")
1294
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" "")))]
1299   ""
1300   "")
1301
1302 ;; ----------------------------------------------------------------------
1303 ;; XOR INSTRUCTIONS
1304 ;; ----------------------------------------------------------------------
1305
1306 (define_insn ""
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)"
1312   "@
1313    xor\\t%X2,%X0
1314    bnot\\t%V2,%R0"
1315   [(set_attr "length" "2,8")
1316    (set_attr "adjust_length" "no")
1317    (set_attr "cc" "set_znv,none_0hit")])
1318
1319 (define_expand "xorqi3"
1320   [(set (match_operand:QI 0 "bit_operand" "")
1321         (xor:QI (match_operand:QI 1 "bit_operand" "")
1322                 (match_operand:QI 2 "nonmemory_operand" "")))]
1323   ""
1324   "
1325 {
1326   if (fix_bit_operand (operands, 1, XOR))
1327     DONE;
1328 }")
1329
1330 (define_expand "xorhi3"
1331   [(set (match_operand:HI 0 "register_operand" "")
1332         (xor:HI (match_operand:HI 1 "register_operand" "")
1333                 (match_operand:HI 2 "nonmemory_operand" "")))]
1334   ""
1335   "")
1336
1337 (define_expand "xorsi3"
1338   [(set (match_operand:SI 0 "register_operand" "")
1339         (xor:SI (match_operand:SI 1 "register_operand" "")
1340                 (match_operand:SI 2 "nonmemory_operand" "")))]
1341   ""
1342   "")
1343
1344 ;; ----------------------------------------------------------------------
1345 ;; {AND,IOR,XOR}{HI3,SI3} PATTERNS
1346 ;; ----------------------------------------------------------------------
1347
1348 (define_insn ""
1349   [(set (match_operand:HI 0 "register_operand" "=r")
1350         (match_operator:HI 3 "bit_operator"
1351           [(match_operand:HI 1 "register_operand" "%0")
1352            (match_operand:HI 2 "nonmemory_operand" "rn")]))]
1353   ""
1354   "* return output_logical_op (HImode, operands);"
1355   [(set (attr "length")
1356         (symbol_ref "compute_logical_op_length (HImode, operands)"))
1357    (set (attr "cc")
1358         (symbol_ref "compute_logical_op_cc (HImode, operands)"))])
1359
1360 (define_insn ""
1361   [(set (match_operand:SI 0 "register_operand" "=r")
1362         (match_operator:SI 3 "bit_operator"
1363           [(match_operand:SI 1 "register_operand" "%0")
1364            (match_operand:SI 2 "nonmemory_operand" "rn")]))]
1365   ""
1366   "* return output_logical_op (SImode, operands);"
1367   [(set (attr "length")
1368         (symbol_ref "compute_logical_op_length (SImode, operands)"))
1369    (set (attr "cc")
1370         (symbol_ref "compute_logical_op_cc (SImode, operands)"))])
1371 \f
1372 ;; ----------------------------------------------------------------------
1373 ;; NEGATION INSTRUCTIONS
1374 ;; ----------------------------------------------------------------------
1375
1376 (define_insn "negqi2"
1377   [(set (match_operand:QI 0 "register_operand" "=r")
1378         (neg:QI (match_operand:QI 1 "register_operand" "0")))]
1379   ""
1380   "neg  %X0"
1381   [(set_attr "length" "2")
1382    (set_attr "cc" "set_zn")])
1383
1384 (define_expand "neghi2"
1385   [(set (match_operand:HI 0 "register_operand" "")
1386         (neg:HI (match_operand:HI 1 "register_operand" "")))]
1387   ""
1388   "
1389 {
1390   if (TARGET_H8300)
1391     {
1392       emit_insn (gen_neghi2_h8300 (operands[0], operands[1]));
1393       DONE;
1394     }
1395 }")
1396
1397 (define_expand "neghi2_h8300"
1398   [(set (match_dup 2)
1399         (not:HI (match_operand:HI 1 "register_operand" "")))
1400    (set (match_dup 2) (plus:HI (match_dup 2) (const_int 1)))
1401    (set (match_operand:HI 0 "register_operand" "")
1402         (match_dup 2))]
1403   ""
1404   "operands[2] = gen_reg_rtx (HImode);")
1405
1406 (define_insn "neghi2_h8300h"
1407   [(set (match_operand:HI 0 "register_operand" "=r")
1408         (neg:HI (match_operand:HI 1 "register_operand" "0")))]
1409   "TARGET_H8300H || TARGET_H8300S"
1410   "neg  %T0"
1411   [(set_attr "length" "2")
1412    (set_attr "cc" "set_zn")])
1413
1414 (define_expand "negsi2"
1415   [(set (match_operand:SI 0 "register_operand" "")
1416         (neg:SI (match_operand:SI 1 "register_operand" "")))]
1417   ""
1418   "
1419 {
1420   if (TARGET_H8300)
1421     {
1422       emit_insn (gen_negsi2_h8300 (operands[0], operands[1]));
1423       DONE;
1424     }
1425 }")
1426
1427 (define_expand "negsi2_h8300"
1428   [(set (match_dup 2)
1429         (not:SI (match_operand:SI 1 "register_operand" "")))
1430    (set (match_dup 2) (plus:SI (match_dup 2) (const_int 1)))
1431    (set (match_operand:SI 0 "register_operand" "")
1432         (match_dup 2))]
1433   ""
1434   "operands[2] = gen_reg_rtx (SImode);")
1435
1436 (define_insn "negsi2_h8300h"
1437   [(set (match_operand:SI 0 "register_operand" "=r")
1438         (neg:SI (match_operand:SI 1 "register_operand" "0")))]
1439   "TARGET_H8300H || TARGET_H8300S"
1440   "neg  %S0"
1441   [(set_attr "length" "2")
1442    (set_attr "cc" "set_zn")])
1443
1444 (define_expand "negsf2"
1445   [(set (match_operand:SF 0 "register_operand" "")
1446         (neg:SF (match_operand:SF 1 "register_operand" "")))]
1447   ""
1448   "")
1449
1450 (define_insn "*negsf2_h8300"
1451   [(set (match_operand:SF 0 "register_operand" "=r")
1452         (neg:SF (match_operand:SF 1 "register_operand" "0")))]
1453   "TARGET_H8300"
1454   "xor.b\\t#128,%z0"
1455   [(set_attr "cc" "clobber")
1456    (set_attr "length" "2")])
1457
1458 (define_insn "*negsf2_h8300hs"
1459   [(set (match_operand:SF 0 "register_operand" "=r")
1460         (neg:SF (match_operand:SF 1 "register_operand" "0")))]
1461   "TARGET_H8300H || TARGET_H8300S"
1462   "xor.w\\t#32768,%e0"
1463   [(set_attr "cc" "clobber")
1464    (set_attr "length" "4")])
1465 \f
1466 ;; ----------------------------------------------------------------------
1467 ;; ABSOLUTE VALUE INSTRUCTIONS
1468 ;; ----------------------------------------------------------------------
1469
1470 (define_expand "abssf2"
1471   [(set (match_operand:SF 0 "register_operand" "")
1472         (abs:SF (match_operand:SF 1 "register_operand" "")))]
1473   ""
1474   "")
1475
1476 (define_insn "*abssf2_h8300"
1477   [(set (match_operand:SF 0 "register_operand" "=r")
1478         (abs:SF (match_operand:SF 1 "register_operand" "0")))]
1479   "TARGET_H8300"
1480   "and.b\\t#127,%z0"
1481   [(set_attr "cc" "clobber")
1482    (set_attr "length" "2")])
1483
1484 (define_insn "*abssf2_h8300hs"
1485   [(set (match_operand:SF 0 "register_operand" "=r")
1486         (abs:SF (match_operand:SF 1 "register_operand" "0")))]
1487   "TARGET_H8300H || TARGET_H8300S"
1488   "and.w\\t#32767,%e0"
1489   [(set_attr "cc" "clobber")
1490    (set_attr "length" "4")])
1491 \f
1492 ;; ----------------------------------------------------------------------
1493 ;; NOT INSTRUCTIONS
1494 ;; ----------------------------------------------------------------------
1495
1496 (define_insn "one_cmplqi2"
1497   [(set (match_operand:QI 0 "register_operand" "=r")
1498         (not:QI (match_operand:QI 1 "register_operand" "0")))]
1499   ""
1500   "not  %X0"
1501   [(set_attr "length" "2")
1502    (set_attr "cc" "set_znv")])
1503
1504 (define_expand "one_cmplhi2"
1505   [(set (match_operand:HI 0 "register_operand" "=r")
1506         (not:HI (match_operand:HI 1 "register_operand" "0")))]
1507   ""
1508   "")
1509
1510 (define_insn ""
1511   [(set (match_operand:HI 0 "register_operand" "=r")
1512         (not:HI (match_operand:HI 1 "register_operand" "0")))]
1513   "TARGET_H8300"
1514   "not  %s0\;not        %t0"
1515   [(set_attr "cc" "clobber")
1516    (set_attr "length" "4")])
1517
1518 (define_insn ""
1519   [(set (match_operand:HI 0 "register_operand" "=r")
1520         (not:HI (match_operand:HI 1 "register_operand" "0")))]
1521   "TARGET_H8300H || TARGET_H8300S"
1522   "not  %T0"
1523   [(set_attr "cc" "set_znv")
1524    (set_attr "length" "2")])
1525
1526 (define_expand "one_cmplsi2"
1527   [(set (match_operand:SI 0 "register_operand" "=r")
1528         (not:SI (match_operand:SI 1 "register_operand" "0")))]
1529   ""
1530   "")
1531
1532 (define_insn ""
1533   [(set (match_operand:SI 0 "register_operand" "=r")
1534         (not:SI (match_operand:SI 1 "register_operand" "0")))]
1535   "TARGET_H8300"
1536   "not  %w0\;not        %x0\;not        %y0\;not        %z0"
1537   [(set_attr "cc" "clobber")
1538    (set_attr "length" "8")])
1539
1540 (define_insn ""
1541   [(set (match_operand:SI 0 "register_operand" "=r")
1542         (not:SI (match_operand:SI 1 "register_operand" "0")))]
1543   "TARGET_H8300H || TARGET_H8300S"
1544   "not  %S0"
1545   [(set_attr "cc" "set_znv")
1546    (set_attr "length" "2")])
1547 \f
1548 ;; ----------------------------------------------------------------------
1549 ;; JUMP INSTRUCTIONS
1550 ;; ----------------------------------------------------------------------
1551
1552 ;; Conditional jump instructions
1553
1554 (define_expand "ble"
1555   [(set (pc)
1556         (if_then_else (le (cc0)
1557                           (const_int 0))
1558                       (label_ref (match_operand 0 "" ""))
1559                       (pc)))]
1560   ""
1561   "")
1562
1563 (define_expand "bleu"
1564   [(set (pc)
1565         (if_then_else (leu (cc0)
1566                            (const_int 0))
1567                       (label_ref (match_operand 0 "" ""))
1568                       (pc)))]
1569   ""
1570   "")
1571
1572 (define_expand "bge"
1573   [(set (pc)
1574         (if_then_else (ge (cc0)
1575                           (const_int 0))
1576                       (label_ref (match_operand 0 "" ""))
1577                       (pc)))]
1578   ""
1579   "")
1580
1581 (define_expand "bgeu"
1582   [(set (pc)
1583         (if_then_else (geu (cc0)
1584                            (const_int 0))
1585                       (label_ref (match_operand 0 "" ""))
1586                       (pc)))]
1587   ""
1588   "")
1589
1590 (define_expand "blt"
1591   [(set (pc)
1592         (if_then_else (lt (cc0)
1593                           (const_int 0))
1594                       (label_ref (match_operand 0 "" ""))
1595                       (pc)))]
1596   ""
1597   "")
1598
1599 (define_expand "bltu"
1600   [(set (pc)
1601         (if_then_else (ltu (cc0)
1602                            (const_int 0))
1603                       (label_ref (match_operand 0 "" ""))
1604                       (pc)))]
1605   ""
1606   "")
1607
1608 (define_expand "bgt"
1609   [(set (pc)
1610         (if_then_else (gt (cc0)
1611                           (const_int 0))
1612                       (label_ref (match_operand 0 "" ""))
1613                       (pc)))]
1614   ""
1615   "")
1616
1617 (define_expand "bgtu"
1618   [(set (pc)
1619         (if_then_else (gtu (cc0)
1620                            (const_int 0))
1621                       (label_ref (match_operand 0 "" ""))
1622                       (pc)))]
1623   ""
1624   "")
1625
1626 (define_expand "beq"
1627   [(set (pc)
1628         (if_then_else (eq (cc0)
1629                           (const_int 0))
1630                       (label_ref (match_operand 0 "" ""))
1631                       (pc)))]
1632   ""
1633   "")
1634
1635 (define_expand "bne"
1636   [(set (pc)
1637         (if_then_else (ne (cc0)
1638                           (const_int 0))
1639                       (label_ref (match_operand 0 "" ""))
1640                       (pc)))]
1641   ""
1642   "")
1643
1644 (define_insn "branch_true"
1645   [(set (pc)
1646         (if_then_else (match_operator 1 "comparison_operator"
1647                                       [(cc0) (const_int 0)])
1648                       (label_ref (match_operand 0 "" ""))
1649                       (pc)))]
1650   ""
1651   "*
1652 {
1653   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0
1654       && (GET_CODE (operands[1]) == GT
1655           || GET_CODE (operands[1]) == GE
1656           || GET_CODE (operands[1]) == LE
1657           || GET_CODE (operands[1]) == LT))
1658     {
1659       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
1660       return 0;
1661     }
1662
1663   if (get_attr_length (insn) == 2)
1664     return \"b%j1       %l0\";
1665   else if (get_attr_length (insn) == 4)
1666     return \"b%j1       %l0:16\";
1667   else
1668     return \"b%k1       .Lh8BR%=\;jmp   @%l0\\n.Lh8BR%=:\";
1669 }"
1670  [(set_attr "type" "branch")
1671    (set_attr "cc" "none")])
1672
1673 (define_insn "branch_false"
1674   [(set (pc)
1675         (if_then_else (match_operator 1 "comparison_operator"
1676                                       [(cc0) (const_int 0)])
1677                       (pc)
1678                       (label_ref (match_operand 0 "" ""))))]
1679   ""
1680   "*
1681 {
1682   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0
1683       && (GET_CODE (operands[1]) == GT
1684           || GET_CODE (operands[1]) == GE
1685           || GET_CODE (operands[1]) == LE
1686           || GET_CODE (operands[1]) == LT))
1687     {
1688       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
1689       return 0;
1690     }
1691
1692   if (get_attr_length (insn) == 2)
1693     return \"b%k1       %l0\";
1694   else if (get_attr_length (insn) == 4)
1695     return \"b%k1       %l0:16\";
1696   else
1697     return \"b%j1       .Lh8BR%=\;jmp   @%l0\\n.Lh8BR%=:\";
1698 }"
1699   [(set_attr "type" "branch")
1700    (set_attr "cc" "none")])
1701
1702 ;; Unconditional and other jump instructions.
1703
1704 (define_insn "jump"
1705   [(set (pc)
1706         (label_ref (match_operand 0 "" "")))]
1707   ""
1708   "*
1709 {
1710   if (get_attr_length (insn) == 2)
1711     return \"bra        %l0\";
1712   else if (get_attr_length (insn) == 4)
1713     return \"bra        %l0:16\";
1714   else
1715     return \"jmp        @%l0\";
1716 }"
1717   [(set_attr "type" "branch")
1718    (set_attr "cc" "none")])
1719
1720 ;; This is a define expand, because pointers may be either 16 or 32 bits.
1721
1722 (define_expand "tablejump"
1723   [(parallel [(set (pc) (match_operand 0 "register_operand" ""))
1724               (use (label_ref (match_operand 1 "" "")))])]
1725   ""
1726   "")
1727
1728 (define_insn "tablejump_h8300"
1729   [(set (pc) (match_operand:HI 0 "register_operand" "r"))
1730    (use (label_ref (match_operand 1 "" "")))]
1731   "TARGET_H8300"
1732   "jmp  @%0"
1733   [(set_attr "cc" "none")
1734    (set_attr "length" "2")])
1735
1736 (define_insn "tablejump_h8300h"
1737   [(set (pc) (match_operand:SI 0 "register_operand" "r"))
1738    (use (label_ref (match_operand 1 "" "")))]
1739   "TARGET_H8300H || TARGET_H8300S"
1740   "jmp  @%0"
1741   [(set_attr "cc" "none")
1742    (set_attr "length" "2")])
1743
1744 (define_insn "tablejump_normal_mode"
1745    [(set (pc) (match_operand:HI 0 "register_operand" "r"))
1746     (use (label_ref (match_operand 1 "" "")))]
1747    "(TARGET_H8300H || TARGET_H8300S) && TARGET_NORMAL_MODE"
1748    "jmp @%S0"
1749    [(set_attr "cc" "none")
1750     (set_attr "length" "2")])
1751
1752 ;; This is a define expand, because pointers may be either 16 or 32 bits.
1753
1754 (define_expand "indirect_jump"
1755   [(set (pc) (match_operand 0 "jump_address_operand" ""))]
1756   ""
1757   "")
1758
1759 (define_insn "indirect_jump_h8300"
1760   [(set (pc) (match_operand:HI 0 "jump_address_operand" "Vr"))]
1761   "TARGET_H8300"
1762   "jmp  @%0"
1763   [(set_attr "cc" "none")
1764    (set_attr "length" "2")])
1765
1766 (define_insn "indirect_jump_h8300h"
1767   [(set (pc) (match_operand:SI 0 "jump_address_operand" "Vr"))]
1768   "TARGET_H8300H || TARGET_H8300S"
1769   "jmp @%0"
1770   [(set_attr "cc" "none")
1771    (set_attr "length" "2")])
1772
1773 (define_insn "indirect_jump_normal_mode"
1774   [(set (pc) (match_operand:HI 0 "jump_address_operand" "Vr"))]
1775   "(TARGET_H8300H || TARGET_H8300S) && TARGET_NORMAL_MODE"
1776   "jmp @%S0"
1777   [(set_attr "cc" "none")
1778    (set_attr "length" "2")])
1779
1780 ;; Call subroutine with no return value.
1781
1782 ;; ??? Even though we use HImode here, this works on the H8/300H and H8S.
1783
1784 (define_insn "call"
1785   [(call (match_operand:QI 0 "call_insn_operand" "or")
1786          (match_operand:HI 1 "general_operand" "g"))]
1787   ""
1788   "*
1789 {
1790   if (GET_CODE (XEXP (operands[0], 0)) == SYMBOL_REF
1791       && SYMBOL_REF_FLAG (XEXP (operands[0], 0)))
1792     return \"jsr\\t@%0:8\";
1793   else
1794     return \"jsr\\t%0\";
1795 }"
1796   [(set_attr "cc" "clobber")
1797    (set (attr "length")
1798         (if_then_else (match_operand:QI 0 "small_call_insn_operand" "")
1799                       (const_int 4)
1800                       (const_int 8)))])
1801
1802 ;; Call subroutine, returning value in operand 0
1803 ;; (which must be a hard register).
1804
1805 ;; ??? Even though we use HImode here, this works on the H8/300H and H8S.
1806
1807 (define_insn "call_value"
1808   [(set (match_operand 0 "" "=r")
1809         (call (match_operand:QI 1 "call_insn_operand" "or")
1810               (match_operand:HI 2 "general_operand" "g")))]
1811   ""
1812   "*
1813 {
1814   if (GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF
1815       && SYMBOL_REF_FLAG (XEXP (operands[1], 0)))
1816     return \"jsr\\t@%1:8\";
1817   else
1818     return \"jsr\\t%1\";
1819 }"
1820   [(set_attr "cc" "clobber")
1821    (set (attr "length")
1822         (if_then_else (match_operand:QI 0 "small_call_insn_operand" "")
1823                       (const_int 4)
1824                       (const_int 8)))])
1825
1826 (define_insn "nop"
1827   [(const_int 0)]
1828   ""
1829   "nop"
1830   [(set_attr "cc" "none")
1831    (set_attr "length" "2")])
1832 \f
1833 ;; ----------------------------------------------------------------------
1834 ;; PROLOGUE/EPILOGUE-RELATED INSTRUCTIONS
1835 ;; ----------------------------------------------------------------------
1836
1837 (define_expand "push_h8300"
1838   [(set (mem:HI (pre_dec:HI (reg:HI SP_REG)))
1839         (match_operand:HI 0 "register_operand" "=r"))]
1840
1841   "TARGET_H8300"
1842   "")
1843
1844 (define_expand "push_h8300hs"
1845   [(set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
1846         (match_operand:SI 0 "register_operand" "=r"))]
1847   "TARGET_H8300H && TARGET_H8300S"
1848   "")
1849
1850 (define_expand "pop_h8300"
1851   [(set (match_operand:HI 0 "register_operand" "=r")
1852         (mem:HI (post_inc:HI (reg:HI SP_REG))))]
1853   "TARGET_H8300"
1854   "")
1855
1856 (define_expand "pop_h8300hs"
1857   [(set (match_operand:SI 0 "register_operand" "=r")
1858         (mem:SI (post_inc:SI (reg:SI SP_REG))))]
1859   "TARGET_H8300H && TARGET_H8300S"
1860   "")
1861
1862 (define_insn "stm_h8300s_2"
1863   [(parallel
1864      [(set (reg:SI SP_REG)
1865            (plus:SI (reg:SI SP_REG) (const_int -8)))
1866       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -4)))
1867            (match_operand:SI 0 "register_operand" ""))
1868       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -8)))
1869            (match_operand:SI 1 "register_operand" ""))])]
1870   "TARGET_H8300S
1871    && ((REGNO (operands[0]) == 0 && REGNO (operands[1]) == 1)
1872        || (REGNO (operands[0]) == 2 && REGNO (operands[1]) == 3)
1873        || (REGNO (operands[0]) == 4 && REGNO (operands[1]) == 5))"
1874   "stm.l\\t%S0-%S1,@-er7"
1875   [(set_attr "cc" "none")
1876    (set_attr "length" "4")])
1877
1878 (define_insn "stm_h8300s_3"
1879   [(parallel
1880      [(set (reg:SI SP_REG)
1881            (plus:SI (reg:SI SP_REG) (const_int -12)))
1882       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -4)))
1883            (match_operand:SI 0 "register_operand" ""))
1884       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -8)))
1885            (match_operand:SI 1 "register_operand" ""))
1886       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -12)))
1887            (match_operand:SI 2 "register_operand" ""))])]
1888   "TARGET_H8300S
1889    && ((REGNO (operands[0]) == 0
1890         && REGNO (operands[1]) == 1
1891         && REGNO (operands[2]) == 2)
1892        || (REGNO (operands[0]) == 4
1893            && REGNO (operands[1]) == 5
1894            && REGNO (operands[2]) == 6))"
1895   "stm.l\\t%S0-%S2,@-er7"
1896   [(set_attr "cc" "none")
1897    (set_attr "length" "4")])
1898
1899 (define_insn "stm_h8300s_4"
1900   [(parallel
1901      [(set (reg:SI SP_REG)
1902            (plus:SI (reg:SI SP_REG) (const_int -16)))
1903       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -4)))
1904            (match_operand:SI 0 "register_operand" ""))
1905       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -8)))
1906            (match_operand:SI 1 "register_operand" ""))
1907       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -12)))
1908            (match_operand:SI 2 "register_operand" ""))
1909       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -16)))
1910            (match_operand:SI 3 "register_operand" ""))])]
1911   "TARGET_H8300S
1912    && REGNO (operands[0]) == 0
1913    && REGNO (operands[1]) == 1
1914    && REGNO (operands[2]) == 2
1915    && REGNO (operands[3]) == 3"
1916   "stm.l\\t%S0-%S3,@-er7"
1917   [(set_attr "cc" "none")
1918    (set_attr "length" "4")])
1919
1920 (define_insn "ldm_h8300s_2"
1921   [(parallel
1922      [(set (reg:SI SP_REG)
1923            (plus:SI (reg:SI SP_REG) (const_int 8)))
1924       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int 4)))
1925            (match_operand:SI 0 "register_operand" ""))
1926       (set (mem:SI (reg:SI SP_REG))
1927            (match_operand:SI 1 "register_operand" ""))])]
1928   "TARGET_H8300S
1929    && ((REGNO (operands[0]) == 0 && REGNO (operands[1]) == 1)
1930        || (REGNO (operands[0]) == 2 && REGNO (operands[1]) == 3)
1931        || (REGNO (operands[0]) == 4 && REGNO (operands[1]) == 5))"
1932   "ldm.l\\t@er7+,%S0-%S1"
1933   [(set_attr "cc" "none")
1934    (set_attr "length" "4")])
1935
1936 (define_insn "ldm_h8300s_3"
1937   [(parallel
1938      [(set (reg:SI SP_REG)
1939            (plus:SI (reg:SI SP_REG) (const_int 12)))
1940       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int 8)))
1941            (match_operand:SI 0 "register_operand" ""))
1942       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int 4)))
1943            (match_operand:SI 1 "register_operand" ""))
1944       (set (mem:SI (reg:SI SP_REG))
1945            (match_operand:SI 2 "register_operand" ""))])]
1946   "TARGET_H8300S
1947    && ((REGNO (operands[0]) == 0
1948         && REGNO (operands[1]) == 1
1949         && REGNO (operands[2]) == 2)
1950        || (REGNO (operands[0]) == 4
1951            && REGNO (operands[1]) == 5
1952            && REGNO (operands[2]) == 6))"
1953   "ldm.l\\t@er7+,%S0-%S2"
1954   [(set_attr "cc" "none")
1955    (set_attr "length" "4")])
1956
1957 (define_insn "ldm_h8300s_4"
1958   [(parallel
1959      [(set (reg:SI SP_REG)
1960            (plus:SI (reg:SI SP_REG) (const_int 16)))
1961       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int 12)))
1962            (match_operand:SI 0 "register_operand" ""))
1963       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int 8)))
1964            (match_operand:SI 1 "register_operand" ""))
1965       (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int 4)))
1966            (match_operand:SI 2 "register_operand" ""))
1967       (set (mem:SI (reg:SI SP_REG))
1968            (match_operand:SI 3 "register_operand" ""))])]
1969   "TARGET_H8300S
1970    && REGNO (operands[0]) == 0
1971    && REGNO (operands[1]) == 1
1972    && REGNO (operands[2]) == 2
1973    && REGNO (operands[3]) == 3"
1974   "ldm.l\\t@er7+,%S0-%S3"
1975   [(set_attr "cc" "none")
1976    (set_attr "length" "4")])
1977
1978 (define_expand "return"
1979   [(return)]
1980   "h8300_can_use_return_insn_p ()"
1981   "")
1982
1983 (define_insn "*return_1"
1984   [(return)]
1985   "reload_completed"
1986   "*
1987 {
1988   if (h8300_current_function_interrupt_function_p ())
1989     return \"rte\";
1990   else
1991     return \"rts\";
1992 }"
1993   [(set_attr "cc" "none")
1994    (set_attr "length" "2")])
1995
1996 (define_expand "prologue"
1997   [(const_int 0)]
1998   ""
1999   "h8300_expand_prologue (); DONE;")
2000
2001 (define_expand "epilogue"
2002   [(return)]
2003   ""
2004   "h8300_expand_epilogue ();")
2005
2006 (define_insn "monitor_prologue"
2007   [(unspec_volatile [(const_int 0)] UNSPEC_MONITOR)]
2008   ""
2009   "*
2010 {
2011   if (TARGET_H8300)
2012     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\";
2013   else if (TARGET_H8300H)
2014     return \"mov.l\\ter0,@-er7\;stc\\tccr,r0l\;mov.b\\tr0l,@(4,er7)\;mov.l\\t@er7+,er0\;orc\\t#128,ccr\";
2015   else if (TARGET_H8300S)
2016     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\";
2017     abort ();
2018 }"
2019   [(set_attr "length" "20")
2020    (set_attr "cc" "clobber")])
2021 \f
2022 ;; ----------------------------------------------------------------------
2023 ;; EXTEND INSTRUCTIONS
2024 ;; ----------------------------------------------------------------------
2025
2026 (define_expand "zero_extendqihi2"
2027   [(set (match_operand:HI 0 "register_operand" "")
2028         (zero_extend:HI (match_operand:QI 1 "general_operand_src" "")))]
2029   ""
2030   "")
2031
2032 (define_insn "*zero_extendqihi2_h8300"
2033   [(set (match_operand:HI 0 "register_operand" "=r,r")
2034         (zero_extend:HI (match_operand:QI 1 "general_operand_src" "0,g>")))]
2035   "TARGET_H8300"
2036   "@
2037   mov.b #0,%t0
2038   #"
2039   [(set_attr "length" "2,10")
2040    (set_attr "cc" "clobber,clobber")])
2041
2042 (define_insn "*zero_extendqihi2_h8300hs"
2043   [(set (match_operand:HI 0 "register_operand" "=r,r")
2044         (zero_extend:HI (match_operand:QI 1 "general_operand_src" "0,g>")))]
2045   "TARGET_H8300H || TARGET_H8300S"
2046   "@
2047   extu.w        %T0
2048   #"
2049   [(set_attr "length" "2,10")
2050    (set_attr "cc" "set_znv,set_znv")])
2051
2052 ;; Split the zero extension of a general operand (actually a memory
2053 ;; operand) into a load of the operand and the actual zero extension
2054 ;; so that 1) the length will be accurate, and 2) the zero extensions
2055 ;; appearing at the end of basic blocks may be merged.
2056
2057 (define_split
2058   [(set (match_operand:HI 0 "register_operand" "")
2059         (zero_extend:HI (match_operand:QI 1 "general_operand_src" "")))]
2060   "reload_completed"
2061   [(set (match_dup 2)
2062         (match_dup 1))
2063    (set (match_dup 0)
2064         (zero_extend:HI (match_dup 2)))]
2065   "operands[2] = gen_rtx_REG (QImode, REGNO (operands[0]));")
2066
2067 (define_expand "zero_extendqisi2"
2068   [(set (match_operand:SI 0 "register_operand" "")
2069         (zero_extend:SI (match_operand:QI 1 "general_operand_src" "")))]
2070   ""
2071   "")
2072
2073 (define_insn "*zero_extendqisi2_h8300"
2074   [(set (match_operand:SI 0 "register_operand" "=r,r")
2075         (zero_extend:SI (match_operand:QI 1 "general_operand_src" "0,g>")))]
2076   "TARGET_H8300"
2077   "@
2078   mov.b #0,%x0\;sub.w   %e0,%e0
2079   mov.b %R1,%w0\;mov.b  #0,%x0\;sub.w   %e0,%e0"
2080   [(set_attr "length" "4,8")
2081    (set_attr "cc" "clobber,clobber")])
2082
2083 (define_insn "*zero_extendqisi2_h8300hs"
2084   [(set (match_operand:SI 0 "register_operand" "=r,r")
2085         (zero_extend:SI (match_operand:QI 1 "general_operand_src" "0,g>")))]
2086   "TARGET_H8300H || TARGET_H8300S"
2087   "@
2088   extu.w        %T0\;extu.l     %S0
2089   mov.b %R1,%w0\;extu.w %T0\;extu.l     %S0"
2090   [(set_attr "length" "4,12")
2091    (set_attr "cc" "set_znv,set_znv")])
2092
2093 (define_split
2094   [(set (match_operand:SI 0 "register_operand" "")
2095         (zero_extend:SI (match_operand:QI 1 "general_operand_src" "")))]
2096   "(TARGET_H8300H || TARGET_H8300S)
2097    && reg_overlap_mentioned_p (operands[0], operands[1])
2098    && reload_completed"
2099   [(set (match_dup 2)
2100         (match_dup 1))
2101    (set (match_dup 0)
2102         (zero_extend:SI (match_dup 2)))]
2103   "operands[2] = gen_rtx_REG (QImode, REGNO (operands[0]));")
2104
2105 (define_split
2106   [(set (match_operand:SI 0 "register_operand" "")
2107         (zero_extend:SI (match_operand:QI 1 "general_operand_src" "")))]
2108   "(TARGET_H8300H || TARGET_H8300S)
2109    && !reg_overlap_mentioned_p (operands[0], operands[1])
2110    && reload_completed"
2111   [(set (match_dup 0)
2112         (const_int 0))
2113    (set (strict_low_part (match_dup 2))
2114         (match_dup 1))]
2115   "operands[2] = gen_rtx_REG (QImode, REGNO (operands[0]));")
2116
2117 (define_expand "zero_extendhisi2"
2118   [(set (match_operand:SI 0 "register_operand" "")
2119         (zero_extend:SI (match_operand:HI 1 "register_operand" "")))]
2120   ""
2121   "")
2122
2123 ;; %e prints the high part of a CONST_INT, not the low part.  Arggh.
2124 (define_insn "*zero_extendhisi2_h8300"
2125   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
2126         (zero_extend:SI (match_operand:HI 1 "general_operand_src" "0,i,g>")))]
2127   "TARGET_H8300"
2128   "@
2129   sub.w %e0,%e0
2130   mov.w %f1,%f0\;sub.w  %e0,%e0
2131   mov.w %e1,%f0\;sub.w  %e0,%e0"
2132   [(set_attr "length" "2,4,6")
2133    (set_attr "cc" "clobber,clobber,clobber")])
2134
2135 (define_insn ""
2136   [(set (match_operand:SI 0 "register_operand" "=r")
2137         (zero_extend:SI (match_operand:HI 1 "register_operand" "0")))]
2138   "TARGET_H8300H || TARGET_H8300S"
2139   "extu.l       %S0"
2140   [(set_attr "length" "2")
2141    (set_attr "cc" "set_znv")])
2142
2143 (define_expand "extendqihi2"
2144   [(set (match_operand:HI 0 "register_operand" "")
2145         (sign_extend:HI (match_operand:QI 1 "register_operand" "")))]
2146   ""
2147   "")
2148
2149 (define_insn ""
2150   [(set (match_operand:HI 0 "register_operand" "=r,r")
2151         (sign_extend:HI (match_operand:QI 1 "general_operand_src" "0,g>")))]
2152   "TARGET_H8300"
2153   "@
2154   bld   #7,%s0\;subx    %t0,%t0
2155   mov.b %R1,%s0\;bld    #7,%s0\;subx    %t0,%t0"
2156   [(set_attr "length" "4,8")
2157    (set_attr "cc" "clobber,clobber")])
2158
2159 (define_insn ""
2160   [(set (match_operand:HI 0 "register_operand" "=r")
2161         (sign_extend:HI (match_operand:QI 1 "register_operand" "0")))]
2162   "TARGET_H8300H || TARGET_H8300S"
2163   "exts.w       %T0"
2164   [(set_attr "length" "2")
2165    (set_attr "cc" "set_znv")])
2166
2167 (define_expand "extendqisi2"
2168   [(set (match_operand:SI 0 "register_operand" "=r,r")
2169         (sign_extend:SI (match_operand:QI 1 "register_operand" "")))]
2170   ""
2171   "")
2172
2173 (define_insn "*extendqisi2_h8300"
2174   [(set (match_operand:SI 0 "register_operand" "")
2175         (sign_extend:SI (match_operand:QI 1 "general_operand_src" "0,g>")))]
2176   "TARGET_H8300"
2177   "@
2178   bld   #7,%w0\;subx    %x0,%x0\;subx   %y0,%y0\;subx   %z0,%z0
2179   mov.b %R1,%w0\;bld    #7,%w0\;subx    %x0,%x0\;subx   %y0,%y0\;subx   %z0,%z0"
2180   [(set_attr "length" "8,12")
2181    (set_attr "cc" "clobber,clobber")])
2182
2183 ;; The following pattern is needed because without the pattern, the
2184 ;; combiner would split (sign_extend:SI (reg:QI)) into into two 24-bit
2185 ;; shifts, one ashift and one ashiftrt.
2186
2187 (define_insn_and_split "*extendqisi2_h8300hs"
2188   [(set (match_operand:SI 0 "register_operand" "=r")
2189         (sign_extend:SI (match_operand:QI 1 "register_operand" "0")))]
2190   "(TARGET_H8300H || TARGET_H8300S)"
2191   "#"
2192   "&& reload_completed"
2193   [(set (match_dup 2)
2194         (sign_extend:HI (match_dup 1)))
2195    (set (match_dup 0)
2196         (sign_extend:SI (match_dup 2)))]
2197   "operands[2] = gen_rtx_REG (HImode, REGNO (operands[0]));")
2198
2199 (define_expand "extendhisi2"
2200   [(set (match_operand:SI 0 "register_operand" "")
2201         (sign_extend:SI (match_operand:HI 1 "register_operand" "")))]
2202   ""
2203   "")
2204
2205 (define_insn "*extendhisi2_h8300"
2206   [(set (match_operand:SI 0 "register_operand" "=r,r")
2207         (sign_extend:SI (match_operand:HI 1 "general_operand_src" "0,g>")))]
2208   "TARGET_H8300"
2209   "@
2210   bld   #7,%x0\;subx    %y0,%y0\;subx   %z0,%z0
2211   mov.w %T1,%f0\;bld    #7,%x0\;subx    %y0,%y0\;subx   %z0,%z0"
2212   [(set_attr "length" "6,10")
2213    (set_attr "cc" "clobber,clobber")])
2214
2215 (define_insn ""
2216   [(set (match_operand:SI 0 "register_operand" "=r")
2217         (sign_extend:SI (match_operand:HI 1 "register_operand" "0")))]
2218   "TARGET_H8300H || TARGET_H8300S"
2219   "exts.l       %S0"
2220   [(set_attr "length" "2")
2221    (set_attr "cc" "set_znv")])
2222 \f
2223 ;; ----------------------------------------------------------------------
2224 ;; SHIFTS
2225 ;; ----------------------------------------------------------------------
2226 ;;
2227 ;; We make some attempt to provide real efficient shifting.  One example is
2228 ;; doing an 8 bit shift of a 16 bit value by moving a byte reg into the other
2229 ;; reg and moving 0 into the former reg.
2230 ;;
2231 ;; We also try to achieve this in a uniform way.  IE: We don't try to achieve
2232 ;; this in both rtl and at insn emit time.  Ideally, we'd use rtl as that would
2233 ;; give the optimizer more cracks at the code.  However, we wish to do things
2234 ;; like optimizing shifting the sign bit to bit 0 by rotating the other way.
2235 ;; There is rtl to handle this (rotate + and), but the H8/300 doesn't handle
2236 ;; 16 bit rotates.  Also, if we emit complicated rtl, combine may not be able
2237 ;; to detect cases it can optimize.
2238 ;;
2239 ;; For these and other fuzzy reasons, I've decided to go the less pretty but
2240 ;; easier "do it at insn emit time" route.
2241
2242 ;; QI BIT SHIFTS
2243
2244 (define_expand "ashlqi3"
2245   [(set (match_operand:QI 0 "register_operand" "")
2246         (ashift:QI (match_operand:QI 1 "register_operand" "")
2247                    (match_operand:QI 2 "nonmemory_operand" "")))]
2248   ""
2249   "expand_a_shift (QImode, ASHIFT, operands); DONE;")
2250
2251 (define_expand "ashrqi3"
2252   [(set (match_operand:QI 0 "register_operand" "")
2253         (ashiftrt:QI (match_operand:QI 1 "register_operand" "")
2254                      (match_operand:QI 2 "nonmemory_operand" "")))]
2255   ""
2256   "expand_a_shift (QImode, ASHIFTRT, operands); DONE;")
2257
2258 (define_expand "lshrqi3"
2259   [(set (match_operand:QI 0 "register_operand" "")
2260         (lshiftrt:QI (match_operand:QI 1 "register_operand" "")
2261                      (match_operand:QI 2 "nonmemory_operand" "")))]
2262   ""
2263   "expand_a_shift (QImode, LSHIFTRT, operands); DONE;")
2264
2265 (define_insn ""
2266   [(set (match_operand:QI 0 "register_operand" "=r,r")
2267         (match_operator:QI 3 "nshift_operator"
2268                         [ (match_operand:QI 1 "register_operand" "0,0")
2269                           (match_operand:QI 2 "nonmemory_operand" "R,rn")]))
2270    (clobber (match_scratch:QI 4 "=X,&r"))]
2271   ""
2272   "* return output_a_shift (operands);"
2273   [(set (attr "length")
2274         (symbol_ref "compute_a_shift_length (insn, operands)"))
2275    (set_attr "cc" "clobber")])
2276
2277 ;; HI BIT SHIFTS
2278
2279 (define_expand "ashlhi3"
2280   [(set (match_operand:HI 0 "register_operand" "")
2281         (ashift:HI (match_operand:HI 1 "nonmemory_operand" "")
2282                    (match_operand:QI 2 "nonmemory_operand" "")))]
2283   ""
2284   "expand_a_shift (HImode, ASHIFT, operands); DONE;")
2285
2286 (define_expand "lshrhi3"
2287   [(set (match_operand:HI 0 "register_operand" "")
2288         (lshiftrt:HI (match_operand:HI 1 "general_operand" "")
2289                      (match_operand:QI 2 "nonmemory_operand" "")))]
2290   ""
2291   "expand_a_shift (HImode, LSHIFTRT, operands); DONE;")
2292
2293 (define_expand "ashrhi3"
2294   [(set (match_operand:HI 0 "register_operand" "")
2295         (ashiftrt:HI (match_operand:HI 1 "register_operand" "")
2296                      (match_operand:QI 2 "nonmemory_operand" "")))]
2297   ""
2298   "expand_a_shift (HImode, ASHIFTRT, operands); DONE;")
2299
2300 (define_insn ""
2301   [(set (match_operand:HI 0 "register_operand" "=r,r")
2302         (match_operator:HI 3 "nshift_operator"
2303                         [ (match_operand:HI 1 "register_operand" "0,0")
2304                           (match_operand:QI 2 "nonmemory_operand" "S,rn")]))
2305    (clobber (match_scratch:QI 4 "=X,&r"))]
2306   ""
2307   "* return output_a_shift (operands);"
2308   [(set (attr "length")
2309         (symbol_ref "compute_a_shift_length (insn, operands)"))
2310    (set_attr "cc" "clobber")])
2311
2312 ;;  SI BIT SHIFTS
2313
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" "")))]
2318   ""
2319   "expand_a_shift (SImode, ASHIFT, operands); DONE;")
2320
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" "")))]
2325   ""
2326   "expand_a_shift (SImode, LSHIFTRT, operands); DONE;")
2327
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" "")))]
2332   ""
2333   "expand_a_shift (SImode, ASHIFTRT, operands); DONE;")
2334
2335 (define_insn ""
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"))]
2341   ""
2342   "* return output_a_shift (operands);"
2343   [(set (attr "length")
2344         (symbol_ref "compute_a_shift_length (insn, operands)"))
2345    (set_attr "cc" "clobber")])
2346
2347 ;; Split a variable shift into a loop.  If the register containing
2348 ;; the shift count dies, then we just use that register.
2349
2350 (define_split
2351   [(parallel
2352      [(set (match_operand 0 "register_operand" "")
2353            (match_operator 2 "nshift_operator"
2354              [(match_dup 0)
2355               (match_operand:QI 1 "register_operand" "")]))
2356       (clobber (match_operand:QI 3 "register_operand" ""))])]
2357   "flow2_completed
2358    && find_regno_note (insn, REG_DEAD, REGNO (operands[1]))"
2359   [(set (cc0)
2360         (match_dup 1))
2361    (set (pc)
2362         (if_then_else (le (cc0) (const_int 0))
2363                       (label_ref (match_dup 5))
2364                       (pc)))
2365    (match_dup 4)
2366    (parallel
2367      [(set (match_dup 0)
2368            (match_op_dup 2 [(match_dup 0) (const_int 1)]))
2369       (clobber (scratch:QI))])
2370    (set (match_dup 1)
2371         (plus:QI (match_dup 1) (const_int -1)))
2372    (set (cc0)
2373         (match_dup 1))
2374    (set (pc)
2375         (if_then_else (ne (cc0) (const_int 0))
2376                       (label_ref (match_dup 4))
2377                       (pc)))
2378    (match_dup 5)]
2379   "operands[4] = gen_label_rtx ();
2380    operands[5] = gen_label_rtx ();")
2381
2382 (define_split
2383   [(parallel
2384      [(set (match_operand 0 "register_operand" "")
2385            (match_operator 2 "nshift_operator"
2386              [(match_dup 0)
2387               (match_operand:QI 1 "register_operand" "")]))
2388       (clobber (match_operand:QI 3 "register_operand" ""))])]
2389   "flow2_completed
2390    && !find_regno_note (insn, REG_DEAD, REGNO (operands[1]))"
2391   [(set (match_dup 3)
2392         (match_dup 1))
2393    (set (cc0)
2394         (match_dup 3))
2395    (set (pc)
2396         (if_then_else (le (cc0) (const_int 0))
2397                       (label_ref (match_dup 5))
2398                       (pc)))
2399    (match_dup 4)
2400    (parallel
2401      [(set (match_dup 0)
2402            (match_op_dup 2 [(match_dup 0) (const_int 1)]))
2403       (clobber (scratch:QI))])
2404    (set (match_dup 3)
2405         (plus:QI (match_dup 3) (const_int -1)))
2406    (set (cc0)
2407         (match_dup 3))
2408    (set (pc)
2409         (if_then_else (ne (cc0) (const_int 0))
2410                       (label_ref (match_dup 4))
2411                       (pc)))
2412    (match_dup 5)]
2413   "operands[4] = gen_label_rtx ();
2414    operands[5] = gen_label_rtx ();")
2415 \f
2416 ;; ----------------------------------------------------------------------
2417 ;; ROTATIONS
2418 ;; ----------------------------------------------------------------------
2419
2420 (define_expand "rotlqi3"
2421   [(set (match_operand:QI 0 "register_operand" "")
2422         (rotate:QI (match_operand:QI 1 "register_operand" "")
2423                    (match_operand:QI 2 "nonmemory_operand" "")))]
2424   ""
2425   "if (expand_a_rotate (ROTATE, operands)) DONE; else FAIL;")
2426
2427 (define_insn "*rotlqi3_1"
2428   [(set (match_operand:QI 0 "register_operand" "=r")
2429         (rotate:QI (match_operand:QI 1 "register_operand" "0")
2430                    (match_operand:QI 2 "immediate_operand" "")))]
2431   ""
2432   "* return emit_a_rotate (ROTATE, operands);"
2433   [(set_attr "length" "20")
2434    (set_attr "cc" "clobber")])
2435
2436 (define_expand "rotlhi3"
2437   [(set (match_operand:HI 0 "register_operand" "")
2438         (rotate:HI (match_operand:HI 1 "register_operand" "")
2439                    (match_operand:QI 2 "nonmemory_operand" "")))]
2440   ""
2441   "if (expand_a_rotate (ROTATE, operands)) DONE; else FAIL;")
2442
2443 (define_insn "*rotlhi3_1"
2444   [(set (match_operand:HI 0 "register_operand" "=r")
2445         (rotate:HI (match_operand:HI 1 "register_operand" "0")
2446                    (match_operand:QI 2 "immediate_operand" "")))]
2447   ""
2448   "* return emit_a_rotate (ROTATE, operands);"
2449   [(set_attr "length" "20")
2450    (set_attr "cc" "clobber")])
2451
2452 (define_expand "rotlsi3"
2453   [(set (match_operand:SI 0 "register_operand" "")
2454         (rotate:SI (match_operand:SI 1 "register_operand" "")
2455                    (match_operand:QI 2 "nonmemory_operand" "")))]
2456   "TARGET_H8300H || TARGET_H8300S"
2457   "if (expand_a_rotate (ROTATE, operands)) DONE; else FAIL;")
2458
2459 (define_insn "*rotlsi3_1"
2460   [(set (match_operand:SI 0 "register_operand" "=r")
2461         (rotate:SI (match_operand:SI 1 "register_operand" "0")
2462                    (match_operand:QI 2 "immediate_operand" "")))]
2463   "TARGET_H8300H || TARGET_H8300S"
2464   "* return emit_a_rotate (ROTATE, operands);"
2465   [(set_attr "length" "20")
2466    (set_attr "cc" "clobber")])
2467 \f
2468 ;; -----------------------------------------------------------------
2469 ;; BIT FIELDS
2470 ;; -----------------------------------------------------------------
2471 ;; The H8/300 has given 1/8th of its opcode space to bitfield
2472 ;; instructions so let's use them as well as we can.
2473
2474 ;; You'll never believe all these patterns perform one basic action --
2475 ;; load a bit from the source, optionally invert the bit, then store it
2476 ;; in the destination (which is known to be zero).
2477 ;;
2478 ;; Combine obviously need some work to better identify this situation and
2479 ;; canonicalize the form better.
2480
2481 ;;
2482 ;; Normal loads with a 16bit destination.
2483 ;;
2484
2485 (define_insn ""
2486   [(set (match_operand:HI 0 "register_operand" "=&r")
2487         (zero_extract:HI (match_operand:HI 1 "register_operand" "r")
2488                          (const_int 1)
2489                          (match_operand:HI 2 "immediate_operand" "n")))]
2490   "TARGET_H8300"
2491   "sub.w        %0,%0\;bld      %Z2,%Y1\;bst    #0,%X0"
2492   [(set_attr "cc" "clobber")
2493    (set_attr "length" "6")])
2494
2495 ;;
2496 ;; Inverted loads with a 16bit destination.
2497 ;;
2498
2499 (define_insn ""
2500   [(set (match_operand:HI 0 "register_operand" "=&r")
2501         (zero_extract:HI (xor:HI (match_operand:HI 1 "register_operand" "r")
2502                                  (match_operand:HI 3 "const_int_operand" "n"))
2503                          (const_int 1)
2504                          (match_operand:HI 2 "const_int_operand" "n")))]
2505   "TARGET_H8300
2506    && (1 << INTVAL (operands[2])) == INTVAL (operands[3])"
2507   "sub.w        %0,%0\;bild     %Z2,%Y1\;bst    #0,%X0"
2508   [(set_attr "cc" "clobber")
2509    (set_attr "length" "8")])
2510
2511 ;;
2512 ;; Normal loads with a 32bit destination.
2513 ;;
2514
2515 (define_insn "*extzv_1_r_h8300"
2516   [(set (match_operand:SI 0 "register_operand" "=&r")
2517         (zero_extract:SI (match_operand:HI 1 "register_operand" "r")
2518                          (const_int 1)
2519                          (match_operand 2 "const_int_operand" "n")))]
2520   "TARGET_H8300
2521    && INTVAL (operands[2]) < 16"
2522   "* return output_simode_bld (0, operands);"
2523   [(set_attr "cc" "clobber")
2524    (set_attr "length" "8")])
2525
2526 (define_insn "*extzv_1_r_h8300hs"
2527   [(set (match_operand:SI 0 "register_operand" "=r,r")
2528         (zero_extract:SI (match_operand:SI 1 "register_operand" "?0,r")
2529                          (const_int 1)
2530                          (match_operand 2 "const_int_operand" "n,n")))]
2531   "(TARGET_H8300H || TARGET_H8300S)
2532    && INTVAL (operands[2]) < 16"
2533   "* return output_simode_bld (0, operands);"
2534   [(set_attr "cc" "clobber,clobber")
2535    (set_attr "length" "8,6")])
2536
2537 ;;
2538 ;; Inverted loads with a 32bit destination.
2539 ;;
2540
2541 (define_insn "*extzv_1_r_inv_h8300"
2542   [(set (match_operand:SI 0 "register_operand" "=&r")
2543         (zero_extract:SI (xor:HI (match_operand:HI 1 "register_operand" "r")
2544                                  (match_operand:HI 3 "const_int_operand" "n"))
2545                          (const_int 1)
2546                          (match_operand 2 "const_int_operand" "n")))]
2547   "TARGET_H8300
2548    && INTVAL (operands[2]) < 16
2549    && (1 << INTVAL (operands[2])) == INTVAL (operands[3])"
2550   "* return output_simode_bld (1, operands);"
2551   [(set_attr "cc" "clobber")
2552    (set_attr "length" "8")])
2553
2554 (define_insn "*extzv_1_r_inv_h8300hs"
2555   [(set (match_operand:SI 0 "register_operand" "=r,r")
2556         (zero_extract:SI (xor:SI (match_operand:SI 1 "register_operand" "?0,r")
2557                                  (match_operand 3 "const_int_operand" "n,n"))
2558                          (const_int 1)
2559                          (match_operand 2 "const_int_operand" "n,n")))]
2560   "(TARGET_H8300H || TARGET_H8300S)
2561    && INTVAL (operands[2]) < 16
2562    && (1 << INTVAL (operands[2])) == INTVAL (operands[3])"
2563   "* return output_simode_bld (1, operands);"
2564   [(set_attr "cc" "clobber,clobber")
2565    (set_attr "length" "8,6")])
2566
2567 (define_expand "insv"
2568   [(set (zero_extract:HI (match_operand:HI 0 "general_operand" "")
2569                          (match_operand:HI 1 "general_operand" "")
2570                          (match_operand:HI 2 "general_operand" ""))
2571         (match_operand:HI 3 "general_operand" ""))]
2572   "TARGET_H8300"
2573   "
2574 {
2575   /* We only have single bit bit-field instructions.  */
2576   if (INTVAL (operands[1]) != 1)
2577     FAIL;
2578
2579   /* For now, we don't allow memory operands.  */
2580   if (GET_CODE (operands[0]) == MEM
2581       || GET_CODE (operands[3]) == MEM)
2582     FAIL;
2583 }")
2584
2585 (define_insn ""
2586   [(set (zero_extract:HI (match_operand:HI 0 "register_operand" "+r")
2587                          (const_int 1)
2588                          (match_operand:HI 1 "immediate_operand" "n"))
2589         (match_operand:HI 2 "register_operand" "r"))]
2590   ""
2591   "bld  #0,%R2\;bst     %Z1,%Y0 ; i1"
2592   [(set_attr "cc" "clobber")
2593    (set_attr "length" "4")])
2594
2595 (define_expand "extzv"
2596   [(set (match_operand:HI 0 "register_operand" "")
2597         (zero_extract:HI (match_operand:HI 1 "bit_operand" "")
2598                          (match_operand:HI 2 "general_operand" "")
2599                          (match_operand:HI 3 "general_operand" "")))]
2600   "TARGET_H8300"
2601   "
2602 {
2603   /* We only have single bit bit-field instructions.  */
2604   if (INTVAL (operands[2]) != 1)
2605     FAIL;
2606
2607   /* For now, we don't allow memory operands.  */
2608   if (GET_CODE (operands[1]) == MEM)
2609     FAIL;
2610 }")
2611
2612 ;; BAND, BOR, and BXOR patterns
2613
2614 (define_insn ""
2615   [(set (match_operand:HI 0 "bit_operand" "=Ur")
2616         (match_operator:HI 4 "bit_operator"
2617            [(zero_extract:HI (match_operand:HI 1 "register_operand" "r")
2618                              (const_int 1)
2619                              (match_operand:HI 2 "immediate_operand" "n"))
2620             (match_operand:HI 3 "bit_operand" "0")]))]
2621   ""
2622   "bld  %Z2,%Y1\;%b4    #0,%R0\;bst     #0,%R0; bl1"
2623   [(set_attr "cc" "clobber")
2624    (set_attr "length" "6")
2625    (set_attr "adjust_length" "no")])
2626
2627 (define_insn ""
2628   [(set (match_operand:HI 0 "bit_operand" "=Ur")
2629         (match_operator:HI 5 "bit_operator"
2630            [(zero_extract:HI (match_operand:HI 1 "register_operand" "r")
2631                              (const_int 1)
2632                              (match_operand:HI 2 "immediate_operand" "n"))
2633             (zero_extract:HI (match_operand:HI 3 "register_operand" "r")
2634                              (const_int 1)
2635                              (match_operand:HI 4 "immediate_operand" "n"))]))]
2636   ""
2637   "bld  %Z2,%Y1\;%b5    %Z4,%Y3\;bst    #0,%R0; bl3"
2638   [(set_attr "cc" "clobber")
2639    (set_attr "length" "6")
2640    (set_attr "adjust_length" "no")])
2641 \f
2642 ;; -----------------------------------------------------------------
2643 ;; COMBINE PATTERNS
2644 ;; -----------------------------------------------------------------
2645
2646 ;; extzv:SI
2647
2648 (define_insn "*extzv_8_8"
2649   [(set (match_operand:SI 0 "register_operand" "=r,r")
2650         (zero_extract:SI (match_operand:SI 1 "register_operand" "?0,r")
2651                          (const_int 8)
2652                          (const_int 8)))]
2653   "TARGET_H8300H || TARGET_H8300S"
2654   "@
2655    mov.b\\t%x1,%w0\;extu.w\\t%f0\;extu.l\\t%S0
2656    sub.l\\t%S0,%S0\;mov.b\\t%x1,%w0"
2657   [(set_attr "cc" "set_znv,clobber")
2658    (set_attr "length" "6,4")])
2659
2660 (define_insn "*extzv_8_16"
2661   [(set (match_operand:SI 0 "register_operand" "=r")
2662         (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
2663                          (const_int 8)
2664                          (const_int 16)))]
2665   "TARGET_H8300H || TARGET_H8300S"
2666   "mov.w\\t%e1,%f0\;extu.w\\t%f0\;extu.l\\t%S0"
2667   [(set_attr "cc" "set_znv")
2668    (set_attr "length" "6")])
2669
2670 (define_insn "*extzv_16_8"
2671   [(set (match_operand:SI 0 "register_operand" "=r")
2672         (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
2673                          (const_int 16)
2674                          (const_int 8)))
2675    (clobber (match_scratch:SI 2 "=&r"))]
2676   "TARGET_H8300H"
2677   "mov.w\\t%e1,%f2\;mov.b\\t%x1,%w0\;mov.b\\t%w2,%x0\;extu.l\\t%S0"
2678   [(set_attr "length" "8")
2679    (set_attr "cc" "set_znv")])
2680
2681 ;; Extract the exponent of a float.
2682
2683 (define_insn_and_split "*extzv_8_23"
2684   [(set (match_operand:SI 0 "register_operand" "=r")
2685         (zero_extract:SI (match_operand:SI 1 "register_operand" "0")
2686                          (const_int 8)
2687                          (const_int 23)))]
2688   "(TARGET_H8300H || TARGET_H8300S)"
2689   "#"
2690   "&& reload_completed"
2691   [(parallel [(set (match_dup 0)
2692                    (ashift:SI (match_dup 0)
2693                               (const_int 1)))
2694               (clobber (scratch:QI))])
2695    (parallel [(set (match_dup 0)
2696                    (lshiftrt:SI (match_dup 0)
2697                                 (const_int 24)))
2698               (clobber (scratch:QI))])]
2699   "")
2700
2701 ;; and:SI
2702
2703 ;; ((SImode) HImode) << 15
2704
2705 (define_insn_and_split "*twoshifts_l16_r1"
2706   [(set (match_operand:SI 0 "register_operand" "=r")
2707         (and:SI (ashift:SI (match_operand:SI 1 "register_operand" "0")
2708                            (const_int 15))
2709                 (const_int 2147450880)))]
2710   "(TARGET_H8300H || TARGET_H8300S)"
2711   "#"
2712   "&& reload_completed"
2713   [(parallel [(set (match_dup 0)
2714                    (ashift:SI (match_dup 0)
2715                               (const_int 16)))
2716               (clobber (scratch:QI))])
2717    (parallel [(set (match_dup 0)
2718                    (lshiftrt:SI (match_dup 0)
2719                                 (const_int 1)))
2720               (clobber (scratch:QI))])]
2721   "")
2722
2723 ;; Transform (SImode << B) & 0xffff into (SImode) (HImode << B).
2724
2725 (define_insn_and_split "*andsi3_ashift_n_lower"
2726   [(set (match_operand:SI 0 "register_operand" "=r,r")
2727         (and:SI (ashift:SI (match_operand:SI 1 "register_operand" "0,0")
2728                            (match_operand:QI 2 "const_int_operand" "S,n"))
2729                 (match_operand:SI 3 "const_int_operand" "n,n")))
2730    (clobber (match_scratch:QI 4 "=X,&r"))]
2731   "(TARGET_H8300H || TARGET_H8300S)
2732    && INTVAL (operands[2]) <= 15
2733    && INTVAL (operands[3]) == ((-1 << INTVAL (operands[2])) & 0xffff)"
2734   "#"
2735   "&& reload_completed"
2736   [(parallel [(set (match_dup 5)
2737                    (ashift:HI (match_dup 5)
2738                               (match_dup 2)))
2739               (clobber (match_dup 4))])
2740    (set (match_dup 0)
2741         (zero_extend:SI (match_dup 5)))]
2742   "operands[5] = gen_rtx_REG (HImode, REGNO (operands[0]));")
2743
2744 ;; Accept (A >> 30) & 2 and the like.
2745
2746 (define_insn "*andsi3_lshiftrt_n_sb"
2747   [(set (match_operand:SI 0 "register_operand" "=r")
2748         (and:SI (lshiftrt:SI (match_operand:SI 1 "register_operand" "0")
2749                              (match_operand:SI 2 "const_int_operand" "n"))
2750                 (match_operand:SI 3 "single_one_operand" "n")))]
2751   "(TARGET_H8300H || TARGET_H8300S)
2752    && exact_log2 (INTVAL (operands[3])) < 16
2753    && INTVAL (operands[2]) + exact_log2 (INTVAL (operands[3])) == 31"
2754   "*
2755 {
2756   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
2757   return \"shll.l\\t%S0\;xor.l\\t%S0,%S0\;bst\\t%Z3,%Y0\";
2758 }"
2759   [(set_attr "length" "8")
2760    (set_attr "cc" "clobber")])
2761
2762 (define_insn_and_split "*andsi3_lshiftrt_9_sb"
2763   [(set (match_operand:SI 0 "register_operand" "=r")
2764         (and:SI (lshiftrt:SI (match_operand:SI 1 "register_operand" "0")
2765                              (const_int 9))
2766                 (const_int 4194304)))]
2767   "(TARGET_H8300H || TARGET_H8300S)"
2768   "#"
2769   "&& reload_completed"
2770   [(set (match_dup 0)
2771         (and:SI (lshiftrt:SI (match_dup 0)
2772                              (const_int 25))
2773                 (const_int 64)))
2774    (parallel [(set (match_dup 0)
2775                    (ashift:SI (match_dup 0)
2776                               (const_int 16)))
2777               (clobber (scratch:QI))])]
2778   "")
2779
2780 ;; plus:SI
2781
2782 (define_insn "*addsi3_upper"
2783   [(set (match_operand:SI 0 "register_operand" "=r")
2784         (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "r")
2785                           (const_int 65536))
2786                  (match_operand:SI 2 "register_operand" "0")))]
2787   "TARGET_H8300H || TARGET_H8300S"
2788   "add.w\\t%f1,%e0"
2789   [(set_attr "length" "2")
2790    (set_attr "cc" "clobber")])
2791
2792 (define_insn "*addsi3_lshiftrt_16_zexthi"
2793   [(set (match_operand:SI 0 "register_operand" "=r")
2794         (plus:SI (lshiftrt:SI (match_operand:SI 1 "register_operand" "r")
2795                               (const_int 16))
2796                  (zero_extend:SI (match_operand:HI 2 "register_operand" "0"))))]
2797   "TARGET_H8300H || TARGET_H8300S"
2798   "add.w\\t%e1,%f0\;xor.w\\t%e0,%e0\;rotxl.w\\t%e0,%e0"
2799   [(set_attr "cc" "clobber")
2800    (set_attr "length" "6")])
2801
2802 ;; [ix]or:HI
2803
2804 (define_insn "*ixorhi3_zext"
2805   [(set (match_operand:HI 0 "register_operand" "=r")
2806         (match_operator:HI 1 "iorxor_operator"
2807           [(zero_extend:HI (match_operand:QI 2 "register_operand" "r"))
2808            (match_operand:HI 3 "register_operand" "0")]))]
2809   ""
2810   "%c1.b\\t%X2,%s0"
2811   [(set_attr "cc" "clobber")
2812    (set_attr "length" "2")])
2813
2814 ;; [ix]or:SI
2815
2816 (define_insn "*ixorsi3_zext_qi"
2817   [(set (match_operand:SI 0 "register_operand" "=r")
2818         (match_operator:SI 1 "iorxor_operator"
2819           [(zero_extend:SI (match_operand:QI 2 "register_operand" "r"))
2820            (match_operand:SI 3 "register_operand" "0")]))]
2821   ""
2822   "%c1.b\\t%X2,%w0"
2823   [(set_attr "cc" "clobber")
2824    (set_attr "length" "2")])
2825
2826 (define_insn "*ixorsi3_zext_hi"
2827   [(set (match_operand:SI 0 "register_operand" "=r")
2828         (match_operator:SI 1 "iorxor_operator"
2829           [(zero_extend:SI (match_operand:HI 2 "register_operand" "r"))
2830            (match_operand:SI 3 "register_operand" "0")]))]
2831   "TARGET_H8300H || TARGET_H8300S"
2832   "%c1.w\\t%T2,%f0"
2833   [(set_attr "cc" "clobber")
2834    (set_attr "length" "2")])
2835
2836 (define_insn "*ixorsi3_ashift_16"
2837   [(set (match_operand:SI 0 "register_operand" "=r")
2838         (match_operator:SI 1 "iorxor_operator"
2839           [(ashift:SI (match_operand:SI 2 "register_operand" "r")
2840                       (const_int 16))
2841            (match_operand:SI 3 "register_operand" "0")]))]
2842   "TARGET_H8300H || TARGET_H8300S"
2843   "%c1.w\\t%f2,%e0"
2844   [(set_attr "cc" "clobber")
2845    (set_attr "length" "2")])
2846
2847 (define_insn "*ixorsi3_lshiftrt_16"
2848   [(set (match_operand:SI 0 "register_operand" "=r")
2849         (match_operator:SI 1 "iorxor_operator"
2850           [(lshiftrt:SI (match_operand:SI 2 "register_operand" "r")
2851                         (const_int 16))
2852            (match_operand:SI 3 "register_operand" "0")]))]
2853   "TARGET_H8300H || TARGET_H8300S"
2854   "%c1.w\\t%e2,%f0"
2855   [(set_attr "cc" "clobber")
2856    (set_attr "length" "2")])
2857
2858 (define_insn_and_split "*addsi3_and_r_1"
2859   [(set (match_operand:SI 0 "register_operand" "=r")
2860         (plus:SI (and:SI (match_operand:SI 1 "register_operand" "r")
2861                          (const_int 1))
2862                  (match_operand:SI 2 "register_operand" "0")))]
2863   "(TARGET_H8300H || TARGET_H8300S)"
2864   "#"
2865   "&& reload_completed"
2866   [(set (cc0)
2867         (zero_extract:SI (match_dup 1)
2868                          (const_int 1)
2869                          (const_int 0)))
2870    (set (pc)
2871         (if_then_else (eq (cc0)
2872                           (const_int 0))
2873                       (label_ref (match_dup 3))
2874                       (pc)))
2875    (set (match_dup 2)
2876         (plus:SI (match_dup 2)
2877                  (const_int 1)))
2878    (match_dup 3)]
2879   "operands[3] = gen_label_rtx ();")
2880
2881 (define_insn_and_split "*addsi3_and_not_r_1"
2882   [(set (match_operand:SI 0 "register_operand" "=r")
2883         (plus:SI (and:SI (not:SI (match_operand:SI 1 "register_operand" "r"))
2884                          (const_int 1))
2885                  (match_operand:SI 2 "register_operand" "0")))]
2886   "(TARGET_H8300H || TARGET_H8300S)"
2887   "#"
2888   "&& reload_completed"
2889   [(set (cc0)
2890         (zero_extract:SI (match_dup 1)
2891                          (const_int 1)
2892                          (const_int 0)))
2893    (set (pc)
2894         (if_then_else (ne (cc0)
2895                           (const_int 0))
2896                       (label_ref (match_dup 3))
2897                       (pc)))
2898    (set (match_dup 2)
2899         (plus:SI (match_dup 2)
2900                  (const_int 1)))
2901    (match_dup 3)]
2902   "operands[3] = gen_label_rtx ();")
2903
2904 ;; ior:HI
2905
2906 (define_insn "*iorhi3_ashift_8"
2907   [(set (match_operand:HI 0 "register_operand" "=r")
2908         (ior:HI (ashift:HI (match_operand:HI 1 "register_operand" "r")
2909                            (const_int 8))
2910                 (match_operand:HI 2 "register_operand" "0")))]
2911   ""
2912   "or.b\\t%s1,%t0"
2913   [(set_attr "cc" "clobber")
2914    (set_attr "length" "2")])
2915
2916 (define_insn "*iorhi3_lshiftrt_8"
2917   [(set (match_operand:HI 0 "register_operand" "=r")
2918         (ior:HI (lshiftrt:HI (match_operand:HI 1 "register_operand" "r")
2919                              (const_int 8))
2920                 (match_operand:HI 2 "register_operand" "0")))]
2921   ""
2922   "or.b\\t%t1,%s0"
2923   [(set_attr "cc" "clobber")
2924    (set_attr "length" "2")])
2925
2926 (define_insn "*iorhi3_two_qi"
2927   [(set (match_operand:HI 0 "register_operand" "=r")
2928         (ior:HI (zero_extend:HI (match_operand:QI 1 "register_operand" "0"))
2929                 (ashift:HI (match_operand:HI 2 "register_operand" "r")
2930                            (const_int 8))))]
2931   ""
2932   "mov.b\\t%s2,%t0"
2933   [(set_attr "cc" "clobber")
2934    (set_attr "length" "2")])
2935
2936 (define_insn "*iorhi3_two_qi_mem"
2937   [(set (match_operand:HI 0 "register_operand" "=&r")
2938         (ior:HI (zero_extend:HI (match_operand:QI 1 "memory_operand" "m"))
2939                 (ashift:HI (subreg:HI (match_operand:QI 2 "memory_operand" "m") 0)
2940                            (const_int 8))))]
2941   ""
2942   "mov.b\\t%X2,%t0\;mov.b\\t%X1,%s0"
2943   [(set_attr "cc" "clobber")
2944    (set_attr "length" "16")])
2945
2946 (define_split
2947   [(set (match_operand:HI 0 "register_operand" "")
2948         (ior:HI (zero_extend:HI (match_operand:QI 1 "memory_operand" ""))
2949                 (ashift:HI (subreg:HI (match_operand:QI 2 "memory_operand" "") 0)
2950                            (const_int 8))))]
2951   "(TARGET_H8300H || TARGET_H8300S)
2952    && reload_completed
2953    && byte_accesses_mergeable_p (XEXP (operands[2], 0), XEXP (operands[1], 0))"
2954   [(set (match_dup 0)
2955         (match_dup 3))]
2956   "operands[3] = gen_rtx_MEM (HImode, XEXP (operands[2], 0));")
2957
2958 ;; ior:SI
2959
2960 (define_insn "*iorsi3_two_hi"
2961   [(set (match_operand:SI 0 "register_operand" "=r")
2962         (ior:SI (zero_extend:SI (match_operand:HI 1 "register_operand" "0"))
2963                 (ashift:SI (match_operand:SI 2 "register_operand" "r")
2964                            (const_int 16))))]
2965   "TARGET_H8300H || TARGET_H8300S"
2966   "mov.w\\t%f2,%e0"
2967   [(set_attr "cc" "clobber")
2968    (set_attr "length" "2")])
2969
2970 (define_insn_and_split "*iorsi3_two_qi_zext"
2971   [(set (match_operand:SI 0 "register_operand" "=&r")
2972         (ior:SI (zero_extend:SI (match_operand:QI 1 "memory_operand" "m"))
2973
2974                 (and:SI (ashift:SI (subreg:SI (match_operand:QI 2 "memory_operand" "m") 0)
2975                                    (const_int 8))
2976                         (const_int 65280))))]
2977   "(TARGET_H8300H || TARGET_H8300S)"
2978   "#"
2979   "&& reload_completed"
2980   [(set (match_dup 3)
2981         (ior:HI (zero_extend:HI (match_dup 1))
2982                 (ashift:HI (subreg:HI (match_dup 2) 0)
2983                            (const_int 8))))
2984    (set (match_dup 0)
2985         (zero_extend:SI (match_dup 3)))]
2986   "operands[3] = gen_rtx_REG (HImode, REGNO (operands[0]));")
2987
2988 (define_insn "*iorsi3_e2f"
2989   [(set (match_operand:SI 0 "register_operand" "=r")
2990         (ior:SI (and:SI (match_operand:SI 1 "register_operand" "0")
2991                         (const_int -65536))
2992                 (lshiftrt:SI (match_operand:SI 2 "register_operand" "r")
2993                              (const_int 16))))]
2994   "TARGET_H8300H || TARGET_H8300S"
2995   "mov.w\\t%e2,%f0"
2996   [(set_attr "length" "2")
2997    (set_attr "cc" "clobber")])
2998
2999 (define_insn_and_split "*iorsi3_two_qi_sext"
3000   [(set (match_operand:SI 0 "register_operand" "=r")
3001         (ior:SI (zero_extend:SI (match_operand:QI 1 "register_operand" "0"))
3002                 (ashift:SI (sign_extend:SI (match_operand:QI 2 "register_operand" "r"))
3003                            (const_int 8))))]
3004   "(TARGET_H8300H || TARGET_H8300S)"
3005   "#"
3006   "&& reload_completed"
3007   [(set (match_dup 3)
3008         (ior:HI (zero_extend:HI (match_dup 1))
3009                 (ashift:HI (match_dup 4)
3010                            (const_int 8))))
3011    (set (match_dup 0)
3012         (sign_extend:SI (match_dup 3)))]
3013   "operands[3] = gen_rtx_REG (HImode, REGNO (operands[0]));
3014    operands[4] = gen_rtx_REG (HImode, REGNO (operands[2]));")
3015
3016 (define_insn "*iorsi3_w"
3017   [(set (match_operand:SI 0 "register_operand" "=r,&r")
3018         (ior:SI (and:SI (match_operand:SI 1 "register_operand" "0,0")
3019                         (const_int -256))
3020                 (zero_extend:SI (match_operand:QI 2 "general_operand_src" "r,g>"))))]
3021   "TARGET_H8300H || TARGET_H8300S"
3022   "mov.b\\t%X2,%w0"
3023   [(set_attr "length" "2,8")
3024    (set_attr "cc" "clobber,clobber")])
3025
3026 (define_insn "*iorsi3_ashift_31"
3027   [(set (match_operand:SI 0 "register_operand" "=&r")
3028         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
3029                            (const_int 31))
3030                 (match_operand:SI 2 "register_operand" "0")))]
3031   "TARGET_H8300H || TARGET_H8300S"
3032   "rotxl.l\\t%S0\;bor\\t#0,%w1\;rotxr.l\\t%S0"
3033   [(set_attr "length" "6")
3034    (set_attr "cc" "set_znv")])
3035
3036 (define_insn "*iorsi3_and_lshiftrt_n_sb"
3037   [(set (match_operand:SI 0 "register_operand" "=r")
3038         (ior:SI (and:SI (lshiftrt:SI (match_operand:SI 1 "register_operand" "r")
3039                                      (const_int 30))
3040                         (const_int 2))
3041                 (match_operand:SI 2 "register_operand" "0")))]
3042   "(TARGET_H8300H || TARGET_H8300S)"
3043   "rotl.l\\t%S1\;rotr.l\\t%S1\;bor\\t#1,%w0\;bst\\t#1,%w0"
3044   [(set_attr "length" "8")
3045    (set_attr "cc" "clobber")])
3046
3047 (define_insn "*iorsi3_and_lshiftrt_9_sb"
3048   [(set (match_operand:SI 0 "register_operand" "=r")
3049         (ior:SI (and:SI (lshiftrt:SI (match_operand:SI 1 "register_operand" "r")
3050                                      (const_int 9))
3051                         (const_int 4194304))
3052                 (match_operand:SI 2 "register_operand" "0")))
3053    (clobber (match_scratch:HI 3 "=&r"))]
3054   "(TARGET_H8300H || TARGET_H8300S)"
3055   "*
3056 {
3057   if (find_regno_note (insn, REG_DEAD, REGNO (operands[1])))
3058     return \"shll.l\\t%S1\;xor.w\\t%T3,%T3\;bst\\t#6,%s3\;or.w\\t%T3,%e0\";
3059   else
3060     return \"rotl.l\\t%S1\;rotr.l\\t%S1\;xor.w\\t%T3,%T3\;bst\\t#6,%s3\;or.w\\t%T3,%e0\";
3061 }"
3062   [(set_attr "length" "10")
3063    (set_attr "cc" "clobber")])
3064
3065 ;; Used to OR the exponent of a float.
3066
3067 (define_insn "*iorsi3_shift"
3068   [(set (match_operand:SI 0 "register_operand" "=r")
3069         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
3070                            (const_int 23))
3071                 (match_operand:SI 2 "register_operand" "0")))
3072    (clobber (match_scratch:SI 3 "=&r"))]
3073   "TARGET_H8300H || TARGET_H8300S"
3074   "#")
3075
3076 (define_split
3077   [(parallel
3078     [(set (match_operand:SI 0 "register_operand" "")
3079           (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "")
3080                              (const_int 23))
3081                   (match_dup 0)))
3082      (clobber (match_operand:SI 2 "register_operand" ""))])]
3083   "(TARGET_H8300H || TARGET_H8300S)
3084    && flow2_completed
3085    && find_regno_note (insn, REG_DEAD, REGNO (operands[1]))
3086    && REGNO (operands[0]) != REGNO (operands[1])"
3087   [(parallel [(set (match_dup 3)
3088                    (ashift:HI (match_dup 3)
3089                               (const_int 7)))
3090               (clobber (scratch:QI))])
3091    (set (match_dup 0)
3092         (ior:SI (ashift:SI (match_dup 1)
3093                            (const_int 16))
3094                 (match_dup 0)))]
3095   "operands[3] = gen_rtx_REG (HImode, REGNO (operands[1]));")
3096
3097 (define_split
3098   [(parallel
3099     [(set (match_operand:SI 0 "register_operand" "")
3100           (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "")
3101                              (const_int 23))
3102                   (match_dup 0)))
3103      (clobber (match_operand:SI 2 "register_operand" ""))])]
3104   "(TARGET_H8300H || TARGET_H8300S)
3105    && flow2_completed
3106    && !(find_regno_note (insn, REG_DEAD, REGNO (operands[1]))
3107         && REGNO (operands[0]) != REGNO (operands[1]))"
3108   [(set (match_dup 2)
3109         (match_dup 1))
3110    (parallel [(set (match_dup 3)
3111                    (ashift:HI (match_dup 3)
3112                               (const_int 7)))
3113               (clobber (scratch:QI))])
3114    (set (match_dup 0)
3115         (ior:SI (ashift:SI (match_dup 2)
3116                            (const_int 16))
3117                 (match_dup 0)))]
3118   "operands[3] = gen_rtx_REG (HImode, REGNO (operands[2]));")
3119
3120 (define_insn "*iorsi2_and_1_lshiftrt_1"
3121   [(set (match_operand:SI 0 "register_operand" "=r")
3122         (ior:SI (and:SI (match_operand:SI 1 "register_operand" "0")
3123                         (const_int 1))
3124                 (lshiftrt:SI (match_dup 1)
3125                              (const_int 1))))]
3126   "TARGET_H8300H || TARGET_H8300S"
3127   "shlr.l\\t%S0\;bor\\t#0,%w0\;bst\\t#0,%w0"
3128   [(set_attr "length" "6")
3129    (set_attr "cc" "clobber")])
3130
3131 (define_insn_and_split "*iorsi3_ashift_16_ashift_24"
3132   [(set (match_operand:SI 0 "register_operand" "=r")
3133         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "0")
3134                            (const_int 16))
3135                 (ashift:SI (match_operand:SI 2 "register_operand" "r")
3136                            (const_int 24))))]
3137   "(TARGET_H8300H || TARGET_H8300S)"
3138   "#"
3139   "&& reload_completed"
3140   [(set (match_dup 3)
3141         (ior:HI (ashift:HI (match_dup 4)
3142                            (const_int 8))
3143                 (match_dup 3)))
3144    (parallel [(set (match_dup 0)
3145                    (ashift:SI (match_dup 0)
3146                               (const_int 16)))
3147               (clobber (scratch:QI))])]
3148   "operands[3] = gen_rtx_REG (HImode, REGNO (operands[0]));
3149    operands[4] = gen_rtx_REG (HImode, REGNO (operands[2]));")
3150
3151 (define_insn_and_split "*iorsi3_ashift_16_ashift_24_mem"
3152   [(set (match_operand:SI 0 "register_operand" "=&r")
3153         (ior:SI (and:SI (ashift:SI (subreg:SI (match_operand:QI 1 "memory_operand" "m") 0)
3154                                    (const_int 16))
3155                         (const_int 16711680))
3156                 (ashift:SI (subreg:SI (match_operand:QI 2 "memory_operand" "m") 0)
3157                            (const_int 24))))]
3158   "(TARGET_H8300H || TARGET_H8300S)"
3159   "#"
3160   "&& reload_completed"
3161   [(set (match_dup 3)
3162         (ior:HI (zero_extend:HI (match_dup 1))
3163                 (ashift:HI (subreg:HI (match_dup 2) 0)
3164                            (const_int 8))))
3165    (parallel [(set (match_dup 0)
3166                    (ashift:SI (match_dup 0)
3167                               (const_int 16)))
3168               (clobber (scratch:QI))])]
3169   "operands[3] = gen_rtx_REG (HImode, REGNO (operands[0]));")
3170
3171 ;; Used to add the exponent of a float.
3172
3173 (define_insn "*addsi3_shift"
3174   [(set (match_operand:SI 0 "register_operand" "=r")
3175         (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "r")
3176                           (const_int 8388608))
3177                  (match_operand:SI 2 "register_operand" "0")))
3178    (clobber (match_scratch:SI 3 "=&r"))]
3179   "TARGET_H8300H || TARGET_H8300S"
3180   "#")
3181
3182 (define_split
3183   [(parallel
3184     [(set (match_operand:SI 0 "register_operand" "")
3185           (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "")
3186                             (const_int 8388608))
3187                    (match_dup 0)))
3188      (clobber (match_operand:SI 2 "register_operand" ""))])]
3189   "(TARGET_H8300H || TARGET_H8300S)
3190    && flow2_completed
3191    && find_regno_note (insn, REG_DEAD, REGNO (operands[1]))
3192    && REGNO (operands[0]) != REGNO (operands[1])"
3193   [(parallel [(set (match_dup 3)
3194                    (ashift:HI (match_dup 3)
3195                               (const_int 7)))
3196               (clobber (scratch:QI))])
3197    (set (match_dup 0)
3198         (plus:SI (mult:SI (match_dup 1)
3199                           (const_int 65536))
3200                  (match_dup 0)))]
3201   "operands[3] = gen_rtx_REG (HImode, REGNO (operands[1]));")
3202
3203 (define_split
3204   [(parallel
3205     [(set (match_operand:SI 0 "register_operand" "")
3206           (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "")
3207                             (const_int 8388608))
3208                    (match_dup 0)))
3209      (clobber (match_operand:SI 2 "register_operand" ""))])]
3210   "(TARGET_H8300H || TARGET_H8300S)
3211    && flow2_completed
3212    && !(find_regno_note (insn, REG_DEAD, REGNO (operands[1]))
3213         && REGNO (operands[0]) != REGNO (operands[1]))"
3214   [(set (match_dup 2)
3215         (match_dup 1))
3216    (parallel [(set (match_dup 3)
3217                    (ashift:HI (match_dup 3)
3218                               (const_int 7)))
3219               (clobber (scratch:QI))])
3220    (set (match_dup 0)
3221         (plus:SI (mult:SI (match_dup 2)
3222                           (const_int 65536))
3223                  (match_dup 0)))]
3224   "operands[3] = gen_rtx_REG (HImode, REGNO (operands[2]));")
3225
3226 ;; ashift:SI
3227
3228 (define_insn_and_split "*ashiftsi_sextqi_7"
3229   [(set (match_operand:SI 0 "register_operand" "=r")
3230         (ashift:SI (sign_extend:SI (match_operand:QI 1 "register_operand" "0"))
3231                    (const_int 7)))]
3232   "(TARGET_H8300H || TARGET_H8300S)"
3233   "#"
3234   "&& reload_completed"
3235   [(parallel [(set (match_dup 2)
3236                    (ashift:HI (match_dup 2)
3237                               (const_int 8)))
3238               (clobber (scratch:QI))])
3239    (set (match_dup 0)
3240         (sign_extend:SI (match_dup 2)))
3241    (parallel [(set (match_dup 0)
3242                    (ashiftrt:SI (match_dup 0)
3243                                 (const_int 1)))
3244               (clobber (scratch:QI))])]
3245   "operands[2] = gen_rtx_REG (HImode, REGNO (operands[0]));")
3246
3247 ;; Storing a part of HImode to QImode.
3248
3249 (define_insn ""
3250   [(set (match_operand:QI 0 "general_operand_dst" "=rm<")
3251         (subreg:QI (lshiftrt:HI (match_operand:HI 1 "register_operand" "r")
3252                                 (const_int 8)) 1))]
3253   ""
3254   "mov.b\\t%t1,%R0"
3255   [(set_attr "cc" "set_znv")
3256    (set_attr "length" "8")])
3257
3258 ;; Storing a part of SImode to QImode.
3259
3260 (define_insn ""
3261   [(set (match_operand:QI 0 "general_operand_dst" "=rm<")
3262         (subreg:QI (lshiftrt:SI (match_operand:SI 1 "register_operand" "r")
3263                                 (const_int 8)) 3))]
3264   ""
3265   "mov.b\\t%x1,%R0"
3266   [(set_attr "cc" "set_znv")
3267    (set_attr "length" "8")])
3268
3269 (define_insn ""
3270   [(set (match_operand:QI 0 "general_operand_dst" "=rm<")
3271         (subreg:QI (lshiftrt:SI (match_operand:SI 1 "register_operand" "r")
3272                                 (const_int 16)) 3))
3273    (clobber (match_scratch:SI 2 "=&r"))]
3274   "TARGET_H8300H || TARGET_H8300S"
3275   "mov.w\\t%e1,%f2\;mov.b\\t%w2,%R0"
3276   [(set_attr "cc" "set_znv")
3277    (set_attr "length" "10")])
3278
3279 (define_insn ""
3280   [(set (match_operand:QI 0 "general_operand_dst" "=rm<")
3281         (subreg:QI (lshiftrt:SI (match_operand:SI 1 "register_operand" "r")
3282                                 (const_int 24)) 3))
3283    (clobber (match_scratch:SI 2 "=&r"))]
3284   "TARGET_H8300H || TARGET_H8300S"
3285   "mov.w\\t%e1,%f2\;mov.b\\t%x2,%R0"
3286   [(set_attr "cc" "set_znv")
3287    (set_attr "length" "10")])
3288
3289 (define_insn_and_split ""
3290   [(set (pc)
3291         (if_then_else (eq (zero_extract:SI (subreg:SI (match_operand:QI 0 "register_operand" "") 0)
3292                                            (const_int 1)
3293                                            (const_int 7))
3294                           (const_int 0))
3295                       (label_ref (match_operand 1 "" ""))
3296                       (pc)))]
3297   ""
3298   "#"
3299   ""
3300   [(set (cc0)
3301         (match_dup 0))
3302    (set (pc)
3303         (if_then_else (ge (cc0)
3304                           (const_int 0))
3305                       (label_ref (match_dup 1))
3306                       (pc)))]
3307   "")
3308
3309 (define_insn_and_split ""
3310   [(set (pc)
3311         (if_then_else (ne (zero_extract:SI (subreg:SI (match_operand:QI 0 "register_operand" "") 0)
3312                                            (const_int 1)
3313                                            (const_int 7))
3314                           (const_int 0))
3315                       (label_ref (match_operand 1 "" ""))
3316                       (pc)))]
3317   ""
3318   "#"
3319   ""
3320   [(set (cc0)
3321         (match_dup 0))
3322    (set (pc)
3323         (if_then_else (lt (cc0)
3324                           (const_int 0))
3325                       (label_ref (match_dup 1))
3326                       (pc)))]
3327   "")
3328 \f
3329 ;; -----------------------------------------------------------------
3330 ;; PEEPHOLE PATTERNS
3331 ;; -----------------------------------------------------------------
3332
3333 ;; Convert (A >> B) & C to (A & 255) >> B if C == 255 >> B.
3334
3335 (define_peephole2
3336   [(parallel
3337      [(set (match_operand:HI 0 "register_operand" "")
3338            (lshiftrt:HI (match_dup 0)
3339                         (match_operand:HI 1 "const_int_operand" "")))
3340       (clobber (match_operand:HI 2 "" ""))])
3341    (set (match_dup 0)
3342         (and:HI (match_dup 0)
3343                 (match_operand:HI 3 "const_int_operand" "")))]
3344   "INTVAL (operands[3]) == (255 >> INTVAL (operands[1]))"
3345   [(set (match_dup 0)
3346         (and:HI (match_dup 0)
3347                 (const_int 255)))
3348    (parallel
3349      [(set (match_dup 0)
3350            (lshiftrt:HI (match_dup 0)
3351                         (match_dup 1)))
3352       (clobber (match_dup 2))])]
3353   "")
3354
3355 ;; Convert (A << B) & C to (A & 255) << B if C == 255 << B.
3356
3357 (define_peephole2
3358   [(parallel
3359      [(set (match_operand:HI 0 "register_operand" "")
3360            (ashift:HI (match_dup 0)
3361                       (match_operand:HI 1 "const_int_operand" "")))
3362       (clobber (match_operand:HI 2 "" ""))])
3363    (set (match_dup 0)
3364         (and:HI (match_dup 0)
3365                 (match_operand:HI 3 "const_int_operand" "")))]
3366   "INTVAL (operands[3]) == (255 << INTVAL (operands[1]))"
3367   [(set (match_dup 0)
3368         (and:HI (match_dup 0)
3369                 (const_int 255)))
3370    (parallel
3371      [(set (match_dup 0)
3372            (ashift:HI (match_dup 0)
3373                       (match_dup 1)))
3374       (clobber (match_dup 2))])]
3375   "")
3376
3377 ;; Convert (A >> B) & C to (A & 255) >> B if C == 255 >> B.
3378
3379 (define_peephole2
3380   [(parallel
3381      [(set (match_operand:SI 0 "register_operand" "")
3382            (lshiftrt:SI (match_dup 0)
3383                         (match_operand:SI 1 "const_int_operand" "")))
3384       (clobber (match_operand:SI 2 "" ""))])
3385    (set (match_dup 0)
3386         (and:SI (match_dup 0)
3387                 (match_operand:SI 3 "const_int_operand" "")))]
3388   "INTVAL (operands[3]) == (255 >> INTVAL (operands[1]))"
3389   [(set (match_dup 0)
3390         (and:SI (match_dup 0)
3391                 (const_int 255)))
3392    (parallel
3393      [(set (match_dup 0)
3394            (lshiftrt:SI (match_dup 0)
3395                         (match_dup 1)))
3396       (clobber (match_dup 2))])]
3397   "")
3398
3399 ;; Convert (A << B) & C to (A & 255) << B if C == 255 << B.
3400
3401 (define_peephole2
3402   [(parallel
3403      [(set (match_operand:SI 0 "register_operand" "")
3404            (ashift:SI (match_dup 0)
3405                       (match_operand:SI 1 "const_int_operand" "")))
3406       (clobber (match_operand:SI 2 "" ""))])
3407    (set (match_dup 0)
3408         (and:SI (match_dup 0)
3409                 (match_operand:SI 3 "const_int_operand" "")))]
3410   "INTVAL (operands[3]) == (255 << INTVAL (operands[1]))"
3411   [(set (match_dup 0)
3412         (and:SI (match_dup 0)
3413                 (const_int 255)))
3414    (parallel
3415      [(set (match_dup 0)
3416            (ashift:SI (match_dup 0)
3417                       (match_dup 1)))
3418       (clobber (match_dup 2))])]
3419   "")
3420
3421 ;; Convert (A >> B) & C to (A & 65535) >> B if C == 65535 >> B.
3422
3423 (define_peephole2
3424   [(parallel
3425      [(set (match_operand:SI 0 "register_operand" "")
3426            (lshiftrt:SI (match_dup 0)
3427                         (match_operand:SI 1 "const_int_operand" "")))
3428       (clobber (match_operand:SI 2 "" ""))])
3429    (set (match_dup 0)
3430         (and:SI (match_dup 0)
3431                 (match_operand:SI 3 "const_int_operand" "")))]
3432   "INTVAL (operands[3]) == (65535 >> INTVAL (operands[1]))"
3433   [(set (match_dup 0)
3434         (and:SI (match_dup 0)
3435                 (const_int 65535)))
3436    (parallel
3437      [(set (match_dup 0)
3438            (lshiftrt:SI (match_dup 0)
3439                         (match_dup 1)))
3440       (clobber (match_dup 2))])]
3441   "")
3442
3443 ;; Convert (A << B) & C to (A & 65535) << B if C == 65535 << B.
3444
3445 (define_peephole2
3446   [(parallel
3447      [(set (match_operand:SI 0 "register_operand" "")
3448            (ashift:SI (match_dup 0)
3449                       (match_operand:SI 1 "const_int_operand" "")))
3450       (clobber (match_operand:SI 2 "" ""))])
3451    (set (match_dup 0)
3452         (and:SI (match_dup 0)
3453                 (match_operand:SI 3 "const_int_operand" "")))]
3454   "INTVAL (operands[3]) == (65535 << INTVAL (operands[1]))"
3455   [(set (match_dup 0)
3456         (and:SI (match_dup 0)
3457                 (const_int 65535)))
3458    (parallel
3459      [(set (match_dup 0)
3460            (ashift:SI (match_dup 0)
3461                       (match_dup 1)))
3462       (clobber (match_dup 2))])]
3463   "")
3464
3465 ;; Convert a QImode push into an SImode push so that the
3466 ;; define_peephole2 below can cram multiple pushes into one stm.l.
3467
3468 (define_peephole2
3469   [(parallel [(set (reg:SI SP_REG)
3470                    (plus:SI (reg:SI SP_REG) (const_int -4)))
3471               (set (mem:QI (plus:SI (reg:SI SP_REG) (const_int -3)))
3472                    (match_operand:QI 0 "register_operand" ""))])]
3473   "TARGET_H8300S"
3474   [(set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3475         (match_dup 0))]
3476   "operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]));")
3477
3478 ;; Convert a HImode push into an SImode push so that the
3479 ;; define_peephole2 below can cram multiple pushes into one stm.l.
3480
3481 (define_peephole2
3482   [(parallel [(set (reg:SI SP_REG)
3483                    (plus:SI (reg:SI SP_REG) (const_int -4)))
3484               (set (mem:HI (plus:SI (reg:SI SP_REG) (const_int -2)))
3485                    (match_operand:HI 0 "register_operand" ""))])]
3486   "TARGET_H8300S"
3487   [(set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3488         (match_dup 0))]
3489   "operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]));")
3490
3491 ;; Cram four pushes into stm.l.
3492
3493 (define_peephole2
3494   [(set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3495         (match_operand:SI 0 "register_operand" ""))
3496    (set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3497         (match_operand:SI 1 "register_operand" ""))
3498    (set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3499         (match_operand:SI 2 "register_operand" ""))
3500    (set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3501         (match_operand:SI 3 "register_operand" ""))]
3502   "TARGET_H8300S
3503    && REGNO (operands[0]) == 0
3504    && REGNO (operands[1]) == 1
3505    && REGNO (operands[2]) == 2
3506    && REGNO (operands[3]) == 3"
3507   [(parallel [(set (reg:SI SP_REG)
3508                    (plus:SI (reg:SI SP_REG)
3509                             (const_int -16)))
3510               (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -4)))
3511                    (match_dup 0))
3512               (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -8)))
3513                    (match_dup 1))
3514               (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -12)))
3515                    (match_dup 2))
3516               (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -16)))
3517                    (match_dup 3))])]
3518   "")
3519
3520 ;; Cram three pushes into stm.l.
3521
3522 (define_peephole2
3523   [(set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3524         (match_operand:SI 0 "register_operand" ""))
3525    (set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3526         (match_operand:SI 1 "register_operand" ""))
3527    (set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3528         (match_operand:SI 2 "register_operand" ""))]
3529   "TARGET_H8300S
3530    && ((REGNO (operands[0]) == 0
3531         && REGNO (operands[1]) == 1
3532         && REGNO (operands[2]) == 2)
3533        || (REGNO (operands[0]) == 4
3534            && REGNO (operands[1]) == 5
3535            && REGNO (operands[2]) == 6))"
3536   [(parallel [(set (reg:SI SP_REG)
3537                    (plus:SI (reg:SI SP_REG)
3538                             (const_int -12)))
3539               (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -4)))
3540                    (match_dup 0))
3541               (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -8)))
3542                    (match_dup 1))
3543               (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -12)))
3544                    (match_dup 2))])]
3545   "")
3546
3547 ;; Cram two pushes into stm.l.
3548
3549 (define_peephole2
3550   [(set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3551         (match_operand:SI 0 "register_operand" ""))
3552    (set (mem:SI (pre_dec:SI (reg:SI SP_REG)))
3553         (match_operand:SI 1 "register_operand" ""))]
3554   "TARGET_H8300S
3555    && ((REGNO (operands[0]) == 0 && REGNO (operands[1]) == 1)
3556        || (REGNO (operands[0]) == 2 && REGNO (operands[1]) == 3)
3557        || (REGNO (operands[0]) == 4 && REGNO (operands[1]) == 5))"
3558   [(parallel [(set (reg:SI SP_REG)
3559                    (plus:SI (reg:SI SP_REG)
3560                             (const_int -8)))
3561               (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -4)))
3562                    (match_dup 0))
3563               (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -8)))
3564                    (match_dup 1))])]
3565   "")
3566
3567 ;; Turn
3568 ;;
3569 ;;   mov.w #2,r0
3570 ;;   add.w r7,r0  (6 bytes)
3571 ;;
3572 ;; into
3573 ;;
3574 ;;   mov.w r7,r0
3575 ;;   adds  #2,r0  (4 bytes)
3576
3577 (define_peephole2
3578   [(set (match_operand:HI 0 "register_operand" "")
3579         (match_operand:HI 1 "const_int_operand" ""))
3580    (set (match_dup 0)
3581         (plus:HI (match_dup 0)
3582                  (match_operand:HI 2 "register_operand" "")))]
3583   "REG_P (operands[0]) && REG_P (operands[2])
3584    && REGNO (operands[0]) != REGNO (operands[2])
3585    && (CONST_OK_FOR_J (INTVAL (operands[1]))
3586        || CONST_OK_FOR_L (INTVAL (operands[1]))
3587        || CONST_OK_FOR_N (INTVAL (operands[1])))"
3588   [(set (match_dup 0)
3589         (match_dup 2))
3590    (set (match_dup 0)
3591         (plus:HI (match_dup 0)
3592                  (match_dup 1)))]
3593   "")
3594
3595 ;; Turn
3596 ;;
3597 ;;   sub.l  er0,er0
3598 ;;   add.b  #4,r0l
3599 ;;   add.l  er7,er0  (6 bytes)
3600 ;;
3601 ;; into
3602 ;;
3603 ;;   mov.l  er7,er0
3604 ;;   adds   #4,er0   (4 bytes)
3605
3606 (define_peephole2
3607   [(set (match_operand:SI 0 "register_operand" "")
3608         (match_operand:SI 1 "const_int_operand" ""))
3609    (set (match_dup 0)
3610         (plus:SI (match_dup 0)
3611                  (match_operand:SI 2 "register_operand" "")))]
3612   "(TARGET_H8300H || TARGET_H8300S)
3613    && REG_P (operands[0]) && REG_P (operands[2])
3614    && REGNO (operands[0]) != REGNO (operands[2])
3615    && (CONST_OK_FOR_L (INTVAL (operands[1]))
3616        || CONST_OK_FOR_N (INTVAL (operands[1])))"
3617   [(set (match_dup 0)
3618         (match_dup 2))
3619    (set (match_dup 0)
3620         (plus:SI (match_dup 0)
3621                  (match_dup 1)))]
3622   "")
3623
3624 ;; Turn
3625 ;;
3626 ;;   mov.l er7,er0
3627 ;;   add.l #10,er0  (takes 8 bytes)
3628 ;;
3629 ;; into
3630 ;;
3631 ;;   sub.l er0,er0
3632 ;;   add.b #10,r0l
3633 ;;   add.l er7,er0  (takes 6 bytes)
3634
3635 (define_peephole2
3636   [(set (match_operand:SI 0 "register_operand" "")
3637         (match_operand:SI 1 "register_operand" ""))
3638    (set (match_dup 0)
3639         (plus:SI (match_dup 0)
3640                  (match_operand:SI 2 "const_int_operand" "")))]
3641   "(TARGET_H8300H || TARGET_H8300S)
3642    && REG_P (operands[0]) && REG_P (operands[1])
3643    && REGNO (operands[0]) != REGNO (operands[1])
3644    && !CONST_OK_FOR_L (INTVAL (operands[2]))
3645    && !CONST_OK_FOR_N (INTVAL (operands[2]))
3646    && ((INTVAL (operands[2]) & 0xff) == INTVAL (operands[2])
3647        || (INTVAL (operands[2]) & 0xff00) == INTVAL (operands[2])
3648        || INTVAL (operands[2]) == 0xffff
3649        || INTVAL (operands[2]) == 0xfffe)"
3650   [(set (match_dup 0)
3651         (match_dup 2))
3652    (set (match_dup 0)
3653         (plus:SI (match_dup 0)
3654                  (match_dup 1)))]
3655   "")
3656
3657 ;; Turn
3658 ;;
3659 ;;   subs   #1,er4
3660 ;;   mov.w  r4,r4
3661 ;;   bne    .L2028
3662 ;;
3663 ;; into
3664 ;;
3665 ;;   dec.w  #1,r4
3666 ;;   bne    .L2028
3667
3668 (define_peephole2
3669   [(set (match_operand:HI 0 "register_operand" "")
3670         (plus:HI (match_dup 0)
3671                  (match_operand 1 "incdec_operand" "")))
3672    (set (cc0)
3673         (match_dup 0))
3674    (set (pc)
3675         (if_then_else (match_operator 3 "eqne_operator"
3676                         [(cc0) (const_int 0)])
3677                       (label_ref (match_operand 2 "" ""))
3678                       (pc)))]
3679   "TARGET_H8300H || TARGET_H8300S"
3680   [(set (match_operand:HI 0 "register_operand" "")
3681         (unspec:HI [(match_dup 0)
3682                     (match_dup 1)]
3683                    UNSPEC_INCDEC))
3684    (set (cc0)
3685         (match_dup 0))
3686    (set (pc)
3687         (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
3688                       (label_ref (match_dup 2))
3689                       (pc)))]
3690   "")
3691
3692 ;; The SImode version of the previous pattern.
3693
3694 (define_peephole2
3695   [(set (match_operand:SI 0 "register_operand" "")
3696         (plus:SI (match_dup 0)
3697                  (match_operand 1 "incdec_operand" "")))
3698    (set (cc0)
3699         (match_dup 0))
3700    (set (pc)
3701         (if_then_else (match_operator 3 "eqne_operator"
3702                         [(cc0) (const_int 0)])
3703                       (label_ref (match_operand 2 "" ""))
3704                       (pc)))]
3705   "TARGET_H8300H || TARGET_H8300S"
3706   [(set (match_operand:SI 0 "register_operand" "")
3707         (unspec:SI [(match_dup 0)
3708                     (match_dup 1)]
3709                    UNSPEC_INCDEC))
3710    (set (cc0)
3711         (match_dup 0))
3712    (set (pc)
3713         (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
3714                       (label_ref (match_dup 2))
3715                       (pc)))]
3716   "")
3717
3718 (define_peephole2
3719   [(parallel [(set (cc0)
3720                    (zero_extract:SI (match_operand:QI 0 "register_operand" "")
3721                                     (const_int 1)
3722                                     (const_int 7)))
3723               (clobber (scratch:QI))])
3724    (set (pc)
3725         (if_then_else (match_operator 1 "eqne_operator"
3726                         [(cc0) (const_int 0)])
3727                       (label_ref (match_operand 2 "" ""))
3728                       (pc)))]
3729   "(TARGET_H8300H || TARGET_H8300S)"
3730   [(set (cc0)
3731         (match_dup 0))
3732    (set (pc)
3733         (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
3734                       (label_ref (match_dup 2))
3735                       (pc)))]
3736   "operands[3] = ((GET_CODE (operands[1]) == EQ)
3737                   ? gen_rtx_GE (VOIDmode, cc0_rtx, const0_rtx)
3738                   : gen_rtx_LT (VOIDmode, cc0_rtx, const0_rtx));")
3739
3740 (define_peephole2
3741   [(set (match_operand:SI 0 "register_operand" "")
3742         (match_operand:SI 1 "general_operand" ""))
3743    (set (match_dup 0)
3744         (and:SI (match_dup 0)
3745                 (const_int 255)))]
3746   "(TARGET_H8300H || TARGET_H8300S)
3747    && !reg_overlap_mentioned_p (operands[0], operands[1])
3748    && !(GET_CODE (operands[1]) == MEM && MEM_VOLATILE_P (operands[1]))"
3749   [(set (match_dup 0)
3750         (const_int 0))
3751    (set (strict_low_part (match_dup 2))
3752         (match_dup 3))]
3753   "operands[2] = gen_lowpart (QImode, operands[0]);
3754    operands[3] = gen_lowpart (QImode, operands[1]);")
3755
3756 (define_peephole2
3757   [(set (match_operand:SI 0 "register_operand" "")
3758         (match_operand:SI 1 "general_operand" ""))
3759    (set (match_dup 0)
3760         (and:SI (match_dup 0)
3761                 (match_operand:SI 2 "const_int_qi_operand" "")))]
3762   "(TARGET_H8300H || TARGET_H8300S)
3763    && !reg_overlap_mentioned_p (operands[0], operands[1])
3764    && !(GET_CODE (operands[1]) == MEM && MEM_VOLATILE_P (operands[1]))"
3765   [(set (match_dup 0)
3766         (const_int 0))
3767    (set (strict_low_part (match_dup 3))
3768         (match_dup 4))
3769    (set (match_dup 0)
3770         (and:SI (match_dup 0)
3771                 (match_dup 5)))]
3772   "operands[3] = gen_lowpart (QImode, operands[0]);
3773    operands[4] = gen_lowpart (QImode, operands[1]);
3774    operands[5] = GEN_INT (~0xff | INTVAL (operands[2]));")
3775
3776 (define_peephole2
3777   [(set (match_operand:SI 0 "register_operand" "")
3778         (match_operand:SI 1 "memory_operand" ""))
3779    (set (match_dup 0)
3780         (and:SI (match_dup 0)
3781                 (match_operand:SI 2 "const_int_operand" "")))]
3782   "(TARGET_H8300H || TARGET_H8300S)
3783    && !(GET_CODE (operands[1]) == MEM && MEM_VOLATILE_P (operands[1]))
3784    && (INTVAL (operands[2]) & ~0xffff) == 0
3785    && INTVAL (operands[2]) != 255"
3786   [(set (match_dup 3)
3787         (match_dup 4))
3788    (set (match_dup 0)
3789         (and:SI (match_dup 0)
3790                 (match_dup 2)))]
3791   "operands[3] = gen_lowpart (HImode, operands[0]);
3792    operands[4] = gen_lowpart (HImode, operands[1]);")
3793
3794 ;; (compare (reg:SI) (const_int)) takes 6 bytes, so we try to achieve
3795 ;; the equivalent with shorter sequences.  Here is the summary.  Cases
3796 ;; are grouped for each define_peephole2.
3797 ;;
3798 ;; reg  const_int                   use     insn
3799 ;; --------------------------------------------------------
3800 ;; live    -2                       eq/ne   copy and inc.l
3801 ;; live    -1                       eq/ne   copy and inc.l
3802 ;; live     1                       eq/ne   copy and dec.l
3803 ;; live     2                       eq/ne   copy and dec.l
3804 ;;
3805 ;; dead    -2                       eq/ne   inc.l
3806 ;; dead    -1                       eq/ne   inc.l
3807 ;; dead     1                       eq/ne   dec.l
3808 ;; dead     2                       eq/ne   dec.l
3809 ;;
3810 ;; dead -131072                     eq/ne   inc.w and test
3811 ;; dead  -65536                     eq/ne   inc.w and test
3812 ;; dead   65536                     eq/ne   inc.w and test
3813 ;; dead  131072                     eq/ne   inc.w and test
3814 ;;
3815 ;; dead 0x000000?? except 1 and 2   eq/ne   xor.b and test
3816 ;; dead 0x0000??00                  eq/ne   xor.b and test
3817 ;; dead 0x0000ffff                  eq/ne   not.w and test
3818 ;;
3819 ;; dead 0xffffff?? except -1 and -2 eq/ne   xor.b and not.l
3820 ;; dead 0xffff??ff                  eq/ne   xor.b and not.l
3821 ;;
3822 ;; dead     1                       geu/ltu and.b and test
3823 ;; dead     3                       geu/ltu and.b and test
3824 ;; dead     7                       geu/ltu and.b and test
3825 ;; dead    15                       geu/ltu and.b and test
3826 ;; dead    31                       geu/ltu and.b and test
3827 ;; dead    63                       geu/ltu and.b and test
3828 ;; dead   127                       geu/ltu and.b and test
3829 ;; dead   255                       geu/ltu and.b and test
3830 ;;
3831 ;; dead 65535                       geu/ltu mov.w
3832
3833 ;; For a small constant, it is cheaper to actually do the subtraction
3834 ;; and then test the register.
3835
3836 (define_peephole2
3837   [(set (cc0)
3838         (compare (match_operand:HI 0 "register_operand" "")
3839                  (match_operand:HI 1 "incdec_operand" "")))
3840    (set (pc)
3841         (if_then_else (match_operator 3 "eqne_operator"
3842                         [(cc0) (const_int 0)])
3843                       (label_ref (match_operand 2 "" ""))
3844                       (pc)))]
3845   "(TARGET_H8300H || TARGET_H8300S)
3846    && peep2_reg_dead_p (1, operands[0])"
3847   [(set (match_dup 0)
3848         (unspec:HI [(match_dup 0)
3849                     (match_dup 4)]
3850                    UNSPEC_INCDEC))
3851    (set (cc0)
3852         (match_dup 0))
3853    (set (pc)
3854         (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
3855                       (label_ref (match_dup 2))
3856                       (pc)))]
3857   "operands[4] = GEN_INT (- INTVAL (operands[1]));")
3858
3859 ;; The SImode version of the previous pattern.
3860
3861 (define_peephole2
3862   [(set (cc0)
3863         (compare (match_operand:SI 0 "register_operand" "")
3864                  (match_operand:SI 1 "incdec_operand" "")))
3865    (set (pc)
3866         (if_then_else (match_operator 3 "eqne_operator"
3867                         [(cc0) (const_int 0)])
3868                       (label_ref (match_operand 2 "" ""))
3869                       (pc)))]
3870   "(TARGET_H8300H || TARGET_H8300S)
3871    && peep2_reg_dead_p (1, operands[0])"
3872   [(set (match_dup 0)
3873         (unspec:SI [(match_dup 0)
3874                     (match_dup 4)]
3875                    UNSPEC_INCDEC))
3876    (set (cc0)
3877         (match_dup 0))
3878    (set (pc)
3879         (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
3880                       (label_ref (match_dup 2))
3881                       (pc)))]
3882   "operands[4] = GEN_INT (- INTVAL (operands[1]));")
3883
3884 (define_peephole2
3885   [(set (cc0)
3886         (compare (match_operand:SI 0 "register_operand" "")
3887                  (match_operand:SI 1 "const_int_operand" "")))
3888    (set (pc)
3889         (if_then_else (match_operator 3 "eqne_operator"
3890                         [(cc0) (const_int 0)])
3891                       (label_ref (match_operand 2 "" ""))
3892                       (pc)))]
3893   "(TARGET_H8300H || TARGET_H8300S)
3894    && peep2_reg_dead_p (1, operands[0])
3895    && (INTVAL (operands[1]) == -131072
3896        || INTVAL (operands[1]) == -65536
3897        || INTVAL (operands[1]) == 65536
3898        || INTVAL (operands[1]) == 131072)"
3899   [(set (match_dup 0)
3900         (plus:SI (match_dup 0)
3901                  (match_dup 4)))
3902    (set (cc0)
3903         (match_dup 0))
3904    (set (pc)
3905         (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
3906                       (label_ref (match_dup 2))
3907                       (pc)))]
3908   "operands[4] = GEN_INT (- INTVAL (operands[1]));")
3909
3910 ;; For certain (in)equaltity comparisions against a constant, we can
3911 ;; XOR the register with the constant, and test the register against
3912 ;; 0.
3913
3914 (define_peephole2
3915   [(set (cc0)
3916         (compare (match_operand:SI 0 "register_operand" "")
3917                  (match_operand:SI 1 "const_int_operand" "")))
3918    (set (pc)
3919         (if_then_else (match_operator 3 "eqne_operator"
3920                         [(cc0) (const_int 0)])
3921                       (label_ref (match_operand 2 "" ""))
3922                       (pc)))]
3923   "(TARGET_H8300H || TARGET_H8300S)
3924    && peep2_reg_dead_p (1, operands[0])
3925    && ((INTVAL (operands[1]) & 0x00ff) == INTVAL (operands[1])
3926        || (INTVAL (operands[1]) & 0xff00) == INTVAL (operands[1])
3927        || INTVAL (operands[1]) == 0x0000ffff)
3928    && INTVAL (operands[1]) != 1
3929    && INTVAL (operands[1]) != 2"
3930   [(set (match_dup 0)
3931         (xor:SI (match_dup 0)
3932                 (match_dup 1)))
3933    (set (cc0)
3934         (match_dup 0))
3935    (set (pc)
3936         (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
3937                       (label_ref (match_dup 2))
3938                       (pc)))]
3939   "")
3940
3941 (define_peephole2
3942   [(set (cc0)
3943         (compare (match_operand:SI 0 "register_operand" "")
3944                  (match_operand:SI 1 "const_int_operand" "")))
3945    (set (pc)
3946         (if_then_else (match_operator 3 "eqne_operator"
3947                         [(cc0) (const_int 0)])
3948                       (label_ref (match_operand 2 "" ""))
3949                       (pc)))]
3950   "(TARGET_H8300H || TARGET_H8300S)
3951    && peep2_reg_dead_p (1, operands[0])
3952    && ((INTVAL (operands[1]) | 0x00ff) == -1
3953         || (INTVAL (operands[1]) | 0xff00) == -1)
3954    && INTVAL (operands[1]) != -1
3955    && INTVAL (operands[1]) != -2"
3956   [(set (match_dup 0)
3957         (xor:SI (match_dup 0)
3958                 (match_dup 4)))
3959    (set (match_dup 0)
3960         (not:SI (match_dup 0)))
3961    (set (cc0)
3962         (match_dup 0))
3963    (set (pc)
3964         (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
3965                       (label_ref (match_dup 2))
3966                       (pc)))]
3967   "operands[4] = GEN_INT (INTVAL (operands[1]) ^ -1);")
3968
3969 ;; Transform A <= 1 to (A & 0xfffffffe) == 0.
3970
3971 (define_peephole2
3972   [(set (cc0)
3973         (compare (match_operand:SI 0 "register_operand" "")
3974                  (match_operand:SI 1 "const_int_operand" "")))
3975    (set (pc)
3976         (if_then_else (match_operator 2 "gtuleu_operator"
3977                         [(cc0) (const_int 0)])
3978                       (label_ref (match_operand 3 "" ""))
3979                       (pc)))]
3980   "(TARGET_H8300H || TARGET_H8300S)
3981    && peep2_reg_dead_p (1, operands[0])
3982    && (INTVAL (operands[1]) == 1
3983        || INTVAL (operands[1]) == 3
3984        || INTVAL (operands[1]) == 7
3985        || INTVAL (operands[1]) == 15
3986        || INTVAL (operands[1]) == 31
3987        || INTVAL (operands[1]) == 63
3988        || INTVAL (operands[1]) == 127
3989        || INTVAL (operands[1]) == 255)"
3990   [(set (match_dup 0)
3991         (and:SI (match_dup 0)
3992                 (match_dup 5)))
3993    (set (cc0)
3994         (match_dup 0))
3995    (set (pc)
3996         (if_then_else (match_dup 4)
3997                       (label_ref (match_dup 3))
3998                       (pc)))]
3999   "operands[4] = ((GET_CODE (operands[2]) == GTU) ?
4000                   gen_rtx_NE (VOIDmode, cc0_rtx, const0_rtx) :
4001                   gen_rtx_EQ (VOIDmode, cc0_rtx, const0_rtx));
4002    operands[5] = GEN_INT (~INTVAL (operands[1]));")
4003
4004 ;; Transform A <= 255 to (A & 0xff00) == 0.
4005
4006 (define_peephole2
4007   [(set (cc0)
4008         (compare (match_operand:HI 0 "register_operand" "")
4009                  (const_int 255)))
4010    (set (pc)
4011         (if_then_else (match_operator 1 "gtuleu_operator"
4012                         [(cc0) (const_int 0)])
4013                       (label_ref (match_operand 2 "" ""))
4014                       (pc)))]
4015   "TARGET_H8300H || TARGET_H8300S"
4016   [(set (cc0)
4017         (and:HI (match_dup 0)
4018                 (const_int -256)))
4019    (set (pc)
4020         (if_then_else (match_dup 4)
4021                       (label_ref (match_dup 2))
4022                       (pc)))]
4023   "operands[4] = ((GET_CODE (operands[1]) == GTU) ?
4024                   gen_rtx_NE (VOIDmode, cc0_rtx, const0_rtx) :
4025                   gen_rtx_EQ (VOIDmode, cc0_rtx, const0_rtx));")
4026
4027 ;; Transform A <= 65535 to (A & 0xffff0000) == 0.
4028
4029 (define_peephole2
4030   [(set (cc0)
4031         (compare (match_operand:SI 0 "register_operand" "")
4032                  (const_int 65535)))
4033    (set (pc)
4034         (if_then_else (match_operator 1 "gtuleu_operator"
4035                         [(cc0) (const_int 0)])
4036                       (label_ref (match_operand 2 "" ""))
4037                       (pc)))]
4038   "TARGET_H8300H || TARGET_H8300S"
4039   [(set (cc0)
4040         (and:SI (match_dup 0)
4041                 (const_int -65536)))
4042    (set (pc)
4043         (if_then_else (match_dup 4)
4044                       (label_ref (match_dup 2))
4045                       (pc)))]
4046   "operands[4] = ((GET_CODE (operands[1]) == GTU) ?
4047                   gen_rtx_NE (VOIDmode, cc0_rtx, const0_rtx) :
4048                   gen_rtx_EQ (VOIDmode, cc0_rtx, const0_rtx));")
4049
4050 ;; For constants like -1, -2, 1, 2, it is still cheaper to make a copy
4051 ;; of the register being tested, do the subtraction on the copy, and
4052 ;; then test the copy.  We avoid this transformation if we see more
4053 ;; than one copy of the same compare insn.
4054
4055 (define_peephole2
4056   [(match_scratch:SI 4 "r")
4057    (set (cc0)
4058         (compare (match_operand:SI 0 "register_operand" "")
4059                  (match_operand:SI 1 "incdec_operand" "")))
4060    (set (pc)
4061         (if_then_else (match_operator 3 "eqne_operator"
4062                         [(cc0) (const_int 0)])
4063                       (label_ref (match_operand 2 "" ""))
4064                       (pc)))]
4065   "(TARGET_H8300H || TARGET_H8300S)
4066    && !peep2_reg_dead_p (1, operands[0])
4067    && !rtx_equal_p (PATTERN (insn),
4068                     PATTERN (next_nonnote_insn (next_nonnote_insn (insn))))"
4069   [(set (match_dup 4)
4070         (match_dup 0))
4071    (set (match_dup 4)
4072         (unspec:SI [(match_dup 4)
4073                     (match_dup 5)]
4074                    UNSPEC_INCDEC))
4075    (set (cc0)
4076         (match_dup 4))
4077    (set (pc)
4078         (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
4079                       (label_ref (match_dup 2))
4080                       (pc)))]
4081   "operands[5] = GEN_INT (- INTVAL (operands[1]));")
4082
4083 ;; Narrow the mode of testing if possible.
4084
4085 (define_peephole2
4086   [(set (match_operand:HI 0 "register_operand" "")
4087         (and:HI (match_dup 0)
4088                 (match_operand:HI 1 "const_int_qi_operand" "")))
4089    (set (cc0)
4090         (match_dup 0))
4091    (set (pc)
4092         (if_then_else (match_operator 3 "eqne_operator"
4093                         [(cc0) (const_int 0)])
4094                       (label_ref (match_operand 2 "" ""))
4095                       (pc)))]
4096   "peep2_reg_dead_p (2, operands[0])"
4097   [(set (match_dup 4)
4098         (and:QI (match_dup 4)
4099                 (match_dup 5)))
4100    (set (cc0)
4101         (match_dup 4))
4102    (set (pc)
4103         (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
4104                       (label_ref (match_dup 2))
4105                       (pc)))]
4106   "operands[4] = gen_rtx_REG (QImode, REGNO (operands[0]));
4107    operands[5] = GEN_INT (trunc_int_for_mode (INTVAL (operands[1]), QImode));")
4108
4109 (define_peephole2
4110   [(set (match_operand:SI 0 "register_operand" "")
4111         (and:SI (match_dup 0)
4112                 (match_operand:SI 1 "const_int_qi_operand" "")))
4113    (set (cc0)
4114         (match_dup 0))
4115    (set (pc)
4116         (if_then_else (match_operator 3 "eqne_operator"
4117                         [(cc0) (const_int 0)])
4118                       (label_ref (match_operand 2 "" ""))
4119                       (pc)))]
4120   "peep2_reg_dead_p (2, operands[0])"
4121   [(set (match_dup 4)
4122         (and:QI (match_dup 4)
4123                 (match_dup 5)))
4124    (set (cc0)
4125         (match_dup 4))
4126    (set (pc)
4127         (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
4128                       (label_ref (match_dup 2))
4129                       (pc)))]
4130   "operands[4] = gen_rtx_REG (QImode, REGNO (operands[0]));
4131    operands[5] = GEN_INT (trunc_int_for_mode (INTVAL (operands[1]), QImode));")
4132
4133 (define_peephole2
4134   [(set (match_operand:SI 0 "register_operand" "")
4135         (and:SI (match_dup 0)
4136                 (match_operand:SI 1 "const_int_hi_operand" "")))
4137    (set (cc0)
4138         (match_dup 0))
4139    (set (pc)
4140         (if_then_else (match_operator 3 "eqne_operator"
4141                         [(cc0) (const_int 0)])
4142                       (label_ref (match_operand 2 "" ""))
4143                       (pc)))]
4144   "peep2_reg_dead_p (2, operands[0])"
4145   [(set (match_dup 4)
4146         (and:HI (match_dup 4)
4147                 (match_dup 5)))
4148    (set (cc0)
4149         (match_dup 4))
4150    (set (pc)
4151         (if_then_else (match_op_dup 3 [(cc0) (const_int 0)])
4152                       (label_ref (match_dup 2))
4153                       (pc)))]
4154   "operands[4] = gen_rtx_REG (HImode, REGNO (operands[0]));
4155    operands[5] = GEN_INT (trunc_int_for_mode (INTVAL (operands[1]), HImode));")
4156
4157 (define_peephole2
4158   [(set (match_operand:SI 0 "register_operand" "")
4159         (and:SI (match_dup 0)
4160                 (match_operand:SI 1 "const_int_qi_operand" "")))
4161    (set (match_dup 0)
4162         (xor:SI (match_dup 0)
4163                 (match_operand:SI 2 "const_int_qi_operand" "")))
4164    (set (cc0)
4165         (match_dup 0))
4166    (set (pc)
4167         (if_then_else (match_operator 4 "eqne_operator"
4168                         [(cc0) (const_int 0)])
4169                       (label_ref (match_operand 3 "" ""))
4170                       (pc)))]
4171   "peep2_reg_dead_p (3, operands[0])
4172    && (~INTVAL (operands[1]) & INTVAL (operands[2])) == 0"
4173   [(set (match_dup 5)
4174         (and:QI (match_dup 5)
4175                 (match_dup 6)))
4176    (set (match_dup 5)
4177         (xor:QI (match_dup 5)
4178                 (match_dup 7)))
4179    (set (cc0)
4180         (match_dup 5))
4181    (set (pc)
4182         (if_then_else (match_op_dup 4 [(cc0) (const_int 0)])
4183                       (label_ref (match_dup 3))
4184                       (pc)))]
4185   "operands[5] = gen_rtx_REG (QImode, REGNO (operands[0]));
4186    operands[6] = GEN_INT (trunc_int_for_mode (INTVAL (operands[1]), QImode));
4187    operands[7] = GEN_INT (trunc_int_for_mode (INTVAL (operands[2]), QImode));")