OSDN Git Service

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