OSDN Git Service

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