OSDN Git Service

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