OSDN Git Service

b2b7cffa587155e512b2c9ede2750f32ae4e812e
[pf3gnuchains/gcc-fork.git] / gcc / config / bfin / bfin.md
1 ;;- Machine description for Blackfin for GNU compiler
2 ;;  Copyright 2005, 2006  Free Software Foundation, Inc.
3 ;;  Contributed by Analog Devices.
4
5 ;; This file is part of GCC.
6
7 ;; GCC is free software; you can redistribute it and/or modify it
8 ;; under the terms of the GNU General Public License as published
9 ;; by the Free Software Foundation; either version 2, or (at your
10 ;; option) any later version.
11
12 ;; GCC is distributed in the hope that it will be useful, but WITHOUT
13 ;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14 ;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
15 ;; License for more details.
16
17 ;; You should have received a copy of the GNU General Public License
18 ;; along with GCC; see the file COPYING.  If not, write to
19 ;; the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 ;; Boston, MA 02110-1301, USA.
21
22 ; operand punctuation marks:
23 ;
24 ;     X -- integer value printed as log2
25 ;     Y -- integer value printed as log2(~value) - for bitclear
26 ;     h -- print half word register, low part
27 ;     d -- print half word register, high part
28 ;     D -- print operand as dregs pairs
29 ;     w -- print operand as accumulator register word (a0w, a1w)
30 ;     H -- high part of double mode operand
31 ;     T -- byte register representation Oct. 02 2001
32
33 ; constant operand classes
34 ;
35 ;     J   2**N       5bit imm scaled
36 ;     Ks7 -64 .. 63  signed 7bit imm
37 ;     Ku5 0..31      unsigned 5bit imm
38 ;     Ks4 -8 .. 7    signed 4bit imm
39 ;     Ks3 -4 .. 3    signed 3bit imm
40 ;     Ku3 0 .. 7     unsigned 3bit imm
41 ;     Pn  0, 1, 2    constants 0, 1 or 2, corresponding to n
42 ;
43 ; register operands
44 ;     d  (r0..r7)
45 ;     a  (p0..p5,fp,sp)
46 ;     e  (a0, a1)
47 ;     b  (i0..i3)
48 ;     f  (m0..m3)
49 ;     B
50 ;     c (i0..i3,m0..m3) CIRCREGS
51 ;     C (CC)            CCREGS
52 ;
53
54 ;; Define constants for hard registers.
55
56 (define_constants
57   [(REG_R0 0)
58    (REG_R1 1)
59    (REG_R2 2)
60    (REG_R3 3)
61    (REG_R4 4)
62    (REG_R5 5)
63    (REG_R6 6)
64    (REG_R7 7)
65
66    (REG_P0 8)
67    (REG_P1 9)
68    (REG_P2 10)
69    (REG_P3 11)
70    (REG_P4 12)
71    (REG_P5 13)
72    (REG_P6 14)
73    (REG_P7 15)
74
75    (REG_SP 14)
76    (REG_FP 15)
77
78    (REG_I0 16)
79    (REG_I1 17)
80    (REG_I2 18)
81    (REG_I3 19)
82
83    (REG_B0 20)
84    (REG_B1 21)
85    (REG_B2 22)
86    (REG_B3 23)
87
88    (REG_L0 24)
89    (REG_L1 25)
90    (REG_L2 26)
91    (REG_L3 27)
92
93    (REG_M0 28)
94    (REG_M1 29)
95    (REG_M2 30)
96    (REG_M3 31)
97
98    (REG_A0 32)
99    (REG_A1 33)
100
101    (REG_CC 34)
102    (REG_RETS 35)
103    (REG_RETI 36)
104    (REG_RETX 37)
105    (REG_RETN 38)
106    (REG_RETE 39)
107
108    (REG_ASTAT 40)
109    (REG_SEQSTAT 41)
110    (REG_USP 42)
111
112    (REG_ARGP 43)])
113
114 ;; Constants used in UNSPECs and UNSPEC_VOLATILEs.
115
116 (define_constants
117   [(UNSPEC_CBRANCH_TAKEN 0)
118    (UNSPEC_CBRANCH_NOPS 1)
119    (UNSPEC_RETURN 2)
120    (UNSPEC_MOVE_PIC 3)
121    (UNSPEC_LIBRARY_OFFSET 4)
122    (UNSPEC_PUSH_MULTIPLE 5)
123    ;; Multiply or MAC with extra CONST_INT operand specifying the macflag
124    (UNSPEC_MUL_WITH_FLAG 6)
125    (UNSPEC_MAC_WITH_FLAG 7)
126    (UNSPEC_MOVE_FDPIC 8)
127    (UNSPEC_FUNCDESC_GOT17M4 9)])
128
129 (define_constants
130   [(UNSPEC_VOLATILE_EH_RETURN 0)
131    (UNSPEC_VOLATILE_CSYNC 1)
132    (UNSPEC_VOLATILE_SSYNC 2)
133    (UNSPEC_VOLATILE_LOAD_FUNCDESC 3)])
134
135 (define_constants
136   [(MACFLAG_NONE 0)
137    (MACFLAG_T 1)
138    (MACFLAG_FU 2)
139    (MACFLAG_TFU 3)
140    (MACFLAG_IS 4)
141    (MACFLAG_IU 5)
142    (MACFLAG_W32 6)
143    (MACFLAG_M 7)
144    (MACFLAG_S2RND 8)
145    (MACFLAG_ISS2 9)
146    (MACFLAG_IH 10)])
147
148 (define_attr "type"
149   "move,mvi,mcld,mcst,dsp32,mult,alu0,shft,brcc,br,call,misc,sync,compare,dummy"
150   (const_string "misc"))
151
152 ;; Scheduling definitions
153
154 (define_automaton "bfin")
155
156 (define_cpu_unit "core" "bfin")
157
158 (define_insn_reservation "alu" 1
159   (eq_attr "type" "move,mvi,mcst,dsp32,alu0,shft,brcc,br,call,misc,sync,compare")
160   "core")
161
162 (define_insn_reservation "imul" 3
163   (eq_attr "type" "mult")
164   "core*3")
165
166 (define_insn_reservation "load" 1
167   (eq_attr "type" "mcld")
168   "core")
169
170 ;; Make sure genautomata knows about the maximum latency that can be produced
171 ;; by the adjust_cost function.
172 (define_insn_reservation "dummy" 5
173   (eq_attr "type" "mcld")
174   "core")
175 \f
176 ;; Operand and operator predicates
177
178 (include "predicates.md")
179
180 \f
181 ;;; FRIO branches have been optimized for code density
182 ;;; this comes at a slight cost of complexity when
183 ;;; a compiler needs to generate branches in the general
184 ;;; case.  In order to generate the correct branching
185 ;;; mechanisms the compiler needs keep track of instruction
186 ;;; lengths.  The follow table describes how to count instructions
187 ;;; for the FRIO architecture.
188 ;;;
189 ;;; unconditional br are 12-bit imm pcrelative branches *2
190 ;;; conditional   br are 10-bit imm pcrelative branches *2
191 ;;; brcc 10-bit:
192 ;;;   1024 10-bit imm *2 is 2048 (-1024..1022)
193 ;;; br 12-bit  :
194 ;;;   4096 12-bit imm *2 is 8192 (-4096..4094)
195 ;;; NOTE : For brcc we generate instructions such as
196 ;;;   if cc jmp; jump.[sl] offset
197 ;;;   offset of jump.[sl] is from the jump instruction but
198 ;;;     gcc calculates length from the if cc jmp instruction
199 ;;;     furthermore gcc takes the end address of the branch instruction
200 ;;;     as (pc) for a forward branch
201 ;;;     hence our range is (-4094, 4092) instead of (-4096, 4094) for a br
202 ;;;
203 ;;; The way the (pc) rtx works in these calculations is somewhat odd;
204 ;;; for backward branches it's the address of the current instruction,
205 ;;; for forward branches it's the previously known address of the following
206 ;;; instruction - we have to take this into account by reducing the range
207 ;;; for a forward branch.
208
209 ;; Lengths for type "mvi" insns are always defined by the instructions
210 ;; themselves.
211 (define_attr "length" ""
212   (cond [(eq_attr "type" "mcld")
213          (if_then_else (match_operand 1 "effective_address_32bit_p" "")
214                        (const_int 4) (const_int 2))
215
216          (eq_attr "type" "mcst")
217          (if_then_else (match_operand 0 "effective_address_32bit_p" "")
218                        (const_int 4) (const_int 2))
219
220          (eq_attr "type" "move") (const_int 2)
221
222          (eq_attr "type" "dsp32") (const_int 4)
223          (eq_attr "type" "call")  (const_int 4)
224
225          (eq_attr "type" "br")
226          (if_then_else (and
227                           (le (minus (match_dup 0) (pc)) (const_int 4092))
228                           (ge (minus (match_dup 0) (pc)) (const_int -4096)))
229                   (const_int 2)
230                   (const_int 4))
231
232          (eq_attr "type" "brcc")
233          (cond [(and
234                     (le (minus (match_dup 3) (pc)) (const_int 1020))
235                     (ge (minus (match_dup 3) (pc)) (const_int -1024)))
236                   (const_int 2)
237                 (and
238                     (le (minus (match_dup 3) (pc)) (const_int 4092))
239                     (ge (minus (match_dup 3) (pc)) (const_int -4094)))
240                   (const_int 4)]
241                (const_int 6))
242         ]
243
244         (const_int 2)))
245
246 ;; Conditional moves
247
248 (define_expand "movsicc"
249   [(set (match_operand:SI 0 "register_operand" "")
250         (if_then_else:SI (match_operand 1 "comparison_operator" "")
251                          (match_operand:SI 2 "register_operand" "")
252                          (match_operand:SI 3 "register_operand" "")))]
253   ""
254 {
255   operands[1] = bfin_gen_compare (operands[1], SImode);
256 })
257
258 (define_insn "*movsicc_insn1"
259   [(set (match_operand:SI 0 "register_operand" "=da,da,da")
260         (if_then_else:SI
261             (eq:BI (match_operand:BI 3 "register_operand" "C,C,C")
262                 (const_int 0))
263             (match_operand:SI 1 "register_operand" "da,0,da")
264             (match_operand:SI 2 "register_operand" "0,da,da")))]
265   ""
266   "@
267     if !cc %0 =%1; /* movsicc-1a */
268     if cc %0 =%2; /* movsicc-1b */
269     if !cc %0 =%1; if cc %0=%2; /* movsicc-1 */"
270   [(set_attr "length" "2,2,4")
271    (set_attr "type" "move")])
272
273 (define_insn "*movsicc_insn2"
274   [(set (match_operand:SI 0 "register_operand" "=da,da,da")
275         (if_then_else:SI
276             (ne:BI (match_operand:BI 3 "register_operand" "C,C,C")
277                 (const_int 0))
278             (match_operand:SI 1 "register_operand" "0,da,da")
279             (match_operand:SI 2 "register_operand" "da,0,da")))]
280   ""
281   "@
282    if !cc %0 =%2; /* movsicc-2b */
283    if cc %0 =%1; /* movsicc-2a */
284    if cc %0 =%1; if !cc %0=%2; /* movsicc-1 */"
285   [(set_attr "length" "2,2,4")
286    (set_attr "type" "move")])
287
288 ;; Insns to load HIGH and LO_SUM
289
290 (define_insn "movsi_high"
291   [(set (match_operand:SI 0 "register_operand" "=x")
292         (high:SI (match_operand:SI 1 "immediate_operand" "i")))]
293   "reload_completed"
294   "%d0 = %d1;"
295   [(set_attr "type" "mvi")
296    (set_attr "length" "4")])
297
298 (define_insn "movstricthi_high"
299   [(set (match_operand:SI 0 "register_operand" "+x")
300         (ior:SI (and:SI (match_dup 0) (const_int 65535))
301                 (match_operand:SI 1 "immediate_operand" "i")))]
302   "reload_completed"
303   "%d0 = %d1;"
304   [(set_attr "type" "mvi")
305    (set_attr "length" "4")])
306
307 (define_insn "movsi_low"
308   [(set (match_operand:SI 0 "register_operand" "=x")
309         (lo_sum:SI (match_operand:SI 1 "register_operand" "0")
310                    (match_operand:SI 2 "immediate_operand" "i")))]
311   "reload_completed"
312   "%h0 = %h2;"
313   [(set_attr "type" "mvi")
314    (set_attr "length" "4")])
315
316 (define_insn "movsi_high_pic"
317   [(set (match_operand:SI 0 "register_operand" "=x")
318         (high:SI (unspec:SI [(match_operand:SI 1 "" "")]
319                             UNSPEC_MOVE_PIC)))]
320   ""
321   "%d0 = %1@GOT_LOW;"
322   [(set_attr "type" "mvi")
323    (set_attr "length" "4")])
324
325 (define_insn "movsi_low_pic"
326   [(set (match_operand:SI 0 "register_operand" "=x")
327         (lo_sum:SI (match_operand:SI 1 "register_operand" "0")
328                    (unspec:SI [(match_operand:SI 2 "" "")]
329                               UNSPEC_MOVE_PIC)))]
330   ""
331   "%h0 = %h2@GOT_HIGH;"
332   [(set_attr "type" "mvi")
333    (set_attr "length" "4")])
334
335 ;;; Move instructions
336
337 (define_insn_and_split "movdi_insn"
338   [(set (match_operand:DI 0 "nonimmediate_operand" "=x,mx,r")
339         (match_operand:DI 1 "general_operand" "iFx,r,mx"))]
340   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
341   "#"
342   "reload_completed"
343   [(set (match_dup 2) (match_dup 3))
344    (set (match_dup 4) (match_dup 5))]
345 {
346   rtx lo_half[2], hi_half[2];
347   split_di (operands, 2, lo_half, hi_half);
348
349   if (reg_overlap_mentioned_p (lo_half[0], hi_half[1]))
350     {
351       operands[2] = hi_half[0];
352       operands[3] = hi_half[1];
353       operands[4] = lo_half[0];
354       operands[5] = lo_half[1];
355     }
356   else
357     {
358       operands[2] = lo_half[0];
359       operands[3] = lo_half[1];
360       operands[4] = hi_half[0];
361       operands[5] = hi_half[1];
362     }
363 })
364
365 (define_insn "movbi"
366   [(set (match_operand:BI 0 "nonimmediate_operand" "=x,x,d,md,C,d,C")
367         (match_operand:BI 1 "general_operand" "x,xKs3,md,d,d,C,P0"))]
368
369   ""
370   "@
371    %0 = %1;
372    %0 = %1 (X);
373    %0 = B %1 (Z);
374    B %0 = %1;
375    CC = %1;
376    %0 = CC;
377    R0 = R0 | R0; CC = AC0;"
378   [(set_attr "type" "move,mvi,mcld,mcst,compare,compare,alu0")
379    (set_attr "length" "2,2,*,*,2,2,4")])
380
381 (define_insn "movpdi"
382   [(set (match_operand:PDI 0 "nonimmediate_operand" "=e,<,e")
383         (match_operand:PDI 1 "general_operand" " e,e,>"))]
384   ""
385   "@
386    %0 = %1;
387    %0 = %x1; %0 = %w1;
388    %w0 = %1; %x0 = %1;"
389   [(set_attr "type" "move,mcst,mcld")])
390
391 (define_insn "load_accumulator"
392   [(set (match_operand:PDI 0 "register_operand" "=e")
393         (sign_extend:PDI (match_operand:SI 1 "register_operand" "d")))]
394   ""
395   "%0 = %1;"
396   [(set_attr "type" "move")])
397
398 (define_insn_and_split "load_accumulator_pair"
399   [(set (match_operand:V2PDI 0 "register_operand" "=e")
400         (sign_extend:V2PDI (vec_concat:V2SI
401                             (match_operand:SI 1 "register_operand" "d")
402                             (match_operand:SI 2 "register_operand" "d"))))]
403   ""
404   "#"
405   "reload_completed"
406   [(set (match_dup 3) (sign_extend:PDI (match_dup 1)))
407    (set (match_dup 4) (sign_extend:PDI (match_dup 2)))]
408 {
409   operands[3] = gen_rtx_REG (PDImode, REGNO (operands[0]));
410   operands[4] = gen_rtx_REG (PDImode, REGNO (operands[0]) + 1);
411 })
412
413 (define_insn "*pushsi_insn"
414   [(set (mem:SI (pre_dec:SI (reg:SI REG_SP)))
415         (match_operand:SI 0 "register_operand" "xy"))]
416   ""
417   "[--SP] = %0;"
418   [(set_attr "type" "mcst")
419    (set_attr "length" "2")])
420
421 (define_insn "*popsi_insn"
422   [(set (match_operand:SI 0 "register_operand" "=xy")
423         (mem:SI (post_inc:SI (reg:SI REG_SP))))]
424   ""
425   "%0 = [SP++];"
426   [(set_attr "type" "mcld")
427    (set_attr "length" "2")])
428
429 ;; The first alternative is used to make reload choose a limited register
430 ;; class when faced with a movsi_insn that had its input operand replaced
431 ;; with a PLUS.  We generally require fewer secondary reloads this way.
432 (define_insn "*movsi_insn"
433   [(set (match_operand:SI 0 "nonimmediate_operand" "=da,x*y,da,x,x,x,da,mr")
434         (match_operand:SI 1 "general_operand" "da,x*y,xKs7,xKsh,xKuh,ix,mr,da"))]
435
436   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
437   "@
438    %0 = %1;
439    %0 = %1;
440    %0 = %1 (X);
441    %0 = %1 (X);
442    %0 = %1 (Z);
443    #
444    %0 = %1;
445    %0 = %1;"
446   [(set_attr "type" "move,move,mvi,mvi,mvi,*,mcld,mcst")
447    (set_attr "length" "2,2,2,4,4,*,*,*")])
448
449 (define_insn_and_split "*movv2hi_insn"
450   [(set (match_operand:V2HI 0 "nonimmediate_operand" "=da,da,d,dm")
451         (match_operand:V2HI 1 "general_operand" "i,di,md,d"))]
452
453   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
454   "@
455    #
456    %0 = %1;
457    %0 = %1;
458    %0 = %1;"
459   "reload_completed && GET_CODE (operands[1]) == CONST_VECTOR"
460   [(set (match_dup 0) (high:SI (match_dup 2)))
461    (set (match_dup 0) (lo_sum:SI (match_dup 0) (match_dup 3)))]
462 {
463   HOST_WIDE_INT intval = INTVAL (XVECEXP (operands[1], 0, 1)) << 16;
464   intval |= INTVAL (XVECEXP (operands[1], 0, 0)) & 0xFFFF;
465
466   operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]));
467   operands[2] = operands[3] = GEN_INT (trunc_int_for_mode (intval, SImode));
468 }
469   [(set_attr "type" "move,move,mcld,mcst")
470    (set_attr "length" "2,2,*,*")])
471
472 (define_insn "*movhi_insn"
473   [(set (match_operand:HI 0 "nonimmediate_operand" "=x,da,x,d,mr")
474         (match_operand:HI 1 "general_operand" "x,xKs7,xKsh,mr,d"))]
475   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
476 {
477   static const char *templates[] = {
478     "%0 = %1;",
479     "%0 = %1 (X);",
480     "%0 = %1 (X);",
481     "%0 = W %1 (X);",
482     "W %0 = %1;",
483     "%h0 = W %1;",
484     "W %0 = %h1;"
485   };
486   int alt = which_alternative;
487   rtx mem = (MEM_P (operands[0]) ? operands[0]
488              : MEM_P (operands[1]) ? operands[1] : NULL_RTX);
489   if (mem && bfin_dsp_memref_p (mem))
490     alt += 2;
491   return templates[alt];
492 }
493   [(set_attr "type" "move,mvi,mvi,mcld,mcst")
494    (set_attr "length" "2,2,4,*,*")])
495
496 (define_insn "*movqi_insn"
497   [(set (match_operand:QI 0 "nonimmediate_operand" "=x,da,x,d,mr")
498         (match_operand:QI 1 "general_operand" "x,xKs7,xKsh,mr,d"))]
499   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
500   "@
501    %0 = %1;
502    %0 = %1 (X);
503    %0 = %1 (X);
504    %0 = B %1 (X);
505    B %0 = %1;"
506   [(set_attr "type" "move,mvi,mvi,mcld,mcst")
507    (set_attr "length" "2,2,4,*,*")])
508
509 (define_insn "*movsf_insn"
510   [(set (match_operand:SF 0 "nonimmediate_operand" "=x,x,da,mr")
511         (match_operand:SF 1 "general_operand" "x,Fx,mr,da"))]
512   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
513   "@
514    %0 = %1;
515    #
516    %0 = %1;
517    %0 = %1;"
518   [(set_attr "type" "move,*,mcld,mcst")])
519
520 (define_insn_and_split "movdf_insn"
521   [(set (match_operand:DF 0 "nonimmediate_operand" "=x,mx,r")
522         (match_operand:DF 1 "general_operand" "iFx,r,mx"))]
523   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
524   "#"
525   "reload_completed"
526   [(set (match_dup 2) (match_dup 3))
527    (set (match_dup 4) (match_dup 5))]
528 {
529   rtx lo_half[2], hi_half[2];
530   split_di (operands, 2, lo_half, hi_half);
531
532   if (reg_overlap_mentioned_p (lo_half[0], hi_half[1]))
533     {
534       operands[2] = hi_half[0];
535       operands[3] = hi_half[1];
536       operands[4] = lo_half[0];
537       operands[5] = lo_half[1];
538     }
539   else
540     {
541       operands[2] = lo_half[0];
542       operands[3] = lo_half[1];
543       operands[4] = hi_half[0];
544       operands[5] = hi_half[1];
545     }
546 })
547
548 ;; Storing halfwords.
549 (define_insn "*movsi_insv"
550   [(set (zero_extract:SI (match_operand 0 "register_operand" "+d,x")
551                          (const_int 16)
552                          (const_int 16))
553         (match_operand:SI 1 "nonmemory_operand" "d,n"))]
554   ""
555   "@
556    %d0 = %h1 << 0;
557    %d0 = %1;"
558   [(set_attr "type" "dsp32,mvi")])
559
560 (define_expand "insv"
561   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "")
562                          (match_operand:SI 1 "immediate_operand" "")
563                          (match_operand:SI 2 "immediate_operand" ""))
564         (match_operand:SI 3 "nonmemory_operand" ""))]
565   ""
566 {
567   if (INTVAL (operands[1]) != 16 || INTVAL (operands[2]) != 16)
568     FAIL;
569
570   /* From mips.md: insert_bit_field doesn't verify that our source
571      matches the predicate, so check it again here.  */
572   if (! register_operand (operands[0], VOIDmode))
573     FAIL;
574 })
575
576 ;; This is the main "hook" for PIC code.  When generating
577 ;; PIC, movsi is responsible for determining when the source address
578 ;; needs PIC relocation and appropriately calling legitimize_pic_address
579 ;; to perform the actual relocation.
580
581 (define_expand "movsi"
582   [(set (match_operand:SI 0 "nonimmediate_operand" "")
583         (match_operand:SI 1 "general_operand" ""))]
584   ""
585   "expand_move (operands, SImode);")
586
587 (define_expand "movv2hi"
588   [(set (match_operand:V2HI 0 "nonimmediate_operand" "")
589         (match_operand:V2HI 1 "general_operand" ""))]
590   ""
591   "expand_move (operands, V2HImode);")
592
593 (define_expand "movdi"
594   [(set (match_operand:DI 0 "nonimmediate_operand" "")
595         (match_operand:DI 1 "general_operand" ""))]
596   ""
597   "expand_move (operands, DImode);")
598
599 (define_expand "movsf"
600  [(set (match_operand:SF 0 "nonimmediate_operand" "")
601        (match_operand:SF 1 "general_operand" ""))]
602   ""
603   "expand_move (operands, SFmode);")
604
605 (define_expand "movdf"
606  [(set (match_operand:DF 0 "nonimmediate_operand" "")
607        (match_operand:DF 1 "general_operand" ""))]
608   ""
609   "expand_move (operands, DFmode);")
610
611 (define_expand "movhi"
612   [(set (match_operand:HI 0 "nonimmediate_operand" "")
613         (match_operand:HI 1 "general_operand" ""))]
614   ""
615   "expand_move (operands, HImode);")
616
617 (define_expand "movqi"
618   [(set (match_operand:QI 0 "nonimmediate_operand" "")
619         (match_operand:QI 1 "general_operand" ""))]
620   ""
621   " expand_move (operands, QImode); ")
622
623 ;; Some define_splits to break up SI/SFmode loads of immediate constants.
624
625 (define_split
626   [(set (match_operand:SI 0 "register_operand" "")
627         (match_operand:SI 1 "symbolic_or_const_operand" ""))]
628   "reload_completed
629    /* Always split symbolic operands; split integer constants that are
630       too large for a single instruction.  */
631    && (GET_CODE (operands[1]) != CONST_INT
632        || (INTVAL (operands[1]) < -32768
633            || INTVAL (operands[1]) >= 65536
634            || (INTVAL (operands[1]) >= 32768 && PREG_P (operands[0]))))"
635   [(set (match_dup 0) (high:SI (match_dup 1)))
636    (set (match_dup 0) (lo_sum:SI (match_dup 0) (match_dup 1)))]
637 {
638   if (GET_CODE (operands[1]) == CONST_INT
639       && split_load_immediate (operands))
640     DONE;
641   /* ??? Do something about TARGET_LOW_64K.  */
642 })
643
644 (define_split
645   [(set (match_operand:SF 0 "register_operand" "")
646         (match_operand:SF 1 "immediate_operand" ""))]
647   "reload_completed"
648   [(set (match_dup 2) (high:SI (match_dup 3)))
649    (set (match_dup 2) (lo_sum:SI (match_dup 2) (match_dup 3)))]
650 {
651   long values;
652   REAL_VALUE_TYPE value;
653
654   gcc_assert (GET_CODE (operands[1]) == CONST_DOUBLE);
655
656   REAL_VALUE_FROM_CONST_DOUBLE (value, operands[1]);
657   REAL_VALUE_TO_TARGET_SINGLE (value, values);
658
659   operands[2] = gen_rtx_REG (SImode, true_regnum (operands[0]));
660   operands[3] = GEN_INT (trunc_int_for_mode (values, SImode));
661   if (values >= -32768 && values < 65536)
662     {
663       emit_move_insn (operands[2], operands[3]);
664       DONE;
665     }
666   if (split_load_immediate (operands + 2))
667     DONE;
668 })
669
670 ;; Sadly, this can't be a proper named movstrict pattern, since the compiler
671 ;; expects to be able to use registers for operand 1.
672 ;; Note that the asm instruction is defined by the manual to take an unsigned
673 ;; constant, but it doesn't matter to the assembler, and the compiler only
674 ;; deals with sign-extended constants.  Hence "Ksh".
675 (define_insn "movstricthi_1"
676   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+x"))
677         (match_operand:HI 1 "immediate_operand" "Ksh"))]
678   ""
679   "%h0 = %1;"
680   [(set_attr "type" "mvi")
681    (set_attr "length" "4")])
682
683 ;; Sign and zero extensions
684
685 (define_insn_and_split "extendhisi2"
686   [(set (match_operand:SI 0 "register_operand" "=d, d")
687         (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "d, m")))]
688   ""
689   "@
690    %0 = %h1 (X);
691    %0 = W %h1 (X);"
692   "reload_completed && bfin_dsp_memref_p (operands[1])"
693   [(set (match_dup 2) (match_dup 1))
694    (set (match_dup 0) (sign_extend:SI (match_dup 2)))]
695 {
696   operands[2] = gen_lowpart (HImode, operands[0]);
697 }
698   [(set_attr "type" "alu0,mcld")])
699
700 (define_insn_and_split "zero_extendhisi2"
701   [(set (match_operand:SI 0 "register_operand" "=d, d")
702         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "d, m")))]
703   ""
704   "@
705    %0 = %h1 (Z);
706    %0 = W %h1 (Z);"
707   "reload_completed && bfin_dsp_memref_p (operands[1])"
708   [(set (match_dup 2) (match_dup 1))
709    (set (match_dup 0) (zero_extend:SI (match_dup 2)))]
710 {
711   operands[2] = gen_lowpart (HImode, operands[0]);
712 }
713   [(set_attr "type" "alu0,mcld")])
714
715 (define_insn "zero_extendbisi2"
716   [(set (match_operand:SI 0 "register_operand" "=d")
717         (zero_extend:SI (match_operand:BI 1 "nonimmediate_operand" "C")))]
718   ""
719   "%0 = %1;"
720   [(set_attr "type" "compare")])
721
722 (define_insn "extendqihi2"
723   [(set (match_operand:HI 0 "register_operand" "=d, d")
724         (sign_extend:HI (match_operand:QI 1 "nonimmediate_operand" "m, d")))]
725   ""
726   "@
727    %0 = B %1 (X);
728    %0 = %T1 (X);"
729   [(set_attr "type" "mcld,alu0")])
730
731 (define_insn "extendqisi2"
732   [(set (match_operand:SI 0 "register_operand" "=d, d")
733         (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "m, d")))]
734   ""
735   "@
736    %0 = B %1 (X);
737    %0 = %T1 (X);"
738   [(set_attr "type" "mcld,alu0")])
739
740
741 (define_insn "zero_extendqihi2"
742   [(set (match_operand:HI 0 "register_operand" "=d, d")
743         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "m, d")))]
744   ""
745   "@
746    %0 = B %1 (Z);
747    %0 = %T1 (Z);"
748   [(set_attr "type" "mcld,alu0")])
749
750
751 (define_insn "zero_extendqisi2"
752   [(set (match_operand:SI 0 "register_operand" "=d, d")
753         (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "m, d")))]
754   ""
755   "@
756    %0 = B %1 (Z);
757    %0 = %T1 (Z);"
758   [(set_attr "type" "mcld,alu0")])
759
760 ;; DImode logical operations
761
762 (define_code_macro any_logical [and ior xor])
763 (define_code_attr optab [(and "and")
764                          (ior "ior")
765                          (xor "xor")])
766 (define_code_attr op [(and "&")
767                       (ior "|")
768                       (xor "^")])
769 (define_code_attr high_result [(and "0")
770                                (ior "%H1")
771                                (xor "%H1")])
772
773 (define_insn "<optab>di3"
774   [(set (match_operand:DI 0 "register_operand" "=d")
775         (any_logical:DI (match_operand:DI 1 "register_operand" "0")
776                         (match_operand:DI 2 "register_operand" "d")))]
777   ""
778   "%0 = %1 <op> %2;\\n\\t%H0 = %H1 <op> %H2;"
779   [(set_attr "length" "4")])
780
781 (define_insn "*<optab>di_zesidi_di"
782   [(set (match_operand:DI 0 "register_operand" "=d")
783         (any_logical:DI (zero_extend:DI
784                          (match_operand:SI 2 "register_operand" "d"))
785                         (match_operand:DI 1 "register_operand" "d")))]
786   ""
787   "%0 = %1 <op>  %2;\\n\\t%H0 = <high_result>;"
788   [(set_attr "length" "4")])
789
790 (define_insn "*<optab>di_sesdi_di"
791   [(set (match_operand:DI 0 "register_operand" "=d")
792         (any_logical:DI (sign_extend:DI
793                          (match_operand:SI 2 "register_operand" "d"))
794                         (match_operand:DI 1 "register_operand" "0")))
795    (clobber (match_scratch:SI 3 "=&d"))]
796   ""
797   "%0 = %1 <op> %2;\\n\\t%3 = %2;\\n\\t%3 >>>= 31;\\n\\t%H0 = %H1 <op> %3;"
798   [(set_attr "length" "8")])
799
800 (define_insn "negdi2"
801   [(set (match_operand:DI 0 "register_operand" "=d")
802         (neg:DI (match_operand:DI 1 "register_operand" "d")))
803    (clobber (match_scratch:SI 2 "=&d"))
804    (clobber (reg:CC REG_CC))]
805   ""
806   "%2 = 0; %2 = %2 - %1; cc = ac0; cc = !cc; %2 = cc;\\n\\t%0 = -%1; %H0 = -%H1; %H0 = %H0 - %2;"
807   [(set_attr "length" "16")])
808
809 (define_insn "one_cmpldi2"
810   [(set (match_operand:DI 0 "register_operand" "=d")
811         (not:DI (match_operand:DI 1 "register_operand" "d")))]
812   ""
813   "%0 = ~%1;\\n\\t%H0 = ~%H1;"
814   [(set_attr "length" "4")])
815
816 ;; DImode zero and sign extend patterns
817
818 (define_insn_and_split "zero_extendsidi2"
819   [(set (match_operand:DI 0 "register_operand" "=d")
820         (zero_extend:DI (match_operand:SI 1 "register_operand" "d")))]
821   ""
822   "#"
823   "reload_completed"
824   [(set (match_dup 3) (const_int 0))]
825 {
826   split_di (operands, 1, operands + 2, operands + 3);
827   if (REGNO (operands[0]) != REGNO (operands[1]))
828     emit_move_insn (operands[2], operands[1]);
829 })
830
831 (define_insn "zero_extendqidi2"
832   [(set (match_operand:DI 0 "register_operand" "=d")
833         (zero_extend:DI (match_operand:QI 1 "register_operand" "d")))]
834   ""
835   "%0 = %T1 (Z);\\n\\t%H0 = 0;"
836   [(set_attr "length" "4")])
837
838 (define_insn "zero_extendhidi2"
839   [(set (match_operand:DI 0 "register_operand" "=d")
840         (zero_extend:DI (match_operand:HI 1 "register_operand" "d")))]
841   ""
842   "%0 = %h1 (Z);\\n\\t%H0 = 0;"
843   [(set_attr "length" "4")])
844
845 (define_insn_and_split "extendsidi2"
846   [(set (match_operand:DI 0 "register_operand" "=d")
847         (sign_extend:DI (match_operand:SI 1 "register_operand" "d")))]
848   ""
849   "#"
850   "reload_completed"
851   [(set (match_dup 3) (match_dup 1))
852    (set (match_dup 3) (ashiftrt:SI (match_dup 3) (const_int 31)))]
853 {
854   split_di (operands, 1, operands + 2, operands + 3);
855   if (REGNO (operands[0]) != REGNO (operands[1]))
856     emit_move_insn (operands[2], operands[1]);
857 })
858
859 (define_insn_and_split "extendqidi2"
860   [(set (match_operand:DI 0 "register_operand" "=d")
861         (sign_extend:DI (match_operand:QI 1 "register_operand" "d")))]
862   ""
863   "#"
864   "reload_completed"
865   [(set (match_dup 2) (sign_extend:SI (match_dup 1)))
866    (set (match_dup 3) (sign_extend:SI (match_dup 1)))
867    (set (match_dup 3) (ashiftrt:SI (match_dup 3) (const_int 31)))]
868 {
869   split_di (operands, 1, operands + 2, operands + 3);
870 })
871
872 (define_insn_and_split "extendhidi2"
873   [(set (match_operand:DI 0 "register_operand" "=d")
874         (sign_extend:DI (match_operand:HI 1 "register_operand" "d")))]
875   ""
876   "#"
877   "reload_completed"
878   [(set (match_dup 2) (sign_extend:SI (match_dup 1)))
879    (set (match_dup 3) (sign_extend:SI (match_dup 1)))
880    (set (match_dup 3) (ashiftrt:SI (match_dup 3) (const_int 31)))]
881 {
882   split_di (operands, 1, operands + 2, operands + 3);
883 })
884
885 ;; DImode arithmetic operations
886
887 (define_insn "adddi3"
888   [(set (match_operand:DI 0 "register_operand" "=&d,&d,&d")
889         (plus:DI (match_operand:DI 1 "register_operand" "%0,0,0")
890                  (match_operand:DI 2 "nonmemory_operand" "Kn7,Ks7,d")))
891    (clobber (match_scratch:SI 3 "=&d,&d,&d"))
892    (clobber (reg:CC 34))]
893   ""
894   "@
895    %0 += %2; cc = ac0; %3 = cc; %H0 += -1; %H0 = %H0 + %3;
896    %0 += %2; cc = ac0; %3 = cc; %H0 = %H0 + %3;
897    %0 = %0 + %2; cc = ac0; %3 = cc; %H0 = %H0 + %H2; %H0 = %H0 + %3;"
898   [(set_attr "type" "alu0")
899    (set_attr "length" "10,8,10")])
900
901 (define_insn "subdi3"
902   [(set (match_operand:DI 0 "register_operand" "=&d")
903         (minus:DI (match_operand:DI 1 "register_operand" "0")
904                   (match_operand:DI 2 "register_operand" "d")))
905    (clobber (reg:CC 34))]
906   ""
907   "%0 = %1-%2;\\n\\tcc = ac0;\\n\\t%H0 = %H1-%H2;\\n\\tif cc jump 1f;\\n\\t%H0 += -1;\\n\\t1:"
908   [(set_attr "length" "10")])
909
910 (define_insn "*subdi_di_zesidi"
911   [(set (match_operand:DI 0 "register_operand" "=d")
912         (minus:DI (match_operand:DI 1 "register_operand" "0")
913                   (zero_extend:DI
914                   (match_operand:SI 2 "register_operand" "d"))))
915    (clobber (match_scratch:SI 3 "=&d"))
916    (clobber (reg:CC 34))]
917   ""
918   "%0 = %1 - %2;\\n\\tcc = ac0;\\n\\tcc = ! cc;\\n\\t%3 = cc;\\n\\t%H0 = %H1 - %3;"
919   [(set_attr "length" "10")])
920
921 (define_insn "*subdi_zesidi_di"
922   [(set (match_operand:DI 0 "register_operand" "=d")
923         (minus:DI (zero_extend:DI
924                   (match_operand:SI 2 "register_operand" "d"))
925                   (match_operand:DI 1 "register_operand" "0")))
926    (clobber (match_scratch:SI 3 "=&d"))
927    (clobber (reg:CC 34))]
928   ""
929   "%0 = %2 - %1;\\n\\tcc = ac0;\\n\\tcc = ! cc;\\n\\t%3 = cc;\\n\\t%3 = -%3;\\n\\t%H0 = %3 - %H1"
930   [(set_attr "length" "12")])
931
932 (define_insn "*subdi_di_sesidi"
933   [(set (match_operand:DI 0 "register_operand" "=d")
934         (minus:DI (match_operand:DI 1 "register_operand" "0")
935                   (sign_extend:DI
936                   (match_operand:SI 2 "register_operand" "d"))))
937    (clobber (match_scratch:SI 3 "=&d"))
938    (clobber (reg:CC 34))]
939   ""
940   "%0 = %1 - %2;\\n\\tcc = ac0;\\n\\t%3 = %2;\\n\\t%3 >>>= 31;\\n\\t%H0 = %H1 - %3;\\n\\tif cc jump 1f;\\n\\t%H0 += -1;\\n\\t1:"
941   [(set_attr "length" "14")])
942
943 (define_insn "*subdi_sesidi_di"
944   [(set (match_operand:DI 0 "register_operand" "=d")
945         (minus:DI (sign_extend:DI
946                   (match_operand:SI 2 "register_operand" "d"))
947                   (match_operand:DI 1 "register_operand" "0")))
948    (clobber (match_scratch:SI 3 "=&d"))
949    (clobber (reg:CC 34))]
950   ""
951   "%0 = %2 - %1;\\n\\tcc = ac0;\\n\\t%3 = %2;\\n\\t%3 >>>= 31;\\n\\t%H0 = %3 - %H1;\\n\\tif cc jump 1f;\\n\\t%H0 += -1;\\n\\t1:"
952   [(set_attr "length" "14")])
953
954 ;; Combined shift/add instructions
955
956 (define_insn ""
957   [(set (match_operand:SI 0 "register_operand" "=a,d")
958         (ashift:SI (plus:SI (match_operand:SI 1 "register_operand" "%0,0")
959                             (match_operand:SI 2 "register_operand" "a,d"))
960                    (match_operand:SI 3 "pos_scale_operand" "P1P2,P1P2")))]
961   ""
962   "%0 = (%0 + %2) << %3;" /* "shadd %0,%2,%3;" */
963   [(set_attr "type" "alu0")])
964
965 (define_insn ""
966   [(set (match_operand:SI 0 "register_operand" "=a")
967         (plus:SI (match_operand:SI 1 "register_operand" "a")
968                  (mult:SI (match_operand:SI 2 "register_operand" "a")
969                           (match_operand:SI 3 "scale_by_operand" "i"))))]
970   ""
971   "%0 = %1 + (%2 << %X3);"
972   [(set_attr "type" "alu0")])
973
974 (define_insn ""
975   [(set (match_operand:SI 0 "register_operand" "=a")
976         (plus:SI (match_operand:SI 1 "register_operand" "a")
977                  (ashift:SI (match_operand:SI 2 "register_operand" "a")
978                             (match_operand:SI 3 "pos_scale_operand" "i"))))]
979   ""
980   "%0 = %1 + (%2 << %3);"
981   [(set_attr "type" "alu0")])
982
983 (define_insn ""
984   [(set (match_operand:SI 0 "register_operand" "=a")
985         (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "a")
986                           (match_operand:SI 2 "scale_by_operand" "i"))
987                  (match_operand:SI 3 "register_operand" "a")))]
988   ""
989   "%0 = %3 + (%1 << %X2);"
990   [(set_attr "type" "alu0")])
991
992 (define_insn ""
993   [(set (match_operand:SI 0 "register_operand" "=a")
994         (plus:SI (ashift:SI (match_operand:SI 1 "register_operand" "a")
995                             (match_operand:SI 2 "pos_scale_operand" "i"))
996                  (match_operand:SI 3 "register_operand" "a")))]
997   ""
998   "%0 = %3 + (%1 << %2);"
999   [(set_attr "type" "alu0")])
1000
1001 (define_insn "mulhisi3"
1002   [(set (match_operand:SI 0 "register_operand" "=d")
1003         (mult:SI (sign_extend:SI (match_operand:HI 1 "register_operand" "%d"))
1004                  (sign_extend:SI (match_operand:HI 2 "register_operand" "d"))))]
1005   ""
1006   "%0 = %h1 * %h2 (IS);"
1007   [(set_attr "type" "dsp32")])
1008
1009 (define_insn "umulhisi3"
1010   [(set (match_operand:SI 0 "register_operand" "=d")
1011         (mult:SI (zero_extend:SI (match_operand:HI 1 "register_operand" "%d"))
1012                  (zero_extend:SI (match_operand:HI 2 "register_operand" "d"))))]
1013   ""
1014   "%0 = %h1 * %h2 (FU);"
1015   [(set_attr "type" "dsp32")])
1016
1017 (define_insn "usmulhisi3"
1018   [(set (match_operand:SI 0 "register_operand" "=W")
1019         (mult:SI (zero_extend:SI (match_operand:HI 1 "register_operand" "W"))
1020                  (sign_extend:SI (match_operand:HI 2 "register_operand" "W"))))]
1021   ""
1022   "%0 = %h2 * %h1 (IS,M);"
1023   [(set_attr "type" "dsp32")])
1024
1025 ;; The processor also supports ireg += mreg or ireg -= mreg, but these
1026 ;; are unusable if we don't ensure that the corresponding lreg is zero.
1027 ;; The same applies to the add/subtract constant versions involving
1028 ;; iregs
1029
1030 (define_insn "addsi3"
1031   [(set (match_operand:SI 0 "register_operand" "=ad,a,d")
1032         (plus:SI (match_operand:SI 1 "register_operand" "%0, a,d")
1033                  (match_operand:SI 2 "reg_or_7bit_operand" "Ks7, a,d")))]
1034   ""
1035   "@
1036    %0 += %2;
1037    %0 = %1 + %2;
1038    %0 = %1 + %2;"
1039   [(set_attr "type" "alu0")
1040    (set_attr "length" "2,2,2")])
1041
1042 (define_insn "ssaddsi3"
1043   [(set (match_operand:SI 0 "register_operand" "=d")
1044         (ss_plus:SI (match_operand:SI 1 "register_operand" "d")
1045                     (match_operand:SI 2 "register_operand" "d")))]
1046   ""
1047   "%0 = %1 + %2 (S);"
1048   [(set_attr "type" "dsp32")])
1049
1050 (define_expand "subsi3"
1051   [(set (match_operand:SI 0 "register_operand" "")
1052         (minus:SI (match_operand:SI 1 "register_operand" "")
1053                   (match_operand:SI 2 "reg_or_7bit_operand" "")))]
1054   ""
1055   "")
1056
1057 (define_insn ""
1058   [(set (match_operand:SI 0 "register_operand" "=da,d,a")
1059         (minus:SI (match_operand:SI 1 "register_operand" "0,d,0")
1060                   (match_operand:SI 2 "reg_or_7bit_operand" "Ks7,d,a")))]
1061   "GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) != -64"
1062 {
1063   static const char *const strings_subsi3[] = {
1064     "%0 += -%2;",
1065     "%0 = %1 - %2;",
1066     "%0 -= %2;",
1067   };
1068
1069   if (CONSTANT_P (operands[2]) && INTVAL (operands[2]) < 0) {
1070      rtx tmp_op = operands[2];
1071      operands[2] = GEN_INT (-INTVAL (operands[2]));
1072      output_asm_insn ("%0 += %2;", operands);
1073      operands[2] = tmp_op;
1074      return "";
1075   }
1076
1077   return strings_subsi3[which_alternative];
1078 }
1079   [(set_attr "type" "alu0")])
1080
1081 (define_insn "sssubsi3"
1082   [(set (match_operand:SI 0 "register_operand" "=d")
1083         (ss_minus:SI (match_operand:SI 1 "register_operand" "d")
1084                      (match_operand:SI 2 "register_operand" "d")))]
1085   ""
1086   "%0 = %1 - %2 (S);"
1087   [(set_attr "type" "dsp32")])
1088
1089 ;; Bit test instructions
1090
1091 (define_insn "*not_bittst"
1092  [(set (match_operand:BI 0 "register_operand" "=C")
1093        (eq:BI (zero_extract:SI (match_operand:SI 1 "register_operand" "d")
1094                                (const_int 1)
1095                                (match_operand:SI 2 "immediate_operand" "Ku5"))
1096               (const_int 0)))]
1097  ""
1098  "cc = !BITTST (%1,%2);"
1099   [(set_attr "type" "alu0")])
1100
1101 (define_insn "*bittst"
1102  [(set (match_operand:BI 0 "register_operand" "=C")
1103        (ne:BI (zero_extract:SI (match_operand:SI 1 "register_operand" "d")
1104                                (const_int 1)
1105                                (match_operand:SI 2 "immediate_operand" "Ku5"))
1106                 (const_int 0)))]
1107  ""
1108  "cc = BITTST (%1,%2);"
1109   [(set_attr "type" "alu0")])
1110
1111 (define_insn_and_split "*bit_extract"
1112   [(set (match_operand:SI 0 "register_operand" "=d")
1113         (zero_extract:SI (match_operand:SI 1 "register_operand" "d")
1114                          (const_int 1)
1115                          (match_operand:SI 2 "immediate_operand" "Ku5")))
1116    (clobber (reg:BI REG_CC))]
1117   ""
1118   "#"
1119   ""
1120   [(set (reg:BI REG_CC)
1121         (ne:BI (zero_extract:SI (match_dup 1) (const_int 1) (match_dup 2))
1122                (const_int 0)))
1123    (set (match_dup 0)
1124         (ne:SI (reg:BI REG_CC) (const_int 0)))])
1125
1126 (define_insn_and_split "*not_bit_extract"
1127   [(set (match_operand:SI 0 "register_operand" "=d")
1128         (zero_extract:SI (not:SI (match_operand:SI 1 "register_operand" "d"))
1129                          (const_int 1)
1130                          (match_operand:SI 2 "immediate_operand" "Ku5")))
1131    (clobber (reg:BI REG_CC))]
1132   ""
1133   "#"
1134   ""
1135   [(set (reg:BI REG_CC)
1136         (eq:BI (zero_extract:SI (match_dup 1) (const_int 1) (match_dup 2))
1137                (const_int 0)))
1138    (set (match_dup 0)
1139         (ne:SI (reg:BI REG_CC) (const_int 0)))])
1140
1141 (define_insn "*andsi_insn"
1142   [(set (match_operand:SI 0 "register_operand" "=d,d,d,d")
1143         (and:SI (match_operand:SI 1 "register_operand" "%0,d,d,d")
1144                 (match_operand:SI 2 "rhs_andsi3_operand" "L,M1,M2,d")))]
1145   ""
1146   "@
1147    BITCLR (%0,%Y2);
1148    %0 = %T1 (Z);
1149    %0 = %h1 (Z);
1150    %0 = %1 & %2;"
1151   [(set_attr "type" "alu0")])
1152
1153 (define_expand "andsi3"
1154   [(set (match_operand:SI 0 "register_operand" "")
1155         (and:SI (match_operand:SI 1 "register_operand" "")
1156                 (match_operand:SI 2 "general_operand" "")))]
1157   ""
1158 {
1159   if (highbits_operand (operands[2], SImode))
1160     {
1161       operands[2] = GEN_INT (exact_log2 (-INTVAL (operands[2])));
1162       emit_insn (gen_ashrsi3 (operands[0], operands[1], operands[2]));
1163       emit_insn (gen_ashlsi3 (operands[0], operands[0], operands[2]));
1164       DONE;
1165     }
1166   if (! rhs_andsi3_operand (operands[2], SImode))
1167     operands[2] = force_reg (SImode, operands[2]);
1168 })
1169
1170 (define_insn "iorsi3"
1171   [(set (match_operand:SI 0 "register_operand" "=d,d")
1172         (ior:SI (match_operand:SI 1 "register_operand" "%0,d")
1173                 (match_operand:SI 2 "regorlog2_operand" "J,d")))]
1174   ""
1175   "@
1176    BITSET (%0, %X2);
1177    %0 = %1 | %2;"
1178   [(set_attr "type" "alu0")])
1179
1180 (define_insn "xorsi3"
1181   [(set (match_operand:SI 0 "register_operand" "=d,d")
1182         (xor:SI (match_operand:SI 1 "register_operand" "%0,d")
1183                   (match_operand:SI 2 "regorlog2_operand" "J,d")))]
1184   ""
1185   "@
1186    BITTGL (%0, %X2);
1187    %0 = %1 ^ %2;"
1188   [(set_attr "type" "alu0")])
1189
1190 (define_insn "smaxsi3"
1191   [(set (match_operand:SI 0 "register_operand" "=d")
1192         (smax:SI (match_operand:SI 1 "register_operand" "d")
1193                  (match_operand:SI 2 "register_operand" "d")))]
1194   ""
1195   "%0 = max(%1,%2);"
1196   [(set_attr "type" "dsp32")])
1197
1198 (define_insn "sminsi3"
1199   [(set (match_operand:SI 0 "register_operand" "=d")
1200         (smin:SI (match_operand:SI 1 "register_operand" "d")
1201                  (match_operand:SI 2 "register_operand" "d")))]
1202   ""
1203   "%0 = min(%1,%2);"
1204   [(set_attr "type" "dsp32")])
1205
1206 (define_insn "abssi2"
1207   [(set (match_operand:SI 0 "register_operand" "=d")
1208         (abs:SI (match_operand:SI 1 "register_operand" "d")))]
1209   ""
1210   "%0 = abs %1;"
1211   [(set_attr "type" "dsp32")])
1212
1213 (define_insn "negsi2"
1214   [(set (match_operand:SI 0 "register_operand" "=d")
1215         (neg:SI (match_operand:SI 1 "register_operand" "d")))]
1216   ""
1217   "%0 = -%1;"
1218   [(set_attr "type" "alu0")])
1219
1220 (define_insn "ssnegsi2"
1221   [(set (match_operand:SI 0 "register_operand" "=d")
1222         (ss_neg:SI (match_operand:SI 1 "register_operand" "d")))]
1223   ""
1224   "%0 = -%1 (S);"
1225   [(set_attr "type" "dsp32")])
1226
1227 (define_insn "one_cmplsi2"
1228   [(set (match_operand:SI 0 "register_operand" "=d")
1229         (not:SI (match_operand:SI 1 "register_operand" "d")))]
1230   ""
1231   "%0 = ~%1;"
1232   [(set_attr "type" "alu0")])
1233
1234 (define_insn "signbitssi2"
1235   [(set (match_operand:HI 0 "register_operand" "=d")
1236         (if_then_else:HI
1237          (lt (match_operand:SI 1 "register_operand" "d") (const_int 0))
1238          (clz:HI (not:SI (match_dup 1)))
1239          (clz:HI (match_dup 1))))]
1240   ""
1241   "%h0 = signbits %1;"
1242   [(set_attr "type" "dsp32")])
1243
1244 (define_insn "smaxhi3"
1245   [(set (match_operand:HI 0 "register_operand" "=d")
1246         (smax:HI (match_operand:HI 1 "register_operand" "d")
1247                  (match_operand:HI 2 "register_operand" "d")))]
1248   ""
1249   "%0 = max(%1,%2) (V);"
1250   [(set_attr "type" "dsp32")])
1251
1252 (define_insn "sminhi3"
1253   [(set (match_operand:HI 0 "register_operand" "=d")
1254         (smin:HI (match_operand:HI 1 "register_operand" "d")
1255                  (match_operand:HI 2 "register_operand" "d")))]
1256   ""
1257   "%0 = min(%1,%2) (V);"
1258   [(set_attr "type" "dsp32")])
1259
1260 (define_insn "abshi2"
1261   [(set (match_operand:HI 0 "register_operand" "=d")
1262         (abs:HI (match_operand:HI 1 "register_operand" "d")))]
1263   ""
1264   "%0 = abs %1 (V);"
1265   [(set_attr "type" "dsp32")])
1266
1267 (define_insn "neghi2"
1268   [(set (match_operand:HI 0 "register_operand" "=d")
1269         (neg:HI (match_operand:HI 1 "register_operand" "d")))]
1270   ""
1271   "%0 = -%1;"
1272   [(set_attr "type" "dsp32")])
1273
1274 (define_insn "ssneghi2"
1275   [(set (match_operand:HI 0 "register_operand" "=d")
1276         (ss_neg:HI (match_operand:HI 1 "register_operand" "d")))]
1277   ""
1278   "%0 = -%1 (V);"
1279   [(set_attr "type" "dsp32")])
1280
1281 (define_insn "signbitshi2"
1282   [(set (match_operand:HI 0 "register_operand" "=d")
1283         (if_then_else:HI
1284          (lt (match_operand:HI 1 "register_operand" "d") (const_int 0))
1285          (clz:HI (not:HI (match_dup 1)))
1286          (clz:HI (match_dup 1))))]
1287   ""
1288   "%h0 = signbits %h1;"
1289   [(set_attr "type" "dsp32")])
1290
1291 (define_insn "mulsi3"
1292   [(set (match_operand:SI 0 "register_operand" "=d")
1293         (mult:SI (match_operand:SI 1 "register_operand" "%0")
1294                  (match_operand:SI 2 "register_operand" "d")))]
1295   ""
1296   "%0 *= %2;"
1297   [(set_attr "type" "mult")])
1298
1299 (define_expand "ashlsi3"
1300   [(set (match_operand:SI 0 "register_operand" "")
1301         (ashift:SI (match_operand:SI 1 "register_operand" "")
1302                    (match_operand:SI 2 "nonmemory_operand" "")))]
1303   ""
1304 {
1305  if (GET_CODE (operands[2]) == CONST_INT
1306      && ((unsigned HOST_WIDE_INT) INTVAL (operands[2])) > 31)
1307    {
1308      emit_insn (gen_movsi (operands[0], const0_rtx));
1309      DONE;
1310    }
1311 })
1312
1313 (define_insn_and_split "*ashlsi3_insn"
1314   [(set (match_operand:SI 0 "register_operand" "=d,a,a,a")
1315         (ashift:SI (match_operand:SI 1 "register_operand" "0,a,a,a")
1316                    (match_operand:SI 2 "nonmemory_operand" "dKu5,P1,P2,?P3P4")))]
1317   ""
1318   "@
1319    %0 <<= %2;
1320    %0 = %1 + %1;
1321    %0 = %1 << %2;
1322    #"
1323   "PREG_P (operands[0]) && INTVAL (operands[2]) > 2"
1324   [(set (match_dup 0) (ashift:SI (match_dup 1) (const_int 2)))
1325    (set (match_dup 0) (ashift:SI (match_dup 0) (match_dup 3)))]
1326   "operands[3] = GEN_INT (INTVAL (operands[2]) - 2);"
1327   [(set_attr "type" "shft")])
1328
1329 (define_insn "ashrsi3"
1330   [(set (match_operand:SI 0 "register_operand" "=d")
1331         (ashiftrt:SI (match_operand:SI 1 "register_operand" "0")
1332                      (match_operand:SI 2 "nonmemory_operand" "dKu5")))]
1333   ""
1334   "%0 >>>= %2;"
1335   [(set_attr "type" "shft")])
1336
1337 (define_insn "ror_one"
1338   [(set (match_operand:SI 0 "register_operand" "=d")
1339         (ior:SI (lshiftrt:SI (match_operand:SI 1 "register_operand" "d") (const_int 1))
1340                 (ashift:SI (zero_extend:SI (reg:BI REG_CC)) (const_int 31))))
1341    (set (reg:BI REG_CC)
1342         (zero_extract:BI (match_dup 1) (const_int 1) (const_int 0)))]
1343   ""
1344   "%0 = ROT %1 BY -1;"
1345   [(set_attr "type" "shft")
1346    (set_attr "length" "4")])
1347
1348 (define_insn "rol_one"
1349   [(set (match_operand:SI 0 "register_operand" "+d")
1350         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "d") (const_int 1))
1351                 (zero_extend:SI (reg:BI REG_CC))))
1352    (set (reg:BI REG_CC)
1353         (zero_extract:BI (match_dup 1) (const_int 31) (const_int 0)))]
1354   ""
1355   "%0 = ROT %1 BY 1;"
1356   [(set_attr "type" "shft")
1357    (set_attr "length" "4")])
1358
1359 (define_expand "lshrdi3"
1360   [(set (match_operand:DI 0 "register_operand" "")
1361         (lshiftrt:DI (match_operand:DI 1 "register_operand" "")
1362                      (match_operand:DI 2 "general_operand" "")))]
1363   ""
1364 {
1365   rtx lo_half[2], hi_half[2];
1366       
1367   if (operands[2] != const1_rtx)
1368     FAIL;
1369   if (! rtx_equal_p (operands[0], operands[1]))
1370     emit_move_insn (operands[0], operands[1]);
1371
1372   split_di (operands, 2, lo_half, hi_half);
1373
1374   emit_move_insn (bfin_cc_rtx, const0_rtx);
1375   emit_insn (gen_ror_one (hi_half[0], hi_half[0]));
1376   emit_insn (gen_ror_one (lo_half[0], lo_half[0]));
1377   DONE;
1378 })
1379
1380 (define_expand "ashrdi3"
1381   [(set (match_operand:DI 0 "register_operand" "")
1382         (ashiftrt:DI (match_operand:DI 1 "register_operand" "")
1383                      (match_operand:DI 2 "general_operand" "")))]
1384   ""
1385 {
1386   rtx lo_half[2], hi_half[2];
1387       
1388   if (operands[2] != const1_rtx)
1389     FAIL;
1390   if (! rtx_equal_p (operands[0], operands[1]))
1391     emit_move_insn (operands[0], operands[1]);
1392
1393   split_di (operands, 2, lo_half, hi_half);
1394
1395   emit_insn (gen_compare_lt (gen_rtx_REG (BImode, REG_CC),
1396                              hi_half[1], const0_rtx));
1397   emit_insn (gen_ror_one (hi_half[0], hi_half[0]));
1398   emit_insn (gen_ror_one (lo_half[0], lo_half[0]));
1399   DONE;
1400 })
1401
1402 (define_expand "ashldi3"
1403   [(set (match_operand:DI 0 "register_operand" "")
1404         (ashift:DI (match_operand:DI 1 "register_operand" "")
1405                    (match_operand:DI 2 "general_operand" "")))]
1406   ""
1407 {
1408   rtx lo_half[2], hi_half[2];
1409       
1410   if (operands[2] != const1_rtx)
1411     FAIL;
1412   if (! rtx_equal_p (operands[0], operands[1]))
1413     emit_move_insn (operands[0], operands[1]);
1414
1415   split_di (operands, 2, lo_half, hi_half);
1416
1417   emit_move_insn (bfin_cc_rtx, const0_rtx);
1418   emit_insn (gen_rol_one (lo_half[0], lo_half[0]));
1419   emit_insn (gen_rol_one (hi_half[0], hi_half[0]));
1420   DONE;
1421 })
1422
1423 (define_insn "lshrsi3"
1424   [(set (match_operand:SI 0 "register_operand" "=d,a")
1425         (lshiftrt:SI (match_operand:SI 1 "register_operand" " 0,a")
1426                      (match_operand:SI 2 "nonmemory_operand" "dKu5,P1P2")))]
1427   ""
1428   "@
1429    %0 >>= %2;
1430    %0 = %1 >> %2;"
1431   [(set_attr "type" "shft")])
1432
1433 ;; A pattern to reload the equivalent of
1434 ;;   (set (Dreg) (plus (FP) (large_constant)))
1435 ;; or
1436 ;;   (set (dagreg) (plus (FP) (arbitrary_constant))) 
1437 ;; using a scratch register
1438 (define_expand "reload_insi"
1439   [(parallel [(set (match_operand:SI 0 "register_operand" "=w")
1440                    (match_operand:SI 1 "fp_plus_const_operand" ""))
1441               (clobber (match_operand:SI 2 "register_operand" "=&a"))])]
1442   ""
1443 {
1444   rtx fp_op = XEXP (operands[1], 0);
1445   rtx const_op = XEXP (operands[1], 1);
1446   rtx primary = operands[0];
1447   rtx scratch = operands[2];
1448
1449   emit_move_insn (scratch, const_op);
1450   emit_insn (gen_addsi3 (scratch, scratch, fp_op));
1451   emit_move_insn (primary, scratch);
1452   DONE;
1453 })
1454
1455 ;; Jump instructions
1456
1457 (define_insn "jump"
1458   [(set (pc)
1459         (label_ref (match_operand 0 "" "")))]
1460   ""
1461 {
1462   if (get_attr_length (insn) == 2)
1463     return "jump.s %0;";
1464   else
1465     return "jump.l %0;";
1466 }
1467   [(set_attr "type" "br")])
1468
1469 (define_insn "indirect_jump"
1470   [(set (pc)
1471         (match_operand:SI 0 "register_operand" "a"))]
1472   ""
1473   "jump (%0);"
1474   [(set_attr "type" "misc")])
1475
1476 (define_expand "tablejump"
1477   [(parallel [(set (pc) (match_operand:SI 0 "register_operand" "a"))
1478               (use (label_ref (match_operand 1 "" "")))])]
1479   ""
1480 {
1481   /* In PIC mode, the table entries are stored PC relative.
1482      Convert the relative address to an absolute address.  */
1483   if (flag_pic)
1484     {
1485       rtx op1 = gen_rtx_LABEL_REF (Pmode, operands[1]);
1486
1487       operands[0] = expand_simple_binop (Pmode, PLUS, operands[0],
1488                                          op1, NULL_RTX, 0, OPTAB_DIRECT);
1489     }
1490 })
1491
1492 (define_insn "*tablejump_internal"
1493   [(set (pc) (match_operand:SI 0 "register_operand" "a"))
1494    (use (label_ref (match_operand 1 "" "")))]
1495   ""
1496   "jump (%0);"
1497   [(set_attr "type" "misc")])
1498
1499 ;;  Call instructions..
1500
1501 ;; The explicit MEM inside the UNSPEC prevents the compiler from moving
1502 ;; the load before a branch after a NULL test, or before a store that
1503 ;; initializes a function descriptor.
1504
1505 (define_insn_and_split "load_funcdescsi"
1506   [(set (match_operand:SI 0 "register_operand" "=a")
1507         (unspec_volatile:SI [(mem:SI (match_operand:SI 1 "address_operand" "p"))]
1508                             UNSPEC_VOLATILE_LOAD_FUNCDESC))]
1509   ""
1510   "#"
1511   "reload_completed"
1512   [(set (match_dup 0) (mem:SI (match_dup 1)))])
1513
1514 (define_expand "call"
1515   [(parallel [(call (match_operand:SI 0 "" "")
1516                     (match_operand 1 "" ""))
1517               (use (match_operand 2 "" ""))])]
1518   ""
1519 {
1520   bfin_expand_call (NULL_RTX, operands[0], operands[1], operands[2], 0);
1521   DONE;
1522 })
1523
1524 (define_expand "sibcall"
1525   [(parallel [(call (match_operand:SI 0 "" "")
1526                     (match_operand 1 "" ""))
1527               (use (match_operand 2 "" ""))
1528               (return)])]
1529   ""
1530 {
1531   bfin_expand_call (NULL_RTX, operands[0], operands[1], operands[2], 1);
1532   DONE;
1533 })
1534
1535 (define_expand "call_value"
1536   [(parallel [(set (match_operand 0 "register_operand" "")
1537                    (call (match_operand:SI 1 "" "")
1538                          (match_operand 2 "" "")))
1539               (use (match_operand 3 "" ""))])]
1540   ""
1541 {
1542   bfin_expand_call (operands[0], operands[1], operands[2], operands[3], 0);
1543   DONE;
1544 })
1545
1546 (define_expand "sibcall_value"
1547   [(parallel [(set (match_operand 0 "register_operand" "")
1548                    (call (match_operand:SI 1 "" "")
1549                          (match_operand 2 "" "")))
1550               (use (match_operand 3 "" ""))
1551               (return)])]
1552   ""
1553 {
1554   bfin_expand_call (operands[0], operands[1], operands[2], operands[3], 1);
1555   DONE;
1556 })
1557
1558 (define_insn "*call_symbol_fdpic"
1559   [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "Q"))
1560          (match_operand 1 "general_operand" "g"))
1561    (use (match_operand:SI 2 "register_operand" "Z"))
1562    (use (match_operand 3 "" ""))]
1563   "! SIBLING_CALL_P (insn)
1564    && GET_CODE (operands[0]) == SYMBOL_REF
1565    && !bfin_longcall_p (operands[0], INTVAL (operands[3]))"
1566   "call %0;"
1567   [(set_attr "type" "call")
1568    (set_attr "length" "4")])
1569
1570 (define_insn "*sibcall_symbol_fdpic"
1571   [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "Q"))
1572          (match_operand 1 "general_operand" "g"))
1573    (use (match_operand:SI 2 "register_operand" "Z"))
1574    (use (match_operand 3 "" ""))
1575    (return)]
1576   "SIBLING_CALL_P (insn)
1577    && GET_CODE (operands[0]) == SYMBOL_REF
1578    && !bfin_longcall_p (operands[0], INTVAL (operands[3]))"
1579   "jump.l %0;"
1580   [(set_attr "type" "br")
1581    (set_attr "length" "4")])
1582
1583 (define_insn "*call_value_symbol_fdpic"
1584   [(set (match_operand 0 "register_operand" "=d")
1585         (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "Q"))
1586               (match_operand 2 "general_operand" "g")))
1587    (use (match_operand:SI 3 "register_operand" "Z"))
1588    (use (match_operand 4 "" ""))]
1589   "! SIBLING_CALL_P (insn)
1590    && GET_CODE (operands[1]) == SYMBOL_REF
1591    && !bfin_longcall_p (operands[1], INTVAL (operands[4]))"
1592   "call %1;"
1593   [(set_attr "type" "call")
1594    (set_attr "length" "4")])
1595
1596 (define_insn "*sibcall_value_symbol_fdpic"
1597   [(set (match_operand 0 "register_operand" "=d")
1598          (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "Q"))
1599                (match_operand 2 "general_operand" "g")))
1600    (use (match_operand:SI 3 "register_operand" "Z"))
1601    (use (match_operand 4 "" ""))
1602    (return)]
1603   "SIBLING_CALL_P (insn)
1604    && GET_CODE (operands[1]) == SYMBOL_REF
1605    && !bfin_longcall_p (operands[1], INTVAL (operands[4]))"
1606   "jump.l %1;"
1607   [(set_attr "type" "br")
1608    (set_attr "length" "4")])
1609
1610 (define_insn "*call_insn_fdpic"
1611   [(call (mem:SI (match_operand:SI 0 "register_no_elim_operand" "Y"))
1612          (match_operand 1 "general_operand" "g"))
1613    (use (match_operand:SI 2 "register_operand" "Z"))
1614    (use (match_operand 3 "" ""))]
1615   "! SIBLING_CALL_P (insn)"
1616   "call (%0);"
1617   [(set_attr "type" "call")
1618    (set_attr "length" "2")])
1619
1620 (define_insn "*sibcall_insn_fdpic"
1621   [(call (mem:SI (match_operand:SI 0 "register_no_elim_operand" "Y"))
1622          (match_operand 1 "general_operand" "g"))
1623    (use (match_operand:SI 2 "register_operand" "Z"))
1624    (use (match_operand 3 "" ""))
1625    (return)]
1626   "SIBLING_CALL_P (insn)"
1627   "jump (%0);"
1628   [(set_attr "type" "br")
1629    (set_attr "length" "2")])
1630
1631 (define_insn "*call_value_insn_fdpic"
1632   [(set (match_operand 0 "register_operand" "=d")
1633         (call (mem:SI (match_operand:SI 1 "register_no_elim_operand" "Y"))
1634               (match_operand 2 "general_operand" "g")))
1635    (use (match_operand:SI 3 "register_operand" "Z"))
1636    (use (match_operand 4 "" ""))]
1637   "! SIBLING_CALL_P (insn)"
1638   "call (%1);"
1639   [(set_attr "type" "call")
1640    (set_attr "length" "2")])
1641
1642 (define_insn "*sibcall_value_insn_fdpic"
1643   [(set (match_operand 0 "register_operand" "=d")
1644          (call (mem:SI (match_operand:SI 1 "register_no_elim_operand" "Y"))
1645                (match_operand 2 "general_operand" "g")))
1646    (use (match_operand:SI 3 "register_operand" "Z"))
1647    (use (match_operand 4 "" ""))
1648    (return)]
1649   "SIBLING_CALL_P (insn)"
1650   "jump (%1);"
1651   [(set_attr "type" "br")
1652    (set_attr "length" "2")])
1653
1654 (define_insn "*call_symbol"
1655   [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "Q"))
1656          (match_operand 1 "general_operand" "g"))
1657    (use (match_operand 2 "" ""))]
1658   "! SIBLING_CALL_P (insn)
1659    && !TARGET_ID_SHARED_LIBRARY
1660    && GET_CODE (operands[0]) == SYMBOL_REF
1661    && !bfin_longcall_p (operands[0], INTVAL (operands[2]))"
1662   "call %0;"
1663   [(set_attr "type" "call")
1664    (set_attr "length" "4")])
1665
1666 (define_insn "*sibcall_symbol"
1667   [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "Q"))
1668          (match_operand 1 "general_operand" "g"))
1669    (use (match_operand 2 "" ""))
1670    (return)]
1671   "SIBLING_CALL_P (insn)
1672    && !TARGET_ID_SHARED_LIBRARY
1673    && GET_CODE (operands[0]) == SYMBOL_REF
1674    && !bfin_longcall_p (operands[0], INTVAL (operands[2]))"
1675   "jump.l %0;"
1676   [(set_attr "type" "br")
1677    (set_attr "length" "4")])
1678
1679 (define_insn "*call_value_symbol"
1680   [(set (match_operand 0 "register_operand" "=d")
1681         (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "Q"))
1682               (match_operand 2 "general_operand" "g")))
1683    (use (match_operand 3 "" ""))]
1684   "! SIBLING_CALL_P (insn)
1685    && !TARGET_ID_SHARED_LIBRARY
1686    && GET_CODE (operands[1]) == SYMBOL_REF
1687    && !bfin_longcall_p (operands[1], INTVAL (operands[3]))"
1688   "call %1;"
1689   [(set_attr "type" "call")
1690    (set_attr "length" "4")])
1691
1692 (define_insn "*sibcall_value_symbol"
1693   [(set (match_operand 0 "register_operand" "=d")
1694          (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "Q"))
1695                (match_operand 2 "general_operand" "g")))
1696    (use (match_operand 3 "" ""))
1697    (return)]
1698   "SIBLING_CALL_P (insn)
1699    && !TARGET_ID_SHARED_LIBRARY
1700    && GET_CODE (operands[1]) == SYMBOL_REF
1701    && !bfin_longcall_p (operands[1], INTVAL (operands[3]))"
1702   "jump.l %1;"
1703   [(set_attr "type" "br")
1704    (set_attr "length" "4")])
1705
1706 (define_insn "*call_insn"
1707   [(call (mem:SI (match_operand:SI 0 "register_no_elim_operand" "a"))
1708          (match_operand 1 "general_operand" "g"))
1709    (use (match_operand 2 "" ""))]
1710   "! SIBLING_CALL_P (insn)"
1711   "call (%0);"
1712   [(set_attr "type" "call")
1713    (set_attr "length" "2")])
1714
1715 (define_insn "*sibcall_insn"
1716   [(call (mem:SI (match_operand:SI 0 "register_no_elim_operand" "z"))
1717          (match_operand 1 "general_operand" "g"))
1718    (use (match_operand 2 "" ""))
1719    (return)]
1720   "SIBLING_CALL_P (insn)"
1721   "jump (%0);"
1722   [(set_attr "type" "br")
1723    (set_attr "length" "2")])
1724
1725 (define_insn "*call_value_insn"
1726   [(set (match_operand 0 "register_operand" "=d")
1727         (call (mem:SI (match_operand:SI 1 "register_no_elim_operand" "a"))
1728               (match_operand 2 "general_operand" "g")))
1729    (use (match_operand 3 "" ""))]
1730   "! SIBLING_CALL_P (insn)"
1731   "call (%1);"
1732   [(set_attr "type" "call")
1733    (set_attr "length" "2")])
1734
1735 (define_insn "*sibcall_value_insn"
1736   [(set (match_operand 0 "register_operand" "=d")
1737          (call (mem:SI (match_operand:SI 1 "register_no_elim_operand" "z"))
1738                (match_operand 2 "general_operand" "g")))
1739    (use (match_operand 3 "" ""))
1740    (return)]
1741   "SIBLING_CALL_P (insn)"
1742   "jump (%1);"
1743   [(set_attr "type" "br")
1744    (set_attr "length" "2")])
1745
1746 ;; Block move patterns
1747
1748 ;; We cheat.  This copies one more word than operand 2 indicates.
1749
1750 (define_insn "rep_movsi"
1751   [(set (match_operand:SI 0 "register_operand" "=&a")
1752         (plus:SI (plus:SI (match_operand:SI 3 "register_operand" "0")
1753                           (ashift:SI (match_operand:SI 2 "register_operand" "a")
1754                                      (const_int 2)))
1755                  (const_int 4)))
1756    (set (match_operand:SI 1 "register_operand" "=&b")
1757         (plus:SI (plus:SI (match_operand:SI 4 "register_operand" "1")
1758                           (ashift:SI (match_dup 2) (const_int 2)))
1759                  (const_int 4)))
1760    (set (mem:BLK (match_dup 3))
1761         (mem:BLK (match_dup 4)))
1762    (use (match_dup 2))
1763    (clobber (match_scratch:HI 5 "=&d"))]
1764   ""
1765   "%5 = [%4++]; lsetup (1f, 1f) LC1 = %2; 1: MNOP || [%3++] = %5 || %5 = [%4++]; [%3++] = %5;"
1766   [(set_attr "type" "misc")
1767    (set_attr "length" "16")])
1768
1769 (define_insn "rep_movhi"
1770   [(set (match_operand:SI 0 "register_operand" "=&a")
1771         (plus:SI (plus:SI (match_operand:SI 3 "register_operand" "0")
1772                           (ashift:SI (match_operand:SI 2 "register_operand" "a")
1773                                      (const_int 1)))
1774                  (const_int 2)))
1775    (set (match_operand:SI 1 "register_operand" "=&b")
1776         (plus:SI (plus:SI (match_operand:SI 4 "register_operand" "1")
1777                           (ashift:SI (match_dup 2) (const_int 1)))
1778                  (const_int 2)))
1779    (set (mem:BLK (match_dup 3))
1780         (mem:BLK (match_dup 4)))
1781    (use (match_dup 2))
1782    (clobber (match_scratch:HI 5 "=&d"))]
1783   ""
1784   "%h5 = W[%4++]; lsetup (1f, 1f) LC1 = %2; 1: MNOP || W [%3++] = %5 || %h5 = W [%4++]; W [%3++] = %5;"
1785   [(set_attr "type" "misc")
1786    (set_attr "length" "16")])
1787
1788 (define_expand "movmemsi"
1789   [(match_operand:BLK 0 "general_operand" "")
1790    (match_operand:BLK 1 "general_operand" "")
1791    (match_operand:SI 2 "const_int_operand" "")
1792    (match_operand:SI 3 "const_int_operand" "")]
1793   ""
1794 {
1795   if (bfin_expand_movmem (operands[0], operands[1], operands[2], operands[3]))
1796     DONE;
1797   FAIL;
1798 })
1799
1800 ;; Conditional branch patterns
1801 ;; The Blackfin has only few condition codes: eq, lt, lte, ltu, leu
1802
1803 ;; The only outcome of this pattern is that global variables
1804 ;; bfin_compare_op[01] are set for use in bcond patterns.
1805
1806 (define_expand "cmpbi"
1807  [(set (cc0) (compare (match_operand:BI 0 "register_operand" "")
1808                       (match_operand:BI 1 "immediate_operand" "")))]
1809  ""
1810 {
1811   bfin_compare_op0 = operands[0];
1812   bfin_compare_op1 = operands[1];
1813   DONE;
1814 })
1815
1816 (define_expand "cmpsi"
1817  [(set (cc0) (compare (match_operand:SI 0 "register_operand" "")
1818                       (match_operand:SI 1 "reg_or_const_int_operand" "")))]
1819  ""
1820 {
1821   bfin_compare_op0 = operands[0];
1822   bfin_compare_op1 = operands[1];
1823   DONE;
1824 })
1825
1826 (define_insn "compare_eq"
1827   [(set (match_operand:BI 0 "register_operand" "=C,C")
1828         (eq:BI (match_operand:SI 1 "register_operand" "d,a")
1829                (match_operand:SI 2 "reg_or_const_int_operand" "dKs3,aKs3")))]
1830   ""
1831   "cc =%1==%2;"
1832   [(set_attr "type" "compare")])
1833
1834 (define_insn "compare_ne"
1835   [(set (match_operand:BI 0 "register_operand" "=C,C")
1836         (ne:BI (match_operand:SI 1 "register_operand" "d,a")
1837                (match_operand:SI 2 "reg_or_const_int_operand" "dKs3,aKs3")))]
1838   "0"
1839   "cc =%1!=%2;"
1840   [(set_attr "type" "compare")])
1841
1842 (define_insn "compare_lt"
1843   [(set (match_operand:BI 0 "register_operand" "=C,C")
1844         (lt:BI (match_operand:SI 1 "register_operand" "d,a")
1845                (match_operand:SI 2 "reg_or_const_int_operand" "dKs3,aKs3")))]
1846   ""
1847   "cc =%1<%2;"
1848   [(set_attr "type" "compare")])
1849
1850 (define_insn "compare_le"
1851   [(set (match_operand:BI 0 "register_operand" "=C,C")
1852         (le:BI (match_operand:SI 1 "register_operand" "d,a")
1853                (match_operand:SI 2 "reg_or_const_int_operand" "dKs3,aKs3")))]
1854   ""
1855   "cc =%1<=%2;"
1856   [(set_attr "type" "compare")])
1857
1858 (define_insn "compare_leu"
1859   [(set (match_operand:BI 0 "register_operand" "=C,C")
1860         (leu:BI (match_operand:SI 1 "register_operand" "d,a")
1861                 (match_operand:SI 2 "reg_or_const_int_operand" "dKu3,aKu3")))]
1862   ""
1863   "cc =%1<=%2 (iu);"
1864   [(set_attr "type" "compare")])
1865
1866 (define_insn "compare_ltu"
1867   [(set (match_operand:BI 0 "register_operand" "=C,C")
1868         (ltu:BI (match_operand:SI 1 "register_operand" "d,a")
1869                 (match_operand:SI 2 "reg_or_const_int_operand" "dKu3,aKu3")))]
1870   ""
1871   "cc =%1<%2 (iu);"
1872   [(set_attr "type" "compare")])
1873
1874 (define_expand "beq"
1875   [(set (match_dup 1) (match_dup 2))
1876    (set (pc)
1877         (if_then_else (match_dup 3)
1878                    (label_ref (match_operand 0 "" ""))
1879                    (pc)))]
1880   ""
1881 {
1882   rtx op0 = bfin_compare_op0, op1 = bfin_compare_op1;
1883   operands[1] = bfin_cc_rtx;    /* hard register: CC */
1884   operands[2] = gen_rtx_EQ (BImode, op0, op1);
1885   /* If we have a BImode input, then we already have a compare result, and
1886      do not need to emit another comparison.  */
1887   if (GET_MODE (bfin_compare_op0) == BImode)
1888     {
1889       gcc_assert (bfin_compare_op1 == const0_rtx);
1890       emit_insn (gen_cbranchbi4 (operands[2], op0, op1, operands[0]));
1891       DONE;
1892     }
1893
1894   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
1895 })
1896
1897 (define_expand "bne"
1898   [(set (match_dup 1) (match_dup 2))
1899    (set (pc)
1900         (if_then_else (match_dup 3)
1901                       (label_ref (match_operand 0 "" ""))
1902                     (pc)))]
1903   ""
1904 {
1905   rtx op0 = bfin_compare_op0, op1 = bfin_compare_op1;
1906   /* If we have a BImode input, then we already have a compare result, and
1907      do not need to emit another comparison.  */
1908   if (GET_MODE (bfin_compare_op0) == BImode)
1909     {
1910       rtx cmp = gen_rtx_NE (BImode, op0, op1);
1911
1912       gcc_assert (bfin_compare_op1 == const0_rtx);
1913       emit_insn (gen_cbranchbi4 (cmp, op0, op1, operands[0]));
1914       DONE;
1915     }
1916
1917   operands[1] = bfin_cc_rtx;    /* hard register: CC */
1918   operands[2] = gen_rtx_EQ (BImode, op0, op1);
1919   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
1920 })
1921
1922 (define_expand "bgt"
1923   [(set (match_dup 1) (match_dup 2))
1924    (set (pc)
1925         (if_then_else (match_dup 3)
1926                       (label_ref (match_operand 0 "" ""))
1927                     (pc)))]
1928   ""
1929 {
1930   operands[1] = bfin_cc_rtx;
1931   operands[2] = gen_rtx_LE (BImode, bfin_compare_op0, bfin_compare_op1);
1932   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
1933 })
1934
1935 (define_expand "bgtu"
1936   [(set (match_dup 1) (match_dup 2))
1937    (set (pc)
1938         (if_then_else (match_dup 3)
1939                       (label_ref (match_operand 0 "" ""))
1940                     (pc)))]
1941   ""
1942 {
1943   operands[1] = bfin_cc_rtx;
1944   operands[2] = gen_rtx_LEU (BImode, bfin_compare_op0, bfin_compare_op1);
1945   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
1946 })
1947
1948 (define_expand "blt"
1949   [(set (match_dup 1) (match_dup 2))
1950    (set (pc)
1951         (if_then_else (match_dup 3)
1952                       (label_ref (match_operand 0 "" ""))
1953                     (pc)))]
1954   ""
1955 {
1956   operands[1] = bfin_cc_rtx;
1957   operands[2] = gen_rtx_LT (BImode, bfin_compare_op0, bfin_compare_op1);
1958   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
1959 })
1960
1961 (define_expand "bltu"
1962   [(set (match_dup 1) (match_dup 2))
1963    (set (pc)
1964         (if_then_else (match_dup 3)
1965                       (label_ref (match_operand 0 "" ""))
1966                       (pc)))]
1967   ""
1968 {
1969   operands[1] = bfin_cc_rtx;
1970   operands[2] = gen_rtx_LTU (BImode, bfin_compare_op0, bfin_compare_op1);
1971   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
1972 })
1973
1974
1975 (define_expand "bge"
1976   [(set (match_dup 1) (match_dup 2))
1977    (set (pc)
1978         (if_then_else (match_dup 3)
1979                       (label_ref (match_operand 0 "" ""))
1980                       (pc)))]
1981   ""
1982 {
1983   operands[1] = bfin_cc_rtx;
1984   operands[2] = gen_rtx_LT (BImode, bfin_compare_op0, bfin_compare_op1);
1985   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
1986 })
1987
1988 (define_expand "bgeu"
1989   [(set (match_dup 1) (match_dup 2))
1990    (set (pc)
1991         (if_then_else (match_dup 3)
1992                       (label_ref (match_operand 0 "" ""))
1993                       (pc)))]
1994   ""
1995 {
1996   operands[1] = bfin_cc_rtx;
1997   operands[2] = gen_rtx_LTU (BImode, bfin_compare_op0, bfin_compare_op1);
1998   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
1999 })
2000
2001 (define_expand "ble"
2002   [(set (match_dup 1) (match_dup 2))
2003    (set (pc)
2004         (if_then_else (match_dup 3)
2005                       (label_ref (match_operand 0 "" ""))
2006                       (pc)))]
2007   ""
2008 {
2009   operands[1] = bfin_cc_rtx;
2010   operands[2] = gen_rtx_LE (BImode, bfin_compare_op0, bfin_compare_op1);
2011   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
2012 })
2013
2014 (define_expand "bleu"
2015   [(set (match_dup 1) (match_dup 2))
2016    (set (pc)
2017         (if_then_else (match_dup 3)
2018                       (label_ref (match_operand 0 "" ""))
2019                       (pc)))
2020   ]
2021   ""
2022 {
2023   operands[1] = bfin_cc_rtx;
2024   operands[2] = gen_rtx_LEU (BImode, bfin_compare_op0, bfin_compare_op1);
2025   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
2026 })
2027
2028 (define_insn "cbranchbi4"
2029   [(set (pc)
2030         (if_then_else
2031          (match_operator 0 "bfin_cbranch_operator"
2032                          [(match_operand:BI 1 "register_operand" "C")
2033                           (match_operand:BI 2 "immediate_operand" "P0")])
2034          (label_ref (match_operand 3 "" ""))
2035          (pc)))]
2036   ""
2037 {
2038   asm_conditional_branch (insn, operands, 0, 0);
2039   return "";
2040 }
2041   [(set_attr "type" "brcc")])
2042
2043 ;; Special cbranch patterns to deal with the speculative load problem - see
2044 ;; bfin_reorg for details.
2045
2046 (define_insn "cbranch_predicted_taken"
2047   [(set (pc)
2048         (if_then_else
2049          (match_operator 0 "bfin_cbranch_operator"
2050                          [(match_operand:BI 1 "register_operand" "C")
2051                           (match_operand:BI 2 "immediate_operand" "P0")])
2052          (label_ref (match_operand 3 "" ""))
2053          (pc)))
2054    (unspec [(const_int 0)] UNSPEC_CBRANCH_TAKEN)]
2055   ""
2056 {
2057   asm_conditional_branch (insn, operands, 0, 1);
2058   return "";
2059 }
2060   [(set_attr "type" "brcc")])
2061
2062 (define_insn "cbranch_with_nops"
2063   [(set (pc)
2064         (if_then_else
2065          (match_operator 0 "bfin_cbranch_operator"
2066                          [(match_operand:BI 1 "register_operand" "C")
2067                           (match_operand:BI 2 "immediate_operand" "P0")])
2068          (label_ref (match_operand 3 "" ""))
2069          (pc)))
2070    (unspec [(match_operand 4 "immediate_operand" "")] UNSPEC_CBRANCH_NOPS)]
2071   "reload_completed"
2072 {
2073   asm_conditional_branch (insn, operands, INTVAL (operands[4]), 0);
2074   return "";
2075 }
2076   [(set_attr "type" "brcc")
2077    (set_attr "length" "6")])
2078
2079 ;; setcc insns.  */
2080 (define_expand "seq"
2081   [(set (match_dup 1) (eq:BI (match_dup 2) (match_dup 3)))
2082    (set (match_operand:SI 0 "register_operand" "")
2083         (ne:SI (match_dup 1) (const_int 0)))]
2084   ""
2085 {
2086   operands[2] = bfin_compare_op0;
2087   operands[3] = bfin_compare_op1;
2088   operands[1] = bfin_cc_rtx;
2089 })
2090
2091 (define_expand "slt"
2092   [(set (match_dup 1) (lt:BI (match_dup 2) (match_dup 3)))
2093    (set (match_operand:SI 0 "register_operand" "")
2094         (ne:SI (match_dup 1) (const_int 0)))]
2095   ""
2096 {
2097    operands[2] = bfin_compare_op0;
2098    operands[3] = bfin_compare_op1;
2099    operands[1] = bfin_cc_rtx;
2100 })
2101
2102 (define_expand "sle"
2103   [(set (match_dup 1) (le:BI (match_dup 2) (match_dup 3)))
2104    (set (match_operand:SI 0 "register_operand" "")
2105         (ne:SI (match_dup 1) (const_int 0)))]
2106   ""
2107 {
2108    operands[2] = bfin_compare_op0;
2109    operands[3] = bfin_compare_op1;
2110    operands[1] = bfin_cc_rtx;
2111 })
2112
2113 (define_expand "sltu"
2114   [(set (match_dup 1) (ltu:BI (match_dup 2) (match_dup 3)))
2115    (set (match_operand:SI 0 "register_operand" "")
2116         (ne:SI (match_dup 1) (const_int 0)))]
2117   ""
2118 {
2119    operands[2] = bfin_compare_op0;
2120    operands[3] = bfin_compare_op1;
2121    operands[1] = bfin_cc_rtx;
2122 })
2123
2124 (define_expand "sleu"
2125   [(set (match_dup 1) (leu:BI (match_dup 2) (match_dup 3)))
2126    (set (match_operand:SI 0 "register_operand" "")
2127         (ne:SI (match_dup 1) (const_int 0)))]
2128   ""
2129 {
2130    operands[2] = bfin_compare_op0;
2131    operands[3] = bfin_compare_op1;
2132    operands[1] = bfin_cc_rtx;
2133 })
2134
2135 (define_insn "nop"
2136   [(const_int 0)]
2137   ""
2138   "nop;")
2139
2140 ;;;;;;;;;;;;;;;;;;;;   CC2dreg   ;;;;;;;;;;;;;;;;;;;;;;;;;
2141 (define_insn "movsibi"
2142   [(set (match_operand:BI 0 "register_operand" "=C")
2143         (ne:BI (match_operand:SI 1 "register_operand" "d")
2144                (const_int 0)))]
2145   ""
2146   "CC = %1;"
2147   [(set_attr "length" "2")])
2148
2149 (define_insn "movbisi"
2150   [(set (match_operand:SI 0 "register_operand" "=d")
2151         (ne:SI (match_operand:BI 1 "register_operand" "C")
2152                (const_int 0)))]
2153   ""
2154   "%0 = CC;"
2155   [(set_attr "length" "2")])
2156
2157 (define_insn ""
2158   [(set (match_operand:BI 0 "register_operand" "=C")
2159         (eq:BI (match_operand:BI 1 "register_operand" " 0")
2160                (const_int 0)))]
2161   ""
2162   "%0 = ! %0;"    /*  NOT CC;"  */
2163   [(set_attr "type" "compare")])
2164
2165 ;; Vector and DSP insns
2166
2167 (define_insn ""
2168   [(set (match_operand:SI 0 "register_operand" "=d")
2169         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "d")
2170                            (const_int 24))
2171                 (lshiftrt:SI (match_operand:SI 2 "register_operand" "d")
2172                              (const_int 8))))]
2173   ""
2174   "%0 = ALIGN8(%1, %2);"
2175   [(set_attr "type" "dsp32")])
2176
2177 (define_insn ""
2178   [(set (match_operand:SI 0 "register_operand" "=d")
2179         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "d")
2180                            (const_int 16))
2181                 (lshiftrt:SI (match_operand:SI 2 "register_operand" "d")
2182                              (const_int 16))))]
2183   ""
2184   "%0 = ALIGN16(%1, %2);"
2185   [(set_attr "type" "dsp32")])
2186
2187 (define_insn ""
2188   [(set (match_operand:SI 0 "register_operand" "=d")
2189         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "d")
2190                            (const_int 8))
2191                 (lshiftrt:SI (match_operand:SI 2 "register_operand" "d")
2192                              (const_int 24))))]
2193   ""
2194   "%0 = ALIGN24(%1, %2);"
2195   [(set_attr "type" "dsp32")])
2196
2197 ;; Prologue and epilogue.
2198
2199 (define_expand "prologue"
2200   [(const_int 1)]
2201   ""
2202   "bfin_expand_prologue (); DONE;")
2203
2204 (define_expand "epilogue"
2205   [(const_int 1)]
2206   ""
2207   "bfin_expand_epilogue (1, 0); DONE;")
2208
2209 (define_expand "sibcall_epilogue"
2210   [(const_int 1)]
2211   ""
2212   "bfin_expand_epilogue (0, 0); DONE;")
2213
2214 (define_expand "eh_return"
2215   [(unspec_volatile [(match_operand:SI 0 "register_operand" "")]
2216                     UNSPEC_VOLATILE_EH_RETURN)]
2217   ""
2218 {
2219   emit_move_insn (EH_RETURN_HANDLER_RTX, operands[0]);
2220   emit_insn (gen_eh_return_internal ());
2221   emit_barrier ();
2222   DONE;
2223 })
2224
2225 (define_insn_and_split "eh_return_internal"
2226   [(unspec_volatile [(reg:SI REG_P2)] UNSPEC_VOLATILE_EH_RETURN)]
2227   ""
2228   "#"
2229   "reload_completed"
2230   [(const_int 1)]
2231   "bfin_expand_epilogue (1, 1); DONE;")
2232
2233 (define_insn "link"
2234   [(set (mem:SI (plus:SI (reg:SI REG_SP) (const_int -4))) (reg:SI REG_RETS))
2235    (set (mem:SI (plus:SI (reg:SI REG_SP) (const_int -8))) (reg:SI REG_FP))
2236    (set (reg:SI REG_FP)
2237         (plus:SI (reg:SI REG_SP) (const_int -8)))
2238    (set (reg:SI REG_SP)
2239         (plus:SI (reg:SI REG_SP) (match_operand:SI 0 "immediate_operand" "i")))]
2240   ""
2241   "LINK %Z0;"
2242   [(set_attr "length" "4")])
2243
2244 (define_insn "unlink"
2245   [(set (reg:SI REG_FP) (mem:SI (reg:SI REG_FP)))
2246    (set (reg:SI REG_RETS) (mem:SI (plus:SI (reg:SI REG_FP) (const_int 4))))
2247    (set (reg:SI REG_SP) (plus:SI (reg:SI REG_FP) (const_int 8)))]
2248   ""
2249   "UNLINK;"
2250   [(set_attr "length" "4")])
2251
2252 ;; This pattern is slightly clumsy.  The stack adjust must be the final SET in
2253 ;; the pattern, otherwise dwarf2out becomes very confused about which reg goes
2254 ;; where on the stack, since it goes through all elements of the parallel in
2255 ;; sequence.
2256 (define_insn "push_multiple"
2257   [(match_parallel 0 "push_multiple_operation"
2258     [(unspec [(match_operand:SI 1 "immediate_operand" "i")] UNSPEC_PUSH_MULTIPLE)])]
2259   ""
2260 {
2261   output_push_multiple (insn, operands);
2262   return "";
2263 })
2264
2265 (define_insn "pop_multiple"
2266   [(match_parallel 0 "pop_multiple_operation"
2267     [(set (reg:SI REG_SP)
2268           (plus:SI (reg:SI REG_SP) (match_operand:SI 1 "immediate_operand" "i")))])]
2269   ""
2270 {
2271   output_pop_multiple (insn, operands);
2272   return "";
2273 })
2274
2275 (define_insn "return_internal"
2276   [(return)
2277    (unspec [(match_operand 0 "immediate_operand" "i")] UNSPEC_RETURN)]
2278   "reload_completed"
2279 {
2280   switch (INTVAL (operands[0]))
2281     {
2282     case EXCPT_HANDLER:
2283       return "rtx;";
2284     case NMI_HANDLER:
2285       return "rtn;";
2286     case INTERRUPT_HANDLER:
2287       return "rti;";
2288     case SUBROUTINE:
2289       return "rts;";
2290     }
2291   gcc_unreachable ();
2292 })
2293
2294 (define_insn "csync"
2295   [(unspec_volatile [(const_int 0)] UNSPEC_VOLATILE_CSYNC)]
2296   ""
2297   "csync;"
2298   [(set_attr "type" "sync")])
2299
2300 (define_insn "ssync"
2301   [(unspec_volatile [(const_int 0)] UNSPEC_VOLATILE_SSYNC)]
2302   ""
2303   "ssync;"
2304   [(set_attr "type" "sync")])
2305
2306 (define_insn "trap"
2307   [(trap_if (const_int 1) (const_int 3))]
2308   ""
2309   "excpt 3;"
2310   [(set_attr "type" "misc")
2311    (set_attr "length" "2")])
2312
2313 (define_insn "trapifcc"
2314   [(trap_if (reg:BI REG_CC) (const_int 3))]
2315   ""
2316   "if !cc jump 4 (bp); excpt 3;"
2317   [(set_attr "type" "misc")
2318    (set_attr "length" "4")])
2319
2320 ;;; Vector instructions
2321
2322 ;; First, all sorts of move variants
2323
2324 (define_insn "movhi_low2high"
2325   [(set (match_operand:V2HI 0 "register_operand" "=d")
2326         (vec_concat:V2HI
2327          (vec_select:HI (match_operand:V2HI 1 "register_operand" "0")
2328                         (parallel [(const_int 0)]))
2329          (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2330                         (parallel [(const_int 0)]))))]
2331   ""
2332   "%d0 = %h2 << 0;"
2333   [(set_attr "type" "dsp32")])
2334
2335 (define_insn "movhi_high2high"
2336   [(set (match_operand:V2HI 0 "register_operand" "=d")
2337         (vec_concat:V2HI
2338          (vec_select:HI (match_operand:V2HI 1 "register_operand" "0")
2339                         (parallel [(const_int 0)]))
2340          (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2341                         (parallel [(const_int 1)]))))]
2342   ""
2343   "%d0 = %d2 << 0;"
2344   [(set_attr "type" "dsp32")])
2345
2346 (define_insn "movhi_low2low"
2347   [(set (match_operand:V2HI 0 "register_operand" "=d")
2348         (vec_concat:V2HI
2349          (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2350                         (parallel [(const_int 0)]))
2351          (vec_select:HI (match_operand:V2HI 1 "register_operand" "0")
2352                         (parallel [(const_int 1)]))))]
2353   ""
2354   "%h0 = %h2 << 0;"
2355   [(set_attr "type" "dsp32")])
2356
2357 (define_insn "movhi_high2low"
2358   [(set (match_operand:V2HI 0 "register_operand" "=d")
2359         (vec_concat:V2HI
2360          (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2361                         (parallel [(const_int 1)]))
2362          (vec_select:HI (match_operand:V2HI 1 "register_operand" "0")
2363                         (parallel [(const_int 1)]))))]
2364   ""
2365   "%h0 = %d2 << 0;"
2366   [(set_attr "type" "dsp32")])
2367
2368 (define_insn "movhiv2hi_low"
2369   [(set (match_operand:V2HI 0 "register_operand" "=d")
2370         (vec_concat:V2HI
2371          (match_operand:HI 2 "register_operand" "d")
2372          (vec_select:HI (match_operand:V2HI 1 "register_operand" "0")
2373                         (parallel [(const_int 1)]))))]
2374   ""
2375   "%h0 = %h2 << 0;"
2376   [(set_attr "type" "dsp32")])
2377
2378 (define_insn "movhiv2hi_high"
2379   [(set (match_operand:V2HI 0 "register_operand" "=d")
2380         (vec_concat:V2HI
2381          (vec_select:HI (match_operand:V2HI 1 "register_operand" "0")
2382                         (parallel [(const_int 0)]))
2383          (match_operand:HI 2 "register_operand" "d")))]
2384   ""
2385   "%d0 = %h2 << 0;"
2386   [(set_attr "type" "dsp32")])
2387
2388 ;; No earlyclobber on alternative two since our sequence ought to be safe.
2389 ;; The order of operands is intentional to match the VDSP builtin (high word
2390 ;; is passed first).
2391 (define_insn_and_split "composev2hi"
2392   [(set (match_operand:V2HI 0 "register_operand" "=d,d")
2393         (vec_concat:V2HI (match_operand:HI 2 "register_operand" "0,d")
2394                          (match_operand:HI 1 "register_operand" "d,d")))]
2395   ""
2396   "@
2397    %d0 = %h2 << 0;
2398    #"
2399   "reload_completed"
2400   [(set (match_dup 0)
2401         (vec_concat:V2HI
2402          (vec_select:HI (match_dup 0) (parallel [(const_int 0)]))
2403          (match_dup 2)))
2404    (set (match_dup 0)
2405         (vec_concat:V2HI
2406          (match_dup 1)
2407          (vec_select:HI (match_dup 0) (parallel [(const_int 1)]))))]
2408   ""
2409   [(set_attr "type" "dsp32")])
2410
2411 ; Like composev2hi, but operating on elements of V2HI vectors.
2412 ; Useful on its own, and as a combiner bridge for the multiply and
2413 ; mac patterns.
2414 (define_insn "packv2hi"
2415   [(set (match_operand:V2HI 0 "register_operand" "=d,d,d,d")
2416         (vec_concat:V2HI (vec_select:HI
2417                           (match_operand:V2HI 1 "register_operand" "d,d,d,d")
2418                           (parallel [(match_operand 3 "const01_operand" "P0,P1,P0,P1")]))
2419                          (vec_select:HI
2420                           (match_operand:V2HI 2 "register_operand" "d,d,d,d")
2421                           (parallel [(match_operand 4 "const01_operand" "P0,P0,P1,P1")]))))]
2422   ""
2423   "@
2424    %0 = PACK (%h2,%h1);
2425    %0 = PACK (%h2,%d1);
2426    %0 = PACK (%d2,%h1);
2427    %0 = PACK (%d2,%d1);"
2428   [(set_attr "type" "dsp32")])
2429
2430 (define_insn "movv2hi_hi"
2431   [(set (match_operand:HI 0 "register_operand" "=d,d,d")
2432         (vec_select:HI (match_operand:V2HI 1 "register_operand" "0,d,d")
2433                        (parallel [(match_operand 2 "const01_operand" "P0,P0,P1")])))]
2434   ""
2435   "@
2436    /* optimized out */
2437    %h0 = %h1 << 0;
2438    %h0 = %d1 << 0;"
2439   [(set_attr "type" "dsp32")])
2440
2441 (define_expand "movv2hi_hi_low"
2442   [(set (match_operand:HI 0 "register_operand" "")
2443         (vec_select:HI (match_operand:V2HI 1 "register_operand" "")
2444                        (parallel [(const_int 0)])))]
2445   ""
2446   "")
2447
2448 (define_expand "movv2hi_hi_high"
2449   [(set (match_operand:HI 0 "register_operand" "")
2450         (vec_select:HI (match_operand:V2HI 1 "register_operand" "")
2451                        (parallel [(const_int 1)])))]
2452   ""
2453   "")
2454
2455 ;; Unusual arithmetic operations on 16 bit registers.
2456
2457 (define_insn "ssaddhi3"
2458   [(set (match_operand:HI 0 "register_operand" "=d")
2459         (ss_plus:HI (match_operand:HI 1 "register_operand" "d")
2460                     (match_operand:HI 2 "register_operand" "d")))]
2461   ""
2462   "%h0 = %h1 + %h2 (S);"
2463   [(set_attr "type" "dsp32")])
2464
2465 (define_insn "sssubhi3"
2466   [(set (match_operand:HI 0 "register_operand" "=d")
2467         (ss_minus:HI (match_operand:HI 1 "register_operand" "d")
2468                      (match_operand:HI 2 "register_operand" "d")))]
2469   ""
2470   "%h0 = %h1 - %h2 (S);"
2471   [(set_attr "type" "dsp32")])
2472
2473 ;; V2HI vector insns
2474
2475 (define_insn "addv2hi3"
2476   [(set (match_operand:V2HI 0 "register_operand" "=d")
2477         (plus:V2HI (match_operand:V2HI 1 "register_operand" "d")
2478                    (match_operand:V2HI 2 "register_operand" "d")))]
2479   ""
2480   "%0 = %1 +|+ %2;"
2481   [(set_attr "type" "dsp32")])
2482
2483 (define_insn "ssaddv2hi3"
2484   [(set (match_operand:V2HI 0 "register_operand" "=d")
2485         (ss_plus:V2HI (match_operand:V2HI 1 "register_operand" "d")
2486                       (match_operand:V2HI 2 "register_operand" "d")))]
2487   ""
2488   "%0 = %1 +|+ %2 (S);"
2489   [(set_attr "type" "dsp32")])
2490
2491 (define_insn "subv2hi3"
2492   [(set (match_operand:V2HI 0 "register_operand" "=d")
2493         (minus:V2HI (match_operand:V2HI 1 "register_operand" "d")
2494                    (match_operand:V2HI 2 "register_operand" "d")))]
2495   ""
2496   "%0 = %1 -|- %2;"
2497   [(set_attr "type" "dsp32")])
2498
2499 (define_insn "sssubv2hi3"
2500   [(set (match_operand:V2HI 0 "register_operand" "=d")
2501         (ss_minus:V2HI (match_operand:V2HI 1 "register_operand" "d")
2502                        (match_operand:V2HI 2 "register_operand" "d")))]
2503   ""
2504   "%0 = %1 -|- %2 (S);"
2505   [(set_attr "type" "dsp32")])
2506
2507 (define_insn "addsubv2hi3"
2508   [(set (match_operand:V2HI 0 "register_operand" "=d")
2509         (vec_concat:V2HI
2510          (plus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2511                                  (parallel [(const_int 0)]))
2512                   (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2513                                  (parallel [(const_int 0)])))
2514          (minus:HI (vec_select:HI (match_dup 1) (parallel [(const_int 1)]))
2515                    (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))))]
2516   ""
2517   "%0 = %1 +|- %2;"
2518   [(set_attr "type" "dsp32")])
2519
2520 (define_insn "subaddv2hi3"
2521   [(set (match_operand:V2HI 0 "register_operand" "=d")
2522         (vec_concat:V2HI
2523          (minus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2524                                   (parallel [(const_int 0)]))
2525                    (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2526                                   (parallel [(const_int 0)])))
2527          (plus:HI (vec_select:HI (match_dup 1) (parallel [(const_int 1)]))
2528                   (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))))]
2529   ""
2530   "%0 = %1 -|+ %2;"
2531   [(set_attr "type" "dsp32")])
2532
2533 (define_insn "ssaddsubv2hi3"
2534   [(set (match_operand:V2HI 0 "register_operand" "=d")
2535         (vec_concat:V2HI
2536          (ss_plus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2537                                     (parallel [(const_int 0)]))
2538                      (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2539                                     (parallel [(const_int 0)])))
2540          (ss_minus:HI (vec_select:HI (match_dup 1) (parallel [(const_int 1)]))
2541                       (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))))]
2542   ""
2543   "%0 = %1 +|- %2 (S);"
2544   [(set_attr "type" "dsp32")])
2545
2546 (define_insn "sssubaddv2hi3"
2547   [(set (match_operand:V2HI 0 "register_operand" "=d")
2548         (vec_concat:V2HI
2549          (ss_minus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2550                                      (parallel [(const_int 0)]))
2551                       (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2552                                      (parallel [(const_int 0)])))
2553          (ss_plus:HI (vec_select:HI (match_dup 1) (parallel [(const_int 1)]))
2554                      (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))))]
2555   ""
2556   "%0 = %1 -|+ %2 (S);"
2557   [(set_attr "type" "dsp32")])
2558
2559 (define_insn "sublohiv2hi3"
2560   [(set (match_operand:HI 0 "register_operand" "=d")
2561         (minus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2562                                  (parallel [(const_int 1)]))
2563                   (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2564                                  (parallel [(const_int 0)]))))]
2565   ""
2566   "%h0 = %d1 - %h2;"
2567   [(set_attr "type" "dsp32")])
2568
2569 (define_insn "subhilov2hi3"
2570   [(set (match_operand:HI 0 "register_operand" "=d")
2571         (minus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2572                                  (parallel [(const_int 0)]))
2573                   (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2574                                  (parallel [(const_int 1)]))))]
2575   ""
2576   "%h0 = %h1 - %d2;"
2577   [(set_attr "type" "dsp32")])
2578
2579 (define_insn "sssublohiv2hi3"
2580   [(set (match_operand:HI 0 "register_operand" "=d")
2581         (ss_minus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2582                                     (parallel [(const_int 1)]))
2583                      (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2584                                     (parallel [(const_int 0)]))))]
2585   ""
2586   "%h0 = %d1 - %h2 (S);"
2587   [(set_attr "type" "dsp32")])
2588
2589 (define_insn "sssubhilov2hi3"
2590   [(set (match_operand:HI 0 "register_operand" "=d")
2591         (ss_minus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2592                                     (parallel [(const_int 0)]))
2593                      (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2594                                     (parallel [(const_int 1)]))))]
2595   ""
2596   "%h0 = %h1 - %d2 (S);"
2597   [(set_attr "type" "dsp32")])
2598
2599 (define_insn "addlohiv2hi3"
2600   [(set (match_operand:HI 0 "register_operand" "=d")
2601         (plus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2602                                 (parallel [(const_int 1)]))
2603                  (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2604                                 (parallel [(const_int 0)]))))]
2605   ""
2606   "%h0 = %d1 + %h2;"
2607   [(set_attr "type" "dsp32")])
2608
2609 (define_insn "addhilov2hi3"
2610   [(set (match_operand:HI 0 "register_operand" "=d")
2611         (plus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2612                                 (parallel [(const_int 0)]))
2613                  (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2614                                 (parallel [(const_int 1)]))))]
2615   ""
2616   "%h0 = %h1 + %d2;"
2617   [(set_attr "type" "dsp32")])
2618
2619 (define_insn "ssaddlohiv2hi3"
2620   [(set (match_operand:HI 0 "register_operand" "=d")
2621         (ss_plus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2622                                    (parallel [(const_int 1)]))
2623                     (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2624                                    (parallel [(const_int 0)]))))]
2625   ""
2626   "%h0 = %d1 + %h2 (S);"
2627   [(set_attr "type" "dsp32")])
2628
2629 (define_insn "ssaddhilov2hi3"
2630   [(set (match_operand:HI 0 "register_operand" "=d")
2631         (ss_plus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2632                                    (parallel [(const_int 0)]))
2633                     (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2634                                    (parallel [(const_int 1)]))))]
2635   ""
2636   "%h0 = %h1 + %d2 (S);"
2637   [(set_attr "type" "dsp32")])
2638
2639 (define_insn "sminv2hi3"
2640   [(set (match_operand:V2HI 0 "register_operand" "=d")
2641         (smin:V2HI (match_operand:V2HI 1 "register_operand" "d")
2642                    (match_operand:V2HI 2 "register_operand" "d")))]
2643   ""
2644   "%0 = MIN (%1, %2) (V);"
2645   [(set_attr "type" "dsp32")])
2646
2647 (define_insn "smaxv2hi3"
2648   [(set (match_operand:V2HI 0 "register_operand" "=d")
2649         (smax:V2HI (match_operand:V2HI 1 "register_operand" "d")
2650                    (match_operand:V2HI 2 "register_operand" "d")))]
2651   ""
2652   "%0 = MAX (%1, %2) (V);"
2653   [(set_attr "type" "dsp32")])
2654
2655 ;; Multiplications.
2656
2657 ;; The Blackfin allows a lot of different options, and we need many patterns to
2658 ;; cover most of the hardware's abilities.
2659 ;; There are a few simple patterns using MULT rtx codes, but most of them use
2660 ;; an unspec with a const_int operand that determines which flag to use in the
2661 ;; instruction.
2662 ;; There are variants for single and parallel multiplications.
2663 ;; There are variants which just use 16 bit lowparts as inputs, and variants
2664 ;; which allow the user to choose just which halves to use as input values.
2665 ;; There are variants which set D registers, variants which set accumulators,
2666 ;; variants which set both, some of them optionally using the accumulators as
2667 ;; inputs for multiply-accumulate operations.
2668
2669 (define_insn "flag_mulhi"
2670   [(set (match_operand:HI 0 "register_operand" "=d")
2671         (unspec:HI [(match_operand:HI 1 "register_operand" "d")
2672                     (match_operand:HI 2 "register_operand" "d")
2673                     (match_operand 3 "const_int_operand" "n")]
2674                    UNSPEC_MUL_WITH_FLAG))]
2675   ""
2676   "%h0 = %h1 * %h2 %M3;"
2677   [(set_attr "type" "dsp32")])
2678
2679 (define_insn "flag_mulhisi"
2680   [(set (match_operand:SI 0 "register_operand" "=d")
2681         (unspec:SI [(match_operand:HI 1 "register_operand" "d")
2682                     (match_operand:HI 2 "register_operand" "d")
2683                     (match_operand 3 "const_int_operand" "n")]
2684                    UNSPEC_MUL_WITH_FLAG))]
2685   ""
2686   "%0 = %h1 * %h2 %M3;"
2687   [(set_attr "type" "dsp32")])
2688
2689 (define_insn "flag_mulhisi_parts"
2690   [(set (match_operand:SI 0 "register_operand" "=d")
2691         (unspec:SI [(vec_select:HI
2692                      (match_operand:V2HI 1 "register_operand" "d")
2693                      (parallel [(match_operand 3 "const01_operand" "P0P1")]))
2694                     (vec_select:HI
2695                      (match_operand:V2HI 2 "register_operand" "d")
2696                      (parallel [(match_operand 4 "const01_operand" "P0P1")]))
2697                     (match_operand 5 "const_int_operand" "n")]
2698                    UNSPEC_MUL_WITH_FLAG))]
2699   ""
2700 {
2701   const char *templates[] = {
2702     "%0 = %h1 * %h2 %M5;",
2703     "%0 = %d1 * %h2 %M5;",
2704     "%0 = %h1 * %d2 %M5;",
2705     "%0 = %d1 * %d2 %M5;" };
2706   int alt = INTVAL (operands[3]) + (INTVAL (operands[4]) << 1);
2707   return templates[alt];
2708 }
2709   [(set_attr "type" "dsp32")])
2710
2711 (define_insn "flag_machi"
2712   [(set (match_operand:HI 0 "register_operand" "=d")
2713         (unspec:HI [(match_operand:HI 1 "register_operand" "d")
2714                     (match_operand:HI 2 "register_operand" "d")
2715                     (match_operand 3 "register_operand" "A")
2716                     (match_operand 4 "const01_operand" "P0P1")
2717                     (match_operand 5 "const_int_operand" "n")]
2718                    UNSPEC_MAC_WITH_FLAG))
2719    (set (match_operand:PDI 6 "register_operand" "=A")
2720         (unspec:PDI [(match_dup 1) (match_dup 2) (match_dup 3)
2721                      (match_dup 4) (match_dup 5)]
2722                     UNSPEC_MAC_WITH_FLAG))]
2723   ""
2724   "%h0 = (A0 %b4 %h1 * %h2) %M6;"
2725   [(set_attr "type" "dsp32")])
2726
2727 (define_insn "flag_machi_acconly"
2728   [(set (match_operand:PDI 0 "register_operand" "=e")
2729         (unspec:PDI [(match_operand:HI 1 "register_operand" "d")
2730                      (match_operand:HI 2 "register_operand" "d")
2731                      (match_operand 3 "register_operand" "A")
2732                      (match_operand 4 "const01_operand" "P0P1")
2733                      (match_operand 5 "const_int_operand" "n")]
2734                     UNSPEC_MAC_WITH_FLAG))]
2735   ""
2736   "%0 %b4 %h1 * %h2 %M6;"
2737   [(set_attr "type" "dsp32")])
2738
2739 (define_insn "flag_macinithi"
2740   [(set (match_operand:HI 0 "register_operand" "=d")
2741         (unspec:HI [(match_operand:HI 1 "register_operand" "d")
2742                     (match_operand:HI 2 "register_operand" "d")
2743                     (match_operand 3 "const_int_operand" "n")]
2744                    UNSPEC_MAC_WITH_FLAG))
2745    (set (match_operand:PDI 4 "register_operand" "=A")
2746         (unspec:PDI [(match_dup 1) (match_dup 2) (match_dup 3)]
2747                     UNSPEC_MAC_WITH_FLAG))]
2748   ""
2749   "%h0 = (A0 = %h1 * %h2) %M3;"
2750   [(set_attr "type" "dsp32")])
2751
2752 (define_insn "flag_macinit1hi"
2753   [(set (match_operand:PDI 0 "register_operand" "=e")
2754         (unspec:PDI [(match_operand:HI 1 "register_operand" "d")
2755                      (match_operand:HI 2 "register_operand" "d")
2756                      (match_operand 3 "const_int_operand" "n")]
2757                     UNSPEC_MAC_WITH_FLAG))]
2758   ""
2759   "%0 = %h1 * %h2 %M3;"
2760   [(set_attr "type" "dsp32")])
2761
2762 (define_insn "mulv2hi3"
2763   [(set (match_operand:V2HI 0 "register_operand" "=d")
2764         (mult:V2HI (match_operand:V2HI 1 "register_operand" "d")
2765                    (match_operand:V2HI 2 "register_operand" "d")))]
2766   ""
2767   "%h0 = %h1 * %h2, %d0 = %d1 * %d2 (IS);"
2768   [(set_attr "type" "dsp32")])
2769
2770 (define_insn "flag_mulv2hi"
2771   [(set (match_operand:V2HI 0 "register_operand" "=d")
2772         (unspec:V2HI [(match_operand:V2HI 1 "register_operand" "d")
2773                       (match_operand:V2HI 2 "register_operand" "d")
2774                       (match_operand 3 "const_int_operand" "n")]
2775                      UNSPEC_MUL_WITH_FLAG))]
2776   ""
2777   "%h0 = %h1 * %h2, %d0 = %d1 * %d2 %M3;"
2778   [(set_attr "type" "dsp32")])
2779
2780 (define_insn "flag_mulv2hi_parts"
2781   [(set (match_operand:V2HI 0 "register_operand" "=d")
2782         (unspec:V2HI [(vec_concat:V2HI
2783                        (vec_select:HI
2784                         (match_operand:V2HI 1 "register_operand" "d")
2785                         (parallel [(match_operand 3 "const01_operand" "P0P1")]))
2786                        (vec_select:HI
2787                         (match_dup 1)
2788                         (parallel [(match_operand 4 "const01_operand" "P0P1")])))
2789                       (vec_concat:V2HI
2790                        (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2791                         (parallel [(match_operand 5 "const01_operand" "P0P1")]))
2792                        (vec_select:HI (match_dup 2)
2793                         (parallel [(match_operand 6 "const01_operand" "P0P1")])))
2794                       (match_operand 7 "const_int_operand" "n")]
2795                      UNSPEC_MUL_WITH_FLAG))]
2796   ""
2797 {
2798   const char *templates[] = {
2799     "%h0 = %h1 * %h2, %d0 = %h1 * %h2 %M7;",
2800     "%h0 = %d1 * %h2, %d0 = %h1 * %h2 %M7;",
2801     "%h0 = %h1 * %h2, %d0 = %d1 * %h2 %M7;",
2802     "%h0 = %d1 * %h2, %d0 = %d1 * %h2 %M7;",
2803     "%h0 = %h1 * %d2, %d0 = %h1 * %h2 %M7;",
2804     "%h0 = %d1 * %d2, %d0 = %h1 * %h2 %M7;",
2805     "%h0 = %h1 * %d2, %d0 = %d1 * %h2 %M7;",
2806     "%h0 = %d1 * %d2, %d0 = %d1 * %h2 %M7;",
2807     "%h0 = %h1 * %h2, %d0 = %h1 * %d2 %M7;",
2808     "%h0 = %d1 * %h2, %d0 = %h1 * %d2 %M7;",
2809     "%h0 = %h1 * %h2, %d0 = %d1 * %d2 %M7;",
2810     "%h0 = %d1 * %h2, %d0 = %d1 * %d2 %M7;",
2811     "%h0 = %h1 * %d2, %d0 = %h1 * %d2 %M7;",
2812     "%h0 = %d1 * %d2, %d0 = %h1 * %d2 %M7;",
2813     "%h0 = %h1 * %d2, %d0 = %d1 * %d2 %M7;",
2814     "%h0 = %d1 * %d2, %d0 = %d1 * %d2 %M7;" };
2815   int alt = (INTVAL (operands[3]) + (INTVAL (operands[4]) << 1)
2816              + (INTVAL (operands[5]) << 2)  + (INTVAL (operands[6]) << 3));
2817   return templates[alt];
2818 }
2819   [(set_attr "type" "dsp32")])
2820
2821 ;; A slightly complicated pattern.
2822 ;; Operand 0 is the halfword output; operand 11 is the accumulator output
2823 ;; Halfword inputs are operands 1 and 2; operands 3, 4, 5 and 6 specify which
2824 ;; parts of these 2x16 bit registers to use.
2825 ;; Operand 7 is the accumulator input.
2826 ;; Operands 8/9 specify whether low/high parts are mac (0) or msu (1)
2827 ;; Operand 10 is the macflag to be used.
2828 (define_insn "flag_macv2hi_parts"
2829   [(set (match_operand:V2HI 0 "register_operand" "=d")
2830         (unspec:V2HI [(vec_concat:V2HI
2831                        (vec_select:HI
2832                         (match_operand:V2HI 1 "register_operand" "d")
2833                         (parallel [(match_operand 3 "const01_operand" "P0P1")]))
2834                        (vec_select:HI
2835                         (match_dup 1)
2836                         (parallel [(match_operand 4 "const01_operand" "P0P1")])))
2837                       (vec_concat:V2HI
2838                        (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2839                         (parallel [(match_operand 5 "const01_operand" "P0P1")]))
2840                        (vec_select:HI (match_dup 2)
2841                         (parallel [(match_operand 6 "const01_operand" "P0P1")])))
2842                       (match_operand:V2PDI 7 "register_operand" "e")
2843                       (match_operand 8 "const01_operand" "P0P1")
2844                       (match_operand 9 "const01_operand" "P0P1")
2845                       (match_operand 10 "const_int_operand" "n")]
2846                      UNSPEC_MAC_WITH_FLAG))
2847    (set (match_operand:V2PDI 11 "register_operand" "=e")
2848         (unspec:V2PDI [(vec_concat:V2HI
2849                         (vec_select:HI (match_dup 1) (parallel [(match_dup 3)]))
2850                         (vec_select:HI (match_dup 1) (parallel [(match_dup 4)])))
2851                        (vec_concat:V2HI
2852                         (vec_select:HI (match_dup 2) (parallel [(match_dup 5)]))
2853                         (vec_select:HI (match_dup 2) (parallel [(match_dup 5)])))
2854                        (match_dup 7) (match_dup 8) (match_dup 9) (match_dup 10)]
2855                       UNSPEC_MAC_WITH_FLAG))]
2856   ""
2857 {
2858   const char *templates[] = {
2859     "%h0 = (A0 %b8 %h1 * %h2), %d0 = (A1 %b9 %h1 * %h2) %M10;",
2860     "%h0 = (A0 %b8 %d1 * %h2), %d0 = (A1 %b9 %h1 * %h2) %M10;",
2861     "%h0 = (A0 %b8 %h1 * %h2), %d0 = (A1 %b9 %d1 * %h2) %M10;",
2862     "%h0 = (A0 %b8 %d1 * %h2), %d0 = (A1 %b9 %d1 * %h2) %M10;",
2863     "%h0 = (A0 %b8 %h1 * %d2), %d0 = (A1 %b9 %h1 * %h2) %M10;",
2864     "%h0 = (A0 %b8 %d1 * %d2), %d0 = (A1 %b9 %h1 * %h2) %M10;",
2865     "%h0 = (A0 %b8 %h1 * %d2), %d0 = (A1 %b9 %d1 * %h2) %M10;",
2866     "%h0 = (A0 %b8 %d1 * %d2), %d0 = (A1 %b9 %d1 * %h2) %M10;",
2867     "%h0 = (A0 %b8 %h1 * %h2), %d0 = (A1 %b9 %h1 * %d2) %M10;",
2868     "%h0 = (A0 %b8 %d1 * %h2), %d0 = (A1 %b9 %h1 * %d2) %M10;",
2869     "%h0 = (A0 %b8 %h1 * %h2), %d0 = (A1 %b9 %d1 * %d2) %M10;",
2870     "%h0 = (A0 %b8 %d1 * %h2), %d0 = (A1 %b9 %d1 * %d2) %M10;",
2871     "%h0 = (A0 %b8 %h1 * %d2), %d0 = (A1 %b9 %h1 * %d2) %M10;",
2872     "%h0 = (A0 %b8 %d1 * %d2), %d0 = (A1 %b9 %h1 * %d2) %M10;",
2873     "%h0 = (A0 %b8 %h1 * %d2), %d0 = (A1 %b9 %d1 * %d2) %M10;",
2874     "%h0 = (A0 %b8 %d1 * %d2), %d0 = (A1 %b9 %d1 * %d2) %M10;" };
2875   int alt = (INTVAL (operands[3]) + (INTVAL (operands[4]) << 1)
2876              + (INTVAL (operands[5]) << 2)  + (INTVAL (operands[6]) << 3));
2877   return templates[alt];
2878 }
2879   [(set_attr "type" "dsp32")])
2880
2881 (define_insn "flag_macv2hi_parts_acconly"
2882   [(set (match_operand:V2PDI 0 "register_operand" "=e")
2883         (unspec:V2PDI [(vec_concat:V2HI
2884                         (vec_select:HI
2885                          (match_operand:V2HI 1 "register_operand" "d")
2886                          (parallel [(match_operand 3 "const01_operand" "P0P1")]))
2887                         (vec_select:HI
2888                          (match_dup 1)
2889                          (parallel [(match_operand 4 "const01_operand" "P0P1")])))
2890                        (vec_concat:V2HI
2891                         (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2892                                        (parallel [(match_operand 5 "const01_operand" "P0P1")]))
2893                         (vec_select:HI (match_dup 2)
2894                                        (parallel [(match_operand 6 "const01_operand" "P0P1")])))
2895                        (match_operand:V2PDI 7 "register_operand" "e")
2896                        (match_operand 8 "const01_operand" "P0P1")
2897                        (match_operand 9 "const01_operand" "P0P1")
2898                        (match_operand 10 "const_int_operand" "n")]
2899                       UNSPEC_MAC_WITH_FLAG))]
2900   ""
2901 {
2902   const char *templates[] = {
2903     "A0 %b8 %h1 * %h2, A1 %b9 %h1 * %h2 %M10;",
2904     "A0 %b8 %d1 * %h2, A1 %b9 %h1 * %h2 %M10;",
2905     "A0 %b8 %h1 * %h2, A1 %b9 %d1 * %h2 %M10;",
2906     "A0 %b8 %d1 * %h2, A1 %b9 %d1 * %h2 %M10;",
2907     "A0 %b8 %h1 * %d2, A1 %b9 %h1 * %h2 %M10;",
2908     "A0 %b8 %d1 * %d2, A1 %b9 %h1 * %h2 %M10;",
2909     "A0 %b8 %h1 * %d2, A1 %b9 %d1 * %h2 %M10;",
2910     "A0 %b8 %d1 * %d2, A1 %b9 %d1 * %h2 %M10;",
2911     "A0 %b8 %h1 * %h2, A1 %b9 %h1 * %d2 %M10;",
2912     "A0 %b8 %d1 * %h2, A1 %b9 %h1 * %d2 %M10;",
2913     "A0 %b8 %h1 * %h2, A1 %b9 %d1 * %d2 %M10;",
2914     "A0 %b8 %d1 * %h2, A1 %b9 %d1 * %d2 %M10;",
2915     "A0 %b8 %h1 * %d2, A1 %b9 %h1 * %d2 %M10;",
2916     "A0 %b8 %d1 * %d2, A1 %b9 %h1 * %d2 %M10;",
2917     "A0 %b8 %h1 * %d2, A1 %b9 %d1 * %d2 %M10;",
2918     "A0 %b8 %d1 * %d2, A1 %b9 %d1 * %d2 %M10;" };
2919   int alt = (INTVAL (operands[3]) + (INTVAL (operands[4]) << 1)
2920              + (INTVAL (operands[5]) << 2)  + (INTVAL (operands[6]) << 3));
2921   return templates[alt];
2922 }
2923   [(set_attr "type" "dsp32")])
2924
2925 ;; Same as above, but initializing the accumulators and therefore a couple fewer
2926 ;; necessary operands.
2927 (define_insn "flag_macinitv2hi_parts"
2928   [(set (match_operand:V2HI 0 "register_operand" "=d")
2929         (unspec:V2HI [(vec_concat:V2HI
2930                        (vec_select:HI
2931                         (match_operand:V2HI 1 "register_operand" "d")
2932                         (parallel [(match_operand 3 "const01_operand" "P0P1")]))
2933                        (vec_select:HI
2934                         (match_dup 1)
2935                         (parallel [(match_operand 4 "const01_operand" "P0P1")])))
2936                       (vec_concat:V2HI
2937                        (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2938                         (parallel [(match_operand 5 "const01_operand" "P0P1")]))
2939                        (vec_select:HI (match_dup 2)
2940                         (parallel [(match_operand 6 "const01_operand" "P0P1")])))
2941                       (match_operand 7 "const_int_operand" "n")]
2942                      UNSPEC_MAC_WITH_FLAG))
2943    (set (match_operand:V2PDI 8 "register_operand" "=e")
2944         (unspec:V2PDI [(vec_concat:V2HI
2945                         (vec_select:HI (match_dup 1) (parallel [(match_dup 3)]))
2946                         (vec_select:HI (match_dup 1) (parallel [(match_dup 4)])))
2947                        (vec_concat:V2HI
2948                         (vec_select:HI (match_dup 2) (parallel [(match_dup 5)]))
2949                         (vec_select:HI (match_dup 2) (parallel [(match_dup 5)])))
2950                        (match_dup 7)]
2951                       UNSPEC_MAC_WITH_FLAG))]
2952   ""
2953 {
2954   const char *templates[] = {
2955     "%h0 = (A0 = %h1 * %h2), %d0 = (A1 = %h1 * %h2) %M7;",
2956     "%h0 = (A0 = %d1 * %h2), %d0 = (A1 = %h1 * %h2) %M7;",
2957     "%h0 = (A0 = %h1 * %h2), %d0 = (A1 = %d1 * %h2) %M7;",
2958     "%h0 = (A0 = %d1 * %h2), %d0 = (A1 = %d1 * %h2) %M7;",
2959     "%h0 = (A0 = %h1 * %d2), %d0 = (A1 = %h1 * %h2) %M7;",
2960     "%h0 = (A0 = %d1 * %d2), %d0 = (A1 = %h1 * %h2) %M7;",
2961     "%h0 = (A0 = %h1 * %d2), %d0 = (A1 = %d1 * %h2) %M7;",
2962     "%h0 = (A0 = %d1 * %d2), %d0 = (A1 = %d1 * %h2) %M7;",
2963     "%h0 = (A0 = %h1 * %h2), %d0 = (A1 = %h1 * %d2) %M7;",
2964     "%h0 = (A0 = %d1 * %h2), %d0 = (A1 = %h1 * %d2) %M7;",
2965     "%h0 = (A0 = %h1 * %h2), %d0 = (A1 = %d1 * %d2) %M7;",
2966     "%h0 = (A0 = %d1 * %h2), %d0 = (A1 = %d1 * %d2) %M7;",
2967     "%h0 = (A0 = %h1 * %d2), %d0 = (A1 = %h1 * %d2) %M7;",
2968     "%h0 = (A0 = %d1 * %d2), %d0 = (A1 = %h1 * %d2) %M7;",
2969     "%h0 = (A0 = %h1 * %d2), %d0 = (A1 = %d1 * %d2) %M7;",
2970     "%h0 = (A0 = %d1 * %d2), %d0 = (A1 = %d1 * %d2) %M7;" };
2971   int alt = (INTVAL (operands[3]) + (INTVAL (operands[4]) << 1)
2972              + (INTVAL (operands[5]) << 2)  + (INTVAL (operands[6]) << 3));
2973   return templates[alt];
2974 }
2975   [(set_attr "type" "dsp32")])
2976
2977 (define_insn "flag_macinit1v2hi_parts"
2978   [(set (match_operand:V2PDI 0 "register_operand" "=e")
2979         (unspec:V2PDI [(vec_concat:V2HI
2980                        (vec_select:HI
2981                         (match_operand:V2HI 1 "register_operand" "d")
2982                         (parallel [(match_operand 3 "const01_operand" "P0P1")]))
2983                        (vec_select:HI
2984                         (match_dup 1)
2985                         (parallel [(match_operand 4 "const01_operand" "P0P1")])))
2986                       (vec_concat:V2HI
2987                        (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2988                         (parallel [(match_operand 5 "const01_operand" "P0P1")]))
2989                        (vec_select:HI (match_dup 2)
2990                         (parallel [(match_operand 6 "const01_operand" "P0P1")])))
2991                       (match_operand 7 "const_int_operand" "n")]
2992                      UNSPEC_MAC_WITH_FLAG))]
2993   ""
2994 {
2995   const char *templates[] = {
2996     "A0 = %h1 * %h2, A1 = %h1 * %h2 %M7;",
2997     "A0 = %d1 * %h2, A1 = %h1 * %h2 %M7;",
2998     "A0 = %h1 * %h2, A1 = %d1 * %h2 %M7;",
2999     "A0 = %d1 * %h2, A1 = %d1 * %h2 %M7;",
3000     "A0 = %h1 * %d2, A1 = %h1 * %h2 %M7;",
3001     "A0 = %d1 * %d2, A1 = %h1 * %h2 %M7;",
3002     "A0 = %h1 * %d2, A1 = %d1 * %h2 %M7;",
3003     "A0 = %d1 * %d2, A1 = %d1 * %h2 %M7;",
3004     "A0 = %h1 * %h2, A1 = %h1 * %d2 %M7;",
3005     "A0 = %d1 * %h2, A1 = %h1 * %d2 %M7;",
3006     "A0 = %h1 * %h2, A1 = %d1 * %d2 %M7;",
3007     "A0 = %d1 * %h2, A1 = %d1 * %d2 %M7;",
3008     "A0 = %h1 * %d2, A1 = %h1 * %d2 %M7;",
3009     "A0 = %d1 * %d2, A1 = %h1 * %d2 %M7;",
3010     "A0 = %h1 * %d2, A1 = %d1 * %d2 %M7;",
3011     "A0 = %d1 * %d2, A1 = %d1 * %d2 %M7;" };
3012   int alt = (INTVAL (operands[3]) + (INTVAL (operands[4]) << 1)
3013              + (INTVAL (operands[5]) << 2)  + (INTVAL (operands[6]) << 3));
3014   return templates[alt];
3015 }
3016   [(set_attr "type" "dsp32")])
3017
3018 (define_insn "mulhisi_ll"
3019   [(set (match_operand:SI 0 "register_operand" "=d")
3020         (mult:SI (sign_extend:SI
3021                   (vec_select:HI (match_operand:V2HI 1 "register_operand" "%d")
3022                                  (parallel [(const_int 0)])))
3023                  (sign_extend:SI
3024                   (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
3025                                  (parallel [(const_int 0)])))))]
3026   ""
3027   "%0 = %h1 * %h2 (IS);"
3028   [(set_attr "type" "dsp32")])
3029
3030 (define_insn "mulhisi_lh"
3031   [(set (match_operand:SI 0 "register_operand" "=d")
3032         (mult:SI (sign_extend:SI
3033                   (vec_select:HI (match_operand:V2HI 1 "register_operand" "%d")
3034                                  (parallel [(const_int 0)])))
3035                  (sign_extend:SI
3036                   (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
3037                                  (parallel [(const_int 1)])))))]
3038   ""
3039   "%0 = %h1 * %d2 (IS);"
3040   [(set_attr "type" "dsp32")])
3041
3042 (define_insn "mulhisi_hl"
3043   [(set (match_operand:SI 0 "register_operand" "=d")
3044         (mult:SI (sign_extend:SI
3045                   (vec_select:HI (match_operand:V2HI 1 "register_operand" "%d")
3046                                  (parallel [(const_int 1)])))
3047                  (sign_extend:SI
3048                   (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
3049                                  (parallel [(const_int 0)])))))]
3050   ""
3051   "%0 = %d1 * %h2 (IS);"
3052   [(set_attr "type" "dsp32")])
3053
3054 (define_insn "mulhisi_hh"
3055   [(set (match_operand:SI 0 "register_operand" "=d")
3056         (mult:SI (sign_extend:SI
3057                   (vec_select:HI (match_operand:V2HI 1 "register_operand" "%d")
3058                                  (parallel [(const_int 1)])))
3059                  (sign_extend:SI
3060                   (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
3061                                  (parallel [(const_int 1)])))))]
3062   ""
3063   "%0 = %d1 * %d2 (IS);"
3064   [(set_attr "type" "dsp32")])
3065
3066 (define_insn "ssnegv2hi2"
3067   [(set (match_operand:V2HI 0 "register_operand" "=d")
3068         (ss_neg:V2HI (match_operand:V2HI 1 "register_operand" "d")))]
3069   ""
3070   "%0 = - %1 (V);"
3071   [(set_attr "type" "dsp32")])
3072
3073 (define_insn "absv2hi2"
3074   [(set (match_operand:V2HI 0 "register_operand" "=d")
3075         (abs:V2HI (match_operand:V2HI 1 "register_operand" "d")))]
3076   ""
3077   "%0 = ABS %1 (V);"
3078   [(set_attr "type" "dsp32")])
3079
3080 ;; Shifts.
3081
3082 (define_insn "ssashiftv2hi3"
3083   [(set (match_operand:V2HI 0 "register_operand" "=d,d,d")
3084         (if_then_else:V2HI
3085          (lt (match_operand:SI 2 "vec_shift_operand" "d,Ku4,Ks4") (const_int 0))
3086          (ashiftrt:V2HI (match_operand:V2HI 1 "register_operand" "d,d,d")
3087                         (match_dup 2))
3088          (ss_ashift:V2HI (match_dup 1) (match_dup 2))))]
3089   ""
3090   "@
3091    %0 = ASHIFT %1 BY %2 (V, S);
3092    %0 = %1 >>> %2 (V,S);
3093    %0 = %1 << %2 (V,S);"
3094   [(set_attr "type" "dsp32")])
3095
3096 (define_insn "ssashifthi3"
3097   [(set (match_operand:HI 0 "register_operand" "=d,d,d")
3098         (if_then_else:HI
3099          (lt (match_operand:SI 2 "vec_shift_operand" "d,Ku4,Ks4") (const_int 0))
3100          (ashiftrt:HI (match_operand:HI 1 "register_operand" "d,d,d")
3101                       (match_dup 2))
3102          (ss_ashift:HI (match_dup 1) (match_dup 2))))]
3103   ""
3104   "@
3105    %0 = ASHIFT %1 BY %2 (V, S);
3106    %0 = %1 >>> %2 (V,S);
3107    %0 = %1 << %2 (V,S);"
3108   [(set_attr "type" "dsp32")])
3109
3110 (define_insn "lshiftv2hi3"
3111   [(set (match_operand:V2HI 0 "register_operand" "=d,d,d")
3112         (if_then_else:V2HI
3113          (lt (match_operand:SI 2 "vec_shift_operand" "d,Ku4,Ks4") (const_int 0))
3114          (lshiftrt:V2HI (match_operand:V2HI 1 "register_operand" "d,d,d")
3115                         (match_dup 2))
3116          (ashift:V2HI (match_dup 1) (match_dup 2))))]
3117   ""
3118   "@
3119    %0 = LSHIFT %1 BY %2 (V);
3120    %0 = %1 >> %2 (V);
3121    %0 = %1 << %2 (V);"
3122   [(set_attr "type" "dsp32")])
3123
3124 (define_insn "lshifthi3"
3125   [(set (match_operand:HI 0 "register_operand" "=d,d,d")
3126         (if_then_else:HI
3127          (lt (match_operand:SI 2 "vec_shift_operand" "d,Ku4,Ks4") (const_int 0))
3128          (lshiftrt:HI (match_operand:HI 1 "register_operand" "d,d,d")
3129                       (match_dup 2))
3130          (ashift:HI (match_dup 1) (match_dup 2))))]
3131   ""
3132   "@
3133    %0 = LSHIFT %1 BY %2 (V);
3134    %0 = %1 >> %2 (V);
3135    %0 = %1 << %2 (V);"
3136   [(set_attr "type" "dsp32")])
3137