OSDN Git Service

PR target/42113
[pf3gnuchains/gcc-fork.git] / gcc / config / alpha / alpha.md
1 ;; Machine description for DEC Alpha for GNU C compiler
2 ;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 ;; 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
4 ;; Free Software Foundation, Inc.
5 ;; Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
6 ;;
7 ;; This file is part of GCC.
8 ;;
9 ;; GCC is free software; you can redistribute it and/or modify
10 ;; it under the terms of the GNU General Public License as published by
11 ;; the Free Software Foundation; either version 3, or (at your option)
12 ;; any later version.
13 ;;
14 ;; GCC is distributed in the hope that it will be useful,
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 ;; GNU General Public License for more details.
18 ;;
19 ;; You should have received a copy of the GNU General Public License
20 ;; along with GCC; see the file COPYING3.  If not see
21 ;; <http://www.gnu.org/licenses/>.
22
23 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
24
25 ;; Uses of UNSPEC in this file:
26
27 (define_constants
28   [(UNSPEC_ARG_HOME     0)
29    (UNSPEC_LDGP1        1)
30    (UNSPEC_INSXH        2)
31    (UNSPEC_MSKXH        3)
32    (UNSPEC_CVTQL        4)
33    (UNSPEC_CVTLQ        5)
34    (UNSPEC_UMK_LAUM     6)
35    (UNSPEC_UMK_LALM     7)
36    (UNSPEC_UMK_LAL      8)
37    (UNSPEC_UMK_LOAD_CIW 9)
38    (UNSPEC_LDGP2        10)
39    (UNSPEC_LITERAL      11)
40    (UNSPEC_LITUSE       12)
41    (UNSPEC_SIBCALL      13)
42    (UNSPEC_SYMBOL       14)
43
44    ;; TLS Support
45    (UNSPEC_TLSGD_CALL   15)
46    (UNSPEC_TLSLDM_CALL  16)
47    (UNSPEC_TLSGD        17)
48    (UNSPEC_TLSLDM       18)
49    (UNSPEC_DTPREL       19)
50    (UNSPEC_TPREL        20)
51    (UNSPEC_TP           21)
52
53    ;; Builtins
54    (UNSPEC_CMPBGE       22)
55    (UNSPEC_ZAP          23)
56    (UNSPEC_AMASK        24)
57    (UNSPEC_IMPLVER      25)
58    (UNSPEC_PERR         26)
59    (UNSPEC_COPYSIGN     27)
60
61    ;; Atomic operations
62    (UNSPEC_MB           28)
63    (UNSPEC_ATOMIC       31)
64    (UNSPEC_CMPXCHG      32)
65    (UNSPEC_XCHG         33)
66   ])
67
68 ;; UNSPEC_VOLATILE:
69
70 (define_constants
71   [(UNSPECV_IMB         0)
72    (UNSPECV_BLOCKAGE    1)
73    (UNSPECV_SETJMPR     2)      ; builtin_setjmp_receiver
74    (UNSPECV_LONGJMP     3)      ; builtin_longjmp
75    (UNSPECV_TRAPB       4)
76    (UNSPECV_PSPL        5)      ; prologue_stack_probe_loop
77    (UNSPECV_REALIGN     6)
78    (UNSPECV_EHR         7)      ; exception_receiver
79    (UNSPECV_MCOUNT      8)
80    (UNSPECV_FORCE_MOV   9)
81    (UNSPECV_LDGP1       10)
82    (UNSPECV_PLDGP2      11)     ; prologue ldgp
83    (UNSPECV_SET_TP      12)
84    (UNSPECV_RPCC        13)
85    (UNSPECV_SETJMPR_ER  14)     ; builtin_setjmp_receiver fragment
86    (UNSPECV_LL          15)     ; load-locked
87    (UNSPECV_SC          16)     ; store-conditional
88   ])
89
90 ;; On non-BWX targets, CQImode must be handled the similarly to HImode
91 ;; when generating reloads.
92 (define_mode_iterator RELOAD12 [QI HI CQI])
93 (define_mode_attr reloadmode [(QI "qi") (HI "hi") (CQI "hi")])
94
95 ;; Other mode iterators
96 (define_mode_iterator I12MODE [QI HI])
97 (define_mode_iterator I48MODE [SI DI])
98 (define_mode_attr modesuffix [(SI "l") (DI "q")])
99
100 ;; Where necessary, the suffixes _le and _be are used to distinguish between
101 ;; little-endian and big-endian patterns.
102 ;;
103 ;; Note that the Unicos/Mk assembler does not support the following
104 ;; opcodes: mov, fmov, nop, fnop, unop.
105 \f
106 ;; Processor type -- this attribute must exactly match the processor_type
107 ;; enumeration in alpha.h.
108
109 (define_attr "tune" "ev4,ev5,ev6"
110   (const (symbol_ref "((enum attr_tune) alpha_tune)")))
111
112 ;; Define an insn type attribute.  This is used in function unit delay
113 ;; computations, among other purposes.  For the most part, we use the names
114 ;; defined in the EV4 documentation, but add a few that we have to know about
115 ;; separately.
116
117 (define_attr "type"
118   "ild,fld,ldsym,ist,fst,ibr,callpal,fbr,jsr,iadd,ilog,shift,icmov,fcmov,
119    icmp,imul,fadd,fmul,fcpys,fdiv,fsqrt,misc,mvi,ftoi,itof,mb,ld_l,st_c,
120    multi,none"
121   (const_string "iadd"))
122
123 ;; Describe a user's asm statement.
124 (define_asm_attributes
125   [(set_attr "type" "multi")])
126
127 ;; Define the operand size an insn operates on.  Used primarily by mul
128 ;; and div operations that have size dependent timings.
129
130 (define_attr "opsize" "si,di,udi"
131   (const_string "di"))
132
133 ;; The TRAP attribute marks instructions that may generate traps
134 ;; (which are imprecise and may need a trapb if software completion
135 ;; is desired).
136
137 (define_attr "trap" "no,yes"
138   (const_string "no"))
139
140 ;; The ROUND_SUFFIX attribute marks which instructions require a
141 ;; rounding-mode suffix.  The value NONE indicates no suffix,
142 ;; the value NORMAL indicates a suffix controlled by alpha_fprm.
143
144 (define_attr "round_suffix" "none,normal,c"
145   (const_string "none"))
146
147 ;; The TRAP_SUFFIX attribute marks instructions requiring a trap-mode suffix:
148 ;;   NONE       no suffix
149 ;;   SU         accepts only /su (cmpt et al)
150 ;;   SUI        accepts only /sui (cvtqt and cvtqs)
151 ;;   V_SV       accepts /v and /sv (cvtql only)
152 ;;   V_SV_SVI   accepts /v, /sv and /svi (cvttq only)
153 ;;   U_SU_SUI   accepts /u, /su and /sui (most fp instructions)
154 ;;
155 ;; The actual suffix emitted is controlled by alpha_fptm.
156
157 (define_attr "trap_suffix" "none,su,sui,v_sv,v_sv_svi,u_su_sui"
158   (const_string "none"))
159
160 ;; The length of an instruction sequence in bytes.
161
162 (define_attr "length" ""
163   (const_int 4))
164
165 ;; The USEGP attribute marks instructions that have relocations that use
166 ;; the GP.
167
168 (define_attr "usegp" "no,yes"
169   (cond [(eq_attr "type" "ldsym,jsr")
170            (const_string "yes")
171          (eq_attr "type" "ild,fld,ist,fst")
172            (symbol_ref "((enum attr_usegp) alpha_find_lo_sum_using_gp (insn))")
173         ]
174         (const_string "no")))
175
176 ;; The CANNOT_COPY attribute marks instructions with relocations that
177 ;; cannot easily be duplicated.  This includes insns with gpdisp relocs
178 ;; since they have to stay in 1-1 correspondence with one another.  This
179 ;; also includes jsr insns, since they must stay in correspondence with
180 ;; the immediately following gpdisp instructions.
181
182 (define_attr "cannot_copy" "false,true"
183   (const_string "false"))
184 \f
185 ;; Include scheduling descriptions.
186   
187 (include "ev4.md")
188 (include "ev5.md")
189 (include "ev6.md")
190
191 \f
192 ;; Operand and operator predicates and constraints
193
194 (include "predicates.md")
195 (include "constraints.md")
196
197 \f
198 ;; First define the arithmetic insns.  Note that the 32-bit forms also
199 ;; sign-extend.
200
201 ;; Handle 32-64 bit extension from memory to a floating point register
202 ;; specially, since this occurs frequently in int->double conversions.
203 ;;
204 ;; Note that while we must retain the =f case in the insn for reload's
205 ;; benefit, it should be eliminated after reload, so we should never emit
206 ;; code for that case.  But we don't reject the possibility.
207
208 (define_expand "extendsidi2"
209   [(set (match_operand:DI 0 "register_operand" "")
210         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "")))]
211   ""
212   "")
213
214 (define_insn "*cvtlq"
215   [(set (match_operand:DI 0 "register_operand" "=f")
216         (unspec:DI [(match_operand:SF 1 "reg_or_0_operand" "fG")]
217                    UNSPEC_CVTLQ))]
218   ""
219   "cvtlq %1,%0"
220   [(set_attr "type" "fadd")])
221
222 (define_insn "*extendsidi2_1"
223   [(set (match_operand:DI 0 "register_operand" "=r,r,!*f")
224         (sign_extend:DI
225           (match_operand:SI 1 "nonimmediate_operand" "r,m,m")))]
226   ""
227   "@
228    addl $31,%1,%0
229    ldl %0,%1
230    lds %0,%1\;cvtlq %0,%0"
231   [(set_attr "type" "iadd,ild,fld")
232    (set_attr "length" "*,*,8")])
233
234 (define_split
235   [(set (match_operand:DI 0 "hard_fp_register_operand" "")
236         (sign_extend:DI (match_operand:SI 1 "memory_operand" "")))]
237   "reload_completed"
238   [(set (match_dup 2) (match_dup 1))
239    (set (match_dup 0) (unspec:DI [(match_dup 2)] UNSPEC_CVTLQ))]
240 {
241   operands[1] = adjust_address (operands[1], SFmode, 0);
242   operands[2] = gen_rtx_REG (SFmode, REGNO (operands[0]));
243 })
244
245 ;; Optimize sign-extension of SImode loads.  This shows up in the wake of
246 ;; reload when converting fp->int.
247
248 (define_peephole2
249   [(set (match_operand:SI 0 "hard_int_register_operand" "")
250         (match_operand:SI 1 "memory_operand" ""))
251    (set (match_operand:DI 2 "hard_int_register_operand" "")
252         (sign_extend:DI (match_dup 0)))]
253   "true_regnum (operands[0]) == true_regnum (operands[2])
254    || peep2_reg_dead_p (2, operands[0])"
255   [(set (match_dup 2)
256         (sign_extend:DI (match_dup 1)))]
257   "")
258
259 (define_insn "addsi3"
260   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
261         (plus:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ,rJ,rJ,rJ")
262                  (match_operand:SI 2 "add_operand" "rI,O,K,L")))]
263   ""
264   "@
265    addl %r1,%2,%0
266    subl %r1,%n2,%0
267    lda %0,%2(%r1)
268    ldah %0,%h2(%r1)")
269
270 (define_split
271   [(set (match_operand:SI 0 "register_operand" "")
272         (plus:SI (match_operand:SI 1 "register_operand" "")
273                  (match_operand:SI 2 "const_int_operand" "")))]
274   "! add_operand (operands[2], SImode)"
275   [(set (match_dup 0) (plus:SI (match_dup 1) (match_dup 3)))
276    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 4)))]
277 {
278   HOST_WIDE_INT val = INTVAL (operands[2]);
279   HOST_WIDE_INT low = (val & 0xffff) - 2 * (val & 0x8000);
280   HOST_WIDE_INT rest = val - low;
281
282   operands[3] = GEN_INT (rest);
283   operands[4] = GEN_INT (low);
284 })
285
286 (define_insn "*addsi_se"
287   [(set (match_operand:DI 0 "register_operand" "=r,r")
288         (sign_extend:DI
289          (plus:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ,rJ")
290                   (match_operand:SI 2 "sext_add_operand" "rI,O"))))]
291   ""
292   "@
293    addl %r1,%2,%0
294    subl %r1,%n2,%0")
295
296 (define_insn "*addsi_se2"
297   [(set (match_operand:DI 0 "register_operand" "=r,r")
298         (sign_extend:DI
299          (subreg:SI (plus:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ,rJ")
300                              (match_operand:DI 2 "sext_add_operand" "rI,O"))
301                     0)))]
302   ""
303   "@
304    addl %r1,%2,%0
305    subl %r1,%n2,%0")
306
307 (define_split
308   [(set (match_operand:DI 0 "register_operand" "")
309         (sign_extend:DI
310          (plus:SI (match_operand:SI 1 "reg_not_elim_operand" "")
311                   (match_operand:SI 2 "const_int_operand" ""))))
312    (clobber (match_operand:SI 3 "reg_not_elim_operand" ""))]
313   "! sext_add_operand (operands[2], SImode) && INTVAL (operands[2]) > 0
314    && INTVAL (operands[2]) % 4 == 0"
315   [(set (match_dup 3) (match_dup 4))
316    (set (match_dup 0) (sign_extend:DI (plus:SI (mult:SI (match_dup 3)
317                                                         (match_dup 5))
318                                                (match_dup 1))))]
319 {
320   HOST_WIDE_INT val = INTVAL (operands[2]) / 4;
321   int mult = 4;
322
323   if (val % 2 == 0)
324     val /= 2, mult = 8;
325
326   operands[4] = GEN_INT (val);
327   operands[5] = GEN_INT (mult);
328 })
329
330 (define_split
331   [(set (match_operand:DI 0 "register_operand" "")
332         (sign_extend:DI
333          (plus:SI (match_operator:SI 1 "comparison_operator"
334                                      [(match_operand 2 "" "")
335                                       (match_operand 3 "" "")])
336                   (match_operand:SI 4 "add_operand" ""))))
337    (clobber (match_operand:DI 5 "register_operand" ""))]
338   ""
339   [(set (match_dup 5) (match_dup 6))
340    (set (match_dup 0) (sign_extend:DI (plus:SI (match_dup 7) (match_dup 4))))]
341 {
342   operands[6] = gen_rtx_fmt_ee (GET_CODE (operands[1]), DImode,
343                                 operands[2], operands[3]);
344   operands[7] = gen_lowpart (SImode, operands[5]);
345 })
346
347 (define_insn "addvsi3"
348   [(set (match_operand:SI 0 "register_operand" "=r,r")
349         (plus:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ,rJ")
350                  (match_operand:SI 2 "sext_add_operand" "rI,O")))
351    (trap_if (ne (plus:DI (sign_extend:DI (match_dup 1))
352                          (sign_extend:DI (match_dup 2)))
353                 (sign_extend:DI (plus:SI (match_dup 1)
354                                          (match_dup 2))))
355             (const_int 0))]
356   ""
357   "@
358    addlv %r1,%2,%0
359    sublv %r1,%n2,%0")
360
361 (define_expand "adddi3"
362   [(set (match_operand:DI 0 "register_operand" "")
363         (plus:DI (match_operand:DI 1 "register_operand" "")
364                  (match_operand:DI 2 "add_operand" "")))]
365   ""
366   "")
367
368 (define_insn "*adddi_er_lo16_dtp"
369   [(set (match_operand:DI 0 "register_operand" "=r")
370         (lo_sum:DI (match_operand:DI 1 "register_operand" "r")
371                    (match_operand:DI 2 "dtp16_symbolic_operand" "")))]
372   "HAVE_AS_TLS"
373   "lda %0,%2(%1)\t\t!dtprel")
374
375 (define_insn "*adddi_er_hi32_dtp"
376   [(set (match_operand:DI 0 "register_operand" "=r")
377         (plus:DI (match_operand:DI 1 "register_operand" "r")
378                  (high:DI (match_operand:DI 2 "dtp32_symbolic_operand" ""))))]
379   "HAVE_AS_TLS"
380   "ldah %0,%2(%1)\t\t!dtprelhi")
381
382 (define_insn "*adddi_er_lo32_dtp"
383   [(set (match_operand:DI 0 "register_operand" "=r")
384         (lo_sum:DI (match_operand:DI 1 "register_operand" "r")
385                    (match_operand:DI 2 "dtp32_symbolic_operand" "")))]
386   "HAVE_AS_TLS"
387   "lda %0,%2(%1)\t\t!dtprello")
388
389 (define_insn "*adddi_er_lo16_tp"
390   [(set (match_operand:DI 0 "register_operand" "=r")
391         (lo_sum:DI (match_operand:DI 1 "register_operand" "r")
392                    (match_operand:DI 2 "tp16_symbolic_operand" "")))]
393   "HAVE_AS_TLS"
394   "lda %0,%2(%1)\t\t!tprel")
395
396 (define_insn "*adddi_er_hi32_tp"
397   [(set (match_operand:DI 0 "register_operand" "=r")
398         (plus:DI (match_operand:DI 1 "register_operand" "r")
399                  (high:DI (match_operand:DI 2 "tp32_symbolic_operand" ""))))]
400   "HAVE_AS_TLS"
401   "ldah %0,%2(%1)\t\t!tprelhi")
402
403 (define_insn "*adddi_er_lo32_tp"
404   [(set (match_operand:DI 0 "register_operand" "=r")
405         (lo_sum:DI (match_operand:DI 1 "register_operand" "r")
406                    (match_operand:DI 2 "tp32_symbolic_operand" "")))]
407   "HAVE_AS_TLS"
408   "lda %0,%2(%1)\t\t!tprello")
409
410 (define_insn "*adddi_er_high_l"
411   [(set (match_operand:DI 0 "register_operand" "=r")
412         (plus:DI (match_operand:DI 1 "register_operand" "r")
413                  (high:DI (match_operand:DI 2 "local_symbolic_operand" ""))))]
414   "TARGET_EXPLICIT_RELOCS && reload_completed"
415   "ldah %0,%2(%1)\t\t!gprelhigh"
416   [(set_attr "usegp" "yes")])
417
418 (define_split
419   [(set (match_operand:DI 0 "register_operand" "")
420         (high:DI (match_operand:DI 1 "local_symbolic_operand" "")))]
421   "TARGET_EXPLICIT_RELOCS && reload_completed"
422   [(set (match_dup 0)
423         (plus:DI (match_dup 2) (high:DI (match_dup 1))))]
424   "operands[2] = pic_offset_table_rtx;")
425
426 ;; We used to expend quite a lot of effort choosing addq/subq/lda.
427 ;; With complications like
428 ;;
429 ;;   The NT stack unwind code can't handle a subq to adjust the stack
430 ;;   (that's a bug, but not one we can do anything about).  As of NT4.0 SP3,
431 ;;   the exception handling code will loop if a subq is used and an
432 ;;   exception occurs.
433 ;;
434 ;;   The 19980616 change to emit prologues as RTL also confused some
435 ;;   versions of GDB, which also interprets prologues.  This has been
436 ;;   fixed as of GDB 4.18, but it does not harm to unconditionally
437 ;;   use lda here.
438 ;;
439 ;; and the fact that the three insns schedule exactly the same, it's
440 ;; just not worth the effort.
441
442 (define_insn "*adddi_internal"
443   [(set (match_operand:DI 0 "register_operand" "=r,r,r")
444         (plus:DI (match_operand:DI 1 "register_operand" "%r,r,r")
445                  (match_operand:DI 2 "add_operand" "r,K,L")))]
446   ""
447   "@
448    addq %1,%2,%0
449    lda %0,%2(%1)
450    ldah %0,%h2(%1)")
451
452 ;; ??? Allow large constants when basing off the frame pointer or some
453 ;; virtual register that may eliminate to the frame pointer.  This is
454 ;; done because register elimination offsets will change the hi/lo split,
455 ;; and if we split before reload, we will require additional instructions.
456
457 (define_insn "*adddi_fp_hack"
458   [(set (match_operand:DI 0 "register_operand" "=r,r,r")
459         (plus:DI (match_operand:DI 1 "reg_no_subreg_operand" "r,r,r")
460                  (match_operand:DI 2 "const_int_operand" "K,L,n")))]
461   "NONSTRICT_REG_OK_FP_BASE_P (operands[1])
462    && INTVAL (operands[2]) >= 0
463    /* This is the largest constant an lda+ldah pair can add, minus
464       an upper bound on the displacement between SP and AP during
465       register elimination.  See INITIAL_ELIMINATION_OFFSET.  */
466    && INTVAL (operands[2])
467         < (0x7fff8000
468            - FIRST_PSEUDO_REGISTER * UNITS_PER_WORD
469            - ALPHA_ROUND(crtl->outgoing_args_size)
470            - (ALPHA_ROUND (get_frame_size ()
471                            + max_reg_num () * UNITS_PER_WORD
472                            + crtl->args.pretend_args_size)
473               - crtl->args.pretend_args_size))"
474   "@
475    lda %0,%2(%1)
476    ldah %0,%h2(%1)
477    #")
478
479 ;; Don't do this if we are adjusting SP since we don't want to do it
480 ;; in two steps.  Don't split FP sources for the reason listed above.
481 (define_split
482   [(set (match_operand:DI 0 "register_operand" "")
483         (plus:DI (match_operand:DI 1 "register_operand" "")
484                  (match_operand:DI 2 "const_int_operand" "")))]
485   "! add_operand (operands[2], DImode)
486    && operands[0] != stack_pointer_rtx
487    && operands[1] != frame_pointer_rtx
488    && operands[1] != arg_pointer_rtx"
489   [(set (match_dup 0) (plus:DI (match_dup 1) (match_dup 3)))
490    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 4)))]
491 {
492   HOST_WIDE_INT val = INTVAL (operands[2]);
493   HOST_WIDE_INT low = (val & 0xffff) - 2 * (val & 0x8000);
494   HOST_WIDE_INT rest = val - low;
495   rtx rest_rtx = GEN_INT (rest);
496
497   operands[4] = GEN_INT (low);
498   if (satisfies_constraint_L (rest_rtx))
499     operands[3] = rest_rtx;
500   else if (can_create_pseudo_p ())
501     {
502       operands[3] = gen_reg_rtx (DImode);
503       emit_move_insn (operands[3], operands[2]);
504       emit_insn (gen_adddi3 (operands[0], operands[1], operands[3]));
505       DONE;
506     }
507   else
508     FAIL;
509 })
510
511 (define_insn "*saddl"
512   [(set (match_operand:SI 0 "register_operand" "=r,r")
513         (plus:SI (mult:SI (match_operand:SI 1 "reg_not_elim_operand" "r,r")
514                           (match_operand:SI 2 "const48_operand" "I,I"))
515                  (match_operand:SI 3 "sext_add_operand" "rI,O")))]
516   ""
517   "@
518    s%2addl %1,%3,%0
519    s%2subl %1,%n3,%0")
520
521 (define_insn "*saddl_se"
522   [(set (match_operand:DI 0 "register_operand" "=r,r")
523         (sign_extend:DI
524          (plus:SI (mult:SI (match_operand:SI 1 "reg_not_elim_operand" "r,r")
525                            (match_operand:SI 2 "const48_operand" "I,I"))
526                   (match_operand:SI 3 "sext_add_operand" "rI,O"))))]
527   ""
528   "@
529    s%2addl %1,%3,%0
530    s%2subl %1,%n3,%0")
531
532 (define_split
533   [(set (match_operand:DI 0 "register_operand" "")
534         (sign_extend:DI
535          (plus:SI (mult:SI (match_operator:SI 1 "comparison_operator"
536                                               [(match_operand 2 "" "")
537                                                (match_operand 3 "" "")])
538                            (match_operand:SI 4 "const48_operand" ""))
539                   (match_operand:SI 5 "sext_add_operand" ""))))
540    (clobber (match_operand:DI 6 "reg_not_elim_operand" ""))]
541   ""
542   [(set (match_dup 6) (match_dup 7))
543    (set (match_dup 0)
544         (sign_extend:DI (plus:SI (mult:SI (match_dup 8) (match_dup 4))
545                                  (match_dup 5))))]
546 {
547   operands[7] = gen_rtx_fmt_ee (GET_CODE (operands[1]), DImode,
548                                 operands[2], operands[3]);
549   operands[8] = gen_lowpart (SImode, operands[6]);
550 })
551
552 (define_insn "*saddq"
553   [(set (match_operand:DI 0 "register_operand" "=r,r")
554         (plus:DI (mult:DI (match_operand:DI 1 "reg_not_elim_operand" "r,r")
555                           (match_operand:DI 2 "const48_operand" "I,I"))
556                  (match_operand:DI 3 "sext_add_operand" "rI,O")))]
557   ""
558   "@
559    s%2addq %1,%3,%0
560    s%2subq %1,%n3,%0")
561
562 (define_insn "addvdi3"
563   [(set (match_operand:DI 0 "register_operand" "=r,r")
564         (plus:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ,rJ")
565                  (match_operand:DI 2 "sext_add_operand" "rI,O")))
566    (trap_if (ne (plus:TI (sign_extend:TI (match_dup 1))
567                          (sign_extend:TI (match_dup 2)))
568                 (sign_extend:TI (plus:DI (match_dup 1)
569                                          (match_dup 2))))
570             (const_int 0))]
571   ""
572   "@
573    addqv %r1,%2,%0
574    subqv %r1,%n2,%0")
575
576 (define_insn "negsi2"
577   [(set (match_operand:SI 0 "register_operand" "=r")
578         (neg:SI (match_operand:SI 1 "reg_or_8bit_operand" "rI")))]
579   ""
580   "subl $31,%1,%0")
581
582 (define_insn "*negsi_se"
583   [(set (match_operand:DI 0 "register_operand" "=r")
584         (sign_extend:DI (neg:SI
585                          (match_operand:SI 1 "reg_or_8bit_operand" "rI"))))]
586   ""
587   "subl $31,%1,%0")
588
589 (define_insn "negvsi2"
590   [(set (match_operand:SI 0 "register_operand" "=r")
591         (neg:SI (match_operand:SI 1 "register_operand" "r")))
592    (trap_if (ne (neg:DI (sign_extend:DI (match_dup 1)))
593                 (sign_extend:DI (neg:SI (match_dup 1))))
594             (const_int 0))]
595   ""
596   "sublv $31,%1,%0")
597
598 (define_insn "negdi2"
599   [(set (match_operand:DI 0 "register_operand" "=r")
600         (neg:DI (match_operand:DI 1 "reg_or_8bit_operand" "rI")))]
601   ""
602   "subq $31,%1,%0")
603
604 (define_insn "negvdi2"
605   [(set (match_operand:DI 0 "register_operand" "=r")
606         (neg:DI (match_operand:DI 1 "register_operand" "r")))
607    (trap_if (ne (neg:TI (sign_extend:TI (match_dup 1)))
608                 (sign_extend:TI (neg:DI (match_dup 1))))
609             (const_int 0))]
610   ""
611   "subqv $31,%1,%0")
612
613 (define_insn "subsi3"
614   [(set (match_operand:SI 0 "register_operand" "=r")
615         (minus:SI (match_operand:SI 1 "reg_or_0_operand" "rJ")
616                   (match_operand:SI 2 "reg_or_8bit_operand" "rI")))]
617   ""
618   "subl %r1,%2,%0")
619
620 (define_insn "*subsi_se"
621   [(set (match_operand:DI 0 "register_operand" "=r")
622         (sign_extend:DI (minus:SI (match_operand:SI 1 "reg_or_0_operand" "rJ")
623                                   (match_operand:SI 2 "reg_or_8bit_operand" "rI"))))]
624   ""
625   "subl %r1,%2,%0")
626
627 (define_insn "*subsi_se2"
628   [(set (match_operand:DI 0 "register_operand" "=r")
629         (sign_extend:DI
630          (subreg:SI (minus:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
631                               (match_operand:DI 2 "reg_or_8bit_operand" "rI"))
632                     0)))]
633   ""
634   "subl %r1,%2,%0")
635
636 (define_insn "subvsi3"
637   [(set (match_operand:SI 0 "register_operand" "=r")
638         (minus:SI (match_operand:SI 1 "reg_or_0_operand" "rJ")
639                   (match_operand:SI 2 "reg_or_8bit_operand" "rI")))
640    (trap_if (ne (minus:DI (sign_extend:DI (match_dup 1))
641                           (sign_extend:DI (match_dup 2)))
642                 (sign_extend:DI (minus:SI (match_dup 1)
643                                           (match_dup 2))))
644             (const_int 0))]
645   ""
646   "sublv %r1,%2,%0")
647
648 (define_insn "subdi3"
649   [(set (match_operand:DI 0 "register_operand" "=r")
650         (minus:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
651                   (match_operand:DI 2 "reg_or_8bit_operand" "rI")))]
652   ""
653   "subq %r1,%2,%0")
654
655 (define_insn "*ssubl"
656   [(set (match_operand:SI 0 "register_operand" "=r")
657         (minus:SI (mult:SI (match_operand:SI 1 "reg_not_elim_operand" "r")
658                            (match_operand:SI 2 "const48_operand" "I"))
659                   (match_operand:SI 3 "reg_or_8bit_operand" "rI")))]
660   ""
661   "s%2subl %1,%3,%0")
662
663 (define_insn "*ssubl_se"
664   [(set (match_operand:DI 0 "register_operand" "=r")
665         (sign_extend:DI
666          (minus:SI (mult:SI (match_operand:SI 1 "reg_not_elim_operand" "r")
667                             (match_operand:SI 2 "const48_operand" "I"))
668                    (match_operand:SI 3 "reg_or_8bit_operand" "rI"))))]
669   ""
670   "s%2subl %1,%3,%0")
671
672 (define_insn "*ssubq"
673   [(set (match_operand:DI 0 "register_operand" "=r")
674         (minus:DI (mult:DI (match_operand:DI 1 "reg_not_elim_operand" "r")
675                            (match_operand:DI 2 "const48_operand" "I"))
676                   (match_operand:DI 3 "reg_or_8bit_operand" "rI")))]
677   ""
678   "s%2subq %1,%3,%0")
679
680 (define_insn "subvdi3"
681   [(set (match_operand:DI 0 "register_operand" "=r")
682         (minus:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
683                   (match_operand:DI 2 "reg_or_8bit_operand" "rI")))
684    (trap_if (ne (minus:TI (sign_extend:TI (match_dup 1))
685                           (sign_extend:TI (match_dup 2)))
686                 (sign_extend:TI (minus:DI (match_dup 1)
687                                           (match_dup 2))))
688             (const_int 0))]
689   ""
690   "subqv %r1,%2,%0")
691
692 ;; The Unicos/Mk assembler doesn't support mull.
693
694 (define_insn "mulsi3"
695   [(set (match_operand:SI 0 "register_operand" "=r")
696         (mult:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ")
697                  (match_operand:SI 2 "reg_or_8bit_operand" "rI")))]
698   "!TARGET_ABI_UNICOSMK"
699   "mull %r1,%2,%0"
700   [(set_attr "type" "imul")
701    (set_attr "opsize" "si")])
702
703 (define_insn "*mulsi_se"
704   [(set (match_operand:DI 0 "register_operand" "=r")
705         (sign_extend:DI
706           (mult:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ")
707                    (match_operand:SI 2 "reg_or_8bit_operand" "rI"))))]
708   "!TARGET_ABI_UNICOSMK"
709   "mull %r1,%2,%0"
710   [(set_attr "type" "imul")
711    (set_attr "opsize" "si")])
712
713 (define_insn "mulvsi3"
714   [(set (match_operand:SI 0 "register_operand" "=r")
715         (mult:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ")
716                  (match_operand:SI 2 "reg_or_8bit_operand" "rI")))
717    (trap_if (ne (mult:DI (sign_extend:DI (match_dup 1))
718                          (sign_extend:DI (match_dup 2)))
719                 (sign_extend:DI (mult:SI (match_dup 1)
720                                          (match_dup 2))))
721             (const_int 0))]
722   "!TARGET_ABI_UNICOSMK"
723   "mullv %r1,%2,%0"
724   [(set_attr "type" "imul")
725    (set_attr "opsize" "si")])
726
727 (define_insn "muldi3"
728   [(set (match_operand:DI 0 "register_operand" "=r")
729         (mult:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ")
730                  (match_operand:DI 2 "reg_or_8bit_operand" "rI")))]
731   ""
732   "mulq %r1,%2,%0"
733   [(set_attr "type" "imul")])
734
735 (define_insn "mulvdi3"
736   [(set (match_operand:DI 0 "register_operand" "=r")
737         (mult:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ")
738                  (match_operand:DI 2 "reg_or_8bit_operand" "rI")))
739    (trap_if (ne (mult:TI (sign_extend:TI (match_dup 1))
740                          (sign_extend:TI (match_dup 2)))
741                 (sign_extend:TI (mult:DI (match_dup 1)
742                                          (match_dup 2))))
743             (const_int 0))]
744   ""
745   "mulqv %r1,%2,%0"
746   [(set_attr "type" "imul")])
747
748 (define_expand "umuldi3_highpart"
749   [(set (match_operand:DI 0 "register_operand" "")
750         (truncate:DI
751          (lshiftrt:TI
752           (mult:TI (zero_extend:TI
753                      (match_operand:DI 1 "register_operand" ""))
754                    (match_operand:DI 2 "reg_or_8bit_operand" ""))
755           (const_int 64))))]
756   ""
757 {
758   if (REG_P (operands[2]))
759     operands[2] = gen_rtx_ZERO_EXTEND (TImode, operands[2]);
760 })
761
762 (define_insn "*umuldi3_highpart_reg"
763   [(set (match_operand:DI 0 "register_operand" "=r")
764         (truncate:DI
765          (lshiftrt:TI
766           (mult:TI (zero_extend:TI
767                      (match_operand:DI 1 "register_operand" "r"))
768                    (zero_extend:TI
769                      (match_operand:DI 2 "register_operand" "r")))
770           (const_int 64))))]
771   ""
772   "umulh %1,%2,%0"
773   [(set_attr "type" "imul")
774    (set_attr "opsize" "udi")])
775
776 (define_insn "*umuldi3_highpart_const"
777   [(set (match_operand:DI 0 "register_operand" "=r")
778         (truncate:DI
779          (lshiftrt:TI
780           (mult:TI (zero_extend:TI (match_operand:DI 1 "register_operand" "r"))
781                    (match_operand:TI 2 "cint8_operand" "I"))
782           (const_int 64))))]
783   ""
784   "umulh %1,%2,%0"
785   [(set_attr "type" "imul")
786    (set_attr "opsize" "udi")])
787 \f
788 ;; The divide and remainder operations take their inputs from r24 and
789 ;; r25, put their output in r27, and clobber r23 and r28 on all
790 ;; systems except Unicos/Mk. On Unicos, the standard library provides
791 ;; subroutines which use the standard calling convention and work on
792 ;; DImode operands.
793
794 ;; ??? Force sign-extension here because some versions of OSF/1 and
795 ;; Interix/NT don't do the right thing if the inputs are not properly
796 ;; sign-extended.  But Linux, for instance, does not have this
797 ;; problem.  Is it worth the complication here to eliminate the sign
798 ;; extension?
799
800 (define_expand "divsi3"
801   [(set (match_dup 3)
802         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "")))
803    (set (match_dup 4)
804         (sign_extend:DI (match_operand:SI 2 "nonimmediate_operand" "")))
805    (parallel [(set (match_dup 5)
806                    (sign_extend:DI (div:SI (match_dup 3) (match_dup 4))))
807               (clobber (reg:DI 23))
808               (clobber (reg:DI 28))])
809    (set (match_operand:SI 0 "nonimmediate_operand" "")
810         (subreg:SI (match_dup 5) 0))]
811   "! TARGET_ABI_OPEN_VMS && ! TARGET_ABI_UNICOSMK"
812 {
813   operands[3] = gen_reg_rtx (DImode);
814   operands[4] = gen_reg_rtx (DImode);
815   operands[5] = gen_reg_rtx (DImode);
816 })
817
818 (define_expand "udivsi3"
819   [(set (match_dup 3)
820         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "")))
821    (set (match_dup 4)
822         (sign_extend:DI (match_operand:SI 2 "nonimmediate_operand" "")))
823    (parallel [(set (match_dup 5)
824                    (sign_extend:DI (udiv:SI (match_dup 3) (match_dup 4))))
825               (clobber (reg:DI 23))
826               (clobber (reg:DI 28))])
827    (set (match_operand:SI 0 "nonimmediate_operand" "")
828         (subreg:SI (match_dup 5) 0))]
829   "! TARGET_ABI_OPEN_VMS && ! TARGET_ABI_UNICOSMK"
830 {
831   operands[3] = gen_reg_rtx (DImode);
832   operands[4] = gen_reg_rtx (DImode);
833   operands[5] = gen_reg_rtx (DImode);
834 })
835
836 (define_expand "modsi3"
837   [(set (match_dup 3)
838         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "")))
839    (set (match_dup 4)
840         (sign_extend:DI (match_operand:SI 2 "nonimmediate_operand" "")))
841    (parallel [(set (match_dup 5)
842                    (sign_extend:DI (mod:SI (match_dup 3) (match_dup 4))))
843               (clobber (reg:DI 23))
844               (clobber (reg:DI 28))])
845    (set (match_operand:SI 0 "nonimmediate_operand" "")
846         (subreg:SI (match_dup 5) 0))]
847   "! TARGET_ABI_OPEN_VMS && ! TARGET_ABI_UNICOSMK"
848 {
849   operands[3] = gen_reg_rtx (DImode);
850   operands[4] = gen_reg_rtx (DImode);
851   operands[5] = gen_reg_rtx (DImode);
852 })
853
854 (define_expand "umodsi3"
855   [(set (match_dup 3)
856         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "")))
857    (set (match_dup 4)
858         (sign_extend:DI (match_operand:SI 2 "nonimmediate_operand" "")))
859    (parallel [(set (match_dup 5)
860                    (sign_extend:DI (umod:SI (match_dup 3) (match_dup 4))))
861               (clobber (reg:DI 23))
862               (clobber (reg:DI 28))])
863    (set (match_operand:SI 0 "nonimmediate_operand" "")
864         (subreg:SI (match_dup 5) 0))]
865   "! TARGET_ABI_OPEN_VMS && ! TARGET_ABI_UNICOSMK"
866 {
867   operands[3] = gen_reg_rtx (DImode);
868   operands[4] = gen_reg_rtx (DImode);
869   operands[5] = gen_reg_rtx (DImode);
870 })
871
872 (define_expand "divdi3"
873   [(parallel [(set (match_operand:DI 0 "register_operand" "")
874                    (div:DI (match_operand:DI 1 "register_operand" "")
875                            (match_operand:DI 2 "register_operand" "")))
876               (clobber (reg:DI 23))
877               (clobber (reg:DI 28))])]
878   "! TARGET_ABI_OPEN_VMS && ! TARGET_ABI_UNICOSMK"
879   "")
880
881 (define_expand "udivdi3"
882   [(parallel [(set (match_operand:DI 0 "register_operand" "")
883                    (udiv:DI (match_operand:DI 1 "register_operand" "")
884                             (match_operand:DI 2 "register_operand" "")))
885               (clobber (reg:DI 23))
886               (clobber (reg:DI 28))])]
887   "! TARGET_ABI_OPEN_VMS && ! TARGET_ABI_UNICOSMK"
888   "")
889
890 (define_expand "moddi3"
891   [(use (match_operand:DI 0 "register_operand" ""))
892    (use (match_operand:DI 1 "register_operand" ""))
893    (use (match_operand:DI 2 "register_operand" ""))]
894   "!TARGET_ABI_OPEN_VMS"
895 {
896   if (TARGET_ABI_UNICOSMK)
897     emit_insn (gen_moddi3_umk (operands[0], operands[1], operands[2]));
898   else
899     emit_insn (gen_moddi3_dft (operands[0], operands[1], operands[2]));
900   DONE;
901 })
902
903 (define_expand "moddi3_dft"
904   [(parallel [(set (match_operand:DI 0 "register_operand" "")
905                    (mod:DI (match_operand:DI 1 "register_operand" "")
906                            (match_operand:DI 2 "register_operand" "")))
907               (clobber (reg:DI 23))
908               (clobber (reg:DI 28))])]
909   "! TARGET_ABI_OPEN_VMS && ! TARGET_ABI_UNICOSMK"
910   "")
911
912 ;; On Unicos/Mk, we do as the system's C compiler does:
913 ;; compute the quotient, multiply and subtract.
914
915 (define_expand "moddi3_umk"
916   [(use (match_operand:DI 0 "register_operand" ""))
917    (use (match_operand:DI 1 "register_operand" ""))
918    (use (match_operand:DI 2 "register_operand" ""))]
919   "TARGET_ABI_UNICOSMK"
920 {
921   rtx div, mul = gen_reg_rtx (DImode);
922
923   div = expand_binop (DImode, sdiv_optab, operands[1], operands[2],
924                       NULL_RTX, 0, OPTAB_LIB);
925   div = force_reg (DImode, div);
926   emit_insn (gen_muldi3 (mul, operands[2], div));
927   emit_insn (gen_subdi3 (operands[0], operands[1], mul));
928   DONE;
929 })
930
931 (define_expand "umoddi3"
932   [(use (match_operand:DI 0 "register_operand" ""))
933    (use (match_operand:DI 1 "register_operand" ""))
934    (use (match_operand:DI 2 "register_operand" ""))]
935   "! TARGET_ABI_OPEN_VMS"
936 {
937   if (TARGET_ABI_UNICOSMK)
938     emit_insn (gen_umoddi3_umk (operands[0], operands[1], operands[2]));
939   else
940     emit_insn (gen_umoddi3_dft (operands[0], operands[1], operands[2]));
941   DONE;
942 })
943
944 (define_expand "umoddi3_dft"
945   [(parallel [(set (match_operand:DI 0 "register_operand" "")
946                    (umod:DI (match_operand:DI 1 "register_operand" "")
947                             (match_operand:DI 2 "register_operand" "")))
948               (clobber (reg:DI 23))
949               (clobber (reg:DI 28))])]
950   "! TARGET_ABI_OPEN_VMS && ! TARGET_ABI_UNICOSMK"
951   "")
952
953 (define_expand "umoddi3_umk"
954   [(use (match_operand:DI 0 "register_operand" ""))
955    (use (match_operand:DI 1 "register_operand" ""))
956    (use (match_operand:DI 2 "register_operand" ""))]
957   "TARGET_ABI_UNICOSMK"
958 {
959   rtx div, mul = gen_reg_rtx (DImode);
960
961   div = expand_binop (DImode, udiv_optab, operands[1], operands[2],
962                       NULL_RTX, 1, OPTAB_LIB);
963   div = force_reg (DImode, div);
964   emit_insn (gen_muldi3 (mul, operands[2], div));
965   emit_insn (gen_subdi3 (operands[0], operands[1], mul));
966   DONE;
967 })
968
969 ;; Lengths of 8 for ldq $t12,__divq($gp); jsr $t9,($t12),__divq as
970 ;; expanded by the assembler.
971
972 (define_insn_and_split "*divmodsi_internal_er"
973   [(set (match_operand:DI 0 "register_operand" "=c")
974         (sign_extend:DI (match_operator:SI 3 "divmod_operator"
975                         [(match_operand:DI 1 "register_operand" "a")
976                          (match_operand:DI 2 "register_operand" "b")])))
977    (clobber (reg:DI 23))
978    (clobber (reg:DI 28))]
979   "TARGET_EXPLICIT_RELOCS && ! TARGET_ABI_OPEN_VMS"
980   "#"
981   "&& reload_completed"
982   [(parallel [(set (match_dup 0)
983                    (sign_extend:DI (match_dup 3)))
984               (use (match_dup 0))
985               (use (match_dup 4))
986               (clobber (reg:DI 23))
987               (clobber (reg:DI 28))])]
988 {
989   const char *str;
990   switch (GET_CODE (operands[3]))
991     {
992     case DIV: 
993       str = "__divl";
994       break; 
995     case UDIV:
996       str = "__divlu";
997       break;
998     case MOD:
999       str = "__reml";
1000       break;
1001     case UMOD:
1002       str = "__remlu";
1003       break;
1004     default:
1005       gcc_unreachable ();
1006     }
1007   operands[4] = GEN_INT (alpha_next_sequence_number++);
1008   emit_insn (gen_movdi_er_high_g (operands[0], pic_offset_table_rtx,
1009                                   gen_rtx_SYMBOL_REF (DImode, str),
1010                                   operands[4]));
1011 }
1012   [(set_attr "type" "jsr")
1013    (set_attr "length" "8")])
1014
1015 (define_insn "*divmodsi_internal_er_1"
1016   [(set (match_operand:DI 0 "register_operand" "=c")
1017         (sign_extend:DI (match_operator:SI 3 "divmod_operator"
1018                         [(match_operand:DI 1 "register_operand" "a")
1019                          (match_operand:DI 2 "register_operand" "b")])))
1020    (use (match_operand:DI 4 "register_operand" "c"))
1021    (use (match_operand 5 "const_int_operand" ""))
1022    (clobber (reg:DI 23))
1023    (clobber (reg:DI 28))]
1024   "TARGET_EXPLICIT_RELOCS && ! TARGET_ABI_OPEN_VMS"
1025   "jsr $23,($27),__%E3%j5"
1026   [(set_attr "type" "jsr")
1027    (set_attr "length" "4")])
1028
1029 (define_insn "*divmodsi_internal"
1030   [(set (match_operand:DI 0 "register_operand" "=c")
1031         (sign_extend:DI (match_operator:SI 3 "divmod_operator"
1032                         [(match_operand:DI 1 "register_operand" "a")
1033                          (match_operand:DI 2 "register_operand" "b")])))
1034    (clobber (reg:DI 23))
1035    (clobber (reg:DI 28))]
1036   "! TARGET_ABI_OPEN_VMS && ! TARGET_ABI_UNICOSMK"
1037   "%E3 %1,%2,%0"
1038   [(set_attr "type" "jsr")
1039    (set_attr "length" "8")])
1040
1041 (define_insn_and_split "*divmoddi_internal_er"
1042   [(set (match_operand:DI 0 "register_operand" "=c")
1043         (match_operator:DI 3 "divmod_operator"
1044                         [(match_operand:DI 1 "register_operand" "a")
1045                          (match_operand:DI 2 "register_operand" "b")]))
1046    (clobber (reg:DI 23))
1047    (clobber (reg:DI 28))]
1048   "TARGET_EXPLICIT_RELOCS && ! TARGET_ABI_OPEN_VMS"
1049   "#"
1050   "&& reload_completed"
1051   [(parallel [(set (match_dup 0) (match_dup 3))
1052               (use (match_dup 0))
1053               (use (match_dup 4))
1054               (clobber (reg:DI 23))
1055               (clobber (reg:DI 28))])]
1056 {
1057   const char *str;
1058   switch (GET_CODE (operands[3]))
1059     {
1060     case DIV: 
1061       str = "__divq";
1062       break; 
1063     case UDIV:
1064       str = "__divqu";
1065       break;
1066     case MOD:
1067       str = "__remq";
1068       break;
1069     case UMOD:
1070       str = "__remqu";
1071       break;
1072     default:
1073       gcc_unreachable ();
1074     }
1075   operands[4] = GEN_INT (alpha_next_sequence_number++);
1076   emit_insn (gen_movdi_er_high_g (operands[0], pic_offset_table_rtx,
1077                                   gen_rtx_SYMBOL_REF (DImode, str),
1078                                   operands[4]));
1079 }
1080   [(set_attr "type" "jsr")
1081    (set_attr "length" "8")])
1082
1083 (define_insn "*divmoddi_internal_er_1"
1084   [(set (match_operand:DI 0 "register_operand" "=c")
1085         (match_operator:DI 3 "divmod_operator"
1086                         [(match_operand:DI 1 "register_operand" "a")
1087                          (match_operand:DI 2 "register_operand" "b")]))
1088    (use (match_operand:DI 4 "register_operand" "c"))
1089    (use (match_operand 5 "const_int_operand" ""))
1090    (clobber (reg:DI 23))
1091    (clobber (reg:DI 28))]
1092   "TARGET_EXPLICIT_RELOCS && ! TARGET_ABI_OPEN_VMS"
1093   "jsr $23,($27),__%E3%j5"
1094   [(set_attr "type" "jsr")
1095    (set_attr "length" "4")])
1096
1097 (define_insn "*divmoddi_internal"
1098   [(set (match_operand:DI 0 "register_operand" "=c")
1099         (match_operator:DI 3 "divmod_operator"
1100                         [(match_operand:DI 1 "register_operand" "a")
1101                          (match_operand:DI 2 "register_operand" "b")]))
1102    (clobber (reg:DI 23))
1103    (clobber (reg:DI 28))]
1104   "! TARGET_ABI_OPEN_VMS && ! TARGET_ABI_UNICOSMK"
1105   "%E3 %1,%2,%0"
1106   [(set_attr "type" "jsr")
1107    (set_attr "length" "8")])
1108 \f
1109 ;; Next are the basic logical operations.  We only expose the DImode operations
1110 ;; to the rtl expanders, but SImode versions exist for combine as well as for
1111 ;; the atomic operation splitters.
1112
1113 (define_insn "*andsi_internal"
1114   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1115         (and:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ,rJ,rJ")
1116                 (match_operand:SI 2 "and_operand" "rI,N,MH")))]
1117   ""
1118   "@
1119    and %r1,%2,%0
1120    bic %r1,%N2,%0
1121    zapnot %r1,%m2,%0"
1122   [(set_attr "type" "ilog,ilog,shift")])
1123
1124 (define_insn "anddi3"
1125   [(set (match_operand:DI 0 "register_operand" "=r,r,r")
1126         (and:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ,rJ,rJ")
1127                 (match_operand:DI 2 "and_operand" "rI,N,MH")))]
1128   ""
1129   "@
1130    and %r1,%2,%0
1131    bic %r1,%N2,%0
1132    zapnot %r1,%m2,%0"
1133   [(set_attr "type" "ilog,ilog,shift")])
1134
1135 ;; There are times when we can split an AND into two AND insns.  This occurs
1136 ;; when we can first clear any bytes and then clear anything else.  For
1137 ;; example "I & 0xffff07" is "(I & 0xffffff) & 0xffffffffffffff07".
1138 ;; Only do this when running on 64-bit host since the computations are
1139 ;; too messy otherwise.
1140
1141 (define_split
1142   [(set (match_operand:DI 0 "register_operand" "")
1143         (and:DI (match_operand:DI 1 "register_operand" "")
1144                 (match_operand:DI 2 "const_int_operand" "")))]
1145   "HOST_BITS_PER_WIDE_INT == 64 && ! and_operand (operands[2], DImode)"
1146   [(set (match_dup 0) (and:DI (match_dup 1) (match_dup 3)))
1147    (set (match_dup 0) (and:DI (match_dup 0) (match_dup 4)))]
1148 {
1149   unsigned HOST_WIDE_INT mask1 = INTVAL (operands[2]);
1150   unsigned HOST_WIDE_INT mask2 = mask1;
1151   int i;
1152
1153   /* For each byte that isn't all zeros, make it all ones.  */
1154   for (i = 0; i < 64; i += 8)
1155     if ((mask1 & ((HOST_WIDE_INT) 0xff << i)) != 0)
1156       mask1 |= (HOST_WIDE_INT) 0xff << i;
1157
1158   /* Now turn on any bits we've just turned off.  */
1159   mask2 |= ~ mask1;
1160
1161   operands[3] = GEN_INT (mask1);
1162   operands[4] = GEN_INT (mask2);
1163 })
1164
1165 (define_expand "zero_extendqihi2"
1166   [(set (match_operand:HI 0 "register_operand" "")
1167         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "")))]
1168   ""
1169 {
1170   if (! TARGET_BWX)
1171     operands[1] = force_reg (QImode, operands[1]);
1172 })
1173
1174 (define_insn "*zero_extendqihi2_bwx"
1175   [(set (match_operand:HI 0 "register_operand" "=r,r")
1176         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "r,m")))]
1177   "TARGET_BWX"
1178   "@
1179    and %1,0xff,%0
1180    ldbu %0,%1"
1181   [(set_attr "type" "ilog,ild")])
1182
1183 (define_insn "*zero_extendqihi2_nobwx"
1184   [(set (match_operand:HI 0 "register_operand" "=r")
1185         (zero_extend:HI (match_operand:QI 1 "register_operand" "r")))]
1186   "! TARGET_BWX"
1187   "and %1,0xff,%0"
1188   [(set_attr "type" "ilog")])
1189
1190 (define_expand "zero_extendqisi2"
1191   [(set (match_operand:SI 0 "register_operand" "")
1192         (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "")))]
1193   ""
1194 {
1195   if (! TARGET_BWX)
1196     operands[1] = force_reg (QImode, operands[1]);
1197 })
1198
1199 (define_insn "*zero_extendqisi2_bwx"
1200   [(set (match_operand:SI 0 "register_operand" "=r,r")
1201         (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "r,m")))]
1202   "TARGET_BWX"
1203   "@
1204    and %1,0xff,%0
1205    ldbu %0,%1"
1206   [(set_attr "type" "ilog,ild")])
1207
1208 (define_insn "*zero_extendqisi2_nobwx"
1209   [(set (match_operand:SI 0 "register_operand" "=r")
1210         (zero_extend:SI (match_operand:QI 1 "register_operand" "r")))]
1211   "! TARGET_BWX"
1212   "and %1,0xff,%0"
1213   [(set_attr "type" "ilog")])
1214
1215 (define_expand "zero_extendqidi2"
1216   [(set (match_operand:DI 0 "register_operand" "")
1217         (zero_extend:DI (match_operand:QI 1 "nonimmediate_operand" "")))]
1218   ""
1219 {
1220   if (! TARGET_BWX)
1221     operands[1] = force_reg (QImode, operands[1]);
1222 })
1223
1224 (define_insn "*zero_extendqidi2_bwx"
1225   [(set (match_operand:DI 0 "register_operand" "=r,r")
1226         (zero_extend:DI (match_operand:QI 1 "nonimmediate_operand" "r,m")))]
1227   "TARGET_BWX"
1228   "@
1229    and %1,0xff,%0
1230    ldbu %0,%1"
1231   [(set_attr "type" "ilog,ild")])
1232
1233 (define_insn "*zero_extendqidi2_nobwx"
1234   [(set (match_operand:DI 0 "register_operand" "=r")
1235         (zero_extend:DI (match_operand:QI 1 "register_operand" "r")))]
1236   "! TARGET_BWX"
1237   "and %1,0xff,%0"
1238   [(set_attr "type" "ilog")])
1239
1240 (define_expand "zero_extendhisi2"
1241   [(set (match_operand:SI 0 "register_operand" "")
1242         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "")))]
1243   ""
1244 {
1245   if (! TARGET_BWX)
1246     operands[1] = force_reg (HImode, operands[1]);
1247 })
1248
1249 (define_insn "*zero_extendhisi2_bwx"
1250   [(set (match_operand:SI 0 "register_operand" "=r,r")
1251         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "r,m")))]
1252   "TARGET_BWX"
1253   "@
1254    zapnot %1,3,%0
1255    ldwu %0,%1"
1256   [(set_attr "type" "shift,ild")])
1257
1258 (define_insn "*zero_extendhisi2_nobwx"
1259   [(set (match_operand:SI 0 "register_operand" "=r")
1260         (zero_extend:SI (match_operand:HI 1 "register_operand" "r")))]
1261   "! TARGET_BWX"
1262   "zapnot %1,3,%0"
1263   [(set_attr "type" "shift")])
1264
1265 (define_expand "zero_extendhidi2"
1266   [(set (match_operand:DI 0 "register_operand" "")
1267         (zero_extend:DI (match_operand:HI 1 "nonimmediate_operand" "")))]
1268   ""
1269 {
1270   if (! TARGET_BWX)
1271     operands[1] = force_reg (HImode, operands[1]);
1272 })
1273
1274 (define_insn "*zero_extendhidi2_bwx"
1275   [(set (match_operand:DI 0 "register_operand" "=r,r")
1276         (zero_extend:DI (match_operand:HI 1 "nonimmediate_operand" "r,m")))]
1277   "TARGET_BWX"
1278   "@
1279    zapnot %1,3,%0
1280    ldwu %0,%1"
1281   [(set_attr "type" "shift,ild")])
1282
1283 (define_insn "*zero_extendhidi2_nobwx"
1284   [(set (match_operand:DI 0 "register_operand" "=r")
1285         (zero_extend:DI (match_operand:HI 1 "register_operand" "r")))]
1286   ""
1287   "zapnot %1,3,%0"
1288   [(set_attr "type" "shift")])
1289
1290 (define_insn "zero_extendsidi2"
1291   [(set (match_operand:DI 0 "register_operand" "=r")
1292         (zero_extend:DI (match_operand:SI 1 "register_operand" "r")))]
1293   ""
1294   "zapnot %1,15,%0"
1295   [(set_attr "type" "shift")])
1296
1297 (define_insn "*andnotsi3"
1298   [(set (match_operand:SI 0 "register_operand" "=r")
1299         (and:SI (not:SI (match_operand:SI 1 "reg_or_8bit_operand" "rI"))
1300                 (match_operand:SI 2 "reg_or_0_operand" "rJ")))]
1301   ""
1302   "bic %r2,%1,%0"
1303   [(set_attr "type" "ilog")])
1304
1305 (define_insn "andnotdi3"
1306   [(set (match_operand:DI 0 "register_operand" "=r")
1307         (and:DI (not:DI (match_operand:DI 1 "reg_or_8bit_operand" "rI"))
1308                 (match_operand:DI 2 "reg_or_0_operand" "rJ")))]
1309   ""
1310   "bic %r2,%1,%0"
1311   [(set_attr "type" "ilog")])
1312
1313 (define_insn "*iorsi_internal"
1314   [(set (match_operand:SI 0 "register_operand" "=r,r")
1315         (ior:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ,rJ")
1316                 (match_operand:SI 2 "or_operand" "rI,N")))]
1317   ""
1318   "@
1319    bis %r1,%2,%0
1320    ornot %r1,%N2,%0"
1321   [(set_attr "type" "ilog")])
1322
1323 (define_insn "iordi3"
1324   [(set (match_operand:DI 0 "register_operand" "=r,r")
1325         (ior:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ,rJ")
1326                 (match_operand:DI 2 "or_operand" "rI,N")))]
1327   ""
1328   "@
1329    bis %r1,%2,%0
1330    ornot %r1,%N2,%0"
1331   [(set_attr "type" "ilog")])
1332
1333 (define_insn "*one_cmplsi_internal"
1334   [(set (match_operand:SI 0 "register_operand" "=r")
1335         (not:SI (match_operand:SI 1 "reg_or_8bit_operand" "rI")))]
1336   ""
1337   "ornot $31,%1,%0"
1338   [(set_attr "type" "ilog")])
1339
1340 (define_insn "one_cmpldi2"
1341   [(set (match_operand:DI 0 "register_operand" "=r")
1342         (not:DI (match_operand:DI 1 "reg_or_8bit_operand" "rI")))]
1343   ""
1344   "ornot $31,%1,%0"
1345   [(set_attr "type" "ilog")])
1346
1347 (define_insn "*iornotsi3"
1348   [(set (match_operand:SI 0 "register_operand" "=r")
1349         (ior:SI (not:SI (match_operand:SI 1 "reg_or_8bit_operand" "rI"))
1350                 (match_operand:SI 2 "reg_or_0_operand" "rJ")))]
1351   ""
1352   "ornot %r2,%1,%0"
1353   [(set_attr "type" "ilog")])
1354
1355 (define_insn "*iornotdi3"
1356   [(set (match_operand:DI 0 "register_operand" "=r")
1357         (ior:DI (not:DI (match_operand:DI 1 "reg_or_8bit_operand" "rI"))
1358                 (match_operand:DI 2 "reg_or_0_operand" "rJ")))]
1359   ""
1360   "ornot %r2,%1,%0"
1361   [(set_attr "type" "ilog")])
1362
1363 (define_insn "*xorsi_internal"
1364   [(set (match_operand:SI 0 "register_operand" "=r,r")
1365         (xor:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ,rJ")
1366                 (match_operand:SI 2 "or_operand" "rI,N")))]
1367   ""
1368   "@
1369    xor %r1,%2,%0
1370    eqv %r1,%N2,%0"
1371   [(set_attr "type" "ilog")])
1372
1373 (define_insn "xordi3"
1374   [(set (match_operand:DI 0 "register_operand" "=r,r")
1375         (xor:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ,rJ")
1376                 (match_operand:DI 2 "or_operand" "rI,N")))]
1377   ""
1378   "@
1379    xor %r1,%2,%0
1380    eqv %r1,%N2,%0"
1381   [(set_attr "type" "ilog")])
1382
1383 (define_insn "*xornotsi3"
1384   [(set (match_operand:SI 0 "register_operand" "=r")
1385         (not:SI (xor:SI (match_operand:SI 1 "register_operand" "%rJ")
1386                         (match_operand:SI 2 "register_operand" "rI"))))]
1387   ""
1388   "eqv %r1,%2,%0"
1389   [(set_attr "type" "ilog")])
1390
1391 (define_insn "*xornotdi3"
1392   [(set (match_operand:DI 0 "register_operand" "=r")
1393         (not:DI (xor:DI (match_operand:DI 1 "register_operand" "%rJ")
1394                         (match_operand:DI 2 "register_operand" "rI"))))]
1395   ""
1396   "eqv %r1,%2,%0"
1397   [(set_attr "type" "ilog")])
1398 \f
1399 ;; Handle FFS and related insns iff we support CIX.
1400
1401 (define_expand "ffsdi2"
1402   [(set (match_dup 2)
1403         (ctz:DI (match_operand:DI 1 "register_operand" "")))
1404    (set (match_dup 3)
1405         (plus:DI (match_dup 2) (const_int 1)))
1406    (set (match_operand:DI 0 "register_operand" "")
1407         (if_then_else:DI (eq (match_dup 1) (const_int 0))
1408                          (const_int 0) (match_dup 3)))]
1409   "TARGET_CIX"
1410 {
1411   operands[2] = gen_reg_rtx (DImode);
1412   operands[3] = gen_reg_rtx (DImode);
1413 })
1414
1415 (define_insn "clzdi2"
1416   [(set (match_operand:DI 0 "register_operand" "=r")
1417         (clz:DI (match_operand:DI 1 "register_operand" "r")))]
1418   "TARGET_CIX"
1419   "ctlz %1,%0"
1420   [(set_attr "type" "mvi")])
1421
1422 (define_insn "ctzdi2"
1423   [(set (match_operand:DI 0 "register_operand" "=r")
1424         (ctz:DI (match_operand:DI 1 "register_operand" "r")))]
1425   "TARGET_CIX"
1426   "cttz %1,%0"
1427   [(set_attr "type" "mvi")])
1428
1429 (define_insn "popcountdi2"
1430   [(set (match_operand:DI 0 "register_operand" "=r")
1431         (popcount:DI (match_operand:DI 1 "register_operand" "r")))]
1432   "TARGET_CIX"
1433   "ctpop %1,%0"
1434   [(set_attr "type" "mvi")])
1435
1436 (define_expand "bswapsi2"
1437   [(set (match_operand:SI 0 "register_operand" "")
1438         (bswap:SI (match_operand:SI 1 "register_operand" "")))]
1439   "!optimize_size"
1440 {
1441   rtx t0, t1;
1442
1443   t0 = gen_reg_rtx (DImode);
1444   t1 = gen_reg_rtx (DImode);
1445
1446   emit_insn (gen_insxh (t0, gen_lowpart (DImode, operands[1]),
1447                         GEN_INT (32), GEN_INT (WORDS_BIG_ENDIAN ? 0 : 7)));
1448   emit_insn (gen_inswl_const (t1, gen_lowpart (HImode, operands[1]),
1449                               GEN_INT (24)));
1450   emit_insn (gen_iordi3 (t1, t0, t1));
1451   emit_insn (gen_lshrdi3 (t0, t1, GEN_INT (16)));
1452   emit_insn (gen_anddi3 (t1, t1, alpha_expand_zap_mask (0x5)));
1453   emit_insn (gen_anddi3 (t0, t0, alpha_expand_zap_mask (0xa)));
1454   emit_insn (gen_addsi3 (operands[0], gen_lowpart (SImode, t0),
1455                          gen_lowpart (SImode, t1)));
1456   DONE;
1457 })
1458
1459 (define_expand "bswapdi2"
1460   [(set (match_operand:DI 0 "register_operand" "")
1461         (bswap:DI (match_operand:DI 1 "register_operand" "")))]
1462   "!optimize_size"
1463 {
1464   rtx t0, t1;
1465
1466   t0 = gen_reg_rtx (DImode);
1467   t1 = gen_reg_rtx (DImode);
1468
1469   /* This method of shifting and masking is not specific to Alpha, but
1470      is only profitable on Alpha because of our handy byte zap insn.  */
1471
1472   emit_insn (gen_lshrdi3 (t0, operands[1], GEN_INT (32)));
1473   emit_insn (gen_ashldi3 (t1, operands[1], GEN_INT (32)));
1474   emit_insn (gen_iordi3 (t1, t0, t1));
1475
1476   emit_insn (gen_lshrdi3 (t0, t1, GEN_INT (16)));
1477   emit_insn (gen_ashldi3 (t1, t1, GEN_INT (16)));
1478   emit_insn (gen_anddi3 (t0, t0, alpha_expand_zap_mask (0xcc)));
1479   emit_insn (gen_anddi3 (t1, t1, alpha_expand_zap_mask (0x33)));
1480   emit_insn (gen_iordi3 (t1, t0, t1));
1481
1482   emit_insn (gen_lshrdi3 (t0, t1, GEN_INT (8)));
1483   emit_insn (gen_ashldi3 (t1, t1, GEN_INT (8)));
1484   emit_insn (gen_anddi3 (t0, t0, alpha_expand_zap_mask (0xaa)));
1485   emit_insn (gen_anddi3 (t1, t1, alpha_expand_zap_mask (0x55)));
1486   emit_insn (gen_iordi3 (operands[0], t0, t1));
1487   DONE;
1488 })
1489 \f
1490 ;; Next come the shifts and the various extract and insert operations.
1491
1492 (define_insn "ashldi3"
1493   [(set (match_operand:DI 0 "register_operand" "=r,r")
1494         (ashift:DI (match_operand:DI 1 "reg_or_0_operand" "rJ,rJ")
1495                    (match_operand:DI 2 "reg_or_6bit_operand" "P,rS")))]
1496   ""
1497 {
1498   switch (which_alternative)
1499     {
1500     case 0:
1501       if (operands[2] == const1_rtx)
1502         return "addq %r1,%r1,%0";
1503       else
1504         return "s%P2addq %r1,0,%0";
1505     case 1:
1506       return "sll %r1,%2,%0";
1507     default:
1508       gcc_unreachable ();
1509     }
1510 }
1511   [(set_attr "type" "iadd,shift")])
1512
1513 (define_insn "*ashldi_se"
1514   [(set (match_operand:DI 0 "register_operand" "=r")
1515         (sign_extend:DI
1516          (subreg:SI (ashift:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1517                                (match_operand:DI 2 "const_int_operand" "P"))
1518                     0)))]
1519   "INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 3"
1520 {
1521   if (operands[2] == const1_rtx)
1522     return "addl %r1,%r1,%0";
1523   else
1524     return "s%P2addl %r1,0,%0";
1525 }
1526   [(set_attr "type" "iadd")])
1527
1528 (define_insn "lshrdi3"
1529   [(set (match_operand:DI 0 "register_operand" "=r")
1530         (lshiftrt:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1531                      (match_operand:DI 2 "reg_or_6bit_operand" "rS")))]
1532   ""
1533   "srl %r1,%2,%0"
1534   [(set_attr "type" "shift")])
1535
1536 (define_insn "ashrdi3"
1537   [(set (match_operand:DI 0 "register_operand" "=r")
1538         (ashiftrt:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1539                      (match_operand:DI 2 "reg_or_6bit_operand" "rS")))]
1540   ""
1541   "sra %r1,%2,%0"
1542   [(set_attr "type" "shift")])
1543
1544 (define_expand "extendqihi2"
1545   [(set (match_dup 2)
1546         (ashift:DI (match_operand:QI 1 "some_operand" "")
1547                    (const_int 56)))
1548    (set (match_operand:HI 0 "register_operand" "")
1549         (ashiftrt:DI (match_dup 2)
1550                      (const_int 56)))]
1551   ""
1552 {
1553   if (TARGET_BWX)
1554     {
1555       emit_insn (gen_extendqihi2x (operands[0],
1556                                    force_reg (QImode, operands[1])));
1557       DONE;
1558     }
1559
1560  /* If we have an unaligned MEM, extend to DImode (which we do
1561      specially) and then copy to the result.  */
1562   if (unaligned_memory_operand (operands[1], HImode))
1563     {
1564       rtx temp = gen_reg_rtx (DImode);
1565
1566       emit_insn (gen_extendqidi2 (temp, operands[1]));
1567       emit_move_insn (operands[0], gen_lowpart (HImode, temp));
1568       DONE;
1569     }
1570
1571   operands[0] = gen_lowpart (DImode, operands[0]);
1572   operands[1] = gen_lowpart (DImode, force_reg (QImode, operands[1]));
1573   operands[2] = gen_reg_rtx (DImode);
1574 })
1575
1576 (define_insn "extendqidi2x"
1577   [(set (match_operand:DI 0 "register_operand" "=r")
1578         (sign_extend:DI (match_operand:QI 1 "register_operand" "r")))]
1579   "TARGET_BWX"
1580   "sextb %1,%0"
1581   [(set_attr "type" "shift")])
1582
1583 (define_insn "extendhidi2x"
1584   [(set (match_operand:DI 0 "register_operand" "=r")
1585         (sign_extend:DI (match_operand:HI 1 "register_operand" "r")))]
1586   "TARGET_BWX"
1587   "sextw %1,%0"
1588   [(set_attr "type" "shift")])
1589
1590 (define_insn "extendqisi2x"
1591   [(set (match_operand:SI 0 "register_operand" "=r")
1592         (sign_extend:SI (match_operand:QI 1 "register_operand" "r")))]
1593   "TARGET_BWX"
1594   "sextb %1,%0"
1595   [(set_attr "type" "shift")])
1596
1597 (define_insn "extendhisi2x"
1598   [(set (match_operand:SI 0 "register_operand" "=r")
1599         (sign_extend:SI (match_operand:HI 1 "register_operand" "r")))]
1600   "TARGET_BWX"
1601   "sextw %1,%0"
1602   [(set_attr "type" "shift")])
1603
1604 (define_insn "extendqihi2x"
1605   [(set (match_operand:HI 0 "register_operand" "=r")
1606         (sign_extend:HI (match_operand:QI 1 "register_operand" "r")))]
1607   "TARGET_BWX"
1608   "sextb %1,%0"
1609   [(set_attr "type" "shift")])
1610
1611 (define_expand "extendqisi2"
1612   [(set (match_dup 2)
1613         (ashift:DI (match_operand:QI 1 "some_operand" "")
1614                    (const_int 56)))
1615    (set (match_operand:SI 0 "register_operand" "")
1616         (ashiftrt:DI (match_dup 2)
1617                      (const_int 56)))]
1618   ""
1619 {
1620   if (TARGET_BWX)
1621     {
1622       emit_insn (gen_extendqisi2x (operands[0],
1623                                    force_reg (QImode, operands[1])));
1624       DONE;
1625     }
1626
1627   /* If we have an unaligned MEM, extend to a DImode form of
1628      the result (which we do specially).  */
1629   if (unaligned_memory_operand (operands[1], QImode))
1630     {
1631       rtx temp = gen_reg_rtx (DImode);
1632
1633       emit_insn (gen_extendqidi2 (temp, operands[1]));
1634       emit_move_insn (operands[0], gen_lowpart (SImode, temp));
1635       DONE;
1636     }
1637
1638   operands[0] = gen_lowpart (DImode, operands[0]);
1639   operands[1] = gen_lowpart (DImode, force_reg (QImode, operands[1]));
1640   operands[2] = gen_reg_rtx (DImode);
1641 })
1642
1643 (define_expand "extendqidi2"
1644   [(set (match_dup 2)
1645         (ashift:DI (match_operand:QI 1 "some_operand" "")
1646                    (const_int 56)))
1647    (set (match_operand:DI 0 "register_operand" "")
1648         (ashiftrt:DI (match_dup 2)
1649                      (const_int 56)))]
1650   ""
1651 {
1652   if (TARGET_BWX)
1653     {
1654       emit_insn (gen_extendqidi2x (operands[0],
1655                                    force_reg (QImode, operands[1])));
1656       DONE;
1657     }
1658
1659   if (unaligned_memory_operand (operands[1], QImode))
1660     {
1661       rtx seq = gen_unaligned_extendqidi (operands[0], XEXP (operands[1], 0));
1662       alpha_set_memflags (seq, operands[1]);
1663       emit_insn (seq);
1664       DONE;
1665     }
1666
1667   operands[1] = gen_lowpart (DImode, force_reg (QImode, operands[1]));
1668   operands[2] = gen_reg_rtx (DImode);
1669 })
1670
1671 (define_expand "extendhisi2"
1672   [(set (match_dup 2)
1673         (ashift:DI (match_operand:HI 1 "some_operand" "")
1674                    (const_int 48)))
1675    (set (match_operand:SI 0 "register_operand" "")
1676         (ashiftrt:DI (match_dup 2)
1677                      (const_int 48)))]
1678   ""
1679 {
1680   if (TARGET_BWX)
1681     {
1682       emit_insn (gen_extendhisi2x (operands[0],
1683                                    force_reg (HImode, operands[1])));
1684       DONE;
1685     }
1686
1687   /* If we have an unaligned MEM, extend to a DImode form of
1688      the result (which we do specially).  */
1689   if (unaligned_memory_operand (operands[1], HImode))
1690     {
1691       rtx temp = gen_reg_rtx (DImode);
1692
1693       emit_insn (gen_extendhidi2 (temp, operands[1]));
1694       emit_move_insn (operands[0], gen_lowpart (SImode, temp));
1695       DONE;
1696     }
1697
1698   operands[0] = gen_lowpart (DImode, operands[0]);
1699   operands[1] = gen_lowpart (DImode, force_reg (HImode, operands[1]));
1700   operands[2] = gen_reg_rtx (DImode);
1701 })
1702
1703 (define_expand "extendhidi2"
1704   [(set (match_dup 2)
1705         (ashift:DI (match_operand:HI 1 "some_operand" "")
1706                    (const_int 48)))
1707    (set (match_operand:DI 0 "register_operand" "")
1708         (ashiftrt:DI (match_dup 2)
1709                      (const_int 48)))]
1710   ""
1711 {
1712   if (TARGET_BWX)
1713     {
1714       emit_insn (gen_extendhidi2x (operands[0],
1715                                    force_reg (HImode, operands[1])));
1716       DONE;
1717     }
1718
1719   if (unaligned_memory_operand (operands[1], HImode))
1720     {
1721       rtx seq = gen_unaligned_extendhidi (operands[0], XEXP (operands[1], 0));
1722
1723       alpha_set_memflags (seq, operands[1]);
1724       emit_insn (seq);
1725       DONE;
1726     }
1727
1728   operands[1] = gen_lowpart (DImode, force_reg (HImode, operands[1]));
1729   operands[2] = gen_reg_rtx (DImode);
1730 })
1731
1732 ;; Here's how we sign extend an unaligned byte and halfword.  Doing this
1733 ;; as a pattern saves one instruction.  The code is similar to that for
1734 ;; the unaligned loads (see below).
1735 ;;
1736 ;; Operand 1 is the address, operand 0 is the result.
1737 (define_expand "unaligned_extendqidi"
1738   [(use (match_operand:QI 0 "register_operand" ""))
1739    (use (match_operand:DI 1 "address_operand" ""))]
1740   ""
1741 {
1742   operands[0] = gen_lowpart (DImode, operands[0]);
1743   if (WORDS_BIG_ENDIAN)
1744     emit_insn (gen_unaligned_extendqidi_be (operands[0], operands[1]));
1745   else
1746     emit_insn (gen_unaligned_extendqidi_le (operands[0], operands[1]));
1747   DONE;
1748 })
1749
1750 (define_expand "unaligned_extendqidi_le"
1751   [(set (match_dup 3)
1752         (mem:DI (and:DI (match_operand:DI 1 "" "") (const_int -8))))
1753    (set (match_dup 4)
1754         (ashift:DI (match_dup 3)
1755                    (minus:DI (const_int 64)
1756                              (ashift:DI
1757                               (and:DI (match_dup 2) (const_int 7))
1758                               (const_int 3)))))
1759    (set (match_operand:DI 0 "register_operand" "")
1760         (ashiftrt:DI (match_dup 4) (const_int 56)))]
1761   "! WORDS_BIG_ENDIAN"
1762 {
1763   operands[2] = get_unaligned_offset (operands[1], 1);
1764   operands[3] = gen_reg_rtx (DImode);
1765   operands[4] = gen_reg_rtx (DImode);
1766 })
1767
1768 (define_expand "unaligned_extendqidi_be"
1769   [(set (match_dup 3)
1770         (mem:DI (and:DI (match_operand:DI 1 "" "") (const_int -8))))
1771    (set (match_dup 4)
1772         (ashift:DI (match_dup 3)
1773                    (ashift:DI
1774                      (and:DI
1775                        (plus:DI (match_dup 2) (const_int 1))
1776                        (const_int 7))
1777                      (const_int 3))))
1778    (set (match_operand:DI 0 "register_operand" "")
1779         (ashiftrt:DI (match_dup 4) (const_int 56)))]
1780   "WORDS_BIG_ENDIAN"
1781 {
1782   operands[2] = get_unaligned_offset (operands[1], -1);
1783   operands[3] = gen_reg_rtx (DImode);
1784   operands[4] = gen_reg_rtx (DImode);
1785 })
1786
1787 (define_expand "unaligned_extendhidi"
1788   [(use (match_operand:QI 0 "register_operand" ""))
1789    (use (match_operand:DI 1 "address_operand" ""))]
1790   ""
1791 {
1792   operands[0] = gen_lowpart (DImode, operands[0]);
1793   if (WORDS_BIG_ENDIAN)
1794     emit_insn (gen_unaligned_extendhidi_be (operands[0], operands[1]));
1795   else
1796     emit_insn (gen_unaligned_extendhidi_le (operands[0], operands[1]));
1797   DONE;
1798 })
1799
1800 (define_expand "unaligned_extendhidi_le"
1801   [(set (match_dup 3)
1802         (mem:DI (and:DI (match_operand:DI 1 "" "") (const_int -8))))
1803    (set (match_dup 4)
1804         (ashift:DI (match_dup 3)
1805                    (minus:DI (const_int 64)
1806                              (ashift:DI
1807                               (and:DI (match_dup 2) (const_int 7))
1808                               (const_int 3)))))
1809    (set (match_operand:DI 0 "register_operand" "")
1810         (ashiftrt:DI (match_dup 4) (const_int 48)))]
1811   "! WORDS_BIG_ENDIAN"
1812 {
1813   operands[2] = get_unaligned_offset (operands[1], 2);
1814   operands[3] = gen_reg_rtx (DImode);
1815   operands[4] = gen_reg_rtx (DImode);
1816 })
1817
1818 (define_expand "unaligned_extendhidi_be"
1819   [(set (match_dup 3)
1820         (mem:DI (and:DI (match_operand:DI 1 "" "") (const_int -8))))
1821    (set (match_dup 4)
1822         (ashift:DI (match_dup 3)
1823                    (ashift:DI
1824                      (and:DI
1825                        (plus:DI (match_dup 2) (const_int 1))
1826                        (const_int 7))
1827                      (const_int 3))))
1828    (set (match_operand:DI 0 "register_operand" "")
1829         (ashiftrt:DI (match_dup 4) (const_int 48)))]
1830   "WORDS_BIG_ENDIAN"
1831 {
1832   operands[2] = get_unaligned_offset (operands[1], -1);
1833   operands[3] = gen_reg_rtx (DImode);
1834   operands[4] = gen_reg_rtx (DImode);
1835 })
1836
1837 (define_insn "*extxl_const"
1838   [(set (match_operand:DI 0 "register_operand" "=r")
1839         (zero_extract:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1840                          (match_operand:DI 2 "mode_width_operand" "n")
1841                          (match_operand:DI 3 "mul8_operand" "I")))]
1842   ""
1843   "ext%M2l %r1,%s3,%0"
1844   [(set_attr "type" "shift")])
1845
1846 (define_insn "extxl_le"
1847   [(set (match_operand:DI 0 "register_operand" "=r")
1848         (zero_extract:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1849                          (match_operand:DI 2 "mode_width_operand" "n")
1850                          (ashift:DI (match_operand:DI 3 "reg_or_8bit_operand" "rI")
1851                                     (const_int 3))))]
1852   "! WORDS_BIG_ENDIAN"
1853   "ext%M2l %r1,%3,%0"
1854   [(set_attr "type" "shift")])
1855
1856 (define_insn "extxl_be"
1857   [(set (match_operand:DI 0 "register_operand" "=r")
1858         (zero_extract:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1859                          (match_operand:DI 2 "mode_width_operand" "n")
1860                          (minus:DI
1861                            (const_int 56)
1862                            (ashift:DI
1863                              (match_operand:DI 3 "reg_or_8bit_operand" "rI")
1864                              (const_int 3)))))]
1865   "WORDS_BIG_ENDIAN"
1866   "ext%M2l %r1,%3,%0"
1867   [(set_attr "type" "shift")])
1868
1869 ;; Combine has some strange notion of preserving existing undefined behavior
1870 ;; in shifts larger than a word size.  So capture these patterns that it
1871 ;; should have turned into zero_extracts.
1872
1873 (define_insn "*extxl_1_le"
1874   [(set (match_operand:DI 0 "register_operand" "=r")
1875         (and:DI (lshiftrt:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1876                   (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1877                              (const_int 3)))
1878              (match_operand:DI 3 "mode_mask_operand" "n")))]
1879   "! WORDS_BIG_ENDIAN"
1880   "ext%U3l %1,%2,%0"
1881   [(set_attr "type" "shift")])
1882
1883 (define_insn "*extxl_1_be"
1884   [(set (match_operand:DI 0 "register_operand" "=r")
1885         (and:DI (lshiftrt:DI
1886                   (match_operand:DI 1 "reg_or_0_operand" "rJ")
1887                   (minus:DI (const_int 56)
1888                     (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1889                                (const_int 3))))
1890                 (match_operand:DI 3 "mode_mask_operand" "n")))]
1891   "WORDS_BIG_ENDIAN"
1892   "ext%U3l %1,%2,%0"
1893   [(set_attr "type" "shift")])
1894
1895 (define_insn "*extql_2_le"
1896   [(set (match_operand:DI 0 "register_operand" "=r")
1897         (lshiftrt:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1898           (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1899                      (const_int 3))))]
1900   "! WORDS_BIG_ENDIAN"
1901   "extql %1,%2,%0"
1902   [(set_attr "type" "shift")])
1903
1904 (define_insn "*extql_2_be"
1905   [(set (match_operand:DI 0 "register_operand" "=r")
1906         (lshiftrt:DI
1907           (match_operand:DI 1 "reg_or_0_operand" "rJ")
1908           (minus:DI (const_int 56)
1909                     (ashift:DI
1910                       (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1911                       (const_int 3)))))]
1912   "WORDS_BIG_ENDIAN"
1913   "extql %1,%2,%0"
1914   [(set_attr "type" "shift")])
1915
1916 (define_insn "extqh_le"
1917   [(set (match_operand:DI 0 "register_operand" "=r")
1918         (ashift:DI
1919          (match_operand:DI 1 "reg_or_0_operand" "rJ")
1920           (minus:DI (const_int 64)
1921                     (ashift:DI
1922                      (and:DI
1923                       (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1924                       (const_int 7))
1925                      (const_int 3)))))]
1926   "! WORDS_BIG_ENDIAN"
1927   "extqh %r1,%2,%0"
1928   [(set_attr "type" "shift")])
1929
1930 (define_insn "extqh_be"
1931   [(set (match_operand:DI 0 "register_operand" "=r")
1932         (ashift:DI
1933           (match_operand:DI 1 "reg_or_0_operand" "rJ")
1934           (ashift:DI
1935             (and:DI
1936               (plus:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1937                        (const_int 1))
1938               (const_int 7))
1939             (const_int 3))))]
1940   "WORDS_BIG_ENDIAN"
1941   "extqh %r1,%2,%0"
1942   [(set_attr "type" "shift")])
1943
1944 (define_insn "extlh_le"
1945   [(set (match_operand:DI 0 "register_operand" "=r")
1946         (ashift:DI
1947          (and:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1948                  (const_int 2147483647))
1949          (minus:DI (const_int 64)
1950                     (ashift:DI
1951                      (and:DI
1952                       (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1953                       (const_int 7))
1954                      (const_int 3)))))]
1955   "! WORDS_BIG_ENDIAN"
1956   "extlh %r1,%2,%0"
1957   [(set_attr "type" "shift")])
1958
1959 (define_insn "extlh_be"
1960   [(set (match_operand:DI 0 "register_operand" "=r")
1961         (and:DI
1962           (ashift:DI
1963             (match_operand:DI 1 "reg_or_0_operand" "rJ")
1964             (ashift:DI
1965               (and:DI
1966                 (plus:DI
1967                   (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1968                   (const_int 1))
1969                 (const_int 7))
1970               (const_int 3)))
1971           (const_int 2147483647)))]
1972   "WORDS_BIG_ENDIAN"
1973   "extlh %r1,%2,%0"
1974   [(set_attr "type" "shift")])
1975
1976 (define_insn "extwh_le"
1977   [(set (match_operand:DI 0 "register_operand" "=r")
1978         (ashift:DI
1979          (and:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1980                  (const_int 65535))
1981          (minus:DI (const_int 64)
1982                     (ashift:DI
1983                      (and:DI
1984                       (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1985                       (const_int 7))
1986                      (const_int 3)))))]
1987   "! WORDS_BIG_ENDIAN"
1988   "extwh %r1,%2,%0"
1989   [(set_attr "type" "shift")])
1990
1991 (define_insn "extwh_be"
1992   [(set (match_operand:DI 0 "register_operand" "=r")
1993         (and:DI
1994           (ashift:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1995                      (ashift:DI
1996                        (and:DI
1997                          (plus:DI
1998                            (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1999                            (const_int 1))
2000                          (const_int 7))
2001                        (const_int 3)))
2002           (const_int 65535)))]
2003   "WORDS_BIG_ENDIAN"
2004   "extwh %r1,%2,%0"
2005   [(set_attr "type" "shift")])
2006
2007 ;; This converts an extXl into an extXh with an appropriate adjustment
2008 ;; to the address calculation.
2009
2010 ;;(define_split
2011 ;;  [(set (match_operand:DI 0 "register_operand" "")
2012 ;;      (ashift:DI (zero_extract:DI (match_operand:DI 1 "register_operand" "")
2013 ;;                                  (match_operand:DI 2 "mode_width_operand" "")
2014 ;;                                  (ashift:DI (match_operand:DI 3 "" "")
2015 ;;                                             (const_int 3)))
2016 ;;                 (match_operand:DI 4 "const_int_operand" "")))
2017 ;;   (clobber (match_operand:DI 5 "register_operand" ""))]
2018 ;;  "INTVAL (operands[4]) == 64 - INTVAL (operands[2])"
2019 ;;  [(set (match_dup 5) (match_dup 6))
2020 ;;   (set (match_dup 0)
2021 ;;      (ashift:DI (zero_extract:DI (match_dup 1) (match_dup 2)
2022 ;;                                  (ashift:DI (plus:DI (match_dup 5)
2023 ;;                                                      (match_dup 7))
2024 ;;                                             (const_int 3)))
2025 ;;                 (match_dup 4)))]
2026 ;;  "
2027 ;;{
2028 ;;  operands[6] = plus_constant (operands[3],
2029 ;;                             INTVAL (operands[2]) / BITS_PER_UNIT);
2030 ;;  operands[7] = GEN_INT (- INTVAL (operands[2]) / BITS_PER_UNIT);
2031 ;;}")
2032
2033 (define_insn "*insbl_const"
2034   [(set (match_operand:DI 0 "register_operand" "=r")
2035         (ashift:DI (zero_extend:DI (match_operand:QI 1 "register_operand" "r"))
2036                    (match_operand:DI 2 "mul8_operand" "I")))]
2037   ""
2038   "insbl %1,%s2,%0"
2039   [(set_attr "type" "shift")])
2040
2041 (define_insn "inswl_const"
2042   [(set (match_operand:DI 0 "register_operand" "=r")
2043         (ashift:DI (zero_extend:DI (match_operand:HI 1 "register_operand" "r"))
2044                    (match_operand:DI 2 "mul8_operand" "I")))]
2045   ""
2046   "inswl %1,%s2,%0"
2047   [(set_attr "type" "shift")])
2048
2049 (define_insn "*insll_const"
2050   [(set (match_operand:DI 0 "register_operand" "=r")
2051         (ashift:DI (zero_extend:DI (match_operand:SI 1 "register_operand" "r"))
2052                    (match_operand:DI 2 "mul8_operand" "I")))]
2053   ""
2054   "insll %1,%s2,%0"
2055   [(set_attr "type" "shift")])
2056
2057 (define_insn "insbl_le"
2058   [(set (match_operand:DI 0 "register_operand" "=r")
2059         (ashift:DI (zero_extend:DI (match_operand:QI 1 "register_operand" "r"))
2060                    (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
2061                               (const_int 3))))]
2062   "! WORDS_BIG_ENDIAN"
2063   "insbl %1,%2,%0"
2064   [(set_attr "type" "shift")])
2065
2066 (define_insn "insbl_be"
2067  [(set (match_operand:DI 0 "register_operand" "=r")
2068        (ashift:DI (zero_extend:DI (match_operand:QI 1 "register_operand" "r"))
2069          (minus:DI (const_int 56)
2070            (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
2071                       (const_int 3)))))]
2072   "WORDS_BIG_ENDIAN"
2073   "insbl %1,%2,%0"
2074   [(set_attr "type" "shift")])
2075
2076 (define_insn "inswl_le"
2077   [(set (match_operand:DI 0 "register_operand" "=r")
2078         (ashift:DI (zero_extend:DI (match_operand:HI 1 "register_operand" "r"))
2079                    (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
2080                               (const_int 3))))]
2081   "! WORDS_BIG_ENDIAN"
2082   "inswl %1,%2,%0"
2083   [(set_attr "type" "shift")])
2084
2085 (define_insn "inswl_be"
2086   [(set (match_operand:DI 0 "register_operand" "=r")
2087         (ashift:DI (zero_extend:DI (match_operand:HI 1 "register_operand" "r"))
2088           (minus:DI (const_int 56)
2089             (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
2090                        (const_int 3)))))]
2091   "WORDS_BIG_ENDIAN"
2092   "inswl %1,%2,%0"
2093   [(set_attr "type" "shift")])
2094
2095 (define_insn "insll_le"
2096   [(set (match_operand:DI 0 "register_operand" "=r")
2097         (ashift:DI (zero_extend:DI (match_operand:SI 1 "register_operand" "r"))
2098                    (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
2099                               (const_int 3))))]
2100   "! WORDS_BIG_ENDIAN"
2101   "insll %1,%2,%0"
2102   [(set_attr "type" "shift")])
2103
2104 (define_insn "insll_be"
2105   [(set (match_operand:DI 0 "register_operand" "=r")
2106         (ashift:DI (zero_extend:DI (match_operand:SI 1 "register_operand" "r"))
2107           (minus:DI (const_int 56)
2108             (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
2109                        (const_int 3)))))]
2110   "WORDS_BIG_ENDIAN"
2111   "insll %1,%2,%0"
2112   [(set_attr "type" "shift")])
2113
2114 (define_insn "insql_le"
2115   [(set (match_operand:DI 0 "register_operand" "=r")
2116         (ashift:DI (match_operand:DI 1 "register_operand" "r")
2117                    (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
2118                               (const_int 3))))]
2119   "! WORDS_BIG_ENDIAN"
2120   "insql %1,%2,%0"
2121   [(set_attr "type" "shift")])
2122
2123 (define_insn "insql_be"
2124   [(set (match_operand:DI 0 "register_operand" "=r")
2125         (ashift:DI (match_operand:DI 1 "register_operand" "r")
2126           (minus:DI (const_int 56)
2127             (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
2128                        (const_int 3)))))]
2129   "WORDS_BIG_ENDIAN"
2130   "insql %1,%2,%0"
2131   [(set_attr "type" "shift")])
2132
2133 ;; Combine has this sometimes habit of moving the and outside of the
2134 ;; shift, making life more interesting.
2135
2136 (define_insn "*insxl"
2137   [(set (match_operand:DI 0 "register_operand" "=r")
2138         (and:DI (ashift:DI (match_operand:DI 1 "register_operand" "r")
2139                            (match_operand:DI 2 "mul8_operand" "I"))
2140                 (match_operand:DI 3 "immediate_operand" "i")))]
2141   "HOST_BITS_PER_WIDE_INT == 64
2142    && CONST_INT_P (operands[3])
2143    && (((unsigned HOST_WIDE_INT) 0xff << INTVAL (operands[2])
2144         == (unsigned HOST_WIDE_INT) INTVAL (operands[3]))
2145        || ((unsigned HOST_WIDE_INT) 0xffff << INTVAL (operands[2])
2146         == (unsigned HOST_WIDE_INT) INTVAL (operands[3]))
2147        || ((unsigned HOST_WIDE_INT) 0xffffffff << INTVAL (operands[2])
2148         == (unsigned HOST_WIDE_INT) INTVAL (operands[3])))"
2149 {
2150 #if HOST_BITS_PER_WIDE_INT == 64
2151   if ((unsigned HOST_WIDE_INT) 0xff << INTVAL (operands[2])
2152       == (unsigned HOST_WIDE_INT) INTVAL (operands[3]))
2153     return "insbl %1,%s2,%0";
2154   if ((unsigned HOST_WIDE_INT) 0xffff << INTVAL (operands[2])
2155       == (unsigned HOST_WIDE_INT) INTVAL (operands[3]))
2156     return "inswl %1,%s2,%0";
2157   if ((unsigned HOST_WIDE_INT) 0xffffffff << INTVAL (operands[2])
2158       == (unsigned HOST_WIDE_INT) INTVAL (operands[3]))
2159     return "insll %1,%s2,%0";
2160 #endif
2161   gcc_unreachable ();
2162 }
2163   [(set_attr "type" "shift")])
2164
2165 ;; We do not include the insXh insns because they are complex to express
2166 ;; and it does not appear that we would ever want to generate them.
2167 ;;
2168 ;; Since we need them for block moves, though, cop out and use unspec.
2169
2170 (define_insn "insxh"
2171   [(set (match_operand:DI 0 "register_operand" "=r")
2172         (unspec:DI [(match_operand:DI 1 "register_operand" "r")
2173                     (match_operand:DI 2 "mode_width_operand" "n")
2174                     (match_operand:DI 3 "reg_or_8bit_operand" "rI")]
2175                    UNSPEC_INSXH))]
2176   ""
2177   "ins%M2h %1,%3,%0"
2178   [(set_attr "type" "shift")])
2179
2180 (define_insn "mskxl_le"
2181   [(set (match_operand:DI 0 "register_operand" "=r")
2182         (and:DI (not:DI (ashift:DI
2183                          (match_operand:DI 2 "mode_mask_operand" "n")
2184                          (ashift:DI
2185                           (match_operand:DI 3 "reg_or_8bit_operand" "rI")
2186                           (const_int 3))))
2187                 (match_operand:DI 1 "reg_or_0_operand" "rJ")))]
2188   "! WORDS_BIG_ENDIAN"
2189   "msk%U2l %r1,%3,%0"
2190   [(set_attr "type" "shift")])
2191
2192 (define_insn "mskxl_be"
2193   [(set (match_operand:DI 0 "register_operand" "=r")
2194         (and:DI (not:DI (ashift:DI
2195                           (match_operand:DI 2 "mode_mask_operand" "n")
2196                           (minus:DI (const_int 56)
2197                             (ashift:DI
2198                               (match_operand:DI 3 "reg_or_8bit_operand" "rI")
2199                               (const_int 3)))))
2200                 (match_operand:DI 1 "reg_or_0_operand" "rJ")))]
2201   "WORDS_BIG_ENDIAN"
2202   "msk%U2l %r1,%3,%0"
2203   [(set_attr "type" "shift")])
2204
2205 ;; We do not include the mskXh insns because it does not appear we would
2206 ;; ever generate one.
2207 ;;
2208 ;; Again, we do for block moves and we use unspec again.
2209
2210 (define_insn "mskxh"
2211   [(set (match_operand:DI 0 "register_operand" "=r")
2212         (unspec:DI [(match_operand:DI 1 "register_operand" "r")
2213                     (match_operand:DI 2 "mode_width_operand" "n")
2214                     (match_operand:DI 3 "reg_or_8bit_operand" "rI")]
2215                    UNSPEC_MSKXH))]
2216   ""
2217   "msk%M2h %1,%3,%0"
2218   [(set_attr "type" "shift")])
2219
2220 ;; Prefer AND + NE over LSHIFTRT + AND.
2221
2222 (define_insn_and_split "*ze_and_ne"
2223   [(set (match_operand:DI 0 "register_operand" "=r")
2224         (zero_extract:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
2225                          (const_int 1)
2226                          (match_operand 2 "const_int_operand" "I")))]
2227   "(unsigned HOST_WIDE_INT) INTVAL (operands[2]) < 8"
2228   "#"
2229   "(unsigned HOST_WIDE_INT) INTVAL (operands[2]) < 8"
2230   [(set (match_dup 0)
2231         (and:DI (match_dup 1) (match_dup 3)))
2232    (set (match_dup 0)
2233         (ne:DI (match_dup 0) (const_int 0)))]
2234   "operands[3] = GEN_INT (1 << INTVAL (operands[2]));")
2235 \f
2236 ;; Floating-point operations.  All the double-precision insns can extend
2237 ;; from single, so indicate that.  The exception are the ones that simply
2238 ;; play with the sign bits; it's not clear what to do there.
2239
2240 (define_insn "abssf2"
2241   [(set (match_operand:SF 0 "register_operand" "=f")
2242         (abs:SF (match_operand:SF 1 "reg_or_0_operand" "fG")))]
2243   "TARGET_FP"
2244   "cpys $f31,%R1,%0"
2245   [(set_attr "type" "fcpys")])
2246
2247 (define_insn "*nabssf2"
2248   [(set (match_operand:SF 0 "register_operand" "=f")
2249         (neg:SF (abs:SF (match_operand:SF 1 "reg_or_0_operand" "fG"))))]
2250   "TARGET_FP"
2251   "cpysn $f31,%R1,%0"
2252   [(set_attr "type" "fadd")])
2253
2254 (define_insn "absdf2"
2255   [(set (match_operand:DF 0 "register_operand" "=f")
2256         (abs:DF (match_operand:DF 1 "reg_or_0_operand" "fG")))]
2257   "TARGET_FP"
2258   "cpys $f31,%R1,%0"
2259   [(set_attr "type" "fcpys")])
2260
2261 (define_insn "*nabsdf2"
2262   [(set (match_operand:DF 0 "register_operand" "=f")
2263         (neg:DF (abs:DF (match_operand:DF 1 "reg_or_0_operand" "fG"))))]
2264   "TARGET_FP"
2265   "cpysn $f31,%R1,%0"
2266   [(set_attr "type" "fadd")])
2267
2268 (define_expand "abstf2"
2269   [(parallel [(set (match_operand:TF 0 "register_operand" "")
2270                    (abs:TF (match_operand:TF 1 "reg_or_0_operand" "")))
2271               (use (match_dup 2))])]
2272   "TARGET_HAS_XFLOATING_LIBS"
2273 {
2274 #if HOST_BITS_PER_WIDE_INT >= 64
2275   operands[2] = force_reg (DImode, GEN_INT ((HOST_WIDE_INT) 1 << 63));
2276 #else
2277   operands[2] = force_reg (DImode, immed_double_const (0, 0x80000000, DImode));
2278 #endif
2279 })
2280
2281 (define_insn_and_split "*abstf_internal"
2282   [(set (match_operand:TF 0 "register_operand" "=r")
2283         (abs:TF (match_operand:TF 1 "reg_or_0_operand" "rG")))
2284    (use (match_operand:DI 2 "register_operand" "r"))]
2285   "TARGET_HAS_XFLOATING_LIBS"
2286   "#"
2287   "&& reload_completed"
2288   [(const_int 0)]
2289   "alpha_split_tfmode_frobsign (operands, gen_andnotdi3); DONE;")
2290
2291 (define_insn "negsf2"
2292   [(set (match_operand:SF 0 "register_operand" "=f")
2293         (neg:SF (match_operand:SF 1 "reg_or_0_operand" "fG")))]
2294   "TARGET_FP"
2295   "cpysn %R1,%R1,%0"
2296   [(set_attr "type" "fadd")])
2297
2298 (define_insn "negdf2"
2299   [(set (match_operand:DF 0 "register_operand" "=f")
2300         (neg:DF (match_operand:DF 1 "reg_or_0_operand" "fG")))]
2301   "TARGET_FP"
2302   "cpysn %R1,%R1,%0"
2303   [(set_attr "type" "fadd")])
2304
2305 (define_expand "negtf2"
2306   [(parallel [(set (match_operand:TF 0 "register_operand" "")
2307                    (neg:TF (match_operand:TF 1 "reg_or_0_operand" "")))
2308               (use (match_dup 2))])]
2309   "TARGET_HAS_XFLOATING_LIBS"
2310 {
2311 #if HOST_BITS_PER_WIDE_INT >= 64
2312   operands[2] = force_reg (DImode, GEN_INT ((HOST_WIDE_INT) 1 << 63));
2313 #else
2314   operands[2] = force_reg (DImode, immed_double_const (0, 0x80000000, DImode));
2315 #endif
2316 })
2317
2318 (define_insn_and_split "*negtf_internal"
2319   [(set (match_operand:TF 0 "register_operand" "=r")
2320         (neg:TF (match_operand:TF 1 "reg_or_0_operand" "rG")))
2321    (use (match_operand:DI 2 "register_operand" "r"))]
2322   "TARGET_HAS_XFLOATING_LIBS"
2323   "#"
2324   "&& reload_completed"
2325   [(const_int 0)]
2326   "alpha_split_tfmode_frobsign (operands, gen_xordi3); DONE;")
2327
2328 (define_insn "copysignsf3"
2329   [(set (match_operand:SF 0 "register_operand" "=f")
2330         (unspec:SF [(match_operand:SF 1 "reg_or_0_operand" "fG")
2331                     (match_operand:SF 2 "reg_or_0_operand" "fG")]
2332                    UNSPEC_COPYSIGN))]
2333   "TARGET_FP"
2334   "cpys %R2,%R1,%0"
2335   [(set_attr "type" "fadd")])
2336
2337 (define_insn "*ncopysignsf3"
2338   [(set (match_operand:SF 0 "register_operand" "=f")
2339         (neg:SF (unspec:SF [(match_operand:SF 1 "reg_or_0_operand" "fG")
2340                             (match_operand:SF 2 "reg_or_0_operand" "fG")]
2341                            UNSPEC_COPYSIGN)))]
2342   "TARGET_FP"
2343   "cpysn %R2,%R1,%0"
2344   [(set_attr "type" "fadd")])
2345
2346 (define_insn "copysigndf3"
2347   [(set (match_operand:DF 0 "register_operand" "=f")
2348         (unspec:DF [(match_operand:DF 1 "reg_or_0_operand" "fG")
2349                     (match_operand:DF 2 "reg_or_0_operand" "fG")]
2350                    UNSPEC_COPYSIGN))]
2351   "TARGET_FP"
2352   "cpys %R2,%R1,%0"
2353   [(set_attr "type" "fadd")])
2354
2355 (define_insn "*ncopysigndf3"
2356   [(set (match_operand:DF 0 "register_operand" "=f")
2357         (neg:DF (unspec:DF [(match_operand:DF 1 "reg_or_0_operand" "fG")
2358                             (match_operand:DF 2 "reg_or_0_operand" "fG")]
2359                            UNSPEC_COPYSIGN)))]
2360   "TARGET_FP"
2361   "cpysn %R2,%R1,%0"
2362   [(set_attr "type" "fadd")])
2363
2364 (define_insn "*addsf_ieee"
2365   [(set (match_operand:SF 0 "register_operand" "=&f")
2366         (plus:SF (match_operand:SF 1 "reg_or_0_operand" "%fG")
2367                  (match_operand:SF 2 "reg_or_0_operand" "fG")))]
2368   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2369   "add%,%/ %R1,%R2,%0"
2370   [(set_attr "type" "fadd")
2371    (set_attr "trap" "yes")
2372    (set_attr "round_suffix" "normal")
2373    (set_attr "trap_suffix" "u_su_sui")])
2374
2375 (define_insn "addsf3"
2376   [(set (match_operand:SF 0 "register_operand" "=f")
2377         (plus:SF (match_operand:SF 1 "reg_or_0_operand" "%fG")
2378                  (match_operand:SF 2 "reg_or_0_operand" "fG")))]
2379   "TARGET_FP"
2380   "add%,%/ %R1,%R2,%0"
2381   [(set_attr "type" "fadd")
2382    (set_attr "trap" "yes")
2383    (set_attr "round_suffix" "normal")
2384    (set_attr "trap_suffix" "u_su_sui")])
2385
2386 (define_insn "*adddf_ieee"
2387   [(set (match_operand:DF 0 "register_operand" "=&f")
2388         (plus:DF (match_operand:DF 1 "reg_or_0_operand" "%fG")
2389                  (match_operand:DF 2 "reg_or_0_operand" "fG")))]
2390   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2391   "add%-%/ %R1,%R2,%0"
2392   [(set_attr "type" "fadd")
2393    (set_attr "trap" "yes")
2394    (set_attr "round_suffix" "normal")
2395    (set_attr "trap_suffix" "u_su_sui")])
2396
2397 (define_insn "adddf3"
2398   [(set (match_operand:DF 0 "register_operand" "=f")
2399         (plus:DF (match_operand:DF 1 "reg_or_0_operand" "%fG")
2400                  (match_operand:DF 2 "reg_or_0_operand" "fG")))]
2401   "TARGET_FP"
2402   "add%-%/ %R1,%R2,%0"
2403   [(set_attr "type" "fadd")
2404    (set_attr "trap" "yes")
2405    (set_attr "round_suffix" "normal")
2406    (set_attr "trap_suffix" "u_su_sui")])
2407
2408 (define_insn "*adddf_ext1"
2409   [(set (match_operand:DF 0 "register_operand" "=f")
2410         (plus:DF (float_extend:DF
2411                   (match_operand:SF 1 "reg_or_0_operand" "fG"))
2412                  (match_operand:DF 2 "reg_or_0_operand" "fG")))]
2413   "TARGET_FP && alpha_fptm < ALPHA_FPTM_SU"
2414   "add%-%/ %R1,%R2,%0"
2415   [(set_attr "type" "fadd")
2416    (set_attr "trap" "yes")
2417    (set_attr "round_suffix" "normal")
2418    (set_attr "trap_suffix" "u_su_sui")])
2419
2420 (define_insn "*adddf_ext2"
2421   [(set (match_operand:DF 0 "register_operand" "=f")
2422         (plus:DF (float_extend:DF
2423                   (match_operand:SF 1 "reg_or_0_operand" "%fG"))
2424                  (float_extend:DF
2425                   (match_operand:SF 2 "reg_or_0_operand" "fG"))))]
2426   "TARGET_FP && alpha_fptm < ALPHA_FPTM_SU"
2427   "add%-%/ %R1,%R2,%0"
2428   [(set_attr "type" "fadd")
2429    (set_attr "trap" "yes")
2430    (set_attr "round_suffix" "normal")
2431    (set_attr "trap_suffix" "u_su_sui")])
2432
2433 (define_expand "addtf3"
2434   [(use (match_operand 0 "register_operand" ""))
2435    (use (match_operand 1 "general_operand" ""))
2436    (use (match_operand 2 "general_operand" ""))]
2437   "TARGET_HAS_XFLOATING_LIBS"
2438   "alpha_emit_xfloating_arith (PLUS, operands); DONE;")
2439
2440 ;; Define conversion operators between DFmode and SImode, using the cvtql
2441 ;; instruction.  To allow combine et al to do useful things, we keep the
2442 ;; operation as a unit until after reload, at which point we split the
2443 ;; instructions.
2444 ;;
2445 ;; Note that we (attempt to) only consider this optimization when the
2446 ;; ultimate destination is memory.  If we will be doing further integer
2447 ;; processing, it is cheaper to do the truncation in the int regs.
2448
2449 (define_insn "*cvtql"
2450   [(set (match_operand:SF 0 "register_operand" "=f")
2451         (unspec:SF [(match_operand:DI 1 "reg_or_0_operand" "fG")]
2452                    UNSPEC_CVTQL))]
2453   "TARGET_FP"
2454   "cvtql%/ %R1,%0"
2455   [(set_attr "type" "fadd")
2456    (set_attr "trap" "yes")
2457    (set_attr "trap_suffix" "v_sv")])
2458
2459 (define_insn_and_split "*fix_truncdfsi_ieee"
2460   [(set (match_operand:SI 0 "memory_operand" "=m")
2461         (subreg:SI
2462           (match_operator:DI 4 "fix_operator" 
2463             [(match_operand:DF 1 "reg_or_0_operand" "fG")]) 0))
2464    (clobber (match_scratch:DI 2 "=&f"))
2465    (clobber (match_scratch:SF 3 "=&f"))]
2466   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2467   "#"
2468   "&& reload_completed"
2469   [(set (match_dup 2) (match_op_dup 4 [(match_dup 1)]))
2470    (set (match_dup 3) (unspec:SF [(match_dup 2)] UNSPEC_CVTQL))
2471    (set (match_dup 5) (match_dup 3))]
2472 {
2473   operands[5] = adjust_address (operands[0], SFmode, 0);
2474 }
2475   [(set_attr "type" "fadd")
2476    (set_attr "trap" "yes")])
2477
2478 (define_insn_and_split "*fix_truncdfsi_internal"
2479   [(set (match_operand:SI 0 "memory_operand" "=m")
2480         (subreg:SI
2481           (match_operator:DI 3 "fix_operator" 
2482             [(match_operand:DF 1 "reg_or_0_operand" "fG")]) 0))
2483    (clobber (match_scratch:DI 2 "=f"))]
2484   "TARGET_FP && alpha_fptm < ALPHA_FPTM_SU"
2485   "#"
2486   "&& reload_completed"
2487   [(set (match_dup 2) (match_op_dup 3 [(match_dup 1)]))
2488    (set (match_dup 4) (unspec:SF [(match_dup 2)] UNSPEC_CVTQL))
2489    (set (match_dup 5) (match_dup 4))]
2490 {
2491   operands[4] = gen_rtx_REG (SFmode, REGNO (operands[2]));
2492   operands[5] = adjust_address (operands[0], SFmode, 0);
2493 }
2494   [(set_attr "type" "fadd")
2495    (set_attr "trap" "yes")])
2496
2497 (define_insn "*fix_truncdfdi_ieee"
2498   [(set (match_operand:DI 0 "reg_no_subreg_operand" "=&f")
2499         (match_operator:DI 2 "fix_operator" 
2500           [(match_operand:DF 1 "reg_or_0_operand" "fG")]))]
2501   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2502   "cvt%-q%/ %R1,%0"
2503   [(set_attr "type" "fadd")
2504    (set_attr "trap" "yes")
2505    (set_attr "round_suffix" "c")
2506    (set_attr "trap_suffix" "v_sv_svi")])
2507
2508 (define_insn "*fix_truncdfdi2"
2509   [(set (match_operand:DI 0 "reg_no_subreg_operand" "=f")
2510         (match_operator:DI 2 "fix_operator" 
2511           [(match_operand:DF 1 "reg_or_0_operand" "fG")]))]
2512   "TARGET_FP"
2513   "cvt%-q%/ %R1,%0"
2514   [(set_attr "type" "fadd")
2515    (set_attr "trap" "yes")
2516    (set_attr "round_suffix" "c")
2517    (set_attr "trap_suffix" "v_sv_svi")])
2518
2519 (define_expand "fix_truncdfdi2"
2520   [(set (match_operand:DI 0 "reg_no_subreg_operand" "")
2521         (fix:DI (match_operand:DF 1 "reg_or_0_operand" "")))]
2522   "TARGET_FP"
2523   "")
2524
2525 (define_expand "fixuns_truncdfdi2"
2526   [(set (match_operand:DI 0 "reg_no_subreg_operand" "")
2527         (unsigned_fix:DI (match_operand:DF 1 "reg_or_0_operand" "")))]
2528   "TARGET_FP"
2529   "")
2530
2531 ;; Likewise between SFmode and SImode.
2532
2533 (define_insn_and_split "*fix_truncsfsi_ieee"
2534   [(set (match_operand:SI 0 "memory_operand" "=m")
2535         (subreg:SI
2536           (match_operator:DI 4 "fix_operator" 
2537             [(float_extend:DF
2538                (match_operand:SF 1 "reg_or_0_operand" "fG"))]) 0))
2539    (clobber (match_scratch:DI 2 "=&f"))
2540    (clobber (match_scratch:SF 3 "=&f"))]
2541   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2542   "#"
2543   "&& reload_completed"
2544   [(set (match_dup 2) (match_op_dup 4 [(float_extend:DF (match_dup 1))]))
2545    (set (match_dup 3) (unspec:SF [(match_dup 2)] UNSPEC_CVTQL))
2546    (set (match_dup 5) (match_dup 3))]
2547 {
2548   operands[5] = adjust_address (operands[0], SFmode, 0);
2549 }
2550   [(set_attr "type" "fadd")
2551    (set_attr "trap" "yes")])
2552
2553 (define_insn_and_split "*fix_truncsfsi_internal"
2554   [(set (match_operand:SI 0 "memory_operand" "=m")
2555         (subreg:SI
2556           (match_operator:DI 3 "fix_operator" 
2557             [(float_extend:DF
2558                (match_operand:SF 1 "reg_or_0_operand" "fG"))]) 0))
2559    (clobber (match_scratch:DI 2 "=f"))]
2560   "TARGET_FP && alpha_fptm < ALPHA_FPTM_SU"
2561   "#"
2562   "&& reload_completed"
2563   [(set (match_dup 2) (match_op_dup 3 [(float_extend:DF (match_dup 1))]))
2564    (set (match_dup 4) (unspec:SF [(match_dup 2)] UNSPEC_CVTQL))
2565    (set (match_dup 5) (match_dup 4))]
2566 {
2567   operands[4] = gen_rtx_REG (SFmode, REGNO (operands[2]));
2568   operands[5] = adjust_address (operands[0], SFmode, 0);
2569 }
2570   [(set_attr "type" "fadd")
2571    (set_attr "trap" "yes")])
2572
2573 (define_insn "*fix_truncsfdi_ieee"
2574   [(set (match_operand:DI 0 "reg_no_subreg_operand" "=&f")
2575         (match_operator:DI 2 "fix_operator" 
2576           [(float_extend:DF (match_operand:SF 1 "reg_or_0_operand" "fG"))]))]
2577   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2578   "cvt%-q%/ %R1,%0"
2579   [(set_attr "type" "fadd")
2580    (set_attr "trap" "yes")
2581    (set_attr "round_suffix" "c")
2582    (set_attr "trap_suffix" "v_sv_svi")])
2583
2584 (define_insn "*fix_truncsfdi2"
2585   [(set (match_operand:DI 0 "reg_no_subreg_operand" "=f")
2586         (match_operator:DI 2 "fix_operator" 
2587           [(float_extend:DF (match_operand:SF 1 "reg_or_0_operand" "fG"))]))]
2588   "TARGET_FP"
2589   "cvt%-q%/ %R1,%0"
2590   [(set_attr "type" "fadd")
2591    (set_attr "trap" "yes")
2592    (set_attr "round_suffix" "c")
2593    (set_attr "trap_suffix" "v_sv_svi")])
2594
2595 (define_expand "fix_truncsfdi2"
2596   [(set (match_operand:DI 0 "reg_no_subreg_operand" "")
2597         (fix:DI (float_extend:DF (match_operand:SF 1 "reg_or_0_operand" ""))))]
2598   "TARGET_FP"
2599   "")
2600
2601 (define_expand "fixuns_truncsfdi2"
2602   [(set (match_operand:DI 0 "reg_no_subreg_operand" "")
2603         (unsigned_fix:DI
2604           (float_extend:DF (match_operand:SF 1 "reg_or_0_operand" ""))))]
2605   "TARGET_FP"
2606   "")
2607
2608 (define_expand "fix_trunctfdi2"
2609   [(use (match_operand:DI 0 "register_operand" ""))
2610    (use (match_operand:TF 1 "general_operand" ""))]
2611   "TARGET_HAS_XFLOATING_LIBS"
2612   "alpha_emit_xfloating_cvt (FIX, operands); DONE;")
2613
2614 (define_expand "fixuns_trunctfdi2"
2615   [(use (match_operand:DI 0 "register_operand" ""))
2616    (use (match_operand:TF 1 "general_operand" ""))]
2617   "TARGET_HAS_XFLOATING_LIBS"
2618   "alpha_emit_xfloating_cvt (UNSIGNED_FIX, operands); DONE;")
2619
2620 (define_insn "*floatdisf_ieee"
2621   [(set (match_operand:SF 0 "register_operand" "=&f")
2622         (float:SF (match_operand:DI 1 "reg_no_subreg_operand" "f")))]
2623   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2624   "cvtq%,%/ %1,%0"
2625   [(set_attr "type" "fadd")
2626    (set_attr "trap" "yes")
2627    (set_attr "round_suffix" "normal")
2628    (set_attr "trap_suffix" "sui")])
2629
2630 (define_insn "floatdisf2"
2631   [(set (match_operand:SF 0 "register_operand" "=f")
2632         (float:SF (match_operand:DI 1 "reg_no_subreg_operand" "f")))]
2633   "TARGET_FP"
2634   "cvtq%,%/ %1,%0"
2635   [(set_attr "type" "fadd")
2636    (set_attr "trap" "yes")
2637    (set_attr "round_suffix" "normal")
2638    (set_attr "trap_suffix" "sui")])
2639
2640 (define_insn_and_split "*floatsisf2_ieee"
2641   [(set (match_operand:SF 0 "register_operand" "=&f")
2642         (float:SF (match_operand:SI 1 "memory_operand" "m")))
2643    (clobber (match_scratch:DI 2 "=&f"))
2644    (clobber (match_scratch:SF 3 "=&f"))]
2645   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2646   "#"
2647   "&& reload_completed"
2648   [(set (match_dup 3) (match_dup 1))
2649    (set (match_dup 2) (unspec:DI [(match_dup 3)] UNSPEC_CVTLQ))
2650    (set (match_dup 0) (float:SF (match_dup 2)))]
2651 {
2652   operands[1] = adjust_address (operands[1], SFmode, 0);
2653 })
2654
2655 (define_insn_and_split "*floatsisf2"
2656   [(set (match_operand:SF 0 "register_operand" "=f")
2657         (float:SF (match_operand:SI 1 "memory_operand" "m")))]
2658   "TARGET_FP"
2659   "#"
2660   "&& reload_completed"
2661   [(set (match_dup 0) (match_dup 1))
2662    (set (match_dup 2) (unspec:DI [(match_dup 0)] UNSPEC_CVTLQ))
2663    (set (match_dup 0) (float:SF (match_dup 2)))]
2664 {
2665   operands[1] = adjust_address (operands[1], SFmode, 0);
2666   operands[2] = gen_rtx_REG (DImode, REGNO (operands[0]));
2667 })
2668
2669 (define_insn "*floatdidf_ieee"
2670   [(set (match_operand:DF 0 "register_operand" "=&f")
2671         (float:DF (match_operand:DI 1 "reg_no_subreg_operand" "f")))]
2672   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2673   "cvtq%-%/ %1,%0"
2674   [(set_attr "type" "fadd")
2675    (set_attr "trap" "yes")
2676    (set_attr "round_suffix" "normal")
2677    (set_attr "trap_suffix" "sui")])
2678
2679 (define_insn "floatdidf2"
2680   [(set (match_operand:DF 0 "register_operand" "=f")
2681         (float:DF (match_operand:DI 1 "reg_no_subreg_operand" "f")))]
2682   "TARGET_FP"
2683   "cvtq%-%/ %1,%0"
2684   [(set_attr "type" "fadd")
2685    (set_attr "trap" "yes")
2686    (set_attr "round_suffix" "normal")
2687    (set_attr "trap_suffix" "sui")])
2688
2689 (define_insn_and_split "*floatsidf2_ieee"
2690   [(set (match_operand:DF 0 "register_operand" "=&f")
2691         (float:DF (match_operand:SI 1 "memory_operand" "m")))
2692    (clobber (match_scratch:DI 2 "=&f"))
2693    (clobber (match_scratch:SF 3 "=&f"))]
2694   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2695   "#"
2696   "&& reload_completed"
2697   [(set (match_dup 3) (match_dup 1))
2698    (set (match_dup 2) (unspec:DI [(match_dup 3)] UNSPEC_CVTLQ))
2699    (set (match_dup 0) (float:DF (match_dup 2)))]
2700 {
2701   operands[1] = adjust_address (operands[1], SFmode, 0);
2702 })
2703
2704 (define_insn_and_split "*floatsidf2"
2705   [(set (match_operand:DF 0 "register_operand" "=f")
2706         (float:DF (match_operand:SI 1 "memory_operand" "m")))]
2707   "TARGET_FP"
2708   "#"
2709   "&& reload_completed"
2710   [(set (match_dup 3) (match_dup 1))
2711    (set (match_dup 2) (unspec:DI [(match_dup 3)] UNSPEC_CVTLQ))
2712    (set (match_dup 0) (float:DF (match_dup 2)))]
2713 {
2714   operands[1] = adjust_address (operands[1], SFmode, 0);
2715   operands[2] = gen_rtx_REG (DImode, REGNO (operands[0]));
2716   operands[3] = gen_rtx_REG (SFmode, REGNO (operands[0]));
2717 })
2718
2719 (define_expand "floatditf2"
2720   [(use (match_operand:TF 0 "register_operand" ""))
2721    (use (match_operand:DI 1 "general_operand" ""))]
2722   "TARGET_HAS_XFLOATING_LIBS"
2723   "alpha_emit_xfloating_cvt (FLOAT, operands); DONE;")
2724
2725 (define_expand "floatunsdisf2"
2726   [(use (match_operand:SF 0 "register_operand" ""))
2727    (use (match_operand:DI 1 "register_operand" ""))]
2728   "TARGET_FP"
2729   "alpha_emit_floatuns (operands); DONE;")
2730
2731 (define_expand "floatunsdidf2"
2732   [(use (match_operand:DF 0 "register_operand" ""))
2733    (use (match_operand:DI 1 "register_operand" ""))]
2734   "TARGET_FP"
2735   "alpha_emit_floatuns (operands); DONE;")
2736
2737 (define_expand "floatunsditf2"
2738   [(use (match_operand:TF 0 "register_operand" ""))
2739    (use (match_operand:DI 1 "general_operand" ""))]
2740   "TARGET_HAS_XFLOATING_LIBS"
2741   "alpha_emit_xfloating_cvt (UNSIGNED_FLOAT, operands); DONE;")
2742
2743 (define_expand "extendsfdf2"
2744   [(set (match_operand:DF 0 "register_operand" "")
2745         (float_extend:DF (match_operand:SF 1 "nonimmediate_operand" "")))]
2746   "TARGET_FP"
2747 {
2748   if (alpha_fptm >= ALPHA_FPTM_SU)
2749     operands[1] = force_reg (SFmode, operands[1]);
2750 })
2751
2752 ;; The Unicos/Mk assembler doesn't support cvtst, but we've already
2753 ;; asserted that alpha_fptm == ALPHA_FPTM_N.
2754
2755 (define_insn "*extendsfdf2_ieee"
2756   [(set (match_operand:DF 0 "register_operand" "=&f")
2757         (float_extend:DF (match_operand:SF 1 "register_operand" "f")))]
2758   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2759   "cvtsts %1,%0"
2760   [(set_attr "type" "fadd")
2761    (set_attr "trap" "yes")])
2762
2763 (define_insn "*extendsfdf2_internal"
2764   [(set (match_operand:DF 0 "register_operand" "=f,f,m")
2765         (float_extend:DF (match_operand:SF 1 "nonimmediate_operand" "f,m,f")))]
2766   "TARGET_FP && alpha_fptm < ALPHA_FPTM_SU"
2767   "@
2768    cpys %1,%1,%0
2769    ld%, %0,%1
2770    st%- %1,%0"
2771   [(set_attr "type" "fcpys,fld,fst")])
2772
2773 ;; Use register_operand for operand 1 to prevent compress_float_constant
2774 ;; from doing something silly.  When optimizing we'll put things back 
2775 ;; together anyway.
2776 (define_expand "extendsftf2"
2777   [(use (match_operand:TF 0 "register_operand" ""))
2778    (use (match_operand:SF 1 "register_operand" ""))]
2779   "TARGET_HAS_XFLOATING_LIBS"
2780 {
2781   rtx tmp = gen_reg_rtx (DFmode);
2782   emit_insn (gen_extendsfdf2 (tmp, operands[1]));
2783   emit_insn (gen_extenddftf2 (operands[0], tmp));
2784   DONE;
2785 })
2786
2787 (define_expand "extenddftf2"
2788   [(use (match_operand:TF 0 "register_operand" ""))
2789    (use (match_operand:DF 1 "register_operand" ""))]
2790   "TARGET_HAS_XFLOATING_LIBS"
2791   "alpha_emit_xfloating_cvt (FLOAT_EXTEND, operands); DONE;")
2792
2793 (define_insn "*truncdfsf2_ieee"
2794   [(set (match_operand:SF 0 "register_operand" "=&f")
2795         (float_truncate:SF (match_operand:DF 1 "reg_or_0_operand" "fG")))]
2796   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2797   "cvt%-%,%/ %R1,%0"
2798   [(set_attr "type" "fadd")
2799    (set_attr "trap" "yes")
2800    (set_attr "round_suffix" "normal")
2801    (set_attr "trap_suffix" "u_su_sui")])
2802
2803 (define_insn "truncdfsf2"
2804   [(set (match_operand:SF 0 "register_operand" "=f")
2805         (float_truncate:SF (match_operand:DF 1 "reg_or_0_operand" "fG")))]
2806   "TARGET_FP"
2807   "cvt%-%,%/ %R1,%0"
2808   [(set_attr "type" "fadd")
2809    (set_attr "trap" "yes")
2810    (set_attr "round_suffix" "normal")
2811    (set_attr "trap_suffix" "u_su_sui")])
2812
2813 (define_expand "trunctfdf2"
2814   [(use (match_operand:DF 0 "register_operand" ""))
2815    (use (match_operand:TF 1 "general_operand" ""))]
2816   "TARGET_HAS_XFLOATING_LIBS"
2817   "alpha_emit_xfloating_cvt (FLOAT_TRUNCATE, operands); DONE;")
2818
2819 (define_expand "trunctfsf2"
2820   [(use (match_operand:SF 0 "register_operand" ""))
2821    (use (match_operand:TF 1 "general_operand" ""))]
2822   "TARGET_FP && TARGET_HAS_XFLOATING_LIBS"
2823 {
2824   rtx tmpf, sticky, arg, lo, hi;
2825
2826   tmpf = gen_reg_rtx (DFmode);
2827   sticky = gen_reg_rtx (DImode);
2828   arg = copy_to_mode_reg (TFmode, operands[1]);
2829   lo = gen_lowpart (DImode, arg);
2830   hi = gen_highpart (DImode, arg);
2831
2832   /* Convert the low word of the TFmode value into a sticky rounding bit,
2833      then or it into the low bit of the high word.  This leaves the sticky
2834      bit at bit 48 of the fraction, which is representable in DFmode,
2835      which prevents rounding error in the final conversion to SFmode.  */
2836
2837   emit_insn (gen_rtx_SET (VOIDmode, sticky,
2838                           gen_rtx_NE (DImode, lo, const0_rtx)));
2839   emit_insn (gen_iordi3 (hi, hi, sticky));
2840   emit_insn (gen_trunctfdf2 (tmpf, arg));
2841   emit_insn (gen_truncdfsf2 (operands[0], tmpf));
2842   DONE;
2843 })
2844
2845 (define_insn "*divsf3_ieee"
2846   [(set (match_operand:SF 0 "register_operand" "=&f")
2847         (div:SF (match_operand:SF 1 "reg_or_0_operand" "fG")
2848                 (match_operand:SF 2 "reg_or_0_operand" "fG")))]
2849   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2850   "div%,%/ %R1,%R2,%0"
2851   [(set_attr "type" "fdiv")
2852    (set_attr "opsize" "si")
2853    (set_attr "trap" "yes")
2854    (set_attr "round_suffix" "normal")
2855    (set_attr "trap_suffix" "u_su_sui")])
2856
2857 (define_insn "divsf3"
2858   [(set (match_operand:SF 0 "register_operand" "=f")
2859         (div:SF (match_operand:SF 1 "reg_or_0_operand" "fG")
2860                 (match_operand:SF 2 "reg_or_0_operand" "fG")))]
2861   "TARGET_FP"
2862   "div%,%/ %R1,%R2,%0"
2863   [(set_attr "type" "fdiv")
2864    (set_attr "opsize" "si")
2865    (set_attr "trap" "yes")
2866    (set_attr "round_suffix" "normal")
2867    (set_attr "trap_suffix" "u_su_sui")])
2868
2869 (define_insn "*divdf3_ieee"
2870   [(set (match_operand:DF 0 "register_operand" "=&f")
2871         (div:DF (match_operand:DF 1 "reg_or_0_operand" "fG")
2872                 (match_operand:DF 2 "reg_or_0_operand" "fG")))]
2873   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2874   "div%-%/ %R1,%R2,%0"
2875   [(set_attr "type" "fdiv")
2876    (set_attr "trap" "yes")
2877    (set_attr "round_suffix" "normal")
2878    (set_attr "trap_suffix" "u_su_sui")])
2879
2880 (define_insn "divdf3"
2881   [(set (match_operand:DF 0 "register_operand" "=f")
2882         (div:DF (match_operand:DF 1 "reg_or_0_operand" "fG")
2883                 (match_operand:DF 2 "reg_or_0_operand" "fG")))]
2884   "TARGET_FP"
2885   "div%-%/ %R1,%R2,%0"
2886   [(set_attr "type" "fdiv")
2887    (set_attr "trap" "yes")
2888    (set_attr "round_suffix" "normal")
2889    (set_attr "trap_suffix" "u_su_sui")])
2890
2891 (define_insn "*divdf_ext1"
2892   [(set (match_operand:DF 0 "register_operand" "=f")
2893         (div:DF (float_extend:DF (match_operand:SF 1 "reg_or_0_operand" "fG"))
2894                 (match_operand:DF 2 "reg_or_0_operand" "fG")))]
2895   "TARGET_FP && alpha_fptm < ALPHA_FPTM_SU"
2896   "div%-%/ %R1,%R2,%0"
2897   [(set_attr "type" "fdiv")
2898    (set_attr "trap" "yes")
2899    (set_attr "round_suffix" "normal")
2900    (set_attr "trap_suffix" "u_su_sui")])
2901
2902 (define_insn "*divdf_ext2"
2903   [(set (match_operand:DF 0 "register_operand" "=f")
2904         (div:DF (match_operand:DF 1 "reg_or_0_operand" "fG")
2905                 (float_extend:DF
2906                  (match_operand:SF 2 "reg_or_0_operand" "fG"))))]
2907   "TARGET_FP && alpha_fptm < ALPHA_FPTM_SU"
2908   "div%-%/ %R1,%R2,%0"
2909   [(set_attr "type" "fdiv")
2910    (set_attr "trap" "yes")
2911    (set_attr "round_suffix" "normal")
2912    (set_attr "trap_suffix" "u_su_sui")])
2913
2914 (define_insn "*divdf_ext3"
2915   [(set (match_operand:DF 0 "register_operand" "=f")
2916         (div:DF (float_extend:DF (match_operand:SF 1 "reg_or_0_operand" "fG"))
2917                 (float_extend:DF (match_operand:SF 2 "reg_or_0_operand" "fG"))))]
2918   "TARGET_FP && alpha_fptm < ALPHA_FPTM_SU"
2919   "div%-%/ %R1,%R2,%0"
2920   [(set_attr "type" "fdiv")
2921    (set_attr "trap" "yes")
2922    (set_attr "round_suffix" "normal")
2923    (set_attr "trap_suffix" "u_su_sui")])
2924
2925 (define_expand "divtf3"
2926   [(use (match_operand 0 "register_operand" ""))
2927    (use (match_operand 1 "general_operand" ""))
2928    (use (match_operand 2 "general_operand" ""))]
2929   "TARGET_HAS_XFLOATING_LIBS"
2930   "alpha_emit_xfloating_arith (DIV, operands); DONE;")
2931
2932 (define_insn "*mulsf3_ieee"
2933   [(set (match_operand:SF 0 "register_operand" "=&f")
2934         (mult:SF (match_operand:SF 1 "reg_or_0_operand" "%fG")
2935                  (match_operand:SF 2 "reg_or_0_operand" "fG")))]
2936   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2937   "mul%,%/ %R1,%R2,%0"
2938   [(set_attr "type" "fmul")
2939    (set_attr "trap" "yes")
2940    (set_attr "round_suffix" "normal")
2941    (set_attr "trap_suffix" "u_su_sui")])
2942
2943 (define_insn "mulsf3"
2944   [(set (match_operand:SF 0 "register_operand" "=f")
2945         (mult:SF (match_operand:SF 1 "reg_or_0_operand" "%fG")
2946                  (match_operand:SF 2 "reg_or_0_operand" "fG")))]
2947   "TARGET_FP"
2948   "mul%,%/ %R1,%R2,%0"
2949   [(set_attr "type" "fmul")
2950    (set_attr "trap" "yes")
2951    (set_attr "round_suffix" "normal")
2952    (set_attr "trap_suffix" "u_su_sui")])
2953
2954 (define_insn "*muldf3_ieee"
2955   [(set (match_operand:DF 0 "register_operand" "=&f")
2956         (mult:DF (match_operand:DF 1 "reg_or_0_operand" "%fG")
2957                  (match_operand:DF 2 "reg_or_0_operand" "fG")))]
2958   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
2959   "mul%-%/ %R1,%R2,%0"
2960   [(set_attr "type" "fmul")
2961    (set_attr "trap" "yes")
2962    (set_attr "round_suffix" "normal")
2963    (set_attr "trap_suffix" "u_su_sui")])
2964
2965 (define_insn "muldf3"
2966   [(set (match_operand:DF 0 "register_operand" "=f")
2967         (mult:DF (match_operand:DF 1 "reg_or_0_operand" "%fG")
2968                  (match_operand:DF 2 "reg_or_0_operand" "fG")))]
2969   "TARGET_FP"
2970   "mul%-%/ %R1,%R2,%0"
2971   [(set_attr "type" "fmul")
2972    (set_attr "trap" "yes")
2973    (set_attr "round_suffix" "normal")
2974    (set_attr "trap_suffix" "u_su_sui")])
2975
2976 (define_insn "*muldf_ext1"
2977   [(set (match_operand:DF 0 "register_operand" "=f")
2978         (mult:DF (float_extend:DF
2979                   (match_operand:SF 1 "reg_or_0_operand" "fG"))
2980                  (match_operand:DF 2 "reg_or_0_operand" "fG")))]
2981   "TARGET_FP && alpha_fptm < ALPHA_FPTM_SU"
2982   "mul%-%/ %R1,%R2,%0"
2983   [(set_attr "type" "fmul")
2984    (set_attr "trap" "yes")
2985    (set_attr "round_suffix" "normal")
2986    (set_attr "trap_suffix" "u_su_sui")])
2987
2988 (define_insn "*muldf_ext2"
2989   [(set (match_operand:DF 0 "register_operand" "=f")
2990         (mult:DF (float_extend:DF
2991                   (match_operand:SF 1 "reg_or_0_operand" "%fG"))
2992                  (float_extend:DF
2993                   (match_operand:SF 2 "reg_or_0_operand" "fG"))))]
2994   "TARGET_FP && alpha_fptm < ALPHA_FPTM_SU"
2995   "mul%-%/ %R1,%R2,%0"
2996   [(set_attr "type" "fmul")
2997    (set_attr "trap" "yes")
2998    (set_attr "round_suffix" "normal")
2999    (set_attr "trap_suffix" "u_su_sui")])
3000
3001 (define_expand "multf3"
3002   [(use (match_operand 0 "register_operand" ""))
3003    (use (match_operand 1 "general_operand" ""))
3004    (use (match_operand 2 "general_operand" ""))]
3005   "TARGET_HAS_XFLOATING_LIBS"
3006   "alpha_emit_xfloating_arith (MULT, operands); DONE;")
3007
3008 (define_insn "*subsf3_ieee"
3009   [(set (match_operand:SF 0 "register_operand" "=&f")
3010         (minus:SF (match_operand:SF 1 "reg_or_0_operand" "fG")
3011                   (match_operand:SF 2 "reg_or_0_operand" "fG")))]
3012   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
3013   "sub%,%/ %R1,%R2,%0"
3014   [(set_attr "type" "fadd")
3015    (set_attr "trap" "yes")
3016    (set_attr "round_suffix" "normal")
3017    (set_attr "trap_suffix" "u_su_sui")])
3018
3019 (define_insn "subsf3"
3020   [(set (match_operand:SF 0 "register_operand" "=f")
3021         (minus:SF (match_operand:SF 1 "reg_or_0_operand" "fG")
3022                   (match_operand:SF 2 "reg_or_0_operand" "fG")))]
3023   "TARGET_FP"
3024   "sub%,%/ %R1,%R2,%0"
3025   [(set_attr "type" "fadd")
3026    (set_attr "trap" "yes")
3027    (set_attr "round_suffix" "normal")
3028    (set_attr "trap_suffix" "u_su_sui")])
3029
3030 (define_insn "*subdf3_ieee"
3031   [(set (match_operand:DF 0 "register_operand" "=&f")
3032         (minus:DF (match_operand:DF 1 "reg_or_0_operand" "fG")
3033                   (match_operand:DF 2 "reg_or_0_operand" "fG")))]
3034   "TARGET_FP && alpha_fptm >= ALPHA_FPTM_SU"
3035   "sub%-%/ %R1,%R2,%0"
3036   [(set_attr "type" "fadd")
3037    (set_attr "trap" "yes")
3038    (set_attr "round_suffix" "normal")
3039    (set_attr "trap_suffix" "u_su_sui")])
3040
3041 (define_insn "subdf3"
3042   [(set (match_operand:DF 0 "register_operand" "=f")
3043         (minus:DF (match_operand:DF 1 "reg_or_0_operand" "fG")
3044                   (match_operand:DF 2 "reg_or_0_operand" "fG")))]
3045   "TARGET_FP"
3046   "sub%-%/ %R1,%R2,%0"
3047   [(set_attr "type" "fadd")
3048    (set_attr "trap" "yes")
3049    (set_attr "round_suffix" "normal")
3050    (set_attr "trap_suffix" "u_su_sui")])
3051
3052 (define_insn "*subdf_ext1"
3053   [(set (match_operand:DF 0 "register_operand" "=f")
3054         (minus:DF (float_extend:DF
3055                    (match_operand:SF 1 "reg_or_0_operand" "fG"))
3056                   (match_operand:DF 2 "reg_or_0_operand" "fG")))]
3057   "TARGET_FP && alpha_fptm < ALPHA_FPTM_SU"
3058   "sub%-%/ %R1,%R2,%0"
3059   [(set_attr "type" "fadd")
3060    (set_attr "trap" "yes")
3061    (set_attr "round_suffix" "normal")
3062    (set_attr "trap_suffix" "u_su_sui")])
3063
3064 (define_insn "*subdf_ext2"
3065   [(set (match_operand:DF 0 "register_operand" "=f")
3066         (minus:DF (match_operand:DF 1 "reg_or_0_operand" "fG")
3067                   (float_extend:DF
3068                    (match_operand:SF 2 "reg_or_0_operand" "fG"))))]
3069   "TARGET_FP && alpha_fptm < ALPHA_FPTM_SU"
3070   "sub%-%/ %R1,%R2,%0"
3071   [(set_attr "type" "fadd")
3072    (set_attr "trap" "yes")
3073    (set_attr "round_suffix" "normal")
3074    (set_attr "trap_suffix" "u_su_sui")])
3075
3076 (define_insn "*subdf_ext3"
3077   [(set (match_operand:DF 0 "register_operand" "=f")
3078         (minus:DF (float_extend:DF
3079                    (match_operand:SF 1 "reg_or_0_operand" "fG"))
3080                   (float_extend:DF
3081                    (match_operand:SF 2 "reg_or_0_operand" "fG"))))]
3082   "TARGET_FP && alpha_fptm < ALPHA_FPTM_SU"
3083   "sub%-%/ %R1,%R2,%0"
3084   [(set_attr "type" "fadd")
3085    (set_attr "trap" "yes")
3086    (set_attr "round_suffix" "normal")
3087    (set_attr "trap_suffix" "u_su_sui")])
3088
3089 (define_expand "subtf3"
3090   [(use (match_operand 0 "register_operand" ""))
3091    (use (match_operand 1 "general_operand" ""))
3092    (use (match_operand 2 "general_operand" ""))]
3093   "TARGET_HAS_XFLOATING_LIBS"
3094   "alpha_emit_xfloating_arith (MINUS, operands); DONE;")
3095
3096 (define_insn "*sqrtsf2_ieee"
3097   [(set (match_operand:SF 0 "register_operand" "=&f")
3098         (sqrt:SF (match_operand:SF 1 "reg_or_0_operand" "fG")))]
3099   "TARGET_FP && TARGET_FIX && alpha_fptm >= ALPHA_FPTM_SU"
3100   "sqrt%,%/ %R1,%0"
3101   [(set_attr "type" "fsqrt")
3102    (set_attr "opsize" "si")
3103    (set_attr "trap" "yes")
3104    (set_attr "round_suffix" "normal")
3105    (set_attr "trap_suffix" "u_su_sui")])
3106
3107 (define_insn "sqrtsf2"
3108   [(set (match_operand:SF 0 "register_operand" "=f")
3109         (sqrt:SF (match_operand:SF 1 "reg_or_0_operand" "fG")))]
3110   "TARGET_FP && TARGET_FIX"
3111   "sqrt%,%/ %R1,%0"
3112   [(set_attr "type" "fsqrt")
3113    (set_attr "opsize" "si")
3114    (set_attr "trap" "yes")
3115    (set_attr "round_suffix" "normal")
3116    (set_attr "trap_suffix" "u_su_sui")])
3117
3118 (define_insn "*sqrtdf2_ieee"
3119   [(set (match_operand:DF 0 "register_operand" "=&f")
3120         (sqrt:DF (match_operand:DF 1 "reg_or_0_operand" "fG")))]
3121   "TARGET_FP && TARGET_FIX && alpha_fptm >= ALPHA_FPTM_SU"
3122   "sqrt%-%/ %R1,%0"
3123   [(set_attr "type" "fsqrt")
3124    (set_attr "trap" "yes")
3125    (set_attr "round_suffix" "normal")
3126    (set_attr "trap_suffix" "u_su_sui")])
3127
3128 (define_insn "sqrtdf2"
3129   [(set (match_operand:DF 0 "register_operand" "=f")
3130         (sqrt:DF (match_operand:DF 1 "reg_or_0_operand" "fG")))]
3131   "TARGET_FP && TARGET_FIX"
3132   "sqrt%-%/ %R1,%0"
3133   [(set_attr "type" "fsqrt")
3134    (set_attr "trap" "yes")
3135    (set_attr "round_suffix" "normal")
3136    (set_attr "trap_suffix" "u_su_sui")])
3137 \f
3138 ;; Next are all the integer comparisons, and conditional moves and branches
3139 ;; and some of the related define_expand's and define_split's.
3140
3141 (define_insn "*setcc_internal"
3142   [(set (match_operand 0 "register_operand" "=r")
3143         (match_operator 1 "alpha_comparison_operator"
3144                            [(match_operand:DI 2 "register_operand" "r")
3145                             (match_operand:DI 3 "reg_or_8bit_operand" "rI")]))]
3146   "GET_MODE_CLASS (GET_MODE (operands[0])) == MODE_INT
3147    && GET_MODE_SIZE (GET_MODE (operands[0])) <= 8
3148    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
3149   "cmp%C1 %2,%3,%0"
3150   [(set_attr "type" "icmp")])
3151
3152 ;; Yes, we can technically support reg_or_8bit_operand in operand 2,
3153 ;; but that's non-canonical rtl and allowing that causes inefficiencies
3154 ;; from cse on.
3155 (define_insn "*setcc_swapped_internal"
3156   [(set (match_operand 0 "register_operand" "=r")
3157         (match_operator 1 "alpha_swapped_comparison_operator"
3158                            [(match_operand:DI 2 "register_operand" "r")
3159                             (match_operand:DI 3 "reg_or_0_operand" "rJ")]))]
3160   "GET_MODE_CLASS (GET_MODE (operands[0])) == MODE_INT
3161    && GET_MODE_SIZE (GET_MODE (operands[0])) <= 8
3162    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
3163   "cmp%c1 %r3,%2,%0"
3164   [(set_attr "type" "icmp")])
3165
3166 ;; Use match_operator rather than ne directly so that we can match
3167 ;; multiple integer modes.
3168 (define_insn "*setne_internal"
3169   [(set (match_operand 0 "register_operand" "=r")
3170         (match_operator 1 "signed_comparison_operator"
3171                           [(match_operand:DI 2 "register_operand" "r")
3172                            (const_int 0)]))]
3173   "GET_MODE_CLASS (GET_MODE (operands[0])) == MODE_INT
3174    && GET_MODE_SIZE (GET_MODE (operands[0])) <= 8
3175    && GET_CODE (operands[1]) == NE
3176    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
3177   "cmpult $31,%2,%0"
3178   [(set_attr "type" "icmp")])
3179
3180 ;; The mode folding trick can't be used with const_int operands, since
3181 ;; reload needs to know the proper mode.
3182 ;;
3183 ;; Use add_operand instead of the more seemingly natural reg_or_8bit_operand
3184 ;; in order to create more pairs of constants.  As long as we're allowing
3185 ;; two constants at the same time, and will have to reload one of them...
3186
3187 (define_insn "*movqicc_internal"
3188   [(set (match_operand:QI 0 "register_operand" "=r,r,r,r")
3189         (if_then_else:QI
3190          (match_operator 2 "signed_comparison_operator"
3191                          [(match_operand:DI 3 "reg_or_0_operand" "rJ,rJ,J,J")
3192                           (match_operand:DI 4 "reg_or_0_operand" "J,J,rJ,rJ")])
3193          (match_operand:QI 1 "add_operand" "rI,0,rI,0")
3194          (match_operand:QI 5 "add_operand" "0,rI,0,rI")))]
3195   "(operands[3] == const0_rtx) ^ (operands[4] == const0_rtx)"
3196   "@
3197    cmov%C2 %r3,%1,%0
3198    cmov%D2 %r3,%5,%0
3199    cmov%c2 %r4,%1,%0
3200    cmov%d2 %r4,%5,%0"
3201   [(set_attr "type" "icmov")])
3202
3203 (define_insn "*movhicc_internal"
3204   [(set (match_operand:HI 0 "register_operand" "=r,r,r,r")
3205         (if_then_else:HI
3206          (match_operator 2 "signed_comparison_operator"
3207                          [(match_operand:DI 3 "reg_or_0_operand" "rJ,rJ,J,J")
3208                           (match_operand:DI 4 "reg_or_0_operand" "J,J,rJ,rJ")])
3209          (match_operand:HI 1 "add_operand" "rI,0,rI,0")
3210          (match_operand:HI 5 "add_operand" "0,rI,0,rI")))]
3211   "(operands[3] == const0_rtx) ^ (operands[4] == const0_rtx)"
3212   "@
3213    cmov%C2 %r3,%1,%0
3214    cmov%D2 %r3,%5,%0
3215    cmov%c2 %r4,%1,%0
3216    cmov%d2 %r4,%5,%0"
3217   [(set_attr "type" "icmov")])
3218
3219 (define_insn "*movsicc_internal"
3220   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
3221         (if_then_else:SI
3222          (match_operator 2 "signed_comparison_operator"
3223                          [(match_operand:DI 3 "reg_or_0_operand" "rJ,rJ,J,J")
3224                           (match_operand:DI 4 "reg_or_0_operand" "J,J,rJ,rJ")])
3225          (match_operand:SI 1 "add_operand" "rI,0,rI,0")
3226          (match_operand:SI 5 "add_operand" "0,rI,0,rI")))]
3227   "(operands[3] == const0_rtx) ^ (operands[4] == const0_rtx)"
3228   "@
3229    cmov%C2 %r3,%1,%0
3230    cmov%D2 %r3,%5,%0
3231    cmov%c2 %r4,%1,%0
3232    cmov%d2 %r4,%5,%0"
3233   [(set_attr "type" "icmov")])
3234
3235 (define_insn "*movdicc_internal"
3236   [(set (match_operand:DI 0 "register_operand" "=r,r,r,r")
3237         (if_then_else:DI
3238          (match_operator 2 "signed_comparison_operator"
3239                          [(match_operand:DI 3 "reg_or_0_operand" "rJ,rJ,J,J")
3240                           (match_operand:DI 4 "reg_or_0_operand" "J,J,rJ,rJ")])
3241          (match_operand:DI 1 "add_operand" "rI,0,rI,0")
3242          (match_operand:DI 5 "add_operand" "0,rI,0,rI")))]
3243   "(operands[3] == const0_rtx) ^ (operands[4] == const0_rtx)"
3244   "@
3245    cmov%C2 %r3,%1,%0
3246    cmov%D2 %r3,%5,%0
3247    cmov%c2 %r4,%1,%0
3248    cmov%d2 %r4,%5,%0"
3249   [(set_attr "type" "icmov")])
3250
3251 (define_insn "*movqicc_lbc"
3252   [(set (match_operand:QI 0 "register_operand" "=r,r")
3253         (if_then_else:QI
3254          (eq (zero_extract:DI (match_operand:DI 2 "reg_or_0_operand" "rJ,rJ")
3255                               (const_int 1)
3256                               (const_int 0))
3257              (const_int 0))
3258          (match_operand:QI 1 "reg_or_8bit_operand" "rI,0")
3259          (match_operand:QI 3 "reg_or_8bit_operand" "0,rI")))]
3260   ""
3261   "@
3262    cmovlbc %r2,%1,%0
3263    cmovlbs %r2,%3,%0"
3264   [(set_attr "type" "icmov")])
3265
3266 (define_insn "*movhicc_lbc"
3267   [(set (match_operand:HI 0 "register_operand" "=r,r")
3268         (if_then_else:HI
3269          (eq (zero_extract:DI (match_operand:DI 2 "reg_or_0_operand" "rJ,rJ")
3270                               (const_int 1)
3271                               (const_int 0))
3272              (const_int 0))
3273          (match_operand:HI 1 "reg_or_8bit_operand" "rI,0")
3274          (match_operand:HI 3 "reg_or_8bit_operand" "0,rI")))]
3275   ""
3276   "@
3277    cmovlbc %r2,%1,%0
3278    cmovlbs %r2,%3,%0"
3279   [(set_attr "type" "icmov")])
3280
3281 (define_insn "*movsicc_lbc"
3282   [(set (match_operand:SI 0 "register_operand" "=r,r")
3283         (if_then_else:SI
3284          (eq (zero_extract:DI (match_operand:DI 2 "reg_or_0_operand" "rJ,rJ")
3285                               (const_int 1)
3286                               (const_int 0))
3287              (const_int 0))
3288          (match_operand:SI 1 "reg_or_8bit_operand" "rI,0")
3289          (match_operand:SI 3 "reg_or_8bit_operand" "0,rI")))]
3290   ""
3291   "@
3292    cmovlbc %r2,%1,%0
3293    cmovlbs %r2,%3,%0"
3294   [(set_attr "type" "icmov")])
3295
3296 (define_insn "*movdicc_lbc"
3297   [(set (match_operand:DI 0 "register_operand" "=r,r")
3298         (if_then_else:DI
3299          (eq (zero_extract:DI (match_operand:DI 2 "reg_or_0_operand" "rJ,rJ")
3300                               (const_int 1)
3301                               (const_int 0))
3302              (const_int 0))
3303          (match_operand:DI 1 "reg_or_8bit_operand" "rI,0")
3304          (match_operand:DI 3 "reg_or_8bit_operand" "0,rI")))]
3305   ""
3306   "@
3307    cmovlbc %r2,%1,%0
3308    cmovlbs %r2,%3,%0"
3309   [(set_attr "type" "icmov")])
3310
3311 (define_insn "*movqicc_lbs"
3312   [(set (match_operand:QI 0 "register_operand" "=r,r")
3313         (if_then_else:QI
3314          (ne (zero_extract:DI (match_operand:DI 2 "reg_or_0_operand" "rJ,rJ")
3315                               (const_int 1)
3316                               (const_int 0))
3317              (const_int 0))
3318          (match_operand:QI 1 "reg_or_8bit_operand" "rI,0")
3319          (match_operand:QI 3 "reg_or_8bit_operand" "0,rI")))]
3320   ""
3321   "@
3322    cmovlbs %r2,%1,%0
3323    cmovlbc %r2,%3,%0"
3324   [(set_attr "type" "icmov")])
3325
3326 (define_insn "*movhicc_lbs"
3327   [(set (match_operand:HI 0 "register_operand" "=r,r")
3328         (if_then_else:HI
3329          (ne (zero_extract:DI (match_operand:DI 2 "reg_or_0_operand" "rJ,rJ")
3330                               (const_int 1)
3331                               (const_int 0))
3332              (const_int 0))
3333          (match_operand:HI 1 "reg_or_8bit_operand" "rI,0")
3334          (match_operand:HI 3 "reg_or_8bit_operand" "0,rI")))]
3335   ""
3336   "@
3337    cmovlbs %r2,%1,%0
3338    cmovlbc %r2,%3,%0"
3339   [(set_attr "type" "icmov")])
3340
3341 (define_insn "*movsicc_lbs"
3342   [(set (match_operand:SI 0 "register_operand" "=r,r")
3343         (if_then_else:SI
3344          (ne (zero_extract:DI (match_operand:DI 2 "reg_or_0_operand" "rJ,rJ")
3345                               (const_int 1)
3346                               (const_int 0))
3347              (const_int 0))
3348          (match_operand:SI 1 "reg_or_8bit_operand" "rI,0")
3349          (match_operand:SI 3 "reg_or_8bit_operand" "0,rI")))]
3350   ""
3351   "@
3352    cmovlbs %r2,%1,%0
3353    cmovlbc %r2,%3,%0"
3354   [(set_attr "type" "icmov")])
3355
3356 (define_insn "*movdicc_lbs"
3357   [(set (match_operand:DI 0 "register_operand" "=r,r")
3358         (if_then_else:DI
3359          (ne (zero_extract:DI (match_operand:DI 2 "reg_or_0_operand" "rJ,rJ")
3360                               (const_int 1)
3361                               (const_int 0))
3362              (const_int 0))
3363          (match_operand:DI 1 "reg_or_8bit_operand" "rI,0")
3364          (match_operand:DI 3 "reg_or_8bit_operand" "0,rI")))]
3365   ""
3366   "@
3367    cmovlbs %r2,%1,%0
3368    cmovlbc %r2,%3,%0"
3369   [(set_attr "type" "icmov")])
3370
3371 ;; For ABS, we have two choices, depending on whether the input and output
3372 ;; registers are the same or not.
3373 (define_expand "absdi2"
3374   [(set (match_operand:DI 0 "register_operand" "")
3375         (abs:DI (match_operand:DI 1 "register_operand" "")))]
3376   ""
3377 {