OSDN Git Service

* MAINTAINERS: Add myself as a maintainer for the RX port.
[pf3gnuchains/gcc-fork.git] / gcc / config / rx / rx.md
1 ;;  Machine Description for Renesas RX processors
2 ;;  Copyright (C) 2008, 2009 Free Software Foundation, Inc.
3 ;;  Contributed by Red Hat.
4
5 ;; This file is part of GCC.
6
7 ;; GCC is free software; you can redistribute it and/or modify
8 ;; it under the terms of the GNU General Public License as published by
9 ;; the Free Software Foundation; either version 3, or (at your option)
10 ;; any later version.
11
12 ;; GCC is distributed in the hope that it will be useful,
13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 ;; GNU General Public 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 \f
21
22 ;; This code iterator allows all branch instructions to
23 ;; be generated from a single define_expand template.
24 (define_code_iterator most_cond [eq ne gt ge lt le gtu geu ltu leu
25                                  unordered ordered ])
26
27 ;; This code iterator is used for sign- and zero- extensions.
28 (define_mode_iterator small_int_modes [(HI "") (QI "")])
29
30 ;; We do not handle DFmode here because by default it is
31 ;; the same as SFmode, and if -m64bit-doubles is active
32 ;; then all operations on doubles have to be handled by
33 ;; library functions.
34 (define_mode_iterator register_modes
35   [(SF "ALLOW_RX_FPU_INSNS") (SI "") (HI "") (QI "")])
36
37
38 ;; Used to map RX condition names to GCC
39 ;; condition names for builtin instructions.
40 (define_code_iterator gcc_conds [eq ne gt ge lt le gtu geu ltu leu
41                                 unge unlt uneq ltgt])
42 (define_code_attr rx_conds [(eq "eq") (ne "ne") (gt "gt") (ge "ge") (lt "lt")
43                             (le "le") (gtu "gtu") (geu "geu") (ltu "ltu")
44                             (leu "leu") (unge "pz") (unlt "n") (uneq "o")
45                             (ltgt "no")])
46
47 (define_constants
48   [
49    (SP_REG 0)
50
51    (UNSPEC_LOW_REG         0)
52    (UNSPEC_HIGH_REG        1)
53
54    (UNSPEC_RTE             10)
55    (UNSPEC_RTFI            11)
56    (UNSPEC_NAKED           12)
57    
58    (UNSPEC_MOVSTR          20)
59    (UNSPEC_MOVMEM          21)
60    (UNSPEC_SETMEM          22)
61    (UNSPEC_STRLEN          23)
62    (UNSPEC_CMPSTRN         24)
63
64    (UNSPEC_BUILTIN_BRK     30)
65    (UNSPEC_BUILTIN_CLRPSW  31)
66    (UNSPEC_BUILTIN_INT     32)
67    (UNSPEC_BUILTIN_MACHI   33)
68    (UNSPEC_BUILTIN_MACLO   34)
69    (UNSPEC_BUILTIN_MULHI   35)
70    (UNSPEC_BUILTIN_MULLO   36)
71    (UNSPEC_BUILTIN_MVFACHI 37)
72    (UNSPEC_BUILTIN_MVFACMI 38)
73    (UNSPEC_BUILTIN_MVFC    39)
74    (UNSPEC_BUILTIN_MVFCP   40)
75    (UNSPEC_BUILTIN_MVTACHI 41)
76    (UNSPEC_BUILTIN_MVTACLO 42)
77    (UNSPEC_BUILTIN_MVTC    43)
78    (UNSPEC_BUILTIN_MVTCP   44)
79    (UNSPEC_BUILTIN_OPEPC   45)
80    (UNSPEC_BUILTIN_RACW    46)
81    (UNSPEC_BUILTIN_REVW    47)
82    (UNSPEC_BUILTIN_RMPA    48)
83    (UNSPEC_BUILTIN_ROUND   49)
84    (UNSPEC_BUILTIN_SAT     50)
85    (UNSPEC_BUILTIN_SETPSW  51)
86    (UNSPEC_BUILTIN_WAIT    52)
87   ]
88 )
89
90 ;; Condition code settings:
91 ;;   none     - insn does not affect the condition code bits
92 ;;   set_zs   - insn sets z,s to usable values;
93 ;;   set_zso  - insn sets z,s,o to usable values;
94 ;;   set_zsoc - insn sets z,s,o,c to usable values;
95 ;;   clobber  - value of cc0 is unknown
96 (define_attr "cc" "none,set_zs,set_zso,set_zsoc,clobber" (const_string "none"))
97
98 (define_attr "length" "" (const_int 8))
99
100 (include "predicates.md")
101 (include "constraints.md")
102
103 ;; Pipeline description.
104
105 ;; The RX only has a single pipeline.  It has five stages (fetch,
106 ;; decode, execute, memory access, writeback) each of which normally
107 ;; takes a single CPU clock cycle.
108
109 ;; The timings attribute consists of two numbers, the first is the
110 ;; throughput, which is the number of cycles the instruction takes
111 ;; to execute and generate a result.  The second is the latency
112 ;; which is the effective number of cycles the instruction takes to
113 ;; execute if its result is used by the following instruction.  The
114 ;; latency is always greater than or equal to the throughput.
115 ;; These values were taken from tables 2.13 and 2.14 in section 2.8
116 ;; of the RX610 Group Hardware Manual v0.11
117
118 ;; Note - it would be nice to use strings rather than integers for
119 ;; the possible values of this attribute, so that we can have the
120 ;; gcc build mechanism check for values that are not supported by
121 ;; the reservations below.  But this will not work because the code
122 ;; in rx_adjust_sched_cost() needs integers not strings.
123
124 (define_attr "timings" "" (const_int 11))
125
126 (define_automaton "pipelining")
127 (define_cpu_unit "throughput" "pipelining")
128
129 (define_insn_reservation "throughput__1_latency__1"  1
130   (eq_attr "timings" "11") "throughput")
131 (define_insn_reservation "throughput__1_latency__2"  2
132   (eq_attr "timings" "12") "throughput,nothing")
133 (define_insn_reservation "throughput__2_latency__2"  1
134   (eq_attr "timings" "22") "throughput*2")
135 (define_insn_reservation "throughput__3_latency__3"  1
136   (eq_attr "timings" "33") "throughput*3")
137 (define_insn_reservation "throughput__3_latency__4"  2
138   (eq_attr "timings" "34") "throughput*3,nothing")
139 (define_insn_reservation "throughput__4_latency__4"  1
140   (eq_attr "timings" "44") "throughput*4")
141 (define_insn_reservation "throughput__4_latency__5"  2
142   (eq_attr "timings" "45") "throughput*4,nothing")
143 (define_insn_reservation "throughput__5_latency__5"  1
144   (eq_attr "timings" "55") "throughput*5")
145 (define_insn_reservation "throughput__5_latency__6"  2
146   (eq_attr "timings" "56") "throughput*5,nothing")
147 (define_insn_reservation "throughput__6_latency__6"  1
148   (eq_attr "timings" "66") "throughput*6")
149 (define_insn_reservation "throughput_10_latency_10"  1
150   (eq_attr "timings" "1010") "throughput*10")
151 (define_insn_reservation "throughput_11_latency_11"  1
152   (eq_attr "timings" "1111") "throughput*11")
153 (define_insn_reservation "throughput_16_latency_16"  1
154   (eq_attr "timings" "1616") "throughput*16")
155 (define_insn_reservation "throughput_18_latency_18"  1
156   (eq_attr "timings" "1818") "throughput*18")
157
158 ;; Comparisons
159
160 (define_expand "cbranchsi4"
161   [(set (cc0) (compare:CC (match_operand:SI 1 "register_operand")
162                           (match_operand:SI 2 "rx_source_operand")))
163    (set (pc)
164         (if_then_else (match_operator:SI  0 "comparison_operator"
165                                           [(cc0) (const_int 0)])
166                       (label_ref (match_operand 3 ""))
167                       (pc)))]
168   ""
169   ""
170 )
171
172 (define_expand "cbranchsf4"
173   [(set (cc0) (compare:CC (match_operand:SF 1 "register_operand")
174                           (match_operand:SF 2 "rx_source_operand")))
175    (set (pc)
176         (if_then_else (match_operator:SI  0 "comparison_operator"
177                                           [(cc0) (const_int 0)])
178                       (label_ref (match_operand 3 ""))
179                       (pc)))]
180   "ALLOW_RX_FPU_INSNS && ! flag_non_call_exceptions"
181   ""
182 )
183
184 ;; The TST instruction is not used as it does not set the Carry flag,
185 ;; so for example, the LessThan comparison cannot be tested.
186 ;;
187 ;; (define_insn "tstsi"
188 ;;   [(set (cc0)
189 ;;         (match_operand:SI 0 "rx_source_operand"  "r,i,Q")))]
190 ;;   ""
191 ;;   {
192 ;;     rx_float_compare_mode = false;
193 ;;     return "tst\t%Q0";
194 ;;   }
195 ;;   [(set_attr "cc" "set_zs")
196 ;;    (set_attr "timings" "11,11,33")
197 ;;    (set_attr "length" "3,7,6")]
198 ;; )
199
200 (define_insn "cmpsi"
201   [(set (cc0) (compare:CC
202                (match_operand:SI 0 "register_operand"  "r,r,r,r,r,r,r")
203                (match_operand:SI 1 "rx_source_operand"
204                                  "r,Uint04,Int08,Sint16,Sint24,i,Q")))]
205   ""
206   {
207     rx_float_compare_mode = false;
208     return "cmp\t%Q1, %Q0";
209   }
210   [(set_attr "cc" "set_zsoc")
211    (set_attr "timings" "11,11,11,11,11,11,33")
212    (set_attr "length"  "2,2,3,4,5,6,5")]
213 )
214
215 ;; This pattern is disabled when -fnon-call-exceptions is active because
216 ;; it could generate a floating point exception, which would introduce an
217 ;; edge into the flow graph between this insn and the conditional branch
218 ;; insn to follow, thus breaking the cc0 relationship.  Run the g++ test
219 ;; g++.dg/eh/080514-1.C to see this happen.
220 (define_insn "cmpsf"
221   [(set (cc0)
222         (compare:CC (match_operand:SF 0 "register_operand"  "r,r,r")
223                     (match_operand:SF 1 "rx_source_operand" "r,i,Q")))]
224   "ALLOW_RX_FPU_INSNS && ! flag_non_call_exceptions"
225   {
226     rx_float_compare_mode = true;
227     return "fcmp\t%1, %0";
228   }
229   [(set_attr "cc" "set_zso")
230    (set_attr "timings" "11,11,33")
231    (set_attr "length" "3,7,5")]
232 )
233
234 ;; Flow Control Instructions:
235
236 (define_expand "b<code>"
237   [(set (pc)
238         (if_then_else (most_cond (cc0) (const_int 0))
239                       (label_ref (match_operand 0))
240                       (pc)))]
241   ""
242   ""
243 )
244
245 (define_insn "*conditional_branch"
246   [(set (pc)
247         (if_then_else (match_operator           1 "comparison_operator"
248                                                 [(cc0) (const_int 0)])
249                       (label_ref (match_operand 0 "" ""))
250                       (pc)))]
251   ""
252   {
253     return rx_gen_cond_branch_template (operands[1], false);
254   }
255   [(set_attr "length" "8")    ;; This length is wrong, but it is
256                               ;; too hard to compute statically.
257    (set_attr "timings" "33")  ;; The timing assumes that the branch is taken.
258    (set_attr "cc" "clobber")] ;; FIXME: This clobber is wrong.
259 )
260
261 (define_insn "*reveresed_conditional_branch"
262   [(set (pc)
263         (if_then_else (match_operator 1 "comparison_operator"
264                                       [(cc0) (const_int 0)])
265                       (pc)
266                       (label_ref (match_operand 0 "" ""))))]
267   ""
268   {
269     return rx_gen_cond_branch_template (operands[1], true);
270   }
271   [(set_attr "length" "8")    ;; This length is wrong, but it is
272                               ;; too hard to compute statically.
273    (set_attr "timings" "33")  ;; The timing assumes that the branch is taken.
274    (set_attr "cc" "clobber")] ;; FIXME: This clobber is wrong.
275 )
276
277 (define_insn "jump"
278   [(set (pc) (label_ref (match_operand 0 "" "")))]
279   ""
280   "bra\t%0"
281   [(set_attr "length" "4")
282    (set_attr "timings" "33")
283    (set_attr "cc" "clobber")] ;; FIXME: This clobber is wrong.
284 )
285
286 (define_insn "indirect_jump"
287   [(set (pc) (match_operand:SI 0 "register_operand" "r"))]
288   ""
289   "jmp\t%0"
290   [(set_attr "length" "2")
291    (set_attr "timings" "33")
292    (set_attr "cc" "clobber")] ;; FIXME: This clobber is wrong.
293 )
294
295 (define_insn "tablejump"
296   [(set (pc) (match_operand:SI     0 "register_operand" "r"))
297    (use (label_ref (match_operand  1 "" "")))]
298   ""
299   { return flag_pic ? (TARGET_AS100_SYNTAX ? "\n?:\tbra\t%0"
300                                            : "\n1:\tbra\t%0")
301                                            : "jmp\t%0";
302   }
303   [(set_attr "cc" "clobber") ;; FIXME: This clobber is wrong.
304    (set_attr "timings" "33")
305    (set_attr "length" "2")]
306 )
307
308 (define_insn "simple_return"
309   [(return)]
310   ""
311   "rts"
312   [(set_attr "length" "1")
313    (set_attr "timings" "55")]
314 )
315
316 (define_insn "deallocate_and_return"
317   [(set (reg:SI SP_REG)
318         (plus:SI (reg:SI SP_REG)
319                  (match_operand:SI 0 "immediate_operand" "i")))
320    (return)]
321   ""
322   "rtsd\t%0"
323   [(set_attr "length" "2")
324    (set_attr "timings" "55")]
325 )
326
327 (define_insn "pop_and_return"
328   [(match_parallel                    1 "rx_rtsd_vector"
329                    [(set:SI (reg:SI SP_REG)
330                             (plus:SI (reg:SI SP_REG)
331                                      (match_operand:SI
332                                       0 "const_int_operand" "n")))])]
333   "reload_completed"
334   {
335     rx_emit_stack_popm (operands, false);
336     return "";
337   }
338   [(set_attr "length" "3")
339    (set_attr "timings" "56")]
340 )
341
342 (define_insn "fast_interrupt_return"
343   [(unspec_volatile [(return)] UNSPEC_RTFI) ]
344   ""
345   "rtfi"
346   [(set_attr "length" "2")
347    (set_attr "timings" "33")]
348 )
349
350 (define_insn "exception_return"
351   [(unspec_volatile [(return)] UNSPEC_RTE) ]
352   ""
353   "rte"
354   [(set_attr "length" "2")
355    (set_attr "timings" "66")]
356 )
357
358 (define_insn "naked_return"
359   [(unspec_volatile [(return)] UNSPEC_NAKED) ]
360   ""
361   "; Naked function: epilogue provided by programmer."
362 )
363
364
365 ;; Note - the following set of patterns do not use the "memory_operand"
366 ;; predicate or an "m" constraint because we do not allow symbol_refs
367 ;; or label_refs as legitmate memory addresses.  This matches the
368 ;; behaviour of most of the RX instructions.  Only the call/branch
369 ;; instructions are allowed to refer to symbols/labels directly.
370 ;; The call operands are in QImode because that is the value of
371 ;; FUNCTION_MODE
372
373 (define_expand "call"
374   [(call (match_operand:QI 0 "general_operand")
375          (match_operand:SI 1 "general_operand"))]
376   ""
377   {
378     rtx dest = XEXP (operands[0], 0);
379
380     if (! rx_call_operand (dest, Pmode))
381       dest = force_reg (Pmode, dest);
382     emit_call_insn (gen_call_internal (dest, operands[1]));
383     DONE;
384   }
385 )
386
387 (define_insn "call_internal"
388   [(call (mem:QI (match_operand:SI 0 "rx_call_operand" "r,Symbol"))
389          (match_operand:SI         1 "general_operand" "g,g"))]
390   ""
391   "@
392   jsr\t%A0
393   bsr\t%A0"
394   [(set_attr "length" "2,4")
395    (set_attr "timings" "33")]
396 )
397
398 (define_expand "call_value"
399   [(set (match_operand          0 "register_operand")
400         (call (match_operand:QI 1 "general_operand")
401               (match_operand:SI 2 "general_operand")))]
402   ""
403   {
404     rtx dest = XEXP (operands[1], 0);
405
406     if (! rx_call_operand (dest, Pmode))
407       dest = force_reg (Pmode, dest);
408     emit_call_insn (gen_call_value_internal (operands[0], dest, operands[2]));
409     DONE;
410   }
411 )
412
413 (define_insn "call_value_internal"
414   [(set (match_operand                  0 "register_operand" "=r,r")
415         (call (mem:QI (match_operand:SI 1 "rx_call_operand"   "r,Symbol"))
416               (match_operand:SI         2 "general_operand"   "g,g")))]
417   ""
418   "@
419   jsr\t%A1
420   bsr\t%A1"
421   [(set_attr "length" "2,4")
422    (set_attr "timings" "33")]
423 )
424
425 (define_insn "sibcall"
426  [(call (mem:QI (match_operand:SI 0 "rx_symbolic_call_operand" "Symbol"))
427         (match_operand:SI         1 "general_operand"          "g"))
428   (return)
429   (use (match_operand             2 "" ""))]
430   ""
431   "bra\t%A0"
432   [(set_attr "length" "4")
433    (set_attr "timings" "33")]
434 )
435
436 (define_insn "sibcall_value"
437  [(set (match_operand                  0 "register_operand"         "=r")
438        (call (mem:QI (match_operand:SI 1 "rx_symbolic_call_operand" "Symbol"))
439              (match_operand:SI         2 "general_operand"          "g")))
440   (return)
441   (use (match_operand                  3 "" ""))]
442   ""
443   "bra\t%A1"
444   [(set_attr "length" "4")
445    (set_attr "timings" "33")]
446 )
447
448 ;; Function Prologue/Epilogue Instructions
449
450 (define_expand "prologue"
451   [(const_int 0)]
452   ""
453   "rx_expand_prologue (); DONE;"
454 )
455
456 (define_expand "epilogue"
457   [(return)]
458   ""
459   "rx_expand_epilogue (false); DONE;"
460 )
461
462 (define_expand "sibcall_epilogue"
463   [(return)]
464   ""
465   "rx_expand_epilogue (true); DONE;"
466 )
467
468 ;; Move Instructions
469
470 ;; Note - we do not allow memory to memory moves, even though the ISA
471 ;; supports them.  The reason is that the conditions on such moves are
472 ;; too restrictive, specifically the source addressing mode is limited
473 ;; by the destination addressing mode and vice versa.  (For example it
474 ;; is not possible to use indexed register indirect addressing for one
475 ;; of the operands if the other operand is anything other than a register,
476 ;; but it is possible to use register relative addressing when the other
477 ;; operand also uses register relative or register indirect addressing).
478 ;;
479 ;; GCC does not support computing legitimate addresses based on the
480 ;; nature of other operands involved in the instruction, and reload is
481 ;; not smart enough to cope with a whole variety of different memory
482 ;; addressing constraints, so it is simpler and safer to just refuse
483 ;; to support memory to memory moves.
484
485 (define_expand "mov<register_modes:mode>"
486   [(set (match_operand:register_modes 0 "general_operand")
487         (match_operand:register_modes 1 "general_operand"))]
488   ""
489   {
490     if (MEM_P (operand0) && MEM_P (operand1))
491       operands[1] = copy_to_mode_reg (<register_modes:MODE>mode, operand1);
492   }
493 )
494
495 (define_insn "*mov<register_modes:mode>_internal"
496   [(set (match_operand:register_modes
497          0 "nonimmediate_operand" "=r,r,r,r,r,r,m,Q,Q,Q,Q")
498         (match_operand:register_modes
499          1 "general_operand" "Int08,Sint16,Sint24,i,r,m,r,Int08,Sint16,Sint24,i"))]
500   ""
501   { return rx_gen_move_template (operands, false); }
502   [(set_attr "length" "3,4,5,6,2,4,6,5,6,7,8")
503    (set_attr "timings" "11,11,11,11,11,12,11,11,11,11,11")]
504 )
505
506 (define_insn "extend<small_int_modes:mode>si2"
507   [(set (match_operand:SI 0 "register_operand"    "=r,r")
508         (sign_extend:SI (match_operand:small_int_modes
509                           1 "nonimmediate_operand" "r,m")))]
510   ""
511   { return rx_gen_move_template (operands, false); }
512   [(set_attr "length" "2,6")
513    (set_attr "timings" "11,12")]
514 )
515
516 (define_insn "zero_extend<small_int_modes:mode>si2"
517   [(set (match_operand:SI 0 "register_operand"     "=r,r")
518         (zero_extend:SI (match_operand:small_int_modes
519                           1 "nonimmediate_operand"  "r,m")))]
520   ""
521   { return rx_gen_move_template (operands, true); }
522   [(set_attr "length" "2,4")
523    (set_attr "timings" "11,12")]
524 )
525
526 (define_insn "stack_push"
527   [(set:SI (reg:SI SP_REG)
528            (minus:SI (reg:SI SP_REG)
529                      (const_int 4)))
530    (set:SI (mem:SI (reg:SI SP_REG))
531            (match_operand:SI 0 "register_operand" "r"))]
532   ""
533   "push.l\t%0"
534   [(set_attr "length" "2")]
535 )
536
537 (define_insn "stack_pushm"
538   [(match_parallel                     1 "rx_store_multiple_vector"
539                    [(set:SI (reg:SI SP_REG)
540                             (minus:SI (reg:SI SP_REG)
541                                       (match_operand:SI
542                                        0 "const_int_operand" "n")))])]
543   "reload_completed"
544   {
545     rx_emit_stack_pushm (operands);
546     return "";
547   }
548   [(set_attr "length" "2")
549    (set_attr "timings" "44")] ;; The timing is a guesstimate average timing.
550 )
551
552 (define_insn "stack_pop"
553   [(set:SI (match_operand:SI 0 "register_operand" "=r")
554            (mem:SI (reg:SI SP_REG)))
555    (set:SI (reg:SI SP_REG)
556            (plus:SI (reg:SI SP_REG)
557                     (const_int 4)))]
558   ""
559   "pop\t%0"
560   [(set_attr "length" "2")
561    (set_attr "timings" "12")]
562 )
563
564 (define_insn "stack_popm"
565   [(match_parallel                     1 "rx_load_multiple_vector"
566                    [(set:SI (reg:SI SP_REG)
567                             (plus:SI (reg:SI SP_REG)
568                                      (match_operand:SI
569                                       0 "const_int_operand" "n")))])]
570   "reload_completed"
571   {
572     rx_emit_stack_popm (operands, true);
573     return "";
574   }
575   [(set_attr "length" "2")
576    (set_attr "timings" "45")] ;; The timing is a guesstimate average timing.
577 )
578
579 (define_insn "cstoresi4"
580   [(set (match_operand:SI  0 "register_operand" "=r,r,r,r,r,r,r")
581         (match_operator:SI
582          1 "comparison_operator"
583          [(match_operand:SI
584            2 "register_operand"  "r,r,r,r,r,r,r")
585           (match_operand:SI
586            3 "rx_source_operand" "r,Uint04,Int08,Sint16,Sint24,i,Q")]))]
587   ""
588   {
589     rx_float_compare_mode = false;
590     return "cmp\t%Q3, %Q2\n\tsc%B1.L\t%0";
591   }
592   [(set_attr "cc" "set_zsoc")
593    (set_attr "timings" "22,22,22,22,22,22,44")
594    (set_attr "length"  "5,5,6,7,8,9,8")]
595 )
596
597 (define_expand "movsicc"
598   [(set (match_operand:SI                   0 "register_operand")
599         (if_then_else:SI (match_operand:SI 1 "comparison_operator")
600                          (match_operand:SI  2 "nonmemory_operand")
601                          (match_operand:SI  3 "immediate_operand")))]
602   ""
603   {
604     if (GET_CODE (operands[1]) != EQ && GET_CODE (operands[1]) != NE)
605       FAIL;
606     if (! CONST_INT_P (operands[3]))
607       FAIL;
608   }
609 )
610
611 (define_insn "*movsieq"
612   [(set (match_operand:SI     0 "register_operand" "=r,r,r")
613         (if_then_else:SI (eq (match_operand:SI
614                               3 "register_operand"  "r,r,r")
615                              (match_operand:SI
616                               4 "rx_source_operand" "riQ,riQ,riQ"))
617                          (match_operand:SI
618                           1 "nonmemory_operand"     "0,i,r")
619                          (match_operand:SI
620                           2 "immediate_operand"     "i,i,i")))]
621   ""
622   "@
623   cmp\t%Q4, %Q3\n\tstnz\t%2, %0
624   cmp\t%Q4, %Q3\n\tmov.l\t%2, %0\n\tstz\t%1, %0
625   cmp\t%Q4, %Q3\n\tmov.l\t%1, %0\n\tstnz\t%2, %0"
626   [(set_attr "cc"      "set_zsoc")
627    (set_attr "length"  "13,19,15")
628    (set_attr "timings" "22,33,33")]
629 )
630
631 (define_insn "*movsine"
632   [(set (match_operand:SI                      0 "register_operand" "=r,r,r")
633         (if_then_else:SI (ne (match_operand:SI 3 "register_operand"  "r,r,r")
634                              (match_operand:SI 4 "rx_source_operand" "riQ,riQ,riQ"))
635                          (match_operand:SI     1 "nonmemory_operand" "0,i,r")
636                          (match_operand:SI     2 "immediate_operand" "i,i,i")))]
637   ""
638   "@
639   cmp\t%Q4, %Q3\n\tstz\t%2, %0
640   cmp\t%Q4, %Q3\n\tmov.l\t%2, %0\n\tstnz\t%1, %0
641   cmp\t%Q4, %Q3\n\tmov.l\t%1, %0\n\tstz\t%2, %0"
642   [(set_attr "cc"      "set_zsoc")
643    (set_attr "length"  "13,19,15")
644    (set_attr "timings" "22,33,33")]
645 )
646
647 ;; Arithmetic Instructions
648
649 (define_insn "abssi2"
650   [(set (match_operand:SI         0 "register_operand" "=r,r")
651         (abs:SI (match_operand:SI 1 "register_operand"  "0,r")))]
652   ""
653   "@
654   abs\t%0
655   abs\t%1, %0"
656   [(set_attr "cc" "set_zso")
657    (set_attr "length" "2,3")]
658 )
659
660 (define_insn "addsi3"
661   [(set (match_operand:SI 0 "register_operand"
662                           "=r,r,r,r,r,r,r,r,r,r,r,r")
663         (plus:SI (match_operand:SI
664                   1 "register_operand"
665                   "%0,0,0,0,0,0,r,r,r,r,r,0")
666                  (match_operand:SI
667                   2 "rx_source_operand"
668                   "r,Uint04,Sint08,Sint16,Sint24,i,r,Sint08,Sint16,Sint24,i,Q")))]
669   ""
670   "@
671   add\t%2, %0
672   add\t%2, %0
673   add\t%2, %0
674   add\t%2, %0
675   add\t%2, %0
676   add\t%2, %0
677   add\t%2, %1, %0
678   add\t%2, %1, %0
679   add\t%2, %1, %0
680   add\t%2, %1, %0
681   add\t%2, %1, %0
682   add\t%Q2, %0"
683   [(set_attr "cc" "set_zsoc")
684    (set_attr "timings" "11,11,11,11,11,11,11,11,11,11,11,33")
685    (set_attr "length" "2,2,3,4,5,6,3,3,4,5,6,5")]
686 )
687
688 (define_insn "adddi3"
689   [(set (match_operand:DI          0 "register_operand" "=r,r,r,r,r,r")
690         (plus:DI (match_operand:DI 1 "register_operand" "%0,0,0,0,0,0")
691                  (match_operand:DI 2 "rx_source_operand"
692                                    "r,Sint08,Sint16,Sint24,i,Q")))]
693   ""
694   "add\t%L2, %L0\n\tadc\t%H2, %H0"
695   [(set_attr "cc" "set_zsoc")
696    (set_attr "timings" "22,22,22,22,22,44")
697    (set_attr "length" "5,7,9,11,13,11")]
698 )
699
700 (define_insn "andsi3"
701   [(set (match_operand:SI         0 "register_operand"  "=r,r,r,r,r,r,r,r,r")
702         (and:SI (match_operand:SI 1 "register_operand"  "%0,0,0,0,0,0,r,0,Q")
703                 (match_operand:SI
704                  2 "rx_source_operand"
705                  "r,Uint04,Sint08,Sint16,Sint24,i,r,Q,0")))]
706   ""
707   "@
708   and\t%2, %0
709   and\t%2, %0
710   and\t%2, %0
711   and\t%2, %0
712   and\t%2, %0
713   and\t%2, %0
714   and\t%2, %1, %0
715   and\t%Q2, %0
716   and\t%Q1, %0"
717   [(set_attr "cc" "set_zs")
718    (set_attr "timings" "11,11,11,11,11,11,11,33,33")
719    (set_attr "length" "2,2,3,4,5,6,3,5,5")]
720 )
721
722 ;; Byte swap (single 32-bit value).
723 (define_insn "bswapsi2"
724   [(set (match_operand:SI           0 "register_operand" "+r")
725         (bswap:SI (match_operand:SI 1 "register_operand"  "r")))]
726   ""
727   "revl\t%1, %0"
728   [(set_attr "length" "3")]
729 )
730
731 ;; Byte swap (single 16-bit value).  Note - we ignore the swapping of the high 16-bits.
732 (define_insn "bswaphi2"
733   [(set (match_operand:HI           0 "register_operand" "+r")
734         (bswap:HI (match_operand:HI 1 "register_operand"  "r")))]
735   ""
736   "revw\t%1, %0"
737   [(set_attr "length" "3")]
738 )
739
740 (define_insn "divsi3"
741   [(set (match_operand:SI         0 "register_operand" "=r,r,r,r,r,r")
742         (div:SI (match_operand:SI 1 "register_operand"  "0,0,0,0,0,0")
743                 (match_operand:SI
744                  2 "rx_source_operand" "r,Sint08,Sint16,Sint24,i,Q")))]
745   ""
746   "div\t%Q2, %0"
747   [(set_attr "cc" "clobber")
748    (set_attr "timings" "1111") ;; Strictly speaking the timing should be
749                                ;; 2222, but that is a worst case sceanario.
750    (set_attr "length" "3,4,5,6,7,6")]
751 )
752
753 (define_insn "udivsi3"
754   [(set (match_operand:SI          0 "register_operand"  "=r,r,r,r,r,r")
755         (udiv:SI (match_operand:SI 1 "register_operand"   "0,0,0,0,0,0")
756                  (match_operand:SI
757                   2 "rx_source_operand"  "r,Sint08,Sint16,Sint24,i,Q")))]
758   ""
759   "divu\t%Q2, %0"
760   [(set_attr "cc" "clobber")
761    (set_attr "timings" "1010") ;; Strictly speaking the timing should be
762                                ;; 2020, but that is a worst case sceanario.
763    (set_attr "length" "3,4,5,6,7,6")]
764 )
765
766 ;; Note - these patterns are suppressed in big-endian mode because they
767 ;; generate a little endian result.  ie the most significant word of the
768 ;; result is placed in the higher numbered register of the destination
769 ;; register pair.
770
771 (define_insn "mulsidi3"
772   [(set (match_operand:DI          0 "register_operand"  "=r,r,r,r,r,r")
773         (mult:DI (sign_extend:DI (match_operand:SI
774                                   1 "register_operand"  "%0,0,0,0,0,0"))
775                  (sign_extend:DI (match_operand:SI
776                                   2 "rx_source_operand"
777                                   "r,Sint08,Sint16,Sint24,i,Q"))))]
778   "! TARGET_BIG_ENDIAN_DATA"
779   "@
780   emul\t%Q2, %0
781   emul\t%Q2, %0
782   emul\t%Q2, %0
783   emul\t%Q2, %0
784   emul\t%Q2, %0
785   emul\t%Q2, %0"
786   [(set_attr "length" "3,4,5,6,7,6")   
787    (set_attr "timings" "22,22,22,22,22,44")]
788 )
789
790 ;; See comment for mulsidi3.
791 ;; Note - the zero_extends are to distinguish this pattern from the
792 ;; mulsidi3 pattern.  Immediate mode addressing is not supported
793 ;; because gcc cannot handle the expression: (zero_extend (const_int)).
794 (define_insn "umulsidi3"
795   [(set (match_operand:DI                          0 "register_operand"
796                                                    "=r,r")
797         (mult:DI (zero_extend:DI (match_operand:SI 1 "register_operand"
798                                                    "%0,0"))
799                  (zero_extend:DI (match_operand:SI 2 "rx_compare_operand"
800                                                    "r,Q"))))]
801   "! TARGET_BIG_ENDIAN_DATA"
802   "@
803   emulu\t%Q2, %0
804   emulu\t%Q2, %0"
805   [(set_attr "length" "3,6")
806    (set_attr "timings" "22,44")]
807 )
808
809 (define_insn "smaxsi3"
810   [(set (match_operand:SI          0 "register_operand" "=r,r,r,r,r,r")
811         (smax:SI (match_operand:SI 1 "register_operand" "%0,0,0,0,0,0")
812                  (match_operand:SI 2 "rx_source_operand"
813                                    "r,Sint08,Sint16,Sint24,i,Q")))]
814   ""
815   "max\t%Q2, %0"
816   [(set_attr "length" "3,4,5,6,7,6")
817    (set_attr "timings" "11,11,11,11,11,33")]
818 )
819
820 (define_insn "sminsi3"
821   [(set (match_operand:SI          0 "register_operand" "=r,r,r,r,r,r,r")
822         (smin:SI (match_operand:SI 1 "register_operand" "%0,0,0,0,0,0,r")
823                  (match_operand:SI 2 "rx_source_operand"
824                                    "r,Sint08,Sint16,Sint24,i,Q,r")))]
825   ""
826   "@
827   min\t%Q2, %0
828   min\t%Q2, %0
829   min\t%Q2, %0
830   min\t%Q2, %0
831   min\t%Q2, %0
832   min\t%Q2, %0
833   mov.l\t%1,%0\n\tmin\t%Q2, %0"
834   [(set_attr "length"  "3,4,5,6,7,6,5")
835    (set_attr "timings" "11,11,11,11,11,33,22")]
836 )
837
838 (define_insn "mulsi3"
839   [(set (match_operand:SI          0 "register_operand" "=r,r,r,r,r,r,r,r,r")
840         (mult:SI (match_operand:SI 1 "register_operand" "%0,0,0,0,0,0,0,Q,r")
841                  (match_operand:SI 2 "rx_source_operand"
842                                    "r,Uint04,Sint08,Sint16,Sint24,i,Q,0,r")))]
843   ""
844   "@
845   mul\t%Q2, %0
846   mul\t%Q2, %0
847   mul\t%Q2, %0
848   mul\t%Q2, %0
849   mul\t%Q2, %0
850   mul\t%Q2, %0
851   mul\t%Q2, %0
852   mul\t%Q1, %0
853   mul\t%Q2, %1, %0"
854   [(set_attr "length"  "2,2,3,4,5,6,5,5,3")
855    (set_attr "timings" "11,11,11,11,11,11,33,33,11")]
856 )
857
858 (define_insn "negsi2"
859   [(set (match_operand:SI         0 "register_operand" "=r,r")
860         (neg:SI (match_operand:SI 1 "register_operand"  "0,r")))]
861   ;; The NEG instruction does not comply with -fwrapv semantics.
862   ;; See gcc.c-torture/execute/pr22493-1.c for an example of this.
863   "! flag_wrapv"
864   "@
865   neg\t%0
866   neg\t%1, %0"
867   [(set_attr "length" "2,3")]
868 )
869
870 (define_insn "one_cmplsi2"
871   [(set (match_operand:SI         0 "register_operand" "=r,r")
872         (not:SI (match_operand:SI 1 "register_operand"  "0,r")))]
873   ""
874   "@
875   not\t%0
876   not\t%1, %0"
877   [(set_attr "cc" "set_zs")
878    (set_attr "length" "2,3")]
879 )
880
881 (define_insn "iorsi3"
882   [(set (match_operand:SI         0 "register_operand" "=r,r,r,r,r,r,r,r,r")
883         (ior:SI (match_operand:SI 1 "register_operand" "%0,0,0,0,0,0,r,0,Q")
884                 (match_operand:SI 2 "rx_source_operand"
885                                   "r,Uint04,Sint08,Sint16,Sint24,i,r,Q,0")))]
886   ""
887   "@
888   or\t%2, %0
889   or\t%2, %0
890   or\t%2, %0
891   or\t%2, %0
892   or\t%2, %0
893   or\t%2, %0
894   or\t%2, %1, %0
895   or\t%Q2, %0
896   or\t%Q1, %0"
897   [(set_attr "cc" "set_zs")
898    (set_attr "timings" "11,11,11,11,11,11,11,33,33")
899    (set_attr "length"  "2,2,3,4,5,6,3,5,5")]
900 )
901
902 (define_insn "rotlsi3"
903   [(set (match_operand:SI            0 "register_operand" "=r")
904         (rotate:SI (match_operand:SI 1 "register_operand"  "0")
905                    (match_operand:SI 2 "rx_shift_operand" "rn")))]
906   ""
907   "rotl\t%2, %0"
908   [(set_attr "cc" "set_zs")
909    (set_attr "length" "3")]
910 )
911
912 (define_insn "rotrsi3"
913   [(set (match_operand:SI              0 "register_operand" "=r")
914         (rotatert:SI (match_operand:SI 1 "register_operand"  "0")
915                      (match_operand:SI 2 "rx_shift_operand" "rn")))]
916   ""
917   "rotr\t%2, %0"
918   [(set_attr "cc" "set_zs")
919    (set_attr "length" "3")]
920 )
921
922 (define_insn "ashrsi3"
923   [(set (match_operand:SI              0 "register_operand" "=r,r,r")
924         (ashiftrt:SI (match_operand:SI 1 "register_operand"  "0,0,r")
925                      (match_operand:SI 2 "rx_shift_operand"  "r,n,n")))]
926   ""
927   "@
928   shar\t%2, %0
929   shar\t%2, %0
930   shar\t%2, %1, %0"
931   [(set_attr "cc" "set_zsoc")
932    (set_attr "length" "3,2,3")]
933 )
934
935 (define_insn "lshrsi3"
936   [(set (match_operand:SI              0 "register_operand" "=r,r,r")
937         (lshiftrt:SI (match_operand:SI 1 "register_operand"  "0,0,r")
938                      (match_operand:SI 2 "rx_shift_operand"  "r,n,n")))]
939   ""
940   "@
941   shlr\t%2, %0
942   shlr\t%2, %0
943   shlr\t%2, %1, %0"
944   [(set_attr "cc" "set_zsoc")
945    (set_attr "length" "3,2,3")]
946 )
947
948 (define_insn "ashlsi3"
949   [(set (match_operand:SI            0 "register_operand" "=r,r,r")
950         (ashift:SI (match_operand:SI 1 "register_operand"  "0,0,r")
951                    (match_operand:SI 2 "rx_shift_operand"  "r,n,n")))]
952   ""
953   "@
954   shll\t%2, %0
955   shll\t%2, %0
956   shll\t%2, %1, %0"
957   [(set_attr "cc" "set_zsoc")
958    (set_attr "length" "3,2,3")]
959 )
960
961 (define_insn "subsi3"
962   [(set (match_operand:SI           0 "register_operand" "=r,r,r,r,r")
963         (minus:SI (match_operand:SI 1 "register_operand"  "0,0,0,r,0")
964                   (match_operand:SI 2 "rx_source_operand" "r,Uint04,n,r,Q")))]
965   ""
966   "@
967   sub\t%2, %0
968   sub\t%2, %0
969   add\t%N2, %0
970   sub\t%2, %1, %0
971   sub\t%Q2, %0"
972   [(set_attr "cc" "set_zsoc")
973    (set_attr "timings" "11,11,11,11,33")
974    (set_attr "length" "2,2,6,3,5")]
975 )
976
977 (define_insn "subdi3"
978   [(set (match_operand:DI           0 "register_operand" "=r,r")
979         (minus:DI (match_operand:DI 1 "register_operand"  "0,0")
980                   (match_operand:DI 2 "rx_source_operand" "r,Q")))]
981   ""
982   "sub\t%L2, %L0\n\tsbb\t%H2, %H0"
983   [(set_attr "cc" "set_zsoc")
984    (set_attr "timings" "22,44")
985    (set_attr "length" "5,11")]
986 )
987
988 (define_insn "xorsi3"
989   [(set (match_operand:SI         0 "register_operand" "=r,r,r,r,r,r")
990         (xor:SI (match_operand:SI 1 "register_operand" "%0,0,0,0,0,0")
991                 (match_operand:SI 2 "rx_source_operand"
992                                   "r,Sint08,Sint16,Sint24,i,Q")))]
993   ""
994   "@
995   xor\t%Q2, %0
996   xor\t%Q2, %0
997   xor\t%Q2, %0
998   xor\t%Q2, %0
999   xor\t%Q2, %0
1000   xor\t%Q2, %0"
1001   [(set_attr "cc" "set_zs")
1002    (set_attr "timings" "11,11,11,11,11,33")
1003    (set_attr "length" "3,4,5,6,7,6")]
1004 )
1005
1006 ;; Floating Point Instructions
1007 ;; These patterns are only enabled with -ffast-math because the RX FPU
1008 ;; cannot handle sub-normal values.
1009
1010 (define_insn "addsf3"
1011   [(set (match_operand:SF          0 "register_operand"  "=r,r,r")
1012         (plus:SF (match_operand:SF 1 "register_operand"  "%0,0,0")
1013                  (match_operand:SF 2 "rx_source_operand"  "r,F,Q")))]
1014   "ALLOW_RX_FPU_INSNS"
1015   "@
1016   fadd\t%2, %0
1017   fadd\t%2, %0
1018   fadd\t%2, %0"
1019   [(set_attr "cc" "set_zs")
1020    (set_attr "timings" "44,44,66")
1021    (set_attr "length" "3,7,5")]
1022 )
1023
1024 (define_insn "divsf3"
1025   [(set (match_operand:SF         0 "register_operand" "=r,r,r")
1026         (div:SF (match_operand:SF 1 "register_operand"  "0,0,0")
1027                 (match_operand:SF 2 "rx_source_operand" "r,F,Q")))]
1028   "ALLOW_RX_FPU_INSNS"
1029   "fdiv\t%2, %0"
1030   [(set_attr "cc" "set_zs")
1031    (set_attr "timings" "1616,1616,1818")
1032    (set_attr "length" "3,7,5")]
1033 )
1034
1035 (define_insn "mulsf3"
1036   [(set (match_operand:SF          0 "register_operand" "=r,r,r")
1037         (mult:SF (match_operand:SF 1 "register_operand" "%0,0,0")
1038                 (match_operand:SF  2 "rx_source_operand" "r,F,Q")))]
1039   "ALLOW_RX_FPU_INSNS"
1040   "@
1041   fmul\t%2, %0
1042   fmul\t%2, %0
1043   fmul\t%2, %0"
1044   [(set_attr "cc" "set_zs")
1045    (set_attr "timings" "33,33,55")
1046    (set_attr "length"  "3,7,5")]
1047 )
1048
1049 (define_insn "subsf3"
1050   [(set (match_operand:SF           0 "register_operand" "=r,r,r")
1051         (minus:SF (match_operand:SF 1 "register_operand"  "0,0,0")
1052                   (match_operand:SF 2 "rx_source_operand" "r,F,Q")))]
1053   "ALLOW_RX_FPU_INSNS"
1054   "fsub\t%2, %0"
1055   [(set_attr "cc" "set_zs")
1056    (set_attr "timings" "44,44,66")
1057    (set_attr "length" "3,7,5")]
1058 )
1059
1060 (define_insn "fix_truncsfsi2"
1061   [(set (match_operand:SI         0 "register_operand"  "=r,r")
1062         (fix:SI (match_operand:SF 1 "rx_compare_operand" "r,Q")))]
1063   "ALLOW_RX_FPU_INSNS"
1064   "ftoi\t%1, %0"
1065   [(set_attr "cc" "set_zs")
1066    (set_attr "timings" "22,44")
1067    (set_attr "length" "3,5")]
1068 )
1069
1070 (define_insn "floatsisf2"
1071   [(set (match_operand:SF           0 "register_operand"  "=r,r")
1072         (float:SF (match_operand:SI 1 "rx_compare_operand" "r,Q")))]
1073   "ALLOW_RX_FPU_INSNS"
1074   "itof\t%1, %0"
1075   [(set_attr "cc" "set_zs")
1076    (set_attr "timings" "22,44")
1077    (set_attr "length" "3,6")]
1078 )
1079 \f
1080 ;; Bit manipulation instructions.
1081 ;; Note - there are two versions of each pattern because the memory
1082 ;; accessing versions use QImode whilst the register accessing
1083 ;; versions use SImode.
1084 ;; The peephole are here because the combiner only looks at a maximum
1085 ;; of three instructions at a time.
1086
1087 (define_insn "bitset"
1088   [(set:SI (match_operand:SI 0 "register_operand" "+r")
1089            (ior:SI (match_operand:SI 1 "register_operand" "0")
1090                    (ashift:SI (const_int 1)
1091                               (match_operand:SI 2 "nonmemory_operand" "ri"))))]
1092   ""
1093   "bset\t%2, %0"
1094   [(set_attr "length" "3")]
1095 )
1096
1097 (define_insn "bitset_in_memory"
1098   [(set:QI (match_operand:QI 0 "memory_operand" "+m")
1099            (ior:QI (match_operand:QI 1 "memory_operand" "0")
1100                    (ashift:QI (const_int 1)
1101                               (match_operand:QI 2 "nonmemory_operand" "ri"))))]
1102   ""
1103   "bset\t%2, %0.B"
1104   [(set_attr "length" "3")
1105    (set_attr "timings" "34")]
1106 )
1107
1108 ;; (set (reg A) (const_int 1))
1109 ;; (set (reg A) (ashift (reg A) (reg B)))
1110 ;; (set (reg C) (ior (reg A) (reg C)))
1111 (define_peephole2
1112   [(set:SI (match_operand:SI 0 "register_operand" "")
1113            (const_int 1))
1114    (set:SI (match_dup 0)
1115            (ashift:SI (match_dup 0)
1116                       (match_operand:SI 1 "register_operand" "")))
1117    (set:SI (match_operand:SI 2 "register_operand" "")
1118            (ior:SI (match_dup 0)
1119                    (match_dup 2)))]
1120   "dead_or_set_p (insn, operands[0])"
1121   [(set:SI (match_dup 2)
1122            (ior:SI (match_dup 2)
1123                    (ashift:SI (const_int 1)
1124                               (match_dup 1))))]
1125 )
1126   
1127 ;; (set (reg A) (const_int 1))
1128 ;; (set (reg A) (ashift (reg A) (reg B)))
1129 ;; (set (reg A) (ior (reg A) (reg C)))
1130 ;; (set (reg C) (reg A)
1131 (define_peephole2
1132   [(set:SI (match_operand:SI 0 "register_operand" "")
1133            (const_int 1))
1134    (set:SI (match_dup 0)
1135            (ashift:SI (match_dup 0)
1136                       (match_operand:SI 1 "register_operand" "")))
1137    (set:SI (match_dup 0)
1138            (ior:SI (match_dup 0)
1139                    (match_operand:SI 2 "register_operand" "")))
1140    (set:SI (match_dup 2) (match_dup 0))]
1141   "dead_or_set_p (insn, operands[0])"
1142   [(set:SI (match_dup 2)
1143            (ior:SI (match_dup 2)
1144                    (ashift:SI (const_int 1)
1145                               (match_dup 1))))]
1146 )
1147   
1148 (define_insn "bitinvert"
1149   [(set:SI (match_operand:SI 0 "register_operand" "+r")
1150            (xor:SI (match_operand:SI 1 "register_operand" "0")
1151                    (ashift:SI (const_int 1)
1152                               (match_operand:SI 2 "nonmemory_operand" "ri"))))]
1153   ""
1154   "bnot\t%2, %0"
1155   [(set_attr "length" "3")]
1156 )
1157
1158 (define_insn "bitinvert_in_memory"
1159   [(set:QI (match_operand:QI 0 "memory_operand" "+m")
1160            (xor:QI (match_operand:QI 1 "register_operand" "0")
1161                    (ashift:QI (const_int 1)
1162                               (match_operand:QI 2 "nonmemory_operand" "ri"))))]
1163   ""
1164   "bnot\t%2, %0.B"
1165   [(set_attr "length" "5")
1166    (set_attr "timings" "33")]
1167 )
1168
1169 ;; (set (reg A) (const_int 1))
1170 ;; (set (reg A) (ashift (reg A) (reg B)))
1171 ;; (set (reg C) (xor (reg A) (reg C)))
1172 (define_peephole2
1173   [(set:SI (match_operand:SI 0 "register_operand" "")
1174            (const_int 1))
1175    (set:SI (match_dup 0)
1176            (ashift:SI (match_dup 0)
1177                       (match_operand:SI 1 "register_operand" "")))
1178    (set:SI (match_operand:SI 2 "register_operand" "")
1179            (xor:SI (match_dup 0)
1180                    (match_dup 2)))]
1181   "dead_or_set_p (insn, operands[0])"
1182   [(set:SI (match_dup 2)
1183            (xor:SI (match_dup 2)
1184                    (ashift:SI (const_int 1)
1185                               (match_dup 1))))]
1186   ""
1187 )
1188   
1189 ;; (set (reg A) (const_int 1))
1190 ;; (set (reg A) (ashift (reg A) (reg B)))
1191 ;; (set (reg A) (xor (reg A) (reg C)))
1192 ;; (set (reg C) (reg A))
1193 (define_peephole2
1194   [(set:SI (match_operand:SI 0 "register_operand" "")
1195            (const_int 1))
1196    (set:SI (match_dup 0)
1197            (ashift:SI (match_dup 0)
1198                       (match_operand:SI 1 "register_operand" "")))
1199    (set:SI (match_dup 0)
1200            (xor:SI (match_dup 0)
1201                    (match_operand:SI 2 "register_operand" "")))
1202    (set:SI (match_dup 2) (match_dup 0))]
1203   "dead_or_set_p (insn, operands[0])"
1204   [(set:SI (match_dup 2)
1205            (xor:SI (match_dup 2)
1206                    (ashift:SI (const_int 1)
1207                               (match_dup 1))))]
1208   ""
1209 )
1210
1211 (define_insn "bitclr"
1212   [(set:SI (match_operand:SI 0 "register_operand" "+r")
1213            (and:SI (match_operand:SI 1 "register_operand" "0")
1214                    (not:SI (ashift:SI (const_int 1)
1215                                       (match_operand:SI 2 "nonmemory_operand" "ri")))))]
1216   ""
1217   "bclr\t%2, %0"
1218   [(set_attr "length" "3")]
1219 )
1220
1221 (define_insn "bitclr_in_memory"
1222   [(set:QI (match_operand:QI 0 "memory_operand" "+m")
1223            (and:QI (match_operand:QI 1 "memory_operand" "0")
1224                    (not:QI (ashift:QI (const_int 1)
1225                                       (match_operand:QI 2 "nonmemory_operand" "ri")))))]
1226   ""
1227   "bclr\t%2, %0.B"
1228   [(set_attr "length" "3")
1229    (set_attr "timings" "34")]
1230 )
1231
1232 ;; (set (reg A) (const_int -2))
1233 ;; (set (reg A) (rotate (reg A) (reg B)))
1234 ;; (set (reg C) (and (reg A) (reg C)))
1235 (define_peephole2
1236   [(set:SI (match_operand:SI 0 "register_operand" "")
1237            (const_int -2))
1238    (set:SI (match_dup 0)
1239            (rotate:SI (match_dup 0)
1240                       (match_operand:SI 1 "register_operand" "")))
1241    (set:SI (match_operand:SI 2 "register_operand" "")
1242            (and:SI (match_dup 0)
1243                    (match_dup 2)))]
1244   "dead_or_set_p (insn, operands[0])"
1245   [(set:SI (match_dup 2)
1246            (and:SI (match_dup 2)
1247                    (not:SI (ashift:SI (const_int 1)
1248                                       (match_dup 1)))))]
1249 )
1250   
1251 ;; (set (reg A) (const_int -2))
1252 ;; (set (reg A) (rotate (reg A) (reg B)))
1253 ;; (set (reg A) (and (reg A) (reg C)))
1254 ;; (set (reg C) (reg A)
1255 (define_peephole2
1256   [(set:SI (match_operand:SI 0 "register_operand" "")
1257            (const_int -2))
1258    (set:SI (match_dup 0)
1259            (rotate:SI (match_dup 0)
1260                       (match_operand:SI 1 "register_operand" "")))
1261    (set:SI (match_dup 0)
1262            (and:SI (match_dup 0)
1263                    (match_operand:SI 2 "register_operand" "")))
1264    (set:SI (match_dup 2) (match_dup 0))]
1265   "dead_or_set_p (insn, operands[0])"
1266   [(set:SI (match_dup 2)
1267            (and:SI (match_dup 2)
1268                    (not:SI (ashift:SI (const_int 1)
1269                                       (match_dup 1)))))]
1270 )
1271
1272 (define_expand "insv"
1273   [(set:SI (zero_extract:SI (match_operand:SI
1274                              0 "nonimmediate_operand") ;; Destination
1275                             (match_operand
1276                              1 "immediate_operand")    ;; # of bits to set
1277                             (match_operand
1278                              2 "immediate_operand"))   ;; Starting bit
1279            (match_operand
1280             3 "immediate_operand"))]  ;; Bits to insert
1281   ""
1282   {
1283     if (rx_expand_insv (operands))
1284       DONE;
1285     FAIL;
1286   }
1287 )   
1288 \f
1289 ;; Atomic exchange operation.
1290
1291 (define_insn "sync_lock_test_and_setsi"
1292   [(set:SI (match_operand:SI 0 "register_operand"   "=r,r")
1293            (match_operand:SI 1 "rx_compare_operand" "=r,Q"))
1294    (set:SI (match_dup 1)
1295            (match_operand:SI 2 "register_operand"    "0,0"))]
1296   ""
1297   "xchg\t%1, %0"
1298   [(set_attr "length" "3,6")
1299    (set_attr "timings" "22")]
1300 )
1301
1302 \f
1303 ;; Block move functions.
1304
1305 (define_expand "movstr"
1306   [(set:SI (match_operand:BLK 1 "memory_operand")    ;; Dest
1307            (match_operand:BLK 2 "memory_operand"))   ;; Source
1308    (use (match_operand:SI     0 "register_operand")) ;; Updated Dest
1309   ]
1310   ""
1311   {
1312     rtx addr1 = gen_rtx_REG (SImode, 1);
1313     rtx addr2 = gen_rtx_REG (SImode, 2);
1314     rtx len   = gen_rtx_REG (SImode, 3);
1315     rtx dest_copy = gen_reg_rtx (SImode);
1316
1317     emit_move_insn (len, GEN_INT (-1));
1318     emit_move_insn (addr1, force_operand (XEXP (operands[1], 0), NULL_RTX));
1319     emit_move_insn (addr2, force_operand (XEXP (operands[2], 0), NULL_RTX));
1320     operands[1] = replace_equiv_address_nv (operands[1], addr1);
1321     operands[2] = replace_equiv_address_nv (operands[2], addr2);
1322     emit_move_insn (dest_copy, addr1);
1323     emit_insn (gen_rx_movstr ());
1324     emit_move_insn (len, GEN_INT (-1));
1325     emit_insn (gen_rx_strend (operands[0], dest_copy));
1326     DONE;
1327   }
1328 )
1329
1330 (define_insn "rx_movstr"
1331   [(set:SI (mem:BLK (reg:SI 1))
1332            (mem:BLK (reg:SI 2)))
1333    (unspec_volatile:BLK [(reg:SI 1) (reg:SI 2) (reg:SI 3)] UNSPEC_MOVSTR)
1334    (clobber (reg:SI 1))
1335    (clobber (reg:SI 2))
1336    (clobber (reg:SI 3))
1337   ]
1338   ""
1339   "smovu"
1340   [(set_attr "length" "2")
1341    (set_attr "timings" "1111")] ;; The timing is a guesstimate.
1342 )
1343
1344 (define_insn "rx_strend"
1345   [(set:SI (match_operand:SI                      0 "register_operand" "=r")
1346            (unspec_volatile:SI [(match_operand:SI 1 "register_operand"  "r")
1347                                 (reg:SI 3)] UNSPEC_STRLEN))
1348    (clobber (reg:SI 1))
1349    (clobber (reg:SI 2))
1350    (clobber (reg:SI 3))
1351   ]
1352   ""
1353   "mov\t%1, r1\n\tmov\t#0, r2\n\tsuntil.b\n\tmov\tr1, %0\n\tsub\t#1, %0"
1354   [(set_attr "length" "10")
1355    (set_attr "cc" "clobber")
1356    (set_attr "timings" "1111")] ;; The timing is a guesstimate.
1357 )
1358
1359 (define_expand "movmemsi"
1360   [(parallel
1361     [(set (match_operand:BLK 0 "memory_operand")    ;; Dest
1362           (match_operand:BLK 1 "memory_operand"))   ;; Source
1363      (use (match_operand:SI  2 "register_operand")) ;; Length in bytes
1364      (match_operand          3 "immediate_operand") ;; Align
1365      (unspec_volatile:BLK [(reg:SI 1) (reg:SI 2) (reg:SI 3)] UNSPEC_MOVMEM)]
1366     )]
1367   ""
1368   {
1369     rtx addr1 = gen_rtx_REG (SImode, 1);
1370     rtx addr2 = gen_rtx_REG (SImode, 2);
1371     rtx len   = gen_rtx_REG (SImode, 3);
1372
1373     if (REG_P (operands[0]) && (REGNO (operands[0]) == 2
1374                                       || REGNO (operands[0]) == 3))
1375       FAIL;
1376     if (REG_P (operands[1]) && (REGNO (operands[1]) == 1
1377                                       || REGNO (operands[1]) == 3))
1378       FAIL;
1379     if (REG_P (operands[2]) && (REGNO (operands[2]) == 1
1380                                       || REGNO (operands[2]) == 2))
1381       FAIL;
1382     emit_move_insn (addr1, force_operand (XEXP (operands[0], 0), NULL_RTX));
1383     emit_move_insn (addr2, force_operand (XEXP (operands[1], 0), NULL_RTX));
1384     emit_move_insn (len, force_operand (operands[2], NULL_RTX));
1385     operands[0] = replace_equiv_address_nv (operands[0], addr1);
1386     operands[1] = replace_equiv_address_nv (operands[1], addr2);
1387     emit_insn (gen_rx_movmem ());
1388     DONE;
1389   }
1390 )
1391
1392 (define_insn "rx_movmem"
1393   [(set (mem:BLK (reg:SI 1))
1394         (mem:BLK (reg:SI 2)))
1395    (use (reg:SI 3))
1396    (unspec_volatile:BLK [(reg:SI 1) (reg:SI 2) (reg:SI 3)] UNSPEC_MOVMEM)
1397    (clobber (reg:SI 1))
1398    (clobber (reg:SI 2))
1399    (clobber (reg:SI 3))]
1400   ""
1401   "smovf"
1402   [(set_attr "length" "2")
1403    (set_attr "timings" "1111")] ;; The timing is a guesstimate.
1404 )
1405
1406 (define_expand "setmemsi"
1407   [(set (match_operand:BLK 0 "memory_operand")     ;; Dest
1408         (match_operand:QI  2 "nonmemory_operand")) ;; Value
1409    (use (match_operand:SI  1 "nonmemory_operand")) ;; Length
1410    (match_operand          3 "immediate_operand")  ;; Align
1411    (unspec_volatile:BLK [(reg:SI 1) (reg:SI 2) (reg:SI 3)] UNSPEC_SETMEM)]
1412   ""
1413   {
1414     rtx addr = gen_rtx_REG (SImode, 1);
1415     rtx val  = gen_rtx_REG (QImode, 2);
1416     rtx len  = gen_rtx_REG (SImode, 3);
1417
1418     emit_move_insn (addr, force_operand (XEXP (operands[0], 0), NULL_RTX));
1419     emit_move_insn (len, force_operand (operands[1], NULL_RTX));
1420     emit_move_insn (val, operands[2]);
1421     emit_insn (gen_rx_setmem ());
1422     DONE;
1423   }
1424 )
1425
1426 (define_insn "rx_setmem"
1427   [(set:BLK (mem:BLK (reg:SI 1)) (reg 2))
1428    (unspec_volatile:BLK [(reg:SI 1) (reg:SI 2) (reg:SI 3)] UNSPEC_SETMEM)
1429    (clobber (reg:SI 1))
1430    (clobber (reg:SI 3))]
1431   ""
1432   "sstr.b"
1433   [(set_attr "length" "2")
1434    (set_attr "timings" "1111")] ;; The timing is a guesstimate.
1435 )
1436
1437 (define_expand "cmpstrnsi"
1438   [(set (match_operand:SI
1439          0 "register_operand") ;; Result
1440         (unspec_volatile:SI [(match_operand:BLK
1441                               1 "memory_operand") ;; String1
1442                              (match_operand:BLK
1443                               2 "memory_operand")] ;; String2
1444                             UNSPEC_CMPSTRN))
1445    (use (match_operand:SI
1446          3 "register_operand")) ;; Max Length
1447    (match_operand:SI
1448     4 "immediate_operand")] ;; Known Align
1449   ""
1450   {
1451     rtx str1 = gen_rtx_REG (SImode, 1);
1452     rtx str2 = gen_rtx_REG (SImode, 2);
1453     rtx len  = gen_rtx_REG (SImode, 3);
1454   
1455     emit_move_insn (str1, force_operand (XEXP (operands[1], 0), NULL_RTX));
1456     emit_move_insn (str2, force_operand (XEXP (operands[2], 0), NULL_RTX));
1457     emit_move_insn (len, force_operand (operands[3], NULL_RTX));
1458
1459     emit_insn (gen_rx_cmpstrn (operands[0], operands[1], operands[2]));
1460     DONE;
1461   }
1462 )
1463
1464 (define_expand "cmpstrsi"
1465   [(set (match_operand:SI
1466          0 "register_operand") ;; Result
1467         (unspec_volatile:SI [(match_operand:BLK
1468                               1 "memory_operand")  ;; String1
1469                              (match_operand:BLK
1470                               2 "memory_operand")] ;; String2
1471                             UNSPEC_CMPSTRN))
1472    (match_operand:SI
1473     3 "immediate_operand")] ;; Known Align
1474   ""
1475   {
1476     rtx str1 = gen_rtx_REG (SImode, 1);
1477     rtx str2 = gen_rtx_REG (SImode, 2);
1478     rtx len  = gen_rtx_REG (SImode, 3);
1479   
1480     emit_move_insn (str1, force_reg (SImode, XEXP (operands[1], 0)));
1481     emit_move_insn (str2, force_reg (SImode, XEXP (operands[2], 0)));
1482     emit_move_insn (len, GEN_INT (-1));
1483
1484     emit_insn (gen_rx_cmpstrn (operands[0], operands[1], operands[2]));
1485     DONE;
1486   }
1487 )
1488
1489 (define_insn "rx_cmpstrn"
1490   [(set:SI (match_operand:SI 0 "register_operand" "=r")
1491            (unspec_volatile:SI [(reg:SI 1) (reg:SI 2) (reg:SI 3)]
1492                                UNSPEC_CMPSTRN))
1493    (use (match_operand:BLK   1 "memory_operand" "m"))
1494    (use (match_operand:BLK   2 "memory_operand" "m"))
1495    (clobber (reg:SI 1))
1496    (clobber (reg:SI 2))
1497    (clobber (reg:SI 3))]
1498   ""
1499   "scmpu                ; Perform the string comparison
1500    mov     #-1, %0      ; Set up -1 result (which cannot be created
1501                         ; by the SC insn)
1502    bnc     ?+           ; If Carry is not set skip over
1503    scne.L  %0           ; Set result based on Z flag
1504 ?:                      
1505 "
1506   [(set_attr "length" "9")
1507    (set_attr "timings" "1111")] ;; The timing is a guesstimate.
1508 )
1509 \f
1510 ;;   Builtin Functions
1511 ;;
1512 ;; GCC does not have the ability to generate the following instructions
1513 ;; on its own so they are provided as builtins instead.  To use them from
1514 ;; a program for example invoke them as __builtin_rx_<insn_name>.  For
1515 ;; example:
1516 ;;
1517 ;;    int short_byte_swap (int arg) { return __builtin_rx_revw (arg); }
1518
1519 ;;---------- Accumulator Support ------------------------
1520
1521 ;; Multiply & Accumulate (high)
1522 (define_insn "machi"
1523   [(unspec:SI [(match_operand:SI 0 "register_operand" "r")
1524                (match_operand:SI 1 "register_operand" "r")]
1525               UNSPEC_BUILTIN_MACHI)]
1526   ""
1527   "machi\t%0, %1"
1528   [(set_attr "length" "3")]
1529 )
1530
1531 ;; Multiply & Accumulate (low)
1532 (define_insn "maclo"
1533   [(unspec:SI [(match_operand:SI 0 "register_operand" "r")
1534                (match_operand:SI 1 "register_operand" "r")]
1535               UNSPEC_BUILTIN_MACLO)]
1536   ""
1537   "maclo\t%0, %1"
1538   [(set_attr "length" "3")]
1539 )
1540
1541 ;; Multiply (high)
1542 (define_insn "mulhi"
1543   [(unspec:SI [(match_operand:SI 0 "register_operand" "r")
1544                (match_operand:SI 1 "register_operand" "r")]
1545               UNSPEC_BUILTIN_MULHI)]
1546   ""
1547   "mulhi\t%0, %1"
1548   [(set_attr "length" "3")]
1549 )
1550
1551 ;; Multiply (low)
1552 (define_insn "mullo"
1553   [(unspec:SI [(match_operand:SI 0 "register_operand" "r")
1554                (match_operand:SI 1 "register_operand" "r")]
1555               UNSPEC_BUILTIN_MULLO)]
1556   ""
1557   "mullo\t%0, %1"
1558   [(set_attr "length" "3")]
1559 )
1560
1561 ;; Move from Accumulator (high)
1562 (define_insn "mvfachi"
1563   [(set (match_operand:SI 0 "register_operand" "=r")
1564         (unspec:SI [(const_int 0)]
1565                    UNSPEC_BUILTIN_MVFACHI))]
1566   ""
1567   "mvfachi\t%0"
1568   [(set_attr "length" "3")]
1569 )
1570
1571 ;; Move from Accumulator (middle)
1572 (define_insn "mvfacmi"
1573   [(set (match_operand:SI 0 "register_operand" "=r")
1574         (unspec:SI [(const_int 0)]
1575                    UNSPEC_BUILTIN_MVFACMI))]
1576   ""
1577   "mvfacmi\t%0"
1578   [(set_attr "length" "3")]
1579 )
1580
1581 ;; Move to Accumulator (high)
1582 (define_insn "mvtachi"
1583   [(unspec:SI [(match_operand:SI 0 "register_operand" "r")]
1584               UNSPEC_BUILTIN_MVTACHI)]
1585   ""
1586   "mvtachi\t%0"
1587   [(set_attr "length" "3")]
1588 )
1589
1590 ;; Move to Accumulator (low)
1591 (define_insn "mvtaclo"
1592   [(unspec:SI [(match_operand:SI 0 "register_operand" "r")]
1593               UNSPEC_BUILTIN_MVTACLO)]
1594   ""
1595   "mvtaclo\t%0"
1596   [(set_attr "length" "3")]
1597 )
1598
1599 ;; Round Accumulator
1600 (define_insn "racw"
1601   [(unspec:SI [(match_operand:SI 0 "immediate_operand" "i")]
1602               UNSPEC_BUILTIN_RACW)]
1603   ""
1604   "racw\t%0"
1605   [(set_attr "length" "3")]
1606 )
1607
1608 ;; Repeat multiply and accumulate
1609 (define_insn "rmpa"
1610   [(unspec:SI [(const_int 0) (reg:SI 1) (reg:SI 2) (reg:SI 3)
1611                (reg:SI 4) (reg:SI 5) (reg:SI 6)]
1612               UNSPEC_BUILTIN_RMPA)
1613   (clobber (reg:SI 1))
1614   (clobber (reg:SI 2))
1615   (clobber (reg:SI 3))]
1616   ""
1617   "rmpa"
1618   [(set_attr "length" "2")
1619    (set_attr "timings" "1010")]
1620 )
1621
1622 ;;---------- Arithmetic ------------------------
1623
1624 ;; Byte swap (two 16-bit values).
1625 (define_insn "revw"
1626   [(set (match_operand:SI             0 "register_operand" "+r")
1627         (unspec:SI [(match_operand:SI 1 "register_operand"  "r")]
1628                    UNSPEC_BUILTIN_REVW))]
1629   ""
1630   "revw\t%1, %0"
1631   [(set_attr "length" "3")]
1632 )
1633
1634 ;; Round to integer.
1635 (define_insn "lrintsf2"
1636   [(set (match_operand:SI             0 "register_operand"  "=r,r")
1637         (unspec:SI [(match_operand:SF 1 "rx_compare_operand" "r,Q")]
1638                    UNSPEC_BUILTIN_ROUND))]
1639   ""
1640   "round\t%1, %0"
1641   [(set_attr "cc" "set_zs")
1642    (set_attr "timings" "22,44")   
1643    (set_attr "length" "3,5")]
1644 )
1645
1646 ;; Saturate to 32-bits
1647 (define_insn "sat"
1648   [(set (match_operand:SI             0 "register_operand" "=r")
1649         (unspec:SI [(match_operand:SI 1 "register_operand"  "0")]
1650                    UNSPEC_BUILTIN_SAT))]
1651   ""
1652   "sat\t%0"
1653   [(set_attr "length" "2")]
1654 )
1655
1656 ;;---------- Control Registers ------------------------
1657
1658 ;; Clear Processor Status Word
1659 (define_insn "clrpsw"
1660   [(unspec:SI [(match_operand:SI 0 "immediate_operand" "i")]
1661               UNSPEC_BUILTIN_CLRPSW)
1662    (clobber (cc0))]
1663   ""
1664   "clrpsw\t%F0"
1665   [(set_attr "length" "2")
1666    (set_attr "cc" "clobber")]
1667 )
1668
1669 ;; Set Processor Status Word
1670 (define_insn "setpsw"
1671   [(unspec:SI [(match_operand:SI 0 "immediate_operand" "i")]
1672               UNSPEC_BUILTIN_SETPSW)
1673    (clobber (cc0))]
1674   ""
1675   "setpsw\t%F0"
1676   [(set_attr "length" "2")
1677    (set_attr "cc" "clobber")]
1678 )
1679
1680 ;; Move from control register
1681 (define_insn "mvfc"
1682   [(set (match_operand:SI                      0 "register_operand" "=r")
1683         (unspec:SI [(match_operand:SI 1 "immediate_operand" "i")]
1684                    UNSPEC_BUILTIN_MVFC))]
1685   ""
1686   "mvfc\t%C1, %0"
1687   [(set_attr "length" "3")]
1688 )
1689
1690 ;; Move to control register
1691 (define_insn "mvtc"
1692   [(unspec:SI [(match_operand:SI 0 "immediate_operand" "i,i")
1693                (match_operand:SI 1 "nonmemory_operand" "r,i")]
1694               UNSPEC_BUILTIN_MVTC)
1695    (clobber (cc0))]
1696   ""
1697   "mvtc\t%1, %C0"
1698   [(set_attr "length" "3,7")
1699    (set_attr "cc" "clobber")]  ;; Just in case the control
1700                                ;; register selected is the psw.
1701 )
1702
1703 ;;---------- Interrupts ------------------------
1704
1705 ;; Break
1706 (define_insn "brk"
1707   [(unspec_volatile [(const_int 0)]
1708                     UNSPEC_BUILTIN_BRK)]
1709   ""
1710   "brk"
1711   [(set_attr "length" "1")
1712    (set_attr "timings" "66")]
1713 )
1714
1715 ;; Interrupt
1716 (define_insn "int"
1717   [(unspec_volatile:SI [(match_operand:SI 0 "immediate_operand" "i")]
1718                        UNSPEC_BUILTIN_INT)]
1719   ""
1720   "int\t%0"
1721   [(set_attr "length" "3")]
1722 )
1723
1724 ;; Wait
1725 (define_insn "wait"
1726   [(unspec_volatile [(const_int 0)]
1727                     UNSPEC_BUILTIN_WAIT)]
1728   ""
1729   "wait"
1730   [(set_attr "length" "2")]
1731 )
1732
1733 ;;---------- CoProcessor Support ------------------------
1734
1735 ;; FIXME: The instructions are currently commented out because
1736 ;; the bit patterns have not been finalized, so the assembler
1737 ;; does not support them.  Once they are decided and the assembler
1738 ;; supports them, enable the instructions here.
1739
1740 ;; Move from co-processor register
1741 (define_insn "mvfcp"
1742   [(set (match_operand:SI             0 "register_operand" "=r")
1743         (unspec:SI [(match_operand:SI 1 "immediate_operand" "i")
1744                     (match_operand:SI 2 "immediate_operand" "i")]
1745                    UNSPEC_BUILTIN_MVFCP))]
1746   ""
1747   "; mvfcp\t%1, %0, %2"
1748   [(set_attr "length" "5")]
1749 )
1750
1751 ;; Move to co-processor register
1752 (define_insn "mvtcp"
1753   [(unspec:SI [(match_operand:SI 0 "immediate_operand" "i,i")
1754                (match_operand:SI 1 "nonmemory_operand" "i,r")
1755                (match_operand:SI 2 "immediate_operand" "i,i")]
1756               UNSPEC_BUILTIN_MVTCP)]
1757   ""
1758   "; mvtcp\t%0, %1, %2"
1759   [(set_attr "length" "7,5")]
1760 )
1761
1762 ;; Co-processor operation
1763 (define_insn "opecp"
1764   [(unspec:SI [(match_operand:SI 0 "immediate_operand" "i")
1765                (match_operand:SI 1 "immediate_operand" "i")]
1766               UNSPEC_BUILTIN_OPEPC)]
1767   ""
1768   "; opecp\t%0, %1"
1769   [(set_attr "length" "5")]
1770 )
1771
1772 ;;---------- Misc ------------------------
1773
1774 ;; Required by cfglayout.c...
1775 (define_insn "nop"
1776   [(const_int 0)]
1777   ""
1778   "nop"
1779   [(set_attr "length" "1")]
1780 )