OSDN Git Service

0c76a044ccc2cb0fc494763c41a60966a1b86b6e
[pf3gnuchains/gcc-fork.git] / gcc / config / m32r / m32r.md
1 ;; Machine description of the Renesas M32R cpu for GNU C compiler
2 ;; Copyright (C) 1996, 1997, 1998, 1999, 2001, 2003, 2004, 2005,
3 ;  2007, 2008 Free Software Foundation, Inc.
4
5 ;; This file is part of GCC.
6
7 ;; GCC is free software; you can redistribute it and/or modify it
8 ;; under the terms of the GNU General Public License as published
9 ;; by the Free Software Foundation; either version 3, or (at your
10 ;; option) any later version.
11
12 ;; GCC is distributed in the hope that it will be useful, but WITHOUT
13 ;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14 ;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
15 ;; License for more details.
16
17 ;; You should have received a copy of the GNU General Public License
18 ;; along with GCC; see the file COPYING3.  If not see
19 ;; <http://www.gnu.org/licenses/>.
20
21 ;; See file "rtl.def" for documentation on define_insn, match_*, et. al.
22 \f
23 ;; UNSPEC_VOLATILE usage
24 (define_constants
25   [(UNSPECV_BLOCKAGE            0)
26    (UNSPECV_FLUSH_ICACHE        1)])
27
28 ;; UNSPEC usage
29 (define_constants
30   [(UNSPEC_LOAD_SDA_BASE        2)
31    (UNSPEC_SET_CBIT             3)
32    (UNSPEC_PIC_LOAD_ADDR        4)
33    (UNSPEC_GET_PC               5)
34    (UNSPEC_GOTOFF               6)
35    ])
36
37 ;; Insn type.  Used to default other attribute values.
38 (define_attr "type"
39   "int2,int4,load2,load4,load8,store2,store4,store8,shift2,shift4,mul2,div4,uncond_branch,branch,call,multi,misc"
40   (const_string "misc"))
41
42 ;; Length in bytes.
43 (define_attr "length" ""
44   (cond [(eq_attr "type" "int2,load2,store2,shift2,mul2")
45          (const_int 2)
46
47          (eq_attr "type" "int4,load4,store4,shift4,div4")
48          (const_int 4)
49
50          (eq_attr "type" "multi")
51          (const_int 8)
52
53          (eq_attr "type" "uncond_branch,branch,call")
54          (const_int 4)]
55
56          (const_int 4)))
57
58 ;; The length here is the length of a single asm.  Unfortunately it might be
59 ;; 2 or 4 so we must allow for 4.  That's ok though.
60 (define_asm_attributes
61   [(set_attr "length" "4")
62    (set_attr "type" "multi")])
63
64 ;; Whether an instruction is short (16-bit) or long (32-bit).
65 (define_attr "insn_size" "short,long"
66   (if_then_else (eq_attr "type" "int2,load2,store2,shift2,mul2")
67                 (const_string "short")
68                 (const_string "long")))
69
70 ;; The target CPU we're compiling for.
71 (define_attr "cpu" "m32r,m32r2,m32rx"
72   (cond [(ne (symbol_ref "TARGET_M32RX") (const_int 0))
73              (const_string "m32rx")
74          (ne (symbol_ref "TARGET_M32R2") (const_int 0))
75              (const_string "m32r2")]
76     (const_string "m32r")))
77
78 ;; Defines the pipeline where an instruction can be executed on.
79 ;; For the M32R, a short instruction can execute one of the two pipes.
80 ;; For the M32Rx, the restrictions are modelled in the second
81 ;;  condition of this attribute definition.
82 (define_attr "m32r_pipeline" "either,s,o,long"
83   (cond [(and (eq_attr "cpu" "m32r")
84               (eq_attr "insn_size" "short"))
85              (const_string "either")
86          (eq_attr "insn_size" "!short")
87              (const_string "long")]
88          (cond [(eq_attr "type" "int2")
89                    (const_string "either")
90                 (eq_attr "type" "load2,store2,shift2,uncond_branch,branch,call")
91                    (const_string "o")
92                 (eq_attr "type" "mul2")
93                    (const_string "s")]
94          (const_string "long"))))
95 \f
96 ;; ::::::::::::::::::::
97 ;; ::
98 ;; :: Pipeline description
99 ;; ::
100 ;; ::::::::::::::::::::
101
102 ;; This model is based on Chapter 2, Appendix 3 and Appendix 4 of the
103 ;; "M32R-FPU Software Manual", Revision 1.01, plus additional information
104 ;; obtained by our best friend and mine, Google.
105 ;;
106 ;; The pipeline is modelled as a fetch unit, and a core with a memory unit,
107 ;; two execution units, where "fetch" models IF and D, "memory" for MEM1
108 ;; and MEM2, and "EXEC" for E, E1, E2, EM, and EA.  Writeback and
109 ;; bypasses are not modelled.
110 (define_automaton "m32r")
111
112 ;; We pretend there are two short (16 bits) instruction fetchers.  The
113 ;; "s" short fetcher cannot be reserved until the "o" short fetcher is
114 ;; reserved.  Some instructions reserve both the left and right fetchers.
115 ;; These fetch units are a hack to get GCC to better pack the instructions
116 ;; for the M32Rx processor, which has two execution pipes.
117 ;;
118 ;; In reality there is only one decoder, which can decode either two 16-bit
119 ;; instructions, or a single 32-bit instruction.
120 ;;
121 ;; Note, "fetch" models both the IF and the D pipeline stages.
122 ;;
123 ;; The m32rx core has two execution pipes.  We name them o_E and s_E.
124 ;; In addition, there's a memory unit.
125
126 (define_cpu_unit "o_IF,s_IF,o_E,s_E,memory" "m32r")
127
128 ;; Prevent the s pipe from being reserved before the o pipe.
129 (absence_set "s_IF" "o_IF")
130 (absence_set "s_E"  "o_E")
131
132 ;; On the M32Rx, long instructions execute on both pipes, so reserve
133 ;; both fetch slots and both pipes.
134 (define_reservation "long_IF" "o_IF+s_IF")
135 (define_reservation "long_E" "o_E+s_E")
136
137 ;; ::::::::::::::::::::
138
139 ;; Simple instructions do 4 stages: IF D E WB.  WB is not modelled.
140 ;; Hence, ready latency is 1.
141 (define_insn_reservation "short_left" 1
142   (and (eq_attr "m32r_pipeline" "o")
143        (and (eq_attr "insn_size" "short")
144             (eq_attr "type" "!load2")))
145   "o_IF,o_E")
146
147 (define_insn_reservation "short_right" 1
148   (and (eq_attr "m32r_pipeline" "s")
149        (and (eq_attr "insn_size" "short")
150             (eq_attr "type" "!load2")))
151   "s_IF,s_E")
152
153 (define_insn_reservation "short_either" 1
154   (and (eq_attr "m32r_pipeline" "either")
155        (and (eq_attr "insn_size" "short")
156             (eq_attr "type" "!load2")))
157   "o_IF|s_IF,o_E|s_E")
158
159 (define_insn_reservation "long_m32r" 1
160   (and (eq_attr "cpu" "m32r")
161        (and (eq_attr "insn_size" "long")
162             (eq_attr "type" "!load4,load8")))
163   "long_IF,long_E")
164
165 (define_insn_reservation "long_m32rx" 2
166   (and (eq_attr "m32r_pipeline" "long")
167        (and (eq_attr "insn_size" "long")
168             (eq_attr "type" "!load4,load8")))
169   "long_IF,long_E")
170
171 ;; Load/store instructions do 6 stages: IF D E MEM1 MEM2 WB.
172 ;; MEM1 may require more than one cycle depending on locality.  We
173 ;; optimistically assume all memory is nearby, i.e. MEM1 takes only
174 ;; one cycle.  Hence, ready latency is 3.
175
176 ;; The M32Rx can do short load/store only on the left pipe.
177 (define_insn_reservation "short_load_left" 3
178   (and (eq_attr "m32r_pipeline" "o")
179        (and (eq_attr "insn_size" "short")
180             (eq_attr "type" "load2")))
181   "o_IF,o_E,memory*2")
182
183 (define_insn_reservation "short_load" 3
184   (and (eq_attr "m32r_pipeline" "either")
185        (and (eq_attr "insn_size" "short")
186             (eq_attr "type" "load2")))
187   "s_IF|o_IF,s_E|o_E,memory*2")
188
189 (define_insn_reservation "long_load" 3
190   (and (eq_attr "cpu" "m32r")
191        (and (eq_attr "insn_size" "long")
192             (eq_attr "type" "load4,load8")))
193   "long_IF,long_E,memory*2")
194
195 (define_insn_reservation "long_load_m32rx" 3
196   (and (eq_attr "m32r_pipeline" "long")
197        (eq_attr "type" "load4,load8"))
198   "long_IF,long_E,memory*2")
199
200 \f
201 (include "predicates.md")
202 (include "constraints.md")
203
204 ;; Expand prologue as RTL
205 (define_expand "prologue"
206   [(const_int 1)]
207   ""
208   "
209 {
210   m32r_expand_prologue ();
211   DONE;
212 }")
213
214 ;; Expand epilogue as RTL
215 (define_expand "epilogue"
216   [(return)]
217   ""
218   "
219 {
220   m32r_expand_epilogue ();
221   emit_jump_insn (gen_return_normal ());
222   DONE;
223 }")
224 \f
225 ;; Move instructions.
226 ;;
227 ;; For QI and HI moves, the register must contain the full properly
228 ;; sign-extended value.  nonzero_bits assumes this [otherwise
229 ;; SHORT_IMMEDIATES_SIGN_EXTEND must be used, but the comment for it
230 ;; says it's a kludge and the .md files should be fixed instead].
231
232 (define_expand "movqi"
233   [(set (match_operand:QI 0 "general_operand" "")
234         (match_operand:QI 1 "general_operand" ""))]
235   ""
236   "
237 {
238   /* Fixup PIC cases.  */
239   if (flag_pic)
240     {
241       if (symbolic_operand (operands[1], QImode))
242         {
243           if (reload_in_progress || reload_completed)
244             operands[1] = m32r_legitimize_pic_address (operands[1], operands[0]);
245           else
246             operands[1] = m32r_legitimize_pic_address (operands[1], NULL_RTX);
247         }
248     }
249
250   /* Everything except mem = const or mem = mem can be done easily.
251      Objects in the small data area are handled too.  */
252
253   if (GET_CODE (operands[0]) == MEM)
254     operands[1] = force_reg (QImode, operands[1]);
255 }")
256
257 (define_insn "*movqi_insn"
258   [(set (match_operand:QI 0 "move_dest_operand" "=r,r,r,r,r,T,m")
259         (match_operand:QI 1 "move_src_operand" "r,I,JQR,T,m,r,r"))]
260   "register_operand (operands[0], QImode) || register_operand (operands[1], QImode)"
261   "@
262    mv %0,%1
263    ldi %0,%#%1
264    ldi %0,%#%1
265    ldub %0,%1
266    ldub %0,%1
267    stb %1,%0
268    stb %1,%0"
269   [(set_attr "type" "int2,int2,int4,load2,load4,store2,store4")
270    (set_attr "length" "2,2,4,2,4,2,4")])
271
272 (define_expand "movhi"
273   [(set (match_operand:HI 0 "general_operand" "")
274         (match_operand:HI 1 "general_operand" ""))]
275   ""
276   "
277 {
278   /* Fixup PIC cases.  */
279   if (flag_pic)
280     {
281       if (symbolic_operand (operands[1], HImode))
282         {
283           if (reload_in_progress || reload_completed)
284             operands[1] = m32r_legitimize_pic_address (operands[1], operands[0]);
285           else
286             operands[1] = m32r_legitimize_pic_address (operands[1], NULL_RTX);
287         }
288     }
289
290   /* Everything except mem = const or mem = mem can be done easily.  */
291
292   if (GET_CODE (operands[0]) == MEM)
293     operands[1] = force_reg (HImode, operands[1]);
294 }")
295
296 (define_insn "*movhi_insn"
297   [(set (match_operand:HI 0 "move_dest_operand" "=r,r,r,r,r,r,T,m")
298         (match_operand:HI 1 "move_src_operand" "r,I,JQR,K,T,m,r,r"))]
299   "register_operand (operands[0], HImode) || register_operand (operands[1], HImode)"
300   "@
301    mv %0,%1
302    ldi %0,%#%1
303    ldi %0,%#%1
304    ld24 %0,%#%1
305    lduh %0,%1
306    lduh %0,%1
307    sth %1,%0
308    sth %1,%0"
309   [(set_attr "type" "int2,int2,int4,int4,load2,load4,store2,store4")
310    (set_attr "length" "2,2,4,4,2,4,2,4")])
311
312 (define_expand "movsi_push"
313   [(set (mem:SI (pre_dec:SI (match_operand:SI 0 "register_operand" "")))
314         (match_operand:SI 1 "register_operand" ""))]
315   ""
316   "")
317
318 (define_expand "movsi_pop"
319   [(set (match_operand:SI 0 "register_operand" "")
320         (mem:SI (post_inc:SI (match_operand:SI 1 "register_operand" ""))))]
321   ""
322   "")
323
324 (define_expand "movsi"
325   [(set (match_operand:SI 0 "general_operand" "")
326         (match_operand:SI 1 "general_operand" ""))]
327   ""
328   "
329 {
330   /* Fixup PIC cases.  */
331   if (flag_pic)
332     {
333       if (symbolic_operand (operands[1], SImode))
334         {
335           if (reload_in_progress || reload_completed)
336             operands[1] = m32r_legitimize_pic_address (operands[1], operands[0]);
337           else
338             operands[1] = m32r_legitimize_pic_address (operands[1], NULL_RTX);
339         }
340     }
341
342   /* Everything except mem = const or mem = mem can be done easily.  */
343
344   if (GET_CODE (operands[0]) == MEM)
345     operands[1] = force_reg (SImode, operands[1]);
346
347   /* Small Data Area reference?  */
348   if (small_data_operand (operands[1], SImode))
349     {
350       emit_insn (gen_movsi_sda (operands[0], operands[1]));
351       DONE;
352     }
353
354   /* If medium or large code model, symbols have to be loaded with
355      seth/add3.  */
356   if (addr32_operand (operands[1], SImode))
357     {
358       emit_insn (gen_movsi_addr32 (operands[0], operands[1]));
359       DONE;
360     }
361 }")
362
363 ;; ??? Do we need a const_double constraint here for large unsigned values?
364 (define_insn "*movsi_insn"
365   [(set (match_operand:SI 0 "move_dest_operand" "=r,r,r,r,r,r,r,r,r,T,S,m")
366         (match_operand:SI 1 "move_src_operand" "r,I,J,MQ,L,n,T,U,m,r,r,r"))]
367   "register_operand (operands[0], SImode) || register_operand (operands[1], SImode)"
368   "*
369 {
370   if (GET_CODE (operands[0]) == REG || GET_CODE (operands[1]) == SUBREG)
371     {
372       switch (GET_CODE (operands[1]))
373         {
374           HOST_WIDE_INT value;
375
376           default:
377             break;
378
379           case REG:
380           case SUBREG:
381             return \"mv %0,%1\";
382
383           case MEM:
384             if (GET_CODE (XEXP (operands[1], 0)) == POST_INC
385                 && XEXP (XEXP (operands[1], 0), 0) == stack_pointer_rtx)
386               return \"pop %0\";
387
388             return \"ld %0,%1\";
389
390           case CONST_INT:
391             if (satisfies_constraint_J (operands[1]))
392               return \"ldi %0,%#%1\\t; %X1\";
393
394             if (satisfies_constraint_M (operands[1]))
395               return \"ld24 %0,%#%1\\t; %X1\";
396
397             if (satisfies_constraint_L (operands[1]))
398               return \"seth %0,%#%T1\\t; %X1\";
399
400             return \"#\";
401
402           case CONST:
403           case SYMBOL_REF:
404           case LABEL_REF:
405             if (TARGET_ADDR24)
406               return \"ld24 %0,%#%1\";
407
408             return \"#\";
409         }
410     }
411
412   else if (GET_CODE (operands[0]) == MEM
413            && (GET_CODE (operands[1]) == REG || GET_CODE (operands[1]) == SUBREG))
414     {
415       if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC
416           && XEXP (XEXP (operands[0], 0), 0) == stack_pointer_rtx)
417         return \"push %1\";
418
419       return \"st %1,%0\";
420     }
421
422   gcc_unreachable ();
423 }"
424   [(set_attr "type" "int2,int2,int4,int4,int4,multi,load2,load2,load4,store2,store2,store4")
425    (set_attr "length" "2,2,4,4,4,8,2,2,4,2,2,4")])
426
427 ; Try to use a four byte / two byte pair for constants not loadable with
428 ; ldi, ld24, seth.
429
430 (define_split
431  [(set (match_operand:SI 0 "register_operand" "")
432        (match_operand:SI 1 "two_insn_const_operand" ""))]
433   ""
434   [(set (match_dup 0) (match_dup 2))
435    (set (match_dup 0) (ior:SI (match_dup 0) (match_dup 3)))]
436   "
437 {
438   unsigned HOST_WIDE_INT val = INTVAL (operands[1]);
439   unsigned HOST_WIDE_INT tmp;
440   int shift;
441
442   /* In all cases we will emit two instructions.  However we try to
443      use 2 byte instructions wherever possible.  We can assume the
444      constant isn't loadable with any of ldi, ld24, or seth.  */
445
446   /* See if we can load a 24-bit unsigned value and invert it.  */
447   if (UINT24_P (~ val))
448     {
449       emit_insn (gen_movsi (operands[0], GEN_INT (~ val)));
450       emit_insn (gen_one_cmplsi2 (operands[0], operands[0]));
451       DONE;
452     }
453
454   /* See if we can load a 24-bit unsigned value and shift it into place.
455      0x01fffffe is just beyond ld24's range.  */
456   for (shift = 1, tmp = 0x01fffffe;
457        shift < 8;
458        ++shift, tmp <<= 1)
459     {
460       if ((val & ~tmp) == 0)
461         {
462           emit_insn (gen_movsi (operands[0], GEN_INT (val >> shift)));
463           emit_insn (gen_ashlsi3 (operands[0], operands[0], GEN_INT (shift)));
464           DONE;
465         }
466     }
467
468   /* Can't use any two byte insn, fall back to seth/or3.  Use ~0xffff instead
469      of 0xffff0000, since the later fails on a 64-bit host.  */
470   operands[2] = GEN_INT ((val) & ~0xffff);
471   operands[3] = GEN_INT ((val) & 0xffff);
472 }")
473
474 (define_split
475   [(set (match_operand:SI 0 "register_operand" "")
476         (match_operand:SI 1 "seth_add3_operand" ""))]
477   "TARGET_ADDR32"
478   [(set (match_dup 0)
479         (high:SI (match_dup 1)))
480    (set (match_dup 0)
481         (lo_sum:SI (match_dup 0)
482                    (match_dup 1)))]
483   "")
484
485 ;; Small data area support.
486 ;; The address of _SDA_BASE_ is loaded into a register and all objects in
487 ;; the small data area are indexed off that.  This is done for each reference
488 ;; but cse will clean things up for us.  We let the compiler choose the
489 ;; register to use so we needn't allocate (and maybe even fix) a special
490 ;; register to use.  Since the load and store insns have a 16-bit offset the
491 ;; total size of the data area can be 64K.  However, if the data area lives
492 ;; above 16M (24 bits), _SDA_BASE_ will have to be loaded with seth/add3 which
493 ;; would then yield 3 instructions to reference an object [though there would
494 ;; be no net loss if two or more objects were referenced].  The 3 insns can be
495 ;; reduced back to 2 if the size of the small data area were reduced to 32K
496 ;; [then seth + ld/st would work for any object in the area].  Doing this
497 ;; would require special handling of _SDA_BASE_ (its value would be
498 ;; (.sdata + 32K) & 0xffff0000) and reloc computations would be different
499 ;; [I think].  What to do about this is deferred until later and for now we
500 ;; require .sdata to be in the first 16M.
501
502 (define_expand "movsi_sda"
503   [(set (match_dup 2)
504         (unspec:SI [(const_int 0)] UNSPEC_LOAD_SDA_BASE))
505    (set (match_operand:SI 0 "register_operand" "")
506         (lo_sum:SI (match_dup 2)
507                    (match_operand:SI 1 "small_data_operand" "")))]
508   ""
509   "
510 {
511   if (reload_in_progress || reload_completed)
512     operands[2] = operands[0];
513   else
514     operands[2] = gen_reg_rtx (SImode);
515 }")
516
517 (define_insn "*load_sda_base_32"
518   [(set (match_operand:SI 0 "register_operand" "=r")
519         (unspec:SI [(const_int 0)] UNSPEC_LOAD_SDA_BASE))]
520   "TARGET_ADDR32"
521   "seth %0,%#shigh(_SDA_BASE_)\;add3 %0,%0,%#low(_SDA_BASE_)"
522   [(set_attr "type" "multi")
523    (set_attr "length" "8")])
524
525 (define_insn "*load_sda_base"
526   [(set (match_operand:SI 0 "register_operand" "=r")
527         (unspec:SI [(const_int 0)] UNSPEC_LOAD_SDA_BASE))]
528   ""
529   "ld24 %0,#_SDA_BASE_"
530   [(set_attr "type" "int4")
531    (set_attr "length" "4")])
532
533 ;; 32-bit address support.
534
535 (define_expand "movsi_addr32"
536   [(set (match_dup 2)
537         ; addr32_operand isn't used because it's too restrictive,
538         ; seth_add3_operand is more general and thus safer.
539         (high:SI (match_operand:SI 1 "seth_add3_operand" "")))
540    (set (match_operand:SI 0 "register_operand" "")
541         (lo_sum:SI (match_dup 2) (match_dup 1)))]
542   ""
543   "
544 {
545   if (reload_in_progress || reload_completed)
546     operands[2] = operands[0];
547   else
548     operands[2] = gen_reg_rtx (SImode);
549 }")
550
551 (define_insn "set_hi_si"
552   [(set (match_operand:SI 0 "register_operand" "=r")
553         (high:SI (match_operand 1 "symbolic_operand" "")))]
554   ""
555   "seth %0,%#shigh(%1)"
556   [(set_attr "type" "int4")
557    (set_attr "length" "4")])
558
559 (define_insn "lo_sum_si"
560   [(set (match_operand:SI 0 "register_operand" "=r")
561         (lo_sum:SI (match_operand:SI 1 "register_operand" "r")
562                    (match_operand:SI 2 "immediate_operand" "in")))]
563   ""
564   "add3 %0,%1,%#%B2"
565   [(set_attr "type" "int4")
566    (set_attr "length" "4")])
567
568 (define_expand "movdi"
569   [(set (match_operand:DI 0 "general_operand" "")
570         (match_operand:DI 1 "general_operand" ""))]
571   ""
572   "
573 {
574   /* Fixup PIC cases.  */
575   if (flag_pic)
576     {
577       if (symbolic_operand (operands[1], DImode))
578         {
579           if (reload_in_progress || reload_completed)
580             operands[1] = m32r_legitimize_pic_address (operands[1], operands[0]);
581           else
582             operands[1] = m32r_legitimize_pic_address (operands[1], NULL_RTX);
583         }
584     }
585
586   /* Everything except mem = const or mem = mem can be done easily.  */
587
588   if (GET_CODE (operands[0]) == MEM)
589     operands[1] = force_reg (DImode, operands[1]);
590 }")
591
592 (define_insn "*movdi_insn"
593   [(set (match_operand:DI 0 "move_dest_operand" "=r,r,r,r,m")
594         (match_operand:DI 1 "move_double_src_operand" "r,nG,F,m,r"))]
595   "register_operand (operands[0], DImode) || register_operand (operands[1], DImode)"
596   "#"
597   [(set_attr "type" "multi,multi,multi,load8,store8")
598    (set_attr "length" "4,4,16,6,6")])
599
600 (define_split
601   [(set (match_operand:DI 0 "move_dest_operand" "")
602         (match_operand:DI 1 "move_double_src_operand" ""))]
603   "reload_completed"
604   [(match_dup 2)]
605   "operands[2] = gen_split_move_double (operands);")
606 \f
607 ;; Floating point move insns.
608
609 (define_expand "movsf"
610   [(set (match_operand:SF 0 "general_operand" "")
611         (match_operand:SF 1 "general_operand" ""))]
612   ""
613   "
614 {
615   /* Fixup PIC cases.  */
616   if (flag_pic)
617     {
618       if (symbolic_operand (operands[1], SFmode))
619         {
620           if (reload_in_progress || reload_completed)
621             operands[1] = m32r_legitimize_pic_address (operands[1], operands[0]);
622           else
623             operands[1] = m32r_legitimize_pic_address (operands[1], NULL_RTX);
624         }
625     }
626
627   /* Everything except mem = const or mem = mem can be done easily.  */
628
629   if (GET_CODE (operands[0]) == MEM)
630     operands[1] = force_reg (SFmode, operands[1]);
631 }")
632
633 (define_insn "*movsf_insn"
634   [(set (match_operand:SF 0 "move_dest_operand" "=r,r,r,r,r,T,S,m")
635         (match_operand:SF 1 "move_src_operand" "r,F,U,S,m,r,r,r"))]
636   "register_operand (operands[0], SFmode) || register_operand (operands[1], SFmode)"
637   "@
638    mv %0,%1
639    #
640    ld %0,%1
641    ld %0,%1
642    ld %0,%1
643    st %1,%0
644    st %1,%0
645    st %1,%0"
646   ;; ??? Length of alternative 1 is either 2, 4 or 8.
647   [(set_attr "type" "int2,multi,load2,load2,load4,store2,store2,store4")
648    (set_attr "length" "2,8,2,2,4,2,2,4")])
649
650 (define_split
651   [(set (match_operand:SF 0 "register_operand" "")
652         (match_operand:SF 1 "const_double_operand" ""))]
653   "reload_completed"
654   [(set (match_dup 2) (match_dup 3))]
655   "
656 {
657   operands[2] = operand_subword (operands[0], 0, 0, SFmode);
658   operands[3] = operand_subword (operands[1], 0, 0, SFmode);
659 }")
660
661 (define_expand "movdf"
662   [(set (match_operand:DF 0 "general_operand" "")
663         (match_operand:DF 1 "general_operand" ""))]
664   ""
665   "
666 {
667   /* Fixup PIC cases.  */
668   if (flag_pic)
669     {
670       if (symbolic_operand (operands[1], DFmode))
671         {
672           if (reload_in_progress || reload_completed)
673             operands[1] = m32r_legitimize_pic_address (operands[1], operands[0]);
674           else
675             operands[1] = m32r_legitimize_pic_address (operands[1], NULL_RTX);
676         }
677     }
678
679   /* Everything except mem = const or mem = mem can be done easily.  */
680
681   if (GET_CODE (operands[0]) == MEM)
682     operands[1] = force_reg (DFmode, operands[1]);
683 }")
684
685 (define_insn "*movdf_insn"
686   [(set (match_operand:DF 0 "move_dest_operand" "=r,r,r,m")
687         (match_operand:DF 1 "move_double_src_operand" "r,F,m,r"))]
688   "register_operand (operands[0], DFmode) || register_operand (operands[1], DFmode)"
689   "#"
690   [(set_attr "type" "multi,multi,load8,store8")
691    (set_attr "length" "4,16,6,6")])
692
693 (define_split
694   [(set (match_operand:DF 0 "move_dest_operand" "")
695         (match_operand:DF 1 "move_double_src_operand" ""))]
696   "reload_completed"
697   [(match_dup 2)]
698   "operands[2] = gen_split_move_double (operands);")
699 \f
700 ;; Zero extension instructions.
701
702 (define_insn "zero_extendqihi2"
703   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
704         (zero_extend:HI (match_operand:QI 1 "extend_operand" "r,T,m")))]
705   ""
706   "@
707    and3 %0,%1,%#255
708    ldub %0,%1
709    ldub %0,%1"
710   [(set_attr "type" "int4,load2,load4")
711    (set_attr "length" "4,2,4")])
712
713 (define_insn "zero_extendqisi2"
714   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
715         (zero_extend:SI (match_operand:QI 1 "extend_operand" "r,T,m")))]
716   ""
717   "@
718    and3 %0,%1,%#255
719    ldub %0,%1
720    ldub %0,%1"
721   [(set_attr "type" "int4,load2,load4")
722    (set_attr "length" "4,2,4")])
723
724 (define_insn "zero_extendhisi2"
725   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
726         (zero_extend:SI (match_operand:HI 1 "extend_operand" "r,T,m")))]
727   ""
728   "@
729    and3 %0,%1,%#65535
730    lduh %0,%1
731    lduh %0,%1"
732   [(set_attr "type" "int4,load2,load4")
733    (set_attr "length" "4,2,4")])
734 \f
735 ;; Signed conversions from a smaller integer to a larger integer
736 (define_insn "extendqihi2"
737   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
738         (sign_extend:HI (match_operand:QI 1 "extend_operand" "0,T,m")))]
739   ""
740   "@
741     #
742     ldb %0,%1
743     ldb %0,%1"
744   [(set_attr "type" "multi,load2,load4")
745    (set_attr "length" "2,2,4")])
746
747 (define_split
748   [(set (match_operand:HI 0 "register_operand" "")
749         (sign_extend:HI (match_operand:QI 1 "register_operand" "")))]
750   "reload_completed"
751   [(match_dup 2)
752    (match_dup 3)]
753   "
754 {
755   rtx op0   = gen_lowpart (SImode, operands[0]);
756   rtx shift = GEN_INT (24);
757
758   operands[2] = gen_ashlsi3 (op0, op0, shift);
759   operands[3] = gen_ashrsi3 (op0, op0, shift);
760 }")
761
762 (define_insn "extendqisi2"
763   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
764         (sign_extend:SI (match_operand:QI 1 "extend_operand" "0,T,m")))]
765   ""
766   "@
767     #
768     ldb %0,%1
769     ldb %0,%1"
770   [(set_attr "type" "multi,load2,load4")
771    (set_attr "length" "4,2,4")])
772
773 (define_split
774   [(set (match_operand:SI 0 "register_operand" "")
775         (sign_extend:SI (match_operand:QI 1 "register_operand" "")))]
776   "reload_completed"
777   [(match_dup 2)
778    (match_dup 3)]
779   "
780 {
781   rtx shift = GEN_INT (24);
782
783   operands[2] = gen_ashlsi3 (operands[0], operands[0], shift);
784   operands[3] = gen_ashrsi3 (operands[0], operands[0], shift);
785 }")
786
787 (define_insn "extendhisi2"
788   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
789         (sign_extend:SI (match_operand:HI 1 "extend_operand" "0,T,m")))]
790   ""
791   "@
792     #
793     ldh %0,%1
794     ldh %0,%1"
795   [(set_attr "type" "multi,load2,load4")
796    (set_attr "length" "4,2,4")])
797
798 (define_split
799   [(set (match_operand:SI 0 "register_operand" "")
800         (sign_extend:SI (match_operand:HI 1 "register_operand" "")))]
801   "reload_completed"
802   [(match_dup 2)
803    (match_dup 3)]
804   "
805 {
806   rtx shift = GEN_INT (16);
807
808   operands[2] = gen_ashlsi3 (operands[0], operands[0], shift);
809   operands[3] = gen_ashrsi3 (operands[0], operands[0], shift);
810 }")
811 \f
812 ;; Arithmetic instructions.
813
814 ; ??? Adding an alternative to split add3 of small constants into two
815 ; insns yields better instruction packing but slower code.  Adds of small
816 ; values is done a lot.
817
818 (define_insn "addsi3"
819   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
820         (plus:SI (match_operand:SI 1 "register_operand" "%0,0,r")
821                  (match_operand:SI 2 "nonmemory_operand" "r,I,J")))]
822   ""
823   "@
824    add %0,%2
825    addi %0,%#%2
826    add3 %0,%1,%#%2"
827   [(set_attr "type" "int2,int2,int4")
828    (set_attr "length" "2,2,4")])
829
830 ;(define_split
831 ;  [(set (match_operand:SI 0 "register_operand" "")
832 ;       (plus:SI (match_operand:SI 1 "register_operand" "")
833 ;                (match_operand:SI 2 "int8_operand" "")))]
834 ;  "reload_completed
835 ;   && REGNO (operands[0]) != REGNO (operands[1])
836 ;   && satisfies_constraint_I (operands[2])
837 ;   && INTVAL (operands[2]) != 0"
838 ;  [(set (match_dup 0) (match_dup 1))
839 ;   (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 2)))]
840 ;  "")
841
842 (define_insn "adddi3"
843   [(set (match_operand:DI 0 "register_operand" "=r")
844         (plus:DI (match_operand:DI 1 "register_operand" "%0")
845                  (match_operand:DI 2 "register_operand" "r")))
846    (clobber (reg:CC 17))]
847   ""
848   "#"
849   [(set_attr "type" "multi")
850    (set_attr "length" "6")])
851
852 ;; ??? The cmp clears the condition bit.  Can we speed up somehow?
853 (define_split
854   [(set (match_operand:DI 0 "register_operand" "")
855         (plus:DI (match_operand:DI 1 "register_operand" "")
856                  (match_operand:DI 2 "register_operand" "")))
857    (clobber (reg:CC 17))]
858   "reload_completed"
859   [(parallel [(set (reg:CC 17)
860                    (const_int 0))
861               (use (match_dup 4))])
862    (parallel [(set (match_dup 4)
863                    (plus:SI (match_dup 4)
864                             (plus:SI (match_dup 5)
865                                      (ne:SI (reg:CC 17) (const_int 0)))))
866               (set (reg:CC 17)
867                    (unspec:CC [(const_int 0)] UNSPEC_SET_CBIT))])
868    (parallel [(set (match_dup 6)
869                    (plus:SI (match_dup 6)
870                             (plus:SI (match_dup 7)
871                                      (ne:SI (reg:CC 17) (const_int 0)))))
872               (set (reg:CC 17)
873                    (unspec:CC [(const_int 0)] UNSPEC_SET_CBIT))])]
874   "
875 {
876   operands[4] = operand_subword (operands[0], (WORDS_BIG_ENDIAN != 0), 0, DImode);
877   operands[5] = operand_subword (operands[2], (WORDS_BIG_ENDIAN != 0), 0, DImode);
878   operands[6] = operand_subword (operands[0], (WORDS_BIG_ENDIAN == 0), 0, DImode);
879   operands[7] = operand_subword (operands[2], (WORDS_BIG_ENDIAN == 0), 0, DImode);
880 }")
881
882 (define_insn "*clear_c"
883   [(set (reg:CC 17)
884         (const_int 0))
885    (use (match_operand:SI 0 "register_operand" "r"))]
886   ""
887   "cmp %0,%0"
888   [(set_attr "type" "int2")
889    (set_attr "length" "2")])
890
891 (define_insn "*add_carry"
892   [(set (match_operand:SI 0 "register_operand" "=r")
893         (plus:SI (match_operand:SI 1 "register_operand" "%0")
894                  (plus:SI (match_operand:SI 2 "register_operand" "r")
895                           (ne:SI (reg:CC 17) (const_int 0)))))
896    (set (reg:CC 17)
897         (unspec:CC [(const_int 0)] UNSPEC_SET_CBIT))]
898   ""
899   "addx %0,%2"
900   [(set_attr "type" "int2")
901    (set_attr "length" "2")])
902
903 (define_insn "subsi3"
904   [(set (match_operand:SI 0 "register_operand" "=r")
905         (minus:SI (match_operand:SI 1 "register_operand" "0")
906                   (match_operand:SI 2 "register_operand" "r")))]
907   ""
908   "sub %0,%2"
909   [(set_attr "type" "int2")
910    (set_attr "length" "2")])
911
912 (define_insn "subdi3"
913   [(set (match_operand:DI 0 "register_operand" "=r")
914         (minus:DI (match_operand:DI 1 "register_operand" "0")
915                   (match_operand:DI 2 "register_operand" "r")))
916    (clobber (reg:CC 17))]
917   ""
918   "#"
919   [(set_attr "type" "multi")
920    (set_attr "length" "6")])
921
922 ;; ??? The cmp clears the condition bit.  Can we speed up somehow?
923 (define_split
924   [(set (match_operand:DI 0 "register_operand" "")
925         (minus:DI (match_operand:DI 1 "register_operand" "")
926                   (match_operand:DI 2 "register_operand" "")))
927    (clobber (reg:CC 17))]
928   "reload_completed"
929   [(parallel [(set (reg:CC 17)
930                    (const_int 0))
931               (use (match_dup 4))])
932    (parallel [(set (match_dup 4)
933                    (minus:SI (match_dup 4)
934                              (minus:SI (match_dup 5)
935                                        (ne:SI (reg:CC 17) (const_int 0)))))
936               (set (reg:CC 17)
937                    (unspec:CC [(const_int 0)] UNSPEC_SET_CBIT))])
938    (parallel [(set (match_dup 6)
939                    (minus:SI (match_dup 6)
940                              (minus:SI (match_dup 7)
941                                        (ne:SI (reg:CC 17) (const_int 0)))))
942               (set (reg:CC 17)
943                    (unspec:CC [(const_int 0)] UNSPEC_SET_CBIT))])]
944   "
945 {
946   operands[4] = operand_subword (operands[0], (WORDS_BIG_ENDIAN != 0), 0, DImode);
947   operands[5] = operand_subword (operands[2], (WORDS_BIG_ENDIAN != 0), 0, DImode);
948   operands[6] = operand_subword (operands[0], (WORDS_BIG_ENDIAN == 0), 0, DImode);
949   operands[7] = operand_subword (operands[2], (WORDS_BIG_ENDIAN == 0), 0, DImode);
950 }")
951
952 (define_insn "*sub_carry"
953   [(set (match_operand:SI 0 "register_operand" "=r")
954         (minus:SI (match_operand:SI 1 "register_operand" "%0")
955                   (minus:SI (match_operand:SI 2 "register_operand" "r")
956                             (ne:SI (reg:CC 17) (const_int 0)))))
957    (set (reg:CC 17)
958         (unspec:CC [(const_int 0)] UNSPEC_SET_CBIT))]
959   ""
960   "subx %0,%2"
961   [(set_attr "type" "int2")
962    (set_attr "length" "2")])
963 \f
964 ; Multiply/Divide instructions.
965
966 (define_insn "mulhisi3"
967   [(set (match_operand:SI 0 "register_operand" "=r")
968         (mult:SI (sign_extend:SI (match_operand:HI 1 "register_operand" "r"))
969                  (sign_extend:SI (match_operand:HI 2 "register_operand" "r"))))]
970   ""
971   "mullo %1,%2\;mvfacmi %0"
972   [(set_attr "type" "multi")
973    (set_attr "length" "4")])
974
975 (define_insn "mulsi3"
976   [(set (match_operand:SI 0 "register_operand" "=r")
977         (mult:SI (match_operand:SI 1 "register_operand" "%0")
978                  (match_operand:SI 2 "register_operand" "r")))]
979   ""
980   "mul %0,%2"
981   [(set_attr "type" "mul2")
982    (set_attr "length" "2")])
983
984 (define_insn "divsi3"
985   [(set (match_operand:SI 0 "register_operand" "=r")
986         (div:SI (match_operand:SI 1 "register_operand" "0")
987                 (match_operand:SI 2 "register_operand" "r")))]
988   ""
989   "div %0,%2"
990   [(set_attr "type" "div4")
991    (set_attr "length" "4")])
992
993 (define_insn "udivsi3"
994   [(set (match_operand:SI 0 "register_operand" "=r")
995         (udiv:SI (match_operand:SI 1 "register_operand" "0")
996                  (match_operand:SI 2 "register_operand" "r")))]
997   ""
998   "divu %0,%2"
999   [(set_attr "type" "div4")
1000    (set_attr "length" "4")])
1001
1002 (define_insn "modsi3"
1003   [(set (match_operand:SI 0 "register_operand" "=r")
1004         (mod:SI (match_operand:SI 1 "register_operand" "0")
1005                 (match_operand:SI 2 "register_operand" "r")))]
1006   ""
1007   "rem %0,%2"
1008   [(set_attr "type" "div4")
1009    (set_attr "length" "4")])
1010
1011 (define_insn "umodsi3"
1012   [(set (match_operand:SI 0 "register_operand" "=r")
1013         (umod:SI (match_operand:SI 1 "register_operand" "0")
1014                  (match_operand:SI 2 "register_operand" "r")))]
1015   ""
1016   "remu %0,%2"
1017   [(set_attr "type" "div4")
1018    (set_attr "length" "4")])
1019 \f
1020 ;; Boolean instructions.
1021 ;;
1022 ;; We don't define the DImode versions as expand_binop does a good enough job.
1023 ;; And if it doesn't it should be fixed.
1024
1025 (define_insn "andsi3"
1026   [(set (match_operand:SI 0 "register_operand" "=r,r")
1027         (and:SI (match_operand:SI 1 "register_operand" "%0,r")
1028                 (match_operand:SI 2 "reg_or_uint16_operand" "r,K")))]
1029   ""
1030   "*
1031 {
1032   /* If we are worried about space, see if we can break this up into two
1033      short instructions, which might eliminate a NOP being inserted.  */
1034   if (optimize_size
1035       && m32r_not_same_reg (operands[0], operands[1])
1036       && satisfies_constraint_I (operands[2]))
1037     return \"#\";
1038
1039   else if (GET_CODE (operands[2]) == CONST_INT)
1040     return \"and3 %0,%1,%#%X2\";
1041
1042   return \"and %0,%2\";
1043 }"
1044   [(set_attr "type" "int2,int4")
1045    (set_attr "length" "2,4")])
1046
1047 (define_split
1048   [(set (match_operand:SI 0 "register_operand" "")
1049         (and:SI (match_operand:SI 1 "register_operand" "")
1050                 (match_operand:SI 2 "int8_operand" "")))]
1051   "optimize_size && m32r_not_same_reg (operands[0], operands[1])"
1052   [(set (match_dup 0) (match_dup 2))
1053    (set (match_dup 0) (and:SI (match_dup 0) (match_dup 1)))]
1054   "")
1055
1056 (define_insn "iorsi3"
1057   [(set (match_operand:SI 0 "register_operand" "=r,r")
1058         (ior:SI (match_operand:SI 1 "register_operand" "%0,r")
1059                 (match_operand:SI 2 "reg_or_uint16_operand" "r,K")))]
1060   ""
1061   "*
1062 {
1063   /* If we are worried about space, see if we can break this up into two
1064      short instructions, which might eliminate a NOP being inserted.  */
1065   if (optimize_size
1066       && m32r_not_same_reg (operands[0], operands[1])
1067       && satisfies_constraint_I (operands[2]))
1068     return \"#\";
1069
1070   else if (GET_CODE (operands[2]) == CONST_INT)
1071     return \"or3 %0,%1,%#%X2\";
1072
1073   return \"or %0,%2\";
1074 }"
1075   [(set_attr "type" "int2,int4")
1076    (set_attr "length" "2,4")])
1077
1078 (define_split
1079   [(set (match_operand:SI 0 "register_operand" "")
1080         (ior:SI (match_operand:SI 1 "register_operand" "")
1081                 (match_operand:SI 2 "int8_operand" "")))]
1082   "optimize_size && m32r_not_same_reg (operands[0], operands[1])"
1083   [(set (match_dup 0) (match_dup 2))
1084    (set (match_dup 0) (ior:SI (match_dup 0) (match_dup 1)))]
1085   "")
1086
1087 (define_insn "xorsi3"
1088   [(set (match_operand:SI 0 "register_operand" "=r,r")
1089         (xor:SI (match_operand:SI 1 "register_operand" "%0,r")
1090                 (match_operand:SI 2 "reg_or_uint16_operand" "r,K")))]
1091   ""
1092   "*
1093 {
1094   /* If we are worried about space, see if we can break this up into two
1095      short instructions, which might eliminate a NOP being inserted.  */
1096   if (optimize_size
1097       && m32r_not_same_reg (operands[0], operands[1])
1098       && satisfies_constraint_I (operands[2]))
1099     return \"#\";
1100
1101   else if (GET_CODE (operands[2]) == CONST_INT)
1102     return \"xor3 %0,%1,%#%X2\";
1103
1104   return \"xor %0,%2\";
1105 }"
1106   [(set_attr "type" "int2,int4")
1107    (set_attr "length" "2,4")])
1108
1109 (define_split
1110   [(set (match_operand:SI 0 "register_operand" "")
1111         (xor:SI (match_operand:SI 1 "register_operand" "")
1112                 (match_operand:SI 2 "int8_operand" "")))]
1113   "optimize_size && m32r_not_same_reg (operands[0], operands[1])"
1114   [(set (match_dup 0) (match_dup 2))
1115    (set (match_dup 0) (xor:SI (match_dup 0) (match_dup 1)))]
1116   "")
1117
1118 (define_insn "negsi2"
1119   [(set (match_operand:SI 0 "register_operand" "=r")
1120         (neg:SI (match_operand:SI 1 "register_operand" "r")))]
1121   ""
1122   "neg %0,%1"
1123   [(set_attr "type" "int2")
1124    (set_attr "length" "2")])
1125
1126 (define_insn "one_cmplsi2"
1127   [(set (match_operand:SI 0 "register_operand" "=r")
1128         (not:SI (match_operand:SI 1 "register_operand" "r")))]
1129   ""
1130   "not %0,%1"
1131   [(set_attr "type" "int2")
1132    (set_attr "length" "2")])
1133 \f
1134 ;; Shift instructions.
1135
1136 (define_insn "ashlsi3"
1137   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1138         (ashift:SI (match_operand:SI 1 "register_operand" "0,0,r")
1139                    (match_operand:SI 2 "reg_or_uint16_operand" "r,O,K")))]
1140   ""
1141   "@
1142    sll %0,%2
1143    slli %0,%#%2
1144    sll3 %0,%1,%#%2"
1145   [(set_attr "type" "shift2,shift2,shift4")
1146    (set_attr "length" "2,2,4")])
1147
1148 (define_insn "ashrsi3"
1149   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1150         (ashiftrt:SI (match_operand:SI 1 "register_operand" "0,0,r")
1151                      (match_operand:SI 2 "reg_or_uint16_operand" "r,O,K")))]
1152   ""
1153   "@
1154    sra %0,%2
1155    srai %0,%#%2
1156    sra3 %0,%1,%#%2"
1157   [(set_attr "type" "shift2,shift2,shift4")
1158    (set_attr "length" "2,2,4")])
1159
1160 (define_insn "lshrsi3"
1161   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1162         (lshiftrt:SI (match_operand:SI 1 "register_operand" "0,0,r")
1163                      (match_operand:SI 2 "reg_or_uint16_operand" "r,O,K")))]
1164   ""
1165   "@
1166    srl %0,%2
1167    srli %0,%#%2
1168    srl3 %0,%1,%#%2"
1169   [(set_attr "type" "shift2,shift2,shift4")
1170    (set_attr "length" "2,2,4")])
1171 \f
1172 ;; Compare instructions.
1173 ;; This controls RTL generation and register allocation.
1174
1175 ;; We generate RTL for comparisons and branches by having the cmpxx
1176 ;; patterns store away the operands.  Then the bcc patterns
1177 ;; emit RTL for both the compare and the branch.
1178 ;;
1179 ;; On the m32r it is more efficient to use the bxxz instructions and
1180 ;; thus merge the compare and branch into one instruction, so they are
1181 ;; preferred.
1182
1183 (define_insn "cmp_eqsi_zero_insn"
1184   [(set (reg:CC 17)
1185         (eq:CC (match_operand:SI 0 "register_operand" "r,r")
1186                (match_operand:SI 1 "reg_or_zero_operand" "r,P")))]
1187   "TARGET_M32RX || TARGET_M32R2"
1188   "@
1189    cmpeq %0, %1
1190    cmpz  %0"
1191   [(set_attr "type" "int4")
1192    (set_attr "length" "4")])
1193
1194 ;; The cmp_xxx_insn patterns set the condition bit to the result of the
1195 ;; comparison.  There isn't a "compare equal" instruction so cmp_eqsi_insn
1196 ;; is quite inefficient.  However, it is rarely used.
1197
1198 (define_insn "cmp_eqsi_insn"
1199   [(set (reg:CC 17)
1200         (eq:CC (match_operand:SI 0 "register_operand" "r,r")
1201                (match_operand:SI 1 "reg_or_cmp_int16_operand" "r,P")))
1202    (clobber (match_scratch:SI 2 "=&r,&r"))]
1203   ""
1204   "*
1205 {
1206   if (which_alternative == 0)
1207     {
1208          return \"mv %2,%0\;sub %2,%1\;cmpui %2,#1\";
1209     }
1210   else
1211     {
1212         if (INTVAL (operands [1]) == 0)
1213           return \"cmpui %0, #1\";
1214         else if (REGNO (operands [2]) == REGNO (operands [0]))
1215           return \"addi %0,%#%N1\;cmpui %2,#1\";
1216         else
1217           return \"add3 %2,%0,%#%N1\;cmpui %2,#1\";
1218     }
1219 }"
1220   [(set_attr "type" "multi,multi")
1221    (set_attr "length" "8,8")])
1222
1223 (define_insn "cmp_ltsi_insn"
1224   [(set (reg:CC 17)
1225         (lt:CC (match_operand:SI 0 "register_operand" "r,r")
1226                (match_operand:SI 1 "reg_or_int16_operand" "r,J")))]
1227   ""
1228   "@
1229    cmp %0,%1
1230    cmpi %0,%#%1"
1231   [(set_attr "type" "int2,int4")
1232    (set_attr "length" "2,4")])
1233
1234 (define_insn "cmp_ltusi_insn"
1235   [(set (reg:CC 17)
1236         (ltu:CC (match_operand:SI 0 "register_operand" "r,r")
1237                 (match_operand:SI 1 "reg_or_int16_operand" "r,J")))]
1238   ""
1239   "@
1240    cmpu %0,%1
1241    cmpui %0,%#%1"
1242   [(set_attr "type" "int2,int4")
1243    (set_attr "length" "2,4")])
1244 \f
1245 ;; These control RTL generation for conditional jump insns.
1246
1247 (define_expand "cbranchsi4"
1248   ; the comparison is emitted by gen_compare if needed.
1249   [(set (pc)
1250         (if_then_else (match_operator 0 "ordered_comparison_operator"
1251                        [(match_operand:SI 1 "register_operand" "")
1252                         (match_operand:SI 2 "reg_or_cmp_int16_operand" "")])
1253                       (label_ref (match_operand 3 "" ""))
1254                       (pc)))]
1255   ""
1256   "
1257 {
1258   operands[0] = gen_compare (GET_CODE (operands[0]), operands[1], operands[2], FALSE);
1259   operands[1] = XEXP (operands[0], 0);
1260   operands[2] = XEXP (operands[0], 1);
1261 }")
1262
1263 ;; Now match both normal and inverted jump.
1264
1265 (define_insn "*branch_insn"
1266   [(set (pc)
1267         (if_then_else (match_operator 1 "eqne_comparison_operator"
1268                                       [(reg 17) (const_int 0)])
1269                       (label_ref (match_operand 0 "" ""))
1270                       (pc)))]
1271   ""
1272   "*
1273 {
1274   static char instruction[40];
1275   sprintf (instruction, \"%s%s %%l0\",
1276            (GET_CODE (operands[1]) == NE) ? \"bc\" : \"bnc\",
1277            (get_attr_length (insn) == 2) ? \".s\" : \"\");
1278   return instruction;
1279 }"
1280   [(set_attr "type" "branch")
1281    ; cf PR gcc/28508
1282    ; We use 300/600 instead of 512,1024 to account for inaccurate insn
1283    ; lengths and insn alignments that are complex to track.
1284    ; It's not important that we be hyper-precise here.  It may be more
1285    ; important blah blah blah when the chip supports parallel execution
1286    ; blah blah blah but until then blah blah blah this is simple and
1287    ; suffices.
1288    (set (attr "length") (if_then_else (ltu (plus (minus (match_dup 0) (pc))
1289                                                  (const_int 300))
1290                                            (const_int 600))
1291                                       (const_int 2)
1292                                       (const_int 4)))])
1293
1294 (define_insn "*rev_branch_insn"
1295   [(set (pc)
1296         (if_then_else (match_operator 1 "eqne_comparison_operator"
1297                                       [(reg 17) (const_int 0)])
1298                       (pc)
1299                       (label_ref (match_operand 0 "" ""))))]
1300   ;"REVERSIBLE_CC_MODE (GET_MODE (XEXP (operands[1], 0)))"
1301   ""
1302   "*
1303 {
1304   static char instruction[40];
1305   sprintf (instruction, \"%s%s %%l0\",
1306            (GET_CODE (operands[1]) == EQ) ? \"bc\" : \"bnc\",
1307            (get_attr_length (insn) == 2) ? \".s\" : \"\");
1308   return instruction;
1309 }"
1310   [(set_attr "type" "branch")
1311    ; cf PR gcc/28508
1312    ; We use 300/600 instead of 512,1024 to account for inaccurate insn
1313    ; lengths and insn alignments that are complex to track.
1314    ; It's not important that we be hyper-precise here.  It may be more
1315    ; important blah blah blah when the chip supports parallel execution
1316    ; blah blah blah but until then blah blah blah this is simple and
1317    ; suffices.
1318    (set (attr "length") (if_then_else (ltu (plus (minus (match_dup 0) (pc))
1319                                                  (const_int 300))
1320                                            (const_int 600))
1321                                       (const_int 2)
1322                                       (const_int 4)))])
1323
1324 ; reg/reg compare and branch insns
1325
1326 (define_insn "*reg_branch_insn"
1327   [(set (pc)
1328         (if_then_else (match_operator 1 "eqne_comparison_operator"
1329                                       [(match_operand:SI 2 "register_operand" "r")
1330                                        (match_operand:SI 3 "register_operand" "r")])
1331                       (label_ref (match_operand 0 "" ""))
1332                       (pc)))]
1333   ""
1334   "*
1335 {
1336   /* Is branch target reachable with beq/bne?  */
1337   if (get_attr_length (insn) == 4)
1338     {
1339       if (GET_CODE (operands[1]) == EQ)
1340         return \"beq %2,%3,%l0\";
1341       else
1342         return \"bne %2,%3,%l0\";
1343     }
1344   else
1345     {
1346       if (GET_CODE (operands[1]) == EQ)
1347         return \"bne %2,%3,1f\;bra %l0\;1:\";
1348       else
1349         return \"beq %2,%3,1f\;bra %l0\;1:\";
1350     }
1351 }"
1352   [(set_attr "type" "branch")
1353   ; We use 25000/50000 instead of 32768/65536 to account for slot filling
1354   ; which is complex to track and inaccurate length specs.
1355    (set (attr "length") (if_then_else (ltu (plus (minus (match_dup 0) (pc))
1356                                                  (const_int 25000))
1357                                            (const_int 50000))
1358                                       (const_int 4)
1359                                       (const_int 8)))])
1360
1361 (define_insn "*rev_reg_branch_insn"
1362   [(set (pc)
1363         (if_then_else (match_operator 1 "eqne_comparison_operator"
1364                                       [(match_operand:SI 2 "register_operand" "r")
1365                                        (match_operand:SI 3 "register_operand" "r")])
1366                       (pc)
1367                       (label_ref (match_operand 0 "" ""))))]
1368   ""
1369   "*
1370 {
1371   /* Is branch target reachable with beq/bne?  */
1372   if (get_attr_length (insn) == 4)
1373     {
1374       if (GET_CODE (operands[1]) == NE)
1375         return \"beq %2,%3,%l0\";
1376       else
1377         return \"bne %2,%3,%l0\";
1378     }
1379   else
1380     {
1381       if (GET_CODE (operands[1]) == NE)
1382         return \"bne %2,%3,1f\;bra %l0\;1:\";
1383       else
1384         return \"beq %2,%3,1f\;bra %l0\;1:\";
1385     }
1386 }"
1387   [(set_attr "type" "branch")
1388   ; We use 25000/50000 instead of 32768/65536 to account for slot filling
1389   ; which is complex to track and inaccurate length specs.
1390    (set (attr "length") (if_then_else (ltu (plus (minus (match_dup 0) (pc))
1391                                                  (const_int 25000))
1392                                            (const_int 50000))
1393                                       (const_int 4)
1394                                       (const_int 8)))])
1395
1396 ; reg/zero compare and branch insns
1397
1398 (define_insn "*zero_branch_insn"
1399   [(set (pc)
1400         (if_then_else (match_operator 1 "signed_comparison_operator"
1401                                       [(match_operand:SI 2 "register_operand" "r")
1402                                        (const_int 0)])
1403                       (label_ref (match_operand 0 "" ""))
1404                       (pc)))]
1405   ""
1406   "*
1407 {
1408   const char *br,*invbr;
1409   char asmtext[40];
1410
1411   switch (GET_CODE (operands[1]))
1412     {
1413       case EQ : br = \"eq\"; invbr = \"ne\"; break;
1414       case NE : br = \"ne\"; invbr = \"eq\"; break;
1415       case LE : br = \"le\"; invbr = \"gt\"; break;
1416       case GT : br = \"gt\"; invbr = \"le\"; break;
1417       case LT : br = \"lt\"; invbr = \"ge\"; break;
1418       case GE : br = \"ge\"; invbr = \"lt\"; break;
1419
1420       default: gcc_unreachable ();
1421     }
1422
1423   /* Is branch target reachable with bxxz?  */
1424   if (get_attr_length (insn) == 4)
1425     {
1426       sprintf (asmtext, \"b%sz %%2,%%l0\", br);
1427       output_asm_insn (asmtext, operands);
1428     }
1429   else
1430     {
1431       sprintf (asmtext, \"b%sz %%2,1f\;bra %%l0\;1:\", invbr);
1432       output_asm_insn (asmtext, operands);
1433     }
1434   return \"\";
1435 }"
1436   [(set_attr "type" "branch")
1437   ; We use 25000/50000 instead of 32768/65536 to account for slot filling
1438   ; which is complex to track and inaccurate length specs.
1439    (set (attr "length") (if_then_else (ltu (plus (minus (match_dup 0) (pc))
1440                                                  (const_int 25000))
1441                                            (const_int 50000))
1442                                       (const_int 4)
1443                                       (const_int 8)))])
1444
1445 (define_insn "*rev_zero_branch_insn"
1446   [(set (pc)
1447         (if_then_else (match_operator 1 "eqne_comparison_operator"
1448                                       [(match_operand:SI 2 "register_operand" "r")
1449                                        (const_int 0)])
1450                       (pc)
1451                       (label_ref (match_operand 0 "" ""))))]
1452   ""
1453   "*
1454 {
1455   const char *br,*invbr;
1456   char asmtext[40];
1457
1458   switch (GET_CODE (operands[1]))
1459     {
1460       case EQ : br = \"eq\"; invbr = \"ne\"; break;
1461       case NE : br = \"ne\"; invbr = \"eq\"; break;
1462       case LE : br = \"le\"; invbr = \"gt\"; break;
1463       case GT : br = \"gt\"; invbr = \"le\"; break;
1464       case LT : br = \"lt\"; invbr = \"ge\"; break;
1465       case GE : br = \"ge\"; invbr = \"lt\"; break;
1466
1467       default: gcc_unreachable ();
1468     }
1469
1470   /* Is branch target reachable with bxxz?  */
1471   if (get_attr_length (insn) == 4)
1472     {
1473       sprintf (asmtext, \"b%sz %%2,%%l0\", invbr);
1474       output_asm_insn (asmtext, operands);
1475     }
1476   else
1477     {
1478       sprintf (asmtext, \"b%sz %%2,1f\;bra %%l0\;1:\", br);
1479       output_asm_insn (asmtext, operands);
1480     }
1481   return \"\";
1482 }"
1483   [(set_attr "type" "branch")
1484   ; We use 25000/50000 instead of 32768/65536 to account for slot filling
1485   ; which is complex to track and inaccurate length specs.
1486    (set (attr "length") (if_then_else (ltu (plus (minus (match_dup 0) (pc))
1487                                                  (const_int 25000))
1488                                            (const_int 50000))
1489                                       (const_int 4)
1490                                       (const_int 8)))])
1491 \f
1492 ;; S<cc> operations to set a register to 1/0 based on a comparison
1493
1494 (define_expand "cstoresi4"
1495   [(match_operand:SI 0 "register_operand" "")
1496    (match_operator:SI 1 "ordered_comparison_operator"
1497     [(match_operand:SI 2 "register_operand" "")
1498      (match_operand:SI 3 "reg_or_cmp_int16_operand" "")])]
1499   ""
1500   "
1501 {
1502   if (GET_MODE (operands[0]) != SImode)
1503     FAIL;
1504
1505   if (!gen_cond_store (GET_CODE (operands[1]),
1506                        operands[0], operands[2], operands[3]))
1507     FAIL;
1508
1509   DONE;
1510 }")
1511
1512 (define_insn "seq_insn_m32rx"
1513   [(set (match_operand:SI 0 "register_operand" "=r")
1514         (eq:SI (match_operand:SI 1 "register_operand" "%r")
1515                (match_operand:SI 2 "reg_or_zero_operand" "rP")))
1516    (clobber (reg:CC 17))]
1517   "TARGET_M32RX || TARGET_M32R2"
1518   "#"
1519   [(set_attr "type" "multi")
1520    (set_attr "length" "6")])
1521
1522 (define_split
1523   [(set (match_operand:SI 0 "register_operand" "")
1524         (eq:SI (match_operand:SI 1 "register_operand" "")
1525                (match_operand:SI 2 "reg_or_zero_operand" "")))
1526    (clobber (reg:CC 17))]
1527   "TARGET_M32RX || TARGET_M32R2"
1528   [(set (reg:CC 17)
1529         (eq:CC (match_dup 1)
1530                (match_dup 2)))
1531    (set (match_dup 0)
1532         (ne:SI (reg:CC 17) (const_int 0)))]
1533   "")
1534
1535 (define_insn "seq_zero_insn"
1536   [(set (match_operand:SI 0 "register_operand" "=r")
1537         (eq:SI (match_operand:SI 1 "register_operand" "r")
1538                (const_int 0)))
1539    (clobber (reg:CC 17))]
1540   "TARGET_M32R"
1541   "#"
1542   [(set_attr "type" "multi")
1543    (set_attr "length" "6")])
1544
1545 (define_split
1546   [(set (match_operand:SI 0 "register_operand" "")
1547         (eq:SI (match_operand:SI 1 "register_operand" "")
1548                (const_int 0)))
1549    (clobber (reg:CC 17))]
1550   "TARGET_M32R"
1551   [(match_dup 3)]
1552   "
1553 {
1554   rtx op0 = operands[0];
1555   rtx op1 = operands[1];
1556
1557   start_sequence ();
1558   emit_insn (gen_cmp_ltusi_insn (op1, const1_rtx));
1559   emit_insn (gen_movcc_insn (op0));
1560   operands[3] = get_insns ();
1561   end_sequence ();
1562 }")
1563
1564 (define_insn "seq_insn"
1565   [(set (match_operand:SI 0 "register_operand" "=r,r,??r,r")
1566         (eq:SI (match_operand:SI 1 "register_operand" "r,r,r,r")
1567                (match_operand:SI 2 "reg_or_eq_int16_operand" "r,r,r,PK")))
1568    (clobber (reg:CC 17))
1569    (clobber (match_scratch:SI 3 "=1,2,&r,r"))]
1570   "TARGET_M32R"
1571   "#"
1572   [(set_attr "type" "multi")
1573    (set_attr "length" "8,8,10,10")])
1574
1575 (define_split
1576   [(set (match_operand:SI 0 "register_operand" "")
1577         (eq:SI (match_operand:SI 1 "register_operand" "")
1578                (match_operand:SI 2 "reg_or_eq_int16_operand" "")))
1579    (clobber (reg:CC 17))
1580    (clobber (match_scratch:SI 3 ""))]
1581   "TARGET_M32R && reload_completed"
1582   [(match_dup 4)]
1583   "
1584 {
1585   rtx op0 = operands[0];
1586   rtx op1 = operands[1];
1587   rtx op2 = operands[2];
1588   rtx op3 = operands[3];
1589   HOST_WIDE_INT value;
1590
1591   if (GET_CODE (op2) == REG && GET_CODE (op3) == REG
1592       && REGNO (op2) == REGNO (op3))
1593     {
1594       op1 = operands[2];
1595       op2 = operands[1];
1596     }
1597
1598   start_sequence ();
1599   if (GET_CODE (op1) == REG && GET_CODE (op3) == REG
1600       && REGNO (op1) != REGNO (op3))
1601     {
1602       emit_move_insn (op3, op1);
1603       op1 = op3;
1604     }
1605
1606   if (satisfies_constraint_P (op2) && (value = INTVAL (op2)) != 0)
1607     emit_insn (gen_addsi3 (op3, op1, GEN_INT (-value)));
1608   else
1609     emit_insn (gen_xorsi3 (op3, op1, op2));
1610
1611   emit_insn (gen_cmp_ltusi_insn (op3, const1_rtx));
1612   emit_insn (gen_movcc_insn (op0));
1613   operands[4] = get_insns ();
1614   end_sequence ();
1615 }")
1616
1617 (define_insn "sne_zero_insn"
1618   [(set (match_operand:SI 0 "register_operand" "=r")
1619         (ne:SI (match_operand:SI 1 "register_operand" "r")
1620                (const_int 0)))
1621    (clobber (reg:CC 17))
1622    (clobber (match_scratch:SI 2 "=&r"))]
1623   ""
1624   "#"
1625   [(set_attr "type" "multi")
1626    (set_attr "length" "6")])
1627
1628 (define_split
1629   [(set (match_operand:SI 0 "register_operand" "")
1630         (ne:SI (match_operand:SI 1 "register_operand" "")
1631                (const_int 0)))
1632    (clobber (reg:CC 17))
1633    (clobber (match_scratch:SI 2 ""))]
1634   "reload_completed"
1635   [(set (match_dup 2)
1636         (const_int 0))
1637    (set (reg:CC 17)
1638         (ltu:CC (match_dup 2)
1639                 (match_dup 1)))
1640    (set (match_dup 0)
1641         (ne:SI (reg:CC 17) (const_int 0)))]
1642   "")
1643
1644 (define_insn "slt_insn"
1645   [(set (match_operand:SI 0 "register_operand" "=r,r")
1646         (lt:SI (match_operand:SI 1 "register_operand" "r,r")
1647                (match_operand:SI 2 "reg_or_int16_operand" "r,J")))
1648    (clobber (reg:CC 17))]
1649   ""
1650   "#"
1651   [(set_attr "type" "multi")
1652    (set_attr "length" "4,6")])
1653
1654 (define_split
1655   [(set (match_operand:SI 0 "register_operand" "")
1656         (lt:SI (match_operand:SI 1 "register_operand" "")
1657                (match_operand:SI 2 "reg_or_int16_operand" "")))
1658    (clobber (reg:CC 17))]
1659   ""
1660   [(set (reg:CC 17)
1661         (lt:CC (match_dup 1)
1662                (match_dup 2)))
1663    (set (match_dup 0)
1664         (ne:SI (reg:CC 17) (const_int 0)))]
1665   "")
1666
1667 (define_insn "sle_insn"
1668   [(set (match_operand:SI 0 "register_operand" "=r")
1669         (le:SI (match_operand:SI 1 "register_operand" "r")
1670                (match_operand:SI 2 "register_operand" "r")))
1671    (clobber (reg:CC 17))]
1672   ""
1673   "#"
1674   [(set_attr "type" "multi")
1675    (set_attr "length" "8")])
1676
1677 (define_split
1678   [(set (match_operand:SI 0 "register_operand" "")
1679         (le:SI (match_operand:SI 1 "register_operand" "")
1680                (match_operand:SI 2 "register_operand" "")))
1681    (clobber (reg:CC 17))]
1682   "!optimize_size"
1683   [(set (reg:CC 17)
1684         (lt:CC (match_dup 2)
1685                (match_dup 1)))
1686    (set (match_dup 0)
1687         (ne:SI (reg:CC 17) (const_int 0)))
1688    (set (match_dup 0)
1689         (xor:SI (match_dup 0)
1690                 (const_int 1)))]
1691   "")
1692
1693 ;; If optimizing for space, use -(reg - 1) to invert the comparison rather than
1694 ;; xor reg,reg,1 which might eliminate a NOP being inserted.
1695 (define_split
1696   [(set (match_operand:SI 0 "register_operand" "")
1697         (le:SI (match_operand:SI 1 "register_operand" "")
1698                (match_operand:SI 2 "register_operand" "")))
1699    (clobber (reg:CC 17))]
1700   "optimize_size"
1701   [(set (reg:CC 17)
1702         (lt:CC (match_dup 2)
1703                (match_dup 1)))
1704    (set (match_dup 0)
1705         (ne:SI (reg:CC 17) (const_int 0)))
1706    (set (match_dup 0)
1707         (plus:SI (match_dup 0)
1708                  (const_int -1)))
1709    (set (match_dup 0)
1710         (neg:SI (match_dup 0)))]
1711   "")
1712
1713 (define_insn "sge_insn"
1714   [(set (match_operand:SI 0 "register_operand" "=r,r")
1715         (ge:SI (match_operand:SI 1 "register_operand" "r,r")
1716                (match_operand:SI 2 "reg_or_int16_operand" "r,J")))
1717    (clobber (reg:CC 17))]
1718   ""
1719   "#"
1720   [(set_attr "type" "multi")
1721    (set_attr "length" "8,10")])
1722
1723 (define_split
1724   [(set (match_operand:SI 0 "register_operand" "")
1725         (ge:SI (match_operand:SI 1 "register_operand" "")
1726                (match_operand:SI 2 "reg_or_int16_operand" "")))
1727    (clobber (reg:CC 17))]
1728   "!optimize_size"
1729   [(set (reg:CC 17)
1730         (lt:CC (match_dup 1)
1731                (match_dup 2)))
1732    (set (match_dup 0)
1733         (ne:SI (reg:CC 17) (const_int 0)))
1734    (set (match_dup 0)
1735         (xor:SI (match_dup 0)
1736                 (const_int 1)))]
1737   "")
1738
1739 ;; If optimizing for space, use -(reg - 1) to invert the comparison rather than
1740 ;; xor reg,reg,1 which might eliminate a NOP being inserted.
1741 (define_split
1742   [(set (match_operand:SI 0 "register_operand" "")
1743         (ge:SI (match_operand:SI 1 "register_operand" "")
1744                (match_operand:SI 2 "reg_or_int16_operand" "")))
1745    (clobber (reg:CC 17))]
1746   "optimize_size"
1747   [(set (reg:CC 17)
1748         (lt:CC (match_dup 1)
1749                (match_dup 2)))
1750    (set (match_dup 0)
1751         (ne:SI (reg:CC 17) (const_int 0)))
1752    (set (match_dup 0)
1753         (plus:SI (match_dup 0)
1754                  (const_int -1)))
1755    (set (match_dup 0)
1756         (neg:SI (match_dup 0)))]
1757   "")
1758
1759 (define_insn "sltu_insn"
1760   [(set (match_operand:SI 0 "register_operand" "=r,r")
1761         (ltu:SI (match_operand:SI 1 "register_operand" "r,r")
1762                 (match_operand:SI 2 "reg_or_int16_operand" "r,J")))
1763    (clobber (reg:CC 17))]
1764   ""
1765   "#"
1766   [(set_attr "type" "multi")
1767    (set_attr "length" "6,8")])
1768
1769 (define_split
1770   [(set (match_operand:SI 0 "register_operand" "")
1771         (ltu:SI (match_operand:SI 1 "register_operand" "")
1772                 (match_operand:SI 2 "reg_or_int16_operand" "")))
1773    (clobber (reg:CC 17))]
1774   ""
1775   [(set (reg:CC 17)
1776         (ltu:CC (match_dup 1)
1777                 (match_dup 2)))
1778    (set (match_dup 0)
1779         (ne:SI (reg:CC 17) (const_int 0)))]
1780   "")
1781
1782 (define_insn "sleu_insn"
1783   [(set (match_operand:SI 0 "register_operand" "=r")
1784         (leu:SI (match_operand:SI 1 "register_operand" "r")
1785                 (match_operand:SI 2 "register_operand" "r")))
1786    (clobber (reg:CC 17))]
1787   ""
1788   "#"
1789   [(set_attr "type" "multi")
1790    (set_attr "length" "8")])
1791
1792 (define_split
1793   [(set (match_operand:SI 0 "register_operand" "")
1794         (leu:SI (match_operand:SI 1 "register_operand" "")
1795                 (match_operand:SI 2 "register_operand" "")))
1796    (clobber (reg:CC 17))]
1797   "!optimize_size"
1798   [(set (reg:CC 17)
1799         (ltu:CC (match_dup 2)
1800                 (match_dup 1)))
1801    (set (match_dup 0)
1802         (ne:SI (reg:CC 17) (const_int 0)))
1803    (set (match_dup 0)
1804         (xor:SI (match_dup 0)
1805                 (const_int 1)))]
1806   "")
1807
1808 ;; If optimizing for space, use -(reg - 1) to invert the comparison rather than
1809 ;; xor reg,reg,1 which might eliminate a NOP being inserted.
1810 (define_split
1811   [(set (match_operand:SI 0 "register_operand" "")
1812         (leu:SI (match_operand:SI 1 "register_operand" "")
1813                 (match_operand:SI 2 "register_operand" "")))
1814    (clobber (reg:CC 17))]
1815   "optimize_size"
1816   [(set (reg:CC 17)
1817         (ltu:CC (match_dup 2)
1818                 (match_dup 1)))
1819    (set (match_dup 0)
1820         (ne:SI (reg:CC 17) (const_int 0)))
1821    (set (match_dup 0)
1822         (plus:SI (match_dup 0)
1823                  (const_int -1)))
1824    (set (match_dup 0)
1825         (neg:SI (match_dup 0)))]
1826   "")
1827
1828 (define_insn "sgeu_insn"
1829   [(set (match_operand:SI 0 "register_operand" "=r,r")
1830         (geu:SI (match_operand:SI 1 "register_operand" "r,r")
1831                 (match_operand:SI 2 "reg_or_int16_operand" "r,J")))
1832    (clobber (reg:CC 17))]
1833   ""
1834   "#"
1835   [(set_attr "type" "multi")
1836    (set_attr "length" "8,10")])
1837
1838 (define_split
1839   [(set (match_operand:SI 0 "register_operand" "")
1840         (geu:SI (match_operand:SI 1 "register_operand" "")
1841                 (match_operand:SI 2 "reg_or_int16_operand" "")))
1842    (clobber (reg:CC 17))]
1843   "!optimize_size"
1844   [(set (reg:CC 17)
1845         (ltu:CC (match_dup 1)
1846                 (match_dup 2)))
1847    (set (match_dup 0)
1848         (ne:SI (reg:CC 17) (const_int 0)))
1849    (set (match_dup 0)
1850         (xor:SI (match_dup 0)
1851                 (const_int 1)))]
1852   "")
1853
1854 ;; If optimizing for space, use -(reg - 1) to invert the comparison rather than
1855 ;; xor reg,reg,1 which might eliminate a NOP being inserted.
1856 (define_split
1857   [(set (match_operand:SI 0 "register_operand" "")
1858         (geu:SI (match_operand:SI 1 "register_operand" "")
1859                 (match_operand:SI 2 "reg_or_int16_operand" "")))
1860    (clobber (reg:CC 17))]
1861   "optimize_size"
1862   [(set (reg:CC 17)
1863         (ltu:CC (match_dup 1)
1864                 (match_dup 2)))
1865    (set (match_dup 0)
1866         (ne:SI (reg:CC 17) (const_int 0)))
1867    (set (match_dup 0)
1868         (plus:SI (match_dup 0)
1869                  (const_int -1)))
1870    (set (match_dup 0)
1871         (neg:SI (match_dup 0)))]
1872   "")
1873
1874 (define_insn "movcc_insn"
1875   [(set (match_operand:SI 0 "register_operand" "=r")
1876         (ne:SI (reg:CC 17) (const_int 0)))]
1877   ""
1878   "mvfc %0, cbr"
1879   [(set_attr "type" "misc")
1880    (set_attr "length" "2")])
1881
1882 \f
1883 ;; Unconditional and other jump instructions.
1884
1885 (define_insn "jump"
1886   [(set (pc) (label_ref (match_operand 0 "" "")))]
1887   ""
1888   "bra %l0"
1889   [(set_attr "type" "uncond_branch")
1890    (set (attr "length") (if_then_else (ltu (plus (minus (match_dup 0) (pc))
1891                                                  (const_int 400))
1892                                            (const_int 800))
1893                                       (const_int 2)
1894                                       (const_int 4)))])
1895
1896 (define_insn "indirect_jump"
1897   [(set (pc) (match_operand:SI 0 "address_operand" "p"))]
1898   ""
1899   "jmp %a0"
1900   [(set_attr "type" "uncond_branch")
1901    (set_attr "length" "2")])
1902
1903 (define_insn "return_lr"
1904   [(parallel [(return) (use (reg:SI 14))])]
1905   ""
1906   "jmp lr"
1907   [(set_attr "type" "uncond_branch")
1908    (set_attr "length" "2")])
1909
1910 (define_insn "return_rte"
1911   [(return)]
1912   ""
1913   "rte"
1914   [(set_attr "type" "uncond_branch")
1915    (set_attr "length" "2")])
1916
1917 (define_expand "return"
1918   [(return)]
1919   "direct_return ()"
1920   "
1921 {
1922   emit_jump_insn (gen_return_lr ());
1923   DONE;
1924 }")
1925
1926 (define_expand "return_normal"
1927   [(return)]
1928   "!direct_return ()"
1929   "
1930 {
1931   enum m32r_function_type fn_type;
1932
1933   fn_type = m32r_compute_function_type (current_function_decl);
1934   if (M32R_INTERRUPT_P (fn_type))
1935     {
1936       emit_jump_insn (gen_return_rte ());
1937       DONE;
1938     }
1939
1940   emit_jump_insn (gen_return_lr ());
1941   DONE;
1942 }")
1943
1944 (define_expand "tablejump"
1945   [(parallel [(set (pc) (match_operand 0 "register_operand" "r"))
1946               (use (label_ref (match_operand 1 "" "")))])]
1947   ""
1948   "
1949 {
1950   /* In pic mode, our address differences are against the base of the
1951      table.  Add that base value back in; CSE ought to be able to combine
1952      the two address loads.  */
1953   if (flag_pic)
1954     {
1955       rtx tmp, tmp2;
1956
1957       tmp = gen_rtx_LABEL_REF (Pmode, operands[1]);
1958       tmp2 = operands[0];
1959       tmp = gen_rtx_PLUS (Pmode, tmp2, tmp);
1960       operands[0] = memory_address (Pmode, tmp);
1961     }
1962 }")
1963
1964 (define_insn "*tablejump_insn"
1965   [(set (pc) (match_operand:SI 0 "address_operand" "p"))
1966    (use (label_ref (match_operand 1 "" "")))]
1967   ""
1968   "jmp %a0"
1969   [(set_attr "type" "uncond_branch")
1970    (set_attr "length" "2")])
1971
1972 (define_expand "call"
1973   ;; operands[1] is stack_size_rtx
1974   ;; operands[2] is next_arg_register
1975   [(parallel [(call (match_operand:SI 0 "call_operand" "")
1976                     (match_operand 1 "" ""))
1977              (clobber (reg:SI 14))])]
1978   ""
1979   "
1980 {
1981   if (flag_pic)
1982     crtl->uses_pic_offset_table = 1;
1983 }")
1984
1985 (define_insn "*call_via_reg"
1986   [(call (mem:SI (match_operand:SI 0 "register_operand" "r"))
1987          (match_operand 1 "" ""))
1988    (clobber (reg:SI 14))]
1989   ""
1990   "jl %0"
1991   [(set_attr "type" "call")
1992    (set_attr "length" "2")])
1993
1994 (define_insn "*call_via_label"
1995   [(call (mem:SI (match_operand:SI 0 "call_address_operand" ""))
1996          (match_operand 1 "" ""))
1997    (clobber (reg:SI 14))]
1998   ""
1999   "*
2000 {
2001   int call26_p = call26_operand (operands[0], FUNCTION_MODE);
2002
2003   if (! call26_p)
2004     {
2005       /* We may not be able to reach with a `bl' insn so punt and leave it to
2006          the linker.
2007          We do this here, rather than doing a force_reg in the define_expand
2008          so these insns won't be separated, say by scheduling, thus simplifying
2009          the linker.  */
2010       return \"seth r14,%T0\;add3 r14,r14,%B0\;jl r14\";
2011     }
2012   else
2013     return \"bl %0\";
2014 }"
2015   [(set_attr "type" "call")
2016    (set (attr "length")
2017         (if_then_else (eq (symbol_ref "call26_operand (operands[0], FUNCTION_MODE)")
2018                           (const_int 0))
2019                       (const_int 12) ; 10 + 2 for nop filler
2020                       ; The return address must be on a 4 byte boundary so
2021                       ; there's no point in using a value of 2 here.  A 2 byte
2022                       ; insn may go in the left slot but we currently can't
2023                       ; use such knowledge.
2024                       (const_int 4)))])
2025
2026 (define_expand "call_value"
2027   ;; operand 2 is stack_size_rtx
2028   ;; operand 3 is next_arg_register
2029   [(parallel [(set (match_operand 0 "register_operand" "=r")
2030                    (call (match_operand:SI 1 "call_operand" "")
2031                          (match_operand 2 "" "")))
2032              (clobber (reg:SI 14))])]
2033   ""
2034   "
2035 {
2036   if (flag_pic)
2037     crtl->uses_pic_offset_table = 1;
2038 }")
2039
2040 (define_insn "*call_value_via_reg"
2041   [(set (match_operand 0 "register_operand" "=r")
2042         (call (mem:SI (match_operand:SI 1 "register_operand" "r"))
2043               (match_operand 2 "" "")))
2044    (clobber (reg:SI 14))]
2045   ""
2046   "jl %1"
2047   [(set_attr "type" "call")
2048    (set_attr "length" "2")])
2049
2050 (define_insn "*call_value_via_label"
2051   [(set (match_operand 0 "register_operand" "=r")
2052         (call (mem:SI (match_operand:SI 1 "call_address_operand" ""))
2053               (match_operand 2 "" "")))
2054    (clobber (reg:SI 14))]
2055   ""
2056   "*
2057 {
2058   int call26_p = call26_operand (operands[1], FUNCTION_MODE);
2059
2060   if (flag_pic)
2061     crtl->uses_pic_offset_table = 1;
2062
2063   if (! call26_p)
2064     {
2065       /* We may not be able to reach with a `bl' insn so punt and leave it to
2066          the linker.
2067          We do this here, rather than doing a force_reg in the define_expand
2068          so these insns won't be separated, say by scheduling, thus simplifying
2069          the linker.  */
2070       return \"seth r14,%T1\;add3 r14,r14,%B1\;jl r14\";
2071     }
2072   else
2073     return \"bl %1\";
2074 }"
2075   [(set_attr "type" "call")
2076    (set (attr "length")
2077         (if_then_else (eq (symbol_ref "call26_operand (operands[1], FUNCTION_MODE)")
2078                           (const_int 0))
2079                       (const_int 12) ; 10 + 2 for nop filler
2080                       ; The return address must be on a 4 byte boundary so
2081                       ; there's no point in using a value of 2 here.  A 2 byte
2082                       ; insn may go in the left slot but we currently can't
2083                       ; use such knowledge.
2084                       (const_int 4)))])
2085 \f
2086 (define_insn "nop"
2087   [(const_int 0)]
2088   ""
2089   "nop"
2090   [(set_attr "type" "int2")
2091    (set_attr "length" "2")])
2092
2093 ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
2094 ;; all of memory.  This blocks insns from being moved across this point.
2095
2096 (define_insn "blockage"
2097   [(unspec_volatile [(const_int 0)] UNSPECV_BLOCKAGE)]
2098   ""
2099   "")
2100
2101 ;; Special pattern to flush the icache.
2102
2103 (define_insn "flush_icache"
2104   [(unspec_volatile [(match_operand 0 "memory_operand" "m")]
2105                     UNSPECV_FLUSH_ICACHE)
2106    (match_operand 1 "" "")
2107    (clobber (reg:SI 17))]
2108   ""
2109   "* return \"trap %#%1 ; flush-icache\";"
2110   [(set_attr "type" "int4")
2111    (set_attr "length" "4")])
2112 \f
2113 ;; Speed up fabs and provide correct sign handling for -0
2114
2115 (define_insn "absdf2"
2116   [(set (match_operand:DF 0 "register_operand" "=r")
2117         (abs:DF (match_operand:DF 1 "register_operand" "0")))]
2118   ""
2119   "#"
2120   [(set_attr "type" "multi")
2121    (set_attr "length" "4")])
2122
2123 (define_split
2124   [(set (match_operand:DF 0 "register_operand" "")
2125         (abs:DF (match_operand:DF 1 "register_operand" "")))]
2126   "reload_completed"
2127   [(set (match_dup 2)
2128         (ashift:SI (match_dup 2)
2129                    (const_int 1)))
2130    (set (match_dup 2)
2131         (lshiftrt:SI (match_dup 2)
2132                      (const_int 1)))]
2133   "operands[2] = gen_highpart (SImode, operands[0]);")
2134
2135 (define_insn "abssf2"
2136   [(set (match_operand:SF 0 "register_operand" "=r")
2137         (abs:SF (match_operand:SF 1 "register_operand" "0")))]
2138   ""
2139   "#"
2140   [(set_attr "type" "multi")
2141    (set_attr "length" "4")])
2142
2143 (define_split
2144   [(set (match_operand:SF 0 "register_operand" "")
2145         (abs:SF (match_operand:SF 1 "register_operand" "")))]
2146   "reload_completed"
2147   [(set (match_dup 2)
2148         (ashift:SI (match_dup 2)
2149                    (const_int 1)))
2150    (set (match_dup 2)
2151         (lshiftrt:SI (match_dup 2)
2152                      (const_int 1)))]
2153   "operands[2] = gen_highpart (SImode, operands[0]);")
2154 \f
2155 ;; Conditional move instructions
2156 ;; Based on those done for the d10v
2157
2158 (define_expand "movsicc"
2159   [
2160    (set (match_operand:SI 0 "register_operand" "r")
2161         (if_then_else:SI (match_operand 1 "" "")
2162                          (match_operand:SI 2 "conditional_move_operand" "O")
2163                          (match_operand:SI 3 "conditional_move_operand" "O")
2164         )
2165    )
2166   ]
2167   ""
2168   "
2169 {
2170   if (! zero_and_one (operands [2], operands [3]))
2171     FAIL;
2172
2173   /* Generate the comparison that will set the carry flag.  */
2174   operands[1] = gen_compare (GET_CODE (operands[1]), XEXP (operands[1], 0),
2175                              XEXP (operands[1], 1), TRUE);
2176
2177   /* See other movsicc pattern below for reason why.  */
2178   emit_insn (gen_blockage ());
2179 }")
2180
2181 ;; Generate the conditional instructions based on how the carry flag is examined.
2182 (define_insn "*movsicc_internal"
2183   [(set (match_operand:SI 0 "register_operand" "=r")
2184         (if_then_else:SI (match_operand 1 "carry_compare_operand" "")
2185                          (match_operand:SI 2 "conditional_move_operand" "O")
2186                          (match_operand:SI 3 "conditional_move_operand" "O")
2187         )
2188    )]
2189   "zero_and_one (operands [2], operands[3])"
2190   "* return emit_cond_move (operands, insn);"
2191   [(set_attr "type" "multi")
2192    (set_attr "length" "8")
2193   ]
2194 )
2195
2196 \f
2197 ;; Block moves, see m32r.c for more details.
2198 ;; Argument 0 is the destination
2199 ;; Argument 1 is the source
2200 ;; Argument 2 is the length
2201 ;; Argument 3 is the alignment
2202
2203 (define_expand "movmemsi"
2204   [(parallel [(set (match_operand:BLK 0 "general_operand" "")
2205                    (match_operand:BLK 1 "general_operand" ""))
2206               (use (match_operand:SI  2 "immediate_operand" ""))
2207               (use (match_operand:SI  3 "immediate_operand" ""))])]
2208   ""
2209   "
2210 {
2211   if (operands[0])              /* Avoid unused code messages.  */
2212     {
2213      if (m32r_expand_block_move (operands))
2214        DONE;
2215      else
2216        FAIL;
2217     }
2218 }")
2219
2220 ;; Insn generated by block moves
2221
2222 (define_insn "movmemsi_internal"
2223   [(set (mem:BLK (match_operand:SI 0 "register_operand" "r"))   ;; destination
2224         (mem:BLK (match_operand:SI 1 "register_operand" "r")))  ;; source
2225    (use (match_operand:SI 2 "m32r_block_immediate_operand" "J"));; # bytes to move
2226    (set (match_operand:SI 3 "register_operand" "=0")
2227         (plus:SI (minus (match_dup 2) (const_int 4))
2228                  (match_dup 0)))
2229    (set (match_operand:SI 4 "register_operand" "=1")
2230         (plus:SI (match_dup 1)
2231                  (match_dup 2)))
2232    (clobber (match_scratch:SI 5 "=&r"))  ;; temp1
2233    (clobber (match_scratch:SI 6 "=&r"))] ;; temp2
2234   ""
2235   "* m32r_output_block_move (insn, operands); return \"\"; "
2236   [(set_attr "type"     "store8")
2237    (set_attr "length"   "72")]) ;; Maximum
2238
2239 ;; PIC
2240
2241 /* When generating pic, we need to load the symbol offset into a register.
2242    So that the optimizer does not confuse this with a normal symbol load
2243    we use an unspec.  The offset will be loaded from a constant pool entry,
2244    since that is the only type of relocation we can use.  */
2245
2246 (define_insn "pic_load_addr"
2247   [(set (match_operand:SI 0 "register_operand" "=r")
2248         (unspec:SI [(match_operand 1 "" "")] UNSPEC_PIC_LOAD_ADDR))]
2249   "flag_pic"
2250   "ld24 %0,%#%1"
2251   [(set_attr "type" "int4")])
2252
2253 (define_insn "gotoff_load_addr"
2254   [(set (match_operand:SI 0 "register_operand" "=r")
2255         (unspec:SI [(match_operand 1 "" "")] UNSPEC_GOTOFF))]
2256   "flag_pic"
2257   "seth %0, %#shigh(%1@GOTOFF)\;add3 %0, %0, low(%1@GOTOFF)"
2258   [(set_attr "type"     "int4")
2259    (set_attr "length"   "8")])
2260
2261 ;; Load program counter insns.
2262
2263 (define_insn "get_pc"
2264   [(clobber (reg:SI 14))
2265    (set (match_operand 0 "register_operand" "=r,r")
2266         (unspec [(match_operand 1 "" "")] UNSPEC_GET_PC))
2267    (use (match_operand:SI 2 "immediate_operand" "W,i"))]
2268   "flag_pic"
2269   "@
2270    bl.s .+4\;seth %0,%#shigh(%1)\;add3 %0,%0,%#low(%1+4)\;add %0,lr
2271    bl.s .+4\;ld24 %0,%#%1\;add %0,lr"
2272   [(set_attr "length" "12,8")])
2273
2274 (define_expand "builtin_setjmp_receiver"
2275   [(label_ref (match_operand 0 "" ""))]
2276   "flag_pic"
2277   "
2278 {
2279   m32r_load_pic_register ();
2280   DONE;
2281 }")