|
111
|
1 /* Support for fully folding sub-trees of an expression for C compiler.
|
|
|
2 Copyright (C) 1992-2017 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 #include "config.h"
|
|
|
21 #include "system.h"
|
|
|
22 #include "coretypes.h"
|
|
|
23 #include "target.h"
|
|
|
24 #include "function.h"
|
|
|
25 #include "bitmap.h"
|
|
|
26 #include "c-tree.h"
|
|
|
27 #include "intl.h"
|
|
|
28 #include "gimplify.h"
|
|
|
29
|
|
|
30 static tree c_fully_fold_internal (tree expr, bool, bool *, bool *, bool);
|
|
|
31
|
|
|
32 /* If DISABLE is true, stop issuing warnings. This is used when
|
|
|
33 parsing code that we know will not be executed. This function may
|
|
|
34 be called multiple times, and works as a stack. */
|
|
|
35
|
|
|
36 static void
|
|
|
37 c_disable_warnings (bool disable)
|
|
|
38 {
|
|
|
39 if (disable)
|
|
|
40 {
|
|
|
41 ++c_inhibit_evaluation_warnings;
|
|
|
42 fold_defer_overflow_warnings ();
|
|
|
43 }
|
|
|
44 }
|
|
|
45
|
|
|
46 /* If ENABLE is true, reenable issuing warnings. */
|
|
|
47
|
|
|
48 static void
|
|
|
49 c_enable_warnings (bool enable)
|
|
|
50 {
|
|
|
51 if (enable)
|
|
|
52 {
|
|
|
53 --c_inhibit_evaluation_warnings;
|
|
|
54 fold_undefer_and_ignore_overflow_warnings ();
|
|
|
55 }
|
|
|
56 }
|
|
|
57
|
|
|
58 /* Fully fold EXPR, an expression that was not folded (beyond integer
|
|
|
59 constant expressions and null pointer constants) when being built
|
|
|
60 up. If IN_INIT, this is in a static initializer and certain
|
|
|
61 changes are made to the folding done. Clear *MAYBE_CONST if
|
|
|
62 MAYBE_CONST is not NULL and EXPR is definitely not a constant
|
|
|
63 expression because it contains an evaluated operator (in C99) or an
|
|
|
64 operator outside of sizeof returning an integer constant (in C90)
|
|
|
65 not permitted in constant expressions, or because it contains an
|
|
|
66 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
|
|
|
67 set to true by callers before calling this function.) Return the
|
|
|
68 folded expression. Function arguments have already been folded
|
|
|
69 before calling this function, as have the contents of SAVE_EXPR,
|
|
|
70 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
|
|
|
71 C_MAYBE_CONST_EXPR. */
|
|
|
72
|
|
|
73 tree
|
|
|
74 c_fully_fold (tree expr, bool in_init, bool *maybe_const)
|
|
|
75 {
|
|
|
76 tree ret;
|
|
|
77 tree eptype = NULL_TREE;
|
|
|
78 bool dummy = true;
|
|
|
79 bool maybe_const_itself = true;
|
|
|
80 location_t loc = EXPR_LOCATION (expr);
|
|
|
81
|
|
|
82 if (!maybe_const)
|
|
|
83 maybe_const = &dummy;
|
|
|
84 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
|
|
|
85 {
|
|
|
86 eptype = TREE_TYPE (expr);
|
|
|
87 expr = TREE_OPERAND (expr, 0);
|
|
|
88 }
|
|
|
89 ret = c_fully_fold_internal (expr, in_init, maybe_const,
|
|
|
90 &maybe_const_itself, false);
|
|
|
91 if (eptype)
|
|
|
92 ret = fold_convert_loc (loc, eptype, ret);
|
|
|
93 *maybe_const &= maybe_const_itself;
|
|
|
94 return ret;
|
|
|
95 }
|
|
|
96
|
|
|
97 /* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
|
|
|
98 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
|
|
|
99 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
|
|
|
100 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
|
|
|
101 both evaluated and unevaluated subexpressions while
|
|
|
102 *MAYBE_CONST_ITSELF is carried from only evaluated
|
|
|
103 subexpressions). FOR_INT_CONST indicates if EXPR is an expression
|
|
|
104 with integer constant operands, and if any of the operands doesn't
|
|
|
105 get folded to an integer constant, don't fold the expression itself. */
|
|
|
106
|
|
|
107 static tree
|
|
|
108 c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
|
|
|
109 bool *maybe_const_itself, bool for_int_const)
|
|
|
110 {
|
|
|
111 tree ret = expr;
|
|
|
112 enum tree_code code = TREE_CODE (expr);
|
|
|
113 enum tree_code_class kind = TREE_CODE_CLASS (code);
|
|
|
114 location_t loc = EXPR_LOCATION (expr);
|
|
|
115 tree op0, op1, op2, op3;
|
|
|
116 tree orig_op0, orig_op1, orig_op2;
|
|
|
117 bool op0_const = true, op1_const = true, op2_const = true;
|
|
|
118 bool op0_const_self = true, op1_const_self = true, op2_const_self = true;
|
|
|
119 bool nowarning = TREE_NO_WARNING (expr);
|
|
|
120 bool unused_p;
|
|
|
121 source_range old_range;
|
|
|
122
|
|
|
123 /* Constants, declarations, statements, errors, and anything else not
|
|
|
124 counted as an expression cannot usefully be folded further at this
|
|
|
125 point. */
|
|
|
126 if (!IS_EXPR_CODE_CLASS (kind)
|
|
|
127 || kind == tcc_statement)
|
|
|
128 return expr;
|
|
|
129
|
|
|
130 if (IS_EXPR_CODE_CLASS (kind))
|
|
|
131 old_range = EXPR_LOCATION_RANGE (expr);
|
|
|
132
|
|
|
133 /* Operands of variable-length expressions (function calls) have
|
|
|
134 already been folded, as have __builtin_* function calls, and such
|
|
|
135 expressions cannot occur in constant expressions. */
|
|
|
136 if (kind == tcc_vl_exp)
|
|
|
137 {
|
|
|
138 *maybe_const_operands = false;
|
|
|
139 ret = fold (expr);
|
|
|
140 goto out;
|
|
|
141 }
|
|
|
142
|
|
|
143 if (code == C_MAYBE_CONST_EXPR)
|
|
|
144 {
|
|
|
145 tree pre = C_MAYBE_CONST_EXPR_PRE (expr);
|
|
|
146 tree inner = C_MAYBE_CONST_EXPR_EXPR (expr);
|
|
|
147 if (C_MAYBE_CONST_EXPR_NON_CONST (expr))
|
|
|
148 *maybe_const_operands = false;
|
|
|
149 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr))
|
|
|
150 {
|
|
|
151 *maybe_const_itself = false;
|
|
|
152 inner = c_fully_fold_internal (inner, in_init, maybe_const_operands,
|
|
|
153 maybe_const_itself, true);
|
|
|
154 }
|
|
|
155 if (pre && !in_init)
|
|
|
156 ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr), pre, inner);
|
|
|
157 else
|
|
|
158 ret = inner;
|
|
|
159 goto out;
|
|
|
160 }
|
|
|
161
|
|
|
162 /* Assignment, increment, decrement, function call and comma
|
|
|
163 operators, and statement expressions, cannot occur in constant
|
|
|
164 expressions if evaluated / outside of sizeof. (Function calls
|
|
|
165 were handled above, though VA_ARG_EXPR is treated like a function
|
|
|
166 call here, and statement expressions are handled through
|
|
|
167 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
|
|
|
168 switch (code)
|
|
|
169 {
|
|
|
170 case MODIFY_EXPR:
|
|
|
171 case PREDECREMENT_EXPR:
|
|
|
172 case PREINCREMENT_EXPR:
|
|
|
173 case POSTDECREMENT_EXPR:
|
|
|
174 case POSTINCREMENT_EXPR:
|
|
|
175 case COMPOUND_EXPR:
|
|
|
176 *maybe_const_operands = false;
|
|
|
177 break;
|
|
|
178
|
|
|
179 case VA_ARG_EXPR:
|
|
|
180 case TARGET_EXPR:
|
|
|
181 case BIND_EXPR:
|
|
|
182 case OBJ_TYPE_REF:
|
|
|
183 *maybe_const_operands = false;
|
|
|
184 ret = fold (expr);
|
|
|
185 goto out;
|
|
|
186
|
|
|
187 default:
|
|
|
188 break;
|
|
|
189 }
|
|
|
190
|
|
|
191 /* Fold individual tree codes as appropriate. */
|
|
|
192 switch (code)
|
|
|
193 {
|
|
|
194 case COMPOUND_LITERAL_EXPR:
|
|
|
195 /* Any non-constancy will have been marked in a containing
|
|
|
196 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
|
|
|
197 goto out;
|
|
|
198
|
|
|
199 case COMPONENT_REF:
|
|
|
200 orig_op0 = op0 = TREE_OPERAND (expr, 0);
|
|
|
201 op1 = TREE_OPERAND (expr, 1);
|
|
|
202 op2 = TREE_OPERAND (expr, 2);
|
|
|
203 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
|
|
|
204 maybe_const_itself, for_int_const);
|
|
|
205 STRIP_TYPE_NOPS (op0);
|
|
|
206 if (op0 != orig_op0)
|
|
|
207 ret = build3 (COMPONENT_REF, TREE_TYPE (expr), op0, op1, op2);
|
|
|
208 if (ret != expr)
|
|
|
209 {
|
|
|
210 TREE_READONLY (ret) = TREE_READONLY (expr);
|
|
|
211 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
|
|
|
212 }
|
|
|
213 goto out;
|
|
|
214
|
|
|
215 case ARRAY_REF:
|
|
|
216 orig_op0 = op0 = TREE_OPERAND (expr, 0);
|
|
|
217 orig_op1 = op1 = TREE_OPERAND (expr, 1);
|
|
|
218 op2 = TREE_OPERAND (expr, 2);
|
|
|
219 op3 = TREE_OPERAND (expr, 3);
|
|
|
220 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
|
|
|
221 maybe_const_itself, for_int_const);
|
|
|
222 STRIP_TYPE_NOPS (op0);
|
|
|
223 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
|
|
|
224 maybe_const_itself, for_int_const);
|
|
|
225 STRIP_TYPE_NOPS (op1);
|
|
|
226 op1 = decl_constant_value_for_optimization (op1);
|
|
|
227 if (op0 != orig_op0 || op1 != orig_op1)
|
|
|
228 ret = build4 (ARRAY_REF, TREE_TYPE (expr), op0, op1, op2, op3);
|
|
|
229 if (ret != expr)
|
|
|
230 {
|
|
|
231 TREE_READONLY (ret) = TREE_READONLY (expr);
|
|
|
232 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
|
|
|
233 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
|
|
|
234 }
|
|
|
235 ret = fold (ret);
|
|
|
236 goto out;
|
|
|
237
|
|
|
238 case COMPOUND_EXPR:
|
|
|
239 case MODIFY_EXPR:
|
|
|
240 case PREDECREMENT_EXPR:
|
|
|
241 case PREINCREMENT_EXPR:
|
|
|
242 case POSTDECREMENT_EXPR:
|
|
|
243 case POSTINCREMENT_EXPR:
|
|
|
244 case PLUS_EXPR:
|
|
|
245 case MINUS_EXPR:
|
|
|
246 case MULT_EXPR:
|
|
|
247 case POINTER_PLUS_EXPR:
|
|
|
248 case TRUNC_DIV_EXPR:
|
|
|
249 case CEIL_DIV_EXPR:
|
|
|
250 case FLOOR_DIV_EXPR:
|
|
|
251 case TRUNC_MOD_EXPR:
|
|
|
252 case RDIV_EXPR:
|
|
|
253 case EXACT_DIV_EXPR:
|
|
|
254 case LSHIFT_EXPR:
|
|
|
255 case RSHIFT_EXPR:
|
|
|
256 case BIT_IOR_EXPR:
|
|
|
257 case BIT_XOR_EXPR:
|
|
|
258 case BIT_AND_EXPR:
|
|
|
259 case LT_EXPR:
|
|
|
260 case LE_EXPR:
|
|
|
261 case GT_EXPR:
|
|
|
262 case GE_EXPR:
|
|
|
263 case EQ_EXPR:
|
|
|
264 case NE_EXPR:
|
|
|
265 case COMPLEX_EXPR:
|
|
|
266 case TRUTH_AND_EXPR:
|
|
|
267 case TRUTH_OR_EXPR:
|
|
|
268 case TRUTH_XOR_EXPR:
|
|
|
269 case UNORDERED_EXPR:
|
|
|
270 case ORDERED_EXPR:
|
|
|
271 case UNLT_EXPR:
|
|
|
272 case UNLE_EXPR:
|
|
|
273 case UNGT_EXPR:
|
|
|
274 case UNGE_EXPR:
|
|
|
275 case UNEQ_EXPR:
|
|
|
276 /* Binary operations evaluating both arguments (increment and
|
|
|
277 decrement are binary internally in GCC). */
|
|
|
278 orig_op0 = op0 = TREE_OPERAND (expr, 0);
|
|
|
279 orig_op1 = op1 = TREE_OPERAND (expr, 1);
|
|
|
280 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
|
|
|
281 maybe_const_itself, for_int_const);
|
|
|
282 STRIP_TYPE_NOPS (op0);
|
|
|
283 if (code != MODIFY_EXPR
|
|
|
284 && code != PREDECREMENT_EXPR
|
|
|
285 && code != PREINCREMENT_EXPR
|
|
|
286 && code != POSTDECREMENT_EXPR
|
|
|
287 && code != POSTINCREMENT_EXPR)
|
|
|
288 op0 = decl_constant_value_for_optimization (op0);
|
|
|
289 /* The RHS of a MODIFY_EXPR was fully folded when building that
|
|
|
290 expression for the sake of conversion warnings. */
|
|
|
291 if (code != MODIFY_EXPR)
|
|
|
292 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
|
|
|
293 maybe_const_itself, for_int_const);
|
|
|
294 STRIP_TYPE_NOPS (op1);
|
|
|
295 op1 = decl_constant_value_for_optimization (op1);
|
|
|
296
|
|
|
297 if (for_int_const && (TREE_CODE (op0) != INTEGER_CST
|
|
|
298 || TREE_CODE (op1) != INTEGER_CST))
|
|
|
299 goto out;
|
|
|
300
|
|
|
301 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
|
|
|
302 ret = in_init
|
|
|
303 ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
|
|
|
304 : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
|
|
|
305 else
|
|
|
306 ret = fold (expr);
|
|
|
307 if (TREE_OVERFLOW_P (ret)
|
|
|
308 && !TREE_OVERFLOW_P (op0)
|
|
|
309 && !TREE_OVERFLOW_P (op1))
|
|
|
310 overflow_warning (EXPR_LOC_OR_LOC (expr, input_location), ret, expr);
|
|
|
311 if (code == LSHIFT_EXPR
|
|
|
312 && TREE_CODE (orig_op0) != INTEGER_CST
|
|
|
313 && TREE_CODE (TREE_TYPE (orig_op0)) == INTEGER_TYPE
|
|
|
314 && TREE_CODE (op0) == INTEGER_CST
|
|
|
315 && c_inhibit_evaluation_warnings == 0
|
|
|
316 && tree_int_cst_sgn (op0) < 0)
|
|
|
317 warning_at (loc, OPT_Wshift_negative_value,
|
|
|
318 "left shift of negative value");
|
|
|
319 if ((code == LSHIFT_EXPR || code == RSHIFT_EXPR)
|
|
|
320 && TREE_CODE (orig_op1) != INTEGER_CST
|
|
|
321 && TREE_CODE (op1) == INTEGER_CST
|
|
|
322 && TREE_CODE (TREE_TYPE (orig_op1)) == INTEGER_TYPE
|
|
|
323 && c_inhibit_evaluation_warnings == 0)
|
|
|
324 {
|
|
|
325 if (tree_int_cst_sgn (op1) < 0)
|
|
|
326 warning_at (loc, OPT_Wshift_count_negative,
|
|
|
327 (code == LSHIFT_EXPR
|
|
|
328 ? G_("left shift count is negative")
|
|
|
329 : G_("right shift count is negative")));
|
|
|
330 else if ((TREE_CODE (TREE_TYPE (orig_op0)) == INTEGER_TYPE
|
|
|
331 || TREE_CODE (TREE_TYPE (orig_op0)) == FIXED_POINT_TYPE)
|
|
|
332 && compare_tree_int (op1,
|
|
|
333 TYPE_PRECISION (TREE_TYPE (orig_op0)))
|
|
|
334 >= 0)
|
|
|
335 warning_at (loc, OPT_Wshift_count_overflow,
|
|
|
336 (code == LSHIFT_EXPR
|
|
|
337 ? G_("left shift count >= width of type")
|
|
|
338 : G_("right shift count >= width of type")));
|
|
|
339 else if (TREE_CODE (TREE_TYPE (orig_op0)) == VECTOR_TYPE
|
|
|
340 && compare_tree_int (op1,
|
|
|
341 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (orig_op0))))
|
|
|
342 >= 0)
|
|
|
343 warning_at (loc, OPT_Wshift_count_overflow,
|
|
|
344 code == LSHIFT_EXPR
|
|
|
345 ? G_("left shift count >= width of vector element")
|
|
|
346 : G_("right shift count >= width of vector element"));
|
|
|
347 }
|
|
|
348 if (code == LSHIFT_EXPR
|
|
|
349 /* If either OP0 has been folded to INTEGER_CST... */
|
|
|
350 && ((TREE_CODE (orig_op0) != INTEGER_CST
|
|
|
351 && TREE_CODE (TREE_TYPE (orig_op0)) == INTEGER_TYPE
|
|
|
352 && TREE_CODE (op0) == INTEGER_CST)
|
|
|
353 /* ...or if OP1 has been folded to INTEGER_CST... */
|
|
|
354 || (TREE_CODE (orig_op1) != INTEGER_CST
|
|
|
355 && TREE_CODE (TREE_TYPE (orig_op1)) == INTEGER_TYPE
|
|
|
356 && TREE_CODE (op1) == INTEGER_CST))
|
|
|
357 && c_inhibit_evaluation_warnings == 0)
|
|
|
358 /* ...then maybe we can detect an overflow. */
|
|
|
359 maybe_warn_shift_overflow (loc, op0, op1);
|
|
|
360 if ((code == TRUNC_DIV_EXPR
|
|
|
361 || code == CEIL_DIV_EXPR
|
|
|
362 || code == FLOOR_DIV_EXPR
|
|
|
363 || code == EXACT_DIV_EXPR
|
|
|
364 || code == TRUNC_MOD_EXPR)
|
|
|
365 && TREE_CODE (orig_op1) != INTEGER_CST
|
|
|
366 && TREE_CODE (op1) == INTEGER_CST
|
|
|
367 && (TREE_CODE (TREE_TYPE (orig_op0)) == INTEGER_TYPE
|
|
|
368 || TREE_CODE (TREE_TYPE (orig_op0)) == FIXED_POINT_TYPE)
|
|
|
369 && TREE_CODE (TREE_TYPE (orig_op1)) == INTEGER_TYPE)
|
|
|
370 warn_for_div_by_zero (loc, op1);
|
|
|
371 goto out;
|
|
|
372
|
|
|
373 case INDIRECT_REF:
|
|
|
374 case FIX_TRUNC_EXPR:
|
|
|
375 case FLOAT_EXPR:
|
|
|
376 CASE_CONVERT:
|
|
|
377 case ADDR_SPACE_CONVERT_EXPR:
|
|
|
378 case VIEW_CONVERT_EXPR:
|
|
|
379 case NON_LVALUE_EXPR:
|
|
|
380 case NEGATE_EXPR:
|
|
|
381 case BIT_NOT_EXPR:
|
|
|
382 case TRUTH_NOT_EXPR:
|
|
|
383 case ADDR_EXPR:
|
|
|
384 case CONJ_EXPR:
|
|
|
385 case REALPART_EXPR:
|
|
|
386 case IMAGPART_EXPR:
|
|
|
387 /* Unary operations. */
|
|
|
388 orig_op0 = op0 = TREE_OPERAND (expr, 0);
|
|
|
389 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
|
|
|
390 maybe_const_itself, for_int_const);
|
|
|
391 STRIP_TYPE_NOPS (op0);
|
|
|
392 if (code != ADDR_EXPR && code != REALPART_EXPR && code != IMAGPART_EXPR)
|
|
|
393 op0 = decl_constant_value_for_optimization (op0);
|
|
|
394
|
|
|
395 if (for_int_const && TREE_CODE (op0) != INTEGER_CST)
|
|
|
396 goto out;
|
|
|
397
|
|
|
398 /* ??? Cope with user tricks that amount to offsetof. The middle-end is
|
|
|
399 not prepared to deal with them if they occur in initializers. */
|
|
|
400 if (op0 != orig_op0
|
|
|
401 && code == ADDR_EXPR
|
|
|
402 && (op1 = get_base_address (op0)) != NULL_TREE
|
|
|
403 && INDIRECT_REF_P (op1)
|
|
|
404 && TREE_CONSTANT (TREE_OPERAND (op1, 0)))
|
|
|
405 ret = fold_convert_loc (loc, TREE_TYPE (expr), fold_offsetof_1 (op0));
|
|
|
406 else if (op0 != orig_op0 || in_init)
|
|
|
407 ret = in_init
|
|
|
408 ? fold_build1_initializer_loc (loc, code, TREE_TYPE (expr), op0)
|
|
|
409 : fold_build1_loc (loc, code, TREE_TYPE (expr), op0);
|
|
|
410 else
|
|
|
411 ret = fold (expr);
|
|
|
412 if (code == INDIRECT_REF
|
|
|
413 && ret != expr
|
|
|
414 && INDIRECT_REF_P (ret))
|
|
|
415 {
|
|
|
416 TREE_READONLY (ret) = TREE_READONLY (expr);
|
|
|
417 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
|
|
|
418 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
|
|
|
419 }
|
|
|
420 switch (code)
|
|
|
421 {
|
|
|
422 case FIX_TRUNC_EXPR:
|
|
|
423 case FLOAT_EXPR:
|
|
|
424 CASE_CONVERT:
|
|
|
425 /* Don't warn about explicit conversions. We will already
|
|
|
426 have warned about suspect implicit conversions. */
|
|
|
427 break;
|
|
|
428
|
|
|
429 default:
|
|
|
430 if (TREE_OVERFLOW_P (ret) && !TREE_OVERFLOW_P (op0))
|
|
|
431 overflow_warning (EXPR_LOCATION (expr), ret, op0);
|
|
|
432 break;
|
|
|
433 }
|
|
|
434 goto out;
|
|
|
435
|
|
|
436 case TRUTH_ANDIF_EXPR:
|
|
|
437 case TRUTH_ORIF_EXPR:
|
|
|
438 /* Binary operations not necessarily evaluating both
|
|
|
439 arguments. */
|
|
|
440 orig_op0 = op0 = TREE_OPERAND (expr, 0);
|
|
|
441 orig_op1 = op1 = TREE_OPERAND (expr, 1);
|
|
|
442 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self,
|
|
|
443 for_int_const);
|
|
|
444 STRIP_TYPE_NOPS (op0);
|
|
|
445
|
|
|
446 unused_p = (op0 == (code == TRUTH_ANDIF_EXPR
|
|
|
447 ? truthvalue_false_node
|
|
|
448 : truthvalue_true_node));
|
|
|
449 c_disable_warnings (unused_p);
|
|
|
450 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self,
|
|
|
451 for_int_const);
|
|
|
452 STRIP_TYPE_NOPS (op1);
|
|
|
453 c_enable_warnings (unused_p);
|
|
|
454
|
|
|
455 if (for_int_const
|
|
|
456 && (TREE_CODE (op0) != INTEGER_CST
|
|
|
457 /* Require OP1 be an INTEGER_CST only if it's evaluated. */
|
|
|
458 || (!unused_p && TREE_CODE (op1) != INTEGER_CST)))
|
|
|
459 goto out;
|
|
|
460
|
|
|
461 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
|
|
|
462 ret = in_init
|
|
|
463 ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
|
|
|
464 : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
|
|
|
465 else
|
|
|
466 ret = fold (expr);
|
|
|
467 *maybe_const_operands &= op0_const;
|
|
|
468 *maybe_const_itself &= op0_const_self;
|
|
|
469 if (!(flag_isoc99
|
|
|
470 && op0_const
|
|
|
471 && op0_const_self
|
|
|
472 && (code == TRUTH_ANDIF_EXPR
|
|
|
473 ? op0 == truthvalue_false_node
|
|
|
474 : op0 == truthvalue_true_node)))
|
|
|
475 *maybe_const_operands &= op1_const;
|
|
|
476 if (!(op0_const
|
|
|
477 && op0_const_self
|
|
|
478 && (code == TRUTH_ANDIF_EXPR
|
|
|
479 ? op0 == truthvalue_false_node
|
|
|
480 : op0 == truthvalue_true_node)))
|
|
|
481 *maybe_const_itself &= op1_const_self;
|
|
|
482 goto out;
|
|
|
483
|
|
|
484 case COND_EXPR:
|
|
|
485 orig_op0 = op0 = TREE_OPERAND (expr, 0);
|
|
|
486 orig_op1 = op1 = TREE_OPERAND (expr, 1);
|
|
|
487 orig_op2 = op2 = TREE_OPERAND (expr, 2);
|
|
|
488 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self,
|
|
|
489 for_int_const);
|
|
|
490
|
|
|
491 STRIP_TYPE_NOPS (op0);
|
|
|
492 c_disable_warnings (op0 == truthvalue_false_node);
|
|
|
493 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self,
|
|
|
494 for_int_const);
|
|
|
495 STRIP_TYPE_NOPS (op1);
|
|
|
496 c_enable_warnings (op0 == truthvalue_false_node);
|
|
|
497
|
|
|
498 c_disable_warnings (op0 == truthvalue_true_node);
|
|
|
499 op2 = c_fully_fold_internal (op2, in_init, &op2_const, &op2_const_self,
|
|
|
500 for_int_const);
|
|
|
501 STRIP_TYPE_NOPS (op2);
|
|
|
502 c_enable_warnings (op0 == truthvalue_true_node);
|
|
|
503
|
|
|
504 if (for_int_const
|
|
|
505 && (TREE_CODE (op0) != INTEGER_CST
|
|
|
506 /* Only the evaluated operand must be an INTEGER_CST. */
|
|
|
507 || (op0 == truthvalue_true_node
|
|
|
508 ? TREE_CODE (op1) != INTEGER_CST
|
|
|
509 : TREE_CODE (op2) != INTEGER_CST)))
|
|
|
510 goto out;
|
|
|
511
|
|
|
512 if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2)
|
|
|
513 ret = fold_build3_loc (loc, code, TREE_TYPE (expr), op0, op1, op2);
|
|
|
514 else
|
|
|
515 ret = fold (expr);
|
|
|
516 *maybe_const_operands &= op0_const;
|
|
|
517 *maybe_const_itself &= op0_const_self;
|
|
|
518 if (!(flag_isoc99
|
|
|
519 && op0_const
|
|
|
520 && op0_const_self
|
|
|
521 && op0 == truthvalue_false_node))
|
|
|
522 *maybe_const_operands &= op1_const;
|
|
|
523 if (!(op0_const
|
|
|
524 && op0_const_self
|
|
|
525 && op0 == truthvalue_false_node))
|
|
|
526 *maybe_const_itself &= op1_const_self;
|
|
|
527 if (!(flag_isoc99
|
|
|
528 && op0_const
|
|
|
529 && op0_const_self
|
|
|
530 && op0 == truthvalue_true_node))
|
|
|
531 *maybe_const_operands &= op2_const;
|
|
|
532 if (!(op0_const
|
|
|
533 && op0_const_self
|
|
|
534 && op0 == truthvalue_true_node))
|
|
|
535 *maybe_const_itself &= op2_const_self;
|
|
|
536 goto out;
|
|
|
537
|
|
|
538 case VEC_COND_EXPR:
|
|
|
539 orig_op0 = op0 = TREE_OPERAND (expr, 0);
|
|
|
540 orig_op1 = op1 = TREE_OPERAND (expr, 1);
|
|
|
541 orig_op2 = op2 = TREE_OPERAND (expr, 2);
|
|
|
542 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
|
|
|
543 maybe_const_itself, for_int_const);
|
|
|
544 STRIP_TYPE_NOPS (op0);
|
|
|
545 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
|
|
|
546 maybe_const_itself, for_int_const);
|
|
|
547 STRIP_TYPE_NOPS (op1);
|
|
|
548 op2 = c_fully_fold_internal (op2, in_init, maybe_const_operands,
|
|
|
549 maybe_const_itself, for_int_const);
|
|
|
550 STRIP_TYPE_NOPS (op2);
|
|
|
551
|
|
|
552 if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2)
|
|
|
553 ret = fold_build3_loc (loc, code, TREE_TYPE (expr), op0, op1, op2);
|
|
|
554 else
|
|
|
555 ret = fold (expr);
|
|
|
556 goto out;
|
|
|
557
|
|
|
558 case EXCESS_PRECISION_EXPR:
|
|
|
559 /* Each case where an operand with excess precision may be
|
|
|
560 encountered must remove the EXCESS_PRECISION_EXPR around
|
|
|
561 inner operands and possibly put one around the whole
|
|
|
562 expression or possibly convert to the semantic type (which
|
|
|
563 c_fully_fold does); we cannot tell at this stage which is
|
|
|
564 appropriate in any particular case. */
|
|
|
565 gcc_unreachable ();
|
|
|
566
|
|
|
567 case SAVE_EXPR:
|
|
|
568 /* Make sure to fold the contents of a SAVE_EXPR exactly once. */
|
|
|
569 op0 = TREE_OPERAND (expr, 0);
|
|
|
570 if (!SAVE_EXPR_FOLDED_P (expr))
|
|
|
571 {
|
|
|
572 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
|
|
|
573 maybe_const_itself, for_int_const);
|
|
|
574 TREE_OPERAND (expr, 0) = op0;
|
|
|
575 SAVE_EXPR_FOLDED_P (expr) = true;
|
|
|
576 }
|
|
|
577 /* Return the SAVE_EXPR operand if it is invariant. */
|
|
|
578 if (tree_invariant_p (op0))
|
|
|
579 ret = op0;
|
|
|
580 goto out;
|
|
|
581
|
|
|
582 default:
|
|
|
583 /* Various codes may appear through folding built-in functions
|
|
|
584 and their arguments. */
|
|
|
585 goto out;
|
|
|
586 }
|
|
|
587
|
|
|
588 out:
|
|
|
589 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
|
|
|
590 have been done by this point, so remove them again. */
|
|
|
591 nowarning |= TREE_NO_WARNING (ret);
|
|
|
592 STRIP_TYPE_NOPS (ret);
|
|
|
593 if (nowarning && !TREE_NO_WARNING (ret))
|
|
|
594 {
|
|
|
595 if (!CAN_HAVE_LOCATION_P (ret))
|
|
|
596 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
|
|
|
597 TREE_NO_WARNING (ret) = 1;
|
|
|
598 }
|
|
|
599 if (ret != expr)
|
|
|
600 {
|
|
|
601 protected_set_expr_location (ret, loc);
|
|
|
602 if (IS_EXPR_CODE_CLASS (kind))
|
|
|
603 set_source_range (ret, old_range.m_start, old_range.m_finish);
|
|
|
604 }
|
|
|
605 return ret;
|
|
|
606 }
|
|
|
607
|
|
|
608 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
|
|
|
609 return EXP. Otherwise, return either EXP or its known constant
|
|
|
610 value (if it has one), but return EXP if EXP has mode BLKmode. ???
|
|
|
611 Is the BLKmode test appropriate? */
|
|
|
612
|
|
|
613 tree
|
|
|
614 decl_constant_value_for_optimization (tree exp)
|
|
|
615 {
|
|
|
616 tree ret;
|
|
|
617
|
|
|
618 if (!optimize
|
|
|
619 || !VAR_P (exp)
|
|
|
620 || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
|
|
|
621 || DECL_MODE (exp) == BLKmode)
|
|
|
622 return exp;
|
|
|
623
|
|
|
624 ret = decl_constant_value (exp);
|
|
|
625 /* Avoid unwanted tree sharing between the initializer and current
|
|
|
626 function's body where the tree can be modified e.g. by the
|
|
|
627 gimplifier. */
|
|
|
628 if (ret != exp && TREE_STATIC (exp))
|
|
|
629 ret = unshare_expr (ret);
|
|
|
630 return ret;
|
|
|
631 }
|
