OSDN Git Service

570ab915ae26ed68304ad6a4a5b3f46f587ebe58
[pf3gnuchains/gcc-fork.git] / gcc / config / alpha / alpha.md
1 ;; Machine description for DEC Alpha for GNU C compiler
2 ;; Copyright (C) 1992, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
3 ;; Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
4
5 ;; This file is part of GNU CC.
6
7 ;; GNU CC is free software; you can redistribute it and/or modify
8 ;; it under the terms of the GNU General Public License as published by
9 ;; the Free Software Foundation; either version 2, or (at your option)
10 ;; any later version.
11
12 ;; GNU CC is distributed in the hope that it will be useful,
13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 ;; GNU General Public License for more details.
16
17 ;; You should have received a copy of the GNU General Public License
18 ;; along with GNU CC; see the file COPYING.  If not, write to
19 ;; the Free Software Foundation, 59 Temple Place - Suite 330,
20 ;; Boston, MA 02111-1307, USA.
21
22 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
23 \f
24 ;; Processor type -- this attribute must exactly match the processor_type
25 ;; enumeration in alpha.h.
26
27 (define_attr "cpu" "ev4,ev5"
28   (const (symbol_ref "alpha_cpu")))
29
30 ;; Define an insn type attribute.  This is used in function unit delay
31 ;; computations, among other purposes.  For the most part, we use the names
32 ;; defined in the EV4 documentation, but add a few that we have to know about
33 ;; separately.
34
35 (define_attr "type"
36   "ld,st,ibr,fbr,jsr,iadd,ilog,shift,cmov,icmp,imull,imulq,imulh,fadd,fmul,fcpys,fdivs,fdivt,ldsym,misc"
37   (const_string "iadd"))
38
39 ;; The TRAP_TYPE attribute marks instructions that may generate traps
40 ;; (which are imprecise and may need a trapb if software complention
41 ;; is desired).
42 (define_attr "trap" "yes,no" (const_string "no"))
43
44 ;; For the EV4 we include four function units: ABOX, which computes
45 ;; the address, BBOX, used for branches, EBOX, used for integer
46 ;; operations, and FBOX, used for FP operations.
47
48 ;; Memory delivers its result in three cycles.
49 (define_function_unit "ev4_abox" 1 0
50   (and (eq_attr "cpu" "ev4")
51        (eq_attr "type" "ld,ldsym,st"))
52   3 1)
53
54 ;; Branches have no delay cost, but do tie up the unit for two cycles.
55 (define_function_unit "ev4_bbox" 1 1
56   (and (eq_attr "cpu" "ev4")
57        (eq_attr "type" "ibr,fbr,jsr"))
58   2 2)
59
60 ;; Arithmetic insns are normally have their results available after
61 ;; two cycles.  There are a number of exceptions.  They are encoded in
62 ;; ADJUST_COST.  Some of the other insns have similar exceptions.
63
64 (define_function_unit "ev4_ebox" 1 0
65   (and (eq_attr "cpu" "ev4")
66        (eq_attr "type" "iadd,ilog,shift,cmov,icmp"))
67   2 1)
68
69 ;; These really don't take up the integer pipeline, but they do occupy
70 ;; IBOX1; we approximate here.
71
72 (define_function_unit "ev4_ebox" 1 0
73   (and (eq_attr "cpu" "ev4")
74        (eq_attr "type" "imull"))
75   21 1)
76
77 (define_function_unit "ev4_ebox" 1 0
78   (and (eq_attr "cpu" "ev4")
79        (eq_attr "type" "imulq,imulh"))
80   23 1)
81
82 (define_function_unit "ev4_imult" 1 0
83   (and (eq_attr "cpu" "ev4")
84        (eq_attr "type" "imull"))
85   21 19)
86
87 (define_function_unit "ev4_imult" 1 0
88   (and (eq_attr "cpu" "ev4")
89        (eq_attr "type" "imulq,imulh"))
90   23 21)
91
92 (define_function_unit "ev4_fbox" 1 0
93   (and (eq_attr "cpu" "ev4")
94        (eq_attr "type" "fadd,fmul,fcpys"))
95   6 1)
96
97 (define_function_unit "ev4_fbox" 1 0
98   (and (eq_attr "cpu" "ev4")
99        (eq_attr "type" "fdivs"))
100   34 0)
101
102 (define_function_unit "ev4_fbox" 1 0
103   (and (eq_attr "cpu" "ev4")
104        (eq_attr "type" "fdivt"))
105   63 0)
106
107 (define_function_unit "ev4_divider" 1 0
108   (and (eq_attr "cpu" "ev4")
109        (eq_attr "type" "fdivs"))
110   34 30)
111
112 (define_function_unit "ev4_divider" 1 0
113   (and (eq_attr "cpu" "ev4")
114        (eq_attr "type" "fdivt"))
115   64 59)
116 \f
117 ;; EV5 scheduling.  EV5 can issue 4 insns per clock.
118
119 ;; EV5 has two asymetric integer units.  Model this with ebox,e0,e1.
120 ;; Everything uses ebox, and those that require particular pipes grab
121 ;; those as well.
122
123 (define_function_unit "ev5_ebox" 2 0
124   (and (eq_attr "cpu" "ev5")
125        (eq_attr "type" "iadd,ilog,icmp,st,shift,imull,imulq,imulh"))
126   1 1)
127
128 ;; Memory takes at least 2 clocks, and load cannot dual issue with stores.
129 (define_function_unit "ev5_ebox" 2 0
130   (and (eq_attr "cpu" "ev5")
131        (eq_attr "type" "ld,ldsym"))
132   2 1)
133
134 (define_function_unit "ev5_e0" 1 0
135   (and (eq_attr "cpu" "ev5")
136        (eq_attr "type" "ld,ldsym"))
137   0 1
138   [(eq_attr "type" "st")])
139
140 ;; Conditional moves always take 2 ticks.
141 (define_function_unit "ev5_ebox" 2 0
142   (and (eq_attr "cpu" "ev5")
143        (eq_attr "type" "cmov"))
144   2 1)
145
146 ;; Stores, shifts, and multiplies can only issue to E0
147 (define_function_unit "ev5_e0" 1 0
148   (and (eq_attr "cpu" "ev5")
149        (eq_attr "type" "st"))
150   1 1)
151
152 ;; But shifts and multiplies don't conflict with loads.
153 (define_function_unit "ev5_e0" 1 0
154   (and (eq_attr "cpu" "ev5")
155        (eq_attr "type" "shift,imull,imulq,imulh"))
156   1 1
157   [(eq_attr "type" "st,shift,imull,imulq,imulh")])
158
159 ;; Branches can only issue to E1
160 (define_function_unit "ev5_e1" 1 0
161   (and (eq_attr "cpu" "ev5")
162        (eq_attr "type" "ibr,jsr"))
163   1 1)
164
165 ;; Multiplies also use the integer multiplier.
166 (define_function_unit "ev5_imult" 1 0
167   (and (eq_attr "cpu" "ev5")
168        (eq_attr "type" "imull"))
169   8 4)
170
171 (define_function_unit "ev5_imult" 1 0
172   (and (eq_attr "cpu" "ev5")
173        (eq_attr "type" "imulq"))
174   12 8)
175
176 (define_function_unit "ev5_imult" 1 0
177   (and (eq_attr "cpu" "ev5")
178        (eq_attr "type" "imulh"))
179   14 8)
180
181 ;; Similarly for the FPU we have two asymetric units.  But fcpys can issue
182 ;; on either so we have to play the game again.
183
184 (define_function_unit "ev5_fpu" 2 0
185   (and (eq_attr "cpu" "ev5")
186        (eq_attr "type" "fadd,fmul,fcpys,fbr,fdivs,fdivt"))
187   4 1)
188   
189 ;; Multiplies (resp. adds) also use the fmul (resp. fadd) units.
190 (define_function_unit "ev5_fm" 1 0
191   (and (eq_attr "cpu" "ev5")
192        (eq_attr "type" "fmul"))
193   4 1)
194
195 (define_function_unit "ev5_fa" 1 0
196   (and (eq_attr "cpu" "ev5")
197        (eq_attr "type" "fadd"))
198   4 1)
199
200 (define_function_unit "ev5_fa" 1 0
201   (and (eq_attr "cpu" "ev5")
202        (eq_attr "type" "fbr"))
203   1 1)
204
205 (define_function_unit "ev5_fa" 1 0
206   (and (eq_attr "cpu" "ev5")
207        (eq_attr "type" "fdivs"))
208   15 1)
209
210 (define_function_unit "ev5_fa" 1 0
211   (and (eq_attr "cpu" "ev5")
212        (eq_attr "type" "fdivt"))
213   22 1)
214 \f
215 ;; First define the arithmetic insns.  Note that the 32-bit forms also
216 ;; sign-extend.
217
218 ;; Note that we can do sign extensions in both FP and integer registers.
219 ;; However, the result must be in the same type of register as the input.
220 ;; The register preferencing code can't handle this case very well, so, for
221 ;; now, don't let the FP case show up here for preferencing.  Also,
222 ;; sign-extends in FP registers take two instructions.
223 (define_insn "extendsidi2"
224   [(set (match_operand:DI 0 "register_operand" "=r,r,*f")
225         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "r,m,*f")))]
226   ""
227   "@
228    addl %1,$31,%0
229    ldl %0,%1
230    cvtql %1,%0\;cvtlq %0,%0"
231   [(set_attr "type" "iadd,ld,fadd")])
232
233 ;; Do addsi3 the way expand_binop would do if we didn't have one.  This
234 ;; generates better code.  We have the anonymous addsi3 pattern below in
235 ;; case combine wants to make it.
236 (define_expand "addsi3"
237   [(set (match_operand:SI 0 "register_operand" "")
238         (plus:SI (match_operand:SI 1 "reg_or_0_operand" "")
239                  (match_operand:SI 2 "add_operand" "")))]
240   ""
241   "
242 { emit_insn (gen_rtx (SET, VOIDmode, gen_lowpart (DImode, operands[0]),
243                       gen_rtx (PLUS, DImode,
244                                gen_lowpart (DImode, operands[1]),
245                                gen_lowpart (DImode, operands[2]))));
246   DONE;
247 } ")
248
249 (define_insn ""
250   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
251         (plus:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ,rJ,rJ,rJ")
252                  (match_operand:SI 2 "add_operand" "rI,O,K,L")))]
253   ""
254   "@
255    addl %r1,%2,%0
256    subl %r1,%n2,%0
257    lda %0,%2(%r1)
258    ldah %0,%h2(%r1)")
259
260 (define_split
261   [(set (match_operand:SI 0 "register_operand" "")
262         (plus:SI (match_operand:SI 1 "register_operand" "")
263                  (match_operand:SI 2 "const_int_operand" "")))]
264   "! add_operand (operands[2], SImode)"
265   [(set (match_dup 0) (plus:SI (match_dup 1) (match_dup 3)))
266    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 4)))]
267   "
268 {
269   HOST_WIDE_INT val = INTVAL (operands[2]);
270   HOST_WIDE_INT low = (val & 0xffff) - 2 * (val & 0x8000);
271   HOST_WIDE_INT rest = val - low;
272
273   operands[3] = GEN_INT (rest);
274   operands[4] = GEN_INT (low);
275 }")
276
277 (define_insn ""
278   [(set (match_operand:DI 0 "register_operand" "=r,r")
279         (sign_extend:DI
280          (plus:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ,rJ")
281                   (match_operand:SI 2 "sext_add_operand" "rI,O"))))]
282   ""
283   "@
284    addl %r1,%2,%0
285    subl %r1,%n2,%0")
286
287 (define_split
288   [(set (match_operand:DI 0 "register_operand" "")
289         (sign_extend:DI
290          (plus:SI (match_operand:SI 1 "register_operand" "")
291                   (match_operand:SI 2 "const_int_operand" ""))))
292    (clobber (match_operand:SI 3 "register_operand" ""))]
293   "! sext_add_operand (operands[2], SImode) && INTVAL (operands[2]) > 0
294    && INTVAL (operands[2]) % 4 == 0"
295   [(set (match_dup 3) (match_dup 4))
296    (set (match_dup 0) (sign_extend:DI (plus:SI (mult:SI (match_dup 3)
297                                                         (match_dup 5))
298                                                (match_dup 1))))]
299   "
300 {
301   HOST_WIDE_INT val = INTVAL (operands[2]) / 4;
302   int mult = 4;
303
304   if (val % 2 == 0)
305     val /= 2, mult = 8;
306
307   operands[4] = GEN_INT (val);
308   operands[5] = GEN_INT (mult);
309 }")
310
311 (define_split
312   [(set (match_operand:DI 0 "register_operand" "")
313         (sign_extend:DI
314          (plus:SI (match_operator:SI 1 "comparison_operator"
315                                      [(match_operand 2 "" "")
316                                       (match_operand 3 "" "")])
317                   (match_operand:SI 4 "add_operand" ""))))
318    (clobber (match_operand:DI 5 "register_operand" ""))]
319   ""
320   [(set (match_dup 5) (match_dup 6))
321    (set (match_dup 0) (sign_extend:DI (plus:SI (match_dup 7) (match_dup 4))))]
322   "
323 {
324   operands[6] = gen_rtx (GET_CODE (operands[1]), DImode,
325                          operands[2], operands[3]);
326   operands[7] = gen_lowpart (SImode, operands[5]);
327 }")
328
329 (define_insn "adddi3"
330   [(set (match_operand:DI 0 "register_operand" "=r,r,r,r")
331         (plus:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ,rJ,rJ,rJ")
332                  (match_operand:DI 2 "add_operand" "rI,O,K,L")))]
333   ""
334   "@
335    addq %r1,%2,%0
336    subq %r1,%n2,%0
337    lda %0,%2(%r1)
338    ldah %0,%h2(%r1)")
339
340 ;; Don't do this if we are adjusting SP since we don't want to do
341 ;; it in two steps. 
342 (define_split
343   [(set (match_operand:DI 0 "register_operand" "")
344         (plus:DI (match_operand:DI 1 "register_operand" "")
345                  (match_operand:DI 2 "const_int_operand" "")))]
346   "! add_operand (operands[2], DImode)
347    && REGNO (operands[0]) != STACK_POINTER_REGNUM"
348   [(set (match_dup 0) (plus:DI (match_dup 1) (match_dup 3)))
349    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 4)))]
350   "
351 {
352   HOST_WIDE_INT val = INTVAL (operands[2]);
353   HOST_WIDE_INT low = (val & 0xffff) - 2 * (val & 0x8000);
354   HOST_WIDE_INT rest = val - low;
355
356   operands[3] = GEN_INT (rest);
357   operands[4] = GEN_INT (low);
358 }")
359
360 (define_insn ""
361   [(set (match_operand:SI 0 "register_operand" "=r,r")
362         (plus:SI (mult:SI (match_operand:SI 1 "reg_or_0_operand" "rJ,rJ")
363                           (match_operand:SI 2 "const48_operand" "I,I"))
364                  (match_operand:SI 3 "sext_add_operand" "rI,O")))]
365   ""
366   "@
367    s%2addl %r1,%3,%0
368    s%2subl %r1,%n3,%0")
369
370 (define_insn ""
371   [(set (match_operand:DI 0 "register_operand" "=r,r")
372         (sign_extend:DI
373          (plus:SI (mult:SI (match_operand:SI 1 "reg_or_0_operand" "rJ,rJ")
374                            (match_operand:SI 2 "const48_operand" "I,I"))
375                   (match_operand:SI 3 "sext_add_operand" "rI,O"))))]
376   ""
377   "@
378    s%2addl %r1,%3,%0
379    s%2subl %r1,%n3,%0")
380
381 (define_split
382   [(set (match_operand:DI 0 "register_operand" "")
383         (sign_extend:DI
384          (plus:SI (mult:SI (match_operator:SI 1 "comparison_operator"
385                                               [(match_operand 2 "" "")
386                                                (match_operand 3 "" "")])
387                            (match_operand:SI 4 "const48_operand" ""))
388                   (match_operand:SI 5 "add_operand" ""))))
389    (clobber (match_operand:DI 6 "register_operand" ""))]
390   ""
391   [(set (match_dup 6) (match_dup 7))
392    (set (match_dup 0)
393         (sign_extend:DI (plus:SI (mult:SI (match_dup 8) (match_dup 4))
394                                  (match_dup 5))))]
395   "
396 {
397   operands[7] = gen_rtx (GET_CODE (operands[1]), DImode,
398                          operands[2], operands[3]);
399   operands[8] = gen_lowpart (SImode, operands[6]);
400 }")
401
402 (define_insn ""
403   [(set (match_operand:DI 0 "register_operand" "=r,r")
404         (plus:DI (mult:DI (match_operand:DI 1 "reg_or_0_operand" "rJ,rJ")
405                           (match_operand:DI 2 "const48_operand" "I,I"))
406                  (match_operand:DI 3 "reg_or_8bit_operand" "rI,O")))]
407   ""
408   "@
409    s%2addq %r1,%3,%0
410    s%2subq %1,%n3,%0")
411
412 ;; These variants of the above insns can occur if the third operand
413 ;; is the frame pointer.  This is a kludge, but there doesn't
414 ;; seem to be a way around it.  Only recognize them while reloading.
415
416 (define_insn ""
417   [(set (match_operand:DI 0 "some_operand" "=&r")
418         (plus:DI (plus:DI (match_operand:DI 1 "some_operand" "r")
419                           (match_operand:DI 2 "some_operand" "r"))
420                  (match_operand:DI 3 "some_operand" "rIOKL")))]
421   "reload_in_progress"
422   "#")
423
424 (define_split
425   [(set (match_operand:DI 0 "register_operand" "")
426         (plus:DI (plus:DI (match_operand:DI 1 "register_operand" "")
427                           (match_operand:DI 2 "register_operand" ""))
428                  (match_operand:DI 3 "add_operand" "")))]
429   "reload_completed"
430   [(set (match_dup 0) (plus:DI (match_dup 1) (match_dup 2)))
431    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 3)))]
432   "")
433                                            
434 (define_insn ""
435   [(set (match_operand:SI 0 "some_operand" "=&r")
436         (plus:SI (plus:SI (mult:SI (match_operand:SI 1 "some_operand" "rJ")
437                                    (match_operand:SI 2 "const48_operand" "I"))
438                           (match_operand:SI 3 "some_operand" "r"))
439                  (match_operand:SI 4 "some_operand" "rIOKL")))]
440   "reload_in_progress"
441   "#")
442
443 (define_split
444   [(set (match_operand:SI 0 "register_operand" "r")
445         (plus:SI (plus:SI (mult:SI (match_operand:SI 1 "reg_or_0_operand" "")
446                                    (match_operand:SI 2 "const48_operand" ""))
447                           (match_operand:SI 3 "register_operand" ""))
448                  (match_operand:SI 4 "add_operand" "rIOKL")))]
449   "reload_completed"
450   [(set (match_dup 0)
451         (plus:SI (mult:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
452    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 4)))]
453   "")
454
455 (define_insn ""
456   [(set (match_operand:DI 0 "some_operand" "=&r")
457         (sign_extend:DI
458          (plus:SI (plus:SI
459                    (mult:SI (match_operand:SI 1 "some_operand" "rJ")
460                             (match_operand:SI 2 "const48_operand" "I"))
461                    (match_operand:SI 3 "some_operand" "r"))
462                   (match_operand:SI 4 "some_operand" "rIOKL"))))]
463   "reload_in_progress"
464   "#")
465
466 (define_split
467   [(set (match_operand:DI 0 "register_operand" "")
468         (sign_extend:DI
469          (plus:SI (plus:SI
470                    (mult:SI (match_operand:SI 1 "reg_or_0_operand" "")
471                             (match_operand:SI 2 "const48_operand" ""))
472                    (match_operand:SI 3 "register_operand" ""))
473                   (match_operand:SI 4 "add_operand" ""))))]
474   "reload_completed"
475   [(set (match_dup 5)
476         (plus:SI (mult:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
477    (set (match_dup 0) (sign_extend:DI (plus:SI (match_dup 5) (match_dup 4))))]
478   "
479 { operands[5] = gen_lowpart (SImode, operands[0]);
480 }")
481
482 (define_insn ""
483   [(set (match_operand:DI 0 "some_operand" "=&r")
484         (plus:DI (plus:DI (mult:DI (match_operand:DI 1 "some_operand" "rJ")
485                                    (match_operand:DI 2 "const48_operand" "I"))
486                           (match_operand:DI 3 "some_operand" "r"))
487                  (match_operand:DI 4 "some_operand" "rIOKL")))]
488   "reload_in_progress"
489   "#")
490
491 (define_split
492   [(set (match_operand:DI 0 "register_operand" "=")
493         (plus:DI (plus:DI (mult:DI (match_operand:DI 1 "reg_or_0_operand" "")
494                                    (match_operand:DI 2 "const48_operand" ""))
495                           (match_operand:DI 3 "register_operand" ""))
496                  (match_operand:DI 4 "add_operand" "")))]
497   "reload_completed"
498   [(set (match_dup 0)
499         (plus:DI (mult:DI (match_dup 1) (match_dup 2)) (match_dup 3)))
500    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 4)))]
501   "")
502
503 (define_insn "negsi2"
504   [(set (match_operand:SI 0 "register_operand" "=r")
505         (neg:SI (match_operand:SI 1 "reg_or_8bit_operand" "rI")))]
506   ""
507   "subl $31,%1,%0")
508
509 (define_insn ""
510   [(set (match_operand:DI 0 "register_operand" "=r")
511         (sign_extend:DI (neg:SI
512                          (match_operand:SI 1 "reg_or_8bit_operand" "rI"))))]
513   ""
514   "subl $31,%1,%0")
515
516 (define_insn "negdi2"
517   [(set (match_operand:DI 0 "register_operand" "=r")
518         (neg:DI (match_operand:DI 1 "reg_or_8bit_operand" "rI")))]
519   ""
520   "subq $31,%1,%0")
521
522 (define_expand "subsi3"
523   [(set (match_operand:SI 0 "register_operand" "")
524         (minus:SI (match_operand:SI 1 "reg_or_0_operand" "")
525                   (match_operand:SI 2 "reg_or_8bit_operand" "")))]
526   ""
527   "
528 { emit_insn (gen_rtx (SET, VOIDmode, gen_lowpart (DImode, operands[0]),
529                       gen_rtx (MINUS, DImode,
530                                gen_lowpart (DImode, operands[1]),
531                                gen_lowpart (DImode, operands[2]))));
532   DONE;
533
534 } ")
535
536 (define_insn ""
537   [(set (match_operand:SI 0 "register_operand" "=r")
538         (minus:SI (match_operand:SI 1 "reg_or_0_operand" "rJ")
539                   (match_operand:SI 2 "reg_or_8bit_operand" "rI")))]
540   ""
541   "subl %r1,%2,%0")
542
543 (define_insn ""
544   [(set (match_operand:DI 0 "register_operand" "=r")
545         (sign_extend:DI (minus:SI (match_operand:SI 1 "reg_or_0_operand" "rJ")
546                                   (match_operand:SI 2 "reg_or_8bit_operand" "rI"))))]
547   ""
548   "subl %r1,%2,%0")
549
550 (define_insn "subdi3"
551   [(set (match_operand:DI 0 "register_operand" "=r")
552         (minus:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
553                   (match_operand:DI 2 "reg_or_8bit_operand" "rI")))]
554   ""
555   "subq %r1,%2,%0")
556
557 (define_insn ""
558   [(set (match_operand:SI 0 "register_operand" "=r")
559         (minus:SI (mult:SI (match_operand:SI 1 "reg_or_0_operand" "rJ")
560                            (match_operand:SI 2 "const48_operand" "I"))
561                   (match_operand:SI 3 "reg_or_8bit_operand" "rI")))]
562   ""
563   "s%2subl %r1,%3,%0")
564
565 (define_insn ""
566   [(set (match_operand:DI 0 "register_operand" "=r")
567         (sign_extend:DI
568          (minus:SI (mult:SI (match_operand:SI 1 "reg_or_0_operand" "rJ")
569                             (match_operand:SI 2 "const48_operand" "I"))
570                    (match_operand:SI 3 "reg_or_8bit_operand" "rI"))))]
571   ""
572   "s%2subl %r1,%3,%0")
573
574 (define_insn ""
575   [(set (match_operand:DI 0 "register_operand" "=r")
576         (minus:DI (mult:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
577                            (match_operand:DI 2 "const48_operand" "I"))
578                   (match_operand:DI 3 "reg_or_8bit_operand" "rI")))]
579   ""
580   "s%2subq %r1,%3,%0")
581
582 (define_insn "mulsi3"
583   [(set (match_operand:SI 0 "register_operand" "=r")
584         (mult:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ")
585                  (match_operand:SI 2 "reg_or_0_operand" "rJ")))]
586   ""
587   "mull %r1,%r2,%0"
588   [(set_attr "type" "imull")])
589
590 (define_insn ""
591   [(set (match_operand:DI 0 "register_operand" "=r")
592         (sign_extend:DI (mult:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ")
593                                  (match_operand:SI 2 "reg_or_0_operand" "rJ"))))]
594   ""
595   "mull %r1,%r2,%0"
596   [(set_attr "type" "imull")])
597
598 (define_insn "muldi3"
599   [(set (match_operand:DI 0 "register_operand" "=r")
600         (mult:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ")
601                  (match_operand:DI 2 "reg_or_0_operand" "rJ")))]
602   ""
603   "mulq %r1,%r2,%0"
604   [(set_attr "type" "imulq")])
605
606 (define_insn "umuldi3_highpart"
607   [(set (match_operand:DI 0 "register_operand" "=r")
608         (truncate:DI
609          (lshiftrt:TI
610           (mult:TI (zero_extend:TI (match_operand:DI 1 "register_operand" "r"))
611                    (zero_extend:TI (match_operand:DI 2 "register_operand" "r")))
612           (const_int 64))))]
613   ""
614   "umulh %1,%2,%0"
615   [(set_attr "type" "imulh")])
616
617 (define_insn ""
618   [(set (match_operand:DI 0 "register_operand" "=r")
619         (truncate:DI
620          (lshiftrt:TI
621           (mult:TI (zero_extend:TI (match_operand:DI 1 "register_operand" "r"))
622                    (match_operand:TI 2 "cint8_operand" "I"))
623           (const_int 64))))]
624   ""
625   "umulh %1,%2,%0"
626   [(set_attr "type" "imulh")])
627 \f
628 ;; The divide and remainder operations always take their inputs from
629 ;; r24 and r25, put their output in r27, and clobber r23 and r28.
630
631 ;; ??? comment out the divsi routines since the library functions
632 ;; don't seem to do the right thing with the high 32-bits of a
633 ;; register nonzero.
634
635 ;(define_expand "divsi3"
636 ;  [(set (reg:SI 24) (match_operand:SI 1 "input_operand" ""))
637 ;   (set (reg:SI 25) (match_operand:SI 2 "input_operand" ""))
638 ;   (parallel [(set (reg:SI 27)
639 ;                  (div:SI (reg:SI 24)
640 ;                          (reg:SI 25)))
641 ;             (clobber (reg:DI 23))
642 ;             (clobber (reg:DI 28))])
643 ;   (set (match_operand:SI 0 "general_operand" "")
644 ;       (reg:SI 27))]
645 ;  "!TARGET_OPEN_VMS"
646 ;  "")
647
648 ;(define_expand "udivsi3"
649 ;  [(set (reg:SI 24) (match_operand:SI 1 "input_operand" ""))
650 ;   (set (reg:SI 25) (match_operand:SI 2 "input_operand" ""))
651 ;   (parallel [(set (reg:SI 27)
652 ;                  (udiv:SI (reg:SI 24)
653 ;                           (reg:SI 25)))
654 ;             (clobber (reg:DI 23))
655 ;             (clobber (reg:DI 28))])
656 ;   (set (match_operand:SI 0 "general_operand" "")
657 ;       (reg:SI 27))]
658 ;  "!TARGET_OPEN_VMS"
659 ;  "")
660
661 ;(define_expand "modsi3"
662 ;  [(set (reg:SI 24) (match_operand:SI 1 "input_operand" ""))
663 ;   (set (reg:SI 25) (match_operand:SI 2 "input_operand" ""))
664 ;   (parallel [(set (reg:SI 27)
665 ;                  (mod:SI (reg:SI 24)
666 ;                          (reg:SI 25)))
667 ;             (clobber (reg:DI 23))
668 ;             (clobber (reg:DI 28))])
669 ;   (set (match_operand:SI 0 "general_operand" "")
670 ;       (reg:SI 27))]
671 ;  "!TARGET_OPEN_VMS"
672 ;  "")
673
674 ;(define_expand "umodsi3"
675 ;  [(set (reg:SI 24) (match_operand:SI 1 "input_operand" ""))
676 ;   (set (reg:SI 25) (match_operand:SI 2 "input_operand" ""))
677 ;   (parallel [(set (reg:SI 27)
678 ;                  (umod:SI (reg:SI 24)
679 ;                           (reg:SI 25)))
680 ;             (clobber (reg:DI 23))
681 ;             (clobber (reg:DI 28))])
682 ;   (set (match_operand:SI 0 "general_operand" "")
683 ;       (reg:SI 27))]
684 ;  "!TARGET_OPEN_VMS"
685 ;  "")
686
687 (define_expand "divdi3"
688   [(set (reg:DI 24) (match_operand:DI 1 "input_operand" ""))
689    (set (reg:DI 25) (match_operand:DI 2 "input_operand" ""))
690    (parallel [(set (reg:DI 27)
691                    (div:DI (reg:DI 24)
692                            (reg:DI 25)))
693               (clobber (reg:DI 23))
694               (clobber (reg:DI 28))])
695    (set (match_operand:DI 0 "general_operand" "")
696         (reg:DI 27))]
697   "!TARGET_OPEN_VMS"
698   "")
699
700 (define_expand "udivdi3"
701   [(set (reg:DI 24) (match_operand:DI 1 "input_operand" ""))
702    (set (reg:DI 25) (match_operand:DI 2 "input_operand" ""))
703    (parallel [(set (reg:DI 27)
704                    (udiv:DI (reg:DI 24)
705                             (reg:DI 25)))
706               (clobber (reg:DI 23))
707               (clobber (reg:DI 28))])
708    (set (match_operand:DI 0 "general_operand" "")
709         (reg:DI 27))]
710   "!TARGET_OPEN_VMS"
711   "")
712
713 (define_expand "moddi3"
714   [(set (reg:DI 24) (match_operand:DI 1 "input_operand" ""))
715    (set (reg:DI 25) (match_operand:DI 2 "input_operand" ""))
716    (parallel [(set (reg:DI 27)
717                    (mod:DI (reg:DI 24)
718                            (reg:DI 25)))
719               (clobber (reg:DI 23))
720               (clobber (reg:DI 28))])
721    (set (match_operand:DI 0 "general_operand" "")
722         (reg:DI 27))]
723   "!TARGET_OPEN_VMS"
724   "")
725
726 (define_expand "umoddi3"
727   [(set (reg:DI 24) (match_operand:DI 1 "input_operand" ""))
728    (set (reg:DI 25) (match_operand:DI 2 "input_operand" ""))
729    (parallel [(set (reg:DI 27)
730                    (umod:DI (reg:DI 24)
731                             (reg:DI 25)))
732               (clobber (reg:DI 23))
733               (clobber (reg:DI 28))])
734    (set (match_operand:DI 0 "general_operand" "")
735         (reg:DI 27))]
736   "!TARGET_OPEN_VMS"
737   "")
738
739 ;(define_insn ""
740 ;  [(set (reg:SI 27)
741 ;       (match_operator:SI 1 "divmod_operator"
742 ;                       [(reg:SI 24) (reg:SI 25)]))
743 ;   (clobber (reg:DI 23))
744 ;   (clobber (reg:DI 28))]
745 ;  "!TARGET_OPEN_VMS"
746 ;  "%E1 $24,$25,$27"
747 ;  [(set_attr "type" "jsr")])
748
749 (define_insn ""
750   [(set (reg:DI 27)
751         (match_operator:DI 1 "divmod_operator"
752                         [(reg:DI 24) (reg:DI 25)]))
753    (clobber (reg:DI 23))
754    (clobber (reg:DI 28))]
755   "!TARGET_OPEN_VMS"
756   "%E1 $24,$25,$27"
757   [(set_attr "type" "jsr")])
758 \f
759 ;; Next are the basic logical operations.  These only exist in DImode.
760
761 (define_insn "anddi3"
762   [(set (match_operand:DI 0 "register_operand" "=r,r,r")
763         (and:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ,rJ,rJ")
764                 (match_operand:DI 2 "and_operand" "rI,N,MH")))]
765   ""
766   "@
767    and %r1,%2,%0
768    bic %r1,%N2,%0
769    zapnot %r1,%m2,%0"
770   [(set_attr "type" "ilog,ilog,shift")])
771
772 ;; There are times when we can split an AND into two AND insns.  This occurs
773 ;; when we can first clear any bytes and then clear anything else.  For
774 ;; example "I & 0xffff07" is "(I & 0xffffff) & 0xffffffffffffff07".
775 ;; Only do this when running on 64-bit host since the computations are
776 ;; too messy otherwise.
777
778 (define_split
779   [(set (match_operand:DI 0 "register_operand" "")
780         (and:DI (match_operand:DI 1 "register_operand" "")
781                 (match_operand:DI 2 "const_int_operand" "")))]
782   "HOST_BITS_PER_WIDE_INT == 64 && ! and_operand (operands[2], DImode)"
783   [(set (match_dup 0) (and:DI (match_dup 1) (match_dup 3)))
784    (set (match_dup 0) (and:DI (match_dup 0) (match_dup 4)))]
785   "
786 {
787   unsigned HOST_WIDE_INT mask1 = INTVAL (operands[2]);
788   unsigned HOST_WIDE_INT mask2 = mask1;
789   int i;
790
791   /* For each byte that isn't all zeros, make it all ones.  */
792   for (i = 0; i < 64; i += 8)
793     if ((mask1 & ((HOST_WIDE_INT) 0xff << i)) != 0)
794       mask1 |= (HOST_WIDE_INT) 0xff << i;
795
796   /* Now turn on any bits we've just turned off.  */
797   mask2 |= ~ mask1;
798
799   operands[3] = GEN_INT (mask1);
800   operands[4] = GEN_INT (mask2);
801 }")
802
803 (define_insn "zero_extendqihi2"
804   [(set (match_operand:HI 0 "register_operand" "=r")
805         (zero_extend:HI (match_operand:QI 1 "register_operand" "r")))]
806   ""
807   "zapnot %1,1,%0"
808   [(set_attr "type" "shift")])
809
810 (define_insn ""
811   [(set (match_operand:SI 0 "register_operand" "=r,r")
812         (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "r,m")))]
813   "TARGET_BYTE_OPS"
814   "@
815    zapnot %1,1,%0
816    ldbu %0,%1"
817   [(set_attr "type" "shift,ld")])
818
819 (define_insn ""
820   [(set (match_operand:SI 0 "register_operand" "=r")
821         (zero_extend:SI (match_operand:QI 1 "register_operand" "r")))]
822   "! TARGET_BYTE_OPS"
823   "zapnot %1,1,%0"
824   [(set_attr "type" "shift")])
825
826 (define_expand "zero_extendqisi2"
827   [(set (match_operand:SI 0 "register_operand" "")
828         (zero_extend:SI (match_operand:QI 1 "register_operand" "")))]
829   ""
830   "")
831
832 (define_insn ""
833   [(set (match_operand:DI 0 "register_operand" "=r,r")
834         (zero_extend:DI (match_operand:QI 1 "nonimmediate_operand" "r,m")))]
835   "TARGET_BYTE_OPS"
836   "@
837    zapnot %1,1,%0
838    ldbu %0,%1"
839   [(set_attr "type" "shift,ld")])
840
841 (define_insn ""
842   [(set (match_operand:DI 0 "register_operand" "=r")
843         (zero_extend:DI (match_operand:QI 1 "register_operand" "r")))]
844   "! TARGET_BYTE_OPS"
845   "zapnot %1,1,%0"
846   [(set_attr "type" "shift")])
847   
848 (define_expand "zero_extendqidi2"
849   [(set (match_operand:DI 0 "register_operand" "")
850         (zero_extend:DI (match_operand:QI 1 "register_operand" "")))]
851   ""
852   "")
853   
854 (define_insn ""
855   [(set (match_operand:SI 0 "register_operand" "=r,r")
856         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "r,m")))]
857   "TARGET_BYTE_OPS"
858   "@
859    zapnot %1,3,%0
860    ldwu %0,%1"
861   [(set_attr "type" "shift,ld")])
862
863 (define_insn ""
864   [(set (match_operand:SI 0 "register_operand" "=r")
865         (zero_extend:SI (match_operand:HI 1 "register_operand" "r")))]
866   "! TARGET_BYTE_OPS"
867   "zapnot %1,3,%0"
868   [(set_attr "type" "shift")])
869
870 (define_expand "zero_extendhisi2"
871   [(set (match_operand:SI 0 "register_operand" "")
872         (zero_extend:SI (match_operand:HI 1 "register_operand" "")))]
873   ""
874   "")
875
876 (define_insn ""
877   [(set (match_operand:DI 0 "register_operand" "=r,r")
878         (zero_extend:DI (match_operand:HI 1 "nonimmediate_operand" "r,m")))]
879   "TARGET_BYTE_OPS"
880   "@
881    zapnot %1,3,%0
882    ldwu %0,%1"
883   [(set_attr "type" "shift,ld")])
884
885 (define_insn ""
886   [(set (match_operand:DI 0 "register_operand" "=r")
887         (zero_extend:DI (match_operand:HI 1 "register_operand" "r")))]
888   ""
889   "zapnot %1,3,%0"
890   [(set_attr "type" "shift")])
891
892 (define_expand "zero_extendhidi2"
893   [(set (match_operand:DI 0 "register_operand" "")
894         (zero_extend:DI (match_operand:HI 1 "register_operand" "")))]
895   ""
896   "")
897
898 (define_insn "zero_extendsidi2"
899   [(set (match_operand:DI 0 "register_operand" "=r")
900         (zero_extend:DI (match_operand:SI 1 "register_operand" "r")))]
901   ""
902   "zapnot %1,15,%0"
903   [(set_attr "type" "shift")])
904
905 (define_insn  ""
906   [(set (match_operand:DI 0 "register_operand" "=r")
907         (and:DI (not:DI (match_operand:DI 1 "reg_or_8bit_operand" "rI"))
908                 (match_operand:DI 2 "reg_or_0_operand" "rJ")))]
909   ""
910   "bic %r2,%1,%0"
911   [(set_attr "type" "ilog")])
912
913 (define_insn "iordi3"
914   [(set (match_operand:DI 0 "register_operand" "=r,r")
915         (ior:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ,rJ")
916                 (match_operand:DI 2 "or_operand" "rI,N")))]
917   ""
918   "@
919    bis %r1,%2,%0
920    ornot %r1,%N2,%0"
921   [(set_attr "type" "ilog")])
922
923 (define_insn "one_cmpldi2"
924   [(set (match_operand:DI 0 "register_operand" "=r")
925         (not:DI (match_operand:DI 1 "reg_or_8bit_operand" "rI")))]
926   ""
927   "ornot $31,%1,%0"
928   [(set_attr "type" "ilog")])
929
930 (define_insn ""
931   [(set (match_operand:DI 0 "register_operand" "=r")
932         (ior:DI (not:DI (match_operand:DI 1 "reg_or_8bit_operand" "rI"))
933                 (match_operand:DI 2 "reg_or_0_operand" "rJ")))]
934   ""
935   "ornot %r2,%1,%0"
936   [(set_attr "type" "ilog")])
937
938 (define_insn "xordi3"
939   [(set (match_operand:DI 0 "register_operand" "=r,r")
940         (xor:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ,rJ")
941                 (match_operand:DI 2 "or_operand" "rI,N")))]
942   ""
943   "@
944    xor %r1,%2,%0
945    eqv %r1,%N2,%0"
946   [(set_attr "type" "ilog")])
947
948 (define_insn ""
949   [(set (match_operand:DI 0 "register_operand" "=r")
950         (not:DI (xor:DI (match_operand:DI 1 "register_operand" "%rJ")
951                         (match_operand:DI 2 "register_operand" "rI"))))]
952   ""
953   "eqv %r1,%2,%0"
954   [(set_attr "type" "ilog")])
955 \f
956 ;; Next come the shifts and the various extract and insert operations.
957
958 (define_insn "ashldi3"
959   [(set (match_operand:DI 0 "register_operand" "=r,r")
960         (ashift:DI (match_operand:DI 1 "reg_or_0_operand" "rJ,rJ")
961                    (match_operand:DI 2 "reg_or_6bit_operand" "P,rI")))]
962   ""
963   "*
964 {
965   switch (which_alternative)
966     {
967     case 0:
968       if (operands[2] == const1_rtx)
969         return \"addq %r1,%r1,%0\";
970       else
971         return \"s%P2addq %r1,0,%0\";
972     case 1:
973       return \"sll %r1,%2,%0\";
974     }
975 }"
976   [(set_attr "type" "iadd,shift")])
977
978 ;; ??? The following pattern is made by combine, but earlier phases
979 ;; (specifically flow) can't handle it.  This occurs in jump.c.  Deal
980 ;; with this in a better way at some point.
981 ;;(define_insn ""
982 ;;  [(set (match_operand:DI 0 "register_operand" "=r")
983 ;;      (sign_extend:DI
984 ;;       (subreg:SI (ashift:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
985 ;;                             (match_operand:DI 2 "const_int_operand" "P"))
986 ;;                  0)))]
987 ;;  "INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 3"
988 ;;  "*
989 ;;{
990 ;;  if (operands[2] == const1_rtx)
991 ;;    return \"addl %r1,%r1,%0\";
992 ;;  else
993 ;;    return \"s%P2addl %r1,0,%0\";
994 ;; }"
995 ;;  [(set_attr "type" "iadd")])
996                           
997 (define_insn "lshrdi3"
998   [(set (match_operand:DI 0 "register_operand" "=r")
999         (lshiftrt:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1000                      (match_operand:DI 2 "reg_or_6bit_operand" "rI")))]
1001   ""
1002   "srl %r1,%2,%0"
1003   [(set_attr "type" "shift")])
1004
1005 (define_insn "ashrdi3"
1006   [(set (match_operand:DI 0 "register_operand" "=r")
1007         (ashiftrt:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1008                      (match_operand:DI 2 "reg_or_6bit_operand" "rI")))]
1009   ""
1010   "sra %r1,%2,%0"
1011   [(set_attr "type" "shift")])
1012
1013 (define_expand "extendqihi2"
1014   [(set (match_dup 2)
1015         (ashift:DI (match_operand:QI 1 "some_operand" "")
1016                    (const_int 56)))
1017    (set (match_operand:HI 0 "register_operand" "")
1018         (ashiftrt:DI (match_dup 2)
1019                      (const_int 56)))]
1020   ""
1021   "
1022 {
1023   if (TARGET_BYTE_OPS)
1024     {
1025       emit_insn (gen_extendqihi2x (operands[0],
1026                                    force_reg (QImode, operands[1])));
1027       DONE;
1028     }
1029  
1030  /* If we have an unaligned MEM, extend to DImode (which we do
1031      specially) and then copy to the result.  */
1032   if (unaligned_memory_operand (operands[1], HImode))
1033     {
1034       rtx temp = gen_reg_rtx (DImode);
1035
1036       emit_insn (gen_extendqidi2 (temp, operands[1]));
1037       emit_move_insn (operands[0], gen_lowpart (HImode, temp));
1038       DONE;
1039     }
1040
1041   operands[0] = gen_lowpart (DImode, operands[0]);
1042   operands[1] = gen_lowpart (DImode, force_reg (QImode, operands[1]));
1043   operands[2] = gen_reg_rtx (DImode);
1044 }")
1045
1046 (define_insn "extendqidi2x"
1047   [(set (match_operand:DI 0 "register_operand" "=r")
1048         (sign_extend:DI (match_operand:QI 1 "register_operand" "r")))]
1049   "TARGET_BYTE_OPS"
1050   "sextb %1,%0"
1051   [(set_attr "type" "shift")])
1052
1053 (define_insn "extendhidi2x"
1054   [(set (match_operand:DI 0 "register_operand" "=r")
1055         (sign_extend:DI (match_operand:HI 1 "register_operand" "r")))]
1056   "TARGET_BYTE_OPS"
1057   "sextw %1,%0"
1058   [(set_attr "type" "shift")])
1059
1060 (define_insn "extendqisi2x"
1061   [(set (match_operand:SI 0 "register_operand" "=r")
1062         (sign_extend:SI (match_operand:QI 1 "register_operand" "r")))]
1063   "TARGET_BYTE_OPS"
1064   "sextb %1,%0"
1065   [(set_attr "type" "shift")])
1066
1067 (define_insn "extendhisi2x"
1068   [(set (match_operand:SI 0 "register_operand" "=r")
1069         (sign_extend:SI (match_operand:HI 1 "register_operand" "r")))]
1070   "TARGET_BYTE_OPS"
1071   "sextw %1,%0"
1072   [(set_attr "type" "shift")])
1073
1074 (define_insn "extendqihi2x"
1075   [(set (match_operand:HI 0 "register_operand" "=r")
1076         (sign_extend:HI (match_operand:QI 1 "register_operand" "r")))]
1077   "TARGET_BYTE_OPS"
1078   "sextb %1,%0"
1079   [(set_attr "type" "shift")])
1080
1081 (define_expand "extendqisi2"
1082   [(set (match_dup 2)
1083         (ashift:DI (match_operand:QI 1 "some_operand" "")
1084                    (const_int 56)))
1085    (set (match_operand:SI 0 "register_operand" "")
1086         (ashiftrt:DI (match_dup 2)
1087                      (const_int 56)))]
1088   ""
1089   "
1090 {
1091   if (TARGET_BYTE_OPS)
1092     {
1093       emit_insn (gen_extendqisi2x (operands[0],
1094                                    force_reg (QImode, operands[1])));
1095       DONE;
1096     }
1097
1098   /* If we have an unaligned MEM, extend to a DImode form of
1099      the result (which we do specially).  */
1100   if (unaligned_memory_operand (operands[1], QImode))
1101     {
1102       rtx temp = gen_reg_rtx (DImode);
1103
1104       emit_insn (gen_extendqidi2 (temp, operands[1]));
1105       emit_move_insn (operands[0], gen_lowpart (SImode, temp));
1106       DONE;
1107     }
1108
1109   operands[0] = gen_lowpart (DImode, operands[0]);
1110   operands[1] = gen_lowpart (DImode, force_reg (QImode, operands[1]));
1111   operands[2] = gen_reg_rtx (DImode);
1112 }")
1113
1114 (define_expand "extendqidi2"
1115   [(set (match_dup 2)
1116         (ashift:DI (match_operand:QI 1 "some_operand" "")
1117                    (const_int 56)))
1118    (set (match_operand:DI 0 "register_operand" "")
1119         (ashiftrt:DI (match_dup 2)
1120                      (const_int 56)))]
1121   ""
1122   "
1123 { extern rtx get_unaligned_address ();
1124
1125   if (TARGET_BYTE_OPS)
1126     {
1127       emit_insn (gen_extendqidi2x (operands[0],
1128                                    force_reg (QImode, operands[1])));
1129       DONE;
1130     }
1131
1132   if (unaligned_memory_operand (operands[1], QImode))
1133     {
1134       rtx seq
1135         = gen_unaligned_extendqidi (operands[0],
1136                                     get_unaligned_address (operands[1], 1));
1137
1138       alpha_set_memflags (seq, operands[1]);
1139       emit_insn (seq);
1140       DONE;
1141     }
1142
1143   operands[1] = gen_lowpart (DImode, force_reg (QImode, operands[1]));
1144   operands[2] = gen_reg_rtx (DImode);
1145 }")
1146
1147 (define_expand "extendhisi2"
1148   [(set (match_dup 2)
1149         (ashift:DI (match_operand:HI 1 "some_operand" "")
1150                    (const_int 48)))
1151    (set (match_operand:SI 0 "register_operand" "")
1152         (ashiftrt:DI (match_dup 2)
1153                      (const_int 48)))]
1154   ""
1155   "
1156 {
1157   if (TARGET_BYTE_OPS)
1158     {
1159       emit_insn (gen_extendhisi2x (operands[0],
1160                                    force_reg (HImode, operands[1])));
1161       DONE;
1162     }
1163
1164   /* If we have an unaligned MEM, extend to a DImode form of
1165      the result (which we do specially).  */
1166   if (unaligned_memory_operand (operands[1], HImode))
1167     {
1168       rtx temp = gen_reg_rtx (DImode);
1169
1170       emit_insn (gen_extendhidi2 (temp, operands[1]));
1171       emit_move_insn (operands[0], gen_lowpart (SImode, temp));
1172       DONE;
1173     }
1174
1175   operands[0] = gen_lowpart (DImode, operands[0]);
1176   operands[1] = gen_lowpart (DImode, force_reg (HImode, operands[1]));
1177   operands[2] = gen_reg_rtx (DImode);
1178 }")
1179
1180 (define_expand "extendhidi2"
1181   [(set (match_dup 2)
1182         (ashift:DI (match_operand:HI 1 "some_operand" "")
1183                    (const_int 48)))
1184    (set (match_operand:DI 0 "register_operand" "")
1185         (ashiftrt:DI (match_dup 2)
1186                      (const_int 48)))]
1187   ""
1188   "
1189 { extern rtx get_unaligned_address ();
1190
1191   if (TARGET_BYTE_OPS)
1192     {
1193       emit_insn (gen_extendhidi2x (operands[0],
1194                                    force_reg (HImode, operands[1])));
1195       DONE;
1196     }
1197
1198   if (unaligned_memory_operand (operands[1], HImode))
1199     {
1200       rtx seq
1201         = gen_unaligned_extendhidi (operands[0],
1202                                     get_unaligned_address (operands[1], 2));
1203
1204       alpha_set_memflags (seq, operands[1]);
1205       emit_insn (seq);
1206       DONE;
1207     }
1208
1209   operands[1] = gen_lowpart (DImode, force_reg (HImode, operands[1]));
1210   operands[2] = gen_reg_rtx (DImode);
1211 }")
1212
1213 ;; Here's how we sign extend an unaligned byte and halfword.  Doing this
1214 ;; as a pattern saves one instruction.  The code is similar to that for
1215 ;; the unaligned loads (see below).
1216 ;;
1217 ;; Operand 1 is the address + 1 (+2 for HI), operand 0 is the result.
1218 (define_expand "unaligned_extendqidi"
1219   [(set (match_dup 2) (match_operand:DI 1 "address_operand" ""))
1220    (set (match_dup 3)
1221         (mem:DI (and:DI (plus:DI (match_dup 2) (const_int -1))
1222                         (const_int -8))))
1223    (set (match_dup 4)
1224         (ashift:DI (match_dup 3)
1225                    (minus:DI (const_int 56)
1226                              (ashift:DI
1227                               (and:DI (plus:DI (match_dup 2) (const_int -1))
1228                                       (const_int 7))
1229                               (const_int 3)))))
1230    (set (subreg:DI (match_operand:QI 0 "register_operand" "") 0)
1231         (ashiftrt:DI (match_dup 4) (const_int 56)))]
1232   ""
1233   "
1234 { operands[2] = gen_reg_rtx (DImode);
1235   operands[3] = gen_reg_rtx (DImode);
1236   operands[4] = gen_reg_rtx (DImode);
1237 }")
1238
1239 (define_expand "unaligned_extendhidi"
1240   [(set (match_dup 2) (match_operand:DI 1 "address_operand" ""))
1241    (set (match_dup 3)
1242         (mem:DI (and:DI (plus:DI (match_dup 2) (const_int -2))
1243                         (const_int -8))))
1244    (set (match_dup 4)
1245         (ashift:DI (match_dup 3)
1246                    (minus:DI (const_int 56)
1247                              (ashift:DI
1248                               (and:DI (plus:DI (match_dup 2) (const_int -1))
1249                                       (const_int 7))
1250                               (const_int 3)))))
1251    (set (subreg:DI (match_operand:QI 0 "register_operand" "") 0)
1252         (ashiftrt:DI (match_dup 4) (const_int 48)))]
1253   ""
1254   "
1255 { operands[2] = gen_reg_rtx (DImode);
1256   operands[3] = gen_reg_rtx (DImode);
1257   operands[4] = gen_reg_rtx (DImode);
1258 }")
1259
1260 (define_insn ""
1261   [(set (match_operand:DI 0 "register_operand" "=r")
1262         (zero_extract:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1263                          (match_operand:DI 2 "mode_width_operand" "n")
1264                          (match_operand:DI 3 "mul8_operand" "I")))]
1265   ""
1266   "ext%M2l %r1,%s3,%0"
1267   [(set_attr "type" "shift")])
1268
1269 (define_insn ""
1270   [(set (match_operand:DI 0 "register_operand" "=r")
1271         (zero_extract:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1272                          (match_operand:DI 2 "mode_width_operand" "n")
1273                          (ashift:DI (match_operand:DI 3 "reg_or_8bit_operand" "rI")
1274                                     (const_int 3))))]
1275   ""
1276   "ext%M2l %r1,%3,%0"
1277   [(set_attr "type" "shift")])
1278
1279 (define_insn ""
1280   [(set (match_operand:DI 0 "register_operand" "=r")
1281         (ashift:DI
1282          (match_operand:DI 1 "reg_or_0_operand" "rJ")
1283           (minus:DI (const_int 56)
1284                     (ashift:DI
1285                      (and:DI
1286                       (plus:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1287                                (const_int -1))
1288                       (const_int 7))
1289                      (const_int 3)))))]
1290   ""
1291   "extqh %r1,%2,%0"
1292   [(set_attr "type" "shift")])
1293
1294 (define_insn ""
1295   [(set (match_operand:DI 0 "register_operand" "=r")
1296         (ashift:DI
1297          (and:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1298                  (const_int 2147483647))
1299          (minus:DI (const_int 56)
1300                     (ashift:DI
1301                      (and:DI
1302                       (plus:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1303                                (const_int -1))
1304                       (const_int 7))
1305                      (const_int 3)))))]
1306   ""
1307   "extlh %r1,%2,%0"
1308   [(set_attr "type" "shift")])
1309
1310 (define_insn ""
1311   [(set (match_operand:DI 0 "register_operand" "=r")
1312         (ashift:DI
1313          (and:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1314                  (const_int 65535))
1315          (minus:DI (const_int 56)
1316                     (ashift:DI
1317                      (and:DI
1318                       (plus:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1319                                (const_int -1))
1320                       (const_int 7))
1321                      (const_int 3)))))]
1322   ""
1323   "extwh %r1,%2,%0"
1324   [(set_attr "type" "shift")])
1325
1326 ;; This converts an extXl into an extXh with an appropriate adjustment
1327 ;; to the address calculation.
1328
1329 ;;(define_split
1330 ;;  [(set (match_operand:DI 0 "register_operand" "")
1331 ;;      (ashift:DI (zero_extract:DI (match_operand:DI 1 "register_operand" "")
1332 ;;                                  (match_operand:DI 2 "mode_width_operand" "")
1333 ;;                                  (ashift:DI (match_operand:DI 3 "" "")
1334 ;;                                             (const_int 3)))
1335 ;;                 (match_operand:DI 4 "const_int_operand" "")))
1336 ;;   (clobber (match_operand:DI 5 "register_operand" ""))]
1337 ;;  "INTVAL (operands[4]) == 64 - INTVAL (operands[2])"
1338 ;;  [(set (match_dup 5) (match_dup 6))
1339 ;;   (set (match_dup 0)
1340 ;;      (ashift:DI (zero_extract:DI (match_dup 1) (match_dup 2)
1341 ;;                                  (ashift:DI (plus:DI (match_dup 5)
1342 ;;                                                      (match_dup 7))
1343 ;;                                             (const_int 3)))
1344 ;;                 (match_dup 4)))]
1345 ;;  "
1346 ;;{
1347 ;;  operands[6] = plus_constant (operands[3], 
1348 ;;                             INTVAL (operands[2]) / BITS_PER_UNIT);
1349 ;;  operands[7] = GEN_INT (- INTVAL (operands[2]) / BITS_PER_UNIT);
1350 ;;}")
1351   
1352 (define_insn ""
1353   [(set (match_operand:DI 0 "register_operand" "=r")
1354         (ashift:DI (zero_extend:DI (match_operand:QI 1 "register_operand" "r"))
1355                    (match_operand:DI 2 "mul8_operand" "I")))]
1356   ""
1357   "insbl %1,%s2,%0"
1358   [(set_attr "type" "shift")])
1359
1360 (define_insn ""
1361   [(set (match_operand:DI 0 "register_operand" "=r")
1362         (ashift:DI (zero_extend:DI (match_operand:HI 1 "register_operand" "r"))
1363                    (match_operand:DI 2 "mul8_operand" "I")))]
1364   ""
1365   "inswl %1,%s2,%0"
1366   [(set_attr "type" "shift")])
1367
1368 (define_insn ""
1369   [(set (match_operand:DI 0 "register_operand" "=r")
1370         (ashift:DI (zero_extend:DI (match_operand:SI 1 "register_operand" "r"))
1371                    (match_operand:DI 2 "mul8_operand" "I")))]
1372   ""
1373   "insll %1,%s2,%0"
1374   [(set_attr "type" "shift")])
1375
1376 (define_insn ""
1377   [(set (match_operand:DI 0 "register_operand" "=r")
1378         (ashift:DI (zero_extend:DI (match_operand:QI 1 "register_operand" "r"))
1379                    (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1380                               (const_int 3))))]
1381   ""
1382   "insbl %1,%2,%0"
1383   [(set_attr "type" "shift")])
1384
1385 (define_insn ""
1386   [(set (match_operand:DI 0 "register_operand" "=r")
1387         (ashift:DI (zero_extend:DI (match_operand:HI 1 "register_operand" "r"))
1388                    (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1389                               (const_int 3))))]
1390   ""
1391   "inswl %1,%2,%0"
1392   [(set_attr "type" "shift")])
1393
1394 (define_insn ""
1395   [(set (match_operand:DI 0 "register_operand" "=r")
1396         (ashift:DI (zero_extend:DI (match_operand:SI 1 "register_operand" "r"))
1397                    (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1398                               (const_int 3))))]
1399   ""
1400   "insll %1,%2,%0"
1401   [(set_attr "type" "shift")])
1402
1403 ;; We do not include the insXh insns because they are complex to express
1404 ;; and it does not appear that we would ever want to generate them.
1405
1406 (define_insn ""
1407   [(set (match_operand:DI 0 "register_operand" "=r")
1408         (and:DI (not:DI (ashift:DI
1409                          (match_operand:DI 2 "mode_mask_operand" "n")
1410                          (ashift:DI
1411                           (match_operand:DI 3 "reg_or_8bit_operand" "rI")
1412                           (const_int 3))))
1413                 (match_operand:DI 1 "reg_or_0_operand" "rJ")))]
1414   ""
1415   "msk%U2l %r1,%3,%0"
1416   [(set_attr "type" "shift")])
1417
1418 ;; We do not include the mskXh insns because it does not appear we would ever
1419 ;; generate one.
1420 \f
1421 ;; Floating-point operations.  All the double-precision insns can extend
1422 ;; from single, so indicate that.  The exception are the ones that simply
1423 ;; play with the sign bits; it's not clear what to do there.
1424
1425 (define_insn "abssf2"
1426   [(set (match_operand:SF 0 "register_operand" "=f")
1427         (abs:SF (match_operand:SF 1 "reg_or_fp0_operand" "fG")))]
1428   "TARGET_FP"
1429   "cpys $f31,%R1,%0"
1430   [(set_attr "type" "fcpys")])
1431
1432 (define_insn "absdf2"
1433   [(set (match_operand:DF 0 "register_operand" "=f")
1434         (abs:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")))]
1435   "TARGET_FP"
1436   "cpys $f31,%R1,%0"
1437   [(set_attr "type" "fcpys")])
1438
1439 (define_insn "negsf2"
1440   [(set (match_operand:SF 0 "register_operand" "=f")
1441         (neg:SF (match_operand:SF 1 "reg_or_fp0_operand" "fG")))]
1442   "TARGET_FP"
1443   "cpysn %R1,%R1,%0"
1444   [(set_attr "type" "fadd")])
1445
1446 (define_insn "negdf2"
1447   [(set (match_operand:DF 0 "register_operand" "=f")
1448         (neg:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")))]
1449   "TARGET_FP"
1450   "cpysn %R1,%R1,%0"
1451   [(set_attr "type" "fadd")])
1452
1453 (define_insn ""
1454   [(set (match_operand:SF 0 "register_operand" "=&f")
1455         (plus:SF (match_operand:SF 1 "reg_or_fp0_operand" "%fG")
1456                  (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1457   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1458   "add%,%)%& %R1,%R2,%0"
1459   [(set_attr "type" "fadd")
1460    (set_attr "trap" "yes")])
1461
1462 (define_insn "addsf3"
1463   [(set (match_operand:SF 0 "register_operand" "=f")
1464         (plus:SF (match_operand:SF 1 "reg_or_fp0_operand" "%fG")
1465                  (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1466   "TARGET_FP"
1467   "add%,%)%& %R1,%R2,%0"
1468   [(set_attr "type" "fadd")
1469    (set_attr "trap" "yes")])
1470
1471 (define_insn ""
1472   [(set (match_operand:DF 0 "register_operand" "=&f")
1473         (plus:DF (match_operand:DF 1 "reg_or_fp0_operand" "%fG")
1474                  (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1475   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1476   "add%-%)%& %R1,%R2,%0"
1477   [(set_attr "type" "fadd")
1478    (set_attr "trap" "yes")])
1479
1480 (define_insn "adddf3"
1481   [(set (match_operand:DF 0 "register_operand" "=f")
1482         (plus:DF (match_operand:DF 1 "reg_or_fp0_operand" "%fG")
1483                  (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1484   "TARGET_FP"
1485   "add%-%)%& %R1,%R2,%0"
1486   [(set_attr "type" "fadd")
1487    (set_attr "trap" "yes")])
1488
1489 (define_insn ""
1490   [(set (match_operand:DF 0 "register_operand" "=f")
1491         (plus:DF (float_extend:DF
1492                   (match_operand:SF 1 "reg_or_fp0_operand" "fG"))
1493                  (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1494   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1495   "add%-%)%& %R1,%R2,%0"
1496   [(set_attr "type" "fadd")
1497    (set_attr "trap" "yes")])
1498
1499 (define_insn ""
1500   [(set (match_operand:DF 0 "register_operand" "=f")
1501         (plus:DF (float_extend:DF
1502                   (match_operand:SF 1 "reg_or_fp0_operand" "%fG"))
1503                  (float_extend:DF
1504                   (match_operand:SF 2 "reg_or_fp0_operand" "fG"))))]
1505   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1506   "add%-%)%& %R1,%R2,%0"
1507   [(set_attr "type" "fadd")
1508    (set_attr "trap" "yes")])
1509
1510 (define_insn "fix_truncdfdi2"
1511   [(set (match_operand:DI 0 "register_operand" "=f")
1512         (fix:DI (match_operand:DF 1 "reg_or_fp0_operand" "fG")))]
1513   "TARGET_FP"
1514   "cvt%-qc %R1,%0"
1515   [(set_attr "type" "fadd")])
1516
1517 (define_insn "fix_truncsfdi2"
1518   [(set (match_operand:DI 0 "register_operand" "=f")
1519         (fix:DI (float_extend:DF
1520                  (match_operand:SF 1 "reg_or_fp0_operand" "fG"))))]
1521   "TARGET_FP"
1522   "cvt%-qc %R1,%0"
1523   [(set_attr "type" "fadd")])
1524
1525 (define_insn ""
1526   [(set (match_operand:SF 0 "register_operand" "=&f")
1527         (float:SF (match_operand:DI 1 "register_operand" "f")))]
1528   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1529   "cvtq%,%+%& %1,%0"
1530   [(set_attr "type" "fadd")
1531    (set_attr "trap" "yes")])
1532
1533 (define_insn "floatdisf2"
1534   [(set (match_operand:SF 0 "register_operand" "=f")
1535         (float:SF (match_operand:DI 1 "register_operand" "f")))]
1536   "TARGET_FP"
1537   "cvtq%,%+%& %1,%0"
1538   [(set_attr "type" "fadd")
1539    (set_attr "trap" "yes")])
1540
1541 (define_insn ""
1542   [(set (match_operand:DF 0 "register_operand" "=&f")
1543         (float:DF (match_operand:DI 1 "register_operand" "f")))]
1544   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1545   "cvtq%-%+%& %1,%0"
1546   [(set_attr "type" "fadd")
1547    (set_attr "trap" "yes")])
1548
1549 (define_insn "floatdidf2"
1550   [(set (match_operand:DF 0 "register_operand" "=f")
1551         (float:DF (match_operand:DI 1 "register_operand" "f")))]
1552   "TARGET_FP"
1553   "cvtq%-%+%& %1,%0"
1554   [(set_attr "type" "fadd")
1555    (set_attr "trap" "yes")])
1556
1557 (define_expand "extendsfdf2"
1558   [(use (match_operand:DF 0 "register_operand" ""))
1559    (use (match_operand:SF 1 "nonimmediate_operand" ""))]
1560   "TARGET_FP"
1561 "
1562 {
1563   if (alpha_tp == ALPHA_TP_INSN)
1564     emit_insn (gen_extendsfdf2_tp (operands[0],
1565                                    force_reg (SFmode, operands[1])));
1566   else
1567     emit_insn (gen_extendsfdf2_no_tp (operands[0], operands[1]));
1568
1569   DONE;
1570 }")
1571 ;; FIXME
1572 (define_insn "extendsfdf2_tp"
1573   [(set (match_operand:DF 0 "register_operand" "=&f")
1574         (float_extend:DF (match_operand:SF 1 "register_operand" "f")))]
1575   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1576   "cvtsts %1,%0"
1577   [(set_attr "type" "fadd")
1578    (set_attr "trap" "yes")])
1579
1580 (define_insn "extendsfdf2_no_tp"
1581   [(set (match_operand:DF 0 "register_operand" "=f,f,m")
1582         (float_extend:DF (match_operand:SF 1 "nonimmediate_operand" "f,m,f")))]
1583   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1584   "@
1585    cpys %1,%1,%0
1586    ld%, %0,%1
1587    st%- %1,%0"
1588   [(set_attr "type" "fcpys,ld,st")
1589    (set_attr "trap" "yes")])
1590
1591 (define_insn ""
1592   [(set (match_operand:SF 0 "register_operand" "=&f")
1593         (float_truncate:SF (match_operand:DF 1 "reg_or_fp0_operand" "fG")))]
1594   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1595   "cvt%-%,%)%& %R1,%0"
1596   [(set_attr "type" "fadd")
1597    (set_attr "trap" "yes")])
1598
1599 (define_insn "truncdfsf2"
1600   [(set (match_operand:SF 0 "register_operand" "=f")
1601         (float_truncate:SF (match_operand:DF 1 "reg_or_fp0_operand" "fG")))]
1602   "TARGET_FP"
1603   "cvt%-%,%)%& %R1,%0"
1604   [(set_attr "type" "fadd")
1605    (set_attr "trap" "yes")])
1606
1607 (define_insn ""
1608   [(set (match_operand:SF 0 "register_operand" "=&f")
1609         (div:SF (match_operand:SF 1 "reg_or_fp0_operand" "fG")
1610                 (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1611   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1612   "div%,%)%& %R1,%R2,%0"
1613   [(set_attr "type" "fdivs")
1614    (set_attr "trap" "yes")])
1615
1616 (define_insn "divsf3"
1617   [(set (match_operand:SF 0 "register_operand" "=f")
1618         (div:SF (match_operand:SF 1 "reg_or_fp0_operand" "fG")
1619                 (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1620   "TARGET_FP"
1621   "div%,%)%& %R1,%R2,%0"
1622   [(set_attr "type" "fdivs")
1623    (set_attr "trap" "yes")])
1624
1625 (define_insn ""
1626   [(set (match_operand:DF 0 "register_operand" "=&f")
1627         (div:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")
1628                 (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1629   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1630   "div%-%)%& %R1,%R2,%0"
1631   [(set_attr "type" "fdivt")
1632    (set_attr "trap" "yes")])
1633
1634 (define_insn "divdf3"
1635   [(set (match_operand:DF 0 "register_operand" "=f")
1636         (div:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")
1637                 (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1638   "TARGET_FP"
1639   "div%-%)%& %R1,%R2,%0"
1640   [(set_attr "type" "fdivt")
1641    (set_attr "trap" "yes")])
1642
1643 (define_insn ""
1644   [(set (match_operand:DF 0 "register_operand" "=f")
1645         (div:DF (float_extend:DF (match_operand:SF 1 "reg_or_fp0_operand" "fG"))
1646                 (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1647   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1648   "div%-%)%& %R1,%R2,%0"
1649   [(set_attr "type" "fdivt")
1650    (set_attr "trap" "yes")])
1651
1652 (define_insn ""
1653   [(set (match_operand:DF 0 "register_operand" "=f")
1654         (div:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")
1655                 (float_extend:DF
1656                  (match_operand:SF 2 "reg_or_fp0_operand" "fG"))))]
1657   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1658   "div%-%)%& %R1,%R2,%0"
1659   [(set_attr "type" "fdivt")
1660    (set_attr "trap" "yes")])
1661
1662 (define_insn ""
1663   [(set (match_operand:DF 0 "register_operand" "=f")
1664         (div:DF (float_extend:DF (match_operand:SF 1 "reg_or_fp0_operand" "fG"))
1665                 (float_extend:DF (match_operand:SF 2 "reg_or_fp0_operand" "fG"))))]
1666   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1667   "div%-%)%& %R1,%R2,%0"
1668   [(set_attr "type" "fdivt")
1669    (set_attr "trap" "yes")])
1670
1671 (define_insn ""
1672   [(set (match_operand:SF 0 "register_operand" "=&f")
1673         (mult:SF (match_operand:SF 1 "reg_or_fp0_operand" "%fG")
1674                  (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1675   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1676   "mul%,%)%& %R1,%R2,%0"
1677   [(set_attr "type" "fmul")
1678    (set_attr "trap" "yes")])
1679
1680 (define_insn "mulsf3"
1681   [(set (match_operand:SF 0 "register_operand" "=f")
1682         (mult:SF (match_operand:SF 1 "reg_or_fp0_operand" "%fG")
1683                  (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1684   "TARGET_FP"
1685   "mul%,%)%& %R1,%R2,%0"
1686   [(set_attr "type" "fmul")
1687    (set_attr "trap" "yes")])
1688
1689 (define_insn ""
1690   [(set (match_operand:DF 0 "register_operand" "=&f")
1691         (mult:DF (match_operand:DF 1 "reg_or_fp0_operand" "%fG")
1692                  (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1693   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1694   "mul%-%)%& %R1,%R2,%0"
1695   [(set_attr "type" "fmul")
1696    (set_attr "trap" "yes")])
1697
1698 (define_insn "muldf3"
1699   [(set (match_operand:DF 0 "register_operand" "=f")
1700         (mult:DF (match_operand:DF 1 "reg_or_fp0_operand" "%fG")
1701                  (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1702   "TARGET_FP"
1703   "mul%-%)%& %R1,%R2,%0"
1704   [(set_attr "type" "fmul")
1705    (set_attr "trap" "yes")])
1706
1707 (define_insn ""
1708   [(set (match_operand:DF 0 "register_operand" "=f")
1709         (mult:DF (float_extend:DF
1710                   (match_operand:SF 1 "reg_or_fp0_operand" "fG"))
1711                  (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1712   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1713   "mul%-%)%& %R1,%R2,%0"
1714   [(set_attr "type" "fmul")
1715    (set_attr "trap" "yes")])
1716
1717 (define_insn ""
1718   [(set (match_operand:DF 0 "register_operand" "=f")
1719         (mult:DF (float_extend:DF
1720                   (match_operand:SF 1 "reg_or_fp0_operand" "%fG"))
1721                  (float_extend:DF
1722                   (match_operand:SF 2 "reg_or_fp0_operand" "fG"))))]
1723   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1724   "mul%-%)%& %R1,%R2,%0"
1725   [(set_attr "type" "fmul")
1726    (set_attr "trap" "yes")])
1727
1728 (define_insn ""
1729   [(set (match_operand:SF 0 "register_operand" "=&f")
1730         (minus:SF (match_operand:SF 1 "reg_or_fp0_operand" "fG")
1731                   (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1732   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1733   "sub%,%)%& %R1,%R2,%0"
1734   [(set_attr "type" "fadd")
1735    (set_attr "trap" "yes")])
1736
1737 (define_insn "subsf3"
1738   [(set (match_operand:SF 0 "register_operand" "=f")
1739         (minus:SF (match_operand:SF 1 "reg_or_fp0_operand" "fG")
1740                   (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1741   "TARGET_FP"
1742   "sub%,%)%& %R1,%R2,%0"
1743   [(set_attr "type" "fadd")
1744    (set_attr "trap" "yes")])
1745
1746 (define_insn ""
1747   [(set (match_operand:DF 0 "register_operand" "=&f")
1748         (minus:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")
1749                   (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1750   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1751   "sub%-%)%& %R1,%R2,%0"
1752   [(set_attr "type" "fadd")
1753    (set_attr "trap" "yes")])
1754
1755 (define_insn "subdf3"
1756   [(set (match_operand:DF 0 "register_operand" "=f")
1757         (minus:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")
1758                   (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1759   "TARGET_FP"
1760   "sub%-%)%& %R1,%R2,%0"
1761   [(set_attr "type" "fadd")
1762    (set_attr "trap" "yes")])
1763
1764 (define_insn ""
1765   [(set (match_operand:DF 0 "register_operand" "=f")
1766         (minus:DF (float_extend:DF
1767                    (match_operand:SF 1 "reg_or_fp0_operand" "fG"))
1768                   (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1769   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1770   "sub%-%)%& %R1,%R2,%0"
1771   [(set_attr "type" "fadd")
1772    (set_attr "trap" "yes")])
1773
1774 (define_insn ""
1775   [(set (match_operand:DF 0 "register_operand" "=f")
1776         (minus:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")
1777                   (float_extend:DF
1778                    (match_operand:SF 2 "reg_or_fp0_operand" "fG"))))]
1779   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1780   "sub%-%)%& %R1,%R2,%0"
1781   [(set_attr "type" "fadd")
1782    (set_attr "trap" "yes")])
1783
1784 (define_insn ""
1785   [(set (match_operand:DF 0 "register_operand" "=f")
1786         (minus:DF (float_extend:DF
1787                    (match_operand:SF 1 "reg_or_fp0_operand" "fG"))
1788                   (float_extend:DF
1789                    (match_operand:SF 2 "reg_or_fp0_operand" "fG"))))]
1790   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1791   "sub%-%)%& %R1,%R2,%0"
1792   [(set_attr "type" "fadd")
1793    (set_attr "trap" "yes")])
1794 \f
1795 ;; Next are all the integer comparisons, and conditional moves and branches
1796 ;; and some of the related define_expand's and define_split's.
1797
1798 (define_insn ""
1799   [(set (match_operand:DI 0 "register_operand" "=r")
1800         (match_operator:DI 1 "alpha_comparison_operator"
1801                            [(match_operand:DI 2 "reg_or_0_operand" "rJ")
1802                             (match_operand:DI 3 "reg_or_8bit_operand" "rI")]))]
1803   ""
1804   "cmp%C1 %r2,%3,%0"
1805   [(set_attr "type" "icmp")])
1806
1807 (define_insn ""
1808   [(set (match_operand:DI 0 "register_operand" "=r")
1809         (match_operator:DI 1 "alpha_swapped_comparison_operator"
1810                            [(match_operand:DI 2 "reg_or_8bit_operand" "rI")
1811                             (match_operand:DI 3 "reg_or_0_operand" "rJ")]))]
1812   ""
1813   "cmp%c1 %r3,%2,%0"
1814   [(set_attr "type" "icmp")])
1815
1816 ;; This pattern exists so conditional moves of SImode values are handled.
1817 ;; Comparisons are still done in DImode though.
1818
1819 (define_insn ""
1820   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
1821         (if_then_else:DI
1822          (match_operator 2 "signed_comparison_operator"
1823                          [(match_operand:DI 3 "reg_or_0_operand" "rJ,rJ,J,J")
1824                           (match_operand:DI 4 "reg_or_0_operand" "J,J,rJ,rJ")])
1825          (match_operand:SI 1 "reg_or_8bit_operand" "rI,0,rI,0")
1826          (match_operand:SI 5 "reg_or_8bit_operand" "0,rI,0,rI")))]
1827   "operands[3] == const0_rtx || operands[4] == const0_rtx"
1828   "@
1829    cmov%C2 %r3,%1,%0
1830    cmov%D2 %r3,%5,%0
1831    cmov%c2 %r4,%1,%0
1832    cmov%d2 %r4,%5,%0"
1833   [(set_attr "type" "cmov")])
1834
1835 (define_insn ""
1836   [(set (match_operand:DI 0 "register_operand" "=r,r,r,r")
1837         (if_then_else:DI
1838          (match_operator 2 "signed_comparison_operator"
1839                          [(match_operand:DI 3 "reg_or_0_operand" "rJ,rJ,J,J")
1840                           (match_operand:DI 4 "reg_or_0_operand" "J,J,rJ,rJ")])
1841          (match_operand:DI 1 "reg_or_8bit_operand" "rI,0,rI,0")
1842          (match_operand:DI 5 "reg_or_8bit_operand" "0,rI,0,rI")))]
1843   "operands[3] == const0_rtx || operands[4] == const0_rtx"
1844   "@
1845    cmov%C2 %r3,%1,%0
1846    cmov%D2 %r3,%5,%0
1847    cmov%c2 %r4,%1,%0
1848    cmov%d2 %r4,%5,%0"
1849   [(set_attr "type" "cmov")])
1850
1851 (define_insn ""
1852   [(set (match_operand:DI 0 "register_operand" "=r,r")
1853         (if_then_else:DI
1854          (eq (zero_extract:DI (match_operand:DI 2 "reg_or_0_operand" "rJ,rJ")
1855                               (const_int 1)
1856                               (const_int 0))
1857              (const_int 0))
1858          (match_operand:DI 1 "reg_or_8bit_operand" "rI,0")
1859          (match_operand:DI 3 "reg_or_8bit_operand" "0,rI")))]
1860   ""
1861   "@
1862    cmovlbc %r2,%1,%0
1863    cmovlbs %r2,%3,%0"
1864   [(set_attr "type" "cmov")])
1865
1866 (define_insn ""
1867   [(set (match_operand:DI 0 "register_operand" "=r,r")
1868         (if_then_else:DI
1869          (ne (zero_extract:DI (match_operand:DI 2 "reg_or_0_operand" "rJ,rJ")
1870                               (const_int 1)
1871                               (const_int 0))
1872              (const_int 0))
1873          (match_operand:DI 1 "reg_or_8bit_operand" "rI,0")
1874          (match_operand:DI 3 "reg_or_8bit_operand" "0,rI")))]
1875   ""
1876   "@
1877    cmovlbs %r2,%1,%0
1878    cmovlbc %r2,%3,%0"
1879   [(set_attr "type" "cmov")])
1880
1881 ;; This form is added since combine thinks that an IF_THEN_ELSE with both
1882 ;; arms constant is a single insn, so it won't try to form it if combine
1883 ;; knows they are really two insns.  This occurs in divides by powers
1884 ;; of two.
1885
1886 (define_insn ""
1887   [(set (match_operand:DI 0 "register_operand" "=r")
1888         (if_then_else:DI
1889          (match_operator 2 "signed_comparison_operator"
1890                          [(match_operand:DI 3 "reg_or_0_operand" "rJ")
1891                           (const_int 0)])
1892          (plus:DI (match_dup 0)
1893                   (match_operand:DI 1 "reg_or_8bit_operand" "rI"))
1894          (match_dup 0)))
1895    (clobber (match_scratch:DI 4 "=&r"))]
1896   ""
1897   "addq %0,%1,%4\;cmov%C2 %r3,%4,%0"
1898   [(set_attr "type" "cmov")])
1899
1900 (define_split
1901   [(set (match_operand:DI 0 "register_operand" "")
1902         (if_then_else:DI
1903          (match_operator 2 "signed_comparison_operator"
1904                          [(match_operand:DI 3 "reg_or_0_operand" "")
1905                           (const_int 0)])
1906          (plus:DI (match_dup 0)
1907                   (match_operand:DI 1 "reg_or_8bit_operand" ""))
1908          (match_dup 0)))
1909    (clobber (match_operand:DI 4 "register_operand" ""))]
1910   ""
1911   [(set (match_dup 4) (plus:DI (match_dup 0) (match_dup 1)))
1912    (set (match_dup 0) (if_then_else:DI (match_op_dup 2
1913                                                      [(match_dup 3)
1914                                                       (const_int 0)])
1915                                        (match_dup 4) (match_dup 0)))]
1916   "")
1917
1918 (define_split
1919   [(parallel
1920     [(set (match_operand:DI 0 "register_operand" "")
1921           (if_then_else:DI
1922            (match_operator 1 "comparison_operator"
1923                            [(zero_extract:DI (match_operand:DI 2 "register_operand" "")
1924                                              (const_int 1)
1925                                              (match_operand:DI 3 "const_int_operand" ""))
1926                             (const_int 0)])
1927            (match_operand:DI 4 "reg_or_8bit_operand" "")
1928            (match_operand:DI 5 "reg_or_8bit_operand" "")))
1929      (clobber (match_operand:DI 6 "register_operand" ""))])]
1930   "INTVAL (operands[3]) != 0"
1931   [(set (match_dup 6)
1932         (lshiftrt:DI (match_dup 2) (match_dup 3)))
1933    (set (match_dup 0)
1934         (if_then_else:DI (match_op_dup 1
1935                                        [(zero_extract:DI (match_dup 6)
1936                                                          (const_int 1)
1937                                                          (const_int 0))
1938                                         (const_int 0)])
1939                          (match_dup 4)
1940                          (match_dup 5)))]
1941   "")
1942
1943 ;; For ABS, we have two choices, depending on whether the input and output
1944 ;; registers are the same or not.
1945 (define_expand "absdi2"
1946   [(set (match_operand:DI 0 "register_operand" "")
1947         (abs:DI (match_operand:DI 1 "register_operand" "")))]
1948   ""
1949   "
1950 { if (rtx_equal_p (operands[0], operands[1]))
1951     emit_insn (gen_absdi2_same (operands[0], gen_reg_rtx (DImode)));
1952   else
1953     emit_insn (gen_absdi2_diff (operands[0], operands[1]));
1954
1955   DONE;
1956 }")
1957
1958 (define_expand "absdi2_same"
1959   [(set (match_operand:DI 1 "register_operand" "")
1960         (neg:DI (match_operand:DI 0 "register_operand" "")))
1961    (set (match_dup 0)
1962         (if_then_else:DI (ge (match_dup 0) (const_int 0))
1963                          (match_dup 0)
1964                          (match_dup 1)))]
1965   ""
1966   "")
1967
1968 (define_expand "absdi2_diff"
1969   [(set (match_operand:DI 0 "register_operand" "")
1970         (neg:DI (match_operand:DI 1 "register_operand" "")))
1971    (set (match_dup 0)
1972         (if_then_else:DI (lt (match_dup 1) (const_int 0))
1973                          (match_dup 0)
1974                          (match_dup 1)))]
1975   ""
1976   "")
1977
1978 (define_split
1979   [(set (match_operand:DI 0 "register_operand" "")
1980         (abs:DI (match_dup 0)))
1981    (clobber (match_operand:DI 2 "register_operand" ""))]
1982   ""
1983   [(set (match_dup 1) (neg:DI (match_dup 0)))
1984    (set (match_dup 0) (if_then_else:DI (ge (match_dup 0) (const_int 0))
1985                                        (match_dup 0) (match_dup 1)))]
1986   "")
1987
1988 (define_split
1989   [(set (match_operand:DI 0 "register_operand" "")
1990         (abs:DI (match_operand:DI 1 "register_operand" "")))]
1991   "! rtx_equal_p (operands[0], operands[1])"
1992   [(set (match_dup 0) (neg:DI (match_dup 1)))
1993    (set (match_dup 0) (if_then_else:DI (lt (match_dup 1) (const_int 0))
1994                                        (match_dup 0) (match_dup 1)))]
1995   "")
1996
1997 (define_split
1998   [(set (match_operand:DI 0 "register_operand" "")
1999         (neg:DI (abs:DI (match_dup 0))))
2000    (clobber (match_operand:DI 2 "register_operand" ""))]
2001   ""
2002   [(set (match_dup 1) (neg:DI (match_dup 0)))
2003    (set (match_dup 0) (if_then_else:DI (le (match_dup 0) (const_int 0))
2004                                        (match_dup 0) (match_dup 1)))]
2005   "")
2006
2007 (define_split
2008   [(set (match_operand:DI 0 "register_operand" "")
2009         (neg:DI (abs:DI (match_operand:DI 1 "register_operand" ""))))]
2010   "! rtx_equal_p (operands[0], operands[1])"
2011   [(set (match_dup 0) (neg:DI (match_dup 1)))
2012    (set (match_dup 0) (if_then_else:DI (gt (match_dup 1) (const_int 0))
2013                                        (match_dup 0) (match_dup 1)))]
2014   "")
2015
2016 (define_expand "smaxdi3"
2017   [(set (match_dup 3)
2018         (le:DI (match_operand:DI 1 "reg_or_0_operand" "")
2019                (match_operand:DI 2 "reg_or_8bit_operand" "")))
2020    (set (match_operand:DI 0 "register_operand" "")
2021         (if_then_else:DI (eq (match_dup 3) (const_int 0))
2022                          (match_dup 1) (match_dup 2)))]
2023   ""
2024   "
2025 { operands[3] = gen_reg_rtx (DImode);
2026 }")
2027
2028 (define_split
2029   [(set (match_operand:DI 0 "register_operand" "")
2030         (smax:DI (match_operand:DI 1 "reg_or_0_operand" "")
2031                  (match_operand:DI 2 "reg_or_8bit_operand" "")))
2032    (clobber (match_operand:DI 3 "register_operand" ""))]
2033   "operands[2] != const0_rtx"
2034   [(set (match_dup 3) (le:DI (match_dup 1) (match_dup 2)))
2035    (set (match_dup 0) (if_then_else:DI (eq (match_dup 3) (const_int 0))
2036                                        (match_dup 1) (match_dup 2)))]
2037   "")
2038
2039 (define_insn ""
2040   [(set (match_operand:DI 0 "register_operand" "=r")
2041         (smax:DI (match_operand:DI 1 "register_operand" "0")
2042                  (const_int 0)))]
2043   ""
2044   "cmovlt %0,0,%0"
2045   [(set_attr "type" "cmov")])
2046
2047 (define_expand "smindi3"
2048   [(set (match_dup 3)
2049         (lt:DI (match_operand:DI 1 "reg_or_0_operand" "")
2050                (match_operand:DI 2 "reg_or_8bit_operand" "")))
2051    (set (match_operand:DI 0 "register_operand" "")
2052         (if_then_else:DI (ne (match_dup 3) (const_int 0))
2053                          (match_dup 1) (match_dup 2)))]
2054   ""
2055   "
2056 { operands[3] = gen_reg_rtx (DImode);
2057 }")
2058
2059 (define_split
2060   [(set (match_operand:DI 0 "register_operand" "")
2061         (smin:DI (match_operand:DI 1 "reg_or_0_operand" "")
2062                  (match_operand:DI 2 "reg_or_8bit_operand" "")))
2063    (clobber (match_operand:DI 3 "register_operand" ""))]
2064   "operands[2] != const0_rtx"
2065   [(set (match_dup 3) (lt:DI (match_dup 1) (match_dup 2)))
2066    (set (match_dup 0) (if_then_else:DI (ne (match_dup 3) (const_int 0))
2067                                        (match_dup 1) (match_dup 2)))]
2068   "")
2069
2070 (define_insn ""
2071   [(set (match_operand:DI 0 "register_operand" "=r")
2072         (smin:DI (match_operand:DI 1 "register_operand" "0")
2073                  (const_int 0)))]
2074   ""
2075   "cmovgt %0,0,%0"
2076   [(set_attr "type" "cmov")])
2077
2078 (define_expand "umaxdi3"
2079   [(set (match_dup 3) 
2080         (leu:DI (match_operand:DI 1 "reg_or_0_operand" "")
2081                 (match_operand:DI 2 "reg_or_8bit_operand" "")))
2082    (set (match_operand:DI 0 "register_operand" "")
2083         (if_then_else:DI (eq (match_dup 3) (const_int 0))
2084                          (match_dup 1) (match_dup 2)))]
2085   ""
2086   "
2087 { operands[3] = gen_reg_rtx (DImode);
2088 }")
2089
2090 (define_split
2091   [(set (match_operand:DI 0 "register_operand" "")
2092         (umax:DI (match_operand:DI 1 "reg_or_0_operand" "")
2093                  (match_operand:DI 2 "reg_or_8bit_operand" "")))
2094    (clobber (match_operand:DI 3 "register_operand" ""))]
2095   "operands[2] != const0_rtx"
2096   [(set (match_dup 3) (leu:DI (match_dup 1) (match_dup 2)))
2097    (set (match_dup 0) (if_then_else:DI (eq (match_dup 3) (const_int 0))
2098                                        (match_dup 1) (match_dup 2)))]
2099   "")
2100
2101 (define_expand "umindi3"
2102   [(set (match_dup 3)
2103         (ltu:DI (match_operand:DI 1 "reg_or_0_operand" "")
2104                 (match_operand:DI 2 "reg_or_8bit_operand" "")))
2105    (set (match_operand:DI 0 "register_operand" "")
2106         (if_then_else:DI (ne (match_dup 3) (const_int 0))
2107                          (match_dup 1) (match_dup 2)))]
2108   ""
2109   "
2110 { operands[3] = gen_reg_rtx (DImode);
2111 }")
2112
2113 (define_split
2114   [(set (match_operand:DI 0 "register_operand" "")
2115         (umin:DI (match_operand:DI 1 "reg_or_0_operand" "")
2116                  (match_operand:DI 2 "reg_or_8bit_operand" "")))
2117    (clobber (match_operand:DI 3 "register_operand" ""))]
2118   "operands[2] != const0_rtx"
2119   [(set (match_dup 3) (ltu:DI (match_dup 1) (match_dup 2)))
2120    (set (match_dup 0) (if_then_else:DI (ne (match_dup 3) (const_int 0))
2121                                        (match_dup 1) (match_dup 2)))]
2122   "")
2123
2124 (define_insn ""
2125   [(set (pc)
2126         (if_then_else
2127          (match_operator 1 "signed_comparison_operator"
2128                          [(match_operand:DI 2 "reg_or_0_operand" "rJ")
2129                           (const_int 0)])
2130          (label_ref (match_operand 0 "" ""))
2131          (pc)))]
2132   ""
2133   "b%C1 %r2,%0"
2134   [(set_attr "type" "ibr")])
2135
2136 (define_insn ""
2137   [(set (pc)
2138         (if_then_else
2139          (match_operator 1 "signed_comparison_operator"
2140                          [(const_int 0)
2141                           (match_operand:DI 2 "register_operand" "r")])
2142          (label_ref (match_operand 0 "" ""))
2143          (pc)))]
2144   ""
2145   "b%c1 %2,%0"
2146   [(set_attr "type" "ibr")])
2147
2148 (define_insn ""
2149   [(set (pc)
2150         (if_then_else
2151          (ne (zero_extract:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
2152                               (const_int 1)
2153                               (const_int 0))
2154              (const_int 0))
2155          (label_ref (match_operand 0 "" ""))
2156          (pc)))]
2157   ""
2158   "blbs %r1,%0"
2159   [(set_attr "type" "ibr")])
2160
2161 (define_insn ""
2162   [(set (pc)
2163         (if_then_else
2164          (eq (zero_extract:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
2165                               (const_int 1)
2166                               (const_int 0))
2167              (const_int 0))
2168          (label_ref (match_operand 0 "" ""))
2169          (pc)))]
2170   ""
2171   "blbc %r1,%0"
2172   [(set_attr "type" "ibr")])
2173
2174 (define_split
2175   [(parallel
2176     [(set (pc)
2177           (if_then_else
2178            (match_operator 1 "comparison_operator"
2179                            [(zero_extract:DI (match_operand:DI 2 "register_operand" "")
2180                                              (const_int 1)
2181                                              (match_operand:DI 3 "const_int_operand" ""))
2182                             (const_int 0)])
2183            (label_ref (match_operand 0 "" ""))
2184            (pc)))
2185      (clobber (match_operand:DI 4 "register_operand" ""))])]
2186   "INTVAL (operands[3]) != 0"
2187   [(set (match_dup 4)
2188         (lshiftrt:DI (match_dup 2) (match_dup 3)))
2189    (set (pc)
2190         (if_then_else (match_op_dup 1
2191                                     [(zero_extract:DI (match_dup 4)
2192                                                       (const_int 1)
2193                                                       (const_int 0))
2194                                      (const_int 0)])
2195                       (label_ref (match_dup 0))
2196                       (pc)))]
2197   "")
2198 \f
2199 ;; The following are the corresponding floating-point insns.  Recall
2200 ;; we need to have variants that expand the arguments from SF mode
2201 ;; to DFmode.
2202
2203 (define_insn ""
2204   [(set (match_operand:DF 0 "register_operand" "=&f")
2205         (match_operator:DF 1 "alpha_comparison_operator"
2206                            [(match_operand:DF 2 "reg_or_fp0_operand" "fG")
2207                             (match_operand:DF 3 "reg_or_fp0_operand" "fG")]))]
2208   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
2209   "cmp%-%C1%' %R2,%R3,%0"
2210   [(set_attr "type" "fadd")
2211    (set_attr "trap" "yes")])
2212
2213 (define_insn ""
2214   [(set (match_operand:DF 0 "register_operand" "=f")
2215         (match_operator:DF 1 "alpha_comparison_operator"
2216                            [(match_operand:DF 2 "reg_or_fp0_operand" "fG")
2217                             (match_operand:DF 3 "reg_or_fp0_operand" "fG")]))]
2218   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2219   "cmp%-%C1%' %R2,%R3,%0"
2220   [(set_attr "type" "fadd")
2221    (set_attr "trap" "yes")])
2222
2223 (define_insn ""
2224   [(set (match_operand:DF 0 "register_operand" "=f")
2225         (match_operator:DF 1 "alpha_comparison_operator"
2226                            [(float_extend:DF
2227                              (match_operand:SF 2 "reg_or_fp0_operand" "fG"))
2228                             (match_operand:DF 3 "reg_or_fp0_operand" "fG")]))]
2229   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2230   "cmp%-%C1%' %R2,%R3,%0"
2231   [(set_attr "type" "fadd")
2232    (set_attr "trap" "yes")])
2233
2234 (define_insn ""
2235   [(set (match_operand:DF 0 "register_operand" "=f")
2236         (match_operator:DF 1 "alpha_comparison_operator"
2237                            [(match_operand:DF 2 "reg_or_fp0_operand" "fG")
2238                             (float_extend:DF
2239                              (match_operand:SF 3 "reg_or_fp0_operand" "fG"))]))]
2240   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2241   "cmp%-%C1%' %R2,%R3,%0"
2242   [(set_attr "type" "fadd")
2243    (set_attr "trap" "yes")])
2244
2245 (define_insn ""
2246   [(set (match_operand:DF 0 "register_operand" "=f")
2247         (match_operator:DF 1 "alpha_comparison_operator"
2248                            [(float_extend:DF
2249                              (match_operand:SF 2 "reg_or_fp0_operand" "fG"))
2250                             (float_extend:DF
2251                              (match_operand:SF 3 "reg_or_fp0_operand" "fG"))]))]
2252   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2253   "cmp%-%C1%' %R2,%R3,%0"
2254   [(set_attr "type" "fadd")
2255    (set_attr "trap" "yes")])
2256
2257 (define_insn ""
2258   [(set (match_operand:DF 0 "register_operand" "=&f,f")
2259         (if_then_else:DF 
2260          (match_operator 3 "signed_comparison_operator"
2261                          [(match_operand:DF 4 "reg_or_fp0_operand" "fG,fG")
2262                           (match_operand:DF 2 "fp0_operand" "G,G")])
2263          (match_operand:DF 1 "reg_or_fp0_operand" "fG,0")
2264          (match_operand:DF 5 "reg_or_fp0_operand" "0,fG")))]
2265   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
2266   "@
2267    fcmov%C3 %R4,%R1,%0
2268    fcmov%D3 %R4,%R5,%0"
2269   [(set_attr "type" "fadd")])
2270
2271 (define_insn ""
2272   [(set (match_operand:DF 0 "register_operand" "=f,f")
2273         (if_then_else:DF 
2274          (match_operator 3 "signed_comparison_operator"
2275                          [(match_operand:DF 4 "reg_or_fp0_operand" "fG,fG")
2276                           (match_operand:DF 2 "fp0_operand" "G,G")])
2277          (match_operand:DF 1 "reg_or_fp0_operand" "fG,0")
2278          (match_operand:DF 5 "reg_or_fp0_operand" "0,fG")))]
2279   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2280   "@
2281    fcmov%C3 %R4,%R1,%0
2282    fcmov%D3 %R4,%R5,%0"
2283   [(set_attr "type" "fadd")])
2284
2285 (define_insn ""
2286   [(set (match_operand:SF 0 "register_operand" "=&f,f")
2287         (if_then_else:SF 
2288          (match_operator 3 "signed_comparison_operator"
2289                          [(match_operand:DF 4 "reg_or_fp0_operand" "fG,fG")
2290                           (match_operand:DF 2 "fp0_operand" "G,G")])
2291          (match_operand:SF 1 "reg_or_fp0_operand" "fG,0")
2292          (match_operand:SF 5 "reg_or_fp0_operand" "0,fG")))]
2293   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
2294   "@
2295    fcmov%C3 %R4,%R1,%0
2296    fcmov%D3 %R4,%R5,%0"
2297   [(set_attr "type" "fadd")])
2298
2299 (define_insn ""
2300   [(set (match_operand:SF 0 "register_operand" "=f,f")
2301         (if_then_else:SF 
2302          (match_operator 3 "signed_comparison_operator"
2303                          [(match_operand:DF 4 "reg_or_fp0_operand" "fG,fG")
2304                           (match_operand:DF 2 "fp0_operand" "G,G")])
2305          (match_operand:SF 1 "reg_or_fp0_operand" "fG,0")
2306          (match_operand:SF 5 "reg_or_fp0_operand" "0,fG")))]
2307   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2308   "@
2309    fcmov%C3 %R4,%R1,%0
2310    fcmov%D3 %R4,%R5,%0"
2311   [(set_attr "type" "fadd")])
2312
2313 (define_insn ""
2314   [(set (match_operand:DF 0 "register_operand" "=f,f")
2315         (if_then_else:DF 
2316          (match_operator 3 "signed_comparison_operator"
2317                          [(match_operand:DF 4 "reg_or_fp0_operand" "fG,fG")
2318                           (match_operand:DF 2 "fp0_operand" "G,G")])
2319          (float_extend:DF (match_operand:SF 1 "reg_or_fp0_operand" "fG,0"))
2320          (match_operand:DF 5 "reg_or_fp0_operand" "0,fG")))]
2321   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2322   "@
2323    fcmov%C3 %R4,%R1,%0
2324    fcmov%D3 %R4,%R5,%0"
2325   [(set_attr "type" "fadd")])
2326
2327 (define_insn ""
2328   [(set (match_operand:DF 0 "register_operand" "=f,f")
2329         (if_then_else:DF 
2330          (match_operator 3 "signed_comparison_operator"
2331                          [(float_extend:DF 
2332                            (match_operand:SF 4 "reg_or_fp0_operand" "fG,fG"))
2333                           (match_operand:DF 2 "fp0_operand" "G,G")])
2334          (match_operand:DF 1 "reg_or_fp0_operand" "fG,0")
2335          (match_operand:DF 5 "reg_or_fp0_operand" "0,fG")))]
2336   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2337   "@
2338    fcmov%C3 %R4,%R1,%0
2339    fcmov%D3 %R4,%R5,%0"
2340   [(set_attr "type" "fadd")])
2341
2342 (define_insn ""
2343   [(set (match_operand:SF 0 "register_operand" "=f,f")
2344         (if_then_else:SF 
2345          (match_operator 3 "signed_comparison_operator"
2346                          [(float_extend:DF
2347                            (match_operand:SF 4 "reg_or_fp0_operand" "fG,fG"))
2348                           (match_operand:DF 2 "fp0_operand" "G,G")])
2349          (match_operand:SF 1 "reg_or_fp0_operand" "fG,0")
2350          (match_operand:SF 5 "reg_or_fp0_operand" "0,fG")))]
2351   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2352   "@
2353    fcmov%C3 %R4,%R1,%0
2354    fcmov%D3 %R4,%R5,%0"
2355   [(set_attr "type" "fadd")])
2356
2357 (define_insn ""
2358   [(set (match_operand:DF 0 "register_operand" "=f,f")
2359         (if_then_else:DF 
2360          (match_operator 3 "signed_comparison_operator"
2361                          [(float_extend:DF
2362                            (match_operand:SF 4 "reg_or_fp0_operand" "fG,fG"))
2363                           (match_operand:DF 2 "fp0_operand" "G,G")])
2364          (float_extend:DF (match_operand:SF 1 "reg_or_fp0_operand" "fG,0"))
2365          (match_operand:DF 5 "reg_or_fp0_operand" "0,fG")))]
2366   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2367   "@
2368    fcmov%C3 %R4,%R1,%0
2369    fcmov%D3 %R4,%R5,%0"
2370   [(set_attr "type" "fadd")])
2371
2372 (define_expand "maxdf3"
2373   [(set (match_dup 3)
2374         (le:DF (match_operand:DF 1 "reg_or_fp0_operand" "")
2375                (match_operand:DF 2 "reg_or_fp0_operand" "")))
2376    (set (match_operand:DF 0 "register_operand" "")
2377         (if_then_else:DF (eq (match_dup 3) (match_dup 4))
2378                          (match_dup 1) (match_dup 2)))]
2379   "TARGET_FP"
2380   "
2381 { operands[3] = gen_reg_rtx (DFmode);
2382   operands[4] = CONST0_RTX (DFmode);
2383 }")
2384
2385 (define_expand "mindf3"
2386   [(set (match_dup 3)
2387         (lt:DF (match_operand:DF 1 "reg_or_fp0_operand" "")
2388                (match_operand:DF 2 "reg_or_fp0_operand" "")))
2389    (set (match_operand:DF 0 "register_operand" "")
2390         (if_then_else:DF (ne (match_dup 3) (match_dup 4))
2391                          (match_dup 1) (match_dup 2)))]
2392   "TARGET_FP"
2393   "
2394 { operands[3] = gen_reg_rtx (DFmode);
2395   operands[4] = CONST0_RTX (DFmode);
2396 }")
2397
2398 (define_expand "maxsf3"
2399   [(set (match_dup 3)
2400         (le:DF (float_extend:DF (match_operand:SF 1 "reg_or_fp0_operand" ""))
2401                (float_extend:DF (match_operand:SF 2 "reg_or_fp0_operand" ""))))
2402    (set (match_operand:SF 0 "register_operand" "")
2403         (if_then_else:SF (eq (match_dup 3) (match_dup 4))
2404                          (match_dup 1) (match_dup 2)))]
2405   "TARGET_FP"
2406   "
2407 { operands[3] = gen_reg_rtx (DFmode);
2408   operands[4] = CONST0_RTX (DFmode);
2409 }")
2410
2411 (define_expand "minsf3"
2412   [(set (match_dup 3)
2413         (lt:DF (float_extend:DF (match_operand:SF 1 "reg_or_fp0_operand" ""))
2414                (float_extend:DF (match_operand:SF 2 "reg_or_fp0_operand" ""))))
2415    (set (match_operand:SF 0 "register_operand" "")
2416         (if_then_else:SF (ne (match_dup 3) (match_dup 4))
2417                       (match_dup 1) (match_dup 2)))]
2418   "TARGET_FP"
2419   "
2420 { operands[3] = gen_reg_rtx (DFmode);
2421   operands[4] = CONST0_RTX (DFmode);
2422 }")
2423
2424 (define_insn ""
2425   [(set (pc)
2426         (if_then_else
2427          (match_operator 1 "signed_comparison_operator"
2428                          [(match_operand:DF 2 "reg_or_fp0_operand" "fG")
2429                           (match_operand:DF 3 "fp0_operand" "G")])
2430          (label_ref (match_operand 0 "" ""))
2431          (pc)))]
2432   "TARGET_FP"
2433   "fb%C1 %R2,%0"
2434   [(set_attr "type" "fbr")])
2435
2436 (define_insn ""
2437   [(set (pc)
2438         (if_then_else
2439          (match_operator 1 "signed_comparison_operator"
2440                          [(float_extend:DF
2441                            (match_operand:SF 2 "reg_or_fp0_operand" "fG"))
2442                           (match_operand:DF 3 "fp0_operand" "G")])
2443          (label_ref (match_operand 0 "" ""))
2444          (pc)))]
2445   "TARGET_FP"
2446   "fb%C1 %R2,%0"
2447   [(set_attr "type" "fbr")])
2448 \f
2449 ;; These are the main define_expand's used to make conditional branches
2450 ;; and compares.
2451
2452 (define_expand "cmpdf"
2453   [(set (cc0) (compare (match_operand:DF 0 "reg_or_fp0_operand" "")
2454                        (match_operand:DF 1 "reg_or_fp0_operand" "")))]
2455   "TARGET_FP"
2456   "
2457 {
2458   alpha_compare_op0 = operands[0];
2459   alpha_compare_op1 = operands[1];
2460   alpha_compare_fp_p = 1;
2461   DONE;
2462 }")
2463
2464 (define_expand "cmpdi"
2465   [(set (cc0) (compare (match_operand:DI 0 "reg_or_0_operand" "")
2466                        (match_operand:DI 1 "reg_or_8bit_operand" "")))]
2467   ""
2468   "
2469 {
2470   alpha_compare_op0 = operands[0];
2471   alpha_compare_op1 = operands[1];
2472   alpha_compare_fp_p = 0;
2473   DONE;
2474 }")
2475
2476 (define_expand "beq"
2477   [(set (match_dup 1) (match_dup 2))
2478    (set (pc)
2479         (if_then_else (match_dup 3)
2480                       (label_ref (match_operand 0 "" ""))
2481                       (pc)))]
2482   ""
2483   "
2484 {
2485   enum machine_mode mode;
2486   enum rtx_code compare_code = EQ, branch_code = NE;
2487
2488   if (alpha_compare_fp_p)
2489     mode = DFmode;
2490   else
2491     {
2492       mode = DImode;
2493       /* We want to use cmpeq/bne when we can, since there is a zero-delay
2494          bypass between logicals and br/cmov on the 21164.  But we don't
2495          want to force valid immediate constants into registers needlessly.  */
2496       if (GET_CODE (alpha_compare_op1) == CONST_INT
2497           && ((INTVAL (alpha_compare_op1) >= -0x8000
2498                && INTVAL (alpha_compare_op1) < 0)
2499               || (INTVAL (alpha_compare_op1) > 0xff
2500                   && INTVAL (alpha_compare_op1) < 0x8000)))
2501         {
2502           compare_code = PLUS, branch_code = EQ;
2503           alpha_compare_op1 = GEN_INT (- INTVAL (alpha_compare_op1));
2504         }
2505     }
2506
2507   operands[1] = gen_reg_rtx (mode);
2508   operands[2] = gen_rtx (compare_code, mode,
2509                          alpha_compare_op0, alpha_compare_op1);
2510   operands[3] = gen_rtx (branch_code, VOIDmode,
2511                          operands[1], CONST0_RTX (mode));
2512 }")
2513
2514 (define_expand "bne"
2515   [(set (match_dup 1) (match_dup 2))
2516    (set (pc)
2517         (if_then_else (match_dup 3)
2518                       (label_ref (match_operand 0 "" ""))
2519                       (pc)))]
2520   ""
2521   "
2522 {
2523   enum machine_mode mode;
2524   enum rtx_code compare_code = EQ, branch_code = EQ;
2525
2526   if (alpha_compare_fp_p)
2527     mode = DFmode;
2528   else
2529     {
2530       mode = DImode;
2531       /* We want to use cmpeq/bne when we can, since there is a zero-delay
2532          bypass between logicals and br/cmov on the 21164.  But we don't
2533          want to force valid immediate constants into registers needlessly.  */
2534       if (GET_CODE (alpha_compare_op1) == CONST_INT
2535           && ((INTVAL (alpha_compare_op1) >= -0x8000
2536                && INTVAL (alpha_compare_op1) < 0)
2537               || (INTVAL (alpha_compare_op1) > 0xff
2538                   && INTVAL (alpha_compare_op1) < 0x8000)))
2539         {
2540           compare_code = PLUS, branch_code = NE;
2541           alpha_compare_op1 = GEN_INT (- INTVAL (alpha_compare_op1));
2542         }
2543     }
2544
2545   operands[1] = gen_reg_rtx (mode);
2546   operands[2] = gen_rtx (compare_code, mode,
2547                          alpha_compare_op0, alpha_compare_op1);
2548   operands[3] = gen_rtx (branch_code, VOIDmode,
2549                          operands[1], CONST0_RTX (mode));
2550 }")
2551
2552 (define_expand "blt"
2553   [(set (match_dup 1) (match_dup 2))
2554    (set (pc)
2555         (if_then_else (match_dup 3)
2556                       (label_ref (match_operand 0 "" ""))
2557                       (pc)))]
2558   ""
2559   "
2560 {
2561   enum machine_mode mode = alpha_compare_fp_p ? DFmode : DImode;
2562   operands[1] = gen_reg_rtx (mode);
2563   operands[2] = gen_rtx (LT, mode, alpha_compare_op0, alpha_compare_op1);
2564   operands[3] = gen_rtx (NE, VOIDmode, operands[1], CONST0_RTX (mode));
2565 }")
2566
2567 (define_expand "ble"
2568   [(set (match_dup 1) (match_dup 2))
2569    (set (pc)
2570         (if_then_else (match_dup 3)
2571                       (label_ref (match_operand 0 "" ""))
2572                       (pc)))]
2573   ""
2574   "
2575 {
2576   enum machine_mode mode = alpha_compare_fp_p ? DFmode : DImode;
2577   operands[1] = gen_reg_rtx (mode);
2578   operands[2] = gen_rtx (LE, mode, alpha_compare_op0, alpha_compare_op1);
2579   operands[3] = gen_rtx (NE, VOIDmode, operands[1], CONST0_RTX (mode));
2580 }")
2581
2582 (define_expand "bgt"
2583   [(set (match_dup 1) (match_dup 2))
2584    (set (pc)
2585         (if_then_else (match_dup 3)
2586                       (label_ref (match_operand 0 "" ""))
2587                       (pc)))]
2588   ""
2589   "
2590 {
2591   if (alpha_compare_fp_p)
2592     {
2593       operands[1] = gen_reg_rtx (DFmode);
2594       operands[2] = gen_rtx (LT, DFmode, alpha_compare_op1, alpha_compare_op0);
2595       operands[3] = gen_rtx (NE, VOIDmode, operands[1], CONST0_RTX (DFmode));
2596     }
2597   else
2598     {
2599       operands[1] = gen_reg_rtx (DImode);
2600       operands[2] = gen_rtx (LE, DImode, alpha_compare_op0, alpha_compare_op1);
2601       operands[3] = gen_rtx (EQ, VOIDmode, operands[1], const0_rtx);
2602     }
2603 }")
2604
2605 (define_expand "bge"
2606   [(set (match_dup 1) (match_dup 2))
2607    (set (pc)
2608         (if_then_else (match_dup 3)
2609                       (label_ref (match_operand 0 "" ""))
2610                       (pc)))]
2611   ""
2612   "
2613 {
2614   if (alpha_compare_fp_p)
2615     {
2616       operands[1] = gen_reg_rtx (DFmode);
2617       operands[2] = gen_rtx (LE, DFmode, alpha_compare_op1, alpha_compare_op0);
2618       operands[3] = gen_rtx (NE, VOIDmode, operands[1], CONST0_RTX (DFmode));
2619     }
2620   else
2621     {
2622       operands[1] = gen_reg_rtx (DImode);
2623       operands[2] = gen_rtx (LT, DImode, alpha_compare_op0, alpha_compare_op1);
2624       operands[3] = gen_rtx (EQ, VOIDmode, operands[1], const0_rtx);
2625     }
2626 }")
2627
2628 (define_expand "bltu"
2629   [(set (match_dup 1) (match_dup 2))
2630    (set (pc)
2631         (if_then_else (match_dup 3)
2632                       (label_ref (match_operand 0 "" ""))
2633                       (pc)))]
2634   ""
2635   "
2636 {
2637   operands[1] = gen_reg_rtx (DImode);
2638   operands[2] = gen_rtx (LTU, DImode, alpha_compare_op0, alpha_compare_op1);
2639   operands[3] = gen_rtx (NE, VOIDmode, operands[1], const0_rtx);
2640 }")
2641
2642 (define_expand "bleu"
2643   [(set (match_dup 1) (match_dup 2))
2644    (set (pc)
2645         (if_then_else (match_dup 3)
2646                       (label_ref (match_operand 0 "" ""))
2647                       (pc)))]
2648   ""
2649   "
2650 {
2651   operands[1] = gen_reg_rtx (DImode);
2652   operands[2] = gen_rtx (LEU, DImode, alpha_compare_op0, alpha_compare_op1);
2653   operands[3] = gen_rtx (NE, VOIDmode, operands[1], const0_rtx);
2654 }")
2655
2656 (define_expand "bgtu"
2657   [(set (match_dup 1) (match_dup 2))
2658    (set (pc)
2659         (if_then_else (match_dup 3)
2660                       (label_ref (match_operand 0 "" ""))
2661                       (pc)))]
2662   ""
2663   "
2664 {
2665   operands[1] = gen_reg_rtx (DImode);
2666   operands[2] = gen_rtx (LEU, DImode, alpha_compare_op0, alpha_compare_op1);
2667   operands[3] = gen_rtx (EQ, VOIDmode, operands[1], const0_rtx);
2668 }")
2669
2670 (define_expand "bgeu"
2671   [(set (match_dup 1) (match_dup 2))
2672    (set (pc)
2673         (if_then_else (match_dup 3)
2674                       (label_ref (match_operand 0 "" ""))
2675                       (pc)))]
2676   ""
2677   "
2678 {
2679   operands[1] = gen_reg_rtx (DImode);
2680   operands[2] = gen_rtx (LTU, DImode, alpha_compare_op0, alpha_compare_op1);
2681   operands[3] = gen_rtx (EQ, VOIDmode, operands[1], const0_rtx);
2682 }")
2683
2684 (define_expand "seq"
2685   [(set (match_operand:DI 0 "register_operand" "")
2686         (match_dup 1))]
2687   ""
2688   "
2689 {
2690   if (alpha_compare_fp_p)
2691     FAIL;
2692
2693   operands[1] = gen_rtx (EQ, DImode, alpha_compare_op0, alpha_compare_op1);
2694 }")
2695
2696 (define_expand "sne"
2697   [(set (match_operand:DI 0 "register_operand" "")
2698         (match_dup 1))
2699    (set (match_dup 0) (xor:DI (match_dup 0) (const_int 1)))]
2700   ""
2701   "
2702 {
2703   if (alpha_compare_fp_p)
2704     FAIL;
2705
2706   operands[1] = gen_rtx (EQ, DImode, alpha_compare_op0, alpha_compare_op1);
2707 }")
2708
2709 (define_expand "slt"
2710   [(set (match_operand:DI 0 "register_operand" "")
2711         (match_dup 1))]
2712   ""
2713   "
2714 {
2715   if (alpha_compare_fp_p)
2716     FAIL;
2717
2718   operands[1] = gen_rtx (LT, DImode, alpha_compare_op0, alpha_compare_op1);
2719 }")
2720
2721 (define_expand "sle"
2722   [(set (match_operand:DI 0 "register_operand" "")
2723         (match_dup 1))]
2724   ""
2725   "
2726 {
2727   if (alpha_compare_fp_p)
2728     FAIL;
2729
2730   operands[1] = gen_rtx (LE, DImode, alpha_compare_op0, alpha_compare_op1);
2731 }")
2732
2733 (define_expand "sgt"
2734   [(set (match_operand:DI 0 "register_operand" "")
2735         (match_dup 1))]
2736   ""
2737   "
2738 {
2739   if (alpha_compare_fp_p)
2740     FAIL;
2741
2742   operands[1] = gen_rtx (LT, DImode, force_reg (DImode, alpha_compare_op1),
2743                          alpha_compare_op0);
2744 }")
2745
2746 (define_expand "sge"
2747   [(set (match_operand:DI 0 "register_operand" "")
2748         (match_dup 1))]
2749   ""
2750   "
2751 {
2752   if (alpha_compare_fp_p)
2753     FAIL;
2754
2755   operands[1] = gen_rtx (LE, DImode, force_reg (DImode, alpha_compare_op1),
2756                          alpha_compare_op0);
2757 }")
2758
2759 (define_expand "sltu"
2760   [(set (match_operand:DI 0 "register_operand" "")
2761         (match_dup 1))]
2762   ""
2763   "
2764 {
2765   if (alpha_compare_fp_p)
2766     FAIL;
2767
2768   operands[1] = gen_rtx (LTU, DImode, alpha_compare_op0, alpha_compare_op1);
2769 }")
2770
2771 (define_expand "sleu"
2772   [(set (match_operand:DI 0 "register_operand" "")
2773         (match_dup 1))]
2774   ""
2775   "
2776 {
2777   if (alpha_compare_fp_p)
2778     FAIL;
2779
2780   operands[1] = gen_rtx (LEU, DImode, alpha_compare_op0, alpha_compare_op1);
2781 }")
2782
2783 (define_expand "sgtu"
2784   [(set (match_operand:DI 0 "register_operand" "")
2785         (match_dup 1))]
2786   ""
2787   "
2788 {
2789   if (alpha_compare_fp_p)
2790     FAIL;
2791
2792   operands[1] = gen_rtx (LTU, DImode, force_reg (DImode, alpha_compare_op1),
2793                          alpha_compare_op0);
2794 }")
2795
2796 (define_expand "sgeu"
2797   [(set (match_operand:DI 0 "register_operand" "")
2798         (match_dup 1))]
2799   ""
2800   "
2801 {
2802   if (alpha_compare_fp_p)
2803     FAIL;
2804
2805   operands[1] = gen_rtx (LEU, DImode, force_reg (DImode, alpha_compare_op1),
2806                          alpha_compare_op0);
2807 }")
2808 \f
2809 ;; These are the main define_expand's used to make conditional moves.
2810
2811 (define_expand "movsicc"
2812   [(set (match_operand:SI 0 "register_operand" "")
2813         (if_then_else:DI (match_operand 1 "comparison_operator" "")
2814                          (match_operand:SI 2 "reg_or_8bit_operand" "")
2815                          (match_operand:SI 3 "reg_or_8bit_operand" "")))]
2816   ""
2817   "
2818 {
2819   if ((operands[1] = alpha_emit_conditional_move (operands[1], SImode)) == 0)
2820     FAIL;
2821 }")
2822
2823 (define_expand "movdicc"
2824   [(set (match_operand:DI 0 "register_operand" "")
2825         (if_then_else:DI (match_operand 1 "comparison_operator" "")
2826                          (match_operand:DI 2 "reg_or_8bit_operand" "")
2827                          (match_operand:DI 3 "reg_or_8bit_operand" "")))]
2828   ""
2829   "
2830 {
2831   if ((operands[1] = alpha_emit_conditional_move (operands[1], DImode)) == 0)
2832     FAIL;
2833 }")
2834
2835 (define_expand "movsfcc"
2836   [(set (match_operand:SF 0 "register_operand" "")
2837         (if_then_else:SF (match_operand 1 "comparison_operator" "")
2838                          (match_operand:SF 2 "reg_or_8bit_operand" "")
2839                          (match_operand:SF 3 "reg_or_8bit_operand" "")))]
2840   ""
2841   "
2842 {
2843   if ((operands[1] = alpha_emit_conditional_move (operands[1], SFmode)) == 0)
2844     FAIL;
2845 }")
2846
2847 (define_expand "movdfcc"
2848   [(set (match_operand:DF 0 "register_operand" "")
2849         (if_then_else:DF (match_operand 1 "comparison_operator" "")
2850                          (match_operand:DF 2 "reg_or_8bit_operand" "")
2851                          (match_operand:DF 3 "reg_or_8bit_operand" "")))]
2852   ""
2853   "
2854 {
2855   if ((operands[1] = alpha_emit_conditional_move (operands[1], DFmode)) == 0)
2856     FAIL;
2857 }")
2858 \f
2859 ;; These define_split definitions are used in cases when comparisons have
2860 ;; not be stated in the correct way and we need to reverse the second
2861 ;; comparison.  For example, x >= 7 has to be done as x < 6 with the
2862 ;; comparison that tests the result being reversed.  We have one define_split
2863 ;; for each use of a comparison.  They do not match valid insns and need
2864 ;; not generate valid insns.
2865 ;;
2866 ;; We can also handle equality comparisons (and inequality comparisons in
2867 ;; cases where the resulting add cannot overflow) by doing an add followed by
2868 ;; a comparison with zero.  This is faster since the addition takes one
2869 ;; less cycle than a compare when feeding into a conditional move.
2870 ;; For this case, we also have an SImode pattern since we can merge the add
2871 ;; and sign extend and the order doesn't matter.
2872 ;;
2873 ;; We do not do this for floating-point, since it isn't clear how the "wrong"
2874 ;; operation could have been generated.
2875
2876 (define_split
2877   [(set (match_operand:DI 0 "register_operand" "")
2878         (if_then_else:DI
2879          (match_operator 1 "comparison_operator"
2880                          [(match_operand:DI 2 "reg_or_0_operand" "")
2881                           (match_operand:DI 3 "reg_or_cint_operand" "")])
2882          (match_operand:DI 4 "reg_or_cint_operand" "")
2883          (match_operand:DI 5 "reg_or_cint_operand" "")))
2884    (clobber (match_operand:DI 6 "register_operand" ""))]
2885   "operands[3] != const0_rtx"
2886   [(set (match_dup 6) (match_dup 7))
2887    (set (match_dup 0)
2888         (if_then_else:DI (match_dup 8) (match_dup 4) (match_dup 5)))]
2889   "
2890 { enum rtx_code code = GET_CODE (operands[1]);
2891   int unsignedp = (code == GEU || code == LEU || code == GTU || code == LTU);
2892
2893   /* If we are comparing for equality with a constant and that constant
2894      appears in the arm when the register equals the constant, use the
2895      register since that is more likely to match (and to produce better code
2896      if both would).  */
2897
2898   if (code == EQ && GET_CODE (operands[3]) == CONST_INT
2899       && rtx_equal_p (operands[4], operands[3]))
2900     operands[4] = operands[2];
2901
2902   else if (code == NE && GET_CODE (operands[3]) == CONST_INT
2903            && rtx_equal_p (operands[5], operands[3]))
2904     operands[5] = operands[2];
2905
2906   if (code == NE || code == EQ
2907       || (extended_count (operands[2], DImode, unsignedp) >= 1
2908           && extended_count (operands[3], DImode, unsignedp) >= 1))
2909     {
2910       if (GET_CODE (operands[3]) == CONST_INT)
2911         operands[7] = gen_rtx (PLUS, DImode, operands[2],
2912                                GEN_INT (- INTVAL (operands[3])));
2913       else
2914         operands[7] = gen_rtx (MINUS, DImode, operands[2], operands[3]);
2915
2916       operands[8] = gen_rtx (code, VOIDmode, operands[6], const0_rtx);
2917     }
2918
2919   else if (code == EQ || code == LE || code == LT
2920            || code == LEU || code == LTU)
2921     {
2922       operands[7] = gen_rtx (code, DImode, operands[2], operands[3]);
2923       operands[8] = gen_rtx (NE, VOIDmode, operands[6], const0_rtx);
2924     }
2925   else
2926     {
2927       operands[7] = gen_rtx (reverse_condition (code), DImode, operands[2],
2928                              operands[3]);
2929       operands[8] = gen_rtx (EQ, VOIDmode, operands[6], const0_rtx);
2930     }
2931 }")
2932
2933 (define_split
2934   [(set (match_operand:DI 0 "register_operand" "")
2935         (if_then_else:DI
2936          (match_operator 1 "comparison_operator"
2937                          [(match_operand:SI 2 "reg_or_0_operand" "")
2938                           (match_operand:SI 3 "reg_or_cint_operand" "")])
2939          (match_operand:DI 4 "reg_or_8bit_operand" "")
2940          (match_operand:DI 5 "reg_or_8bit_operand" "")))
2941    (clobber (match_operand:DI 6 "register_operand" ""))]
2942   "operands[3] != const0_rtx
2943    && (GET_CODE (operands[1]) == EQ || GET_CODE (operands[1]) == NE)"
2944   [(set (match_dup 6) (match_dup 7))
2945    (set (match_dup 0)
2946         (if_then_else:DI (match_dup 8) (match_dup 4) (match_dup 5)))]
2947   "
2948 { enum rtx_code code = GET_CODE (operands[1]);
2949   int unsignedp = (code == GEU || code == LEU || code == GTU || code == LTU);
2950   rtx tem;
2951
2952   if ((code != NE && code != EQ
2953        && ! (extended_count (operands[2], DImode, unsignedp) >= 1
2954              && extended_count (operands[3], DImode, unsignedp) >= 1)))
2955     FAIL;
2956  
2957   if (GET_CODE (operands[3]) == CONST_INT)
2958     tem = gen_rtx (PLUS, SImode, operands[2],
2959                    GEN_INT (- INTVAL (operands[3])));
2960   else
2961     tem = gen_rtx (MINUS, SImode, operands[2], operands[3]);
2962
2963   operands[7] = gen_rtx (SIGN_EXTEND, DImode, tem);
2964   operands[8] = gen_rtx (GET_CODE (operands[1]), VOIDmode, operands[6],
2965                          const0_rtx);
2966 }")
2967
2968 (define_split
2969   [(set (pc)
2970         (if_then_else
2971          (match_operator 1 "comparison_operator"
2972                          [(match_operand:DI 2 "reg_or_0_operand" "")
2973                           (match_operand:DI 3 "reg_or_cint_operand" "")])
2974          (label_ref (match_operand 0 "" ""))
2975          (pc)))
2976    (clobber (match_operand:DI 4 "register_operand" ""))]
2977   "operands[3] != const0_rtx"
2978   [(set (match_dup 4) (match_dup 5))
2979    (set (pc) (if_then_else (match_dup 6) (label_ref (match_dup 0)) (pc)))]
2980   "
2981 { enum rtx_code code = GET_CODE (operands[1]);
2982   int unsignedp = (code == GEU || code == LEU || code == GTU || code == LTU);
2983
2984   if (code == NE || code == EQ
2985       || (extended_count (operands[2], DImode, unsignedp) >= 1
2986           && extended_count (operands[3], DImode, unsignedp) >= 1))
2987     {
2988       if (GET_CODE (operands[3]) == CONST_INT)
2989         operands[5] = gen_rtx (PLUS, DImode, operands[2],
2990                                GEN_INT (- INTVAL (operands[3])));
2991       else
2992         operands[5] = gen_rtx (MINUS, DImode, operands[2], operands[3]);
2993
2994       operands[6] = gen_rtx (code, VOIDmode, operands[4], const0_rtx);
2995     }
2996
2997   else if (code == EQ || code == LE || code == LT
2998            || code == LEU || code == LTU)
2999     {
3000       operands[5] = gen_rtx (code, DImode, operands[2], operands[3]);
3001       operands[6] = gen_rtx (NE, VOIDmode, operands[4], const0_rtx);
3002     }
3003   else
3004     {
3005       operands[5] = gen_rtx (reverse_condition (code), DImode, operands[2],
3006                              operands[3]);
3007       operands[6] = gen_rtx (EQ, VOIDmode, operands[4], const0_rtx);
3008     }
3009 }")
3010
3011 (define_split
3012   [(set (pc)
3013         (if_then_else
3014          (match_operator 1 "comparison_operator"
3015                          [(match_operand:SI 2 "reg_or_0_operand" "")
3016                           (match_operand:SI 3 "const_int_operand" "")])
3017          (label_ref (match_operand 0 "" ""))
3018          (pc)))
3019    (clobber (match_operand:DI 4 "register_operand" ""))]
3020   "operands[3] != const0_rtx
3021    && (GET_CODE (operands[1]) == EQ || GET_CODE (operands[1]) == NE)"
3022   [(set (match_dup 4) (match_dup 5))
3023    (set (pc) (if_then_else (match_dup 6) (label_ref (match_dup 0)) (pc)))]
3024   "
3025 { rtx tem;
3026
3027   if (GET_CODE (operands[3]) == CONST_INT)
3028     tem = gen_rtx (PLUS, SImode, operands[2],
3029                    GEN_INT (- INTVAL (operands[3])));
3030   else
3031     tem = gen_rtx (MINUS, SImode, operands[2], operands[3]);
3032   
3033   operands[5] = gen_rtx (SIGN_EXTEND, DImode, tem);
3034   operands[6] = gen_rtx (GET_CODE (operands[1]), VOIDmode,
3035                          operands[4], const0_rtx);
3036 }")
3037
3038 ;; We can convert such things as "a > 0xffff" to "t = a & ~ 0xffff; t != 0".
3039 ;; This eliminates one, and sometimes two, insns when the AND can be done
3040 ;; with a ZAP.
3041 (define_split
3042   [(set (match_operand:DI 0 "register_operand" "")
3043         (match_operator 1 "comparison_operator"
3044                         [(match_operand:DI 2 "register_operand" "")
3045                          (match_operand:DI 3 "const_int_operand" "")]))
3046    (clobber (match_operand:DI 4 "register_operand" ""))]
3047   "exact_log2 (INTVAL (operands[3]) + 1) >= 0
3048    && (GET_CODE (operands[1]) == GTU
3049        || GET_CODE (operands[1]) == LEU
3050        || ((GET_CODE (operands[1]) == GT || GET_CODE (operands[1]) == LE)
3051            && extended_count (operands[2], DImode, 1) > 0))"
3052   [(set (match_dup 4) (and:DI (match_dup 2) (match_dup 5)))
3053    (set (match_dup 0) (match_dup 6))]
3054   "
3055 {
3056   operands[5] = GEN_INT (~ INTVAL (operands[3]));
3057   operands[6] = gen_rtx (((GET_CODE (operands[1]) == GTU
3058                            || GET_CODE (operands[1]) == GT)
3059                           ? NE : EQ),
3060                          DImode, operands[4], const0_rtx);
3061 }")
3062 \f
3063 ;; Here are the CALL and unconditional branch insns.  Calls on NT and OSF
3064 ;; work differently, so we have different patterns for each.
3065
3066 (define_expand "call"
3067   [(use (match_operand:DI 0 "" ""))
3068    (use (match_operand 1 "" ""))
3069    (use (match_operand 2 "" ""))
3070    (use (match_operand 3 "" ""))]
3071   ""
3072   "
3073 { if (TARGET_WINDOWS_NT)
3074     emit_call_insn (gen_call_nt (operands[0], operands[1]));
3075   else if (TARGET_OPEN_VMS)
3076     emit_call_insn (gen_call_vms (operands[0], operands[2]));
3077   else
3078     emit_call_insn (gen_call_osf (operands[0], operands[1]));
3079
3080   DONE;
3081 }")
3082
3083 (define_expand "call_osf"
3084   [(parallel [(call (mem:DI (match_operand 0 "" ""))
3085                     (match_operand 1 "" ""))
3086               (clobber (reg:DI 27))
3087               (clobber (reg:DI 26))])]
3088   ""
3089   "
3090 { if (GET_CODE (operands[0]) != MEM)
3091     abort ();
3092
3093   operands[0] = XEXP (operands[0], 0);
3094
3095   if (GET_CODE (operands[0]) != SYMBOL_REF
3096       && ! (GET_CODE (operands[0]) == REG && REGNO (operands[0]) == 27))
3097     {
3098       rtx tem = gen_rtx (REG, DImode, 27);
3099       emit_move_insn (tem, operands[0]);
3100       operands[0] = tem;
3101     }
3102 }")
3103
3104 (define_expand "call_nt"
3105   [(parallel [(call (mem:DI (match_operand:DI 0 "" ""))
3106                     (match_operand 1 "" ""))
3107               (clobber (reg:DI 26))])]
3108   ""
3109   "
3110 { if (GET_CODE (operands[0]) != MEM)
3111     abort ();
3112   operands[0] = XEXP (operands[0], 0);
3113
3114   if (GET_CODE (operands[1]) != SYMBOL_REF
3115       && ! (GET_CODE (operands[1]) == REG && REGNO (operands[1]) == 27))
3116     {
3117       rtx tem = gen_rtx (REG, DImode, 27);
3118       emit_move_insn (tem, operands[1]);
3119       operands[1] = tem;
3120     }
3121 }")
3122
3123 ;;
3124 ;; call openvms/alpha
3125 ;; op 0: symbol ref for called function
3126 ;; op 1: next_arg_reg (argument information value for R25)
3127 ;;
3128 (define_expand "call_vms"
3129   [(parallel [(call (mem:DI (match_operand 0 "" ""))
3130                     (match_operand 1 "" ""))
3131               (use (match_dup 2))
3132               (use (reg:DI 25))
3133               (use (reg:DI 26))
3134               (clobber (reg:DI 27))])]
3135   ""
3136   "
3137 { if (GET_CODE (operands[0]) != MEM)
3138     abort ();
3139
3140   operands[0] = XEXP (operands[0], 0);
3141
3142   /* Always load AI with argument information, then handle symbolic and
3143      indirect call differently.  Load RA and set operands[2] to PV in
3144      both cases.  */
3145
3146   emit_move_insn (gen_rtx (REG, DImode, 25), operands[1]);
3147   if (GET_CODE (operands[0]) == SYMBOL_REF)
3148     {
3149       extern char *savealloc ();
3150       char *symbol = XSTR (operands[0], 0);
3151       char *linksym = savealloc (strlen (symbol) + 5);
3152       rtx linkage;
3153
3154       alpha_need_linkage (symbol, 0);
3155
3156       strcpy (linksym, symbol);
3157       strcat (linksym, \"..lk\");
3158       linkage = gen_rtx (SYMBOL_REF, Pmode, linksym);
3159
3160       emit_move_insn (gen_rtx (REG, Pmode, 26), gen_rtx (MEM, Pmode, linkage));
3161
3162       operands[2]
3163         = validize_mem (gen_rtx (MEM, Pmode, plus_constant (linkage, 8)));
3164     }
3165   else
3166     {
3167       emit_move_insn (gen_rtx (REG, Pmode, 26),
3168                       gen_rtx (MEM, Pmode, plus_constant (operands[0], 8)));
3169
3170       operands[2] = operands[0];
3171     }
3172
3173 }")
3174
3175 (define_expand "call_value"
3176   [(use (match_operand 0 "" ""))
3177    (use (match_operand:DI 1 "" ""))
3178    (use (match_operand 2 "" ""))
3179    (use (match_operand 3 "" ""))
3180    (use (match_operand 4 "" ""))]
3181   ""
3182   "
3183 { if (TARGET_WINDOWS_NT)
3184     emit_call_insn (gen_call_value_nt (operands[0], operands[1], operands[2]));
3185   else if (TARGET_OPEN_VMS)
3186     emit_call_insn (gen_call_value_vms (operands[0], operands[1],
3187                                         operands[3]));
3188   else
3189     emit_call_insn (gen_call_value_osf (operands[0], operands[1],
3190                                         operands[2]));
3191   DONE;
3192 }")
3193
3194 (define_expand "call_value_osf"
3195   [(parallel [(set (match_operand 0 "" "")
3196                    (call (mem:DI (match_operand 1 "" ""))
3197                          (match_operand 2 "" "")))
3198               (clobber (reg:DI 27))
3199               (clobber (reg:DI 26))])]
3200   ""
3201   "
3202 { if (GET_CODE (operands[1]) != MEM)
3203     abort ();
3204
3205   operands[1] = XEXP (operands[1], 0);
3206
3207   if (GET_CODE (operands[1]) != SYMBOL_REF
3208       && ! (GET_CODE (operands[1]) == REG && REGNO (operands[1]) == 27))
3209     {
3210       rtx tem = gen_rtx (REG, DImode, 27);
3211       emit_move_insn (tem, operands[1]);
3212       operands[1] = tem;
3213     }
3214 }")
3215
3216 (define_expand "call_value_nt"
3217   [(parallel [(set (match_operand 0 "" "")
3218                    (call (mem:DI (match_operand:DI 1 "" ""))
3219                          (match_operand 2 "" "")))
3220               (clobber (reg:DI 26))])]
3221   ""
3222   "
3223 { if (GET_CODE (operands[1]) != MEM)
3224     abort ();
3225
3226   operands[1] = XEXP (operands[1], 0);
3227   if (GET_CODE (operands[1]) != SYMBOL_REF
3228       && ! (GET_CODE (operands[1]) == REG && REGNO (operands[1]) == 27))
3229     {
3230       rtx tem = gen_rtx (REG, DImode, 27);
3231       emit_move_insn (tem, operands[1]);
3232       operands[1] = tem;
3233     }
3234 }")
3235
3236 (define_expand "call_value_vms"
3237   [(parallel [(set (match_operand 0 "" "")
3238                    (call (mem:DI (match_operand:DI 1 "" ""))
3239                          (match_operand 2 "" "")))
3240               (use (match_dup 3))
3241               (use (reg:DI 25))
3242               (use (reg:DI 26))
3243               (clobber (reg:DI 27))])]
3244   ""
3245   "
3246 { if (GET_CODE (operands[1]) != MEM)
3247     abort ();
3248
3249   operands[1] = XEXP (operands[1], 0);
3250
3251   /* Always load AI with argument information, then handle symbolic and
3252      indirect call differently.  Load RA and set operands[3] to PV in
3253      both cases.  */
3254
3255   emit_move_insn (gen_rtx (REG, DImode, 25), operands[2]);
3256   if (GET_CODE (operands[1]) == SYMBOL_REF)
3257     {
3258       extern char *savealloc ();
3259       char *symbol = XSTR (operands[1], 0);
3260       char *linksym = savealloc (strlen (symbol) + 5);
3261       rtx linkage;
3262
3263       alpha_need_linkage (symbol, 0);
3264       strcpy (linksym, symbol);
3265       strcat (linksym, \"..lk\");
3266       linkage = gen_rtx (SYMBOL_REF, Pmode, linksym);
3267
3268       emit_move_insn (gen_rtx (REG, Pmode, 26), gen_rtx (MEM, Pmode, linkage));
3269
3270       operands[3]
3271         = validize_mem (gen_rtx (MEM, Pmode, plus_constant (linkage, 8)));
3272     }
3273   else
3274     {
3275       emit_move_insn (gen_rtx (REG, Pmode, 26),
3276                       gen_rtx (MEM, Pmode, plus_constant (operands[1], 8)));
3277
3278       operands[3] = operands[1];
3279     }
3280 }")
3281
3282 (define_insn ""
3283   [(call (mem:DI (match_operand:DI 0 "call_operand" "r,R,i"))
3284          (match_operand 1 "" ""))
3285    (clobber (reg:DI 27))
3286    (clobber (reg:DI 26))]
3287   "! TARGET_WINDOWS_NT && ! TARGET_OPEN_VMS"
3288   "@
3289    jsr $26,($27),0\;ldgp $29,0($26)
3290    bsr $26,%0..ng
3291    jsr $26,%0\;ldgp $29,0($26)"
3292   [(set_attr "type" "jsr")])
3293       
3294 (define_insn ""
3295   [(call (mem:DI (match_operand:DI 0 "call_operand" "r,i"))
3296          (match_operand 1 "" ""))
3297    (clobber (reg:DI 26))]
3298   "TARGET_WINDOWS_NT"
3299   "@
3300    jsr $26,(%0)
3301    bsr $26,%0"
3302   [(set_attr "type" "jsr")])
3303       
3304 (define_insn ""
3305   [(call (mem:DI (match_operand:DI 0 "call_operand" "r,i"))
3306          (match_operand 1 "" ""))
3307    (use (match_operand:DI 2 "general_operand" "r,m"))
3308    (use (reg:DI 25))
3309    (use (reg:DI 26))
3310    (clobber (reg:DI 27))]
3311   "TARGET_OPEN_VMS"
3312   "@
3313    bis %2,%2,$27\;jsr $26,0\;ldq $27,0($29)
3314    ldq $27,%2\;jsr $26,%0\;ldq $27,0($29)"
3315   [(set_attr "type" "jsr")])
3316
3317 (define_insn ""
3318   [(set (match_operand 0 "register_operand" "=rf,rf,rf")
3319         (call (mem:DI (match_operand:DI 1 "call_operand" "r,R,i"))
3320               (match_operand 2 "" "")))
3321    (clobber (reg:DI 27))
3322    (clobber (reg:DI 26))]
3323   "! TARGET_WINDOWS_NT && ! TARGET_OPEN_VMS"
3324   "@
3325    jsr $26,($27),0\;ldgp $29,0($26)
3326    bsr $26,%1..ng
3327    jsr $26,%1\;ldgp $29,0($26)"
3328   [(set_attr "type" "jsr")])
3329
3330 (define_insn ""
3331   [(set (match_operand 0 "register_operand" "=rf,rf")
3332         (call (mem:DI (match_operand:DI 1 "call_operand" "r,i"))
3333               (match_operand 2 "" "")))
3334    (clobber (reg:DI 26))]
3335   "TARGET_WINDOWS_NT"
3336   "@
3337    jsr $26,(%1)
3338    bsr $26,%1"
3339   [(set_attr "type" "jsr")])
3340
3341 (define_insn ""
3342   [(set (match_operand 0 "register_operand" "")
3343         (call (mem:DI (match_operand:DI 1 "call_operand" "r,i"))
3344               (match_operand 2 "" "")))
3345    (use (match_operand:DI 3 "general_operand" "r,m"))
3346    (use (reg:DI 25))
3347    (use (reg:DI 26))
3348    (clobber (reg:DI 27))]
3349   "TARGET_OPEN_VMS"
3350   "@
3351    bis %3,%3,$27\;jsr $26,0\;ldq $27,0($29)
3352    ldq $27,%3\;jsr $26,%1\;ldq $27,0($29)"
3353   [(set_attr "type" "jsr")])
3354
3355 ;; Call subroutine returning any type.
3356
3357 (define_expand "untyped_call"
3358   [(parallel [(call (match_operand 0 "" "")
3359                     (const_int 0))
3360               (match_operand 1 "" "")
3361               (match_operand 2 "" "")])]
3362   ""
3363   "
3364 {
3365   int i;
3366
3367   emit_call_insn (gen_call (operands[0], const0_rtx, NULL, const0_rtx));
3368
3369   for (i = 0; i < XVECLEN (operands[2], 0); i++)
3370     {
3371       rtx set = XVECEXP (operands[2], 0, i);
3372       emit_move_insn (SET_DEST (set), SET_SRC (set));
3373     }
3374
3375   /* The optimizer does not know that the call sets the function value
3376      registers we stored in the result block.  We avoid problems by
3377      claiming that all hard registers are used and clobbered at this
3378      point.  */
3379   emit_insn (gen_blockage ());
3380
3381   DONE;
3382 }")
3383
3384 ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
3385 ;; all of memory.  This blocks insns from being moved across this point.
3386
3387 (define_insn "blockage"
3388   [(unspec_volatile [(const_int 0)] 1)]
3389   ""
3390   "")
3391
3392 (define_insn "jump"
3393   [(set (pc)
3394         (label_ref (match_operand 0 "" "")))]
3395   ""
3396   "br $31,%l0"
3397   [(set_attr "type" "ibr")])
3398
3399 (define_insn "return"
3400   [(return)]
3401   "direct_return ()"
3402   "ret $31,($26),1"
3403   [(set_attr "type" "ibr")])
3404
3405 (define_insn "indirect_jump"
3406   [(set (pc) (match_operand:DI 0 "register_operand" "r"))]
3407   ""
3408   "jmp $31,(%0),0"
3409   [(set_attr "type" "ibr")])
3410
3411 (define_insn "nop"
3412   [(const_int 0)]
3413   ""
3414   "bis $31,$31,$31"
3415   [(set_attr "type" "ilog")])
3416
3417 (define_expand "tablejump"
3418   [(use (match_operand:SI 0 "register_operand" ""))
3419    (use (match_operand:SI 1 "" ""))]
3420   ""
3421   "
3422 {
3423   if (TARGET_WINDOWS_NT)
3424     emit_jump_insn (gen_tablejump_nt (operands[0], operands[1]));
3425   else if (TARGET_OPEN_VMS)
3426     emit_jump_insn (gen_tablejump_vms (operands[0], operands[1]));
3427   else
3428     emit_jump_insn (gen_tablejump_osf (operands[0], operands[1]));
3429
3430   DONE;
3431 }")
3432
3433 (define_expand "tablejump_osf"
3434   [(set (match_dup 3)
3435         (sign_extend:DI (match_operand:SI 0 "register_operand" "")))
3436    (parallel [(set (pc)
3437                    (plus:DI (match_dup 3)
3438                             (label_ref:DI (match_operand 1 "" ""))))
3439               (clobber (match_scratch:DI 2 "=r"))])]
3440   ""
3441   "
3442 { operands[3] = gen_reg_rtx (DImode); }")
3443
3444 (define_expand "tablejump_nt"
3445   [(set (match_dup 3)
3446         (sign_extend:DI (match_operand:SI 0 "register_operand" "")))
3447    (parallel [(set (pc)
3448                    (match_dup 3))
3449               (use (label_ref (match_operand 1 "" "")))])]
3450   ""
3451   "
3452 { operands[3] = gen_reg_rtx (DImode); }")
3453
3454 ;;
3455 ;; tablejump, openVMS way
3456 ;; op 0: offset
3457 ;; op 1: label preceding jump-table
3458 ;;
3459 (define_expand "tablejump_vms"
3460   [(set (match_dup 2)
3461       (match_operand:DI 0 "register_operand" ""))
3462         (set (pc)
3463         (plus:DI (match_dup 2)
3464                 (label_ref:DI (match_operand 1 "" ""))))]
3465   ""
3466   "
3467 { operands[2] = gen_reg_rtx (DImode); }")
3468
3469 (define_insn ""
3470   [(set (pc)
3471         (plus:DI (match_operand:DI 0 "register_operand" "r")
3472                  (label_ref:DI (match_operand 1 "" ""))))
3473    (clobber (match_scratch:DI 2 "=r"))]
3474   "! TARGET_WINDOWS_NT && ! TARGET_OPEN_VMS && next_active_insn (insn) != 0
3475    && GET_CODE (PATTERN (next_active_insn (insn))) == ADDR_DIFF_VEC
3476    && PREV_INSN (next_active_insn (insn)) == operands[1]"
3477   "*
3478 { rtx best_label = 0;
3479   rtx jump_table_insn = next_active_insn (operands[1]);
3480
3481   if (GET_CODE (jump_table_insn) == JUMP_INSN
3482       && GET_CODE (PATTERN (jump_table_insn)) == ADDR_DIFF_VEC)
3483     {
3484       rtx jump_table = PATTERN (jump_table_insn);
3485       int n_labels = XVECLEN (jump_table, 1);
3486       int best_count = -1;
3487       int i, j;
3488
3489       for (i = 0; i < n_labels; i++)
3490         {
3491           int count = 1;
3492
3493           for (j = i + 1; j < n_labels; j++)
3494             if (XEXP (XVECEXP (jump_table, 1, i), 0)
3495                 == XEXP (XVECEXP (jump_table, 1, j), 0))
3496               count++;
3497
3498           if (count > best_count)
3499             best_count = count, best_label = XVECEXP (jump_table, 1, i);
3500         }
3501     }
3502
3503   if (best_label)
3504     {
3505       operands[3] = best_label;
3506       return \"addq %0,$29,%2\;jmp $31,(%2),%3\";
3507     }
3508   else
3509     return \"addq %0,$29,%2\;jmp $31,(%2),0\";
3510 }"
3511   [(set_attr "type" "ibr")])
3512
3513 (define_insn ""
3514   [(set (pc)
3515         (match_operand:DI 0 "register_operand" "r"))
3516    (use (label_ref (match_operand 1 "" "")))]
3517   "TARGET_WINDOWS_NT && next_active_insn (insn) != 0
3518    && GET_CODE (PATTERN (next_active_insn (insn))) == ADDR_DIFF_VEC
3519    && PREV_INSN (next_active_insn (insn)) == operands[1]"
3520   "*
3521 { rtx best_label = 0;
3522   rtx jump_table_insn = next_active_insn (operands[1]);
3523
3524   if (GET_CODE (jump_table_insn) == JUMP_INSN
3525       && GET_CODE (PATTERN (jump_table_insn)) == ADDR_DIFF_VEC)
3526     {
3527       rtx jump_table = PATTERN (jump_table_insn);
3528       int n_labels = XVECLEN (jump_table, 1);
3529       int best_count = -1;
3530       int i, j;
3531
3532       for (i = 0; i < n_labels; i++)
3533         {
3534           int count = 1;
3535
3536           for (j = i + 1; j < n_labels; j++)
3537             if (XEXP (XVECEXP (jump_table, 1, i), 0)
3538                 == XEXP (XVECEXP (jump_table, 1, j), 0))
3539               count++;
3540
3541           if (count > best_count)
3542             best_count = count, best_label = XVECEXP (jump_table, 1, i);
3543         }
3544     }
3545
3546   if (best_label)
3547     {
3548       operands[2] = best_label;
3549       return \"jmp $31,(%0),%2\";
3550     }
3551   else
3552     return \"jmp $31,(%0),0\";
3553 }"
3554   [(set_attr "type" "ibr")])
3555
3556 ;;
3557 ;; op 0 is table offset
3558 ;; op 1 is table label
3559 ;;
3560
3561 (define_insn ""
3562   [(set (pc)
3563         (plus:DI (match_operand 0 "register_operand" "r")
3564                 (label_ref (match_operand 1 "" ""))))]
3565   "TARGET_OPEN_VMS"
3566   "jmp $31,(%0),0"
3567   [(set_attr "type" "ibr")])
3568
3569 ;; Cache flush.  Used by INITIALIZE_TRAMPOLINE.  0x86 is PAL_imb, but we don't
3570 ;; want to have to include pal.h in our .s file.
3571 ;;
3572 ;; Technically the type for call_pal is jsr, but we use that for determining
3573 ;; if we need a GP.  Use ibr instead since it has the same scheduling 
3574 ;; characteristics.
3575 (define_insn ""
3576   [(unspec_volatile [(const_int 0)] 0)]
3577   ""
3578   "call_pal 0x86"
3579   [(set_attr "type" "ibr")])
3580 \f
3581 ;; Finally, we have the basic data motion insns.  The byte and word insns
3582 ;; are done via define_expand.  Start with the floating-point insns, since
3583 ;; they are simpler.
3584
3585 (define_insn ""
3586   [(set (match_operand:SF 0 "nonimmediate_operand" "=r,r,m,f,f,f,m")
3587         (match_operand:SF 1 "input_operand" "rG,m,rG,f,G,m,fG"))]
3588   "register_operand (operands[0], SFmode)
3589    || reg_or_fp0_operand (operands[1], SFmode)"
3590   "@
3591    bis %r1,%r1,%0
3592    ldl %0,%1
3593    stl %r1,%0
3594    cpys %1,%1,%0
3595    cpys $f31,$f31,%0
3596    ld%, %0,%1
3597    st%, %R1,%0"
3598   [(set_attr "type" "ilog,ld,st,fcpys,fcpys,ld,st")])
3599
3600 (define_insn ""
3601   [(set (match_operand:DF 0 "nonimmediate_operand" "=r,r,m,f,f,f,m")
3602         (match_operand:DF 1 "input_operand" "rG,m,rG,f,G,m,fG"))]
3603   "register_operand (operands[0], DFmode)
3604    || reg_or_fp0_operand (operands[1], DFmode)"
3605   "@
3606    bis %r1,%r1,%0
3607    ldq %0,%1
3608    stq %r1,%0
3609    cpys %1,%1,%0
3610    cpys $f31,$f31,%0
3611    ld%- %0,%1
3612    st%- %R1,%0"
3613   [(set_attr "type" "ilog,ld,st,fcpys,fcpys,ld,st")])
3614
3615 (define_expand "movsf"
3616   [(set (match_operand:SF 0 "nonimmediate_operand" "")
3617         (match_operand:SF 1 "general_operand" ""))]
3618   ""
3619   "
3620 {
3621   if (GET_CODE (operands[0]) == MEM
3622       && ! reg_or_fp0_operand (operands[1], SFmode))
3623     operands[1] = force_reg (SFmode, operands[1]);
3624 }")
3625
3626 (define_expand "movdf"
3627   [(set (match_operand:DF 0 "nonimmediate_operand" "")
3628         (match_operand:DF 1 "general_operand" ""))]
3629   ""
3630   "
3631 {
3632   if (GET_CODE (operands[0]) == MEM
3633       && ! reg_or_fp0_operand (operands[1], DFmode))
3634     operands[1] = force_reg (DFmode, operands[1]);
3635 }")
3636
3637 (define_insn ""
3638   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,r,r,r,r,m,f,f,f,m")
3639         (match_operand:SI 1 "input_operand" "r,J,I,K,L,m,rJ,f,J,m,fG"))]
3640   "! TARGET_WINDOWS_NT && ! TARGET_OPEN_VMS
3641    && (register_operand (operands[0], SImode)
3642        || reg_or_0_operand (operands[1], SImode))"
3643   "@
3644    bis %1,%1,%0
3645    bis $31,$31,%0
3646    bis $31,%1,%0
3647    lda %0,%1
3648    ldah %0,%h1
3649    ldl %0,%1
3650    stl %r1,%0
3651    cpys %1,%1,%0
3652    cpys $f31,$f31,%0
3653    lds %0,%1
3654    sts %R1,%0"
3655   [(set_attr "type" "ilog,ilog,ilog,iadd,iadd,ld,st,fcpys,fcpys,ld,st")])
3656
3657 (define_insn ""
3658   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,r,r,r,r,r,m,f,f,f,m")
3659         (match_operand:SI 1 "input_operand" "r,J,I,K,L,s,m,rJ,f,J,m,fG"))]
3660   "(TARGET_WINDOWS_NT || TARGET_OPEN_VMS)
3661         && (register_operand (operands[0], SImode)
3662                          || reg_or_0_operand (operands[1], SImode))"
3663   "@
3664    bis %1,%1,%0
3665    bis $31,$31,%0
3666    bis $31,%1,%0
3667    lda %0,%1
3668    ldah %0,%h1
3669    lda %0,%1
3670    ldl %0,%1
3671    stl %r1,%0
3672    cpys %1,%1,%0
3673    cpys $f31,$f31,%0
3674    lds %0,%1
3675    sts %R1,%0"
3676   [(set_attr "type" "ilog,ilog,ilog,iadd,iadd,ldsym,ld,st,fcpys,fcpys,ld,st")])
3677
3678 (define_insn ""
3679   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,r,r,f,f")
3680         (match_operand:HI 1 "input_operand" "r,J,I,n,f,J"))]
3681   "! TARGET_BYTE_OPS
3682    && (register_operand (operands[0], HImode)
3683        || register_operand (operands[1], HImode))"
3684   "@
3685    bis %1,%1,%0
3686    bis $31,$31,%0
3687    bis $31,%1,%0
3688    lda %0,%L1
3689    cpys %1,%1,%0
3690    cpys $f31,$f31,%0"
3691   [(set_attr "type" "ilog,ilog,ilog,iadd,fcpys,fcpys")])
3692
3693 (define_insn ""
3694   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,r,r,r,m,f,f")
3695         (match_operand:HI 1 "input_operand" "r,J,I,n,m,rJ,f,J"))]
3696   "TARGET_BYTE_OPS
3697    && (register_operand (operands[0], HImode)
3698        || reg_or_0_operand (operands[1], HImode))"
3699   "@
3700    bis %1,%1,%0
3701    bis $31,$31,%0
3702    bis $31,%1,%0
3703    lda %0,%L1
3704    ldwu %0,%1
3705    stw %r1,%0
3706    cpys %1,%1,%0
3707    cpys $f31,$f31,%0"
3708   [(set_attr "type" "ilog,ilog,ilog,iadd,ld,st,fcpys,fcpys")])
3709
3710 (define_insn ""
3711   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,r,r,f,f")
3712         (match_operand:QI 1 "input_operand" "r,J,I,n,f,J"))]
3713   "! TARGET_BYTE_OPS
3714    && (register_operand (operands[0], QImode)
3715        || register_operand (operands[1], QImode))"
3716   "@
3717    bis %1,%1,%0
3718    bis $31,$31,%0
3719    bis $31,%1,%0
3720    lda %0,%L1
3721    cpys %1,%1,%0
3722    cpys $f31,$f31,%0"
3723   [(set_attr "type" "ilog,ilog,ilog,iadd,fcpys,fcpys")])
3724
3725 (define_insn ""
3726   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,r,r,r,m,f,f")
3727         (match_operand:QI 1 "input_operand" "r,J,I,n,m,rJ,f,J"))]
3728   "TARGET_BYTE_OPS
3729    && (register_operand (operands[0], QImode)
3730        || reg_or_0_operand (operands[1], QImode))"
3731   "@
3732    bis %1,%1,%0
3733    bis $31,$31,%0
3734    bis $31,%1,%0
3735    lda %0,%L1
3736    ldbu %0,%1
3737    stb %r1,%0
3738    cpys %1,%1,%0
3739    cpys $f31,$f31,%0"
3740   [(set_attr "type" "ilog,ilog,ilog,iadd,ld,st,fcpys,fcpys")])
3741
3742 ;; We do two major things here: handle mem->mem and construct long
3743 ;; constants.
3744
3745 (define_expand "movsi"
3746   [(set (match_operand:SI 0 "general_operand" "")
3747         (match_operand:SI 1 "general_operand" ""))]
3748   ""
3749   "
3750 {
3751   if (GET_CODE (operands[0]) == MEM
3752       && ! reg_or_0_operand (operands[1], SImode))
3753     operands[1] = force_reg (SImode, operands[1]);
3754
3755   if (! CONSTANT_P (operands[1]) || input_operand (operands[1], SImode))
3756     ;
3757   else if (GET_CODE (operands[1]) == CONST_INT)
3758     {
3759       operands[1]
3760         = alpha_emit_set_const (operands[0], SImode, INTVAL (operands[1]), 3);
3761       if (rtx_equal_p (operands[0], operands[1]))
3762         DONE;
3763     }
3764 }")
3765
3766 ;; Split a load of a large constant into the appropriate two-insn
3767 ;; sequence.
3768
3769 (define_split
3770   [(set (match_operand:SI 0 "register_operand" "")
3771         (match_operand:SI 1 "const_int_operand" ""))]
3772   "! add_operand (operands[1], SImode)"
3773   [(set (match_dup 0) (match_dup 2))
3774    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 3)))]
3775   "
3776 { rtx tem
3777     = alpha_emit_set_const (operands[0], SImode, INTVAL (operands[1]), 2);
3778
3779   if (tem == operands[0])
3780     DONE;
3781   else
3782     FAIL;
3783 }")
3784
3785 (define_insn ""
3786   [(set (match_operand:DI 0 "general_operand" "=r,r,r,r,r,r,r,m,f,f,f,Q")
3787         (match_operand:DI 1 "input_operand" "r,J,I,K,L,s,m,rJ,f,J,Q,fG"))]
3788   "register_operand (operands[0], DImode)
3789    || reg_or_0_operand (operands[1], DImode)"
3790   "@
3791    bis %1,%1,%0
3792    bis $31,$31,%0
3793    bis $31,%1,%0
3794    lda %0,%1
3795    ldah %0,%h1
3796    lda %0,%1
3797    ldq%A1 %0,%1
3798    stq%A0 %r1,%0
3799    cpys %1,%1,%0
3800    cpys $f31,$f31,%0
3801    ldt %0,%1
3802    stt %R1,%0"
3803   [(set_attr "type" "ilog,ilog,ilog,iadd,iadd,ldsym,ld,st,fcpys,fcpys,ld,st")])
3804
3805 ;; We do three major things here: handle mem->mem, put 64-bit constants in
3806 ;; memory, and construct long 32-bit constants.
3807
3808 (define_expand "movdi"
3809   [(set (match_operand:DI 0 "general_operand" "")
3810         (match_operand:DI 1 "general_operand" ""))]
3811   ""
3812   "
3813 {
3814   rtx tem;
3815
3816   if (GET_CODE (operands[0]) == MEM
3817       && ! reg_or_0_operand (operands[1], DImode))
3818     operands[1] = force_reg (DImode, operands[1]);
3819
3820   if (! CONSTANT_P (operands[1]) || input_operand (operands[1], DImode))
3821     ;
3822   else if (GET_CODE (operands[1]) == CONST_INT
3823            && (tem = alpha_emit_set_const (operands[0], DImode,
3824                                            INTVAL (operands[1]), 3)) != 0)
3825     {
3826       if (rtx_equal_p (tem, operands[0]))
3827         DONE;
3828       else
3829         operands[1] = tem;
3830     }
3831   else if (CONSTANT_P (operands[1]))
3832     {
3833       if (TARGET_BUILD_CONSTANTS)
3834         {
3835 #if HOST_BITS_PER_WIDE_INT == 64
3836           HOST_WIDE_INT i;
3837
3838           if (GET_CODE (operands[1]) == CONST_INT)
3839             i = INTVAL (operands[1]);
3840           else if (GET_CODE (operands[1]) == CONST_DOUBLE)
3841             i = CONST_DOUBLE_LOW (operands[1]);
3842           else
3843             abort();
3844           
3845           tem = alpha_emit_set_long_const (operands[0], i);
3846           if (rtx_equal_p (tem, operands[0]))
3847             DONE;
3848           else
3849             operands[1] = tem;
3850 #else
3851           abort();
3852 #endif
3853         }
3854       else
3855         {
3856           operands[1] = force_const_mem (DImode, operands[1]);
3857           if (reload_in_progress)
3858             {
3859               emit_move_insn (operands[0], XEXP (operands[1], 0));
3860               operands[1] = copy_rtx (operands[1]);
3861               XEXP (operands[1], 0) = operands[0];
3862             }
3863           else
3864             operands[1] = validize_mem (operands[1]);
3865         }
3866     }
3867   else
3868     abort ();
3869 }")
3870
3871 ;; Split a load of a large constant into the appropriate two-insn
3872 ;; sequence.
3873
3874 (define_split
3875   [(set (match_operand:DI 0 "register_operand" "")
3876         (match_operand:DI 1 "const_int_operand" ""))]
3877   "! add_operand (operands[1], DImode)"
3878   [(set (match_dup 0) (match_dup 2))
3879    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 3)))]
3880   "
3881 { rtx tem
3882     = alpha_emit_set_const (operands[0], DImode, INTVAL (operands[1]), 2);
3883
3884   if (tem == operands[0])
3885     DONE;
3886   else
3887     FAIL;
3888 }")
3889
3890 ;; These are the partial-word cases.
3891 ;;
3892 ;; First we have the code to load an aligned word.  Operand 0 is the register
3893 ;; in which to place the result.  It's mode is QImode or HImode.  Operand 1
3894 ;; is an SImode MEM at the low-order byte of the proper word.  Operand 2 is the
3895 ;; number of bits within the word that the value is.  Operand 3 is an SImode
3896 ;; scratch register.  If operand 0 is a hard register, operand 3 may be the
3897 ;; same register.  It is allowed to conflict with operand 1 as well.
3898
3899 (define_expand "aligned_loadqi"
3900   [(set (match_operand:SI 3 "register_operand" "")
3901         (match_operand:SI 1 "memory_operand" ""))
3902    (set (subreg:DI (match_operand:QI 0 "register_operand" "") 0)
3903         (zero_extract:DI (subreg:DI (match_dup 3) 0)
3904                          (const_int 8)
3905                          (match_operand:DI 2 "const_int_operand" "")))]
3906          
3907   ""
3908   "")
3909   
3910 (define_expand "aligned_loadhi"
3911   [(set (match_operand:SI 3 "register_operand" "")
3912         (match_operand:SI 1 "memory_operand" ""))
3913    (set (subreg:DI (match_operand:HI 0 "register_operand" "") 0)
3914         (zero_extract:DI (subreg:DI (match_dup 3) 0)
3915                          (const_int 16)
3916                          (match_operand:DI 2 "const_int_operand" "")))]
3917          
3918   ""
3919   "")
3920   
3921 ;; Similar for unaligned loads, where we use the sequence from the
3922 ;; Alpha Architecture manual.
3923 ;;
3924 ;; Operand 1 is the address.  Operands 2 and 3 are temporaries, where
3925 ;; operand 3 can overlap the input and output registers.
3926
3927 (define_expand "unaligned_loadqi"
3928   [(set (match_operand:DI 2 "register_operand" "")
3929         (mem:DI (and:DI (match_operand:DI 1 "address_operand" "")
3930                         (const_int -8))))
3931    (set (match_operand:DI 3 "register_operand" "")
3932         (match_dup 1))
3933    (set (subreg:DI (match_operand:QI 0 "register_operand" "") 0)
3934         (zero_extract:DI (match_dup 2)
3935                          (const_int 8)
3936                          (ashift:DI (match_dup 3) (const_int 3))))]
3937   ""
3938   "")
3939
3940 (define_expand "unaligned_loadhi"
3941   [(set (match_operand:DI 2 "register_operand" "")
3942         (mem:DI (and:DI (match_operand:DI 1 "address_operand" "")
3943                         (const_int -8))))
3944    (set (match_operand:DI 3 "register_operand" "")
3945         (match_dup 1))
3946    (set (subreg:DI (match_operand:QI 0 "register_operand" "") 0)
3947         (zero_extract:DI (match_dup 2)
3948                          (const_int 16)
3949                          (ashift:DI (match_dup 3) (const_int 3))))]
3950   ""
3951   "")
3952
3953 ;; Storing an aligned byte or word requires two temporaries.  Operand 0 is the
3954 ;; aligned SImode MEM.  Operand 1 is the register containing the 
3955 ;; byte or word to store.  Operand 2 is the number of bits within the word that
3956 ;; the value should be placed.  Operands 3 and 4 are SImode temporaries.
3957
3958 (define_expand "aligned_store"
3959   [(set (match_operand:SI 3 "register_operand" "")
3960         (match_operand:SI 0 "memory_operand" ""))
3961    (set (subreg:DI (match_dup 3) 0)
3962         (and:DI (subreg:DI (match_dup 3) 0) (match_dup 5)))
3963    (set (subreg:DI (match_operand:SI 4 "register_operand" "") 0)
3964         (ashift:DI (zero_extend:DI (match_operand 1 "register_operand" ""))
3965                    (match_operand:DI 2 "const_int_operand" "")))
<