OSDN Git Service

52f26aa84abe1114e153025f7133210c2fc088ae
[pf3gnuchains/gcc-fork.git] / gcc / config / ia64 / ia64.md
1 ;; IA-64 Machine description template
2 ;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 ;; Free Software Foundation, Inc.
4 ;; Contributed by James E. Wilson <wilson@cygnus.com> and
5 ;;                David Mosberger <davidm@hpl.hp.com>.
6
7 ;; This file is part of GCC.
8
9 ;; GCC is free software; you can redistribute it and/or modify
10 ;; it under the terms of the GNU General Public License as published by
11 ;; the Free Software Foundation; either version 3, or (at your option)
12 ;; any later version.
13
14 ;; GCC is distributed in the hope that it will be useful,
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 ;; GNU General Public License for more details.
18
19 ;; You should have received a copy of the GNU General Public License
20 ;; along with GCC; see the file COPYING3.  If not see
21 ;; <http://www.gnu.org/licenses/>.
22
23 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
24
25 ;; ??? register_operand accepts (subreg:DI (mem:SI X)) which forces later
26 ;; reload.  This will be fixed once scheduling support is turned on.
27
28 ;; ??? Optimize for post-increment addressing modes.
29
30 ;; ??? fselect is not supported, because there is no integer register
31 ;; equivalent.
32
33 ;; ??? fp abs/min/max instructions may also work for integer values.
34
35 ;; ??? Would a predicate_reg_operand predicate be useful?  The HP one is buggy,
36 ;; it assumes the operand is a register and takes REGNO of it without checking.
37
38 ;; ??? Would a branch_reg_operand predicate be useful?  The HP one is buggy,
39 ;; it assumes the operand is a register and takes REGNO of it without checking.
40
41 ;; ??? Go through list of documented named patterns and look for more to
42 ;; implement.
43
44 ;; ??? Go through instruction manual and look for more instructions that
45 ;; can be emitted.
46
47 ;; ??? Add function unit scheduling info for Itanium (TM) processor.
48
49 ;; ??? Need a better way to describe alternate fp status registers.
50
51 (define_constants
52   [; Relocations
53    (UNSPEC_LTOFF_DTPMOD         0)
54    (UNSPEC_LTOFF_DTPREL         1)
55    (UNSPEC_DTPREL               2)
56    (UNSPEC_LTOFF_TPREL          3)
57    (UNSPEC_TPREL                4)
58    (UNSPEC_DTPMOD               5)
59
60    (UNSPEC_LD_BASE              9)
61    (UNSPEC_GR_SPILL             10)
62    (UNSPEC_GR_RESTORE           11)
63    (UNSPEC_FR_SPILL             12)
64    (UNSPEC_FR_RESTORE           13)
65    (UNSPEC_FR_RECIP_APPROX      14)
66    (UNSPEC_PRED_REL_MUTEX       15)
67    (UNSPEC_GETF_EXP             16)
68    (UNSPEC_PIC_CALL             17)
69    (UNSPEC_MF                   18)
70    (UNSPEC_CMPXCHG_ACQ          19)
71    (UNSPEC_FETCHADD_ACQ         20)
72    (UNSPEC_BSP_VALUE            21)
73    (UNSPEC_FLUSHRS              22)
74    (UNSPEC_BUNDLE_SELECTOR      23)
75    (UNSPEC_ADDP4                24)
76    (UNSPEC_PROLOGUE_USE         25)
77    (UNSPEC_RET_ADDR             26)
78    (UNSPEC_SETF_EXP             27)
79    (UNSPEC_FR_SQRT_RECIP_APPROX 28)
80    (UNSPEC_SHRP                 29)
81    (UNSPEC_COPYSIGN             30)
82    (UNSPEC_VECT_EXTR            31)
83    (UNSPEC_LDA                  40)
84    (UNSPEC_LDS                  41)
85    (UNSPEC_LDSA                 42)
86    (UNSPEC_LDCCLR               43)
87    (UNSPEC_CHKACLR              45)
88    (UNSPEC_CHKS                 47)     
89   ])
90
91 (define_constants
92   [(UNSPECV_ALLOC               0)
93    (UNSPECV_BLOCKAGE            1)
94    (UNSPECV_INSN_GROUP_BARRIER  2)
95    (UNSPECV_BREAK               3)
96    (UNSPECV_SET_BSP             4)
97    (UNSPECV_PSAC_ALL            5)      ; pred.safe_across_calls
98    (UNSPECV_PSAC_NORMAL         6)
99    (UNSPECV_SETJMP_RECEIVER     7)
100   ])
101
102 (include "predicates.md")
103 (include "constraints.md")
104 \f
105 ;; ::::::::::::::::::::
106 ;; ::
107 ;; :: Attributes
108 ;; ::
109 ;; ::::::::::::::::::::
110
111 ;; Processor type.  This attribute must exactly match the processor_type
112 ;; enumeration in ia64.h.
113 (define_attr "cpu" "itanium,itanium2" (const (symbol_ref "ia64_tune")))
114
115 ;; Instruction type.  This primarily determines how instructions can be
116 ;; packed in bundles, and secondarily affects scheduling to function units.
117
118 ;; A alu, can go in I or M syllable of a bundle
119 ;; I integer
120 ;; M memory
121 ;; F floating-point
122 ;; B branch
123 ;; L long immediate, takes two syllables
124 ;; S stop bit
125
126 ;; ??? Should not have any pattern with type unknown.  Perhaps add code to
127 ;; check this in md_reorg?  Currently use unknown for patterns which emit
128 ;; multiple instructions, patterns which emit 0 instructions, and patterns
129 ;; which emit instruction that can go in any slot (e.g. nop).
130
131 (define_attr "itanium_class" "unknown,ignore,stop_bit,br,fcmp,fcvtfx,fld,
132         fldp,fmac,fmisc,frar_i,frar_m,frbr,frfr,frpr,ialu,icmp,ilog,ishf,
133         ld,chk_s_i,chk_s_f,chk_a,long_i,mmalua,mmmul,mmshf,mmshfi,rse_m,scall,sem,stf,
134         st,syst_m0, syst_m,tbit,toar_i,toar_m,tobr,tofr,topr,xmpy,xtd,nop,
135         nop_b,nop_f,nop_i,nop_m,nop_x,lfetch,pre_cycle"
136   (const_string "unknown"))
137
138 ;; chk_s_i has an I and an M form; use type A for convenience.
139 (define_attr "type" "unknown,A,I,M,F,B,L,X,S"
140   (cond [(eq_attr "itanium_class" "ld,st,fld,fldp,stf,sem,nop_m") (const_string "M")
141          (eq_attr "itanium_class" "rse_m,syst_m,syst_m0") (const_string "M")
142          (eq_attr "itanium_class" "frar_m,toar_m,frfr,tofr") (const_string "M")
143          (eq_attr "itanium_class" "lfetch") (const_string "M")
144          (eq_attr "itanium_class" "chk_s_f,chk_a") (const_string "M")
145          (eq_attr "itanium_class" "chk_s_i,ialu,icmp,ilog,mmalua")
146            (const_string "A")
147          (eq_attr "itanium_class" "fmisc,fmac,fcmp,xmpy") (const_string "F")
148          (eq_attr "itanium_class" "fcvtfx,nop_f") (const_string "F")
149          (eq_attr "itanium_class" "frar_i,toar_i,frbr,tobr") (const_string "I")
150          (eq_attr "itanium_class" "frpr,topr,ishf,xtd,tbit") (const_string "I")
151          (eq_attr "itanium_class" "mmmul,mmshf,mmshfi,nop_i") (const_string "I")
152          (eq_attr "itanium_class" "br,scall,nop_b") (const_string "B")
153          (eq_attr "itanium_class" "stop_bit") (const_string "S")
154          (eq_attr "itanium_class" "nop_x") (const_string "X")
155          (eq_attr "itanium_class" "long_i") (const_string "L")]
156         (const_string "unknown")))
157
158 (define_attr "itanium_requires_unit0" "no,yes"
159   (cond [(eq_attr "itanium_class" "syst_m0,sem,frfr,rse_m") (const_string "yes")
160          (eq_attr "itanium_class" "toar_m,frar_m") (const_string "yes")
161          (eq_attr "itanium_class" "frbr,tobr,mmmul") (const_string "yes")
162          (eq_attr "itanium_class" "tbit,ishf,topr,frpr") (const_string "yes")
163          (eq_attr "itanium_class" "toar_i,frar_i") (const_string "yes")
164          (eq_attr "itanium_class" "fmisc,fcmp") (const_string "yes")]
165         (const_string "no")))
166
167 ;; Predication.  True iff this instruction can be predicated.
168
169 (define_attr "predicable" "no,yes" (const_string "yes"))
170
171 ;; Empty.  True iff this insn does not generate any code.
172
173 (define_attr "empty" "no,yes" (const_string "no"))
174
175 ;; True iff this insn must be the first insn of an instruction group.
176 ;; This is true for the alloc instruction, and will also be true of others
177 ;; when we have full intrinsics support.
178
179 (define_attr "first_insn" "no,yes" (const_string "no"))
180
181 (define_attr "data_speculative" "no,yes" (const_string "no"))
182
183 (define_attr "control_speculative" "no,yes" (const_string "no"))
184
185 (define_attr "check_load" "no,yes" (const_string "no"))
186 \f
187 ;; DFA descriptions of ia64 processors used for insn scheduling and
188 ;; bundling.
189
190 (automata_option "ndfa")
191
192 ;; Uncomment the following line to output automata for debugging.
193 ;; (automata_option "v")
194
195 (automata_option "w")
196
197 (include "itanium1.md")
198 (include "itanium2.md")
199
200 \f
201 ;; ::::::::::::::::::::
202 ;; ::
203 ;; :: Moves
204 ;; ::
205 ;; ::::::::::::::::::::
206
207 ;; Set of a single predicate register.  This is only used to implement
208 ;; pr-to-pr move and complement.
209
210 (define_insn "*movcci"
211   [(set (match_operand:CCI 0 "register_operand" "=c,c,c")
212         (match_operand:CCI 1 "nonmemory_operand" "O,n,c"))]
213   ""
214   "@
215    cmp.ne %0, p0 = r0, r0
216    cmp.eq %0, p0 = r0, r0
217    (%1) cmp.eq.unc %0, p0 = r0, r0"
218   [(set_attr "itanium_class" "icmp")
219    (set_attr "predicable" "no")])
220
221 (define_insn "movbi"
222   [(set (match_operand:BI 0 "destination_operand" "=c,c,?c,?*r, c,*r,*r,*m,*r")
223         (match_operand:BI 1 "move_operand"        " O,n, c,  c,*r, n,*m,*r,*r"))]
224   ""
225   "@
226    cmp.ne %0, %I0 = r0, r0
227    cmp.eq %0, %I0 = r0, r0
228    #
229    #
230    tbit.nz %0, %I0 = %1, 0
231    adds %0 = %1, r0
232    ld1%O1 %0 = %1%P1
233    st1%Q0 %0 = %1%P0
234    mov %0 = %1"
235   [(set_attr "itanium_class" "icmp,icmp,unknown,unknown,tbit,ialu,ld,st,ialu")])
236
237 (define_split
238   [(set (match_operand:BI 0 "register_operand" "")
239         (match_operand:BI 1 "register_operand" ""))]
240   "reload_completed
241    && GET_CODE (operands[0]) == REG && GR_REGNO_P (REGNO (operands[0]))
242    && GET_CODE (operands[1]) == REG && PR_REGNO_P (REGNO (operands[1]))"
243   [(cond_exec (ne (match_dup 1) (const_int 0))
244      (set (match_dup 0) (const_int 1)))
245    (cond_exec (eq (match_dup 1) (const_int 0))
246      (set (match_dup 0) (const_int 0)))]
247   "")
248
249 (define_split
250   [(set (match_operand:BI 0 "register_operand" "")
251         (match_operand:BI 1 "register_operand" ""))]
252   "reload_completed
253    && GET_CODE (operands[0]) == REG && PR_REGNO_P (REGNO (operands[0]))
254    && GET_CODE (operands[1]) == REG && PR_REGNO_P (REGNO (operands[1]))"
255   [(set (match_dup 2) (match_dup 4))
256    (set (match_dup 3) (match_dup 5))
257    (set (match_dup 0) (unspec:BI [(match_dup 0)] UNSPEC_PRED_REL_MUTEX))]
258   "operands[2] = gen_rtx_REG (CCImode, REGNO (operands[0]));
259    operands[3] = gen_rtx_REG (CCImode, REGNO (operands[0]) + 1);
260    operands[4] = gen_rtx_REG (CCImode, REGNO (operands[1]));
261    operands[5] = gen_rtx_REG (CCImode, REGNO (operands[1]) + 1);")
262
263 (define_expand "movqi"
264   [(set (match_operand:QI 0 "general_operand" "")
265         (match_operand:QI 1 "general_operand" ""))]
266   ""
267 {
268   rtx op1 = ia64_expand_move (operands[0], operands[1]);
269   if (!op1)
270     DONE;
271   operands[1] = op1;
272 })
273
274 (define_insn "*movqi_internal"
275   [(set (match_operand:QI 0 "destination_operand" "=r,r,r, m, r,*f,*f")
276         (match_operand:QI 1 "move_operand"        "rO,J,m,rO,*f,rO,*f"))]
277   "ia64_move_ok (operands[0], operands[1])"
278   "@
279    mov %0 = %r1
280    addl %0 = %1, r0
281    ld1%O1 %0 = %1%P1
282    st1%Q0 %0 = %r1%P0
283    getf.sig %0 = %1
284    setf.sig %0 = %r1
285    mov %0 = %1"
286   [(set_attr "itanium_class" "ialu,ialu,ld,st,frfr,tofr,fmisc")])
287
288 (define_expand "movhi"
289   [(set (match_operand:HI 0 "general_operand" "")
290         (match_operand:HI 1 "general_operand" ""))]
291   ""
292 {
293   rtx op1 = ia64_expand_move (operands[0], operands[1]);
294   if (!op1)
295     DONE;
296   operands[1] = op1;
297 })
298
299 (define_insn "*movhi_internal"
300   [(set (match_operand:HI 0 "destination_operand" "=r,r,r, m, r,*f,*f")
301         (match_operand:HI 1 "move_operand"        "rO,J,m,rO,*f,rO,*f"))]
302   "ia64_move_ok (operands[0], operands[1])"
303   "@
304    mov %0 = %r1
305    addl %0 = %1, r0
306    ld2%O1 %0 = %1%P1
307    st2%Q0 %0 = %r1%P0
308    getf.sig %0 = %1
309    setf.sig %0 = %r1
310    mov %0 = %1"
311   [(set_attr "itanium_class" "ialu,ialu,ld,st,frfr,tofr,fmisc")])
312
313 (define_expand "movsi"
314   [(set (match_operand:SI 0 "general_operand" "")
315         (match_operand:SI 1 "general_operand" ""))]
316   ""
317 {
318   rtx op1 = ia64_expand_move (operands[0], operands[1]);
319   if (!op1)
320     DONE;
321   operands[1] = op1;
322 })
323
324 (define_insn "*movsi_internal"
325   [(set (match_operand:SI 0 "destination_operand" "=r,r,r,r, m, r,*f,*f, r,*d")
326         (match_operand:SI 1 "move_operand"        "rO,J,i,m,rO,*f,rO,*f,*d,rK"))]
327   "ia64_move_ok (operands[0], operands[1])"
328   "@
329   mov %0 = %r1
330   addl %0 = %1, r0
331   movl %0 = %1
332   ld4%O1 %0 = %1%P1
333   st4%Q0 %0 = %r1%P0
334   getf.sig %0 = %1
335   setf.sig %0 = %r1
336   mov %0 = %1
337   mov %0 = %1
338   mov %0 = %r1"
339   ;; frar_m, toar_m ??? why not frar_i and toar_i
340   [(set_attr "itanium_class" "ialu,ialu,long_i,ld,st,frfr,tofr,fmisc,frar_m,toar_m")])
341
342 (define_expand "movdi"
343   [(set (match_operand:DI 0 "general_operand" "")
344         (match_operand:DI 1 "general_operand" ""))]
345   ""
346 {
347   rtx op1 = ia64_expand_move (operands[0], operands[1]);
348   if (!op1)
349     DONE;
350   operands[1] = op1;
351 })
352
353 (define_insn "*movdi_internal"
354   [(set (match_operand:DI 0 "destination_operand"
355                     "=r,r,r,r, m, r,*f,*f,*f, Q, r,*b, r,*e, r,*d, r,*c")
356         (match_operand:DI 1 "move_operand"
357                     "rO,JT,i,m,rO,*f,rO,*f, Q,*f,*b,rO,*e,rK,*d,rK,*c,rO"))]
358   "ia64_move_ok (operands[0], operands[1])"
359 {
360   static const char * const alt[] = {
361     "%,mov %0 = %r1",
362     "%,addl %0 = %1, r0",
363     "%,movl %0 = %1",
364     "%,ld8%O1 %0 = %1%P1",
365     "%,st8%Q0 %0 = %r1%P0",
366     "%,getf.sig %0 = %1",
367     "%,setf.sig %0 = %r1",
368     "%,mov %0 = %1",
369     "%,ldf8 %0 = %1%P1",
370     "%,stf8 %0 = %1%P0",
371     "%,mov %0 = %1",
372     "%,mov %0 = %r1",
373     "%,mov %0 = %1",
374     "%,mov %0 = %1",
375     "%,mov %0 = %1",
376     "%,mov %0 = %1",
377     "mov %0 = pr",
378     "mov pr = %1, -1"
379   };
380
381   gcc_assert (which_alternative != 2 || TARGET_NO_PIC
382               || !symbolic_operand (operands[1], VOIDmode));
383
384   return alt[which_alternative];
385 }
386   [(set_attr "itanium_class" "ialu,ialu,long_i,ld,st,frfr,tofr,fmisc,fld,stf,frbr,tobr,frar_i,toar_i,frar_m,toar_m,frpr,topr")])
387
388 (define_mode_iterator MODE [BI QI HI SI DI SF DF XF TI])
389 (define_mode_iterator MODE_FOR_EXTEND [QI HI SI])
390
391 (define_mode_attr output_a [
392   (BI "ld1.a %0 = %1%P1")
393   (QI "ld1.a %0 = %1%P1")
394   (HI "ld2.a %0 = %1%P1")
395   (SI "ld4.a %0 = %1%P1")
396   (DI
397    "@
398     ld8.a %0 = %1%P1
399     ldf8.a %0 = %1%P1")
400   (SF
401    "@
402     ldfs.a %0 = %1%P1
403     ld4.a %0 = %1%P1")
404   (DF
405    "@
406     ldfd.a %0 = %1%P1
407     ld8.a %0 = %1%P1")
408   (XF "ldfe.a %0 = %1%P1")
409   (TI "ldfp8.a %X0 = %1%P1")])
410
411 (define_mode_attr output_s [
412   (BI "ld1.s %0 = %1%P1")
413   (QI "ld1.s %0 = %1%P1")
414   (HI "ld2.s %0 = %1%P1")
415   (SI "ld4.s %0 = %1%P1")
416   (DI
417    "@
418     ld8.s %0 = %1%P1
419     ldf8.s %0 = %1%P1")
420   (SF
421    "@
422     ldfs.s %0 = %1%P1
423     ld4.s %0 = %1%P1")
424   (DF
425    "@
426     ldfd.s %0 = %1%P1
427     ld8.s %0 = %1%P1")
428   (XF "ldfe.s %0 = %1%P1")
429   (TI "ldfp8.s %X0 = %1%P1")])
430
431 (define_mode_attr output_sa [
432   (BI "ld1.sa %0 = %1%P1")
433   (QI "ld1.sa %0 = %1%P1")
434   (HI "ld2.sa %0 = %1%P1")
435   (SI "ld4.sa %0 = %1%P1")
436   (DI
437    "@
438     ld8.sa %0 = %1%P1
439     ldf8.sa %0 = %1%P1")
440   (SF
441    "@
442     ldfs.sa %0 = %1%P1
443     ld4.sa %0 = %1%P1")
444   (DF
445    "@
446     ldfd.sa %0 = %1%P1
447     ld8.sa %0 = %1%P1")
448   (XF "ldfe.sa %0 = %1%P1")
449   (TI "ldfp8.sa %X0 = %1%P1")])
450
451 (define_mode_attr output_c_clr [
452   (BI "ld1.c.clr%O1 %0 = %1%P1")
453   (QI "ld1.c.clr%O1 %0 = %1%P1")
454   (HI "ld2.c.clr%O1 %0 = %1%P1")
455   (SI "ld4.c.clr%O1 %0 = %1%P1")
456   (DI
457    "@
458     ld8.c.clr%O1 %0 = %1%P1
459     ldf8.c.clr %0 = %1%P1")
460   (SF
461    "@
462     ldfs.c.clr %0 = %1%P1
463     ld4.c.clr%O1 %0 = %1%P1")
464   (DF
465    "@
466     ldfd.c.clr %0 = %1%P1
467     ld8.c.clr%O1 %0 = %1%P1")
468   (XF "ldfe.c.clr %0 = %1%P1")
469   (TI "ldfp8.c.clr %X0 = %1%P1")])
470
471 (define_mode_attr ld_reg_constr [(BI "=*r") (QI "=r") (HI "=r") (SI "=r") (DI "=r,*f") (SF "=f,*r") (DF "=f,*r") (XF "=f") (TI "=*x")])
472 (define_mode_attr ldc_reg_constr [(BI "+*r") (QI "+r") (HI "+r") (SI "+r") (DI "+r,*f") (SF "+f,*r") (DF "+f,*r") (XF "+f") (TI "+*x")])
473 (define_mode_attr chk_reg_constr [(BI "*r") (QI "r") (HI "r") (SI "r") (DI "r,*f") (SF "f,*r") (DF "f,*r") (XF "f") (TI "*x")])
474
475 (define_mode_attr mem_constr [(BI "*m") (QI "m") (HI "m") (SI "m") (DI "m,Q") (SF "Q,m") (DF "Q,m") (XF "m") (TI "Q")])
476
477 ;; Define register predicate prefix.
478 ;; We can generate speculative loads only for general and fp registers - this
479 ;; is constrained in ia64.c: ia64_speculate_insn ().
480 (define_mode_attr reg_pred_prefix [(BI "gr") (QI "gr") (HI "gr") (SI "gr") (DI "grfr") (SF "grfr") (DF "grfr") (XF "fr") (TI "fr")])
481
482 (define_mode_attr ld_class [(BI "ld") (QI "ld") (HI "ld") (SI "ld") (DI "ld,fld") (SF "fld,ld") (DF "fld,ld") (XF "fld") (TI "fldp")])
483 (define_mode_attr chka_class [(BI "chk_a") (QI "chk_a") (HI "chk_a") (SI "chk_a") (DI "chk_a,chk_a") (SF "chk_a,chk_a") (DF "chk_a,chk_a") (XF "chk_a") (TI "chk_a")])
484 (define_mode_attr chks_class [(BI "chk_s_i") (QI "chk_s_i") (HI "chk_s_i") (SI "chk_s_i") (DI "chk_s_i,chk_s_f") (SF "chk_s_f,chk_s_i") (DF "chk_s_f,chk_s_i") (XF "chk_s_f") (TI "chk_s_i")])
485
486 (define_mode_attr attr_yes [(BI "yes") (QI "yes") (HI "yes") (SI "yes") (DI "yes,yes") (SF "yes,yes") (DF "yes,yes") (XF "yes") (TI "yes")])
487
488 (define_insn "mov<mode>_advanced"
489   [(set (match_operand:MODE 0 "<reg_pred_prefix>_register_operand" "<ld_reg_constr>")
490         (unspec:MODE [(match_operand:MODE 1 "memory_operand" "<mem_constr>")] UNSPEC_LDA))]
491   "ia64_move_ok (operands[0], operands[1])"
492   "<output_a>"
493   [(set_attr "itanium_class" "<ld_class>")
494    (set_attr "data_speculative" "<attr_yes>")])
495
496 (define_insn "zero_extend<mode>di2_advanced"
497   [(set (match_operand:DI 0 "gr_register_operand" "=r")
498         (zero_extend:DI (unspec:MODE_FOR_EXTEND [(match_operand:MODE_FOR_EXTEND 1 "memory_operand" "<mem_constr>")] UNSPEC_LDA)))]
499   ""
500   "<output_a>"
501   [(set_attr "itanium_class" "<ld_class>")
502    (set_attr "data_speculative" "<attr_yes>")])
503
504 (define_insn "mov<mode>_speculative"
505   [(set (match_operand:MODE 0 "<reg_pred_prefix>_register_operand" "<ld_reg_constr>")
506         (unspec:MODE [(match_operand:MODE 1 "memory_operand" "<mem_constr>")] UNSPEC_LDS))]
507   "ia64_move_ok (operands[0], operands[1])"
508   "<output_s>"
509   [(set_attr "itanium_class" "<ld_class>")
510    (set_attr "control_speculative" "<attr_yes>")])
511
512 (define_insn "zero_extend<mode>di2_speculative"
513   [(set (match_operand:DI 0 "gr_register_operand" "=r")
514         (zero_extend:DI (unspec:MODE_FOR_EXTEND [(match_operand:MODE_FOR_EXTEND 1 "memory_operand" "<mem_constr>")] UNSPEC_LDS)))]
515   ""
516   "<output_s>"
517   [(set_attr "itanium_class" "<ld_class>")
518    (set_attr "control_speculative" "<attr_yes>")])
519
520 (define_insn "mov<mode>_speculative_advanced"
521   [(set (match_operand:MODE 0 "<reg_pred_prefix>_register_operand" "<ld_reg_constr>")
522         (unspec:MODE [(match_operand:MODE 1 "memory_operand" "<mem_constr>")] UNSPEC_LDSA))]
523   "ia64_move_ok (operands[0], operands[1])"
524   "<output_sa>"
525   [(set_attr "itanium_class" "<ld_class>")
526    (set_attr "data_speculative" "<attr_yes>")
527    (set_attr "control_speculative" "<attr_yes>")])
528
529 (define_insn "zero_extend<mode>di2_speculative_advanced"
530   [(set (match_operand:DI 0 "gr_register_operand" "=r")
531         (zero_extend:DI (unspec:MODE_FOR_EXTEND [(match_operand:MODE_FOR_EXTEND 1 "memory_operand" "<mem_constr>")] UNSPEC_LDSA)))]
532   ""
533   "<output_sa>"
534   [(set_attr "itanium_class" "<ld_class>")
535    (set_attr "data_speculative" "<attr_yes>")
536    (set_attr "control_speculative" "<attr_yes>")])
537
538 (define_insn "mov<mode>_clr"
539   [(set (match_operand:MODE 0 "<reg_pred_prefix>_register_operand" "<ldc_reg_constr>")
540         (if_then_else:MODE (ne (unspec [(match_dup 0)] UNSPEC_LDCCLR) (const_int 0))
541                            (match_operand:MODE 1 "memory_operand" "<mem_constr>")
542                            (match_dup 0)))]
543   "ia64_move_ok (operands[0], operands[1])"
544   "<output_c_clr>"
545   [(set_attr "itanium_class" "<ld_class>")
546    (set_attr "check_load" "<attr_yes>")])
547
548 (define_insn "zero_extend<mode>di2_clr"
549   [(set (match_operand:DI 0 "gr_register_operand" "+r")
550         (if_then_else:DI (ne (unspec [(match_dup 0)] UNSPEC_LDCCLR) (const_int 0))
551                          (zero_extend:DI (match_operand:MODE_FOR_EXTEND 1 "memory_operand" "<mem_constr>"))
552                          (match_dup 0)))]
553   ""
554   "<output_c_clr>"
555   [(set_attr "itanium_class" "<ld_class>")
556    (set_attr "check_load" "<attr_yes>")])
557
558 (define_insn "advanced_load_check_clr_<mode>"
559   [(set (pc)
560         (if_then_else (ne (unspec [(match_operand:MODE 0 "<reg_pred_prefix>_register_operand" "<chk_reg_constr>")] UNSPEC_CHKACLR) (const_int 0))
561                       (pc)
562                       (label_ref (match_operand 1 "" ""))))]
563   ""
564   "chk.a.clr %0, %l1"
565   [(set_attr "itanium_class" "<chka_class>")])
566
567 (define_insn "speculation_check_<mode>"
568   [(set (pc) 
569         (if_then_else (ne (unspec [(match_operand:MODE 0 "<reg_pred_prefix>_register_operand" "<chk_reg_constr>")] UNSPEC_CHKS) (const_int 0))
570                       (pc)
571                       (label_ref (match_operand 1 "" ""))))]
572   ""
573   "chk.s %0, %l1"
574   [(set_attr "itanium_class" "<chks_class>")])
575
576 (define_split
577   [(set (match_operand 0 "register_operand" "")
578         (match_operand 1 "symbolic_operand" ""))]
579   "reload_completed"
580   [(const_int 0)]
581 {
582   if (ia64_expand_load_address (operands[0], operands[1]))
583     DONE;
584   else
585     FAIL;
586 })
587
588 (define_expand "load_fptr"
589   [(set (match_operand:DI 0 "register_operand" "")
590         (plus:DI (match_dup 2) (match_operand 1 "function_operand" "")))
591    (set (match_dup 0) (match_dup 3))]
592   "reload_completed"
593 {
594   operands[2] = pic_offset_table_rtx;
595   operands[3] = gen_const_mem (DImode, operands[0]);
596 })
597
598 (define_insn "*load_fptr_internal1"
599   [(set (match_operand:DI 0 "register_operand" "=r")
600         (plus:DI (reg:DI 1) (match_operand 1 "function_operand" "s")))]
601   "reload_completed"
602   "addl %0 = @ltoff(@fptr(%1)), gp"
603   [(set_attr "itanium_class" "ialu")])
604
605 (define_insn "load_gprel"
606   [(set (match_operand:DI 0 "register_operand" "=r")
607         (plus:DI (reg:DI 1) (match_operand 1 "sdata_symbolic_operand" "s")))]
608   "reload_completed"
609   "addl %0 = @gprel(%1), gp"
610   [(set_attr "itanium_class" "ialu")])
611
612 (define_insn "*gprel64_offset"
613   [(set (match_operand:DI 0 "register_operand" "=r")
614         (minus:DI (match_operand:DI 1 "symbolic_operand" "") (reg:DI 1)))]
615   "reload_completed"
616   "movl %0 = @gprel(%1)"
617   [(set_attr "itanium_class" "long_i")])
618
619 (define_expand "load_gprel64"
620   [(set (match_operand:DI 0 "register_operand" "")
621         (minus:DI (match_operand:DI 1 "symbolic_operand" "") (match_dup 2)))
622    (set (match_dup 0)
623         (plus:DI (match_dup 2) (match_dup 0)))]
624   "reload_completed"
625 {
626   operands[2] = pic_offset_table_rtx;
627 })
628
629 ;; This is used as a placeholder for the return address during early
630 ;; compilation.  We won't know where we've placed this until during
631 ;; reload, at which point it can wind up in b0, a general register,
632 ;; or memory.  The only safe destination under these conditions is a
633 ;; general register.
634
635 (define_insn_and_split "*movdi_ret_addr"
636   [(set (match_operand:DI 0 "register_operand" "=r")
637         (unspec:DI [(const_int 0)] UNSPEC_RET_ADDR))]
638   ""
639   "#"
640   "reload_completed"
641   [(const_int 0)]
642 {
643   ia64_split_return_addr_rtx (operands[0]);
644   DONE;
645 }
646   [(set_attr "itanium_class" "ialu")])
647
648 (define_insn "*load_symptr_high"
649   [(set (match_operand:DI 0 "register_operand" "=r")
650         (plus:DI (high:DI (match_operand 1 "got_symbolic_operand" "s"))
651                  (match_operand:DI 2 "register_operand" "a")))]
652   "reload_completed"
653 {
654   if (HAVE_AS_LTOFFX_LDXMOV_RELOCS)
655     return "%,addl %0 = @ltoffx(%1), %2";
656   else
657     return "%,addl %0 = @ltoff(%1), %2";
658 }
659   [(set_attr "itanium_class" "ialu")])
660
661 (define_insn "*load_symptr_low"
662   [(set (match_operand:DI 0 "register_operand" "=r")
663         (lo_sum:DI (match_operand:DI 1 "register_operand" "r")
664                    (match_operand 2 "got_symbolic_operand" "s")))]
665   "reload_completed"
666 {
667   if (HAVE_AS_LTOFFX_LDXMOV_RELOCS)
668     return "%,ld8.mov %0 = [%1], %2";
669   else
670     return "%,ld8 %0 = [%1]";
671 }
672   [(set_attr "itanium_class" "ld")])
673
674 (define_insn_and_split "load_dtpmod"
675   [(set (match_operand:DI 0 "register_operand" "=r")
676         (unspec:DI [(match_operand 1 "tls_symbolic_operand" "")]
677                    UNSPEC_DTPMOD))]
678   ""
679   "#"
680   "reload_completed"
681   [(set (match_dup 0)
682         (plus:DI (unspec:DI [(match_dup 1)] UNSPEC_LTOFF_DTPMOD)
683                  (match_dup 2)))
684    (set (match_dup 0) (match_dup 3))]
685 {
686   operands[2] = pic_offset_table_rtx;
687   operands[3] = gen_const_mem (DImode, operands[0]);
688 })
689
690 (define_insn "*load_ltoff_dtpmod"
691   [(set (match_operand:DI 0 "register_operand" "=r")
692         (plus:DI (unspec:DI [(match_operand 1 "tls_symbolic_operand" "")]
693                             UNSPEC_LTOFF_DTPMOD)
694                  (match_operand:DI 2 "register_operand" "a")))]
695   "reload_completed"
696   "addl %0 = @ltoff(@dtpmod(%1)), %2"
697   [(set_attr "itanium_class" "ialu")])
698
699 (define_expand "load_dtprel"
700   [(set (match_operand:DI 0 "register_operand" "")
701         (unspec:DI [(match_operand 1 "tls_symbolic_operand" "")]
702                    UNSPEC_DTPREL))]
703   ""
704   "")
705
706 (define_insn "*load_dtprel64"
707   [(set (match_operand:DI 0 "register_operand" "=r")
708         (unspec:DI [(match_operand 1 "ld_tls_symbolic_operand" "")]
709                    UNSPEC_DTPREL))]
710   "TARGET_TLS64"
711   "movl %0 = @dtprel(%1)"
712   [(set_attr "itanium_class" "long_i")])
713
714 (define_insn "*load_dtprel22"
715   [(set (match_operand:DI 0 "register_operand" "=r")
716         (unspec:DI [(match_operand 1 "ld_tls_symbolic_operand" "")]
717                    UNSPEC_DTPREL))]
718   ""
719   "addl %0 = @dtprel(%1), r0"
720   [(set_attr "itanium_class" "ialu")])
721
722 (define_insn_and_split "*load_dtprel_gd"
723   [(set (match_operand:DI 0 "register_operand" "=r")
724         (unspec:DI [(match_operand 1 "tls_symbolic_operand" "")]
725                    UNSPEC_DTPREL))]
726   ""
727   "#"
728   "reload_completed"
729   [(set (match_dup 0)
730         (plus:DI (unspec:DI [(match_dup 1)] UNSPEC_LTOFF_DTPREL)
731                  (match_dup 2)))
732    (set (match_dup 0) (match_dup 3))]
733 {
734   operands[2] = pic_offset_table_rtx;
735   operands[3] = gen_const_mem (DImode, operands[0]);
736 })
737
738 (define_insn "*load_ltoff_dtprel"
739   [(set (match_operand:DI 0 "register_operand" "=r")
740         (plus:DI (unspec:DI [(match_operand 1 "tls_symbolic_operand" "")]
741                             UNSPEC_LTOFF_DTPREL)
742                  (match_operand:DI 2 "register_operand" "a")))]
743   ""
744   "addl %0 = @ltoff(@dtprel(%1)), %2"
745   [(set_attr "itanium_class" "ialu")])
746
747 (define_expand "add_dtprel"
748   [(set (match_operand:DI 0 "register_operand" "")
749         (plus:DI (unspec:DI [(match_operand 1 "ld_tls_symbolic_operand" "")]
750                             UNSPEC_DTPREL)
751                  (match_operand:DI 2 "register_operand" "")))]
752   "!TARGET_TLS64"
753   "")
754
755 (define_insn "*add_dtprel14"
756   [(set (match_operand:DI 0 "register_operand" "=r")
757         (plus:DI (unspec:DI [(match_operand 1 "ld_tls_symbolic_operand" "")]
758                             UNSPEC_DTPREL)
759                  (match_operand:DI 2 "register_operand" "r")))]
760   "TARGET_TLS14"
761   "adds %0 = @dtprel(%1), %2"
762   [(set_attr "itanium_class" "ialu")])
763
764 (define_insn "*add_dtprel22"
765   [(set (match_operand:DI 0 "register_operand" "=r")
766         (plus:DI (unspec:DI [(match_operand 1 "ld_tls_symbolic_operand" "")]
767                             UNSPEC_DTPREL)
768                  (match_operand:DI 2 "register_operand" "a")))]
769   "TARGET_TLS22"
770   "addl %0 = @dtprel(%1), %2"
771   [(set_attr "itanium_class" "ialu")])
772
773 (define_expand "load_tprel"
774   [(set (match_operand:DI 0 "register_operand" "")
775         (unspec:DI [(match_operand 1 "tls_symbolic_operand" "")]
776                    UNSPEC_TPREL))]
777   ""
778   "")
779
780 (define_insn "*load_tprel64"
781   [(set (match_operand:DI 0 "register_operand" "=r")
782         (unspec:DI [(match_operand 1 "le_tls_symbolic_operand" "")]
783                    UNSPEC_TPREL))]
784   "TARGET_TLS64"
785   "movl %0 = @tprel(%1)"
786   [(set_attr "itanium_class" "long_i")])
787
788 (define_insn "*load_tprel22"
789   [(set (match_operand:DI 0 "register_operand" "=r")
790         (unspec:DI [(match_operand 1 "le_tls_symbolic_operand" "")]
791                    UNSPEC_TPREL))]
792   ""
793   "addl %0 = @tprel(%1), r0"
794   [(set_attr "itanium_class" "ialu")])
795
796 (define_insn_and_split "*load_tprel_ie"
797   [(set (match_operand:DI 0 "register_operand" "=r")
798         (unspec:DI [(match_operand 1 "ie_tls_symbolic_operand" "")]
799                    UNSPEC_TPREL))]
800   ""
801   "#"
802   "reload_completed"
803   [(set (match_dup 0)
804         (plus:DI (unspec:DI [(match_dup 1)] UNSPEC_LTOFF_TPREL)
805                  (match_dup 2)))
806    (set (match_dup 0) (match_dup 3))]
807 {
808   operands[2] = pic_offset_table_rtx;
809   operands[3] = gen_const_mem (DImode, operands[0]);
810 })
811
812 (define_insn "*load_ltoff_tprel"
813   [(set (match_operand:DI 0 "register_operand" "=r")
814         (plus:DI (unspec:DI [(match_operand 1 "ie_tls_symbolic_operand" "")]
815                             UNSPEC_LTOFF_TPREL)
816                  (match_operand:DI 2 "register_operand" "a")))]
817   ""
818   "addl %0 = @ltoff(@tprel(%1)), %2"
819   [(set_attr "itanium_class" "ialu")])
820
821 (define_expand "add_tprel"
822   [(set (match_operand:DI 0 "register_operand" "")
823         (plus:DI (unspec:DI [(match_operand 1 "le_tls_symbolic_operand" "")]
824                             UNSPEC_TPREL)
825                  (match_operand:DI 2 "register_operand" "")))]
826   "!TARGET_TLS64"
827   "")
828
829 (define_insn "*add_tprel14"
830   [(set (match_operand:DI 0 "register_operand" "=r")
831         (plus:DI (unspec:DI [(match_operand 1 "le_tls_symbolic_operand" "")]
832                             UNSPEC_TPREL)
833                  (match_operand:DI 2 "register_operand" "r")))]
834   "TARGET_TLS14"
835   "adds %0 = @tprel(%1), %2"
836   [(set_attr "itanium_class" "ialu")])
837
838 (define_insn "*add_tprel22"
839   [(set (match_operand:DI 0 "register_operand" "=r")
840         (plus:DI (unspec:DI [(match_operand 1 "le_tls_symbolic_operand" "")]
841                             UNSPEC_TPREL)
842                  (match_operand:DI 2 "register_operand" "a")))]
843   "TARGET_TLS22"
844   "addl %0 = @tprel(%1), %2"
845   [(set_attr "itanium_class" "ialu")])
846
847 ;; With no offsettable memory references, we've got to have a scratch
848 ;; around to play with the second word.  However, in order to avoid a
849 ;; reload nightmare we lie, claim we don't need one, and fix it up
850 ;; in ia64_split_tmode_move.
851 (define_expand "movti"
852   [(set (match_operand:TI 0 "general_operand" "")
853         (match_operand:TI 1 "general_operand" ""))]
854   ""
855 {
856   rtx op1 = ia64_expand_move (operands[0], operands[1]);
857   if (!op1)
858     DONE;
859   operands[1] = op1;
860 })
861
862 (define_insn_and_split "*movti_internal"
863   [(set (match_operand:TI 0 "destination_operand" "=r,   *fm,*x,*f,  Q")
864         (match_operand:TI 1 "general_operand"     "r*fim,r,  Q, *fOQ,*f"))]
865   "ia64_move_ok (operands[0], operands[1])"
866   "@
867    #
868    #
869    ldfp8 %X0 = %1%P1
870    #
871    #"
872   "reload_completed && !ia64_load_pair_ok(operands[0], operands[1])"
873   [(const_int 0)]
874 {
875   ia64_split_tmode_move (operands);
876   DONE;
877 }
878   [(set_attr "itanium_class" "unknown,unknown,fldp,unknown,unknown")])
879
880 ;; Floating Point Moves
881 ;;
882 ;; Note - Patterns for SF mode moves are compulsory, but
883 ;; patterns for DF are optional, as GCC can synthesize them.
884
885 (define_expand "movsf"
886   [(set (match_operand:SF 0 "general_operand" "")
887         (match_operand:SF 1 "general_operand" ""))]
888   ""
889 {
890   rtx op1 = ia64_expand_move (operands[0], operands[1]);
891   if (!op1)
892     DONE;
893   operands[1] = op1;
894 })
895
896 (define_insn "*movsf_internal"
897   [(set (match_operand:SF 0 "destination_operand" "=f,f, Q,*r, f,*r,*r, m")
898         (match_operand:SF 1 "general_operand"     "fG,Q,fG,fG,*r,*r, m,*r"))]
899   "ia64_move_ok (operands[0], operands[1])"
900   "@
901    mov %0 = %F1
902    ldfs %0 = %1%P1
903    stfs %0 = %F1%P0
904    getf.s %0 = %F1
905    setf.s %0 = %1
906    mov %0 = %1
907    ld4%O1 %0 = %1%P1
908    st4%Q0 %0 = %1%P0"
909   [(set_attr "itanium_class" "fmisc,fld,stf,frfr,tofr,ialu,ld,st")])
910
911 (define_expand "movdf"
912   [(set (match_operand:DF 0 "general_operand" "")
913         (match_operand:DF 1 "general_operand" ""))]
914   ""
915 {
916   rtx op1 = ia64_expand_move (operands[0], operands[1]);
917   if (!op1)
918     DONE;
919   operands[1] = op1;
920 })
921
922 (define_insn "*movdf_internal"
923   [(set (match_operand:DF 0 "destination_operand" "=f,f, Q,*r, f,*r,*r, m")
924         (match_operand:DF 1 "general_operand"     "fG,Q,fG,fG,*r,*r, m,*r"))]
925   "ia64_move_ok (operands[0], operands[1])"
926   "@
927    mov %0 = %F1
928    ldfd %0 = %1%P1
929    stfd %0 = %F1%P0
930    getf.d %0 = %F1
931    setf.d %0 = %1
932    mov %0 = %1
933    ld8%O1 %0 = %1%P1
934    st8%Q0 %0 = %1%P0"
935   [(set_attr "itanium_class" "fmisc,fld,stf,frfr,tofr,ialu,ld,st")])
936
937 ;; With no offsettable memory references, we've got to have a scratch
938 ;; around to play with the second word if the variable winds up in GRs.
939 (define_expand "movxf"
940   [(set (match_operand:XF 0 "general_operand" "")
941         (match_operand:XF 1 "general_operand" ""))]
942   ""
943 {
944   if (ia64_expand_movxf_movrf (XFmode, operands))
945     DONE;
946 })
947
948 ;; ??? There's no easy way to mind volatile acquire/release semantics.
949
950 (define_insn "*movxf_internal"
951   [(set (match_operand:XF 0 "destination_operand" "=f,f, m")
952         (match_operand:XF 1 "general_operand"     "fG,m,fG"))]
953   "ia64_move_ok (operands[0], operands[1])"
954   "@
955    mov %0 = %F1
956    ldfe %0 = %1%P1
957    stfe %0 = %F1%P0"
958   [(set_attr "itanium_class" "fmisc,fld,stf")])
959
960 ;; Same as for movxf, but for RFmode.
961 (define_expand "movrf"
962   [(set (match_operand:RF 0 "general_operand" "")
963         (match_operand:RF 1 "general_operand" ""))]
964   ""
965 {
966   if (ia64_expand_movxf_movrf (RFmode, operands))
967     DONE;
968 })
969
970 (define_insn "*movrf_internal"
971   [(set (match_operand:RF 0 "destination_operand" "=f,f, m")
972         (match_operand:RF 1 "general_operand"     "fG,m,fG"))]
973   "ia64_move_ok (operands[0], operands[1])"
974   "@
975    mov %0 = %F1
976    ldf.fill %0 = %1%P1
977    stf.spill %0 = %F1%P0"
978   [(set_attr "itanium_class" "fmisc,fld,stf")])
979
980 ;; Better code generation via insns that deal with TFmode register pairs
981 ;; directly.  Same concerns apply as for TImode.
982 (define_expand "movtf"
983   [(set (match_operand:TF 0 "general_operand" "")
984         (match_operand:TF 1 "general_operand" ""))]
985   ""
986 {
987   rtx op1 = ia64_expand_move (operands[0], operands[1]);
988   if (!op1)
989     DONE;
990   operands[1] = op1;
991 })
992
993 (define_insn_and_split "*movtf_internal"
994   [(set (match_operand:TF 0 "destination_operand"  "=r,r,m")
995         (match_operand:TF 1 "general_operand"      "ri,m,r"))]
996   "ia64_move_ok (operands[0], operands[1])"
997   "#"
998   "reload_completed"
999   [(const_int 0)]
1000 {
1001   ia64_split_tmode_move (operands);
1002   DONE;
1003 }
1004   [(set_attr "itanium_class" "unknown")
1005    (set_attr "predicable" "no")])
1006
1007 \f
1008 ;; ::::::::::::::::::::
1009 ;; ::
1010 ;; :: Conversions
1011 ;; ::
1012 ;; ::::::::::::::::::::
1013
1014 ;; Signed conversions from a smaller integer to a larger integer
1015
1016 (define_insn "extendqidi2"
1017   [(set (match_operand:DI 0 "gr_register_operand" "=r")
1018         (sign_extend:DI (match_operand:QI 1 "gr_register_operand" "r")))]
1019   ""
1020   "sxt1 %0 = %1"
1021   [(set_attr "itanium_class" "xtd")])
1022
1023 (define_insn "extendhidi2"
1024   [(set (match_operand:DI 0 "gr_register_operand" "=r")
1025         (sign_extend:DI (match_operand:HI 1 "gr_register_operand" "r")))]
1026   ""
1027   "sxt2 %0 = %1"
1028   [(set_attr "itanium_class" "xtd")])
1029
1030 (define_insn "extendsidi2"
1031   [(set (match_operand:DI 0 "grfr_register_operand" "=r,?f")
1032         (sign_extend:DI (match_operand:SI 1 "grfr_register_operand" "r,f")))]
1033   ""
1034   "@
1035    sxt4 %0 = %1
1036    fsxt.r %0 = %1, %1"
1037   [(set_attr "itanium_class" "xtd,fmisc")])
1038
1039 ;; Unsigned conversions from a smaller integer to a larger integer
1040
1041 (define_insn "zero_extendqidi2"
1042   [(set (match_operand:DI 0 "gr_register_operand" "=r,r")
1043         (zero_extend:DI (match_operand:QI 1 "gr_nonimmediate_operand" "r,m")))]
1044   ""
1045   "@
1046    zxt1 %0 = %1
1047    ld1%O1 %0 = %1%P1"
1048   [(set_attr "itanium_class" "xtd,ld")])
1049
1050 (define_insn "zero_extendhidi2"
1051   [(set (match_operand:DI 0 "gr_register_operand" "=r,r")
1052         (zero_extend:DI (match_operand:HI 1 "gr_nonimmediate_operand" "r,m")))]
1053   ""
1054   "@
1055    zxt2 %0 = %1
1056    ld2%O1 %0 = %1%P1"
1057   [(set_attr "itanium_class" "xtd,ld")])
1058
1059 (define_insn "zero_extendsidi2"
1060   [(set (match_operand:DI 0 "grfr_register_operand" "=r,r,?f")
1061         (zero_extend:DI
1062           (match_operand:SI 1 "grfr_nonimmediate_operand" "r,m,f")))]
1063   ""
1064   "@
1065    addp4 %0 = %1, r0
1066    ld4%O1 %0 = %1%P1
1067    fmix.r %0 = f0, %1"
1068   [(set_attr "itanium_class" "ialu,ld,fmisc")])
1069
1070 ;; Convert between floating point types of different sizes.
1071
1072 ;; At first glance, it would appear that emitting fnorm for an extending
1073 ;; conversion is unnecessary.  However, the stf and getf instructions work
1074 ;; correctly only if the input is properly rounded for its type.  In
1075 ;; particular, we get the wrong result for getf.d/stfd if the input is a
1076 ;; denorm single.  Since we don't know what the next instruction will be, we
1077 ;; have to emit an fnorm.
1078
1079 ;; ??? Optimization opportunity here.  Get rid of the insn altogether
1080 ;; when we can.  Should probably use a scheme like has been proposed
1081 ;; for ia32 in dealing with operands that match unary operators.  This
1082 ;; would let combine merge the thing into adjacent insns.  See also how the
1083 ;; mips port handles SIGN_EXTEND as operands to integer arithmetic insns via
1084 ;; se_register_operand.
1085
1086 (define_insn "extendsfdf2"
1087   [(set (match_operand:DF 0 "fr_register_operand" "=f")
1088         (float_extend:DF (match_operand:SF 1 "fr_register_operand" "f")))]
1089   ""
1090   "fnorm.d %0 = %1"
1091   [(set_attr "itanium_class" "fmac")])
1092
1093 (define_insn "extendsfxf2"
1094   [(set (match_operand:XF 0 "fr_register_operand" "=f")
1095         (float_extend:XF (match_operand:SF 1 "fr_register_operand" "f")))]
1096   ""
1097   "fnorm %0 = %1"
1098   [(set_attr "itanium_class" "fmac")])
1099
1100 (define_insn "extenddfxf2"
1101   [(set (match_operand:XF 0 "fr_register_operand" "=f")
1102         (float_extend:XF (match_operand:DF 1 "fr_register_operand" "f")))]
1103   ""
1104   "fnorm %0 = %1"
1105   [(set_attr "itanium_class" "fmac")])
1106
1107 (define_insn "truncdfsf2"
1108   [(set (match_operand:SF 0 "fr_register_operand" "=f")
1109         (float_truncate:SF (match_operand:DF 1 "fr_register_operand" "f")))]
1110   ""
1111   "fnorm.s %0 = %1"
1112   [(set_attr "itanium_class" "fmac")])
1113
1114 (define_insn "truncxfsf2"
1115   [(set (match_operand:SF 0 "fr_register_operand" "=f")
1116         (float_truncate:SF (match_operand:XF 1 "fr_register_operand" "f")))]
1117   ""
1118   "fnorm.s %0 = %1"
1119   [(set_attr "itanium_class" "fmac")])
1120
1121 (define_insn "truncxfdf2"
1122   [(set (match_operand:DF 0 "fr_register_operand" "=f")
1123         (float_truncate:DF (match_operand:XF 1 "fr_register_operand" "f")))]
1124   ""
1125   "fnorm.d %0 = %1"
1126   [(set_attr "itanium_class" "fmac")])
1127
1128 ;; Convert between signed integer types and floating point.
1129
1130 (define_insn "floatdixf2"
1131   [(set (match_operand:XF 0 "fr_register_operand" "=f")
1132         (float:XF (match_operand:DI 1 "fr_register_operand" "f")))]
1133   ""
1134   "fcvt.xf %0 = %1"
1135   [(set_attr "itanium_class" "fcvtfx")])
1136
1137 (define_insn "fix_truncsfdi2"
1138   [(set (match_operand:DI 0 "fr_register_operand" "=f")
1139         (fix:DI (match_operand:SF 1 "fr_register_operand" "f")))]
1140   ""
1141   "fcvt.fx.trunc %0 = %1"
1142   [(set_attr "itanium_class" "fcvtfx")])
1143
1144 (define_insn "fix_truncdfdi2"
1145   [(set (match_operand:DI 0 "fr_register_operand" "=f")
1146         (fix:DI (match_operand:DF 1 "fr_register_operand" "f")))]
1147   ""
1148   "fcvt.fx.trunc %0 = %1"
1149   [(set_attr "itanium_class" "fcvtfx")])
1150
1151 (define_insn "fix_truncxfdi2"
1152   [(set (match_operand:DI 0 "fr_register_operand" "=f")
1153         (fix:DI (match_operand:XF 1 "fr_register_operand" "f")))]
1154   ""
1155   "fcvt.fx.trunc %0 = %1"
1156   [(set_attr "itanium_class" "fcvtfx")])
1157
1158 (define_insn "fix_truncxfdi2_alts"
1159   [(set (match_operand:DI 0 "fr_register_operand" "=f")
1160         (fix:DI (match_operand:XF 1 "fr_register_operand" "f")))
1161    (use (match_operand:SI 2 "const_int_operand" ""))]
1162   ""
1163   "fcvt.fx.trunc.s%2 %0 = %1"
1164   [(set_attr "itanium_class" "fcvtfx")])
1165
1166 ;; Convert between unsigned integer types and floating point.
1167
1168 (define_insn "floatunsdisf2"
1169   [(set (match_operand:SF 0 "fr_register_operand" "=f")
1170         (unsigned_float:SF (match_operand:DI 1 "fr_register_operand" "f")))]
1171   ""
1172   "fcvt.xuf.s %0 = %1"
1173   [(set_attr "itanium_class" "fcvtfx")])
1174
1175 (define_insn "floatunsdidf2"
1176   [(set (match_operand:DF 0 "fr_register_operand" "=f")
1177         (unsigned_float:DF (match_operand:DI 1 "fr_register_operand" "f")))]
1178   ""
1179   "fcvt.xuf.d %0 = %1"
1180   [(set_attr "itanium_class" "fcvtfx")])
1181
1182 (define_insn "floatunsdixf2"
1183   [(set (match_operand:XF 0 "fr_register_operand" "=f")
1184         (unsigned_float:XF (match_operand:DI 1 "fr_register_operand" "f")))]
1185   ""
1186   "fcvt.xuf %0 = %1"
1187   [(set_attr "itanium_class" "fcvtfx")])
1188
1189 (define_insn "fixuns_truncsfdi2"
1190   [(set (match_operand:DI 0 "fr_register_operand" "=f")
1191         (unsigned_fix:DI (match_operand:SF 1 "fr_register_operand" "f")))]
1192   ""
1193   "fcvt.fxu.trunc %0 = %1"
1194   [(set_attr "itanium_class" "fcvtfx")])
1195
1196 (define_insn "fixuns_truncdfdi2"
1197   [(set (match_operand:DI 0 "fr_register_operand" "=f")
1198         (unsigned_fix:DI (match_operand:DF 1 "fr_register_operand" "f")))]
1199   ""
1200   "fcvt.fxu.trunc %0 = %1"
1201   [(set_attr "itanium_class" "fcvtfx")])
1202
1203 (define_insn "fixuns_truncxfdi2"
1204   [(set (match_operand:DI 0 "fr_register_operand" "=f")
1205         (unsigned_fix:DI (match_operand:XF 1 "fr_register_operand" "f")))]
1206   ""
1207   "fcvt.fxu.trunc %0 = %1"
1208   [(set_attr "itanium_class" "fcvtfx")])
1209
1210 (define_insn "fixuns_truncxfdi2_alts"
1211   [(set (match_operand:DI 0 "fr_register_operand" "=f")
1212         (unsigned_fix:DI (match_operand:XF 1 "fr_register_operand" "f")))
1213    (use (match_operand:SI 2 "const_int_operand" ""))]
1214   ""
1215   "fcvt.fxu.trunc.s%2 %0 = %1"
1216   [(set_attr "itanium_class" "fcvtfx")])
1217 \f
1218 ;; ::::::::::::::::::::
1219 ;; ::
1220 ;; :: Bit field extraction
1221 ;; ::
1222 ;; ::::::::::::::::::::
1223
1224 (define_insn "extv"
1225   [(set (match_operand:DI 0 "gr_register_operand" "=r")
1226         (sign_extract:DI (match_operand:DI 1 "gr_register_operand" "r")
1227                          (match_operand:DI 2 "extr_len_operand" "n")
1228                          (match_operand:DI 3 "shift_count_operand" "M")))]
1229   ""
1230   "extr %0 = %1, %3, %2"
1231   [(set_attr "itanium_class" "ishf")])
1232
1233 (define_insn "extzv"
1234   [(set (match_operand:DI 0 "gr_register_operand" "=r")
1235         (zero_extract:DI (match_operand:DI 1 "gr_register_operand" "r")
1236                          (match_operand:DI 2 "extr_len_operand" "n")
1237                          (match_operand:DI 3 "shift_count_operand" "M")))]
1238   ""
1239   "extr.u %0 = %1, %3, %2"
1240   [(set_attr "itanium_class" "ishf")])
1241
1242 ;; Insert a bit field.
1243 ;; Can have 3 operands, source1 (inserter), source2 (insertee), dest.
1244 ;; Source1 can be 0 or -1.
1245 ;; Source2 can be 0.
1246
1247 ;; ??? Actual dep instruction is more powerful than what these insv
1248 ;; patterns support.  Unfortunately, combine is unable to create patterns
1249 ;; where source2 != dest.
1250
1251 (define_expand "insv"
1252   [(set (zero_extract:DI (match_operand:DI 0 "gr_register_operand" "")
1253                          (match_operand:DI 1 "const_int_operand" "")
1254                          (match_operand:DI 2 "const_int_operand" ""))
1255         (match_operand:DI 3 "nonmemory_operand" ""))]
1256   ""
1257 {
1258   int width = INTVAL (operands[1]);
1259   int shift = INTVAL (operands[2]);
1260
1261   /* If operand[3] is a constant, and isn't 0 or -1, then load it into a
1262      pseudo.  */
1263   if (! register_operand (operands[3], DImode)
1264       && operands[3] != const0_rtx && operands[3] != constm1_rtx)
1265     operands[3] = force_reg (DImode, operands[3]);
1266
1267   /* If this is a single dep instruction, we have nothing to do.  */
1268   if (! ((register_operand (operands[3], DImode) && width <= 16)
1269          || operands[3] == const0_rtx || operands[3] == constm1_rtx))
1270     {
1271       /* Check for cases that can be implemented with a mix instruction.  */
1272       if (width == 32 && shift == 0)
1273         {
1274           /* Directly generating the mix4left instruction confuses
1275              optimize_bit_field in function.c.  Since this is performing
1276              a useful optimization, we defer generation of the complicated
1277              mix4left RTL to the first splitting phase.  */
1278           rtx tmp = gen_reg_rtx (DImode);
1279           emit_insn (gen_shift_mix4left (operands[0], operands[3], tmp));
1280           DONE;
1281         }
1282       else if (width == 32 && shift == 32)
1283         {
1284           emit_insn (gen_mix4right (operands[0], operands[3]));
1285           DONE;
1286         }
1287
1288       /* We could handle remaining cases by emitting multiple dep
1289          instructions.
1290
1291          If we need more than two dep instructions then we lose.  A 6
1292          insn sequence mov mask1,mov mask2,shl;;and,and;;or is better than
1293          mov;;dep,shr;;dep,shr;;dep.  The former can be executed in 3 cycles,
1294          the latter is 6 cycles on an Itanium (TM) processor, because there is
1295          only one function unit that can execute dep and shr immed.
1296
1297          If we only need two dep instruction, then we still lose.
1298          mov;;dep,shr;;dep is still 4 cycles.  Even if we optimize away
1299          the unnecessary mov, this is still undesirable because it will be
1300          hard to optimize, and it creates unnecessary pressure on the I0
1301          function unit.  */
1302
1303       FAIL;
1304
1305 #if 0
1306       /* This code may be useful for other IA-64 processors, so we leave it in
1307          for now.  */
1308       while (width > 16)
1309         {
1310           rtx tmp;
1311
1312           emit_insn (gen_insv (operands[0], GEN_INT (16), GEN_INT (shift),
1313                                operands[3]));
1314           shift += 16;
1315           width -= 16;
1316           tmp = gen_reg_rtx (DImode);
1317           emit_insn (gen_lshrdi3 (tmp, operands[3], GEN_INT (16)));
1318           operands[3] = tmp;
1319         }
1320       operands[1] = GEN_INT (width);
1321       operands[2] = GEN_INT (shift);
1322 #endif
1323     }
1324 })
1325
1326 (define_insn "*insv_internal"
1327   [(set (zero_extract:DI (match_operand:DI 0 "gr_register_operand" "+r")
1328                          (match_operand:DI 1 "const_int_operand" "n")
1329                          (match_operand:DI 2 "const_int_operand" "n"))
1330         (match_operand:DI 3 "nonmemory_operand" "rP"))]
1331   "(gr_register_operand (operands[3], DImode) && INTVAL (operands[1]) <= 16)
1332    || operands[3] == const0_rtx || operands[3] == constm1_rtx"
1333   "dep %0 = %3, %0, %2, %1"
1334   [(set_attr "itanium_class" "ishf")])
1335
1336 ;; Combine doesn't like to create bit-field insertions into zero.
1337 (define_insn "*shladdp4_internal"
1338   [(set (match_operand:DI 0 "gr_register_operand" "=r")
1339         (and:DI (ashift:DI (match_operand:DI 1 "gr_register_operand" "r")
1340                            (match_operand:DI 2 "shladd_log2_operand" "n"))
1341                 (match_operand:DI 3 "const_int_operand" "n")))]
1342   "ia64_depz_field_mask (operands[3], operands[2]) + INTVAL (operands[2]) == 32"
1343   "shladdp4 %0 = %1, %2, r0"
1344   [(set_attr "itanium_class" "ialu")])
1345
1346 (define_insn "*depz_internal"
1347   [(set (match_operand:DI 0 "gr_register_operand" "=r")
1348         (and:DI (ashift:DI (match_operand:DI 1 "gr_register_operand" "r")
1349                            (match_operand:DI 2 "const_int_operand" "M"))
1350                 (match_operand:DI 3 "const_int_operand" "n")))]
1351   "satisfies_constraint_M (operands[2])
1352    && ia64_depz_field_mask (operands[3], operands[2]) > 0"
1353 {
1354   operands[3] = GEN_INT (ia64_depz_field_mask (operands[3], operands[2]));
1355   return "%,dep.z %0 = %1, %2, %3";
1356 }
1357   [(set_attr "itanium_class" "ishf")])
1358
1359 (define_insn "shift_mix4left"
1360   [(set (zero_extract:DI (match_operand:DI 0 "gr_register_operand" "+r")
1361                          (const_int 32) (const_int 0))
1362         (match_operand:DI 1 "gr_register_operand" "r"))
1363    (clobber (match_operand:DI 2 "gr_register_operand" "=r"))]
1364   ""
1365   "#"
1366   [(set_attr "itanium_class" "unknown")])
1367
1368 (define_split
1369   [(set (zero_extract:DI (match_operand:DI 0 "register_operand" "")
1370                          (const_int 32) (const_int 0))
1371         (match_operand:DI 1 "register_operand" ""))
1372    (clobber (match_operand:DI 2 "register_operand" ""))]
1373   ""
1374   [(set (match_dup 3) (ashift:DI (match_dup 1) (const_int 32)))
1375    (set (zero_extract:DI (match_dup 0) (const_int 32) (const_int 0))
1376         (lshiftrt:DI (match_dup 3) (const_int 32)))]
1377   "operands[3] = operands[2];")
1378
1379 (define_insn "*mix4left"
1380   [(set (zero_extract:DI (match_operand:DI 0 "gr_register_operand" "+r")
1381                          (const_int 32) (const_int 0))
1382         (lshiftrt:DI (match_operand:DI 1 "gr_register_operand" "r")
1383                      (const_int 32)))]
1384   ""
1385   "mix4.l %0 = %0, %r1"
1386   [(set_attr "itanium_class" "mmshf")])
1387
1388 (define_insn "mix4right"
1389   [(set (zero_extract:DI (match_operand:DI 0 "gr_register_operand" "+r")
1390                          (const_int 32) (const_int 32))
1391         (match_operand:DI 1 "gr_reg_or_0_operand" "rO"))]
1392   ""
1393   "mix4.r %0 = %r1, %0"
1394   [(set_attr "itanium_class" "mmshf")])
1395
1396 ;; This is used by the rotrsi3 pattern.
1397
1398 (define_insn "*mix4right_3op"
1399   [(set (match_operand:DI 0 "gr_register_operand" "=r")
1400         (ior:DI (zero_extend:DI (match_operand:SI 1 "gr_register_operand" "r"))
1401                 (ashift:DI (zero_extend:DI
1402                              (match_operand:SI 2 "gr_register_operand" "r"))
1403                            (const_int 32))))]
1404   ""
1405   "mix4.r %0 = %2, %1"
1406   [(set_attr "itanium_class" "mmshf")])
1407
1408 \f
1409 ;; ::::::::::::::::::::
1410 ;; ::
1411 ;; :: 1-bit Integer arithmetic
1412 ;; ::
1413 ;; ::::::::::::::::::::
1414
1415 (define_insn_and_split "andbi3"
1416   [(set (match_operand:BI 0 "register_operand" "=c,c,r")
1417         (and:BI (match_operand:BI 1 "register_operand" "%0,0,r")
1418                 (match_operand:BI 2 "register_operand" "c,r,r")))]
1419   ""
1420   "@
1421    #
1422    tbit.nz.and.orcm %0, %I0 = %2, 0
1423    and %0 = %2, %1"
1424   "reload_completed
1425    && GET_CODE (operands[0]) == REG && PR_REGNO_P (REGNO (operands[0]))
1426    && GET_CODE (operands[2]) == REG && PR_REGNO_P (REGNO (operands[2]))"
1427   [(cond_exec (eq (match_dup 2) (const_int 0))
1428      (set (match_dup 0) (and:BI (ne:BI (const_int 0) (const_int 0))
1429                                 (match_dup 0))))]
1430   ""
1431   [(set_attr "itanium_class" "unknown,tbit,ilog")])
1432
1433 (define_insn_and_split "*andcmbi3"
1434   [(set (match_operand:BI 0 "register_operand" "=c,c,r")
1435         (and:BI (not:BI (match_operand:BI 1 "register_operand" "c,r,r"))
1436                 (match_operand:BI 2 "register_operand" "0,0,r")))]
1437   ""
1438   "@
1439    #
1440    tbit.z.and.orcm %0, %I0 = %1, 0
1441    andcm %0 = %2, %1"
1442   "reload_completed
1443    && GET_CODE (operands[0]) == REG && PR_REGNO_P (REGNO (operands[0]))
1444    && GET_CODE (operands[1]) == REG && PR_REGNO_P (REGNO (operands[1]))"
1445   [(cond_exec (ne (match_dup 1) (const_int 0))
1446      (set (match_dup 0) (and:BI (ne:BI (const_int 0) (const_int 0))
1447                                 (match_dup 0))))]
1448   ""
1449   [(set_attr "itanium_class" "unknown,tbit,ilog")])
1450
1451 (define_insn_and_split "iorbi3"
1452   [(set (match_operand:BI 0 "register_operand" "=c,c,r")
1453         (ior:BI (match_operand:BI 1 "register_operand" "%0,0,r")
1454                 (match_operand:BI 2 "register_operand" "c,r,r")))]
1455   ""
1456   "@
1457    #
1458    tbit.nz.or.andcm %0, %I0 = %2, 0
1459    or %0 = %2, %1"
1460   "reload_completed
1461    && GET_CODE (operands[0]) == REG && PR_REGNO_P (REGNO (operands[0]))
1462    && GET_CODE (operands[2]) == REG && PR_REGNO_P (REGNO (operands[2]))"
1463   [(cond_exec (ne (match_dup 2) (const_int 0))
1464      (set (match_dup 0) (ior:BI (eq:BI (const_int 0) (const_int 0))
1465                                 (match_dup 0))))]
1466   ""
1467   [(set_attr "itanium_class" "unknown,tbit,ilog")])
1468
1469 (define_insn_and_split "*iorcmbi3"
1470   [(set (match_operand:BI 0 "register_operand" "=c,c")
1471         (ior:BI (not:BI (match_operand:BI 1 "register_operand" "c,r"))
1472                 (match_operand:BI 2 "register_operand" "0,0")))]
1473   ""
1474   "@
1475    #
1476    tbit.z.or.andcm %0, %I0 = %1, 0"
1477   "reload_completed
1478    && GET_CODE (operands[0]) == REG && PR_REGNO_P (REGNO (operands[0]))
1479    && GET_CODE (operands[1]) == REG && PR_REGNO_P (REGNO (operands[1]))"
1480   [(cond_exec (eq (match_dup 1) (const_int 0))
1481      (set (match_dup 0) (ior:BI (eq:BI (const_int 0) (const_int 0))
1482                                 (match_dup 0))))]
1483   ""
1484   [(set_attr "itanium_class" "unknown,tbit")])
1485
1486 (define_insn "one_cmplbi2"
1487   [(set (match_operand:BI 0 "register_operand" "=c,r,c,&c")
1488         (not:BI (match_operand:BI 1 "register_operand" "r,r,0,c")))
1489    (clobber (match_scratch:BI 2 "=X,X,c,X"))]
1490   ""
1491   "@
1492    tbit.z %0, %I0 = %1, 0
1493    xor %0 = 1, %1
1494    #
1495    #"
1496   [(set_attr "itanium_class" "tbit,ilog,unknown,unknown")])
1497
1498 (define_split
1499   [(set (match_operand:BI 0 "register_operand" "")
1500         (not:BI (match_operand:BI 1 "register_operand" "")))
1501    (clobber (match_scratch:BI 2 ""))]
1502   "reload_completed
1503    && GET_CODE (operands[0]) == REG && PR_REGNO_P (REGNO (operands[0]))
1504    && rtx_equal_p (operands[0], operands[1])"
1505   [(set (match_dup 4) (match_dup 3))
1506    (set (match_dup 0) (const_int 1))
1507    (cond_exec (ne (match_dup 2) (const_int 0))
1508      (set (match_dup 0) (const_int 0)))
1509    (set (match_dup 0) (unspec:BI [(match_dup 0)] UNSPEC_PRED_REL_MUTEX))]
1510   "operands[3] = gen_rtx_REG (CCImode, REGNO (operands[1]));
1511    operands[4] = gen_rtx_REG (CCImode, REGNO (operands[2]));")
1512
1513 (define_split
1514   [(set (match_operand:BI 0 "register_operand" "")
1515         (not:BI (match_operand:BI 1 "register_operand" "")))
1516    (clobber (match_scratch:BI 2 ""))]
1517   "reload_completed
1518    && GET_CODE (operands[0]) == REG && PR_REGNO_P (REGNO (operands[0]))
1519    && GET_CODE (operands[1]) == REG && PR_REGNO_P (REGNO (operands[1]))
1520    && ! rtx_equal_p (operands[0], operands[1])"
1521   [(cond_exec (ne (match_dup 1) (const_int 0))
1522      (set (match_dup 0) (const_int 0)))
1523    (cond_exec (eq (match_dup 1) (const_int 0))
1524      (set (match_dup 0) (const_int 1)))
1525    (set (match_dup 0) (unspec:BI [(match_dup 0)] UNSPEC_PRED_REL_MUTEX))]
1526   "")
1527
1528 (define_insn "*cmpsi_and_0"
1529   [(set (match_operand:BI 0 "register_operand" "=c")
1530         (and:BI (match_operator:BI 4 "predicate_operator"
1531                   [(match_operand:SI 2 "gr_reg_or_0_operand" "rO")
1532                    (match_operand:SI 3 "gr_reg_or_8bit_operand" "rK")])
1533                 (match_operand:BI 1 "register_operand" "0")))]
1534   ""
1535   "cmp4.%C4.and.orcm %0, %I0 = %3, %r2"
1536   [(set_attr "itanium_class" "icmp")])
1537
1538 (define_insn "*cmpsi_and_1"
1539   [(set (match_operand:BI 0 "register_operand" "=c")
1540         (and:BI (match_operator:BI 3 "signed_inequality_operator"
1541                   [(match_operand:SI 2 "gr_register_operand" "r")
1542                    (const_int 0)])
1543                 (match_operand:BI 1 "register_operand" "0")))]
1544   ""
1545   "cmp4.%C3.and.orcm %0, %I0 = r0, %2"
1546   [(set_attr "itanium_class" "icmp")])
1547
1548 (define_insn "*cmpsi_andnot_0"
1549   [(set (match_operand:BI 0 "register_operand" "=c")
1550         (and:BI (not:BI (match_operator:BI 4 "predicate_operator"
1551                          [(match_operand:SI 2 "gr_reg_or_0_operand" "rO")
1552                           (match_operand:SI 3 "gr_reg_or_8bit_operand" "rK")]))
1553                 (match_operand:BI 1 "register_operand" "0")))]
1554   ""
1555   "cmp4.%C4.or.andcm %I0, %0 = %3, %r2"
1556   [(set_attr "itanium_class" "icmp")])
1557
1558 (define_insn "*cmpsi_andnot_1"
1559   [(set (match_operand:BI 0 "register_operand" "=c")
1560         (and:BI (not:BI (match_operator:BI 3 "signed_inequality_operator"
1561                           [(match_operand:SI 2 "gr_register_operand" "r")
1562                            (const_int 0)]))
1563                 (match_operand:BI 1 "register_operand" "0")))]
1564   ""
1565   "cmp4.%C3.or.andcm %I0, %0 = r0, %2"
1566   [(set_attr "itanium_class" "icmp")])
1567
1568 (define_insn "*cmpdi_and_0"
1569   [(set (match_operand:BI 0 "register_operand" "=c")
1570         (and:BI (match_operator:BI 4 "predicate_operator"
1571                   [(match_operand:DI 2 "gr_register_operand" "r")
1572                    (match_operand:DI 3 "gr_reg_or_8bit_operand" "rK")])
1573                 (match_operand:BI 1 "register_operand" "0")))]
1574   ""
1575   "cmp.%C4.and.orcm %0, %I0 = %3, %2"
1576   [(set_attr "itanium_class" "icmp")])
1577
1578 (define_insn "*cmpdi_and_1"
1579   [(set (match_operand:BI 0 "register_operand" "=c")
1580         (and:BI (match_operator:BI 3 "signed_inequality_operator"
1581                   [(match_operand:DI 2 "gr_register_operand" "r")
1582                    (const_int 0)])
1583                 (match_operand:BI 1 "register_operand" "0")))]
1584   ""
1585   "cmp.%C3.and.orcm %0, %I0 = r0, %2"
1586   [(set_attr "itanium_class" "icmp")])
1587
1588 (define_insn "*cmpdi_andnot_0"
1589   [(set (match_operand:BI 0 "register_operand" "=c")
1590         (and:BI (not:BI (match_operator:BI 4 "predicate_operator"
1591                          [(match_operand:DI 2 "gr_register_operand" "r")
1592                           (match_operand:DI 3 "gr_reg_or_8bit_operand" "rK")]))
1593                 (match_operand:BI 1 "register_operand" "0")))]
1594   ""
1595   "cmp.%C4.or.andcm %I0, %0 = %3, %2"
1596   [(set_attr "itanium_class" "icmp")])
1597
1598 (define_insn "*cmpdi_andnot_1"
1599   [(set (match_operand:BI 0 "register_operand" "=c")
1600         (and:BI (not:BI (match_operator:BI 3 "signed_inequality_operator"
1601                           [(match_operand:DI 2 "gr_register_operand" "r")
1602                            (const_int 0)]))
1603                 (match_operand:BI 1 "register_operand" "0")))]
1604   ""
1605   "cmp.%C3.or.andcm %I0, %0 = r0, %2"
1606   [(set_attr "itanium_class" "icmp")])
1607
1608 (define_insn "*tbit_and_0"
1609   [(set (match_operand:BI 0 "register_operand" "=c")
1610         (and:BI (ne:BI (and:DI (match_operand:DI 1 "gr_register_operand" "r")
1611                                (const_int 1))
1612                        (const_int 0))
1613                 (match_operand:BI 2 "register_operand" "0")))]
1614   ""
1615   "tbit.nz.and.orcm %0, %I0 = %1, 0"
1616   [(set_attr "itanium_class" "tbit")])
1617
1618 (define_insn "*tbit_and_1"
1619   [(set (match_operand:BI 0 "register_operand" "=c")
1620         (and:BI (eq:BI (and:DI (match_operand:DI 1 "gr_register_operand" "r")
1621                                (const_int 1))
1622                        (const_int 0))
1623                 (match_operand:BI 2 "register_operand" "0")))]
1624   ""
1625   "tbit.z.and.orcm %0, %I0 = %1, 0"
1626   [(set_attr "itanium_class" "tbit")])
1627
1628 (define_insn "*tbit_and_2"
1629   [(set (match_operand:BI 0 "register_operand" "=c")
1630         (and:BI (ne:BI (zero_extract:DI
1631                          (match_operand:DI 1 "gr_register_operand" "r")
1632                          (const_int 1)
1633                          (match_operand:DI 2 "shift_count_operand" "M"))
1634                        (const_int 0))
1635                 (match_operand:BI 3 "register_operand" "0")))]
1636   ""
1637   "tbit.nz.and.orcm %0, %I0 = %1, %2"
1638   [(set_attr "itanium_class" "tbit")])
1639
1640 (define_insn "*tbit_and_3"
1641   [(set (match_operand:BI 0 "register_operand" "=c")
1642         (and:BI (eq:BI (zero_extract:DI
1643                          (match_operand:DI 1 "gr_register_operand" "r")
1644                          (const_int 1)
1645                          (match_operand:DI 2 "shift_count_operand" "M"))
1646                        (const_int 0))
1647                 (match_operand:BI 3 "register_operand" "0")))]
1648   ""
1649   "tbit.z.and.orcm %0, %I0 = %1, %2"
1650   [(set_attr "itanium_class" "tbit")])
1651
1652 (define_insn "*cmpsi_or_0"
1653   [(set (match_operand:BI 0 "register_operand" "=c")
1654         (ior:BI (match_operator:BI 4 "predicate_operator"
1655                   [(match_operand:SI 2 "gr_reg_or_0_operand" "rO")
1656                    (match_operand:SI 3 "gr_reg_or_8bit_operand" "rK")])
1657                 (match_operand:BI 1 "register_operand" "0")))]
1658   ""
1659   "cmp4.%C4.or.andcm %0, %I0 = %3, %r2"
1660   [(set_attr "itanium_class" "icmp")])
1661
1662 (define_insn "*cmpsi_or_1"
1663   [(set (match_operand:BI 0 "register_operand" "=c")
1664         (ior:BI (match_operator:BI 3 "signed_inequality_operator"
1665                   [(match_operand:SI 2 "gr_register_operand" "r")
1666                    (const_int 0)])
1667                 (match_operand:BI 1 "register_operand" "0")))]
1668   ""
1669   "cmp4.%C3.or.andcm %0, %I0 = r0, %2"
1670   [(set_attr "itanium_class" "icmp")])
1671
1672 (define_insn "*cmpsi_orcm_0"
1673   [(set (match_operand:BI 0 "register_operand" "=c")
1674         (ior:BI (not:BI (match_operator:BI 4 "predicate_operator"
1675                          [(match_operand:SI 2 "gr_reg_or_0_operand" "rO")
1676                           (match_operand:SI 3 "gr_reg_or_8bit_operand" "rK")]))
1677                 (match_operand:BI 1 "register_operand" "0")))]
1678   ""
1679   "cmp4.%C4.and.orcm %I0, %0 = %3, %r2"
1680   [(set_attr "itanium_class" "icmp")])
1681
1682 (define_insn "*cmpsi_orcm_1"
1683   [(set (match_operand:BI 0 "register_operand" "=c")
1684         (ior:BI (not:BI (match_operator:BI 3 "signed_inequality_operator"
1685                           [(match_operand:SI 2 "gr_register_operand" "r")
1686                            (const_int 0)]))
1687                 (match_operand:BI 1 "register_operand" "0")))]
1688   ""
1689   "cmp4.%C3.and.orcm %I0, %0 = r0, %2"
1690   [(set_attr "itanium_class" "icmp")])
1691
1692 (define_insn "*cmpdi_or_0"
1693   [(set (match_operand:BI 0 "register_operand" "=c")
1694         (ior:BI (match_operator:BI 4 "predicate_operator"
1695                   [(match_operand:DI 2 "gr_register_operand" "r")
1696                    (match_operand:DI 3 "gr_reg_or_8bit_operand" "rK")])
1697                 (match_operand:BI 1 "register_operand" "0")))]
1698   ""
1699   "cmp.%C4.or.andcm %0, %I0 = %3, %2"
1700   [(set_attr "itanium_class" "icmp")])
1701
1702 (define_insn "*cmpdi_or_1"
1703   [(set (match_operand:BI 0 "register_operand" "=c")
1704         (ior:BI (match_operator:BI 3 "signed_inequality_operator"
1705                   [(match_operand:DI 2 "gr_register_operand" "r")
1706                    (const_int 0)])
1707                 (match_operand:BI 1 "register_operand" "0")))]
1708   ""
1709   "cmp.%C3.or.andcm %0, %I0 = r0, %2"
1710   [(set_attr "itanium_class" "icmp")])
1711
1712 (define_insn "*cmpdi_orcm_0"
1713   [(set (match_operand:BI 0 "register_operand" "=c")
1714         (ior:BI (not:BI (match_operator:BI 4 "predicate_operator"
1715                          [(match_operand:DI 2 "gr_register_operand" "r")
1716                           (match_operand:DI 3 "gr_reg_or_8bit_operand" "rK")]))
1717                 (match_operand:BI 1 "register_operand" "0")))]
1718   ""
1719   "cmp.%C4.and.orcm %I0, %0 = %3, %2"
1720   [(set_attr "itanium_class" "icmp")])
1721
1722 (define_insn "*cmpdi_orcm_1"
1723   [(set (match_operand:BI 0 "register_operand" "=c")
1724         (ior:BI (not:BI (match_operator:BI 3 "signed_inequality_operator"
1725                           [(match_operand:DI 2 "gr_register_operand" "r")
1726                            (const_int 0)]))
1727                 (match_operand:BI 1 "register_operand" "0")))]
1728   ""
1729   "cmp.%C3.and.orcm %I0, %0 = r0, %2"
1730   [(set_attr "itanium_class" "icmp")])
1731
1732 (define_insn "*tbit_or_0"
1733   [(set (match_operand:BI 0 "register_operand" "=c")
1734         (ior:BI (ne:BI (and:DI (match_operand:DI 1 "gr_register_operand" "r")
1735                                (const_int 1))
1736                        (const_int 0))
1737                 (match_operand:BI 2 "register_operand" "0")))]
1738   ""
1739   "tbit.nz.or.andcm %0, %I0 = %1, 0"
1740   [(set_attr "itanium_class" "tbit")])
1741
1742 (define_insn "*tbit_or_1"
1743   [(set (match_operand:BI 0 "register_operand" "=c")
1744         (ior:BI (eq:BI (and:DI (match_operand:DI 1 "gr_register_operand" "r")
1745                                (const_int 1))
1746                        (const_int 0))
1747                 (match_operand:BI 2 "register_operand" "0")))]
1748   ""
1749   "tbit.z.or.andcm %0, %I0 = %1, 0"
1750   [(set_attr "itanium_class" "tbit")])
1751
1752 (define_insn "*tbit_or_2"
1753   [(set (match_operand:BI 0 "register_operand" "=c")
1754         (ior:BI (ne:BI (zero_extract:DI
1755                          (match_operand:DI 1 "gr_register_operand" "r")
1756                          (const_int 1)
1757                          (match_operand:DI 2 "shift_count_operand" "M"))
1758                        (const_int 0))
1759                 (match_operand:BI 3 "register_operand" "0")))]
1760   ""
1761   "tbit.nz.or.andcm %0, %I0 = %1, %2"
1762   [(set_attr "itanium_class" "tbit")])
1763
1764 (define_insn "*tbit_or_3"
1765   [(set (match_operand:BI 0 "register_operand" "=c")
1766         (ior:BI (eq:BI (zero_extract:DI
1767                          (match_operand:DI 1 "gr_register_operand" "r")
1768                          (const_int 1)
1769                          (match_operand:DI 2 "shift_count_operand" "M"))
1770                        (const_int 0))
1771                 (match_operand:BI 3 "register_operand" "0")))]
1772   ""
1773   "tbit.z.or.andcm %0, %I0 = %1, %2"
1774   [(set_attr "itanium_class" "tbit")])
1775
1776 ;; Transform test of and/or of setcc into parallel comparisons.
1777
1778 (define_split
1779   [(set (match_operand:BI 0 "register_operand" "")
1780         (ne:BI (and:DI (ne:DI (match_operand:BI 2 "register_operand" "")
1781                               (const_int 0))
1782                        (match_operand:DI 3 "register_operand" ""))
1783                (const_int 0)))]
1784   ""
1785   [(set (match_dup 0)
1786         (and:BI (ne:BI (and:DI (match_dup 3) (const_int 1)) (const_int 0))
1787                 (match_dup 2)))]
1788   "")
1789
1790 (define_split
1791   [(set (match_operand:BI 0 "register_operand" "")
1792         (eq:BI (and:DI (ne:DI (match_operand:BI 2 "register_operand" "")
1793                               (const_int 0))
1794                        (match_operand:DI 3 "register_operand" ""))
1795                (const_int 0)))]
1796   ""
1797   [(set (match_dup 0)
1798         (and:BI (ne:BI (and:DI (match_dup 3) (const_int 1)) (const_int 0))
1799                 (match_dup 2)))
1800    (parallel [(set (match_dup 0) (not:BI (match_dup 0)))
1801               (clobber (scratch))])]
1802   "")
1803
1804 (define_split
1805   [(set (match_operand:BI 0 "register_operand" "")
1806         (ne:BI (ior:DI (ne:DI (match_operand:BI 2 "register_operand" "")
1807                               (const_int 0))
1808                        (match_operand:DI 3 "register_operand" ""))
1809                (const_int 0)))]
1810   ""
1811   [(set (match_dup 0) 
1812         (ior:BI (ne:BI (match_dup 3) (const_int 0))
1813                 (match_dup 2)))]
1814   "")
1815
1816 (define_split
1817   [(set (match_operand:BI 0 "register_operand" "")
1818         (eq:BI (ior:DI (ne:DI (match_operand:BI 2 "register_operand" "")
1819                               (const_int 0))
1820                        (match_operand:DI 3 "register_operand" ""))
1821                (const_int 0)))]
1822   ""
1823   [(set (match_dup 0) 
1824         (ior:BI (ne:BI (match_dup 3) (const_int 0))
1825                 (match_dup 2)))
1826    (parallel [(set (match_dup 0) (not:BI (match_dup 0)))
1827               (clobber (scratch))])]
1828   "")
1829
1830 ;; ??? Incredibly hackish.  Either need four proper patterns with all
1831 ;; the alternatives, or rely on sched1 to split the insn and hope that
1832 ;; nothing bad happens to the comparisons in the meantime.
1833 ;;
1834 ;; Alternately, adjust combine to allow 2->2 and 3->3 splits, assuming
1835 ;; that we're doing height reduction.
1836 ;
1837 ;(define_insn_and_split ""
1838 ;  [(set (match_operand:BI 0 "register_operand" "=c")
1839 ;       (and:BI (and:BI (match_operator:BI 1 "comparison_operator"
1840 ;                         [(match_operand 2 "" "")
1841 ;                          (match_operand 3 "" "")])
1842 ;                       (match_operator:BI 4 "comparison_operator"
1843 ;                         [(match_operand 5 "" "")
1844 ;                          (match_operand 6 "" "")]))
1845 ;               (match_dup 0)))]
1846 ;  "flag_schedule_insns"
1847 ;  "#"
1848 ;  ""
1849 ;  [(set (match_dup 0) (and:BI (match_dup 1) (match_dup 0)))
1850 ;   (set (match_dup 0) (and:BI (match_dup 4) (match_dup 0)))]
1851 ;  "")
1852 ;
1853 ;(define_insn_and_split ""
1854 ;  [(set (match_operand:BI 0 "register_operand" "=c")
1855 ;       (ior:BI (ior:BI (match_operator:BI 1 "comparison_operator"
1856 ;                         [(match_operand 2 "" "")
1857 ;                          (match_operand 3 "" "")])
1858 ;                       (match_operator:BI 4 "comparison_operator"
1859 ;                         [(match_operand 5 "" "")
1860 ;                          (match_operand 6 "" "")]))
1861 ;               (match_dup 0)))]
1862 ;  "flag_schedule_insns"
1863 ;  "#"
1864 ;  ""
1865 ;  [(set (match_dup 0) (ior:BI (match_dup 1) (match_dup 0)))
1866 ;   (set (match_dup 0) (ior:BI (match_dup 4) (match_dup 0)))]
1867 ;  "")
1868 ;
1869 ;(define_split
1870 ;  [(set (match_operand:BI 0 "register_operand" "")
1871 ;       (and:BI (and:BI (match_operator:BI 1 "comparison_operator"
1872 ;                         [(match_operand 2 "" "")
1873 ;                          (match_operand 3 "" "")])
1874 ;                       (match_operand:BI 7 "register_operand" ""))
1875 ;               (and:BI (match_operator:BI 4 "comparison_operator"
1876 ;                         [(match_operand 5 "" "")
1877 ;                          (match_operand 6 "" "")])
1878 ;                       (match_operand:BI 8 "register_operand" ""))))]
1879 ;  ""
1880 ;  [(set (match_dup 0) (and:BI (match_dup 7) (match_dup 8)))
1881 ;   (set (match_dup 0) (and:BI (and:BI (match_dup 1) (match_dup 4))
1882 ;                             (match_dup 0)))]
1883 ;  "")
1884 ;
1885 ;(define_split
1886 ;  [(set (match_operand:BI 0 "register_operand" "")
1887 ;       (ior:BI (ior:BI (match_operator:BI 1 "comparison_operator"
1888 ;                         [(match_operand 2 "" "")
1889 ;                          (match_operand 3 "" "")])
1890 ;                       (match_operand:BI 7 "register_operand" ""))
1891 ;               (ior:BI (match_operator:BI 4 "comparison_operator"
1892 ;                         [(match_operand 5 "" "")
1893 ;                          (match_operand 6 "" "")])
1894 ;                       (match_operand:BI 8 "register_operand" ""))))]
1895 ;  ""
1896 ;  [(set (match_dup 0) (ior:BI (match_dup 7) (match_dup 8)))
1897 ;   (set (match_dup 0) (ior:BI (ior:BI (match_dup 1) (match_dup 4))
1898 ;                             (match_dup 0)))]
1899 ;  "")
1900
1901 ;; Try harder to avoid predicate copies by duplicating compares.
1902 ;; Note that we'll have already split the predicate copy, which
1903 ;; is kind of a pain, but oh well.
1904
1905 (define_peephole2
1906   [(set (match_operand:BI 0 "register_operand" "")
1907         (match_operand:BI 1 "comparison_operator" ""))
1908    (set (match_operand:CCI 2 "register_operand" "")
1909         (match_operand:CCI 3 "register_operand" ""))
1910    (set (match_operand:CCI 4 "register_operand" "")
1911         (match_operand:CCI 5 "register_operand" ""))
1912    (set (match_operand:BI 6 "register_operand" "")
1913         (unspec:BI [(match_dup 6)] UNSPEC_PRED_REL_MUTEX))]
1914   "REGNO (operands[3]) == REGNO (operands[0])
1915    && REGNO (operands[4]) == REGNO (operands[0]) + 1
1916    && REGNO (operands[4]) == REGNO (operands[2]) + 1
1917    && REGNO (operands[6]) == REGNO (operands[2])"
1918   [(set (match_dup 0) (match_dup 1))
1919    (set (match_dup 6) (match_dup 7))]
1920   "operands[7] = copy_rtx (operands[1]);")
1921 \f
1922 ;; ::::::::::::::::::::
1923 ;; ::
1924 ;; :: 16-bit Integer arithmetic
1925 ;; ::
1926 ;; ::::::::::::::::::::
1927
1928 (define_insn "mulhi3"
1929   [(set (match_operand:HI 0 "gr_register_operand" "=r")
1930         (mult:HI (match_operand:HI 1 "gr_register_operand" "r")
1931                  (match_operand:HI 2 "gr_register_operand" "r")))]
1932   ""
1933   "pmpy2.r %0 = %1, %2"
1934   [(set_attr "itanium_class" "mmmul")])
1935
1936 \f
1937 ;; ::::::::::::::::::::
1938 ;; ::
1939 ;; :: 32-bit Integer arithmetic
1940 ;; ::
1941 ;; ::::::::::::::::::::
1942
1943 (define_insn "addsi3"
1944   [(set (match_operand:SI 0 "gr_register_operand" "=r,r,r")
1945         (plus:SI (match_operand:SI 1 "gr_register_operand" "%r,r,a")
1946                  (match_operand:SI 2 "gr_reg_or_22bit_operand" "r,I,J")))]
1947   ""
1948   "@
1949    add %0 = %1, %2
1950    adds %0 = %2, %1
1951    addl %0 = %2, %1"
1952   [(set_attr "itanium_class" "ialu")])
1953
1954 (define_insn "*addsi3_plus1"
1955   [(set (match_operand:SI 0 "gr_register_operand" "=r")
1956         (plus:SI (plus:SI (match_operand:SI 1 "gr_register_operand" "r")
1957                           (match_operand:SI 2 "gr_register_operand" "r"))
1958                  (const_int 1)))]
1959   ""
1960   "add %0 = %1, %2, 1"
1961   [(set_attr "itanium_class" "ialu")])
1962
1963 (define_insn "*addsi3_plus1_alt"
1964   [(set (match_operand:SI 0 "gr_register_operand" "=r")
1965         (plus:SI (mult:SI (match_operand:SI 1 "gr_register_operand" "r")
1966                           (const_int 2))
1967                  (const_int 1)))]
1968   ""
1969   "add %0 = %1, %1, 1"
1970   [(set_attr "itanium_class" "ialu")])
1971
1972 (define_insn "*addsi3_shladd"
1973   [(set (match_operand:SI 0 "gr_register_operand" "=r")
1974         (plus:SI (mult:SI (match_operand:SI 1 "gr_register_operand" "r")
1975                           (match_operand:SI 2 "shladd_operand" "n"))
1976                  (match_operand:SI 3 "gr_register_operand" "r")))]
1977   ""
1978   "shladd %0 = %1, %S2, %3"
1979   [(set_attr "itanium_class" "ialu")])
1980
1981 (define_insn "subsi3"
1982   [(set (match_operand:SI 0 "gr_register_operand" "=r")
1983         (minus:SI (match_operand:SI 1 "gr_reg_or_8bit_operand" "rK")
1984                   (match_operand:SI 2 "gr_register_operand" "r")))]
1985   ""
1986   "sub %0 = %1, %2"
1987   [(set_attr "itanium_class" "ialu")])
1988
1989 (define_insn "*subsi3_minus1"
1990   [(set (match_operand:SI 0 "gr_register_operand" "=r")
1991         (plus:SI (not:SI (match_operand:SI 1 "gr_register_operand" "r"))
1992                  (match_operand:SI 2 "gr_register_operand" "r")))]
1993   ""
1994   "sub %0 = %2, %1, 1"
1995   [(set_attr "itanium_class" "ialu")])
1996
1997 ;; ??? Could add maddsi3 patterns patterned after the madddi3 patterns.
1998
1999 (define_insn "mulsi3"
2000   [(set (match_operand:SI 0 "fr_register_operand" "=f")
2001         (mult:SI (match_operand:SI 1 "grfr_register_operand" "f")
2002                  (match_operand:SI 2 "grfr_register_operand" "f")))]
2003   ""
2004   "xmpy.l %0 = %1, %2"
2005   [(set_attr "itanium_class" "xmpy")])
2006
2007 (define_insn "maddsi4"
2008   [(set (match_operand:SI 0 "fr_register_operand" "=f")
2009         (plus:SI (mult:SI (match_operand:SI 1 "grfr_register_operand" "f")
2010                           (match_operand:SI 2 "grfr_register_operand" "f"))
2011                  (match_operand:SI 3 "grfr_register_operand" "f")))]
2012   ""
2013   "xma.l %0 = %1, %2, %3"
2014   [(set_attr "itanium_class" "xmpy")])
2015
2016 (define_insn "negsi2"
2017   [(set (match_operand:SI 0 "gr_register_operand" "=r")
2018         (neg:SI (match_operand:SI 1 "gr_register_operand" "r")))]
2019   ""
2020   "sub %0 = r0, %1"
2021   [(set_attr "itanium_class" "ialu")])
2022
2023 (define_expand "abssi2"
2024   [(set (match_dup 2)
2025         (ge:BI (match_operand:SI 1 "gr_register_operand" "") (const_int 0)))
2026    (set (match_operand:SI 0 "gr_register_operand" "")
2027         (if_then_else:SI (eq (match_dup 2) (const_int 0))
2028                          (neg:SI (match_dup 1))
2029                          (match_dup 1)))]
2030   ""
2031   { operands[2] = gen_reg_rtx (BImode); })
2032
2033 (define_expand "sminsi3"
2034   [(set (match_dup 3)
2035         (ge:BI (match_operand:SI 1 "gr_register_operand" "")
2036                (match_operand:SI 2 "gr_register_operand" "")))
2037    (set (match_operand:SI 0 "gr_register_operand" "")
2038         (if_then_else:SI (ne (match_dup 3) (const_int 0))
2039                          (match_dup 2) (match_dup 1)))]
2040   ""
2041   { operands[3] = gen_reg_rtx (BImode); })
2042
2043 (define_expand "smaxsi3"
2044   [(set (match_dup 3)
2045         (ge:BI (match_operand:SI 1 "gr_register_operand" "")
2046                (match_operand:SI 2 "gr_register_operand" "")))
2047    (set (match_operand:SI 0 "gr_register_operand" "")
2048         (if_then_else:SI (ne (match_dup 3) (const_int 0))
2049                          (match_dup 1) (match_dup 2)))]
2050   ""
2051   { operands[3] = gen_reg_rtx (BImode); })
2052
2053 (define_expand "uminsi3"
2054   [(set (match_dup 3)
2055         (geu:BI (match_operand:SI 1 "gr_register_operand" "")
2056                 (match_operand:SI 2 "gr_register_operand" "")))
2057    (set (match_operand:SI 0 "gr_register_operand" "")
2058         (if_then_else:SI (ne (match_dup 3) (const_int 0))
2059                          (match_dup 2) (match_dup 1)))]
2060   ""
2061   { operands[3] = gen_reg_rtx (BImode); })
2062
2063 (define_expand "umaxsi3"
2064   [(set (match_dup 3)
2065         (geu:BI (match_operand:SI 1 "gr_register_operand" "")
2066                 (match_operand:SI 2 "gr_register_operand" "")))
2067    (set (match_operand:SI 0 "gr_register_operand" "")
2068         (if_then_else:SI (ne (match_dup 3) (const_int 0))
2069                          (match_dup 1) (match_dup 2)))]
2070   ""
2071   { operands[3] = gen_reg_rtx (BImode); })
2072
2073 (define_expand "divsi3"
2074   [(set (match_operand:SI 0 "register_operand" "")
2075         (div:SI (match_operand:SI 1 "general_operand" "")
2076                 (match_operand:SI 2 "general_operand" "")))]
2077   "TARGET_INLINE_INT_DIV"
2078 {
2079   rtx op1_xf, op2_xf, op0_xf, op0_di, twon34, twon34_exp;
2080
2081   op0_xf = gen_reg_rtx (XFmode);
2082   op0_di = gen_reg_rtx (DImode);
2083
2084   if (CONSTANT_P (operands[1]))
2085     operands[1] = force_reg (SImode, operands[1]);
2086   op1_xf = gen_reg_rtx (XFmode);
2087   expand_float (op1_xf, operands[1], 0);
2088
2089   if (CONSTANT_P (operands[2]))
2090     operands[2] = force_reg (SImode, operands[2]);
2091   op2_xf = gen_reg_rtx (XFmode);
2092   expand_float (op2_xf, operands[2], 0);
2093
2094   /* 2^-34 */
2095   twon34_exp = gen_reg_rtx (DImode);
2096   emit_move_insn (twon34_exp, GEN_INT (65501));
2097   twon34 = gen_reg_rtx (XFmode);
2098   emit_insn (gen_setf_exp_xf (twon34, twon34_exp));
2099
2100   emit_insn (gen_cond_trap (EQ, operands[2], CONST0_RTX (SImode),
2101                             CONST1_RTX (SImode)));
2102   
2103   emit_insn (gen_divsi3_internal (op0_xf, op1_xf, op2_xf, twon34));
2104
2105   emit_insn (gen_fix_truncxfdi2_alts (op0_di, op0_xf, const1_rtx));
2106   emit_move_insn (operands[0], gen_lowpart (SImode, op0_di));
2107   DONE;
2108 })
2109
2110 (define_expand "modsi3"
2111   [(set (match_operand:SI 0 "register_operand" "")
2112         (mod:SI (match_operand:SI 1 "general_operand" "")
2113                 (match_operand:SI 2 "general_operand" "")))]
2114   "TARGET_INLINE_INT_DIV"
2115 {
2116   rtx op2_neg, op1_di, div;
2117
2118   div = gen_reg_rtx (SImode);
2119   emit_insn (gen_divsi3 (div, operands[1], operands[2]));
2120
2121   op2_neg = expand_unop (SImode, neg_optab, operands[2], NULL_RTX, 0);
2122
2123   /* This is a trick to get us to reuse the value that we're sure to
2124      have already copied to the FP regs.  */
2125   op1_di = gen_reg_rtx (DImode);
2126   convert_move (op1_di, operands[1], 0);
2127
2128   emit_insn (gen_maddsi4 (operands[0], div, op2_neg,
2129                           gen_lowpart (SImode, op1_di)));
2130   DONE;
2131 })
2132
2133 (define_expand "udivsi3"
2134   [(set (match_operand:SI 0 "register_operand" "")
2135         (udiv:SI (match_operand:SI 1 "general_operand" "")
2136                  (match_operand:SI 2 "general_operand" "")))]
2137   "TARGET_INLINE_INT_DIV"
2138 {
2139   rtx op1_xf, op2_xf, op0_xf, op0_di, twon34, twon34_exp;
2140
2141   op0_xf = gen_reg_rtx (XFmode);
2142   op0_di = gen_reg_rtx (DImode);
2143
2144   if (CONSTANT_P (operands[1]))
2145     operands[1] = force_reg (SImode, operands[1]);
2146   op1_xf = gen_reg_rtx (XFmode);
2147   expand_float (op1_xf, operands[1], 1);
2148
2149   if (CONSTANT_P (operands[2]))
2150     operands[2] = force_reg (SImode, operands[2]);
2151   op2_xf = gen_reg_rtx (XFmode);
2152   expand_float (op2_xf, operands[2], 1);
2153
2154   /* 2^-34 */
2155   twon34_exp = gen_reg_rtx (DImode);
2156   emit_move_insn (twon34_exp, GEN_INT (65501));
2157   twon34 = gen_reg_rtx (XFmode);
2158   emit_insn (gen_setf_exp_xf (twon34, twon34_exp));
2159
2160   emit_insn (gen_cond_trap (EQ, operands[2], CONST0_RTX (SImode),
2161                             CONST1_RTX (SImode)));
2162   
2163   emit_insn (gen_divsi3_internal (op0_xf, op1_xf, op2_xf, twon34));
2164
2165   emit_insn (gen_fixuns_truncxfdi2_alts (op0_di, op0_xf, const1_rtx));
2166   emit_move_insn (operands[0], gen_lowpart (SImode, op0_di));
2167   DONE;
2168 })
2169
2170 (define_expand "umodsi3"
2171   [(set (match_operand:SI 0 "register_operand" "")
2172         (umod:SI (match_operand:SI 1 "general_operand" "")
2173                  (match_operand:SI 2 "general_operand" "")))]
2174   "TARGET_INLINE_INT_DIV"
2175 {
2176   rtx op2_neg, op1_di, div;
2177
2178   div = gen_reg_rtx (SImode);
2179   emit_insn (gen_udivsi3 (div, operands[1], operands[2]));
2180
2181   op2_neg = expand_unop (SImode, neg_optab, operands[2], NULL_RTX, 0);
2182
2183   /* This is a trick to get us to reuse the value that we're sure to
2184      have already copied to the FP regs.  */
2185   op1_di = gen_reg_rtx (DImode);
2186   convert_move (op1_di, operands[1], 1);
2187
2188   emit_insn (gen_maddsi4 (operands[0], div, op2_neg,
2189                           gen_lowpart (SImode, op1_di)));
2190   DONE;
2191 })
2192
2193 (define_insn_and_split "divsi3_internal"
2194   [(set (match_operand:XF 0 "fr_register_operand" "=&f")
2195         (float:XF (div:SI (match_operand:XF 1 "fr_register_operand" "f")
2196                           (match_operand:XF 2 "fr_register_operand" "f"))))
2197    (clobber (match_scratch:XF 4 "=&f"))
2198    (clobber (match_scratch:XF 5 "=&f"))
2199    (clobber (match_scratch:BI 6 "=c"))
2200    (use (match_operand:XF 3 "fr_register_operand" "f"))]
2201   "TARGET_INLINE_INT_DIV"
2202   "#"
2203   "&& reload_completed"
2204   [(parallel [(set (match_dup 0) (div:XF (const_int 1) (match_dup 2)))
2205               (set (match_dup 6) (unspec:BI [(match_dup 1) (match_dup 2)]
2206                                             UNSPEC_FR_RECIP_APPROX))
2207               (use (const_int 1))])
2208    (cond_exec (ne (match_dup 6) (const_int 0))
2209      (parallel [(set (match_dup 4) (mult:XF (match_dup 1) (match_dup 0)))
2210                 (use (const_int 1))]))
2211    (cond_exec (ne (match_dup 6) (const_int 0))
2212      (parallel [(set (match_dup 5)
2213                      (minus:XF (match_dup 7)
2214                                (mult:XF (match_dup 2) (match_dup 0))))
2215                 (use (const_int 1))]))
2216    (cond_exec (ne (match_dup 6) (const_int 0))
2217      (parallel [(set (match_dup 4)
2218                      (plus:XF (mult:XF (match_dup 5) (match_dup 4))
2219                               (match_dup 4)))
2220                 (use (const_int 1))]))
2221    (cond_exec (ne (match_dup 6) (const_int 0))
2222      (parallel [(set (match_dup 5)
2223                      (plus:XF (mult:XF (match_dup 5) (match_dup 5))
2224                               (match_dup 3)))
2225                 (use (const_int 1))]))
2226    (cond_exec (ne (match_dup 6) (const_int 0))
2227      (parallel [(set (match_dup 0)
2228                      (plus:XF (mult:XF (match_dup 5) (match_dup 4))
2229                               (match_dup 4)))
2230                 (use (const_int 1))]))
2231   ] 
2232   "operands[7] = CONST1_RTX (XFmode);"
2233   [(set_attr "predicable" "no")])
2234 \f
2235 ;; ::::::::::::::::::::
2236 ;; ::
2237 ;; :: 64-bit Integer arithmetic
2238 ;; ::
2239 ;; ::::::::::::::::::::
2240
2241 (define_insn "adddi3"
2242   [(set (match_operand:DI 0 "gr_register_operand" "=r,r,r")
2243         (plus:DI (match_operand:DI 1 "gr_register_operand" "%r,r,a")
2244                  (match_operand:DI 2 "gr_reg_or_22bit_operand" "r,I,J")))]
2245   ""
2246   "@
2247    add %0 = %1, %2
2248    adds %0 = %2, %1
2249    addl %0 = %2, %1"
2250   [(set_attr "itanium_class" "ialu")])
2251
2252 (define_insn "*adddi3_plus1"
2253   [(set (match_operand:DI 0 "gr_register_operand" "=r")
2254         (plus:DI (plus:DI (match_operand:DI 1 "gr_register_operand" "r")
2255                           (match_operand:DI 2 "gr_register_operand" "r"))
2256                  (const_int 1)))]
2257   ""
2258   "add %0 = %1, %2, 1"
2259   [(set_attr "itanium_class" "ialu")])
2260
2261 ;; This has some of the same problems as shladd.  We let the shladd
2262 ;; eliminator hack handle it, which results in the 1 being forced into
2263 ;; a register, but not more ugliness here.
2264 (define_insn "*adddi3_plus1_alt"
2265   [(set (match_operand:DI 0 "gr_register_operand" "=r")
2266         (plus:DI (mult:DI (match_operand:DI 1 "gr_register_operand" "r")
2267                           (const_int 2))
2268                  (const_int 1)))]
2269   ""
2270   "add %0 = %1, %1, 1"
2271   [(set_attr "itanium_class" "ialu")])
2272
2273 (define_insn "subdi3"
2274   [(set (match_operand:DI 0 "gr_register_operand" "=r")
2275         (minus:DI (match_operand:DI 1 "gr_reg_or_8bit_operand" "rK")
2276                   (match_operand:DI 2 "gr_register_operand" "r")))]
2277   ""
2278   "sub %0 = %1, %2"
2279   [(set_attr "itanium_class" "ialu")])
2280
2281 (define_insn "*subdi3_minus1"
2282   [(set (match_operand:DI 0 "gr_register_operand" "=r")
2283         (plus:DI (not:DI (match_operand:DI 1 "gr_register_operand" "r"))
2284                  (match_operand:DI 2 "gr_register_operand" "r")))]
2285   ""
2286   "sub %0 = %2, %1, 1"
2287   [(set_attr "itanium_class" "ialu")])
2288
2289 ;; ??? Use grfr instead of fr because of virtual register elimination
2290 ;; and silly test cases multiplying by the frame pointer.
2291 (define_insn "muldi3"
2292   [(set (match_operand:DI 0 "fr_register_operand" "=f")
2293         (mult:DI (match_operand:DI 1 "grfr_register_operand" "f")
2294                  (match_operand:DI 2 "grfr_register_operand" "f")))]
2295   ""
2296   "xmpy.l %0 = %1, %2"
2297   [(set_attr "itanium_class" "xmpy")])
2298
2299 ;; ??? If operand 3 is an eliminable reg, then register elimination causes the
2300 ;; same problem that we have with shladd below.  Unfortunately, this case is
2301 ;; much harder to fix because the multiply puts the result in an FP register,
2302 ;; but the add needs inputs from a general register.  We add a spurious clobber
2303 ;; here so that it will be present just in case register elimination gives us
2304 ;; the funny result.
2305
2306 ;; ??? Maybe validate_changes should try adding match_scratch clobbers?
2307
2308 ;; ??? Maybe we should change how adds are canonicalized.
2309
2310 (define_insn "madddi4"
2311   [(set (match_operand:DI 0 "fr_register_operand" "=f")
2312         (plus:DI (mult:DI (match_operand:DI 1 "grfr_register_operand" "f")
2313                           (match_operand:DI 2 "grfr_register_operand" "f"))
2314                  (match_operand:DI 3 "grfr_register_operand" "f")))
2315    (clobber (match_scratch:DI 4 "=X"))]
2316   ""
2317   "xma.l %0 = %1, %2, %3"
2318   [(set_attr "itanium_class" "xmpy")])
2319
2320 ;; This can be created by register elimination if operand3 of shladd is an
2321 ;; eliminable register or has reg_equiv_constant set.
2322
2323 ;; We have to use nonmemory_operand for operand 4, to ensure that the
2324 ;; validate_changes call inside eliminate_regs will always succeed.  If it
2325 ;; doesn't succeed, then this remain a madddi4 pattern, and will be reloaded
2326 ;; incorrectly.
2327
2328 (define_insn "*madddi4_elim"
2329   [(set (match_operand:DI 0 "register_operand" "=&r")
2330         (plus:DI (plus:DI (mult:DI (match_operand:DI 1 "register_operand" "f")
2331                                    (match_operand:DI 2 "register_operand" "f"))
2332                           (match_operand:DI 3 "register_operand" "f"))
2333                  (match_operand:DI 4 "nonmemory_operand" "rI")))
2334    (clobber (match_scratch:DI 5 "=f"))]
2335   "reload_in_progress"
2336   "#"
2337   [(set_attr "itanium_class" "unknown")])
2338
2339 (define_split
2340   [(set (match_operand:DI 0 "register_operand" "")
2341         (plus:DI (plus:DI (mult:DI (match_operand:DI 1 "register_operand" "")
2342                                    (match_operand:DI 2 "register_operand" ""))
2343                           (match_operand:DI 3 "register_operand" ""))
2344                  (match_operand:DI 4 "gr_reg_or_14bit_operand" "")))
2345    (clobber (match_scratch:DI 5 ""))]
2346   "reload_completed"
2347   [(parallel [(set (match_dup 5) (plus:DI (mult:DI (match_dup 1) (match_dup 2))
2348                                           (match_dup 3)))
2349               (clobber (match_dup 0))])
2350    (set (match_dup 0) (match_dup 5))
2351    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 4)))]
2352   "")
2353
2354 (define_insn "smuldi3_highpart"
2355   [(set (match_operand:DI 0 "fr_register_operand" "=f")
2356         (truncate:DI
2357          (lshiftrt:TI
2358           (mult:TI (sign_extend:TI
2359                      (match_operand:DI 1 "fr_register_operand" "f"))
2360                    (sign_extend:TI
2361                      (match_operand:DI 2 "fr_register_operand" "f")))
2362           (const_int 64))))]
2363   ""
2364   "xmpy.h %0 = %1, %2"
2365   [(set_attr "itanium_class" "xmpy")])
2366
2367 (define_insn "umuldi3_highpart"
2368   [(set (match_operand:DI 0 "fr_register_operand" "=f")
2369         (truncate:DI
2370          (lshiftrt:TI
2371           (mult:TI (zero_extend:TI
2372                      (match_operand:DI 1 "fr_register_operand" "f"))
2373                    (zero_extend:TI
2374                      (match_operand:DI 2 "fr_register_operand" "f")))
2375           (const_int 64))))]
2376   ""
2377   "xmpy.hu %0 = %1, %2"
2378   [(set_attr "itanium_class" "xmpy")])
2379
2380 (define_insn "negdi2"
2381   [(set (match_operand:DI 0 "gr_register_operand" "=r")
2382         (neg:DI (match_operand:DI 1 "gr_register_operand" "r")))]
2383   ""
2384   "sub %0 = r0, %1"
2385   [(set_attr "itanium_class" "ialu")])
2386
2387 (define_expand "absdi2"
2388   [(set (match_dup 2)
2389         (ge:BI (match_operand:DI 1 "gr_register_operand" "") (const_int 0)))
2390    (set (match_operand:DI 0 "gr_register_operand" "")
2391         (if_then_else:DI (eq (match_dup 2) (const_int 0))
2392                          (neg:DI (match_dup 1))
2393                          (match_dup 1)))]
2394   ""
2395   { operands[2] = gen_reg_rtx (BImode); })
2396
2397 (define_expand "smindi3"
2398   [(set (match_dup 3)
2399         (ge:BI (match_operand:DI 1 "gr_register_operand" "")
2400                (match_operand:DI 2 "gr_register_operand" "")))
2401    (set (match_operand:DI 0 "gr_register_operand" "")
2402         (if_then_else:DI (ne (match_dup 3) (const_int 0))
2403                          (match_dup 2) (match_dup 1)))]
2404   ""
2405   { operands[3] = gen_reg_rtx (BImode); })
2406
2407 (define_expand "smaxdi3"
2408   [(set (match_dup 3)
2409         (ge:BI (match_operand:DI 1 "gr_register_operand" "")
2410                (match_operand:DI 2 "gr_register_operand" "")))
2411    (set (match_operand:DI 0 "gr_register_operand" "")
2412         (if_then_else:DI (ne (match_dup 3) (const_int 0))
2413                          (match_dup 1) (match_dup 2)))]
2414   ""
2415   { operands[3] = gen_reg_rtx (BImode); })
2416
2417 (define_expand "umindi3"
2418   [(set (match_dup 3)
2419         (geu:BI (match_operand:DI 1 "gr_register_operand" "")
2420                 (match_operand:DI 2 "gr_register_operand" "")))
2421    (set (match_operand:DI 0 "gr_register_operand" "")
2422         (if_then_else:DI (ne (match_dup 3) (const_int 0))
2423                          (match_dup 2) (match_dup 1)))]
2424   ""
2425   { operands[3] = gen_reg_rtx (BImode); })
2426
2427 (define_expand "umaxdi3"
2428   [(set (match_dup 3)
2429         (geu:BI (match_operand:DI 1 "gr_register_operand" "")
2430                 (match_operand:DI 2 "gr_register_operand" "")))
2431    (set (match_operand:DI 0 "gr_register_operand" "")
2432         (if_then_else:DI (ne (match_dup 3) (const_int 0))
2433                          (match_dup 1) (match_dup 2)))]
2434   ""
2435   { operands[3] = gen_reg_rtx (BImode); })
2436
2437 (define_expand "ffsdi2"
2438   [(set (match_dup 6)
2439         (eq:BI (match_operand:DI 1 "gr_register_operand" "") (const_int 0)))
2440    (set (match_dup 2) (plus:DI (match_dup 1) (const_int -1)))
2441    (set (match_dup 5) (const_int 0))
2442    (set (match_dup 3) (xor:DI (match_dup 1) (match_dup 2)))
2443    (set (match_dup 4) (popcount:DI (match_dup 3)))
2444    (set (match_operand:DI 0 "gr_register_operand" "")
2445         (if_then_else:DI (ne (match_dup 6) (const_int 0))
2446                          (match_dup 5) (match_dup 4)))]
2447   ""
2448 {
2449   operands[2] = gen_reg_rtx (DImode);
2450   operands[3] = gen_reg_rtx (DImode);
2451   operands[4] = gen_reg_rtx (DImode);
2452   operands[5] = gen_reg_rtx (DImode);
2453   operands[6] = gen_reg_rtx (BImode);
2454 })
2455
2456 (define_expand "ctzdi2"
2457   [(set (match_dup 2) (plus:DI (match_operand:DI 1 "gr_register_operand" "")
2458                                (const_int -1)))
2459    (set (match_dup 3) (not:DI (match_dup 1)))
2460    (set (match_dup 4) (and:DI (match_dup 2) (match_dup 3)))
2461    (set (match_operand:DI 0 "gr_register_operand" "")
2462         (popcount:DI (match_dup 4)))]
2463   ""
2464 {
2465   operands[2] = gen_reg_rtx (DImode);
2466   operands[3] = gen_reg_rtx (DImode);
2467   operands[4] = gen_reg_rtx (DImode);
2468 })
2469
2470 ;; Note the computation here is op0 = 63 - (exp - 0xffff).
2471 (define_expand "clzdi2"
2472   [(set (match_dup 2)
2473         (unsigned_float:XF (match_operand:DI 1 "fr_register_operand" "")))
2474    (set (match_dup 3)
2475         (unspec:DI [(match_dup 2)] UNSPEC_GETF_EXP))
2476    (set (match_dup 4) (const_int 65598))
2477    (set (match_operand:DI 0 "gr_register_operand" "")
2478         (minus:DI (match_dup 4) (match_dup 3)))]
2479   ""
2480 {
2481   operands[2] = gen_reg_rtx (XFmode);
2482   operands[3] = gen_reg_rtx (DImode);
2483   operands[4] = gen_reg_rtx (DImode);
2484 })
2485
2486 (define_insn "popcountdi2"
2487   [(set (match_operand:DI 0 "gr_register_operand" "=r")
2488         (popcount:DI (match_operand:DI 1 "gr_register_operand" "r")))]
2489   ""
2490   "popcnt %0 = %1"
2491   [(set_attr "itanium_class" "mmmul")])
2492
2493 (define_insn "bswapdi2"
2494   [(set (match_operand:DI 0 "gr_register_operand" "=r")
2495         (bswap:DI (match_operand:DI 1 "gr_register_operand" "r")))]
2496   ""
2497   "mux1 %0 = %1, @rev"
2498   [(set_attr "itanium_class" "mmshf")])
2499
2500 (define_insn "*getf_exp_xf"
2501   [(set (match_operand:DI 0 "gr_register_operand" "=r")
2502         (unspec:DI [(match_operand:XF 1 "fr_register_operand" "f")]
2503                    UNSPEC_GETF_EXP))]
2504   ""
2505   "getf.exp %0 = %1"
2506   [(set_attr "itanium_class" "frfr")])
2507
2508 (define_expand "divdi3"
2509   [(set (match_operand:DI 0 "register_operand" "")
2510         (div:DI (match_operand:DI 1 "general_operand" "")
2511                 (match_operand:DI 2 "general_operand" "")))]
2512   "TARGET_INLINE_INT_DIV"
2513 {
2514   rtx op1_xf, op2_xf, op0_xf;
2515
2516   op0_xf = gen_reg_rtx (XFmode);
2517
2518   if (CONSTANT_P (operands[1]))
2519     operands[1] = force_reg (DImode, operands[1]);
2520   op1_xf = gen_reg_rtx (XFmode);
2521   expand_float (op1_xf, operands[1], 0);
2522
2523   if (CONSTANT_P (operands[2]))
2524     operands[2] = force_reg (DImode, operands[2]);
2525   op2_xf = gen_reg_rtx (XFmode);
2526   expand_float (op2_xf, operands[2], 0);
2527
2528   emit_insn (gen_cond_trap (EQ, operands[2], CONST0_RTX (DImode),
2529                             CONST1_RTX (DImode)));
2530
2531   if (TARGET_INLINE_INT_DIV == INL_MIN_LAT)
2532     emit_insn (gen_divdi3_internal_lat (op0_xf, op1_xf, op2_xf));
2533   else
2534     emit_insn (gen_divdi3_internal_thr (op0_xf, op1_xf, op2_xf));
2535
2536   emit_insn (gen_fix_truncxfdi2_alts (operands[0], op0_xf, const1_rtx));
2537   DONE;
2538 })
2539
2540 (define_expand "moddi3"
2541   [(set (match_operand:DI 0 "register_operand" "")
2542         (mod:SI (match_operand:DI 1 "general_operand" "")
2543                 (match_operand:DI 2 "general_operand" "")))]
2544   "TARGET_INLINE_INT_DIV"
2545 {
2546   rtx op2_neg, div;
2547
2548   div = gen_reg_rtx (DImode);
2549   emit_insn (gen_divdi3 (div, operands[1], operands[2]));
2550
2551   op2_neg = expand_unop (DImode, neg_optab, operands[2], NULL_RTX, 0);
2552
2553   emit_insn (gen_madddi4 (operands[0], div, op2_neg, operands[1]));
2554   DONE;
2555 })
2556
2557 (define_expand "udivdi3"
2558   [(set (match_operand:DI 0 "register_operand" "")
2559         (udiv:DI (match_operand:DI 1 "general_operand" "")
2560                  (match_operand:DI 2 "general_operand" "")))]
2561   "TARGET_INLINE_INT_DIV"
2562 {
2563   rtx op1_xf, op2_xf, op0_xf;
2564
2565   op0_xf = gen_reg_rtx (XFmode);
2566
2567   if (CONSTANT_P (operands[1]))
2568     operands[1] = force_reg (DImode, operands[1]);
2569   op1_xf = gen_reg_rtx (XFmode);
2570   expand_float (op1_xf, operands[1], 1);
2571
2572   if (CONSTANT_P (operands[2]))
2573     operands[2] = force_reg (DImode, operands[2]);
2574   op2_xf = gen_reg_rtx (XFmode);
2575   expand_float (op2_xf, operands[2], 1);
2576
2577   emit_insn (gen_cond_trap (EQ, operands[2], CONST0_RTX (DImode),
2578                             CONST1_RTX (DImode)));
2579
2580   if (TARGET_INLINE_INT_DIV == INL_MIN_LAT)
2581     emit_insn (gen_divdi3_internal_lat (op0_xf, op1_xf, op2_xf));
2582   else
2583     emit_insn (gen_divdi3_internal_thr (op0_xf, op1_xf, op2_xf));
2584
2585   emit_insn (gen_fixuns_truncxfdi2_alts (operands[0], op0_xf, const1_rtx));
2586   DONE;
2587 })
2588
2589 (define_expand "umoddi3"
2590   [(set (match_operand:DI 0 "register_operand" "")
2591         (umod:DI (match_operand:DI 1 "general_operand" "")
2592                  (match_operand:DI 2 "general_operand" "")))]
2593   "TARGET_INLINE_INT_DIV"
2594 {
2595   rtx op2_neg, div;
2596
2597   div = gen_reg_rtx (DImode);
2598   emit_insn (gen_udivdi3 (div, operands[1], operands[2]));
2599
2600   op2_neg = expand_unop (DImode, neg_optab, operands[2], NULL_RTX, 0);
2601
2602   emit_insn (gen_madddi4 (operands[0], div, op2_neg, operands[1]));
2603   DONE;
2604 })
2605
2606 (define_insn_and_split "divdi3_internal_lat"
2607   [(set (match_operand:XF 0 "fr_register_operand" "=&f")
2608         (float:XF (div:SI (match_operand:XF 1 "fr_register_operand" "f")
2609                           (match_operand:XF 2 "fr_register_operand" "f"))))
2610    (clobber (match_scratch:XF 3 "=&f"))
2611    (clobber (match_scratch:XF 4 "=&f"))
2612    (clobber (match_scratch:XF 5 "=&f"))
2613    (clobber (match_scratch:BI 6 "=c"))]
2614   "TARGET_INLINE_INT_DIV == INL_MIN_LAT"
2615   "#"
2616   "&& reload_completed"
2617   [(parallel [(set (match_dup 0) (div:XF (const_int 1) (match_dup 2)))
2618               (set (match_dup 6) (unspec:BI [(match_dup 1) (match_dup 2)]
2619                                             UNSPEC_FR_RECIP_APPROX))
2620               (use (const_int 1))])
2621    (cond_exec (ne (match_dup 6) (const_int 0))
2622      (parallel [(set (match_dup 3)
2623                      (minus:XF (match_dup 7)
2624                                (mult:XF (match_dup 2) (match_dup 0))))
2625                 (use (const_int 1))]))
2626    (cond_exec (ne (match_dup 6) (const_int 0))
2627      (parallel [(set (match_dup 4) (mult:XF (match_dup 1) (match_dup 0)))
2628                 (use (const_int 1))]))
2629    (cond_exec (ne (match_dup 6) (const_int 0))
2630      (parallel [(set (match_dup 5) (mult:XF (match_dup 3) (match_dup 3)))
2631                 (use (const_int 1))]))
2632    (cond_exec (ne (match_dup 6) (const_int 0))
2633      (parallel [(set (match_dup 4)
2634                      (plus:XF (mult:XF (match_dup 3) (match_dup 4))
2635                               (match_dup 4)))
2636                 (use (const_int 1))]))
2637    (cond_exec (ne (match_dup 6) (const_int 0))
2638      (parallel [(set (match_dup 0)
2639                      (plus:XF (mult:XF (match_dup 3) (match_dup 0))
2640                               (match_dup 0)))
2641                 (use (const_int 1))]))
2642    (cond_exec (ne (match_dup 6) (const_int 0))
2643      (parallel [(set (match_dup 3)
2644                      (plus:XF (mult:XF (match_dup 5) (match_dup 4))
2645                               (match_dup 4)))
2646                 (use (const_int 1))]))
2647    (cond_exec (ne (match_dup 6) (const_int 0))
2648      (parallel [(set (match_dup 0)
2649                      (plus:XF (mult:XF (match_dup 5) (match_dup 0))
2650                               (match_dup 0)))
2651                 (use (const_int 1))]))
2652    (cond_exec (ne (match_dup 6) (const_int 0))
2653      (parallel [(set (match_dup 4)
2654                      (minus:XF (match_dup 1)
2655                                (mult:XF (match_dup 2) (match_dup 3))))
2656                 (use (const_int 1))]))
2657    (cond_exec (ne (match_dup 6) (const_int 0))
2658      (parallel [(set (match_dup 0)
2659                      (plus:XF (mult:XF (match_dup 4) (match_dup 0))
2660                               (match_dup 3)))
2661                 (use (const_int 1))]))
2662   ] 
2663   "operands[7] = CONST1_RTX (XFmode);"
2664   [(set_attr "predicable" "no")])
2665
2666 (define_insn_and_split "divdi3_internal_thr"
2667   [(set (match_operand:XF 0 "fr_register_operand" "=&f")
2668         (float:XF (div:SI (match_operand:XF 1 "fr_register_operand" "f")
2669                           (match_operand:XF 2 "fr_register_operand" "f"))))
2670    (clobber (match_scratch:XF 3 "=&f"))
2671    (clobber (match_scratch:XF 4 "=f"))
2672    (clobber (match_scratch:BI 5 "=c"))]
2673   "TARGET_INLINE_INT_DIV == INL_MAX_THR"
2674   "#"
2675   "&& reload_completed"
2676   [(parallel [(set (match_dup 0) (div:XF (const_int 1) (match_dup 2)))
2677               (set (match_dup 5) (unspec:BI [(match_dup 1) (match_dup 2)] 
2678                                             UNSPEC_FR_RECIP_APPROX))
2679               (use (const_int 1))])
2680    (cond_exec (ne (match_dup 5) (const_int 0))
2681      (parallel [(set (match_dup 3)
2682                      (minus:XF (match_dup 6)
2683                                (mult:XF (match_dup 2) (match_dup 0))))
2684                 (use (const_int 1))]))
2685    (cond_exec (ne (match_dup 5) (const_int 0))
2686      (parallel [(set (match_dup 0)
2687                      (plus:XF (mult:XF (match_dup 3) (match_dup 0))
2688                               (match_dup 0)))
2689                 (use (const_int 1))]))
2690    (cond_exec (ne (match_dup 5) (const_int 0))
2691      (parallel [(set (match_dup 3) (mult:XF (match_dup 3) (match_dup 3)))
2692                 (use (const_int 1))]))
2693    (cond_exec (ne (match_dup 5) (const_int 0))
2694      (parallel [(set (match_dup 0)
2695                      (plus:XF (mult:XF (match_dup 3) (match_dup 0))
2696                               (match_dup 0)))
2697                 (use (const_int 1))]))
2698    (cond_exec (ne (match_dup 5) (const_int 0))
2699      (parallel [(set (match_dup 3) (mult:XF (match_dup 0) (match_dup 1)))
2700                 (use (const_int 1))]))
2701    (cond_exec (ne (match_dup 5) (const_int 0))
2702      (parallel [(set (match_dup 4)
2703                      (minus:XF (match_dup 1)
2704                                (mult:XF (match_dup 2) (match_dup 3))))
2705                 (use (const_int 1))]))
2706    (cond_exec (ne (match_dup 5) (const_int 0))
2707      (parallel [(set (match_dup 0)
2708                      (plus:XF (mult:XF (match_dup 4) (match_dup 0))
2709                               (match_dup 3)))
2710                 (use (const_int 1))]))
2711   ] 
2712   "operands[6] = CONST1_RTX (XFmode);"
2713   [(set_attr "predicable" "no")])
2714 \f
2715 ;; ::::::::::::::::::::
2716 ;; ::
2717 ;; :: 128-bit Integer arithmetic
2718 ;; ::
2719 ;; ::::::::::::::::::::
2720
2721 (define_insn "addti3"
2722   [(set (match_operand:TI 0 "gr_register_operand" "=&r")
2723         (plus:TI (match_operand:TI 1 "gr_register_operand" "%r")
2724                  (match_operand:TI 2 "gr_reg_or_14bit_operand" "rI")))
2725    (clobber (match_scratch:BI 3 "=&c"))]
2726   ""
2727   "#"
2728   [(set_attr "itanium_class" "unknown")])
2729
2730 (define_split
2731   [(set (match_operand:TI 0 "register_operand" "")
2732         (plus:TI (match_operand:TI 1 "register_operand" "")
2733                  (match_operand:TI 2 "register_operand" "")))
2734    (clobber (match_scratch:BI 3 ""))]
2735   "reload_completed"
2736   [(set (match_dup 0) (plus:DI (match_dup 1) (match_dup 2)))
2737    (set (match_dup 3) (ltu:BI (match_dup 0) (match_dup 1)))
2738    (cond_exec (eq (match_dup 3) (const_int 0))
2739               (set (match_dup 4) (plus:DI (match_dup 5) (match_dup 6))))
2740    (cond_exec (ne (match_dup 3) (const_int 0))
2741               (set (match_dup 4)
2742                    (plus:DI (plus:DI (match_dup 5) (match_dup 6))
2743                             (const_int 1))))]
2744 {
2745   operands[4] = gen_highpart (DImode, operands[0]);
2746   operands[0] = gen_lowpart (DImode, operands[0]);
2747   operands[5] = gen_highpart (DImode, operands[1]);
2748   operands[1] = gen_lowpart (DImode, operands[1]);
2749   operands[6] = gen_highpart (DImode, operands[2]);
2750   operands[2] = gen_lowpart (DImode, operands[2]);
2751 })
2752
2753 (define_split
2754   [(set (match_operand:TI 0 "register_operand" "")
2755         (plus:TI (match_operand:TI 1 "register_operand" "")
2756                  (match_operand:TI 2 "immediate_operand" "")))
2757    (clobber (match_scratch:BI 3 ""))]
2758   "reload_completed"
2759   [(set (match_dup 0) (plus:DI (match_dup 1) (match_dup 2)))
2760    (set (match_dup 3) (ltu:BI (match_dup 0) (match_dup 1)))
2761    (cond_exec (eq (match_dup 3) (const_int 0))
2762               (set (match_dup 4)
2763                    (plus:DI (match_dup 5) (match_dup 6))))
2764    (cond_exec (ne (match_dup 3) (const_int 0))
2765               (set (match_dup 4)
2766                    (plus:DI (match_dup 5) (match_dup 7))))]
2767 {
2768   operands[4] = gen_highpart (DImode, operands[0]);
2769   operands[0] = gen_lowpart (DImode, operands[0]);
2770   operands[5] = gen_highpart (DImode, operands[1]);
2771   operands[1] = gen_lowpart (DImode, operands[1]);
2772   operands[6] = INTVAL (operands[2]) < 0 ? constm1_rtx : const0_rtx;
2773   operands[7] = INTVAL (operands[2]) < 0 ? const0_rtx : const1_rtx;
2774 })
2775
2776 (define_insn "subti3"
2777   [(set (match_operand:TI 0 "gr_register_operand" "=&r")
2778         (minus:TI (match_operand:TI 1 "gr_reg_or_8bit_operand" "rK")
2779                   (match_operand:TI 2 "gr_register_operand" "r")))
2780    (clobber (match_scratch:BI 3 "=&c"))]
2781   ""
2782   "#"
2783   [(set_attr "itanium_class" "unknown")])
2784
2785 (define_split
2786   [(set (match_operand:TI 0 "register_operand" "")
2787         (minus:TI (match_operand:TI 1 "register_operand" "")
2788                   (match_operand:TI 2 "register_operand" "")))
2789    (clobber (match_scratch:BI 3 "=&c"))]
2790   "reload_completed"
2791   [(set (match_dup 0) (minus:DI (match_dup 1) (match_dup 2)))
2792    (set (match_dup 3) (ltu:BI (match_dup 1) (match_dup 0)))
2793    (cond_exec (eq (match_dup 3) (const_int 0))
2794               (set (match_dup 4) (minus:DI (match_dup 5) (match_dup 6))))
2795    (cond_exec (ne (match_dup 3) (const_int 0))
2796               (set (match_dup 4)
2797                    (plus:DI (not:DI (match_dup 6)) (match_dup 5))))]
2798 {
2799   operands[4] = gen_highpart (DImode, operands[0]);
2800   operands[0] = gen_lowpart (DImode, operands[0]);
2801   operands[5] = gen_highpart (DImode, operands[1]);
2802   operands[1] = gen_lowpart (DImode, operands[1]);
2803   operands[6] = gen_highpart (DImode, operands[2]);
2804   operands[2] = gen_lowpart (DImode, operands[2]);
2805 })
2806
2807 (define_split
2808   [(set (match_operand:TI 0 "register_operand" "")
2809         (minus:TI (match_operand:TI 1 "immediate_operand" "")
2810                   (match_operand:TI 2 "register_operand" "")))
2811    (clobber (match_scratch:BI 3 "=&c"))]
2812   "reload_completed && satisfies_constraint_K (operands[1])"
2813   [(set (match_dup 0) (minus:DI (match_dup 1) (match_dup 2)))
2814    (set (match_dup 3) (gtu:BI (match_dup 0) (match_dup 1)))
2815    (cond_exec (ne (match_dup 3) (const_int 0))
2816               (set (match_dup 4) (minus:DI (match_dup 6) (match_dup 5))))
2817    (cond_exec (eq (match_dup 3) (const_int 0))
2818               (set (match_dup 4) (minus:DI (match_dup 7) (match_dup 5))))]
2819 {
2820   operands[4] = gen_highpart (DImode, operands[0]);
2821   operands[0] = gen_lowpart (DImode, operands[0]);
2822   operands[5] = gen_highpart (DImode, operands[2]);
2823   operands[2] = gen_lowpart (DImode, operands[2]);
2824   operands[6] = INTVAL (operands[1]) < 0 ? GEN_INT (-2) : constm1_rtx;
2825   operands[7] = INTVAL (operands[1]) < 0 ? constm1_rtx : const0_rtx;
2826 })
2827
2828 (define_expand "mulditi3"
2829   [(set (match_operand:TI 0 "fr_register_operand" "")
2830         (mult:TI (sign_extend:TI
2831                    (match_operand:DI 1 "fr_register_operand" ""))
2832                  (sign_extend:TI
2833                    (match_operand:DI 2 "fr_register_operand" ""))))]
2834   ""
2835   "")
2836
2837 (define_insn_and_split "*mulditi3_internal"
2838   [(set (match_operand:TI 0 "fr_register_operand" "=&f")
2839         (mult:TI (sign_extend:TI
2840                    (match_operand:DI 1 "fr_register_operand" "%f"))
2841                  (sign_extend:TI
2842                    (match_operand:DI 2 "fr_register_operand" "f"))))]
2843   ""
2844   "#"
2845   "reload_completed"
2846   [(set (match_dup 0) (mult:DI (match_dup 1) (match_dup 2)))
2847    (set (match_dup 3) (truncate:DI
2848                         (lshiftrt:TI
2849                           (mult:TI (sign_extend:TI (match_dup 1))
2850                                    (sign_extend:TI (match_dup 2)))
2851                           (const_int 64))))]
2852 {
2853   operands[3] = gen_highpart (DImode, operands[0]);
2854   operands[0] = gen_lowpart (DImode, operands[0]);
2855 }
2856   [(set_attr "itanium_class" "unknown")])
2857
2858 (define_expand "umulditi3"
2859   [(set (match_operand:TI 0 "fr_register_operand" "")
2860         (mult:TI (zero_extend:TI
2861                    (match_operand:DI 1 "fr_register_operand" ""))
2862                  (zero_extend:TI
2863                    (match_operand:DI 2 "fr_register_operand" ""))))]
2864   ""
2865   "")
2866
2867 (define_insn_and_split "*umulditi3_internal"
2868   [(set (match_operand:TI 0 "fr_register_operand" "=&f")
2869         (mult:TI (zero_extend:TI
2870                    (match_operand:DI 1 "fr_register_operand" "%f"))
2871                  (zero_extend:TI
2872                    (match_operand:DI 2 "fr_register_operand" "f"))))]
2873   ""
2874   "#"
2875   "reload_completed"
2876   [(set (match_dup 0) (mult:DI (match_dup 1) (match_dup 2)))
2877    (set (match_dup 3) (truncate:DI
2878                         (lshiftrt:TI
2879                           (mult:TI (zero_extend:TI (match_dup 1))
2880                                    (zero_extend:TI (match_dup 2)))
2881                           (const_int 64))))]
2882 {
2883   operands[3] = gen_highpart (DImode, operands[0]);
2884   operands[0] = gen_lowpart (DImode, operands[0]);
2885 }
2886   [(set_attr "itanium_class" "unknown")])
2887
2888 (define_insn_and_split "negti2"
2889   [(set (match_operand:TI 0 "gr_register_operand" "=&r")
2890         (neg:TI (match_operand:TI 1 "gr_register_operand" "r")))
2891    (clobber (match_scratch:BI 2 "=&c"))]
2892   ""
2893   "#"
2894   "reload_completed"
2895   [(set (match_dup 2) (eq:BI (match_dup 1) (const_int 0)))
2896    (set (match_dup 0) (minus:DI (const_int 0) (match_dup 1)))
2897    (cond_exec (eq (match_dup 2) (const_int 0))
2898               (set (match_dup 3) (minus:DI (const_int -1) (match_dup 4))))
2899    (cond_exec (ne (match_dup 2) (const_int 0))
2900               (set (match_dup 3) (minus:DI (const_int 0) (match_dup 4))))]
2901 {
2902   operands[3] = gen_highpart (DImode, operands[0]);
2903   operands[0] = gen_lowpart (DImode, operands[0]);
2904   operands[4] = gen_highpart (DImode, operands[1]);
2905   operands[1] = gen_lowpart (DImode, operands[1]);
2906 }
2907   [(set_attr "itanium_class" "unknown")])
2908 \f
2909 ;; ::::::::::::::::::::
2910 ;; ::
2911 ;; :: 32-bit floating point arithmetic
2912 ;; ::
2913 ;; ::::::::::::::::::::
2914
2915 (define_insn "addsf3"
2916   [(set (match_operand:SF 0 "fr_register_operand" "=f")
2917         (plus:SF (match_operand:SF 1 "fr_register_operand" "%f")
2918                  (match_operand:SF 2 "fr_reg_or_fp01_operand" "fG")))]
2919   ""
2920   "fadd.s %0 = %1, %F2"
2921   [(set_attr "itanium_class" "fmac")])
2922
2923 (define_insn "subsf3"
2924   [(set (match_operand:SF 0 "fr_register_operand" "=f")
2925         (minus:SF (match_operand:SF 1 "fr_reg_or_fp01_operand" "fG")
2926                   (match_operand:SF 2 "fr_reg_or_fp01_operand" "fG")))]
2927   ""
2928   "fsub.s %0 = %F1, %F2"
2929   [(set_attr "itanium_class" "fmac")])
2930
2931 (define_insn "mulsf3"
2932   [(set (match_operand:SF 0 "fr_register_operand" "=f")
2933         (mult:SF (match_operand:SF 1 "fr_register_operand" "%f")
2934                  (match_operand:SF 2 "fr_register_operand" "f")))]
2935   ""
2936   "fmpy.s %0 = %1, %2"
2937   [(set_attr "itanium_class" "fmac")])
2938
2939 (define_insn "abssf2"
2940   [(set (match_operand:SF 0 "fr_register_operand" "=f")
2941         (abs:SF (match_operand:SF 1 "fr_register_operand" "f")))]
2942   ""
2943   "fabs %0 = %1"
2944   [(set_attr "itanium_class" "fmisc")])
2945
2946 (define_insn "negsf2"
2947   [(set (match_operand:SF 0 "fr_register_operand" "=f")
2948         (neg:SF (match_operand:SF 1 "fr_register_operand" "f")))]
2949   ""
2950   "fneg %0 = %1"
2951   [(set_attr "itanium_class" "fmisc")])
2952
2953 (define_insn "*nabssf2"
2954   [(set (match_operand:SF 0 "fr_register_operand" "=f")
2955         (neg:SF (abs:SF (match_operand:SF 1 "fr_register_operand" "f"))))]
2956   ""
2957   "fnegabs %0 = %1"
2958   [(set_attr "itanium_class" "fmisc")])
2959
2960 (define_insn "copysignsf3"
2961   [(set (match_operand:SF 0 "register_operand" "=f")
2962         (unspec:SF [(match_operand:SF 1 "fr_reg_or_fp01_operand" "fG")
2963                     (match_operand:SF 2 "fr_reg_or_fp01_operand" "fG")]
2964                    UNSPEC_COPYSIGN))]
2965   ""
2966   "fmerge.s %0 = %F2, %F1"
2967   [(set_attr "itanium_class" "fmisc")])
2968
2969 (define_insn "*ncopysignsf3"
2970   [(set (match_operand:SF 0 "register_operand" "=f")
2971         (neg:SF (unspec:SF [(match_operand:SF 1 "fr_reg_or_fp01_operand" "fG")
2972                             (match_operand:SF 2 "fr_reg_or_fp01_operand" "fG")]
2973                            UNSPEC_COPYSIGN)))]
2974   ""
2975   "fmerge.ns %0 = %F2, %F1"
2976   [(set_attr "itanium_class" "fmisc")])
2977
2978 (define_insn "sminsf3"
2979   [(set (match_operand:SF 0 "fr_register_operand" "=f")
2980         (smin:SF (match_operand:SF 1 "fr_register_operand" "f")
2981                  (match_operand:SF 2 "fr_reg_or_fp01_operand" "fG")))]
2982   ""
2983   "fmin %0 = %1, %F2"
2984   [(set_attr "itanium_class" "fmisc")])
2985
2986 (define_insn "smaxsf3"
2987   [(set (match_operand:SF 0 "fr_register_operand" "=f")
2988         (smax:SF (match_operand:SF 1 "fr_register_operand" "f")
2989                  (match_operand:SF 2 "fr_reg_or_fp01_operand" "fG")))]
2990   ""
2991   "fmax %0 = %1, %F2"
2992   [(set_attr "itanium_class" "fmisc")])
2993
2994 (define_insn "*maddsf4"
2995   [(set (match_operand:SF 0 "fr_register_operand" "=f")
2996         (plus:SF (mult:SF (match_operand:SF 1 "fr_register_operand" "f")
2997                           (match_operand:SF 2 "fr_register_operand" "f"))
2998                  (match_operand:SF 3 "fr_reg_or_fp01_operand" "fG")))]
2999   ""
3000   "fma.s %0 = %1, %2, %F3"
3001   [(set_attr "itanium_class" "fmac")])
3002
3003 (define_insn "*msubsf4"
3004   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3005         (minus:SF (mult:SF (match_operand:SF 1 "fr_register_operand" "f")
3006                            (match_operand:SF 2 "fr_register_operand" "f"))
3007                   (match_operand:SF 3 "fr_reg_or_fp01_operand" "fG")))]
3008   ""
3009   "fms.s %0 = %1, %2, %F3"
3010   [(set_attr "itanium_class" "fmac")])
3011
3012 (define_insn "*nmulsf3"
3013   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3014         (neg:SF (mult:SF (match_operand:SF 1 "fr_register_operand" "f")
3015                          (match_operand:SF 2 "fr_register_operand" "f"))))]
3016   ""
3017   "fnmpy.s %0 = %1, %2"
3018   [(set_attr "itanium_class" "fmac")])
3019
3020 (define_insn "*nmaddsf4"
3021   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3022         (minus:SF (match_operand:SF 3 "fr_reg_or_fp01_operand" "fG") 
3023                   (mult:SF (match_operand:SF 1 "fr_register_operand" "f")
3024                            (match_operand:SF 2 "fr_register_operand" "f"))))]
3025   ""
3026   "fnma.s %0 = %1, %2, %F3"
3027   [(set_attr "itanium_class" "fmac")])
3028
3029 (define_insn "*nmaddsf4_alts"
3030   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3031         (minus:SF (match_operand:SF 3 "fr_reg_or_fp01_operand" "fG") 
3032                   (mult:SF (match_operand:SF 1 "fr_register_operand" "f")
3033                            (match_operand:SF 2 "fr_register_operand" "f"))))
3034    (use (match_operand:SI 4 "const_int_operand" ""))]
3035   ""
3036   "fnma.s.s%4 %0 = %1, %2, %F3"
3037   [(set_attr "itanium_class" "fmac")])
3038
3039 (define_expand "divsf3"
3040   [(set (match_operand:SF 0 "fr_register_operand" "")
3041         (div:SF (match_operand:SF 1 "fr_register_operand" "")
3042                 (match_operand:SF 2 "fr_register_operand" "")))]
3043   "TARGET_INLINE_FLOAT_DIV"
3044 {
3045   rtx insn;
3046   if (TARGET_INLINE_FLOAT_DIV == INL_MIN_LAT)
3047     insn = gen_divsf3_internal_lat (operands[0], operands[1], operands[2]);
3048   else
3049     insn = gen_divsf3_internal_thr (operands[0], operands[1], operands[2]);
3050   emit_insn (insn);
3051   DONE;
3052 })
3053
3054 (define_insn_and_split "divsf3_internal_lat"
3055   [(set (match_operand:SF 0 "fr_register_operand" "=&f")
3056         (div:SF (match_operand:SF 1 "fr_register_operand" "f")
3057                 (match_operand:SF 2 "fr_register_operand" "f")))
3058    (clobber (match_scratch:XF 3 "=&f"))
3059    (clobber (match_scratch:XF 4 "=f"))
3060    (clobber (match_scratch:BI 5 "=c"))]
3061   "TARGET_INLINE_FLOAT_DIV == INL_MIN_LAT"
3062   "#"
3063   "&& reload_completed"
3064   [(parallel [(set (match_dup 6) (div:XF (const_int 1) (match_dup 8)))
3065               (set (match_dup 5) (unspec:BI [(match_dup 7) (match_dup 8)]
3066                                             UNSPEC_FR_RECIP_APPROX))
3067               (use (const_int 0))])
3068    (cond_exec (ne (match_dup 5) (const_int 0))
3069      (parallel [(set (match_dup 3) (mult:XF (match_dup 7) (match_dup 6)))
3070                 (use (const_int 1))]))
3071    (cond_exec (ne (match_dup 5) (const_int 0))
3072      (parallel [(set (match_dup 4)
3073                      (minus:XF (match_dup 10)
3074                                (mult:XF (match_dup 8) (match_dup 6))))
3075                 (use (const_int 1))]))
3076    (cond_exec (ne (match_dup 5) (const_int 0))
3077      (parallel [(set (match_dup 3)
3078                      (plus:XF (mult:XF (match_dup 4) (match_dup 3))
3079                               (match_dup 3)))
3080                 (use (const_int 1))]))
3081    (cond_exec (ne (match_dup 5) (const_int 0))
3082      (parallel [(set (match_dup 4) (mult:XF (match_dup 4) (match_dup 4)))
3083                 (use (const_int 1))]))
3084    (cond_exec (ne (match_dup 5) (const_int 0))
3085      (parallel [(set (match_dup 3)
3086                      (plus:XF (mult:XF (match_dup 4) (match_dup 3))
3087                               (match_dup 3)))
3088                 (use (const_int 1))]))
3089    (cond_exec (ne (match_dup 5) (const_int 0))
3090      (parallel [(set (match_dup 4) (mult:XF (match_dup 4) (match_dup 4)))
3091                 (use (const_int 1))]))
3092    (cond_exec (ne (match_dup 5) (const_int 0))
3093      (parallel [(set (match_dup 9)
3094                      (float_truncate:DF
3095                        (plus:XF (mult:XF (match_dup 4) (match_dup 3))
3096                               (match_dup 3))))
3097                 (use (const_int 1))]))
3098    (cond_exec (ne (match_dup 5) (const_int 0))
3099      (set (match_dup 0)
3100           (float_truncate:SF (match_dup 6))))
3101   ] 
3102 {
3103   operands[6] = gen_rtx_REG (XFmode, REGNO (operands[0]));
3104   operands[7] = gen_rtx_REG (XFmode, REGNO (operands[1]));
3105   operands[8] = gen_rtx_REG (XFmode, REGNO (operands[2]));
3106   operands[9] = gen_rtx_REG (DFmode, REGNO (operands[0]));
3107   operands[10] = CONST1_RTX (XFmode);
3108 }
3109   [(set_attr "predicable" "no")])
3110
3111 ;; Inline square root.
3112
3113 (define_insn "*sqrt_approx"
3114   [(set (match_operand:XF 0 "fr_register_operand" "=f")
3115         (div:XF (const_int 1)
3116                 (sqrt:XF (match_operand:XF 2 "fr_register_operand" "f"))))
3117    (set (match_operand:BI 1 "register_operand" "=c")
3118         (unspec:BI [(match_dup 2)] UNSPEC_FR_SQRT_RECIP_APPROX))
3119    (use (match_operand:SI 3 "const_int_operand" "")) ]
3120   ""
3121   "frsqrta.s%3 %0, %1 = %2"
3122   [(set_attr "itanium_class" "fmisc")
3123    (set_attr "predicable" "no")])
3124
3125 (define_insn "setf_exp_xf"
3126   [(set (match_operand:XF 0 "fr_register_operand" "=f")
3127         (unspec:XF [(match_operand:DI 1 "register_operand" "r")]
3128                   UNSPEC_SETF_EXP))]
3129   ""
3130   "setf.exp %0 = %1"
3131   [(set_attr "itanium_class" "frfr")])
3132
3133 (define_expand "sqrtsf2"
3134   [(set (match_operand:SF 0 "fr_register_operand" "=&f")
3135         (sqrt:SF (match_operand:SF 1 "fr_register_operand" "f")))]
3136   "TARGET_INLINE_SQRT"
3137 {
3138   rtx insn;
3139 #if 0
3140   if (TARGET_INLINE_SQRT == INL_MIN_LAT)
3141     insn = gen_sqrtsf2_internal_lat (operands[0], operands[1]);
3142   else
3143 #else
3144   gcc_assert (TARGET_INLINE_SQRT != INL_MIN_LAT);
3145 #endif
3146   insn = gen_sqrtsf2_internal_thr (operands[0], operands[1]);
3147   emit_insn (insn);
3148   DONE;
3149 })
3150
3151 ;; Latency-optimized square root.
3152 ;; FIXME: Implement.
3153
3154 ;; Throughput-optimized square root.
3155
3156 (define_insn_and_split "sqrtsf2_internal_thr"
3157   [(set (match_operand:SF 0 "fr_register_operand" "=&f")
3158         (sqrt:SF (match_operand:SF 1 "fr_register_operand" "f")))
3159    ;; Register r2 in optimization guide.
3160    (clobber (match_scratch:DI 2 "=r"))
3161    ;; Register f8 in optimization guide
3162    (clobber (match_scratch:XF 3 "=&f"))
3163    ;; Register f9 in optimization guide
3164    (clobber (match_scratch:XF 4 "=&f"))
3165    ;; Register f10 in optimization guide
3166    (clobber (match_scratch:XF 5 "=&f"))
3167    ;; Register p6 in optimization guide.
3168    (clobber (match_scratch:BI 6 "=c"))]
3169   "TARGET_INLINE_SQRT == INL_MAX_THR"
3170   "#"
3171   "&& reload_completed"
3172   [ ;; exponent of +1/2 in r2
3173     (set (match_dup 2) (const_int 65534))
3174     ;; +1/2 in f8
3175     (set (match_dup 3) 
3176          (unspec:XF [(match_dup 2)] UNSPEC_SETF_EXP))
3177     ;; Step 1
3178     ;; y0 = 1/sqrt(a) in f7
3179     (parallel [(set (match_dup 7)
3180                     (div:XF (const_int 1)
3181                             (sqrt:XF (match_dup 8))))
3182                (set (match_dup 6)
3183                     (unspec:BI [(match_dup 8)]
3184                                  UNSPEC_FR_SQRT_RECIP_APPROX))
3185                (use (const_int 0))])
3186     ;; Step 2
3187     ;; H0 = 1/2 * y0 in f9
3188     (cond_exec (ne (match_dup 6) (const_int 0))
3189       (parallel [(set (match_dup 4)
3190                       (plus:XF (mult:XF (match_dup 3) (match_dup 7))
3191                                (match_dup 9)))
3192                  (use (const_int 1))]))
3193     ;; Step 3
3194     ;; S0 = a * y0 in f7
3195     (cond_exec (ne (match_dup 6) (const_int 0))
3196       (parallel [(set (match_dup 7)
3197                       (plus:XF (mult:XF (match_dup 8) (match_dup 7))
3198                                (match_dup 9)))
3199                  (use (const_int 1))]))
3200     ;; Step 4
3201     ;; d = 1/2 - S0 * H0 in f10
3202     (cond_exec (ne (match_dup 6) (const_int 0))
3203       (parallel [(set (match_dup 5)
3204                       (minus:XF (match_dup 3)
3205                                 (mult:XF (match_dup 7) (match_dup 4))))
3206                  (use (const_int 1))]))
3207     ;; Step 5
3208     ;; d' = d + 1/2 * d in f8
3209     (cond_exec (ne (match_dup 6) (const_int 0))
3210        (parallel [(set (match_dup 3)
3211                        (plus:XF (mult:XF (match_dup 3) (match_dup 5))
3212                                 (match_dup 5)))
3213                   (use (const_int 1))]))
3214     ;; Step 6
3215     ;; e = d + d * d' in f8
3216     (cond_exec (ne (match_dup 6) (const_int 0))
3217        (parallel [(set (match_dup 3)
3218                        (plus:XF (mult:XF (match_dup 5) (match_dup 3))
3219                                 (match_dup 5)))
3220                   (use (const_int 1))]))
3221     ;; Step 7
3222     ;; S1 = S0 + e * S0 in f7
3223     (cond_exec (ne (match_dup 6) (const_int 0))
3224       (parallel [(set (match_dup 0)
3225                       (float_truncate:SF
3226                         (plus:XF (mult:XF (match_dup 3) (match_dup 7))
3227                                  (match_dup 7))))
3228                  (use (const_int 1))]))
3229     ;; Step 8
3230     ;; H1 = H0 + e * H0 in f8
3231     (cond_exec (ne (match_dup 6) (const_int 0))
3232        (parallel [(set (match_dup 3)
3233                        (plus:XF (mult:XF (match_dup 3) (match_dup 4))
3234                                 (match_dup 4)))
3235                   (use (const_int 1))]))
3236     ;; Step 9 
3237     ;; d1 = a - S1 * S1 in f9
3238     (cond_exec (ne (match_dup 6) (const_int 0))
3239        (parallel [(set (match_dup 4)
3240                        (minus:XF (match_dup 8)
3241                                  (mult:XF (match_dup 7) (match_dup 7))))
3242                   (use (const_int 1))]))
3243     ;; Step 10
3244     ;; S = S1 + d1 * H1 in f7
3245     (cond_exec (ne (match_dup 6) (const_int 0))
3246        (parallel [(set (match_dup 0)
3247                        (float_truncate:SF
3248                          (plus:XF (mult:XF (match_dup 4) (match_dup 3))
3249                                   (match_dup 7))))
3250                   (use (const_int 0))]))]
3251 {
3252   /* Generate 82-bit versions of the input and output operands.  */
3253   operands[7] = gen_rtx_REG (XFmode, REGNO (operands[0]));
3254   operands[8] = gen_rtx_REG (XFmode, REGNO (operands[1]));
3255   /* Generate required floating-point constants.  */
3256   operands[9] = CONST0_RTX (XFmode);
3257 }
3258   [(set_attr "predicable" "no")])
3259 \f
3260 ;; ::::::::::::::::::::
3261 ;; ::
3262 ;; :: 64-bit floating point arithmetic
3263 ;; ::
3264 ;; ::::::::::::::::::::
3265
3266 (define_insn "adddf3"
3267   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3268         (plus:DF (match_operand:DF 1 "fr_register_operand" "%f")
3269                  (match_operand:DF 2 "fr_reg_or_fp01_operand" "fG")))]
3270   ""
3271   "fadd.d %0 = %1, %F2"
3272   [(set_attr "itanium_class" "fmac")])
3273
3274 (define_insn "*adddf3_trunc"
3275   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3276         (float_truncate:SF
3277           (plus:DF (match_operand:DF 1 "fr_register_operand" "%f")
3278                    (match_operand:DF 2 "fr_reg_or_fp01_operand" "fG"))))]
3279   ""
3280   "fadd.s %0 = %1, %F2"
3281   [(set_attr "itanium_class" "fmac")])
3282
3283 (define_insn "subdf3"
3284   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3285         (minus:DF (match_operand:DF 1 "fr_reg_or_fp01_operand" "fG")
3286                   (match_operand:DF 2 "fr_reg_or_fp01_operand" "fG")))]
3287   ""
3288   "fsub.d %0 = %F1, %F2"
3289   [(set_attr "itanium_class" "fmac")])
3290
3291 (define_insn "*subdf3_trunc"
3292   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3293         (float_truncate:SF
3294           (minus:DF (match_operand:DF 1 "fr_reg_or_fp01_operand" "fG")
3295                     (match_operand:DF 2 "fr_reg_or_fp01_operand" "fG"))))]
3296   ""
3297   "fsub.s %0 = %F1, %F2"
3298   [(set_attr "itanium_class" "fmac")])
3299
3300 (define_insn "muldf3"
3301   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3302         (mult:DF (match_operand:DF 1 "fr_register_operand" "f")
3303                  (match_operand:DF 2 "fr_register_operand" "f")))]
3304   ""
3305   "fmpy.d %0 = %1, %2"
3306   [(set_attr "itanium_class" "fmac")])
3307
3308 (define_insn "*muldf3_trunc"
3309   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3310         (float_truncate:SF
3311           (mult:DF (match_operand:DF 1 "fr_register_operand" "f")
3312                    (match_operand:DF 2 "fr_register_operand" "f"))))]
3313   ""
3314   "fmpy.s %0 = %1, %2"
3315   [(set_attr "itanium_class" "fmac")])
3316
3317 (define_insn "absdf2"
3318   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3319         (abs:DF (match_operand:DF 1 "fr_register_operand" "f")))]
3320   ""
3321   "fabs %0 = %1"
3322   [(set_attr "itanium_class" "fmisc")])
3323
3324 (define_insn "negdf2"
3325   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3326         (neg:DF (match_operand:DF 1 "fr_register_operand" "f")))]
3327   ""
3328   "fneg %0 = %1"
3329   [(set_attr "itanium_class" "fmisc")])
3330
3331 (define_insn "*nabsdf2"
3332   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3333         (neg:DF (abs:DF (match_operand:DF 1 "fr_register_operand" "f"))))]
3334   ""
3335   "fnegabs %0 = %1"
3336   [(set_attr "itanium_class" "fmisc")])
3337
3338 (define_insn "copysigndf3"
3339   [(set (match_operand:DF 0 "register_operand" "=f")
3340         (unspec:DF [(match_operand:DF 1 "fr_reg_or_fp01_operand" "fG")
3341                     (match_operand:DF 2 "fr_reg_or_fp01_operand" "fG")]
3342                    UNSPEC_COPYSIGN))]
3343   ""
3344   "fmerge.s %0 = %F2, %F1"
3345   [(set_attr "itanium_class" "fmisc")])
3346
3347 (define_insn "*ncopysigndf3"
3348   [(set (match_operand:DF 0 "register_operand" "=f")
3349         (neg:DF (unspec:DF [(match_operand:DF 1 "fr_reg_or_fp01_operand" "fG")
3350                             (match_operand:DF 2 "fr_reg_or_fp01_operand" "fG")]
3351                            UNSPEC_COPYSIGN)))]
3352   ""
3353   "fmerge.ns %0 = %F2, %F1"
3354   [(set_attr "itanium_class" "fmisc")])
3355
3356 (define_insn "smindf3"
3357   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3358         (smin:DF (match_operand:DF 1 "fr_register_operand" "f")
3359                  (match_operand:DF 2 "fr_reg_or_fp01_operand" "fG")))]
3360   ""
3361   "fmin %0 = %1, %F2"
3362   [(set_attr "itanium_class" "fmisc")])
3363
3364 (define_insn "smaxdf3"
3365   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3366         (smax:DF (match_operand:DF 1 "fr_register_operand" "f")
3367                  (match_operand:DF 2 "fr_reg_or_fp01_operand" "fG")))]
3368   ""
3369   "fmax %0 = %1, %F2"
3370   [(set_attr "itanium_class" "fmisc")])
3371
3372 (define_insn "*madddf4"
3373   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3374         (plus:DF (mult:DF (match_operand:DF 1 "fr_register_operand" "f")
3375                           (match_operand:DF 2 "fr_register_operand" "f"))
3376                  (match_operand:DF 3 "fr_reg_or_fp01_operand" "fG")))]
3377   ""
3378   "fma.d %0 = %1, %2, %F3"
3379   [(set_attr "itanium_class" "fmac")])
3380
3381 (define_insn "*madddf4_trunc"
3382   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3383         (float_truncate:SF
3384           (plus:DF (mult:DF (match_operand:DF 1 "fr_register_operand" "f")
3385                             (match_operand:DF 2 "fr_register_operand" "f"))
3386                    (match_operand:DF 3 "fr_reg_or_fp01_operand" "fG"))))]
3387   ""
3388   "fma.s %0 = %1, %2, %F3"
3389   [(set_attr "itanium_class" "fmac")])
3390
3391 (define_insn "*msubdf4"
3392   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3393         (minus:DF (mult:DF (match_operand:DF 1 "fr_register_operand" "f")
3394                            (match_operand:DF 2 "fr_register_operand" "f"))
3395                   (match_operand:DF 3 "fr_reg_or_fp01_operand" "fG")))]
3396   ""
3397   "fms.d %0 = %1, %2, %F3"
3398   [(set_attr "itanium_class" "fmac")])
3399
3400 (define_insn "*msubdf4_trunc"
3401   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3402         (float_truncate:SF
3403           (minus:DF (mult:DF (match_operand:DF 1 "fr_register_operand" "f")
3404                              (match_operand:DF 2 "fr_register_operand" "f"))
3405                     (match_operand:DF 3 "fr_reg_or_fp01_operand" "fG"))))]
3406   ""
3407   "fms.s %0 = %1, %2, %F3"
3408   [(set_attr "itanium_class" "fmac")])
3409
3410 (define_insn "*nmuldf3"
3411   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3412         (neg:DF (mult:DF (match_operand:DF 1 "fr_register_operand" "f")
3413                          (match_operand:DF 2 "fr_register_operand" "f"))))]
3414   ""
3415   "fnmpy.d %0 = %1, %2"
3416   [(set_attr "itanium_class" "fmac")])
3417
3418 (define_insn "*nmuldf3_trunc"
3419   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3420         (float_truncate:SF
3421           (neg:DF (mult:DF (match_operand:DF 1 "fr_register_operand" "f")
3422                            (match_operand:DF 2 "fr_register_operand" "f")))))]
3423   ""
3424   "fnmpy.s %0 = %1, %2"
3425   [(set_attr "itanium_class" "fmac")])
3426
3427 (define_insn "*nmadddf4"
3428   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3429         (minus:DF (match_operand:DF 3 "fr_reg_or_fp01_operand" "fG")
3430                   (mult:DF (match_operand:DF 1 "fr_register_operand" "f")
3431                            (match_operand:DF 2 "fr_register_operand" "f"))))]
3432   ""
3433   "fnma.d %0 = %1, %2, %F3"
3434   [(set_attr "itanium_class" "fmac")])
3435
3436 (define_insn "*nmadddf4_alts"
3437   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3438         (minus:DF (match_operand:DF 3 "fr_reg_or_fp01_operand" "fG")
3439                   (mult:DF (match_operand:DF 1 "fr_register_operand" "f")
3440                            (match_operand:DF 2 "fr_register_operand" "f"))))
3441    (use (match_operand:SI 4 "const_int_operand" ""))]
3442   ""
3443   "fnma.d.s%4 %0 = %1, %2, %F3"
3444   [(set_attr "itanium_class" "fmac")])
3445
3446 (define_insn "*nmadddf4_truncsf"
3447   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3448         (float_truncate:SF
3449         (minus:DF (match_operand:DF 3 "fr_reg_or_fp01_operand" "fG")
3450                   (mult:DF (match_operand:DF 1 "fr_register_operand" "f")
3451                            (match_operand:DF 2 "fr_register_operand" "f")))))]
3452   ""
3453   "fnma.s %0 = %1, %2, %F3"
3454   [(set_attr "itanium_class" "fmac")])
3455
3456 (define_insn "*nmadddf4_truncsf_alts"
3457   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3458         (float_truncate:SF
3459         (minus:DF (match_operand:DF 3 "fr_reg_or_fp01_operand" "fG")
3460                   (mult:DF (match_operand:DF 1 "fr_register_operand" "f")
3461                            (match_operand:DF 2 "fr_register_operand" "f")))))
3462    (use (match_operand:SI 4 "const_int_operand" ""))]
3463   ""
3464   "fnma.s.s%4 %0 = %1, %2, %F3"
3465   [(set_attr "itanium_class" "fmac")])
3466
3467 (define_expand "divdf3"
3468   [(set (match_operand:DF 0 "fr_register_operand" "")
3469         (div:DF (match_operand:DF 1 "fr_register_operand" "")
3470                 (match_operand:DF 2 "fr_register_operand" "")))]
3471   "TARGET_INLINE_FLOAT_DIV"
3472 {
3473   rtx insn;
3474   if (TARGET_INLINE_FLOAT_DIV == INL_MIN_LAT)
3475     insn = gen_divdf3_internal_lat (operands[0], operands[1], operands[2]);
3476   else
3477     insn = gen_divdf3_internal_thr (operands[0], operands[1], operands[2]);
3478   emit_insn (insn);
3479   DONE;
3480 })
3481
3482 (define_insn_and_split "divdf3_internal_lat"
3483   [(set (match_operand:DF 0 "fr_register_operand" "=&f")
3484         (div:DF (match_operand:DF 1 "fr_register_operand" "f")
3485                 (match_operand:DF 2 "fr_register_operand" "f")))
3486    (clobber (match_scratch:XF 3 "=&f"))
3487    (clobber (match_scratch:XF 4 "=&f"))
3488    (clobber (match_scratch:XF 5 "=&f"))
3489    (clobber (match_scratch:BI 6 "=c"))]
3490   "TARGET_INLINE_FLOAT_DIV == INL_MIN_LAT"
3491   "#"
3492   "&& reload_completed"
3493   [(parallel [(set (match_dup 7) (div:XF (const_int 1) (match_dup 9)))
3494               (set (match_dup 6) (unspec:BI [(match_dup 8) (match_dup 9)]
3495                                             UNSPEC_FR_RECIP_APPROX))
3496               (use (const_int 0))])
3497    (cond_exec (ne (match_dup 6) (const_int 0))
3498      (parallel [(set (match_dup 3) (mult:XF (match_dup 8) (match_dup 7)))
3499                 (use (const_int 1))]))
3500    (cond_exec (ne (match_dup 6) (const_int 0))
3501      (parallel [(set (match_dup 4)
3502                      (minus:XF (match_dup 12)
3503                                (mult:XF (match_dup 9) (match_dup 7))))
3504                 (use (const_int 1))]))
3505    (cond_exec (ne (match_dup 6) (const_int 0))
3506      (parallel [(set (match_dup 3)
3507                      (plus:XF (mult:XF (match_dup 4) (match_dup 3))
3508                               (match_dup 3)))
3509                 (use (const_int 1))]))
3510    (cond_exec (ne (match_dup 6) (const_int 0))
3511      (parallel [(set (match_dup 5) (mult:XF (match_dup 4) (match_dup 4)))
3512                 (use (const_int 1))]))
3513    (cond_exec (ne (match_dup 6) (const_int 0))
3514      (parallel [(set (match_dup 7)
3515                      (plus:XF (mult:XF (match_dup 4) (match_dup 7))
3516                               (match_dup 7)))
3517                 (use (const_int 1))]))
3518    (cond_exec (ne (match_dup 6) (const_int 0))
3519      (parallel [(set (match_dup 3)
3520                      (plus:XF (mult:XF (match_dup 5) (match_dup 3))
3521                               (match_dup 3)))
3522                 (use (const_int 1))]))
3523    (cond_exec (ne (match_dup 6) (const_int 0))
3524      (parallel [(set (match_dup 4) (mult:XF (match_dup 5) (match_dup 5)))
3525                 (use (const_int 1))]))
3526    (cond_exec (ne (match_dup 6) (const_int 0))
3527      (parallel [(set (match_dup 7)
3528                      (plus:XF (mult:XF (match_dup 5) (match_dup 7))
3529                               (match_dup 7)))
3530                 (use (const_int 1))]))
3531    (cond_exec (ne (match_dup 6) (const_int 0))
3532      (parallel [(set (match_dup 10)
3533                      (float_truncate:DF
3534                        (plus:XF (mult:XF (match_dup 4) (match_dup 3))
3535                               (match_dup 3))))
3536                 (use (const_int 1))]))
3537    (cond_exec (ne (match_dup 6) (const_int 0))
3538      (parallel [(set (match_dup 7)
3539                      (plus:XF (mult:XF (match_dup 4) (match_dup 7))
3540                               (match_dup 7)))
3541                 (use (const_int 1))]))
3542    (cond_exec (ne (match_dup 6) (const_int 0))
3543      (parallel [(set (match_dup 11)
3544                      (float_truncate:DF
3545                        (minus:XF (match_dup 8)
3546                                  (mult:XF (match_dup 9) (match_dup 3)))))
3547                 (use (const_int 1))]))
3548    (cond_exec (ne (match_dup 6) (const_int 0))
3549      (set (match_dup 0)
3550           (float_truncate:DF (plus:XF (mult:XF (match_dup 5) (match_dup 7))
3551                               (match_dup 3)))))
3552   ] 
3553 {
3554   operands[7] = gen_rtx_REG (XFmode, REGNO (operands[0]));
3555   operands[8] = gen_rtx_REG (XFmode, REGNO (operands[1]));
3556   operands[9] = gen_rtx_REG (XFmode, REGNO (operands[2]));
3557   operands[10] = gen_rtx_REG (DFmode, REGNO (operands[3]));
3558   operands[11] = gen_rtx_REG (DFmode, REGNO (operands[5]));
3559   operands[12] = CONST1_RTX (XFmode);
3560 }
3561   [(set_attr "predicable" "no")])
3562
3563 ;; Inline square root.
3564
3565 (define_expand "sqrtdf2"
3566   [(set (match_operand:DF 0 "fr_register_operand" "=&f")
3567         (sqrt:DF (match_operand:DF 1 "fr_register_operand" "f")))]
3568   "TARGET_INLINE_SQRT"
3569 {
3570   rtx insn;
3571 #if 0
3572   if (TARGET_INLINE_SQRT == INL_MIN_LAT)
3573     insn = gen_sqrtdf2_internal_lat (operands[0], operands[1]);
3574   else
3575 #else
3576   gcc_assert (TARGET_INLINE_SQRT != INL_MIN_LAT);
3577 #endif
3578   insn = gen_sqrtdf2_internal_thr (operands[0], operands[1]);
3579   emit_insn (insn);
3580   DONE;
3581 })
3582
3583 ;; Latency-optimized square root.
3584 ;; FIXME: Implement.
3585
3586 ;; Throughput-optimized square root.
3587
3588 (define_insn_and_split "sqrtdf2_internal_thr"
3589   [(set (match_operand:DF 0 "fr_register_operand" "=&f")
3590         (sqrt:DF (match_operand:DF 1 "fr_register_operand" "f")))
3591    ;; Register r2 in optimization guide.
3592    (clobber (match_scratch:DI 2 "=r"))
3593    ;; Register f8 in optimization guide
3594    (clobber (match_scratch:XF 3 "=&f"))
3595    ;; Register f9 in optimization guide
3596    (clobber (match_scratch:XF 4 "=&f"))
3597    ;; Register f10 in optimization guide
3598    (clobber (match_scratch:XF 5 "=&f"))
3599    ;; Register p6 in optimization guide.
3600    (clobber (match_scratch:BI 6 "=c"))]
3601   "TARGET_INLINE_SQRT == INL_MAX_THR"
3602   "#"
3603   "&& reload_completed"
3604   [ ;; exponent of +1/2 in r2
3605     (set (match_dup 2) (const_int 65534))
3606     ;; +1/2 in f10
3607     (set (match_dup 5) 
3608          (unspec:XF [(match_dup 2)] UNSPEC_SETF_EXP))
3609     ;; Step 1
3610     ;; y0 = 1/sqrt(a) in f7
3611     (parallel [(set (match_dup 7)
3612                     (div:XF (const_int 1)
3613                             (sqrt:XF (match_dup 8))))
3614                (set (match_dup 6)
3615                     (unspec:BI [(match_dup 8)]
3616                                  UNSPEC_FR_SQRT_RECIP_APPROX))
3617                (use (const_int 0))])
3618     ;; Step 2
3619     ;; H0 = 1/2 * y0 in f8
3620     (cond_exec (ne (match_dup 6) (const_int 0))
3621       (parallel [(set (match_dup 3)
3622                       (plus:XF (mult:XF (match_dup 5) (match_dup 7))
3623                                (match_dup 9)))
3624                  (use (const_int 1))]))
3625     ;; Step 3
3626     ;; G0 = a * y0 in f7
3627     (cond_exec (ne (match_dup 6) (const_int 0))
3628       (parallel [(set (match_dup 7)
3629                       (plus:XF (mult:XF (match_dup 8) (match_dup 7))
3630                                (match_dup 9)))
3631                  (use (const_int 1))]))
3632     ;; Step 4
3633     ;; r0 = 1/2 - G0 * H0 in f9
3634     (cond_exec (ne (match_dup 6) (const_int 0))
3635       (parallel [(set (match_dup 4)
3636                       (minus:XF (match_dup 5)
3637                                 (mult:XF (match_dup 7) (match_dup 3))))
3638                  (use (const_int 1))]))
3639     ;; Step 5
3640     ;; H1 = H0 + r0 * H0 in f8
3641     (cond_exec (ne (match_dup 6) (const_int 0))
3642        (parallel [(set (match_dup 3)
3643                        (plus:XF (mult:XF (match_dup 4) (match_dup 3))
3644                                 (match_dup 3)))
3645                   (use (const_int 1))]))
3646     ;; Step 6
3647     ;; G1 = G0 + r0 * G0 in f7
3648     (cond_exec (ne (match_dup 6) (const_int 0))
3649        (parallel [(set (match_dup 7)
3650                        (plus:XF (mult:XF (match_dup 4) (match_dup 7))
3651                                 (match_dup 7)))
3652                   (use (const_int 1))]))
3653     ;; Step 7
3654     ;; r1 = 1/2 - G1 * H1 in f9
3655     (cond_exec (ne (match_dup 6) (const_int 0))
3656       (parallel [(set (match_dup 4)
3657                       (minus:XF (match_dup 5)
3658                                 (mult:XF (match_dup 7) (match_dup 3))))
3659                  (use (const_int 1))]))
3660     ;; Step 8
3661     ;; H2 = H1 + r1 * H1 in f8
3662     (cond_exec (ne (match_dup 6) (const_int 0))
3663        (parallel [(set (match_dup 3)
3664                        (plus:XF (mult:XF (match_dup 4) (match_dup 3))
3665                                 (match_dup 3)))
3666                   (use (const_int 1))]))
3667     ;; Step 9 
3668     ;; G2 = G1 + r1 * G1 in f7
3669     (cond_exec (ne (match_dup 6) (const_int 0))
3670        (parallel [(set (match_dup 7)
3671                        (plus:XF (mult:XF (match_dup 4) (match_dup 7))
3672                                 (match_dup 7)))
3673                   (use (const_int 1))]))
3674     ;; Step 10
3675     ;; d2 = a - G2 * G2 in f9
3676     (cond_exec (ne (match_dup 6) (const_int 0))
3677        (parallel [(set (match_dup 4)
3678                        (minus:XF (match_dup 8)
3679                                  (mult:XF (match_dup 7) (match_dup 7))))
3680                   (use (const_int 1))]))
3681     ;; Step 11
3682     ;; G3 = G2 + d2 * H2 in f7
3683     (cond_exec (ne (match_dup 6) (const_int 0))
3684        (parallel [(set (match_dup 7)
3685                        (plus:XF (mult:XF (match_dup 4) (match_dup 3))
3686                                 (match_dup 7)))
3687                   (use (const_int 1))]))
3688     ;; Step 12
3689     ;; d3 = a - G3 * G3 in f9
3690     (cond_exec (ne (match_dup 6) (const_int 0))
3691        (parallel [(set (match_dup 4)
3692                        (minus:XF (match_dup 8)
3693                                  (mult:XF (match_dup 7) (match_dup 7))))
3694                   (use (const_int 1))]))
3695     ;; Step 13
3696     ;; S = G3 + d3 * H2 in f7
3697     (cond_exec (ne (match_dup 6) (const_int 0))
3698        (parallel [(set (match_dup 0)
3699                        (float_truncate:DF
3700                          (plus:XF (mult:XF (match_dup 4) (match_dup 3))
3701                                   (match_dup 7))))
3702                   (use (const_int 0))]))]
3703 {
3704   /* Generate 82-bit versions of the input and output operands.  */
3705   operands[7] = gen_rtx_REG (XFmode, REGNO (operands[0]));
3706   operands[8] = gen_rtx_REG (XFmode, REGNO (operands[1]));
3707   /* Generate required floating-point constants.  */
3708   operands[9] = CONST0_RTX (XFmode);
3709 }
3710   [(set_attr "predicable" "no")])
3711 \f
3712 ;; ::::::::::::::::::::
3713 ;; ::
3714 ;; :: 80-bit floating point arithmetic
3715 ;; ::
3716 ;; ::::::::::::::::::::
3717
3718 (define_insn "addxf3"
3719   [(set (match_operand:XF 0 "fr_register_operand" "=f")
3720         (plus:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3721                  (match_operand:XF 2 "xfreg_or_fp01_operand" "fG")))]
3722   ""
3723   "fadd %0 = %F1, %F2"
3724   [(set_attr "itanium_class" "fmac")])
3725
3726 (define_insn "*addxf3_truncsf"
3727   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3728         (float_truncate:SF
3729           (plus:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3730                    (match_operand:XF 2 "xfreg_or_fp01_operand" "fG"))))]
3731   ""
3732   "fadd.s %0 = %F1, %F2"
3733   [(set_attr "itanium_class" "fmac")])
3734
3735 (define_insn "*addxf3_truncdf"
3736   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3737         (float_truncate:DF
3738           (plus:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3739                    (match_operand:XF 2 "xfreg_or_fp01_operand" "fG"))))]
3740   ""
3741   "fadd.d %0 = %F1, %F2"
3742   [(set_attr "itanium_class" "fmac")])
3743
3744 (define_insn "subxf3"
3745   [(set (match_operand:XF 0 "fr_register_operand" "=f")
3746         (minus:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3747                   (match_operand:XF 2 "xfreg_or_fp01_operand" "fG")))]
3748   ""
3749   "fsub %0 = %F1, %F2"
3750   [(set_attr "itanium_class" "fmac")])
3751
3752 (define_insn "*subxf3_truncsf"
3753   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3754         (float_truncate:SF
3755           (minus:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3756                     (match_operand:XF 2 "xfreg_or_fp01_operand" "fG"))))]
3757   ""
3758   "fsub.s %0 = %F1, %F2"
3759   [(set_attr "itanium_class" "fmac")])
3760
3761 (define_insn "*subxf3_truncdf"
3762   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3763         (float_truncate:DF
3764           (minus:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3765                     (match_operand:XF 2 "xfreg_or_fp01_operand" "fG"))))]
3766   ""
3767   "fsub.d %0 = %F1, %F2"
3768   [(set_attr "itanium_class" "fmac")])
3769
3770 (define_insn "mulxf3"
3771   [(set (match_operand:XF 0 "fr_register_operand" "=f")
3772         (mult:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3773                  (match_operand:XF 2 "xfreg_or_fp01_operand" "fG")))]
3774   ""
3775   "fmpy %0 = %F1, %F2"
3776   [(set_attr "itanium_class" "fmac")])
3777
3778 (define_insn "*mulxf3_truncsf"
3779   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3780         (float_truncate:SF
3781           (mult:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3782                    (match_operand:XF 2 "xfreg_or_fp01_operand" "fG"))))]
3783   ""
3784   "fmpy.s %0 = %F1, %F2"
3785   [(set_attr "itanium_class" "fmac")])
3786
3787 (define_insn "*mulxf3_truncdf"
3788   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3789         (float_truncate:DF
3790           (mult:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3791                    (match_operand:XF 2 "xfreg_or_fp01_operand" "fG"))))]
3792   ""
3793   "fmpy.d %0 = %F1, %F2"
3794   [(set_attr "itanium_class" "fmac")])
3795
3796 (define_insn "*mulxf3_alts"
3797   [(set (match_operand:XF 0 "fr_register_operand" "=f")
3798         (mult:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3799                  (match_operand:XF 2 "xfreg_or_fp01_operand" "fG")))
3800    (use (match_operand:SI 3 "const_int_operand" ""))]
3801   ""
3802   "fmpy.s%3 %0 = %F1, %F2"
3803   [(set_attr "itanium_class" "fmac")])
3804
3805 (define_insn "*mulxf3_truncsf_alts"
3806   [(set (match_operand:SF 0 "fr_register_operand" "=f")
3807         (float_truncate:SF
3808           (mult:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3809                    (match_operand:XF 2 "xfreg_or_fp01_operand" "fG"))))
3810    (use (match_operand:SI 3 "const_int_operand" ""))]
3811   ""
3812   "fmpy.s.s%3 %0 = %F1, %F2"
3813   [(set_attr "itanium_class" "fmac")])
3814
3815 (define_insn "*mulxf3_truncdf_alts"
3816   [(set (match_operand:DF 0 "fr_register_operand" "=f")
3817         (float_truncate:DF
3818           (mult:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3819                    (match_operand:XF 2 "xfreg_or_fp01_operand" "fG"))))
3820    (use (match_operand:SI 3 "const_int_operand" ""))]
3821   ""
3822   "fmpy.d.s%3 %0 = %F1, %F2"
3823   [(set_attr "itanium_class" "fmac")])
3824
3825 (define_insn "absxf2"
3826   [(set (match_operand:XF 0 "fr_register_operand" "=f")
3827         (abs:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")))]
3828   ""
3829   "fabs %0 = %F1"
3830   [(set_attr "itanium_class" "fmisc")])
3831
3832 (define_insn "negxf2"
3833   [(set (match_operand:XF 0 "fr_register_operand" "=f")
3834         (neg:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")))]
3835   ""
3836   "fneg %0 = %F1"
3837   [(set_attr "itanium_class" "fmisc")])
3838
3839 (define_insn "*nabsxf2"
3840   [(set (match_operand:XF 0 "fr_register_operand" "=f")
3841         (neg:XF (abs:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG"))))]
3842   ""
3843   "fnegabs %0 = %F1"
3844   [(set_attr "itanium_class" "fmisc")])
3845
3846 (define_insn "copysignxf3"
3847   [(set (match_operand:XF 0 "register_operand" "=f")
3848         (unspec:XF [(match_operand:XF 1 "fr_reg_or_fp01_operand" "fG")
3849                     (match_operand:XF 2 "fr_reg_or_fp01_operand" "fG")]
3850                    UNSPEC_COPYSIGN))]
3851   ""
3852   "fmerge.s %0 = %F2, %F1"
3853   [(set_attr "itanium_class" "fmisc")])
3854
3855 (define_insn "*ncopysignxf3"
3856   [(set (match_operand:XF 0 "register_operand" "=f")
3857         (neg:XF (unspec:XF [(match_operand:XF 1 "fr_reg_or_fp01_operand" "fG")
3858                             (match_operand:XF 2 "fr_reg_or_fp01_operand" "fG")]
3859                            UNSPEC_COPYSIGN)))]
3860   ""
3861   "fmerge.ns %0 = %F2, %F1"
3862   [(set_attr "itanium_class" "fmisc")])
3863
3864 (define_insn "sminxf3"
3865   [(set (match_operand:XF 0 "fr_register_operand" "=f")
3866         (smin:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3867                  (match_operand:XF 2 "xfreg_or_fp01_operand" "fG")))]
3868   ""
3869   "fmin %0 = %F1, %F2"
3870   [(set_attr "itanium_class" "fmisc")])
3871
3872 (define_insn "smaxxf3"
3873   [(set (match_operand:XF 0 "fr_register_operand" "=f")
3874         (smax:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3875                  (match_operand:XF 2 "xfreg_or_fp01_operand" "fG")))]
3876   ""
3877   "fmax %0 = %F1, %F2"
3878   [(set_attr "itanium_class" "fmisc")])
3879
3880 (define_insn "*maddxf4"
3881   [(set (match_operand:XF 0 "fr_register_operand" "=f")
3882         (plus:XF (mult:XF (match_operand:XF 1 "xfreg_or_fp01_operand" "fG")
3883                           (match_operand:XF 2 "xfreg_or_fp01_operand" "fG"))
3884                  (match_operand:XF 3 "xfreg_or_fp01_operand" "fG")))]
3885   ""
3886   "fma %0 = %F1, %F2, %F3"
3887   [(set_attr "itanium_class" "fmac")])
3888
3889 (define_insn "*maddxf4_truncsf"