OSDN Git Service

c68cb8a0e5aa8a85a0abfe1b72aefc936a39cebf
[pf3gnuchains/gcc-fork.git] / gcc / config / cris / cris.md
1 ;; GCC machine description for CRIS cpu cores.
2 ;; Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 ;; Free Software Foundation, Inc.
4 ;; Contributed by Axis Communications.
5
6 ;; This file is part of GCC.
7 ;;
8 ;; GCC is free software; you can redistribute it and/or modify
9 ;; it under the terms of the GNU General Public License as published by
10 ;; the Free Software Foundation; either version 2, or (at your option)
11 ;; any later version.
12 ;;
13 ;; GCC is distributed in the hope that it will be useful,
14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 ;; GNU General Public License for more details.
17 ;;
18 ;; You should have received a copy of the GNU General Public License
19 ;; along with GCC; see the file COPYING.  If not, write to
20 ;; the Free Software Foundation, 59 Temple Place - Suite 330,
21 ;; Boston, MA 02111-1307, USA.
22
23 ;; The original PO technology requires these to be ordered by speed,
24 ;; so that assigner will pick the fastest.
25
26 ;; See files "md.texi" and "rtl.def" for documentation on define_insn,
27 ;; match_*, et. al.
28 ;;
29 ;; The function cris_notice_update_cc in cris.c handles condition code
30 ;; updates for most instructions, helped by the "cc" attribute.
31
32 ;; There are several instructions that are orthogonal in size, and seems
33 ;; they could be matched by a single pattern without a specified size
34 ;; for the operand that is orthogonal.  However, this did not work on
35 ;; gcc-2.7.2 (and probably not on gcc-2.8.1), relating to that when a
36 ;; constant is substituted into an operand, the actual mode must be
37 ;; deduced from the pattern.  There is reasonable hope that that has been
38 ;; fixed, so FIXME: try again.
39
40 ;; You will notice that three-operand alternatives ("=r", "r", "!To")
41 ;; are marked with a "!" constraint modifier to avoid being reloaded
42 ;; into.  This is because gcc would otherwise prefer to use the constant
43 ;; pool and its offsettable address instead of reloading to an
44 ;; ("=r", "0", "i") alternative.  Also, the constant-pool support was not
45 ;; only suboptimal but also buggy in 2.7.2, ??? maybe only in 2.6.3.
46
47 ;; All insns that look like (set (...) (plus (...) (reg:SI 8)))
48 ;; get problems when reloading r8 (frame pointer) to r14 + offs (stack
49 ;; pointer).  Thus the instructions that get into trouble have specific
50 ;; checks against matching frame_pointer_rtx.
51 ;; ??? But it should be re-checked for gcc > 2.7.2
52 ;; FIXME: This changed some time ago (from 2000-03-16) for gcc-2.9x.
53
54 ;; FIXME: When PIC, all [rX=rY+S] could be enabled to match
55 ;; [rX=gotless_symbol].
56 ;; The movsi for a gotless symbol could be split (post reload).
57 \f
58 ;; UNSPEC Usage:
59 ;; 0 PLT reference from call expansion: operand 0 is the address,
60 ;;   the mode is VOIDmode.  Always wrapped in CONST.
61 ;; 1 Stack frame deallocation barrier.
62 ;; 2 The address of the global offset table as a source operand.
63
64 (define_constants
65   [(CRIS_UNSPEC_PLT 0)
66    (CRIS_UNSPEC_FRAME_DEALLOC 1)
67    (CRIS_UNSPEC_GOT 2)])
68
69 ;; Register numbers.
70 (define_constants
71   [(CRIS_GOT_REGNUM 0)
72    (CRIS_STATIC_CHAIN_REGNUM 7)
73    (CRIS_FP_REGNUM 8)
74    (CRIS_SP_REGNUM 14)
75    (CRIS_SRP_REGNUM 16)
76    (CRIS_AP_REGNUM 17)
77    (CRIS_MOF_REGNUM 18)]
78 )
79
80 ;; We need an attribute to define whether an instruction can be put in
81 ;; a branch-delay slot or not, and whether it has a delay slot.
82 ;;
83 ;; Branches and return instructions have a delay slot, and cannot
84 ;; themselves be put in a delay slot.  This has changed *for short
85 ;; branches only* between architecture variants, but the possible win
86 ;; is presumed negligible compared to the added complexity of the machine
87 ;; description: one would have to add always-correct infrastructure to
88 ;; distinguish short branches.
89 ;;
90 ;; Whether an instruction can be put in a delay slot depends on the
91 ;; instruction (all short instructions except jumps and branches)
92 ;; and the addressing mode (must not be prefixed or referring to pc).
93 ;; In short, any "slottable" instruction must be 16 bit and not refer
94 ;; to pc, or alter it.
95 ;;
96 ;; The possible values are "yes", "no" and "has_slot".  Yes/no means if
97 ;; the insn is slottable or not.  Has_slot means that the insn is a
98 ;; return insn or branch insn (which are not considered slottable since
99 ;; that is generally true).  Having the seemingly illogical value
100 ;; "has_slot" means we do not have to add another attribute just to say
101 ;; that an insn has a delay-slot, since it also infers that it is not
102 ;; slottable.  Better names for the attribute were found to be longer and
103 ;; not add readability to the machine description.
104 ;;
105 ;; The default that is defined here for this attribute is "no", not
106 ;; slottable, not having a delay-slot, so there's no need to worry about
107 ;; it being wrong for non-branch and return instructions.
108 ;;  The default could depend on the kind of insn and the addressing
109 ;; mode, but that would need more attributes and hairier, more error
110 ;; prone code.
111 ;;
112 ;;  There is an extra memory constraint, 'Q', which recognizes an indirect
113 ;; register.  The constraints 'Q' and '>' together match all possible
114 ;; memory operands that are slottable.
115 ;;  For other operands, you need to check if it has a valid "slottable"
116 ;; quick-immediate operand, where the particular signedness-variation
117 ;; may match the constraints 'I' or 'J'.), and include it in the
118 ;; constraint pattern for the slottable pattern.  An alternative using
119 ;; only "r" constraints is most often slottable.
120
121 (define_attr "slottable" "no,yes,has_slot" (const_string "no"))
122
123 ;; We also need attributes to sanely determine the condition code
124 ;; state.  See cris_notice_update_cc for how this is used.
125
126 (define_attr "cc" "none,clobber,normal" (const_string "normal"))
127
128 ;; At the moment, this attribute is just used to help bb-reorder do its
129 ;; work; the default 0 doesn't help it.  Many insns have other lengths,
130 ;; though none are shorter.
131 (define_attr "length" "" (const_int 2))
132
133 ;; A branch or return has one delay-slot.  The instruction in the
134 ;; delay-slot is always executed, independent of whether the branch is
135 ;; taken or not.  Note that besides setting "slottable" to "has_slot",
136 ;; there also has to be a "%#" at the end of a "delayed" instruction
137 ;; output pattern (for "jump" this means "ba %l0%#"), so print_operand can
138 ;; catch it and print a "nop" if necessary.  This method was stolen from
139 ;; sparc.md.
140
141 (define_delay (eq_attr "slottable" "has_slot")
142   [(eq_attr "slottable" "yes") (nil) (nil)])
143 \f
144 ;; Operand and operator predicates.
145
146 (include "predicates.md")
147 \f
148 ;; Test insns.
149
150 ;; DImode
151 ;;
152 ;; Allow register and offsettable mem operands only; post-increment is
153 ;; not worth the trouble.
154
155 (define_insn "tstdi"
156   [(set (cc0)
157         (match_operand:DI 0 "nonimmediate_operand" "r,o"))]
158   ""
159   "test.d %M0\;ax\;test.d %H0")
160
161 ;; No test insns with side-effect on the mem addressing.
162 ;;
163 ;; See note on cmp-insns with side-effects (or lack of them)
164
165 ;; Normal named test patterns from SI on.
166 ;; FIXME: Seems they should change to be in order smallest..largest.
167
168 (define_insn "tstsi"
169   [(set (cc0)
170         (match_operand:SI 0 "nonimmediate_operand" "r,Q>,m"))]
171   ""
172   "test.d %0"
173   [(set_attr "slottable" "yes,yes,no")])
174
175 (define_insn "tsthi"
176   [(set (cc0)
177         (match_operand:HI 0 "nonimmediate_operand" "r,Q>,m"))]
178   ""
179   "test.w %0"
180   [(set_attr "slottable" "yes,yes,no")])
181
182 (define_insn "tstqi"
183   [(set (cc0)
184         (match_operand:QI 0 "nonimmediate_operand" "r,Q>,m"))]
185   ""
186   "test.b %0"
187   [(set_attr "slottable" "yes,yes,no")])
188
189 ;; It seems that the position of the sign-bit and the fact that 0.0 is
190 ;; all 0-bits would make "tstsf" a straight-forward implementation;
191 ;; either "test.d" it for positive/negative or "btstq 30,r" it for
192 ;; zeroness.
193 ;;
194 ;; FIXME: Do that some time; check next_cc0_user to determine if
195 ;; zero or negative is tested for.
196 \f
197 ;; Compare insns.
198
199 ;; We could optimize the sizes of the immediate operands for various
200 ;; cases, but that is not worth it because of the very little usage of
201 ;; DImode for anything else but a structure/block-mode.  Just do the
202 ;; obvious stuff for the straight-forward constraint letters.
203
204 (define_insn "cmpdi"
205   [(set (cc0)
206         (compare (match_operand:DI 0 "nonimmediate_operand" "r,r,r,r,r,r,o")
207                  (match_operand:DI 1 "general_operand" "K,I,P,n,r,o,r")))]
208   ""
209   "@
210    cmpq %1,%M0\;ax\;cmpq 0,%H0
211    cmpq %1,%M0\;ax\;cmpq -1,%H0
212    cmp%e1.%z1 %1,%M0\;ax\;cmpq %H1,%H0
213    cmp.d %M1,%M0\;ax\;cmp.d %H1,%H0
214    cmp.d %M1,%M0\;ax\;cmp.d %H1,%H0
215    cmp.d %M1,%M0\;ax\;cmp.d %H1,%H0
216    cmp.d %M0,%M1\;ax\;cmp.d %H0,%H1")
217
218 ;; Note that compare insns with side effect addressing mode (e.g.):
219 ;;
220 ;; cmp.S [rx=ry+i],rz;
221 ;; cmp.S [%3=%1+%2],%0
222 ;;
223 ;; are *not* usable for gcc since the reloader *does not accept*
224 ;; cc0-changing insns with side-effects other than setting the condition
225 ;; codes.  The reason is that the reload stage *may* cause another insn to
226 ;; be output after the main instruction, in turn invalidating cc0 for the
227 ;; insn using the test.  (This does not apply to the CRIS case, since a
228 ;; reload for output -- move to memory -- does not change the condition
229 ;; code.  Unfortunately we have no way to describe that at the moment.  I
230 ;; think code would improve being in the order of one percent faster.
231 \f
232 ;; We have cmps and cmpu (compare reg w. sign/zero extended mem).
233 ;; These are mostly useful for compares in SImode, using 8 or 16-bit
234 ;; constants, but sometimes gcc will find its way to use it for other
235 ;; (memory) operands.  Avoid side-effect patterns, though (see above).
236 ;;
237 ;; FIXME: These could have an anonymous mode for operand 1.
238
239 ;; QImode
240
241 (define_insn "*cmp_extsi"
242   [(set (cc0)
243         (compare
244          (match_operand:SI 0 "register_operand" "r,r")
245          (match_operator:SI 2 "cris_extend_operator"
246                          [(match_operand:QI 1 "memory_operand" "Q>,m")])))]
247   ""
248   "cmp%e2.%s1 %1,%0"
249   [(set_attr "slottable" "yes,no")])
250
251 ;; HImode
252 (define_insn "*cmp_exthi"
253   [(set (cc0)
254         (compare
255          (match_operand:SI 0 "register_operand" "r,r")
256          (match_operator:SI 2 "cris_extend_operator"
257                          [(match_operand:HI 1 "memory_operand" "Q>,m")])))]
258   ""
259   "cmp%e2.%s1 %1,%0"
260   [(set_attr "slottable" "yes,no")])
261
262 ;; Swap operands; it seems the canonical look (if any) is not enforced.
263 ;;
264 ;; FIXME: Investigate that.
265 ;; FIXME: These could have an anonymous mode for operand 1.
266
267 ;; QImode
268
269 (define_insn "*cmp_swapextqi"
270   [(set (cc0)
271         (compare
272          (match_operator:SI 2 "cris_extend_operator"
273                             [(match_operand:QI 0 "memory_operand" "Q>,m")])
274          (match_operand:SI 1 "register_operand" "r,r")))]
275   ""
276   "cmp%e2.%s0 %0,%1" ; The function cris_notice_update_cc knows about
277                      ; swapped operands to compares.
278   [(set_attr "slottable" "yes,no")])
279
280 ;; HImode
281
282 (define_insn "*cmp_swapexthi"
283   [(set (cc0)
284         (compare
285          (match_operator:SI 2 "cris_extend_operator"
286                             [(match_operand:HI 0 "memory_operand" "Q>,m")])
287          (match_operand:SI 1 "register_operand" "r,r")))]
288   ""
289   "cmp%e2.%s0 %0,%1" ; The function cris_notice_update_cc knows about
290                      ; swapped operands to compares.
291   [(set_attr "slottable" "yes,no")])
292 \f
293 ;; The "normal" compare patterns, from SI on.
294
295 (define_insn "cmpsi"
296   [(set (cc0)
297         (compare
298          (match_operand:SI 0 "nonimmediate_operand" "r,r,r, r,Q>,Q>,r,r,m,m")
299          (match_operand:SI 1 "general_operand"      "I,r,Q>,M,M, r, P,g,M,r")))]
300   ""
301   "@
302    cmpq %1,%0
303    cmp.d %1,%0
304    cmp.d %1,%0
305    test.d %0
306    test.d %0
307    cmp.d %0,%1
308    cmp%e1.%z1 %1,%0
309    cmp.d %1,%0
310    test.d %0
311    cmp.d %0,%1"
312   [(set_attr "slottable" "yes,yes,yes,yes,yes,yes,no,no,no,no")])
313
314 (define_insn "cmphi"
315   [(set (cc0)
316         (compare (match_operand:HI 0 "nonimmediate_operand" "r,r, r,Q>,Q>,r,m,m")
317                  (match_operand:HI 1 "general_operand"      "r,Q>,M,M, r, g,M,r")))]
318   ""
319   "@
320    cmp.w %1,%0
321    cmp.w %1,%0
322    test.w %0
323    test.w %0
324    cmp.w %0,%1
325    cmp.w %1,%0
326    test.w %0
327    cmp.w %0,%1"
328   [(set_attr "slottable" "yes,yes,yes,yes,yes,no,no,no")])
329
330 (define_insn "cmpqi"
331   [(set (cc0)
332         (compare
333          (match_operand:QI 0 "nonimmediate_operand" "r,r, r,Q>,Q>,r,m,m")
334          (match_operand:QI 1 "general_operand"      "r,Q>,M,M, r, g,M,r")))]
335   ""
336   "@
337    cmp.b %1,%0
338    cmp.b %1,%0
339    test.b %0
340    test.b %0
341    cmp.b %0,%1
342    cmp.b %1,%0
343    test.b %0
344    cmp.b %0,%1"
345   [(set_attr "slottable" "yes,yes,yes,yes,yes,no,no,no")])
346 \f
347 ;; Pattern matching the BTST insn.
348 ;; It is useful for "if (i & val)" constructs, where val is an exact
349 ;; power of 2, or if val + 1 is a power of two, where we check for a bunch
350 ;; of zeros starting at bit 0).
351
352 ;; SImode.  This mode is the only one needed, since gcc automatically
353 ;; extends subregs for lower-size modes.  FIXME: Add testcase.
354 (define_insn "*btst"
355   [(set (cc0)
356         (zero_extract
357          (match_operand:SI 0 "nonmemory_operand" "r,r,r,r,r,r,n")
358          (match_operand:SI 1 "const_int_operand" "K,n,K,n,K,n,n")
359          (match_operand:SI 2 "nonmemory_operand" "M,M,K,n,r,r,r")))]
360   ;; Either it is a single bit, or consecutive ones starting at 0.
361   "GET_CODE (operands[1]) == CONST_INT
362    && (operands[1] == const1_rtx || operands[2] == const0_rtx)
363    && (REG_S_P (operands[0])
364        || (operands[1] == const1_rtx
365            && REG_S_P (operands[2])
366            && GET_CODE (operands[0]) == CONST_INT
367            && exact_log2 (INTVAL (operands[0])) >= 0))"
368
369 ;; The last "&&" condition above should be caught by some kind of
370 ;; canonicalization in gcc, but we can easily help with it here.
371 ;;  It results from expressions of the type
372 ;; "power_of_2_value & (1 << y)".
373 ;;
374 ;; Since there may be codes with tests in on bits (in constant position)
375 ;; beyond the size of a word, handle that by assuming those bits are 0.
376 ;; GCC should handle that, but it's a matter of easily-added belts while
377 ;; having suspenders.
378
379   "@
380    btstq (%1-1),%0
381    test.d %0
382    btstq %2,%0
383    clearf nz
384    btst %2,%0
385    clearf nz
386    cmpq %p0,%2"
387  [(set_attr "slottable" "yes")])
388 \f
389 ;; Move insns.
390
391 ;; The whole mandatory movdi family is here; expander, "anonymous"
392 ;; recognizer and splitter.  We're forced to have a movdi pattern,
393 ;; although GCC should be able to split it up itself.  Normally it can,
394 ;; but if other insns have DI operands (as is the case here), reload
395 ;; must be able to generate or match a movdi.  many testcases fail at
396 ;; -O3 or -fssa if we don't have this.  FIXME: Fix GCC...  See
397 ;; <URL:http://gcc.gnu.org/ml/gcc-patches/2000-04/msg00104.html>.
398 ;; However, a patch from Richard Kenner (similar to the cause of
399 ;; discussion at the URL above), indicates otherwise.  See
400 ;; <URL:http://gcc.gnu.org/ml/gcc-patches/2000-04/msg00554.html>.
401 ;; The truth has IMO is not been decided yet, so check from time to
402 ;; time by disabling the movdi patterns.
403
404 (define_expand "movdi"
405   [(set (match_operand:DI 0 "nonimmediate_operand" "")
406         (match_operand:DI 1 "general_operand" ""))]
407   ""
408   "
409 {
410   if (GET_CODE (operands[0]) == MEM && operands[1] != const0_rtx)
411     operands[1] = copy_to_mode_reg (DImode, operands[1]);
412
413   /* Some other ports (as of 2001-09-10 for example mcore and romp) also
414      prefer to split up constants early, like this.  The testcase in
415      gcc.c-torture/execute/961213-1.c shows that CSE2 gets confused by the
416      resulting subreg sets when using the construct from mcore (as of FSF
417      CVS, version -r 1.5), and it believes that the high part (the last one
418      emitted) is the final value.  This construct from romp seems more
419      robust, especially considering the head comments from
420      emit_no_conflict_block.  */
421   if ((GET_CODE (operands[1]) == CONST_INT
422        || GET_CODE (operands[1]) == CONST_DOUBLE)
423       && ! reload_completed
424       && ! reload_in_progress)
425     {
426       rtx insns;
427       rtx op0 = operands[0];
428       rtx op1 = operands[1];
429
430       start_sequence ();
431       emit_move_insn (operand_subword (op0, 0, 1, DImode),
432                       operand_subword (op1, 0, 1, DImode));
433       emit_move_insn (operand_subword (op0, 1, 1, DImode),
434                       operand_subword (op1, 1, 1, DImode));
435       insns = get_insns ();
436       end_sequence ();
437
438       emit_no_conflict_block (insns, op0, op1, 0, op1);
439       DONE;
440     }
441 }")
442
443 (define_insn "*movdi_insn"
444   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,r,m")
445         (match_operand:DI 1 "general_operand" "r,g,rM"))]
446   "register_operand (operands[0], DImode)
447    || register_operand (operands[1], DImode)
448    || operands[1] == const0_rtx"
449   "#")
450
451 (define_split
452   [(set (match_operand:DI 0 "nonimmediate_operand" "")
453         (match_operand:DI 1 "general_operand" ""))]
454   "reload_completed"
455   [(match_dup 2)]
456   "operands[2] = cris_split_movdx (operands);")
457 \f
458 ;; Side-effect patterns for move.S1 [rx=ry+rx.S2],rw
459 ;; and move.S1 [rx=ry+i],rz
460 ;;  Then movs.S1 and movu.S1 for both modes.
461 ;;
462 ;; move.S1 [rx=ry+rz.S],rw avoiding when rx is ry, or rw is rx
463 ;; FIXME: These could have anonymous mode for operand 0.
464
465 ;; QImode
466
467 (define_insn "*mov_sideqi_biap"
468   [(set (match_operand:QI 0 "register_operand" "=r,r")
469         (mem:QI (plus:SI
470                  (mult:SI (match_operand:SI 1 "register_operand" "r,r")
471                           (match_operand:SI 2 "const_int_operand" "n,n"))
472                  (match_operand:SI 3 "register_operand" "r,r"))))
473    (set (match_operand:SI 4 "register_operand" "=*3,r")
474         (plus:SI (mult:SI (match_dup 1)
475                           (match_dup 2))
476                  (match_dup 3)))]
477   "cris_side_effect_mode_ok (MULT, operands, 4, 3, 1, 2, 0)"
478   "@
479    #
480    move.%s0 [%4=%3+%1%T2],%0")
481
482 ;; HImode
483
484 (define_insn "*mov_sidehi_biap"
485   [(set (match_operand:HI 0 "register_operand" "=r,r")
486         (mem:HI (plus:SI
487                  (mult:SI (match_operand:SI 1 "register_operand" "r,r")
488                           (match_operand:SI 2 "const_int_operand" "n,n"))
489                  (match_operand:SI 3 "register_operand" "r,r"))))
490    (set (match_operand:SI 4 "register_operand" "=*3,r")
491         (plus:SI (mult:SI (match_dup 1)
492                           (match_dup 2))
493                  (match_dup 3)))]
494   "cris_side_effect_mode_ok (MULT, operands, 4, 3, 1, 2, 0)"
495   "@
496    #
497    move.%s0 [%4=%3+%1%T2],%0")
498
499 ;; SImode
500
501 (define_insn "*mov_sidesisf_biap"
502   [(set (match_operand 0 "register_operand" "=r,r")
503         (mem (plus:SI
504               (mult:SI (match_operand:SI 1 "register_operand" "r,r")
505                        (match_operand:SI 2 "const_int_operand" "n,n"))
506               (match_operand:SI 3 "register_operand" "r,r"))))
507    (set (match_operand:SI 4 "register_operand" "=*3,r")
508         (plus:SI (mult:SI (match_dup 1)
509                           (match_dup 2))
510                  (match_dup 3)))]
511   "GET_MODE_SIZE (GET_MODE (operands[0])) == UNITS_PER_WORD
512    && cris_side_effect_mode_ok (MULT, operands, 4, 3, 1, 2, 0)"
513   "@
514    #
515    move.%s0 [%4=%3+%1%T2],%0")
516 \f
517 ;; move.S1 [rx=ry+i],rz
518 ;; avoiding move.S1 [ry=ry+i],rz
519 ;; and      move.S1 [rz=ry+i],rz
520 ;; Note that "i" is allowed to be a register.
521 ;; FIXME: These could have anonymous mode for operand 0.
522
523 ;; QImode
524
525 (define_insn "*mov_sideqi"
526   [(set (match_operand:QI 0 "register_operand" "=r,r,r")
527         (mem:QI
528          (plus:SI (match_operand:SI 1 "cris_bdap_operand" "%r,r,r")
529                   (match_operand:SI 2 "cris_bdap_operand" "r>Rn,r,>Rn"))))
530    (set (match_operand:SI 3 "register_operand" "=*1,r,r")
531         (plus:SI (match_dup 1)
532                  (match_dup 2)))]
533   "cris_side_effect_mode_ok (PLUS, operands, 3, 1, 2, -1, 0)"
534   "*
535 {
536   if (which_alternative == 0
537       && (GET_CODE (operands[2]) != CONST_INT
538           || INTVAL (operands[2]) > 127
539           || INTVAL (operands[2]) < -128
540           || CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'N')
541           || CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'J')))
542     return \"#\";
543   return \"move.%s0 [%3=%1%S2],%0\";
544 }")
545
546 ;; HImode
547
548 (define_insn "*mov_sidehi"
549   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
550         (mem:HI
551          (plus:SI (match_operand:SI 1 "cris_bdap_operand" "%r,r,r")
552                   (match_operand:SI 2 "cris_bdap_operand" "r>Rn,r,>Rn"))))
553    (set (match_operand:SI 3 "register_operand" "=*1,r,r")
554         (plus:SI (match_dup 1)
555                  (match_dup 2)))]
556   "cris_side_effect_mode_ok (PLUS, operands, 3, 1, 2, -1, 0)"
557   "*
558 {
559   if (which_alternative == 0
560       && (GET_CODE (operands[2]) != CONST_INT
561           || INTVAL (operands[2]) > 127
562           || INTVAL (operands[2]) < -128
563           || CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'N')
564           || CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'J')))
565     return \"#\";
566   return \"move.%s0 [%3=%1%S2],%0\";
567 }")
568
569 ;; SImode
570
571 (define_insn "*mov_sidesisf"
572   [(set (match_operand 0 "register_operand" "=r,r,r")
573         (mem
574          (plus:SI (match_operand:SI 1 "cris_bdap_operand" "%r,r,r")
575                   (match_operand:SI 2 "cris_bdap_operand" "r>Rn,r,>Rn"))))
576    (set (match_operand:SI 3 "register_operand" "=*1,r,r")
577         (plus:SI (match_dup 1)
578                  (match_dup 2)))]
579   "GET_MODE_SIZE (GET_MODE (operands[0])) == UNITS_PER_WORD
580    && cris_side_effect_mode_ok (PLUS, operands, 3, 1, 2, -1, 0)"
581   "*
582 {
583   if (which_alternative == 0
584       && (GET_CODE (operands[2]) != CONST_INT
585           || INTVAL (operands[2]) > 127
586           || INTVAL (operands[2]) < -128
587           || CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'N')
588           || CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'J')))
589     return \"#\";
590   return \"move.%s0 [%3=%1%S2],%0\";
591 }")
592 \f
593 ;; Other way around; move to memory.
594
595 ;; Note that the condition (which for side-effect patterns is usually a
596 ;; call to cris_side_effect_mode_ok), isn't consulted for register
597 ;; allocation preferences -- constraints is the method for that.  The
598 ;; drawback is that we can't exclude register allocation to cause
599 ;; "move.s rw,[rx=ry+rz.S]" when rw==rx without also excluding rx==ry or
600 ;; rx==rz if we use an earlyclobber modifier for the constraint for rx.
601 ;; Instead of that, we recognize and split the cases where dangerous
602 ;; register combinations are spotted: where a register is set in the
603 ;; side-effect, and used in the main insn.  We don't handle the case where
604 ;; the set in the main insn overlaps the set in the side-effect; that case
605 ;; must be handled in gcc.  We handle just the case where the set in the
606 ;; side-effect overlaps the input operand of the main insn (i.e. just
607 ;; moves to memory).
608
609 ;;
610 ;; move.s rz,[ry=rx+rw.S]
611 ;; FIXME: These could have anonymous mode for operand 3.
612
613 ;; QImode
614
615 (define_insn "*mov_sideqi_biap_mem"
616   [(set (mem:QI (plus:SI
617                  (mult:SI (match_operand:SI 0 "register_operand" "r,r,r")
618                           (match_operand:SI 1 "const_int_operand" "n,n,n"))
619                  (match_operand:SI 2 "register_operand" "r,r,r")))
620         (match_operand:QI 3 "register_operand" "r,r,r"))
621    (set (match_operand:SI 4 "register_operand" "=*2,!3,r")
622         (plus:SI (mult:SI (match_dup 0)
623                           (match_dup 1))
624                  (match_dup 2)))]
625   "cris_side_effect_mode_ok (MULT, operands, 4, 2, 0, 1, 3)"
626   "@
627    #
628    #
629    move.%s3 %3,[%4=%2+%0%T1]")
630
631 ;; HImode
632
633 (define_insn "*mov_sidehi_biap_mem"
634   [(set (mem:HI (plus:SI
635                  (mult:SI (match_operand:SI 0 "register_operand" "r,r,r")
636                           (match_operand:SI 1 "const_int_operand" "n,n,n"))
637                  (match_operand:SI 2 "register_operand" "r,r,r")))
638         (match_operand:HI 3 "register_operand" "r,r,r"))
639    (set (match_operand:SI 4 "register_operand" "=*2,!3,r")
640         (plus:SI (mult:SI (match_dup 0)
641                           (match_dup 1))
642                  (match_dup 2)))]
643   "cris_side_effect_mode_ok (MULT, operands, 4, 2, 0, 1, 3)"
644   "@
645    #
646    #
647    move.%s3 %3,[%4=%2+%0%T1]")
648
649 ;; SImode
650
651 (define_insn "*mov_sidesisf_biap_mem"
652   [(set (mem (plus:SI
653               (mult:SI (match_operand:SI 0 "register_operand" "r,r,r")
654                        (match_operand:SI 1 "const_int_operand" "n,n,n"))
655               (match_operand:SI 2 "register_operand" "r,r,r")))
656         (match_operand 3 "register_operand" "r,r,r"))
657    (set (match_operand:SI 4 "register_operand" "=*2,!3,r")
658         (plus:SI (mult:SI (match_dup 0)
659                           (match_dup 1))
660                  (match_dup 2)))]
661   "GET_MODE_SIZE (GET_MODE (operands[3])) == UNITS_PER_WORD
662    && cris_side_effect_mode_ok (MULT, operands, 4, 2, 0, 1, 3)"
663   "@
664    #
665    #
666    move.%s3 %3,[%4=%2+%0%T1]")
667
668 ;; Split for the case above where we're out of luck with register
669 ;; allocation (again, the condition isn't checked for that), and we end up
670 ;; with the set in the side-effect getting the same register as the input
671 ;; register.
672
673 (define_split
674   [(parallel
675     [(set (match_operator
676            6 "cris_mem_op"
677            [(plus:SI
678              (mult:SI (match_operand:SI 0 "register_operand" "")
679                       (match_operand:SI 1 "const_int_operand" ""))
680              (match_operand:SI 2 "register_operand" ""))])
681           (match_operand 3 "register_operand" ""))
682      (set (match_operand:SI 4 "register_operand" "")
683           (plus:SI (mult:SI (match_dup 0)
684                             (match_dup 1))
685                    (match_dup 2)))])]
686   "reload_completed && reg_overlap_mentioned_p (operands[4], operands[3])"
687   [(set (match_dup 5) (match_dup 3))
688    (set (match_dup 4) (match_dup 2))
689    (set (match_dup 4)
690         (plus:SI (mult:SI (match_dup 0)
691                           (match_dup 1))
692                  (match_dup 4)))]
693   "operands[5]
694      = replace_equiv_address (operands[6],
695                               gen_rtx_PLUS (SImode,
696                                             gen_rtx_MULT (SImode,
697                                                           operands[0],
698                                                           operands[1]),
699                                             operands[2]));")
700 \f
701 ;; move.s rx,[ry=rz+i]
702 ;; FIXME: These could have anonymous mode for operand 2.
703
704 ;; QImode
705
706 (define_insn "*mov_sideqi_mem"
707   [(set (mem:QI
708          (plus:SI (match_operand:SI 0 "cris_bdap_operand" "%r,r,r,r")
709                   (match_operand:SI 1 "cris_bdap_operand" "r>Rn,r>Rn,r,>Rn")))
710         (match_operand:QI 2 "register_operand" "r,r,r,r"))
711    (set (match_operand:SI 3 "register_operand" "=*0,!2,r,r")
712         (plus:SI (match_dup 0)
713                  (match_dup 1)))]
714   "cris_side_effect_mode_ok (PLUS, operands, 3, 0, 1, -1, 2)"
715   "*
716 {
717   if (which_alternative == 0
718       && (GET_CODE (operands[1]) != CONST_INT
719           || INTVAL (operands[1]) > 127
720           || INTVAL (operands[1]) < -128
721           || CONST_OK_FOR_LETTER_P (INTVAL (operands[1]), 'N')
722           || CONST_OK_FOR_LETTER_P (INTVAL (operands[1]), 'J')))
723     return \"#\";
724   if (which_alternative == 1)
725     return \"#\";
726   return \"move.%s2 %2,[%3=%0%S1]\";
727 }")
728
729 ;; HImode
730
731 (define_insn "*mov_sidehi_mem"
732   [(set (mem:HI
733          (plus:SI (match_operand:SI 0 "cris_bdap_operand" "%r,r,r,r")
734                   (match_operand:SI 1 "cris_bdap_operand" "r>Rn,r>Rn,r,>Rn")))
735         (match_operand:HI 2 "register_operand" "r,r,r,r"))
736    (set (match_operand:SI 3 "register_operand" "=*0,!2,r,r")
737         (plus:SI (match_dup 0)
738                  (match_dup 1)))]
739   "cris_side_effect_mode_ok (PLUS, operands, 3, 0, 1, -1, 2)"
740   "*
741 {
742   if (which_alternative == 0
743       && (GET_CODE (operands[1]) != CONST_INT
744           || INTVAL (operands[1]) > 127
745           || INTVAL (operands[1]) < -128
746           || CONST_OK_FOR_LETTER_P (INTVAL (operands[1]), 'N')
747           || CONST_OK_FOR_LETTER_P (INTVAL (operands[1]), 'J')))
748     return \"#\";
749   if (which_alternative == 1)
750     return \"#\";
751   return \"move.%s2 %2,[%3=%0%S1]\";
752 }")
753
754 ;; SImode
755
756 (define_insn "*mov_sidesisf_mem"
757   [(set (mem
758          (plus:SI (match_operand:SI 0 "cris_bdap_operand" "%r,r,r,r")
759                   (match_operand:SI 1 "cris_bdap_operand" "r>Rn,r>Rn,r,>Rn")))
760         (match_operand 2 "register_operand" "r,r,r,r"))
761    (set (match_operand:SI 3 "register_operand" "=*0,!2,r,r")
762         (plus:SI (match_dup 0)
763                  (match_dup 1)))]
764   "GET_MODE_SIZE (GET_MODE (operands[2])) == UNITS_PER_WORD
765    && cris_side_effect_mode_ok (PLUS, operands, 3, 0, 1, -1, 2)"
766   "*
767 {
768   if (which_alternative == 0
769       && (GET_CODE (operands[1]) != CONST_INT
770           || INTVAL (operands[1]) > 127
771           || INTVAL (operands[1]) < -128
772           || CONST_OK_FOR_LETTER_P (INTVAL (operands[1]), 'N')
773           || CONST_OK_FOR_LETTER_P (INTVAL (operands[1]), 'J')))
774     return \"#\";
775   if (which_alternative == 1)
776     return \"#\";
777   return \"move.%s2 %2,[%3=%0%S1]\";
778 }")
779
780 ;; Like the biap case, a split where the set in the side-effect gets the
781 ;; same register as the input register to the main insn, since the
782 ;; condition isn't checked at register allocation.
783
784 (define_split
785   [(parallel
786     [(set (match_operator
787            4 "cris_mem_op"
788            [(plus:SI
789              (match_operand:SI 0 "cris_bdap_operand" "")
790              (match_operand:SI 1 "cris_bdap_operand" ""))])
791           (match_operand 2 "register_operand" ""))
792      (set (match_operand:SI 3 "register_operand" "")
793           (plus:SI (match_dup 0) (match_dup 1)))])]
794   "reload_completed && reg_overlap_mentioned_p (operands[3], operands[2])"
795   [(set (match_dup 4) (match_dup 2))
796    (set (match_dup 3) (match_dup 0))
797    (set (match_dup 3) (plus:SI (match_dup 3) (match_dup 1)))]
798   "")
799 \f
800 ;; Clear memory side-effect patterns.  It is hard to get to the mode if
801 ;; the MEM was anonymous, so there will be one for each mode.
802
803 ;; clear.d [ry=rx+rw.s2]
804
805 (define_insn "*clear_sidesi_biap"
806   [(set (mem:SI (plus:SI
807                  (mult:SI (match_operand:SI 0 "register_operand" "r,r")
808                           (match_operand:SI 1 "const_int_operand" "n,n"))
809                  (match_operand:SI 2 "register_operand" "r,r")))
810         (const_int 0))
811    (set (match_operand:SI 3 "register_operand" "=*2,r")
812         (plus:SI (mult:SI (match_dup 0)
813                           (match_dup 1))
814                  (match_dup 2)))]
815   "cris_side_effect_mode_ok (MULT, operands, 3, 2, 0, 1, -1)"
816   "@
817    #
818    clear.d [%3=%2+%0%T1]")
819
820 ;; clear.d [ry=rz+i]
821
822 (define_insn "*clear_sidesi"
823   [(set (mem:SI
824          (plus:SI (match_operand:SI 0 "cris_bdap_operand" "%r,r,r")
825                   (match_operand:SI 1 "cris_bdap_operand" "r>Rn,r,>Rn")))
826         (const_int 0))
827    (set (match_operand:SI 2 "register_operand" "=*0,r,r")
828         (plus:SI (match_dup 0)
829                  (match_dup 1)))]
830   "cris_side_effect_mode_ok (PLUS, operands, 2, 0, 1, -1, -1)"
831   "*
832 {
833   if (which_alternative == 0
834       && (GET_CODE (operands[1]) != CONST_INT
835           || INTVAL (operands[1]) > 127
836           || INTVAL (operands[1]) < -128
837           || CONST_OK_FOR_LETTER_P (INTVAL (operands[1]), 'N')
838           || CONST_OK_FOR_LETTER_P (INTVAL (operands[1]), 'J')))
839     return \"#\";
840   return \"clear.d [%2=%0%S1]\";
841 }")
842
843 ;;  clear.w [ry=rx+rw.s2]
844
845 (define_insn "*clear_sidehi_biap"
846   [(set (mem:HI (plus:SI
847                  (mult:SI (match_operand:SI 0 "register_operand" "r,r")
848                           (match_operand:SI 1 "const_int_operand" "n,n"))
849                  (match_operand:SI 2 "register_operand" "r,r")))
850         (const_int 0))
851    (set (match_operand:SI 3 "register_operand" "=*2,r")
852         (plus:SI (mult:SI (match_dup 0)
853                           (match_dup 1))
854                  (match_dup 2)))]
855   "cris_side_effect_mode_ok (MULT, operands, 3, 2, 0, 1, -1)"
856   "@
857    #
858    clear.w [%3=%2+%0%T1]")
859
860 ;; clear.w [ry=rz+i]
861
862 (define_insn "*clear_sidehi"
863   [(set (mem:HI
864          (plus:SI (match_operand:SI 0 "cris_bdap_operand" "%r,r,r")
865                   (match_operand:SI 1 "cris_bdap_operand" "r>Rn,r,>Rn")))
866         (const_int 0))
867    (set (match_operand:SI 2 "register_operand" "=*0,r,r")
868         (plus:SI (match_dup 0)
869                  (match_dup 1)))]
870   "cris_side_effect_mode_ok (PLUS, operands, 2, 0, 1, -1, -1)"
871   "*
872 {
873   if (which_alternative == 0
874       && (GET_CODE (operands[1]) != CONST_INT
875           || INTVAL (operands[1]) > 127
876           || INTVAL (operands[1]) < -128
877           || CONST_OK_FOR_LETTER_P (INTVAL (operands[1]), 'N')
878           || CONST_OK_FOR_LETTER_P (INTVAL (operands[1]), 'J')))
879     return \"#\";
880   return \"clear.w [%2=%0%S1]\";
881 }")
882
883 ;;  clear.b [ry=rx+rw.s2]
884
885 (define_insn "*clear_sideqi_biap"
886   [(set (mem:QI (plus:SI
887                  (mult:SI (match_operand:SI 0 "register_operand" "r,r")
888                           (match_operand:SI 1 "const_int_operand" "n,n"))
889                  (match_operand:SI 2 "register_operand" "r,r")))
890         (const_int 0))
891    (set (match_operand:SI 3 "register_operand" "=*2,r")
892         (plus:SI (mult:SI (match_dup 0)
893                           (match_dup 1))
894                  (match_dup 2)))]
895   "cris_side_effect_mode_ok (MULT, operands, 3, 2, 0, 1, -1)"
896   "@
897    #
898    clear.b [%3=%2+%0%T1]")
899
900 ;; clear.b [ry=rz+i]
901
902 (define_insn "*clear_sideqi"
903   [(set (mem:QI
904          (plus:SI (match_operand:SI 0 "cris_bdap_operand" "%r,r,r")
905                   (match_operand:SI 1 "cris_bdap_operand" "r>Rn,r,>Rn")))
906         (const_int 0))
907    (set (match_operand:SI 2 "register_operand" "=*0,r,r")
908         (plus:SI (match_dup 0)
909                  (match_dup 1)))]
910   "cris_side_effect_mode_ok (PLUS, operands, 2, 0, 1, -1, -1)"
911   "*
912 {
913   if (which_alternative == 0
914       && (GET_CODE (operands[1]) != CONST_INT
915           || INTVAL (operands[1]) > 127
916           || INTVAL (operands[1]) < -128
917           || CONST_OK_FOR_LETTER_P (INTVAL (operands[1]), 'N')
918           || CONST_OK_FOR_LETTER_P (INTVAL (operands[1]), 'J')))
919     return \"#\";
920   return \"clear.b [%2=%0%S1]\";
921 }")
922 \f
923 ;; To appease testcase gcc.c-torture/execute/920501-2.c (and others) at
924 ;; -O0, we need a movdi as a temporary measure.  Here's how things fail:
925 ;;  A cmpdi RTX needs reloading (global):
926 ;;    (insn 185 326 186 (set (cc0)
927 ;;          (compare (mem/f:DI (reg/v:SI 22) 0)
928 ;;              (const_int 1 [0x1]))) 4 {cmpdi} (nil)
929 ;;      (nil))
930 ;; Now, reg 22 is reloaded for input address, and the mem is also moved
931 ;; out of the instruction (into a register), since one of the operands
932 ;; must be a register.  Reg 22 is reloaded (into reg 10), and the mem is
933 ;; moved out and synthesized in SImode parts (reg 9, reg 10 - should be ok
934 ;; wrt. overlap).  The bad things happen with the synthesis in
935 ;; emit_move_insn_1; the location where to substitute reg 10 is lost into
936 ;; two new RTX:es, both still having reg 22.  Later on, the left-over reg
937 ;; 22 is recognized to have an equivalent in memory which is substituted
938 ;; straight in, and we end up with an unrecognizable insn:
939 ;;    (insn 325 324 326 (set (reg:SI 9 r9)
940 ;;            (mem/f:SI (mem:SI (plus:SI (reg:SI 8 r8)
941 ;;                        (const_int -84 [0xffffffac])) 0) 0)) -1 (nil)
942 ;;        (nil))
943 ;; which is the first part of the reloaded synthesized "movdi".
944 ;;  The right thing would be to add equivalent replacement locations for
945 ;; insn with pseudos that need more reloading.  The question is where.
946
947 ;; Normal move patterns from SI on.
948
949 (define_expand "movsi"
950   [(set
951     (match_operand:SI 0 "nonimmediate_operand" "")
952     (match_operand:SI 1 "cris_general_operand_or_symbol" ""))]
953   ""
954   "
955 {
956   /* If the output goes to a MEM, make sure we have zero or a register as
957      input.  */
958   if (GET_CODE (operands[0]) == MEM
959       && ! REG_S_P (operands[1])
960       && operands[1] != const0_rtx
961       && ! no_new_pseudos)
962     operands[1] = force_reg (SImode, operands[1]);
963
964   /* If we're generating PIC and have an incoming symbol, validize it to a
965      general operand or something that will match a special pattern.
966
967      FIXME: Do we *have* to recognize anything that would normally be a
968      valid symbol?  Can we exclude global PIC addresses with an added
969      offset?  */
970   if (flag_pic
971       && CONSTANT_ADDRESS_P (operands[1])
972       && cris_symbol (operands[1]))
973     {
974       /* We must have a register as destination for what we're about to
975          do, and for the patterns we generate.  */
976       if (! REG_S_P (operands[0]))
977         {
978           if (no_new_pseudos)
979             abort ();
980           operands[1] = force_reg (SImode, operands[1]);
981         }
982       else
983         {
984           /* Mark a needed PIC setup for a LABEL_REF:s coming in here:
985              they are so rare not-being-branch-targets that we don't mark
986              a function as needing PIC setup just because we have
987              inspected LABEL_REF:s as operands.  It is only in
988              __builtin_setjmp and such that we can get a LABEL_REF
989              assigned to a register.  */
990           if (GET_CODE (operands[1]) == LABEL_REF)
991             current_function_uses_pic_offset_table = 1;
992
993           /* We don't have to do anything for global PIC operands; they
994              look just like ``[rPIC+sym]''.  */
995           if (! cris_got_symbol (operands[1])
996               /* We don't do anything for local PIC operands; we match
997                  that with a special alternative.  */
998               && ! cris_gotless_symbol (operands[1]))
999             {
1000               /* We get here when we have to change something that would
1001                  be recognizable if it wasn't PIC.  A ``sym'' is ok for
1002                  PIC symbols both with and without a GOT entry.  And ``sym
1003                  + offset'' is ok for local symbols, so the only thing it
1004                  could be, is a global symbol with an offset.  Check and
1005                  abort if not.  */
1006               rtx sym = get_related_value (operands[1]);
1007               HOST_WIDE_INT offs = get_integer_term (operands[1]);
1008
1009               if (sym == NULL_RTX || offs == 0)
1010                 abort ();
1011               emit_move_insn (operands[0], sym);
1012               if (expand_binop (SImode, add_optab, operands[0],
1013                                 GEN_INT (offs), operands[0], 0,
1014                                 OPTAB_LIB_WIDEN) != operands[0])
1015                 abort ();
1016               DONE;
1017             }
1018         }
1019     }
1020 }")
1021
1022 (define_insn "*movsi_internal"
1023   [(set
1024     (match_operand:SI 0 "nonimmediate_operand" "=r,r, r,Q>,r,Q>,g,r,r, r,g,rQ>,x,  m,x")
1025     (match_operand:SI 1
1026     ;; FIXME: We want to put S last, but apparently g matches S.
1027     ;; It's a bug: an S is not a general_operand and shouldn't match g.
1028      "cris_general_operand_or_gotless_symbol"   "r,Q>,M,M, I,r, M,n,!S,g,r,x,  rQ>,x,gi"))]
1029   ""
1030   "*
1031 {
1032   /* Better to have c-switch here; it is worth it to optimize the size of
1033      move insns.  The alternative would be to try to find more constraint
1034      letters.  FIXME: Check again.  It seems this could shrink a bit.  */
1035   switch (which_alternative)
1036     {
1037     case 0:
1038     case 1:
1039     case 5:
1040     case 9:
1041     case 10:
1042       return \"move.d %1,%0\";
1043
1044     case 11:
1045     case 12:
1046     case 13:
1047     case 14:
1048       return \"move %d1,%0\";
1049
1050     case 2:
1051     case 3:
1052     case 6:
1053       return \"clear.d %0\";
1054
1055       /* Constants -32..31 except 0.  */
1056     case 4:
1057       return \"moveq %1,%0\";
1058
1059       /* We can win a little on constants -32768..-33, 32..65535.  */
1060     case 7:
1061       if (INTVAL (operands[1]) > 0 && INTVAL (operands[1]) < 65536)
1062         {
1063           if (INTVAL (operands[1]) < 256)
1064             return \"movu.b %1,%0\";
1065           return \"movu.w %1,%0\";
1066         }
1067       else if (INTVAL (operands[1]) >= -32768 && INTVAL (operands[1]) < 32768)
1068         {
1069           if (INTVAL (operands[1]) >= -128 && INTVAL (operands[1]) < 128)
1070             return \"movs.b %1,%0\";
1071           return \"movs.w %1,%0\";
1072         }
1073       return \"move.d %1,%0\";
1074
1075     case 8:
1076       /* FIXME: Try and split this into pieces GCC makes better code of,
1077          than this multi-insn pattern.  Synopsis: wrap the GOT-relative
1078          symbol into an unspec, and when PIC, recognize the unspec
1079          everywhere a symbol is normally recognized.  (The PIC register
1080          should be recognized by GCC as pic_offset_table_rtx when needed
1081          and similar for PC.)  Each component can then be optimized with
1082          the rest of the code; it should be possible to have a constant
1083          term added on an unspec.  Don't forget to add a REG_EQUAL (or
1084          is it REG_EQUIV) note to the destination.  It might not be
1085          worth it.  Measure.
1086
1087          Note that the 'v' modifier makes PLT references be output as
1088          sym:PLT rather than [rPIC+sym:GOTPLT].  */
1089       if (GET_CODE (operands[1]) == UNSPEC
1090           && XINT (operands[1], 1) == CRIS_UNSPEC_GOT)
1091         {
1092           /* We clobber cc0 rather than set it to GOT.  Should not
1093              matter, though.  */
1094           CC_STATUS_INIT;
1095           if (REGNO (operands[0]) != PIC_OFFSET_TABLE_REGNUM)
1096             abort ();
1097
1098           return \"move.d $pc,%0\;sub.d .:GOTOFF,%0\";
1099         }
1100
1101       return \"move.d %v1,%0\;add.d %P1,%0\";
1102
1103     default:
1104       return \"BOGUS: %1 to %0\";
1105     }
1106 }"
1107   [(set_attr "slottable" "yes,yes,yes,yes,yes,yes,no,no,no,no,no,yes,yes,no,no")
1108    (set_attr "cc" "*,*,*,*,*,*,*,*,*,*,*,none,none,none,none")])
1109 \f
1110 ;; Extend operations with side-effect from mem to register, using
1111 ;; MOVS/MOVU.  These are from mem to register only.
1112 ;;
1113 ;; [rx=ry+rz.S]
1114 ;;
1115 ;; QImode to HImode
1116 ;;
1117 ;; FIXME: Can we omit extend to HImode, since GCC should truncate for
1118 ;; HImode by itself?  Perhaps use only anonymous modes?
1119
1120 (define_insn "*ext_sideqihi_biap"
1121   [(set (match_operand:HI 0 "register_operand" "=r,r")
1122         (match_operator:HI
1123          5 "cris_extend_operator"
1124          [(mem:QI (plus:SI
1125                    (mult:SI (match_operand:SI 1 "register_operand" "r,r")
1126                             (match_operand:SI 2 "const_int_operand" "n,n"))
1127                    (match_operand:SI 3 "register_operand" "r,r")))]))
1128    (set (match_operand:SI 4 "register_operand" "=*3,r")
1129         (plus:SI (mult:SI (match_dup 1)
1130                           (match_dup 2))
1131                  (match_dup 3)))]
1132   "cris_side_effect_mode_ok (MULT, operands, 4, 3, 1, 2, 0)"
1133   "@
1134    #
1135    mov%e5.%m5 [%4=%3+%1%T2],%0")
1136
1137 ;; QImode to SImode
1138
1139 (define_insn "*ext_sideqisi_biap"
1140   [(set (match_operand:SI 0 "register_operand" "=r,r")
1141         (match_operator:SI
1142          5 "cris_extend_operator"
1143          [(mem:QI (plus:SI
1144                    (mult:SI (match_operand:SI 1 "register_operand" "r,r")
1145                             (match_operand:SI 2 "const_int_operand" "n,n"))
1146                    (match_operand:SI 3 "register_operand" "r,r")))]))
1147    (set (match_operand:SI 4 "register_operand" "=*3,r")
1148         (plus:SI (mult:SI (match_dup 1)
1149                           (match_dup 2))
1150                  (match_dup 3)))]
1151   "cris_side_effect_mode_ok (MULT, operands, 4, 3, 1, 2, 0)"
1152   "@
1153    #
1154    mov%e5.%m5 [%4=%3+%1%T2],%0")
1155
1156 ;; HImode to SImode
1157
1158 (define_insn "*ext_sidehisi_biap"
1159   [(set (match_operand:SI 0 "register_operand" "=r,r")
1160         (match_operator:SI
1161          5 "cris_extend_operator"
1162          [(mem:HI (plus:SI
1163                    (mult:SI (match_operand:SI 1 "register_operand" "r,r")
1164                             (match_operand:SI 2 "const_int_operand" "n,n"))
1165                    (match_operand:SI 3 "register_operand" "r,r")))]))
1166    (set (match_operand:SI 4 "register_operand" "=*3,r")
1167         (plus:SI (mult:SI (match_dup 1)
1168                           (match_dup 2))
1169                  (match_dup 3)))]
1170   "cris_side_effect_mode_ok (MULT, operands, 4, 3, 1, 2, 0)"
1171   "@
1172    #
1173    mov%e5.%m5 [%4=%3+%1%T2],%0")
1174 \f
1175 ;; Same but [rx=ry+i]
1176
1177 ;; QImode to HImode
1178
1179 (define_insn "*ext_sideqihi"
1180   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
1181         (match_operator:HI
1182          4 "cris_extend_operator"
1183          [(mem:QI (plus:SI
1184                    (match_operand:SI 1 "cris_bdap_operand" "%r,r,r")
1185                    (match_operand:SI 2 "cris_bdap_operand" "r>Rn,r,>Rn")))]))
1186    (set (match_operand:SI 3 "register_operand" "=*1,r,r")
1187         (plus:SI (match_dup 1)
1188                  (match_dup 2)))]
1189   "cris_side_effect_mode_ok (PLUS, operands, 3, 1, 2, -1, 0)"
1190   "*
1191 {
1192   if (which_alternative == 0
1193       && (GET_CODE (operands[2]) != CONST_INT
1194           || INTVAL (operands[2]) > 127
1195           || INTVAL (operands[2]) < -128
1196           || CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'N')
1197           || CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'J')))
1198     return \"#\";
1199   return \"mov%e4.%m4 [%3=%1%S2],%0\";
1200 }")
1201
1202 ;; QImode to SImode
1203
1204 (define_insn "*ext_sideqisi"
1205   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1206         (match_operator:SI
1207          4 "cris_extend_operator"
1208          [(mem:QI (plus:SI
1209                    (match_operand:SI 1 "cris_bdap_operand" "%r,r,r")
1210                    (match_operand:SI 2 "cris_bdap_operand" "r>Rn,r,>Rn")))]))
1211    (set (match_operand:SI 3 "register_operand" "=*1,r,r")
1212         (plus:SI (match_dup 1)
1213                  (match_dup 2)))]
1214   "cris_side_effect_mode_ok (PLUS, operands, 3, 1, 2, -1, 0)"
1215   "*
1216 {
1217   if (which_alternative == 0
1218       && (GET_CODE (operands[2]) != CONST_INT
1219           || INTVAL (operands[2]) > 127
1220           || INTVAL (operands[2]) < -128
1221           || CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'N')
1222           || CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'J')))
1223     return \"#\";
1224   return \"mov%e4.%m4 [%3=%1%S2],%0\";
1225 }")
1226
1227 ;; HImode to SImode
1228
1229 (define_insn "*ext_sidehisi"
1230   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1231         (match_operator:SI
1232          4 "cris_extend_operator"
1233          [(mem:HI (plus:SI
1234                    (match_operand:SI 1 "cris_bdap_operand" "%r,r,r")
1235                    (match_operand:SI 2 "cris_bdap_operand" "r>Rn,r,>Rn")))]))
1236    (set (match_operand:SI 3 "register_operand" "=*1,r,r")
1237         (plus:SI (match_dup 1)
1238                  (match_dup 2)))]
1239   "cris_side_effect_mode_ok (PLUS, operands, 3, 1, 2, -1, 0)"
1240   "*
1241 {
1242   if (which_alternative == 0
1243       && (GET_CODE (operands[2]) != CONST_INT
1244           || INTVAL (operands[2]) > 127
1245           || INTVAL (operands[2]) < -128
1246           || CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'N')
1247           || CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'J')))
1248     return \"#\";
1249   return \"mov%e4.%m4 [%3=%1%S2],%0\";
1250 }")
1251 \f
1252 ;; FIXME: See movsi.
1253
1254 (define_insn "movhi"
1255   [(set
1256     (match_operand:HI 0 "nonimmediate_operand" "=r,r, r,Q>,r,Q>,r,r,r,g,g,r,r,x")
1257     (match_operand:HI 1 "general_operand"       "r,Q>,M,M, I,r, L,O,n,M,r,g,x,r"))]
1258   ""
1259   "*
1260 {
1261   switch (which_alternative)
1262     {
1263     case 0:
1264     case 1:
1265     case 5:
1266     case 10:
1267     case 11:
1268       return \"move.w %1,%0\";
1269     case 12:
1270     case 13:
1271       return \"move %1,%0\";
1272     case 2:
1273     case 3:
1274     case 9:
1275       return \"clear.w %0\";
1276     case 4:
1277       return \"moveq %1,%0\";
1278     case 6:
1279     case 8:
1280       if (INTVAL (operands[1]) < 256 && INTVAL (operands[1]) >= -128)
1281         {
1282           if (INTVAL (operands[1]) > 0)
1283             return \"movu.b %1,%0\";
1284           return \"movs.b %1,%0\";
1285         }
1286       return \"move.w %1,%0\";
1287     case 7:
1288       return \"movEq %b1,%0\";
1289     default:
1290       return \"BOGUS: %1 to %0\";
1291   }
1292 }"
1293   [(set_attr "slottable" "yes,yes,yes,yes,yes,yes,no,yes,no,no,no,no,yes,yes")
1294    (set_attr "cc" "*,*,none,none,*,none,*,clobber,*,none,none,*,none,none")])
1295
1296 (define_insn "movstricthi"
1297   [(set
1298     (strict_low_part
1299      (match_operand:HI 0 "nonimmediate_operand" "+r,r, r,Q>,Q>,g,r,g"))
1300     (match_operand:HI 1 "general_operand"        "r,Q>,M,M, r, M,g,r"))]
1301   ""
1302   "@
1303    move.w %1,%0
1304    move.w %1,%0
1305    clear.w %0
1306    clear.w %0
1307    move.w %1,%0
1308    clear.w %0
1309    move.w %1,%0
1310    move.w %1,%0"
1311   [(set_attr "slottable" "yes,yes,yes,yes,yes,no,no,no")])
1312
1313 (define_expand "reload_inhi"
1314   [(set (match_operand:HI 2 "register_operand" "=r")
1315         (match_operand:HI 1 "memory_operand" "m"))
1316    (set (match_operand:HI 0 "register_operand" "=x")
1317         (match_dup 2))]
1318   ""
1319   "")
1320
1321 (define_expand "reload_outhi"
1322   [(set (match_operand:HI 2 "register_operand" "=r")
1323         (match_operand:HI 1 "register_operand" "x"))
1324    (set (match_operand:HI 0 "memory_operand" "=m")
1325         (match_dup 2))]
1326   ""
1327   "")
1328 \f
1329 (define_insn "movqi"
1330   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,Q>,r, r,Q>,r,g,g,r,r,r,x")
1331         (match_operand:QI 1 "general_operand"       "r,r, Q>,M,M, I,M,r,O,g,x,r"))]
1332   ""
1333   "@
1334    move.b %1,%0
1335    move.b %1,%0
1336    move.b %1,%0
1337    clear.b %0
1338    clear.b %0
1339    moveq %1,%0
1340    clear.b %0
1341    move.b %1,%0
1342    moveq %b1,%0
1343    move.b %1,%0
1344    move %1,%0
1345    move %1,%0"
1346   [(set_attr "slottable" "yes,yes,yes,yes,yes,yes,no,no,yes,no,yes,yes")
1347    (set_attr "cc" "*,*,*,*,*,*,*,*,clobber,*,none,none")])
1348
1349 (define_insn "movstrictqi"
1350   [(set (strict_low_part
1351          (match_operand:QI 0 "nonimmediate_operand" "+r,Q>,r, r,Q>,g,g,r"))
1352         (match_operand:QI 1 "general_operand"        "r,r, Q>,M,M, M,r,g"))]
1353   ""
1354   "@
1355    move.b %1,%0
1356    move.b %1,%0
1357    move.b %1,%0
1358    clear.b %0
1359    clear.b %0
1360    clear.b %0
1361    move.b %1,%0
1362    move.b %1,%0"
1363   [(set_attr "slottable" "yes,yes,yes,yes,yes,no,no,no")])
1364
1365 (define_expand "reload_inqi"
1366   [(set (match_operand:QI 2 "register_operand" "=r")
1367         (match_operand:QI 1 "memory_operand" "m"))
1368    (set (match_operand:QI 0 "register_operand" "=x")
1369         (match_dup 2))]
1370   ""
1371   "")
1372
1373 (define_expand "reload_outqi"
1374   [(set (match_operand:QI 2 "register_operand" "=r")
1375         (match_operand:QI 1 "register_operand" "x"))
1376    (set (match_operand:QI 0 "memory_operand" "=m")
1377         (match_dup 2))]
1378   ""
1379   "")
1380
1381 ;; The valid "quick" bit-patterns are, except for 0.0, denormalized
1382 ;; values REALLY close to 0, and some NaN:s (I think; their exponent is
1383 ;; all ones); the worthwhile one is "0.0".
1384 ;; It will use clear, so we know ALL types of immediate 0 never change cc.
1385
1386 (define_insn "movsf"
1387   [(set (match_operand:SF 0 "nonimmediate_operand" "=r,Q>,r, r,Q>,g,g,r,r,x,Q>,m,x, x")
1388         (match_operand:SF 1 "general_operand"       "r,r, Q>,G,G, G,r,g,x,r,x, x,Q>,g"))]
1389   ""
1390   "@
1391    move.d %1,%0
1392    move.d %1,%0
1393    move.d %1,%0
1394    clear.d %0
1395    clear.d %0
1396    clear.d %0
1397    move.d %1,%0
1398    move.d %1,%0
1399    move %1,%0
1400    move %1,%0
1401    move %1,%0
1402    move %1,%0
1403    move %1,%0
1404    move %1,%0"
1405   [(set_attr "slottable" "yes,yes,yes,yes,yes,no,no,no,yes,yes,yes,no,yes,no")])
1406
1407 ;; Note that the memory layout of the registers is the reverse of that
1408 ;; of the standard patterns "load_multiple" and "store_multiple".
1409 (define_insn "*cris_load_multiple"
1410   [(match_parallel 0 "cris_load_multiple_op"
1411                    [(set (match_operand:SI 1 "register_operand" "=r,r")
1412                          (match_operand:SI 2 "memory_operand" "Q,m"))])]
1413   ""
1414   "movem %O0,%o0"
1415   [(set_attr "cc" "none")
1416    (set_attr "slottable" "yes,no")
1417    ;; Not true, but setting the length to 0 causes return sequences (ret
1418    ;; movem) to have the cost they had when (return) included the movem
1419    ;; and reduces the performance penalty taken for needing to emit an
1420    ;; epilogue (in turn copied by bb-reorder) instead of return patterns.
1421    ;; FIXME: temporary change until all insn lengths are correctly
1422    ;; described.  FIXME: have better target control over bb-reorder.
1423    (set_attr "length" "0")])
1424
1425 (define_insn "*cris_store_multiple"
1426   [(match_parallel 0 "cris_store_multiple_op"
1427                    [(set (match_operand:SI 2 "memory_operand" "=Q,m")
1428                          (match_operand:SI 1 "register_operand" "r,r"))])]
1429   ""
1430   "movem %o0,%O0"
1431   [(set_attr "cc" "none")
1432    (set_attr "slottable" "yes,no")])
1433 \f
1434
1435 ;; Sign- and zero-extend insns with standard names.
1436 ;;  Those for integer source operand are ordered with the widest source
1437 ;; type first.
1438
1439 ;; Sign-extend.
1440
1441 (define_insn "extendsidi2"
1442   [(set (match_operand:DI 0 "register_operand" "=r")
1443         (sign_extend:DI (match_operand:SI 1 "general_operand" "g")))]
1444   ""
1445   "move.d %1,%M0\;smi %H0\;neg.d %H0,%H0")
1446
1447 (define_insn "extendhidi2"
1448   [(set (match_operand:DI 0 "register_operand" "=r")
1449         (sign_extend:DI (match_operand:HI 1 "general_operand" "g")))]
1450   ""
1451   "movs.w %1,%M0\;smi %H0\;neg.d %H0,%H0")
1452
1453 (define_insn "extendhisi2"
1454   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1455         (sign_extend:SI (match_operand:HI 1 "general_operand" "r,Q>,g")))]
1456   ""
1457   "movs.w %1,%0"
1458   [(set_attr "slottable" "yes,yes,no")])
1459
1460 (define_insn "extendqidi2"
1461   [(set (match_operand:DI 0 "register_operand" "=r")
1462         (sign_extend:DI (match_operand:QI 1 "general_operand" "g")))]
1463   ""
1464   "movs.b %1,%M0\;smi %H0\;neg.d %H0,%H0")
1465
1466 (define_insn "extendqisi2"
1467   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1468         (sign_extend:SI (match_operand:QI 1 "general_operand" "r,Q>,g")))]
1469   ""
1470   "movs.b %1,%0"
1471   [(set_attr "slottable" "yes,yes,no")])
1472
1473 ;; To do a byte->word extension, extend to dword, exept that the top half
1474 ;; of the register will be clobbered.  FIXME: Perhaps this is not needed.
1475
1476 (define_insn "extendqihi2"
1477   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
1478         (sign_extend:HI (match_operand:QI 1 "general_operand" "r,Q>,g")))]
1479   ""
1480   "movs.b %1,%0"
1481   [(set_attr "slottable" "yes,yes,no")])
1482 \f
1483
1484 ;; Zero-extend.  The DImode ones are synthesized by gcc, so we don't
1485 ;; specify them here.
1486
1487 (define_insn "zero_extendhisi2"
1488   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1489         (zero_extend:SI
1490          (match_operand:HI 1 "nonimmediate_operand" "r,Q>,m")))]
1491   ""
1492   "movu.w %1,%0"
1493   [(set_attr "slottable" "yes,yes,no")])
1494
1495 (define_insn "zero_extendqisi2"
1496   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1497         (zero_extend:SI
1498          (match_operand:QI 1 "nonimmediate_operand" "r,Q>,m")))]
1499   ""
1500   "movu.b %1,%0"
1501   [(set_attr "slottable" "yes,yes,no")])
1502
1503 ;; Same comment as sign-extend QImode to HImode above applies.
1504
1505 (define_insn "zero_extendqihi2"
1506   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
1507         (zero_extend:HI
1508          (match_operand:QI 1 "nonimmediate_operand" "r,Q>,m")))]
1509   ""
1510   "movu.b %1,%0"
1511   [(set_attr "slottable" "yes,yes,no")])
1512 \f
1513 ;; All kinds of arithmetic and logical instructions.
1514 ;;
1515 ;; First, anonymous patterns to match addressing modes with
1516 ;; side-effects.
1517 ;;
1518 ;; op.S [rx=ry+I],rz; (add, sub, or, and, bound).
1519 ;;
1520 ;; [rx=ry+rz.S]
1521 ;; FIXME: These could have anonymous mode for operand 0.
1522
1523 ;; QImode
1524
1525 (define_insn "*op_sideqi_biap"
1526   [(set (match_operand:QI 0 "register_operand" "=r,r")
1527         (match_operator:QI
1528          6 "cris_orthogonal_operator"
1529          [(match_operand:QI 1 "register_operand" "0,0")
1530           (mem:QI (plus:SI
1531                    (mult:SI (match_operand:SI 2 "register_operand" "r,r")
1532                             (match_operand:SI 3 "const_int_operand" "n,n"))
1533                    (match_operand:SI 4 "register_operand" "r,r")))]))
1534    (set (match_operand:SI 5 "register_operand" "=*4,r")
1535         (plus:SI (mult:SI (match_dup 2)
1536                           (match_dup 3))
1537                  (match_dup 4)))]
1538   "cris_side_effect_mode_ok (MULT, operands, 5, 4, 2, 3, 0)"
1539   "@
1540    #
1541    %x6.%s0 [%5=%4+%2%T3],%0")
1542
1543 ;; HImode
1544
1545 (define_insn "*op_sidehi_biap"
1546   [(set (match_operand:HI 0 "register_operand" "=r,r")
1547         (match_operator:HI
1548          6 "cris_orthogonal_operator"
1549          [(match_operand:HI 1 "register_operand" "0,0")
1550           (mem:HI (plus:SI
1551                    (mult:SI (match_operand:SI 2 "register_operand" "r,r")
1552                             (match_operand:SI 3 "const_int_operand" "n,n"))
1553                    (match_operand:SI 4 "register_operand" "r,r")))]))
1554    (set (match_operand:SI 5 "register_operand" "=*4,r")
1555         (plus:SI (mult:SI (match_dup 2)
1556                           (match_dup 3))
1557                  (match_dup 4)))]
1558   "cris_side_effect_mode_ok (MULT, operands, 5, 4, 2, 3, 0)"
1559   "@
1560    #
1561    %x6.%s0 [%5=%4+%2%T3],%0")
1562
1563 ;; SImode
1564
1565 (define_insn "*op_sidesi_biap"
1566   [(set (match_operand:SI 0 "register_operand" "=r,r")
1567         (match_operator:SI
1568          6 "cris_orthogonal_operator"
1569          [(match_operand:SI 1 "register_operand" "0,0")
1570           (mem:SI (plus:SI
1571                    (mult:SI (match_operand:SI 2 "register_operand" "r,r")
1572                             (match_operand:SI 3 "const_int_operand" "n,n"))
1573                    (match_operand:SI 4 "register_operand" "r,r")))]))
1574    (set (match_operand:SI 5 "register_operand" "=*4,r")
1575         (plus:SI (mult:SI (match_dup 2)
1576                           (match_dup 3))
1577                  (match_dup 4)))]
1578   "cris_side_effect_mode_ok (MULT, operands, 5, 4, 2, 3, 0)"
1579   "@
1580    #
1581    %x6.%s0 [%5=%4+%2%T3],%0")
1582 \f
1583 ;; [rx=ry+i] ([%4=%2+%3])
1584 ;; FIXME: These could have anonymous mode for operand 0.
1585
1586 ;; QImode
1587
1588 (define_insn "*op_sideqi"
1589   [(set (match_operand:QI 0 "register_operand" "=r,r,r")
1590         (match_operator:QI
1591          5 "cris_orthogonal_operator"
1592          [(match_operand:QI 1 "register_operand" "0,0,0")
1593           (mem:QI (plus:SI
1594                    (match_operand:SI 2 "cris_bdap_operand" "%r,r,r")
1595                    (match_operand:SI 3 "cris_bdap_operand" "r>Rn,r,>Rn")))]))
1596    (set (match_operand:SI 4 "register_operand" "=*2,r,r")
1597         (plus:SI (match_dup 2)
1598                  (match_dup 3)))]
1599   "cris_side_effect_mode_ok (PLUS, operands, 4, 2, 3, -1, 0)"
1600   "*
1601 {
1602   if (which_alternative == 0
1603       && (GET_CODE (operands[3]) != CONST_INT
1604           || INTVAL (operands[3]) > 127
1605           || INTVAL (operands[3]) < -128
1606           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'N')
1607           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'J')))
1608     return \"#\";
1609   return \"%x5.%s0 [%4=%2%S3],%0\";
1610 }")
1611
1612 ;; HImode
1613
1614 (define_insn "*op_sidehi"
1615   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
1616         (match_operator:HI
1617          5 "cris_orthogonal_operator"
1618          [(match_operand:HI 1 "register_operand" "0,0,0")
1619           (mem:HI (plus:SI
1620                    (match_operand:SI 2 "cris_bdap_operand" "%r,r,r")
1621                    (match_operand:SI 3 "cris_bdap_operand" "r>Rn,r,>Rn")))]))
1622    (set (match_operand:SI 4 "register_operand" "=*2,r,r")
1623         (plus:SI (match_dup 2)
1624                  (match_dup 3)))]
1625   "cris_side_effect_mode_ok (PLUS, operands, 4, 2, 3, -1, 0)"
1626   "*
1627 {
1628   if (which_alternative == 0
1629       && (GET_CODE (operands[3]) != CONST_INT
1630           || INTVAL (operands[3]) > 127
1631           || INTVAL (operands[3]) < -128
1632           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'N')
1633           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'J')))
1634     return \"#\";
1635   return \"%x5.%s0 [%4=%2%S3],%0\";
1636 }")
1637
1638 ;; SImode
1639
1640 (define_insn "*op_sidesi"
1641   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1642         (match_operator:SI
1643          5 "cris_orthogonal_operator"
1644          [(match_operand:SI 1 "register_operand" "0,0,0")
1645           (mem:SI (plus:SI
1646                    (match_operand:SI 2 "cris_bdap_operand" "%r,r,r")
1647                    (match_operand:SI 3 "cris_bdap_operand" "r>Rn,r,>Rn")))]))
1648    (set (match_operand:SI 4 "register_operand" "=*2,r,r")
1649         (plus:SI (match_dup 2)
1650                  (match_dup 3)))]
1651   "cris_side_effect_mode_ok (PLUS, operands, 4, 2, 3, -1, 0)"
1652   "*
1653 {
1654   if (which_alternative == 0
1655       && (GET_CODE (operands[3]) != CONST_INT
1656           || INTVAL (operands[3]) > 127
1657           || INTVAL (operands[3]) < -128
1658           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'N')
1659           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'J')))
1660     return \"#\";
1661   return \"%x5.%s0 [%4=%2%S3],%0\";
1662 }")
1663 \f
1664 ;; To match all cases for commutative operations we may have to have the
1665 ;; following pattern for add, or & and.  I do not know really, but it does
1666 ;; not break anything.
1667 ;;
1668 ;; FIXME: This really ought to be checked.
1669 ;;
1670 ;; op.S [rx=ry+I],rz;
1671 ;;
1672 ;; [rx=ry+rz.S]
1673 ;; FIXME: These could have anonymous mode for operand 0.
1674
1675 ;; QImode
1676
1677 (define_insn "*op_swap_sideqi_biap"
1678   [(set (match_operand:QI 0 "register_operand" "=r,r")
1679         (match_operator:QI
1680          6 "cris_commutative_orth_op"
1681          [(mem:QI (plus:SI
1682                    (mult:SI (match_operand:SI 2 "register_operand" "r,r")
1683                             (match_operand:SI 3 "const_int_operand" "n,n"))
1684                    (match_operand:SI 4 "register_operand" "r,r")))
1685           (match_operand:QI 1 "register_operand" "0,0")]))
1686    (set (match_operand:SI 5 "register_operand" "=*4,r")
1687         (plus:SI (mult:SI (match_dup 2)
1688                           (match_dup 3))
1689                  (match_dup 4)))]
1690   "cris_side_effect_mode_ok (MULT, operands, 5, 4, 2, 3, 0)"
1691   "@
1692    #
1693    %x6.%s0 [%5=%4+%2%T3],%0")
1694
1695 ;; HImode
1696
1697 (define_insn "*op_swap_sidehi_biap"
1698   [(set (match_operand:HI 0 "register_operand" "=r,r")
1699         (match_operator:HI
1700          6 "cris_commutative_orth_op"
1701          [(mem:HI (plus:SI
1702                    (mult:SI (match_operand:SI 2 "register_operand" "r,r")
1703                             (match_operand:SI 3 "const_int_operand" "n,n"))
1704                    (match_operand:SI 4 "register_operand" "r,r")))
1705           (match_operand:HI 1 "register_operand" "0,0")]))
1706    (set (match_operand:SI 5 "register_operand" "=*4,r")
1707         (plus:SI (mult:SI (match_dup 2)
1708                           (match_dup 3))
1709                  (match_dup 4)))]
1710   "cris_side_effect_mode_ok (MULT, operands, 5, 4, 2, 3, 0)"
1711   "@
1712    #
1713    %x6.%s0 [%5=%4+%2%T3],%0")
1714
1715 ;; SImode
1716
1717 (define_insn "*op_swap_sidesi_biap"
1718   [(set (match_operand:SI 0 "register_operand" "=r,r")
1719         (match_operator:SI
1720          6 "cris_commutative_orth_op"
1721          [(mem:SI (plus:SI
1722                    (mult:SI (match_operand:SI 2 "register_operand" "r,r")
1723                             (match_operand:SI 3 "const_int_operand" "n,n"))
1724                    (match_operand:SI 4 "register_operand" "r,r")))
1725           (match_operand:SI 1 "register_operand" "0,0")]))
1726    (set (match_operand:SI 5 "register_operand" "=*4,r")
1727         (plus:SI (mult:SI (match_dup 2)
1728                           (match_dup 3))
1729                  (match_dup 4)))]
1730   "cris_side_effect_mode_ok (MULT, operands, 5, 4, 2, 3, 0)"
1731   "@
1732    #
1733    %x6.%s0 [%5=%4+%2%T3],%0")
1734 \f
1735 ;; [rx=ry+i] ([%4=%2+%3])
1736 ;; FIXME: These could have anonymous mode for operand 0.
1737
1738 ;; QImode
1739
1740 (define_insn "*op_swap_sideqi"
1741   [(set (match_operand:QI 0 "register_operand" "=r,r,r")
1742         (match_operator:QI
1743          5 "cris_commutative_orth_op"
1744          [(mem:QI
1745            (plus:SI (match_operand:SI 2 "cris_bdap_operand" "%r,r,r")
1746                     (match_operand:SI 3 "cris_bdap_operand" "r>Rn,r,>Rn")))
1747           (match_operand:QI 1 "register_operand" "0,0,0")]))
1748    (set (match_operand:SI 4 "register_operand" "=*2,r,r")
1749         (plus:SI (match_dup 2)
1750                  (match_dup 3)))]
1751   "cris_side_effect_mode_ok (PLUS, operands, 4, 2, 3, -1, 0)"
1752   "*
1753 {
1754   if (which_alternative == 0
1755       && (GET_CODE (operands[3]) != CONST_INT
1756           || INTVAL (operands[3]) > 127
1757           || INTVAL (operands[3]) < -128
1758           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'N')
1759           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'J')))
1760     return \"#\";
1761   return \"%x5.%s0 [%4=%2%S3],%0\";
1762 }")
1763
1764 ;; HImode
1765
1766 (define_insn "*op_swap_sidehi"
1767   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
1768         (match_operator:HI
1769          5 "cris_commutative_orth_op"
1770          [(mem:HI
1771            (plus:SI (match_operand:SI 2 "cris_bdap_operand" "%r,r,r")
1772                     (match_operand:SI 3 "cris_bdap_operand" "r>Rn,r,>Rn")))
1773           (match_operand:HI 1 "register_operand" "0,0,0")]))
1774    (set (match_operand:SI 4 "register_operand" "=*2,r,r")
1775         (plus:SI (match_dup 2)
1776                  (match_dup 3)))]
1777   "cris_side_effect_mode_ok (PLUS, operands, 4, 2, 3, -1, 0)"
1778   "*
1779 {
1780   if (which_alternative == 0
1781       && (GET_CODE (operands[3]) != CONST_INT
1782           || INTVAL (operands[3]) > 127
1783           || INTVAL (operands[3]) < -128
1784           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'N')
1785           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'J')))
1786     return \"#\";
1787   return \"%x5.%s0 [%4=%2%S3],%0\";
1788 }")
1789
1790 ;; SImode
1791
1792 (define_insn "*op_swap_sidesi"
1793   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1794         (match_operator:SI
1795          5 "cris_commutative_orth_op"
1796          [(mem:SI
1797            (plus:SI (match_operand:SI 2 "cris_bdap_operand" "%r,r,r")
1798                     (match_operand:SI 3 "cris_bdap_operand" "r>Rn,r,>Rn")))
1799           (match_operand:SI 1 "register_operand" "0,0,0")]))
1800    (set (match_operand:SI 4 "register_operand" "=*2,r,r")
1801         (plus:SI (match_dup 2)
1802                  (match_dup 3)))]
1803   "cris_side_effect_mode_ok (PLUS, operands, 4, 2, 3, -1, 0)"
1804   "*
1805 {
1806   if (which_alternative == 0
1807       && (GET_CODE (operands[3]) != CONST_INT
1808           || INTVAL (operands[3]) > 127
1809           || INTVAL (operands[3]) < -128
1810           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'N')
1811           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'J')))
1812     return \"#\";
1813   return \"%x5.%s0 [%4=%2%S3],%0\";
1814 }")
1815 \f
1816 ;; Add operations, standard names.
1817
1818 ;; Note that for the 'P' constraint, the high part can be -1 or 0.  We
1819 ;; output the insn through the 'A' output modifier as "adds.w" and "addq",
1820 ;; respectively.
1821 (define_insn "adddi3"
1822   [(set (match_operand:DI 0 "register_operand" "=r,r,r,&r,&r")
1823         (plus:DI (match_operand:DI 1 "register_operand" "%0,0,0,0,r")
1824                  (match_operand:DI 2 "general_operand" "J,N,P,g,!To")))]
1825   ""
1826   "@
1827    addq %2,%M0\;ax\;addq 0,%H0
1828    subq %n2,%M0\;ax\;subq 0,%H0
1829    add%e2.%z2 %2,%M0\;ax\;%A2 %H2,%H0
1830    add.d %M2,%M0\;ax\;add.d %H2,%H0
1831    add.d %M2,%M1,%M0\;ax\;add.d %H2,%H1,%H0")
1832
1833 (define_insn "addsi3"
1834   [(set (match_operand:SI 0 "register_operand"  "=r,r, r,r,r,r,r,  r")
1835         (plus:SI
1836          (match_operand:SI 1 "register_operand" "%0,0, 0,0,0,0,r,  r")
1837          (match_operand:SI 2 "general_operand"   "r,Q>,J,N,n,g,!To,0")))]
1838
1839 ;; The last constraint is due to that after reload, the '%' is not
1840 ;; honored, and canonicalization doesn't care about keeping the same
1841 ;; register as in destination.  This will happen after insn splitting.
1842 ;; gcc <= 2.7.2.  FIXME: Check for gcc-2.9x
1843
1844  ""
1845  "*
1846 {
1847   switch (which_alternative)
1848     {
1849     case 0:
1850     case 1:
1851       return \"add.d %2,%0\";
1852     case 2:
1853       return \"addq %2,%0\";
1854     case 3:
1855       return \"subq %n2,%0\";
1856     case 4:
1857       /* 'Known value', but not in -63..63.
1858          Check if addu/subu may be used.  */
1859       if (INTVAL (operands[2]) > 0)
1860         {
1861           if (INTVAL (operands[2]) < 256)
1862             return \"addu.b %2,%0\";
1863           if (INTVAL (operands[2]) < 65536)
1864             return \"addu.w %2,%0\";
1865         }
1866       else
1867         {
1868           if (INTVAL (operands[2]) >= -255)
1869             return \"subu.b %n2,%0\";
1870           if (INTVAL (operands[2]) >= -65535)
1871             return \"subu.w %n2,%0\";
1872         }
1873       return \"add.d %2,%0\";
1874     case 6:
1875       return \"add.d %2,%1,%0\";
1876     case 5:
1877       return \"add.d %2,%0\";
1878     case 7:
1879       return \"add.d %1,%0\";
1880     default:
1881       return \"BOGUS addsi %2+%1 to %0\";
1882     }
1883 }"
1884  [(set_attr "slottable" "yes,yes,yes,yes,no,no,no,yes")])
1885 \f
1886 (define_insn "addhi3"
1887   [(set (match_operand:HI 0 "register_operand"          "=r,r, r,r,r,r")
1888         (plus:HI (match_operand:HI 1 "register_operand" "%0,0, 0,0,0,r")
1889                  (match_operand:HI 2 "general_operand"   "r,Q>,J,N,g,!To")))]
1890   ""
1891   "@
1892    add.w %2,%0
1893    add.w %2,%0
1894    addq %2,%0
1895    subq %n2,%0
1896    add.w %2,%0
1897    add.w %2,%1,%0"
1898   [(set_attr "slottable" "yes,yes,yes,yes,no,no")
1899    (set_attr "cc" "normal,normal,clobber,clobber,normal,normal")])
1900
1901 (define_insn "addqi3"
1902   [(set (match_operand:QI 0 "register_operand"          "=r,r, r,r,r,r,r")
1903         (plus:QI (match_operand:QI 1 "register_operand" "%0,0, 0,0,0,0,r")
1904                  (match_operand:QI 2 "general_operand"   "r,Q>,J,N,O,g,!To")))]
1905   ""
1906   "@
1907    add.b %2,%0
1908    add.b %2,%0
1909    addq %2,%0
1910    subq %n2,%0
1911    subQ -%b2,%0
1912    add.b %2,%0
1913    add.b %2,%1,%0"
1914   [(set_attr "slottable" "yes,yes,yes,yes,yes,no,no")
1915    (set_attr "cc" "normal,normal,clobber,clobber,clobber,normal,normal")])
1916 \f
1917 ;; Subtract.
1918 ;;
1919 ;; Note that because of insn canonicalization these will *seldom* but
1920 ;; rarely be used with a known constant as an operand.
1921
1922 ;; Note that for the 'P' constraint, the high part can be -1 or 0.  We
1923 ;; output the insn through the 'D' output modifier as "subs.w" and "subq",
1924 ;; respectively.
1925 (define_insn "subdi3"
1926   [(set (match_operand:DI 0 "register_operand" "=r,r,r,&r,&r")
1927         (minus:DI (match_operand:DI 1 "register_operand" "0,0,0,0,r")
1928                   (match_operand:DI 2 "general_operand" "J,N,P,g,!To")))]
1929   ""
1930   "@
1931    subq %2,%M0\;ax\;subq 0,%H0
1932    addq %n2,%M0\;ax\;addq 0,%H0
1933    sub%e2.%z2 %2,%M0\;ax\;%D2 %H2,%H0
1934    sub.d %M2,%M0\;ax\;sub.d %H2,%H0
1935    sub.d %M2,%M1,%M0\;ax\;sub.d %H2,%H1,%H0")
1936
1937 (define_insn "subsi3"
1938   [(set (match_operand:SI 0 "register_operand" "=r,r, r,r,r,r,r,r")
1939         (minus:SI
1940          (match_operand:SI 1 "register_operand" "0,0, 0,0,0,0,0,r")
1941          (match_operand:SI 2 "general_operand"  "r,Q>,J,N,P,n,g,!To")))]
1942   ""
1943
1944 ;; This does not do the optimal: "addu.w 65535,r0" when %2 is negative.
1945 ;; But then again, %2 should not be negative.
1946
1947   "@
1948    sub.d %2,%0
1949    sub.d %2,%0
1950    subq %2,%0
1951    addq %n2,%0
1952    sub%e2.%z2 %2,%0
1953    sub.d %2,%0
1954    sub.d %2,%0
1955    sub.d %2,%1,%0"
1956   [(set_attr "slottable" "yes,yes,yes,yes,no,no,no,no")])
1957 \f
1958 (define_insn "subhi3"
1959   [(set (match_operand:HI 0 "register_operand"          "=r,r, r,r,r,r")
1960         (minus:HI (match_operand:HI 1 "register_operand" "0,0, 0,0,0,r")
1961                   (match_operand:HI 2 "general_operand"  "r,Q>,J,N,g,!To")))]
1962   ""
1963   "@
1964    sub.w %2,%0
1965    sub.w %2,%0
1966    subq %2,%0
1967    addq %n2,%0
1968    sub.w %2,%0
1969    sub.w %2,%1,%0"
1970   [(set_attr "slottable" "yes,yes,yes,yes,no,no")
1971    (set_attr "cc" "normal,normal,clobber,clobber,normal,normal")])
1972
1973 (define_insn "subqi3"
1974   [(set (match_operand:QI 0 "register_operand"          "=r,r, r,r,r,r")
1975         (minus:QI (match_operand:QI 1 "register_operand" "0,0, 0,0,0,r")
1976                   (match_operand:QI 2 "general_operand"  "r,Q>,J,N,g,!To")))]
1977   ""
1978   "@
1979    sub.b %2,%0
1980    sub.b %2,%0
1981    subq %2,%0
1982    addq %2,%0
1983    sub.b %2,%0
1984    sub.b %2,%1,%0"
1985   [(set_attr "slottable" "yes,yes,yes,yes,no,no")
1986    (set_attr "cc" "normal,normal,clobber,clobber,normal,normal")])
1987 \f
1988 ;; CRIS has some add/sub-with-sign/zero-extend instructions.
1989 ;;  Although these perform sign/zero-extension to SImode, they are
1990 ;; equally applicable for the HImode case.
1991 ;; FIXME: Check; GCC should handle the widening.
1992 ;;  Note that these must be located after the normal add/sub patterns,
1993 ;; so not to get constants into any less specific operands.
1994 ;;
1995 ;; Extend with add/sub and side-effect.
1996 ;;
1997 ;; ADDS/SUBS/ADDU/SUBU and BOUND, which needs a check for zero_extend
1998 ;;
1999 ;; adds/subs/addu/subu bound [rx=ry+rz.S]
2000 ;; FIXME: These could have anonymous mode for operand 0.
2001
2002 ;; QImode to HImode
2003 ;; FIXME: GCC should widen.
2004
2005 (define_insn "*extopqihi_side_biap"
2006   [(set (match_operand:HI 0 "register_operand" "=r,r")
2007         (match_operator:HI
2008          6 "cris_additive_operand_extend_operator"
2009          [(match_operand:HI 1 "register_operand" "0,0")
2010           (match_operator:HI
2011            7 "cris_extend_operator"
2012            [(mem:QI (plus:SI
2013                      (mult:SI (match_operand:SI 2 "register_operand" "r,r")
2014                               (match_operand:SI 3 "const_int_operand" "n,n"))
2015                      (match_operand:SI 4 "register_operand" "r,r")))])]))
2016    (set (match_operand:SI 5 "register_operand" "=*4,r")
2017         (plus:SI (mult:SI (match_dup 2)
2018                           (match_dup 3))
2019                  (match_dup 4)))]
2020   "cris_side_effect_mode_ok (MULT, operands, 5, 4, 2, 3, 0)"
2021   "@
2022    #
2023    %x6%e7.%m7 [%5=%4+%2%T3],%0")
2024
2025 ;; QImode to SImode
2026
2027 (define_insn "*extopqisi_side_biap"
2028   [(set (match_operand:SI 0 "register_operand" "=r,r")
2029         (match_operator:SI
2030          6 "cris_operand_extend_operator"
2031          [(match_operand:SI 1 "register_operand" "0,0")
2032           (match_operator:SI
2033            7 "cris_extend_operator"
2034            [(mem:QI (plus:SI
2035                      (mult:SI (match_operand:SI 2 "register_operand" "r,r")
2036                               (match_operand:SI 3 "const_int_operand" "n,n"))
2037                      (match_operand:SI 4 "register_operand" "r,r")))])]))
2038    (set (match_operand:SI 5 "register_operand" "=*4,r")
2039         (plus:SI (mult:SI (match_dup 2)
2040                           (match_dup 3))
2041                  (match_dup 4)))]
2042   "(GET_CODE (operands[6]) != UMIN || GET_CODE (operands[7]) == ZERO_EXTEND)
2043    && cris_side_effect_mode_ok (MULT, operands, 5, 4, 2, 3, 0)"
2044   "@
2045    #
2046    %x6%e7.%m7 [%5=%4+%2%T3],%0")
2047
2048 ;; HImode to SImode
2049
2050 (define_insn "*extophisi_side_biap"
2051   [(set (match_operand:SI 0 "register_operand" "=r,r")
2052         (match_operator:SI
2053          6 "cris_operand_extend_operator"
2054          [(match_operand:SI 1 "register_operand" "0,0")
2055           (match_operator:SI
2056            7 "cris_extend_operator"
2057            [(mem:HI (plus:SI
2058                      (mult:SI (match_operand:SI 2 "register_operand" "r,r")
2059                               (match_operand:SI 3 "const_int_operand" "n,n"))
2060                      (match_operand:SI 4 "register_operand" "r,r")))])]))
2061    (set (match_operand:SI 5 "register_operand" "=*4,r")
2062         (plus:SI (mult:SI (match_dup 2)
2063                           (match_dup 3))
2064                  (match_dup 4)))]
2065   "(GET_CODE (operands[6]) != UMIN || GET_CODE (operands[7]) == ZERO_EXTEND)
2066    && cris_side_effect_mode_ok (MULT, operands, 5, 4, 2, 3, 0)"
2067   "@
2068    #
2069    %x6%e7.%m7 [%5=%4+%2%T3],%0")
2070 \f
2071
2072 ;; [rx=ry+i]
2073 ;; FIXME: These could have anonymous mode for operand 0.
2074
2075 ;; QImode to HImode
2076
2077 (define_insn "*extopqihi_side"
2078   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
2079         (match_operator:HI
2080          5 "cris_additive_operand_extend_operator"
2081          [(match_operand:HI 1 "register_operand" "0,0,0")
2082           (match_operator:HI
2083            6 "cris_extend_operator"
2084            [(mem:QI
2085              (plus:SI (match_operand:SI 2 "cris_bdap_operand" "%r,r,r")
2086                       (match_operand:SI 3 "cris_bdap_operand" "r>Rn,r,>Rn")
2087                       ))])]))
2088    (set (match_operand:SI 4 "register_operand" "=*2,r,r")
2089         (plus:SI (match_dup 2)
2090                  (match_dup 3)))]
2091   "cris_side_effect_mode_ok (PLUS, operands, 4, 2, 3, -1, 0)"
2092   "*
2093 {
2094   if (which_alternative == 0
2095       && (GET_CODE (operands[3]) != CONST_INT
2096           || INTVAL (operands[3]) > 127
2097           || INTVAL (operands[3]) < -128
2098           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'N')
2099           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'J')))
2100     return \"#\";
2101   return \"%x5%e6.%m6 [%4=%2%S3],%0\";
2102 }")
2103
2104 ;; QImode to SImode
2105
2106 (define_insn "*extopqisi_side"
2107   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
2108         (match_operator:SI
2109          5 "cris_operand_extend_operator"
2110          [(match_operand:SI 1 "register_operand" "0,0,0")
2111           (match_operator:SI
2112            6 "cris_extend_operator"
2113            [(mem:QI
2114              (plus:SI (match_operand:SI 2 "cris_bdap_operand" "%r,r,r")
2115                       (match_operand:SI 3 "cris_bdap_operand" "r>Rn,r,>Rn")
2116                       ))])]))
2117    (set (match_operand:SI 4 "register_operand" "=*2,r,r")
2118         (plus:SI (match_dup 2)
2119                  (match_dup 3)))]
2120
2121   "(GET_CODE (operands[5]) != UMIN || GET_CODE (operands[6]) == ZERO_EXTEND)
2122    && cris_side_effect_mode_ok (PLUS, operands, 4, 2, 3, -1, 0)"
2123   "*
2124 {
2125   if (which_alternative == 0
2126       && (GET_CODE (operands[3]) != CONST_INT
2127           || INTVAL (operands[3]) > 127
2128           || INTVAL (operands[3]) < -128
2129           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'N')
2130           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'J')))
2131     return \"#\";
2132   return \"%x5%e6.%m6 [%4=%2%S3],%0\";
2133 }")
2134
2135 ;; HImode to SImode
2136
2137 (define_insn "*extophisi_side"
2138   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
2139         (match_operator:SI
2140          5 "cris_operand_extend_operator"
2141          [(match_operand:SI 1 "register_operand" "0,0,0")
2142           (match_operator:SI
2143            6 "cris_extend_operator"
2144            [(mem:HI
2145              (plus:SI (match_operand:SI 2 "cris_bdap_operand" "%r,r,r")
2146                       (match_operand:SI 3 "cris_bdap_operand" "r>Rn,r,>Rn")
2147                       ))])]))
2148    (set (match_operand:SI 4 "register_operand" "=*2,r,r")
2149         (plus:SI (match_dup 2)
2150                  (match_dup 3)))]
2151   "(GET_CODE (operands[5]) != UMIN || GET_CODE (operands[6]) == ZERO_EXTEND)
2152    && cris_side_effect_mode_ok (PLUS, operands, 4, 2, 3, -1, 0)"
2153   "*
2154 {
2155   if (which_alternative == 0
2156       && (GET_CODE (operands[3]) != CONST_INT
2157           || INTVAL (operands[3]) > 127
2158           || INTVAL (operands[3]) < -128
2159           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'N')
2160           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'J')))
2161     return \"#\";
2162   return \"%x5%e6.%m6 [%4=%2%S3],%0\";
2163 }")
2164 \f
2165
2166 ;; As with op.S we may have to add special pattern to match commuted
2167 ;; operands to adds/addu  and bound
2168 ;;
2169 ;; adds/addu/bound [rx=ry+rz.S]
2170
2171 ;; QImode to HImode
2172 ;; FIXME: GCC should widen.
2173
2174 (define_insn "*extopqihi_swap_side_biap"
2175   [(set (match_operand:HI 0 "register_operand" "=r,r")
2176         (plus:HI
2177          (match_operator:HI
2178           6 "cris_extend_operator"
2179           [(mem:QI (plus:SI
2180                     (mult:SI (match_operand:SI 2 "register_operand" "r,r")
2181                              (match_operand:SI 3 "const_int_operand" "n,n"))
2182                     (match_operand:SI 4 "register_operand" "r,r")))])
2183          (match_operand:HI 1 "register_operand" "0,0")))
2184    (set (match_operand:SI 5 "register_operand" "=*4,r")
2185         (plus:SI (mult:SI (match_dup 2)
2186                           (match_dup 3))
2187                  (match_dup 4)))]
2188   "cris_side_effect_mode_ok (MULT, operands, 5, 4, 2, 3, 0)"
2189   "@
2190    #
2191    add%e6.b [%5=%4+%2%T3],%0")
2192
2193 ;; QImode to SImode
2194
2195 (define_insn "*extopqisi_swap_side_biap"
2196   [(set (match_operand:SI 0 "register_operand" "=r,r")
2197         (match_operator:SI
2198          7 "cris_plus_or_bound_operator"
2199          [(match_operator:SI
2200            6 "cris_extend_operator"
2201            [(mem:QI (plus:SI
2202                      (mult:SI (match_operand:SI 2 "register_operand" "r,r")
2203                               (match_operand:SI 3 "const_int_operand" "n,n"))
2204                      (match_operand:SI 4 "register_operand" "r,r")))])
2205           (match_operand:SI 1 "register_operand" "0,0")]))
2206    (set (match_operand:SI 5 "register_operand" "=*4,r")
2207         (plus:SI (mult:SI (match_dup 2)
2208                           (match_dup 3))
2209                  (match_dup 4)))]
2210   "(GET_CODE (operands[7]) != UMIN || GET_CODE (operands[6]) == ZERO_EXTEND)
2211    && cris_side_effect_mode_ok (MULT, operands, 5, 4, 2, 3, 0)"
2212   "@
2213    #
2214    %x7%e6.%m6 [%5=%4+%2%T3],%0")
2215
2216 ;; HImode to SImode
2217 (define_insn "*extophisi_swap_side_biap"
2218   [(set (match_operand:SI 0 "register_operand" "=r,r")
2219         (match_operator:SI
2220          7 "cris_plus_or_bound_operator"
2221          [(match_operator:SI
2222            6 "cris_extend_operator"
2223            [(mem:HI (plus:SI
2224                      (mult:SI (match_operand:SI 2 "register_operand" "r,r")
2225                               (match_operand:SI 3 "const_int_operand" "n,n"))
2226                      (match_operand:SI 4 "register_operand" "r,r")))])
2227           (match_operand:SI 1 "register_operand" "0,0")]))
2228    (set (match_operand:SI 5 "register_operand" "=*4,r")
2229         (plus:SI (mult:SI (match_dup 2)
2230                           (match_dup 3))
2231                  (match_dup 4)))]
2232   "(GET_CODE (operands[7]) != UMIN || GET_CODE (operands[6]) == ZERO_EXTEND)
2233    && cris_side_effect_mode_ok (MULT, operands, 5, 4, 2, 3, 0)"
2234   "@
2235    #
2236    %x7%e6.%m6 [%5=%4+%2%T3],%0")
2237 \f
2238 ;; [rx=ry+i]
2239 ;; FIXME: These could have anonymous mode for operand 0.
2240 ;; FIXME: GCC should widen.
2241
2242 ;; QImode to HImode
2243
2244 (define_insn "*extopqihi_swap_side"
2245   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
2246         (plus:HI
2247          (match_operator:HI
2248           5 "cris_extend_operator"
2249           [(mem:QI (plus:SI
2250                     (match_operand:SI 2 "cris_bdap_operand" "%r,r,r")
2251                     (match_operand:SI 3 "cris_bdap_operand" "r>Rn,r,>Rn")))])
2252          (match_operand:HI 1 "register_operand" "0,0,0")))
2253    (set (match_operand:SI 4 "register_operand" "=*2,r,r")
2254         (plus:SI (match_dup 2)
2255                  (match_dup 3)))]
2256   "cris_side_effect_mode_ok (PLUS, operands, 4, 2, 3, -1, 0)"
2257   "*
2258 {
2259   if (which_alternative == 0
2260       && (GET_CODE (operands[3]) != CONST_INT
2261           || INTVAL (operands[3]) > 127
2262           || INTVAL (operands[3]) < -128
2263           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'N')
2264           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'J')))
2265     return \"#\";
2266   return \"add%e5.b [%4=%2%S3],%0\";
2267 }")
2268
2269 ;; QImode to SImode
2270
2271 (define_insn "*extopqisi_swap_side"
2272   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
2273         (match_operator:SI
2274          6 "cris_plus_or_bound_operator"
2275          [(match_operator:SI
2276            5 "cris_extend_operator"
2277            [(mem:QI (plus:SI
2278                      (match_operand:SI 2 "cris_bdap_operand" "%r,r,r")
2279                      (match_operand:SI 3 "cris_bdap_operand" "r>Rn,r,>Rn")))])
2280           (match_operand:SI 1 "register_operand" "0,0,0")]))
2281    (set (match_operand:SI 4 "register_operand" "=*2,r,r")
2282         (plus:SI (match_dup 2)
2283                  (match_dup 3)))]
2284   "(GET_CODE (operands[6]) != UMIN || GET_CODE (operands[5]) == ZERO_EXTEND)
2285    && cris_side_effect_mode_ok (PLUS, operands, 4, 2, 3, -1, 0)"
2286   "*
2287 {
2288   if (which_alternative == 0
2289       && (GET_CODE (operands[3]) != CONST_INT
2290           || INTVAL (operands[3]) > 127
2291           || INTVAL (operands[3]) < -128
2292           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'N')
2293           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'J')))
2294     return \"#\";
2295   return \"%x6%e5.%m5 [%4=%2%S3],%0\";
2296 }")
2297
2298 ;; HImode to SImode
2299
2300 (define_insn "*extophisi_swap_side"
2301   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
2302         (match_operator:SI
2303          6 "cris_plus_or_bound_operator"
2304          [(match_operator:SI
2305            5 "cris_extend_operator"
2306            [(mem:HI (plus:SI
2307                      (match_operand:SI 2 "cris_bdap_operand" "%r,r,r")
2308                      (match_operand:SI 3 "cris_bdap_operand" "r>Rn,r,>Rn")))])
2309           (match_operand:SI 1 "register_operand" "0,0,0")]))
2310    (set (match_operand:SI 4 "register_operand" "=*2,r,r")
2311         (plus:SI (match_dup 2)
2312                  (match_dup 3)))]
2313   "(GET_CODE (operands[6]) != UMIN || GET_CODE (operands[5]) == ZERO_EXTEND)
2314    && cris_side_effect_mode_ok (PLUS, operands, 4, 2, 3, -1, 0)"
2315   "*
2316 {
2317   if (which_alternative == 0
2318       && (GET_CODE (operands[3]) != CONST_INT
2319           || INTVAL (operands[3]) > 127
2320           || INTVAL (operands[3]) < -128
2321           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'N')
2322           || CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'J')))
2323     return \"#\";
2324   return \"%x6%e5.%m5 [%4=%2%S3],%0\";
2325 }")
2326 \f
2327 ;; Extend versions (zero/sign) of normal add/sub (no side-effects).
2328 ;; FIXME: These could have anonymous mode for operand 0.
2329
2330 ;; QImode to HImode
2331 ;; FIXME: GCC should widen.
2332
2333 (define_insn "*extopqihi"
2334   [(set (match_operand:HI 0 "register_operand" "=r,r,r,r")
2335         (match_operator:HI
2336          3 "cris_additive_operand_extend_operator"
2337          [(match_operand:HI 1 "register_operand" "0,0,0,r")
2338           (match_operator:HI
2339            4 "cris_extend_operator"
2340            [(match_operand:QI 2 "nonimmediate_operand" "r,Q>,m,!To")])]))]
2341   "GET_MODE_SIZE (GET_MODE (operands[0])) <= UNITS_PER_WORD
2342    && (operands[1] != frame_pointer_rtx || GET_CODE (operands[3]) != PLUS)"
2343   "@
2344    %x3%e4.%m4 %2,%0
2345    %x3%e4.%m4 %2,%0
2346    %x3%e4.%m4 %2,%0
2347    %x3%e4.%m4 %2,%1,%0"
2348   [(set_attr "slottable" "yes,yes,no,no")
2349    (set_attr "cc" "clobber")])
2350
2351 ;; QImode to SImode
2352
2353 (define_insn "*extopqisi"
2354   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
2355         (match_operator:SI
2356          3 "cris_operand_extend_operator"
2357          [(match_operand:SI 1 "register_operand" "0,0,0,r")
2358           (match_operator:SI
2359            4 "cris_extend_operator"
2360            [(match_operand:QI 2 "nonimmediate_operand" "r,Q>,m,!To")])]))]
2361   "(GET_CODE (operands[3]) != UMIN || GET_CODE (operands[4]) == ZERO_EXTEND)
2362    && GET_MODE_SIZE (GET_MODE (operands[0])) <= UNITS_PER_WORD
2363    && (operands[1] != frame_pointer_rtx || GET_CODE (operands[3]) != PLUS)"
2364   "@
2365    %x3%e4.%m4 %2,%0
2366    %x3%e4.%m4 %2,%0
2367    %x3%e4.%m4 %2,%0
2368    %x3%e4.%m4 %2,%1,%0"
2369   [(set_attr "slottable" "yes,yes,no,no")])
2370
2371 ;; HImode to SImode
2372
2373 (define_insn "*extophisi"
2374   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
2375         (match_operator:SI
2376          3 "cris_operand_extend_operator"
2377          [(match_operand:SI 1 "register_operand" "0,0,0,r")
2378           (match_operator:SI
2379            4 "cris_extend_operator"
2380            [(match_operand:HI 2 "nonimmediate_operand" "r,Q>,m,!To")])]))]
2381   "(GET_CODE (operands[3]) != UMIN || GET_CODE (operands[4]) == ZERO_EXTEND)
2382    && GET_MODE_SIZE (GET_MODE (operands[0])) <= UNITS_PER_WORD
2383    && (operands[1] != frame_pointer_rtx || GET_CODE (operands[3]) != PLUS)"
2384   "@
2385    %x3%e4.%m4 %2,%0
2386    %x3%e4.%m4 %2,%0
2387    %x3%e4.%m4 %2,%0
2388    %x3%e4.%m4 %2,%1,%0"
2389   [(set_attr "slottable" "yes,yes,no,no")])
2390 \f
2391
2392 ;; As with the side-effect patterns, may have to have swapped operands for add.
2393 ;; FIXME: *should* be redundant to gcc.
2394
2395 ;; QImode to HImode
2396
2397 (define_insn "*extopqihi_swap"
2398   [(set (match_operand:HI 0 "register_operand" "=r,r,r,r")
2399         (plus:HI
2400          (match_operator:HI
2401           3 "cris_extend_operator"
2402           [(match_operand:QI 2 "nonimmediate_operand" "r,Q>,m,!To")])
2403          (match_operand:HI 1 "register_operand" "0,0,0,r")))]
2404   "operands[1] != frame_pointer_rtx"
2405   "@
2406    add%e3.b %2,%0
2407    add%e3.b %2,%0
2408    add%e3.b %2,%0
2409    add%e3.b %2,%1,%0"
2410   [(set_attr "slottable" "yes,yes,no,no")
2411    (set_attr "cc" "clobber")])
2412
2413 ;; QImode to SImode
2414
2415 (define_insn "*extopqisi_swap"
2416   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
2417         (match_operator:SI
2418          4 "cris_plus_or_bound_operator"
2419          [(match_operator:SI
2420            3 "cris_extend_operator"
2421            [(match_operand:QI 2 "nonimmediate_operand" "r,Q>,m,!To")])
2422           (match_operand:SI 1 "register_operand" "0,0,0,r")]))]
2423   "(GET_CODE (operands[4]) != UMIN || GET_CODE (operands[3]) == ZERO_EXTEND)
2424    && operands[1] != frame_pointer_rtx"
2425   "@
2426    %x4%e3.%m3 %2,%0
2427    %x4%e3.%m3 %2,%0
2428    %x4%e3.%m3 %2,%0
2429    %x4%e3.%m3 %2,%1,%0"
2430   [(set_attr "slottable" "yes,yes,no,no")])
2431
2432 ;; HImode to SImode
2433
2434 (define_insn "*extophisi_swap"
2435   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
2436         (match_operator:SI
2437          4 "cris_plus_or_bound_operator"
2438          [(match_operator:SI
2439            3 "cris_extend_operator"
2440            [(match_operand:HI 2 "nonimmediate_operand" "r,Q>,m,!To")])
2441           (match_operand:SI 1 "register_operand" "0,0,0,r")]))]
2442   "(GET_CODE (operands[4]) != UMIN || GET_CODE (operands[3]) == ZERO_EXTEND)
2443    && operands[1] != frame_pointer_rtx"
2444   "@
2445    %x4%e3.%m3 %2,%0
2446    %x4%e3.%m3 %2,%0
2447    %x4%e3.%m3 %2,%0
2448    %x4%e3.%m3 %2,%1,%0"
2449   [(set_attr "slottable" "yes,yes,no,no")])
2450 \f
2451 ;; This is the special case when we use what corresponds to the
2452 ;; instruction above in "casesi".  Do *not* change it to use the generic
2453 ;; pattern and "REG 15" as pc; I did that and it led to madness and
2454 ;; maintenance problems: Instead of (as imagined) recognizing and removing
2455 ;; or replacing this pattern with something simpler, other variant
2456 ;; patterns were recognized or combined, including some prefix variants
2457 ;; where the value in pc is not that of the next instruction (which means
2458 ;; this instruction actually *is* special and *should* be marked as such).
2459 ;; When switching from the "generic pattern match" approach to this simpler
2460 ;; approach, there were insignificant differences in gcc, ipps and
2461 ;; product code, somehow due to scratching reload behind the ear or
2462 ;; something.  Testcase "gcc" looked .01% slower and 4 bytes bigger;
2463 ;; product code became .001% smaller but "looked better".  The testcase
2464 ;; "ipps" was just different at register allocation).
2465 ;;
2466 ;; Assumptions in the jump optimizer forces us to use IF_THEN_ELSE in this
2467 ;; pattern with the default-label as the else, with the "if" being
2468 ;; index-is-less-than the max number of cases plus one.  The default-label
2469 ;; is attached to the end of the case-table at time of output.
2470
2471 (define_insn "*casesi_adds_w"
2472   [(set (pc)
2473         (if_then_else
2474          (ltu (match_operand:SI 0 "register_operand" "r")
2475               (match_operand:SI 1 "const_int_operand" "n"))
2476          (plus:SI (sign_extend:SI
2477                    (mem:HI
2478                     (plus:SI (mult:SI (match_dup 0) (const_int 2))
2479                              (pc))))
2480                   (pc))
2481          (label_ref (match_operand 2 "" ""))))
2482    (use (label_ref (match_operand 3 "" "")))]
2483
2484   "operands[0] != frame_pointer_rtx"
2485
2486   "adds.w [$pc+%0.w],$pc"
2487   [(set_attr "cc" "clobber")])
2488 \f
2489 ;; Multiply instructions.
2490
2491 ;; Sometimes powers of 2 (which are normally canonicalized to a
2492 ;; left-shift) appear here, as a result of address reloading.
2493 ;; As a special, for values 3 and 5, we can match with an addi, so add those.
2494 ;;
2495 ;; FIXME: This may be unnecessary now.
2496 ;; Explicitly named for convenience of having a gen_... function.
2497
2498 (define_insn "addi_mul"
2499   [(set (match_operand:SI 0 "register_operand" "=r")
2500         (mult:SI
2501          (match_operand:SI 1 "register_operand" "%0")
2502          (match_operand:SI 2 "const_int_operand" "n")))]
2503   "operands[0] != frame_pointer_rtx
2504    && operands[1] != frame_pointer_rtx
2505    && GET_CODE (operands[2]) == CONST_INT
2506    && (INTVAL (operands[2]) == 2
2507        || INTVAL (operands[2]) == 4 || INTVAL (operands[2]) == 3
2508        || INTVAL (operands[2]) == 5)"
2509   "*
2510 {
2511   if (INTVAL (operands[2]) == 2)
2512     return \"lslq 1,%0\";
2513   else if (INTVAL (operands[2]) == 4)
2514     return \"lslq 2,%0\";
2515   else if (INTVAL (operands[2]) == 3)
2516     return \"addi %0.w,%0\";
2517   else if (INTVAL (operands[2]) == 5)
2518     return \"addi %0.d,%0\";
2519   return \"BAD: adr_mulsi: %0=%1*%2\";
2520 }"
2521 [(set_attr "slottable" "yes")
2522  ;; No flags are changed if this insn is "addi", but it does not seem
2523  ;; worth the trouble to distinguish that to the lslq cases.
2524  (set_attr "cc" "clobber")])
2525
2526 ;; The addi insn as it is normally used.
2527
2528 (define_insn "*addi"
2529   [(set (match_operand:SI 0 "register_operand" "=r")
2530         (plus:SI
2531          (mult:SI (match_operand:SI 2 "register_operand" "r")
2532                   (match_operand:SI 3 "const_int_operand" "n"))
2533          (match_operand:SI 1 "register_operand" "0")))]
2534   "operands[0] != frame_pointer_rtx
2535    && operands[1] != frame_pointer_rtx
2536    && GET_CODE (operands[3]) == CONST_INT
2537    && (INTVAL (operands[3]) == 1
2538        || INTVAL (operands[3]) == 2 || INTVAL (operands[3]) == 4)"
2539   "addi %2%T3,%0"
2540   [(set_attr "slottable" "yes")
2541    (set_attr "cc" "none")])
2542
2543 ;; The mstep instruction.  Probably not useful by itself; it's to
2544 ;; non-linear wrt. the other insns.  We used to expand to it, so at least
2545 ;; it's correct.
2546
2547 (define_insn "mstep_shift"
2548   [(set (match_operand:SI 0 "register_operand" "=r")
2549         (if_then_else:SI
2550          (lt:SI (cc0) (const_int 0))
2551          (plus:SI (ashift:SI (match_operand:SI 1 "register_operand" "0")
2552                              (const_int 1))
2553                   (match_operand:SI 2 "register_operand" "r"))
2554          (ashift:SI (match_operand:SI 3 "register_operand" "0")
2555                     (const_int 1))))]
2556   ""
2557   "mstep %2,%0"
2558   [(set_attr "slottable" "yes")])
2559
2560 ;; When illegitimate addresses are legitimized, sometimes gcc forgets
2561 ;; to canonicalize the multiplications.
2562 ;;
2563 ;; FIXME: Check gcc > 2.7.2, remove and possibly fix in gcc.
2564
2565 (define_insn "mstep_mul"
2566   [(set (match_operand:SI 0 "register_operand" "=r")
2567         (if_then_else:SI
2568          (lt:SI (cc0) (const_int 0))
2569          (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "0")
2570                            (const_int 2))
2571                   (match_operand:SI 2 "register_operand" "r"))
2572          (mult:SI (match_operand:SI 3 "register_operand" "0")
2573                   (const_int 2))))]
2574   "operands[0] != frame_pointer_rtx
2575    && operands[1] != frame_pointer_rtx
2576    && operands[2] != frame_pointer_rtx
2577    && operands[3] != frame_pointer_rtx"
2578   "mstep %2,%0"
2579   [(set_attr "slottable" "yes")])
2580
2581 (define_insn "umulhisi3"
2582   [(set (match_operand:SI 0 "register_operand" "=r")
2583         (mult:SI
2584          (zero_extend:SI (match_operand:HI 1 "register_operand" "%0"))
2585          (zero_extend:SI (match_operand:HI 2 "register_operand" "r"))))
2586    (clobber (match_scratch:SI 3 "=h"))]
2587   "TARGET_HAS_MUL_INSNS"
2588   "%!mulu.w %2,%0"
2589   [(set (attr "slottable")
2590         (if_then_else (ne (symbol_ref "TARGET_MUL_BUG") (const_int 0))
2591                       (const_string "no")
2592                       (const_string "yes")))
2593    ;; Just N unusable here, but let's be safe.
2594    (set_attr "cc" "clobber")])
2595
2596 (define_insn "umulqihi3"
2597   [(set (match_operand:HI 0 "register_operand" "=r")
2598         (mult:HI
2599          (zero_extend:HI (match_operand:QI 1 "register_operand" "%0"))
2600          (zero_extend:HI (match_operand:QI 2 "register_operand" "r"))))
2601    (clobber (match_scratch:SI 3 "=h"))]
2602   "TARGET_HAS_MUL_INSNS"
2603   "%!mulu.b %2,%0"
2604   [(set (attr "slottable")
2605         (if_then_else (ne (symbol_ref "TARGET_MUL_BUG") (const_int 0))
2606                       (const_string "no")
2607                       (const_string "yes")))
2608    ;; Not exactly sure, but let's be safe.
2609    (set_attr "cc" "clobber")])
2610
2611 ;; Note that gcc does not make use of such a thing as umulqisi3.  It gets
2612 ;; confused and will erroneously use it instead of umulhisi3, failing (at
2613 ;; least) gcc.c-torture/execute/arith-rand.c at all optimization levels.
2614 ;; Inspection of optab code shows that there must be only one widening
2615 ;; multiplication per mode widened to.
2616
2617 (define_insn "mulsi3"
2618   [(set (match_operand:SI 0 "register_operand" "=r")
2619         (mult:SI (match_operand:SI 1 "register_operand" "%0")
2620                  (match_operand:SI 2 "register_operand" "r")))
2621    (clobber (match_scratch:SI 3 "=h"))]
2622   "TARGET_HAS_MUL_INSNS"
2623   "%!muls.d %2,%0"
2624   [(set (attr "slottable")
2625         (if_then_else (ne (symbol_ref "TARGET_MUL_BUG") (const_int 0))
2626                       (const_string "no")
2627                       (const_string "yes")))
2628    ;; Just N unusable here, but let's be safe.
2629    (set_attr "cc" "clobber")])
2630 \f
2631 ;; A few multiply variations.
2632
2633 ;; This really extends to SImode, so cc should be considered clobbered.
2634
2635 (define_insn "mulqihi3"
2636   [(set (match_operand:HI 0 "register_operand" "=r")
2637         (mult:HI
2638          (sign_extend:HI (match_operand:QI 1 "register_operand" "%0"))
2639          (sign_extend:HI (match_operand:QI 2 "register_operand" "r"))))
2640    (clobber (match_scratch:SI 3 "=h"))]
2641   "TARGET_HAS_MUL_INSNS"
2642   "%!muls.b %2,%0"
2643   [(set (attr "slottable")
2644         (if_then_else (ne (symbol_ref "TARGET_MUL_BUG") (const_int 0))
2645                       (const_string "no")
2646                       (const_string "yes")))
2647    (set_attr "cc" "clobber")])
2648
2649 (define_insn "mulhisi3"
2650   [(set (match_operand:SI 0 "register_operand" "=r")
2651         (mult:SI
2652          (sign_extend:SI (match_operand:HI 1 "register_operand" "%0"))
2653          (sign_extend:SI (match_operand:HI 2 "register_operand" "r"))))
2654    (clobber (match_scratch:SI 3 "=h"))]
2655   "TARGET_HAS_MUL_INSNS"
2656   "%!muls.w %2,%0"
2657   [(set (attr "slottable")
2658         (if_then_else (ne (symbol_ref "TARGET_MUL_BUG") (const_int 0))
2659                       (const_string "no")
2660                       (const_string "yes")))
2661    ;; Just N unusable here, but let's be safe.
2662    (set_attr "cc" "clobber")])
2663
2664 ;; When needed, we can get the high 32 bits from the overflow
2665 ;; register.  We don't care to split and optimize these.
2666 ;;
2667 ;; Note that cc0 is still valid after the move-from-overflow-register
2668 ;; insn; no special precaution need to be taken in cris_notice_update_cc.
2669
2670 (define_insn "mulsidi3"
2671   [(set (match_operand:DI 0 "register_operand" "=r")
2672         (mult:DI
2673          (sign_extend:DI (match_operand:SI 1 "register_operand" "%0"))
2674          (sign_extend:DI (match_operand:SI 2 "register_operand" "r"))))
2675    (clobber (match_scratch:SI 3 "=h"))]
2676   "TARGET_HAS_MUL_INSNS"
2677   "%!muls.d %2,%M0\;move $mof,%H0")
2678
2679 (define_insn "umulsidi3"
2680   [(set (match_operand:DI 0 "register_operand" "=r")
2681         (mult:DI
2682          (zero_extend:DI (match_operand:SI 1 "register_operand" "%0"))
2683          (zero_extend:DI (match_operand:SI 2 "register_operand" "r"))))
2684    (clobber (match_scratch:SI 3 "=h"))]
2685   "TARGET_HAS_MUL_INSNS"
2686   "%!mulu.d %2,%M0\;move $mof,%H0")
2687
2688 ;; These two patterns may be expressible by other means, perhaps by making
2689 ;; [u]?mulsidi3 a define_expand.
2690
2691 ;; Due to register allocation braindamage, the clobber 1,2 alternatives
2692 ;; cause a move into the clobbered register *before* the insn, then
2693 ;; after the insn, mof is moved too, rather than the clobber assigned
2694 ;; the last mof target.  This became apparent when making MOF and SRP
2695 ;; visible registers, with the necessary tweak to smulsi3_highpart.
2696 ;; Because these patterns are used in division by constants, that damage
2697 ;; is visible (ipps regression tests).  Therefore the last two
2698 ;; alternatives, "helping" reload to avoid an unnecessary move, but
2699 ;; punished by force of one "?".  Check code from "int d (int a) {return
2700 ;; a / 1000;}" and unsigned.  FIXME: Comment above was for 3.2, revisit.
2701
2702 (define_insn "smulsi3_highpart"
2703   [(set (match_operand:SI 0 "nonimmediate_operand" "=h,h,?r,?r")
2704         (truncate:SI
2705          (lshiftrt:DI
2706           (mult:DI
2707            (sign_extend:DI (match_operand:SI 1 "register_operand" "r,r,0,r"))
2708            (sign_extend:DI (match_operand:SI 2 "register_operand" "r,r,r,0")))
2709           (const_int 32))))
2710    (clobber (match_scratch:SI 3 "=1,2,h,h"))]
2711   "TARGET_HAS_MUL_INSNS"
2712   "@
2713    %!muls.d %2,%1
2714    .error 'untested assembly generated by GCC (smulsi3_highpart): muls.d %1,%2'
2715    %!muls.d %2,%1\;move $mof,%0
2716    %!muls.d %1,%2\;move $mof,%0"
2717   [(set_attr "slottable" "yes,yes,no,no")
2718    (set_attr "cc" "clobber")])
2719
2720 (define_insn "umulsi3_highpart"
2721   [(set (match_operand:SI 0 "register_operand" "=h,h,?r,?r")
2722         (truncate:SI
2723          (lshiftrt:DI
2724           (mult:DI
2725            (zero_extend:DI (match_operand:SI 1 "register_operand" "r,r,0,r"))
2726            (zero_extend:DI (match_operand:SI 2 "register_operand" "r,r,r,0")))
2727           (const_int 32))))
2728    (clobber (match_scratch:SI 3 "=1,2,h,h"))]
2729   "TARGET_HAS_MUL_INSNS"
2730   "@
2731    %!mulu.d %2,%1
2732    .error 'untested assembly generated by GCC (umulsi3_highpart): mulu.d %1,%2'
2733    %!mulu.d %2,%1\;move $mof,%0
2734    %!mulu.d %1,%2\;move $mof,%0"
2735   [(set_attr "slottable" "yes,yes,no,no")
2736    (set_attr "cc" "clobber")])
2737 \f
2738 ;; Divide and modulus instructions.  CRIS only has a step instruction.
2739
2740 (define_insn "dstep_shift"
2741   [(set (match_operand:SI 0 "register_operand" "=r")
2742         (if_then_else:SI
2743          (geu:SI (ashift:SI (match_operand:SI 1 "register_operand" "0")
2744                             (const_int 1))
2745               (match_operand:SI 2 "register_operand" "r"))
2746          (minus:SI (ashift:SI (match_operand:SI 3 "register_operand" "0")
2747                         (const_int 1))
2748                    (match_operand:SI 4 "register_operand" "2"))
2749          (ashift:SI (match_operand:SI 5 "register_operand" "0")
2750                         (const_int 1))))]
2751   ""
2752   "dstep %2,%0"
2753   [(set_attr "slottable" "yes")])
2754
2755 ;; Here's a variant with mult instead of ashift.
2756 ;;
2757 ;; FIXME: This should be investigated.  Which one matches through combination?
2758
2759 (define_insn "dstep_mul"
2760   [(set (match_operand:SI 0 "register_operand" "=r")
2761         (if_then_else:SI
2762          (geu:SI (mult:SI (match_operand:SI 1 "register_operand" "0")
2763                           (const_int 2))
2764               (match_operand:SI 2 "register_operand" "r"))
2765          (minus:SI (mult:SI (match_operand:SI 3 "register_operand" "0")
2766                             (const_int 2))
2767                    (match_operand:SI 4 "register_operand" "2"))
2768          (mult:SI (match_operand:SI 5 "register_operand" "0")
2769                   (const_int 2))))]
2770   "operands[0] != frame_pointer_rtx
2771    && operands[1] != frame_pointer_rtx
2772    && operands[2] != frame_pointer_rtx
2773    && operands[3] != frame_pointer_rtx"
2774   "dstep %2,%0"
2775   [(set_attr "slottable" "yes")])
2776 \f
2777 ;; Logical operators.
2778
2779 ;; Bitwise "and".
2780
2781 ;; There is no use in defining "anddi3", because gcc can expand this by
2782 ;; itself, and make reasonable code without interference.
2783
2784 ;; If the first operand is memory or a register and is the same as the
2785 ;; second operand, and the third operand is -256 or -65536, we can use
2786 ;; CLEAR instead.  Or, if the first operand is a register, and the third
2787 ;; operand is 255 or 65535, we can zero_extend.
2788 ;; GCC isn't smart enough to recognize these cases (yet), and they seem
2789 ;; to be common enough to be worthwhile.
2790 ;; FIXME: This should be made obsolete.
2791
2792 (define_expand "andsi3"
2793   [(set (match_operand:SI 0 "nonimmediate_operand"         "")
2794         (and:SI (match_operand:SI 1 "nonimmediate_operand" "")
2795                 (match_operand:SI 2 "general_operand"    "")))]
2796   ""
2797   "
2798 {
2799   if (! (GET_CODE (operands[2]) == CONST_INT
2800          && (((INTVAL (operands[2]) == -256
2801                || INTVAL (operands[2]) == -65536)
2802               && rtx_equal_p (operands[1], operands[0]))
2803              || ((INTVAL (operands[2]) == 255
2804                   || INTVAL (operands[2]) == 65535)
2805                  && REG_P (operands[0])))))
2806     {
2807       /* Make intermediate steps if operand0 is not a register or
2808          operand1 is not a register, and hope that the reload pass will
2809          make something useful out of it.  Note that the operands are
2810          *not* canonicalized.  For the moment, I chicken out on this,
2811          because all or most ports do not describe 'and' with
2812          canonicalized operands, and I seem to remember magic in reload,
2813          checking that operand1 has constraint '%0', in which case
2814          operand0 and operand1 must have similar predicates.
2815          FIXME: Investigate.  */
2816       rtx reg0 = REG_P (operands[0]) ? operands[0] : gen_reg_rtx (SImode);
2817       rtx reg1 = operands[1];
2818
2819       if (! REG_P (reg1))
2820         {
2821           emit_move_insn (reg0, reg1);
2822           reg1 = reg0;
2823         }
2824
2825       emit_insn (gen_rtx_SET (SImode, reg0,
2826                           gen_rtx_AND (SImode, reg1, operands[2])));
2827
2828       /* Make sure we get the right *final* destination.  */
2829       if (! REG_P (operands[0]))
2830         emit_move_insn (operands[0], reg0);
2831
2832       DONE;
2833     }
2834 }")
2835
2836 ;; Some special cases of andsi3.
2837
2838 (define_insn "*andsi_movu"
2839   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
2840         (and:SI (match_operand:SI 1 "nonimmediate_operand" "%r,Q,To")
2841                 (match_operand:SI 2 "const_int_operand" "n,n,n")))]
2842   "(INTVAL (operands[2]) == 255 || INTVAL (operands[2]) == 65535)
2843    && (GET_CODE (operands[1]) != MEM || ! MEM_VOLATILE_P (operands[1]))"
2844   "movu.%z2 %1,%0"
2845   [(set_attr "slottable" "yes,yes,no")])
2846
2847 (define_insn "*andsi_clear"
2848   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,Q,Q,To,To")
2849         (and:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0,0,0,0")
2850                 (match_operand:SI 2 "const_int_operand" "P,n,P,n,P,n")))]
2851   "(INTVAL (operands[2]) == -65536 || INTVAL (operands[2]) == -256)
2852    && (GET_CODE (operands[0]) != MEM || ! MEM_VOLATILE_P (operands[0]))"
2853   "@
2854    cLear.b %0
2855    cLear.w %0
2856    cLear.b %0
2857    cLear.w %0
2858    cLear.b %0
2859    cLear.w %0"
2860   [(set_attr "slottable" "yes,yes,yes,yes,no,no")
2861    (set_attr "cc" "none")])
2862
2863 ;; This is a catch-all pattern, taking care of everything that was not
2864 ;; matched in the insns above.
2865 ;;
2866 ;; Sidenote: the tightening from "nonimmediate_operand" to
2867 ;; "register_operand" for operand 1 actually increased the register
2868 ;; pressure (worse code).  That will hopefully change with an
2869 ;; improved reload pass.
2870
2871 (define_insn "*expanded_andsi"
2872   [(set (match_operand:SI 0 "register_operand"         "=r,r,r, r,r")
2873         (and:SI (match_operand:SI 1 "register_operand" "%0,0,0, 0,r")
2874                 (match_operand:SI 2 "general_operand"   "I,r,Q>,g,!To")))]
2875   ""
2876   "@
2877    andq %2,%0
2878    and.d %2,%0
2879    and.d %2,%0
2880    and.d %2,%0
2881    and.d %2,%1,%0"
2882   [(set_attr "slottable" "yes,yes,yes,no,no")])
2883 \f
2884 ;; For both QI and HI we may use the quick patterns.  This results in
2885 ;; useless condition codes, but that is used rarely enough for it to
2886 ;; normally be a win (could check ahead for use of cc0, but seems to be
2887 ;; more pain than win).
2888
2889 ;; FIXME: See note for andsi3
2890
2891 (define_expand "andhi3"
2892   [(set (match_operand:HI 0 "nonimmediate_operand" "")
2893         (and:HI (match_operand:HI 1 "nonimmediate_operand" "")
2894                 (match_operand:HI 2 "general_operand"  "")))]
2895   ""
2896   "
2897 {
2898   if (! (GET_CODE (operands[2]) == CONST_INT
2899          && (((INTVAL (operands[2]) == -256
2900                || INTVAL (operands[2]) == 65280)
2901               && rtx_equal_p (operands[1], operands[0]))
2902              || (INTVAL (operands[2]) == 255
2903                  && REG_P (operands[0])))))
2904     {
2905       /* See comment for andsi3.  */
2906       rtx reg0 = REG_P (operands[0]) ? operands[0] : gen_reg_rtx (HImode);
2907       rtx reg1 = operands[1];
2908
2909       if (! REG_P (reg1))
2910         {
2911           emit_move_insn (reg0, reg1);
2912           reg1 = reg0;
2913         }
2914
2915       emit_insn (gen_rtx_SET (HImode, reg0,
2916                           gen_rtx_AND (HImode, reg1, operands[2])));
2917
2918       /* Make sure we get the right destination.  */
2919       if (! REG_P (operands[0]))
2920         emit_move_insn (operands[0], reg0);
2921
2922       DONE;
2923     }
2924 }")
2925
2926 ;; Some fast andhi3 special cases.
2927
2928 (define_insn "*andhi_movu"
2929   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
2930         (and:HI (match_operand:HI 1 "nonimmediate_operand" "r,Q,To")
2931                 (const_int 255)))]
2932   "GET_CODE (operands[1]) != MEM || ! MEM_VOLATILE_P (operands[1])"
2933   "mOvu.b %1,%0"
2934   [(set_attr "slottable" "yes,yes,no")])
2935
2936 (define_insn "*andhi_clear"
2937   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,Q,To")
2938         (and:HI (match_operand:HI 1 "nonimmediate_operand" "0,0,0")
2939                 (const_int -256)))]
2940   "GET_CODE (operands[0]) != MEM || ! MEM_VOLATILE_P (operands[0])"
2941   "cLear.b %0"
2942   [(set_attr "slottable" "yes,yes,no")
2943    (set_attr "cc" "none")])
2944
2945 ;; Catch-all andhi3 pattern.
2946
2947 (define_insn "*expanded_andhi"
2948   [(set (match_operand:HI 0 "register_operand"         "=r,r,r, r,r,r,r")
2949         (and:HI (match_operand:HI 1 "register_operand" "%0,0,0, 0,0,0,r")
2950                 (match_operand:HI 2 "general_operand"   "I,r,Q>,L,O,g,!To")))]
2951
2952 ;; Sidenote: the tightening from "general_operand" to
2953 ;; "register_operand" for operand 1 actually increased the register
2954 ;; pressure (worse code).  That will hopefully change with an
2955 ;; improved reload pass.
2956
2957   ""
2958   "@
2959    andq %2,%0
2960    and.w %2,%0
2961    and.w %2,%0
2962    and.w %2,%0
2963    anDq %b2,%0
2964    and.w %2,%0
2965    and.w %2,%1,%0"
2966   [(set_attr "slottable" "yes,yes,yes,no,yes,no,no")
2967    (set_attr "cc" "clobber,normal,normal,normal,clobber,normal,normal")])
2968
2969 ;; A strict_low_part pattern.
2970
2971 (define_insn "*andhi_lowpart"
2972   [(set (strict_low_part
2973          (match_operand:HI 0 "register_operand"        "=r,r, r,r,r,r"))
2974         (and:HI (match_operand:HI 1 "register_operand" "%0,0, 0,0,0,r")
2975                 (match_operand:HI 2 "general_operand"   "r,Q>,L,O,g,!To")))]
2976   ""
2977   "@
2978    and.w %2,%0
2979    and.w %2,%0
2980    and.w %2,%0
2981    anDq %b2,%0
2982    and.w %2,%0
2983    and.w %2,%1,%0"
2984   [(set_attr "slottable" "yes,yes,no,yes,no,no")
2985    (set_attr "cc" "normal,normal,normal,clobber,normal,normal")])
2986 \f
2987 (define_insn "andqi3"
2988   [(set (match_operand:QI 0 "register_operand"         "=r,r,r, r,r,r")
2989         (and:QI (match_operand:QI 1 "register_operand" "%0,0,0, 0,0,r")
2990                 (match_operand:QI 2 "general_operand"   "I,r,Q>,O,g,!To")))]
2991   ""
2992   "@
2993    andq %2,%0
2994    and.b %2,%0
2995    and.b %2,%0
2996    andQ %b2,%0
2997    and.b %2,%0
2998    and.b %2,%1,%0"
2999   [(set_attr "slottable" "yes,yes,yes,yes,no,no")
3000    (set_attr "cc" "clobber,normal,normal,clobber,normal,normal")])
3001
3002 (define_insn "*andqi_lowpart"
3003   [(set (strict_low_part
3004          (match_operand:QI 0 "register_operand"        "=r,r, r,r,r"))
3005         (and:QI (match_operand:QI 1 "register_operand" "%0,0, 0,0,r")
3006                 (match_operand:QI 2 "general_operand"   "r,Q>,O,g,!To")))]
3007   ""
3008   "@
3009    and.b %2,%0
3010    and.b %2,%0
3011    andQ %b2,%0
3012    and.b %2,%0
3013    and.b %2,%1,%0"
3014   [(set_attr "slottable" "yes,yes,yes,no,no")
3015    (set_attr "cc" "normal,normal,clobber,normal,normal")])
3016 \f
3017 ;; Bitwise or.
3018
3019 ;; Same comment as anddi3 applies here - no need for such a pattern.
3020
3021 ;; It seems there's no need to jump through hoops to get good code such as
3022 ;; with andsi3.
3023
3024 (define_insn "iorsi3"
3025   [(set (match_operand:SI 0 "register_operand"         "=r,r,r, r,r,r")
3026         (ior:SI (match_operand:SI 1 "register_operand" "%0,0,0, 0,0,r")
3027                 (match_operand:SI 2 "general_operand"  "I, r,Q>,n,g,!To")))]
3028   ""
3029   "@
3030    orq %2,%0
3031    or.d %2,%0
3032    or.d %2,%0
3033    oR.%s2 %2,%0
3034    or.d %2,%0
3035    or.d %2,%1,%0"
3036   [(set_attr "slottable" "yes,yes,yes,no,no,no")
3037    (set_attr "cc" "normal,normal,normal,clobber,normal,normal")])
3038
3039 (define_insn "iorhi3"
3040   [(set (match_operand:HI 0 "register_operand"         "=r,r,r, r,r,r,r")
3041         (ior:HI (match_operand:HI 1 "register_operand" "%0,0,0, 0,0,0,r")
3042                 (match_operand:HI 2 "general_operand"   "I,r,Q>,L,O,g,!To")))]
3043   ""
3044   "@
3045    orq %2,%0
3046    or.w %2,%0
3047    or.w %2,%0
3048    or.w %2,%0
3049    oRq %b2,%0
3050    or.w %2,%0
3051    or.w %2,%1,%0"
3052   [(set_attr "slottable" "yes,yes,yes,no,yes,no,no")
3053    (set_attr "cc" "clobber,normal,normal,normal,clobber,normal,normal")])
3054
3055 (define_insn "iorqi3"
3056   [(set (match_operand:QI 0 "register_operand"         "=r,r,r, r,r,r")
3057         (ior:QI (match_operand:QI 1 "register_operand" "%0,0,0, 0,0,r")
3058                 (match_operand:QI 2 "general_operand"   "I,r,Q>,O,g,!To")))]
3059   ""
3060   "@
3061    orq %2,%0
3062    or.b %2,%0
3063    or.b %2,%0
3064    orQ %b2,%0
3065    or.b %2,%0
3066    or.b %2,%1,%0"
3067   [(set_attr "slottable" "yes,yes,yes,yes,no,no")
3068    (set_attr "cc" "clobber,normal,normal,clobber,normal,normal")])
3069 \f
3070 ;; Exclusive-or
3071
3072 ;; See comment about "anddi3" for xordi3 - no need for such a pattern.
3073
3074 (define_insn "xorsi3"
3075   [(set (match_operand:SI 0 "register_operand" "=r")
3076         (xor:SI (match_operand:SI 1 "register_operand" "%0")
3077                 (match_operand:SI 2 "register_operand" "r")))]
3078   ""
3079   "xor %2,%0"
3080   [(set_attr "slottable" "yes")])
3081
3082 (define_insn "xorhi3"
3083   [(set (match_operand:HI 0 "register_operand" "=r")
3084         (xor:HI (match_operand:HI 1 "register_operand" "%0")
3085                 (match_operand:HI 2 "register_operand" "r")))]
3086   ""
3087   "xor %2,%0"
3088   [(set_attr "slottable" "yes")
3089    (set_attr "cc" "clobber")])
3090
3091 (define_insn "xorqi3"
3092   [(set (match_operand:QI 0 "register_operand" "=r")
3093         (xor:QI (match_operand:QI 1 "register_operand" "%0")
3094                 (match_operand:QI 2 "register_operand" "r")))]
3095   ""
3096   "xor %2,%0"
3097   [(set_attr "slottable" "yes")
3098    (set_attr "cc" "clobber")])
3099 \f
3100 ;; Negation insns.
3101
3102 ;; Questionable use, here mostly as a (slightly usable) define_expand
3103 ;; example.
3104
3105 (define_expand "negsf2"
3106   [(set (match_dup 2)
3107         (match_dup 3))
3108    (parallel [(set (match_operand:SF 0 "register_operand" "=r")
3109                    (neg:SF (match_operand:SF 1
3110                             "register_operand" "0")))
3111               (use (match_dup 2))])]
3112   ""
3113   "
3114 {
3115   operands[2] = gen_reg_rtx (SImode);
3116   operands[3] = GEN_INT (1 << 31);
3117 }")
3118
3119 (define_insn "*expanded_negsf2"
3120   [(set (match_operand:SF 0 "register_operand" "=r")
3121         (neg:SF (match_operand:SF 1 "register_operand" "0")))
3122    (use (match_operand:SI 2 "register_operand" "r"))]
3123   ""
3124   "xor %2,%0"
3125   [(set_attr "slottable" "yes")])
3126
3127 ;; No "negdi2" although we could make one up that may be faster than
3128 ;; the one in libgcc.
3129
3130 (define_insn "negsi2"
3131   [(set (match_operand:SI 0 "register_operand" "=r")
3132         (neg:SI (match_operand:SI 1 "register_operand" "r")))]
3133   ""
3134   "neg.d %1,%0"
3135   [(set_attr "slottable" "yes")])
3136
3137 (define_insn "neghi2"
3138   [(set (match_operand:HI 0 "register_operand" "=r")
3139         (neg:HI (match_operand:HI 1 "register_operand" "r")))]
3140   ""
3141   "neg.w %1,%0"
3142   [(set_attr "slottable" "yes")])
3143
3144 (define_insn "negqi2"
3145   [(set (match_operand:QI 0 "register_operand" "=r")
3146         (neg:QI (match_operand:QI 1 "register_operand" "r")))]
3147   ""
3148   "neg.b %1,%0"
3149   [(set_attr "slottable" "yes")])
3150 \f
3151 ;; One-complements.
3152
3153 ;; See comment on anddi3 - no need for a DImode pattern.
3154
3155 (define_insn "one_cmplsi2"
3156   [(set (match_operand:SI 0 "register_operand" "=r")
3157         (not:SI (match_operand:SI 1 "register_operand" "0")))]
3158   ""
3159   "not %0"
3160   [(set_attr "slottable" "yes")])
3161
3162 (define_insn "one_cmplhi2"
3163   [(set (match_operand:HI 0 "register_operand" "=r")
3164         (not:HI (match_operand:HI 1 "register_operand" "0")))]
3165   ""
3166   "not %0"
3167   [(set_attr "slottable" "yes")
3168    (set_attr "cc" "clobber")])
3169
3170 (define_insn "one_cmplqi2"
3171   [(set (match_operand:QI 0 "register_operand" "=r")
3172         (not:QI (match_operand:QI 1 "register_operand" "0")))]
3173   ""
3174   "not %0"
3175   [(set_attr "slottable" "yes")
3176    (set_attr "cc" "clobber")])
3177 \f
3178 ;; Arithmetic shift right.
3179
3180 (define_insn "ashrsi3"
3181   [(set (match_operand:SI 0 "register_operand" "=r")
3182         (ashiftrt:SI (match_operand:SI 1 "register_operand" "0")
3183                      (match_operand:SI 2 "nonmemory_operand" "Kr")))]
3184   ""
3185   "*
3186 {
3187   if (REG_S_P (operands[2]))
3188     return \"asr.d %2,%0\";
3189
3190   return \"asrq %2,%0\";
3191 }"
3192   [(set_attr "slottable" "yes")])
3193
3194 ;; Since gcc gets lost, and forgets to zero-extend the source (or mask
3195 ;; the destination) when it changes shifts of lower modes into SImode,
3196 ;; it is better to make these expands an anonymous patterns instead of
3197 ;; the more correct define_insns.  This occurs when gcc thinks that is
3198 ;; is better to widen to SImode and use immediate shift count.
3199
3200 ;; FIXME: Is this legacy or still true for gcc >= 2.7.2?
3201
3202 (define_expand "ashrhi3"
3203   [(set (match_dup 3)
3204         (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "rm")))
3205    (set (match_dup 4)
3206         (zero_extend:SI (match_operand:HI 2 "nonimmediate_operand" "rm")))
3207    (set (match_dup 5) (ashiftrt:SI (match_dup 3) (match_dup 4)))
3208    (set (match_operand:HI 0 "general_operand" "=g")
3209         (subreg:HI (match_dup 5) 0))]
3210   ""
3211   "
3212 {
3213   int i;
3214
3215   for (i = 3; i < 6; i++)
3216     operands[i] = gen_reg_rtx (SImode);
3217 }")
3218
3219 (define_insn "*expanded_ashrhi"
3220   [(set (match_operand:HI 0 "register_operand" "=r")
3221         (ashiftrt:HI (match_operand:HI 1 "register_operand" "0")
3222                      (match_operand:HI 2 "register_operand" "r")))]
3223   ""
3224   "asr.w %2,%0"
3225   [(set_attr "slottable" "yes")])
3226
3227 (define_insn "*ashrhi_lowpart"
3228   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+r"))
3229         (ashiftrt:HI (match_dup 0)
3230                      (match_operand:HI 1 "register_operand" "r")))]
3231   ""
3232   "asr.w %1,%0"
3233   [(set_attr "slottable" "yes")])
3234
3235 ;; Same comment goes as for "ashrhi3".
3236
3237 (define_expand "ashrqi3"
3238   [(set (match_dup 3)
3239         (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "g")))
3240    (set (match_dup 4)
3241         (zero_extend:SI (match_operand:QI 2 "nonimmediate_operand" "g")))
3242    (set (match_dup 5) (ashiftrt:SI (match_dup 3) (match_dup 4)))
3243    (set (match_operand:QI 0 "general_operand" "=g")
3244         (subreg:QI (match_dup 5) 0))]
3245   ""
3246   "
3247 {
3248   int i;
3249
3250   for (i = 3; i < 6; i++)
3251     operands[i] = gen_reg_rtx (SImode);
3252 }")
3253
3254 (define_insn "*expanded_ashrqi"
3255   [(set (match_operand:QI 0 "register_operand" "=r")
3256         (ashiftrt:QI (match_operand:QI 1 "register_operand" "0")
3257                      (match_operand:QI 2 "register_operand" "r")))]
3258   ""
3259   "asr.b %2,%0"
3260   [(set_attr "slottable" "yes")])
3261
3262 ;; A strict_low_part matcher.
3263
3264 (define_insn "*ashrqi_lowpart"
3265   [(set (strict_low_part (match_operand:QI 0 "register_operand" "+r"))
3266         (ashiftrt:QI (match_dup 0)
3267                      (match_operand:QI 1 "register_operand" "r")))]
3268   ""
3269   "asr.b %1,%0"
3270   [(set_attr "slottable" "yes")])
3271 \f
3272 ;; Logical shift right.
3273
3274 (define_insn "lshrsi3"
3275   [(set (match_operand:SI 0 "register_operand" "=r")
3276         (lshiftrt:SI (match_operand:SI 1 "register_operand" "0")
3277                      (match_operand:SI 2 "nonmemory_operand" "Kr")))]
3278   ""
3279   "*
3280 {
3281   if (REG_S_P (operands[2]))
3282     return \"lsr.d %2,%0\";
3283
3284   return \"lsrq %2,%0\";
3285 }"
3286   [(set_attr "slottable" "yes")])
3287
3288 ;; Same comments as for ashrhi3.
3289
3290 (define_expand "lshrhi3"
3291   [(set (match_dup 3)
3292         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "g")))
3293    (set (match_dup 4)
3294         (zero_extend:SI (match_operand:HI 2 "nonimmediate_operand" "g")))
3295    (set (match_dup 5) (lshiftrt:SI (match_dup 3) (match_dup 4)))
3296    (set (match_operand:HI 0 "general_operand" "=g")
3297         (subreg:HI (match_dup 5) 0))]
3298   ""
3299   "
3300 {
3301   int i;
3302
3303   for (i = 3; i < 6; i++)
3304     operands[i] = gen_reg_rtx (SImode);
3305 }")
3306
3307 (define_insn "*expanded_lshrhi"
3308   [(set (match_operand:HI 0 "register_operand" "=r")
3309         (lshiftrt:HI (match_operand:HI 1 "register_operand" "0")
3310                      (match_operand:HI 2 "register_operand" "r")))]
3311   ""
3312   "lsr.w %2,%0"
3313   [(set_attr "slottable" "yes")])
3314
3315 ;; A strict_low_part matcher.
3316
3317 (define_insn "*lshrhi_lowpart"
3318   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+r"))
3319         (lshiftrt:HI (match_dup 0)
3320                      (match_operand:HI 1 "register_operand" "r")))]
3321   ""
3322   "lsr.w %1,%0"
3323   [(set_attr "slottable" "yes")])
3324
3325 ;; Same comments as for ashrhi3.
3326
3327 (define_expand "lshrqi3"
3328   [(set (match_dup 3)
3329         (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "g")))
3330    (set (match_dup 4)
3331         (zero_extend:SI (match_operand:QI 2 "nonimmediate_operand" "g")))
3332    (set (match_dup 5) (lshiftrt:SI (match_dup 3) (match_dup 4)))
3333    (set (match_operand:QI 0 "general_operand" "=g")
3334         (subreg:QI (match_dup 5) 0))]
3335   ""
3336   "
3337 {
3338   int i;
3339
3340   for (i = 3; i < 6; i++)
3341     operands[i] = gen_reg_rtx (SImode);
3342 }")
3343
3344 (define_insn "*expanded_lshrqi"
3345   [(set (match_operand:QI 0 "register_operand" "=r")
3346         (lshiftrt:QI (match_operand:QI 1 "register_operand" "0")
3347                      (match_operand:QI 2 "register_operand" "r")))]
3348   ""
3349   "lsr.b %2,%0"
3350   [(set_attr "slottable" "yes")])
3351
3352 ;; A strict_low_part matcher.
3353
3354 (define_insn "*lshrqi_lowpart"
3355   [(set (strict_low_part (match_operand:QI 0 "register_operand" "+r"))
3356         (lshiftrt:QI (match_dup 0)
3357                      (match_operand:QI 1 "register_operand" "r")))]
3358   ""
3359   "lsr.b %1,%0"
3360   [(set_attr "slottable" "yes")])
3361 \f
3362 ;; Arithmetic/logical shift left.
3363
3364 (define_insn "ashlsi3"
3365   [(set (match_operand:SI 0 "register_operand" "=r")
3366         (ashift:SI (match_operand:SI 1 "register_operand" "0")
3367                    (match_operand:SI 2 "nonmemory_operand" "Kr")))]
3368   ""
3369   "*
3370 {
3371   if (REG_S_P (operands[2]))
3372     return \"lsl.d %2,%0\";
3373
3374   return \"lslq %2,%0\";
3375 }"
3376   [(set_attr "slottable" "yes")])
3377
3378 ;; For narrower modes than SI, we can use lslq although it makes cc
3379 ;; unusable.  The win is that we do not have to reload the shift-count
3380 ;; into a register.
3381
3382 (define_insn "ashlhi3"
3383   [(set (match_operand:HI 0 "register_operand" "=r,r")
3384         (ashift:HI (match_operand:HI 1 "register_operand" "0,0")
3385                    (match_operand:HI 2 "nonmemory_operand" "r,K")))]
3386   ""
3387   "*
3388 {
3389   return
3390     (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) > 15)
3391     ? \"moveq 0,%0\"
3392     : (CONSTANT_P (operands[2])
3393        ? \"lslq %2,%0\" : \"lsl.w %2,%0\");
3394 }"
3395   [(set_attr "slottable" "yes")
3396    (set_attr "cc" "normal,clobber")])
3397
3398 ;; A strict_low_part matcher.
3399
3400 (define_insn "*ashlhi_lowpart"
3401   [(set (strict_low_part (match_operand:HI 0 "r