Mercurial > hg > CbC > CbC_gcc
annotate gcc/fixed-value.c @ 55:77e2b8dfacca gcc-4.4.5
update it from 4.4.3 to 4.5.0
author | ryoma <e075725@ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 12 Feb 2010 23:39:51 +0900 |
parents | a06113de4d67 |
children | b7f97abdc517 |
rev | line source |
---|---|
0 | 1 /* Fixed-point arithmetic support. |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2 Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc. |
0 | 3 |
4 This file is part of GCC. | |
5 | |
6 GCC is free software; you can redistribute it and/or modify it under | |
7 the terms of the GNU General Public License as published by the Free | |
8 Software Foundation; either version 3, or (at your option) any later | |
9 version. | |
10 | |
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
12 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 COPYING3. If not see | |
18 <http://www.gnu.org/licenses/>. */ | |
19 | |
20 #include "config.h" | |
21 #include "system.h" | |
22 #include "coretypes.h" | |
23 #include "tm.h" | |
24 #include "tree.h" | |
25 #include "toplev.h" | |
26 #include "fixed-value.h" | |
27 | |
28 /* Compare two fixed objects for bitwise identity. */ | |
29 | |
30 bool | |
31 fixed_identical (const FIXED_VALUE_TYPE *a, const FIXED_VALUE_TYPE *b) | |
32 { | |
33 return (a->mode == b->mode | |
34 && a->data.high == b->data.high | |
35 && a->data.low == b->data.low); | |
36 } | |
37 | |
38 /* Calculate a hash value. */ | |
39 | |
40 unsigned int | |
41 fixed_hash (const FIXED_VALUE_TYPE *f) | |
42 { | |
43 return (unsigned int) (f->data.low ^ f->data.high); | |
44 } | |
45 | |
46 /* Define the enum code for the range of the fixed-point value. */ | |
47 enum fixed_value_range_code { | |
48 FIXED_OK, /* The value is within the range. */ | |
49 FIXED_UNDERFLOW, /* The value is less than the minimum. */ | |
50 FIXED_GT_MAX_EPS, /* The value is greater than the maximum, but not equal | |
51 to the maximum plus the epsilon. */ | |
52 FIXED_MAX_EPS /* The value equals the maximum plus the epsilon. */ | |
53 }; | |
54 | |
55 /* Check REAL_VALUE against the range of the fixed-point mode. | |
56 Return FIXED_OK, if it is within the range. | |
57 FIXED_UNDERFLOW, if it is less than the minimum. | |
58 FIXED_GT_MAX_EPS, if it is greater than the maximum, but not equal to | |
59 the maximum plus the epsilon. | |
60 FIXED_MAX_EPS, if it is equal to the maximum plus the epsilon. */ | |
61 | |
62 static enum fixed_value_range_code | |
63 check_real_for_fixed_mode (REAL_VALUE_TYPE *real_value, enum machine_mode mode) | |
64 { | |
65 REAL_VALUE_TYPE max_value, min_value, epsilon_value; | |
66 | |
67 real_2expN (&max_value, GET_MODE_IBIT (mode), mode); | |
68 real_2expN (&epsilon_value, -GET_MODE_FBIT (mode), mode); | |
69 | |
70 if (SIGNED_FIXED_POINT_MODE_P (mode)) | |
71 min_value = REAL_VALUE_NEGATE (max_value); | |
72 else | |
73 real_from_string (&min_value, "0.0"); | |
74 | |
75 if (real_compare (LT_EXPR, real_value, &min_value)) | |
76 return FIXED_UNDERFLOW; | |
77 if (real_compare (EQ_EXPR, real_value, &max_value)) | |
78 return FIXED_MAX_EPS; | |
79 real_arithmetic (&max_value, MINUS_EXPR, &max_value, &epsilon_value); | |
80 if (real_compare (GT_EXPR, real_value, &max_value)) | |
81 return FIXED_GT_MAX_EPS; | |
82 return FIXED_OK; | |
83 } | |
84 | |
85 /* Initialize from a decimal or hexadecimal string. */ | |
86 | |
87 void | |
88 fixed_from_string (FIXED_VALUE_TYPE *f, const char *str, enum machine_mode mode) | |
89 { | |
90 REAL_VALUE_TYPE real_value, fixed_value, base_value; | |
91 unsigned int fbit; | |
92 enum fixed_value_range_code temp; | |
93 | |
94 f->mode = mode; | |
95 fbit = GET_MODE_FBIT (mode); | |
96 | |
97 real_from_string (&real_value, str); | |
98 temp = check_real_for_fixed_mode (&real_value, f->mode); | |
99 /* We don't want to warn the case when the _Fract value is 1.0. */ | |
100 if (temp == FIXED_UNDERFLOW | |
101 || temp == FIXED_GT_MAX_EPS | |
102 || (temp == FIXED_MAX_EPS && ALL_ACCUM_MODE_P (f->mode))) | |
103 warning (OPT_Woverflow, | |
104 "large fixed-point constant implicitly truncated to fixed-point type"); | |
105 real_2expN (&base_value, fbit, mode); | |
106 real_arithmetic (&fixed_value, MULT_EXPR, &real_value, &base_value); | |
107 real_to_integer2 ((HOST_WIDE_INT *)&f->data.low, &f->data.high, | |
108 &fixed_value); | |
109 | |
110 if (temp == FIXED_MAX_EPS && ALL_FRACT_MODE_P (f->mode)) | |
111 { | |
112 /* From the spec, we need to evaluate 1 to the maximal value. */ | |
113 f->data.low = -1; | |
114 f->data.high = -1; | |
115 f->data = double_int_ext (f->data, | |
116 GET_MODE_FBIT (f->mode) | |
117 + GET_MODE_IBIT (f->mode), 1); | |
118 } | |
119 else | |
120 f->data = double_int_ext (f->data, | |
121 SIGNED_FIXED_POINT_MODE_P (f->mode) | |
122 + GET_MODE_FBIT (f->mode) | |
123 + GET_MODE_IBIT (f->mode), | |
124 UNSIGNED_FIXED_POINT_MODE_P (f->mode)); | |
125 } | |
126 | |
127 /* Render F as a decimal floating point constant. */ | |
128 | |
129 void | |
130 fixed_to_decimal (char *str, const FIXED_VALUE_TYPE *f_orig, | |
131 size_t buf_size) | |
132 { | |
133 REAL_VALUE_TYPE real_value, base_value, fixed_value; | |
134 | |
135 real_2expN (&base_value, GET_MODE_FBIT (f_orig->mode), f_orig->mode); | |
136 real_from_integer (&real_value, VOIDmode, f_orig->data.low, f_orig->data.high, | |
137 UNSIGNED_FIXED_POINT_MODE_P (f_orig->mode)); | |
138 real_arithmetic (&fixed_value, RDIV_EXPR, &real_value, &base_value); | |
139 real_to_decimal (str, &fixed_value, buf_size, 0, 1); | |
140 } | |
141 | |
142 /* If SAT_P, saturate A to the maximum or the minimum, and save to *F based on | |
143 the machine mode MODE. | |
144 Do not modify *F otherwise. | |
145 This function assumes the width of double_int is greater than the width | |
146 of the fixed-point value (the sum of a possible sign bit, possible ibits, | |
147 and fbits). | |
148 Return true, if !SAT_P and overflow. */ | |
149 | |
150 static bool | |
151 fixed_saturate1 (enum machine_mode mode, double_int a, double_int *f, | |
152 bool sat_p) | |
153 { | |
154 bool overflow_p = false; | |
155 bool unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (mode); | |
156 int i_f_bits = GET_MODE_IBIT (mode) + GET_MODE_FBIT (mode); | |
157 | |
158 if (unsigned_p) /* Unsigned type. */ | |
159 { | |
160 double_int max; | |
161 max.low = -1; | |
162 max.high = -1; | |
163 max = double_int_ext (max, i_f_bits, 1); | |
164 if (double_int_cmp (a, max, 1) == 1) | |
165 { | |
166 if (sat_p) | |
167 *f = max; | |
168 else | |
169 overflow_p = true; | |
170 } | |
171 } | |
172 else /* Signed type. */ | |
173 { | |
174 double_int max, min; | |
175 max.high = -1; | |
176 max.low = -1; | |
177 max = double_int_ext (max, i_f_bits, 1); | |
178 min.high = 0; | |
179 min.low = 1; | |
180 lshift_double (min.low, min.high, i_f_bits, | |
181 2 * HOST_BITS_PER_WIDE_INT, | |
182 &min.low, &min.high, 1); | |
183 min = double_int_ext (min, 1 + i_f_bits, 0); | |
184 if (double_int_cmp (a, max, 0) == 1) | |
185 { | |
186 if (sat_p) | |
187 *f = max; | |
188 else | |
189 overflow_p = true; | |
190 } | |
191 else if (double_int_cmp (a, min, 0) == -1) | |
192 { | |
193 if (sat_p) | |
194 *f = min; | |
195 else | |
196 overflow_p = true; | |
197 } | |
198 } | |
199 return overflow_p; | |
200 } | |
201 | |
202 /* If SAT_P, saturate {A_HIGH, A_LOW} to the maximum or the minimum, and | |
203 save to *F based on the machine mode MODE. | |
204 Do not modify *F otherwise. | |
205 This function assumes the width of two double_int is greater than the width | |
206 of the fixed-point value (the sum of a possible sign bit, possible ibits, | |
207 and fbits). | |
208 Return true, if !SAT_P and overflow. */ | |
209 | |
210 static bool | |
211 fixed_saturate2 (enum machine_mode mode, double_int a_high, double_int a_low, | |
212 double_int *f, bool sat_p) | |
213 { | |
214 bool overflow_p = false; | |
215 bool unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (mode); | |
216 int i_f_bits = GET_MODE_IBIT (mode) + GET_MODE_FBIT (mode); | |
217 | |
218 if (unsigned_p) /* Unsigned type. */ | |
219 { | |
220 double_int max_r, max_s; | |
221 max_r.high = 0; | |
222 max_r.low = 0; | |
223 max_s.high = -1; | |
224 max_s.low = -1; | |
225 max_s = double_int_ext (max_s, i_f_bits, 1); | |
226 if (double_int_cmp (a_high, max_r, 1) == 1 | |
227 || (double_int_equal_p (a_high, max_r) && | |
228 double_int_cmp (a_low, max_s, 1) == 1)) | |
229 { | |
230 if (sat_p) | |
231 *f = max_s; | |
232 else | |
233 overflow_p = true; | |
234 } | |
235 } | |
236 else /* Signed type. */ | |
237 { | |
238 double_int max_r, max_s, min_r, min_s; | |
239 max_r.high = 0; | |
240 max_r.low = 0; | |
241 max_s.high = -1; | |
242 max_s.low = -1; | |
243 max_s = double_int_ext (max_s, i_f_bits, 1); | |
244 min_r.high = -1; | |
245 min_r.low = -1; | |
246 min_s.high = 0; | |
247 min_s.low = 1; | |
248 lshift_double (min_s.low, min_s.high, i_f_bits, | |
249 2 * HOST_BITS_PER_WIDE_INT, | |
250 &min_s.low, &min_s.high, 1); | |
251 min_s = double_int_ext (min_s, 1 + i_f_bits, 0); | |
252 if (double_int_cmp (a_high, max_r, 0) == 1 | |
253 || (double_int_equal_p (a_high, max_r) && | |
254 double_int_cmp (a_low, max_s, 1) == 1)) | |
255 { | |
256 if (sat_p) | |
257 *f = max_s; | |
258 else | |
259 overflow_p = true; | |
260 } | |
261 else if (double_int_cmp (a_high, min_r, 0) == -1 | |
262 || (double_int_equal_p (a_high, min_r) && | |
263 double_int_cmp (a_low, min_s, 1) == -1)) | |
264 { | |
265 if (sat_p) | |
266 *f = min_s; | |
267 else | |
268 overflow_p = true; | |
269 } | |
270 } | |
271 return overflow_p; | |
272 } | |
273 | |
274 /* Return the sign bit based on I_F_BITS. */ | |
275 | |
276 static inline int | |
277 get_fixed_sign_bit (double_int a, int i_f_bits) | |
278 { | |
279 if (i_f_bits < HOST_BITS_PER_WIDE_INT) | |
280 return (a.low >> i_f_bits) & 1; | |
281 else | |
282 return (a.high >> (i_f_bits - HOST_BITS_PER_WIDE_INT)) & 1; | |
283 } | |
284 | |
285 /* Calculate F = A + (SUBTRACT_P ? -B : B). | |
286 If SAT_P, saturate the result to the max or the min. | |
287 Return true, if !SAT_P and overflow. */ | |
288 | |
289 static bool | |
290 do_fixed_add (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a, | |
291 const FIXED_VALUE_TYPE *b, bool subtract_p, bool sat_p) | |
292 { | |
293 bool overflow_p = false; | |
294 bool unsigned_p; | |
295 double_int temp; | |
296 int i_f_bits; | |
297 | |
298 /* This was a conditional expression but it triggered a bug in | |
299 Sun C 5.5. */ | |
300 if (subtract_p) | |
301 temp = double_int_neg (b->data); | |
302 else | |
303 temp = b->data; | |
304 | |
305 unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (a->mode); | |
306 i_f_bits = GET_MODE_IBIT (a->mode) + GET_MODE_FBIT (a->mode); | |
307 f->mode = a->mode; | |
308 f->data = double_int_add (a->data, temp); | |
309 if (unsigned_p) /* Unsigned type. */ | |
310 { | |
311 if (subtract_p) /* Unsigned subtraction. */ | |
312 { | |
313 if (double_int_cmp (a->data, b->data, 1) == -1) | |
314 { | |
315 if (sat_p) | |
316 { | |
317 f->data.high = 0; | |
318 f->data.low = 0; | |
319 } | |
320 else | |
321 overflow_p = true; | |
322 } | |
323 } | |
324 else /* Unsigned addition. */ | |
325 { | |
326 f->data = double_int_ext (f->data, i_f_bits, 1); | |
327 if (double_int_cmp (f->data, a->data, 1) == -1 | |
328 || double_int_cmp (f->data, b->data, 1) == -1) | |
329 { | |
330 if (sat_p) | |
331 { | |
332 f->data.high = -1; | |
333 f->data.low = -1; | |
334 } | |
335 else | |
336 overflow_p = true; | |
337 } | |
338 } | |
339 } | |
340 else /* Signed type. */ | |
341 { | |
342 if ((!subtract_p | |
343 && (get_fixed_sign_bit (a->data, i_f_bits) | |
344 == get_fixed_sign_bit (b->data, i_f_bits)) | |
345 && (get_fixed_sign_bit (a->data, i_f_bits) | |
346 != get_fixed_sign_bit (f->data, i_f_bits))) | |
347 || (subtract_p | |
348 && (get_fixed_sign_bit (a->data, i_f_bits) | |
349 != get_fixed_sign_bit (b->data, i_f_bits)) | |
350 && (get_fixed_sign_bit (a->data, i_f_bits) | |
351 != get_fixed_sign_bit (f->data, i_f_bits)))) | |
352 { | |
353 if (sat_p) | |
354 { | |
355 f->data.low = 1; | |
356 f->data.high = 0; | |
357 lshift_double (f->data.low, f->data.high, i_f_bits, | |
358 2 * HOST_BITS_PER_WIDE_INT, | |
359 &f->data.low, &f->data.high, 1); | |
360 if (get_fixed_sign_bit (a->data, i_f_bits) == 0) | |
361 { | |
362 double_int one; | |
363 one.low = 1; | |
364 one.high = 0; | |
365 f->data = double_int_add (f->data, double_int_neg (one)); | |
366 } | |
367 } | |
368 else | |
369 overflow_p = true; | |
370 } | |
371 } | |
372 f->data = double_int_ext (f->data, (!unsigned_p) + i_f_bits, unsigned_p); | |
373 return overflow_p; | |
374 } | |
375 | |
376 /* Calculate F = A * B. | |
377 If SAT_P, saturate the result to the max or the min. | |
378 Return true, if !SAT_P and overflow. */ | |
379 | |
380 static bool | |
381 do_fixed_multiply (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a, | |
382 const FIXED_VALUE_TYPE *b, bool sat_p) | |
383 { | |
384 bool overflow_p = false; | |
385 bool unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (a->mode); | |
386 int i_f_bits = GET_MODE_IBIT (a->mode) + GET_MODE_FBIT (a->mode); | |
387 f->mode = a->mode; | |
388 if (GET_MODE_PRECISION (f->mode) <= HOST_BITS_PER_WIDE_INT) | |
389 { | |
390 f->data = double_int_mul (a->data, b->data); | |
391 lshift_double (f->data.low, f->data.high, | |
392 (-GET_MODE_FBIT (f->mode)), | |
393 2 * HOST_BITS_PER_WIDE_INT, | |
394 &f->data.low, &f->data.high, !unsigned_p); | |
395 overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, sat_p); | |
396 } | |
397 else | |
398 { | |
399 /* The result of multiplication expands to two double_int. */ | |
400 double_int a_high, a_low, b_high, b_low; | |
401 double_int high_high, high_low, low_high, low_low; | |
402 double_int r, s, temp1, temp2; | |
403 int carry = 0; | |
404 | |
405 /* Decompose a and b to four double_int. */ | |
406 a_high.low = a->data.high; | |
407 a_high.high = 0; | |
408 a_low.low = a->data.low; | |
409 a_low.high = 0; | |
410 b_high.low = b->data.high; | |
411 b_high.high = 0; | |
412 b_low.low = b->data.low; | |
413 b_low.high = 0; | |
414 | |
415 /* Perform four multiplications. */ | |
416 low_low = double_int_mul (a_low, b_low); | |
417 low_high = double_int_mul (a_low, b_high); | |
418 high_low = double_int_mul (a_high, b_low); | |
419 high_high = double_int_mul (a_high, b_high); | |
420 | |
421 /* Accumulate four results to {r, s}. */ | |
422 temp1.high = high_low.low; | |
423 temp1.low = 0; | |
424 s = double_int_add (low_low, temp1); | |
425 if (double_int_cmp (s, low_low, 1) == -1 | |
426 || double_int_cmp (s, temp1, 1) == -1) | |
427 carry ++; /* Carry */ | |
428 temp1.high = s.high; | |
429 temp1.low = s.low; | |
430 temp2.high = low_high.low; | |
431 temp2.low = 0; | |
432 s = double_int_add (temp1, temp2); | |
433 if (double_int_cmp (s, temp1, 1) == -1 | |
434 || double_int_cmp (s, temp2, 1) == -1) | |
435 carry ++; /* Carry */ | |
436 | |
437 temp1.low = high_low.high; | |
438 temp1.high = 0; | |
439 r = double_int_add (high_high, temp1); | |
440 temp1.low = low_high.high; | |
441 temp1.high = 0; | |
442 r = double_int_add (r, temp1); | |
443 temp1.low = carry; | |
444 temp1.high = 0; | |
445 r = double_int_add (r, temp1); | |
446 | |
447 /* We need to add neg(b) to r, if a < 0. */ | |
448 if (!unsigned_p && a->data.high < 0) | |
449 r = double_int_add (r, double_int_neg (b->data)); | |
450 /* We need to add neg(a) to r, if b < 0. */ | |
451 if (!unsigned_p && b->data.high < 0) | |
452 r = double_int_add (r, double_int_neg (a->data)); | |
453 | |
454 /* Shift right the result by FBIT. */ | |
455 if (GET_MODE_FBIT (f->mode) == 2 * HOST_BITS_PER_WIDE_INT) | |
456 { | |
457 s.low = r.low; | |
458 s.high = r.high; | |
459 if (unsigned_p) | |
460 { | |
461 r.low = 0; | |
462 r.high = 0; | |
463 } | |
464 else | |
465 { | |
466 r.low = -1; | |
467 r.high = -1; | |
468 } | |
469 f->data.low = s.low; | |
470 f->data.high = s.high; | |
471 } | |
472 else | |
473 { | |
474 lshift_double (s.low, s.high, | |
475 (-GET_MODE_FBIT (f->mode)), | |
476 2 * HOST_BITS_PER_WIDE_INT, | |
477 &s.low, &s.high, 0); | |
478 lshift_double (r.low, r.high, | |
479 (2 * HOST_BITS_PER_WIDE_INT | |
480 - GET_MODE_FBIT (f->mode)), | |
481 2 * HOST_BITS_PER_WIDE_INT, | |
482 &f->data.low, &f->data.high, 0); | |
483 f->data.low = f->data.low | s.low; | |
484 f->data.high = f->data.high | s.high; | |
485 s.low = f->data.low; | |
486 s.high = f->data.high; | |
487 lshift_double (r.low, r.high, | |
488 (-GET_MODE_FBIT (f->mode)), | |
489 2 * HOST_BITS_PER_WIDE_INT, | |
490 &r.low, &r.high, !unsigned_p); | |
491 } | |
492 | |
493 overflow_p = fixed_saturate2 (f->mode, r, s, &f->data, sat_p); | |
494 } | |
495 | |
496 f->data = double_int_ext (f->data, (!unsigned_p) + i_f_bits, unsigned_p); | |
497 return overflow_p; | |
498 } | |
499 | |
500 /* Calculate F = A / B. | |
501 If SAT_P, saturate the result to the max or the min. | |
502 Return true, if !SAT_P and overflow. */ | |
503 | |
504 static bool | |
505 do_fixed_divide (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a, | |
506 const FIXED_VALUE_TYPE *b, bool sat_p) | |
507 { | |
508 bool overflow_p = false; | |
509 bool unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (a->mode); | |
510 int i_f_bits = GET_MODE_IBIT (a->mode) + GET_MODE_FBIT (a->mode); | |
511 f->mode = a->mode; | |
512 if (GET_MODE_PRECISION (f->mode) <= HOST_BITS_PER_WIDE_INT) | |
513 { | |
514 lshift_double (a->data.low, a->data.high, | |
515 GET_MODE_FBIT (f->mode), | |
516 2 * HOST_BITS_PER_WIDE_INT, | |
517 &f->data.low, &f->data.high, !unsigned_p); | |
518 f->data = double_int_div (f->data, b->data, unsigned_p, TRUNC_DIV_EXPR); | |
519 overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, sat_p); | |
520 } | |
521 else | |
522 { | |
523 double_int pos_a, pos_b, r, s; | |
524 double_int quo_r, quo_s, mod, temp; | |
525 int num_of_neg = 0; | |
526 int i; | |
527 | |
528 /* If a < 0, negate a. */ | |
529 if (!unsigned_p && a->data.high < 0) | |
530 { | |
531 pos_a = double_int_neg (a->data); | |
532 num_of_neg ++; | |
533 } | |
534 else | |
535 pos_a = a->data; | |
536 | |
537 /* If b < 0, negate b. */ | |
538 if (!unsigned_p && b->data.high < 0) | |
539 { | |
540 pos_b = double_int_neg (b->data); | |
541 num_of_neg ++; | |
542 } | |
543 else | |
544 pos_b = b->data; | |
545 | |
546 /* Left shift pos_a to {r, s} by FBIT. */ | |
547 if (GET_MODE_FBIT (f->mode) == 2 * HOST_BITS_PER_WIDE_INT) | |
548 { | |
549 r = pos_a; | |
550 s.high = 0; | |
551 s.low = 0; | |
552 } | |
553 else | |
554 { | |
555 lshift_double (pos_a.low, pos_a.high, | |
556 GET_MODE_FBIT (f->mode), | |
557 2 * HOST_BITS_PER_WIDE_INT, | |
558 &s.low, &s.high, 0); | |
559 lshift_double (pos_a.low, pos_a.high, | |
560 - (2 * HOST_BITS_PER_WIDE_INT | |
561 - GET_MODE_FBIT (f->mode)), | |
562 2 * HOST_BITS_PER_WIDE_INT, | |
563 &r.low, &r.high, 0); | |
564 } | |
565 | |
566 /* Divide r by pos_b to quo_r. The remainder is in mod. */ | |
567 div_and_round_double (TRUNC_DIV_EXPR, 1, r.low, r.high, pos_b.low, | |
568 pos_b.high, &quo_r.low, &quo_r.high, &mod.low, | |
569 &mod.high); | |
570 | |
571 quo_s.high = 0; | |
572 quo_s.low = 0; | |
573 | |
574 for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; i++) | |
575 { | |
576 /* Record the leftmost bit of mod. */ | |
577 int leftmost_mod = (mod.high < 0); | |
578 | |
579 /* Shift left mod by 1 bit. */ | |
580 lshift_double (mod.low, mod.high, 1, 2 * HOST_BITS_PER_WIDE_INT, | |
581 &mod.low, &mod.high, 0); | |
582 | |
583 /* Test the leftmost bit of s to add to mod. */ | |
584 if (s.high < 0) | |
585 mod.low += 1; | |
586 | |
587 /* Shift left quo_s by 1 bit. */ | |
588 lshift_double (quo_s.low, quo_s.high, 1, 2 * HOST_BITS_PER_WIDE_INT, | |
589 &quo_s.low, &quo_s.high, 0); | |
590 | |
591 /* Try to calculate (mod - pos_b). */ | |
592 temp = double_int_add (mod, double_int_neg (pos_b)); | |
593 | |
594 if (leftmost_mod == 1 || double_int_cmp (mod, pos_b, 1) != -1) | |
595 { | |
596 quo_s.low += 1; | |
597 mod = temp; | |
598 } | |
599 | |
600 /* Shift left s by 1 bit. */ | |
601 lshift_double (s.low, s.high, 1, 2 * HOST_BITS_PER_WIDE_INT, | |
602 &s.low, &s.high, 0); | |
603 | |
604 } | |
605 | |
606 if (num_of_neg == 1) | |
607 { | |
608 quo_s = double_int_neg (quo_s); | |
609 if (quo_s.high == 0 && quo_s.low == 0) | |
610 quo_r = double_int_neg (quo_r); | |
611 else | |
612 { | |
613 quo_r.low = ~quo_r.low; | |
614 quo_r.high = ~quo_r.high; | |
615 } | |
616 } | |
617 | |
618 f->data = quo_s; | |
619 overflow_p = fixed_saturate2 (f->mode, quo_r, quo_s, &f->data, sat_p); | |
620 } | |
621 | |
622 f->data = double_int_ext (f->data, (!unsigned_p) + i_f_bits, unsigned_p); | |
623 return overflow_p; | |
624 } | |
625 | |
626 /* Calculate F = A << B if LEFT_P. Otherwise, F = A >> B. | |
627 If SAT_P, saturate the result to the max or the min. | |
628 Return true, if !SAT_P and overflow. */ | |
629 | |
630 static bool | |
631 do_fixed_shift (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a, | |
632 const FIXED_VALUE_TYPE *b, bool left_p, bool sat_p) | |
633 { | |
634 bool overflow_p = false; | |
635 bool unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (a->mode); | |
636 int i_f_bits = GET_MODE_IBIT (a->mode) + GET_MODE_FBIT (a->mode); | |
637 f->mode = a->mode; | |
638 | |
639 if (b->data.low == 0) | |
640 { | |
641 f->data = a->data; | |
642 return overflow_p; | |
643 } | |
644 | |
645 if (GET_MODE_PRECISION (f->mode) <= HOST_BITS_PER_WIDE_INT || (!left_p)) | |
646 { | |
647 lshift_double (a->data.low, a->data.high, | |
648 left_p ? b->data.low : (-b->data.low), | |
649 2 * HOST_BITS_PER_WIDE_INT, | |
650 &f->data.low, &f->data.high, !unsigned_p); | |
651 if (left_p) /* Only left shift saturates. */ | |
652 overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, sat_p); | |
653 } | |
654 else /* We need two double_int to store the left-shift result. */ | |
655 { | |
656 double_int temp_high, temp_low; | |
657 if (b->data.low == 2 * HOST_BITS_PER_WIDE_INT) | |
658 { | |
659 temp_high = a->data; | |
660 temp_low.high = 0; | |
661 temp_low.low = 0; | |
662 } | |
663 else | |
664 { | |
665 lshift_double (a->data.low, a->data.high, | |
666 b->data.low, | |
667 2 * HOST_BITS_PER_WIDE_INT, | |
668 &temp_low.low, &temp_low.high, !unsigned_p); | |
669 /* Logical shift right to temp_high. */ | |
670 lshift_double (a->data.low, a->data.high, | |
671 b->data.low - 2 * HOST_BITS_PER_WIDE_INT, | |
672 2 * HOST_BITS_PER_WIDE_INT, | |
673 &temp_high.low, &temp_high.high, 0); | |
674 } | |
675 if (!unsigned_p && a->data.high < 0) /* Signed-extend temp_high. */ | |
676 temp_high = double_int_ext (temp_high, b->data.low, unsigned_p); | |
677 f->data = temp_low; | |
678 overflow_p = fixed_saturate2 (f->mode, temp_high, temp_low, &f->data, | |
679 sat_p); | |
680 } | |
681 f->data = double_int_ext (f->data, (!unsigned_p) + i_f_bits, unsigned_p); | |
682 return overflow_p; | |
683 } | |
684 | |
685 /* Calculate F = -A. | |
686 If SAT_P, saturate the result to the max or the min. | |
687 Return true, if !SAT_P and overflow. */ | |
688 | |
689 static bool | |
690 do_fixed_neg (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a, bool sat_p) | |
691 { | |
692 bool overflow_p = false; | |
693 bool unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (a->mode); | |
694 int i_f_bits = GET_MODE_IBIT (a->mode) + GET_MODE_FBIT (a->mode); | |
695 f->mode = a->mode; | |
696 f->data = double_int_neg (a->data); | |
697 f->data = double_int_ext (f->data, (!unsigned_p) + i_f_bits, unsigned_p); | |
698 | |
699 if (unsigned_p) /* Unsigned type. */ | |
700 { | |
701 if (f->data.low != 0 || f->data.high != 0) | |
702 { | |
703 if (sat_p) | |
704 { | |
705 f->data.low = 0; | |
706 f->data.high = 0; | |
707 } | |
708 else | |
709 overflow_p = true; | |
710 } | |
711 } | |
712 else /* Signed type. */ | |
713 { | |
714 if (!(f->data.high == 0 && f->data.low == 0) | |
715 && f->data.high == a->data.high && f->data.low == a->data.low ) | |
716 { | |
717 if (sat_p) | |
718 { | |
719 /* Saturate to the maximum by subtracting f->data by one. */ | |
720 f->data.low = -1; | |
721 f->data.high = -1; | |
722 f->data = double_int_ext (f->data, i_f_bits, 1); | |
723 } | |
724 else | |
725 overflow_p = true; | |
726 } | |
727 } | |
728 return overflow_p; | |
729 } | |
730 | |
731 /* Perform the binary or unary operation described by CODE. | |
732 Note that OP0 and OP1 must have the same mode for binary operators. | |
733 For a unary operation, leave OP1 NULL. | |
734 Return true, if !SAT_P and overflow. */ | |
735 | |
736 bool | |
737 fixed_arithmetic (FIXED_VALUE_TYPE *f, int icode, const FIXED_VALUE_TYPE *op0, | |
738 const FIXED_VALUE_TYPE *op1, bool sat_p) | |
739 { | |
740 switch (icode) | |
741 { | |
742 case NEGATE_EXPR: | |
743 return do_fixed_neg (f, op0, sat_p); | |
744 break; | |
745 | |
746 case PLUS_EXPR: | |
747 gcc_assert (op0->mode == op1->mode); | |
748 return do_fixed_add (f, op0, op1, false, sat_p); | |
749 break; | |
750 | |
751 case MINUS_EXPR: | |
752 gcc_assert (op0->mode == op1->mode); | |
753 return do_fixed_add (f, op0, op1, true, sat_p); | |
754 break; | |
755 | |
756 case MULT_EXPR: | |
757 gcc_assert (op0->mode == op1->mode); | |
758 return do_fixed_multiply (f, op0, op1, sat_p); | |
759 break; | |
760 | |
761 case TRUNC_DIV_EXPR: | |
762 gcc_assert (op0->mode == op1->mode); | |
763 return do_fixed_divide (f, op0, op1, sat_p); | |
764 break; | |
765 | |
766 case LSHIFT_EXPR: | |
767 return do_fixed_shift (f, op0, op1, true, sat_p); | |
768 break; | |
769 | |
770 case RSHIFT_EXPR: | |
771 return do_fixed_shift (f, op0, op1, false, sat_p); | |
772 break; | |
773 | |
774 default: | |
775 gcc_unreachable (); | |
776 } | |
777 return false; | |
778 } | |
779 | |
780 /* Compare fixed-point values by tree_code. | |
781 Note that OP0 and OP1 must have the same mode. */ | |
782 | |
783 bool | |
784 fixed_compare (int icode, const FIXED_VALUE_TYPE *op0, | |
785 const FIXED_VALUE_TYPE *op1) | |
786 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
787 enum tree_code code = (enum tree_code) icode; |
0 | 788 gcc_assert (op0->mode == op1->mode); |
789 | |
790 switch (code) | |
791 { | |
792 case NE_EXPR: | |
793 return !double_int_equal_p (op0->data, op1->data); | |
794 | |
795 case EQ_EXPR: | |
796 return double_int_equal_p (op0->data, op1->data); | |
797 | |
798 case LT_EXPR: | |
799 return double_int_cmp (op0->data, op1->data, | |
800 UNSIGNED_FIXED_POINT_MODE_P (op0->mode)) == -1; | |
801 | |
802 case LE_EXPR: | |
803 return double_int_cmp (op0->data, op1->data, | |
804 UNSIGNED_FIXED_POINT_MODE_P (op0->mode)) != 1; | |
805 | |
806 case GT_EXPR: | |
807 return double_int_cmp (op0->data, op1->data, | |
808 UNSIGNED_FIXED_POINT_MODE_P (op0->mode)) == 1; | |
809 | |
810 case GE_EXPR: | |
811 return double_int_cmp (op0->data, op1->data, | |
812 UNSIGNED_FIXED_POINT_MODE_P (op0->mode)) != -1; | |
813 | |
814 default: | |
815 gcc_unreachable (); | |
816 } | |
817 } | |
818 | |
819 /* Extend or truncate to a new mode. | |
820 If SAT_P, saturate the result to the max or the min. | |
821 Return true, if !SAT_P and overflow. */ | |
822 | |
823 bool | |
824 fixed_convert (FIXED_VALUE_TYPE *f, enum machine_mode mode, | |
825 const FIXED_VALUE_TYPE *a, bool sat_p) | |
826 { | |
827 bool overflow_p = false; | |
828 if (mode == a->mode) | |
829 { | |
830 *f = *a; | |
831 return overflow_p; | |
832 } | |
833 | |
834 if (GET_MODE_FBIT (mode) > GET_MODE_FBIT (a->mode)) | |
835 { | |
836 /* Left shift a to temp_high, temp_low based on a->mode. */ | |
837 double_int temp_high, temp_low; | |
838 int amount = GET_MODE_FBIT (mode) - GET_MODE_FBIT (a->mode); | |
839 lshift_double (a->data.low, a->data.high, | |
840 amount, | |
841 2 * HOST_BITS_PER_WIDE_INT, | |
842 &temp_low.low, &temp_low.high, | |
843 SIGNED_FIXED_POINT_MODE_P (a->mode)); | |
844 /* Logical shift right to temp_high. */ | |
845 lshift_double (a->data.low, a->data.high, | |
846 amount - 2 * HOST_BITS_PER_WIDE_INT, | |
847 2 * HOST_BITS_PER_WIDE_INT, | |
848 &temp_high.low, &temp_high.high, 0); | |
849 if (SIGNED_FIXED_POINT_MODE_P (a->mode) | |
850 && a->data.high < 0) /* Signed-extend temp_high. */ | |
851 temp_high = double_int_ext (temp_high, amount, 0); | |
852 f->mode = mode; | |
853 f->data = temp_low; | |
854 if (SIGNED_FIXED_POINT_MODE_P (a->mode) == | |
855 SIGNED_FIXED_POINT_MODE_P (f->mode)) | |
856 overflow_p = fixed_saturate2 (f->mode, temp_high, temp_low, &f->data, | |
857 sat_p); | |
858 else | |
859 { | |
860 /* Take care of the cases when converting between signed and | |
861 unsigned. */ | |
862 if (SIGNED_FIXED_POINT_MODE_P (a->mode)) | |
863 { | |
864 /* Signed -> Unsigned. */ | |
865 if (a->data.high < 0) | |
866 { | |
867 if (sat_p) | |
868 { | |
869 f->data.low = 0; /* Set to zero. */ | |
870 f->data.high = 0; /* Set to zero. */ | |
871 } | |
872 else | |
873 overflow_p = true; | |
874 } | |
875 else | |
876 overflow_p = fixed_saturate2 (f->mode, temp_high, temp_low, | |
877 &f->data, sat_p); | |
878 } | |
879 else | |
880 { | |
881 /* Unsigned -> Signed. */ | |
882 if (temp_high.high < 0) | |
883 { | |
884 if (sat_p) | |
885 { | |
886 /* Set to maximum. */ | |
887 f->data.low = -1; /* Set to all ones. */ | |
888 f->data.high = -1; /* Set to all ones. */ | |
889 f->data = double_int_ext (f->data, | |
890 GET_MODE_FBIT (f->mode) | |
891 + GET_MODE_IBIT (f->mode), | |
892 1); /* Clear the sign. */ | |
893 } | |
894 else | |
895 overflow_p = true; | |
896 } | |
897 else | |
898 overflow_p = fixed_saturate2 (f->mode, temp_high, temp_low, | |
899 &f->data, sat_p); | |
900 } | |
901 } | |
902 } | |
903 else | |
904 { | |
905 /* Right shift a to temp based on a->mode. */ | |
906 double_int temp; | |
907 lshift_double (a->data.low, a->data.high, | |
908 GET_MODE_FBIT (mode) - GET_MODE_FBIT (a->mode), | |
909 2 * HOST_BITS_PER_WIDE_INT, | |
910 &temp.low, &temp.high, | |
911 SIGNED_FIXED_POINT_MODE_P (a->mode)); | |
912 f->mode = mode; | |
913 f->data = temp; | |
914 if (SIGNED_FIXED_POINT_MODE_P (a->mode) == | |
915 SIGNED_FIXED_POINT_MODE_P (f->mode)) | |
916 overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, sat_p); | |
917 else | |
918 { | |
919 /* Take care of the cases when converting between signed and | |
920 unsigned. */ | |
921 if (SIGNED_FIXED_POINT_MODE_P (a->mode)) | |
922 { | |
923 /* Signed -> Unsigned. */ | |
924 if (a->data.high < 0) | |
925 { | |
926 if (sat_p) | |
927 { | |
928 f->data.low = 0; /* Set to zero. */ | |
929 f->data.high = 0; /* Set to zero. */ | |
930 } | |
931 else | |
932 overflow_p = true; | |
933 } | |
934 else | |
935 overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, | |
936 sat_p); | |
937 } | |
938 else | |
939 { | |
940 /* Unsigned -> Signed. */ | |
941 if (temp.high < 0) | |
942 { | |
943 if (sat_p) | |
944 { | |
945 /* Set to maximum. */ | |
946 f->data.low = -1; /* Set to all ones. */ | |
947 f->data.high = -1; /* Set to all ones. */ | |
948 f->data = double_int_ext (f->data, | |
949 GET_MODE_FBIT (f->mode) | |
950 + GET_MODE_IBIT (f->mode), | |
951 1); /* Clear the sign. */ | |
952 } | |
953 else | |
954 overflow_p = true; | |
955 } | |
956 else | |
957 overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, | |
958 sat_p); | |
959 } | |
960 } | |
961 } | |
962 | |
963 f->data = double_int_ext (f->data, | |
964 SIGNED_FIXED_POINT_MODE_P (f->mode) | |
965 + GET_MODE_FBIT (f->mode) | |
966 + GET_MODE_IBIT (f->mode), | |
967 UNSIGNED_FIXED_POINT_MODE_P (f->mode)); | |
968 return overflow_p; | |
969 } | |
970 | |
971 /* Convert to a new fixed-point mode from an integer. | |
972 If UNSIGNED_P, this integer is unsigned. | |
973 If SAT_P, saturate the result to the max or the min. | |
974 Return true, if !SAT_P and overflow. */ | |
975 | |
976 bool | |
977 fixed_convert_from_int (FIXED_VALUE_TYPE *f, enum machine_mode mode, | |
978 double_int a, bool unsigned_p, bool sat_p) | |
979 { | |
980 bool overflow_p = false; | |
981 /* Left shift a to temp_high, temp_low. */ | |
982 double_int temp_high, temp_low; | |
983 int amount = GET_MODE_FBIT (mode); | |
984 if (amount == 2 * HOST_BITS_PER_WIDE_INT) | |
985 { | |
986 temp_high = a; | |
987 temp_low.low = 0; | |
988 temp_low.high = 0; | |
989 } | |
990 else | |
991 { | |
992 lshift_double (a.low, a.high, | |
993 amount, | |
994 2 * HOST_BITS_PER_WIDE_INT, | |
995 &temp_low.low, &temp_low.high, 0); | |
996 | |
997 /* Logical shift right to temp_high. */ | |
998 lshift_double (a.low, a.high, | |
999 amount - 2 * HOST_BITS_PER_WIDE_INT, | |
1000 2 * HOST_BITS_PER_WIDE_INT, | |
1001 &temp_high.low, &temp_high.high, 0); | |
1002 } | |
1003 if (!unsigned_p && a.high < 0) /* Signed-extend temp_high. */ | |
1004 temp_high = double_int_ext (temp_high, amount, 0); | |
1005 | |
1006 f->mode = mode; | |
1007 f->data = temp_low; | |
1008 | |
1009 if (unsigned_p == UNSIGNED_FIXED_POINT_MODE_P (f->mode)) | |
1010 overflow_p = fixed_saturate2 (f->mode, temp_high, temp_low, &f->data, | |
1011 sat_p); | |
1012 else | |
1013 { | |
1014 /* Take care of the cases when converting between signed and unsigned. */ | |
1015 if (!unsigned_p) | |
1016 { | |
1017 /* Signed -> Unsigned. */ | |
1018 if (a.high < 0) | |
1019 { | |
1020 if (sat_p) | |
1021 { | |
1022 f->data.low = 0; /* Set to zero. */ | |
1023 f->data.high = 0; /* Set to zero. */ | |
1024 } | |
1025 else | |
1026 overflow_p = true; | |
1027 } | |
1028 else | |
1029 overflow_p = fixed_saturate2 (f->mode, temp_high, temp_low, | |
1030 &f->data, sat_p); | |
1031 } | |
1032 else | |
1033 { | |
1034 /* Unsigned -> Signed. */ | |
1035 if (temp_high.high < 0) | |
1036 { | |
1037 if (sat_p) | |
1038 { | |
1039 /* Set to maximum. */ | |
1040 f->data.low = -1; /* Set to all ones. */ | |
1041 f->data.high = -1; /* Set to all ones. */ | |
1042 f->data = double_int_ext (f->data, | |
1043 GET_MODE_FBIT (f->mode) | |
1044 + GET_MODE_IBIT (f->mode), | |
1045 1); /* Clear the sign. */ | |
1046 } | |
1047 else | |
1048 overflow_p = true; | |
1049 } | |
1050 else | |
1051 overflow_p = fixed_saturate2 (f->mode, temp_high, temp_low, | |
1052 &f->data, sat_p); | |
1053 } | |
1054 } | |
1055 f->data = double_int_ext (f->data, | |
1056 SIGNED_FIXED_POINT_MODE_P (f->mode) | |
1057 + GET_MODE_FBIT (f->mode) | |
1058 + GET_MODE_IBIT (f->mode), | |
1059 UNSIGNED_FIXED_POINT_MODE_P (f->mode)); | |
1060 return overflow_p; | |
1061 } | |
1062 | |
1063 /* Convert to a new fixed-point mode from a real. | |
1064 If SAT_P, saturate the result to the max or the min. | |
1065 Return true, if !SAT_P and overflow. */ | |
1066 | |
1067 bool | |
1068 fixed_convert_from_real (FIXED_VALUE_TYPE *f, enum machine_mode mode, | |
1069 const REAL_VALUE_TYPE *a, bool sat_p) | |
1070 { | |
1071 bool overflow_p = false; | |
1072 REAL_VALUE_TYPE real_value, fixed_value, base_value; | |
1073 bool unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (mode); | |
1074 int i_f_bits = GET_MODE_IBIT (mode) + GET_MODE_FBIT (mode); | |
1075 unsigned int fbit = GET_MODE_FBIT (mode); | |
1076 enum fixed_value_range_code temp; | |
1077 | |
1078 real_value = *a; | |
1079 f->mode = mode; | |
1080 real_2expN (&base_value, fbit, mode); | |
1081 real_arithmetic (&fixed_value, MULT_EXPR, &real_value, &base_value); | |
1082 real_to_integer2 ((HOST_WIDE_INT *)&f->data.low, &f->data.high, &fixed_value); | |
1083 temp = check_real_for_fixed_mode (&real_value, mode); | |
1084 if (temp == FIXED_UNDERFLOW) /* Minimum. */ | |
1085 { | |
1086 if (sat_p) | |
1087 { | |
1088 if (unsigned_p) | |
1089 { | |
1090 f->data.low = 0; | |
1091 f->data.high = 0; | |
1092 } | |
1093 else | |
1094 { | |
1095 f->data.low = 1; | |
1096 f->data.high = 0; | |
1097 lshift_double (f->data.low, f->data.high, i_f_bits, | |
1098 2 * HOST_BITS_PER_WIDE_INT, | |
1099 &f->data.low, &f->data.high, 1); | |
1100 f->data = double_int_ext (f->data, 1 + i_f_bits, 0); | |
1101 } | |
1102 } | |
1103 else | |
1104 overflow_p = true; | |
1105 } | |
1106 else if (temp == FIXED_GT_MAX_EPS || temp == FIXED_MAX_EPS) /* Maximum. */ | |
1107 { | |
1108 if (sat_p) | |
1109 { | |
1110 f->data.low = -1; | |
1111 f->data.high = -1; | |
1112 f->data = double_int_ext (f->data, i_f_bits, 1); | |
1113 } | |
1114 else | |
1115 overflow_p = true; | |
1116 } | |
1117 f->data = double_int_ext (f->data, (!unsigned_p) + i_f_bits, unsigned_p); | |
1118 return overflow_p; | |
1119 } | |
1120 | |
1121 /* Convert to a new real mode from a fixed-point. */ | |
1122 | |
1123 void | |
1124 real_convert_from_fixed (REAL_VALUE_TYPE *r, enum machine_mode mode, | |
1125 const FIXED_VALUE_TYPE *f) | |
1126 { | |
1127 REAL_VALUE_TYPE base_value, fixed_value, real_value; | |
1128 | |
1129 real_2expN (&base_value, GET_MODE_FBIT (f->mode), f->mode); | |
1130 real_from_integer (&fixed_value, VOIDmode, f->data.low, f->data.high, | |
1131 UNSIGNED_FIXED_POINT_MODE_P (f->mode)); | |
1132 real_arithmetic (&real_value, RDIV_EXPR, &fixed_value, &base_value); | |
1133 real_convert (r, mode, &real_value); | |
1134 } | |
1135 | |
1136 /* Determine whether a fixed-point value F is negative. */ | |
1137 | |
1138 bool | |
1139 fixed_isneg (const FIXED_VALUE_TYPE *f) | |
1140 { | |
1141 if (SIGNED_FIXED_POINT_MODE_P (f->mode)) | |
1142 { | |
1143 int i_f_bits = GET_MODE_IBIT (f->mode) + GET_MODE_FBIT (f->mode); | |
1144 int sign_bit = get_fixed_sign_bit (f->data, i_f_bits); | |
1145 if (sign_bit == 1) | |
1146 return true; | |
1147 } | |
1148 | |
1149 return false; | |
1150 } |