OSDN Git Service

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