gcc/config/h8300/h8300.md

   1 ;; GCC machine description for Hitachi H8/300
   2 ;; Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
   3
   4 ;;   Contributed by Steve Chamberlain (sac@cygnus.com),
   5 ;;   Jim Wilson (wilson@cygnus.com), and Doug Evans (dje@cygnus.com).
   6
   7 ;; This file is part of GNU CC.
   8
   9 ;; GNU CC is free software; you can redistribute it and/or modify
  10 ;; it under the terms of the GNU General Public License as published by
  11 ;; the Free Software Foundation; either version 2, or (at your option)
  12 ;; any later version.
  13
  14 ;; GNU CC is distributed in the hope that it will be useful,
  15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 ;; GNU General Public License for more details.
  18
  19 ;; You should have received a copy of the GNU General Public License
  20 ;; along with GNU CC; see the file COPYING.  If not, write to
  21 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  22
  23
  24 ;; The original PO technology requires these to be ordered by speed,
  25 ;; so that assigner will pick the fastest.
  26
  27 ;; See file "rtl.def" for documentation on define_insn, match_*, et. al.
  28
  29 (define_attr "cpu" "h8300,h8300h"
  30   (const (symbol_ref "cpu_type")))
  31
  32 ;; ??? If we can remove the operand type on all the insns, do it.
  33 ;; ??? Otherwise, try to have the operand type on all the insns.
  34
  35 (define_attr "type" "branch,return,call,arith,move,float,multi"
  36   (const_string "arith"))
  37
  38 ;; The size of instructions in bytes.
  39
  40 (define_attr "length" ""
  41   (cond [(eq_attr "type" "branch")
  42          (if_then_else (and (ge (minus (pc) (match_dup 0))
  43                                 (const_int -120))
  44                             (le (minus (pc) (match_dup 0))
  45                                 (const_int 120)))
  46                        (const_int 2)
  47                        (if_then_else (and (eq_attr "cpu" "h8300h")
  48                                           (and (ge (minus (pc) (match_dup 0))
  49                                                    (const_int -32000))
  50                                                (le (minus (pc) (match_dup 0))
  51                                                    (const_int 32000))))
  52                                      (const_int 4)
  53                                      (const_int 6)))
  54          (eq_attr "type" "move")        (const_int 4)
  55          (eq_attr "type" "return")      (const_int 2)
  56          (eq_attr "type" "float")       (const_int 12)
  57          (eq_attr "type" "call")        (const_int 4)]
  58         (const_int 200)))
  59
  60 (define_attr "cc" "none,clobber,none_0hit,set,compare,whoops,cbit"
  61   (const_string "whoops"))
  62
  63 ;; ----------------------------------------------------------------------
  64 ;; MOVE INSTRUCTIONS
  65 ;; ----------------------------------------------------------------------
  66
  67 ;; movqi
  68
  69 (define_insn "movqi_push"
  70   [(set (match_operand:QI 0 "push_operand" "=<")
  71         (match_operand:QI 1 "register_operand" "r"))]
  72   ""
  73   "*
  74 {
  75   if (TARGET_H8300)
  76     return \"push.w     %T1\";
  77   else
  78     return \"push.l     %S1\";
  79 }"
  80   [(set_attr "type" "move")
  81    (set (attr "length") (if_then_else (eq_attr "cpu" "h8300") (const_int 2) (const_int 4)))
  82    (set_attr "cc" "set")])
  83
  84 (define_insn "movqi_internal"
  85   [(set (match_operand:QI 0 "general_operand_dst" "=r,r,r,o,<,r")
  86         (match_operand:QI 1 "general_operand_src" "I,r>,io,r,r,c"))]
  87   "register_operand (operands[0],QImode) || register_operand (operands[1], QImode)"
  88   "@
  89    sub.b        %X0,%X0
  90    mov.b        %X1,%X0
  91    mov.b        %X1,%X0
  92    mov.b        %X1,%X0
  93    mov.b        %X1,%X0
  94    xor          %X0,%X0\;bst    #0,%X0"
  95   [(set_attr "type" "move")
  96    (set_attr_alternative "length"
  97      [(const_int 2) (const_int 2)
  98       (if_then_else (eq_attr "cpu" "h8300") (const_int 4) (const_int 8))
  99       (if_then_else (eq_attr "cpu" "h8300") (const_int 4) (const_int 8))
 100       (if_then_else (eq_attr "cpu" "h8300") (const_int 2) (const_int 4))
 101       (const_int 4)])
 102    (set_attr "cc" "set,set,set,set,set,none")])
 103
 104 (define_expand "movqi"
 105   [(set (match_operand:QI 0 "general_operand_dst" "")
 106         (match_operand:QI 1 "general_operand_src" ""))]
 107   ""
 108   "
 109 {
 110   /* One of the ops has to be in a register */
 111   if (!register_operand(operand0, QImode)
 112       && !register_operand(operand1, QImode))
 113     {
 114       operands[1] = copy_to_mode_reg(QImode, operand1);
 115     }
 116 }")
 117
 118 (define_insn "movstrictqi"
 119   [(set (strict_low_part (match_operand:QI 0 "general_operand_dst" "=r,r,r,o,<"))
 120                          (match_operand:QI 1 "general_operand_src" "I,r,io,r,r"))]
 121   ""
 122   "@
 123    sub.b        %X0,%X0
 124    mov.b        %X1,%X0
 125    mov.b        %X1,%X0
 126    mov.b        %X1,%X0
 127    mov.b        %X1,%X0"
 128   [(set_attr "type" "move")
 129    (set_attr_alternative "length"
 130      [(const_int 2) (const_int 2)
 131       (if_then_else (eq_attr "cpu" "h8300") (const_int 4) (const_int 8))
 132       (if_then_else (eq_attr "cpu" "h8300") (const_int 4) (const_int 8))
 133       (if_then_else (eq_attr "cpu" "h8300") (const_int 2) (const_int 4))])
 134    (set_attr "cc" "set")])
 135
 136 ;; movhi
 137
 138 (define_insn "movhi_push"
 139   [(set (match_operand:HI 0 "push_operand" "=<")
 140         (match_operand:HI 1 "register_operand" "ra"))]
 141   ""
 142   "*
 143 {
 144   if (TARGET_H8300)
 145     return \"push.w     %T1\";
 146   else
 147     return \"push.l     %S1\";
 148 }"
 149   [(set_attr "type" "move")
 150    (set (attr "length") (if_then_else (eq_attr "cpu" "h8300") (const_int 2) (const_int 4)))
 151    (set_attr "cc" "set")])
 152
 153 (define_insn "movhi_internal"
 154   [(set (match_operand:HI 0 "general_operand_dst" "=ra,ra,ra,o,<")
 155         (match_operand:HI 1 "general_operand_src" "I,ra>,ion,ra,ra"))]
 156   ""
 157   "@
 158    sub.w        %T0,%T0
 159    mov.w        %T1,%T0
 160    mov.w        %T1,%T0
 161    mov.w        %T1,%T0
 162    mov.w        %T1,%T0"
 163   [(set_attr "type" "move")
 164    (set_attr_alternative "length"
 165      [(const_int 2) (const_int 2)
 166       (if_then_else (eq_attr "cpu" "h8300") (const_int 4) (const_int 8))
 167       (if_then_else (eq_attr "cpu" "h8300") (const_int 4) (const_int 8))
 168       (if_then_else (eq_attr "cpu" "h8300") (const_int 2) (const_int 4))])
 169    (set_attr "cc" "set")])
 170
 171 (define_expand "movhi"
 172   [(set (match_operand:HI 0 "general_operand_dst" "")
 173         (match_operand:HI 1 "general_operand_src" ""))]
 174   ""
 175   "
 176 {
 177   /* One of the ops has to be in a register */
 178   if (!register_operand(operand1, HImode)
 179       && !register_operand(operand0, HImode))
 180     {
 181       operands[1] = copy_to_mode_reg(HImode, operand1);
 182     }
 183 }")
 184
 185 (define_insn "movstricthi"
 186   [(set (strict_low_part (match_operand:HI 0 "general_operand_dst" "=r,r,r,o,<"))
 187                          (match_operand:HI 1 "general_operand_src" "I,r,io,r,r"))]
 188   ""
 189   "@
 190    sub.w        %T0,%T0
 191    mov.w        %T1,%T0
 192    mov.w        %T1,%T0
 193    mov.w        %T1,%T0
 194    mov.w        %T1,%T0"
 195   [(set_attr "type" "move")
 196    (set_attr_alternative "length"
 197      [(const_int 2) (const_int 2)
 198       (if_then_else (eq_attr "cpu" "h8300") (const_int 4) (const_int 8))
 199       (if_then_else (eq_attr "cpu" "h8300") (const_int 4) (const_int 8))
 200       (if_then_else (eq_attr "cpu" "h8300") (const_int 2) (const_int 4))])
 201    (set_attr "cc" "set")])
 202
 203 ;; movsi
 204
 205 (define_expand "movsi"
 206   [(set (match_operand:SI 0 "general_operand_dst" "")
 207         (match_operand:SI 1 "general_operand_src" ""))]
 208   ""
 209   "
 210 {
 211   if (TARGET_H8300)
 212     {
 213       if (do_movsi (operands))
 214         DONE;
 215     }
 216   else /* TARGET_H8300H */
 217     {
 218       /* One of the ops has to be in a register.  */
 219       if (!register_operand (operand1, SImode)
 220           && !register_operand (operand0, SImode))
 221         {
 222           operands[1] = copy_to_mode_reg (SImode, operand1);
 223         }
 224     }
 225 }")
 226
 227 (define_expand "movsf"
 228   [(set (match_operand:SF 0 "general_operand_dst" "")
 229         (match_operand:SF 1 "general_operand_src" ""))]
 230   ""
 231   "
 232 {
 233   if (TARGET_H8300)
 234     {
 235       if (do_movsi (operands))
 236         DONE;
 237     }
 238   else /* TARGET_H8300H */
 239     {
 240       /* One of the ops has to be in a register.  */
 241       if (!register_operand (operand1, SFmode)
 242           && !register_operand (operand0, SFmode))
 243         {
 244           operands[1] = copy_to_mode_reg (SFmode, operand1);
 245         }
 246     }
 247 }")
 248
 249 (define_insn "movsi_h8300"
 250   [(set (match_operand:SI 0 "general_operand_dst" "=r,r,r,o,<,r")
 251         (match_operand:SI 1 "general_operand_src" "I,r,ion,r,r,>"))]
 252   "TARGET_H8300
 253    && (register_operand (operands[0], SImode)
 254        || register_operand (operands[1], SImode))"
 255   "*
 256 {
 257   int rn = -1;
 258   switch (which_alternative)
 259     {
 260     case 0:
 261       return \"sub.w    %e0,%e0\;sub.w  %f0,%f0\";
 262     case 1:
 263       if (REGNO(operands[0]) < REGNO(operands[1]))
 264         return \"mov.w  %e1,%e0\;mov.w  %f1,%f0\";
 265       else
 266         return \"mov.w  %f1,%f0\;mov.w  %e1,%e0\";
 267     case 2:
 268       /* Make sure we don't trample the register we index with.  */
 269
 270       if (GET_CODE(operands[1]) == MEM)
 271         {
 272           rtx inside = XEXP (operands[1],0);
 273           if  (REG_P (inside))
 274             {
 275               rn = REGNO(inside);
 276             }
 277           else if (GET_CODE (inside) == PLUS)
 278             {
 279               rtx lhs = XEXP (inside,0);
 280               rtx rhs = XEXP (inside,1);
 281               if (REG_P (lhs)) rn = REGNO (lhs);
 282               if (REG_P (rhs)) rn = REGNO (rhs);
 283             }
 284         }
 285       if (rn == REGNO (operands[0]))
 286         {
 287           /* Move the second word first.  */
 288           return \"mov.w        %f1,%f0\;mov.w  %e1,%e0\";
 289         }
 290       else
 291         {
 292           return \"mov.w        %e1,%e0\;mov.w  %f1,%f0\";
 293         }
 294
 295     case 3:
 296       return \"mov.w    %e1,%e0\;mov.w  %f1,%f0\";
 297     case 4:
 298       return \"mov.w    %f1,%T0\;mov.w  %e1,%T0\";
 299     case 5:
 300       return \"mov.w    %T1,%e0\;mov.w  %T1,%f0\";
 301     }
 302 }"
 303   [(set_attr "type" "move")
 304    (set_attr "length" "4,4,8,8,4,4")
 305    (set_attr "cc" "clobber")])
 306
 307 (define_insn "movsf_h8300"
 308   [(set (match_operand:SF 0 "general_operand_dst" "=r,r,r,o,<,r")
 309         (match_operand:SF 1 "general_operand_src" "I,r,ion,r,r,>"))]
 310   "TARGET_H8300
 311    && (register_operand (operands[0], SFmode)
 312        || register_operand (operands[1], SFmode))"
 313   "*
 314 {
 315   /* Copy of the movsi stuff */
 316   int rn = -1;
 317   switch (which_alternative)
 318     {
 319     case 0:
 320       return \"sub.w    %e0,%e0\;sub.w  %f0,%f0\";
 321     case 1:
 322       if (REGNO(operands[0]) < REGNO(operands[1]))
 323         return \"mov.w  %e1,%e0\;mov.w  %f1,%f0\";
 324       else
 325         return \"mov.w  %f1,%f0\;mov.w  %e1,%e0\";
 326     case 2:
 327       /* Make sure we don't trample the register we index with.  */
 328
 329       if (GET_CODE (operands[1]) == MEM)
 330         {
 331           rtx inside = XEXP (operands[1],0);
 332           if (REG_P (inside))
 333             {
 334               rn = REGNO (inside);
 335             }
 336           else if (GET_CODE (inside) == PLUS)
 337             {
 338               rtx lhs = XEXP (inside,0);
 339               rtx rhs = XEXP (inside,1);
 340               if (REG_P (lhs)) rn = REGNO (lhs);
 341               if (REG_P (rhs)) rn = REGNO (rhs);
 342             }
 343         }
 344       if (rn == REGNO (operands[0]))
 345         {
 346           /* move the second word first */
 347           return \"mov.w        %f1,%f0\;mov.w  %e1,%e0\";
 348         }
 349       else
 350         {
 351           return \"mov.w        %e1,%e0\;mov.w  %f1,%f0\";
 352         }
 353
 354     case 3:
 355       return \"mov.w    %e1,%e0\;mov.w  %f1,%f0\";
 356     case 4:
 357       return \"mov.w    %f1,%T0\;mov.w  %e1,%T0\";
 358     case 5:
 359       return \"mov.w    %T1,%e0\;mov.w  %T1,%f0\";
 360
 361     }
 362 }"
 363   [(set_attr "type" "move")
 364    (set_attr "length" "4,4,8,8,4,4")
 365    (set_attr "cc" "clobber")])
 366
 367 (define_insn "movsi_h8300h"
 368   [(set (match_operand:SI 0 "general_operand_dst" "=ra,ra,ra,o,<,ra")
 369         (match_operand:SI 1 "general_operand_src" "I,ra,ion,ra,ra,>"))]
 370   "TARGET_H8300H
 371    && (register_operand (operands[0], SImode)
 372        || register_operand (operands[1], SImode))"
 373   "@
 374    sub.l        %S0,%S0
 375    mov.l        %S1,%S0
 376    mov.l        %S1,%S0
 377    mov.l        %S1,%S0
 378    mov.l        %S1,%S0
 379    mov.l        %S1,%S0"
 380   [(set_attr "type" "move")
 381    (set_attr "length" "2,2,8,8,4,4")
 382    (set_attr "cc" "set")])
 383
 384 (define_insn "movsf_h8300h"
 385   [(set (match_operand:SF 0 "general_operand_dst" "=r,r,r,o,<")
 386         (match_operand:SF 1 "general_operand_src" "I,r,ion,r,r"))]
 387   "TARGET_H8300H
 388    && (register_operand (operands[0], SFmode)
 389        || register_operand (operands[1], SFmode))"
 390   "@
 391    sub.l        %S0,%S0
 392    mov.l        %S1,%S0
 393    mov.l        %S1,%S0
 394    mov.l        %S1,%S0
 395    mov.l        %S1,%S0"
 396   [(set_attr "type" "move")
 397    (set_attr "length" "2,2,8,8,4")
 398    (set_attr "cc" "set")])
 399
 400 ;; ----------------------------------------------------------------------
 401 ;; TEST INSTRUCTIONS
 402 ;; ----------------------------------------------------------------------
 403
 404 (define_insn "tstqi"
 405   [(set (cc0) (match_operand:QI 0 "register_operand" "ra"))]
 406   ""
 407   "*
 408 {
 409   /* ??? I don't think this is right.  --Jim */
 410   if (cc_prev_status.flags & CC_DONE_CBIT)
 411     return \"btst       #0,%X0\";
 412   else
 413     return \"cmp.b      #0,%X0\";
 414 }"
 415   [(set_attr "type" "arith")
 416    (set_attr "length" "4")
 417    (set_attr "cc" "set")])
 418
 419 (define_insn "tsthi"
 420   [(set (cc0) (match_operand:HI 0 "general_operand" "ra"))]
 421   ""
 422   "*
 423 {
 424   /* ??? I don't think this is right.  --Jim */
 425   if (cc_prev_status.flags & CC_DONE_CBIT)
 426     return \"btst       #0,%0l\";
 427   else
 428     return \"mov.w      %T0,%T0\";
 429 }"
 430   [(set_attr "type" "arith")
 431    (set_attr "length" "4")
 432    (set_attr "cc" "set")])
 433
 434 (define_insn "tstsi"
 435   [(set (cc0) (match_operand:SI 0 "general_operand" "ra"))]
 436   "TARGET_H8300H"
 437   "*
 438 {
 439   /* ??? I don't think this is right.  --Jim */
 440   if (cc_prev_status.flags & CC_DONE_CBIT)
 441     return \"btst       #0,%0l\";
 442   else
 443     return \"mov.l      %S0,%S0\";
 444 }"
 445   [(set_attr "type" "arith")
 446    (set_attr "length" "4")
 447    (set_attr "cc" "set")])
 448
 449 (define_insn "cmpqi"
 450   [(set (cc0)
 451         (compare:QI (match_operand:QI 0 "register_operand" "ra")
 452                     (match_operand:QI 1 "nonmemory_operand" "rai")))]
 453   ""
 454   "cmp.b        %X1,%X0"
 455   [(set_attr "type" "arith")
 456    (set_attr "length" "2")
 457    (set_attr "cc" "compare")])
 458
 459 ;; ??? 300h can have an immediate operand here.
 460
 461 (define_insn "cmphi"
 462   [(set (cc0)
 463         (compare:HI (match_operand:HI 0 "register_operand" "ra")
 464                     (match_operand:HI 1 "register_operand" "ra")))]
 465   ""
 466   "cmp.w        %T1,%T0"
 467   [(set_attr "type" "arith")
 468    (set_attr "length" "2")
 469    (set_attr "cc" "compare")])
 470
 471 ;; ??? 300h can have an immediate operand here.
 472
 473 (define_insn "cmpsi"
 474   [(set (cc0)
 475         (compare:SI (match_operand:SI 0 "register_operand" "ra")
 476                     (match_operand:SI 1 "register_operand" "ra")))]
 477   "TARGET_H8300H"
 478   "cmp.l        %S1,%S0"
 479   [(set_attr "type" "arith")
 480    (set_attr "length" "2")
 481    (set_attr "cc" "compare")])
 482
 483 ;; ----------------------------------------------------------------------
 484 ;; ADD INSTRUCTIONS
 485 ;; ----------------------------------------------------------------------
 486
 487 (define_insn "addqi3"
 488   [(set (match_operand:QI 0 "register_operand" "=r")
 489         (plus:QI (match_operand:QI 1 "register_operand" "%0")
 490                  (match_operand:QI 2 "nonmemory_operand" "ri")))]
 491   ""
 492   "add.b        %X2,%X0"
 493   [(set_attr "type" "arith")
 494    (set_attr "length" "2")
 495    (set_attr "cc" "set")])
 496
 497 ;; ??? adds operates on the 32bit register.  We can use it because we don't
 498 ;; use the e0-7 registers.
 499 ;; ??? 4 can be handled in one insn on the 300h.
 500
 501 (define_insn "addhi3_internal"
 502   [(set (match_operand:HI 0 "register_operand" "=ra,ra,ra,ra,r,ra")
 503         (plus:HI (match_operand:HI 1 "register_operand" "%0,0,0,0,0,0")
 504                  (match_operand:HI 2 "nonmemory_operand" "K,M,L,N,n,ra")))]
 505   ""
 506   "@
 507    adds %T2,%A0
 508    adds #2,%A0\;adds    %C2,%A0
 509    subs %M2,%A0
 510    subs #2,%A0\;subs    %M2,%A0
 511    add.b        %s2,%s0\;addx   %t2,%t0
 512    add.w        %T2,%T0"
 513   [(set_attr "type" "arith,multi,arith,multi,multi,arith")
 514    (set_attr "length" "2,4,2,4,4,2")
 515    (set_attr "cc" "none_0hit,none_0hit,none_0hit,none_0hit,clobber,set")])
 516
 517 ;; ??? Why is this here?
 518 (define_expand "addhi3"
 519   [(set (match_operand:HI 0 "register_operand" "")
 520         (plus:HI (match_operand:HI 1 "register_operand" "")
 521                  (match_operand:HI 2 "nonmemory_operand" "")))]
 522   ""
 523   "")
 524
 525 (define_expand "addsi3"
 526   [(set (match_operand:SI 0 "register_operand" "")
 527         (plus:SI (match_operand:SI 1 "register_operand" "")
 528                  (match_operand:SI 2 "nonmemory_operand" "")))]
 529   ""
 530   "")
 531
 532 (define_insn "addsi_h8300"
 533   [(set (match_operand:SI 0 "register_operand" "=r,r,&r")
 534         (plus:SI (match_operand:SI 1 "register_operand" "%0,0,r")
 535                  (match_operand:SI 2 "nonmemory_operand" "n,r,r")))]
 536   "TARGET_H8300"
 537   "@
 538    add  %w2,%w0\;addx   %x2,%x0\;addx   %y2,%y0\;addx   %z2,%z0
 539    add.w        %f2,%f0\;addx   %y2,%y0\;addx   %z2,%z0
 540    mov  %f1,%f0\;mov    %e1,%e0\;add.w  %f2,%f0\;addx   %y2,%y0\;addx   %z2,%z0"
 541   [(set_attr "type" "arith")
 542    (set_attr "length" "8,6,20")
 543    (set_attr "cc" "clobber")])
 544
 545 ;; ??? 4 can be handled in one insn on the 300h.
 546 ;; ??? Should the 'n' constraint be 'i' here?
 547 ;; ??? We don't handle (reg + symbol_ref) which the 300h can handle.
 548
 549 (define_insn "addsi_h8300h"
 550   [(set (match_operand:SI 0 "register_operand" "=ra,ra,ra,ra,r,ra")
 551         (plus:SI (match_operand:SI 1 "register_operand" "%0,0,0,0,0,0")
 552                  (match_operand:SI 2 "nonmemory_operand" "K,M,L,N,n,ra")))]
 553   "TARGET_H8300H"
 554   "@
 555    adds %S2,%S0
 556    adds #2,%S0\;adds    %C2,%S0
 557    subs %M2,%S0
 558    subs #2,%S0\;subs    %M2,%S0
 559    add.l        %S2,%S0
 560    add.l        %S2,%S0"
 561   [(set_attr "type" "multi,multi,multi,multi,arith,arith")
 562    (set_attr "length" "2,4,2,4,6,2")
 563    (set_attr "cc" "none_0hit,none_0hit,none_0hit,none_0hit,clobber,clobber")])
 564
 565 ;; ----------------------------------------------------------------------
 566 ;; SUBTRACT INSTRUCTIONS
 567 ;; ----------------------------------------------------------------------
 568
 569 (define_insn "subqi3"
 570   [(set (match_operand:QI 0 "register_operand" "=r,r")
 571         (minus:QI (match_operand:QI 1 "register_operand" "0,0")
 572                   (match_operand:QI 2 "nonmemory_operand" "r,i")))]
 573   ""
 574   "@
 575    sub.b        %X2,%X0
 576    add.b        %G2,%X0"
 577   [(set_attr "type" "arith")
 578    (set_attr "length" "2")
 579    (set_attr "cc" "set")])
 580
 581 ;; ??? subs operates on the 32bit register.  We can use it because we don't
 582 ;; use the e0-7 registers.
 583 ;; ??? 4 can be handled in one insn on the 300h.
 584 ;; ??? The fourth alternative can use sub.w on the 300h.
 585 ;; ??? Should the 'n' constraint be an 'i' here?
 586
 587 (define_insn "subhi3_internal"
 588   [(set (match_operand:HI 0 "register_operand" "=ra,ra,ra,r")
 589         (minus:HI (match_operand:HI 1 "general_operand" "0,0,0,0")
 590                   (match_operand:HI 2 "nonmemory_operand" "K,M,ra,n")))]
 591   ""
 592   "@
 593    subs %T2,%T0
 594    subs #2,%T0\;subs    %M2,%T0
 595    sub.w        %T2,%T0
 596    add.b        %E2,%s0\;addx   %F2,%t0 ; -%0"
 597   [(set_attr "type" "multi")
 598    (set_attr "length" "2,4,2,4")
 599    (set_attr "cc" "none_0hit,none_0hit,set,clobber")])
 600
 601 ;; ??? Why is this here?
 602 (define_expand "subhi3"
 603   [(set (match_operand:HI 0 "register_operand" "")
 604         (minus:HI (match_operand:HI 1 "register_operand" "")
 605                   (match_operand:HI 2 "nonmemory_operand" "")))]
 606   ""
 607   "")
 608
 609 (define_expand "subsi3"
 610   [(set (match_operand:SI 0 "register_operand" "")
 611         (minus:SI (match_operand:SI 1 "register_operand" "")
 612                   (match_operand:SI 2 "nonmemory_operand" "")))]
 613   ""
 614   "")
 615
 616 (define_insn "subsi3_h8300"
 617   [(set (match_operand:SI 0 "register_operand" "=r")
 618         (minus:SI (match_operand:SI 1 "register_operand" "0")
 619                   (match_operand:SI 2 "register_operand" "r")))]
 620   "TARGET_H8300"
 621   "sub.w        %f2,%f0\;subx   %y2,%y0\;subx   %z2,%z0"
 622   [(set_attr "type" "arith")
 623    (set_attr "length" "6")
 624    (set_attr "cc" "clobber")])
 625
 626 ;; ??? 4 can be handled in one insn on the 300h.
 627
 628 (define_insn "subsi3_h8300h"
 629   [(set (match_operand:SI 0 "register_operand" "=ra,ra,ra,r")
 630         (minus:SI (match_operand:SI 1 "general_operand" "0,0,0,0")
 631                   (match_operand:SI 2 "nonmemory_operand" "K,M,ra,n")))]
 632   "TARGET_H8300H"
 633   "@
 634    subs %T2,%T0
 635    subs #2,%T0\;subs    %E2,%T0
 636    sub.l        %S2,%S0
 637    sub.l        %S2,%S0"
 638   [(set_attr "type" "multi")
 639    (set_attr "length" "2,4,2,6")
 640    (set_attr "cc" "none_0hit,none_0hit,set,set")])
 641
 642 ;; ----------------------------------------------------------------------
 643 ;; MULTIPLY INSTRUCTIONS
 644 ;; ----------------------------------------------------------------------
 645
 646 ;; Note that the h8/300 can only handle umulqihi3.
 647
 648 (define_insn "mulqihi3"
 649   [(set (match_operand:HI 0 "register_operand" "=r")
 650         (mult:HI (sign_extend:HI (match_operand:QI 1 "general_operand" "%0"))
 651                  (sign_extend:HI (match_operand:QI 2 "register_operand" "r"))))]
 652   "TARGET_H8300H"
 653   "mulxs.b      %X2,%T0"
 654   [(set_attr "type" "multi")
 655    (set_attr "length" "4")
 656    (set_attr "cc" "set")])
 657
 658 (define_insn "mulhisi3"
 659   [(set (match_operand:SI 0 "register_operand" "=r")
 660         (mult:SI (sign_extend:SI (match_operand:HI 1 "general_operand" "%0"))
 661                  (sign_extend:SI (match_operand:HI 2 "register_operand" "r"))))]
 662   "TARGET_H8300H"
 663   "mulxs.w      %T2,%S0"
 664   [(set_attr "type" "multi")
 665    (set_attr "length" "4")
 666    (set_attr "cc" "set")])
 667
 668 (define_insn "umulqihi3"
 669   [(set (match_operand:HI 0 "register_operand" "=r")
 670         (mult:HI (zero_extend:HI (match_operand:QI 1 "general_operand" "%0"))
 671                  (zero_extend:HI (match_operand:QI 2 "register_operand" "r"))))]
 672   ""
 673   "mulxu        %X2,%T0"
 674   [(set_attr "type" "multi")
 675    (set_attr "length" "2")
 676    (set_attr "cc" "none_0hit")])
 677
 678 (define_insn "umulhisi3"
 679   [(set (match_operand:SI 0 "register_operand" "=r")
 680         (mult:SI (zero_extend:SI (match_operand:HI 1 "general_operand" "%0"))
 681                  (zero_extend:SI (match_operand:HI 2 "register_operand" "r"))))]
 682   "TARGET_H8300H"
 683   "mulxu.w      %T2,%S0"
 684   [(set_attr "type" "multi")
 685    (set_attr "length" "2")
 686    (set_attr "cc" "none_0hit")])
 687
 688 ;; ----------------------------------------------------------------------
 689 ;; DIVIDE INSTRUCTIONS
 690 ;; ----------------------------------------------------------------------
 691
 692 (define_insn "udivqi3"
 693   [(set (match_operand:QI 0 "register_operand" "=r")
 694         (udiv:QI (match_operand:HI 1 "general_operand" "0")
 695                  (match_operand:QI 2 "register_operand" "r")))]
 696   ""
 697   "divxu        %X2,%T0"
 698   [(set_attr "type" "multi")
 699    (set_attr "length" "2")
 700    (set_attr "cc" "clobber")])
 701
 702 ;; ??? Will divxu always work here?
 703
 704 (define_insn "divqi3"
 705   [(set (match_operand:QI 0 "register_operand" "=r")
 706         (div:QI (match_operand:HI 1 "general_operand" "0")
 707                 (match_operand:QI 2 "register_operand" "r")))]
 708   ""
 709   "divxu        %X2,%T0"
 710   [(set_attr "type" "multi")
 711    (set_attr "length" "2")
 712    (set_attr "cc" "clobber")])
 713
 714 (define_insn "udivhi3"
 715   [(set (match_operand:HI 0 "register_operand" "=r")
 716         (udiv:HI (match_operand:SI 1 "general_operand" "0")
 717                  (match_operand:HI 2 "register_operand" "r")))]
 718   "TARGET_H8300H"
 719   "divxu.w      %T2,%S0"
 720   [(set_attr "type" "multi")
 721    (set_attr "length" "2")
 722    (set_attr "cc" "clobber")])
 723
 724 (define_insn "divhi3"
 725   [(set (match_operand:HI 0 "register_operand" "=r")
 726         (div:HI (match_operand:SI 1 "general_operand" "0")
 727                 (match_operand:HI 2 "register_operand" "r")))]
 728   "TARGET_H8300H"
 729   "divxs.w      %T2,%S0"
 730   [(set_attr "type" "multi")
 731    (set_attr "length" "4")
 732    (set_attr "cc" "clobber")])
 733
 734 ;; ----------------------------------------------------------------------
 735 ;; MOD INSTRUCTIONS
 736 ;; ----------------------------------------------------------------------
 737
 738 (define_insn "umodqi3"
 739   [(set (match_operand:QI 0 "register_operand" "=r")
 740         (umod:QI (match_operand:HI 1 "general_operand" "0")
 741                  (match_operand:QI 2 "register_operand" "r")))]
 742   ""
 743   "divxu        %X2,%T0\;mov %t0,%s0"
 744   [(set_attr "type" "multi")
 745    (set_attr "length" "4")
 746    (set_attr "cc" "clobber")])
 747
 748 (define_insn "modqi3"
 749   [(set (match_operand:QI 0 "register_operand" "=r")
 750         (mod:QI (match_operand:HI 1 "general_operand" "0")
 751                 (match_operand:QI 2 "register_operand" "r")))]
 752   "TARGET_H8300H"
 753   "divxs.b      %X2,%T0\;mov %t0,%s0"
 754   [(set_attr "type" "multi")
 755    (set_attr "length" "6")
 756    (set_attr "cc" "clobber")])
 757
 758 (define_insn "umodhi3"
 759   [(set (match_operand:HI 0 "register_operand" "=r")
 760         (umod:HI (match_operand:SI 1 "general_operand" "0")
 761                  (match_operand:HI 2 "register_operand" "r")))]
 762   "TARGET_H8300H"
 763   "divxu.w      %T2,%S0\;mov %e0,%f0"
 764   [(set_attr "type" "multi")
 765    (set_attr "length" "4")
 766    (set_attr "cc" "clobber")])
 767
 768 (define_insn "modhi3"
 769   [(set (match_operand:HI 0 "register_operand" "=r")
 770         (mod:HI (match_operand:SI 1 "general_operand" "0")
 771                 (match_operand:HI 2 "register_operand" "r")))]
 772   "TARGET_H8300H"
 773   "divxs.w      %T2,%S0\;mov %e0,%f0"
 774   [(set_attr "type" "multi")
 775    (set_attr "length" "6")
 776    (set_attr "cc" "clobber")])
 777
 778 ;; ----------------------------------------------------------------------
 779 ;; AND INSTRUCTIONS
 780 ;; ----------------------------------------------------------------------
 781
 782 (define_insn "andqi3_internal"
 783   [(set (match_operand:QI 0 "bit_operand" "=r,U")
 784         (and:QI (match_operand:QI 1 "bit_operand" "%0,0")
 785                 (match_operand:QI 2 "nonmemory_operand" "rn,O")))]
 786   "register_operand (operands[0], QImode) || o_operand (operands[2], QImode)"
 787   "@
 788    and  %X2,%X0
 789    bclr %W2,%X0"
 790   [(set_attr "type" "arith")
 791    (set_attr "length" "2,4")
 792    (set_attr "cc" "set,none_0hit")])
 793
 794 (define_expand "andqi3"
 795   [(set (match_operand:QI 0 "bit_operand" "=r,U")
 796         (and:QI (match_operand:QI 1 "bit_operand" "%0,0")
 797                 (match_operand:QI 2 "nonmemory_operand" "rn,O")))]
 798   ""
 799   "
 800 {
 801   if (fix_bit_operand (operands, 'O', AND))
 802     DONE;
 803 }")
 804
 805 ;; ??? Should have a bclr case here also.
 806
 807 (define_insn "andhi3"
 808   [(set (match_operand:HI 0 "register_operand" "=r")
 809         (and:HI (match_operand:HI 1 "register_operand" "%0")
 810                 (match_operand:HI 2 "nonmemory_operand" "ri")))]
 811   ""
 812   "*
 813 {
 814   if (GET_CODE (operands[2]) == CONST_INT)
 815     {
 816       int i = INTVAL (operands[2]);
 817       if ((i & 0x00ff) != 0x00ff)
 818         output_asm_insn (\"and  %s2,%s0\", operands);
 819       if ((i & 0xff00) != 0xff00)
 820         output_asm_insn (\"and  %t2,%t0\", operands);
 821       return \"\";
 822     }
 823   return \"and  %s2,%s0\;and    %t2,%t0;\";
 824 }"
 825   [(set_attr "type" "multi")
 826    (set_attr "length" "4")
 827    (set_attr "cc" "clobber")])
 828
 829 ;; ??? There is an iorsi3 for TARGET_H8300.  Should we have andsi3?
 830
 831 (define_insn "andsi3"
 832   [(set (match_operand:SI 0 "register_operand" "=r,r")
 833         (and:SI (match_operand:SI 1 "register_operand" "%0,0")
 834                 (match_operand:SI 2 "nonmemory_operand" "r,i")))]
 835   "TARGET_H8300H"
 836   "@
 837    and  %S2,%S0
 838    and  %S2,%S0"
 839   [(set_attr "type" "arith")
 840    (set_attr "length" "4,6")
 841    (set_attr "cc" "clobber")])
 842
 843 ;; ----------------------------------------------------------------------
 844 ;; OR INSTRUCTIONS
 845 ;; ----------------------------------------------------------------------
 846
 847 (define_insn "iorqi3_internal"
 848   [(set (match_operand:QI 0 "bit_operand" "=U,r")
 849         (ior:QI (match_operand:QI 1 "bit_operand" "%0,0")
 850                 (match_operand:QI 2 "nonmemory_operand" "P,rn")))]
 851   "register_operand (operands[0], QImode) || p_operand (operands[2], QImode)"
 852   "@
 853    bset %V2,%X0
 854    or   %X2,%X0"
 855   [(set_attr "type" "arith")
 856    (set_attr "length" "4,2")
 857    (set_attr "cc" "none_0hit,set")])
 858
 859 (define_expand "iorqi3"
 860   [(set (match_operand:QI 0 "bit_operand" "=r,U")
 861         (ior:QI (match_operand:QI 1 "bit_operand" "%0,0")
 862                 (match_operand:QI 2 "nonmemory_operand" "rn,P")))]
 863   ""
 864   "
 865 {
 866   if (fix_bit_operand (operands, 'P', IOR))
 867     DONE;
 868 }")
 869
 870 ;; ??? Should have a bset case here also.
 871
 872 (define_insn "iorhi3"
 873   [(set (match_operand:HI 0 "general_operand" "=r,r")
 874         (ior:HI (match_operand:HI 1 "general_operand" "%0,0")
 875                 (match_operand:HI 2 "general_operand" "J,ri")))]
 876   ""
 877   "*
 878 {
 879   if (TARGET_H8300)
 880     {
 881       if (GET_CODE (operands[2]) == CONST_INT)
 882         {
 883           int i = INTVAL (operands[2]);
 884           if ((i & 0x00ff) != 0)
 885             output_asm_insn (\"or       %s2,%s0\", operands);
 886           if ((i & 0xff00) != 0)
 887             output_asm_insn (\"or       %t2,%t0\", operands);
 888           return \"\";
 889         }
 890       return \"or       %s2,%s0\;or     %t2,%t0; %2 or2\";
 891     }
 892   else
 893     {
 894       return \"or       %S2,%S0\";
 895     }
 896 }"
 897   [(set_attr "type" "multi")
 898    (set_attr "length" "2,4")
 899    (set_attr "cc" "clobber,clobber")])
 900
 901 (define_insn "iorsi3"
 902   [(set (match_operand:SI 0 "register_operand" "=r")
 903         (ior:SI (match_operand:SI 1 "register_operand" "%0")
 904                 (match_operand:SI 2 "nonmemory_operand" "ri")))]
 905   ""
 906   "*
 907 {
 908   if (TARGET_H8300)
 909     {
 910       if (GET_CODE (operands[2]) == CONST_INT)
 911         {
 912           int i = INTVAL (operands[2]);
 913           if ((i & 0x000000ff) != 0)
 914             output_asm_insn (\"or       %w2,%w0\", operands);
 915           if ((i & 0x0000ff00) != 0)
 916             output_asm_insn (\"or       %x2,%x0\", operands);
 917           if ((i & 0x00ff0000) != 0)
 918             output_asm_insn (\"or       %y2,%y0\", operands);
 919           if ((i & 0xff000000) != 0)
 920             output_asm_insn (\"or       %z2,%z0\", operands);
 921           return \"\";
 922         }
 923       return \"or       %w2,%w0\;or     %x2,%x0\;or     %y2,%y0\;or     %z2,%z0\;\";
 924     }
 925   else
 926     {
 927       return \"or       %S2,%S0\";
 928     }
 929 }"
 930   [(set_attr "type" "multi")
 931    (set_attr "length" "8")
 932    (set_attr "cc" "clobber")])
 933
 934 ;; ----------------------------------------------------------------------
 935 ;; XOR INSTRUCTIONS
 936 ;; ----------------------------------------------------------------------
 937
 938 (define_insn "xorqi3_internal"
 939   [(set (match_operand:QI 0 "bit_operand" "=r,U")
 940         (xor:QI (match_operand:QI 1 "bit_operand" "%0,0")
 941                 (match_operand:QI 2 "nonmemory_operand" "rn,P")))]
 942   "register_operand (operands[0], QImode) || p_operand (operands[2], QImode)"
 943   "@
 944    xor  %X2,%X0
 945    bnot %V2,%X0"
 946   [(set_attr "type" "arith")
 947    (set_attr "length" "2,4")
 948    (set_attr "cc" "set,none_0hit")])
 949
 950 (define_expand "xorqi3"
 951   [(set (match_operand:QI 0 "bit_operand" "=r,U")
 952         (xor:QI (match_operand:QI 1 "bit_operand" "%0,0")
 953                 (match_operand:QI 2 "nonmemory_operand" "rn,O")))]
 954   ""
 955   "
 956 {
 957   if (fix_bit_operand (operands, 'O', XOR))
 958     DONE;
 959 }")
 960
 961 (define_insn "xorhi3"
 962   [(set (match_operand:HI 0 "register_operand" "=r")
 963         (xor:HI (match_operand:HI 1 "general_operand" "%0")
 964                 (match_operand:HI 2 "nonmemory_operand" "ri")))]
 965   ""
 966   "*
 967 {
 968   if (TARGET_H8300)
 969     return \"xor        %s2,%s0\;xor    %t2,%t0\";
 970   else
 971     return \"xor        %S2,%S0\";
 972 }"
 973   [(set_attr "type" "multi")
 974    (set_attr "length" "4")
 975    (set_attr "cc" "clobber")])
 976
 977 ;; ??? There is an iorsi3 for TARGET_H8300.  Should we have xorsi3?
 978
 979 (define_insn "xorsi3"
 980   [(set (match_operand:SI 0 "register_operand" "=r,r")
 981         (xor:SI (match_operand:SI 1 "register_operand" "%0,0")
 982                 (match_operand:SI 2 "nonmemory_operand" "r,i")))]
 983   "TARGET_H8300H"
 984   "@
 985    xor  %S2,%S0
 986    xor  %S2,%S0"
 987   [(set_attr "type" "arith")
 988    (set_attr "length" "4,6")
 989    (set_attr "cc" "clobber")])
 990
 991 ;; ----------------------------------------------------------------------
 992 ;; NEGATION INSTRUCTIONS
 993 ;; ----------------------------------------------------------------------
 994
 995 (define_insn "negqi2"
 996   [(set (match_operand:QI 0 "register_operand" "=r")
 997         (neg:QI (match_operand:QI 1 "general_operand" "0")))]
 998   ""
 999   "neg  %X0"
1000   [(set_attr "type" "arith")
1001    (set_attr "length" "2")
1002    (set_attr "cc" "clobber")])
1003
1004 (define_expand "neghi2"
1005   [(set (match_operand:HI 0 "register_operand" "=r")
1006         (neg:HI (match_operand:HI 1 "general_operand" "0")))]
1007   ""
1008   "
1009 {
1010   if (TARGET_H8300)
1011     {
1012       emit_insn (gen_neghi2_h8300 (operands[0], operands[1]));
1013       DONE;
1014     }
1015 }")
1016
1017 (define_expand "neghi2_h8300"
1018   [(set (match_dup 2)
1019         (not:HI (match_operand:HI 1 "register_operand" "r")))
1020    (set (match_dup 2) (plus:HI (match_dup 2) (const_int 1)))
1021    (set (match_operand:HI 0 "register_operand" "=r")
1022         (match_dup 2))]
1023   ""
1024   "{ operands[2] = gen_reg_rtx (HImode); }")
1025
1026 (define_insn "neghi2_h8300h"
1027   [(set (match_operand:HI 0 "register_operand" "=r")
1028         (neg:HI (match_operand:HI 1 "general_operand" "0")))]
1029   "TARGET_H8300H"
1030   "neg  %T0"
1031   [(set_attr "type" "arith")
1032    (set_attr "length" "2")
1033    (set_attr "cc" "clobber")])
1034
1035 (define_expand "negsi2"
1036   [(set (match_operand:SI 0 "register_operand" "=r")
1037         (neg:SI (match_operand:SI 1 "general_operand" "0")))]
1038   ""
1039   "
1040 {
1041   if (TARGET_H8300)
1042     {
1043       emit_insn (gen_negsi2_h8300 (operands[0], operands[1]));
1044       DONE;
1045     }
1046 }")
1047
1048 (define_expand "negsi2_h8300"
1049   [(set (match_dup 2)
1050         (not:SI (match_operand:SI 1 "register_operand" "r")))
1051    (set (match_dup 2) (plus:SI (match_dup 2) (const_int 1)))
1052    (set (match_operand:SI 0 "register_operand" "=r")
1053         (match_dup 2))]
1054   ""
1055   "{ operands[2] = gen_reg_rtx(SImode); }")
1056
1057 (define_insn "negsi2_h8300h"
1058   [(set (match_operand:SI 0 "register_operand" "=r")
1059         (neg:SI (match_operand:SI 1 "general_operand" "0")))]
1060   "TARGET_H8300H"
1061   "neg  %S0"
1062   [(set_attr "type" "arith")
1063    (set_attr "length" "2")
1064    (set_attr "cc" "clobber")])
1065
1066 ;; ----------------------------------------------------------------------
1067 ;; NOT INSTRUCTIONS
1068 ;; ----------------------------------------------------------------------
1069
1070 (define_insn "one_cmplqi2"
1071   [(set (match_operand:QI 0 "register_operand" "=r")
1072         (not:QI (match_operand:QI 1 "general_operand" "0")))]
1073   ""
1074   "not  %X0"
1075   [(set_attr "type" "arith")
1076    (set_attr "length" "2")
1077    (set_attr "cc" "set")])
1078
1079 (define_insn "one_cmplhi2"
1080   [(set (match_operand:HI 0 "register_operand" "=r")
1081         (not:HI (match_operand:HI 1 "general_operand" "0")))]
1082   ""
1083   "*
1084 {
1085   if (TARGET_H8300)
1086     return \"not        %s0\;not        %t0\";
1087   else
1088     return \"not        %T0\";
1089 }"
1090   [(set_attr "type" "arith")
1091    (set_attr "length" "4")
1092    (set_attr "cc" "clobber")])
1093
1094 (define_insn "one_cmplsi2"
1095   [(set (match_operand:SI 0 "register_operand" "=r")
1096         (not:SI (match_operand:SI 1 "general_operand" "0")))]
1097   ""
1098   "*
1099 {
1100   if (TARGET_H8300)
1101     return \"not        %w0\;not        %x0\;not        %y0\;not        %z0\";
1102   else
1103     return \"not        %S0\";
1104 }"
1105   [(set_attr "type" "arith")
1106 ;; ??? length is wrong for 300h
1107    (set_attr "length" "8")
1108    (set_attr "cc" "clobber")])
1109
1110 ;; ----------------------------------------------------------------------
1111 ;; JUMP INSTRUCTIONS
1112 ;; ----------------------------------------------------------------------
1113
1114 ;; Conditional jump instructions
1115
1116 (define_expand "ble"
1117   [(set (pc)
1118         (if_then_else (le (cc0)
1119                           (const_int 0))
1120                       (label_ref (match_operand 0 "" ""))
1121                       (pc)))]
1122   ""
1123   "")
1124
1125 (define_expand "bleu"
1126   [(set (pc)
1127         (if_then_else (leu (cc0)
1128                            (const_int 0))
1129                       (label_ref (match_operand 0 "" ""))
1130                       (pc)))]
1131   ""
1132   "")
1133
1134 (define_expand "bge"
1135   [(set (pc)
1136         (if_then_else (ge (cc0)
1137                           (const_int 0))
1138                       (label_ref (match_operand 0 "" ""))
1139                       (pc)))]
1140   ""
1141   "")
1142
1143 (define_expand "bgeu"
1144   [(set (pc)
1145         (if_then_else (geu (cc0)
1146                            (const_int 0))
1147                       (label_ref (match_operand 0 "" ""))
1148                       (pc)))]
1149   ""
1150   "")
1151
1152 (define_expand "blt"
1153   [(set (pc)
1154         (if_then_else (lt (cc0)
1155                           (const_int 0))
1156                       (label_ref (match_operand 0 "" ""))
1157                       (pc)))]
1158   ""
1159   "")
1160
1161 (define_expand "bltu"
1162   [(set (pc)
1163         (if_then_else (ltu (cc0)
1164                            (const_int 0))
1165                       (label_ref (match_operand 0 "" ""))
1166                       (pc)))]
1167   ""
1168   "")
1169
1170 (define_expand "bgt"
1171   [(set (pc)
1172         (if_then_else (gt (cc0)
1173                           (const_int 0))
1174                       (label_ref (match_operand 0 "" ""))
1175                       (pc)))]
1176   ""
1177   "")
1178
1179 (define_expand "bgtu"
1180   [(set (pc)
1181         (if_then_else (gtu (cc0)
1182                            (const_int 0))
1183                       (label_ref (match_operand 0 "" ""))
1184                       (pc)))]
1185   ""
1186   "")
1187
1188 (define_expand "beq"
1189   [(set (pc)
1190         (if_then_else (eq (cc0)
1191                           (const_int 0))
1192                       (label_ref (match_operand 0 "" ""))
1193                       (pc)))]
1194   ""
1195   "")
1196
1197 (define_expand "bne"
1198   [(set (pc)
1199         (if_then_else (ne (cc0)
1200                           (const_int 0))
1201                       (label_ref (match_operand 0 "" ""))
1202                       (pc)))]
1203   ""
1204   "")
1205
1206 (define_insn "branch_true"
1207   [(set (pc)
1208         (if_then_else (match_operator 1 "comparison_operator"
1209                                       [(cc0) (const_int 0)])
1210                       (label_ref (match_operand 0 "" ""))
1211                       (pc)))]
1212   ""
1213   "*
1214 {
1215   if (get_attr_length (insn) == 2)
1216     return \"b%j1       %l0\";
1217   else if (get_attr_length (insn) == 4)
1218     return \"b%j1       %l0:16\";
1219   else
1220     return \"b%k1       %L0\;jmp        @%l0\;%L0:\";
1221 }"
1222  [(set_attr "type" "branch")
1223    (set_attr "cc" "none")])
1224
1225 (define_insn "branch_false"
1226   [(set (pc)
1227         (if_then_else (match_operator 1 "comparison_operator"
1228                                       [(cc0) (const_int 0)])
1229                       (pc)
1230                       (label_ref (match_operand 0 "" ""))))]
1231   ""
1232 ;; ??? We don't take advantage of 16 bit relative jumps in the 300h.
1233   "*
1234 {
1235   if (get_attr_length (insn) == 2)
1236     return \"b%k1       %l0\";
1237   else if (get_attr_length (insn) == 4)
1238     return \"b%k1       %l0:16\";
1239   else
1240     return \"b%j1       %L0\;jmp        @%l0\;%L0:\";
1241 }"
1242   [(set_attr "type" "branch")
1243    (set_attr "cc" "none")])
1244
1245 ;; Unconditional and other jump instructions.
1246
1247 (define_insn "jump"
1248   [(set (pc)
1249         (label_ref (match_operand 0 "" "")))]
1250   ""
1251   "*
1252 {
1253   if (get_attr_length (insn) == 2)
1254     return \"bra        %l0\";
1255   else if (get_attr_length (insn) == 4)
1256     return \"bra        %l0:16\";
1257   else
1258     return \"jmp        @%l0\";
1259 }"
1260   [(set_attr "type" "branch")
1261    (set_attr "cc" "none")])
1262
1263 ;; This is a define expand, because pointers may be either 16 or 32 bits.
1264
1265 (define_expand "tablejump"
1266   [(parallel [(set (pc) (match_operand 0 "register_operand" "r"))
1267               (use (label_ref (match_operand 1 "" "")))])]
1268   ""
1269   "")
1270
1271 (define_insn "tablejump_h8300"
1272   [(set (pc) (match_operand:HI 0 "register_operand" ""))
1273    (use (label_ref (match_operand 1 "" "")))]
1274   "TARGET_H8300"
1275   "jmp  @%0"
1276   [(set_attr "type" "branch")
1277    (set_attr "cc" "none")
1278    (set_attr "length" "2")])
1279
1280 (define_insn "tablejump_h8300h"
1281   [(set (pc) (match_operand:SI 0 "register_operand" ""))
1282    (use (label_ref (match_operand 1 "" "")))]
1283   "TARGET_H8300H"
1284   "jmp  @%0"
1285   [(set_attr "type" "branch")
1286    (set_attr "cc" "none")
1287    (set_attr "length" "2")])
1288
1289 ;; This is a define expand, because pointers may be either 16 or 32 bits.
1290
1291 ;(define_insn "indirect_jump"
1292 ;  [(set (pc) (match_operand:HI 0 "register_operand" "r"))]
1293 ;  ""
1294 ;  "jmp @%0"
1295 ;  [(set_attr "type" "branch")
1296 ;   (set_attr "cc" "none")
1297 ;   (set_attr "length" "2")])
1298
1299 (define_expand "indirect_jump"
1300   [(set (pc) (match_operand 0 "jump_address_operand" "Vr"))]
1301   ""
1302   "")
1303
1304 (define_insn "indirect_jump_h8300"
1305   [(set (pc) (match_operand:HI 0 "jump_address_operand" "V,r"))]
1306   "TARGET_H8300"
1307   "@
1308    jmp  @%0
1309    jmp  @%0"
1310   [(set_attr "type" "branch")
1311    (set_attr "cc" "none")
1312    (set_attr "length" "2")])
1313
1314 (define_insn "indirect_jump_h8300h"
1315   [(set (pc) (match_operand:SI 0 "jump_address_operand" "V,r"))]
1316   "TARGET_H8300H"
1317   "@
1318    jmp @%0
1319    jmp @%0"
1320   [(set_attr "type" "branch")
1321    (set_attr "cc" "none")
1322    (set_attr "length" "2")])
1323
1324 ;; Call subroutine with no return value.
1325
1326 ;; ??? Even though we use HImode here, this works for the 300h.
1327
1328 (define_insn "call"
1329   [(call (match_operand:QI 0 "call_insn_operand" "or")
1330          (match_operand:HI 1 "general_operand" "g"))]
1331   ""
1332   "jsr  %0"
1333   [(set_attr "type" "call")
1334    (set_attr "cc" "clobber")
1335    (set_attr "length" "4")])
1336
1337 ;; Call subroutine, returning value in operand 0
1338 ;; (which must be a hard register).
1339
1340 ;; ??? Even though we use HImode here, this works on the 300h.
1341
1342 (define_insn "call_value"
1343   [(set (match_operand 0 "" "=r")
1344         (call (match_operand:QI 1 "call_insn_operand" "or")
1345               (match_operand:HI 2 "general_operand" "g")))]
1346   ""
1347   "jsr  %1"
1348   [(set_attr "type" "call")
1349    (set_attr "cc" "clobber")
1350    (set_attr "length" "4")])
1351
1352 (define_insn "nop"
1353   [(const_int 0)]
1354   ""
1355   "nop"
1356   [(set_attr "type" "multi")
1357    (set_attr "cc" "none")
1358    (set_attr "length" "2")])
1359
1360 ;; ----------------------------------------------------------------------
1361 ;; EXTEND INSTRUCTIONS
1362 ;; ----------------------------------------------------------------------
1363
1364 (define_insn "zero_extendqihi2"
1365   [(set (match_operand:HI 0 "register_operand" "=r,r")
1366         (zero_extend:HI (match_operand:QI 1 "general_operand" "0,g")))]
1367   ""
1368   "*
1369 {
1370   if (which_alternative==0)
1371     return \"mov.b      #0,%t0\";
1372
1373   if (TARGET_H8300)
1374     return \"mov.b      %X1,%s0\;mov.b  #0,%t0\";
1375   else
1376     {
1377       /* ??? See how often this gets optimized.  */
1378       if (REG_P (operands[1]) && (REGNO (operands[1]) == REGNO (operands[0])))
1379         return \"extu.w %T0\";
1380       else
1381         return \"mov.b  %X1,%s0\;extu.w %T0\";
1382     }
1383 }"
1384   [(set_attr "type" "multi")
1385 ;; ??? This length is wrong for one case.
1386    (set_attr "length" "4")
1387    (set_attr "cc" "clobber")])
1388
1389 (define_insn "zero_extendhisi2"
1390   [(set (match_operand:SI 0 "register_operand" "=r")
1391         (zero_extend:SI (match_operand:HI 1 "general_operand" "g")))]
1392   "TARGET_H8300H"
1393   "*
1394 {
1395   /* ??? See how often this gets optimized.  */
1396   if (REG_P (operands[1]) && (REGNO (operands[1]) == REGNO (operands[0])))
1397     return \"extu.l     %S0\";
1398   else
1399     return \"mov.w      %T1,%T0\;extu.l %S0\";
1400 }"
1401   [(set_attr "type" "multi")
1402 ;; ??? This length is wrong for one case.
1403    (set_attr "length" "4")
1404    (set_attr "cc" "clobber")])
1405
1406 (define_insn "extendqihi2"
1407   [(set (match_operand:HI 0 "register_operand" "=r")
1408         (sign_extend:HI (match_operand:QI 1 "general_operand" "g")))]
1409   ""
1410   "*
1411 {
1412   if (TARGET_H8300)
1413     {
1414       /* ??? See how often this gets optimized.  */
1415       if (REG_P (operands[1]) && (REGNO (operands[1]) == REGNO (operands[0])))
1416         return \"bld    #7,%s0\;subx    %t0,%t0\";
1417       else
1418         return \"mov.b  %X1,%s0\;bld    #7,%s0\;subx    %t0,%t0\";
1419     }
1420   else
1421     {
1422       /* ??? See how often this gets optimized.  */
1423       if (REG_P (operands[1]) && (REGNO (operands[1]) == REGNO (operands[0])))
1424         return \"exts.w %T0\";
1425       else
1426         return \"mov.b  %X1,%s0\;exts.w %T0\";
1427     }
1428 }"
1429   [(set_attr "type" "multi")
1430 ;; ??? Length is wrong in some cases.
1431    (set_attr "length" "6")
1432    (set_attr "cc" "clobber")])
1433
1434 (define_expand "extendhisi2"
1435   [(set (match_operand:SI 0 "register_operand" "")
1436         (sign_extend:SI (match_operand:HI 1 "general_operand" "")))]
1437   ""
1438   "
1439 {
1440   if (TARGET_H8300)
1441     emit_insn (gen_extendhisi2_h8300 (operands[0], operands[1]));
1442   else
1443     emit_insn (gen_extendhisi2_h8300h (operands[0], operands[1]));
1444   DONE;
1445 }")
1446
1447 (define_expand "extendhisi2_h8300"
1448   [(set (reg:HI 1) (match_operand:HI 1 "general_operand" ""))
1449    (set (reg:SI 0) (sign_extend:SI (reg:HI 1)))
1450    (set (match_operand:SI 0 "general_operand" "" ) (reg:SI 0))]
1451   "TARGET_H8300"
1452   "")
1453
1454 (define_expand "extendhisi2_h8300h"
1455   [(set (match_operand:SI 0 "register_operand" "")
1456         (sign_extend:SI (match_operand:HI 1 "general_operand" "")))]
1457   "TARGET_H8300H"
1458   "")
1459
1460 (define_insn "extendhisi2_h8300_internal"
1461   [(set (match_operand:SI 0 "register_operand" "=r")
1462         (sign_extend:SI (match_operand:HI 1 "register_operand" "0")))]
1463   "TARGET_H8300"
1464   "mov.w        %T1,%f0\;bld    #7,%x0\;subx    %y0,%y0\;subx   %z0,%z0"
1465   [(set_attr "length" "10")
1466    (set_attr "cc" "clobber")])
1467
1468 (define_insn "extendhisi2_h8300h_internal"
1469   [(set (match_operand:SI 0 "register_operand" "=r")
1470         (sign_extend:SI (match_operand:HI 1 "general_operand" "g")))]
1471   "TARGET_H8300H"
1472   "*
1473 {
1474   /* ??? See how often this gets optimized.  */
1475   if (REG_P (operands[1]) && (REGNO (operands[1]) == REGNO (operands[0])))
1476     return \"exts.l     %S0\";
1477   else
1478     return \"mov.w      %T1,%T0\;exts.l %S0\";
1479 }"
1480   [(set_attr "length" "10")
1481    (set_attr "cc" "clobber")])
1482
1483 ;; ----------------------------------------------------------------------
1484 ;; SHIFTS
1485 ;; ----------------------------------------------------------------------
1486 ;;
1487 ;; We make some attempt to provide real efficient shifting.  One example is
1488 ;; doing an 8 bit shift of a 16 bit value by moving a byte reg into the other
1489 ;; reg and moving 0 into the former reg.
1490 ;;
1491 ;; We also try to achieve this in a uniform way.  IE: We don't try to achieve
1492 ;; this in both rtl and at insn emit time.  Ideally, we'd use rtl as that would
1493 ;; give the optimizer more cracks at the code.  However, we wish to do things
1494 ;; like optimizing shifting the sign bit to bit 0 by rotating the other way.
1495 ;; There is rtl to handle this (rotate + and), but the h8/300 doesn't handle
1496 ;; 16 bit rotates.  Also, if we emit complicated rtl, combine may not be able
1497 ;; to detect cases it can optimize.
1498 ;;
1499 ;; For these and other fuzzy reasons, I've decided to go the less pretty but
1500 ;; easier "do it at insn emit time" route.
1501
1502 ;; QI BIT SHIFTS
1503
1504 (define_expand "ashlqi3"
1505   [(set (match_operand:QI 0 "register_operand" "")
1506         (ashift:QI (match_operand:QI 1 "register_operand" "")
1507                    (match_operand:QI 2 "nonmemory_operand" "")))]
1508   ""
1509   "if (expand_a_shift (QImode, ASHIFT, operands)) DONE;else FAIL;")
1510
1511 (define_expand "ashrqi3"
1512   [(set (match_operand:QI 0 "register_operand" "")
1513         (ashiftrt:QI (match_operand:QI 1 "register_operand" "")
1514                      (match_operand:QI 2 "nonmemory_operand" "")))]
1515   ""
1516   "if (expand_a_shift (QImode, ASHIFTRT, operands)) DONE;else FAIL;")
1517
1518 (define_expand "lshrqi3"
1519   [(set (match_operand:QI 0 "register_operand" "")
1520         (lshiftrt:QI (match_operand:QI 1 "register_operand" "")
1521                      (match_operand:QI 2 "nonmemory_operand" "")))]
1522   ""
1523   "if (expand_a_shift (QImode, LSHIFTRT, operands)) DONE;else FAIL;")
1524
1525 ;; WARNING: The constraints on the scratch register say one is not needed
1526 ;; for constant shifts of 1,2,3,4.  Emit_a_shift() must know this.
1527
1528 (define_insn "shiftbyn_QI"
1529   [(set (match_operand:QI 0 "register_operand" "=r,r")
1530         (match_operator:QI 3 "nshift_operator"
1531                         [ (match_operand:QI 1 "register_operand" "0,0")
1532                           (match_operand:QI 2 "nonmemory_operand" "IKM,rn")]))
1533    (clobber (match_scratch:QI 4 "=X,&r"))]
1534   ""
1535   "* return emit_a_shift (insn, operands);"
1536   [(set_attr "type" "arith")
1537    (set_attr "length" "20")
1538 ;; ??? We'd like to indicate that cc is set here, and it is for simple shifts.
1539 ;; However, for cases that loop or are done in pieces, cc does not contain
1540 ;; what we want.  Emit_a_shift is free to tweak cc_status as desired.
1541    (set_attr "cc" "clobber")])
1542
1543 ;; HI BIT SHIFTS
1544
1545 (define_expand "ashlhi3"
1546   [(set (match_operand:HI 0 "register_operand" "")
1547         (ashift:HI (match_operand:HI 1 "nonmemory_operand" "")
1548                    (match_operand:QI 2 "nonmemory_operand" "")))]
1549   ""
1550   "if (expand_a_shift (HImode, ASHIFT, operands)) DONE;else FAIL;")
1551
1552 (define_expand "lshrhi3"
1553   [(set (match_operand:HI 0 "register_operand" "")
1554         (lshiftrt:HI (match_operand:HI 1 "general_operand_src" "")
1555                      (match_operand:QI 2 "nonmemory_operand" "")))]
1556   ""
1557   "if (expand_a_shift (HImode, LSHIFTRT, operands)) DONE;else FAIL;")
1558
1559 (define_expand "ashrhi3"
1560   [(set (match_operand:HI 0 "register_operand" "")
1561         (ashiftrt:HI (match_operand:HI 1 "register_operand" "")
1562                      (match_operand:QI 2 "nonmemory_operand" "")))]
1563   ""
1564   "if (expand_a_shift (HImode, ASHIFTRT, operands)) DONE;else FAIL;")
1565
1566 ;; WARNING: The constraints on the scratch register say one is not needed
1567 ;; for constant shifts of 1,2,3,4.  Emit_a_shift() must know this.
1568
1569 (define_insn "shiftbyn_HI"
1570   [(set (match_operand:HI 0 "register_operand" "=r,r")
1571         (match_operator:HI 3 "nshift_operator"
1572                         [ (match_operand:HI 1 "register_operand" "0,0")
1573                           (match_operand:QI 2 "nonmemory_operand" "IKM,rn")]))
1574    (clobber (match_scratch:QI 4 "=X,&r"))]
1575   ""
1576   "* return emit_a_shift (insn, operands);"
1577   [(set_attr "type" "arith")
1578    (set_attr "length" "20")
1579 ;; ??? We'd like to indicate that cc is set here, and it is for simple shifts.
1580 ;; However, for cases that loop or are done in pieces, cc does not contain
1581 ;; what we want.  Emit_a_shift is free to tweak cc_status as desired.
1582    (set_attr "cc" "clobber")])
1583
1584 ;;  SI BIT SHIFTS
1585
1586 (define_expand "ashlsi3"
1587   [(set (match_operand:SI 0 "register_operand" "")
1588         (ashift:SI
1589          (match_operand:SI 1 "general_operand_src" "")
1590          (match_operand:QI 2 "nonmemory_operand" "")))]
1591   ""
1592   "if (expand_a_shift (SImode, ASHIFT, operands)) DONE;else FAIL;")
1593
1594 (define_expand "lshrsi3"
1595   [(set (match_operand:SI 0 "register_operand" "")
1596         (lshiftrt:SI
1597          (match_operand:SI 1 "general_operand_src" "")
1598          (match_operand:QI 2 "nonmemory_operand" "")))]
1599   ""
1600   "if (expand_a_shift (SImode, LSHIFTRT, operands)) DONE;else FAIL;")
1601
1602 (define_expand "ashrsi3"
1603   [(set (match_operand:SI 0 "register_operand" "")
1604         (ashiftrt:SI
1605          (match_operand:SI 1 "general_operand_src" "")
1606          (match_operand:QI 2 "nonmemory_operand" "")))]
1607   ""
1608   "if (expand_a_shift (SImode, ASHIFTRT, operands)) DONE;else FAIL;")
1609
1610 ;; WARNING: The constraints on the scratch register say one is not needed
1611 ;; for constant shifts of 1,2.  Emit_a_shift() must know this.
1612
1613 (define_insn "shiftbyn_SI"
1614   [(set (match_operand:SI 0 "register_operand" "=r,r")
1615         (match_operator:SI 3 "nshift_operator"
1616                         [ (match_operand:SI 1 "register_operand" "0,0")
1617                           (match_operand:QI 2 "nonmemory_operand" "IK,rn")]))
1618    (clobber (match_scratch:QI 4 "=X,&r"))]
1619   ""
1620   "* return emit_a_shift (insn, operands);"
1621   [(set_attr "type" "arith")
1622    (set_attr "length" "20")
1623 ;; ??? We'd like to indicate that cc is set here, and it is for simple shifts.
1624 ;; However, for cases that loop or are done in pieces, cc does not contain
1625 ;; what we want.  Emit_a_shift is free to tweak cc_status as desired.
1626    (set_attr "cc" "clobber")])
1627
1628 ;; -----------------------------------------------------------------
1629 ;; BIT FIELDS
1630 ;; -----------------------------------------------------------------
1631 ;; The H8/300 has given 1/8th of its opcode space to bitfield
1632 ;; instuctions so let's use them as well as we can
1633
1634 ;; BCC and BCS patterns.
1635
1636 (define_insn "bcs_qiqi"
1637   [(set (pc)
1638         (if_then_else
1639          (match_operator 1 "eq_operator"
1640                          [(zero_extract:QI (match_operand:QI 2 "bit_operand" "Ur")
1641                                            (const_int 1)
1642                                            (match_operand:HI 3 "immediate_operand" "i"))
1643                           (const_int 0)])
1644          (label_ref (match_operand 0 "" ""))
1645          (pc)))]
1646   ""
1647   "*
1648 {
1649   output_asm_insn(\"bld %Z3,%Y2\", operands);
1650   if (get_attr_length (insn) == 2)
1651     return \"b%d1       %l0\";
1652   else if (get_attr_length (insn) == 4)
1653     return \"b%d1       %l0:16\";
1654   else
1655     return \"b%g1       %L0\;jmp        @%l0\;%L0:\";
1656 }"
1657   [(set_attr "type" "branch")
1658    (set_attr "cc" "clobber")])
1659
1660 (define_insn "bcs_hihi"
1661   [(set (pc)
1662         (if_then_else
1663          (match_operator 1 "eq_operator"
1664                          [(zero_extract:HI (match_operand:HI 2 "bit_operand" "Ur")
1665                                            (const_int 1)
1666                                            (match_operand:HI 3 "immediate_operand" "i"))
1667                           (const_int 0)])
1668          (label_ref (match_operand 0 "" ""))
1669          (pc)))]
1670   ""
1671   "*
1672 {
1673   output_asm_insn(\"bld %Z3,%Y2\", operands);
1674   if (get_attr_length (insn) == 2)
1675     return \"%d1        %l0\";
1676   else if (get_attr_length (insn) == 4)
1677     return \"%d1        %l0:16\";
1678   else
1679     return \"%g1        %L0\;jmp        @%l0\;%L0:\";
1680 }"
1681   [(set_attr "type" "branch")
1682    (set_attr "cc" "clobber")])
1683
1684 (define_insn "bcs_hiqi"
1685   [(set (pc)
1686         (if_then_else
1687          (match_operator 1 "eq_operator"
1688                          [(zero_extract:HI (match_operand:QI 2 "bit_operand" "Ur")
1689                                            (const_int 1)
1690                                            (match_operand:HI 3 "immediate_operand" "i"))
1691                           (const_int 0)])
1692          (label_ref (match_operand 0 "" ""))
1693          (pc)))]
1694   ""
1695   "*
1696 {
1697   output_asm_insn(\"bld %Z3,%Y2\", operands);
1698   if (get_attr_length (insn) == 2)
1699     return \"%d1        %l0\";
1700   else if (get_attr_length (insn) == 4)
1701     return \"%d1        %l0:16\";
1702   else
1703     return \"%g1        %L0\;jmp        @%l0\;%L0:\";
1704 }"
1705   [(set_attr "type" "branch")
1706    (set_attr "cc" "clobber")])
1707
1708 ;; BLD and BST patterns
1709
1710 (define_insn "extract_1"
1711   [(set (match_operand:HI 0 "register_operand" "=&r")
1712         (zero_extract:HI (match_operand:QI 1 "bit_operand" "Ur")
1713                          (const_int 1)
1714                          (match_operand:HI 2 "immediate_operand" "i")))]
1715   ""
1716   "sub.w        %0,%0\;bld      %Z2,%Y1\;bst    #0,%X0")
1717
1718 (define_insn "extract_1_hi"
1719   [(set (match_operand:HI 0 "register_operand" "=&r")
1720         (zero_extract:HI (match_operand:HI 1 "bit_operand" "Ur")
1721                          (const_int 1)
1722                          (match_operand:HI 2 "immediate_operand" "i")))]
1723   ""
1724   "sub.w        %0,%0\;bld      %Z2,%Y1\;bst    #0,%X0")
1725
1726 (define_insn "insert_1"
1727   [(set (zero_extract:HI (match_operand:QI 0 "bit_operand" "+Ur")
1728                          (const_int 1)
1729                          (match_operand:HI 1 "immediate_operand" "i"))
1730         (zero_extract:HI (match_operand:QI 2 "bit_operand" "Ur")
1731                          (const_int 1)
1732                          (const_int 0)))]
1733   ""
1734   "bld  #0,%X2\;bst     %Z1,%Y0 ; i1")
1735
1736 ;; This is how combine canonicalizes this pattern.  This is perhaps a bug
1737 ;; in combine.c, but there is no problem with writing it this way so we do.
1738 (define_insn "extract_insert_1"
1739   [(set (zero_extract:QI (match_operand:QI 0 "bit_operand" "+Ur")
1740                          (const_int 1)
1741                          (match_operand:HI 1 "immediate_operand" "i"))
1742         (lshiftrt:QI (match_operand:QI 2 "bit_operand" "Ur")
1743                      (match_operand:HI 3 "immediate_operand" "i")))]
1744  ""
1745  "bld   %Z3,%Y2\;bst    %Z1,%Y0; ei1")
1746
1747 ;; BAND, BOR, and BXOR patterns
1748
1749 (define_insn "bitlogical_1"
1750   [(set (match_operand:HI 0 "bit_operand" "=Ur")
1751         (match_operator:HI 4 "bit_operator"
1752            [(zero_extract:HI (match_operand:QI 1 "bit_operand" "Ur")
1753                              (const_int 1)
1754                              (match_operand:HI 2 "immediate_operand" "i"))
1755             (match_operand:HI 3 "bit_operand" "0")]))]
1756   ""
1757   "bld  %Z2,%Y1\;%b4    #0,%X0\;bst     #0,%X0; bl1")
1758
1759 (define_insn "bitlogical_1_hi"
1760   [(set (match_operand:HI 0 "bit_operand" "=Ur")
1761         (match_operator:HI 4 "bit_operator"
1762            [(zero_extract:HI (match_operand:HI 1 "bit_operand" "Ur")
1763                              (const_int 1)
1764                              (match_operand:HI 2 "immediate_operand" "i"))
1765             (match_operand:HI 3 "bit_operand" "0")]))]
1766   ""
1767   "bld  %Z2,%Y1\;%b4    #0,%X0\;bst     #0,%X0; bl2")
1768
1769 (define_insn "bitlogical_2"
1770   [(set (match_operand:HI 0 "bit_operand" "=Ur")
1771         (match_operator:HI 5 "bit_operator"
1772            [(zero_extract:HI (match_operand:QI 1 "bit_operand" "Ur")
1773                              (const_int 1)
1774                              (match_operand:HI 2 "immediate_operand" "i"))
1775             (zero_extract:HI (match_operand:QI 3 "bit_operand" "Ur")
1776                              (const_int 1)
1777                              (match_operand:HI 4 "immediate_operand" "i"))]))]
1778   ""
1779   "bld  %Z2,%Y1\;%b5    %Z4,%Y3\;bst    #0,%X0; bl3")
1780
1781 (define_insn "bitlogical_2_hi"
1782   [(set (match_operand:HI 0 "bit_operand" "=Ur")
1783         (match_operator:HI 5 "bit_operator"
1784            [(zero_extract:HI (match_operand:HI 1 "bit_operand" "Ur")
1785                              (const_int 1)
1786                              (match_operand:HI 2 "immediate_operand" "i"))
1787             (zero_extract:HI (match_operand:HI 3 "bit_operand" "Ur")
1788                              (const_int 1)
1789                              (match_operand:HI 4 "immediate_operand" "i"))]))]
1790   ""
1791   "bld  %Z2,%Y1\;%b5    %Z4,%Y3\;bst    #0,%X0; bl3")
1792
1793 ;; This is how combine canonicalizes this pattern.  This is perhaps a bug
1794 ;; in combine.c, but there is no problem with writing it this way so we do.
1795 (define_insn "bitlogical_3"
1796   [(set (zero_extract:QI (match_operand:QI 0 "bit_operand" "+Ur")
1797                          (const_int 1)
1798                          (match_operand:HI 1 "immediate_operand" "i"))
1799         (match_operator:QI 6 "bit_operator"
1800            [(lshiftrt:QI (match_operand:QI 2 "bit_operand" "Ur")
1801                          (match_operand:HI 3 "immediate_operand" "i"))
1802             (lshiftrt:QI (match_operand:QI 4 "bit_operand" "Ur")
1803                          (match_operand:HI 5 "immediate_operand" "i"))]))]
1804   ""
1805   "bld  %Z3,%Y2\;%b6    %Z5,%Y4\;bst    %Z1,%Y0; bl5")
1806
1807 ;; This is how combine canonicalizes this pattern.  This is perhaps a bug
1808 ;; in combine.c, but there is no problem with writing it this way so we do.
1809 (define_insn "bitnot_1"
1810   [(set (zero_extract:QI (match_operand:QI 0 "bit_operand" "=Ur")
1811                          (const_int 1)
1812                          (match_operand:HI 1 "immediate_operand" "i"))
1813         (lshiftrt:QI (xor:QI (match_operand:QI 2 "bit_operand" "0")
1814                              (match_operand:HI 3 "immediate_operand" "i"))
1815                      (match_operand:HI 4 "immediate_operand" "1")))]
1816   "GET_CODE (operands[3]) == CONST_INT && GET_CODE (operands[1]) == CONST_INT
1817    && exact_log2 (INTVAL (operands[3])) == INTVAL (operands[1])"
1818   "bnot %Z1,%Y0")
1819
1820 ;; ??? Implement BIAND, BIOR, BIXOR
1821
1822 ;; ??? Implement BILD, BIST
1823
1824 ;; ??? Apparently general_operand for the 1st and 2nd operands is useful,
1825 ;; but I don't know why.  --Jim
1826
1827 (define_expand "insv"
1828   [(set (zero_extract:HI (match_operand:QI 0 "bit_operand" "Ur")
1829                          (match_operand:HI 1 "general_operand" "g")
1830                          (match_operand:HI 2 "general_operand" "g"))
1831         (zero_extract:HI (match_operand:QI 3 "bit_operand" "Ur")
1832                          (const_int 1)
1833                          (const_int 0)))]
1834 ;; ??? This should have word mode which is SImode for the h8/300h.
1835   "TARGET_H8300"
1836   "
1837 {
1838   if (INTVAL (operands[1]) != 1)
1839     FAIL;
1840
1841   /* ??? HACK ???
1842      This INSV pattern is wrong.  It should use HImode for operand 3.
1843      Also, the zero_extract around operand 3 is superfluous and should be
1844      deleted.  Fixing this is more work than we care to do for the moment,
1845      because it means most of the above patterns would need to be rewritten,
1846      and we also need more combine.c patches to make this work.
1847
1848      So, for now, we work around this bug by simply not accepting any bitfield
1849      inserts that have a position greater than fits in QImode.  */
1850
1851   if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) >= 8)
1852     FAIL;
1853
1854   /* The bit_operand predicate accepts any memory durint RTL generation, but
1855      only 'U' memory afterwards, so if this is a MEM operand, we must force
1856      it to be valid for 'U' by reloading the address.  */
1857
1858   if (GET_CODE (operands[0]) == MEM && ! EXTRA_CONSTRAINT (operands[0], 'U'))
1859     {
1860       rtx mem;
1861       mem = gen_rtx (MEM, GET_MODE (operands[0]),
1862                      copy_to_mode_reg (Pmode, XEXP (operands[0], 0)));
1863       RTX_UNCHANGING_P (mem) = RTX_UNCHANGING_P (operands[0]);
1864       MEM_IN_STRUCT_P (mem) = MEM_IN_STRUCT_P (operands[0]);
1865       MEM_VOLATILE_P (mem) = MEM_VOLATILE_P (operands[0]);
1866       operands[0] = mem;
1867     }
1868
1869   /* Likewise for operands[3].  */
1870
1871   if (GET_CODE (operands[3]) == MEM && ! EXTRA_CONSTRAINT (operands[3], 'U'))
1872     {
1873       rtx mem;
1874       mem = gen_rtx (MEM, GET_MODE (operands[3]),
1875                      copy_to_mode_reg (Pmode, XEXP (operands[3], 0)));
1876       RTX_UNCHANGING_P (mem) = RTX_UNCHANGING_P (operands[3]);
1877       MEM_IN_STRUCT_P (mem) = MEM_IN_STRUCT_P (operands[3]);
1878       MEM_VOLATILE_P (mem) = MEM_VOLATILE_P (operands[3]);
1879       operands[3] = mem;
1880     }
1881 }")
1882
1883 ;; ??? Apparently general_operand for the 2nd and 3rd operands is useful,
1884 ;; but I don't know why.  --Jim
1885
1886 (define_expand "extzv"
1887   [(set (match_operand:HI 0 "register_operand" "")
1888         (zero_extract:HI (match_operand:QI 1 "bit_operand" "")
1889                          (match_operand:HI 2 "general_operand" "g")
1890                          (match_operand:HI 3 "general_operand" "g")))]
1891 ;; ??? This should have word mode which is SImode for the h8/300h.
1892   "TARGET_H8300"
1893   "
1894 {
1895   if (INTVAL (operands[2]) != 1)
1896     FAIL;
1897
1898   /* The bit_operand predicate accepts any memory durint RTL generation, but
1899      only 'U' memory afterwards, so if this is a MEM operand, we must force
1900      it to be valid for 'U' by reloading the address.  */
1901
1902   if (GET_CODE (operands[1]) == MEM && ! EXTRA_CONSTRAINT (operands[1], 'U'))
1903     {
1904       rtx mem;
1905       mem = gen_rtx (MEM, GET_MODE (operands[1]),
1906                      copy_to_mode_reg (Pmode, XEXP (operands[1], 0)));
1907       RTX_UNCHANGING_P (mem) = RTX_UNCHANGING_P (operands[1]);
1908       MEM_IN_STRUCT_P (mem) = MEM_IN_STRUCT_P (operands[1]);
1909       MEM_VOLATILE_P (mem) = MEM_VOLATILE_P (operands[1]);
1910       operands[1] = mem;
1911     }
1912 }")
1913
1914 ;; -----------------------------------------------------------------
1915 ;; STACK POINTER MANIPULATIONS
1916 ;; -----------------------------------------------------------------
1917
1918 ;; This pattern is needed because there is no way on the H8/300
1919 ;; to add a 16 bit immediate value to the stack pointer in one
1920 ;; instruction, which could leave an invalid instruction if interrupted
1921 ;; half way through.  Here we add to the stack pointer from a
1922 ;; register.
1923
1924 (define_insn "stack_pointer_manip"
1925   [(set (match_operand:HI 0 "register_operand" "=&ra")
1926         (plus:HI (match_operand:HI 1 "general_operand_src" "g")
1927                  (match_operand:HI 2 "register_operand" "ra")))]
1928   "TARGET_H8300"
1929   "mov.w        %T1,%T0\;add.w  %T2,%T0"
1930   [(set_attr "type" "arith")
1931    (set_attr "length" "6")
1932    (set_attr "cc" "set")])
1933
1934
1935 ;; -------------------------------------------
1936 ;; BLK moves
1937 ;; -------------------------------------------
1938
1939 (define_expand "movstrhi"
1940   [(parallel [(set (mem:BLK (match_operand:BLK 0 "general_operand" ""))
1941                    (mem:BLK (match_operand:BLK 1 "general_operand" "")))
1942              (use (match_operand:HI 2 "general_operand" ""))
1943              (use (match_operand:HI 3 "immediate_operand" ""))
1944              (clobber (match_dup 3))
1945   ])]
1946   ""
1947   "
1948 {
1949         rtx src_ptr = copy_to_mode_reg (Pmode, XEXP(operands[1], 0));
1950         rtx dst_ptr = copy_to_mode_reg (Pmode, XEXP(operands[0], 0));
1951
1952         int max = GET_CODE (operands[2]) == CONST_INT
1953           ? MIN (INTVAL (operands[2]), INTVAL (operands[3])) : 1;
1954         enum machine_mode mode = max >= 2 ? HImode : QImode;
1955         rtx tmpreg = gen_reg_rtx (mode);
1956         rtx increment = mode == QImode ? const1_rtx : const2_rtx;
1957         rtx length = operands[2];
1958         rtx label = gen_label_rtx ();
1959         rtx end_src_ptr = gen_reg_rtx (Pmode);
1960
1961 /*      emit_move_insn (length, gen_rtx(MINUS, HImode, length, increment));*/
1962         FAIL;
1963         if (Pmode == HImode)
1964           emit_insn (gen_addhi3 (end_src_ptr, src_ptr, length));
1965         else
1966           emit_insn (gen_addsi3 (end_src_ptr, src_ptr, length));
1967
1968         emit_label (label);
1969         emit_move_insn (tmpreg, gen_rtx (MEM, mode, src_ptr));
1970         emit_move_insn (gen_rtx (MEM, mode, dst_ptr), tmpreg);
1971         emit_insn (gen_rtx (SET, VOIDmode, src_ptr,
1972                             gen_rtx (PLUS, Pmode, src_ptr, increment)));
1973         emit_insn (gen_rtx (SET, VOIDmode, dst_ptr,
1974                             gen_rtx (PLUS, Pmode, dst_ptr, increment)));
1975
1976         emit_insn (gen_rtx (SET, VOIDmode, cc0_rtx,
1977                             gen_rtx (COMPARE, Pmode, src_ptr, end_src_ptr)));
1978         emit_jump_insn (gen_bne (label));
1979
1980         DONE;
1981 }")
1982
1983 ;; ----------------------------------------------
1984 ;; Peepholes go at the end.
1985 ;; ----------------------------------------------
1986
1987 ;; Notice when two byte moves in a row could be a word move.
1988
1989 (define_peephole
1990   [(set (match_operand:QI 0 "register_operand" "=r")
1991         (mem:QI (plus:HI (match_operand:HI 1 "register_operand" "ra")
1992                          (match_operand:HI 2 "immediate_operand" "n"))))
1993    (set (match_operand:QI 3 "register_operand" "=r")
1994         (mem:QI (plus:HI (match_dup 1)
1995                          (match_operand:HI 4 "immediate_operand" "n"))))]
1996   "(INTVAL(operands[2]) == INTVAL(operands[4])+1) && REGNO(operands[0]) +1 == REGNO(operands[3])"
1997   "mov.w        @(%u4,%T1),%T0"
1998   [(set_attr "length" "6")
1999    (set_attr "cc" "set")])
2000
2001 (define_peephole
2002   [(set (mem:QI (plus:HI (match_operand:HI 1 "register_operand" "ra")
2003                          (match_operand:HI 2 "immediate_operand" "n")))
2004         (match_operand:QI 0 "register_operand" "r"))
2005    (set (mem:QI (plus:HI (match_dup 1)
2006                          (match_operand:HI 4 "immediate_operand" "n")))
2007         (match_operand:QI 3 "register_operand" "r"))]
2008   "(INTVAL(operands[2]) == INTVAL(operands[4])+1) && REGNO(operands[0]) +1 == REGNO(operands[3])"
2009   "mov.w        %T0,@(%u4,%T1)"
2010   [(set_attr "length" "6")
2011    (set_attr "cc" "set")])
2012
2013 ;; Notice a move which could be post incremented.
2014
2015 (define_peephole
2016   [(set (match_operand:QI 0 "register_operand" "")
2017         (mem:QI (match_operand:HI 1 "register_operand" "")))
2018    (set (match_dup 1) (plus:HI (match_dup 1) (const_int 1)))]
2019   "REGNO(operands[1]) != REGNO(operands[0])"
2020   "mov.b        @%T1+,%X0"
2021   [(set_attr "length" "2")
2022    (set_attr "cc" "set")])
2023
2024 (define_peephole
2025   [(set (match_operand:HI 0 "register_operand" "")
2026         (mem:HI (match_operand:HI 1 "register_operand" "")))
2027    (set (match_dup 1) (plus:HI (match_dup 1) (const_int 2)))]
2028   "REGNO(operands[1]) != REGNO(operands[0])"
2029   "mov.w        @%T1+,%T0"
2030   [(set_attr "length" "2")
2031    (set_attr "cc" "set")])
2032
2033 ;; Notice a move which could be predecremented.
2034
2035 (define_peephole
2036   [(set (match_operand:HI 1 "register_operand" "")
2037         (plus:HI (match_dup 1) (const_int -1)))
2038    (set (mem:QI (match_dup 1))
2039                 (match_operand:QI 0 "register_operand" ""))]
2040   "REGNO(operands[1]) != REGNO(operands[0])"
2041   "mov.b        %X0,@-%T1"
2042   [(set_attr "length" "2")
2043    (set_attr "cc" "set")])
2044
2045 (define_peephole
2046   [(set (match_operand:HI 1 "register_operand" "")
2047         (plus:HI (match_dup 1) (const_int -1)))
2048    (set (mem:HI (match_dup 1))
2049                 (match_operand:HI 0 "register_operand" ""))]
2050   "REGNO(operands[1]) != REGNO(operands[0])"
2051   "mov.w        %T0,@-%T1"
2052   [(set_attr "length" "2")
2053    (set_attr "cc" "set")])
2054
2055 ;(define_insn ""
2056 ;  [(set (match_operand:HI 0 "register_operand" "=r")
2057 ;       (MEM:HI (match_operand:HI 1 "register_operand" "r")))
2058 ;   (set (match_operand:HI 3 "register_operand" "=r")
2059 ;       (zero_extract:HI (match_dup 0)
2060 ;                        (const_int 1)
2061 ;                        (match_operand:HI 2 "general_operand" "g")))
2062 ;   (set (MEM:HI (match_dup 1) (match_dup 3)))]
2063 ;  ""
2064 ;  "bld #0,%3l\;bst     %Z2,%0%Y1"
2065 ;  [(set_attr "type" "multi")
2066 ;   (set_attr "length" "4")
2067 ;   (set_attr "cc" "clobber")])
2068
2069 (define_insn "fancybset1"
2070   [(set (match_operand:QI 0 "bit_operand" "=Ur")
2071         (ior:QI (subreg:QI
2072                  (ashift:HI (const_int 1)
2073                             (subreg:QI (match_operand:HI 1 "register_operand" "ri") 0)) 0)
2074                 (match_dup 0)))]
2075   ""
2076   "bset %X1,%X0")
2077
2078 (define_insn "fancybset"
2079   [(set (match_operand:QI 0 "bit_operand" "=Ur")
2080         (ior:QI (subreg:QI
2081                  (ashift:HI (const_int 1)
2082                             (match_operand:HI 1 "nonmemory_operand" "ri") ) 0)
2083                 (match_operand:QI 2 "general_operand" "Ur")))]
2084   ""
2085   "mov.b        %X2,%X0\;bset   %X1,%X0")
2086
2087
2088 (define_insn "fancybclr4"
2089   [(set (match_operand:QI 0 "general_operand" "=Ur,Ur")
2090         (and:QI
2091          (subreg:QI
2092           (rotate:HI (const_int -2)
2093                      (match_operand:HI 2 "nonmemory_operand" "ri,ri") ) 0)
2094          (match_operand:QI 1 "general_operand" "0,Ur")))
2095    (clobber (match_scratch:HI 3 "=X,&r"))]
2096   ""
2097   "@
2098    bclr %X2,%X0; l1
2099    mov.b        %X1,%X3\;mov.b  %3,%0\;bclr     %X2,%X0; l3")
2100
2101 (define_insn "fancybclr5"
2102   [(set (match_operand:QI 0 "general_operand" "=Ur,Ur")
2103         (and:QI
2104          (subreg:QI
2105           (rotate:HI (const_int -2)
2106                      (match_operand:QI 2 "nonmemory_operand" "ri,ri")) 0)
2107          (match_operand:QI 1 "general_operand" "0,Ur")))
2108    (clobber (match_scratch:HI 3 "=X,&r"))]
2109   ""
2110   "@
2111    bclr %X2,%X0; l1
2112    mov.b        %X1,%X3\;mov.b  %3,%0\;bclr     %X2,%X0;l2")
2113
2114 (define_insn "fancybclr2"
2115   [(set (match_operand:QI 0 "general_operand" "=U,r")
2116         (and:QI
2117          (subreg:QI
2118           (rotate:HI (const_int -2)
2119                      (match_operand:HI 2 "nonmemory_operand" "ri,ri") ) 0)
2120          (match_operand:QI 1 "general_operand" "0,0")))]
2121   ""
2122   "bclr %X2,%X0")
2123
2124 (define_insn "fancybclr3"
2125   [(set (match_operand:QI 0 "general_operand" "=U,r")
2126         (and:QI
2127          (subreg:QI
2128           (rotate:HI (const_int -2)
2129                      (match_operand:QI 2 "nonmemory_operand" "ri,ri")) 0)
2130          (match_operand:QI 1 "general_operand" "0,0")))]
2131   ""
2132   "bclr %X2,%X0")
2133
2134 (define_insn "fancybclr"
2135   [(set (match_operand:QI 0 "general_operand" "=r")
2136         (and:QI (not:QI (match_operand:QI 1 "general_operand" "0"))
2137                 (match_operand:QI 2 "general_operand" "r")))]
2138   ""
2139   "not  %X0\;and        %X2,%X0")
2140
2141 (define_insn "fancybsetp3"
2142   [(set (match_operand:QI 0 "bit_operand" "=Ur")
2143         (ior:QI (subreg:QI (ashift:HI (const_int 1)
2144                                       (match_operand:QI 1 "register_operand" "r")) 0)
2145                 (match_operand:QI 2 "bit_operand" "0")))]
2146   ""
2147   "bset %X1,%X0")
2148
2149 (define_insn "fancybsetp2"
2150   [(set (match_operand:QI 0 "general_operand" "=r,U")
2151         (ior:QI (subreg:QI (ashift:HI (const_int 1)
2152                                       (match_operand:QI 1 "register_operand" "r,r")) 0)
2153                 (match_operand:QI 2 "general_operand" "U,r")))]
2154   ""
2155   "mov.b        %X2,%X0\;bset   %X1,%X0")
2156
2157 (define_insn "fancybnot"
2158   [(set (match_operand:QI 0 "bit_operand" "=Ur")
2159         (xor:QI (subreg:QI (ashift:HI (const_int 1)
2160                                       (match_operand:QI 1 "register_operand" "r")) 0)
2161                 (match_operand:QI 2 "bit_operand" "0")))]
2162
2163   ""
2164   "bnot %X1,%X0")
2165
2166 (define_insn "fancy_btst"
2167   [(set (pc)
2168         (if_then_else (eq (zero_extract:HI (zero_extend:HI (match_operand:QI 0 "general_operand" "Ur"))
2169                                            (const_int 1)
2170                                            (match_operand:HI 1 "nonmemory_operand" "rn"))
2171                           (const_int 0))
2172                       (label_ref (match_operand 2 "" ""))
2173                       (pc)))]
2174   ""
2175   "*
2176 {
2177   if (get_attr_length (insn) == 2)
2178     return \"btst       %X1,%X0\;beq    %l2\";
2179   else if (get_attr_length (insn) == 4)
2180     return \"btst       %X1,%X0\;beq    %l2:16\";
2181   else
2182     return \"btst       %X1,%X0\;bne    %L0\;jmp        @%l2\;%L0:\";
2183 }"
2184   [(set_attr "type" "branch")
2185    (set_attr "cc" "clobber")])
2186
2187 (define_insn "fancy_btst1"
2188   [(set (pc)
2189         (if_then_else (ne (zero_extract:HI (zero_extend:HI (match_operand:QI 0 "general_operand" "Ur"))
2190                                            (const_int 1)
2191                                            (match_operand:HI 1 "nonmemory_operand" "rn"))
2192                           (const_int 0))
2193                       (label_ref (match_operand 2 "" ""))
2194                       (pc)))]
2195   ""
2196   "*
2197 {
2198   if (get_attr_length (insn) == 2)
2199     return \"btst       %X1,%X0\;bne    %l2\";
2200   else if (get_attr_length (insn) == 4)
2201     return \"btst       %X1,%X0\;bne    %l2:16\";
2202   else
2203     return \"btst       %X1,%X0\;beq    %L0\;jmp        @%l2\;%L0:\";
2204 }"
2205   [(set_attr "type" "branch")
2206    (set_attr "cc" "clobber")])
2207
2208 (define_insn "pxor"
2209   [(set (zero_extract:QI (match_operand:QI 0 "bit_operand" "=r,U")
2210                          (const_int 1)
2211                          (match_operand 1 "immediate_operand" "n,n"))
2212         (and:QI (not:QI (match_operand:QI 2 "bit_operand" "r,U"))
2213                         (const_int 1)))]
2214   ""
2215   "bld  #0,%X2\;bist    %1,%0"
2216   [(set_attr "type" "arith")
2217    (set_attr "length" "4")
2218    (set_attr "cc" "clobber")])