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/] [rs6000/] [dfp.md] - Blame information for rev 282

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.