OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc1/] [gcc/] [config/] [rs6000/] [dfp.md] - Blame information for rev 338

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 282 jeremybenn 
;; Decimal Floating Point (DFP) patterns.
2 
;; Copyright (C) 2007, 2008, 2010
3 
;; Free Software Foundation, Inc.
4 
;; Contributed by Ben Elliston (bje@au.ibm.com) and Peter Bergner
5 
;; (bergner@vnet.ibm.com).
6 
 
7 
;; This file is part of GCC.
8 
 
9 
;; GCC is free software; you can redistribute it and/or modify it
10 
;; under the terms of the GNU General Public License as published
11 
;; by the Free Software Foundation; either version 3, or (at your
12 
;; option) any later version.
13 
 
14 
;; GCC is distributed in the hope that it will be useful, but WITHOUT
15 
;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16 
;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
17 
;; 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 
;; .
22 
 
23 
;;
24 
;; UNSPEC usage
25 
;;
26 
 
27 
(define_constants
28 
  [(UNSPEC_MOVSD_LOAD           400)
29 
   (UNSPEC_MOVSD_STORE          401)
30 
  ])
31 
 
32 
 
33 
(define_expand "movsd"
34 
  [(set (match_operand:SD 0 "nonimmediate_operand" "")
35 
        (match_operand:SD 1 "any_operand" ""))]
36 
  "TARGET_HARD_FLOAT && TARGET_FPRS"
37 
  "{ rs6000_emit_move (operands[0], operands[1], SDmode); DONE; }")
38 
 
39 
(define_split
40 
  [(set (match_operand:SD 0 "gpc_reg_operand" "")
41 
        (match_operand:SD 1 "const_double_operand" ""))]
42 
  "reload_completed
43 
   && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
44 
       || (GET_CODE (operands[0]) == SUBREG
45 
           && GET_CODE (SUBREG_REG (operands[0])) == REG
46 
           && REGNO (SUBREG_REG (operands[0])) <= 31))"
47 
  [(set (match_dup 2) (match_dup 3))]
48 
  "
49 
{
50 
  long l;
51 
  REAL_VALUE_TYPE rv;
52 
 
53 
  REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
54 
  REAL_VALUE_TO_TARGET_DECIMAL32 (rv, l);
55 
 
56 
  if (! TARGET_POWERPC64)
57 
    operands[2] = operand_subword (operands[0], 0, 0, SDmode);
58 
  else
59 
    operands[2] = gen_lowpart (SImode, operands[0]);
60 
 
61 
  operands[3] = gen_int_mode (l, SImode);
62 
}")
63 
 
64 
(define_insn "movsd_hardfloat"
65 
  [(set (match_operand:SD 0 "nonimmediate_operand" "=r,r,m,f,*c*l,*q,!r,*h,!r,!r")
66 
        (match_operand:SD 1 "input_operand"        "r,m,r,f,r,r,h,0,G,Fn"))]
67 
  "(gpc_reg_operand (operands[0], SDmode)
68 
   || gpc_reg_operand (operands[1], SDmode))
69 
   && (TARGET_HARD_FLOAT && TARGET_FPRS)"
70 
  "@
71 
   mr %0,%1
72 
   {l%U1%X1|lwz%U1%X1} %0,%1
73 
   {st%U0%X0|stw%U0%X0} %1,%0
74 
   fmr %0,%1
75 
   mt%0 %1
76 
   mt%0 %1
77 
   mf%1 %0
78 
   {cror 0,0,0|nop}
79 
   #
80 
   #"
81 
  [(set_attr "type" "*,load,store,fp,mtjmpr,*,mfjmpr,*,*,*")
82 
   (set_attr "length" "4,4,4,4,4,4,4,4,4,8")])
83 
 
84 
(define_insn "movsd_softfloat"
85 
  [(set (match_operand:SD 0 "nonimmediate_operand" "=r,cl,q,r,r,m,r,r,r,r,r,*h")
86 
        (match_operand:SD 1 "input_operand" "r,r,r,h,m,r,I,L,R,G,Fn,0"))]
87 
  "(gpc_reg_operand (operands[0], SDmode)
88 
   || gpc_reg_operand (operands[1], SDmode))
89 
   && (TARGET_SOFT_FLOAT || !TARGET_FPRS)"
90 
  "@
91 
   mr %0,%1
92 
   mt%0 %1
93 
   mt%0 %1
94 
   mf%1 %0
95 
   {l%U1%X1|lwz%U1%X1} %0,%1
96 
   {st%U0%X0|stw%U0%X0} %1,%0
97 
   {lil|li} %0,%1
98 
   {liu|lis} %0,%v1
99 
   {cal|la} %0,%a1
100 
   #
101 
   #
102 
   {cror 0,0,0|nop}"
103 
  [(set_attr "type" "*,mtjmpr,*,mfjmpr,load,store,*,*,*,*,*,*")
104 
   (set_attr "length" "4,4,4,4,4,4,4,4,4,4,8,4")])
105 
 
106 
(define_insn "movsd_store"
107 
  [(set (match_operand:DD 0 "nonimmediate_operand" "=m")
108 
        (unspec:DD [(match_operand:SD 1 "input_operand" "d")]
109 
                   UNSPEC_MOVSD_STORE))]
110 
  "(gpc_reg_operand (operands[0], DDmode)
111 
   || gpc_reg_operand (operands[1], SDmode))
112 
   && TARGET_HARD_FLOAT && TARGET_FPRS"
113 
  "stfd%U0%X0 %1,%0"
114 
  [(set_attr "type" "fpstore")
115 
   (set_attr "length" "4")])
116 
 
117 
(define_insn "movsd_load"
118 
  [(set (match_operand:SD 0 "nonimmediate_operand" "=f")
119 
        (unspec:SD [(match_operand:DD 1 "input_operand" "m")]
120 
                   UNSPEC_MOVSD_LOAD))]
121 
  "(gpc_reg_operand (operands[0], SDmode)
122 
   || gpc_reg_operand (operands[1], DDmode))
123 
   && TARGET_HARD_FLOAT && TARGET_FPRS"
124 
  "lfd%U1%X1 %0,%1"
125 
  [(set_attr "type" "fpload")
126 
   (set_attr "length" "4")])
127 
 
128 
;; Hardware support for decimal floating point operations.
129 
 
130 
(define_insn "extendsddd2"
131 
  [(set (match_operand:DD 0 "gpc_reg_operand" "=d")
132 
        (float_extend:DD (match_operand:SD 1 "gpc_reg_operand" "f")))]
133 
  "TARGET_DFP"
134 
  "dctdp %0,%1"
135 
  [(set_attr "type" "fp")])
136 
 
137 
(define_expand "extendsdtd2"
138 
  [(set (match_operand:TD 0 "gpc_reg_operand" "=d")
139 
        (float_extend:TD (match_operand:SD 1 "gpc_reg_operand" "d")))]
140 
  "TARGET_DFP"
141 
{
142 
  rtx tmp = gen_reg_rtx (DDmode);
143 
  emit_insn (gen_extendsddd2 (tmp, operands[1]));
144 
  emit_insn (gen_extendddtd2 (operands[0], tmp));
145 
  DONE;
146 
})
147 
 
148 
(define_insn "truncddsd2"
149 
  [(set (match_operand:SD 0 "gpc_reg_operand" "=f")
150 
        (float_truncate:SD (match_operand:DD 1 "gpc_reg_operand" "d")))]
151 
  "TARGET_DFP"
152 
  "drsp %0,%1"
153 
  [(set_attr "type" "fp")])
154 
 
155 
(define_expand "negdd2"
156 
  [(set (match_operand:DD 0 "gpc_reg_operand" "")
157 
        (neg:DD (match_operand:DD 1 "gpc_reg_operand" "")))]
158 
  "TARGET_HARD_FLOAT && TARGET_FPRS"
159 
  "")
160 
 
161 
(define_insn "*negdd2_fpr"
162 
  [(set (match_operand:DD 0 "gpc_reg_operand" "=d")
163 
        (neg:DD (match_operand:DD 1 "gpc_reg_operand" "d")))]
164 
  "TARGET_HARD_FLOAT && TARGET_FPRS"
165 
  "fneg %0,%1"
166 
  [(set_attr "type" "fp")])
167 
 
168 
(define_expand "absdd2"
169 
  [(set (match_operand:DD 0 "gpc_reg_operand" "")
170 
        (abs:DD (match_operand:DD 1 "gpc_reg_operand" "")))]
171 
  "TARGET_HARD_FLOAT && TARGET_FPRS"
172 
  "")
173 
 
174 
(define_insn "*absdd2_fpr"
175 
  [(set (match_operand:DD 0 "gpc_reg_operand" "=d")
176 
        (abs:DD (match_operand:DD 1 "gpc_reg_operand" "d")))]
177 
  "TARGET_HARD_FLOAT && TARGET_FPRS"
178 
  "fabs %0,%1"
179 
  [(set_attr "type" "fp")])
180 
 
181 
(define_insn "*nabsdd2_fpr"
182 
  [(set (match_operand:DD 0 "gpc_reg_operand" "=d")
183 
        (neg:DD (abs:DD (match_operand:DD 1 "gpc_reg_operand" "d"))))]
184 
  "TARGET_HARD_FLOAT && TARGET_FPRS"
185 
  "fnabs %0,%1"
186 
  [(set_attr "type" "fp")])
187 
 
188 
(define_expand "movdd"
189 
  [(set (match_operand:DD 0 "nonimmediate_operand" "")
190 
        (match_operand:DD 1 "any_operand" ""))]
191 
  ""
192 
  "{ rs6000_emit_move (operands[0], operands[1], DDmode); DONE; }")
193 
 
194 
(define_split
195 
  [(set (match_operand:DD 0 "gpc_reg_operand" "")
196 
        (match_operand:DD 1 "const_int_operand" ""))]
197 
  "! TARGET_POWERPC64 && reload_completed
198 
   && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
199 
       || (GET_CODE (operands[0]) == SUBREG
200 
           && GET_CODE (SUBREG_REG (operands[0])) == REG
201 
           && REGNO (SUBREG_REG (operands[0])) <= 31))"
202 
  [(set (match_dup 2) (match_dup 4))
203 
   (set (match_dup 3) (match_dup 1))]
204 
  "
205 
{
206 
  int endian = (WORDS_BIG_ENDIAN == 0);
207 
  HOST_WIDE_INT value = INTVAL (operands[1]);
208 
 
209 
  operands[2] = operand_subword (operands[0], endian, 0, DDmode);
210 
  operands[3] = operand_subword (operands[0], 1 - endian, 0, DDmode);
211 
#if HOST_BITS_PER_WIDE_INT == 32
212 
  operands[4] = (value & 0x80000000) ? constm1_rtx : const0_rtx;
213 
#else
214 
  operands[4] = GEN_INT (value >> 32);
215 
  operands[1] = GEN_INT (((value & 0xffffffff) ^ 0x80000000) - 0x80000000);
216 
#endif
217 
}")
218 
 
219 
(define_split
220 
  [(set (match_operand:DD 0 "gpc_reg_operand" "")
221 
        (match_operand:DD 1 "const_double_operand" ""))]
222 
  "! TARGET_POWERPC64 && reload_completed
223 
   && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
224 
       || (GET_CODE (operands[0]) == SUBREG
225 
           && GET_CODE (SUBREG_REG (operands[0])) == REG
226 
           && REGNO (SUBREG_REG (operands[0])) <= 31))"
227 
  [(set (match_dup 2) (match_dup 4))
228 
   (set (match_dup 3) (match_dup 5))]
229 
  "
230 
{
231 
  int endian = (WORDS_BIG_ENDIAN == 0);
232 
  long l[2];
233 
  REAL_VALUE_TYPE rv;
234 
 
235 
  REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
236 
  REAL_VALUE_TO_TARGET_DECIMAL64 (rv, l);
237 
 
238 
  operands[2] = operand_subword (operands[0], endian, 0, DDmode);
239 
  operands[3] = operand_subword (operands[0], 1 - endian, 0, DDmode);
240 
  operands[4] = gen_int_mode (l[endian], SImode);
241 
  operands[5] = gen_int_mode (l[1 - endian], SImode);
242 
}")
243 
 
244 
(define_split
245 
  [(set (match_operand:DD 0 "gpc_reg_operand" "")
246 
        (match_operand:DD 1 "const_double_operand" ""))]
247 
  "TARGET_POWERPC64 && reload_completed
248 
   && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
249 
       || (GET_CODE (operands[0]) == SUBREG
250 
           && GET_CODE (SUBREG_REG (operands[0])) == REG
251 
           && REGNO (SUBREG_REG (operands[0])) <= 31))"
252 
  [(set (match_dup 2) (match_dup 3))]
253 
  "
254 
{
255 
  int endian = (WORDS_BIG_ENDIAN == 0);
256 
  long l[2];
257 
  REAL_VALUE_TYPE rv;
258 
#if HOST_BITS_PER_WIDE_INT >= 64
259 
  HOST_WIDE_INT val;
260 
#endif
261 
 
262 
  REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
263 
  REAL_VALUE_TO_TARGET_DECIMAL64 (rv, l);
264 
 
265 
  operands[2] = gen_lowpart (DImode, operands[0]);
266 
  /* HIGHPART is lower memory address when WORDS_BIG_ENDIAN.  */
267 
#if HOST_BITS_PER_WIDE_INT >= 64
268 
  val = ((HOST_WIDE_INT)(unsigned long)l[endian] << 32
269 
         | ((HOST_WIDE_INT)(unsigned long)l[1 - endian]));
270 
 
271 
  operands[3] = gen_int_mode (val, DImode);
272 
#else
273 
  operands[3] = immed_double_const (l[1 - endian], l[endian], DImode);
274 
#endif
275 
}")
276 
 
277 
;; Don't have reload use general registers to load a constant.  First,
278 
;; it might not work if the output operand is the equivalent of
279 
;; a non-offsettable memref, but also it is less efficient than loading
280 
;; the constant into an FP register, since it will probably be used there.
281 
;; The "??" is a kludge until we can figure out a more reasonable way
282 
;; of handling these non-offsettable values.
283 
(define_insn "*movdd_hardfloat32"
284 
  [(set (match_operand:DD 0 "nonimmediate_operand" "=!r,??r,m,d,d,m,!r,!r,!r")
285 
        (match_operand:DD 1 "input_operand" "r,m,r,d,m,d,G,H,F"))]
286 
  "! TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS
287 
   && (gpc_reg_operand (operands[0], DDmode)
288 
       || gpc_reg_operand (operands[1], DDmode))"
289 
  "*
290 
{
291 
  switch (which_alternative)
292 
    {
293 
    default:
294 
      gcc_unreachable ();
295 
    case 0:
296 
    case 1:
297 
    case 2:
298 
      return \"#\";
299 
    case 3:
300 
      return \"fmr %0,%1\";
301 
    case 4:
302 
      return \"lfd%U1%X1 %0,%1\";
303 
    case 5:
304 
      return \"stfd%U0%X0 %1,%0\";
305 
    case 6:
306 
    case 7:
307 
    case 8:
308 
      return \"#\";
309 
    }
310 
}"
311 
  [(set_attr "type" "two,load,store,fp,fpload,fpstore,*,*,*")
312 
   (set_attr "length" "8,16,16,4,4,4,8,12,16")])
313 
 
314 
(define_insn "*movdd_softfloat32"
315 
  [(set (match_operand:DD 0 "nonimmediate_operand" "=r,r,m,r,r,r")
316 
        (match_operand:DD 1 "input_operand" "r,m,r,G,H,F"))]
317 
  "! TARGET_POWERPC64 && (TARGET_SOFT_FLOAT || !TARGET_FPRS)
318 
   && (gpc_reg_operand (operands[0], DDmode)
319 
       || gpc_reg_operand (operands[1], DDmode))"
320 
  "#"
321 
  [(set_attr "type" "two,load,store,*,*,*")
322 
   (set_attr "length" "8,8,8,8,12,16")])
323 
 
324 
; ld/std require word-aligned displacements -> 'Y' constraint.
325 
; List Y->r and r->Y before r->r for reload.
326 
(define_insn "*movdd_hardfloat64_mfpgpr"
327 
  [(set (match_operand:DD 0 "nonimmediate_operand" "=Y,r,!r,d,d,m,*c*l,!r,*h,!r,!r,!r,r,d")
328 
        (match_operand:DD 1 "input_operand" "r,Y,r,d,m,d,r,h,0,G,H,F,d,r"))]
329 
  "TARGET_POWERPC64 && TARGET_MFPGPR && TARGET_HARD_FLOAT && TARGET_FPRS
330 
   && (gpc_reg_operand (operands[0], DDmode)
331 
       || gpc_reg_operand (operands[1], DDmode))"
332 
  "@
333 
   std%U0%X0 %1,%0
334 
   ld%U1%X1 %0,%1
335 
   mr %0,%1
336 
   fmr %0,%1
337 
   lfd%U1%X1 %0,%1
338 
   stfd%U0%X0 %1,%0
339 
   mt%0 %1
340 
   mf%1 %0
341 
   {cror 0,0,0|nop}
342 
   #
343 
   #
344 
   #
345 
   mftgpr %0,%1
346 
   mffgpr %0,%1"
347 
  [(set_attr "type" "store,load,*,fp,fpload,fpstore,mtjmpr,mfjmpr,*,*,*,*,mftgpr,mffgpr")
348 
   (set_attr "length" "4,4,4,4,4,4,4,4,4,8,12,16,4,4")])
349 
 
350 
; ld/std require word-aligned displacements -> 'Y' constraint.
351 
; List Y->r and r->Y before r->r for reload.
352 
(define_insn "*movdd_hardfloat64"
353 
  [(set (match_operand:DD 0 "nonimmediate_operand" "=Y,r,!r,d,d,m,*c*l,!r,*h,!r,!r,!r")
354 
        (match_operand:DD 1 "input_operand" "r,Y,r,d,m,d,r,h,0,G,H,F"))]
355 
  "TARGET_POWERPC64 && !TARGET_MFPGPR && TARGET_HARD_FLOAT && TARGET_FPRS
356 
   && (gpc_reg_operand (operands[0], DDmode)
357 
       || gpc_reg_operand (operands[1], DDmode))"
358 
  "@
359 
   std%U0%X0 %1,%0
360 
   ld%U1%X1 %0,%1
361 
   mr %0,%1
362 
   fmr %0,%1
363 
   lfd%U1%X1 %0,%1
364 
   stfd%U0%X0 %1,%0
365 
   mt%0 %1
366 
   mf%1 %0
367 
   {cror 0,0,0|nop}
368 
   #
369 
   #
370 
   #"
371 
  [(set_attr "type" "store,load,*,fp,fpload,fpstore,mtjmpr,mfjmpr,*,*,*,*")
372 
   (set_attr "length" "4,4,4,4,4,4,4,4,4,8,12,16")])
373 
 
374 
(define_insn "*movdd_softfloat64"
375 
  [(set (match_operand:DD 0 "nonimmediate_operand" "=r,Y,r,cl,r,r,r,r,*h")
376 
        (match_operand:DD 1 "input_operand" "Y,r,r,r,h,G,H,F,0"))]
377 
  "TARGET_POWERPC64 && (TARGET_SOFT_FLOAT || !TARGET_FPRS)
378 
   && (gpc_reg_operand (operands[0], DDmode)
379 
       || gpc_reg_operand (operands[1], DDmode))"
380 
  "@
381 
   ld%U1%X1 %0,%1
382 
   std%U0%X0 %1,%0
383 
   mr %0,%1
384 
   mt%0 %1
385 
   mf%1 %0
386 
   #
387 
   #
388 
   #
389 
   {cror 0,0,0|nop}"
390 
  [(set_attr "type" "load,store,*,mtjmpr,mfjmpr,*,*,*,*")
391 
   (set_attr "length" "4,4,4,4,4,8,12,16,4")])
392 
 
393 
(define_expand "negtd2"
394 
  [(set (match_operand:TD 0 "gpc_reg_operand" "")
395 
        (neg:TD (match_operand:TD 1 "gpc_reg_operand" "")))]
396 
  "TARGET_HARD_FLOAT && TARGET_FPRS"
397 
  "")
398 
 
399 
(define_insn "*negtd2_fpr"
400 
  [(set (match_operand:TD 0 "gpc_reg_operand" "=d")
401 
        (neg:TD (match_operand:TD 1 "gpc_reg_operand" "d")))]
402 
  "TARGET_HARD_FLOAT && TARGET_FPRS"
403 
  "fneg %0,%1"
404 
  [(set_attr "type" "fp")])
405 
 
406 
(define_expand "abstd2"
407 
  [(set (match_operand:TD 0 "gpc_reg_operand" "")
408 
        (abs:TD (match_operand:TD 1 "gpc_reg_operand" "")))]
409 
  "TARGET_HARD_FLOAT && TARGET_FPRS"
410 
  "")
411 
 
412 
(define_insn "*abstd2_fpr"
413 
  [(set (match_operand:TD 0 "gpc_reg_operand" "=d")
414 
        (abs:TD (match_operand:TD 1 "gpc_reg_operand" "d")))]
415 
  "TARGET_HARD_FLOAT && TARGET_FPRS"
416 
  "fabs %0,%1"
417 
  [(set_attr "type" "fp")])
418 
 
419 
(define_insn "*nabstd2_fpr"
420 
  [(set (match_operand:TD 0 "gpc_reg_operand" "=d")
421 
        (neg:TD (abs:TD (match_operand:TD 1 "gpc_reg_operand" "d"))))]
422 
  "TARGET_HARD_FLOAT && TARGET_FPRS"
423 
  "fnabs %0,%1"
424 
  [(set_attr "type" "fp")])
425 
 
426 
(define_expand "movtd"
427 
  [(set (match_operand:TD 0 "general_operand" "")
428 
        (match_operand:TD 1 "any_operand" ""))]
429 
  "TARGET_HARD_FLOAT && TARGET_FPRS"
430 
  "{ rs6000_emit_move (operands[0], operands[1], TDmode); DONE; }")
431 
 
432 
; It's important to list the o->f and f->o moves before f->f because
433 
; otherwise reload, given m->f, will try to pick f->f and reload it,
434 
; which doesn't make progress.  Likewise r->Y must be before r->r.
435 
(define_insn_and_split "*movtd_internal"
436 
  [(set (match_operand:TD 0 "nonimmediate_operand" "=o,d,d,r,Y,r")
437 
        (match_operand:TD 1 "input_operand"         "d,o,d,YGHF,r,r"))]
438 
  "TARGET_HARD_FLOAT && TARGET_FPRS
439 
   && (gpc_reg_operand (operands[0], TDmode)
440 
       || gpc_reg_operand (operands[1], TDmode))"
441 
  "#"
442 
  "&& reload_completed"
443 
  [(pc)]
444 
{ rs6000_split_multireg_move (operands[0], operands[1]); DONE; }
445 
  [(set_attr "length" "8,8,8,20,20,16")])
446 
 
447 
;; Hardware support for decimal floating point operations.
448 
 
449 
(define_insn "extendddtd2"
450 
  [(set (match_operand:TD 0 "gpc_reg_operand" "=d")
451 
        (float_extend:TD (match_operand:DD 1 "gpc_reg_operand" "d")))]
452 
  "TARGET_DFP"
453 
  "dctqpq %0,%1"
454 
  [(set_attr "type" "fp")])
455 
 
456 
;; The result of drdpq is an even/odd register pair with the converted
457 
;; value in the even register and zero in the odd register.
458 
;; FIXME: Avoid the register move by using a reload constraint to ensure
459 
;; that the result is the first of the pair receiving the result of drdpq.
460 
 
461 
(define_insn "trunctddd2"
462 
  [(set (match_operand:DD 0 "gpc_reg_operand" "=d")
463 
        (float_truncate:DD (match_operand:TD 1 "gpc_reg_operand" "d")))
464 
   (clobber (match_scratch:TD 2 "=d"))]
465 
  "TARGET_DFP"
466 
  "drdpq %2,%1\;fmr %0,%2"
467 
  [(set_attr "type" "fp")])
468 
 
469 
(define_insn "adddd3"
470 
  [(set (match_operand:DD 0 "gpc_reg_operand" "=d")
471 
        (plus:DD (match_operand:DD 1 "gpc_reg_operand" "%d")
472 
                 (match_operand:DD 2 "gpc_reg_operand" "d")))]
473 
  "TARGET_DFP"
474 
  "dadd %0,%1,%2"
475 
  [(set_attr "type" "fp")])
476 
 
477 
(define_insn "addtd3"
478 
  [(set (match_operand:TD 0 "gpc_reg_operand" "=d")
479 
        (plus:TD (match_operand:TD 1 "gpc_reg_operand" "%d")
480 
                 (match_operand:TD 2 "gpc_reg_operand" "d")))]
481 
  "TARGET_DFP"
482 
  "daddq %0,%1,%2"
483 
  [(set_attr "type" "fp")])
484 
 
485 
(define_insn "subdd3"
486 
  [(set (match_operand:DD 0 "gpc_reg_operand" "=d")
487 
        (minus:DD (match_operand:DD 1 "gpc_reg_operand" "d")
488 
                  (match_operand:DD 2 "gpc_reg_operand" "d")))]
489 
  "TARGET_DFP"
490 
  "dsub %0,%1,%2"
491 
  [(set_attr "type" "fp")])
492 
 
493 
(define_insn "subtd3"
494 
  [(set (match_operand:TD 0 "gpc_reg_operand" "=d")
495 
        (minus:TD (match_operand:TD 1 "gpc_reg_operand" "d")
496 
                  (match_operand:TD 2 "gpc_reg_operand" "d")))]
497 
  "TARGET_DFP"
498 
  "dsubq %0,%1,%2"
499 
  [(set_attr "type" "fp")])
500 
 
501 
(define_insn "muldd3"
502 
  [(set (match_operand:DD 0 "gpc_reg_operand" "=d")
503 
        (mult:DD (match_operand:DD 1 "gpc_reg_operand" "%d")
504 
                 (match_operand:DD 2 "gpc_reg_operand" "d")))]
505 
  "TARGET_DFP"
506 
  "dmul %0,%1,%2"
507 
  [(set_attr "type" "fp")])
508 
 
509 
(define_insn "multd3"
510 
  [(set (match_operand:TD 0 "gpc_reg_operand" "=d")
511 
        (mult:TD (match_operand:TD 1 "gpc_reg_operand" "%d")
512 
                 (match_operand:TD 2 "gpc_reg_operand" "d")))]
513 
  "TARGET_DFP"
514 
  "dmulq %0,%1,%2"
515 
  [(set_attr "type" "fp")])
516 
 
517 
(define_insn "divdd3"
518 
  [(set (match_operand:DD 0 "gpc_reg_operand" "=d")
519 
        (div:DD (match_operand:DD 1 "gpc_reg_operand" "d")
520 
                (match_operand:DD 2 "gpc_reg_operand" "d")))]
521 
  "TARGET_DFP"
522 
  "ddiv %0,%1,%2"
523 
  [(set_attr "type" "fp")])
524 
 
525 
(define_insn "divtd3"
526 
  [(set (match_operand:TD 0 "gpc_reg_operand" "=d")
527 
        (div:TD (match_operand:TD 1 "gpc_reg_operand" "d")
528 
                (match_operand:TD 2 "gpc_reg_operand" "d")))]
529 
  "TARGET_DFP"
530 
  "ddivq %0,%1,%2"
531 
  [(set_attr "type" "fp")])
532 
 
533 
(define_insn "*cmpdd_internal1"
534 
  [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
535 
        (compare:CCFP (match_operand:DD 1 "gpc_reg_operand" "d")
536 
                      (match_operand:DD 2 "gpc_reg_operand" "d")))]
537 
  "TARGET_DFP"
538 
  "dcmpu %0,%1,%2"
539 
  [(set_attr "type" "fpcompare")])
540 
 
541 
(define_insn "*cmptd_internal1"
542 
  [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
543 
        (compare:CCFP (match_operand:TD 1 "gpc_reg_operand" "d")
544 
                      (match_operand:TD 2 "gpc_reg_operand" "d")))]
545 
  "TARGET_DFP"
546 
  "dcmpuq %0,%1,%2"
547 
  [(set_attr "type" "fpcompare")])
548 
 
549 
(define_insn "floatditd2"
550 
  [(set (match_operand:TD 0 "gpc_reg_operand" "=d")
551 
        (float:TD (match_operand:DI 1 "gpc_reg_operand" "d")))]
552 
  "TARGET_DFP"
553 
  "dcffixq %0,%1"
554 
  [(set_attr "type" "fp")])
555 
 
556 
;; Convert a decimal64 to a decimal64 whose value is an integer.
557 
;; This is the first stage of converting it to an integer type.
558 
 
559 
(define_insn "ftruncdd2"
560 
  [(set (match_operand:DD 0 "gpc_reg_operand" "=d")
561 
        (fix:DD (match_operand:DD 1 "gpc_reg_operand" "d")))]
562 
  "TARGET_DFP"
563 
  "drintn. 0,%0,%1,1"
564 
  [(set_attr "type" "fp")])
565 
 
566 
;; Convert a decimal64 whose value is an integer to an actual integer.
567 
;; This is the second stage of converting decimal float to integer type.
568 
 
569 
(define_insn "fixdddi2"
570 
  [(set (match_operand:DI 0 "gpc_reg_operand" "=d")
571 
        (fix:DI (match_operand:DD 1 "gpc_reg_operand" "d")))]
572 
  "TARGET_DFP"
573 
  "dctfix %0,%1"
574 
  [(set_attr "type" "fp")])
575 
 
576 
;; Convert a decimal128 to a decimal128 whose value is an integer.
577 
;; This is the first stage of converting it to an integer type.
578 
 
579 
(define_insn "ftrunctd2"
580 
  [(set (match_operand:TD 0 "gpc_reg_operand" "=d")
581 
        (fix:TD (match_operand:TD 1 "gpc_reg_operand" "d")))]
582 
  "TARGET_DFP"
583 
  "drintnq. 0,%0,%1,1"
584 
  [(set_attr "type" "fp")])
585 
 
586 
;; Convert a decimal128 whose value is an integer to an actual integer.
587 
;; This is the second stage of converting decimal float to integer type.
588 
 
589 
(define_insn "fixtddi2"
590 
  [(set (match_operand:DI 0 "gpc_reg_operand" "=d")
591 
        (fix:DI (match_operand:TD 1 "gpc_reg_operand" "d")))]
592 
  "TARGET_DFP"
593 
  "dctfixq %0,%1"
594 
  [(set_attr "type" "fp")])

powered by: WebSVN 2.1.0

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