OSDN Git Service

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