OSDN Git Service

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