OSDN Git Service

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