OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [config/] [ia64/] [div.md] - Blame information for rev 301

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 282 jeremybenn 
;; Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
2 
;;
3 
;; This file is part of GCC.
4 
;;
5 
;; GCC is free software; you can redistribute it and/or modify
6 
;; it under the terms of the GNU General Public License as published by
7 
;; the Free Software Foundation; either version 3, or (at your option)
8 
;; any later version.
9 
;;
10 
;; GCC is distributed in the hope that it will be useful,
11 
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
12 
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 
;; GNU General Public License for more details.
14 
;;
15 
;; You should have received a copy of the GNU General Public License
16 
;; along with GCC; see the file COPYING3.  If not see
17 
;; .
18 
 
19 
;; For the internal conditional math routines:
20 
 
21 
;; operand 0 is always the result
22 
;; operand 1 is always the predicate
23 
;; operand 2, 3, and sometimes 4 are the input values.
24 
;; operand 4 or 5 is the floating point status register to use.
25 
;; operand 5 or 6 is the rounding to do. (0 = single, 1 = double, 2 = none)
26 
;;
27 
;; addrf3_cond   - F0 = F2 + F3
28 
;; subrf3_cond   - F0 = F2 - F3
29 
;; mulrf3_cond   - F0 = F2 * F3
30 
;; nmulrf3_cond  - F0 = - (F2 * F3)
31 
;; m1addrf4_cond - F0 = (F2 * F3) + F4
32 
;; m1subrf4_cond - F0 = (F2 * F3) - F4
33 
;; m2addrf4_cond - F0 = F2 + (F3 * F4)
34 
;; m2subrf4_cond - F0 = F2 - (F3 * F4)
35 
 
36 
;; Basic plus/minus/mult operations
37 
 
38 
(define_insn "addrf3_cond"
39 
  [(set (match_operand:RF 0 "fr_register_operand" "=f,f")
40 
        (if_then_else:RF (ne:RF (match_operand:BI 1 "register_operand"  "c,c")
41 
                                (const_int 0))
42 
          (plus:RF
43 
            (match_operand:RF 2 "fr_reg_or_fp01_operand" "fG,fG")
44 
            (match_operand:RF 3 "fr_reg_or_fp01_operand" "fG,fG"))
45 
          (match_operand:RF 4 "fr_reg_or_0_operand" "0,H")))
46 
   (use (match_operand:SI 5 "const_int_operand" ""))
47 
   (use (match_operand:SI 6 "const_int_operand" ""))]
48 
  ""
49 
  "(%1) fadd%R6.s%5 %0 = %F2, %F3"
50 
  [(set_attr "itanium_class" "fmac")
51 
   (set_attr "predicable" "no")])
52 
 
53 
(define_insn "subrf3_cond"
54 
  [(set (match_operand:RF 0 "fr_register_operand" "=f,f")
55 
        (if_then_else:RF (ne:RF (match_operand:BI 1 "register_operand"  "c,c")
56 
                                (const_int 0))
57 
          (minus:RF
58 
            (match_operand:RF 2 "fr_reg_or_fp01_operand" "fG,fG")
59 
            (match_operand:RF 3 "fr_reg_or_fp01_operand" "fG,fG"))
60 
          (match_operand:RF 4 "fr_reg_or_0_operand" "0,H")))
61 
   (use (match_operand:SI 5 "const_int_operand" ""))
62 
   (use (match_operand:SI 6 "const_int_operand" ""))]
63 
  ""
64 
  "(%1) fsub%R6.s%5 %0 = %F2, %F3"
65 
  [(set_attr "itanium_class" "fmac")
66 
   (set_attr "predicable" "no")])
67 
 
68 
(define_insn "mulrf3_cond"
69 
  [(set (match_operand:RF 0 "fr_register_operand" "=f,f")
70 
        (if_then_else:RF (ne:RF (match_operand:BI 1 "register_operand"  "c,c")
71 
                                (const_int 0))
72 
          (mult:RF
73 
            (match_operand:RF 2 "fr_reg_or_fp01_operand" "fG,fG")
74 
            (match_operand:RF 3 "fr_reg_or_fp01_operand" "fG,fG"))
75 
          (match_operand:RF 4 "fr_reg_or_0_operand" "0,H")))
76 
   (use (match_operand:SI 5 "const_int_operand" ""))
77 
   (use (match_operand:SI 6 "const_int_operand" ""))]
78 
  ""
79 
  "(%1) fmpy%R6.s%5 %0 = %F2, %F3"
80 
  [(set_attr "itanium_class" "fmac")
81 
   (set_attr "predicable" "no")])
82 
 
83 
;; neg-mult operation
84 
 
85 
(define_insn "nmulrf3_cond"
86 
  [(set (match_operand:RF 0 "fr_register_operand" "=f,f")
87 
        (if_then_else:RF (ne:RF (match_operand:BI 1 "register_operand"  "c,c")
88 
                                (const_int 0))
89 
          (neg:RF (mult:RF
90 
            (match_operand:RF 2 "fr_reg_or_fp01_operand" "fG,fG")
91 
            (match_operand:RF 3 "fr_reg_or_fp01_operand" "fG,fG")))
92 
          (match_operand:RF 4 "fr_reg_or_0_operand" "0,H")))
93 
   (use (match_operand:SI 5 "const_int_operand" ""))
94 
   (use (match_operand:SI 6 "const_int_operand" ""))]
95 
  ""
96 
  "(%1) fnmpy%R6.s%5 %0 = %F2, %F3"
97 
  [(set_attr "itanium_class" "fmac")
98 
   (set_attr "predicable" "no")])
99 
 
100 
;; add-mult/sub-mult operations (mult as op1)
101 
 
102 
(define_insn "m1addrf4_cond"
103 
  [(set (match_operand:RF 0 "fr_register_operand" "=f,f")
104 
        (if_then_else:RF (ne:RF (match_operand:BI 1 "register_operand"  "c,c")
105 
                                (const_int 0))
106 
          (plus:RF
107 
            (mult:RF
108 
              (match_operand:RF 2 "fr_reg_or_fp01_operand" "fG,fG")
109 
              (match_operand:RF 3 "fr_reg_or_fp01_operand" "fG,fG"))
110 
            (match_operand:RF 4 "fr_reg_or_fp01_operand" "fG,fG"))
111 
          (match_operand:RF 5 "fr_reg_or_0_operand" "0,H")))
112 
   (use (match_operand:SI 6 "const_int_operand" ""))
113 
   (use (match_operand:SI 7 "const_int_operand" ""))]
114 
  ""
115 
  "(%1) fma%R7.s%6 %0 = %F2, %F3, %F4"
116 
  [(set_attr "itanium_class" "fmac")
117 
   (set_attr "predicable" "no")])
118 
 
119 
(define_insn "m1subrf4_cond"
120 
  [(set (match_operand:RF 0 "fr_register_operand" "=f,f")
121 
        (if_then_else:RF (ne:RF (match_operand:BI 1 "register_operand"  "c,c")
122 
                                (const_int 0))
123 
          (minus:RF
124 
            (mult:RF
125 
              (match_operand:RF 2 "fr_reg_or_fp01_operand" "fG,fG")
126 
              (match_operand:RF 3 "fr_reg_or_fp01_operand" "fG,fG"))
127 
            (match_operand:RF 4 "fr_reg_or_fp01_operand" "fG,fG"))
128 
          (match_operand:RF 5 "fr_reg_or_0_operand" "0,H")))
129 
   (use (match_operand:SI 6 "const_int_operand" ""))
130 
   (use (match_operand:SI 7 "const_int_operand" ""))]
131 
  ""
132 
  "(%1) fms%R7.s%6 %0 = %F2, %F3, %F4"
133 
  [(set_attr "itanium_class" "fmac")
134 
   (set_attr "predicable" "no")])
135 
 
136 
;; add-mult/sub-mult operations (mult as op2)
137 
 
138 
(define_insn "m2addrf4_cond"
139 
  [(set (match_operand:RF 0 "fr_register_operand" "=f,f")
140 
        (if_then_else:RF (ne:RF (match_operand:BI 1 "register_operand"  "c,c")
141 
                                (const_int 0))
142 
          (plus:RF
143 
            (match_operand:RF 2 "fr_reg_or_fp01_operand" "fG,fG")
144 
            (mult:RF
145 
              (match_operand:RF 3 "fr_reg_or_fp01_operand" "fG,fG")
146 
              (match_operand:RF 4 "fr_reg_or_fp01_operand" "fG,fG")))
147 
          (match_operand:RF 5 "fr_reg_or_0_operand" "0,H")))
148 
   (use (match_operand:SI 6 "const_int_operand" ""))
149 
   (use (match_operand:SI 7 "const_int_operand" ""))]
150 
  ""
151 
  "(%1) fma%R7.s%6 %0 = %F3, %F4, %F2"
152 
  [(set_attr "itanium_class" "fmac")
153 
   (set_attr "predicable" "no")])
154 
 
155 
(define_insn "m2subrf4_cond"
156 
  [(set (match_operand:RF 0 "fr_register_operand" "=f,f")
157 
        (if_then_else:RF (ne:RF (match_operand:BI 1 "register_operand"  "c,c")
158 
                                (const_int 0))
159 
          (minus:RF
160 
            (match_operand:RF 2 "fr_reg_or_fp01_operand" "fG,fG")
161 
            (mult:RF
162 
              (match_operand:RF 3 "fr_reg_or_fp01_operand" "fG,fG")
163 
              (match_operand:RF 4 "fr_reg_or_fp01_operand" "fG,fG")))
164 
          (match_operand:RF 5 "fr_reg_or_0_operand" "0,H")))
165 
   (use (match_operand:SI 6 "const_int_operand" ""))
166 
   (use (match_operand:SI 7 "const_int_operand" ""))]
167 
  ""
168 
  "(%1) fnma%R7.s%6 %0 = %F3, %F4, %F2"
169 
  [(set_attr "itanium_class" "fmac")
170 
   (set_attr "predicable" "no")])
171 
 
172 
;; Conversions to/from RF and SF/DF/XF
173 
;; These conversions should not generate any code but make it possible
174 
;; for all the instructions used to implement floating point division
175 
;; to be written for RFmode only and to not have to handle multiple
176 
;; modes or to have to handle a register in more than one mode.
177 
 
178 
(define_mode_iterator SDX_F [SF DF XF])
179 
 
180 
(define_insn "extendrf2"
181 
  [(set (match_operand:RF 0 "fr_register_operand" "=f")
182 
        (float_extend:RF (match_operand:SDX_F 1 "fr_reg_or_fp01_operand" "fG")))]
183 
  ""
184 
  "#"
185 
  [(set_attr "itanium_class" "fmisc")
186 
   (set_attr "predicable" "yes")])
187 
 
188 
(define_split
189 
  [(set (match_operand:RF 0 "fr_register_operand" "")
190 
        (float_extend:RF (match_operand:SDX_F 1 "fr_reg_or_fp01_operand" "")))]
191 
   "reload_completed"
192 
   [(set (match_dup 0) (match_dup 2))]
193 
{
194 
   if (operands[1] == CONST0_RTX (mode))
195 
     operands[2] = gen_rtx_REG (RFmode, FR_REG (0));
196 
   else if (operands[1] == CONST1_RTX (mode))
197 
     operands[2] = gen_rtx_REG (RFmode, FR_REG (1));
198 
   else
199 
     operands[2] = gen_rtx_REG (RFmode, REGNO (operands[1]));
200 
})
201 
 
202 
 
203 
(define_insn "truncrf2"
204 
  [(set (match_operand:SDX_F 0 "fr_register_operand" "=f")
205 
        (float_truncate:SDX_F (match_operand:RF 1 "fr_reg_or_fp01_operand" "fG")))]
206 
  ""
207 
  "#"
208 
  [(set_attr "itanium_class" "fmisc")
209 
   (set_attr "predicable" "yes")])
210 
 
211 
(define_split
212 
  [(set (match_operand:SDX_F 0 "fr_register_operand" "")
213 
        (float_truncate:SDX_F (match_operand:RF 1 "fr_reg_or_fp01_operand" "")))]
214 
   "reload_completed"
215 
   [(set (match_dup 0) (match_dup 2))]
216 
{
217 
   if (operands[1] == CONST0_RTX (RFmode))
218 
     operands[2] = gen_rtx_REG (mode, FR_REG (0));
219 
   else if (operands[1] == CONST1_RTX (RFmode))
220 
     operands[2] = gen_rtx_REG (mode, FR_REG (1));
221 
   else
222 
     operands[2] = gen_rtx_REG (mode, REGNO (operands[1]));
223 
})
224 
 
225 
;; Float to integer truncations using an alternative status register.
226 
 
227 
(define_insn "fix_truncrfdi2_alts"
228 
  [(set (match_operand:DI 0 "fr_register_operand" "=f")
229 
        (fix:DI (match_operand:RF 1 "fr_register_operand" "f")))
230 
   (use (match_operand:SI 2 "const_int_operand" ""))]
231 
  ""
232 
  "fcvt.fx.trunc.s%2 %0 = %1"
233 
  [(set_attr "itanium_class" "fcvtfx")])
234 
 
235 
(define_insn "fixuns_truncrfdi2_alts"
236 
  [(set (match_operand:DI 0 "fr_register_operand" "=f")
237 
        (unsigned_fix:DI (match_operand:RF 1 "fr_register_operand" "f")))
238 
   (use (match_operand:SI 2 "const_int_operand" ""))]
239 
  ""
240 
  "fcvt.fxu.trunc.s%2 %0 = %1"
241 
  [(set_attr "itanium_class" "fcvtfx")])
242 
 
243 
(define_insn "setf_exp_rf"
244 
  [(set (match_operand:RF 0 "fr_register_operand" "=f")
245 
        (unspec:RF [(match_operand:DI 1 "register_operand" "r")]
246 
                  UNSPEC_SETF_EXP))]
247 
  ""
248 
  "setf.exp %0 = %1"
249 
  [(set_attr "itanium_class" "frfr")])
250 
 
251 
;; Reciprocal approximation
252 
 
253 
(define_insn "recip_approx_rf"
254 
  [(set (match_operand:RF 0 "fr_register_operand" "=f")
255 
        (unspec:RF [(match_operand:RF 1 "fr_reg_or_fp01_operand" "fG")
256 
                    (match_operand:RF 2 "fr_reg_or_fp01_operand" "fG")]
257 
                   UNSPEC_FR_RECIP_APPROX_RES))
258 
   (set (match_operand:BI 3 "register_operand" "=c")
259 
        (unspec:BI [(match_dup 1) (match_dup 2)] UNSPEC_FR_RECIP_APPROX))
260 
   (use (match_operand:SI 4 "const_int_operand" ""))]
261 
  ""
262 
  "frcpa.s%4 %0, %3 = %F1, %F2"
263 
  [(set_attr "itanium_class" "fmisc")
264 
   (set_attr "predicable" "no")])
265 
 
266 
;; Single precision floating point division
267 
 
268 
(define_expand "divsf3"
269 
  [(set (match_operand:SF 0 "fr_register_operand" "")
270 
        (div:SF (match_operand:SF 1 "fr_reg_or_fp01_operand" "")
271 
                (match_operand:SF 2 "fr_reg_or_fp01_operand" "")))]
272 
  "TARGET_INLINE_FLOAT_DIV"
273 
{
274 
  rtx insn;
275 
  if (TARGET_INLINE_FLOAT_DIV == INL_MIN_LAT)
276 
    insn = gen_divsf3_internal_lat (operands[0], operands[1], operands[2]);
277 
  else
278 
    insn = gen_divsf3_internal_thr (operands[0], operands[1], operands[2]);
279 
  emit_insn (insn);
280 
  DONE;
281 
})
282 
 
283 
;; Single precision floating point division (maximum throughput algorithm).
284 
 
285 
(define_expand "divsf3_internal_thr"
286 
  [(set (match_operand:SF 0 "fr_register_operand" "")
287 
        (div:SF (match_operand:SF 1 "fr_reg_or_fp01_operand" "")
288 
                (match_operand:SF 2 "fr_reg_or_fp01_operand" "")))]
289 
  "TARGET_INLINE_FLOAT_DIV"
290 
{
291 
  rtx y     = gen_reg_rtx (RFmode);
292 
  rtx a     = gen_reg_rtx (RFmode);
293 
  rtx b     = gen_reg_rtx (RFmode);
294 
  rtx e     = gen_reg_rtx (RFmode);
295 
  rtx y1    = gen_reg_rtx (RFmode);
296 
  rtx y2    = gen_reg_rtx (RFmode);
297 
  rtx q     = gen_reg_rtx (RFmode);
298 
  rtx r     = gen_reg_rtx (RFmode);
299 
  rtx q_res = gen_reg_rtx (RFmode);
300 
  rtx cond  = gen_reg_rtx (BImode);
301 
  rtx zero    = CONST0_RTX (RFmode);
302 
  rtx one     = CONST1_RTX (RFmode);
303 
  rtx status0 = CONST0_RTX (SImode);
304 
  rtx status1 = CONST1_RTX (SImode);
305 
  rtx trunc_sgl = CONST0_RTX (SImode);
306 
  rtx trunc_off    = CONST2_RTX (SImode);
307 
 
308 
  /* Empty conversions to put inputs into RFmode.  */
309 
  emit_insn (gen_extendsfrf2 (a, operands[1]));
310 
  emit_insn (gen_extendsfrf2 (b, operands[2]));
311 
  /* y = 1 / b                          */
312 
  emit_insn (gen_recip_approx_rf (y, a, b, cond, status0));
313 
  /* e = 1 - (b * y)                    */
314 
  emit_insn (gen_m2subrf4_cond (e, cond, one, b, y, zero, status1, trunc_off));
315 
  /* y1 = y + (y * e)                   */
316 
  emit_insn (gen_m2addrf4_cond (y1, cond, y, y, e, zero, status1, trunc_off));
317 
  /* y2 = y + (y1 * e)                  */
318 
  emit_insn (gen_m2addrf4_cond (y2, cond, y, y1, e, zero, status1, trunc_off));
319 
  /* q = single(a * y2)                 */
320 
  emit_insn (gen_mulrf3_cond (q, cond, a, y2, zero, status1, trunc_sgl));
321 
  /* r = a - (q * b)                    */
322 
  emit_insn (gen_m2subrf4_cond (r, cond, a, q, b, zero, status1, trunc_off));
323 
  /* Q = single (q + (r * y2))          */
324 
  emit_insn (gen_m2addrf4_cond (q_res, cond, q, r, y2, y, status0, trunc_sgl));
325 
  /* Conversion back into SFmode.       */
326 
  emit_insn (gen_truncrfsf2 (operands[0], q_res));
327 
  DONE;
328 
})
329 
 
330 
;; Single precision floating point division (minimum latency algorithm).
331 
 
332 
(define_expand "divsf3_internal_lat"
333 
  [(set (match_operand:SF 0 "fr_register_operand" "")
334 
        (div:SF (match_operand:SF 1 "fr_reg_or_fp01_operand" "")
335 
                (match_operand:SF 2 "fr_reg_or_fp01_operand" "")))]
336 
  "TARGET_INLINE_FLOAT_DIV"
337 
{
338 
  rtx y         = gen_reg_rtx (RFmode);
339 
  rtx a         = gen_reg_rtx (RFmode);
340 
  rtx b         = gen_reg_rtx (RFmode);
341 
  rtx e         = gen_reg_rtx (RFmode);
342 
  rtx q         = gen_reg_rtx (RFmode);
343 
  rtx e1        = gen_reg_rtx (RFmode);
344 
  rtx y1        = gen_reg_rtx (RFmode);
345 
  rtx q1        = gen_reg_rtx (RFmode);
346 
  rtx r         = gen_reg_rtx (RFmode);
347 
  rtx q_res     = gen_reg_rtx (RFmode);
348 
  rtx cond      = gen_reg_rtx (BImode);
349 
  rtx zero      = CONST0_RTX (RFmode);
350 
  rtx one       = CONST1_RTX (RFmode);
351 
  rtx status0   = CONST0_RTX (SImode);
352 
  rtx status1   = CONST1_RTX (SImode);
353 
  rtx trunc_sgl = CONST0_RTX (SImode);
354 
  rtx trunc_off = CONST2_RTX (SImode);
355 
 
356 
  /* Empty conversions to put inputs into RFmode.  */
357 
  emit_insn (gen_extendsfrf2 (a, operands[1]));
358 
  emit_insn (gen_extendsfrf2 (b, operands[2]));
359 
  /* y = 1 / b                          */
360 
  emit_insn (gen_recip_approx_rf (y, a, b, cond, status0));
361 
  /* q = a * y                          */
362 
  emit_insn (gen_mulrf3_cond (q, cond, a, y, zero, status1, trunc_off));
363 
  /* e = 1 - (b * y)                    */
364 
  emit_insn (gen_m2subrf4_cond (e, cond, one, b, y, zero, status1, trunc_off));
365 
  /* e1 = e + (e * e)                   */
366 
  emit_insn (gen_m2addrf4_cond (e1, cond, e, e, e, zero, status1, trunc_off));
367 
  /* q1 = single(q + (q * e1))          */
368 
  emit_insn (gen_m2addrf4_cond (q1, cond, q, q, e1, zero, status1, trunc_sgl));
369 
  /* y1 = y + (y * e1)                  */
370 
  emit_insn (gen_m2addrf4_cond (y1, cond, y, y, e1, zero, status1, trunc_off));
371 
  /* r = a - (q1 * b)                   */
372 
  emit_insn (gen_m2subrf4_cond (r, cond, a, q1, b, zero, status1, trunc_off));
373 
  /* Q = single (q1 + (r * y1))         */
374 
  emit_insn (gen_m2addrf4_cond (q_res, cond, q1, r, y1, y, status0, trunc_sgl));
375 
  /* Conversion back into SFmode.       */
376 
  emit_insn (gen_truncrfsf2 (operands[0], q_res));
377 
  DONE;
378 
})
379 
 
380 
;; Double precision floating point division
381 
 
382 
(define_expand "divdf3"
383 
  [(set (match_operand:DF 0 "fr_register_operand" "")
384 
        (div:DF (match_operand:DF 1 "fr_reg_or_fp01_operand" "")
385 
                (match_operand:DF 2 "fr_reg_or_fp01_operand" "")))]
386 
  "TARGET_INLINE_FLOAT_DIV"
387 
{
388 
  rtx insn;
389 
  if (TARGET_INLINE_FLOAT_DIV == INL_MIN_LAT)
390 
    insn = gen_divdf3_internal_lat (operands[0], operands[1], operands[2]);
391 
  else
392 
    insn = gen_divdf3_internal_thr (operands[0], operands[1], operands[2]);
393 
  emit_insn (insn);
394 
  DONE;
395 
})
396 
 
397 
;; Double precision floating point division (maximum throughput algorithm).
398 
 
399 
(define_expand "divdf3_internal_thr"
400 
  [(set (match_operand:DF 0 "fr_register_operand" "")
401 
        (div:DF (match_operand:DF 1 "fr_reg_or_fp01_operand" "")
402 
                (match_operand:DF 2 "fr_reg_or_fp01_operand" "")))]
403 
  "TARGET_INLINE_FLOAT_DIV"
404 
{
405 
  rtx q_res = gen_reg_rtx (RFmode);
406 
  rtx a     = gen_reg_rtx (RFmode);
407 
  rtx b     = gen_reg_rtx (RFmode);
408 
  rtx y     = gen_reg_rtx (RFmode);
409 
  rtx e     = gen_reg_rtx (RFmode);
410 
  rtx y1    = gen_reg_rtx (RFmode);
411 
  rtx e1    = gen_reg_rtx (RFmode);
412 
  rtx y2    = gen_reg_rtx (RFmode);
413 
  rtx e2    = gen_reg_rtx (RFmode);
414 
  rtx y3    = gen_reg_rtx (RFmode);
415 
  rtx q     = gen_reg_rtx (RFmode);
416 
  rtx r     = gen_reg_rtx (RFmode);
417 
  rtx cond  = gen_reg_rtx (BImode);
418 
  rtx zero    = CONST0_RTX (RFmode);
419 
  rtx one     = CONST1_RTX (RFmode);
420 
  rtx status0 = CONST0_RTX (SImode);
421 
  rtx status1 = CONST1_RTX (SImode);
422 
  rtx trunc_dbl = CONST1_RTX (SImode);
423 
  rtx trunc_off = CONST2_RTX (SImode);
424 
  /* Empty conversions to put inputs into RFmode */
425 
  emit_insn (gen_extenddfrf2 (a, operands[1]));
426 
  emit_insn (gen_extenddfrf2 (b, operands[2]));
427 
  /* y  = 1 / b                 */
428 
  emit_insn (gen_recip_approx_rf (y, a, b, cond, status0));
429 
  /* e  = 1 - (b * y)           */
430 
  emit_insn (gen_m2subrf4_cond (e, cond, one, b, y, zero, status1, trunc_off));
431 
  /* y1 = y + (y * e)           */
432 
  emit_insn (gen_m2addrf4_cond (y1, cond, y, y, e, zero, status1, trunc_off));
433 
  /* e1 = e * e                 */
434 
  emit_insn (gen_mulrf3_cond (e1, cond, e, e, zero, status1, trunc_off));
435 
  /* y2 = y1 + (y1 * e1)        */
436 
  emit_insn (gen_m2addrf4_cond (y2, cond, y1, y1, e1, zero, status1, trunc_off));
437 
  /* e2 = e1 * e1               */
438 
  emit_insn (gen_mulrf3_cond (e2, cond, e1, e1, zero, status1, trunc_off));
439 
  /* y3 = y2 + (y2 * e2)        */
440 
  emit_insn (gen_m2addrf4_cond (y3, cond, y2, y2, e2, zero, status1, trunc_off));
441 
  /* q  = double (a * y3)       */
442 
  emit_insn (gen_mulrf3_cond (q, cond, a, y3, zero, status1, trunc_dbl));
443 
  /* r  = a - (b * q)           */
444 
  emit_insn (gen_m2subrf4_cond (r, cond, a, b, q, zero, status1, trunc_off));
445 
  /* Q  = double (q + (r * y3)) */
446 
  emit_insn (gen_m2addrf4_cond (q_res, cond, q, r, y3, y, status0, trunc_dbl));
447 
  /* Conversion back into DFmode */
448 
  emit_insn (gen_truncrfdf2 (operands[0], q_res));
449 
  DONE;
450 
})
451 
 
452 
;; Double precision floating point division (minimum latency algorithm).
453 
 
454 
(define_expand "divdf3_internal_lat"
455 
  [(set (match_operand:DF 0 "fr_register_operand" "")
456 
        (div:DF (match_operand:DF 1 "fr_reg_or_fp01_operand" "")
457 
                (match_operand:DF 2 "fr_reg_or_fp01_operand" "")))]
458 
  "TARGET_INLINE_FLOAT_DIV"
459 
{
460 
  rtx q_res     = gen_reg_rtx (RFmode);
461 
  rtx a         = gen_reg_rtx (RFmode);
462 
  rtx b         = gen_reg_rtx (RFmode);
463 
  rtx y         = gen_reg_rtx (RFmode);
464 
  rtx e         = gen_reg_rtx (RFmode);
465 
  rtx y1        = gen_reg_rtx (RFmode);
466 
  rtx e1        = gen_reg_rtx (RFmode);
467 
  rtx q1        = gen_reg_rtx (RFmode);
468 
  rtx y2        = gen_reg_rtx (RFmode);
469 
  rtx e2        = gen_reg_rtx (RFmode);
470 
  rtx q2        = gen_reg_rtx (RFmode);
471 
  rtx e3        = gen_reg_rtx (RFmode);
472 
  rtx q         = gen_reg_rtx (RFmode);
473 
  rtx r1        = gen_reg_rtx (RFmode);
474 
  rtx cond      = gen_reg_rtx (BImode);
475 
  rtx zero      = CONST0_RTX (RFmode);
476 
  rtx one       = CONST1_RTX (RFmode);
477 
  rtx status0   = CONST0_RTX (SImode);
478 
  rtx status1   = CONST1_RTX (SImode);
479 
  rtx trunc_dbl = CONST1_RTX (SImode);
480 
  rtx trunc_off = CONST2_RTX (SImode);
481 
 
482 
  /* Empty conversions to put inputs into RFmode */
483 
  emit_insn (gen_extenddfrf2 (a, operands[1]));
484 
  emit_insn (gen_extenddfrf2 (b, operands[2]));
485 
  /* y  = 1 / b                 */
486 
  emit_insn (gen_recip_approx_rf (y, a, b, cond, status0));
487 
  /* e  = 1 - (b * y)           */
488 
  emit_insn (gen_m2subrf4_cond (e, cond, one, b, y, zero, status1, trunc_off));
489 
  /* q  = a * y                 */
490 
  emit_insn (gen_mulrf3_cond (q, cond, a, y, zero, status1, trunc_off));
491 
  /* e2 = e + (e * e)           */
492 
  emit_insn (gen_m2addrf4_cond (e2, cond, e, e, e, zero, status1, trunc_off));
493 
  /* e1 = e * e                 */
494 
  emit_insn (gen_mulrf3_cond (e1, cond, e, e, zero, status1, trunc_off));
495 
  /* e3 = e + (e1 * e1)         */
496 
  emit_insn (gen_m2addrf4_cond (e3, cond, e, e1, e1, zero, status1, trunc_off));
497 
  /* q1 = q + (q * e2)          */
498 
  emit_insn (gen_m2addrf4_cond (q1, cond, q, q, e2, zero, status1, trunc_off));
499 
  /* y1 = y + (y * e2)          */
500 
  emit_insn (gen_m2addrf4_cond (y1, cond, y, y, e2, zero, status1, trunc_off));
501 
  /* q2 = double(q + (q1 * e3)) */
502 
  emit_insn (gen_m2addrf4_cond (q2, cond, q, q1, e3, zero, status1, trunc_dbl));
503 
  /* y2 = y + (y1 * e3)         */
504 
  emit_insn (gen_m2addrf4_cond (y2, cond, y, y1, e3, zero, status1, trunc_off));
505 
  /* r1  = a - (b * q2)         */
506 
  emit_insn (gen_m2subrf4_cond (r1, cond, a, b, q2, zero, status1, trunc_off));
507 
  /* Q  = double (q2 + (r1 * y2))       */
508 
  emit_insn (gen_m2addrf4_cond (q_res, cond, q2, r1, y2, y, status0, trunc_dbl));
509 
  /* Conversion back into DFmode */
510 
  emit_insn (gen_truncrfdf2 (operands[0], q_res));
511 
  DONE;
512 
})
513 
 
514 
;; Extended precision floating point division.
515 
 
516 
(define_expand "divxf3"
517 
  [(set (match_operand:XF 0 "fr_register_operand" "")
518 
        (div:XF (match_operand:XF 1 "fr_reg_or_fp01_operand" "")
519 
                (match_operand:XF 2 "fr_reg_or_fp01_operand" "")))]
520 
  "TARGET_INLINE_FLOAT_DIV"
521 
{
522 
  rtx q_res     = gen_reg_rtx (RFmode);
523 
  rtx a         = gen_reg_rtx (RFmode);
524 
  rtx b         = gen_reg_rtx (RFmode);
525 
  rtx y         = gen_reg_rtx (RFmode);
526 
  rtx e         = gen_reg_rtx (RFmode);
527 
  rtx y1        = gen_reg_rtx (RFmode);
528 
  rtx e1        = gen_reg_rtx (RFmode);
529 
  rtx q1        = gen_reg_rtx (RFmode);
530 
  rtx y2        = gen_reg_rtx (RFmode);
531 
  rtx e2        = gen_reg_rtx (RFmode);
532 
  rtx y3        = gen_reg_rtx (RFmode);
533 
  rtx e3        = gen_reg_rtx (RFmode);
534 
  rtx e4        = gen_reg_rtx (RFmode);
535 
  rtx q         = gen_reg_rtx (RFmode);
536 
  rtx r         = gen_reg_rtx (RFmode);
537 
  rtx r1        = gen_reg_rtx (RFmode);
538 
  rtx cond      = gen_reg_rtx (BImode);
539 
  rtx zero      = CONST0_RTX (RFmode);
540 
  rtx one       = CONST1_RTX (RFmode);
541 
  rtx status0   = CONST0_RTX (SImode);
542 
  rtx status1   = CONST1_RTX (SImode);
543 
  rtx trunc_off = CONST2_RTX (SImode);
544 
 
545 
  /* Empty conversions to put inputs into RFmode */
546 
  emit_insn (gen_extendxfrf2 (a, operands[1]));
547 
  emit_insn (gen_extendxfrf2 (b, operands[2]));
548 
  /* y  = 1 / b                 */
549 
  emit_insn (gen_recip_approx_rf (y, a, b, cond, status0));
550 
  /* e  = 1 - (b * y)           */
551 
  emit_insn (gen_m2subrf4_cond (e, cond, one, b, y, zero, status1, trunc_off));
552 
  /* q  = a * y                 */
553 
  emit_insn (gen_mulrf3_cond (q, cond, a, y, zero, status1, trunc_off));
554 
  /* e2 = e + (e * e)           */
555 
  emit_insn (gen_m2addrf4_cond (e2, cond, e, e, e, zero, status1, trunc_off));
556 
  /* e1 = e * e                 */
557 
  emit_insn (gen_mulrf3_cond (e1, cond, e, e, zero, status1, trunc_off));
558 
  /* y1 = y + (y * e2)          */
559 
  emit_insn (gen_m2addrf4_cond (y1, cond, y, y, e2, zero, status1, trunc_off));
560 
  /* e3 = e + (e1 * e1)         */
561 
  emit_insn (gen_m2addrf4_cond (e3, cond, e, e1, e1, zero, status1, trunc_off));
562 
  /* y2 = y + (y1 * e3)         */
563 
  emit_insn (gen_m2addrf4_cond (y2, cond, y, y1, e3, zero, status1, trunc_off));
564 
  /* r  = a - (b * q)           */
565 
  emit_insn (gen_m2subrf4_cond (r, cond, a, b, q, zero, status1, trunc_off));
566 
  /* e4  = 1 - (b * y2)         */
567 
  emit_insn (gen_m2subrf4_cond (e4, cond, one, b, y2, zero, status1, trunc_off));
568 
  /* q1 = q + (r * y2)          */
569 
  emit_insn (gen_m2addrf4_cond (q1, cond, q, r, y2, zero, status1, trunc_off));
570 
  /* y3 = y2 + (y2 * e4)        */
571 
  emit_insn (gen_m2addrf4_cond (y3, cond, y2, y2, e4, zero, status1, trunc_off));
572 
  /* r1  = a - (b * q1)         */
573 
  emit_insn (gen_m2subrf4_cond (r1, cond, a, b, q1, zero, status1, trunc_off));
574 
  /* Q  = q1 + (r1 * y3)        */
575 
  emit_insn (gen_m2addrf4_cond (q_res, cond, q1, r1, y3, y, status0, trunc_off));
576 
  /* Conversion back into XFmode */
577 
  emit_insn (gen_truncrfxf2 (operands[0], q_res));
578 
  DONE;
579 
})
580 
 
581 
 
582 
;; Integer division operations
583 
 
584 
(define_expand "divsi3"
585 
  [(set (match_operand:SI 0 "register_operand" "")
586 
        (div:SI (match_operand:SI 1 "general_operand" "")
587 
                (match_operand:SI 2 "general_operand" "")))]
588 
  "TARGET_INLINE_INT_DIV"
589 
{
590 
  rtx op1_rf, op2_rf, op0_rf, op0_di;
591 
 
592 
  op0_rf = gen_reg_rtx (RFmode);
593 
  op0_di = gen_reg_rtx (DImode);
594 
 
595 
  if (! register_operand (operands[1], SImode))
596 
    operands[1] = force_reg (SImode, operands[1]);
597 
  op1_rf = gen_reg_rtx (RFmode);
598 
  expand_float (op1_rf, operands[1], 0);
599 
 
600 
  if (! register_operand (operands[2], SImode))
601 
    operands[2] = force_reg (SImode, operands[2]);
602 
  op2_rf = gen_reg_rtx (RFmode);
603 
  expand_float (op2_rf, operands[2], 0);
604 
 
605 
  emit_insn (gen_cond_trap (EQ, operands[2], CONST0_RTX (SImode),
606 
                            CONST1_RTX (SImode)));
607 
 
608 
  emit_insn (gen_divsi3_internal (op0_rf, op1_rf, op2_rf));
609 
 
610 
  emit_insn (gen_fix_truncrfdi2_alts (op0_di, op0_rf, const1_rtx));
611 
  emit_move_insn (operands[0], gen_lowpart (SImode, op0_di));
612 
  DONE;
613 
})
614 
 
615 
(define_expand "modsi3"
616 
  [(set (match_operand:SI 0 "register_operand" "")
617 
        (mod:SI (match_operand:SI 1 "general_operand" "")
618 
                (match_operand:SI 2 "general_operand" "")))]
619 
  "TARGET_INLINE_INT_DIV"
620 
{
621 
  rtx op2_neg, op1_di, div;
622 
 
623 
  div = gen_reg_rtx (SImode);
624 
  emit_insn (gen_divsi3 (div, operands[1], operands[2]));
625 
 
626 
  op2_neg = expand_unop (SImode, neg_optab, operands[2], NULL_RTX, 0);
627 
 
628 
  /* This is a trick to get us to reuse the value that we're sure to
629 
     have already copied to the FP regs.  */
630 
  op1_di = gen_reg_rtx (DImode);
631 
  convert_move (op1_di, operands[1], 0);
632 
 
633 
  emit_insn (gen_maddsi4 (operands[0], div, op2_neg,
634 
                          gen_lowpart (SImode, op1_di)));
635 
  DONE;
636 
})
637 
 
638 
(define_expand "udivsi3"
639 
  [(set (match_operand:SI 0 "register_operand" "")
640 
        (udiv:SI (match_operand:SI 1 "general_operand" "")
641 
                 (match_operand:SI 2 "general_operand" "")))]
642 
  "TARGET_INLINE_INT_DIV"
643 
{
644 
  rtx op1_rf, op2_rf, op0_rf, op0_di;
645 
 
646 
  op0_rf = gen_reg_rtx (RFmode);
647 
  op0_di = gen_reg_rtx (DImode);
648 
 
649 
  if (! register_operand (operands[1], SImode))
650 
    operands[1] = force_reg (SImode, operands[1]);
651 
  op1_rf = gen_reg_rtx (RFmode);
652 
  expand_float (op1_rf, operands[1], 1);
653 
 
654 
  if (! register_operand (operands[2], SImode))
655 
    operands[2] = force_reg (SImode, operands[2]);
656 
  op2_rf = gen_reg_rtx (RFmode);
657 
  expand_float (op2_rf, operands[2], 1);
658 
 
659 
  emit_insn (gen_cond_trap (EQ, operands[2], CONST0_RTX (SImode),
660 
                            CONST1_RTX (SImode)));
661 
 
662 
  emit_insn (gen_divsi3_internal (op0_rf, op1_rf, op2_rf));
663 
 
664 
  emit_insn (gen_fixuns_truncrfdi2_alts (op0_di, op0_rf, const1_rtx));
665 
  emit_move_insn (operands[0], gen_lowpart (SImode, op0_di));
666 
  DONE;
667 
})
668 
 
669 
(define_expand "umodsi3"
670 
  [(set (match_operand:SI 0 "register_operand" "")
671 
        (umod:SI (match_operand:SI 1 "general_operand" "")
672 
                 (match_operand:SI 2 "general_operand" "")))]
673 
  "TARGET_INLINE_INT_DIV"
674 
{
675 
  rtx op2_neg, op1_di, div;
676 
 
677 
  div = gen_reg_rtx (SImode);
678 
  emit_insn (gen_udivsi3 (div, operands[1], operands[2]));
679 
 
680 
  op2_neg = expand_unop (SImode, neg_optab, operands[2], NULL_RTX, 0);
681 
 
682 
  /* This is a trick to get us to reuse the value that we're sure to
683 
     have already copied to the FP regs.  */
684 
  op1_di = gen_reg_rtx (DImode);
685 
  convert_move (op1_di, operands[1], 1);
686 
 
687 
  emit_insn (gen_maddsi4 (operands[0], div, op2_neg,
688 
                          gen_lowpart (SImode, op1_di)));
689 
  DONE;
690 
})
691 
 
692 
(define_expand "divsi3_internal"
693 
  [(set (match_operand:RF 0 "fr_register_operand" "")
694 
        (float:RF (div:SI (match_operand:RF 1 "fr_register_operand" "")
695 
                          (match_operand:RF 2 "fr_register_operand" ""))))]
696 
  "TARGET_INLINE_INT_DIV"
697 
{
698 
  rtx a         = operands[1];
699 
  rtx b         = operands[2];
700 
  rtx y         = gen_reg_rtx (RFmode);
701 
  rtx e         = gen_reg_rtx (RFmode);
702 
  rtx e1        = gen_reg_rtx (RFmode);
703 
  rtx q         = gen_reg_rtx (RFmode);
704 
  rtx q1        = gen_reg_rtx (RFmode);
705 
  rtx cond      = gen_reg_rtx (BImode);
706 
  rtx zero      = CONST0_RTX (RFmode);
707 
  rtx one       = CONST1_RTX (RFmode);
708 
  rtx status1   = CONST1_RTX (SImode);
709 
  rtx trunc_off = CONST2_RTX (SImode);
710 
  rtx twon34_exp = gen_reg_rtx (DImode);
711 
  rtx twon34    = gen_reg_rtx (RFmode);
712 
 
713 
  /* Load cosntant 2**(-34) */
714 
  emit_move_insn (twon34_exp, GEN_INT (65501));
715 
  emit_insn (gen_setf_exp_rf (twon34, twon34_exp));
716 
 
717 
  /* y  = 1 / b                 */
718 
  emit_insn (gen_recip_approx_rf (y, a, b, cond, status1));
719 
  /* e  = 1 - (b * y)           */
720 
  emit_insn (gen_m2subrf4_cond (e, cond, one, b, y, zero, status1, trunc_off));
721 
  /* q  = a * y                 */
722 
  emit_insn (gen_mulrf3_cond (q, cond, a, y, zero, status1, trunc_off));
723 
  /* q1 = q + (q * e)           */
724 
  emit_insn (gen_m2addrf4_cond (q1, cond, q, q, e, zero, status1, trunc_off));
725 
  /* e1 = (2**-34) + (e * e)            */
726 
  emit_insn (gen_m2addrf4_cond (e1, cond, twon34, e, e, zero, status1, trunc_off));
727 
  /* q2 = q1 + (e1 * q1)                */
728 
  emit_insn (gen_m2addrf4_cond (operands[0], cond, q1, e1, q1, y, status1, trunc_off));
729 
  DONE;
730 
})
731 
 
732 
(define_expand "divdi3"
733 
  [(set (match_operand:DI 0 "register_operand" "")
734 
        (div:DI (match_operand:DI 1 "general_operand" "")
735 
                (match_operand:DI 2 "general_operand" "")))]
736 
  "TARGET_INLINE_INT_DIV"
737 
{
738 
  rtx op1_rf, op2_rf, op0_rf;
739 
 
740 
  op0_rf = gen_reg_rtx (RFmode);
741 
 
742 
  if (! register_operand (operands[1], DImode))
743 
    operands[1] = force_reg (DImode, operands[1]);
744 
  op1_rf = gen_reg_rtx (RFmode);
745 
  expand_float (op1_rf, operands[1], 0);
746 
 
747 
  if (! register_operand (operands[2], DImode))
748 
    operands[2] = force_reg (DImode, operands[2]);
749 
  op2_rf = gen_reg_rtx (RFmode);
750 
  expand_float (op2_rf, operands[2], 0);
751 
 
752 
  emit_insn (gen_cond_trap (EQ, operands[2], CONST0_RTX (DImode),
753 
                            CONST1_RTX (DImode)));
754 
 
755 
  if (TARGET_INLINE_INT_DIV == INL_MIN_LAT)
756 
    emit_insn (gen_divdi3_internal_lat (op0_rf, op1_rf, op2_rf));
757 
  else
758 
    emit_insn (gen_divdi3_internal_thr (op0_rf, op1_rf, op2_rf));
759 
 
760 
  emit_insn (gen_fix_truncrfdi2_alts (operands[0], op0_rf, const1_rtx));
761 
  DONE;
762 
})
763 
 
764 
(define_expand "moddi3"
765 
  [(set (match_operand:DI 0 "register_operand" "")
766 
        (mod:SI (match_operand:DI 1 "general_operand" "")
767 
                (match_operand:DI 2 "general_operand" "")))]
768 
  "TARGET_INLINE_INT_DIV"
769 
{
770 
  rtx op2_neg, div;
771 
 
772 
  div = gen_reg_rtx (DImode);
773 
  emit_insn (gen_divdi3 (div, operands[1], operands[2]));
774 
 
775 
  op2_neg = expand_unop (DImode, neg_optab, operands[2], NULL_RTX, 0);
776 
 
777 
  emit_insn (gen_madddi4 (operands[0], div, op2_neg, operands[1]));
778 
  DONE;
779 
})
780 
 
781 
(define_expand "udivdi3"
782 
  [(set (match_operand:DI 0 "register_operand" "")
783 
        (udiv:DI (match_operand:DI 1 "general_operand" "")
784 
                 (match_operand:DI 2 "general_operand" "")))]
785 
  "TARGET_INLINE_INT_DIV"
786 
{
787 
  rtx op1_rf, op2_rf, op0_rf;
788 
 
789 
  op0_rf = gen_reg_rtx (RFmode);
790 
 
791 
  if (! register_operand (operands[1], DImode))
792 
    operands[1] = force_reg (DImode, operands[1]);
793 
  op1_rf = gen_reg_rtx (RFmode);
794 
  expand_float (op1_rf, operands[1], 1);
795 
 
796 
  if (! register_operand (operands[2], DImode))
797 
    operands[2] = force_reg (DImode, operands[2]);
798 
  op2_rf = gen_reg_rtx (RFmode);
799 
  expand_float (op2_rf, operands[2], 1);
800 
 
801 
  emit_insn (gen_cond_trap (EQ, operands[2], CONST0_RTX (DImode),
802 
                            CONST1_RTX (DImode)));
803 
 
804 
  if (TARGET_INLINE_INT_DIV == INL_MIN_LAT)
805 
    emit_insn (gen_divdi3_internal_lat (op0_rf, op1_rf, op2_rf));
806 
  else
807 
    emit_insn (gen_divdi3_internal_thr (op0_rf, op1_rf, op2_rf));
808 
 
809 
  emit_insn (gen_fixuns_truncrfdi2_alts (operands[0], op0_rf, const1_rtx));
810 
  DONE;
811 
})
812 
 
813 
(define_expand "umoddi3"
814 
  [(set (match_operand:DI 0 "register_operand" "")
815 
        (umod:DI (match_operand:DI 1 "general_operand" "")
816 
                 (match_operand:DI 2 "general_operand" "")))]
817 
  "TARGET_INLINE_INT_DIV"
818 
{
819 
  rtx op2_neg, div;
820 
 
821 
  div = gen_reg_rtx (DImode);
822 
  emit_insn (gen_udivdi3 (div, operands[1], operands[2]));
823 
 
824 
  op2_neg = expand_unop (DImode, neg_optab, operands[2], NULL_RTX, 0);
825 
 
826 
  emit_insn (gen_madddi4 (operands[0], div, op2_neg, operands[1]));
827 
  DONE;
828 
})
829 
 
830 
(define_expand "divdi3_internal_lat"
831 
  [(set (match_operand:RF 0 "fr_register_operand" "")
832 
        (float:RF (div:DI (match_operand:RF 1 "fr_register_operand" "")
833 
                          (match_operand:RF 2 "fr_register_operand" ""))))]
834 
  "TARGET_INLINE_INT_DIV"
835 
{
836 
  rtx a         = operands[1];
837 
  rtx b         = operands[2];
838 
  rtx y         = gen_reg_rtx (RFmode);
839 
  rtx y1        = gen_reg_rtx (RFmode);
840 
  rtx y2        = gen_reg_rtx (RFmode);
841 
  rtx e         = gen_reg_rtx (RFmode);
842 
  rtx e1        = gen_reg_rtx (RFmode);
843 
  rtx q         = gen_reg_rtx (RFmode);
844 
  rtx q1        = gen_reg_rtx (RFmode);
845 
  rtx q2        = gen_reg_rtx (RFmode);
846 
  rtx r         = gen_reg_rtx (RFmode);
847 
  rtx cond      = gen_reg_rtx (BImode);
848 
  rtx zero      = CONST0_RTX (RFmode);
849 
  rtx one       = CONST1_RTX (RFmode);
850 
  rtx status1   = CONST1_RTX (SImode);
851 
  rtx trunc_off = CONST2_RTX (SImode);
852 
 
853 
  /* y  = 1 / b                 */
854 
  emit_insn (gen_recip_approx_rf (y, a, b, cond, status1));
855 
  /* e  = 1 - (b * y)           */
856 
  emit_insn (gen_m2subrf4_cond (e, cond, one, b, y, zero, status1, trunc_off));
857 
  /* q  = a * y                 */
858 
  emit_insn (gen_mulrf3_cond (q, cond, a, y, zero, status1, trunc_off));
859 
  /* q1 = q + (q * e)           */
860 
  emit_insn (gen_m2addrf4_cond (q1, cond, q, q, e, zero, status1, trunc_off));
861 
  /* e1 = e * e                 */
862 
  emit_insn (gen_mulrf3_cond (e1, cond, e, e, zero, status1, trunc_off));
863 
  /* q2 = q1 + (e1 * q1)        */
864 
  emit_insn (gen_m2addrf4_cond (q2, cond, q1, e1, q1, zero, status1, trunc_off));
865 
  /* y1 = y + (y * e)           */
866 
  emit_insn (gen_m2addrf4_cond (y1, cond, y, y, e, zero, status1, trunc_off));
867 
  /* r  = a - (b * q2)          */
868 
  emit_insn (gen_m2subrf4_cond (r, cond, a, b, q2, zero, status1, trunc_off));
869 
  /* y2 = y1 + (y1 * e1)        */
870 
  emit_insn (gen_m2addrf4_cond (y2, cond, y1, y1, e1, zero, status1, trunc_off));
871 
  /* q3 = q2 + (r * y2)         */
872 
  emit_insn (gen_m2addrf4_cond (operands[0], cond, q2, r, y2, y, status1, trunc_off));
873 
  DONE;
874 
})
875 
 
876 
(define_expand "divdi3_internal_thr"
877 
  [(set (match_operand:RF 0 "fr_register_operand" "")
878 
        (float:RF (div:DI (match_operand:RF 1 "fr_register_operand" "")
879 
                          (match_operand:RF 2 "fr_register_operand" ""))))]
880 
  "TARGET_INLINE_INT_DIV"
881 
{
882 
  rtx a         = operands[1];
883 
  rtx b         = operands[2];
884 
  rtx y         = gen_reg_rtx (RFmode);
885 
  rtx y1        = gen_reg_rtx (RFmode);
886 
  rtx y2        = gen_reg_rtx (RFmode);
887 
  rtx e         = gen_reg_rtx (RFmode);
888 
  rtx e1        = gen_reg_rtx (RFmode);
889 
  rtx q2        = gen_reg_rtx (RFmode);
890 
  rtx r         = gen_reg_rtx (RFmode);
891 
  rtx cond      = gen_reg_rtx (BImode);
892 
  rtx zero      = CONST0_RTX (RFmode);
893 
  rtx one       = CONST1_RTX (RFmode);
894 
  rtx status1   = CONST1_RTX (SImode);
895 
  rtx trunc_off = CONST2_RTX (SImode);
896 
 
897 
  /* y  = 1 / b                 */
898 
  emit_insn (gen_recip_approx_rf (y, a, b, cond, status1));
899 
  /* e  = 1 - (b * y)           */
900 
  emit_insn (gen_m2subrf4_cond (e, cond, one, b, y, zero, status1, trunc_off));
901 
  /* y1 = y + (y * e)           */
902 
  emit_insn (gen_m2addrf4_cond (y1, cond, y, y, e, zero, status1, trunc_off));
903 
  /* e1 = e * e                 */
904 
  emit_insn (gen_mulrf3_cond (e1, cond, e, e, zero, status1, trunc_off));
905 
  /* y2 = y1 + (y1 * e1)        */
906 
  emit_insn (gen_m2addrf4_cond (y2, cond, y1, y1, e1, zero, status1, trunc_off));
907 
  /* q2 = y2 * a                */
908 
  emit_insn (gen_mulrf3_cond (q2, cond, y2, a, zero, status1, trunc_off));
909 
  /* r  = a - (b * q2)          */
910 
  emit_insn (gen_m2subrf4_cond (r, cond, a, b, q2, zero, status1, trunc_off));
911 
  /* q3 = q2 + (r * y2)         */
912 
  emit_insn (gen_m2addrf4_cond (operands[0], cond, q2, r, y2, y, status1, trunc_off));
913 
  DONE;
914 
})
915 
 
916 
;; SQRT operations
917 
 
918 
 
919 
(define_insn "sqrt_approx_rf"
920 
  [(set (match_operand:RF 0 "fr_register_operand" "=f")
921 
                (unspec:RF [(match_operand:RF 1 "fr_reg_or_fp01_operand" "fG")]
922 
                           UNSPEC_FR_SQRT_RECIP_APPROX_RES))
923 
   (set (match_operand:BI 2 "register_operand" "=c")
924 
        (unspec:BI [(match_dup 1)] UNSPEC_FR_SQRT_RECIP_APPROX))
925 
   (use (match_operand:SI 3 "const_int_operand" ""))]
926 
  ""
927 
  "frsqrta.s%3 %0, %2 = %F1"
928 
  [(set_attr "itanium_class" "fmisc")
929 
   (set_attr "predicable" "no")])
930 
 
931 
(define_expand "sqrtsf2"
932 
  [(set (match_operand:SF 0 "fr_register_operand" "=&f")
933 
        (sqrt:SF (match_operand:SF 1 "fr_reg_or_fp01_operand" "fG")))]
934 
  "TARGET_INLINE_SQRT"
935 
{
936 
  rtx insn;
937 
  if (TARGET_INLINE_SQRT == INL_MIN_LAT)
938 
    insn = gen_sqrtsf2_internal_lat (operands[0], operands[1]);
939 
  else
940 
    insn = gen_sqrtsf2_internal_thr (operands[0], operands[1]);
941 
  emit_insn (insn);
942 
  DONE;
943 
})
944 
 
945 
(define_expand "sqrtsf2_internal_thr"
946 
  [(set (match_operand:SF 0 "fr_register_operand" "")
947 
        (sqrt:SF (match_operand:SF 1 "fr_register_operand" "")))]
948 
  "TARGET_INLINE_SQRT"
949 
{
950 
  rtx y         = gen_reg_rtx (RFmode);
951 
  rtx b         = gen_reg_rtx (RFmode);
952 
  rtx g         = gen_reg_rtx (RFmode);
953 
  rtx e         = gen_reg_rtx (RFmode);
954 
  rtx s         = gen_reg_rtx (RFmode);
955 
  rtx f         = gen_reg_rtx (RFmode);
956 
  rtx y1        = gen_reg_rtx (RFmode);
957 
  rtx g1        = gen_reg_rtx (RFmode);
958 
  rtx h         = gen_reg_rtx (RFmode);
959 
  rtx d         = gen_reg_rtx (RFmode);
960 
  rtx g2        = gen_reg_rtx (RFmode);
961 
  rtx cond      = gen_reg_rtx (BImode);
962 
  rtx zero      = CONST0_RTX (RFmode);
963 
  rtx one       = CONST1_RTX (RFmode);
964 
  rtx c1        = ia64_dconst_0_5();
965 
  rtx c2        = ia64_dconst_0_375();
966 
  rtx reg_df_c1 = gen_reg_rtx (DFmode);
967 
  rtx reg_df_c2 = gen_reg_rtx (DFmode);
968 
  rtx reg_rf_c1 = gen_reg_rtx (RFmode);
969 
  rtx reg_rf_c2 = gen_reg_rtx (RFmode);
970 
  rtx status0   = CONST0_RTX (SImode);
971 
  rtx status1   = CONST1_RTX (SImode);
972 
  rtx trunc_sgl = CONST0_RTX (SImode);
973 
  rtx trunc_off = CONST2_RTX (SImode);
974 
 
975 
  /* Put needed constants into registers.        */
976 
  emit_insn (gen_movdf (reg_df_c1, c1));
977 
  emit_insn (gen_movdf (reg_df_c2, c2));
978 
  emit_insn (gen_extenddfrf2 (reg_rf_c1, reg_df_c1));
979 
  emit_insn (gen_extenddfrf2 (reg_rf_c2, reg_df_c2));
980 
  /* Empty conversion to put input into RFmode.  */
981 
  emit_insn (gen_extendsfrf2 (b, operands[1]));
982 
  /* y = sqrt (1 / b)                   */
983 
  emit_insn (gen_sqrt_approx_rf (y, b, cond, status0));
984 
  /* g = b * y                          */
985 
  emit_insn (gen_mulrf3_cond (g, cond, b, y, zero, status1, trunc_off));
986 
  /* e = 1 - (g * y)                    */
987 
  emit_insn (gen_m2subrf4_cond (e, cond, one, g, y, zero, status1, trunc_off));
988 
  /* s = 0.5 + (0.375 * e)              */
989 
  emit_insn (gen_m2addrf4_cond (s, cond, reg_rf_c1, reg_rf_c2, e, zero, status1, trunc_off));
990 
  /* f = y * e                          */
991 
  emit_insn (gen_mulrf3_cond (f, cond, y, e, zero, status1, trunc_off));
992 
  /* y1 = y + (f * s)                   */
993 
  emit_insn (gen_m2addrf4_cond (y1, cond, y, f, s, zero, status1, trunc_off));
994 
  /* g1 = single (b * y1)               */
995 
  emit_insn (gen_mulrf3_cond (g1, cond, b, y1, zero, status1, trunc_sgl));
996 
  /* h = 0.5 * y1                       */
997 
  emit_insn (gen_mulrf3_cond (h, cond, reg_rf_c1, y1, zero, status1, trunc_off));
998 
  /* d = b - g1 * g1                    */
999 
  emit_insn (gen_m2subrf4_cond (d, cond, b, g1, g1, zero, status1, trunc_off));
1000 
  /* g2 = single(g1 + (d * h))          */
1001 
  emit_insn (gen_m2addrf4_cond (g2, cond, g1, d, h, y, status0, trunc_sgl));
1002 
  /* Conversion back into SFmode.       */
1003 
  emit_insn (gen_truncrfsf2 (operands[0], g2));
1004 
  DONE;
1005 
})
1006 
 
1007 
(define_expand "sqrtsf2_internal_lat"
1008 
  [(set (match_operand:SF 0 "fr_register_operand" "")
1009 
        (sqrt:SF (match_operand:SF 1 "fr_register_operand" "")))]
1010 
  "TARGET_INLINE_SQRT"
1011 
{
1012 
  rtx y         = gen_reg_rtx (RFmode);
1013 
  rtx b         = gen_reg_rtx (RFmode);
1014 
  rtx g         = gen_reg_rtx (RFmode);
1015 
  rtx g1        = gen_reg_rtx (RFmode);
1016 
  rtx g2        = gen_reg_rtx (RFmode);
1017 
  rtx e         = gen_reg_rtx (RFmode);
1018 
  rtx s         = gen_reg_rtx (RFmode);
1019 
  rtx f         = gen_reg_rtx (RFmode);
1020 
  rtx f1        = gen_reg_rtx (RFmode);
1021 
  rtx h         = gen_reg_rtx (RFmode);
1022 
  rtx h1        = gen_reg_rtx (RFmode);
1023 
  rtx d         = gen_reg_rtx (RFmode);
1024 
  rtx cond      = gen_reg_rtx (BImode);
1025 
  rtx zero      = CONST0_RTX (RFmode);
1026 
  rtx one       = CONST1_RTX (RFmode);
1027 
  rtx c1        = ia64_dconst_0_5();
1028 
  rtx c2        = ia64_dconst_0_375();
1029 
  rtx reg_df_c1 = gen_reg_rtx (DFmode);
1030 
  rtx reg_df_c2 = gen_reg_rtx (DFmode);
1031 
  rtx reg_rf_c1 = gen_reg_rtx (RFmode);
1032 
  rtx reg_rf_c2 = gen_reg_rtx (RFmode);
1033 
  rtx status0   = CONST0_RTX (SImode);
1034 
  rtx status1   = CONST1_RTX (SImode);
1035 
  rtx trunc_sgl = CONST0_RTX (SImode);
1036 
  rtx trunc_off = CONST2_RTX (SImode);
1037 
 
1038 
  /* Put needed constants into registers.        */
1039 
  emit_insn (gen_movdf (reg_df_c1, c1));
1040 
  emit_insn (gen_movdf (reg_df_c2, c2));
1041 
  emit_insn (gen_extenddfrf2 (reg_rf_c1, reg_df_c1));
1042 
  emit_insn (gen_extenddfrf2 (reg_rf_c2, reg_df_c2));
1043 
  /* Empty conversion to put input into RFmode.  */
1044 
  emit_insn (gen_extendsfrf2 (b, operands[1]));
1045 
  /* y = sqrt (1 / b)                   */
1046 
  emit_insn (gen_sqrt_approx_rf (y, b, cond, status0));
1047 
  /* g = b * y                          */
1048 
  emit_insn (gen_mulrf3_cond (g, cond, b, y, zero, status1, trunc_off));
1049 
  /* e = 1 - (g * y)                    */
1050 
  emit_insn (gen_m2subrf4_cond (e, cond, one, g, y, zero, status1, trunc_off));
1051 
  /* h = 0.5 * y                        */
1052 
  emit_insn (gen_mulrf3_cond (h, cond, reg_rf_c1, y, zero, status1, trunc_off));
1053 
  /* s = 0.5 + (0.375 * e)              */
1054 
  emit_insn (gen_m2addrf4_cond (s, cond, reg_rf_c1, reg_rf_c2, e, zero, status1, trunc_off));
1055 
  /* f = e * g                          */
1056 
  emit_insn (gen_mulrf3_cond (f, cond, e, g, zero, status1, trunc_off));
1057 
  /* g1 = single (g + (f * s))          */
1058 
  emit_insn (gen_m2addrf4_cond (g1, cond, g, f, s, zero, status1, trunc_sgl));
1059 
  /* f1 = e * h                         */
1060 
  emit_insn (gen_mulrf3_cond (f1, cond, e, h, zero, status1, trunc_off));
1061 
  /* d = b - g1 * g1                    */
1062 
  emit_insn (gen_m2subrf4_cond (d, cond, b, g1, g1, zero, status1, trunc_off));
1063 
  /* h1 = h + (f1 * s)                  */
1064 
  emit_insn (gen_m2addrf4_cond (h1, cond, h, f1, s, zero, status1, trunc_off));
1065 
  /* g2 = single(g1 + (d * h1))         */
1066 
  emit_insn (gen_m2addrf4_cond (g2, cond, g1, d, h1, y, status0, trunc_sgl));
1067 
  /* Conversion back into SFmode.       */
1068 
  emit_insn (gen_truncrfsf2 (operands[0], g2));
1069 
  DONE;
1070 
})
1071 
 
1072 
(define_expand "sqrtdf2"
1073 
  [(set (match_operand:DF 0 "fr_register_operand" "=&f")
1074 
        (sqrt:DF (match_operand:DF 1 "fr_reg_or_fp01_operand" "fG")))]
1075 
  "TARGET_INLINE_SQRT"
1076 
{
1077 
  rtx insn;
1078 
#if 0
1079 
  if (TARGET_INLINE_SQRT == INL_MIN_LAT)
1080 
    insn = gen_sqrtdf2_internal_lat (operands[0], operands[1]);
1081 
  else
1082 
#endif
1083 
  insn = gen_sqrtdf2_internal_thr (operands[0], operands[1]);
1084 
  emit_insn (insn);
1085 
  DONE;
1086 
})
1087 
 
1088 
(define_expand "sqrtdf2_internal_thr"
1089 
  [(set (match_operand:DF 0 "fr_register_operand" "")
1090 
        (sqrt:DF (match_operand:DF 1 "fr_register_operand" "")))]
1091 
  "TARGET_INLINE_SQRT"
1092 
{
1093 
  rtx y         = gen_reg_rtx (RFmode);
1094 
  rtx b         = gen_reg_rtx (RFmode);
1095 
  rtx g         = gen_reg_rtx (RFmode);
1096 
  rtx g1        = gen_reg_rtx (RFmode);
1097 
  rtx g2        = gen_reg_rtx (RFmode);
1098 
  rtx g3        = gen_reg_rtx (RFmode);
1099 
  rtx g4        = gen_reg_rtx (RFmode);
1100 
  rtx r         = gen_reg_rtx (RFmode);
1101 
  rtx r1        = gen_reg_rtx (RFmode);
1102 
  rtx h         = gen_reg_rtx (RFmode);
1103 
  rtx h1        = gen_reg_rtx (RFmode);
1104 
  rtx h2        = gen_reg_rtx (RFmode);
1105 
  rtx d         = gen_reg_rtx (RFmode);
1106 
  rtx d1        = gen_reg_rtx (RFmode);
1107 
  rtx cond      = gen_reg_rtx (BImode);
1108 
  rtx zero      = CONST0_RTX (RFmode);
1109 
  rtx c1        = ia64_dconst_0_5();
1110 
  rtx reg_df_c1 = gen_reg_rtx (DFmode);
1111 
  rtx reg_rf_c1 = gen_reg_rtx (RFmode);
1112 
  rtx status0   = CONST0_RTX (SImode);
1113 
  rtx status1   = CONST1_RTX (SImode);
1114 
  rtx trunc_dbl = CONST1_RTX (SImode);
1115 
  rtx trunc_off = CONST2_RTX (SImode);
1116 
 
1117 
  /* Put needed constants into registers.        */
1118 
  emit_insn (gen_movdf (reg_df_c1, c1));
1119 
  emit_insn (gen_extenddfrf2 (reg_rf_c1, reg_df_c1));
1120 
  /* Empty conversion to put input into RFmode.  */
1121 
  emit_insn (gen_extenddfrf2 (b, operands[1]));
1122 
  /* y = sqrt (1 / b)                   */
1123 
  emit_insn (gen_sqrt_approx_rf (y, b, cond, status0));
1124 
  /* g = b * y                          */
1125 
  emit_insn (gen_mulrf3_cond (g, cond, b, y, zero, status1, trunc_off));
1126 
  /* h = 0.5 * y                        */
1127 
  emit_insn (gen_mulrf3_cond (h, cond, reg_rf_c1, y, zero, status1, trunc_off));
1128 
  /* r = 0.5 - (g * h)                  */
1129 
  emit_insn (gen_m2subrf4_cond (r, cond, reg_rf_c1, g, h, zero, status1, trunc_off));
1130 
  /* g1 = g + (g * r)                   */
1131 
  emit_insn (gen_m2addrf4_cond (g1, cond, g, g, r, zero, status1, trunc_off));
1132 
  /* h1 = h + (h * r)                   */
1133 
  emit_insn (gen_m2addrf4_cond (h1, cond, h, h, r, zero, status1, trunc_off));
1134 
  /* r1 = 0.5 - (g1 * h1)               */
1135 
  emit_insn (gen_m2subrf4_cond (r1, cond, reg_rf_c1, g1, h1, zero, status1, trunc_off));
1136 
  /* g2 = g1 + (g1 * r1)                */
1137 
  emit_insn (gen_m2addrf4_cond (g2, cond, g1, g1, r1, zero, status1, trunc_off));
1138 
  /* h2 = h1 + (h1 * r1)                */
1139 
  emit_insn (gen_m2addrf4_cond (h2, cond, h1, h1, r1, zero, status1, trunc_off));
1140 
  /* d = b - (g2 * g2)                  */
1141 
  emit_insn (gen_m2subrf4_cond (d, cond, b, g2, g2, zero, status1, trunc_off));
1142 
  /* g3 = g2 + (d * h2)                 */
1143 
  emit_insn (gen_m2addrf4_cond (g3, cond, g2, d, h2, zero, status1, trunc_off));
1144 
  /* d1 = b - (g3 * g3)                 */
1145 
  emit_insn (gen_m2subrf4_cond (d1, cond, b, g3, g3, zero, status1, trunc_off));
1146 
  /* g4 = g3 + (d1 * h2)                */
1147 
  emit_insn (gen_m2addrf4_cond (g4, cond, g3, d1, h2, y, status1, trunc_dbl));
1148 
  /* Conversion back into SFmode.       */
1149 
  emit_insn (gen_truncrfdf2 (operands[0], g4));
1150 
  DONE;
1151 
})
1152 
 
1153 
(define_expand "sqrtxf2"
1154 
  [(set (match_operand:XF 0 "fr_register_operand" "")
1155 
        (sqrt:XF (match_operand:XF 1 "fr_register_operand" "")))]
1156 
  "TARGET_INLINE_SQRT"
1157 
{
1158 
  rtx y         = gen_reg_rtx (RFmode);
1159 
  rtx b         = gen_reg_rtx (RFmode);
1160 
  rtx g         = gen_reg_rtx (RFmode);
1161 
  rtx g1        = gen_reg_rtx (RFmode);
1162 
  rtx g2        = gen_reg_rtx (RFmode);
1163 
  rtx g3        = gen_reg_rtx (RFmode);
1164 
  rtx g4        = gen_reg_rtx (RFmode);
1165 
  rtx e         = gen_reg_rtx (RFmode);
1166 
  rtx e1        = gen_reg_rtx (RFmode);
1167 
  rtx e2        = gen_reg_rtx (RFmode);
1168 
  rtx h         = gen_reg_rtx (RFmode);
1169 
  rtx h1        = gen_reg_rtx (RFmode);
1170 
  rtx h2        = gen_reg_rtx (RFmode);
1171 
  rtx h3        = gen_reg_rtx (RFmode);
1172 
  rtx d         = gen_reg_rtx (RFmode);
1173 
  rtx d1        = gen_reg_rtx (RFmode);
1174 
  rtx cond      = gen_reg_rtx (BImode);
1175 
  rtx zero      = CONST0_RTX (RFmode);
1176 
  rtx c1        = ia64_dconst_0_5();
1177 
  rtx reg_df_c1 = gen_reg_rtx (DFmode);
1178 
  rtx reg_rf_c1 = gen_reg_rtx (RFmode);
1179 
  rtx status0   = CONST0_RTX (SImode);
1180 
  rtx status1   = CONST1_RTX (SImode);
1181 
  rtx trunc_off = CONST2_RTX (SImode);
1182 
 
1183 
  /* Put needed constants into registers.        */
1184 
  emit_insn (gen_movdf (reg_df_c1, c1));
1185 
  emit_insn (gen_extenddfrf2 (reg_rf_c1, reg_df_c1));
1186 
  /* Empty conversion to put input into RFmode.  */
1187 
  emit_insn (gen_extendxfrf2 (b, operands[1]));
1188 
  /* y = sqrt (1 / b)                   */
1189 
  emit_insn (gen_sqrt_approx_rf (y, b, cond, status0));
1190 
  /* g = b * y                          */
1191 
  emit_insn (gen_mulrf3_cond (g, cond, b, y, zero, status1, trunc_off));
1192 
  /* h = 0.5 * y                        */
1193 
  emit_insn (gen_mulrf3_cond (h, cond, reg_rf_c1, y, zero, status1, trunc_off));
1194 
  /* e = 0.5 - (g * h)                  */
1195 
  emit_insn (gen_m2subrf4_cond (e, cond, reg_rf_c1, g, h, zero, status1, trunc_off));
1196 
  /* g1 = g + (g * e)                   */
1197 
  emit_insn (gen_m2addrf4_cond (g1, cond, g, g, e, zero, status1, trunc_off));
1198 
  /* h1 = h + (h * e)                   */
1199 
  emit_insn (gen_m2addrf4_cond (h1, cond, h, h, e, zero, status1, trunc_off));
1200 
  /* e1 = 0.5 - (g1 * h1)               */
1201 
  emit_insn (gen_m2subrf4_cond (e1, cond, reg_rf_c1, g1, h1, zero, status1, trunc_off));
1202 
  /* g2 = g1 + (g1 * e1)                */
1203 
  emit_insn (gen_m2addrf4_cond (g2, cond, g1, g1, e1, zero, status1, trunc_off));
1204 
  /* h2 = h1 + (h1 * e1)                */
1205 
  emit_insn (gen_m2addrf4_cond (h2, cond, h1, h1, e1, zero, status1, trunc_off));
1206 
  /* d = b - (g2 * g2)                  */
1207 
  emit_insn (gen_m2subrf4_cond (d, cond, b, g2, g2, zero, status1, trunc_off));
1208 
  /* e2 = 0.5 - (g2 * h2)               */
1209 
  emit_insn (gen_m2subrf4_cond (e2, cond, reg_rf_c1, g2, h2, zero, status1, trunc_off));
1210 
  /* g3 = g2 + (d * h2)                 */
1211 
  emit_insn (gen_m2addrf4_cond (g3, cond, g2, d, h2, zero, status1, trunc_off));
1212 
  /* h3 = h2 + (e2 * h2)                */
1213 
  emit_insn (gen_m2addrf4_cond (h3, cond, h2, e2, h2, zero, status1, trunc_off));
1214 
  /* d1 = b - (g3 * g3)                 */
1215 
  emit_insn (gen_m2subrf4_cond (d1, cond, b, g3, g3, zero, status1, trunc_off));
1216 
  /* g4 = g3 + (d1 * h3)                */
1217 
  emit_insn (gen_m2addrf4_cond (g4, cond, g3, d1, h3, y, status1, trunc_off));
1218 
  /* Conversion back into SFmode.       */
1219 
  emit_insn (gen_truncrfxf2 (operands[0], g4));
1220 
  DONE;
1221 
})

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.