OSDN Git Service

* gengtype.c (main): Handle double_int type.
[pf3gnuchains/gcc-fork.git] / gcc / double-int.c
1 /* Operations with long integers.
2    Copyright (C) 2006 Free Software Foundation, Inc.
3    
4 This file is part of GCC.
5    
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
9 later version.
10    
11 GCC is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 for more details.
15    
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING.  If not, write to the Free
18 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
19 02110-1301, USA.  */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "tree.h"
26
27 /* Returns mask for PREC bits.  */
28
29 static inline double_int
30 double_int_mask (unsigned prec)
31 {
32   unsigned HOST_WIDE_INT m;
33   double_int mask;
34
35   if (prec > HOST_BITS_PER_WIDE_INT)
36     {
37       prec -= HOST_BITS_PER_WIDE_INT;
38       m = ((unsigned HOST_WIDE_INT) 2 << (prec - 1)) - 1;
39       mask.high = (HOST_WIDE_INT) m;
40       mask.low = ALL_ONES;
41     }
42   else
43     {
44       mask.high = 0;
45       mask.low = ((unsigned HOST_WIDE_INT) 2 << (prec - 1)) - 1;
46     }
47
48   return mask;
49 }
50
51 /* Clears the bits of CST over the precision PREC.  If UNS is false, the bits
52    outside of the precision are set to the sign bit (i.e., the PREC-th one),
53    otherwise they are set to zero.
54  
55    This corresponds to returning the value represented by PREC lowermost bits
56    of CST, with the given signedness.  */
57
58 double_int
59 double_int_ext (double_int cst, unsigned prec, bool uns)
60 {
61   if (uns)
62     return double_int_zext (cst, prec);
63   else
64     return double_int_sext (cst, prec);
65 }
66
67 /* The same as double_int_ext with UNS = true.  */
68
69 double_int
70 double_int_zext (double_int cst, unsigned prec)
71 {
72   double_int mask = double_int_mask (prec);
73   double_int r;
74
75   r.low = cst.low & ~mask.low;
76   r.high = cst.high & ~mask.high;
77
78   return r;
79 }
80
81 /* The same as double_int_ext with UNS = false.  */
82
83 double_int
84 double_int_sext (double_int cst, unsigned prec)
85 {
86   double_int mask = double_int_mask (prec);
87   double_int r;
88   unsigned HOST_WIDE_INT snum;
89
90   if (prec <= HOST_BITS_PER_WIDE_INT)
91     snum = cst.low;
92   else
93     {
94       prec -= HOST_BITS_PER_WIDE_INT;
95       snum = (unsigned HOST_WIDE_INT) cst.high;
96     }
97   if (((snum >> (prec - 1)) & 1) == 1)
98     {
99       r.low = cst.low | mask.low;
100       r.high = cst.high | mask.high;
101     }
102   else
103     {
104       r.low = cst.low & ~mask.low;
105       r.high = cst.high & ~mask.high;
106     } 
107
108   return r;
109 }
110
111 /* Constructs long integer from tree CST.  The extra bits over the precision of
112    the number are filled with sign bit if CST is signed, and with zeros if it
113    is unsigned.  */
114
115 double_int
116 tree_to_double_int (tree cst)
117 {
118   /* We do not need to call double_int_restrict here to ensure the semantics as
119      described, as this is the default one for trees.  */
120   return TREE_INT_CST (cst);
121 }
122
123 /* Returns true if CST fits in unsigned HOST_WIDE_INT.  */
124
125 bool
126 double_int_fits_in_uhwi_p (double_int cst)
127 {
128   return cst.high == 0;
129 }
130
131 /* Returns true if CST fits in signed HOST_WIDE_INT.  */
132
133 bool
134 double_int_fits_in_shwi_p (double_int cst)
135 {
136   if (cst.high == 0)
137     return (HOST_WIDE_INT) cst.low >= 0;
138   else if (cst.high == -1)
139     return (HOST_WIDE_INT) cst.low < 0;
140   else
141     return false;
142 }
143
144 /* Returns true if CST fits in HOST_WIDE_INT if UNS is false, or in
145    unsigned HOST_WIDE_INT if UNS is true.  */
146
147 bool
148 double_int_fits_in_hwi_p (double_int cst, bool uns)
149 {
150   if (uns)
151     return double_int_fits_in_uhwi_p (cst);
152   else
153     return double_int_fits_in_shwi_p (cst);
154 }
155
156 /* Returns value of CST as a signed number.  CST must satisfy
157    double_int_fits_in_shwi_p.  */
158
159 HOST_WIDE_INT
160 double_int_to_shwi (double_int cst)
161 {
162   return (HOST_WIDE_INT) cst.low;
163 }
164
165 /* Returns value of CST as an unsigned number.  CST must satisfy
166    double_int_fits_in_uhwi_p.  */
167
168 unsigned HOST_WIDE_INT
169 double_int_to_uhwi (double_int cst)
170 {
171   return cst.low;
172 }
173
174 /* Returns A * B.  */
175
176 double_int
177 double_int_mul (double_int a, double_int b)
178 {
179   double_int ret;
180   mul_double (a.low, a.high, b.low, b.high, &ret.low, &ret.high);
181   return ret;
182 }
183
184 /* Returns A + B.  */
185
186 double_int
187 double_int_add (double_int a, double_int b)
188 {
189   double_int ret;
190   add_double (a.low, a.high, b.low, b.high, &ret.low, &ret.high);
191   return ret;
192 }
193
194 /* Returns -A.  */
195
196 double_int
197 double_int_neg (double_int a)
198 {
199   double_int ret;
200   neg_double (a.low, a.high, &ret.low, &ret.high);
201   return ret;
202 }
203
204 /* Returns A / B (computed as unsigned depending on UNS, and rounded as
205    specified by CODE).  CODE is enum tree_code in fact, but double_int.h
206    must be included before tree.h.  */
207
208 double_int
209 double_int_div (double_int a, double_int b, bool uns, unsigned code)
210 {
211   unsigned HOST_WIDE_INT rem_lo;
212   HOST_WIDE_INT rem_hi;
213   double_int ret;
214
215   div_and_round_double (code, uns, a.low, a.high, b.low, b.high,
216                         &ret.low, &ret.high, &rem_lo, &rem_hi);
217   return ret;
218 }
219
220 /* The same as double_int_div with UNS = false.  */
221
222 double_int
223 double_int_sdiv (double_int a, double_int b, unsigned code)
224 {
225   return double_int_div (a, b, false, code);
226 }
227
228 /* The same as double_int_div with UNS = true.  */
229
230 double_int
231 double_int_udiv (double_int a, double_int b, unsigned code)
232 {
233   return double_int_div (a, b, true, code);
234 }
235
236 /* Constructs tree in type TYPE from with value given by CST.  */
237
238 tree
239 double_int_to_tree (tree type, double_int cst)
240 {
241   cst = double_int_ext (cst, TYPE_PRECISION (type), TYPE_UNSIGNED (type));
242
243   return build_int_cst_wide (type, cst.low, cst.high);
244 }
245
246 /* Returns true if CST is negative.  Of course, CST is considered to
247    be signed.  */
248
249 bool
250 double_int_negative_p (double_int cst)
251 {
252   return cst.high < 0;
253 }
254
255 /* Returns -1 if A < B, 0 if A == B and 1 if A > B.  Signedness of the
256    comparison is given by UNS.  */
257
258 int
259 double_int_cmp (double_int a, double_int b, bool uns)
260 {
261   if (uns)
262     return double_int_ucmp (a, b);
263   else
264     return double_int_scmp (a, b);
265 }
266
267 /* Compares two unsigned values A and B.  Returns -1 if A < B, 0 if A == B,
268    and 1 if A > B.  */
269
270 int
271 double_int_ucmp (double_int a, double_int b)
272 {
273   if ((unsigned HOST_WIDE_INT) a.high < (unsigned HOST_WIDE_INT) b.high)
274     return -1;
275   if ((unsigned HOST_WIDE_INT) a.high > (unsigned HOST_WIDE_INT) b.high)
276     return 1;
277   if (a.low < b.low)
278     return -1;
279   if (a.low > b.low)
280     return 1;
281
282   return 0;
283 }
284
285 /* Compares two signed values A and B.  Returns -1 if A < B, 0 if A == B,
286    and 1 if A > B.  */
287
288 int
289 double_int_scmp (double_int a, double_int b)
290 {
291   if (a.high < b.high)
292     return -1;
293   if (a.high > b.high)
294     return 1;
295   if ((HOST_WIDE_INT) a.low < (HOST_WIDE_INT) b.low)
296     return -1;
297   if ((HOST_WIDE_INT) a.low > (HOST_WIDE_INT) b.low)
298     return 1;
299
300   return 0;
301 }
302
303 /* Splits last digit of *CST (taken as unsigned) in BASE and returns it.  */
304
305 static unsigned
306 double_int_split_digit (double_int *cst, unsigned base)
307 {
308   unsigned HOST_WIDE_INT resl, reml;
309   HOST_WIDE_INT resh, remh;
310
311   div_and_round_double (FLOOR_DIV_EXPR, true, cst->low, cst->high, base, 0,
312                         &resl, &resh, &reml, &remh);
313   cst->high = resh;
314   cst->low = resl;
315
316   return reml;
317 }
318
319 /* Dumps CST to FILE.  If UNS is true, CST is considered to be unsigned,
320    otherwise it is signed.  */
321
322 void
323 dump_double_int (FILE *file, double_int cst, bool uns)
324 {
325   unsigned digits[100], n;
326   int i;
327
328   if (double_int_zero_p (cst))
329     {
330       fprintf (file, "0");
331       return;
332     }
333
334   if (!uns && double_int_negative_p (cst))
335     {
336       fprintf (file, "-");
337       cst = double_int_neg (cst);
338     }
339
340   for (n = 0; !double_int_zero_p (cst); n++)
341     digits[n] = double_int_split_digit (&cst, 10);
342   for (i = n - 1; i >= 0; i--)
343     fprintf (file, "%u", digits[i]);
344 }