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 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 GNU CC.
   9
  10 ;; GNU CC 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 ;; GNU CC 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 GNU CC; 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 ;; The original PO technology requires these to be ordered by speed,
  26 ;; so that assigner will pick the fastest.
  27
  28 ;; See file "rtl.def" for documentation on define_insn, match_*, et. al.
  29
  30 (define_attr "cpu" "h8300,h8300h"
  31   (const (symbol_ref "cpu_type")))
  32
  33 ;; Many logical operations should have "bit" variants if only one
  34 ;; bit is going to be operated on.
  35
  36 ;; (and (logical op) (const_int X))
  37 ;; If const_int only specifies a few bits (like a single byte in a 4 byte
  38 ;; operation, then it's more efficient to only apply the and and logical_op
  39 ;; to the bits we care about.
  40
  41 ;; Some of the extend instructions accept a general_operand_src, which
  42 ;; allows all the normal memory addressing modes.  The length computations
  43 ;; don't take this into account.  The lengths in the MD file should be
  44 ;; "worst case" and then be adjusted to their correct values by
  45 ;; h8300_adjust_insn_length.
  46
  47 ;; On the h8300h, adds/subs operate on the 32bit "er" registers.  Right
  48 ;; now GCC doesn't expose the "e" half to the compiler, so using add/subs
  49 ;; for addhi and subhi is safe.
  50 ;; Long term, we want to expose the "e" half to the compiler (gives us
  51 ;; 8 more 16bit registers).  At that point addhi and subhi can't use adds/subs.
  52
  53 ;; There's currently no way to have a insv/extzv expander for the H8/300H
  54 ;; because word_mode is different for the H8/300 and H8/300H.
  55
  56 ;; Shifts/rotates by small constants should be handled by special
  57 ;; patterns so we get the length and cc status correct.
  58
  59 ;; Bitfield operations no longer accept memory operands.  We need
  60 ;; to add variants which operate on memory back to the MD.
  61
  62 ;; ??? Implement remaining bit ops available on the h8300
  63
  64 (define_attr "type" "branch,arith"
  65   (const_string "arith"))
  66
  67 ;; The size of instructions in bytes.
  68
  69 (define_attr "length" ""
  70   (cond [(eq_attr "type" "branch")
  71          (if_then_else (and (ge (minus (pc) (match_dup 0))
  72                                 (const_int -120))
  73                             (le (minus (pc) (match_dup 0))
  74                                 (const_int 120)))
  75                        (const_int 2)
  76                        (if_then_else (and (eq_attr "cpu" "h8300h")
  77                                           (and (ge (minus (pc) (match_dup 0))
  78                                                    (const_int -32000))
  79                                                (le (minus (pc) (match_dup 0))
  80                                                    (const_int 32000))))
  81                                      (const_int 4)
  82                                      (const_int 6)))]
  83         (const_int 200)))
  84
  85 ;; The necessity of instruction length adjustment.
  86
  87 (define_attr "adjust_length" "yes,no"
  88   (cond [(eq_attr "type" "branch") (const_string "no")]
  89         (const_string "yes")))
  90
  91 ;; Condition code settings.
  92 ;; none - insn does not affect cc
  93 ;; none_0hit - insn does not affect cc but it does modify operand 0
  94 ;;      This attribute is used to keep track of when operand 0 changes.
  95 ;;      See the description of NOTICE_UPDATE_CC for more info.
  96 ;; set_znv - insn sets z,n,v to usable values (like a tst insn); c is unknown.
  97 ;; set_zn  - insn sets z,n to usable values; v,c are unknown.
  98 ;; compare - compare instruction
  99 ;; clobber - value of cc is unknown
 100 (define_attr "cc" "none,none_0hit,set_znv,set_zn,compare,clobber"
 101   (const_string "clobber"))
 102 \f
 103 ;; ----------------------------------------------------------------------
 104 ;; MOVE INSTRUCTIONS
 105 ;; ----------------------------------------------------------------------
 106
 107 ;; movqi
 108
 109 (define_insn "pushqi1_h8300"
 110   [(parallel [(set (reg:HI 7)
 111                    (plus:HI (reg:HI 7) (const_int -2)))
 112               (set (mem:QI (plus:HI (reg:HI 7) (const_int -1)))
 113                    (match_operand:QI 0 "register_operand" "r"))])]
 114   "TARGET_H8300"
 115   "mov.w       %T0,@-r7"
 116   [(set_attr "length" "2")
 117    (set_attr "cc" "clobber")])
 118
 119 (define_insn "pushqi1_h8300hs"
 120   [(parallel [(set (reg:SI 7)
 121                    (plus:SI (reg:SI 7) (const_int -4)))
 122               (set (mem:QI (plus:SI (reg:SI 7) (const_int -3)))
 123                    (match_operand:QI 0 "register_operand" "r"))])]
 124   "TARGET_H8300H || TARGET_H8300S"
 125   "mov.l       %S0,@-er7"
 126   [(set_attr "length" "4")
 127    (set_attr "cc" "clobber")])
 128
 129 (define_expand "pushqi1"
 130   [(use (match_operand:QI 0 "register_operand" "r"))]
 131   ""
 132   "
 133 {
 134   if (TARGET_H8300)
 135     emit_insn (gen_pushqi1_h8300 (operands[0]));
 136   else
 137     emit_insn (gen_pushqi1_h8300hs (operands[0]));
 138   DONE;
 139 }")
 140
 141 (define_insn ""
 142   [(set (match_operand:QI 0 "general_operand_dst" "=r,r ,<,r,r,m")
 143         (match_operand:QI 1 "general_operand_src" " I,r>,r,n,m,r"))]
 144   "TARGET_H8300
 145    && (register_operand (operands[0], QImode)
 146        || register_operand (operands[1], QImode))"
 147   "@
 148    sub.b        %X0,%X0
 149    mov.b        %R1,%X0
 150    mov.b        %X1,%R0
 151    mov.b        %R1,%X0
 152    mov.b        %R1,%X0
 153    mov.b        %X1,%R0"
 154   [(set_attr "length" "2,2,2,2,4,4")
 155    (set_attr "cc" "set_zn,set_znv,set_znv,set_znv,set_znv,set_znv")])
 156
 157 (define_insn ""
 158   [(set (match_operand:QI 0 "general_operand_dst" "=r,r ,<,r,r,m")
 159         (match_operand:QI 1 "general_operand_src" " I,r>,r,n,m,r"))]
 160   "(TARGET_H8300H || TARGET_H8300S)
 161    && (register_operand (operands[0], QImode)
 162        || register_operand (operands[1], QImode))"
 163   "@
 164    sub.b        %X0,%X0
 165    mov.b        %R1,%X0
 166    mov.b        %X1,%R0
 167    mov.b        %R1,%X0
 168    mov.b        %R1,%X0
 169    mov.b        %X1,%R0"
 170   [(set_attr "length" "2,2,2,2,8,8")
 171    (set_attr "cc" "set_zn,set_znv,set_znv,clobber,set_znv,set_znv")])
 172
 173 (define_expand "movqi"
 174   [(set (match_operand:QI 0 "general_operand_dst" "")
 175         (match_operand:QI 1 "general_operand_src" ""))]
 176   ""
 177   "
 178 {
 179   /* One of the ops has to be in a register.  */
 180   if (!register_operand (operand0, QImode)
 181       && !register_operand (operand1, QImode))
 182     {
 183       operands[1] = copy_to_mode_reg (QImode, operand1);
 184     }
 185 }")
 186
 187 (define_insn "movstrictqi"
 188   [(set (strict_low_part (match_operand:QI 0 "general_operand_dst" "+r,r,r,r"))
 189                          (match_operand:QI 1 "general_operand_src" "I,r,n,m"))]
 190   ""
 191   "@
 192    sub.b        %X0,%X0
 193    mov.b        %X1,%X0
 194    mov.b        %R1,%X0
 195    mov.b        %R1,%X0"
 196   [(set_attr_alternative "length"
 197      [(const_int 2) (const_int 2) (const_int 2)
 198       (if_then_else (eq_attr "cpu" "h8300") (const_int 4) (const_int 8))])
 199    (set_attr "cc" "set_zn,set_znv,set_znv,set_znv")])
 200
 201 ;; movhi
 202
 203 (define_expand "pushhi1_h8300"
 204   [(set (mem:QI (pre_dec:HI (reg:HI 7)))
 205         (match_operand:QI 0 "register_operand" "r"))]
 206   "TARGET_H8300"
 207   "")
 208
 209 (define_insn "pushhi1_h8300hs"
 210   [(parallel [(set (reg:SI 7)
 211                    (plus:SI (reg:SI 7) (const_int -4)))
 212               (set (mem:HI (plus:SI (reg:SI 7) (const_int -2)))
 213                    (match_operand:HI 0 "register_operand" "r"))])]
 214   "TARGET_H8300H || TARGET_H8300S"
 215   "mov.l       %S0,@-er7"
 216   [(set_attr "length" "4")
 217    (set_attr "cc" "clobber")])
 218
 219 (define_expand "pushhi1"
 220   [(use (match_operand:QI 0 "register_operand" "r"))]
 221   ""
 222   "
 223 {
 224   if (TARGET_H8300)
 225     emit_insn (gen_pushhi1_h8300 (operands[0]));
 226   else
 227     emit_insn (gen_pushhi1_h8300hs (operands[0]));
 228   DONE;
 229 }")
 230
 231 (define_insn ""
 232   [(set (match_operand:HI 0 "general_operand_dst" "=r,r,<,r,r,m")
 233         (match_operand:HI 1 "general_operand_src" "I,r>,r,i,m,r"))]
 234   "TARGET_H8300
 235    && (register_operand (operands[0], HImode)
 236        || register_operand (operands[1], HImode))
 237    && !(GET_CODE (operands[0]) == MEM
 238         && GET_CODE (XEXP (operands[0], 0)) == PRE_DEC
 239         && GET_CODE (XEXP (XEXP (operands[0], 0), 0)) == REG
 240         && GET_CODE (operands[1]) == REG
 241         && REGNO (XEXP (XEXP (operands[0], 0), 0)) == REGNO (operands[1]))"
 242   "@
 243    sub.w        %T0,%T0
 244    mov.w        %T1,%T0
 245    mov.w        %T1,%T0
 246    mov.w        %T1,%T0
 247    mov.w        %T1,%T0
 248    mov.w        %T1,%T0"
 249   [(set_attr "length" "2,2,2,4,4,4")
 250    (set_attr "cc" "set_zn,set_znv,set_znv,set_znv,set_znv,set_znv")])
 251
 252 (define_insn ""
 253   [(set (match_operand:HI 0 "general_operand_dst" "=r,r,<,r,r,m")
 254         (match_operand:HI 1 "general_operand_src" "I,r>,r,i,m,r"))]
 255   "(TARGET_H8300H || TARGET_H8300S)
 256    && (register_operand (operands[0], HImode)
 257        || register_operand (operands[1], HImode))"
 258   "@
 259    sub.w        %T0,%T0
 260    mov.w        %T1,%T0
 261    mov.w        %T1,%T0
 262    mov.w        %T1,%T0
 263    mov.w        %T1,%T0
 264    mov.w        %T1,%T0"
 265   [(set_attr "length" "2,2,2,4,8,8")
 266    (set_attr "cc" "set_zn,set_znv,set_znv,set_znv,set_znv,set_znv")])
 267
 268 (define_expand "movhi"
 269   [(set (match_operand:HI 0 "general_operand_dst" "")
 270         (match_operand:HI 1 "general_operand_src" ""))]
 271   ""
 272   "
 273 {
 274   /* One of the ops has to be in a register.  */
 275   if (!register_operand (operand1, HImode)
 276       && !register_operand (operand0, HImode))
 277     {
 278       operands[1] = copy_to_mode_reg (HImode, operand1);
 279     }
 280 }")
 281
 282 (define_insn "movstricthi"
 283   [(set (strict_low_part (match_operand:HI 0 "general_operand_dst" "+r,r,r,r"))
 284                          (match_operand:HI 1 "general_operand_src" "I,r,i,m"))]
 285   ""
 286   "@
 287    sub.w        %T0,%T0
 288    mov.w        %T1,%T0
 289    mov.w        %T1,%T0
 290    mov.w        %T1,%T0"
 291   [(set_attr_alternative "length"
 292      [(const_int 2) (const_int 2) (const_int 4)
 293       (if_then_else (eq_attr "cpu" "h8300") (const_int 4) (const_int 8))])
 294    (set_attr "cc" "set_zn,set_znv,set_znv,set_znv")])
 295
 296 ;; movsi
 297
 298 (define_expand "movsi"
 299   [(set (match_operand:SI 0 "general_operand_dst" "")
 300         (match_operand:SI 1 "general_operand_src" ""))]
 301   ""
 302   "
 303 {
 304   if (TARGET_H8300)
 305     {
 306       if (do_movsi (operands))
 307         DONE;
 308     }
 309   else
 310     {
 311       /* One of the ops has to be in a register.  */
 312       if (!register_operand (operand1, SImode)
 313           && !register_operand (operand0, SImode))
 314         {
 315           operands[1] = copy_to_mode_reg (SImode, operand1);
 316         }
 317     }
 318 }")
 319
 320 (define_expand "movsf"
 321   [(set (match_operand:SF 0 "general_operand_dst" "")
 322         (match_operand:SF 1 "general_operand_src" ""))]
 323   ""
 324   "
 325 {
 326   if (TARGET_H8300)
 327     {
 328       if (do_movsi (operands))
 329         DONE;
 330     }
 331   else
 332     {
 333       /* One of the ops has to be in a register.  */
 334       if (!register_operand (operand1, SFmode)
 335           && !register_operand (operand0, SFmode))
 336         {
 337           operands[1] = copy_to_mode_reg (SFmode, operand1);
 338         }
 339     }
 340 }")
 341
 342 (define_insn "movsi_h8300"
 343   [(set (match_operand:SI 0 "general_operand_dst" "=r,r,r,o,<,r")
 344         (match_operand:SI 1 "general_operand_src" "I,r,io,r,r,>"))]
 345   "TARGET_H8300
 346    && (register_operand (operands[0], SImode)
 347        || register_operand (operands[1], SImode))"
 348   "*
 349 {
 350   int rn = -1;
 351   switch (which_alternative)
 352     {
 353     case 0:
 354       return \"sub.w    %e0,%e0\;sub.w  %f0,%f0\";
 355     case 1:
 356       if (REGNO (operands[0]) < REGNO (operands[1]))
 357         return \"mov.w  %e1,%e0\;mov.w  %f1,%f0\";
 358       else
 359         return \"mov.w  %f1,%f0\;mov.w  %e1,%e0\";
 360     case 2:
 361       /* Make sure we don't trample the register we index with.  */
 362       if (GET_CODE (operands[1]) == MEM)
 363         {
 364           rtx inside = XEXP (operands[1], 0);
 365           if (REG_P (inside))
 366             {
 367               rn = REGNO (inside);
 368             }
 369           else if (GET_CODE (inside) == PLUS)
 370             {
 371               rtx lhs = XEXP (inside, 0);
 372               rtx rhs = XEXP (inside, 1);
 373               if (REG_P (lhs)) rn = REGNO (lhs);
 374               if (REG_P (rhs)) rn = REGNO (rhs);
 375             }
 376         }
 377       if (rn == REGNO (operands[0]))
 378         {
 379           /* Move the second word first.  */
 380           return \"mov.w        %f1,%f0\;mov.w  %e1,%e0\";
 381         }
 382       else
 383         {
 384           /* See if either half is zero.  If so, use sub.w to clear
 385              that half.  */
 386           if (GET_CODE (operands[1]) == CONST_INT)
 387             {
 388               if ((INTVAL (operands[1]) & 0xffff) == 0)
 389                 return \"mov.w  %e1,%e0\;sub.w  %f0,%f0\";
 390               if (((INTVAL (operands[1]) >> 16) & 0xffff) == 0)
 391                 return \"sub.w  %e0,%e0\;mov.w  %f1,%f0\";
 392             }
 393           return \"mov.w        %e1,%e0\;mov.w  %f1,%f0\";
 394         }
 395     case 3:
 396       return \"mov.w    %e1,%e0\;mov.w  %f1,%f0\";
 397     case 4:
 398       return \"mov.w    %f1,%T0\;mov.w  %e1,%T0\";
 399     case 5:
 400       return \"mov.w    %T1,%e0\;mov.w  %T1,%f0\";
 401     default:
 402       abort();
 403     }
 404 }"
 405   [(set_attr "length" "4,4,8,8,4,4")
 406    (set_attr "cc" "clobber")])
 407
 408 (define_insn "movsf_h8300"
 409   [(set (match_operand:SF 0 "general_operand_dst" "=r,r,r,o,<,r")
 410         (match_operand:SF 1 "general_operand_src" "I,r,io,r,r,>"))]
 411   "TARGET_H8300
 412    && (register_operand (operands[0], SFmode)
 413        || register_operand (operands[1], SFmode))"
 414   "*
 415 {
 416   /* Copy of the movsi stuff.  */
 417   int rn = -1;
 418   switch (which_alternative)
 419     {
 420     case 0:
 421       return \"sub.w    %e0,%e0\;sub.w  %f0,%f0\";
 422     case 1:
 423       if (REGNO (operands[0]) < REGNO (operands[1]))
 424         return \"mov.w  %e1,%e0\;mov.w  %f1,%f0\";
 425       else
 426         return \"mov.w  %f1,%f0\;mov.w  %e1,%e0\";
 427     case 2:
 428       /* Make sure we don't trample the register we index with.  */
 429       if (GET_CODE (operands[1]) == MEM)
 430         {
 431           rtx inside = XEXP (operands[1], 0);
 432           if (REG_P (inside))
 433             {
 434               rn = REGNO (inside);
 435             }
 436           else if (GET_CODE (inside) == PLUS)
 437             {
 438               rtx lhs = XEXP (inside, 0);
 439               rtx rhs = XEXP (inside, 1);
 440               if (REG_P (lhs)) rn = REGNO (lhs);
 441               if (REG_P (rhs)) rn = REGNO (rhs);
 442             }
 443         }
 444       if (rn == REGNO (operands[0]))
 445         /* Move the second word first.  */
 446         return \"mov.w  %f1,%f0\;mov.w  %e1,%e0\";
 447       else
 448         /* Move the first word first.  */
 449         return \"mov.w  %e1,%e0\;mov.w  %f1,%f0\";
 450
 451     case 3:
 452       return \"mov.w    %e1,%e0\;mov.w  %f1,%f0\";
 453     case 4:
 454       return \"mov.w    %f1,%T0\;mov.w  %e1,%T0\";
 455     case 5:
 456       return \"mov.w    %T1,%e0\;mov.w  %T1,%f0\";
 457     default:
 458       abort();
 459     }
 460 }"
 461   [(set_attr "length" "4,4,8,8,4,4")
 462    (set_attr "cc" "clobber")])
 463
 464 (define_insn "movsi_h8300hs"
 465   [(set (match_operand:SI 0 "general_operand_dst" "=r,r,r,r,m,<,r,*a,*a,r")
 466         (match_operand:SI 1 "general_operand_src" "I,r,i,m,r,r,>,I,r,*a"))]
 467   "(TARGET_H8300S || TARGET_H8300H)
 468    && (register_operand (operands[0], SImode)
 469        || register_operand (operands[1], SImode))
 470    && !(GET_CODE (operands[0]) == MEM
 471         && GET_CODE (XEXP (operands[0], 0)) == PRE_DEC
 472         && GET_CODE (XEXP (XEXP (operands[0], 0), 0)) == REG
 473         && GET_CODE (operands[1]) == REG
 474         && REGNO (XEXP (XEXP (operands[0], 0), 0)) == REGNO (operands[1]))"
 475   "*
 476 {
 477   switch (which_alternative)
 478     {
 479     case 0:
 480       return \"sub.l    %S0,%S0\";
 481     case 7:
 482       return \"clrmac\";
 483     case 8:
 484       return \"clrmac\;ldmac %1,macl\";
 485     case 9:
 486       return \"stmac    macl,%0\";
 487     default:
 488       if (GET_CODE (operands[1]) == CONST_INT)
 489         {
 490           int val = INTVAL (operands[1]);
 491
 492           /* Look for constants which can be made by adding an 8-bit
 493              number to zero in one of the two low bytes.  */
 494           if (val == (val & 0xff))
 495             {
 496               operands[1] = GEN_INT ((char) val & 0xff);
 497               return \"sub.l\\t%S0,%S0\;add.b\\t%1,%w0\";
 498             }
 499
 500           if (val == (val & 0xff00))
 501             {
 502               operands[1] = GEN_INT ((char) (val >> 8) & 0xff);
 503               return \"sub.l\\t%S0,%S0\;add.b\\t%1,%x0\";
 504             }
 505
 506           /* Look for constants that can be obtained by subs, inc, and
 507              dec to 0.  */
 508           switch (val & 0xffffffff)
 509             {
 510             case 0xffffffff:
 511               return \"sub.l\\t%S0,%S0\;subs\\t#1,%S0\";
 512             case 0xfffffffe:
 513               return \"sub.l\\t%S0,%S0\;subs\\t#2,%S0\";
 514             case 0xfffffffc:
 515               return \"sub.l\\t%S0,%S0\;subs\\t#4,%S0\";
 516
 517             case 0x0000ffff:
 518               return \"sub.l\\t%S0,%S0\;dec.w\\t#1,%f0\";
 519             case 0x0000fffe:
 520               return \"sub.l\\t%S0,%S0\;dec.w\\t#2,%f0\";
 521
 522             case 0xffff0000:
 523               return \"sub.l\\t%S0,%S0\;dec.w\\t#1,%e0\";
 524             case 0xfffe0000:
 525               return \"sub.l\\t%S0,%S0\;dec.w\\t#2,%e0\";
 526
 527             case 0x00010000:
 528               return \"sub.l\\t%S0,%S0\;inc.w\\t#1,%e0\";
 529             case 0x00020000:
 530               return \"sub.l\\t%S0,%S0\;inc.w\\t#2,%e0\";
 531             }
 532         }
 533     }
 534    return \"mov.l       %S1,%S0\";
 535 }"
 536   [(set_attr "length" "2,2,10,10,10,4,4,2,6,4")
 537    (set_attr "cc" "set_zn,set_znv,clobber,set_znv,set_znv,set_znv,set_znv,none_0hit,none_0hit,set_znv")])
 538
 539 (define_insn "movsf_h8300h"
 540   [(set (match_operand:SF 0 "general_operand_dst" "=r,r,r,m,<,r")
 541         (match_operand:SF 1 "general_operand_src" "I,r,im,r,r,>"))]
 542   "(TARGET_H8300H || TARGET_H8300S)
 543    && (register_operand (operands[0], SFmode)
 544        || register_operand (operands[1], SFmode))"
 545   "@
 546    sub.l        %S0,%S0
 547    mov.l        %S1,%S0
 548    mov.l        %S1,%S0
 549    mov.l        %S1,%S0
 550    mov.l        %S1,%S0
 551    mov.l        %S1,%S0"
 552   [(set_attr "length" "2,2,10,10,4,4")
 553    (set_attr "cc" "set_zn,set_znv,set_znv,set_znv,set_znv,set_znv")])
 554 \f
 555 ;; ----------------------------------------------------------------------
 556 ;; TEST INSTRUCTIONS
 557 ;; ----------------------------------------------------------------------
 558
 559 (define_insn ""
 560   [(set (cc0) (zero_extract:QI (match_operand:QI 0 "bit_memory_operand" "r,U")
 561                                (const_int 1)
 562                                (match_operand:QI 1 "const_int_operand" "n,n")))]
 563   ""
 564   "btst %Z1,%R0"
 565   [(set_attr "length" "2,8")
 566    (set_attr "cc" "set_zn,set_zn")])
 567
 568 (define_insn ""
 569   [(set (cc0) (zero_extract:HI (match_operand:QI 0 "bit_memory_operand" "r,U")
 570                                (const_int 1)
 571                                (match_operand:QI 1 "const_int_operand" "n,n")))]
 572   ""
 573   "btst %Z1,%Y0"
 574   [(set_attr "length" "2,8")
 575    (set_attr "cc" "set_zn,set_zn")])
 576
 577 (define_insn ""
 578   [(set (cc0) (zero_extract:SI (match_operand:QI 0 "bit_memory_operand" "r,U")
 579                                (const_int 1)
 580                                (match_operand:QI 1 "const_int_operand" "n,n")))]
 581   ""
 582   "btst %Z1,%Y0"
 583   [(set_attr "length" "2,8")
 584    (set_attr "cc" "set_zn,set_zn")])
 585
 586 (define_insn ""
 587   [(set (cc0) (zero_extract:QI (match_operand:HI 0 "register_operand" "r")
 588                                (const_int 1)
 589                                (match_operand:HI 1 "const_int_operand" "n")))]
 590   ""
 591   "btst %Z1,%R0"
 592   [(set_attr "length" "2")
 593    (set_attr "cc" "set_zn")])
 594
 595 (define_insn ""
 596   [(set (cc0) (zero_extract:HI (match_operand:HI 0 "register_operand" "r")
 597                                (const_int 1)
 598                                (match_operand:HI 1 "const_int_operand" "n")))]
 599   ""
 600   "btst %Z1,%Y0"
 601   [(set_attr "length" "2")
 602    (set_attr "cc" "set_zn")])
 603
 604 (define_insn ""
 605   [(set (cc0) (zero_extract:SI (match_operand:HI 0 "register_operand" "r")
 606                                (const_int 1)
 607                                (match_operand:HI 1 "const_int_operand" "n")))]
 608   ""
 609   "btst %Z1,%Y0"
 610   [(set_attr "length" "2")
 611    (set_attr "cc" "set_zn")])
 612
 613 (define_insn "tstqi"
 614   [(set (cc0) (match_operand:QI 0 "register_operand" "r"))]
 615   ""
 616   "mov.b        %X0,%X0"
 617   [(set_attr "length" "2")
 618    (set_attr "cc" "set_znv")])
 619
 620 (define_insn "tsthi"
 621   [(set (cc0) (match_operand:HI 0 "register_operand" "r"))]
 622   ""
 623   "mov.w        %T0,%T0"
 624   [(set_attr "length" "2")
 625    (set_attr "cc" "set_znv")])
 626
 627 (define_insn "tstsi"
 628   [(set (cc0) (match_operand:SI 0 "register_operand" "r"))]
 629   "TARGET_H8300H || TARGET_H8300S"
 630   "mov.l        %S0,%S0"
 631   [(set_attr "length" "2")
 632    (set_attr "cc" "set_znv")])
 633
 634 (define_insn "cmpqi"
 635   [(set (cc0)
 636         (compare:QI (match_operand:QI 0 "register_operand" "r")
 637                     (match_operand:QI 1 "nonmemory_operand" "rn")))]
 638   ""
 639   "cmp.b        %X1,%X0"
 640   [(set_attr "length" "2")
 641    (set_attr "cc" "compare")])
 642
 643 (define_expand "cmphi"
 644   [(set (cc0)
 645         (compare:HI (match_operand:HI 0 "register_operand" "")
 646                     (match_operand:HI 1 "nonmemory_operand" "")))]
 647   ""
 648   "
 649 {
 650   /* Force operand1 into a register if we're compiling
 651      for the H8/300.  */
 652   if (GET_CODE (operands[1]) != REG && TARGET_H8300)
 653     operands[1] = force_reg (HImode, operands[1]);
 654 }")
 655
 656 (define_insn ""
 657   [(set (cc0)
 658         (compare:HI (match_operand:HI 0 "register_operand" "r")
 659                     (match_operand:HI 1 "register_operand" "r")))]
 660   "TARGET_H8300"
 661   "cmp.w        %T1,%T0"
 662   [(set_attr "length" "2")
 663    (set_attr "cc" "compare")])
 664
 665 (define_insn ""
 666   [(set (cc0)
 667         (compare:HI (match_operand:HI 0 "register_operand" "r,r")
 668                     (match_operand:HI 1 "nonmemory_operand" "r,n")))]
 669   "TARGET_H8300H || TARGET_H8300S"
 670   "cmp.w        %T1,%T0"
 671   [(set_attr "length" "2,4")
 672    (set_attr "cc" "compare,compare")])
 673
 674 (define_insn "cmpsi"
 675   [(set (cc0)
 676         (compare:SI (match_operand:SI 0 "register_operand" "r,r")
 677                     (match_operand:SI 1 "nonmemory_operand" "r,i")))]
 678   "TARGET_H8300H || TARGET_H8300S"
 679   "cmp.l        %S1,%S0"
 680   [(set_attr "length" "2,6")
 681    (set_attr "cc" "compare,compare")])
 682 \f
 683 ;; ----------------------------------------------------------------------
 684 ;; ADD INSTRUCTIONS
 685 ;; ----------------------------------------------------------------------
 686
 687 (define_insn "addqi3"
 688   [(set (match_operand:QI 0 "register_operand" "=r")
 689         (plus:QI (match_operand:QI 1 "register_operand" "%0")
 690                  (match_operand:QI 2 "nonmemory_operand" "rn")))]
 691   ""
 692   "add.b        %X2,%X0"
 693   [(set_attr "length" "2")
 694    (set_attr "cc" "set_zn")])
 695
 696 (define_expand "addhi3"
 697   [(set (match_operand:HI 0 "register_operand" "")
 698         (plus:HI (match_operand:HI 1 "register_operand" "")
 699                  (match_operand:HI 2 "nonmemory_operand" "")))]
 700   ""
 701   "")
 702
 703 (define_insn ""
 704   [(set (match_operand:HI 0 "register_operand" "=r,r,r,r,&r")
 705         (plus:HI (match_operand:HI 1 "register_operand" "%0,0,0,0,g")
 706                  (match_operand:HI 2 "nonmemory_operand" "L,N,n,r,r")))]
 707   "TARGET_H8300"
 708   "@
 709    adds %2,%A0
 710    subs %G2,%A0
 711    add.b        %s2,%s0\;addx   %t2,%t0
 712    add.w        %T2,%T0
 713    mov.w        %T1,%T0\;add.w  %T2,%T0"
 714   [(set_attr "length" "2,2,4,2,6")
 715    (set_attr "cc" "none_0hit,none_0hit,clobber,set_zn,set_zn")])
 716
 717 (define_insn ""
 718   [(set (match_operand:HI 0 "register_operand" "=r,r,r,r")
 719         (plus:HI (match_operand:HI 1 "register_operand" "%0,0,0,0")
 720                  (match_operand:HI 2 "nonmemory_operand" "L,N,n,r")))]
 721   "TARGET_H8300H || TARGET_H8300S"
 722   "@
 723    adds %2,%A0
 724    subs %G2,%A0
 725    add.w        %T2,%T0
 726    add.w        %T2,%T0"
 727   [(set_attr "length" "2,2,4,2")
 728    (set_attr "cc" "none_0hit,none_0hit,set_zn,set_zn")])
 729
 730 (define_split
 731   [(set (match_operand:HI 0 "register_operand" "")
 732         (plus:HI (match_dup 0)
 733                  (match_operand:HI 1 "two_insn_adds_subs_operand" "")))]
 734   ""
 735   [(const_int 0)]
 736   "split_adds_subs (HImode, operands); DONE;")
 737
 738 (define_expand "addsi3"
 739   [(set (match_operand:SI 0 "register_operand" "")
 740         (plus:SI (match_operand:SI 1 "register_operand" "")
 741                  (match_operand:SI 2 "nonmemory_operand" "")))]
 742   ""
 743   "")
 744
 745 (define_insn "addsi_h8300"
 746   [(set (match_operand:SI 0 "register_operand" "=r,r,&r")
 747         (plus:SI (match_operand:SI 1 "register_operand" "%0,0,r")
 748                  (match_operand:SI 2 "nonmemory_operand" "n,r,r")))]
 749   "TARGET_H8300"
 750   "@
 751    add  %w2,%w0\;addx   %x2,%x0\;addx   %y2,%y0\;addx   %z2,%z0
 752    add.w        %f2,%f0\;addx   %y2,%y0\;addx   %z2,%z0
 753    mov.w        %f1,%f0\;mov.w  %e1,%e0\;add.w  %f2,%f0\;addx   %y2,%y0\;addx   %z2,%z0"
 754   [(set_attr "length" "8,6,10")
 755    (set_attr "cc" "clobber")])
 756
 757 (define_insn "addsi_h8300h"
 758   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
 759         (plus:SI (match_operand:SI 1 "register_operand" "%0,0,0,0")
 760                  (match_operand:SI 2 "nonmemory_operand" "L,N,i,r")))]
 761   "TARGET_H8300H || TARGET_H8300S"
 762   "@
 763    adds %2,%A0
 764    subs %G2,%A0
 765    add.l        %S2,%S0
 766    add.l        %S2,%S0"
 767   [(set_attr "length" "2,2,6,2")
 768    (set_attr "cc" "none_0hit,none_0hit,set_zn,set_zn")])
 769
 770 (define_split
 771   [(set (match_operand:SI 0 "register_operand" "")
 772         (plus:SI (match_dup 0)
 773                  (match_operand:SI 1 "two_insn_adds_subs_operand" "")))]
 774   "TARGET_H8300H || TARGET_H8300S"
 775   [(const_int 0)]
 776   "split_adds_subs (SImode, operands); DONE;")
 777
 778 ;; ----------------------------------------------------------------------
 779 ;; SUBTRACT INSTRUCTIONS
 780 ;; ----------------------------------------------------------------------
 781
 782 (define_insn "subqi3"
 783   [(set (match_operand:QI 0 "register_operand" "=r,r")
 784         (minus:QI (match_operand:QI 1 "register_operand" "0,0")
 785                   (match_operand:QI 2 "nonmemory_operand" "r,n")))]
 786   ""
 787   "@
 788    sub.b        %X2,%X0
 789    add.b        %G2,%X0"
 790   [(set_attr "length" "2")
 791    (set_attr "cc" "set_zn")])
 792
 793 (define_expand "subhi3"
 794   [(set (match_operand:HI 0 "register_operand" "")
 795         (minus:HI (match_operand:HI 1 "general_operand" "")
 796                   (match_operand:HI 2 "nonmemory_operand" "")))]
 797   ""
 798   "")
 799
 800 (define_insn ""
 801   [(set (match_operand:HI 0 "register_operand" "=r,&r")
 802         (minus:HI (match_operand:HI 1 "general_operand" "0,0")
 803                   (match_operand:HI 2 "nonmemory_operand" "r,n")))]
 804   "TARGET_H8300"
 805   "@
 806    sub.w        %T2,%T0
 807    add.b        %E2,%s0\;addx   %F2,%t0"
 808   [(set_attr "length" "2,4")
 809    (set_attr "cc" "set_zn,clobber")])
 810
 811 (define_insn ""
 812   [(set (match_operand:HI 0 "register_operand" "=r,&r")
 813         (minus:HI (match_operand:HI 1 "general_operand" "0,0")
 814                   (match_operand:HI 2 "nonmemory_operand" "r,n")))]
 815   "TARGET_H8300H || TARGET_H8300S"
 816   "@
 817    sub.w        %T2,%T0
 818    sub.w        %T2,%T0"
 819   [(set_attr "length" "2,4")
 820    (set_attr "cc" "set_zn,set_zn")])
 821
 822 (define_expand "subsi3"
 823   [(set (match_operand:SI 0 "register_operand" "")
 824         (minus:SI (match_operand:SI 1 "register_operand" "")
 825                   (match_operand:SI 2 "nonmemory_operand" "")))]
 826   ""
 827   "")
 828
 829 (define_insn "subsi3_h8300"
 830   [(set (match_operand:SI 0 "register_operand" "=r")
 831         (minus:SI (match_operand:SI 1 "register_operand" "0")
 832                   (match_operand:SI 2 "register_operand" "r")))]
 833   "TARGET_H8300"
 834   "sub.w        %f2,%f0\;subx   %y2,%y0\;subx   %z2,%z0"
 835   [(set_attr "length" "6")
 836    (set_attr "cc" "clobber")])
 837
 838 (define_insn "subsi3_h8300h"
 839   [(set (match_operand:SI 0 "register_operand" "=r,r")
 840         (minus:SI (match_operand:SI 1 "general_operand" "0,0")
 841                   (match_operand:SI 2 "nonmemory_operand" "r,i")))]
 842   "TARGET_H8300H || TARGET_H8300S"
 843   "@
 844    sub.l        %S2,%S0
 845    sub.l        %S2,%S0"
 846   [(set_attr "length" "2,6")
 847    (set_attr "cc" "set_zn,set_zn")])
 848 \f
 849 ;; ----------------------------------------------------------------------
 850 ;; MULTIPLY INSTRUCTIONS
 851 ;; ----------------------------------------------------------------------
 852
 853 ;; Note that the H8/300 can only handle umulqihi3.
 854
 855 (define_insn "mulqihi3"
 856   [(set (match_operand:HI 0 "register_operand" "=r")
 857         (mult:HI (sign_extend:HI (match_operand:QI 1 "general_operand" "%0"))
 858                  (sign_extend:HI (match_operand:QI 2 "register_operand" "r"))))]
 859   "TARGET_H8300H || TARGET_H8300S"
 860   "mulxs.b      %X2,%T0"
 861   [(set_attr "length" "4")
 862    (set_attr "cc" "set_zn")])
 863
 864 (define_insn "mulhisi3"
 865   [(set (match_operand:SI 0 "register_operand" "=r")
 866         (mult:SI (sign_extend:SI (match_operand:HI 1 "general_operand" "%0"))
 867                  (sign_extend:SI (match_operand:HI 2 "register_operand" "r"))))]
 868   "TARGET_H8300H || TARGET_H8300S"
 869   "mulxs.w      %T2,%S0"
 870   [(set_attr "length" "4")
 871    (set_attr "cc" "set_zn")])
 872
 873 (define_insn "umulqihi3"
 874   [(set (match_operand:HI 0 "register_operand" "=r")
 875         (mult:HI (zero_extend:HI (match_operand:QI 1 "general_operand" "%0"))
 876                  (zero_extend:HI (match_operand:QI 2 "register_operand" "r"))))]
 877   ""
 878   "mulxu        %X2,%T0"
 879   [(set_attr "length" "2")
 880    (set_attr "cc" "none_0hit")])
 881
 882 (define_insn "umulhisi3"
 883   [(set (match_operand:SI 0 "register_operand" "=r")
 884         (mult:SI (zero_extend:SI (match_operand:HI 1 "general_operand" "%0"))
 885                  (zero_extend:SI (match_operand:HI 2 "register_operand" "r"))))]
 886   "TARGET_H8300H || TARGET_H8300S"
 887   "mulxu.w      %T2,%S0"
 888   [(set_attr "length" "2")
 889    (set_attr "cc" "none_0hit")])
 890
 891 ;; This is a "bridge" instruction.  Combine can't cram enough insns
 892 ;; together to crate a MAC instruction directly, but it can create
 893 ;; this instruction, which then allows combine to create the real
 894 ;; MAC insn.
 895 ;;
 896 ;; Unfortunately, if combine doesn't create a MAC instruction, this
 897 ;; insn must generate reasonably correct code.  Egad.
 898 (define_insn ""
 899   [(set (match_operand:SI 0 "register_operand" "=a")
 900         (mult:SI
 901           (sign_extend:SI
 902             (mem:HI (post_inc:SI (match_operand:SI 1 "register_operand" "r"))))
 903           (sign_extend:SI
 904             (mem:HI (post_inc:SI (match_operand:SI 2 "register_operand" "r"))))))]
 905   "TARGET_MAC"
 906   "clrmac\;mac  @%2+,@%1+"
 907   [(set_attr "length" "6")
 908    (set_attr "cc" "none_0hit")])
 909
 910 (define_insn ""
 911   [(set (match_operand:SI 0 "register_operand" "=a")
 912         (plus:SI (mult:SI
 913           (sign_extend:SI (mem:HI
 914             (post_inc:SI (match_operand:SI 1 "register_operand" "r"))))
 915           (sign_extend:SI (mem:HI
 916             (post_inc:SI (match_operand:SI 2 "register_operand" "r")))))
 917               (match_operand:SI 3 "register_operand" "0")))]
 918   "TARGET_MAC"
 919   "mac  @%2+,@%1+"
 920   [(set_attr "length" "4")
 921    (set_attr "cc" "none_0hit")])
 922
 923 ;; ----------------------------------------------------------------------
 924 ;; DIVIDE/MOD INSTRUCTIONS
 925 ;; ----------------------------------------------------------------------
 926
 927 (define_insn "udivmodqi4"
 928   [(set (match_operand:QI 0 "register_operand" "=r")
 929         (truncate:QI
 930           (udiv:HI
 931             (match_operand:HI 1 "general_operand" "0")
 932             (zero_extend:HI (match_operand:QI 2 "register_operand" "r")))))
 933    (set (match_operand:QI 3 "register_operand" "=r")
 934         (truncate:QI
 935           (umod:HI
 936             (match_dup 1)
 937             (zero_extend:HI (match_dup 2)))))]
 938   "TARGET_H8300H || TARGET_H8300S"
 939   "*
 940 {
 941   if (find_reg_note (insn, REG_UNUSED, operands[3]))
 942     return \"divxu.b\\t%X2,%T0\";
 943   else
 944     return \"divxu.b\\t%X2,%T0\;mov.b\\t%t0,%s3\";
 945 }"
 946   [(set_attr "length" "4")
 947    (set_attr "cc" "clobber")])
 948
 949 (define_insn "divmodqi4"
 950   [(set (match_operand:QI 0 "register_operand" "=r")
 951         (truncate:QI
 952           (div:HI
 953             (match_operand:HI 1 "general_operand" "0")
 954             (sign_extend:HI (match_operand:QI 2 "register_operand" "r")))))
 955    (set (match_operand:QI 3 "register_operand" "=r")
 956         (truncate:QI
 957           (mod:HI
 958             (match_dup 1)
 959             (sign_extend:HI (match_dup 2)))))]
 960   "TARGET_H8300H || TARGET_H8300S"
 961   "*
 962 {
 963   if (find_reg_note (insn, REG_UNUSED, operands[3]))
 964     return \"divxs.b\\t%X2,%T0\";
 965   else
 966     return \"divxs.b\\t%X2,%T0\;mov.b\\t%t0,%s3\";
 967 }"
 968   [(set_attr "length" "6")
 969    (set_attr "cc" "clobber")])
 970
 971 (define_insn "udivmodhi4"
 972   [(set (match_operand:HI 0 "register_operand" "=r")
 973         (truncate:HI
 974           (udiv:SI
 975             (match_operand:SI 1 "general_operand" "0")
 976             (zero_extend:SI (match_operand:HI 2 "register_operand" "r")))))
 977    (set (match_operand:HI 3 "register_operand" "=r")
 978         (truncate:HI
 979           (umod:SI
 980             (match_dup 1)
 981             (zero_extend:SI (match_dup 2)))))]
 982   "TARGET_H8300H || TARGET_H8300S"
 983   "*
 984 {
 985   if (find_reg_note (insn, REG_UNUSED, operands[3]))
 986     return \"divxu.w\\t%T2,%S0\";
 987   else
 988     return \"divxu.w\\t%T2,%S0\;mov.w\\t%e0,%f3\";
 989 }"
 990   [(set_attr "length" "4")
 991    (set_attr "cc" "clobber")])
 992
 993 (define_insn "divmodhi4"
 994   [(set (match_operand:HI 0 "register_operand" "=r")
 995         (truncate:HI
 996           (div:SI
 997             (match_operand:SI 1 "general_operand" "0")
 998             (sign_extend:SI (match_operand:HI 2 "register_operand" "r")))))
 999    (set (match_operand:HI 3 "register_operand" "=r")
1000         (truncate:HI
1001           (mod:SI
1002             (match_dup 1)
1003             (sign_extend:SI (match_dup 2)))))]
1004   "TARGET_H8300H || TARGET_H8300S"
1005   "*
1006 {
1007   if (find_reg_note (insn, REG_UNUSED, operands[3]))
1008     return \"divxs.w\\t%T2,%S0\";
1009   else
1010     return \"divxs.w\\t%T2,%S0\;mov.w\\t%e0,%f3\";
1011 }"
1012   [(set_attr "length" "6")
1013    (set_attr "cc" "clobber")])
1014 \f
1015 ;; ----------------------------------------------------------------------
1016 ;; AND INSTRUCTIONS
1017 ;; ----------------------------------------------------------------------
1018
1019 (define_insn ""
1020   [(set (match_operand:QI 0 "bit_operand" "=r,U")
1021         (and:QI (match_operand:QI 1 "bit_operand" "%0,0")
1022                 (match_operand:QI 2 "nonmemory_operand" "rn,O")))]
1023   "register_operand (operands[0], QImode) || o_operand (operands[2], QImode)"
1024   "@
1025    and  %X2,%X0
1026    bclr %W2,%R0"
1027   [(set_attr "length" "2,8")
1028    (set_attr "adjust_length" "no")
1029    (set_attr "cc" "set_znv,none_0hit")])
1030
1031 (define_expand "andqi3"
1032   [(set (match_operand:QI 0 "bit_operand" "")
1033         (and:QI (match_operand:QI 1 "bit_operand" "")
1034                 (match_operand:QI 2 "nonmemory_operand" "")))]
1035   ""
1036   "
1037 {
1038   if (fix_bit_operand (operands, 'O', AND))
1039     DONE;
1040 }")
1041
1042 (define_expand "andhi3"
1043   [(set (match_operand:HI 0 "register_operand" "")
1044         (and:HI (match_operand:HI 1 "register_operand" "")
1045                 (match_operand:HI 2 "nonmemory_operand" "")))]
1046   ""
1047   "")
1048
1049 (define_insn ""
1050   [(set (match_operand:HI 0 "register_operand" "=r")
1051         (and:HI (match_operand:HI 1 "register_operand" "%0")
1052                 (match_operand:HI 2 "nonmemory_operand" "rn")))]
1053   "TARGET_H8300"
1054   "* return output_logical_op (HImode, AND, operands);"
1055   [(set_attr "length" "4")
1056    (set_attr "cc" "clobber")])
1057
1058 (define_insn ""
1059   [(set (match_operand:HI 0 "register_operand" "=r,r")
1060         (and:HI (match_operand:HI 1 "register_operand" "%0,0")
1061                 (match_operand:HI 2 "nonmemory_operand" "r,n")))]
1062   "TARGET_H8300H || TARGET_H8300S"
1063   "* return output_logical_op (HImode, AND, operands);"
1064   [(set_attr "length" "2,4")
1065    (set_attr "cc" "set_znv,clobber")])
1066
1067 (define_insn "*andorhi3"
1068   [(set (match_operand:HI 0 "register_operand" "=r")
1069         (ior:HI (and:HI (match_operand:HI 2 "register_operand" "r")
1070                         (match_operand:HI 3 "p_operand" "P"))
1071         (match_operand:HI 1 "register_operand" "0")))]
1072   ""
1073   "*
1074 {
1075   if (INTVAL (operands[3]) > 128)
1076     {
1077       operands[3] = GEN_INT (INTVAL (operands[3]) >> 8);
1078       return \"bld\\t%V3,%t2\;bst\\t%V3,%t0\";
1079     }
1080   return \"bld\\t%V3,%s2\;bst\\t%V3,%s0\";
1081 }"
1082   [(set_attr "length" "4")
1083    (set_attr "cc" "clobber")])
1084
1085 (define_expand "andsi3"
1086   [(set (match_operand:SI 0 "register_operand" "")
1087         (and:SI (match_operand:SI 1 "register_operand" "")
1088                 (match_operand:SI 2 "nonmemory_operand" "")))]
1089   ""
1090   "")
1091
1092 (define_insn ""
1093   [(set (match_operand:SI 0 "register_operand" "=r")
1094         (and:SI (match_operand:SI 1 "register_operand" "%0")
1095                 (match_operand:SI 2 "nonmemory_operand" "rn")))]
1096   "TARGET_H8300"
1097   "* return output_logical_op (SImode, AND, operands);"
1098   [(set_attr "length" "8")
1099    (set_attr "cc" "clobber")])
1100
1101 (define_insn ""
1102   [(set (match_operand:SI 0 "register_operand" "=r,r")
1103         (and:SI (match_operand:SI 1 "register_operand" "%0,0")
1104                 (match_operand:SI 2 "nonmemory_operand" "r,n")))]
1105   "TARGET_H8300H || TARGET_H8300S"
1106   "* return output_logical_op (SImode, AND, operands);"
1107   [(set_attr "length" "4,6")
1108    (set_attr "cc" "set_znv,clobber")])
1109
1110 ;; ----------------------------------------------------------------------
1111 ;; OR INSTRUCTIONS
1112 ;; ----------------------------------------------------------------------
1113
1114 (define_insn ""
1115   [(set (match_operand:QI 0 "bit_operand" "=r,U")
1116         (ior:QI (match_operand:QI 1 "bit_operand" "%0,0")
1117                 (match_operand:QI 2 "nonmemory_operand" "rn,P")))]
1118   "register_operand (operands[0], QImode) || p_operand (operands[2], QImode)"
1119   "@
1120    or   %X2,%X0
1121    bset %V2,%R0"
1122   [(set_attr "length" "2,8")
1123    (set_attr "adjust_length" "no")
1124    (set_attr "cc" "set_znv,none_0hit")])
1125
1126 (define_expand "iorqi3"
1127   [(set (match_operand:QI 0 "bit_operand" "")
1128         (ior:QI (match_operand:QI 1 "bit_operand" "")
1129                 (match_operand:QI 2 "nonmemory_operand" "")))]
1130   ""
1131   "
1132 {
1133   if (fix_bit_operand (operands, 'P', IOR))
1134     DONE;
1135 }")
1136
1137 (define_expand "iorhi3"
1138   [(set (match_operand:HI 0 "general_operand" "")
1139         (ior:HI (match_operand:HI 1 "general_operand" "")
1140                 (match_operand:HI 2 "general_operand" "")))]
1141   ""
1142   "")
1143
1144 (define_insn ""
1145   [(set (match_operand:HI 0 "general_operand" "=r,r")
1146         (ior:HI (match_operand:HI 1 "general_operand" "%0,0")
1147                 (match_operand:HI 2 "general_operand" "J,rn")))]
1148   "TARGET_H8300"
1149   "* return output_logical_op (HImode, IOR, operands);"
1150   [(set_attr "length" "2,4")
1151    (set_attr "cc" "clobber,clobber")])
1152
1153 (define_insn ""
1154   [(set (match_operand:HI 0 "general_operand" "=r,r,r")
1155         (ior:HI (match_operand:HI 1 "general_operand" "%0,0,0")
1156                 (match_operand:HI 2 "general_operand" "J,r,n")))]
1157   "TARGET_H8300H || TARGET_H8300S"
1158   "* return output_logical_op (HImode, IOR, operands);"
1159   [(set_attr "length" "2,2,4")
1160    (set_attr "cc" "clobber,set_znv,clobber")])
1161
1162 (define_expand "iorsi3"
1163   [(set (match_operand:SI 0 "register_operand" "")
1164         (ior:SI (match_operand:SI 1 "register_operand" "")
1165                 (match_operand:SI 2 "nonmemory_operand" "")))]
1166   ""
1167   "")
1168
1169 (define_insn ""
1170   [(set (match_operand:SI 0 "register_operand" "=r,r")
1171         (ior:SI (match_operand:SI 1 "register_operand" "%0,0")
1172                 (match_operand:SI 2 "nonmemory_operand" "J,rn")))]
1173   "TARGET_H8300"
1174   "* return output_logical_op (SImode, IOR, operands);"
1175   [(set_attr "length" "2,8")
1176    (set_attr "cc" "clobber,clobber")])
1177
1178 (define_insn ""
1179   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1180         (ior:SI (match_operand:SI 1 "register_operand" "%0,0,0")
1181                 (match_operand:SI 2 "nonmemory_operand" "J,r,n")))]
1182   "TARGET_H8300H || TARGET_H8300S"
1183   "* return output_logical_op (SImode, IOR, operands);"
1184   [(set_attr "length" "2,4,6")
1185    (set_attr "cc" "clobber,set_znv,clobber")])
1186
1187 ;; ----------------------------------------------------------------------
1188 ;; XOR INSTRUCTIONS
1189 ;; ----------------------------------------------------------------------
1190
1191 (define_insn ""
1192   [(set (match_operand:QI 0 "bit_operand" "=r,U")
1193         (xor:QI (match_operand:QI 1 "bit_operand" "%0,0")
1194                 (match_operand:QI 2 "nonmemory_operand" "rn,P")))]
1195   "register_operand (operands[0], QImode) || p_operand (operands[2], QImode)"
1196   "@
1197    xor  %X2,%X0
1198    bnot %V2,%R0"
1199   [(set_attr "length" "2,8")
1200    (set_attr "adjust_length" "no")
1201    (set_attr "cc" "set_znv,none_0hit")])
1202
1203 (define_expand "xorqi3"
1204   [(set (match_operand:QI 0 "bit_operand" "")
1205         (xor:QI (match_operand:QI 1 "bit_operand" "")
1206                 (match_operand:QI 2 "nonmemory_operand" "")))]
1207   ""
1208   "
1209 {
1210   if (fix_bit_operand (operands, 'O', XOR))
1211     DONE;
1212 }")
1213
1214 (define_expand "xorhi3"
1215   [(set (match_operand:HI 0 "register_operand" "")
1216         (xor:HI (match_operand:HI 1 "general_operand" "")
1217                 (match_operand:HI 2 "nonmemory_operand" "")))]
1218   ""
1219   "")
1220
1221 (define_insn ""
1222   [(set (match_operand:HI 0 "register_operand" "=r,r")
1223         (xor:HI (match_operand:HI 1 "general_operand" "%0,0")
1224                 (match_operand:HI 2 "nonmemory_operand" "J,rn")))]
1225   "TARGET_H8300"
1226   "* return output_logical_op (HImode, XOR, operands);"
1227   [(set_attr "length" "2,4")
1228    (set_attr "cc" "clobber,clobber")])
1229
1230 (define_insn ""
1231   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
1232         (xor:HI (match_operand:HI 1 "general_operand" "%0,0,0")
1233                 (match_operand:HI 2 "nonmemory_operand" "J,r,n")))]
1234   "TARGET_H8300H || TARGET_H8300S"
1235   "* return output_logical_op (HImode, XOR, operands);"
1236   [(set_attr "length" "2,2,4")
1237    (set_attr "cc" "clobber,set_znv,clobber")])
1238
1239 (define_expand "xorsi3"
1240   [(set (match_operand:SI 0 "register_operand" "")
1241         (xor:SI (match_operand:SI 1 "register_operand" "")
1242                 (match_operand:SI 2 "nonmemory_operand" "")))]
1243   ""
1244   "")
1245
1246 (define_insn ""
1247   [(set (match_operand:SI 0 "register_operand" "=r,r")
1248         (xor:SI (match_operand:SI 1 "register_operand" "%0,0")
1249                 (match_operand:SI 2 "nonmemory_operand" "J,rn")))]
1250   "TARGET_H8300"
1251   "* return output_logical_op (SImode, XOR, operands);"
1252   [(set_attr "length" "2,8")
1253    (set_attr "cc" "clobber,clobber")])
1254
1255 (define_insn ""
1256   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1257         (xor:SI (match_operand:SI 1 "register_operand" "%0,0,0")
1258                 (match_operand:SI 2 "nonmemory_operand" "J,r,n")))]
1259   "TARGET_H8300H || TARGET_H8300S"
1260   "* return output_logical_op (SImode, XOR, operands);"
1261   [(set_attr "length" "2,4,6")
1262    (set_attr "cc" "clobber,set_znv,clobber")])
1263 \f
1264 ;; ----------------------------------------------------------------------
1265 ;; NEGATION INSTRUCTIONS
1266 ;; ----------------------------------------------------------------------
1267
1268 (define_insn "negqi2"
1269   [(set (match_operand:QI 0 "register_operand" "=r")
1270         (neg:QI (match_operand:QI 1 "general_operand" "0")))]
1271   ""
1272   "neg  %X0"
1273   [(set_attr "length" "2")
1274    (set_attr "cc" "set_zn")])
1275
1276 (define_expand "neghi2"
1277   [(set (match_operand:HI 0 "register_operand" "=r")
1278         (neg:HI (match_operand:HI 1 "general_operand" "0")))]
1279   ""
1280   "
1281 {
1282   if (TARGET_H8300)
1283     {
1284       emit_insn (gen_neghi2_h8300 (operands[0], operands[1]));
1285       DONE;
1286     }
1287 }")
1288
1289 (define_expand "neghi2_h8300"
1290   [(set (match_dup 2)
1291         (not:HI (match_operand:HI 1 "register_operand" "r")))
1292    (set (match_dup 2) (plus:HI (match_dup 2) (const_int 1)))
1293    (set (match_operand:HI 0 "register_operand" "=r")
1294         (match_dup 2))]
1295   ""
1296   "{ operands[2] = gen_reg_rtx (HImode); }")
1297
1298 (define_insn "neghi2_h8300h"
1299   [(set (match_operand:HI 0 "register_operand" "=r")
1300         (neg:HI (match_operand:HI 1 "general_operand" "0")))]
1301   "TARGET_H8300H || TARGET_H8300S"
1302   "neg  %T0"
1303   [(set_attr "length" "2")
1304    (set_attr "cc" "set_zn")])
1305
1306 (define_expand "negsi2"
1307   [(set (match_operand:SI 0 "register_operand" "=r")
1308         (neg:SI (match_operand:SI 1 "general_operand" "0")))]
1309   ""
1310   "
1311 {
1312   if (TARGET_H8300)
1313     {
1314       emit_insn (gen_negsi2_h8300 (operands[0], operands[1]));
1315       DONE;
1316     }
1317 }")
1318
1319 (define_expand "negsi2_h8300"
1320   [(set (match_dup 2)
1321         (not:SI (match_operand:SI 1 "register_operand" "r")))
1322    (set (match_dup 2) (plus:SI (match_dup 2) (const_int 1)))
1323    (set (match_operand:SI 0 "register_operand" "=r")
1324         (match_dup 2))]
1325   ""
1326   "{ operands[2] = gen_reg_rtx(SImode); }")
1327
1328 (define_insn "negsi2_h8300h"
1329   [(set (match_operand:SI 0 "register_operand" "=r")
1330         (neg:SI (match_operand:SI 1 "general_operand" "0")))]
1331   "TARGET_H8300H || TARGET_H8300S"
1332   "neg  %S0"
1333   [(set_attr "length" "2")
1334    (set_attr "cc" "set_zn")])
1335
1336 ;; ----------------------------------------------------------------------
1337 ;; NOT INSTRUCTIONS
1338 ;; ----------------------------------------------------------------------
1339
1340 (define_insn "one_cmplqi2"
1341   [(set (match_operand:QI 0 "register_operand" "=r")
1342         (not:QI (match_operand:QI 1 "general_operand" "0")))]
1343   ""
1344   "not  %X0"
1345   [(set_attr "length" "2")
1346    (set_attr "cc" "set_znv")])
1347
1348 (define_insn "one_cmplhi2"
1349   [(set (match_operand:HI 0 "register_operand" "=r")
1350         (not:HI (match_operand:HI 1 "general_operand" "0")))]
1351   ""
1352   "*
1353 {
1354   if (TARGET_H8300)
1355     return \"not        %s0\;not        %t0\";
1356   else
1357     return \"not        %T0\";
1358 }"
1359   [(set_attr "cc" "clobber")
1360    (set (attr "length")
1361         (if_then_else (eq (symbol_ref "TARGET_H8300H || TARGET_H8300S")
1362                           (const_int 0))
1363                       (const_int 4)
1364                       (const_int 2)))])
1365
1366 (define_insn "one_cmplsi2"
1367   [(set (match_operand:SI 0 "register_operand" "=r")
1368         (not:SI (match_operand:SI 1 "general_operand" "0")))]
1369   ""
1370   "*
1371 {
1372   if (TARGET_H8300)
1373     return \"not        %w0\;not        %x0\;not        %y0\;not        %z0\";
1374   else
1375     return \"not        %S0\";
1376 }"
1377   [(set_attr "cc" "clobber")
1378    (set (attr "length")
1379         (if_then_else (eq (symbol_ref "TARGET_H8300H || TARGET_H8300S")
1380                           (const_int 0))
1381                       (const_int 8)
1382                       (const_int 2)))])
1383 \f
1384 ;; ----------------------------------------------------------------------
1385 ;; JUMP INSTRUCTIONS
1386 ;; ----------------------------------------------------------------------
1387
1388 ;; Conditional jump instructions
1389
1390 (define_expand "ble"
1391   [(set (pc)
1392         (if_then_else (le (cc0)
1393                           (const_int 0))
1394                       (label_ref (match_operand 0 "" ""))
1395                       (pc)))]
1396   ""
1397   "")
1398
1399 (define_expand "bleu"
1400   [(set (pc)
1401         (if_then_else (leu (cc0)
1402                            (const_int 0))
1403                       (label_ref (match_operand 0 "" ""))
1404                       (pc)))]
1405   ""
1406   "")
1407
1408 (define_expand "bge"
1409   [(set (pc)
1410         (if_then_else (ge (cc0)
1411                           (const_int 0))
1412                       (label_ref (match_operand 0 "" ""))
1413                       (pc)))]
1414   ""
1415   "")
1416
1417 (define_expand "bgeu"
1418   [(set (pc)
1419         (if_then_else (geu (cc0)
1420                            (const_int 0))
1421                       (label_ref (match_operand 0 "" ""))
1422                       (pc)))]
1423   ""
1424   "")
1425
1426 (define_expand "blt"
1427   [(set (pc)
1428         (if_then_else (lt (cc0)
1429                           (const_int 0))
1430                       (label_ref (match_operand 0 "" ""))
1431                       (pc)))]
1432   ""
1433   "")
1434
1435 (define_expand "bltu"
1436   [(set (pc)
1437         (if_then_else (ltu (cc0)
1438                            (const_int 0))
1439                       (label_ref (match_operand 0 "" ""))
1440                       (pc)))]
1441   ""
1442   "")
1443
1444 (define_expand "bgt"
1445   [(set (pc)
1446         (if_then_else (gt (cc0)
1447                           (const_int 0))
1448                       (label_ref (match_operand 0 "" ""))
1449                       (pc)))]
1450   ""
1451   "")
1452
1453 (define_expand "bgtu"
1454   [(set (pc)
1455         (if_then_else (gtu (cc0)
1456                            (const_int 0))
1457                       (label_ref (match_operand 0 "" ""))
1458                       (pc)))]
1459   ""
1460   "")
1461
1462 (define_expand "beq"
1463   [(set (pc)
1464         (if_then_else (eq (cc0)
1465                           (const_int 0))
1466                       (label_ref (match_operand 0 "" ""))
1467                       (pc)))]
1468   ""
1469   "")
1470
1471 (define_expand "bne"
1472   [(set (pc)
1473         (if_then_else (ne (cc0)
1474                           (const_int 0))
1475                       (label_ref (match_operand 0 "" ""))
1476                       (pc)))]
1477   ""
1478   "")
1479
1480 (define_insn "branch_true"
1481   [(set (pc)
1482         (if_then_else (match_operator 1 "comparison_operator"
1483                                       [(cc0) (const_int 0)])
1484                       (label_ref (match_operand 0 "" ""))
1485                       (pc)))]
1486   ""
1487   "*
1488 {
1489   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0
1490       && (GET_CODE (operands[1]) == GT
1491           || GET_CODE (operands[1]) == GE
1492           || GET_CODE (operands[1]) == LE
1493           || GET_CODE (operands[1]) == LT))
1494     {
1495       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
1496       return 0;
1497     }
1498
1499   if (get_attr_length (insn) == 2)
1500     return \"b%j1       %l0\";
1501   else if (get_attr_length (insn) == 4)
1502     return \"b%j1       %l0:16\";
1503   else
1504     return \"b%k1       .Lh8BR%=\;jmp   @%l0\\n.Lh8BR%=:\";
1505 }"
1506  [(set_attr "type" "branch")
1507    (set_attr "cc" "none")])
1508
1509 (define_insn "branch_false"
1510   [(set (pc)
1511         (if_then_else (match_operator 1 "comparison_operator"
1512                                       [(cc0) (const_int 0)])
1513                       (pc)
1514                       (label_ref (match_operand 0 "" ""))))]
1515   ""
1516   "*
1517 {
1518   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0
1519       && (GET_CODE (operands[1]) == GT
1520           || GET_CODE (operands[1]) == GE
1521           || GET_CODE (operands[1]) == LE
1522           || GET_CODE (operands[1]) == LT))
1523     {
1524       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
1525       return 0;
1526     }
1527
1528   if (get_attr_length (insn) == 2)
1529     return \"b%k1       %l0\";
1530   else if (get_attr_length (insn) == 4)
1531     return \"b%k1       %l0:16\";
1532   else
1533     return \"b%j1       .Lh8BR%=\;jmp   @%l0\\n.Lh8BR%=:\";
1534 }"
1535   [(set_attr "type" "branch")
1536    (set_attr "cc" "none")])
1537
1538 ;; Unconditional and other jump instructions.
1539
1540 (define_insn "jump"
1541   [(set (pc)
1542         (label_ref (match_operand 0 "" "")))]
1543   ""
1544   "*
1545 {
1546   if (get_attr_length (insn) == 2)
1547     return \"bra        %l0\";
1548   else if (get_attr_length (insn) == 4)
1549     return \"bra        %l0:16\";
1550   else
1551     return \"jmp        @%l0\";
1552 }"
1553   [(set_attr "type" "branch")
1554    (set_attr "cc" "none")])
1555
1556 ;; This is a define expand, because pointers may be either 16 or 32 bits.
1557
1558 (define_expand "tablejump"
1559   [(parallel [(set (pc) (match_operand 0 "register_operand" "r"))
1560               (use (label_ref (match_operand 1 "" "")))])]
1561   ""
1562   "")
1563
1564 (define_insn "tablejump_h8300"
1565   [(set (pc) (match_operand:HI 0 "register_operand" "r"))
1566    (use (label_ref (match_operand 1 "" "")))]
1567   "TARGET_H8300"
1568   "jmp  @%0"
1569   [(set_attr "cc" "none")
1570    (set_attr "length" "2")])
1571
1572 (define_insn "tablejump_h8300h"
1573   [(set (pc) (match_operand:SI 0 "register_operand" "r"))
1574    (use (label_ref (match_operand 1 "" "")))]
1575   "TARGET_H8300H || TARGET_H8300S"
1576   "jmp  @%0"
1577   [(set_attr "cc" "none")
1578    (set_attr "length" "2")])
1579
1580 ;; This is a define expand, because pointers may be either 16 or 32 bits.
1581
1582 (define_expand "indirect_jump"
1583   [(set (pc) (match_operand 0 "jump_address_operand" ""))]
1584   ""
1585   "")
1586
1587 (define_insn "indirect_jump_h8300"
1588   [(set (pc) (match_operand:HI 0 "jump_address_operand" "Vr"))]
1589   "TARGET_H8300"
1590   "jmp  @%0"
1591   [(set_attr "cc" "none")
1592    (set_attr "length" "2")])
1593
1594 (define_insn "indirect_jump_h8300h"
1595   [(set (pc) (match_operand:SI 0 "jump_address_operand" "Vr"))]
1596   "TARGET_H8300H || TARGET_H8300S"
1597   "jmp @%0"
1598   [(set_attr "cc" "none")
1599    (set_attr "length" "2")])
1600
1601 ;; Call subroutine with no return value.
1602
1603 ;; ??? Even though we use HImode here, this works for the 300h.
1604
1605 (define_insn "call"
1606   [(call (match_operand:QI 0 "call_insn_operand" "or")
1607          (match_operand:HI 1 "general_operand" "g"))]
1608   ""
1609   "*
1610 {
1611   if (GET_CODE (XEXP (operands[0], 0)) == SYMBOL_REF
1612       && SYMBOL_REF_FLAG (XEXP (operands[0], 0)))
1613     return \"jsr\\t@%0:8\";
1614   else
1615     return \"jsr\\t%0\";
1616 }"
1617   [(set_attr "cc" "clobber")
1618    (set (attr "length")
1619      (if_then_else (match_operand:QI 0 "small_call_insn_operand" "")
1620                    (const_int 4)
1621                    (const_int 8)))])
1622
1623 ;; Call subroutine, returning value in operand 0
1624 ;; (which must be a hard register).
1625
1626 ;; ??? Even though we use HImode here, this works on the 300h.
1627
1628 (define_insn "call_value"
1629   [(set (match_operand 0 "" "=r")
1630         (call (match_operand:QI 1 "call_insn_operand" "or")
1631               (match_operand:HI 2 "general_operand" "g")))]
1632   ""
1633   "*
1634 {
1635   if (GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF
1636       && SYMBOL_REF_FLAG (XEXP (operands[1], 0)))
1637     return \"jsr\\t@%1:8\";
1638   else
1639     return \"jsr\\t%1\";
1640 }"
1641   [(set_attr "cc" "clobber")
1642    (set (attr "length")
1643      (if_then_else (match_operand:QI 0 "small_call_insn_operand" "")
1644                    (const_int 4)
1645                    (const_int 8)))])
1646
1647 (define_insn "nop"
1648   [(const_int 0)]
1649   ""
1650   "nop"
1651   [(set_attr "cc" "none")
1652    (set_attr "length" "2")])
1653 \f
1654 ;; ----------------------------------------------------------------------
1655 ;; EXTEND INSTRUCTIONS
1656 ;; ----------------------------------------------------------------------
1657
1658 (define_expand "zero_extendqihi2"
1659   [(set (match_operand:HI 0 "register_operand" "")
1660         (zero_extend:HI (match_operand:QI 1 "general_operand_src" "")))]
1661   ""
1662   "")
1663
1664 (define_insn ""
1665   [(set (match_operand:HI 0 "register_operand" "=r,r")
1666         (zero_extend:HI (match_operand:QI 1 "general_operand_src" "0,g>")))]
1667   "TARGET_H8300"
1668   "@
1669   mov.b #0,%t0
1670   mov.b %R1,%s0\;mov.b  #0,%t0"
1671   [(set_attr "length" "2,10")
1672    (set_attr "cc" "clobber,clobber")])
1673
1674 (define_insn ""
1675   [(set (match_operand:HI 0 "register_operand" "=r,r")
1676         (zero_extend:HI (match_operand:QI 1 "general_operand_src" "0,g>")))]
1677   "TARGET_H8300H || TARGET_H8300S"
1678   "@
1679   extu.w        %T0
1680   mov.b %R1,%s0\;extu.w %T0"
1681   [(set_attr "length" "2,10")
1682    (set_attr "cc" "set_znv,set_znv")])
1683
1684 ;; The compiler can synthesize a 300H variant of this which is
1685 ;; just as efficient as one that we'd create
1686 (define_insn "zero_extendqisi2"
1687   [(set (match_operand:SI 0 "register_operand" "=r,r")
1688         (zero_extend:SI (match_operand:QI 1 "general_operand_src" "0,g>")))]
1689   "TARGET_H8300"
1690   "@
1691   mov.b #0,%x0\;sub.w   %e0,%e0
1692   mov.b %R1,%w0\;mov.b  #0,%x0\;sub.w   %e0,%e0"
1693   [(set_attr "length" "4,6")
1694    (set_attr "cc" "clobber,clobber")])
1695
1696 (define_expand "zero_extendhisi2"
1697   [(set (match_operand:SI 0 "register_operand" "")
1698         (zero_extend:SI (match_operand:HI 1 "register_operand" "")))]
1699   ""
1700   "")
1701
1702 ;; %e prints the high part of a CONST_INT, not the low part.  Arggh.
1703 (define_insn ""
1704   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1705         (zero_extend:SI (match_operand:HI 1 "general_operand_src" "0,i,g>")))]
1706   "TARGET_H8300"
1707   "@
1708   sub.w %e0,%e0
1709   mov.w %f1,%f0\;sub.w  %e0,%e0
1710   mov.w %e1,%f0\;sub.w  %e0,%e0"
1711   [(set_attr "length" "2,4,4")
1712    (set_attr "cc" "clobber,clobber,clobber")])
1713
1714 (define_insn ""
1715   [(set (match_operand:SI 0 "register_operand" "=r")
1716         (zero_extend:SI (match_operand:HI 1 "register_operand" "0")))]
1717   "TARGET_H8300H || TARGET_H8300S"
1718   "extu.l       %S0"
1719   [(set_attr "length" "2")
1720    (set_attr "cc" "set_znv")])
1721
1722 (define_expand "extendqihi2"
1723   [(set (match_operand:HI 0 "register_operand" "")
1724         (sign_extend:HI (match_operand:QI 1 "register_operand" "")))]
1725   ""
1726   "")
1727
1728 (define_insn ""
1729   [(set (match_operand:HI 0 "register_operand" "=r,r")
1730         (sign_extend:HI (match_operand:QI 1 "general_operand_src" "0,g>")))]
1731   "TARGET_H8300"
1732   "@
1733   bld   #7,%s0\;subx    %t0,%t0
1734   mov.b %R1,%s0\;bld    #7,%s0\;subx    %t0,%t0"
1735   [(set_attr "length" "4,6")
1736    (set_attr "cc" "clobber,clobber")])
1737
1738 (define_insn ""
1739   [(set (match_operand:HI 0 "register_operand" "=r")
1740         (sign_extend:HI (match_operand:QI 1 "register_operand" "0")))]
1741   "TARGET_H8300H || TARGET_H8300S"
1742   "exts.w       %T0"
1743   [(set_attr "length" "2")
1744    (set_attr "cc" "set_znv")])
1745
1746 ;; The compiler can synthesize a 300H variant of this which is
1747 ;; just as efficient as one that we'd create
1748 (define_insn "extendqisi2"
1749   [(set (match_operand:SI 0 "register_operand" "=r,r")
1750         (sign_extend:SI (match_operand:QI 1 "general_operand_src" "0,g>")))]
1751   "TARGET_H8300"
1752   "@
1753   bld   #7,%w0\;subx    %x0,%x0\;subx   %y0,%y0\;subx   %z0,%z0
1754   mov.b %R1,%w0\;bld    #7,%w0\;subx    %x0,%x0\;subx   %y0,%y0\;subx   %z0,%z0"
1755   [(set_attr "length" "8,10")
1756    (set_attr "cc" "clobber,clobber")])
1757
1758 (define_expand "extendhisi2"
1759   [(set (match_operand:SI 0 "register_operand" "")
1760         (sign_extend:SI (match_operand:HI 1 "register_operand" "")))]
1761   ""
1762   "")
1763
1764 (define_insn ""
1765   [(set (match_operand:SI 0 "register_operand" "=r,r")
1766         (sign_extend:SI (match_operand:HI 1 "general_operand_src" "0,g>")))]
1767   "TARGET_H8300"
1768   "@
1769   bld   #7,%x0\;subx    %y0,%y0\;subx   %z0,%z0
1770   mov.w %T1,%f0\;bld    #7,%x0\;subx    %y0,%y0\;subx   %z0,%z0"
1771   [(set_attr "length" "6,8")
1772    (set_attr "cc" "clobber,clobber")])
1773
1774 (define_insn ""
1775   [(set (match_operand:SI 0 "register_operand" "=r")
1776         (sign_extend:SI (match_operand:HI 1 "register_operand" "0")))]
1777   "TARGET_H8300H || TARGET_H8300S"
1778   "exts.l       %S0"
1779   [(set_attr "length" "2")
1780    (set_attr "cc" "set_znv")])
1781 \f
1782 ;; ----------------------------------------------------------------------
1783 ;; SHIFTS
1784 ;; ----------------------------------------------------------------------
1785 ;;
1786 ;; We make some attempt to provide real efficient shifting.  One example is
1787 ;; doing an 8 bit shift of a 16 bit value by moving a byte reg into the other
1788 ;; reg and moving 0 into the former reg.
1789 ;;
1790 ;; We also try to achieve this in a uniform way.  IE: We don't try to achieve
1791 ;; this in both rtl and at insn emit time.  Ideally, we'd use rtl as that would
1792 ;; give the optimizer more cracks at the code.  However, we wish to do things
1793 ;; like optimizing shifting the sign bit to bit 0 by rotating the other way.
1794 ;; There is rtl to handle this (rotate + and), but the H8/300 doesn't handle
1795 ;; 16 bit rotates.  Also, if we emit complicated rtl, combine may not be able
1796 ;; to detect cases it can optimize.
1797 ;;
1798 ;; For these and other fuzzy reasons, I've decided to go the less pretty but
1799 ;; easier "do it at insn emit time" route.
1800
1801 ;; QI BIT SHIFTS
1802
1803 (define_expand "ashlqi3"
1804   [(set (match_operand:QI 0 "register_operand" "")
1805         (ashift:QI (match_operand:QI 1 "register_operand" "")
1806                    (match_operand:QI 2 "nonmemory_operand" "")))]
1807   ""
1808   "if (expand_a_shift (QImode, ASHIFT, operands)) DONE; else FAIL;")
1809
1810 (define_expand "ashrqi3"
1811   [(set (match_operand:QI 0 "register_operand" "")
1812         (ashiftrt:QI (match_operand:QI 1 "register_operand" "")
1813                      (match_operand:QI 2 "nonmemory_operand" "")))]
1814   ""
1815   "if (expand_a_shift (QImode, ASHIFTRT, operands)) DONE; else FAIL;")
1816
1817 (define_expand "lshrqi3"
1818   [(set (match_operand:QI 0 "register_operand" "")
1819         (lshiftrt:QI (match_operand:QI 1 "register_operand" "")
1820                      (match_operand:QI 2 "nonmemory_operand" "")))]
1821   ""
1822   "if (expand_a_shift (QImode, LSHIFTRT, operands)) DONE; else FAIL;")
1823
1824 (define_insn ""
1825   [(set (match_operand:QI 0 "register_operand" "=r,r")
1826         (match_operator:QI 3 "nshift_operator"
1827                         [ (match_operand:QI 1 "register_operand" "0,0")
1828                           (match_operand:QI 2 "nonmemory_operand" "KM,rn")]))
1829    (clobber (match_scratch:QI 4 "=X,&r"))]
1830   ""
1831   "* return emit_a_shift (insn, operands);"
1832   [(set_attr "length" "20")
1833    (set_attr "cc" "clobber")])
1834
1835 ;; HI BIT SHIFTS
1836
1837 (define_expand "ashlhi3"
1838   [(set (match_operand:HI 0 "register_operand" "")
1839         (ashift:HI (match_operand:HI 1 "nonmemory_operand" "")
1840                    (match_operand:QI 2 "nonmemory_operand" "")))]
1841   ""
1842   "if (expand_a_shift (HImode, ASHIFT, operands)) DONE; else FAIL;")
1843
1844 (define_expand "lshrhi3"
1845   [(set (match_operand:HI 0 "register_operand" "")
1846         (lshiftrt:HI (match_operand:HI 1 "general_operand" "")
1847                      (match_operand:QI 2 "nonmemory_operand" "")))]
1848   ""
1849   "if (expand_a_shift (HImode, LSHIFTRT, operands)) DONE; else FAIL;")
1850
1851 (define_expand "ashrhi3"
1852   [(set (match_operand:HI 0 "register_operand" "")
1853         (ashiftrt:HI (match_operand:HI 1 "register_operand" "")
1854                      (match_operand:QI 2 "nonmemory_operand" "")))]
1855   ""
1856   "if (expand_a_shift (HImode, ASHIFTRT, operands)) DONE; else FAIL;")
1857
1858 (define_insn ""
1859   [(set (match_operand:HI 0 "register_operand" "=r,r")
1860         (match_operator:HI 3 "nshift_operator"
1861                         [ (match_operand:HI 1 "register_operand" "0,0")
1862                           (match_operand:QI 2 "nonmemory_operand" "KM,rn")]))
1863    (clobber (match_scratch:QI 4 "=X,&r"))]
1864   ""
1865   "* return emit_a_shift (insn, operands);"
1866   [(set_attr "length" "20")
1867    (set_attr "cc" "clobber")])
1868
1869 ;;  SI BIT SHIFTS
1870
1871 (define_expand "ashlsi3"
1872   [(set (match_operand:SI 0 "register_operand" "")
1873         (ashift:SI
1874          (match_operand:SI 1 "general_operand" "")
1875          (match_operand:QI 2 "nonmemory_operand" "")))]
1876   ""
1877   "if (expand_a_shift (SImode, ASHIFT, operands)) DONE; else FAIL;")
1878
1879 (define_expand "lshrsi3"
1880   [(set (match_operand:SI 0 "register_operand" "")
1881         (lshiftrt:SI
1882          (match_operand:SI 1 "general_operand" "")
1883          (match_operand:QI 2 "nonmemory_operand" "")))]
1884   ""
1885   "if (expand_a_shift (SImode, LSHIFTRT, operands)) DONE; else FAIL;")
1886
1887 (define_expand "ashrsi3"
1888   [(set (match_operand:SI 0 "register_operand" "")
1889         (ashiftrt:SI
1890          (match_operand:SI 1 "general_operand" "")
1891          (match_operand:QI 2 "nonmemory_operand" "")))]
1892   ""
1893   "if (expand_a_shift (SImode, ASHIFTRT, operands)) DONE; else FAIL;")
1894
1895 (define_insn ""
1896   [(set (match_operand:SI 0 "register_operand" "=r,r")
1897         (match_operator:SI 3 "nshift_operator"
1898                         [ (match_operand:SI 1 "register_operand" "0,0")
1899                           (match_operand:QI 2 "nonmemory_operand" "K,rn")]))
1900    (clobber (match_scratch:QI 4 "=X,&r"))]
1901   ""
1902   "* return emit_a_shift (insn, operands);"
1903   [(set_attr "length" "20")
1904    (set_attr "cc" "clobber")])
1905 \f
1906 ;; ----------------------------------------------------------------------
1907 ;; ROTATIONS
1908 ;; ----------------------------------------------------------------------
1909
1910 (define_expand "rotlqi3"
1911   [(set (match_operand:QI 0 "register_operand" "")
1912         (rotate:QI (match_operand:QI 1 "register_operand" "")
1913                    (match_operand:QI 2 "nonmemory_operand" "")))]
1914   ""
1915   "if (expand_a_rotate (ROTATE, operands)) DONE; else FAIL;")
1916
1917 (define_insn "*rotlqi3_1"
1918   [(set (match_operand:QI 0 "register_operand" "=r")
1919         (rotate:QI (match_operand:QI 1 "register_operand" "0")
1920                    (match_operand:QI 2 "immediate_operand" "")))]
1921   ""
1922   "* return emit_a_rotate (ROTATE, operands);"
1923   [(set_attr "length" "20")
1924    (set_attr "cc" "clobber")])
1925
1926 (define_expand "rotlhi3"
1927   [(set (match_operand:HI 0 "register_operand" "")
1928         (rotate:HI (match_operand:HI 1 "register_operand" "")
1929                    (match_operand:QI 2 "nonmemory_operand" "")))]
1930   ""
1931   "if (expand_a_rotate (ROTATE, operands)) DONE; else FAIL;")
1932
1933 (define_insn "*rotlhi3_1"
1934   [(set (match_operand:HI 0 "register_operand" "=r")
1935         (rotate:HI (match_operand:HI 1 "register_operand" "0")
1936                    (match_operand:QI 2 "immediate_operand" "")))]
1937   ""
1938   "* return emit_a_rotate (ROTATE, operands);"
1939   [(set_attr "length" "20")
1940    (set_attr "cc" "clobber")])
1941
1942 (define_expand "rotlsi3"
1943   [(set (match_operand:SI 0 "register_operand" "")
1944         (rotate:SI (match_operand:SI 1 "register_operand" "")
1945                    (match_operand:QI 2 "nonmemory_operand" "")))]
1946   "TARGET_H8300H || TARGET_H8300S"
1947   "if (expand_a_rotate (ROTATE, operands)) DONE; else FAIL;")
1948
1949 (define_insn "*rotlsi3_1"
1950   [(set (match_operand:SI 0 "register_operand" "=r")
1951         (rotate:SI (match_operand:SI 1 "register_operand" "0")
1952                    (match_operand:QI 2 "immediate_operand" "")))]
1953   "TARGET_H8300H || TARGET_H8300S"
1954   "* return emit_a_rotate (ROTATE, operands);"
1955   [(set_attr "length" "20")
1956    (set_attr "cc" "clobber")])
1957 \f
1958 ;; -----------------------------------------------------------------
1959 ;; BIT FIELDS
1960 ;; -----------------------------------------------------------------
1961 ;; The H8/300 has given 1/8th of its opcode space to bitfield
1962 ;; instructions so let's use them as well as we can.
1963
1964 ;; You'll never believe all these patterns perform one basic action --
1965 ;; load a bit from the source, optionally invert the bit, then store it
1966 ;; in the destination (which is known to be zero).
1967 ;;
1968 ;; Combine obviously need some work to better identify this situation and
1969 ;; canonicalize the form better.
1970
1971 ;;
1972 ;; Normal loads with a 16bit destination.
1973 ;;
1974 ;; Yes, both cases are needed.
1975 ;;
1976 (define_insn ""
1977   [(set (match_operand:HI 0 "register_operand" "=&r")
1978         (zero_extract:HI (match_operand:HI 1 "register_operand" "r")
1979                          (const_int 1)
1980                          (match_operand:HI 2 "immediate_operand" "n")))]
1981   ""
1982   "sub.w        %0,%0\;bld      %Z2,%Y1\;bst    #0,%X0"
1983   [(set_attr "cc" "clobber")
1984    (set_attr "length" "6")])
1985
1986 (define_insn ""
1987   [(set (match_operand:HI 0 "register_operand" "=&r")
1988         (subreg:HI (zero_extract:SI
1989                      (match_operand:HI 1 "register_operand" "r")
1990                      (const_int 1)
1991                      (match_operand:HI 2 "immediate_operand" "n")) 2))]
1992   ""
1993   "sub.w        %0,%0\;bld      %Z2,%Y1\;bst    #0,%X0"
1994   [(set_attr "cc" "clobber")
1995    (set_attr "length" "6")])
1996
1997 ;;
1998 ;; Inverted loads with a 16bit destination.
1999 ;;
2000 ;; Yes, all four cases are needed.
2001 ;;
2002
2003 (define_insn ""
2004   [(set (match_operand:HI 0 "register_operand" "=&r")
2005         (zero_extract:HI (xor:HI (match_operand:HI 1 "register_operand" "r")
2006                                  (match_operand:HI 3 "p_operand" "P"))
2007                          (const_int 1)
2008                          (match_operand:HI 2 "const_int_operand" "n")))]
2009   "(1 << INTVAL (operands[2])) == INTVAL (operands[3])"
2010   "sub.w        %0,%0\;bild     %Z2,%Y1\;bst    #0,%X0"
2011   [(set_attr "cc" "clobber")
2012    (set_attr "length" "8")])
2013
2014 (define_insn ""
2015   [(set (match_operand:HI 0 "register_operand" "=&r")
2016         (and:HI (not:HI
2017                   (lshiftrt:HI
2018                     (match_operand:HI 1 "bit_operand" "Ur")
2019                     (match_operand:HI 2 "const_int_operand" "n")))
2020                 (const_int 1)))]
2021   ""
2022   "sub.w        %0,%0\;bild     %Z2,%Y1\;bst    #0,%X0"
2023   [(set_attr "cc" "clobber")
2024    (set_attr "length" "8")])
2025
2026 (define_insn ""
2027   [(set (match_operand:HI 0 "register_operand" "=&r")
2028         (and:HI (not:HI
2029                   (subreg:HI
2030                     (lshiftrt:SI
2031                       (match_operand:SI 1 "register_operand" "Ur")
2032                       (match_operand:SI 2 "const_int_operand" "n")) 2))
2033                 (const_int 1)))]
2034   "INTVAL (operands[2]) < 16"
2035   "sub.w        %0,%0\;bild     %Z2,%Y1\;bst    #0,%X0"
2036   [(set_attr "cc" "clobber")
2037    (set_attr "length" "8")])
2038
2039 (define_insn ""
2040   [(set (match_operand:HI 0 "register_operand" "=&r")
2041         (and:HI (not:HI
2042                   (subreg:HI
2043                     (lshiftrt:SI
2044                       (match_operand:SI 1 "bit_operand" "Ur")
2045                       (match_operand:SI 2 "const_int_operand" "n")) 0))
2046                 (const_int 1)))]
2047   "(TARGET_H8300H || TARGET_H8300S)
2048    && INTVAL (operands[2]) < 16"
2049   "sub.w        %0,%0\;bild     %Z2,%Y1\;bst    #0,%X0"
2050   [(set_attr "cc" "clobber")
2051    (set_attr "length" "8")])
2052
2053 ;;
2054 ;; Normal loads with a 32bit destination.
2055 ;;
2056 ;; Yes, all three cases are needed.
2057 ;;
2058 (define_insn ""
2059   [(set (match_operand:SI 0 "register_operand" "=&r")
2060         (zero_extract:SI (match_operand:HI 1 "register_operand" "r")
2061                          (const_int 1)
2062                          (match_operand:HI 2 "const_int_operand" "n")))]
2063   ""
2064   "* return output_simode_bld (0, 0, operands);"
2065   [(set_attr "cc" "clobber")
2066    (set (attr "length")
2067         (if_then_else (eq (symbol_ref "TARGET_H8300H || TARGET_H8300S")
2068                           (const_int 0))
2069                       (const_int 10)
2070                       (const_int 8)))])
2071
2072 (define_insn ""
2073   [(set (match_operand:SI 0 "register_operand" "=&r")
2074         (and:SI (zero_extend:SI
2075                    (lshiftrt:QI
2076                      (match_operand:QI 1 "bit_operand" "Ur")
2077                      (match_operand:QI 2 "const_int_operand" "n")))
2078                 (const_int 1)))]
2079   ""
2080   "* return output_simode_bld (0, 0, operands);"
2081   [(set_attr "cc" "clobber")
2082    (set (attr "length")
2083         (if_then_else (eq (symbol_ref "TARGET_H8300H || TARGET_H8300S")
2084                           (const_int 0))
2085                       (const_int 10)
2086                       (const_int 8)))])
2087
2088 (define_insn ""
2089   [(set (match_operand:SI 0 "register_operand" "=&r")
2090         (and:SI (zero_extend:SI
2091                    (lshiftrt:HI
2092                       (match_operand:HI 1 "bit_operand" "Ur")
2093                       (match_operand:HI 2 "const_int_operand" "n")))
2094                 (const_int 1)))]
2095   ""
2096   "* return output_simode_bld (0, 0, operands);"
2097   [(set_attr "cc" "clobber")
2098    (set (attr "length")
2099         (if_then_else (eq (symbol_ref "TARGET_H8300H || TARGET_H8300S")
2100                           (const_int 0))
2101                       (const_int 10)
2102                       (const_int 8)))])
2103
2104 ;;
2105 ;; Inverted loads with a 32bit destination.
2106 ;;
2107 ;; Yes, all five cases are needed.
2108 ;;
2109 (define_insn ""
2110   [(set (match_operand:SI 0 "register_operand" "=&r")
2111         (and:SI (not:SI
2112                   (zero_extend:SI
2113                     (lshiftrt:HI (match_operand:HI 1 "bit_operand" "Ur")
2114                                  (match_operand:HI 2 "const_int_operand" "n"))))
2115                 (const_int 1)))]
2116   ""
2117   "* return output_simode_bld (1, 0, operands);"
2118   [(set_attr "cc" "clobber")
2119    (set (attr "length")
2120         (if_then_else (eq (symbol_ref "TARGET_H8300H || TARGET_H8300S")
2121                           (const_int 0))
2122                       (const_int 10)
2123                       (const_int 8)))])
2124
2125 (define_insn ""
2126   [(set (match_operand:SI 0 "register_operand" "=&r")
2127         (and:SI (not:SI
2128                   (zero_extend:SI
2129                     (lshiftrt:QI (match_operand:QI 1 "bit_operand" "Ur")
2130                                  (match_operand:QI 2 "const_int_operand" "n"))))
2131                 (const_int 1)))]
2132   ""
2133   "* return output_simode_bld (1, 0, operands);"
2134   [(set_attr "cc" "clobber")
2135    (set (attr "length")
2136         (if_then_else (eq (symbol_ref "TARGET_H8300H || TARGET_H8300S")
2137                           (const_int 0))
2138                       (const_int 10)
2139                       (const_int 8)))])
2140
2141 (define_insn ""
2142   [(set (match_operand:SI 0 "register_operand" "=&r")
2143         (and:SI (not:SI
2144                   (subreg:SI
2145                      (lshiftrt:HI
2146                         (match_operand:HI 1 "bit_operand" "Ur")
2147                         (match_operand:HI 2 "const_int_operand" "n")) 0))
2148                 (const_int 1)))]
2149   "1"
2150   "* return output_simode_bld (1, 0, operands);"
2151   [(set_attr "cc" "clobber")
2152    (set (attr "length")
2153         (if_then_else (eq (symbol_ref "TARGET_H8300H || TARGET_H8300S")
2154                           (const_int 0))
2155                       (const_int 10)
2156                       (const_int 8)))])
2157
2158 (define_insn ""
2159   [(set (match_operand:SI 0 "register_operand" "=&r")
2160         (and:SI (not:SI
2161                   (subreg:SI
2162                      (lshiftrt:QI
2163                         (match_operand:QI 1 "bit_operand" "Ur")
2164                         (match_operand:QI 2 "const_int_operand" "n")) 0))
2165                 (const_int 1)))]
2166   "1"
2167   "* return output_simode_bld (1, 0, operands);"
2168   [(set_attr "cc" "clobber")
2169    (set (attr "length")
2170         (if_then_else (eq (symbol_ref "TARGET_H8300H || TARGET_H8300S")
2171                           (const_int 0))
2172                       (const_int 10)
2173                       (const_int 8)))])
2174
2175 (define_insn ""
2176   [(set (match_operand:SI 0 "register_operand" "=&r")
2177         (zero_extract:SI (xor:HI (match_operand:HI 1 "register_operand" "r")
2178                                  (match_operand:HI 3 "p_operand" "P"))
2179                          (const_int 1)
2180                          (match_operand:HI 2 "const_int_operand" "n")))]
2181   "(1 << INTVAL (operands[2])) == INTVAL (operands[3])"
2182   "sub.w        %0,%0\;bild     %Z2,%Y1\;bst    #0,%X0"
2183   [(set_attr "cc" "clobber")
2184    (set_attr "length" "8")])
2185
2186 (define_expand "insv"
2187   [(set (zero_extract:HI (match_operand:HI 0 "general_operand" "")
2188                          (match_operand:HI 1 "general_operand" "")
2189                          (match_operand:HI 2 "general_operand" ""))
2190         (match_operand:HI 3 "general_operand" ""))]
2191   "TARGET_H8300"
2192   "
2193 {
2194   /* We only have single bit bitfield instructions.  */
2195   if (INTVAL (operands[1]) != 1)
2196     FAIL;
2197
2198   /* For now, we don't allow memory operands.  */
2199   if (GET_CODE (operands[0]) == MEM
2200       || GET_CODE (operands[3]) == MEM)
2201     FAIL;
2202 }")
2203
2204 (define_insn ""
2205   [(set (zero_extract:HI (match_operand:HI 0 "register_operand" "+r")
2206                          (const_int 1)
2207                          (match_operand:HI 1 "immediate_operand" "n"))
2208         (match_operand:HI 2 "register_operand" "r"))]
2209   ""
2210   "bld  #0,%R2\;bst     %Z1,%Y0 ; i1"
2211   [(set_attr "cc" "clobber")
2212    (set_attr "length" "4")])
2213
2214 (define_expand "extzv"
2215   [(set (match_operand:HI 0 "register_operand" "")
2216         (zero_extract:HI (match_operand:HI 1 "bit_operand" "")
2217                          (match_operand:HI 2 "general_operand" "")
2218                          (match_operand:HI 3 "general_operand" "")))]
2219   "TARGET_H8300"
2220   "
2221 {
2222   /* We only have single bit bitfield instructions.  */
2223   if (INTVAL (operands[2]) != 1)
2224     FAIL;
2225
2226   /* For now, we don't allow memory operands.  */
2227   if (GET_CODE (operands[1]) == MEM)
2228     FAIL;
2229 }")
2230
2231 ;; BAND, BOR, and BXOR patterns
2232
2233 (define_insn ""
2234   [(set (match_operand:HI 0 "bit_operand" "=Ur")
2235         (match_operator:HI 4 "bit_operator"
2236            [(zero_extract:HI (match_operand:HI 1 "register_operand" "r")
2237                              (const_int 1)
2238                              (match_operand:HI 2 "immediate_operand" "n"))
2239             (match_operand:HI 3 "bit_operand" "0")]))]
2240   ""
2241   "bld  %Z2,%Y1\;%b4    #0,%R0\;bst     #0,%R0; bl1"
2242   [(set_attr "cc" "clobber")
2243    (set_attr "length" "6")
2244    (set_attr "adjust_length" "no")])
2245
2246 (define_insn ""
2247   [(set (match_operand:HI 0 "bit_operand" "=Ur")
2248         (match_operator:HI 5 "bit_operator"
2249            [(zero_extract:HI (match_operand:HI 1 "register_operand" "r")
2250                              (const_int 1)
2251                              (match_operand:HI 2 "immediate_operand" "n"))
2252             (zero_extract:HI (match_operand:HI 3 "register_operand" "r")
2253                              (const_int 1)
2254                              (match_operand:HI 4 "immediate_operand" "n"))]))]
2255   ""
2256   "bld  %Z2,%Y1\;%b5    %Z4,%Y3\;bst    #0,%R0; bl3"
2257   [(set_attr "cc" "clobber")
2258    (set_attr "length" "6")
2259    (set_attr "adjust_length" "no")])
2260 \f
2261 ;; -----------------------------------------------------------------
2262 ;; COMBINE PATTERNS
2263 ;; -----------------------------------------------------------------
2264
2265 (define_insn ""
2266   [(set (match_operand:HI 0 "register_operand" "=r")
2267         (ior:HI
2268            (zero_extend:HI (match_operand:QI 1 "register_operand" "r"))
2269            (match_operand:HI 2 "register_operand" "0")))]
2270   "REG_P (operands[0])
2271    && REG_P (operands[1])
2272    && REGNO (operands[0]) != REGNO (operands[1])"
2273   "or\\t%X1,%s0"
2274   [(set_attr "cc" "clobber")
2275    (set_attr "length" "2")])
2276
2277 (define_insn ""
2278   [(set (match_operand:SI 0 "register_operand" "=r")
2279         (ior:SI
2280            (zero_extend:SI (match_operand:HI 1 "register_operand" "r"))
2281            (match_operand:SI 2 "register_operand" "0")))]
2282   "(TARGET_H8300H || TARGET_H8300S)
2283    && REG_P (operands[0])
2284    && REG_P (operands[1])
2285    && (REGNO (operands[0]) != REGNO (operands[1]))"
2286   "or.w\\t%T1,%f0"
2287   [(set_attr "cc" "clobber")
2288    (set_attr "length" "2")])
2289
2290 (define_insn ""
2291   [(set (match_operand:SI 0 "register_operand" "=r")
2292         (ior:SI
2293            (zero_extend:SI (match_operand:QI 1 "register_operand" "r"))
2294            (match_operand:SI 2 "register_operand" "0")))]
2295   "REG_P (operands[0])
2296    && REG_P (operands[1])
2297    && REGNO (operands[0]) != REGNO (operands[1])"
2298   "or\\t%X1,%s0"
2299   [(set_attr "cc" "clobber")
2300    (set_attr "length" "2")])
2301
2302 (define_insn ""
2303   [(set (match_operand:HI 0 "register_operand" "=r")
2304         (xor:HI
2305            (zero_extend:HI (match_operand:QI 1 "register_operand" "r"))
2306            (match_operand:HI 2 "register_operand" "0")))]
2307   "REG_P (operands[0])
2308    && REG_P (operands[1])
2309    && REGNO (operands[0]) != REGNO (operands[1])"
2310   "xor\\t%X1,%s0"
2311   [(set_attr "cc" "clobber")
2312    (set_attr "length" "2")])
2313
2314 (define_insn ""
2315   [(set (match_operand:SI 0 "register_operand" "=r")
2316         (xor:SI
2317            (zero_extend:SI (match_operand:HI 1 "register_operand" "r"))
2318            (match_operand:SI 2 "register_operand" "0")))]
2319   "(TARGET_H8300H || TARGET_H8300S)
2320    && REG_P (operands[0])
2321    && REG_P (operands[1])
2322    && (REGNO (operands[0]) != REGNO (operands[1]))"
2323   "xor.w\\t%T1,%f0"
2324   [(set_attr "cc" "clobber")
2325    (set_attr "length" "2")])
2326
2327 (define_insn ""
2328   [(set (match_operand:SI 0 "register_operand" "=r")
2329         (xor:SI
2330            (zero_extend:SI (match_operand:QI 1 "register_operand" "r"))
2331            (match_operand:SI 2 "register_operand" "0")))]
2332   "REG_P (operands[0])
2333    && REG_P (operands[1])
2334    && REGNO (operands[0]) != REGNO (operands[1])"
2335   "xor\\t%X1,%s0"
2336   [(set_attr "cc" "clobber")
2337    (set_attr "length" "2")])
2338
2339 (define_insn ""
2340   [(set (match_operand:HI 0 "register_operand" "=r")
2341         (ior:HI
2342            (zero_extend:HI (match_operand:QI 1 "register_operand" "0"))
2343            (ashift:HI (match_operand:HI 2 "register_operand" "r")
2344                       (const_int 8))))]
2345   "REG_P (operands[0])
2346    && REG_P (operands[2])
2347    && REGNO (operands[0]) != REGNO (operands[2])"
2348   "mov.b\\t%s2,%t0"
2349   [(set_attr "cc" "clobber")
2350    (set_attr "length" "2")])
2351
2352 (define_insn ""
2353   [(set (match_operand:SI 0 "register_operand" "=r")
2354         (ior:SI
2355            (zero_extend:SI (match_operand:HI 1 "register_operand" "0"))
2356            (ashift:SI (match_operand:SI 2 "register_operand" "r")
2357                       (const_int 16))))]
2358   "(TARGET_H8300H || TARGET_H8300S)
2359    && REG_P (operands[0])
2360    && REG_P (operands[2])
2361    && (REGNO (operands[0]) != REGNO (operands[2]))"
2362   "mov.w\\t%f2,%e0"
2363   [(set_attr "cc" "clobber")
2364    (set_attr "length" "2")])