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