OSDN Git Service

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