OSDN Git Service

0bc405a3f54e275ecd286a1e44bfde1c173c38ed
[pf3gnuchains/gcc-fork.git] / gcc / config / rs6000 / dfp.md
1 ;; Decimal Floating Point (DFP) patterns.
2 ;; Copyright (C) 2007
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 ;; <http://www.gnu.org/licenses/>.
22
23 (define_expand "negdd2"
24   [(set (match_operand:DD 0 "gpc_reg_operand" "")
25         (neg:DD (match_operand:DD 1 "gpc_reg_operand" "")))]
26   "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)"
27   "")
28
29 (define_insn "*negdd2_fpr"
30   [(set (match_operand:DD 0 "gpc_reg_operand" "=f")
31         (neg:DD (match_operand:DD 1 "gpc_reg_operand" "f")))]
32   "TARGET_HARD_FLOAT && TARGET_FPRS"
33   "fneg %0,%1"
34   [(set_attr "type" "fp")])
35
36 (define_expand "absdd2"
37   [(set (match_operand:DD 0 "gpc_reg_operand" "")
38         (abs:DD (match_operand:DD 1 "gpc_reg_operand" "")))]
39   "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)"
40   "")
41
42 (define_insn "*absdd2_fpr"
43   [(set (match_operand:DD 0 "gpc_reg_operand" "=f")
44         (abs:DD (match_operand:DD 1 "gpc_reg_operand" "f")))]
45   "TARGET_HARD_FLOAT && TARGET_FPRS"
46   "fabs %0,%1"
47   [(set_attr "type" "fp")])
48
49 (define_insn "*nabsdd2_fpr"
50   [(set (match_operand:DD 0 "gpc_reg_operand" "=f")
51         (neg:DD (abs:DD (match_operand:DF 1 "gpc_reg_operand" "f"))))]
52   "TARGET_HARD_FLOAT && TARGET_FPRS"
53   "fnabs %0,%1"
54   [(set_attr "type" "fp")])
55
56 (define_expand "movdd"
57   [(set (match_operand:DD 0 "nonimmediate_operand" "")
58         (match_operand:DD 1 "any_operand" ""))]
59   ""
60   "{ rs6000_emit_move (operands[0], operands[1], DDmode); DONE; }")
61
62 (define_split
63   [(set (match_operand:DD 0 "gpc_reg_operand" "")
64         (match_operand:DD 1 "const_int_operand" ""))]
65   "! TARGET_POWERPC64 && reload_completed
66    && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
67        || (GET_CODE (operands[0]) == SUBREG
68            && GET_CODE (SUBREG_REG (operands[0])) == REG
69            && REGNO (SUBREG_REG (operands[0])) <= 31))"
70   [(set (match_dup 2) (match_dup 4))
71    (set (match_dup 3) (match_dup 1))]
72   "
73 {
74   int endian = (WORDS_BIG_ENDIAN == 0);
75   HOST_WIDE_INT value = INTVAL (operands[1]);
76
77   operands[2] = operand_subword (operands[0], endian, 0, DDmode);
78   operands[3] = operand_subword (operands[0], 1 - endian, 0, DDmode);
79 #if HOST_BITS_PER_WIDE_INT == 32
80   operands[4] = (value & 0x80000000) ? constm1_rtx : const0_rtx;
81 #else
82   operands[4] = GEN_INT (value >> 32);
83   operands[1] = GEN_INT (((value & 0xffffffff) ^ 0x80000000) - 0x80000000);
84 #endif
85 }")
86
87 (define_split
88   [(set (match_operand:DD 0 "gpc_reg_operand" "")
89         (match_operand:DD 1 "const_double_operand" ""))]
90   "! TARGET_POWERPC64 && reload_completed
91    && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
92        || (GET_CODE (operands[0]) == SUBREG
93            && GET_CODE (SUBREG_REG (operands[0])) == REG
94            && REGNO (SUBREG_REG (operands[0])) <= 31))"
95   [(set (match_dup 2) (match_dup 4))
96    (set (match_dup 3) (match_dup 5))]
97   "
98 {
99   int endian = (WORDS_BIG_ENDIAN == 0);
100   long l[2];
101   REAL_VALUE_TYPE rv;
102
103   REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
104   REAL_VALUE_TO_TARGET_DECIMAL64 (rv, l);
105
106   operands[2] = operand_subword (operands[0], endian, 0, DDmode);
107   operands[3] = operand_subword (operands[0], 1 - endian, 0, DDmode);
108   operands[4] = gen_int_mode (l[endian], SImode);
109   operands[5] = gen_int_mode (l[1 - endian], SImode);
110 }")
111
112 (define_split
113   [(set (match_operand:DD 0 "gpc_reg_operand" "")
114         (match_operand:DD 1 "const_double_operand" ""))]
115   "TARGET_POWERPC64 && reload_completed
116    && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
117        || (GET_CODE (operands[0]) == SUBREG
118            && GET_CODE (SUBREG_REG (operands[0])) == REG
119            && REGNO (SUBREG_REG (operands[0])) <= 31))"
120   [(set (match_dup 2) (match_dup 3))]
121   "
122 {
123   int endian = (WORDS_BIG_ENDIAN == 0);
124   long l[2];
125   REAL_VALUE_TYPE rv;
126 #if HOST_BITS_PER_WIDE_INT >= 64
127   HOST_WIDE_INT val;
128 #endif
129
130   REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
131   REAL_VALUE_TO_TARGET_DECIMAL64 (rv, l);
132
133   operands[2] = gen_lowpart (DImode, operands[0]);
134   /* HIGHPART is lower memory address when WORDS_BIG_ENDIAN.  */
135 #if HOST_BITS_PER_WIDE_INT >= 64
136   val = ((HOST_WIDE_INT)(unsigned long)l[endian] << 32
137          | ((HOST_WIDE_INT)(unsigned long)l[1 - endian]));
138
139   operands[3] = gen_int_mode (val, DImode);
140 #else
141   operands[3] = immed_double_const (l[1 - endian], l[endian], DImode);
142 #endif
143 }")
144
145 ;; Don't have reload use general registers to load a constant.  First,
146 ;; it might not work if the output operand is the equivalent of
147 ;; a non-offsettable memref, but also it is less efficient than loading
148 ;; the constant into an FP register, since it will probably be used there.
149 ;; The "??" is a kludge until we can figure out a more reasonable way
150 ;; of handling these non-offsettable values.
151 (define_insn "*movdd_hardfloat32"
152   [(set (match_operand:DD 0 "nonimmediate_operand" "=!r,??r,m,f,f,m,!r,!r,!r")
153         (match_operand:DD 1 "input_operand" "r,m,r,f,m,f,G,H,F"))]
154   "! TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS
155    && (gpc_reg_operand (operands[0], DDmode)
156        || gpc_reg_operand (operands[1], DDmode))"
157   "*
158 {
159   switch (which_alternative)
160     {
161     default:
162       gcc_unreachable ();
163     case 0:
164       /* We normally copy the low-numbered register first.  However, if
165          the first register operand 0 is the same as the second register
166          of operand 1, we must copy in the opposite order.  */
167       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
168         return \"mr %L0,%L1\;mr %0,%1\";
169       else
170         return \"mr %0,%1\;mr %L0,%L1\";
171     case 1:
172       if (rs6000_offsettable_memref_p (operands[1])
173           || (GET_CODE (operands[1]) == MEM
174               && (GET_CODE (XEXP (operands[1], 0)) == LO_SUM
175                   || GET_CODE (XEXP (operands[1], 0)) == PRE_INC
176                   || GET_CODE (XEXP (operands[1], 0)) == PRE_DEC)))
177         {
178           /* If the low-address word is used in the address, we must load
179              it last.  Otherwise, load it first.  Note that we cannot have
180              auto-increment in that case since the address register is
181              known to be dead.  */
182           if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
183                                  operands[1], 0))
184             return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
185           else
186             return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\";
187         }
188       else
189         {
190           rtx addreg;
191
192           addreg = find_addr_reg (XEXP (operands[1], 0));
193           if (refers_to_regno_p (REGNO (operands[0]),
194                                  REGNO (operands[0]) + 1,
195                                  operands[1], 0))
196             {
197               output_asm_insn (\"{cal|la} %0,4(%0)\", &addreg);
198               output_asm_insn (\"{lx|lwzx} %L0,%1\", operands);
199               output_asm_insn (\"{cal|la} %0,-4(%0)\", &addreg);
200               return \"{lx|lwzx} %0,%1\";
201             }
202           else
203             {
204               output_asm_insn (\"{lx|lwzx} %0,%1\", operands);
205               output_asm_insn (\"{cal|la} %0,4(%0)\", &addreg);
206               output_asm_insn (\"{lx|lwzx} %L0,%1\", operands);
207               output_asm_insn (\"{cal|la} %0,-4(%0)\", &addreg);
208               return \"\";
209             }
210         }
211     case 2:
212       if (rs6000_offsettable_memref_p (operands[0])
213           || (GET_CODE (operands[0]) == MEM
214               && (GET_CODE (XEXP (operands[0], 0)) == LO_SUM
215                   || GET_CODE (XEXP (operands[0], 0)) == PRE_INC
216                   || GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)))
217         return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\";
218       else
219         {
220           rtx addreg;
221
222           addreg = find_addr_reg (XEXP (operands[0], 0));
223           output_asm_insn (\"{stx|stwx} %1,%0\", operands);
224           output_asm_insn (\"{cal|la} %0,4(%0)\", &addreg);
225           output_asm_insn (\"{stx|stwx} %L1,%0\", operands);
226           output_asm_insn (\"{cal|la} %0,-4(%0)\", &addreg);
227           return \"\";
228         }
229     case 3:
230       return \"fmr %0,%1\";
231     case 4:
232       return \"lfd%U1%X1 %0,%1\";
233     case 5:
234       return \"stfd%U0%X0 %1,%0\";
235     case 6:
236     case 7:
237     case 8:
238       return \"#\";
239     }
240 }"
241   [(set_attr "type" "two,load,store,fp,fpload,fpstore,*,*,*")
242    (set_attr "length" "8,16,16,4,4,4,8,12,16")])
243
244 (define_insn "*movdd_softfloat32"
245   [(set (match_operand:DD 0 "nonimmediate_operand" "=r,r,m,r,r,r")
246         (match_operand:DD 1 "input_operand" "r,m,r,G,H,F"))]
247   "! TARGET_POWERPC64 && TARGET_SOFT_FLOAT
248    && (gpc_reg_operand (operands[0], DDmode)
249        || gpc_reg_operand (operands[1], DDmode))"
250   "*
251 {
252   switch (which_alternative)
253     {
254     default:
255       gcc_unreachable ();
256     case 0:
257       /* We normally copy the low-numbered register first.  However, if
258          the first register operand 0 is the same as the second register of
259          operand 1, we must copy in the opposite order.  */
260       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
261         return \"mr %L0,%L1\;mr %0,%1\";
262       else
263         return \"mr %0,%1\;mr %L0,%L1\";
264     case 1:
265       /* If the low-address word is used in the address, we must load
266          it last.  Otherwise, load it first.  Note that we cannot have
267          auto-increment in that case since the address register is
268          known to be dead.  */
269       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
270                              operands[1], 0))
271         return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
272       else
273         return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\";
274     case 2:
275       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\";
276     case 3:
277     case 4:
278     case 5:
279       return \"#\";
280     }
281 }"
282   [(set_attr "type" "two,load,store,*,*,*")
283    (set_attr "length" "8,8,8,8,12,16")])
284
285 ; ld/std require word-aligned displacements -> 'Y' constraint.
286 ; List Y->r and r->Y before r->r for reload.
287 (define_insn "*movdd_hardfloat64_mfpgpr"
288   [(set (match_operand:DD 0 "nonimmediate_operand" "=Y,r,!r,f,f,m,*c*l,!r,*h,!r,!r,!r,r,f")
289         (match_operand:DD 1 "input_operand" "r,Y,r,f,m,f,r,h,0,G,H,F,f,r"))]
290   "TARGET_POWERPC64 && TARGET_MFPGPR && TARGET_HARD_FLOAT && TARGET_FPRS
291    && (gpc_reg_operand (operands[0], DDmode)
292        || gpc_reg_operand (operands[1], DDmode))"
293   "@
294    std%U0%X0 %1,%0
295    ld%U1%X1 %0,%1
296    mr %0,%1
297    fmr %0,%1
298    lfd%U1%X1 %0,%1
299    stfd%U0%X0 %1,%0
300    mt%0 %1
301    mf%1 %0
302    {cror 0,0,0|nop}
303    #
304    #
305    #
306    mftgpr %0,%1
307    mffgpr %0,%1"
308   [(set_attr "type" "store,load,*,fp,fpload,fpstore,mtjmpr,mfjmpr,*,*,*,*,mftgpr,mffgpr")
309    (set_attr "length" "4,4,4,4,4,4,4,4,4,8,12,16,4,4")])
310
311 ; ld/std require word-aligned displacements -> 'Y' constraint.
312 ; List Y->r and r->Y before r->r for reload.(define_insn "*movdd_hardfloat64"
313 (define_insn "*movdd_hardfloat64"
314   [(set (match_operand:DD 0 "nonimmediate_operand" "=Y,r,!r,f,f,m,*c*l,!r,*h,!r,!r,!r")
315         (match_operand:DD 1 "input_operand" "r,Y,r,f,m,f,r,h,0,G,H,F"))]
316   "TARGET_POWERPC64 && !TARGET_MFPGPR && TARGET_HARD_FLOAT && TARGET_FPRS
317    && (gpc_reg_operand (operands[0], DDmode)
318        || gpc_reg_operand (operands[1], DDmode))"
319   "@
320    std%U0%X0 %1,%0
321    ld%U1%X1 %0,%1
322    mr %0,%1
323    fmr %0,%1
324    lfd%U1%X1 %0,%1
325    stfd%U0%X0 %1,%0
326    mt%0 %1
327    mf%1 %0
328    {cror 0,0,0|nop}
329    #
330    #
331    #"
332   [(set_attr "type" "store,load,*,fp,fpload,fpstore,mtjmpr,mfjmpr,*,*,*,*")
333    (set_attr "length" "4,4,4,4,4,4,4,4,4,8,12,16")])
334
335 (define_insn "*movdd_softfloat64"
336   [(set (match_operand:DD 0 "nonimmediate_operand" "=r,Y,r,cl,r,r,r,r,*h")
337         (match_operand:DD 1 "input_operand" "Y,r,r,r,h,G,H,F,0"))]
338   "TARGET_POWERPC64 && (TARGET_SOFT_FLOAT || !TARGET_FPRS)
339    && (gpc_reg_operand (operands[0], DDmode)
340        || gpc_reg_operand (operands[1], DDmode))"
341   "@
342    ld%U1%X1 %0,%1
343    std%U0%X0 %1,%0
344    mr %0,%1
345    mt%0 %1
346    mf%1 %0
347    #
348    #
349    #
350    {cror 0,0,0|nop}"
351   [(set_attr "type" "load,store,*,mtjmpr,mfjmpr,*,*,*,*")
352    (set_attr "length" "4,4,4,4,4,8,12,16,4")])
353
354 (define_expand "negtd2"
355   [(set (match_operand:TD 0 "gpc_reg_operand" "")
356         (neg:TD (match_operand:TD 1 "gpc_reg_operand" "")))]
357   "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)"
358   "")
359
360 (define_insn "*negtd2_fpr"
361   [(set (match_operand:TD 0 "gpc_reg_operand" "=f")
362         (neg:TD (match_operand:TD 1 "gpc_reg_operand" "f")))]
363   "TARGET_HARD_FLOAT && TARGET_FPRS"
364   "fneg %0,%1"
365   [(set_attr "type" "fp")])
366
367 (define_expand "abstd2"
368   [(set (match_operand:TD 0 "gpc_reg_operand" "")
369         (abs:TD (match_operand:TD 1 "gpc_reg_operand" "")))]
370   "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)"
371   "")
372
373 (define_insn "*abstd2_fpr"
374   [(set (match_operand:TD 0 "gpc_reg_operand" "=f")
375         (abs:TD (match_operand:TD 1 "gpc_reg_operand" "f")))]
376   "TARGET_HARD_FLOAT && TARGET_FPRS"
377   "fabs %0,%1"
378   [(set_attr "type" "fp")])
379
380 (define_insn "*nabstd2_fpr"
381   [(set (match_operand:TD 0 "gpc_reg_operand" "=f")
382         (neg:TD (abs:TD (match_operand:DF 1 "gpc_reg_operand" "f"))))]
383   "TARGET_HARD_FLOAT && TARGET_FPRS"
384   "fnabs %0,%1"
385   [(set_attr "type" "fp")])
386
387 (define_expand "movtd"
388   [(set (match_operand:TD 0 "general_operand" "")
389         (match_operand:TD 1 "any_operand" ""))]
390   "TARGET_HARD_FLOAT && TARGET_FPRS"
391   "{ rs6000_emit_move (operands[0], operands[1], TDmode); DONE; }")
392
393 ; It's important to list the o->f and f->o moves before f->f because
394 ; otherwise reload, given m->f, will try to pick f->f and reload it,
395 ; which doesn't make progress.  Likewise r->Y must be before r->r.
396 (define_insn_and_split "*movtd_internal"
397   [(set (match_operand:TD 0 "nonimmediate_operand" "=o,f,f,r,Y,r")
398         (match_operand:TD 1 "input_operand"         "f,o,f,YGHF,r,r"))]
399   "TARGET_HARD_FLOAT && TARGET_FPRS
400    && (gpc_reg_operand (operands[0], TDmode)
401        || gpc_reg_operand (operands[1], TDmode))"
402   "#"
403   "&& reload_completed"
404   [(pc)]
405 { rs6000_split_multireg_move (operands[0], operands[1]); DONE; }
406   [(set_attr "length" "8,8,8,20,20,16")])
407