OSDN Git Service

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