OSDN Git Service

* config/h8300/h8300.md (anonymous patterns): Check that
[pf3gnuchains/gcc-fork.git] / 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")])