1 /* Utility routines for data type conversion for GCC.
2 Copyright (C) 1987-2014 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 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
21 /* These routines are somewhat language-independent utility function
22 intended to be called by the language-specific convert () functions. */
23
24 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "tm.h"
28 #include "tree.h"
29 #include "stor-layout.h"
30 #include "flags.h"
31 #include "convert.h"
32 #include "diagnostic-core.h"
33 #include "target.h"
34 #include "langhooks.h"
35
36 /* Convert EXPR to some pointer or reference type TYPE.
37 EXPR must be pointer, reference, integer, enumeral, or literal zero;
38 in other cases error is called. */
39
40 tree
convert_to_pointer(tree type,tree expr)41 convert_to_pointer (tree type, tree expr)
42 {
43 location_t loc = EXPR_LOCATION (expr);
44 if (TREE_TYPE (expr) == type)
45 return expr;
46
47 switch (TREE_CODE (TREE_TYPE (expr)))
48 {
49 case POINTER_TYPE:
50 case REFERENCE_TYPE:
51 {
52 /* If the pointers point to different address spaces, conversion needs
53 to be done via a ADDR_SPACE_CONVERT_EXPR instead of a NOP_EXPR. */
54 addr_space_t to_as = TYPE_ADDR_SPACE (TREE_TYPE (type));
55 addr_space_t from_as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (expr)));
56
57 if (to_as == from_as)
58 return fold_build1_loc (loc, NOP_EXPR, type, expr);
59 else
60 return fold_build1_loc (loc, ADDR_SPACE_CONVERT_EXPR, type, expr);
61 }
62
63 case INTEGER_TYPE:
64 case ENUMERAL_TYPE:
65 case BOOLEAN_TYPE:
66 {
67 /* If the input precision differs from the target pointer type
68 precision, first convert the input expression to an integer type of
69 the target precision. Some targets, e.g. VMS, need several pointer
70 sizes to coexist so the latter isn't necessarily POINTER_SIZE. */
71 unsigned int pprec = TYPE_PRECISION (type);
72 unsigned int eprec = TYPE_PRECISION (TREE_TYPE (expr));
73
74 if (eprec != pprec)
75 expr = fold_build1_loc (loc, NOP_EXPR,
76 lang_hooks.types.type_for_size (pprec, 0),
77 expr);
78 }
79
80 return fold_build1_loc (loc, CONVERT_EXPR, type, expr);
81
82 default:
83 error ("cannot convert to a pointer type");
84 return convert_to_pointer (type, integer_zero_node);
85 }
86 }
87
88
89 /* Convert EXPR to some floating-point type TYPE.
90
91 EXPR must be float, fixed-point, integer, or enumeral;
92 in other cases error is called. */
93
94 tree
convert_to_real(tree type,tree expr)95 convert_to_real (tree type, tree expr)
96 {
97 enum built_in_function fcode = builtin_mathfn_code (expr);
98 tree itype = TREE_TYPE (expr);
99
100 /* Disable until we figure out how to decide whether the functions are
101 present in runtime. */
102 /* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
103 if (optimize
104 && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
105 || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
106 {
107 switch (fcode)
108 {
109 #define CASE_MATHFN(FN) case BUILT_IN_##FN: case BUILT_IN_##FN##L:
110 CASE_MATHFN (COSH)
111 CASE_MATHFN (EXP)
112 CASE_MATHFN (EXP10)
113 CASE_MATHFN (EXP2)
114 CASE_MATHFN (EXPM1)
115 CASE_MATHFN (GAMMA)
116 CASE_MATHFN (J0)
117 CASE_MATHFN (J1)
118 CASE_MATHFN (LGAMMA)
119 CASE_MATHFN (POW10)
120 CASE_MATHFN (SINH)
121 CASE_MATHFN (TGAMMA)
122 CASE_MATHFN (Y0)
123 CASE_MATHFN (Y1)
124 /* The above functions may set errno differently with float
125 input or output so this transformation is not safe with
126 -fmath-errno. */
127 if (flag_errno_math)
128 break;
129 CASE_MATHFN (ACOS)
130 CASE_MATHFN (ACOSH)
131 CASE_MATHFN (ASIN)
132 CASE_MATHFN (ASINH)
133 CASE_MATHFN (ATAN)
134 CASE_MATHFN (ATANH)
135 CASE_MATHFN (CBRT)
136 CASE_MATHFN (COS)
137 CASE_MATHFN (ERF)
138 CASE_MATHFN (ERFC)
139 CASE_MATHFN (LOG)
140 CASE_MATHFN (LOG10)
141 CASE_MATHFN (LOG2)
142 CASE_MATHFN (LOG1P)
143 CASE_MATHFN (SIN)
144 CASE_MATHFN (TAN)
145 CASE_MATHFN (TANH)
146 /* The above functions are not safe to do this conversion. */
147 if (!flag_unsafe_math_optimizations)
148 break;
149 CASE_MATHFN (SQRT)
150 CASE_MATHFN (FABS)
151 CASE_MATHFN (LOGB)
152 #undef CASE_MATHFN
153 {
154 tree arg0 = strip_float_extensions (CALL_EXPR_ARG (expr, 0));
155 tree newtype = type;
156
157 /* We have (outertype)sqrt((innertype)x). Choose the wider mode from
158 the both as the safe type for operation. */
159 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
160 newtype = TREE_TYPE (arg0);
161
162 /* We consider to convert
163
164 (T1) sqrtT2 ((T2) exprT3)
165 to
166 (T1) sqrtT4 ((T4) exprT3)
167
168 , where T1 is TYPE, T2 is ITYPE, T3 is TREE_TYPE (ARG0),
169 and T4 is NEWTYPE. All those types are of floating point types.
170 T4 (NEWTYPE) should be narrower than T2 (ITYPE). This conversion
171 is safe only if P1 >= P2*2+2, where P1 and P2 are precisions of
172 T2 and T4. See the following URL for a reference:
173 http://stackoverflow.com/questions/9235456/determining-
174 floating-point-square-root
175 */
176 if ((fcode == BUILT_IN_SQRT || fcode == BUILT_IN_SQRTL)
177 && !flag_unsafe_math_optimizations)
178 {
179 /* The following conversion is unsafe even the precision condition
180 below is satisfied:
181
182 (float) sqrtl ((long double) double_val) -> (float) sqrt (double_val)
183 */
184 if (TYPE_MODE (type) != TYPE_MODE (newtype))
185 break;
186
187 int p1 = REAL_MODE_FORMAT (TYPE_MODE (itype))->p;
188 int p2 = REAL_MODE_FORMAT (TYPE_MODE (newtype))->p;
189 if (p1 < p2 * 2 + 2)
190 break;
191 }
192
193 /* Be careful about integer to fp conversions.
194 These may overflow still. */
195 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
196 && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
197 && (TYPE_MODE (newtype) == TYPE_MODE (double_type_node)
198 || TYPE_MODE (newtype) == TYPE_MODE (float_type_node)))
199 {
200 tree fn = mathfn_built_in (newtype, fcode);
201
202 if (fn)
203 {
204 tree arg = fold (convert_to_real (newtype, arg0));
205 expr = build_call_expr (fn, 1, arg);
206 if (newtype == type)
207 return expr;
208 }
209 }
210 }
211 default:
212 break;
213 }
214 }
215 if (optimize
216 && (((fcode == BUILT_IN_FLOORL
217 || fcode == BUILT_IN_CEILL
218 || fcode == BUILT_IN_ROUNDL
219 || fcode == BUILT_IN_RINTL
220 || fcode == BUILT_IN_TRUNCL
221 || fcode == BUILT_IN_NEARBYINTL)
222 && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
223 || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
224 || ((fcode == BUILT_IN_FLOOR
225 || fcode == BUILT_IN_CEIL
226 || fcode == BUILT_IN_ROUND
227 || fcode == BUILT_IN_RINT
228 || fcode == BUILT_IN_TRUNC
229 || fcode == BUILT_IN_NEARBYINT)
230 && (TYPE_MODE (type) == TYPE_MODE (float_type_node)))))
231 {
232 tree fn = mathfn_built_in (type, fcode);
233
234 if (fn)
235 {
236 tree arg = strip_float_extensions (CALL_EXPR_ARG (expr, 0));
237
238 /* Make sure (type)arg0 is an extension, otherwise we could end up
239 changing (float)floor(double d) into floorf((float)d), which is
240 incorrect because (float)d uses round-to-nearest and can round
241 up to the next integer. */
242 if (TYPE_PRECISION (type) >= TYPE_PRECISION (TREE_TYPE (arg)))
243 return build_call_expr (fn, 1, fold (convert_to_real (type, arg)));
244 }
245 }
246
247 /* Propagate the cast into the operation. */
248 if (itype != type && FLOAT_TYPE_P (type))
249 switch (TREE_CODE (expr))
250 {
251 /* Convert (float)-x into -(float)x. This is safe for
252 round-to-nearest rounding mode when the inner type is float. */
253 case ABS_EXPR:
254 case NEGATE_EXPR:
255 if (!flag_rounding_math
256 && FLOAT_TYPE_P (itype)
257 && TYPE_PRECISION (type) < TYPE_PRECISION (itype))
258 return build1 (TREE_CODE (expr), type,
259 fold (convert_to_real (type,
260 TREE_OPERAND (expr, 0))));
261 break;
262 /* Convert (outertype)((innertype0)a+(innertype1)b)
263 into ((newtype)a+(newtype)b) where newtype
264 is the widest mode from all of these. */
265 case PLUS_EXPR:
266 case MINUS_EXPR:
267 case MULT_EXPR:
268 case RDIV_EXPR:
269 {
270 tree arg0 = strip_float_extensions (TREE_OPERAND (expr, 0));
271 tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1));
272
273 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
274 && FLOAT_TYPE_P (TREE_TYPE (arg1))
275 && DECIMAL_FLOAT_TYPE_P (itype) == DECIMAL_FLOAT_TYPE_P (type))
276 {
277 tree newtype = type;
278
279 if (TYPE_MODE (TREE_TYPE (arg0)) == SDmode
280 || TYPE_MODE (TREE_TYPE (arg1)) == SDmode
281 || TYPE_MODE (type) == SDmode)
282 newtype = dfloat32_type_node;
283 if (TYPE_MODE (TREE_TYPE (arg0)) == DDmode
284 || TYPE_MODE (TREE_TYPE (arg1)) == DDmode
285 || TYPE_MODE (type) == DDmode)
286 newtype = dfloat64_type_node;
287 if (TYPE_MODE (TREE_TYPE (arg0)) == TDmode
288 || TYPE_MODE (TREE_TYPE (arg1)) == TDmode
289 || TYPE_MODE (type) == TDmode)
290 newtype = dfloat128_type_node;
291 if (newtype == dfloat32_type_node
292 || newtype == dfloat64_type_node
293 || newtype == dfloat128_type_node)
294 {
295 expr = build2 (TREE_CODE (expr), newtype,
296 fold (convert_to_real (newtype, arg0)),
297 fold (convert_to_real (newtype, arg1)));
298 if (newtype == type)
299 return expr;
300 break;
301 }
302
303 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (newtype))
304 newtype = TREE_TYPE (arg0);
305 if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype))
306 newtype = TREE_TYPE (arg1);
307 /* Sometimes this transformation is safe (cannot
308 change results through affecting double rounding
309 cases) and sometimes it is not. If NEWTYPE is
310 wider than TYPE, e.g. (float)((long double)double
311 + (long double)double) converted to
312 (float)(double + double), the transformation is
313 unsafe regardless of the details of the types
314 involved; double rounding can arise if the result
315 of NEWTYPE arithmetic is a NEWTYPE value half way
316 between two representable TYPE values but the
317 exact value is sufficiently different (in the
318 right direction) for this difference to be
319 visible in ITYPE arithmetic. If NEWTYPE is the
320 same as TYPE, however, the transformation may be
321 safe depending on the types involved: it is safe
322 if the ITYPE has strictly more than twice as many
323 mantissa bits as TYPE, can represent infinities
324 and NaNs if the TYPE can, and has sufficient
325 exponent range for the product or ratio of two
326 values representable in the TYPE to be within the
327 range of normal values of ITYPE. */
328 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
329 && (flag_unsafe_math_optimizations
330 || (TYPE_PRECISION (newtype) == TYPE_PRECISION (type)
331 && real_can_shorten_arithmetic (TYPE_MODE (itype),
332 TYPE_MODE (type))
333 && !excess_precision_type (newtype))))
334 {
335 expr = build2 (TREE_CODE (expr), newtype,
336 fold (convert_to_real (newtype, arg0)),
337 fold (convert_to_real (newtype, arg1)));
338 if (newtype == type)
339 return expr;
340 }
341 }
342 }
343 break;
344 default:
345 break;
346 }
347
348 switch (TREE_CODE (TREE_TYPE (expr)))
349 {
350 case REAL_TYPE:
351 /* Ignore the conversion if we don't need to store intermediate
352 results and neither type is a decimal float. */
353 return build1 ((flag_float_store
354 || DECIMAL_FLOAT_TYPE_P (type)
355 || DECIMAL_FLOAT_TYPE_P (itype))
356 ? CONVERT_EXPR : NOP_EXPR, type, expr);
357
358 case INTEGER_TYPE:
359 case ENUMERAL_TYPE:
360 case BOOLEAN_TYPE:
361 return build1 (FLOAT_EXPR, type, expr);
362
363 case FIXED_POINT_TYPE:
364 return build1 (FIXED_CONVERT_EXPR, type, expr);
365
366 case COMPLEX_TYPE:
367 return convert (type,
368 fold_build1 (REALPART_EXPR,
369 TREE_TYPE (TREE_TYPE (expr)), expr));
370
371 case POINTER_TYPE:
372 case REFERENCE_TYPE:
373 error ("pointer value used where a floating point value was expected");
374 return convert_to_real (type, integer_zero_node);
375
376 default:
377 error ("aggregate value used where a float was expected");
378 return convert_to_real (type, integer_zero_node);
379 }
380 }
381
382 /* Convert EXPR to some integer (or enum) type TYPE.
383
384 EXPR must be pointer, integer, discrete (enum, char, or bool), float,
385 fixed-point or vector; in other cases error is called.
386
387 The result of this is always supposed to be a newly created tree node
388 not in use in any existing structure. */
389
390 tree
convert_to_integer(tree type,tree expr)391 convert_to_integer (tree type, tree expr)
392 {
393 enum tree_code ex_form = TREE_CODE (expr);
394 tree intype = TREE_TYPE (expr);
395 unsigned int inprec = element_precision (intype);
396 unsigned int outprec = element_precision (type);
397
398 /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
399 be. Consider `enum E = { a, b = (enum E) 3 };'. */
400 if (!COMPLETE_TYPE_P (type))
401 {
402 error ("conversion to incomplete type");
403 return error_mark_node;
404 }
405
406 /* Convert e.g. (long)round(d) -> lround(d). */
407 /* If we're converting to char, we may encounter differing behavior
408 between converting from double->char vs double->long->char.
409 We're in "undefined" territory but we prefer to be conservative,
410 so only proceed in "unsafe" math mode. */
411 if (optimize
412 && (flag_unsafe_math_optimizations
413 || (long_integer_type_node
414 && outprec >= TYPE_PRECISION (long_integer_type_node))))
415 {
416 tree s_expr = strip_float_extensions (expr);
417 tree s_intype = TREE_TYPE (s_expr);
418 const enum built_in_function fcode = builtin_mathfn_code (s_expr);
419 tree fn = 0;
420
421 switch (fcode)
422 {
423 CASE_FLT_FN (BUILT_IN_CEIL):
424 /* Only convert in ISO C99 mode. */
425 if (!targetm.libc_has_function (function_c99_misc))
426 break;
427 if (outprec < TYPE_PRECISION (integer_type_node)
428 || (outprec == TYPE_PRECISION (integer_type_node)
429 && !TYPE_UNSIGNED (type)))
430 fn = mathfn_built_in (s_intype, BUILT_IN_ICEIL);
431 else if (outprec == TYPE_PRECISION (long_integer_type_node)
432 && !TYPE_UNSIGNED (type))
433 fn = mathfn_built_in (s_intype, BUILT_IN_LCEIL);
434 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
435 && !TYPE_UNSIGNED (type))
436 fn = mathfn_built_in (s_intype, BUILT_IN_LLCEIL);
437 break;
438
439 CASE_FLT_FN (BUILT_IN_FLOOR):
440 /* Only convert in ISO C99 mode. */
441 if (!targetm.libc_has_function (function_c99_misc))
442 break;
443 if (outprec < TYPE_PRECISION (integer_type_node)
444 || (outprec == TYPE_PRECISION (integer_type_node)
445 && !TYPE_UNSIGNED (type)))
446 fn = mathfn_built_in (s_intype, BUILT_IN_IFLOOR);
447 else if (outprec == TYPE_PRECISION (long_integer_type_node)
448 && !TYPE_UNSIGNED (type))
449 fn = mathfn_built_in (s_intype, BUILT_IN_LFLOOR);
450 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
451 && !TYPE_UNSIGNED (type))
452 fn = mathfn_built_in (s_intype, BUILT_IN_LLFLOOR);
453 break;
454
455 CASE_FLT_FN (BUILT_IN_ROUND):
456 /* Only convert in ISO C99 mode. */
457 if (!targetm.libc_has_function (function_c99_misc))
458 break;
459 if (outprec < TYPE_PRECISION (integer_type_node)
460 || (outprec == TYPE_PRECISION (integer_type_node)
461 && !TYPE_UNSIGNED (type)))
462 fn = mathfn_built_in (s_intype, BUILT_IN_IROUND);
463 else if (outprec == TYPE_PRECISION (long_integer_type_node)
464 && !TYPE_UNSIGNED (type))
465 fn = mathfn_built_in (s_intype, BUILT_IN_LROUND);
466 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
467 && !TYPE_UNSIGNED (type))
468 fn = mathfn_built_in (s_intype, BUILT_IN_LLROUND);
469 break;
470
471 CASE_FLT_FN (BUILT_IN_NEARBYINT):
472 /* Only convert nearbyint* if we can ignore math exceptions. */
473 if (flag_trapping_math)
474 break;
475 /* ... Fall through ... */
476 CASE_FLT_FN (BUILT_IN_RINT):
477 /* Only convert in ISO C99 mode. */
478 if (!targetm.libc_has_function (function_c99_misc))
479 break;
480 if (outprec < TYPE_PRECISION (integer_type_node)
481 || (outprec == TYPE_PRECISION (integer_type_node)
482 && !TYPE_UNSIGNED (type)))
483 fn = mathfn_built_in (s_intype, BUILT_IN_IRINT);
484 else if (outprec == TYPE_PRECISION (long_integer_type_node)
485 && !TYPE_UNSIGNED (type))
486 fn = mathfn_built_in (s_intype, BUILT_IN_LRINT);
487 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
488 && !TYPE_UNSIGNED (type))
489 fn = mathfn_built_in (s_intype, BUILT_IN_LLRINT);
490 break;
491
492 CASE_FLT_FN (BUILT_IN_TRUNC):
493 return convert_to_integer (type, CALL_EXPR_ARG (s_expr, 0));
494
495 default:
496 break;
497 }
498
499 if (fn)
500 {
501 tree newexpr = build_call_expr (fn, 1, CALL_EXPR_ARG (s_expr, 0));
502 return convert_to_integer (type, newexpr);
503 }
504 }
505
506 /* Convert (int)logb(d) -> ilogb(d). */
507 if (optimize
508 && flag_unsafe_math_optimizations
509 && !flag_trapping_math && !flag_errno_math && flag_finite_math_only
510 && integer_type_node
511 && (outprec > TYPE_PRECISION (integer_type_node)
512 || (outprec == TYPE_PRECISION (integer_type_node)
513 && !TYPE_UNSIGNED (type))))
514 {
515 tree s_expr = strip_float_extensions (expr);
516 tree s_intype = TREE_TYPE (s_expr);
517 const enum built_in_function fcode = builtin_mathfn_code (s_expr);
518 tree fn = 0;
519
520 switch (fcode)
521 {
522 CASE_FLT_FN (BUILT_IN_LOGB):
523 fn = mathfn_built_in (s_intype, BUILT_IN_ILOGB);
524 break;
525
526 default:
527 break;
528 }
529
530 if (fn)
531 {
532 tree newexpr = build_call_expr (fn, 1, CALL_EXPR_ARG (s_expr, 0));
533 return convert_to_integer (type, newexpr);
534 }
535 }
536
537 switch (TREE_CODE (intype))
538 {
539 case POINTER_TYPE:
540 case REFERENCE_TYPE:
541 if (integer_zerop (expr))
542 return build_int_cst (type, 0);
543
544 /* Convert to an unsigned integer of the correct width first, and from
545 there widen/truncate to the required type. Some targets support the
546 coexistence of multiple valid pointer sizes, so fetch the one we need
547 from the type. */
548 expr = fold_build1 (CONVERT_EXPR,
549 lang_hooks.types.type_for_size
550 (TYPE_PRECISION (intype), 0),
551 expr);
552 return fold_convert (type, expr);
553
554 case INTEGER_TYPE:
555 case ENUMERAL_TYPE:
556 case BOOLEAN_TYPE:
557 case OFFSET_TYPE:
558 /* If this is a logical operation, which just returns 0 or 1, we can
559 change the type of the expression. */
560
561 if (TREE_CODE_CLASS (ex_form) == tcc_comparison)
562 {
563 expr = copy_node (expr);
564 TREE_TYPE (expr) = type;
565 return expr;
566 }
567
568 /* If we are widening the type, put in an explicit conversion.
569 Similarly if we are not changing the width. After this, we know
570 we are truncating EXPR. */
571
572 else if (outprec >= inprec)
573 {
574 enum tree_code code;
575
576 /* If the precision of the EXPR's type is K bits and the
577 destination mode has more bits, and the sign is changing,
578 it is not safe to use a NOP_EXPR. For example, suppose
579 that EXPR's type is a 3-bit unsigned integer type, the
580 TYPE is a 3-bit signed integer type, and the machine mode
581 for the types is 8-bit QImode. In that case, the
582 conversion necessitates an explicit sign-extension. In
583 the signed-to-unsigned case the high-order bits have to
584 be cleared. */
585 if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (TREE_TYPE (expr))
586 && (TYPE_PRECISION (TREE_TYPE (expr))
587 != GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (expr)))))
588 code = CONVERT_EXPR;
589 else
590 code = NOP_EXPR;
591
592 return fold_build1 (code, type, expr);
593 }
594
595 /* If TYPE is an enumeral type or a type with a precision less
596 than the number of bits in its mode, do the conversion to the
597 type corresponding to its mode, then do a nop conversion
598 to TYPE. */
599 else if (TREE_CODE (type) == ENUMERAL_TYPE
600 || outprec != GET_MODE_PRECISION (TYPE_MODE (type)))
601 return build1 (NOP_EXPR, type,
602 convert (lang_hooks.types.type_for_mode
603 (TYPE_MODE (type), TYPE_UNSIGNED (type)),
604 expr));
605
606 /* Here detect when we can distribute the truncation down past some
607 arithmetic. For example, if adding two longs and converting to an
608 int, we can equally well convert both to ints and then add.
609 For the operations handled here, such truncation distribution
610 is always safe.
611 It is desirable in these cases:
612 1) when truncating down to full-word from a larger size
613 2) when truncating takes no work.
614 3) when at least one operand of the arithmetic has been extended
615 (as by C's default conversions). In this case we need two conversions
616 if we do the arithmetic as already requested, so we might as well
617 truncate both and then combine. Perhaps that way we need only one.
618
619 Note that in general we cannot do the arithmetic in a type
620 shorter than the desired result of conversion, even if the operands
621 are both extended from a shorter type, because they might overflow
622 if combined in that type. The exceptions to this--the times when
623 two narrow values can be combined in their narrow type even to
624 make a wider result--are handled by "shorten" in build_binary_op. */
625
626 switch (ex_form)
627 {
628 case RSHIFT_EXPR:
629 /* We can pass truncation down through right shifting
630 when the shift count is a nonpositive constant. */
631 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
632 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) <= 0)
633 goto trunc1;
634 break;
635
636 case LSHIFT_EXPR:
637 /* We can pass truncation down through left shifting
638 when the shift count is a nonnegative constant and
639 the target type is unsigned. */
640 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
641 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
642 && TYPE_UNSIGNED (type)
643 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
644 {
645 /* If shift count is less than the width of the truncated type,
646 really shift. */
647 if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
648 /* In this case, shifting is like multiplication. */
649 goto trunc1;
650 else
651 {
652 /* If it is >= that width, result is zero.
653 Handling this with trunc1 would give the wrong result:
654 (int) ((long long) a << 32) is well defined (as 0)
655 but (int) a << 32 is undefined and would get a
656 warning. */
657
658 tree t = build_int_cst (type, 0);
659
660 /* If the original expression had side-effects, we must
661 preserve it. */
662 if (TREE_SIDE_EFFECTS (expr))
663 return build2 (COMPOUND_EXPR, type, expr, t);
664 else
665 return t;
666 }
667 }
668 break;
669
670 case TRUNC_DIV_EXPR:
671 {
672 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
673 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
674
675 /* Don't distribute unless the output precision is at least as big
676 as the actual inputs and it has the same signedness. */
677 if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
678 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
679 /* If signedness of arg0 and arg1 don't match,
680 we can't necessarily find a type to compare them in. */
681 && (TYPE_UNSIGNED (TREE_TYPE (arg0))
682 == TYPE_UNSIGNED (TREE_TYPE (arg1)))
683 /* Do not change the sign of the division. */
684 && (TYPE_UNSIGNED (TREE_TYPE (expr))
685 == TYPE_UNSIGNED (TREE_TYPE (arg0)))
686 /* Either require unsigned division or a division by
687 a constant that is not -1. */
688 && (TYPE_UNSIGNED (TREE_TYPE (arg0))
689 || (TREE_CODE (arg1) == INTEGER_CST
690 && !integer_all_onesp (arg1))))
691 goto trunc1;
692 break;
693 }
694
695 case MAX_EXPR:
696 case MIN_EXPR:
697 case MULT_EXPR:
698 {
699 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
700 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
701
702 /* Don't distribute unless the output precision is at least as big
703 as the actual inputs. Otherwise, the comparison of the
704 truncated values will be wrong. */
705 if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
706 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
707 /* If signedness of arg0 and arg1 don't match,
708 we can't necessarily find a type to compare them in. */
709 && (TYPE_UNSIGNED (TREE_TYPE (arg0))
710 == TYPE_UNSIGNED (TREE_TYPE (arg1))))
711 goto trunc1;
712 break;
713 }
714
715 case PLUS_EXPR:
716 case MINUS_EXPR:
717 case BIT_AND_EXPR:
718 case BIT_IOR_EXPR:
719 case BIT_XOR_EXPR:
720 trunc1:
721 {
722 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
723 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
724
725 /* Do not try to narrow operands of pointer subtraction;
726 that will interfere with other folding. */
727 if (ex_form == MINUS_EXPR
728 && CONVERT_EXPR_P (arg0)
729 && CONVERT_EXPR_P (arg1)
730 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0)))
731 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg1, 0))))
732 break;
733
734 if (outprec >= BITS_PER_WORD
735 || TRULY_NOOP_TRUNCATION (outprec, inprec)
736 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
737 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
738 {
739 /* Do the arithmetic in type TYPEX,
740 then convert result to TYPE. */
741 tree typex = type;
742
743 /* Can't do arithmetic in enumeral types
744 so use an integer type that will hold the values. */
745 if (TREE_CODE (typex) == ENUMERAL_TYPE)
746 typex = lang_hooks.types.type_for_size
747 (TYPE_PRECISION (typex), TYPE_UNSIGNED (typex));
748
749 /* But now perhaps TYPEX is as wide as INPREC.
750 In that case, do nothing special here.
751 (Otherwise would recurse infinitely in convert. */
752 if (TYPE_PRECISION (typex) != inprec)
753 {
754 /* Don't do unsigned arithmetic where signed was wanted,
755 or vice versa.
756 Exception: if both of the original operands were
757 unsigned then we can safely do the work as unsigned.
758 Exception: shift operations take their type solely
759 from the first argument.
760 Exception: the LSHIFT_EXPR case above requires that
761 we perform this operation unsigned lest we produce
762 signed-overflow undefinedness.
763 And we may need to do it as unsigned
764 if we truncate to the original size. */
765 if (TYPE_UNSIGNED (TREE_TYPE (expr))
766 || (TYPE_UNSIGNED (TREE_TYPE (arg0))
767 && (TYPE_UNSIGNED (TREE_TYPE (arg1))
768 || ex_form == LSHIFT_EXPR
769 || ex_form == RSHIFT_EXPR
770 || ex_form == LROTATE_EXPR
771 || ex_form == RROTATE_EXPR))
772 || ex_form == LSHIFT_EXPR
773 /* If we have !flag_wrapv, and either ARG0 or
774 ARG1 is of a signed type, we have to do
775 PLUS_EXPR, MINUS_EXPR or MULT_EXPR in an unsigned
776 type in case the operation in outprec precision
777 could overflow. Otherwise, we would introduce
778 signed-overflow undefinedness. */
779 || ((!TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0))
780 || !TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1)))
781 && ((TYPE_PRECISION (TREE_TYPE (arg0)) * 2u
782 > outprec)
783 || (TYPE_PRECISION (TREE_TYPE (arg1)) * 2u
784 > outprec))
785 && (ex_form == PLUS_EXPR
786 || ex_form == MINUS_EXPR
787 || ex_form == MULT_EXPR)))
788 typex = unsigned_type_for (typex);
789 else
790 typex = signed_type_for (typex);
791 return convert (type,
792 fold_build2 (ex_form, typex,
793 convert (typex, arg0),
794 convert (typex, arg1)));
795 }
796 }
797 }
798 break;
799
800 case NEGATE_EXPR:
801 case BIT_NOT_EXPR:
802 /* This is not correct for ABS_EXPR,
803 since we must test the sign before truncation. */
804 {
805 tree typex = unsigned_type_for (type);
806 return convert (type,
807 fold_build1 (ex_form, typex,
808 convert (typex,
809 TREE_OPERAND (expr, 0))));
810 }
811
812 case NOP_EXPR:
813 /* Don't introduce a
814 "can't convert between vector values of different size" error. */
815 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == VECTOR_TYPE
816 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0))))
817 != GET_MODE_SIZE (TYPE_MODE (type))))
818 break;
819 /* If truncating after truncating, might as well do all at once.
820 If truncating after extending, we may get rid of wasted work. */
821 return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
822
823 case COND_EXPR:
824 /* It is sometimes worthwhile to push the narrowing down through
825 the conditional and never loses. A COND_EXPR may have a throw
826 as one operand, which then has void type. Just leave void
827 operands as they are. */
828 return fold_build3 (COND_EXPR, type, TREE_OPERAND (expr, 0),
829 VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 1)))
830 ? TREE_OPERAND (expr, 1)
831 : convert (type, TREE_OPERAND (expr, 1)),
832 VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 2)))
833 ? TREE_OPERAND (expr, 2)
834 : convert (type, TREE_OPERAND (expr, 2)));
835
836 default:
837 break;
838 }
839
840 /* When parsing long initializers, we might end up with a lot of casts.
841 Shortcut this. */
842 if (TREE_CODE (expr) == INTEGER_CST)
843 return fold_convert (type, expr);
844 return build1 (CONVERT_EXPR, type, expr);
845
846 case REAL_TYPE:
847 return build1 (FIX_TRUNC_EXPR, type, expr);
848
849 case FIXED_POINT_TYPE:
850 return build1 (FIXED_CONVERT_EXPR, type, expr);
851
852 case COMPLEX_TYPE:
853 return convert (type,
854 fold_build1 (REALPART_EXPR,
855 TREE_TYPE (TREE_TYPE (expr)), expr));
856
857 case VECTOR_TYPE:
858 if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
859 {
860 error ("can%'t convert between vector values of different size");
861 return error_mark_node;
862 }
863 return build1 (VIEW_CONVERT_EXPR, type, expr);
864
865 default:
866 error ("aggregate value used where an integer was expected");
867 return convert (type, integer_zero_node);
868 }
869 }
870
871 /* Convert EXPR to the complex type TYPE in the usual ways. */
872
873 tree
convert_to_complex(tree type,tree expr)874 convert_to_complex (tree type, tree expr)
875 {
876 tree subtype = TREE_TYPE (type);
877
878 switch (TREE_CODE (TREE_TYPE (expr)))
879 {
880 case REAL_TYPE:
881 case FIXED_POINT_TYPE:
882 case INTEGER_TYPE:
883 case ENUMERAL_TYPE:
884 case BOOLEAN_TYPE:
885 return build2 (COMPLEX_EXPR, type, convert (subtype, expr),
886 convert (subtype, integer_zero_node));
887
888 case COMPLEX_TYPE:
889 {
890 tree elt_type = TREE_TYPE (TREE_TYPE (expr));
891
892 if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
893 return expr;
894 else if (TREE_CODE (expr) == COMPLEX_EXPR)
895 return fold_build2 (COMPLEX_EXPR, type,
896 convert (subtype, TREE_OPERAND (expr, 0)),
897 convert (subtype, TREE_OPERAND (expr, 1)));
898 else
899 {
900 expr = save_expr (expr);
901 return
902 fold_build2 (COMPLEX_EXPR, type,
903 convert (subtype,
904 fold_build1 (REALPART_EXPR,
905 TREE_TYPE (TREE_TYPE (expr)),
906 expr)),
907 convert (subtype,
908 fold_build1 (IMAGPART_EXPR,
909 TREE_TYPE (TREE_TYPE (expr)),
910 expr)));
911 }
912 }
913
914 case POINTER_TYPE:
915 case REFERENCE_TYPE:
916 error ("pointer value used where a complex was expected");
917 return convert_to_complex (type, integer_zero_node);
918
919 default:
920 error ("aggregate value used where a complex was expected");
921 return convert_to_complex (type, integer_zero_node);
922 }
923 }
924
925 /* Convert EXPR to the vector type TYPE in the usual ways. */
926
927 tree
convert_to_vector(tree type,tree expr)928 convert_to_vector (tree type, tree expr)
929 {
930 switch (TREE_CODE (TREE_TYPE (expr)))
931 {
932 case INTEGER_TYPE:
933 case VECTOR_TYPE:
934 if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
935 {
936 error ("can%'t convert between vector values of different size");
937 return error_mark_node;
938 }
939 return build1 (VIEW_CONVERT_EXPR, type, expr);
940
941 default:
942 error ("can%'t convert value to a vector");
943 return error_mark_node;
944 }
945 }
946
947 /* Convert EXPR to some fixed-point type TYPE.
948
949 EXPR must be fixed-point, float, integer, or enumeral;
950 in other cases error is called. */
951
952 tree
convert_to_fixed(tree type,tree expr)953 convert_to_fixed (tree type, tree expr)
954 {
955 if (integer_zerop (expr))
956 {
957 tree fixed_zero_node = build_fixed (type, FCONST0 (TYPE_MODE (type)));
958 return fixed_zero_node;
959 }
960 else if (integer_onep (expr) && ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)))
961 {
962 tree fixed_one_node = build_fixed (type, FCONST1 (TYPE_MODE (type)));
963 return fixed_one_node;
964 }
965
966 switch (TREE_CODE (TREE_TYPE (expr)))
967 {
968 case FIXED_POINT_TYPE:
969 case INTEGER_TYPE:
970 case ENUMERAL_TYPE:
971 case BOOLEAN_TYPE:
972 case REAL_TYPE:
973 return build1 (FIXED_CONVERT_EXPR, type, expr);
974
975 case COMPLEX_TYPE:
976 return convert (type,
977 fold_build1 (REALPART_EXPR,
978 TREE_TYPE (TREE_TYPE (expr)), expr));
979
980 default:
981 error ("aggregate value used where a fixed-point was expected");
982 return error_mark_node;
983 }
984 }
985