Branch data Line data Source code
1 : : /* Statement simplification on GIMPLE.
2 : : Copyright (C) 2010-2024 Free Software Foundation, Inc.
3 : : Split out from tree-ssa-ccp.cc.
4 : :
5 : : This file is part of GCC.
6 : :
7 : : GCC is free software; you can redistribute it and/or modify it
8 : : under the terms of the GNU General Public License as published by the
9 : : Free Software Foundation; either version 3, or (at your option) any
10 : : later version.
11 : :
12 : : GCC is distributed in the hope that it will be useful, but WITHOUT
13 : : ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 : : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 : : for more details.
16 : :
17 : : You should have received a copy of the GNU General Public License
18 : : along with GCC; see the file COPYING3. If not see
19 : : <http://www.gnu.org/licenses/>. */
20 : :
21 : : #include "config.h"
22 : : #include "system.h"
23 : : #include "coretypes.h"
24 : : #include "backend.h"
25 : : #include "target.h"
26 : : #include "rtl.h"
27 : : #include "tree.h"
28 : : #include "gimple.h"
29 : : #include "predict.h"
30 : : #include "ssa.h"
31 : : #include "cgraph.h"
32 : : #include "gimple-pretty-print.h"
33 : : #include "gimple-ssa-warn-access.h"
34 : : #include "gimple-ssa-warn-restrict.h"
35 : : #include "fold-const.h"
36 : : #include "stmt.h"
37 : : #include "expr.h"
38 : : #include "stor-layout.h"
39 : : #include "dumpfile.h"
40 : : #include "gimple-iterator.h"
41 : : #include "gimple-fold.h"
42 : : #include "gimplify.h"
43 : : #include "tree-into-ssa.h"
44 : : #include "tree-dfa.h"
45 : : #include "tree-object-size.h"
46 : : #include "tree-ssa.h"
47 : : #include "tree-ssa-propagate.h"
48 : : #include "ipa-utils.h"
49 : : #include "tree-ssa-address.h"
50 : : #include "langhooks.h"
51 : : #include "gimplify-me.h"
52 : : #include "dbgcnt.h"
53 : : #include "builtins.h"
54 : : #include "tree-eh.h"
55 : : #include "gimple-match.h"
56 : : #include "gomp-constants.h"
57 : : #include "optabs-query.h"
58 : : #include "omp-general.h"
59 : : #include "tree-cfg.h"
60 : : #include "fold-const-call.h"
61 : : #include "stringpool.h"
62 : : #include "attribs.h"
63 : : #include "asan.h"
64 : : #include "diagnostic-core.h"
65 : : #include "intl.h"
66 : : #include "calls.h"
67 : : #include "tree-vector-builder.h"
68 : : #include "tree-ssa-strlen.h"
69 : : #include "varasm.h"
70 : : #include "internal-fn.h"
71 : : #include "gimple-range.h"
72 : :
73 : : enum strlen_range_kind {
74 : : /* Compute the exact constant string length. */
75 : : SRK_STRLEN,
76 : : /* Compute the maximum constant string length. */
77 : : SRK_STRLENMAX,
78 : : /* Compute a range of string lengths bounded by object sizes. When
79 : : the length of a string cannot be determined, consider as the upper
80 : : bound the size of the enclosing object the string may be a member
81 : : or element of. Also determine the size of the largest character
82 : : array the string may refer to. */
83 : : SRK_LENRANGE,
84 : : /* Determine the integer value of the argument (not string length). */
85 : : SRK_INT_VALUE
86 : : };
87 : :
88 : : static bool
89 : : get_range_strlen (tree, bitmap, strlen_range_kind, c_strlen_data *, unsigned);
90 : :
91 : : /* Return true when DECL can be referenced from current unit.
92 : : FROM_DECL (if non-null) specify constructor of variable DECL was taken from.
93 : : We can get declarations that are not possible to reference for various
94 : : reasons:
95 : :
96 : : 1) When analyzing C++ virtual tables.
97 : : C++ virtual tables do have known constructors even
98 : : when they are keyed to other compilation unit.
99 : : Those tables can contain pointers to methods and vars
100 : : in other units. Those methods have both STATIC and EXTERNAL
101 : : set.
102 : : 2) In WHOPR mode devirtualization might lead to reference
103 : : to method that was partitioned elsehwere.
104 : : In this case we have static VAR_DECL or FUNCTION_DECL
105 : : that has no corresponding callgraph/varpool node
106 : : declaring the body.
107 : : 3) COMDAT functions referred by external vtables that
108 : : we devirtualize only during final compilation stage.
109 : : At this time we already decided that we will not output
110 : : the function body and thus we can't reference the symbol
111 : : directly. */
112 : :
113 : : static bool
114 : 4488232 : can_refer_decl_in_current_unit_p (tree decl, tree from_decl)
115 : : {
116 : 4488232 : varpool_node *vnode;
117 : 4488232 : struct cgraph_node *node;
118 : 4488232 : symtab_node *snode;
119 : :
120 : 4488232 : if (DECL_ABSTRACT_P (decl))
121 : : return false;
122 : :
123 : : /* We are concerned only about static/external vars and functions. */
124 : 1510741 : if ((!TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
125 : 5594422 : || !VAR_OR_FUNCTION_DECL_P (decl))
126 : : return true;
127 : :
128 : : /* Static objects can be referred only if they are defined and not optimized
129 : : out yet. */
130 : 4083681 : if (!TREE_PUBLIC (decl))
131 : : {
132 : 1089850 : if (DECL_EXTERNAL (decl))
133 : : return false;
134 : : /* Before we start optimizing unreachable code we can be sure all
135 : : static objects are defined. */
136 : 1089794 : if (symtab->function_flags_ready)
137 : : return true;
138 : 1055441 : snode = symtab_node::get (decl);
139 : 1055441 : if (!snode || !snode->definition)
140 : : return false;
141 : 1055394 : node = dyn_cast <cgraph_node *> (snode);
142 : 1063875 : return !node || !node->inlined_to;
143 : : }
144 : :
145 : : /* We will later output the initializer, so we can refer to it.
146 : : So we are concerned only when DECL comes from initializer of
147 : : external var or var that has been optimized out. */
148 : 2993831 : if (!from_decl
149 : 523834 : || !VAR_P (from_decl)
150 : 522758 : || (!DECL_EXTERNAL (from_decl)
151 : 213666 : && (vnode = varpool_node::get (from_decl)) != NULL
152 : 142552 : && vnode->definition)
153 : 3374050 : || (flag_ltrans
154 : 2 : && (vnode = varpool_node::get (from_decl)) != NULL
155 : 2 : && vnode->in_other_partition))
156 : : return true;
157 : : /* We are folding reference from external vtable. The vtable may reffer
158 : : to a symbol keyed to other compilation unit. The other compilation
159 : : unit may be in separate DSO and the symbol may be hidden. */
160 : 380217 : if (DECL_VISIBILITY_SPECIFIED (decl)
161 : 372714 : && DECL_EXTERNAL (decl)
162 : 301272 : && DECL_VISIBILITY (decl) != VISIBILITY_DEFAULT
163 : 589964 : && (!(snode = symtab_node::get (decl)) || !snode->in_other_partition))
164 : : return false;
165 : : /* When function is public, we always can introduce new reference.
166 : : Exception are the COMDAT functions where introducing a direct
167 : : reference imply need to include function body in the curren tunit. */
168 : 170470 : if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
169 : : return true;
170 : : /* We have COMDAT. We are going to check if we still have definition
171 : : or if the definition is going to be output in other partition.
172 : : Bypass this when gimplifying; all needed functions will be produced.
173 : :
174 : : As observed in PR20991 for already optimized out comdat virtual functions
175 : : it may be tempting to not necessarily give up because the copy will be
176 : : output elsewhere when corresponding vtable is output.
177 : : This is however not possible - ABI specify that COMDATs are output in
178 : : units where they are used and when the other unit was compiled with LTO
179 : : it is possible that vtable was kept public while the function itself
180 : : was privatized. */
181 : 121761 : if (!symtab->function_flags_ready)
182 : : return true;
183 : :
184 : 108398 : snode = symtab_node::get (decl);
185 : 108398 : if (!snode
186 : 108398 : || ((!snode->definition || DECL_EXTERNAL (decl))
187 : 15206 : && (!snode->in_other_partition
188 : 0 : || (!snode->forced_by_abi && !snode->force_output))))
189 : : return false;
190 : 62072 : node = dyn_cast <cgraph_node *> (snode);
191 : 62072 : return !node || !node->inlined_to;
192 : : }
193 : :
194 : : /* Create a temporary for TYPE for a statement STMT. If the current function
195 : : is in SSA form, a SSA name is created. Otherwise a temporary register
196 : : is made. */
197 : :
198 : : tree
199 : 895688 : create_tmp_reg_or_ssa_name (tree type, gimple *stmt)
200 : : {
201 : 895688 : if (gimple_in_ssa_p (cfun))
202 : 880820 : return make_ssa_name (type, stmt);
203 : : else
204 : 14868 : return create_tmp_reg (type);
205 : : }
206 : :
207 : : /* CVAL is value taken from DECL_INITIAL of variable. Try to transform it into
208 : : acceptable form for is_gimple_min_invariant.
209 : : FROM_DECL (if non-NULL) specify variable whose constructor contains CVAL. */
210 : :
211 : : tree
212 : 15088913 : canonicalize_constructor_val (tree cval, tree from_decl)
213 : : {
214 : 15088913 : if (CONSTANT_CLASS_P (cval))
215 : : return cval;
216 : :
217 : 9334657 : tree orig_cval = cval;
218 : 9334657 : STRIP_NOPS (cval);
219 : 9334657 : if (TREE_CODE (cval) == POINTER_PLUS_EXPR
220 : 9334657 : && TREE_CODE (TREE_OPERAND (cval, 1)) == INTEGER_CST)
221 : : {
222 : 74124 : tree ptr = TREE_OPERAND (cval, 0);
223 : 74124 : if (is_gimple_min_invariant (ptr))
224 : 222021 : cval = build1_loc (EXPR_LOCATION (cval),
225 : 74007 : ADDR_EXPR, TREE_TYPE (ptr),
226 : 148014 : fold_build2 (MEM_REF, TREE_TYPE (TREE_TYPE (ptr)),
227 : : ptr,
228 : : fold_convert (ptr_type_node,
229 : : TREE_OPERAND (cval, 1))));
230 : : }
231 : 9334657 : if (TREE_CODE (cval) == ADDR_EXPR)
232 : : {
233 : 5160113 : tree base = NULL_TREE;
234 : 5160113 : if (TREE_CODE (TREE_OPERAND (cval, 0)) == COMPOUND_LITERAL_EXPR)
235 : : {
236 : 189 : base = COMPOUND_LITERAL_EXPR_DECL (TREE_OPERAND (cval, 0));
237 : 189 : if (base)
238 : 189 : TREE_OPERAND (cval, 0) = base;
239 : : }
240 : : else
241 : 5159924 : base = get_base_address (TREE_OPERAND (cval, 0));
242 : 5160113 : if (!base)
243 : 0 : return NULL_TREE;
244 : :
245 : 2263645 : if (VAR_OR_FUNCTION_DECL_P (base)
246 : 6462266 : && !can_refer_decl_in_current_unit_p (base, from_decl))
247 : : return NULL_TREE;
248 : 4949362 : if (TREE_TYPE (base) == error_mark_node)
249 : : return NULL_TREE;
250 : 4949362 : if (VAR_P (base))
251 : : /* ??? We should be able to assert that TREE_ADDRESSABLE is set,
252 : : but since the use can be in a debug stmt we can't. */
253 : : ;
254 : 2262521 : else if (TREE_CODE (base) == FUNCTION_DECL)
255 : : {
256 : : /* Make sure we create a cgraph node for functions we'll reference.
257 : : They can be non-existent if the reference comes from an entry
258 : : of an external vtable for example. */
259 : 1301029 : cgraph_node::get_create (base);
260 : : }
261 : : /* Fixup types in global initializers. */
262 : 4949362 : if (TREE_TYPE (TREE_TYPE (cval)) != TREE_TYPE (TREE_OPERAND (cval, 0)))
263 : 37679 : cval = build_fold_addr_expr (TREE_OPERAND (cval, 0));
264 : :
265 : 4949362 : if (!useless_type_conversion_p (TREE_TYPE (orig_cval), TREE_TYPE (cval)))
266 : 216145 : cval = fold_convert (TREE_TYPE (orig_cval), cval);
267 : 4949362 : return cval;
268 : : }
269 : : /* In CONSTRUCTORs we may see unfolded constants like (int (*) ()) 0. */
270 : 4174544 : if (TREE_CODE (cval) == INTEGER_CST)
271 : : {
272 : 65416 : if (TREE_OVERFLOW_P (cval))
273 : 0 : cval = drop_tree_overflow (cval);
274 : 65416 : if (!useless_type_conversion_p (TREE_TYPE (orig_cval), TREE_TYPE (cval)))
275 : 65415 : cval = fold_convert (TREE_TYPE (orig_cval), cval);
276 : 65416 : return cval;
277 : : }
278 : : return orig_cval;
279 : : }
280 : :
281 : : /* If SYM is a constant variable with known value, return the value.
282 : : NULL_TREE is returned otherwise. */
283 : :
284 : : tree
285 : 19757461 : get_symbol_constant_value (tree sym)
286 : : {
287 : 19757461 : tree val = ctor_for_folding (sym);
288 : 19757461 : if (val != error_mark_node)
289 : : {
290 : 37378 : if (val)
291 : : {
292 : 35296 : val = canonicalize_constructor_val (unshare_expr (val), sym);
293 : 35296 : if (val
294 : 35296 : && is_gimple_min_invariant (val)
295 : 63754 : && useless_type_conversion_p (TREE_TYPE (sym), TREE_TYPE (val)))
296 : : return val;
297 : : else
298 : 6945 : return NULL_TREE;
299 : : }
300 : : /* Variables declared 'const' without an initializer
301 : : have zero as the initializer if they may not be
302 : : overridden at link or run time. */
303 : 2082 : if (!val
304 : 2082 : && is_gimple_reg_type (TREE_TYPE (sym)))
305 : 1821 : return build_zero_cst (TREE_TYPE (sym));
306 : : }
307 : :
308 : : return NULL_TREE;
309 : : }
310 : :
311 : :
312 : :
313 : : /* Subroutine of fold_stmt. We perform constant folding of the
314 : : memory reference tree EXPR. */
315 : :
316 : : static tree
317 : 56580464 : maybe_fold_reference (tree expr)
318 : : {
319 : 56580464 : tree result = NULL_TREE;
320 : :
321 : 56580464 : if ((TREE_CODE (expr) == VIEW_CONVERT_EXPR
322 : 54701254 : || TREE_CODE (expr) == REALPART_EXPR
323 : 54017499 : || TREE_CODE (expr) == IMAGPART_EXPR)
324 : 58085467 : && CONSTANT_CLASS_P (TREE_OPERAND (expr, 0)))
325 : 265 : result = fold_unary_loc (EXPR_LOCATION (expr),
326 : : TREE_CODE (expr),
327 : 265 : TREE_TYPE (expr),
328 : 265 : TREE_OPERAND (expr, 0));
329 : 56580199 : else if (TREE_CODE (expr) == BIT_FIELD_REF
330 : 56580199 : && CONSTANT_CLASS_P (TREE_OPERAND (expr, 0)))
331 : 4 : result = fold_ternary_loc (EXPR_LOCATION (expr),
332 : : TREE_CODE (expr),
333 : 4 : TREE_TYPE (expr),
334 : 4 : TREE_OPERAND (expr, 0),
335 : 4 : TREE_OPERAND (expr, 1),
336 : 4 : TREE_OPERAND (expr, 2));
337 : : else
338 : 56580195 : result = fold_const_aggregate_ref (expr);
339 : :
340 : 56580464 : if (result && is_gimple_min_invariant (result))
341 : : return result;
342 : :
343 : : return NULL_TREE;
344 : : }
345 : :
346 : : /* Return true if EXPR is an acceptable right-hand-side for a
347 : : GIMPLE assignment. We validate the entire tree, not just
348 : : the root node, thus catching expressions that embed complex
349 : : operands that are not permitted in GIMPLE. This function
350 : : is needed because the folding routines in fold-const.cc
351 : : may return such expressions in some cases, e.g., an array
352 : : access with an embedded index addition. It may make more
353 : : sense to have folding routines that are sensitive to the
354 : : constraints on GIMPLE operands, rather than abandoning any
355 : : any attempt to fold if the usual folding turns out to be too
356 : : aggressive. */
357 : :
358 : : bool
359 : 0 : valid_gimple_rhs_p (tree expr)
360 : : {
361 : 0 : enum tree_code code = TREE_CODE (expr);
362 : :
363 : 0 : switch (TREE_CODE_CLASS (code))
364 : : {
365 : 0 : case tcc_declaration:
366 : 0 : if (!is_gimple_variable (expr))
367 : : return false;
368 : : break;
369 : :
370 : : case tcc_constant:
371 : : /* All constants are ok. */
372 : : break;
373 : :
374 : 0 : case tcc_comparison:
375 : : /* GENERIC allows comparisons with non-boolean types, reject
376 : : those for GIMPLE. Let vector-typed comparisons pass - rules
377 : : for GENERIC and GIMPLE are the same here. */
378 : 0 : if (!(INTEGRAL_TYPE_P (TREE_TYPE (expr))
379 : 0 : && (TREE_CODE (TREE_TYPE (expr)) == BOOLEAN_TYPE
380 : 0 : || TYPE_PRECISION (TREE_TYPE (expr)) == 1))
381 : 0 : && ! VECTOR_TYPE_P (TREE_TYPE (expr)))
382 : : return false;
383 : :
384 : : /* Fallthru. */
385 : 0 : case tcc_binary:
386 : 0 : if (!is_gimple_val (TREE_OPERAND (expr, 0))
387 : 0 : || !is_gimple_val (TREE_OPERAND (expr, 1)))
388 : 0 : return false;
389 : : break;
390 : :
391 : 0 : case tcc_unary:
392 : 0 : if (!is_gimple_val (TREE_OPERAND (expr, 0)))
393 : : return false;
394 : : break;
395 : :
396 : 0 : case tcc_expression:
397 : 0 : switch (code)
398 : : {
399 : 0 : case ADDR_EXPR:
400 : 0 : {
401 : 0 : tree t;
402 : 0 : if (is_gimple_min_invariant (expr))
403 : : return true;
404 : 0 : t = TREE_OPERAND (expr, 0);
405 : 0 : while (handled_component_p (t))
406 : : {
407 : : /* ??? More checks needed, see the GIMPLE verifier. */
408 : 0 : if ((TREE_CODE (t) == ARRAY_REF
409 : 0 : || TREE_CODE (t) == ARRAY_RANGE_REF)
410 : 0 : && !is_gimple_val (TREE_OPERAND (t, 1)))
411 : : return false;
412 : 0 : t = TREE_OPERAND (t, 0);
413 : : }
414 : 0 : if (!is_gimple_id (t))
415 : : return false;
416 : : }
417 : : break;
418 : :
419 : 0 : default:
420 : 0 : if (get_gimple_rhs_class (code) == GIMPLE_TERNARY_RHS)
421 : : {
422 : 0 : if (!is_gimple_val (TREE_OPERAND (expr, 0))
423 : 0 : || !is_gimple_val (TREE_OPERAND (expr, 1))
424 : 0 : || !is_gimple_val (TREE_OPERAND (expr, 2)))
425 : 0 : return false;
426 : : break;
427 : : }
428 : : return false;
429 : : }
430 : : break;
431 : :
432 : : case tcc_vl_exp:
433 : : return false;
434 : :
435 : 0 : case tcc_exceptional:
436 : 0 : if (code == CONSTRUCTOR)
437 : : {
438 : : unsigned i;
439 : : tree elt;
440 : 0 : FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr), i, elt)
441 : 0 : if (!is_gimple_val (elt))
442 : : return false;
443 : : return true;
444 : : }
445 : 0 : if (code != SSA_NAME)
446 : : return false;
447 : : break;
448 : :
449 : 0 : case tcc_reference:
450 : 0 : if (code == BIT_FIELD_REF)
451 : 0 : return is_gimple_val (TREE_OPERAND (expr, 0));
452 : : return false;
453 : :
454 : : default:
455 : : return false;
456 : : }
457 : :
458 : : return true;
459 : : }
460 : :
461 : :
462 : : /* Attempt to fold an assignment statement pointed-to by SI. Returns a
463 : : replacement rhs for the statement or NULL_TREE if no simplification
464 : : could be made. It is assumed that the operands have been previously
465 : : folded. */
466 : :
467 : : static tree
468 : 228172723 : fold_gimple_assign (gimple_stmt_iterator *si)
469 : : {
470 : 228172723 : gimple *stmt = gsi_stmt (*si);
471 : 228172723 : enum tree_code subcode = gimple_assign_rhs_code (stmt);
472 : 228172723 : location_t loc = gimple_location (stmt);
473 : :
474 : 228172723 : tree result = NULL_TREE;
475 : :
476 : 228172723 : switch (get_gimple_rhs_class (subcode))
477 : : {
478 : 151991343 : case GIMPLE_SINGLE_RHS:
479 : 151991343 : {
480 : 151991343 : tree rhs = gimple_assign_rhs1 (stmt);
481 : :
482 : 151991343 : if (TREE_CLOBBER_P (rhs))
483 : : return NULL_TREE;
484 : :
485 : 138888169 : if (REFERENCE_CLASS_P (rhs))
486 : 55051656 : return maybe_fold_reference (rhs);
487 : :
488 : 83836513 : else if (TREE_CODE (rhs) == OBJ_TYPE_REF)
489 : : {
490 : 81718 : tree val = OBJ_TYPE_REF_EXPR (rhs);
491 : 81718 : if (is_gimple_min_invariant (val))
492 : : return val;
493 : 81718 : else if (flag_devirtualize && virtual_method_call_p (rhs))
494 : : {
495 : 81678 : bool final;
496 : 81678 : vec <cgraph_node *>targets
497 : 81678 : = possible_polymorphic_call_targets (rhs, stmt, &final);
498 : 81703 : if (final && targets.length () <= 1 && dbg_cnt (devirt))
499 : : {
500 : 25 : if (dump_enabled_p ())
501 : : {
502 : 0 : dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, stmt,
503 : : "resolving virtual function address "
504 : : "reference to function %s\n",
505 : 0 : targets.length () == 1
506 : 0 : ? targets[0]->name ()
507 : : : "NULL");
508 : : }
509 : 25 : if (targets.length () == 1)
510 : : {
511 : 16 : val = fold_convert (TREE_TYPE (val),
512 : : build_fold_addr_expr_loc
513 : : (loc, targets[0]->decl));
514 : 16 : STRIP_USELESS_TYPE_CONVERSION (val);
515 : : }
516 : : else
517 : : /* We cannot use __builtin_unreachable here because it
518 : : cannot have address taken. */
519 : 9 : val = build_int_cst (TREE_TYPE (val), 0);
520 : 25 : return val;
521 : : }
522 : : }
523 : : }
524 : :
525 : 83754795 : else if (TREE_CODE (rhs) == ADDR_EXPR)
526 : : {
527 : 13401857 : tree ref = TREE_OPERAND (rhs, 0);
528 : 13401857 : if (TREE_CODE (ref) == MEM_REF
529 : 13401857 : && integer_zerop (TREE_OPERAND (ref, 1)))
530 : : {
531 : 2322 : result = TREE_OPERAND (ref, 0);
532 : 2322 : if (!useless_type_conversion_p (TREE_TYPE (rhs),
533 : 2322 : TREE_TYPE (result)))
534 : 0 : result = build1 (NOP_EXPR, TREE_TYPE (rhs), result);
535 : 2322 : return result;
536 : : }
537 : : }
538 : :
539 : 70352938 : else if (TREE_CODE (rhs) == CONSTRUCTOR
540 : 70352938 : && TREE_CODE (TREE_TYPE (rhs)) == VECTOR_TYPE)
541 : : {
542 : : /* Fold a constant vector CONSTRUCTOR to VECTOR_CST. */
543 : : unsigned i;
544 : : tree val;
545 : :
546 : 474062 : FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), i, val)
547 : 469825 : if (! CONSTANT_CLASS_P (val))
548 : : return NULL_TREE;
549 : :
550 : 4237 : return build_vector_from_ctor (TREE_TYPE (rhs),
551 : 8474 : CONSTRUCTOR_ELTS (rhs));
552 : : }
553 : :
554 : 69962668 : else if (DECL_P (rhs)
555 : 69962668 : && is_gimple_reg_type (TREE_TYPE (rhs)))
556 : 11451660 : return get_symbol_constant_value (rhs);
557 : : }
558 : : break;
559 : :
560 : : case GIMPLE_UNARY_RHS:
561 : : break;
562 : :
563 : : case GIMPLE_BINARY_RHS:
564 : : break;
565 : :
566 : 377946 : case GIMPLE_TERNARY_RHS:
567 : 755892 : result = fold_ternary_loc (loc, subcode,
568 : 377946 : TREE_TYPE (gimple_assign_lhs (stmt)),
569 : : gimple_assign_rhs1 (stmt),
570 : : gimple_assign_rhs2 (stmt),
571 : : gimple_assign_rhs3 (stmt));
572 : :
573 : 377946 : if (result)
574 : : {
575 : 0 : STRIP_USELESS_TYPE_CONVERSION (result);
576 : 0 : if (valid_gimple_rhs_p (result))
577 : : return result;
578 : : }
579 : : break;
580 : :
581 : 0 : case GIMPLE_INVALID_RHS:
582 : 0 : gcc_unreachable ();
583 : : }
584 : :
585 : : return NULL_TREE;
586 : : }
587 : :
588 : :
589 : : /* Replace a statement at *SI_P with a sequence of statements in STMTS,
590 : : adjusting the replacement stmts location and virtual operands.
591 : : If the statement has a lhs the last stmt in the sequence is expected
592 : : to assign to that lhs. */
593 : :
594 : : void
595 : 118399 : gsi_replace_with_seq_vops (gimple_stmt_iterator *si_p, gimple_seq stmts)
596 : : {
597 : 118399 : gimple *stmt = gsi_stmt (*si_p);
598 : :
599 : 118399 : if (gimple_has_location (stmt))
600 : 98355 : annotate_all_with_location (stmts, gimple_location (stmt));
601 : :
602 : : /* First iterate over the replacement statements backward, assigning
603 : : virtual operands to their defining statements. */
604 : 118399 : gimple *laststore = NULL;
605 : 236798 : for (gimple_stmt_iterator i = gsi_last (stmts);
606 : 437895 : !gsi_end_p (i); gsi_prev (&i))
607 : : {
608 : 159748 : gimple *new_stmt = gsi_stmt (i);
609 : 159748 : if ((gimple_assign_single_p (new_stmt)
610 : 109197 : && !is_gimple_reg (gimple_assign_lhs (new_stmt)))
611 : 268486 : || (is_gimple_call (new_stmt)
612 : 13975 : && (gimple_call_flags (new_stmt)
613 : 13975 : & (ECF_NOVOPS | ECF_PURE | ECF_CONST | ECF_NORETURN)) == 0))
614 : : {
615 : 2605 : tree vdef;
616 : 2605 : if (!laststore)
617 : 2452 : vdef = gimple_vdef (stmt);
618 : : else
619 : 153 : vdef = make_ssa_name (gimple_vop (cfun), new_stmt);
620 : 2605 : gimple_set_vdef (new_stmt, vdef);
621 : 2605 : if (vdef && TREE_CODE (vdef) == SSA_NAME)
622 : 1634 : SSA_NAME_DEF_STMT (vdef) = new_stmt;
623 : : laststore = new_stmt;
624 : : }
625 : : }
626 : :
627 : : /* Second iterate over the statements forward, assigning virtual
628 : : operands to their uses. */
629 : 118399 : tree reaching_vuse = gimple_vuse (stmt);
630 : 118399 : for (gimple_stmt_iterator i = gsi_start (stmts);
631 : 278147 : !gsi_end_p (i); gsi_next (&i))
632 : : {
633 : 159748 : gimple *new_stmt = gsi_stmt (i);
634 : : /* If the new statement possibly has a VUSE, update it with exact SSA
635 : : name we know will reach this one. */
636 : 159748 : if (gimple_has_mem_ops (new_stmt))
637 : 159746 : gimple_set_vuse (new_stmt, reaching_vuse);
638 : 159748 : gimple_set_modified (new_stmt, true);
639 : 477603 : if (gimple_vdef (new_stmt))
640 : 159748 : reaching_vuse = gimple_vdef (new_stmt);
641 : : }
642 : :
643 : : /* If the new sequence does not do a store release the virtual
644 : : definition of the original statement. */
645 : 118399 : if (reaching_vuse
646 : 197914 : && reaching_vuse == gimple_vuse (stmt))
647 : : {
648 : 78034 : tree vdef = gimple_vdef (stmt);
649 : 78034 : if (vdef
650 : 1316 : && TREE_CODE (vdef) == SSA_NAME)
651 : : {
652 : 1261 : unlink_stmt_vdef (stmt);
653 : 1261 : release_ssa_name (vdef);
654 : : }
655 : : }
656 : :
657 : : /* Finally replace the original statement with the sequence. */
658 : 118399 : gsi_replace_with_seq (si_p, stmts, false);
659 : 118399 : }
660 : :
661 : : /* Helper function for update_gimple_call and
662 : : gimplify_and_update_call_from_tree. A GIMPLE_CALL STMT is being replaced
663 : : with GIMPLE_CALL NEW_STMT. */
664 : :
665 : : static void
666 : 2259 : finish_update_gimple_call (gimple_stmt_iterator *si_p, gimple *new_stmt,
667 : : gimple *stmt)
668 : : {
669 : 2259 : tree lhs = gimple_call_lhs (stmt);
670 : 2259 : gimple_call_set_lhs (new_stmt, lhs);
671 : 2259 : if (lhs && TREE_CODE (lhs) == SSA_NAME)
672 : 757 : SSA_NAME_DEF_STMT (lhs) = new_stmt;
673 : 2259 : gimple_move_vops (new_stmt, stmt);
674 : 2259 : gimple_set_location (new_stmt, gimple_location (stmt));
675 : 2259 : if (gimple_block (new_stmt) == NULL_TREE)
676 : 0 : gimple_set_block (new_stmt, gimple_block (stmt));
677 : 2259 : gsi_replace (si_p, new_stmt, false);
678 : 2259 : }
679 : :
680 : : /* Update a GIMPLE_CALL statement at iterator *SI_P to call to FN
681 : : with number of arguments NARGS, where the arguments in GIMPLE form
682 : : follow NARGS argument. */
683 : :
684 : : bool
685 : 2257 : update_gimple_call (gimple_stmt_iterator *si_p, tree fn, int nargs, ...)
686 : : {
687 : 2257 : va_list ap;
688 : 2257 : gcall *new_stmt, *stmt = as_a <gcall *> (gsi_stmt (*si_p));
689 : :
690 : 2257 : gcc_assert (is_gimple_call (stmt));
691 : 2257 : va_start (ap, nargs);
692 : 2257 : new_stmt = gimple_build_call_valist (fn, nargs, ap);
693 : 2257 : finish_update_gimple_call (si_p, new_stmt, stmt);
694 : 2257 : va_end (ap);
695 : 2257 : return true;
696 : : }
697 : :
698 : : /* Return true if EXPR is a CALL_EXPR suitable for representation
699 : : as a single GIMPLE_CALL statement. If the arguments require
700 : : further gimplification, return false. */
701 : :
702 : : static bool
703 : 50448 : valid_gimple_call_p (tree expr)
704 : : {
705 : 50448 : unsigned i, nargs;
706 : :
707 : 50448 : if (TREE_CODE (expr) != CALL_EXPR)
708 : : return false;
709 : :
710 : 2 : nargs = call_expr_nargs (expr);
711 : 4 : for (i = 0; i < nargs; i++)
712 : : {
713 : 2 : tree arg = CALL_EXPR_ARG (expr, i);
714 : 2 : if (is_gimple_reg_type (TREE_TYPE (arg)))
715 : : {
716 : 2 : if (!is_gimple_val (arg))
717 : : return false;
718 : : }
719 : : else
720 : 0 : if (!is_gimple_lvalue (arg))
721 : : return false;
722 : : }
723 : :
724 : : return true;
725 : : }
726 : :
727 : : /* Convert EXPR into a GIMPLE value suitable for substitution on the
728 : : RHS of an assignment. Insert the necessary statements before
729 : : iterator *SI_P. The statement at *SI_P, which must be a GIMPLE_CALL
730 : : is replaced. If the call is expected to produces a result, then it
731 : : is replaced by an assignment of the new RHS to the result variable.
732 : : If the result is to be ignored, then the call is replaced by a
733 : : GIMPLE_NOP. A proper VDEF chain is retained by making the first
734 : : VUSE and the last VDEF of the whole sequence be the same as the replaced
735 : : statement and using new SSA names for stores in between. */
736 : :
737 : : void
738 : 50448 : gimplify_and_update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
739 : : {
740 : 50448 : tree lhs;
741 : 50448 : gimple *stmt, *new_stmt;
742 : 50448 : gimple_stmt_iterator i;
743 : 50448 : gimple_seq stmts = NULL;
744 : :
745 : 50448 : stmt = gsi_stmt (*si_p);
746 : :
747 : 50448 : gcc_assert (is_gimple_call (stmt));
748 : :
749 : 50448 : if (valid_gimple_call_p (expr))
750 : : {
751 : : /* The call has simplified to another call. */
752 : 2 : tree fn = CALL_EXPR_FN (expr);
753 : 2 : unsigned i;
754 : 2 : unsigned nargs = call_expr_nargs (expr);
755 : 2 : vec<tree> args = vNULL;
756 : 2 : gcall *new_stmt;
757 : :
758 : 2 : if (nargs > 0)
759 : : {
760 : 2 : args.create (nargs);
761 : 2 : args.safe_grow_cleared (nargs, true);
762 : :
763 : 6 : for (i = 0; i < nargs; i++)
764 : 2 : args[i] = CALL_EXPR_ARG (expr, i);
765 : : }
766 : :
767 : 2 : new_stmt = gimple_build_call_vec (fn, args);
768 : 2 : finish_update_gimple_call (si_p, new_stmt, stmt);
769 : 2 : args.release ();
770 : 2 : return;
771 : : }
772 : :
773 : 50446 : lhs = gimple_call_lhs (stmt);
774 : 50446 : if (lhs == NULL_TREE)
775 : : {
776 : 11930 : push_gimplify_context (gimple_in_ssa_p (cfun));
777 : 5965 : gimplify_and_add (expr, &stmts);
778 : 5965 : pop_gimplify_context (NULL);
779 : :
780 : : /* We can end up with folding a memcpy of an empty class assignment
781 : : which gets optimized away by C++ gimplification. */
782 : 5965 : if (gimple_seq_empty_p (stmts))
783 : : {
784 : 5638 : if (gimple_in_ssa_p (cfun))
785 : : {
786 : 5638 : unlink_stmt_vdef (stmt);
787 : 5638 : release_defs (stmt);
788 : : }
789 : 5638 : gsi_replace (si_p, gimple_build_nop (), false);
790 : 5638 : return;
791 : : }
792 : : }
793 : : else
794 : : {
795 : 44481 : tree tmp = force_gimple_operand (expr, &stmts, false, NULL_TREE);
796 : 44481 : new_stmt = gimple_build_assign (lhs, tmp);
797 : 44481 : i = gsi_last (stmts);
798 : 44481 : gsi_insert_after_without_update (&i, new_stmt,
799 : : GSI_CONTINUE_LINKING);
800 : : }
801 : :
802 : 44808 : gsi_replace_with_seq_vops (si_p, stmts);
803 : : }
804 : :
805 : :
806 : : /* Replace the call at *GSI with the gimple value VAL. */
807 : :
808 : : void
809 : 67586 : replace_call_with_value (gimple_stmt_iterator *gsi, tree val)
810 : : {
811 : 67586 : gimple *stmt = gsi_stmt (*gsi);
812 : 67586 : tree lhs = gimple_call_lhs (stmt);
813 : 67586 : gimple *repl;
814 : 67586 : if (lhs)
815 : : {
816 : 64442 : if (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (val)))
817 : 2660 : val = fold_convert (TREE_TYPE (lhs), val);
818 : 64442 : repl = gimple_build_assign (lhs, val);
819 : : }
820 : : else
821 : 3144 : repl = gimple_build_nop ();
822 : 67586 : tree vdef = gimple_vdef (stmt);
823 : 67586 : if (vdef && TREE_CODE (vdef) == SSA_NAME)
824 : : {
825 : 3657 : unlink_stmt_vdef (stmt);
826 : 3657 : release_ssa_name (vdef);
827 : : }
828 : 67586 : gsi_replace (gsi, repl, false);
829 : 67586 : }
830 : :
831 : : /* Replace the call at *GSI with the new call REPL and fold that
832 : : again. */
833 : :
834 : : static void
835 : 39588 : replace_call_with_call_and_fold (gimple_stmt_iterator *gsi, gimple *repl)
836 : : {
837 : 39588 : gimple *stmt = gsi_stmt (*gsi);
838 : 39588 : gimple_call_set_lhs (repl, gimple_call_lhs (stmt));
839 : 39588 : gimple_set_location (repl, gimple_location (stmt));
840 : 39588 : gimple_move_vops (repl, stmt);
841 : 39588 : gsi_replace (gsi, repl, false);
842 : 39588 : fold_stmt (gsi);
843 : 39588 : }
844 : :
845 : : /* Return true if VAR is a VAR_DECL or a component thereof. */
846 : :
847 : : static bool
848 : 447500 : var_decl_component_p (tree var)
849 : : {
850 : 447500 : tree inner = var;
851 : 656224 : while (handled_component_p (inner))
852 : 208724 : inner = TREE_OPERAND (inner, 0);
853 : 447500 : return (DECL_P (inner)
854 : 447500 : || (TREE_CODE (inner) == MEM_REF
855 : 43410 : && TREE_CODE (TREE_OPERAND (inner, 0)) == ADDR_EXPR));
856 : : }
857 : :
858 : : /* Return TRUE if the SIZE argument, representing the size of an
859 : : object, is in a range of values of which exactly zero is valid. */
860 : :
861 : : static bool
862 : 887673 : size_must_be_zero_p (tree size)
863 : : {
864 : 887673 : if (integer_zerop (size))
865 : : return true;
866 : :
867 : 885298 : if (TREE_CODE (size) != SSA_NAME || !INTEGRAL_TYPE_P (TREE_TYPE (size)))
868 : : return false;
869 : :
870 : 482458 : tree type = TREE_TYPE (size);
871 : 482458 : int prec = TYPE_PRECISION (type);
872 : :
873 : : /* Compute the value of SSIZE_MAX, the largest positive value that
874 : : can be stored in ssize_t, the signed counterpart of size_t. */
875 : 482458 : wide_int ssize_max = wi::lshift (wi::one (prec), prec - 1) - 1;
876 : 482458 : wide_int zero = wi::zero (TYPE_PRECISION (type));
877 : 482458 : value_range valid_range (type, zero, ssize_max);
878 : 482458 : value_range vr;
879 : 964916 : get_range_query (cfun)->range_of_expr (vr, size);
880 : :
881 : 482458 : if (vr.undefined_p ())
882 : 48 : vr.set_varying (TREE_TYPE (size));
883 : 482458 : vr.intersect (valid_range);
884 : 482458 : return vr.zero_p ();
885 : 482458 : }
886 : :
887 : : /* Fold function call to builtin mem{{,p}cpy,move}. Try to detect and
888 : : diagnose (otherwise undefined) overlapping copies without preventing
889 : : folding. When folded, GCC guarantees that overlapping memcpy has
890 : : the same semantics as memmove. Call to the library memcpy need not
891 : : provide the same guarantee. Return false if no simplification can
892 : : be made. */
893 : :
894 : : static bool
895 : 887673 : gimple_fold_builtin_memory_op (gimple_stmt_iterator *gsi,
896 : : tree dest, tree src, enum built_in_function code)
897 : : {
898 : 887673 : gimple *stmt = gsi_stmt (*gsi);
899 : 887673 : tree lhs = gimple_call_lhs (stmt);
900 : 887673 : tree len = gimple_call_arg (stmt, 2);
901 : 887673 : location_t loc = gimple_location (stmt);
902 : :
903 : : /* If the LEN parameter is a constant zero or in range where
904 : : the only valid value is zero, return DEST. */
905 : 887673 : if (size_must_be_zero_p (len))
906 : : {
907 : 2406 : gimple *repl;
908 : 2406 : if (gimple_call_lhs (stmt))
909 : 57 : repl = gimple_build_assign (gimple_call_lhs (stmt), dest);
910 : : else
911 : 2349 : repl = gimple_build_nop ();
912 : 2406 : tree vdef = gimple_vdef (stmt);
913 : 2406 : if (vdef && TREE_CODE (vdef) == SSA_NAME)
914 : : {
915 : 390 : unlink_stmt_vdef (stmt);
916 : 390 : release_ssa_name (vdef);
917 : : }
918 : 2406 : gsi_replace (gsi, repl, false);
919 : 2406 : return true;
920 : : }
921 : :
922 : : /* If SRC and DEST are the same (and not volatile), return
923 : : DEST{,+LEN,+LEN-1}. */
924 : 885267 : if (operand_equal_p (src, dest, 0))
925 : : {
926 : : /* Avoid diagnosing exact overlap in calls to __builtin_memcpy.
927 : : It's safe and may even be emitted by GCC itself (see bug
928 : : 32667). */
929 : 67 : unlink_stmt_vdef (stmt);
930 : 134 : if (gimple_vdef (stmt) && TREE_CODE (gimple_vdef (stmt)) == SSA_NAME)
931 : 27 : release_ssa_name (gimple_vdef (stmt));
932 : 67 : if (!lhs)
933 : : {
934 : 46 : gsi_replace (gsi, gimple_build_nop (), false);
935 : 46 : return true;
936 : : }
937 : 21 : goto done;
938 : : }
939 : : else
940 : : {
941 : : /* We cannot (easily) change the type of the copy if it is a storage
942 : : order barrier, i.e. is equivalent to a VIEW_CONVERT_EXPR that can
943 : : modify the storage order of objects (see storage_order_barrier_p). */
944 : 885200 : tree srctype
945 : 896537 : = POINTER_TYPE_P (TREE_TYPE (src))
946 : 896537 : ? TREE_TYPE (TREE_TYPE (src)) : NULL_TREE;
947 : 885200 : tree desttype
948 : 904497 : = POINTER_TYPE_P (TREE_TYPE (dest))
949 : 904497 : ? TREE_TYPE (TREE_TYPE (dest)) : NULL_TREE;
950 : 885200 : tree destvar, srcvar, srcoff;
951 : 885200 : unsigned int src_align, dest_align;
952 : 885200 : unsigned HOST_WIDE_INT tmp_len;
953 : 885200 : const char *tmp_str;
954 : :
955 : : /* Build accesses at offset zero with a ref-all character type. */
956 : 885200 : tree off0
957 : 885200 : = build_int_cst (build_pointer_type_for_mode (char_type_node,
958 : 885200 : ptr_mode, true), 0);
959 : :
960 : : /* If we can perform the copy efficiently with first doing all loads
961 : : and then all stores inline it that way. Currently efficiently
962 : : means that we can load all the memory into a single integer
963 : : register which is what MOVE_MAX gives us. */
964 : 885200 : src_align = get_pointer_alignment (src);
965 : 885200 : dest_align = get_pointer_alignment (dest);
966 : 885200 : if (tree_fits_uhwi_p (len)
967 : 393838 : && compare_tree_int (len, MOVE_MAX) <= 0
968 : : /* FIXME: Don't transform copies from strings with known length.
969 : : Until GCC 9 this prevented a case in gcc.dg/strlenopt-8.c
970 : : from being handled, and the case was XFAILed for that reason.
971 : : Now that it is handled and the XFAIL removed, as soon as other
972 : : strlenopt tests that rely on it for passing are adjusted, this
973 : : hack can be removed. */
974 : 298826 : && !c_strlen (src, 1)
975 : 176509 : && !((tmp_str = getbyterep (src, &tmp_len)) != NULL
976 : 79131 : && memchr (tmp_str, 0, tmp_len) == NULL)
977 : 109027 : && !(srctype
978 : 109027 : && AGGREGATE_TYPE_P (srctype)
979 : 53655 : && TYPE_REVERSE_STORAGE_ORDER (srctype))
980 : 994078 : && !(desttype
981 : 108878 : && AGGREGATE_TYPE_P (desttype)
982 : 62429 : && TYPE_REVERSE_STORAGE_ORDER (desttype)))
983 : : {
984 : 108841 : unsigned ilen = tree_to_uhwi (len);
985 : 108841 : if (pow2p_hwi (ilen))
986 : : {
987 : : /* Detect out-of-bounds accesses without issuing warnings.
988 : : Avoid folding out-of-bounds copies but to avoid false
989 : : positives for unreachable code defer warning until after
990 : : DCE has worked its magic.
991 : : -Wrestrict is still diagnosed. */
992 : 19750 : if (int warning = check_bounds_or_overlap (as_a <gcall *>(stmt),
993 : : dest, src, len, len,
994 : 19750 : false, false))
995 : 1135 : if (warning != OPT_Wrestrict)
996 : 17503 : return false;
997 : :
998 : 18685 : scalar_int_mode imode;
999 : 18685 : machine_mode mode;
1000 : 18685 : if (int_mode_for_size (ilen * BITS_PER_UNIT, 0).exists (&imode)
1001 : 18685 : && bitwise_mode_for_size (ilen
1002 : 18685 : * BITS_PER_UNIT).exists (&mode)
1003 : 37370 : && known_eq (GET_MODE_BITSIZE (mode), ilen * BITS_PER_UNIT)
1004 : : /* If the destination pointer is not aligned we must be able
1005 : : to emit an unaligned store. */
1006 : 18685 : && (dest_align >= GET_MODE_ALIGNMENT (mode)
1007 : 10852 : || !targetm.slow_unaligned_access (mode, dest_align)
1008 : 0 : || (optab_handler (movmisalign_optab, mode)
1009 : : != CODE_FOR_nothing)))
1010 : : {
1011 : 18685 : tree type = bitwise_type_for_mode (mode);
1012 : 18685 : tree srctype = type;
1013 : 18685 : tree desttype = type;
1014 : 18685 : if (src_align < GET_MODE_ALIGNMENT (mode))
1015 : 10627 : srctype = build_aligned_type (type, src_align);
1016 : 18685 : tree srcmem = fold_build2 (MEM_REF, srctype, src, off0);
1017 : 18685 : tree tem = fold_const_aggregate_ref (srcmem);
1018 : 18685 : if (tem)
1019 : : srcmem = tem;
1020 : 17952 : else if (src_align < GET_MODE_ALIGNMENT (mode)
1021 : 10400 : && targetm.slow_unaligned_access (mode, src_align)
1022 : 17952 : && (optab_handler (movmisalign_optab, mode)
1023 : : == CODE_FOR_nothing))
1024 : : srcmem = NULL_TREE;
1025 : 17952 : if (srcmem)
1026 : : {
1027 : 18685 : gimple *new_stmt;
1028 : 18685 : if (is_gimple_reg_type (TREE_TYPE (srcmem)))
1029 : : {
1030 : 18685 : new_stmt = gimple_build_assign (NULL_TREE, srcmem);
1031 : 18685 : srcmem
1032 : 18685 : = create_tmp_reg_or_ssa_name (TREE_TYPE (srcmem),
1033 : : new_stmt);
1034 : 18685 : gimple_assign_set_lhs (new_stmt, srcmem);
1035 : 37370 : gimple_set_vuse (new_stmt, gimple_vuse (stmt));
1036 : 18685 : gimple_set_location (new_stmt, loc);
1037 : 18685 : gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT);
1038 : : }
1039 : 18685 : if (dest_align < GET_MODE_ALIGNMENT (mode))
1040 : 10852 : desttype = build_aligned_type (type, dest_align);
1041 : 18685 : new_stmt
1042 : 18685 : = gimple_build_assign (fold_build2 (MEM_REF, desttype,
1043 : : dest, off0),
1044 : : srcmem);
1045 : 18685 : gimple_move_vops (new_stmt, stmt);
1046 : 18685 : if (!lhs)
1047 : : {
1048 : 16438 : gsi_replace (gsi, new_stmt, false);
1049 : 16438 : return true;
1050 : : }
1051 : 2247 : gimple_set_location (new_stmt, loc);
1052 : 2247 : gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT);
1053 : 2247 : goto done;
1054 : : }
1055 : : }
1056 : : }
1057 : : }
1058 : :
1059 : 865450 : if (code == BUILT_IN_MEMMOVE)
1060 : : {
1061 : : /* Both DEST and SRC must be pointer types.
1062 : : ??? This is what old code did. Is the testing for pointer types
1063 : : really mandatory?
1064 : :
1065 : : If either SRC is readonly or length is 1, we can use memcpy. */
1066 : 182708 : if (!dest_align || !src_align)
1067 : : return false;
1068 : 182708 : if (readonly_data_expr (src)
1069 : 182708 : || (tree_fits_uhwi_p (len)
1070 : 28653 : && (MIN (src_align, dest_align) / BITS_PER_UNIT
1071 : 28653 : >= tree_to_uhwi (len))))
1072 : : {
1073 : 831112 : tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
1074 : 18630 : if (!fn)
1075 : : return false;
1076 : 18630 : gimple_call_set_fndecl (stmt, fn);
1077 : 18630 : gimple_call_set_arg (stmt, 0, dest);
1078 : 18630 : gimple_call_set_arg (stmt, 1, src);
1079 : 18630 : fold_stmt (gsi);
1080 : 18630 : return true;
1081 : : }
1082 : :
1083 : : /* If *src and *dest can't overlap, optimize into memcpy as well. */
1084 : 164078 : if (TREE_CODE (src) == ADDR_EXPR
1085 : 5038 : && TREE_CODE (dest) == ADDR_EXPR)
1086 : : {
1087 : 1745 : tree src_base, dest_base, fn;
1088 : 1745 : poly_int64 src_offset = 0, dest_offset = 0;
1089 : 1745 : poly_uint64 maxsize;
1090 : :
1091 : 1745 : srcvar = TREE_OPERAND (src, 0);
1092 : 1745 : src_base = get_addr_base_and_unit_offset (srcvar, &src_offset);
1093 : 1745 : if (src_base == NULL)
1094 : 0 : src_base = srcvar;
1095 : 1745 : destvar = TREE_OPERAND (dest, 0);
1096 : 1745 : dest_base = get_addr_base_and_unit_offset (destvar,
1097 : : &dest_offset);
1098 : 1745 : if (dest_base == NULL)
1099 : 0 : dest_base = destvar;
1100 : 1745 : if (!poly_int_tree_p (len, &maxsize))
1101 : 158 : maxsize = -1;
1102 : 1745 : if (SSA_VAR_P (src_base)
1103 : 1735 : && SSA_VAR_P (dest_base))
1104 : : {
1105 : 1735 : if (operand_equal_p (src_base, dest_base, 0)
1106 : 1735 : && ranges_maybe_overlap_p (src_offset, maxsize,
1107 : : dest_offset, maxsize))
1108 : : return false;
1109 : : }
1110 : 10 : else if (TREE_CODE (src_base) == MEM_REF
1111 : 0 : && TREE_CODE (dest_base) == MEM_REF)
1112 : : {
1113 : 0 : if (! operand_equal_p (TREE_OPERAND (src_base, 0),
1114 : 0 : TREE_OPERAND (dest_base, 0), 0))
1115 : 0 : return false;
1116 : 0 : poly_offset_int full_src_offset
1117 : 0 : = mem_ref_offset (src_base) + src_offset;
1118 : 0 : poly_offset_int full_dest_offset
1119 : 0 : = mem_ref_offset (dest_base) + dest_offset;
1120 : 0 : if (ranges_maybe_overlap_p (full_src_offset, maxsize,
1121 : : full_dest_offset, maxsize))
1122 : : return false;
1123 : 0 : }
1124 : : else
1125 : : return false;
1126 : :
1127 : 1745 : fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
1128 : 1256 : if (!fn)
1129 : : return false;
1130 : 1256 : gimple_call_set_fndecl (stmt, fn);
1131 : 1256 : gimple_call_set_arg (stmt, 0, dest);
1132 : 1256 : gimple_call_set_arg (stmt, 1, src);
1133 : 1256 : fold_stmt (gsi);
1134 : 1256 : return true;
1135 : : }
1136 : :
1137 : : /* If the destination and source do not alias optimize into
1138 : : memcpy as well. */
1139 : 162333 : if ((is_gimple_min_invariant (dest)
1140 : 159217 : || TREE_CODE (dest) == SSA_NAME)
1141 : 304669 : && (is_gimple_min_invariant (src)
1142 : 142183 : || TREE_CODE (src) == SSA_NAME))
1143 : : {
1144 : 144377 : ao_ref destr, srcr;
1145 : 144377 : ao_ref_init_from_ptr_and_size (&destr, dest, len);
1146 : 144377 : ao_ref_init_from_ptr_and_size (&srcr, src, len);
1147 : 144377 : if (!refs_may_alias_p_1 (&destr, &srcr, false))
1148 : : {
1149 : 10584 : tree fn;
1150 : 10584 : fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
1151 : 10584 : if (!fn)
1152 : 10584 : return false;
1153 : 10584 : gimple_call_set_fndecl (stmt, fn);
1154 : 10584 : gimple_call_set_arg (stmt, 0, dest);
1155 : 10584 : gimple_call_set_arg (stmt, 1, src);
1156 : 10584 : fold_stmt (gsi);
1157 : 10584 : return true;
1158 : : }
1159 : : }
1160 : :
1161 : 151749 : return false;
1162 : : }
1163 : :
1164 : 682742 : if (!tree_fits_shwi_p (len))
1165 : : return false;
1166 : 329600 : if (!srctype
1167 : 329600 : || (AGGREGATE_TYPE_P (srctype)
1168 : 210471 : && TYPE_REVERSE_STORAGE_ORDER (srctype)))
1169 : : return false;
1170 : 329451 : if (!desttype
1171 : 329451 : || (AGGREGATE_TYPE_P (desttype)
1172 : 202155 : && TYPE_REVERSE_STORAGE_ORDER (desttype)))
1173 : : return false;
1174 : : /* In the following try to find a type that is most natural to be
1175 : : used for the memcpy source and destination and that allows
1176 : : the most optimization when memcpy is turned into a plain assignment
1177 : : using that type. In theory we could always use a char[len] type
1178 : : but that only gains us that the destination and source possibly
1179 : : no longer will have their address taken. */
1180 : 329414 : if (TREE_CODE (srctype) == ARRAY_TYPE
1181 : 329414 : && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
1182 : 140137 : srctype = TREE_TYPE (srctype);
1183 : 329414 : if (TREE_CODE (desttype) == ARRAY_TYPE
1184 : 329414 : && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
1185 : 121913 : desttype = TREE_TYPE (desttype);
1186 : 329414 : if (TREE_ADDRESSABLE (srctype)
1187 : 329398 : || TREE_ADDRESSABLE (desttype))
1188 : : return false;
1189 : :
1190 : : /* Make sure we are not copying using a floating-point mode or
1191 : : a type whose size possibly does not match its precision. */
1192 : 658119 : if (FLOAT_MODE_P (TYPE_MODE (desttype))
1193 : 328464 : || TREE_CODE (desttype) == BOOLEAN_TYPE
1194 : 657822 : || TREE_CODE (desttype) == ENUMERAL_TYPE)
1195 : 942 : desttype = bitwise_type_for_mode (TYPE_MODE (desttype));
1196 : 658277 : if (FLOAT_MODE_P (TYPE_MODE (srctype))
1197 : 328767 : || TREE_CODE (srctype) == BOOLEAN_TYPE
1198 : 658131 : || TREE_CODE (srctype) == ENUMERAL_TYPE)
1199 : 633 : srctype = bitwise_type_for_mode (TYPE_MODE (srctype));
1200 : 329382 : if (!srctype)
1201 : 137 : srctype = desttype;
1202 : 329382 : if (!desttype)
1203 : 0 : desttype = srctype;
1204 : 329382 : if (!srctype)
1205 : : return false;
1206 : :
1207 : 329382 : src_align = get_pointer_alignment (src);
1208 : 329382 : dest_align = get_pointer_alignment (dest);
1209 : :
1210 : : /* Choose between src and destination type for the access based
1211 : : on alignment, whether the access constitutes a register access
1212 : : and whether it may actually expose a declaration for SSA rewrite
1213 : : or SRA decomposition. Also try to expose a string constant, we
1214 : : might be able to concatenate several of them later into a single
1215 : : string store. */
1216 : 329382 : destvar = NULL_TREE;
1217 : 329382 : srcvar = NULL_TREE;
1218 : 329382 : if (TREE_CODE (dest) == ADDR_EXPR
1219 : 133134 : && var_decl_component_p (TREE_OPERAND (dest, 0))
1220 : 133129 : && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len)
1221 : 24062 : && dest_align >= TYPE_ALIGN (desttype)
1222 : 353444 : && (is_gimple_reg_type (desttype)
1223 : 23464 : || src_align >= TYPE_ALIGN (desttype)))
1224 : 19454 : destvar = fold_build2 (MEM_REF, desttype, dest, off0);
1225 : 309928 : else if (TREE_CODE (src) == ADDR_EXPR
1226 : 248064 : && var_decl_component_p (TREE_OPERAND (src, 0))
1227 : 45650 : && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len)
1228 : 7552 : && src_align >= TYPE_ALIGN (srctype)
1229 : 317462 : && (is_gimple_reg_type (srctype)
1230 : 7342 : || dest_align >= TYPE_ALIGN (srctype)))
1231 : 2672 : srcvar = fold_build2 (MEM_REF, srctype, src, off0);
1232 : : /* FIXME: Don't transform copies from strings with known original length.
1233 : : As soon as strlenopt tests that rely on it for passing are adjusted,
1234 : : this hack can be removed. */
1235 : 307256 : else if (gimple_call_alloca_for_var_p (stmt)
1236 : 4 : && (srcvar = string_constant (src, &srcoff, NULL, NULL))
1237 : 4 : && integer_zerop (srcoff)
1238 : 4 : && tree_int_cst_equal (TYPE_SIZE_UNIT (TREE_TYPE (srcvar)), len)
1239 : 307260 : && dest_align >= TYPE_ALIGN (TREE_TYPE (srcvar)))
1240 : 4 : srctype = TREE_TYPE (srcvar);
1241 : : else
1242 : 307252 : return false;
1243 : :
1244 : : /* Now that we chose an access type express the other side in
1245 : : terms of it if the target allows that with respect to alignment
1246 : : constraints. */
1247 : 22130 : if (srcvar == NULL_TREE)
1248 : : {
1249 : 19454 : if (src_align >= TYPE_ALIGN (desttype))
1250 : 19438 : srcvar = fold_build2 (MEM_REF, desttype, src, off0);
1251 : : else
1252 : : {
1253 : 16 : enum machine_mode mode = TYPE_MODE (desttype);
1254 : 16 : if ((mode == BLKmode && STRICT_ALIGNMENT)
1255 : 16 : || (targetm.slow_unaligned_access (mode, src_align)
1256 : 16 : && (optab_handler (movmisalign_optab, mode)
1257 : : == CODE_FOR_nothing)))
1258 : : return false;
1259 : 16 : srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
1260 : : src_align);
1261 : 16 : srcvar = fold_build2 (MEM_REF, srctype, src, off0);
1262 : : }
1263 : : }
1264 : 2676 : else if (destvar == NULL_TREE)
1265 : : {
1266 : 2676 : if (dest_align >= TYPE_ALIGN (srctype))
1267 : 2676 : destvar = fold_build2 (MEM_REF, srctype, dest, off0);
1268 : : else
1269 : : {
1270 : 0 : enum machine_mode mode = TYPE_MODE (srctype);
1271 : 0 : if ((mode == BLKmode && STRICT_ALIGNMENT)
1272 : 0 : || (targetm.slow_unaligned_access (mode, dest_align)
1273 : 0 : && (optab_handler (movmisalign_optab, mode)
1274 : : == CODE_FOR_nothing)))
1275 : : return false;
1276 : 0 : desttype = build_aligned_type (TYPE_MAIN_VARIANT (srctype),
1277 : : dest_align);
1278 : 0 : destvar = fold_build2 (MEM_REF, desttype, dest, off0);
1279 : : }
1280 : : }
1281 : :
1282 : : /* Same as above, detect out-of-bounds accesses without issuing
1283 : : warnings. Avoid folding out-of-bounds copies but to avoid
1284 : : false positives for unreachable code defer warning until
1285 : : after DCE has worked its magic.
1286 : : -Wrestrict is still diagnosed. */
1287 : 22130 : if (int warning = check_bounds_or_overlap (as_a <gcall *>(stmt),
1288 : : dest, src, len, len,
1289 : 22130 : false, false))
1290 : 131 : if (warning != OPT_Wrestrict)
1291 : : return false;
1292 : :
1293 : 22009 : gimple *new_stmt;
1294 : 22009 : if (is_gimple_reg_type (TREE_TYPE (srcvar)))
1295 : : {
1296 : 727 : tree tem = fold_const_aggregate_ref (srcvar);
1297 : 727 : if (tem)
1298 : 705 : srcvar = tem;
1299 : 727 : if (! is_gimple_min_invariant (srcvar))
1300 : : {
1301 : 22 : new_stmt = gimple_build_assign (NULL_TREE, srcvar);
1302 : 22 : srcvar = create_tmp_reg_or_ssa_name (TREE_TYPE (srcvar),
1303 : : new_stmt);
1304 : 22 : gimple_assign_set_lhs (new_stmt, srcvar);
1305 : 44 : gimple_set_vuse (new_stmt, gimple_vuse (stmt));
1306 : 22 : gimple_set_location (new_stmt, loc);
1307 : 22 : gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT);
1308 : : }
1309 : 727 : new_stmt = gimple_build_assign (destvar, srcvar);
1310 : 727 : goto set_vop_and_replace;
1311 : : }
1312 : :
1313 : : /* We get an aggregate copy. If the source is a STRING_CST, then
1314 : : directly use its type to perform the copy. */
1315 : 21282 : if (TREE_CODE (srcvar) == STRING_CST)
1316 : : desttype = srctype;
1317 : :
1318 : : /* Or else, use an unsigned char[] type to perform the copy in order
1319 : : to preserve padding and to avoid any issues with TREE_ADDRESSABLE
1320 : : types or float modes behavior on copying. */
1321 : : else
1322 : : {
1323 : 42556 : desttype = build_array_type_nelts (unsigned_char_type_node,
1324 : 21278 : tree_to_uhwi (len));
1325 : 21278 : srctype = desttype;
1326 : 21278 : if (src_align > TYPE_ALIGN (srctype))
1327 : 12499 : srctype = build_aligned_type (srctype, src_align);
1328 : 21278 : srcvar = fold_build2 (MEM_REF, srctype, src, off0);
1329 : : }
1330 : :
1331 : 21282 : if (dest_align > TYPE_ALIGN (desttype))
1332 : 12668 : desttype = build_aligned_type (desttype, dest_align);
1333 : 21282 : destvar = fold_build2 (MEM_REF, desttype, dest, off0);
1334 : 21282 : new_stmt = gimple_build_assign (destvar, srcvar);
1335 : :
1336 : 22009 : set_vop_and_replace:
1337 : 22009 : gimple_move_vops (new_stmt, stmt);
1338 : 22009 : if (!lhs)
1339 : : {
1340 : 21529 : gsi_replace (gsi, new_stmt, false);
1341 : 21529 : return true;
1342 : : }
1343 : 480 : gimple_set_location (new_stmt, loc);
1344 : 480 : gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT);
1345 : : }
1346 : :
1347 : 2748 : done:
1348 : 2748 : gimple_seq stmts = NULL;
1349 : 2748 : if (code == BUILT_IN_MEMCPY || code == BUILT_IN_MEMMOVE)
1350 : 2748 : len = NULL_TREE;
1351 : 197 : else if (code == BUILT_IN_MEMPCPY)
1352 : : {
1353 : 197 : len = gimple_convert_to_ptrofftype (&stmts, loc, len);
1354 : 197 : dest = gimple_build (&stmts, loc, POINTER_PLUS_EXPR,
1355 : 197 : TREE_TYPE (dest), dest, len);
1356 : : }
1357 : : else
1358 : 0 : gcc_unreachable ();
1359 : :
1360 : 2748 : gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT);
1361 : 2748 : gimple *repl = gimple_build_assign (lhs, dest);
1362 : 2748 : gsi_replace (gsi, repl, false);
1363 : 2748 : return true;
1364 : : }
1365 : :
1366 : : /* Transform a call to built-in bcmp(a, b, len) at *GSI into one
1367 : : to built-in memcmp (a, b, len). */
1368 : :
1369 : : static bool
1370 : 142 : gimple_fold_builtin_bcmp (gimple_stmt_iterator *gsi)
1371 : : {
1372 : 142 : tree fn = builtin_decl_implicit (BUILT_IN_MEMCMP);
1373 : :
1374 : 142 : if (!fn)
1375 : : return false;
1376 : :
1377 : : /* Transform bcmp (a, b, len) into memcmp (a, b, len). */
1378 : :
1379 : 142 : gimple *stmt = gsi_stmt (*gsi);
1380 : 142 : tree a = gimple_call_arg (stmt, 0);
1381 : 142 : tree b = gimple_call_arg (stmt, 1);
1382 : 142 : tree len = gimple_call_arg (stmt, 2);
1383 : :
1384 : 142 : gimple *repl = gimple_build_call (fn, 3, a, b, len);
1385 : 142 : replace_call_with_call_and_fold (gsi, repl);
1386 : :
1387 : 142 : return true;
1388 : : }
1389 : :
1390 : : /* Transform a call to built-in bcopy (src, dest, len) at *GSI into one
1391 : : to built-in memmove (dest, src, len). */
1392 : :
1393 : : static bool
1394 : 387 : gimple_fold_builtin_bcopy (gimple_stmt_iterator *gsi)
1395 : : {
1396 : 387 : tree fn = builtin_decl_implicit (BUILT_IN_MEMMOVE);
1397 : :
1398 : 387 : if (!fn)
1399 : : return false;
1400 : :
1401 : : /* bcopy has been removed from POSIX in Issue 7 but Issue 6 specifies
1402 : : it's quivalent to memmove (not memcpy). Transform bcopy (src, dest,
1403 : : len) into memmove (dest, src, len). */
1404 : :
1405 : 387 : gimple *stmt = gsi_stmt (*gsi);
1406 : 387 : tree src = gimple_call_arg (stmt, 0);
1407 : 387 : tree dest = gimple_call_arg (stmt, 1);
1408 : 387 : tree len = gimple_call_arg (stmt, 2);
1409 : :
1410 : 387 : gimple *repl = gimple_build_call (fn, 3, dest, src, len);
1411 : 387 : gimple_call_set_fntype (as_a <gcall *> (stmt), TREE_TYPE (fn));
1412 : 387 : replace_call_with_call_and_fold (gsi, repl);
1413 : :
1414 : 387 : return true;
1415 : : }
1416 : :
1417 : : /* Transform a call to built-in bzero (dest, len) at *GSI into one
1418 : : to built-in memset (dest, 0, len). */
1419 : :
1420 : : static bool
1421 : 283 : gimple_fold_builtin_bzero (gimple_stmt_iterator *gsi)
1422 : : {
1423 : 283 : tree fn = builtin_decl_implicit (BUILT_IN_MEMSET);
1424 : :
1425 : 283 : if (!fn)
1426 : : return false;
1427 : :
1428 : : /* Transform bzero (dest, len) into memset (dest, 0, len). */
1429 : :
1430 : 283 : gimple *stmt = gsi_stmt (*gsi);
1431 : 283 : tree dest = gimple_call_arg (stmt, 0);
1432 : 283 : tree len = gimple_call_arg (stmt, 1);
1433 : :
1434 : 283 : gimple_seq seq = NULL;
1435 : 283 : gimple *repl = gimple_build_call (fn, 3, dest, integer_zero_node, len);
1436 : 283 : gimple_seq_add_stmt_without_update (&seq, repl);
1437 : 283 : gsi_replace_with_seq_vops (gsi, seq);
1438 : 283 : fold_stmt (gsi);
1439 : :
1440 : 283 : return true;
1441 : : }
1442 : :
1443 : : /* Fold function call to builtin memset or bzero at *GSI setting the
1444 : : memory of size LEN to VAL. Return whether a simplification was made. */
1445 : :
1446 : : static bool
1447 : 316990 : gimple_fold_builtin_memset (gimple_stmt_iterator *gsi, tree c, tree len)
1448 : : {
1449 : 316990 : gimple *stmt = gsi_stmt (*gsi);
1450 : 316990 : tree etype;
1451 : 316990 : unsigned HOST_WIDE_INT length, cval;
1452 : :
1453 : : /* If the LEN parameter is zero, return DEST. */
1454 : 316990 : if (integer_zerop (len))
1455 : : {
1456 : 802 : replace_call_with_value (gsi, gimple_call_arg (stmt, 0));
1457 : 802 : return true;
1458 : : }
1459 : :
1460 : 316188 : if (! tree_fits_uhwi_p (len))
1461 : : return false;
1462 : :
1463 : 209016 : if (TREE_CODE (c) != INTEGER_CST)
1464 : : return false;
1465 : :
1466 : 202649 : tree dest = gimple_call_arg (stmt, 0);
1467 : 202649 : tree var = dest;
1468 : 202649 : if (TREE_CODE (var) != ADDR_EXPR)
1469 : : return false;
1470 : :
1471 : 166081 : var = TREE_OPERAND (var, 0);
1472 : 166081 : if (TREE_THIS_VOLATILE (var))
1473 : : return false;
1474 : :
1475 : 166037 : etype = TREE_TYPE (var);
1476 : 166037 : if (TREE_CODE (etype) == ARRAY_TYPE)
1477 : 89200 : etype = TREE_TYPE (etype);
1478 : :
1479 : 166037 : if ((!INTEGRAL_TYPE_P (etype)
1480 : 100146 : && !POINTER_TYPE_P (etype))
1481 : 66330 : || TREE_CODE (etype) == BITINT_TYPE)
1482 : : return NULL_TREE;
1483 : :
1484 : 66302 : if (! var_decl_component_p (var))
1485 : : return NULL_TREE;
1486 : :
1487 : 66302 : length = tree_to_uhwi (len);
1488 : 66302 : if (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (etype)) != length
1489 : 1838 : || (GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (etype))
1490 : 3676 : != GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (etype)))
1491 : 68140 : || get_pointer_alignment (dest) / BITS_PER_UNIT < length)
1492 : 64464 : return NULL_TREE;
1493 : :
1494 : 1838 : if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
1495 : : return NULL_TREE;
1496 : :
1497 : 1838 : if (!type_has_mode_precision_p (etype))
1498 : 7 : etype = lang_hooks.types.type_for_mode (SCALAR_INT_TYPE_MODE (etype),
1499 : 7 : TYPE_UNSIGNED (etype));
1500 : :
1501 : 1838 : if (integer_zerop (c))
1502 : : cval = 0;
1503 : : else
1504 : : {
1505 : 326 : if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
1506 : : return NULL_TREE;
1507 : :
1508 : 326 : cval = TREE_INT_CST_LOW (c);
1509 : 326 : cval &= 0xff;
1510 : 326 : cval |= cval << 8;
1511 : 326 : cval |= cval << 16;
1512 : 326 : cval |= (cval << 31) << 1;
1513 : : }
1514 : :
1515 : 1838 : var = fold_build2 (MEM_REF, etype, dest, build_int_cst (ptr_type_node, 0));
1516 : 1838 : gimple *store = gimple_build_assign (var, build_int_cst_type (etype, cval));
1517 : 1838 : gimple_move_vops (store, stmt);
1518 : 1838 : gimple_set_location (store, gimple_location (stmt));
1519 : 1838 : gsi_insert_before (gsi, store, GSI_SAME_STMT);
1520 : 1838 : if (gimple_call_lhs (stmt))
1521 : : {
1522 : 8 : gimple *asgn = gimple_build_assign (gimple_call_lhs (stmt), dest);
1523 : 8 : gsi_replace (gsi, asgn, false);
1524 : : }
1525 : : else
1526 : : {
1527 : 1830 : gimple_stmt_iterator gsi2 = *gsi;
1528 : 1830 : gsi_prev (gsi);
1529 : 1830 : gsi_remove (&gsi2, true);
1530 : : }
1531 : :
1532 : : return true;
1533 : : }
1534 : :
1535 : : /* Helper of get_range_strlen for ARG that is not an SSA_NAME. */
1536 : :
1537 : : static bool
1538 : 619669 : get_range_strlen_tree (tree arg, bitmap visited, strlen_range_kind rkind,
1539 : : c_strlen_data *pdata, unsigned eltsize)
1540 : : {
1541 : 619669 : gcc_assert (TREE_CODE (arg) != SSA_NAME);
1542 : :
1543 : : /* The length computed by this invocation of the function. */
1544 : 619669 : tree val = NULL_TREE;
1545 : :
1546 : : /* True if VAL is an optimistic (tight) bound determined from
1547 : : the size of the character array in which the string may be
1548 : : stored. In that case, the computed VAL is used to set
1549 : : PDATA->MAXBOUND. */
1550 : 619669 : bool tight_bound = false;
1551 : :
1552 : : /* We can end up with &(*iftmp_1)[0] here as well, so handle it. */
1553 : 619669 : if (TREE_CODE (arg) == ADDR_EXPR
1554 : 619669 : && TREE_CODE (TREE_OPERAND (arg, 0)) == ARRAY_REF)
1555 : : {
1556 : 32410 : tree op = TREE_OPERAND (arg, 0);
1557 : 32410 : if (integer_zerop (TREE_OPERAND (op, 1)))
1558 : : {
1559 : 13598 : tree aop0 = TREE_OPERAND (op, 0);
1560 : 13598 : if (TREE_CODE (aop0) == INDIRECT_REF
1561 : 13598 : && TREE_CODE (TREE_OPERAND (aop0, 0)) == SSA_NAME)
1562 : 0 : return get_range_strlen (TREE_OPERAND (aop0, 0), visited, rkind,
1563 : 0 : pdata, eltsize);
1564 : : }
1565 : 18812 : else if (TREE_CODE (TREE_OPERAND (op, 0)) == COMPONENT_REF
1566 : 18812 : && rkind == SRK_LENRANGE)
1567 : : {
1568 : : /* Fail if an array is the last member of a struct object
1569 : : since it could be treated as a (fake) flexible array
1570 : : member. */
1571 : 4689 : tree idx = TREE_OPERAND (op, 1);
1572 : :
1573 : 4689 : arg = TREE_OPERAND (op, 0);
1574 : 4689 : tree optype = TREE_TYPE (arg);
1575 : 4689 : if (tree dom = TYPE_DOMAIN (optype))
1576 : 4689 : if (tree bound = TYPE_MAX_VALUE (dom))
1577 : 4689 : if (TREE_CODE (bound) == INTEGER_CST
1578 : 4689 : && TREE_CODE (idx) == INTEGER_CST
1579 : 7808 : && tree_int_cst_lt (bound, idx))
1580 : : return false;
1581 : : }
1582 : : }
1583 : :
1584 : 619438 : if (rkind == SRK_INT_VALUE)
1585 : : {
1586 : : /* We are computing the maximum value (not string length). */
1587 : 27793 : val = arg;
1588 : 27793 : if (TREE_CODE (val) != INTEGER_CST
1589 : 27793 : || tree_int_cst_sgn (val) < 0)
1590 : 2841 : return false;
1591 : : }
1592 : : else
1593 : : {
1594 : 591645 : c_strlen_data lendata = { };
1595 : 591645 : val = c_strlen (arg, 1, &lendata, eltsize);
1596 : :
1597 : 591645 : if (!val && lendata.decl)
1598 : : {
1599 : : /* ARG refers to an unterminated const character array.
1600 : : DATA.DECL with size DATA.LEN. */
1601 : 4535 : val = lendata.minlen;
1602 : 4535 : pdata->decl = lendata.decl;
1603 : : }
1604 : : }
1605 : :
1606 : : /* Set if VAL represents the maximum length based on array size (set
1607 : : when exact length cannot be determined). */
1608 : 616597 : bool maxbound = false;
1609 : :
1610 : 616597 : if (!val && rkind == SRK_LENRANGE)
1611 : : {
1612 : 382729 : if (TREE_CODE (arg) == ADDR_EXPR)
1613 : 156703 : return get_range_strlen (TREE_OPERAND (arg, 0), visited, rkind,
1614 : 156703 : pdata, eltsize);
1615 : :
1616 : 226026 : if (TREE_CODE (arg) == ARRAY_REF)
1617 : : {
1618 : 24423 : tree optype = TREE_TYPE (TREE_OPERAND (arg, 0));
1619 : :
1620 : : /* Determine the "innermost" array type. */
1621 : 24423 : while (TREE_CODE (optype) == ARRAY_TYPE
1622 : 30656 : && TREE_CODE (TREE_TYPE (optype)) == ARRAY_TYPE)
1623 : 6233 : optype = TREE_TYPE (optype);
1624 : :
1625 : : /* Avoid arrays of pointers. */
1626 : 24423 : tree eltype = TREE_TYPE (optype);
1627 : 24423 : if (TREE_CODE (optype) != ARRAY_TYPE
1628 : 24423 : || !INTEGRAL_TYPE_P (eltype))
1629 : : return false;
1630 : :
1631 : : /* Fail when the array bound is unknown or zero. */
1632 : 15001 : val = TYPE_SIZE_UNIT (optype);
1633 : 15001 : if (!val
1634 : 14929 : || TREE_CODE (val) != INTEGER_CST
1635 : 29898 : || integer_zerop (val))
1636 : 113 : return false;
1637 : :
1638 : 14888 : val = fold_build2 (MINUS_EXPR, TREE_TYPE (val), val,
1639 : : integer_one_node);
1640 : :
1641 : : /* Set the minimum size to zero since the string in
1642 : : the array could have zero length. */
1643 : 14888 : pdata->minlen = ssize_int (0);
1644 : :
1645 : 14888 : tight_bound = true;
1646 : : }
1647 : 201603 : else if (TREE_CODE (arg) == COMPONENT_REF
1648 : 201603 : && (TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 1)))
1649 : : == ARRAY_TYPE))
1650 : : {
1651 : : /* Use the type of the member array to determine the upper
1652 : : bound on the length of the array. This may be overly
1653 : : optimistic if the array itself isn't NUL-terminated and
1654 : : the caller relies on the subsequent member to contain
1655 : : the NUL but that would only be considered valid if
1656 : : the array were the last member of a struct. */
1657 : :
1658 : 10747 : tree fld = TREE_OPERAND (arg, 1);
1659 : :
1660 : 10747 : tree optype = TREE_TYPE (fld);
1661 : :
1662 : : /* Determine the "innermost" array type. */
1663 : 10747 : while (TREE_CODE (optype) == ARRAY_TYPE
1664 : 10989 : && TREE_CODE (TREE_TYPE (optype)) == ARRAY_TYPE)
1665 : 242 : optype = TREE_TYPE (optype);
1666 : :
1667 : : /* Fail when the array bound is unknown or zero. */
1668 : 10747 : val = TYPE_SIZE_UNIT (optype);
1669 : 10747 : if (!val
1670 : 10485 : || TREE_CODE (val) != INTEGER_CST
1671 : 21198 : || integer_zerop (val))
1672 : 387 : return false;
1673 : 10360 : val = fold_build2 (MINUS_EXPR, TREE_TYPE (val), val,
1674 : : integer_one_node);
1675 : :
1676 : : /* Set the minimum size to zero since the string in
1677 : : the array could have zero length. */
1678 : 10360 : pdata->minlen = ssize_int (0);
1679 : :
1680 : : /* The array size determined above is an optimistic bound
1681 : : on the length. If the array isn't nul-terminated the
1682 : : length computed by the library function would be greater.
1683 : : Even though using strlen to cross the subobject boundary
1684 : : is undefined, avoid drawing conclusions from the member
1685 : : type about the length here. */
1686 : 10360 : tight_bound = true;
1687 : : }
1688 : 190856 : else if (TREE_CODE (arg) == MEM_REF
1689 : 27467 : && TREE_CODE (TREE_TYPE (arg)) == ARRAY_TYPE
1690 : 4984 : && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == INTEGER_TYPE
1691 : 195263 : && TREE_CODE (TREE_OPERAND (arg, 0)) == ADDR_EXPR)
1692 : : {
1693 : : /* Handle a MEM_REF into a DECL accessing an array of integers,
1694 : : being conservative about references to extern structures with
1695 : : flexible array members that can be initialized to arbitrary
1696 : : numbers of elements as an extension (static structs are okay). */
1697 : 4407 : tree ref = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
1698 : 4407 : if ((TREE_CODE (ref) == PARM_DECL || VAR_P (ref))
1699 : 8800 : && (decl_binds_to_current_def_p (ref)
1700 : 457 : || !array_ref_flexible_size_p (arg)))
1701 : : {
1702 : : /* Fail if the offset is out of bounds. Such accesses
1703 : : should be diagnosed at some point. */
1704 : 4268 : val = DECL_SIZE_UNIT (ref);
1705 : 4268 : if (!val
1706 : 4096 : || TREE_CODE (val) != INTEGER_CST
1707 : 8364 : || integer_zerop (val))
1708 : 388 : return false;
1709 : :
1710 : 4094 : poly_offset_int psiz = wi::to_offset (val);
1711 : 4094 : poly_offset_int poff = mem_ref_offset (arg);
1712 : 4094 : if (known_le (psiz, poff))
1713 : : return false;
1714 : :
1715 : 3880 : pdata->minlen = ssize_int (0);
1716 : :
1717 : : /* Subtract the offset and one for the terminating nul. */
1718 : 3880 : psiz -= poff;
1719 : 3880 : psiz -= 1;
1720 : 3880 : val = wide_int_to_tree (TREE_TYPE (val), psiz);
1721 : : /* Since VAL reflects the size of a declared object
1722 : : rather the type of the access it is not a tight bound. */
1723 : : }
1724 : : }
1725 : 186449 : else if (TREE_CODE (arg) == PARM_DECL || VAR_P (arg))
1726 : : {
1727 : : /* Avoid handling pointers to arrays. GCC might misuse
1728 : : a pointer to an array of one bound to point to an array
1729 : : object of a greater bound. */
1730 : 136213 : tree argtype = TREE_TYPE (arg);
1731 : 136213 : if (TREE_CODE (argtype) == ARRAY_TYPE)
1732 : : {
1733 : 46814 : val = TYPE_SIZE_UNIT (argtype);
1734 : 46814 : if (!val
1735 : 46003 : || TREE_CODE (val) != INTEGER_CST
1736 : 92817 : || integer_zerop (val))
1737 : 928 : return false;
1738 : 45886 : val = wide_int_to_tree (TREE_TYPE (val),
1739 : 45886 : wi::sub (wi::to_wide (val), 1));
1740 : :
1741 : : /* Set the minimum size to zero since the string in
1742 : : the array could have zero length. */
1743 : 45886 : pdata->minlen = ssize_int (0);
1744 : : }
1745 : : }
1746 : : maxbound = true;
1747 : : }
1748 : :
1749 : 448656 : if (!val)
1750 : : return false;
1751 : :
1752 : : /* Adjust the lower bound on the string length as necessary. */
1753 : 282751 : if (!pdata->minlen
1754 : 282751 : || (rkind != SRK_STRLEN
1755 : 80056 : && TREE_CODE (pdata->minlen) == INTEGER_CST
1756 : 80056 : && TREE_CODE (val) == INTEGER_CST
1757 : 80051 : && tree_int_cst_lt (val, pdata->minlen)))
1758 : 202301 : pdata->minlen = val;
1759 : :
1760 : 282751 : if (pdata->maxbound && TREE_CODE (pdata->maxbound) == INTEGER_CST)
1761 : : {
1762 : : /* Adjust the tighter (more optimistic) string length bound
1763 : : if necessary and proceed to adjust the more conservative
1764 : : bound. */
1765 : 2045 : if (TREE_CODE (val) == INTEGER_CST)
1766 : : {
1767 : 2045 : if (tree_int_cst_lt (pdata->maxbound, val))
1768 : 591 : pdata->maxbound = val;
1769 : : }
1770 : : else
1771 : 0 : pdata->maxbound = val;
1772 : : }
1773 : 280706 : else if (pdata->maxbound || maxbound)
1774 : : /* Set PDATA->MAXBOUND only if it either isn't INTEGER_CST or
1775 : : if VAL corresponds to the maximum length determined based
1776 : : on the type of the object. */
1777 : 77565 : pdata->maxbound = val;
1778 : :
1779 : 282751 : if (tight_bound)
1780 : : {
1781 : : /* VAL computed above represents an optimistically tight bound
1782 : : on the length of the string based on the referenced object's
1783 : : or subobject's type. Determine the conservative upper bound
1784 : : based on the enclosing object's size if possible. */
1785 : 25248 : if (rkind == SRK_LENRANGE)
1786 : : {
1787 : 25248 : poly_int64 offset;
1788 : 25248 : tree base = get_addr_base_and_unit_offset (arg, &offset);
1789 : 25248 : if (!base)
1790 : : {
1791 : : /* When the call above fails due to a non-constant offset
1792 : : assume the offset is zero and use the size of the whole
1793 : : enclosing object instead. */
1794 : 7827 : base = get_base_address (arg);
1795 : 7827 : offset = 0;
1796 : : }
1797 : : /* If the base object is a pointer no upper bound on the length
1798 : : can be determined. Otherwise the maximum length is equal to
1799 : : the size of the enclosing object minus the offset of
1800 : : the referenced subobject minus 1 (for the terminating nul). */
1801 : 25248 : tree type = TREE_TYPE (base);
1802 : 25248 : if (TREE_CODE (type) == POINTER_TYPE
1803 : 25244 : || (TREE_CODE (base) != PARM_DECL && !VAR_P (base))
1804 : 43834 : || !(val = DECL_SIZE_UNIT (base)))
1805 : 7827 : val = build_all_ones_cst (size_type_node);
1806 : : else
1807 : : {
1808 : 17421 : val = DECL_SIZE_UNIT (base);
1809 : 17421 : val = fold_build2 (MINUS_EXPR, TREE_TYPE (val), val,
1810 : : size_int (offset + 1));
1811 : : }
1812 : : }
1813 : : else
1814 : : return false;
1815 : : }
1816 : :
1817 : 282751 : if (pdata->maxlen)
1818 : : {
1819 : : /* Adjust the more conservative bound if possible/necessary
1820 : : and fail otherwise. */
1821 : 10336 : if (rkind != SRK_STRLEN)
1822 : : {
1823 : 9238 : if (TREE_CODE (pdata->maxlen) != INTEGER_CST
1824 : 9238 : || TREE_CODE (val) != INTEGER_CST)
1825 : : return false;
1826 : :
1827 : 9233 : if (tree_int_cst_lt (pdata->maxlen, val))
1828 : 1350 : pdata->maxlen = val;
1829 : 9233 : return true;
1830 : : }
1831 : 1098 : else if (simple_cst_equal (val, pdata->maxlen) != 1)
1832 : : {
1833 : : /* Fail if the length of this ARG is different from that
1834 : : previously determined from another ARG. */
1835 : : return false;
1836 : : }
1837 : : }
1838 : :
1839 : 272542 : pdata->maxlen = val;
1840 : 272542 : return rkind == SRK_LENRANGE || !integer_all_onesp (val);
1841 : : }
1842 : :
1843 : : /* For an ARG referencing one or more strings, try to obtain the range
1844 : : of their lengths, or the size of the largest array ARG referes to if
1845 : : the range of lengths cannot be determined, and store all in *PDATA.
1846 : : For an integer ARG (when RKIND == SRK_INT_VALUE), try to determine
1847 : : the maximum constant value.
1848 : : If ARG is an SSA_NAME, follow its use-def chains. When RKIND ==
1849 : : SRK_STRLEN, then if PDATA->MAXLEN is not equal to the determined
1850 : : length or if we are unable to determine the length, return false.
1851 : : VISITED is a bitmap of visited variables.
1852 : : RKIND determines the kind of value or range to obtain (see
1853 : : strlen_range_kind).
1854 : : Set PDATA->DECL if ARG refers to an unterminated constant array.
1855 : : On input, set ELTSIZE to 1 for normal single byte character strings,
1856 : : and either 2 or 4 for wide characer strings (the size of wchar_t).
1857 : : Return true if *PDATA was successfully populated and false otherwise. */
1858 : :
1859 : : static bool
1860 : 1553032 : get_range_strlen (tree arg, bitmap visited,
1861 : : strlen_range_kind rkind,
1862 : : c_strlen_data *pdata, unsigned eltsize)
1863 : : {
1864 : :
1865 : 1639913 : if (TREE_CODE (arg) != SSA_NAME)
1866 : 619669 : return get_range_strlen_tree (arg, visited, rkind, pdata, eltsize);
1867 : :
1868 : : /* If ARG is registered for SSA update we cannot look at its defining
1869 : : statement. */
1870 : 1020244 : if (name_registered_for_update_p (arg))
1871 : : return false;
1872 : :
1873 : : /* If we were already here, break the infinite cycle. */
1874 : 1020244 : if (!bitmap_set_bit (visited, SSA_NAME_VERSION (arg)))
1875 : : return true;
1876 : :
1877 : 1017635 : tree var = arg;
1878 : 1017635 : gimple *def_stmt = SSA_NAME_DEF_STMT (var);
1879 : :
1880 : 1017635 : switch (gimple_code (def_stmt))
1881 : : {
1882 : 133254 : case GIMPLE_ASSIGN:
1883 : : /* The RHS of the statement defining VAR must either have a
1884 : : constant length or come from another SSA_NAME with a constant
1885 : : length. */
1886 : 133254 : if (gimple_assign_single_p (def_stmt)
1887 : 133254 : || gimple_assign_unary_nop_p (def_stmt))
1888 : : {
1889 : 86881 : tree rhs = gimple_assign_rhs1 (def_stmt);
1890 : 86881 : return get_range_strlen (rhs, visited, rkind, pdata, eltsize);
1891 : : }
1892 : 46373 : else if (gimple_assign_rhs_code (def_stmt) == COND_EXPR)
1893 : : {
1894 : 246 : tree ops[2] = { gimple_assign_rhs2 (def_stmt),
1895 : 246 : gimple_assign_rhs3 (def_stmt) };
1896 : :
1897 : 738 : for (unsigned int i = 0; i < 2; i++)
1898 : 492 : if (!get_range_strlen (ops[i], visited, rkind, pdata, eltsize))
1899 : : {
1900 : 28 : if (rkind != SRK_LENRANGE)
1901 : : return false;
1902 : : /* Set the upper bound to the maximum to prevent
1903 : : it from being adjusted in the next iteration but
1904 : : leave MINLEN and the more conservative MAXBOUND
1905 : : determined so far alone (or leave them null if
1906 : : they haven't been set yet). That the MINLEN is
1907 : : in fact zero can be determined from MAXLEN being
1908 : : unbounded but the discovered minimum is used for
1909 : : diagnostics. */
1910 : 28 : pdata->maxlen = build_all_ones_cst (size_type_node);
1911 : : }
1912 : : return true;
1913 : : }
1914 : : return false;
1915 : :
1916 : : case GIMPLE_PHI:
1917 : : /* Unless RKIND == SRK_LENRANGE, all arguments of the PHI node
1918 : : must have a constant length. */
1919 : 64123 : for (unsigned i = 0; i < gimple_phi_num_args (def_stmt); i++)
1920 : : {
1921 : 45178 : tree arg = gimple_phi_arg (def_stmt, i)->def;
1922 : :
1923 : : /* If this PHI has itself as an argument, we cannot
1924 : : determine the string length of this argument. However,
1925 : : if we can find a constant string length for the other
1926 : : PHI args then we can still be sure that this is a
1927 : : constant string length. So be optimistic and just
1928 : : continue with the next argument. */
1929 : 45178 : if (arg == gimple_phi_result (def_stmt))
1930 : 0 : continue;
1931 : :
1932 : 45178 : if (!get_range_strlen (arg, visited, rkind, pdata, eltsize))
1933 : : {
1934 : 21944 : if (rkind != SRK_LENRANGE)
1935 : : return false;
1936 : : /* Set the upper bound to the maximum to prevent
1937 : : it from being adjusted in the next iteration but
1938 : : leave MINLEN and the more conservative MAXBOUND
1939 : : determined so far alone (or leave them null if
1940 : : they haven't been set yet). That the MINLEN is
1941 : : in fact zero can be determined from MAXLEN being
1942 : : unbounded but the discovered minimum is used for
1943 : : diagnostics. */
1944 : 19879 : pdata->maxlen = build_all_ones_cst (size_type_node);
1945 : : }
1946 : : }
1947 : : return true;
1948 : :
1949 : : default:
1950 : : return false;
1951 : : }
1952 : : }
1953 : :
1954 : : /* Try to obtain the range of the lengths of the string(s) referenced
1955 : : by ARG, or the size of the largest array ARG refers to if the range
1956 : : of lengths cannot be determined, and store all in *PDATA which must
1957 : : be zero-initialized on input except PDATA->MAXBOUND may be set to
1958 : : a non-null tree node other than INTEGER_CST to request to have it
1959 : : set to the length of the longest string in a PHI. ELTSIZE is
1960 : : the expected size of the string element in bytes: 1 for char and
1961 : : some power of 2 for wide characters.
1962 : : Return true if the range [PDATA->MINLEN, PDATA->MAXLEN] is suitable
1963 : : for optimization. Returning false means that a nonzero PDATA->MINLEN
1964 : : doesn't reflect the true lower bound of the range when PDATA->MAXLEN
1965 : : is -1 (in that case, the actual range is indeterminate, i.e.,
1966 : : [0, PTRDIFF_MAX - 2]. */
1967 : :
1968 : : bool
1969 : 1246857 : get_range_strlen (tree arg, c_strlen_data *pdata, unsigned eltsize)
1970 : : {
1971 : 1246857 : auto_bitmap visited;
1972 : 1246857 : tree maxbound = pdata->maxbound;
1973 : :
1974 : 1246857 : if (!get_range_strlen (arg, visited, SRK_LENRANGE, pdata, eltsize))
1975 : : {
1976 : : /* On failure extend the length range to an impossible maximum
1977 : : (a valid MAXLEN must be less than PTRDIFF_MAX - 1). Other
1978 : : members can stay unchanged regardless. */
1979 : 1015116 : pdata->minlen = ssize_int (0);
1980 : 1015116 : pdata->maxlen = build_all_ones_cst (size_type_node);
1981 : : }
1982 : 231741 : else if (!pdata->minlen)
1983 : 5268 : pdata->minlen = ssize_int (0);
1984 : :
1985 : : /* If it's unchanged from it initial non-null value, set the conservative
1986 : : MAXBOUND to SIZE_MAX. Otherwise leave it null (if it is null). */
1987 : 1246857 : if (maxbound && pdata->maxbound == maxbound)
1988 : 664494 : pdata->maxbound = build_all_ones_cst (size_type_node);
1989 : :
1990 : 1246857 : return !integer_all_onesp (pdata->maxlen);
1991 : 1246857 : }
1992 : :
1993 : : /* Return the maximum value for ARG given RKIND (see strlen_range_kind).
1994 : : For ARG of pointer types, NONSTR indicates if the caller is prepared
1995 : : to handle unterminated strings. For integer ARG and when RKIND ==
1996 : : SRK_INT_VALUE, NONSTR must be null.
1997 : :
1998 : : If an unterminated array is discovered and our caller handles
1999 : : unterminated arrays, then bubble up the offending DECL and
2000 : : return the maximum size. Otherwise return NULL. */
2001 : :
2002 : : static tree
2003 : 103802 : get_maxval_strlen (tree arg, strlen_range_kind rkind, tree *nonstr = NULL)
2004 : : {
2005 : : /* A non-null NONSTR is meaningless when determining the maximum
2006 : : value of an integer ARG. */
2007 : 103802 : gcc_assert (rkind != SRK_INT_VALUE || nonstr == NULL);
2008 : : /* ARG must have an integral type when RKIND says so. */
2009 : 103802 : gcc_assert (rkind != SRK_INT_VALUE || INTEGRAL_TYPE_P (TREE_TYPE (arg)));
2010 : :
2011 : 103802 : auto_bitmap visited;
2012 : :
2013 : : /* Reset DATA.MAXLEN if the call fails or when DATA.MAXLEN
2014 : : is unbounded. */
2015 : 103802 : c_strlen_data lendata = { };
2016 : 103802 : if (!get_range_strlen (arg, visited, rkind, &lendata, /* eltsize = */1))
2017 : 55668 : lendata.maxlen = NULL_TREE;
2018 : 48134 : else if (lendata.maxlen && integer_all_onesp (lendata.maxlen))
2019 : 0 : lendata.maxlen = NULL_TREE;
2020 : :
2021 : 103802 : if (nonstr)
2022 : : {
2023 : : /* For callers prepared to handle unterminated arrays set
2024 : : *NONSTR to point to the declaration of the array and return
2025 : : the maximum length/size. */
2026 : 26066 : *nonstr = lendata.decl;
2027 : 26066 : return lendata.maxlen;
2028 : : }
2029 : :
2030 : : /* Fail if the constant array isn't nul-terminated. */
2031 : 77736 : return lendata.decl ? NULL_TREE : lendata.maxlen;
2032 : 103802 : }
2033 : :
2034 : : /* Return true if LEN is known to be less than or equal to (or if STRICT is
2035 : : true, strictly less than) the lower bound of SIZE at compile time and false
2036 : : otherwise. */
2037 : :
2038 : : static bool
2039 : 69266 : known_lower (gimple *stmt, tree len, tree size, bool strict = false)
2040 : : {
2041 : 69266 : if (len == NULL_TREE)
2042 : : return false;
2043 : :
2044 : 257285 : wide_int size_range[2];
2045 : 257285 : wide_int len_range[2];
2046 : 51457 : if (get_range (len, stmt, len_range) && get_range (size, stmt, size_range))
2047 : : {
2048 : 18114 : if (strict)
2049 : 2242 : return wi::ltu_p (len_range[1], size_range[0]);
2050 : : else
2051 : 15872 : return wi::leu_p (len_range[1], size_range[0]);
2052 : : }
2053 : :
2054 : : return false;
2055 : 308742 : }
2056 : :
2057 : : /* Fold function call to builtin strcpy with arguments DEST and SRC.
2058 : : If LEN is not NULL, it represents the length of the string to be
2059 : : copied. Return NULL_TREE if no simplification can be made. */
2060 : :
2061 : : static bool
2062 : 28415 : gimple_fold_builtin_strcpy (gimple_stmt_iterator *gsi,
2063 : : tree dest, tree src)
2064 : : {
2065 : 28415 : gimple *stmt = gsi_stmt (*gsi);
2066 : 28415 : location_t loc = gimple_location (stmt);
2067 : 28415 : tree fn;
2068 : :
2069 : : /* If SRC and DEST are the same (and not volatile), return DEST. */
2070 : 28415 : if (operand_equal_p (src, dest, 0))
2071 : : {
2072 : : /* Issue -Wrestrict unless the pointers are null (those do
2073 : : not point to objects and so do not indicate an overlap;
2074 : : such calls could be the result of sanitization and jump
2075 : : threading). */
2076 : 89 : if (!integer_zerop (dest) && !warning_suppressed_p (stmt, OPT_Wrestrict))
2077 : : {
2078 : 54 : tree func = gimple_call_fndecl (stmt);
2079 : :
2080 : 54 : warning_at (loc, OPT_Wrestrict,
2081 : : "%qD source argument is the same as destination",
2082 : : func);
2083 : : }
2084 : :
2085 : 89 : replace_call_with_value (gsi, dest);
2086 : 89 : return true;
2087 : : }
2088 : :
2089 : 28326 : if (optimize_function_for_size_p (cfun))
2090 : : return false;
2091 : :
2092 : 51541 : fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
2093 : 26066 : if (!fn)
2094 : : return false;
2095 : :
2096 : : /* Set to non-null if ARG refers to an unterminated array. */
2097 : 26066 : tree nonstr = NULL;
2098 : 26066 : tree len = get_maxval_strlen (src, SRK_STRLEN, &nonstr);
2099 : :
2100 : 26066 : if (nonstr)
2101 : : {
2102 : : /* Avoid folding calls with unterminated arrays. */
2103 : 596 : if (!warning_suppressed_p (stmt, OPT_Wstringop_overread))
2104 : 69 : warn_string_no_nul (loc, stmt, "strcpy", src, nonstr);
2105 : 596 : suppress_warning (stmt, OPT_Wstringop_overread);
2106 : 596 : return false;
2107 : : }
2108 : :
2109 : 25470 : if (!len)
2110 : : return false;
2111 : :
2112 : 2851 : len = fold_convert_loc (loc, size_type_node, len);
2113 : 2851 : len = size_binop_loc (loc, PLUS_EXPR, len, build_int_cst (size_type_node, 1));
2114 : 2851 : len = force_gimple_operand_gsi (gsi, len, true,
2115 : : NULL_TREE, true, GSI_SAME_STMT);
2116 : 2851 : gimple *repl = gimple_build_call (fn, 3, dest, src, len);
2117 : 2851 : replace_call_with_call_and_fold (gsi, repl);
2118 : 2851 : return true;
2119 : : }
2120 : :
2121 : : /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
2122 : : If SLEN is not NULL, it represents the length of the source string.
2123 : : Return NULL_TREE if no simplification can be made. */
2124 : :
2125 : : static bool
2126 : 19902 : gimple_fold_builtin_strncpy (gimple_stmt_iterator *gsi,
2127 : : tree dest, tree src, tree len)
2128 : : {
2129 : 19902 : gimple *stmt = gsi_stmt (*gsi);
2130 : 19902 : location_t loc = gimple_location (stmt);
2131 : 19902 : bool nonstring = get_attr_nonstring_decl (dest) != NULL_TREE;
2132 : :
2133 : : /* If the LEN parameter is zero, return DEST. */
2134 : 19902 : if (integer_zerop (len))
2135 : : {
2136 : : /* Avoid warning if the destination refers to an array/pointer
2137 : : decorate with attribute nonstring. */
2138 : 185 : if (!nonstring)
2139 : : {
2140 : 180 : tree fndecl = gimple_call_fndecl (stmt);
2141 : :
2142 : : /* Warn about the lack of nul termination: the result is not
2143 : : a (nul-terminated) string. */
2144 : 180 : tree slen = get_maxval_strlen (src, SRK_STRLEN);
2145 : 180 : if (slen && !integer_zerop (slen))
2146 : 26 : warning_at (loc, OPT_Wstringop_truncation,
2147 : : "%qD destination unchanged after copying no bytes "
2148 : : "from a string of length %E",
2149 : : fndecl, slen);
2150 : : else
2151 : 154 : warning_at (loc, OPT_Wstringop_truncation,
2152 : : "%qD destination unchanged after copying no bytes",
2153 : : fndecl);
2154 : : }
2155 : :
2156 : 185 : replace_call_with_value (gsi, dest);
2157 : 185 : return true;
2158 : : }
2159 : :
2160 : : /* We can't compare slen with len as constants below if len is not a
2161 : : constant. */
2162 : 19717 : if (TREE_CODE (len) != INTEGER_CST)
2163 : : return false;
2164 : :
2165 : : /* Now, we must be passed a constant src ptr parameter. */
2166 : 12449 : tree slen = get_maxval_strlen (src, SRK_STRLEN);
2167 : 12449 : if (!slen || TREE_CODE (slen) != INTEGER_CST)
2168 : : return false;
2169 : :
2170 : : /* The size of the source string including the terminating nul. */
2171 : 2036 : tree ssize = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
2172 : :
2173 : : /* We do not support simplification of this case, though we do
2174 : : support it when expanding trees into RTL. */
2175 : : /* FIXME: generate a call to __builtin_memset. */
2176 : 2036 : if (tree_int_cst_lt (ssize, len))
2177 : : return false;
2178 : :
2179 : : /* Diagnose truncation that leaves the copy unterminated. */
2180 : 733 : maybe_diag_stxncpy_trunc (*gsi, src, len);
2181 : :
2182 : : /* OK transform into builtin memcpy. */
2183 : 19717 : tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
2184 : 733 : if (!fn)
2185 : : return false;
2186 : :
2187 : 733 : len = fold_convert_loc (loc, size_type_node, len);
2188 : 733 : len = force_gimple_operand_gsi (gsi, len, true,
2189 : : NULL_TREE, true, GSI_SAME_STMT);
2190 : 733 : gimple *repl = gimple_build_call (fn, 3, dest, src, len);
2191 : 733 : replace_call_with_call_and_fold (gsi, repl);
2192 : :
2193 : 733 : return true;
2194 : : }
2195 : :
2196 : : /* Fold function call to builtin strchr or strrchr.
2197 : : If both arguments are constant, evaluate and fold the result,
2198 : : otherwise simplify str(r)chr (str, 0) into str + strlen (str).
2199 : : In general strlen is significantly faster than strchr
2200 : : due to being a simpler operation. */
2201 : : static bool
2202 : 6113 : gimple_fold_builtin_strchr (gimple_stmt_iterator *gsi, bool is_strrchr)
2203 : : {
2204 : 6113 : gimple *stmt = gsi_stmt (*gsi);
2205 : 6113 : tree str = gimple_call_arg (stmt, 0);
2206 : 6113 : tree c = gimple_call_arg (stmt, 1);
2207 : 6113 : location_t loc = gimple_location (stmt);
2208 : 6113 : const char *p;
2209 : 6113 : char ch;
2210 : :
2211 : 6113 : if (!gimple_call_lhs (stmt))
2212 : : return false;
2213 : :
2214 : : /* Avoid folding if the first argument is not a nul-terminated array.
2215 : : Defer warning until later. */
2216 : 6103 : if (!check_nul_terminated_array (NULL_TREE, str))
2217 : : return false;
2218 : :
2219 : 6009 : if ((p = c_getstr (str)) && target_char_cst_p (c, &ch))
2220 : : {
2221 : 49 : const char *p1 = is_strrchr ? strrchr (p, ch) : strchr (p, ch);
2222 : :
2223 : 49 : if (p1 == NULL)
2224 : : {
2225 : 1 : replace_call_with_value (gsi, integer_zero_node);
2226 : 1 : return true;
2227 : : }
2228 : :
2229 : 48 : tree len = build_int_cst (size_type_node, p1 - p);
2230 : 48 : gimple_seq stmts = NULL;
2231 : 48 : gimple *new_stmt = gimple_build_assign (gimple_call_lhs (stmt),
2232 : : POINTER_PLUS_EXPR, str, len);
2233 : 48 : gimple_seq_add_stmt_without_update (&stmts, new_stmt);
2234 : 48 : gsi_replace_with_seq_vops (gsi, stmts);
2235 : 48 : return true;
2236 : : }
2237 : :
2238 : 5960 : if (!integer_zerop (c))
2239 : : return false;
2240 : :
2241 : : /* Transform strrchr (s, 0) to strchr (s, 0) when optimizing for size. */
2242 : 82 : if (is_strrchr && optimize_function_for_size_p (cfun))
2243 : : {
2244 : 3 : tree strchr_fn = builtin_decl_implicit (BUILT_IN_STRCHR);
2245 : :
2246 : 3 : if (strchr_fn)
2247 : : {
2248 : 3 : gimple *repl = gimple_build_call (strchr_fn, 2, str, c);
2249 : 3 : replace_call_with_call_and_fold (gsi, repl);
2250 : 3 : return true;
2251 : : }
2252 : :
2253 : : return false;
2254 : : }
2255 : :
2256 : 79 : tree len;
2257 : 6061 : tree strlen_fn = builtin_decl_implicit (BUILT_IN_STRLEN);
2258 : :
2259 : 79 : if (!strlen_fn)
2260 : : return false;
2261 : :
2262 : : /* Create newstr = strlen (str). */
2263 : 79 : gimple_seq stmts = NULL;
2264 : 79 : gimple *new_stmt = gimple_build_call (strlen_fn, 1, str);
2265 : 79 : gimple_set_location (new_stmt, loc);
2266 : 79 : len = create_tmp_reg_or_ssa_name (size_type_node);
2267 : 79 : gimple_call_set_lhs (new_stmt, len);
2268 : 79 : gimple_seq_add_stmt_without_update (&stmts, new_stmt);
2269 : :
2270 : : /* Create (str p+ strlen (str)). */
2271 : 79 : new_stmt = gimple_build_assign (gimple_call_lhs (stmt),
2272 : : POINTER_PLUS_EXPR, str, len);
2273 : 79 : gimple_seq_add_stmt_without_update (&stmts, new_stmt);
2274 : 79 : gsi_replace_with_seq_vops (gsi, stmts);
2275 : : /* gsi now points at the assignment to the lhs, get a
2276 : : stmt iterator to the strlen.
2277 : : ??? We can't use gsi_for_stmt as that doesn't work when the
2278 : : CFG isn't built yet. */
2279 : 79 : gimple_stmt_iterator gsi2 = *gsi;
2280 : 79 : gsi_prev (&gsi2);
2281 : 79 : fold_stmt (&gsi2);
2282 : 79 : return true;
2283 : : }
2284 : :
2285 : : /* Fold function call to builtin strstr.
2286 : : If both arguments are constant, evaluate and fold the result,
2287 : : additionally fold strstr (x, "") into x and strstr (x, "c")
2288 : : into strchr (x, 'c'). */
2289 : : static bool
2290 : 4111 : gimple_fold_builtin_strstr (gimple_stmt_iterator *gsi)
2291 : : {
2292 : 4111 : gimple *stmt = gsi_stmt (*gsi);
2293 : 4111 : if (!gimple_call_lhs (stmt))
2294 : : return false;
2295 : :
2296 : 4108 : tree haystack = gimple_call_arg (stmt, 0);
2297 : 4108 : tree needle = gimple_call_arg (stmt, 1);
2298 : :
2299 : : /* Avoid folding if either argument is not a nul-terminated array.
2300 : : Defer warning until later. */
2301 : 4108 : if (!check_nul_terminated_array (NULL_TREE, haystack)
2302 : 4108 : || !check_nul_terminated_array (NULL_TREE, needle))
2303 : 21 : return false;
2304 : :
2305 : 4087 : const char *q = c_getstr (needle);
2306 : 4087 : if (q == NULL)
2307 : : return false;
2308 : :
2309 : 3028 : if (const char *p = c_getstr (haystack))
2310 : : {
2311 : 18 : const char *r = strstr (p, q);
2312 : :
2313 : 18 : if (r == NULL)
2314 : : {
2315 : 1 : replace_call_with_value (gsi, integer_zero_node);
2316 : 1 : return true;
2317 : : }
2318 : :
2319 : 17 : tree len = build_int_cst (size_type_node, r - p);
2320 : 17 : gimple_seq stmts = NULL;
2321 : 17 : gimple *new_stmt
2322 : 17 : = gimple_build_assign (gimple_call_lhs (stmt), POINTER_PLUS_EXPR,
2323 : : haystack, len);
2324 : 17 : gimple_seq_add_stmt_without_update (&stmts, new_stmt);
2325 : 17 : gsi_replace_with_seq_vops (gsi, stmts);
2326 : 17 : return true;
2327 : : }
2328 : :
2329 : : /* For strstr (x, "") return x. */
2330 : 3010 : if (q[0] == '\0')
2331 : : {
2332 : 6 : replace_call_with_value (gsi, haystack);
2333 : 6 : return true;
2334 : : }
2335 : :
2336 : : /* Transform strstr (x, "c") into strchr (x, 'c'). */
2337 : 3004 : if (q[1] == '\0')
2338 : : {
2339 : 22 : tree strchr_fn = builtin_decl_implicit (BUILT_IN_STRCHR);
2340 : 22 : if (strchr_fn)
2341 : : {
2342 : 22 : tree c = build_int_cst (integer_type_node, q[0]);
2343 : 22 : gimple *repl = gimple_build_call (strchr_fn, 2, haystack, c);
2344 : 22 : replace_call_with_call_and_fold (gsi, repl);
2345 : 22 : return true;
2346 : : }
2347 : : }
2348 : :
2349 : : return false;
2350 : : }
2351 : :
2352 : : /* Simplify a call to the strcat builtin. DST and SRC are the arguments
2353 : : to the call.
2354 : :
2355 : : Return NULL_TREE if no simplification was possible, otherwise return the
2356 : : simplified form of the call as a tree.
2357 : :
2358 : : The simplified form may be a constant or other expression which
2359 : : computes the same value, but in a more efficient manner (including
2360 : : calls to other builtin functions).
2361 : :
2362 : : The call may contain arguments which need to be evaluated, but
2363 : : which are not useful to determine the result of the call. In
2364 : : this case we return a chain of COMPOUND_EXPRs. The LHS of each
2365 : : COMPOUND_EXPR will be an argument which must be evaluated.
2366 : : COMPOUND_EXPRs are chained through their RHS. The RHS of the last
2367 : : COMPOUND_EXPR in the chain will contain the tree for the simplified
2368 : : form of the builtin function call. */
2369 : :
2370 : : static bool
2371 : 8042 : gimple_fold_builtin_strcat (gimple_stmt_iterator *gsi, tree dst, tree src)
2372 : : {
2373 : 8042 : gimple *stmt = gsi_stmt (*gsi);
2374 : 8042 : location_t loc = gimple_location (stmt);
2375 : :
2376 : 8042 : const char *p = c_getstr (src);
2377 : :
2378 : : /* If the string length is zero, return the dst parameter. */
2379 : 8042 : if (p && *p == '\0')
2380 : : {
2381 : 72 : replace_call_with_value (gsi, dst);
2382 : 72 : return true;
2383 : : }
2384 : :
2385 : 7970 : if (!optimize_bb_for_speed_p (gimple_bb (stmt)))
2386 : : return false;
2387 : :
2388 : : /* See if we can store by pieces into (dst + strlen(dst)). */
2389 : 7325 : tree newdst;
2390 : 7325 : tree strlen_fn = builtin_decl_implicit (BUILT_IN_STRLEN);
2391 : 7325 : tree memcpy_fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
2392 : :
2393 : 7325 : if (!strlen_fn || !memcpy_fn)
2394 : : return false;
2395 : :
2396 : : /* If the length of the source string isn't computable don't
2397 : : split strcat into strlen and memcpy. */
2398 : 7325 : tree len = get_maxval_strlen (src, SRK_STRLEN);
2399 : 7325 : if (! len)
2400 : : return false;
2401 : :
2402 : : /* Create strlen (dst). */
2403 : 759 : gimple_seq stmts = NULL, stmts2;
2404 : 759 : gimple *repl = gimple_build_call (strlen_fn, 1, dst);
2405 : 759 : gimple_set_location (repl, loc);
2406 : 759 : newdst = create_tmp_reg_or_ssa_name (size_type_node);
2407 : 759 : gimple_call_set_lhs (repl, newdst);
2408 : 759 : gimple_seq_add_stmt_without_update (&stmts, repl);
2409 : :
2410 : : /* Create (dst p+ strlen (dst)). */
2411 : 759 : newdst = fold_build_pointer_plus_loc (loc, dst, newdst);
2412 : 759 : newdst = force_gimple_operand (newdst, &stmts2, true, NULL_TREE);
2413 : 759 : gimple_seq_add_seq_without_update (&stmts, stmts2);
2414 : :
2415 : 759 : len = fold_convert_loc (loc, size_type_node, len);
2416 : 759 : len = size_binop_loc (loc, PLUS_EXPR, len,
2417 : 759 : build_int_cst (size_type_node, 1));
2418 : 759 : len = force_gimple_operand (len, &stmts2, true, NULL_TREE);
2419 : 759 : gimple_seq_add_seq_without_update (&stmts, stmts2);
2420 : :
2421 : 759 : repl = gimple_build_call (memcpy_fn, 3, newdst, src, len);
2422 : 759 : gimple_seq_add_stmt_without_update (&stmts, repl);
2423 : 759 : if (gimple_call_lhs (stmt))
2424 : : {
2425 : 165 : repl = gimple_build_assign (gimple_call_lhs (stmt), dst);
2426 : 165 : gimple_seq_add_stmt_without_update (&stmts, repl);
2427 : 165 : gsi_replace_with_seq_vops (gsi, stmts);
2428 : : /* gsi now points at the assignment to the lhs, get a
2429 : : stmt iterator to the memcpy call.
2430 : : ??? We can't use gsi_for_stmt as that doesn't work when the
2431 : : CFG isn't built yet. */
2432 : 165 : gimple_stmt_iterator gsi2 = *gsi;
2433 : 165 : gsi_prev (&gsi2);
2434 : 165 : fold_stmt (&gsi2);
2435 : : }
2436 : : else
2437 : : {
2438 : 594 : gsi_replace_with_seq_vops (gsi, stmts);
2439 : 594 : fold_stmt (gsi);
2440 : : }
2441 : : return true;
2442 : : }
2443 : :
2444 : : /* Fold a call to the __strcat_chk builtin FNDECL. DEST, SRC, and SIZE
2445 : : are the arguments to the call. */
2446 : :
2447 : : static bool
2448 : 1872 : gimple_fold_builtin_strcat_chk (gimple_stmt_iterator *gsi)
2449 : : {
2450 : 1872 : gimple *stmt = gsi_stmt (*gsi);
2451 : 1872 : tree dest = gimple_call_arg (stmt, 0);
2452 : 1872 : tree src = gimple_call_arg (stmt, 1);
2453 : 1872 : tree size = gimple_call_arg (stmt, 2);
2454 : 1872 : tree fn;
2455 : 1872 : const char *p;
2456 : :
2457 : :
2458 : 1872 : p = c_getstr (src);
2459 : : /* If the SRC parameter is "", return DEST. */
2460 : 1872 : if (p && *p == '\0')
2461 : : {
2462 : 60 : replace_call_with_value (gsi, dest);
2463 : 60 : return true;
2464 : : }
2465 : :
2466 : 1812 : if (! tree_fits_uhwi_p (size) || ! integer_all_onesp (size))
2467 : 1730 : return false;
2468 : :
2469 : : /* If __builtin_strcat_chk is used, assume strcat is available. */
2470 : 82 : fn = builtin_decl_explicit (BUILT_IN_STRCAT);
2471 : 82 : if (!fn)
2472 : : return false;
2473 : :
2474 : 82 : gimple *repl = gimple_build_call (fn, 2, dest, src);
2475 : 82 : replace_call_with_call_and_fold (gsi, repl);
2476 : 82 : return true;
2477 : : }
2478 : :
2479 : : /* Simplify a call to the strncat builtin. */
2480 : :
2481 : : static bool
2482 : 6605 : gimple_fold_builtin_strncat (gimple_stmt_iterator *gsi)
2483 : : {
2484 : 6605 : gimple *stmt = gsi_stmt (*gsi);
2485 : 6605 : tree dst = gimple_call_arg (stmt, 0);
2486 : 6605 : tree src = gimple_call_arg (stmt, 1);
2487 : 6605 : tree len = gimple_call_arg (stmt, 2);
2488 : 6605 : tree src_len = c_strlen (src, 1);
2489 : :
2490 : : /* If the requested length is zero, or the src parameter string
2491 : : length is zero, return the dst parameter. */
2492 : 6605 : if (integer_zerop (len) || (src_len && integer_zerop (src_len)))
2493 : : {
2494 : 124 : replace_call_with_value (gsi, dst);
2495 : 124 : return true;
2496 : : }
2497 : :
2498 : : /* Return early if the requested len is less than the string length.
2499 : : Warnings will be issued elsewhere later. */
2500 : 6481 : if (!src_len || known_lower (stmt, len, src_len, true))
2501 : 5777 : return false;
2502 : :
2503 : : /* Warn on constant LEN. */
2504 : 704 : if (TREE_CODE (len) == INTEGER_CST)
2505 : : {
2506 : 140 : bool nowarn = warning_suppressed_p (stmt, OPT_Wstringop_overflow_);
2507 : 140 : tree dstsize;
2508 : :
2509 : 140 : if (!nowarn && compute_builtin_object_size (dst, 1, &dstsize)
2510 : 184 : && TREE_CODE (dstsize) == INTEGER_CST)
2511 : : {
2512 : 44 : int cmpdst = tree_int_cst_compare (len, dstsize);
2513 : :
2514 : 44 : if (cmpdst >= 0)
2515 : : {
2516 : 19 : tree fndecl = gimple_call_fndecl (stmt);
2517 : :
2518 : : /* Strncat copies (at most) LEN bytes and always appends
2519 : : the terminating NUL so the specified bound should never
2520 : : be equal to (or greater than) the size of the destination.
2521 : : If it is, the copy could overflow. */
2522 : 19 : location_t loc = gimple_location (stmt);
2523 : 37 : nowarn = warning_at (loc, OPT_Wstringop_overflow_,
2524 : : cmpdst == 0
2525 : : ? G_("%qD specified bound %E equals "
2526 : : "destination size")
2527 : : : G_("%qD specified bound %E exceeds "
2528 : : "destination size %E"),
2529 : : fndecl, len, dstsize);
2530 : 19 : if (nowarn)
2531 : 0 : suppress_warning (stmt, OPT_Wstringop_overflow_);
2532 : : }
2533 : : }
2534 : :
2535 : 140 : if (!nowarn && TREE_CODE (src_len) == INTEGER_CST
2536 : 261 : && tree_int_cst_compare (src_len, len) == 0)
2537 : : {
2538 : 22 : tree fndecl = gimple_call_fndecl (stmt);
2539 : 22 : location_t loc = gimple_location (stmt);
2540 : :
2541 : : /* To avoid possible overflow the specified bound should also
2542 : : not be equal to the length of the source, even when the size
2543 : : of the destination is unknown (it's not an uncommon mistake
2544 : : to specify as the bound to strncpy the length of the source). */
2545 : 22 : if (warning_at (loc, OPT_Wstringop_overflow_,
2546 : : "%qD specified bound %E equals source length",
2547 : : fndecl, len))
2548 : 7 : suppress_warning (stmt, OPT_Wstringop_overflow_);
2549 : : }
2550 : : }
2551 : :
2552 : 704 : if (!known_lower (stmt, src_len, len))
2553 : : return false;
2554 : :
2555 : 6481 : tree fn = builtin_decl_implicit (BUILT_IN_STRCAT);
2556 : :
2557 : : /* If the replacement _DECL isn't initialized, don't do the
2558 : : transformation. */
2559 : 146 : if (!fn)
2560 : : return false;
2561 : :
2562 : : /* Otherwise, emit a call to strcat. */
2563 : 146 : gcall *repl = gimple_build_call (fn, 2, dst, src);
2564 : 146 : replace_call_with_call_and_fold (gsi, repl);
2565 : 146 : return true;
2566 : : }
2567 : :
2568 : : /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
2569 : : LEN, and SIZE. */
2570 : :
2571 : : static bool
2572 : 1262 : gimple_fold_builtin_strncat_chk (gimple_stmt_iterator *gsi)
2573 : : {
2574 : 1262 : gimple *stmt = gsi_stmt (*gsi);
2575 : 1262 : tree dest = gimple_call_arg (stmt, 0);
2576 : 1262 : tree src = gimple_call_arg (stmt, 1);
2577 : 1262 : tree len = gimple_call_arg (stmt, 2);
2578 : 1262 : tree size = gimple_call_arg (stmt, 3);
2579 : 1262 : tree fn;
2580 : 1262 : const char *p;
2581 : :
2582 : 1262 : p = c_getstr (src);
2583 : : /* If the SRC parameter is "" or if LEN is 0, return DEST. */
2584 : 324 : if ((p && *p == '\0')
2585 : 1535 : || integer_zerop (len))
2586 : : {
2587 : 78 : replace_call_with_value (gsi, dest);
2588 : 78 : return true;
2589 : : }
2590 : :
2591 : 1184 : if (! integer_all_onesp (size))
2592 : : {
2593 : 1094 : tree src_len = c_strlen (src, 1);
2594 : 1094 : if (known_lower (stmt, src_len, len))
2595 : : {
2596 : : /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
2597 : 67 : fn = builtin_decl_explicit (BUILT_IN_STRCAT_CHK);
2598 : 67 : if (!fn)
2599 : : return false;
2600 : :
2601 : 67 : gimple *repl = gimple_build_call (fn, 3, dest, src, size);
2602 : 67 : replace_call_with_call_and_fold (gsi, repl);
2603 : 67 : return true;
2604 : : }
2605 : : return false;
2606 : : }
2607 : :
2608 : : /* If __builtin_strncat_chk is used, assume strncat is available. */
2609 : 90 : fn = builtin_decl_explicit (BUILT_IN_STRNCAT);
2610 : 90 : if (!fn)
2611 : : return false;
2612 : :
2613 : 90 : gimple *repl = gimple_build_call (fn, 3, dest, src, len);
2614 : 90 : replace_call_with_call_and_fold (gsi, repl);
2615 : 90 : return true;
2616 : : }
2617 : :
2618 : : /* Build and append gimple statements to STMTS that would load a first
2619 : : character of a memory location identified by STR. LOC is location
2620 : : of the statement. */
2621 : :
2622 : : static tree
2623 : 436 : gimple_load_first_char (location_t loc, tree str, gimple_seq *stmts)
2624 : : {
2625 : 436 : tree var;
2626 : :
2627 : 436 : tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
2628 : 436 : tree cst_uchar_ptr_node
2629 : 436 : = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
2630 : 436 : tree off0 = build_int_cst (cst_uchar_ptr_node, 0);
2631 : :
2632 : 436 : tree temp = fold_build2_loc (loc, MEM_REF, cst_uchar_node, str, off0);
2633 : 436 : gassign *stmt = gimple_build_assign (NULL_TREE, temp);
2634 : 436 : var = create_tmp_reg_or_ssa_name (cst_uchar_node, stmt);
2635 : :
2636 : 436 : gimple_assign_set_lhs (stmt, var);
2637 : 436 : gimple_seq_add_stmt_without_update (stmts, stmt);
2638 : :
2639 : 436 : return var;
2640 : : }
2641 : :
2642 : : /* Fold a call to the str{n}{case}cmp builtin pointed by GSI iterator. */
2643 : :
2644 : : static bool
2645 : 1405479 : gimple_fold_builtin_string_compare (gimple_stmt_iterator *gsi)
2646 : : {
2647 : 1405479 : gimple *stmt = gsi_stmt (*gsi);
2648 : 1405479 : tree callee = gimple_call_fndecl (stmt);
2649 : 1405479 : enum built_in_function fcode = DECL_FUNCTION_CODE (callee);
2650 : :
2651 : 1405479 : tree type = integer_type_node;
2652 : 1405479 : tree str1 = gimple_call_arg (stmt, 0);
2653 : 1405479 : tree str2 = gimple_call_arg (stmt, 1);
2654 : 1405479 : tree lhs = gimple_call_lhs (stmt);
2655 : :
2656 : 1405479 : tree bound_node = NULL_TREE;
2657 : 1405479 : unsigned HOST_WIDE_INT bound = HOST_WIDE_INT_M1U;
2658 : :
2659 : : /* Handle strncmp and strncasecmp functions. */
2660 : 1405479 : if (gimple_call_num_args (stmt) == 3)
2661 : : {
2662 : 23396 : bound_node = gimple_call_arg (stmt, 2);
2663 : 23396 : if (tree_fits_uhwi_p (bound_node))
2664 : 17956 : bound = tree_to_uhwi (bound_node);
2665 : : }
2666 : :
2667 : : /* If the BOUND parameter is zero, return zero. */
2668 : 17956 : if (bound == 0)
2669 : : {
2670 : 4 : replace_call_with_value (gsi, integer_zero_node);
2671 : 4 : return true;
2672 : : }
2673 : :
2674 : : /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
2675 : 1405475 : if (operand_equal_p (str1, str2, 0))
2676 : : {
2677 : 35 : replace_call_with_value (gsi, integer_zero_node);
2678 : 35 : return true;
2679 : : }
2680 : :
2681 : : /* Initially set to the number of characters, including the terminating
2682 : : nul if each array has one. LENx == strnlen (Sx, LENx) implies that
2683 : : the array Sx is not terminated by a nul.
2684 : : For nul-terminated strings then adjusted to their length so that
2685 : : LENx == NULPOSx holds. */
2686 : 1405440 : unsigned HOST_WIDE_INT len1 = HOST_WIDE_INT_MAX, len2 = len1;
2687 : 1405440 : const char *p1 = getbyterep (str1, &len1);
2688 : 1405440 : const char *p2 = getbyterep (str2, &len2);
2689 : :
2690 : : /* The position of the terminating nul character if one exists, otherwise
2691 : : a value greater than LENx. */
2692 : 1405440 : unsigned HOST_WIDE_INT nulpos1 = HOST_WIDE_INT_MAX, nulpos2 = nulpos1;
2693 : :
2694 : 1405440 : if (p1)
2695 : : {
2696 : 42657 : size_t n = strnlen (p1, len1);
2697 : 42657 : if (n < len1)
2698 : 42542 : len1 = nulpos1 = n;
2699 : : }
2700 : :
2701 : 1405440 : if (p2)
2702 : : {
2703 : 1377785 : size_t n = strnlen (p2, len2);
2704 : 1377785 : if (n < len2)
2705 : 1377721 : len2 = nulpos2 = n;
2706 : : }
2707 : :
2708 : : /* For known strings, return an immediate value. */
2709 : 1405440 : if (p1 && p2)
2710 : : {
2711 : 39371 : int r = 0;
2712 : 39371 : bool known_result = false;
2713 : :
2714 : 39371 : switch (fcode)
2715 : : {
2716 : 38172 : case BUILT_IN_STRCMP:
2717 : 38172 : case BUILT_IN_STRCMP_EQ:
2718 : 38172 : if (len1 != nulpos1 || len2 != nulpos2)
2719 : : break;
2720 : :
2721 : 38144 : r = strcmp (p1, p2);
2722 : 38144 : known_result = true;
2723 : 38144 : break;
2724 : :
2725 : 1118 : case BUILT_IN_STRNCMP:
2726 : 1118 : case BUILT_IN_STRNCMP_EQ:
2727 : 1118 : {
2728 : 1118 : if (bound == HOST_WIDE_INT_M1U)
2729 : : break;
2730 : :
2731 : : /* Reduce the bound to be no more than the length
2732 : : of the shorter of the two strings, or the sizes
2733 : : of the unterminated arrays. */
2734 : 38 : unsigned HOST_WIDE_INT n = bound;
2735 : :
2736 : 38 : if (len1 == nulpos1 && len1 < n)
2737 : 4 : n = len1 + 1;
2738 : 38 : if (len2 == nulpos2 && len2 < n)
2739 : 11 : n = len2 + 1;
2740 : :
2741 : 38 : if (MIN (nulpos1, nulpos2) + 1 < n)
2742 : : break;
2743 : :
2744 : 38 : r = strncmp (p1, p2, n);
2745 : 38 : known_result = true;
2746 : 38 : break;
2747 : : }
2748 : : /* Only handleable situation is where the string are equal (result 0),
2749 : : which is already handled by operand_equal_p case. */
2750 : : case BUILT_IN_STRCASECMP:
2751 : : break;
2752 : 41 : case BUILT_IN_STRNCASECMP:
2753 : 41 : {
2754 : 41 : if (bound == HOST_WIDE_INT_M1U)
2755 : : break;
2756 : 41 : r = strncmp (p1, p2, bound);
2757 : 41 : if (r == 0)
2758 : : known_result = true;
2759 : : break;
2760 : : }
2761 : 0 : default:
2762 : 0 : gcc_unreachable ();
2763 : : }
2764 : :
2765 : 38182 : if (known_result)
2766 : : {
2767 : 38182 : replace_call_with_value (gsi, build_cmp_result (type, r));
2768 : 38182 : return true;
2769 : : }
2770 : : }
2771 : :
2772 : 2734516 : bool nonzero_bound = (bound >= 1 && bound < HOST_WIDE_INT_M1U)
2773 : 1349457 : || fcode == BUILT_IN_STRCMP
2774 : 1349457 : || fcode == BUILT_IN_STRCMP_EQ
2775 : 1372893 : || fcode == BUILT_IN_STRCASECMP;
2776 : :
2777 : 1367258 : location_t loc = gimple_location (stmt);
2778 : :
2779 : : /* If the second arg is "", return *(const unsigned char*)arg1. */
2780 : 1367258 : if (p2 && *p2 == '\0' && nonzero_bound)
2781 : : {
2782 : 142 : gimple_seq stmts = NULL;
2783 : 142 : tree var = gimple_load_first_char (loc, str1, &stmts);
2784 : 142 : if (lhs)
2785 : : {
2786 : 142 : stmt = gimple_build_assign (lhs, NOP_EXPR, var);
2787 : 142 : gimple_seq_add_stmt_without_update (&stmts, stmt);
2788 : : }
2789 : :
2790 : 142 : gsi_replace_with_seq_vops (gsi, stmts);
2791 : 142 : return true;
2792 : : }
2793 : :
2794 : : /* If the first arg is "", return -*(const unsigned char*)arg2. */
2795 : 1367116 : if (p1 && *p1 == '\0' && nonzero_bound)
2796 : : {
2797 : 86 : gimple_seq stmts = NULL;
2798 : 86 : tree var = gimple_load_first_char (loc, str2, &stmts);
2799 : :
2800 : 86 : if (lhs)
2801 : : {
2802 : 86 : tree c = create_tmp_reg_or_ssa_name (integer_type_node);
2803 : 86 : stmt = gimple_build_assign (c, NOP_EXPR, var);
2804 : 86 : gimple_seq_add_stmt_without_update (&stmts, stmt);
2805 : :
2806 : 86 : stmt = gimple_build_assign (lhs, NEGATE_EXPR, c);
2807 : 86 : gimple_seq_add_stmt_without_update (&stmts, stmt);
2808 : : }
2809 : :
2810 : 86 : gsi_replace_with_seq_vops (gsi, stmts);
2811 : 86 : return true;
2812 : : }
2813 : :
2814 : : /* If BOUND is one, return an expression corresponding to
2815 : : (*(const unsigned char*)arg2 - *(const unsigned char*)arg1). */
2816 : 1367030 : if (fcode == BUILT_IN_STRNCMP && bound == 1)
2817 : : {
2818 : 104 : gimple_seq stmts = NULL;
2819 : 104 : tree temp1 = gimple_load_first_char (loc, str1, &stmts);
2820 : 104 : tree temp2 = gimple_load_first_char (loc, str2, &stmts);
2821 : :
2822 : 104 : if (lhs)
2823 : : {
2824 : 101 : tree c1 = create_tmp_reg_or_ssa_name (integer_type_node);
2825 : 101 : gassign *convert1 = gimple_build_assign (c1, NOP_EXPR, temp1);
2826 : 101 : gimple_seq_add_stmt_without_update (&stmts, convert1);
2827 : :
2828 : 101 : tree c2 = create_tmp_reg_or_ssa_name (integer_type_node);
2829 : 101 : gassign *convert2 = gimple_build_assign (c2, NOP_EXPR, temp2);
2830 : 101 : gimple_seq_add_stmt_without_update (&stmts, convert2);
2831 : :
2832 : 101 : stmt = gimple_build_assign (lhs, MINUS_EXPR, c1, c2);
2833 : 101 : gimple_seq_add_stmt_without_update (&stmts, stmt);
2834 : : }
2835 : :
2836 : 104 : gsi_replace_with_seq_vops (gsi, stmts);
2837 : 104 : return true;
2838 : : }
2839 : :
2840 : : /* If BOUND is greater than the length of one constant string,
2841 : : and the other argument is also a nul-terminated string, replace
2842 : : strncmp with strcmp. */
2843 : 1366926 : if (fcode == BUILT_IN_STRNCMP
2844 : 1366926 : && bound > 0 && bound < HOST_WIDE_INT_M1U
2845 : 12575 : && ((p2 && len2 < bound && len2 == nulpos2)
2846 : 12357 : || (p1 && len1 < bound && len1 == nulpos1)))
2847 : : {
2848 : 284 : tree fn = builtin_decl_implicit (BUILT_IN_STRCMP);
2849 : 284 : if (!fn)
2850 : : return false;
2851 : 284 : gimple *repl = gimple_build_call (fn, 2, str1, str2);
2852 : 284 : replace_call_with_call_and_fold (gsi, repl);
2853 : 284 : return true;
2854 : : }
2855 : :
2856 : : return false;
2857 : : }
2858 : :
2859 : : /* Fold a call to the memchr pointed by GSI iterator. */
2860 : :
2861 : : static bool
2862 : 23080 : gimple_fold_builtin_memchr (gimple_stmt_iterator *gsi)
2863 : : {
2864 : 23080 : gimple *stmt = gsi_stmt (*gsi);
2865 : 23080 : tree lhs = gimple_call_lhs (stmt);
2866 : 23080 : tree arg1 = gimple_call_arg (stmt, 0);
2867 : 23080 : tree arg2 = gimple_call_arg (stmt, 1);
2868 : 23080 : tree len = gimple_call_arg (stmt, 2);
2869 : :
2870 : : /* If the LEN parameter is zero, return zero. */
2871 : 23080 : if (integer_zerop (len))
2872 : : {
2873 : 1 : replace_call_with_value (gsi, build_int_cst (ptr_type_node, 0));
2874 : 1 : return true;
2875 : : }
2876 : :
2877 : 23079 : char c;
2878 : 23079 : if (TREE_CODE (arg2) != INTEGER_CST
2879 : 12668 : || !tree_fits_uhwi_p (len)
2880 : 23790 : || !target_char_cst_p (arg2, &c))
2881 : 22368 : return false;
2882 : :
2883 : 711 : unsigned HOST_WIDE_INT length = tree_to_uhwi (len);
2884 : 711 : unsigned HOST_WIDE_INT string_length;
2885 : 711 : const char *p1 = getbyterep (arg1, &string_length);
2886 : :
2887 : 711 : if (p1)
2888 : : {
2889 : 96 : const char *r = (const char *)memchr (p1, c, MIN (length, string_length));
2890 : 96 : if (r == NULL)
2891 : : {
2892 : 15 : tree mem_size, offset_node;
2893 : 15 : byte_representation (arg1, &offset_node, &mem_size, NULL);
2894 : 30 : unsigned HOST_WIDE_INT offset = (offset_node == NULL_TREE)
2895 : 15 : ? 0 : tree_to_uhwi (offset_node);
2896 : : /* MEM_SIZE is the size of the array the string literal
2897 : : is stored in. */
2898 : 15 : unsigned HOST_WIDE_INT string_size = tree_to_uhwi (mem_size) - offset;
2899 : 15 : gcc_checking_assert (string_length <= string_size);
2900 : 15 : if (length <= string_size)
2901 : : {
2902 : 3 : replace_call_with_value (gsi, build_int_cst (ptr_type_node, 0));
2903 : 3 : return true;
2904 : : }
2905 : : }
2906 : : else
2907 : : {
2908 : 81 : unsigned HOST_WIDE_INT offset = r - p1;
2909 : 81 : gimple_seq stmts = NULL;
2910 : 81 : if (lhs != NULL_TREE)
2911 : : {
2912 : 79 : tree offset_cst = build_int_cst (sizetype, offset);
2913 : 79 : gassign *stmt = gimple_build_assign (lhs, POINTER_PLUS_EXPR,
2914 : : arg1, offset_cst);
2915 : 79 : gimple_seq_add_stmt_without_update (&stmts, stmt);
2916 : : }
2917 : : else
2918 : 2 : gimple_seq_add_stmt_without_update (&stmts,
2919 : : gimple_build_nop ());
2920 : :
2921 : 81 : gsi_replace_with_seq_vops (gsi, stmts);
2922 : 81 : return true;
2923 : : }
2924 : : }
2925 : :
2926 : : return false;
2927 : : }
2928 : :
2929 : : /* Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments
2930 : : to the call. IGNORE is true if the value returned
2931 : : by the builtin will be ignored. UNLOCKED is true is true if this
2932 : : actually a call to fputs_unlocked. If LEN in non-NULL, it represents
2933 : : the known length of the string. Return NULL_TREE if no simplification
2934 : : was possible. */
2935 : :
2936 : : static bool
2937 : 21494 : gimple_fold_builtin_fputs (gimple_stmt_iterator *gsi,
2938 : : tree arg0, tree arg1,
2939 : : bool unlocked)
2940 : : {
2941 : 21494 : gimple *stmt = gsi_stmt (*gsi);
2942 : :
2943 : : /* If we're using an unlocked function, assume the other unlocked
2944 : : functions exist explicitly. */
2945 : 21494 : tree const fn_fputc = (unlocked
2946 : 21494 : ? builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED)
2947 : 21494 : : builtin_decl_implicit (BUILT_IN_FPUTC));
2948 : 21494 : tree const fn_fwrite = (unlocked
2949 : 21494 : ? builtin_decl_explicit (BUILT_IN_FWRITE_UNLOCKED)
2950 : 21494 : : builtin_decl_implicit (BUILT_IN_FWRITE));
2951 : :
2952 : : /* If the return value is used, don't do the transformation. */
2953 : 21494 : if (gimple_call_lhs (stmt))
2954 : : return false;
2955 : :
2956 : : /* Get the length of the string passed to fputs. If the length
2957 : : can't be determined, punt. */
2958 : 21414 : tree len = get_maxval_strlen (arg0, SRK_STRLEN);
2959 : 21414 : if (!len || TREE_CODE (len) != INTEGER_CST)
2960 : : return false;
2961 : :
2962 : 16479 : switch (compare_tree_int (len, 1))
2963 : : {
2964 : 91 : case -1: /* length is 0, delete the call entirely . */
2965 : 91 : replace_call_with_value (gsi, integer_zero_node);
2966 : 91 : return true;
2967 : :
2968 : 999 : case 0: /* length is 1, call fputc. */
2969 : 999 : {
2970 : 999 : const char *p = c_getstr (arg0);
2971 : 999 : if (p != NULL)
2972 : : {
2973 : 984 : if (!fn_fputc)
2974 : : return false;
2975 : :
2976 : 984 : gimple *repl
2977 : 984 : = gimple_build_call (fn_fputc, 2,
2978 : : build_int_cst (integer_type_node, p[0]),
2979 : : arg1);
2980 : 984 : replace_call_with_call_and_fold (gsi, repl);
2981 : 984 : return true;
2982 : : }
2983 : : }
2984 : : /* FALLTHROUGH */
2985 : 15404 : case 1: /* length is greater than 1, call fwrite. */
2986 : 15404 : {
2987 : : /* If optimizing for size keep fputs. */
2988 : 15404 : if (optimize_function_for_size_p (cfun))
2989 : : return false;
2990 : : /* New argument list transforming fputs(string, stream) to
2991 : : fwrite(string, 1, len, stream). */
2992 : 7768 : if (!fn_fwrite)
2993 : : return false;
2994 : :
2995 : 7768 : gimple *repl
2996 : 7768 : = gimple_build_call (fn_fwrite, 4, arg0, size_one_node,
2997 : : fold_convert (size_type_node, len), arg1);
2998 : 7768 : replace_call_with_call_and_fold (gsi, repl);
2999 : 7768 : return true;
3000 : : }
3001 : 0 : default:
3002 : 0 : gcc_unreachable ();
3003 : : }
3004 : : }
3005 : :
3006 : : /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
3007 : : DEST, SRC, LEN, and SIZE are the arguments to the call.
3008 : : IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
3009 : : code of the builtin. If MAXLEN is not NULL, it is maximum length
3010 : : passed as third argument. */
3011 : :
3012 : : static bool
3013 : 27365 : gimple_fold_builtin_memory_chk (gimple_stmt_iterator *gsi,
3014 : : tree dest, tree src, tree len, tree size,
3015 : : enum built_in_function fcode)
3016 : : {
3017 : 27365 : gimple *stmt = gsi_stmt (*gsi);
3018 : 27365 : location_t loc = gimple_location (stmt);
3019 : 27365 : bool ignore = gimple_call_lhs (stmt) == NULL_TREE;
3020 : 27365 : tree fn;
3021 : :
3022 : : /* If SRC and DEST are the same (and not volatile), return DEST
3023 : : (resp. DEST+LEN for __mempcpy_chk). */
3024 : 27365 : if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
3025 : : {
3026 : 13 : if (fcode != BUILT_IN_MEMPCPY_CHK)
3027 : : {
3028 : 7 : replace_call_with_value (gsi, dest);
3029 : 7 : return true;
3030 : : }
3031 : : else
3032 : : {
3033 : 6 : gimple_seq stmts = NULL;
3034 : 6 : len = gimple_convert_to_ptrofftype (&stmts, loc, len);
3035 : 6 : tree temp = gimple_build (&stmts, loc, POINTER_PLUS_EXPR,
3036 : 6 : TREE_TYPE (dest), dest, len);
3037 : 6 : gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT);
3038 : 6 : replace_call_with_value (gsi, temp);
3039 : 6 : return true;
3040 : : }
3041 : : }
3042 : :
3043 : 27352 : tree maxlen = get_maxval_strlen (len, SRK_INT_VALUE);
3044 : 27352 : if (! integer_all_onesp (size)
3045 : 25789 : && !known_lower (stmt, len, size)
3046 : 46098 : && !known_lower (stmt, maxlen, size))
3047 : : {
3048 : : /* MAXLEN and LEN both cannot be proved to be less than SIZE, at
3049 : : least try to optimize (void) __mempcpy_chk () into
3050 : : (void) __memcpy_chk () */
3051 : 18669 : if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
3052 : : {
3053 : 42 : fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
3054 : 42 : if (!fn)
3055 : : return false;
3056 : :
3057 : 42 : gimple *repl = gimple_build_call (fn, 4, dest, src, len, size);
3058 : 42 : replace_call_with_call_and_fold (gsi, repl);
3059 : 42 : return true;
3060 : : }
3061 : : return false;
3062 : : }
3063 : :
3064 : 8683 : fn = NULL_TREE;
3065 : : /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
3066 : : mem{cpy,pcpy,move,set} is available. */
3067 : 8683 : switch (fcode)
3068 : : {
3069 : 1825 : case BUILT_IN_MEMCPY_CHK:
3070 : 1825 : fn = builtin_decl_explicit (BUILT_IN_MEMCPY);
3071 : 1825 : break;
3072 : 1072 : case BUILT_IN_MEMPCPY_CHK:
3073 : 1072 : fn = builtin_decl_explicit (BUILT_IN_MEMPCPY);
3074 : 1072 : break;
3075 : 1717 : case BUILT_IN_MEMMOVE_CHK:
3076 : 1717 : fn = builtin_decl_explicit (BUILT_IN_MEMMOVE);
3077 : 1717 : break;
3078 : 4069 : case BUILT_IN_MEMSET_CHK:
3079 : 4069 : fn = builtin_decl_explicit (BUILT_IN_MEMSET);
3080 : 4069 : break;
3081 : : default:
3082 : : break;
3083 : : }
3084 : :
3085 : 8683 : if (!fn)
3086 : : return false;
3087 : :
3088 : 8683 : gimple *repl = gimple_build_call (fn, 3, dest, src, len);
3089 : 8683 : replace_call_with_call_and_fold (gsi, repl);
3090 : 8683 : return true;
3091 : : }
3092 : :
3093 : : /* Print a message in the dump file recording transformation of FROM to TO. */
3094 : :
3095 : : static void
3096 : 886 : dump_transformation (gcall *from, gcall *to)
3097 : : {
3098 : 886 : if (dump_enabled_p ())
3099 : 2 : dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, from, "simplified %T to %T\n",
3100 : : gimple_call_fn (from), gimple_call_fn (to));
3101 : 886 : }
3102 : :
3103 : : /* Fold a call to the __st[rp]cpy_chk builtin.
3104 : : DEST, SRC, and SIZE are the arguments to the call.
3105 : : IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_*
3106 : : code of the builtin. If MAXLEN is not NULL, it is maximum length of
3107 : : strings passed as second argument. */
3108 : :
3109 : : static bool
3110 : 2726 : gimple_fold_builtin_stxcpy_chk (gimple_stmt_iterator *gsi,
3111 : : tree dest,
3112 : : tree src, tree size,
3113 : : enum built_in_function fcode)
3114 : : {
3115 : 2726 : gcall *stmt = as_a <gcall *> (gsi_stmt (*gsi));
3116 : 2726 : location_t loc = gimple_location (stmt);
3117 : 2726 : bool ignore = gimple_call_lhs (stmt) == NULL_TREE;
3118 : 2726 : tree len, fn;
3119 : :
3120 : : /* If SRC and DEST are the same (and not volatile), return DEST. */
3121 : 2726 : if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
3122 : : {
3123 : : /* Issue -Wrestrict unless the pointers are null (those do
3124 : : not point to objects and so do not indicate an overlap;
3125 : : such calls could be the result of sanitization and jump
3126 : : threading). */
3127 : 0 : if (!integer_zerop (dest)
3128 : 0 : && !warning_suppressed_p (stmt, OPT_Wrestrict))
3129 : : {
3130 : 0 : tree func = gimple_call_fndecl (stmt);
3131 : :
3132 : 0 : warning_at (loc, OPT_Wrestrict,
3133 : : "%qD source argument is the same as destination",
3134 : : func);
3135 : : }
3136 : :
3137 : 0 : replace_call_with_value (gsi, dest);
3138 : 0 : return true;
3139 : : }
3140 : :
3141 : 2726 : tree maxlen = get_maxval_strlen (src, SRK_STRLENMAX);
3142 : 2726 : if (! integer_all_onesp (size))
3143 : : {
3144 : 2638 : len = c_strlen (src, 1);
3145 : 2638 : if (!known_lower (stmt, len, size, true)
3146 : 2638 : && !known_lower (stmt, maxlen, size, true))
3147 : : {
3148 : 2303 : if (fcode == BUILT_IN_STPCPY_CHK)
3149 : : {
3150 : 1153 : if (! ignore)
3151 : : return false;
3152 : :
3153 : : /* If return value of __stpcpy_chk is ignored,
3154 : : optimize into __strcpy_chk. */
3155 : 37 : fn = builtin_decl_explicit (BUILT_IN_STRCPY_CHK);
3156 : 37 : if (!fn)
3157 : : return false;
3158 : :
3159 : 37 : gimple *repl = gimple_build_call (fn, 3, dest, src, size);
3160 : 37 : replace_call_with_call_and_fold (gsi, repl);
3161 : 37 : return true;
3162 : : }
3163 : :
3164 : 1150 : if (! len || TREE_SIDE_EFFECTS (len))
3165 : : return false;
3166 : :
3167 : : /* If c_strlen returned something, but not provably less than size,
3168 : : transform __strcpy_chk into __memcpy_chk. */
3169 : 106 : fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
3170 : 106 : if (!fn)
3171 : : return false;
3172 : :
3173 : 106 : gimple_seq stmts = NULL;
3174 : 106 : len = force_gimple_operand (len, &stmts, true, NULL_TREE);
3175 : 106 : len = gimple_convert (&stmts, loc, size_type_node, len);
3176 : 106 : len = gimple_build (&stmts, loc, PLUS_EXPR, size_type_node, len,
3177 : 106 : build_int_cst (size_type_node, 1));
3178 : 106 : gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT);
3179 : 106 : gimple *repl = gimple_build_call (fn, 4, dest, src, len, size);
3180 : 106 : replace_call_with_call_and_fold (gsi, repl);
3181 : 106 : return true;
3182 : : }
3183 : : }
3184 : :
3185 : : /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
3186 : 689 : fn = builtin_decl_explicit (fcode == BUILT_IN_STPCPY_CHK && !ignore
3187 : : ? BUILT_IN_STPCPY : BUILT_IN_STRCPY);
3188 : 423 : if (!fn)
3189 : : return false;
3190 : :
3191 : 423 : gcall *repl = gimple_build_call (fn, 2, dest, src);
3192 : 423 : dump_transformation (stmt, repl);
3193 : 423 : replace_call_with_call_and_fold (gsi, repl);
3194 : 423 : return true;
3195 : : }
3196 : :
3197 : : /* Fold a call to the __st{r,p}ncpy_chk builtin. DEST, SRC, LEN, and SIZE
3198 : : are the arguments to the call. If MAXLEN is not NULL, it is maximum
3199 : : length passed as third argument. IGNORE is true if return value can be
3200 : : ignored. FCODE is the BUILT_IN_* code of the builtin. */
3201 : :
3202 : : static bool
3203 : 3133 : gimple_fold_builtin_stxncpy_chk (gimple_stmt_iterator *gsi,
3204 : : tree dest, tree src,
3205 : : tree len, tree size,
3206 : : enum built_in_function fcode)
3207 : : {
3208 : 3133 : gcall *stmt = as_a <gcall *> (gsi_stmt (*gsi));
3209 : 3133 : bool ignore = gimple_call_lhs (stmt) == NULL_TREE;
3210 : 3133 : tree fn;
3211 : :
3212 : 3133 : tree maxlen = get_maxval_strlen (len, SRK_INT_VALUE);
3213 : 3133 : if (! integer_all_onesp (size)
3214 : 3133 : && !known_lower (stmt, len, size) && !known_lower (stmt, maxlen, size))
3215 : : {
3216 : 2670 : if (fcode == BUILT_IN_STPNCPY_CHK && ignore)
3217 : : {
3218 : : /* If return value of __stpncpy_chk is ignored,
3219 : : optimize into __strncpy_chk. */
3220 : 215 : fn = builtin_decl_explicit (BUILT_IN_STRNCPY_CHK);
3221 : 215 : if (fn)
3222 : : {
3223 : 215 : gimple *repl = gimple_build_call (fn, 4, dest, src, len, size);
3224 : 215 : replace_call_with_call_and_fold (gsi, repl);
3225 : 215 : return true;
3226 : : }
3227 : : }
3228 : : return false;
3229 : : }
3230 : :
3231 : : /* If __builtin_st{r,p}ncpy_chk is used, assume st{r,p}ncpy is available. */
3232 : 816 : fn = builtin_decl_explicit (fcode == BUILT_IN_STPNCPY_CHK && !ignore
3233 : : ? BUILT_IN_STPNCPY : BUILT_IN_STRNCPY);
3234 : 463 : if (!fn)
3235 : : return false;
3236 : :
3237 : 463 : gcall *repl = gimple_build_call (fn, 3, dest, src, len);
3238 : 463 : dump_transformation (stmt, repl);
3239 : 463 : replace_call_with_call_and_fold (gsi, repl);
3240 : 463 : return true;
3241 : : }
3242 : :
3243 : : /* Fold function call to builtin stpcpy with arguments DEST and SRC.
3244 : : Return NULL_TREE if no simplification can be made. */
3245 : :
3246 : : static bool
3247 : 4333 : gimple_fold_builtin_stpcpy (gimple_stmt_iterator *gsi)
3248 : : {
3249 : 4333 : gcall *stmt = as_a <gcall *> (gsi_stmt (*gsi));
3250 : 4333 : location_t loc = gimple_location (stmt);
3251 : 4333 : tree dest = gimple_call_arg (stmt, 0);
3252 : 4333 : tree src = gimple_call_arg (stmt, 1);
3253 : 4333 : tree fn, lenp1;
3254 : :
3255 : : /* If the result is unused, replace stpcpy with strcpy. */
3256 : 4333 : if (gimple_call_lhs (stmt) == NULL_TREE)
3257 : : {
3258 : 30 : tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
3259 : 30 : if (!fn)
3260 : : return false;
3261 : 30 : gimple_call_set_fndecl (stmt, fn);
3262 : 30 : fold_stmt (gsi);
3263 : 30 : return true;
3264 : : }
3265 : :
3266 : : /* Set to non-null if ARG refers to an unterminated array. */
3267 : 4303 : c_strlen_data data = { };
3268 : : /* The size of the unterminated array if SRC referes to one. */
3269 : 4303 : tree size;
3270 : : /* True if the size is exact/constant, false if it's the lower bound
3271 : : of a range. */
3272 : 4303 : bool exact;
3273 : 4303 : tree len = c_strlen (src, 1, &data, 1);
3274 : 4303 : if (!len
3275 : 757 : || TREE_CODE (len) != INTEGER_CST)
3276 : : {
3277 : 3806 : data.decl = unterminated_array (src, &size, &exact);
3278 : 3806 : if (!data.decl)
3279 : : return false;
3280 : : }
3281 : :
3282 : 1172 : if (data.decl)
3283 : : {
3284 : : /* Avoid folding calls with unterminated arrays. */
3285 : 675 : if (!warning_suppressed_p (stmt, OPT_Wstringop_overread))
3286 : 75 : warn_string_no_nul (loc, stmt, "stpcpy", src, data.decl, size,
3287 : : exact);
3288 : 675 : suppress_warning (stmt, OPT_Wstringop_overread);
3289 : 675 : return false;
3290 : : }
3291 : :
3292 : 497 : if (optimize_function_for_size_p (cfun)
3293 : : /* If length is zero it's small enough. */
3294 : 497 : && !integer_zerop (len))
3295 : : return false;
3296 : :
3297 : : /* If the source has a known length replace stpcpy with memcpy. */
3298 : 4303 : fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
3299 : 290 : if (!fn)
3300 : : return false;
3301 : :
3302 : 290 : gimple_seq stmts = NULL;
3303 : 290 : tree tem = gimple_convert (&stmts, loc, size_type_node, len);
3304 : 290 : lenp1 = gimple_build (&stmts, loc, PLUS_EXPR, size_type_node,
3305 : 290 : tem, build_int_cst (size_type_node, 1));
3306 : 290 : gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT);
3307 : 290 : gcall *repl = gimple_build_call (fn, 3, dest, src, lenp1);
3308 : 290 : gimple_move_vops (repl, stmt);
3309 : 290 : gsi_insert_before (gsi, repl, GSI_SAME_STMT);
3310 : : /* Replace the result with dest + len. */
3311 : 290 : stmts = NULL;
3312 : 290 : tem = gimple_convert (&stmts, loc, sizetype, len);
3313 : 290 : gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT);
3314 : 290 : gassign *ret = gimple_build_assign (gimple_call_lhs (stmt),
3315 : : POINTER_PLUS_EXPR, dest, tem);
3316 : 290 : gsi_replace (gsi, ret, false);
3317 : : /* Finally fold the memcpy call. */
3318 : 290 : gimple_stmt_iterator gsi2 = *gsi;
3319 : 290 : gsi_prev (&gsi2);
3320 : 290 : fold_stmt (&gsi2);
3321 : 290 : return true;
3322 : : }
3323 : :
3324 : : /* Fold a call EXP to {,v}snprintf having NARGS passed as ARGS. Return
3325 : : NULL_TREE if a normal call should be emitted rather than expanding
3326 : : the function inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
3327 : : BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
3328 : : passed as second argument. */
3329 : :
3330 : : static bool
3331 : 2966 : gimple_fold_builtin_snprintf_chk (gimple_stmt_iterator *gsi,
3332 : : enum built_in_function fcode)
3333 : : {
3334 : 2966 : gcall *stmt = as_a <gcall *> (gsi_stmt (*gsi));
3335 : 2966 : tree dest, size, len, fn, fmt, flag;
3336 : 2966 : const char *fmt_str;
3337 : :
3338 : : /* Verify the required arguments in the original call. */
3339 : 2966 : if (gimple_call_num_args (stmt) < 5)
3340 : : return false;
3341 : :
3342 : 2966 : dest = gimple_call_arg (stmt, 0);
3343 : 2966 : len = gimple_call_arg (stmt, 1);
3344 : 2966 : flag = gimple_call_arg (stmt, 2);
3345 : 2966 : size = gimple_call_arg (stmt, 3);
3346 : 2966 : fmt = gimple_call_arg (stmt, 4);
3347 : :
3348 : 2966 : tree maxlen = get_maxval_strlen (len, SRK_INT_VALUE);
3349 : 2966 : if (! integer_all_onesp (size)
3350 : 2966 : && !known_lower (stmt, len, size) && !known_lower (stmt, maxlen, size))
3351 : : return false;
3352 : :
3353 : 314 : if (!init_target_chars ())
3354 : : return false;
3355 : :
3356 : : /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
3357 : : or if format doesn't contain % chars or is "%s". */
3358 : 314 : if (! integer_zerop (flag))
3359 : : {
3360 : 58 : fmt_str = c_getstr (fmt);
3361 : 58 : if (fmt_str == NULL)
3362 : : return false;
3363 : 58 : if (strchr (fmt_str, target_percent) != NULL
3364 : 57 : && strcmp (fmt_str, target_percent_s))
3365 : : return false;
3366 : : }
3367 : :
3368 : : /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
3369 : : available. */
3370 : 415 : fn = builtin_decl_explicit (fcode == BUILT_IN_VSNPRINTF_CHK
3371 : : ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF);
3372 : 259 : if (!fn)
3373 : : return false;
3374 : :
3375 : : /* Replace the called function and the first 5 argument by 3 retaining
3376 : : trailing varargs. */
3377 : 259 : gimple_call_set_fndecl (stmt, fn);
3378 : 259 : gimple_call_set_fntype (stmt, TREE_TYPE (fn));
3379 : 259 : gimple_call_set_arg (stmt, 0, dest);
3380 : 259 : gimple_call_set_arg (stmt, 1, len);
3381 : 259 : gimple_call_set_arg (stmt, 2, fmt);
3382 : 546 : for (unsigned i = 3; i < gimple_call_num_args (stmt) - 2; ++i)
3383 : 287 : gimple_call_set_arg (stmt, i, gimple_call_arg (stmt, i + 2));
3384 : 259 : gimple_set_num_ops (stmt, gimple_num_ops (stmt) - 2);
3385 : 259 : fold_stmt (gsi);
3386 : 259 : return true;
3387 : : }
3388 : :
3389 : : /* Fold a call EXP to __{,v}sprintf_chk having NARGS passed as ARGS.
3390 : : Return NULL_TREE if a normal call should be emitted rather than
3391 : : expanding the function inline. FCODE is either BUILT_IN_SPRINTF_CHK
3392 : : or BUILT_IN_VSPRINTF_CHK. */
3393 : :
3394 : : static bool
3395 : 5147 : gimple_fold_builtin_sprintf_chk (gimple_stmt_iterator *gsi,
3396 : : enum built_in_function fcode)
3397 : : {
3398 : 5147 : gcall *stmt = as_a <gcall *> (gsi_stmt (*gsi));
3399 : 5147 : tree dest, size, len, fn, fmt, flag;
3400 : 5147 : const char *fmt_str;
3401 : 5147 : unsigned nargs = gimple_call_num_args (stmt);
3402 : :
3403 : : /* Verify the required arguments in the original call. */
3404 : 5147 : if (nargs < 4)
3405 : : return false;
3406 : 5147 : dest = gimple_call_arg (stmt, 0);
3407 : 5147 : flag = gimple_call_arg (stmt, 1);
3408 : 5147 : size = gimple_call_arg (stmt, 2);
3409 : 5147 : fmt = gimple_call_arg (stmt, 3);
3410 : :
3411 : 5147 : len = NULL_TREE;
3412 : :
3413 : 5147 : if (!init_target_chars ())
3414 : : return false;
3415 : :
3416 : : /* Check whether the format is a literal string constant. */
3417 : 5147 : fmt_str = c_getstr (fmt);
3418 : 5147 : if (fmt_str != NULL)
3419 : : {
3420 : : /* If the format doesn't contain % args or %%, we know the size. */
3421 : 4723 : if (strchr (fmt_str, target_percent) == 0)
3422 : : {
3423 : 322 : if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
3424 : 322 : len = build_int_cstu (size_type_node, strlen (fmt_str));
3425 : : }
3426 : : /* If the format is "%s" and first ... argument is a string literal,
3427 : : we know the size too. */
3428 : 4401 : else if (fcode == BUILT_IN_SPRINTF_CHK
3429 : 3418 : && strcmp (fmt_str, target_percent_s) == 0)
3430 : : {
3431 : 490 : tree arg;
3432 : :
3433 : 490 : if (nargs == 5)
3434 : : {
3435 : 490 : arg = gimple_call_arg (stmt, 4);
3436 : 490 : if (POINTER_TYPE_P (TREE_TYPE (arg)))
3437 : 454 : len = c_strlen (arg, 1);
3438 : : }
3439 : : }
3440 : : }
3441 : :
3442 : 5147 : if (! integer_all_onesp (size) && !known_lower (stmt, len, size, true))
3443 : : return false;
3444 : :
3445 : : /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
3446 : : or if format doesn't contain % chars or is "%s". */
3447 : 202 : if (! integer_zerop (flag))
3448 : : {
3449 : 1 : if (fmt_str == NULL)
3450 : : return false;
3451 : 1 : if (strchr (fmt_str, target_percent) != NULL
3452 : 0 : && strcmp (fmt_str, target_percent_s))
3453 : : return false;
3454 : : }
3455 : :
3456 : : /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
3457 : 347 : fn = builtin_decl_explicit (fcode == BUILT_IN_VSPRINTF_CHK
3458 : : ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF);
3459 : 202 : if (!fn)
3460 : : return false;
3461 : :
3462 : : /* Replace the called function and the first 4 argument by 2 retaining
3463 : : trailing varargs. */
3464 : 202 : gimple_call_set_fndecl (stmt, fn);
3465 : 202 : gimple_call_set_fntype (stmt, TREE_TYPE (fn));
3466 : 202 : gimple_call_set_arg (stmt, 0, dest);
3467 : 202 : gimple_call_set_arg (stmt, 1, fmt);
3468 : 400 : for (unsigned i = 2; i < gimple_call_num_args (stmt) - 2; ++i)
3469 : 198 : gimple_call_set_arg (stmt, i, gimple_call_arg (stmt, i + 2));
3470 : 202 : gimple_set_num_ops (stmt, gimple_num_ops (stmt) - 2);
3471 : 202 : fold_stmt (gsi);
3472 : 202 : return true;
3473 : : }
3474 : :
3475 : : /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
3476 : : ORIG may be null if this is a 2-argument call. We don't attempt to
3477 : : simplify calls with more than 3 arguments.
3478 : :
3479 : : Return true if simplification was possible, otherwise false. */
3480 : :
3481 : : bool
3482 : 2228 : gimple_fold_builtin_sprintf (gimple_stmt_iterator *gsi)
3483 : : {
3484 : 2228 : gimple *stmt = gsi_stmt (*gsi);
3485 : :
3486 : : /* Verify the required arguments in the original call. We deal with two
3487 : : types of sprintf() calls: 'sprintf (str, fmt)' and
3488 : : 'sprintf (dest, "%s", orig)'. */
3489 : 2228 : if (gimple_call_num_args (stmt) > 3)
3490 : : return false;
3491 : :
3492 : 1840 : tree orig = NULL_TREE;
3493 : 1840 : if (gimple_call_num_args (stmt) == 3)
3494 : 1749 : orig = gimple_call_arg (stmt, 2);
3495 : :
3496 : : /* Check whether the format is a literal string constant. */
3497 : 1840 : tree fmt = gimple_call_arg (stmt, 1);
3498 : 1840 : const char *fmt_str = c_getstr (fmt);
3499 : 1840 : if (fmt_str == NULL)
3500 : : return false;
3501 : :
3502 : 1840 : tree dest = gimple_call_arg (stmt, 0);
3503 : :
3504 : 1840 : if (!init_target_chars ())
3505 : : return false;
3506 : :
3507 : 3219 : tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
3508 : 1840 : if (!fn)
3509 : : return false;
3510 : :
3511 : : /* If the format doesn't contain % args or %%, use strcpy. */
3512 : 1840 : if (strchr (fmt_str, target_percent) == NULL)
3513 : : {
3514 : : /* Don't optimize sprintf (buf, "abc", ptr++). */
3515 : 103 : if (orig)
3516 : : return false;
3517 : :
3518 : : /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
3519 : : 'format' is known to contain no % formats. */
3520 : 90 : gimple_seq stmts = NULL;
3521 : 90 : gimple *repl = gimple_build_call (fn, 2, dest, fmt);
3522 : :
3523 : : /* Propagate the NO_WARNING bit to avoid issuing the same
3524 : : warning more than once. */
3525 : 90 : copy_warning (repl, stmt);
3526 : :
3527 : 90 : gimple_seq_add_stmt_without_update (&stmts, repl);
3528 : 90 : if (tree lhs = gimple_call_lhs (stmt))
3529 : : {
3530 : 0 : repl = gimple_build_assign (lhs, build_int_cst (TREE_TYPE (lhs),
3531 : 0 : strlen (fmt_str)));
3532 : 0 : gimple_seq_add_stmt_without_update (&stmts, repl);
3533 : 0 : gsi_replace_with_seq_vops (gsi, stmts);
3534 : : /* gsi now points at the assignment to the lhs, get a
3535 : : stmt iterator to the memcpy call.
3536 : : ??? We can't use gsi_for_stmt as that doesn't work when the
3537 : : CFG isn't built yet. */
3538 : 0 : gimple_stmt_iterator gsi2 = *gsi;
3539 : 0 : gsi_prev (&gsi2);
3540 : 0 : fold_stmt (&gsi2);
3541 : : }
3542 : : else
3543 : : {
3544 : 90 : gsi_replace_with_seq_vops (gsi, stmts);
3545 : 90 : fold_stmt (gsi);
3546 : : }
3547 : 90 : return true;
3548 : : }
3549 : :
3550 : : /* If the format is "%s", use strcpy if the result isn't used. */
3551 : 1737 : else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
3552 : : {
3553 : : /* Don't crash on sprintf (str1, "%s"). */
3554 : 746 : if (!orig)
3555 : : return false;
3556 : :
3557 : : /* Don't fold calls with source arguments of invalid (nonpointer)
3558 : : types. */
3559 : 745 : if (!POINTER_TYPE_P (TREE_TYPE (orig)))
3560 : : return false;
3561 : :
3562 : 739 : tree orig_len = NULL_TREE;
3563 : 739 : if (gimple_call_lhs (stmt))
3564 : : {
3565 : 17 : orig_len = get_maxval_strlen (orig, SRK_STRLEN);
3566 : 17 : if (!orig_len)
3567 : : return false;
3568 : : }
3569 : :
3570 : : /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
3571 : 722 : gimple_seq stmts = NULL;
3572 : 722 : gimple *repl = gimple_build_call (fn, 2, dest, orig);
3573 : :
3574 : : /* Propagate the NO_WARNING bit to avoid issuing the same
3575 : : warning more than once. */
3576 : 722 : copy_warning (repl, stmt);
3577 : :
3578 : 722 : gimple_seq_add_stmt_without_update (&stmts, repl);
3579 : 722 : if (tree lhs = gimple_call_lhs (stmt))
3580 : : {
3581 : 0 : if (!useless_type_conversion_p (TREE_TYPE (lhs),
3582 : 0 : TREE_TYPE (orig_len)))
3583 : 0 : orig_len = fold_convert (TREE_TYPE (lhs), orig_len);
3584 : 0 : repl = gimple_build_assign (lhs, orig_len);
3585 : 0 : gimple_seq_add_stmt_without_update (&stmts, repl);
3586 : 0 : gsi_replace_with_seq_vops (gsi, stmts);
3587 : : /* gsi now points at the assignment to the lhs, get a
3588 : : stmt iterator to the memcpy call.
3589 : : ??? We can't use gsi_for_stmt as that doesn't work when the
3590 : : CFG isn't built yet. */
3591 : 0 : gimple_stmt_iterator gsi2 = *gsi;
3592 : 0 : gsi_prev (&gsi2);
3593 : 0 : fold_stmt (&gsi2);
3594 : : }
3595 : : else
3596 : : {
3597 : 722 : gsi_replace_with_seq_vops (gsi, stmts);
3598 : 722 : fold_stmt (gsi);
3599 : : }
3600 : 722 : return true;
3601 : : }
3602 : : return false;
3603 : : }
3604 : :
3605 : : /* Simplify a call to the snprintf builtin with arguments DEST, DESTSIZE,
3606 : : FMT, and ORIG. ORIG may be null if this is a 3-argument call. We don't
3607 : : attempt to simplify calls with more than 4 arguments.
3608 : :
3609 : : Return true if simplification was possible, otherwise false. */
3610 : :
3611 : : bool
3612 : 1483 : gimple_fold_builtin_snprintf (gimple_stmt_iterator *gsi)
3613 : : {
3614 : 1483 : gcall *stmt = as_a <gcall *> (gsi_stmt (*gsi));
3615 : 1483 : tree dest = gimple_call_arg (stmt, 0);
3616 : 1483 : tree destsize = gimple_call_arg (stmt, 1);
3617 : 1483 : tree fmt = gimple_call_arg (stmt, 2);
3618 : 1483 : tree orig = NULL_TREE;
3619 : 1483 : const char *fmt_str = NULL;
3620 : :
3621 : 1483 : if (gimple_call_num_args (stmt) > 4)
3622 : : return false;
3623 : :
3624 : 688 : if (gimple_call_num_args (stmt) == 4)
3625 : 569 : orig = gimple_call_arg (stmt, 3);
3626 : :
3627 : : /* Check whether the format is a literal string constant. */
3628 : 688 : fmt_str = c_getstr (fmt);
3629 : 688 : if (fmt_str == NULL)
3630 : : return false;
3631 : :
3632 : 688 : if (!init_target_chars ())
3633 : : return false;
3634 : :
3635 : : /* If the format doesn't contain % args or %%, use strcpy. */
3636 : 688 : if (strchr (fmt_str, target_percent) == NULL)
3637 : : {
3638 : 148 : tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
3639 : 118 : if (!fn)
3640 : : return false;
3641 : :
3642 : : /* Don't optimize snprintf (buf, 4, "abc", ptr++). */
3643 : 118 : if (orig)
3644 : : return false;
3645 : :
3646 : 118 : tree len = build_int_cstu (TREE_TYPE (destsize), strlen (fmt_str));
3647 : :
3648 : : /* We could expand this as
3649 : : memcpy (str, fmt, cst - 1); str[cst - 1] = '\0';
3650 : : or to
3651 : : memcpy (str, fmt_with_nul_at_cstm1, cst);
3652 : : but in the former case that might increase code size
3653 : : and in the latter case grow .rodata section too much.
3654 : : So punt for now. */
3655 : 118 : if (!known_lower (stmt, len, destsize, true))
3656 : : return false;
3657 : :
3658 : 88 : gimple_seq stmts = NULL;
3659 : 88 : gimple *repl = gimple_build_call (fn, 2, dest, fmt);
3660 : 88 : gimple_seq_add_stmt_without_update (&stmts, repl);
3661 : 88 : if (tree lhs = gimple_call_lhs (stmt))
3662 : : {
3663 : 0 : repl = gimple_build_assign (lhs,
3664 : 0 : fold_convert (TREE_TYPE (lhs), len));
3665 : 0 : gimple_seq_add_stmt_without_update (&stmts, repl);
3666 : 0 : gsi_replace_with_seq_vops (gsi, stmts);
3667 : : /* gsi now points at the assignment to the lhs, get a
3668 : : stmt iterator to the memcpy call.
3669 : : ??? We can't use gsi_for_stmt as that doesn't work when the
3670 : : CFG isn't built yet. */
3671 : 0 : gimple_stmt_iterator gsi2 = *gsi;
3672 : 0 : gsi_prev (&gsi2);
3673 : 0 : fold_stmt (&gsi2);
3674 : : }
3675 : : else
3676 : : {
3677 : 88 : gsi_replace_with_seq_vops (gsi, stmts);
3678 : 88 : fold_stmt (gsi);
3679 : : }
3680 : 88 : return true;
3681 : : }
3682 : :
3683 : : /* If the format is "%s", use strcpy if the result isn't used. */
3684 : 570 : else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
3685 : : {
3686 : 292 : tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
3687 : 174 : if (!fn)
3688 : : return false;
3689 : :
3690 : : /* Don't crash on snprintf (str1, cst, "%s"). */
3691 : 174 : if (!orig)
3692 : : return false;
3693 : :
3694 : 174 : tree orig_len = get_maxval_strlen (orig, SRK_STRLEN);
3695 : :
3696 : : /* We could expand this as
3697 : : memcpy (str1, str2, cst - 1); str1[cst - 1] = '\0';
3698 : : or to
3699 : : memcpy (str1, str2_with_nul_at_cstm1, cst);
3700 : : but in the former case that might increase code size
3701 : : and in the latter case grow .rodata section too much.
3702 : : So punt for now. */
3703 : 174 : if (!known_lower (stmt, orig_len, destsize, true))
3704 : : return false;
3705 : :
3706 : : /* Convert snprintf (str1, cst, "%s", str2) into
3707 : : strcpy (str1, str2) if strlen (str2) < cst. */
3708 : 56 : gimple_seq stmts = NULL;
3709 : 56 : gimple *repl = gimple_build_call (fn, 2, dest, orig);
3710 : 56 : gimple_seq_add_stmt_without_update (&stmts, repl);
3711 : 56 : if (tree lhs = gimple_call_lhs (stmt))
3712 : : {
3713 : 0 : if (!useless_type_conversion_p (TREE_TYPE (lhs),
3714 : 0 : TREE_TYPE (orig_len)))
3715 : 0 : orig_len = fold_convert (TREE_TYPE (lhs), orig_len);
3716 : 0 : repl = gimple_build_assign (lhs, orig_len);
3717 : 0 : gimple_seq_add_stmt_without_update (&stmts, repl);
3718 : 0 : gsi_replace_with_seq_vops (gsi, stmts);
3719 : : /* gsi now points at the assignment to the lhs, get a
3720 : : stmt iterator to the memcpy call.
3721 : : ??? We can't use gsi_for_stmt as that doesn't work when the
3722 : : CFG isn't built yet. */
3723 : 0 : gimple_stmt_iterator gsi2 = *gsi;
3724 : 0 : gsi_prev (&gsi2);
3725 : 0 : fold_stmt (&gsi2);
3726 : : }
3727 : : else
3728 : : {
3729 : 56 : gsi_replace_with_seq_vops (gsi, stmts);
3730 : 56 : fold_stmt (gsi);
3731 : : }
3732 : 56 : return true;
3733 : : }
3734 : : return false;
3735 : : }
3736 : :
3737 : : /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
3738 : : FP, FMT, and ARG are the arguments to the call. We don't fold calls with
3739 : : more than 3 arguments, and ARG may be null in the 2-argument case.
3740 : :
3741 : : Return NULL_TREE if no simplification was possible, otherwise return the
3742 : : simplified form of the call as a tree. FCODE is the BUILT_IN_*
3743 : : code of the function to be simplified. */
3744 : :
3745 : : static bool
3746 : 53266 : gimple_fold_builtin_fprintf (gimple_stmt_iterator *gsi,
3747 : : tree fp, tree fmt, tree arg,
3748 : : enum built_in_function fcode)
3749 : : {
3750 : 53266 : gcall *stmt = as_a <gcall *> (gsi_stmt (*gsi));
3751 : 53266 : tree fn_fputc, fn_fputs;
3752 : 53266 : const char *fmt_str = NULL;
3753 : :
3754 : : /* If the return value is used, don't do the transformation. */
3755 : 53266 : if (gimple_call_lhs (stmt) != NULL_TREE)
3756 : : return false;
3757 : :
3758 : : /* Check whether the format is a literal string constant. */
3759 : 48577 : fmt_str = c_getstr (fmt);
3760 : 48577 : if (fmt_str == NULL)
3761 : : return false;
3762 : :
3763 : 48325 : if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
3764 : : {
3765 : : /* If we're using an unlocked function, assume the other
3766 : : unlocked functions exist explicitly. */
3767 : 86 : fn_fputc = builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED);
3768 : 86 : fn_fputs = builtin_decl_explicit (BUILT_IN_FPUTS_UNLOCKED);
3769 : : }
3770 : : else
3771 : : {
3772 : 48239 : fn_fputc = builtin_decl_implicit (BUILT_IN_FPUTC);
3773 : 48239 : fn_fputs = builtin_decl_implicit (BUILT_IN_FPUTS);
3774 : : }
3775 : :
3776 : 48325 : if (!init_target_chars ())
3777 : : return false;
3778 : :
3779 : : /* If the format doesn't contain % args or %%, use strcpy. */
3780 : 48325 : if (strchr (fmt_str, target_percent) == NULL)
3781 : : {
3782 : 9091 : if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
3783 : 9021 : && arg)
3784 : : return false;
3785 : :
3786 : : /* If the format specifier was "", fprintf does nothing. */
3787 : 9091 : if (fmt_str[0] == '\0')
3788 : : {
3789 : 58 : replace_call_with_value (gsi, NULL_TREE);
3790 : 58 : return true;
3791 : : }
3792 : :
3793 : : /* When "string" doesn't contain %, replace all cases of
3794 : : fprintf (fp, string) with fputs (string, fp). The fputs
3795 : : builtin will take care of special cases like length == 1. */
3796 : 9033 : if (fn_fputs)
3797 : : {
3798 : 9033 : gcall *repl = gimple_build_call (fn_fputs, 2, fmt, fp);
3799 : 9033 : replace_call_with_call_and_fold (gsi, repl);
3800 : 9033 : return true;
3801 : : }
3802 : : }
3803 : :
3804 : : /* The other optimizations can be done only on the non-va_list variants. */
3805 : 39234 : else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
3806 : : return false;
3807 : :
3808 : : /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
3809 : 38027 : else if (strcmp (fmt_str, target_percent_s) == 0)
3810 : : {
3811 : 636 : if (!arg || ! POINTER_TYPE_P (TREE_TYPE (arg)))
3812 : : return false;
3813 : 636 : if (fn_fputs)
3814 : : {
3815 : 636 : gcall *repl = gimple_build_call (fn_fputs, 2, arg, fp);
3816 : 636 : replace_call_with_call_and_fold (gsi, repl);
3817 : 636 : return true;
3818 : : }
3819 : : }
3820 : :
3821 : : /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
3822 : 37391 : else if (strcmp (fmt_str, target_percent_c) == 0)
3823 : : {
3824 : 49 : if (!arg
3825 : 49 : || ! useless_type_conversion_p (integer_type_node, TREE_TYPE (arg)))
3826 : 0 : return false;
3827 : 49 : if (fn_fputc)
3828 : : {
3829 : 49 : gcall *repl = gimple_build_call (fn_fputc, 2, arg, fp);
3830 : 49 : replace_call_with_call_and_fold (gsi, repl);
3831 : 49 : return true;
3832 : : }
3833 : : }
3834 : :
3835 : : return false;
3836 : : }
3837 : :
3838 : : /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
3839 : : FMT and ARG are the arguments to the call; we don't fold cases with
3840 : : more than 2 arguments, and ARG may be null if this is a 1-argument case.
3841 : :
3842 : : Return NULL_TREE if no simplification was possible, otherwise return the
3843 : : simplified form of the call as a tree. FCODE is the BUILT_IN_*
3844 : : code of the function to be simplified. */
3845 : :
3846 : : static bool
3847 : 117007 : gimple_fold_builtin_printf (gimple_stmt_iterator *gsi, tree fmt,
3848 : : tree arg, enum built_in_function fcode)
3849 : : {
3850 : 117007 : gcall *stmt = as_a <gcall *> (gsi_stmt (*gsi));
3851 : 117007 : tree fn_putchar, fn_puts, newarg;
3852 : 117007 : const char *fmt_str = NULL;
3853 : :
3854 : : /* If the return value is used, don't do the transformation. */
3855 : 117007 : if (gimple_call_lhs (stmt) != NULL_TREE)
3856 : : return false;
3857 : :
3858 : : /* Check whether the format is a literal string constant. */
3859 : 113511 : fmt_str = c_getstr (fmt);
3860 : 113511 : if (fmt_str == NULL)
3861 : : return false;
3862 : :
3863 : 110218 : if (fcode == BUILT_IN_PRINTF_UNLOCKED)
3864 : : {
3865 : : /* If we're using an unlocked function, assume the other
3866 : : unlocked functions exist explicitly. */
3867 : 86 : fn_putchar = builtin_decl_explicit (BUILT_IN_PUTCHAR_UNLOCKED);
3868 : 86 : fn_puts = builtin_decl_explicit (BUILT_IN_PUTS_UNLOCKED);
3869 : : }
3870 : : else
3871 : : {
3872 : 110132 : fn_putchar = builtin_decl_implicit (BUILT_IN_PUTCHAR);
3873 : 110132 : fn_puts = builtin_decl_implicit (BUILT_IN_PUTS);
3874 : : }
3875 : :
3876 : 110218 : if (!init_target_chars ())
3877 : : return false;
3878 : :
3879 : 110218 : if (strcmp (fmt_str, target_percent_s) == 0
3880 : 103136 : || strchr (fmt_str, target_percent) == NULL)
3881 : : {
3882 : 15510 : const char *str;
3883 : :
3884 : 15510 : if (strcmp (fmt_str, target_percent_s) == 0)
3885 : : {
3886 : 7082 : if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
3887 : : return false;
3888 : :
3889 : 6758 : if (!arg || ! POINTER_TYPE_P (TREE_TYPE (arg)))
3890 : : return false;
3891 : :
3892 : 6753 : str = c_getstr (arg);
3893 : 6753 : if (str == NULL)
3894 : : return false;
3895 : : }
3896 : : else
3897 : : {
3898 : : /* The format specifier doesn't contain any '%' characters. */
3899 : 8428 : if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
3900 : 8285 : && arg)
3901 : : return false;
3902 : : str = fmt_str;
3903 : : }
3904 : :
3905 : : /* If the string was "", printf does nothing. */
3906 : 6206 : if (str[0] == '\0')
3907 : : {
3908 : 110 : replace_call_with_value (gsi, NULL_TREE);
3909 : 110 : return true;
3910 : : }
3911 : :
3912 : : /* If the string has length of 1, call putchar. */
3913 : 6096 : if (str[1] == '\0')
3914 : : {
3915 : : /* Given printf("c"), (where c is any one character,)
3916 : : convert "c"[0] to an int and pass that to the replacement
3917 : : function. */
3918 : 525 : newarg = build_int_cst (integer_type_node, str[0]);
3919 : 525 : if (fn_putchar)
3920 : : {
3921 : 525 : gcall *repl = gimple_build_call (fn_putchar, 1, newarg);
3922 : 525 : replace_call_with_call_and_fold (gsi, repl);
3923 : 525 : return true;
3924 : : }
3925 : : }
3926 : : else
3927 : : {
3928 : : /* If the string was "string\n", call puts("string"). */
3929 : 5571 : size_t len = strlen (str);
3930 : 5571 : if ((unsigned char)str[len - 1] == target_newline
3931 : 4398 : && (size_t) (int) len == len
3932 : 4398 : && (int) len > 0)
3933 : : {
3934 : 4398 : char *newstr;
3935 : :
3936 : : /* Create a NUL-terminated string that's one char shorter
3937 : : than the original, stripping off the trailing '\n'. */
3938 : 4398 : newstr = xstrdup (str);
3939 : 4398 : newstr[len - 1] = '\0';
3940 : 4398 : newarg = build_string_literal (len, newstr);
3941 : 4398 : free (newstr);
3942 : 4398 : if (fn_puts)
3943 : : {
3944 : 4398 : gcall *repl = gimple_build_call (fn_puts, 1, newarg);
3945 : 4398 : replace_call_with_call_and_fold (gsi, repl);
3946 : 4398 : return true;
3947 : : }
3948 : : }
3949 : : else
3950 : : /* We'd like to arrange to call fputs(string,stdout) here,
3951 : : but we need stdout and don't have a way to get it yet. */
3952 : : return false;
3953 : : }
3954 : : }
3955 : :
3956 : : /* The other optimizations can be done only on the non-va_list variants. */
3957 : 94708 : else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
3958 : : return false;
3959 : :
3960 : : /* If the format specifier was "%s\n", call __builtin_puts(arg). */
3961 : 94429 : else if (strcmp (fmt_str, target_percent_s_newline) == 0)
3962 : : {
3963 : 217 : if (!arg || ! POINTER_TYPE_P (TREE_TYPE (arg)))
3964 : : return false;
3965 : 217 : if (fn_puts)
3966 : : {
3967 : 217 : gcall *repl = gimple_build_call (fn_puts, 1, arg);
3968 : 217 : replace_call_with_call_and_fold (gsi, repl);
3969 : 217 : return true;
3970 : : }
3971 : : }
3972 : :
3973 : : /* If the format specifier was "%c", call __builtin_putchar(arg). */
3974 : 94212 : else if (strcmp (fmt_str, target_percent_c) == 0)
3975 : : {
3976 : 96 : if (!arg || ! useless_type_conversion_p (integer_type_node,
3977 : 48 : TREE_TYPE (arg)))
3978 : 0 : return false;
3979 : 48 : if (fn_putchar)
3980 : : {
3981 : 48 : gcall *repl = gimple_build_call (fn_putchar, 1, arg);
3982 : 48 : replace_call_with_call_and_fold (gsi, repl);
3983 : 48 : return true;
3984 : : }
3985 : : }
3986 : :
3987 : : return false;
3988 : : }
3989 : :
3990 : :
3991 : :
3992 : : /* Fold a call to __builtin_strlen with known length LEN. */
3993 : :
3994 : : static bool
3995 : 155674 : gimple_fold_builtin_strlen (gimple_stmt_iterator *gsi)
3996 : : {
3997 : 155674 : gimple *stmt = gsi_stmt (*gsi);
3998 : 155674 : tree arg = gimple_call_arg (stmt, 0);
3999 : :
4000 : 155674 : wide_int minlen;
4001 : 155674 : wide_int maxlen;
4002 : :
4003 : 155674 : c_strlen_data lendata = { };
4004 : 155674 : if (get_range_strlen (arg, &lendata, /* eltsize = */ 1)
4005 : 37803 : && !lendata.decl
4006 : 34539 : && lendata.minlen && TREE_CODE (lendata.minlen) == INTEGER_CST
4007 : 190108 : && lendata.maxlen && TREE_CODE (lendata.maxlen) == INTEGER_CST)
4008 : : {
4009 : : /* The range of lengths refers to either a single constant
4010 : : string or to the longest and shortest constant string
4011 : : referenced by the argument of the strlen() call, or to
4012 : : the strings that can possibly be stored in the arrays
4013 : : the argument refers to. */
4014 : 34434 : minlen = wi::to_wide (lendata.minlen);
4015 : 34434 : maxlen = wi::to_wide (lendata.maxlen);
4016 : : }
4017 : : else
4018 : : {
4019 : 121240 : unsigned prec = TYPE_PRECISION (sizetype);
4020 : :
4021 : 121240 : minlen = wi::shwi (0, prec);
4022 : 121240 : maxlen = wi::to_wide (max_object_size (), prec) - 2;
4023 : : }
4024 : :
4025 : : /* For -fsanitize=address, don't optimize the upper bound of the
4026 : : length to be able to diagnose UB on non-zero terminated arrays. */
4027 : 155674 : if (sanitize_flags_p (SANITIZE_ADDRESS))
4028 : 287 : maxlen = wi::max_value (TYPE_PRECISION (sizetype), UNSIGNED);
4029 : :
4030 : 155674 : if (minlen == maxlen)
4031 : : {
4032 : : /* Fold the strlen call to a constant. */
4033 : 2434 : tree type = TREE_TYPE (lendata.minlen);
4034 : 2434 : tree len = force_gimple_operand_gsi (gsi,
4035 : : wide_int_to_tree (type, minlen),
4036 : : true, NULL, true, GSI_SAME_STMT);
4037 : 2434 : replace_call_with_value (gsi, len);
4038 : 2434 : return true;
4039 : : }
4040 : :
4041 : : /* Set the strlen() range to [0, MAXLEN]. */
4042 : 153240 : if (tree lhs = gimple_call_lhs (stmt))
4043 : 153235 : set_strlen_range (lhs, minlen, maxlen);
4044 : :
4045 : : return false;
4046 : 155674 : }
4047 : :
4048 : : /* Fold a call to __builtin_acc_on_device. */
4049 : :
4050 : : static bool
4051 : 1172 : gimple_fold_builtin_acc_on_device (gimple_stmt_iterator *gsi, tree arg0)
4052 : : {
4053 : : /* Defer folding until we know which compiler we're in. */
4054 : 1172 : if (symtab->state != EXPANSION)
4055 : : return false;
4056 : :
4057 : 224 : unsigned val_host = GOMP_DEVICE_HOST;
4058 : 224 : unsigned val_dev = GOMP_DEVICE_NONE;
4059 : :
4060 : : #ifdef ACCEL_COMPILER
4061 : : val_host = GOMP_DEVICE_NOT_HOST;
4062 : : val_dev = ACCEL_COMPILER_acc_device;
4063 : : #endif
4064 : :
4065 : 224 : location_t loc = gimple_location (gsi_stmt (*gsi));
4066 : :
4067 : 224 : tree host_eq = make_ssa_name (boolean_type_node);
4068 : 224 : gimple *host_ass = gimple_build_assign
4069 : 224 : (host_eq, EQ_EXPR, arg0, build_int_cst (TREE_TYPE (arg0), val_host));
4070 : 224 : gimple_set_location (host_ass, loc);
4071 : 224 : gsi_insert_before (gsi, host_ass, GSI_SAME_STMT);
4072 : :
4073 : 224 : tree dev_eq = make_ssa_name (boolean_type_node);
4074 : 224 : gimple *dev_ass = gimple_build_assign
4075 : 224 : (dev_eq, EQ_EXPR, arg0, build_int_cst (TREE_TYPE (arg0), val_dev));
4076 : 224 : gimple_set_location (dev_ass, loc);
4077 : 224 : gsi_insert_before (gsi, dev_ass, GSI_SAME_STMT);
4078 : :
4079 : 224 : tree result = make_ssa_name (boolean_type_node);
4080 : 224 : gimple *result_ass = gimple_build_assign
4081 : 224 : (result, BIT_IOR_EXPR, host_eq, dev_eq);
4082 : 224 : gimple_set_location (result_ass, loc);
4083 : 224 : gsi_insert_before (gsi, result_ass, GSI_SAME_STMT);
4084 : :
4085 : 224 : replace_call_with_value (gsi, result);
4086 : :
4087 : 224 : return true;
4088 : : }
4089 : :
4090 : : /* Fold realloc (0, n) -> malloc (n). */
4091 : :
4092 : : static bool
4093 : 28092 : gimple_fold_builtin_realloc (gimple_stmt_iterator *gsi)
4094 : : {
4095 : 28092 : gimple *stmt = gsi_stmt (*gsi);
4096 : 28092 : tree arg = gimple_call_arg (stmt, 0);
4097 : 28092 : tree size = gimple_call_arg (stmt, 1);
4098 : :
4099 : 28092 : if (operand_equal_p (arg, null_pointer_node, 0))
4100 : : {
4101 : 1154 : tree fn_malloc = builtin_decl_implicit (BUILT_IN_MALLOC);
4102 : 1154 : if (fn_malloc)
4103 : : {
4104 : 1154 : gcall *repl = gimple_build_call (fn_malloc, 1, size);
4105 : 1154 : replace_call_with_call_and_fold (gsi, repl);
4106 : 1154 : return true;
4107 : : }
4108 : : }
4109 : : return false;
4110 : : }
4111 : :
4112 : : /* Number of bytes into which any type but aggregate, vector or
4113 : : _BitInt types should fit. */
4114 : : static constexpr size_t clear_padding_unit
4115 : : = MAX_BITSIZE_MODE_ANY_MODE / BITS_PER_UNIT;
4116 : : /* Buffer size on which __builtin_clear_padding folding code works. */
4117 : : static const size_t clear_padding_buf_size = 32 * clear_padding_unit;
4118 : :
4119 : : /* Data passed through __builtin_clear_padding folding. */
4120 : : struct clear_padding_struct {
4121 : : location_t loc;
4122 : : /* 0 during __builtin_clear_padding folding, nonzero during
4123 : : clear_type_padding_in_mask. In that case, instead of clearing the
4124 : : non-padding bits in union_ptr array clear the padding bits in there. */
4125 : : bool clear_in_mask;
4126 : : tree base;
4127 : : tree alias_type;
4128 : : gimple_stmt_iterator *gsi;
4129 : : /* Alignment of buf->base + 0. */
4130 : : unsigned align;
4131 : : /* Offset from buf->base. Should be always a multiple of UNITS_PER_WORD. */
4132 : : HOST_WIDE_INT off;
4133 : : /* Number of padding bytes before buf->off that don't have padding clear
4134 : : code emitted yet. */
4135 : : HOST_WIDE_INT padding_bytes;
4136 : : /* The size of the whole object. Never emit code to touch
4137 : : buf->base + buf->sz or following bytes. */
4138 : : HOST_WIDE_INT sz;
4139 : : /* Number of bytes recorded in buf->buf. */
4140 : : size_t size;
4141 : : /* When inside union, instead of emitting code we and bits inside of
4142 : : the union_ptr array. */
4143 : : unsigned char *union_ptr;
4144 : : /* Set bits mean padding bits that need to be cleared by the builtin. */
4145 : : unsigned char buf[clear_padding_buf_size + clear_padding_unit];
4146 : : };
4147 : :
4148 : : /* Emit code to clear padding requested in BUF->buf - set bits
4149 : : in there stand for padding that should be cleared. FULL is true
4150 : : if everything from the buffer should be flushed, otherwise
4151 : : it can leave up to 2 * clear_padding_unit bytes for further
4152 : : processing. */
4153 : :
4154 : : static void
4155 : 29565 : clear_padding_flush (clear_padding_struct *buf, bool full)
4156 : : {
4157 : 29565 : gcc_assert ((clear_padding_unit % UNITS_PER_WORD) == 0);
4158 : 29565 : if (!full && buf->size < 2 * clear_padding_unit)
4159 : 29565 : return;
4160 : 30672 : gcc_assert ((buf->off % UNITS_PER_WORD) == 0);
4161 : 29523 : size_t end = buf->size;
4162 : 29523 : if (!full)
4163 : 42 : end = ((end - clear_padding_unit - 1) / clear_padding_unit
4164 : : * clear_padding_unit);
4165 : 29523 : size_t padding_bytes = buf->padding_bytes;
4166 : 29523 : if (buf->union_ptr)
4167 : : {
4168 : 28756 : if (buf->clear_in_mask)
4169 : : {
4170 : : /* During clear_type_padding_in_mask, clear the padding
4171 : : bits set in buf->buf in the buf->union_ptr mask. */
4172 : 200804 : for (size_t i = 0; i < end; i++)
4173 : : {
4174 : 172459 : if (buf->buf[i] == (unsigned char) ~0)
4175 : 6818 : padding_bytes++;
4176 : : else
4177 : : {
4178 : 165641 : memset (&buf->union_ptr[buf->off + i - padding_bytes],
4179 : : 0, padding_bytes);
4180 : 165641 : padding_bytes = 0;
4181 : 165641 : buf->union_ptr[buf->off + i] &= ~buf->buf[i];
4182 : : }
4183 : : }
4184 : 28345 : if (full)
4185 : : {
4186 : 28345 : memset (&buf->union_ptr[buf->off + end - padding_bytes],
4187 : : 0, padding_bytes);
4188 : 28345 : buf->off = 0;
4189 : 28345 : buf->size = 0;
4190 : 28345 : buf->padding_bytes = 0;
4191 : : }
4192 : : else
4193 : : {
4194 : 0 : memmove (buf->buf, buf->buf + end, buf->size - end);
4195 : 0 : buf->off += end;
4196 : 0 : buf->size -= end;
4197 : 0 : buf->padding_bytes = padding_bytes;
4198 : : }
4199 : 28345 : return;
4200 : : }
4201 : : /* Inside of a union, instead of emitting any code, instead
4202 : : clear all bits in the union_ptr buffer that are clear
4203 : : in buf. Whole padding bytes don't clear anything. */
4204 : 3111 : for (size_t i = 0; i < end; i++)
4205 : : {
4206 : 2700 : if (buf->buf[i] == (unsigned char) ~0)
4207 : 1430 : padding_bytes++;
4208 : : else
4209 : : {
4210 : 1270 : padding_bytes = 0;
4211 : 1270 : buf->union_ptr[buf->off + i] &= buf->buf[i];
4212 : : }
4213 : : }
4214 : 411 : if (full)
4215 : : {
4216 : 411 : buf->off = 0;
4217 : 411 : buf->size = 0;
4218 : 411 : buf->padding_bytes = 0;
4219 : : }
4220 : : else
4221 : : {
4222 : 0 : memmove (buf->buf, buf->buf + end, buf->size - end);
4223 : 0 : buf->off += end;
4224 : 0 : buf->size -= end;
4225 : 0 : buf->padding_bytes = padding_bytes;
4226 : : }
4227 : 411 : return;
4228 : : }
4229 : 767 : size_t wordsize = UNITS_PER_WORD;
4230 : 43883 : for (size_t i = 0; i < end; i += wordsize)
4231 : : {
4232 : 43116 : size_t nonzero_first = wordsize;
4233 : 43116 : size_t nonzero_last = 0;
4234 : 43116 : size_t zero_first = wordsize;
4235 : 43116 : size_t zero_last = 0;
4236 : 43116 : bool all_ones = true, bytes_only = true;
4237 : 43428 : if ((unsigned HOST_WIDE_INT) (buf->off + i + wordsize)
4238 : 43116 : > (unsigned HOST_WIDE_INT) buf->sz)
4239 : : {
4240 : 312 : gcc_assert (wordsize > 1);
4241 : 312 : wordsize /= 2;
4242 : 312 : i -= wordsize;
4243 : 312 : continue;
4244 : : }
4245 : 383821 : for (size_t j = i; j < i + wordsize && j < end; j++)
4246 : : {
4247 : 341017 : if (buf->buf[j])
4248 : : {
4249 : 330191 : if (nonzero_first == wordsize)
4250 : : {
4251 : 41753 : nonzero_first = j - i;
4252 : 41753 : nonzero_last = j - i;
4253 : : }
4254 : 330191 : if (nonzero_last != j - i)
4255 : 159 : all_ones = false;
4256 : 330191 : nonzero_last = j + 1 - i;
4257 : : }
4258 : : else
4259 : : {
4260 : 10826 : if (zero_first == wordsize)
4261 : 2036 : zero_first = j - i;
4262 : 10826 : zero_last = j + 1 - i;
4263 : : }
4264 : 341017 : if (buf->buf[j] != 0 && buf->buf[j] != (unsigned char) ~0)
4265 : : {
4266 : 79 : all_ones = false;
4267 : 79 : bytes_only = false;
4268 : : }
4269 : : }
4270 : 42804 : size_t padding_end = i;
4271 : 42804 : if (padding_bytes)
4272 : : {
4273 : 41087 : if (nonzero_first == 0
4274 : 41087 : && nonzero_last == wordsize
4275 : 40621 : && all_ones)
4276 : : {
4277 : : /* All bits are padding and we had some padding
4278 : : before too. Just extend it. */
4279 : 40621 : padding_bytes += wordsize;
4280 : 40621 : continue;
4281 : : }
4282 : 466 : if (all_ones && nonzero_first == 0)
4283 : : {
4284 : 21 : padding_bytes += nonzero_last;
4285 : 21 : padding_end += nonzero_last;
4286 : 21 : nonzero_first = wordsize;
4287 : 21 : nonzero_last = 0;
4288 : : }
4289 : 445 : else if (bytes_only && nonzero_first == 0)
4290 : : {
4291 : 0 : gcc_assert (zero_first && zero_first != wordsize);
4292 : 0 : padding_bytes += zero_first;
4293 : 0 : padding_end += zero_first;
4294 : : }
4295 : 466 : tree atype, src;
4296 : 466 : if (padding_bytes == 1)
4297 : : {
4298 : 33 : atype = char_type_node;
4299 : 33 : src = build_zero_cst (char_type_node);
4300 : : }
4301 : : else
4302 : : {
4303 : 433 : atype = build_array_type_nelts (char_type_node, padding_bytes);
4304 : 433 : src = build_constructor (atype, NULL);
4305 : : }
4306 : 466 : tree dst = build2_loc (buf->loc, MEM_REF, atype, buf->base,
4307 : : build_int_cst (buf->alias_type,
4308 : 466 : buf->off + padding_end
4309 : 466 : - padding_bytes));
4310 : 466 : gimple *g = gimple_build_assign (dst, src);
4311 : 466 : gimple_set_location (g, buf->loc);
4312 : 466 : gsi_insert_before (buf->gsi, g, GSI_SAME_STMT);
4313 : 466 : padding_bytes = 0;
4314 : 466 : buf->padding_bytes = 0;
4315 : : }
4316 : 2183 : if (nonzero_first == wordsize)
4317 : : /* All bits in a word are 0, there are no padding bits. */
4318 : 1072 : continue;
4319 : 1111 : if (all_ones && nonzero_last == wordsize)
4320 : : {
4321 : : /* All bits between nonzero_first and end of word are padding
4322 : : bits, start counting padding_bytes. */
4323 : 826 : padding_bytes = nonzero_last - nonzero_first;
4324 : 826 : continue;
4325 : : }
4326 : 285 : if (bytes_only)
4327 : : {
4328 : : /* If bitfields aren't involved in this word, prefer storing
4329 : : individual bytes or groups of them over performing a RMW
4330 : : operation on the whole word. */
4331 : 248 : gcc_assert (i + zero_last <= end);
4332 : 1177 : for (size_t j = padding_end; j < i + zero_last; j++)
4333 : : {
4334 : 929 : if (buf->buf[j])
4335 : : {
4336 : : size_t k;
4337 : 626 : for (k = j; k < i + zero_last; k++)
4338 : 626 : if (buf->buf[k] == 0)
4339 : : break;
4340 : 264 : HOST_WIDE_INT off = buf->off + j;
4341 : 264 : tree atype, src;
4342 : 264 : if (k - j == 1)
4343 : : {
4344 : 215 : atype = char_type_node;
4345 : 215 : src = build_zero_cst (char_type_node);
4346 : : }
4347 : : else
4348 : : {
4349 : 49 : atype = build_array_type_nelts (char_type_node, k - j);
4350 : 49 : src = build_constructor (atype, NULL);
4351 : : }
4352 : 264 : tree dst = build2_loc (buf->loc, MEM_REF, atype,
4353 : : buf->base,
4354 : : build_int_cst (buf->alias_type, off));
4355 : 264 : gimple *g = gimple_build_assign (dst, src);
4356 : 264 : gimple_set_location (g, buf->loc);
4357 : 264 : gsi_insert_before (buf->gsi, g, GSI_SAME_STMT);
4358 : 264 : j = k;
4359 : : }
4360 : : }
4361 : 248 : if (nonzero_last == wordsize)
4362 : 99 : padding_bytes = nonzero_last - zero_last;
4363 : 248 : continue;
4364 : 248 : }
4365 : 120 : for (size_t eltsz = 1; eltsz <= wordsize; eltsz <<= 1)
4366 : : {
4367 : 120 : if (nonzero_last - nonzero_first <= eltsz
4368 : 37 : && ((nonzero_first & ~(eltsz - 1))
4369 : 37 : == ((nonzero_last - 1) & ~(eltsz - 1))))
4370 : : {
4371 : 37 : tree type;
4372 : 37 : if (eltsz == 1)
4373 : 2 : type = char_type_node;
4374 : : else
4375 : 35 : type = lang_hooks.types.type_for_size (eltsz * BITS_PER_UNIT,
4376 : : 0);
4377 : 37 : size_t start = nonzero_first & ~(eltsz - 1);
4378 : 37 : HOST_WIDE_INT off = buf->off + i + start;
4379 : 37 : tree atype = type;
4380 : 37 : if (eltsz > 1 && buf->align < TYPE_ALIGN (type))
4381 : 0 : atype = build_aligned_type (type, buf->align);
4382 : 37 : tree dst = build2_loc (buf->loc, MEM_REF, atype, buf->base,
4383 : : build_int_cst (buf->alias_type, off));
4384 : 37 : tree src;
4385 : 37 : gimple *g;
4386 : 37 : if (all_ones
4387 : 37 : && nonzero_first == start
4388 : 0 : && nonzero_last == start + eltsz)
4389 : 0 : src = build_zero_cst (type);
4390 : : else
4391 : : {
4392 : 37 : src = make_ssa_name (type);
4393 : 37 : tree tmp_dst = unshare_expr (dst);
4394 : : /* The folding introduces a read from the tmp_dst, we should
4395 : : prevent uninitialized warning analysis from issuing warning
4396 : : for such fake read. In order to suppress warning only for
4397 : : this expr, we should set the location of tmp_dst to
4398 : : UNKNOWN_LOCATION first, then suppress_warning will call
4399 : : set_no_warning_bit to set the no_warning flag only for
4400 : : tmp_dst. */
4401 : 37 : SET_EXPR_LOCATION (tmp_dst, UNKNOWN_LOCATION);
4402 : 37 : suppress_warning (tmp_dst, OPT_Wuninitialized);
4403 : 37 : g = gimple_build_assign (src, tmp_dst);
4404 : 37 : gimple_set_location (g, buf->loc);
4405 : 37 : gsi_insert_before (buf->gsi, g, GSI_SAME_STMT);
4406 : 74 : tree mask = native_interpret_expr (type,
4407 : 37 : buf->buf + i + start,
4408 : : eltsz);
4409 : 37 : gcc_assert (mask && TREE_CODE (mask) == INTEGER_CST);
4410 : 37 : mask = fold_build1 (BIT_NOT_EXPR, type, mask);
4411 : 37 : tree src_masked = make_ssa_name (type);
4412 : 37 : g = gimple_build_assign (src_masked, BIT_AND_EXPR,
4413 : : src, mask);
4414 : 37 : gimple_set_location (g, buf->loc);
4415 : 37 : gsi_insert_before (buf->gsi, g, GSI_SAME_STMT);
4416 : 37 : src = src_masked;
4417 : : }
4418 : 37 : g = gimple_build_assign (dst, src);
4419 : 37 : gimple_set_location (g, buf->loc);
4420 : 37 : gsi_insert_before (buf->gsi, g, GSI_SAME_STMT);
4421 : 37 : break;
4422 : : }
4423 : : }
4424 : : }
4425 : 767 : if (full)
4426 : : {
4427 : 725 : if (padding_bytes)
4428 : : {
4429 : 459 : tree atype, src;
4430 : 459 : if (padding_bytes == 1)
4431 : : {
4432 : 96 : atype = char_type_node;
4433 : 96 : src = build_zero_cst (char_type_node);
4434 : : }
4435 : : else
4436 : : {
4437 : 363 : atype = build_array_type_nelts (char_type_node, padding_bytes);
4438 : 363 : src = build_constructor (atype, NULL);
4439 : : }
4440 : 459 : tree dst = build2_loc (buf->loc, MEM_REF, atype, buf->base,
4441 : : build_int_cst (buf->alias_type,
4442 : 459 : buf->off + end
4443 : 459 : - padding_bytes));
4444 : 459 : gimple *g = gimple_build_assign (dst, src);
4445 : 459 : gimple_set_location (g, buf->loc);
4446 : 459 : gsi_insert_before (buf->gsi, g, GSI_SAME_STMT);
4447 : : }
4448 : 725 : size_t end_rem = end % UNITS_PER_WORD;
4449 : 725 : buf->off += end - end_rem;
4450 : 725 : buf->size = end_rem;
4451 : 725 : memset (buf->buf, 0, buf->size);
4452 : 725 : buf->padding_bytes = 0;
4453 : : }
4454 : : else
4455 : : {
4456 : 42 : memmove (buf->buf, buf->buf + end, buf->size - end);
4457 : 42 : buf->off += end;
4458 : 42 : buf->size -= end;
4459 : 42 : buf->padding_bytes = padding_bytes;
4460 : : }
4461 : : }
4462 : :
4463 : : /* Append PADDING_BYTES padding bytes. */
4464 : :
4465 : : static void
4466 : 5217 : clear_padding_add_padding (clear_padding_struct *buf,
4467 : : HOST_WIDE_INT padding_bytes)
4468 : : {
4469 : 5217 : if (padding_bytes == 0)
4470 : : return;
4471 : 1649 : if ((unsigned HOST_WIDE_INT) padding_bytes + buf->size
4472 : : > (unsigned HOST_WIDE_INT) clear_padding_buf_size)
4473 : 42 : clear_padding_flush (buf, false);
4474 : 1649 : if ((unsigned HOST_WIDE_INT) padding_bytes + buf->size
4475 : : > (unsigned HOST_WIDE_INT) clear_padding_buf_size)
4476 : : {
4477 : 42 : memset (buf->buf + buf->size, ~0, clear_padding_buf_size - buf->size);
4478 : 42 : padding_bytes -= clear_padding_buf_size - buf->size;
4479 : 42 : buf->size = clear_padding_buf_size;
4480 : 42 : clear_padding_flush (buf, false);
4481 : 42 : gcc_assert (buf->padding_bytes);
4482 : : /* At this point buf->buf[0] through buf->buf[buf->size - 1]
4483 : : is guaranteed to be all ones. */
4484 : 42 : padding_bytes += buf->size;
4485 : 42 : buf->size = padding_bytes % UNITS_PER_WORD;
4486 : 42 : memset (buf->buf, ~0, buf->size);
4487 : 42 : buf->off += padding_bytes - buf->size;
4488 : 42 : buf->padding_bytes += padding_bytes - buf->size;
4489 : : }
4490 : : else
4491 : : {
4492 : 1607 : memset (buf->buf + buf->size, ~0, padding_bytes);
4493 : 1607 : buf->size += padding_bytes;
4494 : : }
4495 : : }
4496 : :
4497 : : static void clear_padding_type (clear_padding_struct *, tree,
4498 : : HOST_WIDE_INT, bool);
4499 : :
4500 : : /* Clear padding bits of union type TYPE. */
4501 : :
4502 : : static void
4503 : 140 : clear_padding_union (clear_padding_struct *buf, tree type,
4504 : : HOST_WIDE_INT sz, bool for_auto_init)
4505 : : {
4506 : 140 : clear_padding_struct *union_buf;
4507 : 140 : HOST_WIDE_INT start_off = 0, next_off = 0;
4508 : 140 : size_t start_size = 0;
4509 : 140 : if (buf->union_ptr)
4510 : : {
4511 : 42 : start_off = buf->off + buf->size;
4512 : 42 : next_off = start_off + sz;
4513 : 42 : start_size = start_off % UNITS_PER_WORD;
4514 : 42 : start_off -= start_size;
4515 : 42 : clear_padding_flush (buf, true);
4516 : 42 : union_buf = buf;
4517 : : }
4518 : : else
4519 : : {
4520 : 98 : if (sz + buf->size > clear_padding_buf_size)
4521 : 0 : clear_padding_flush (buf, false);
4522 : 98 : union_buf = XALLOCA (clear_padding_struct);
4523 : 98 : union_buf->loc = buf->loc;
4524 : 98 : union_buf->clear_in_mask = buf->clear_in_mask;
4525 : 98 : union_buf->base = NULL_TREE;
4526 : 98 : union_buf->alias_type = NULL_TREE;
4527 : 98 : union_buf->gsi = NULL;
4528 : 98 : union_buf->align = 0;
4529 : 98 : union_buf->off = 0;
4530 : 98 : union_buf->padding_bytes = 0;
4531 : 98 : union_buf->sz = sz;
4532 : 98 : union_buf->size = 0;
4533 : 98 : if (sz + buf->size <= clear_padding_buf_size)
4534 : 98 : union_buf->union_ptr = buf->buf + buf->size;
4535 : : else
4536 : 0 : union_buf->union_ptr = XNEWVEC (unsigned char, sz);
4537 : 98 : memset (union_buf->union_ptr, ~0, sz);
4538 : : }
4539 : :
4540 : 1265 : for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
4541 : 1125 : if (TREE_CODE (field) == FIELD_DECL && !DECL_PADDING_P (field))
4542 : : {
4543 : 384 : if (DECL_SIZE_UNIT (field) == NULL_TREE)
4544 : : {
4545 : 15 : if (TREE_TYPE (field) == error_mark_node)
4546 : 15 : continue;
4547 : 0 : gcc_assert (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
4548 : : && !COMPLETE_TYPE_P (TREE_TYPE (field)));
4549 : 0 : if (!buf->clear_in_mask && !for_auto_init)
4550 : 0 : error_at (buf->loc, "flexible array member %qD does not have "
4551 : : "well defined padding bits for %qs",
4552 : : field, "__builtin_clear_padding");
4553 : 0 : continue;
4554 : : }
4555 : 369 : HOST_WIDE_INT fldsz = tree_to_shwi (DECL_SIZE_UNIT (field));
4556 : 369 : gcc_assert (union_buf->size == 0);
4557 : 369 : union_buf->off = start_off;
4558 : 369 : union_buf->size = start_size;
4559 : 369 : memset (union_buf->buf, ~0, start_size);
4560 : 369 : clear_padding_type (union_buf, TREE_TYPE (field), fldsz, for_auto_init);
4561 : 369 : clear_padding_add_padding (union_buf, sz - fldsz);
4562 : 369 : clear_padding_flush (union_buf, true);
4563 : : }
4564 : :
4565 : 140 : if (buf == union_buf)
4566 : : {
4567 : 42 : buf->off = next_off;
4568 : 42 : buf->size = next_off % UNITS_PER_WORD;
4569 : 42 : buf->off -= buf->size;
4570 : 42 : memset (buf->buf, ~0, buf->size);
4571 : : }
4572 : 98 : else if (sz + buf->size <= clear_padding_buf_size)
4573 : 98 : buf->size += sz;
4574 : : else
4575 : : {
4576 : 0 : unsigned char *union_ptr = union_buf->union_ptr;
4577 : 0 : while (sz)
4578 : : {
4579 : 0 : clear_padding_flush (buf, false);
4580 : 0 : HOST_WIDE_INT this_sz
4581 : 0 : = MIN ((unsigned HOST_WIDE_INT) sz,
4582 : : clear_padding_buf_size - buf->size);
4583 : 0 : memcpy (buf->buf + buf->size, union_ptr, this_sz);
4584 : 0 : buf->size += this_sz;
4585 : 0 : union_ptr += this_sz;
4586 : 0 : sz -= this_sz;
4587 : : }
4588 : 0 : XDELETE (union_buf->union_ptr);
4589 : : }
4590 : 140 : }
4591 : :
4592 : : /* The only known floating point formats with padding bits are the
4593 : : IEEE extended ones. */
4594 : :
4595 : : static bool
4596 : 29993 : clear_padding_real_needs_padding_p (tree type)
4597 : : {
4598 : 29993 : const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
4599 : 29993 : return (fmt->b == 2
4600 : 29658 : && fmt->signbit_ro == fmt->signbit_rw
4601 : 59651 : && (fmt->signbit_ro == 79 || fmt->signbit_ro == 95));
4602 : : }
4603 : :
4604 : : /* _BitInt has padding bits if it isn't extended in the ABI and has smaller
4605 : : precision than bits in limb or corresponding number of limbs. */
4606 : :
4607 : : static bool
4608 : 6 : clear_padding_bitint_needs_padding_p (tree type)
4609 : : {
4610 : 6 : struct bitint_info info;
4611 : 6 : bool ok = targetm.c.bitint_type_info (TYPE_PRECISION (type), &info);
4612 : 6 : gcc_assert (ok);
4613 : 6 : if (info.extended)
4614 : : return false;
4615 : 6 : scalar_int_mode limb_mode = as_a <scalar_int_mode> (info.abi_limb_mode);
4616 : 6 : if (TYPE_PRECISION (type) < GET_MODE_PRECISION (limb_mode))
4617 : : return true;
4618 : 4 : else if (TYPE_PRECISION (type) == GET_MODE_PRECISION (limb_mode))
4619 : : return false;
4620 : : else
4621 : 4 : return (((unsigned) TYPE_PRECISION (type))
4622 : 4 : % GET_MODE_PRECISION (limb_mode)) != 0;
4623 : : }
4624 : :
4625 : : /* Return true if TYPE might contain any padding bits. */
4626 : :
4627 : : bool
4628 : 860192 : clear_padding_type_may_have_padding_p (tree type)
4629 : : {
4630 : 988025 : switch (TREE_CODE (type))
4631 : : {
4632 : : case RECORD_TYPE:
4633 : : case UNION_TYPE:
4634 : : return true;
4635 : 127833 : case ARRAY_TYPE:
4636 : 127833 : case COMPLEX_TYPE:
4637 : 127833 : case VECTOR_TYPE:
4638 : 127833 : return clear_padding_type_may_have_padding_p (TREE_TYPE (type));
4639 : 1643 : case REAL_TYPE:
4640 : 1643 : return clear_padding_real_needs_padding_p (type);
4641 : 6 : case BITINT_TYPE:
4642 : 6 : return clear_padding_bitint_needs_padding_p (type);
4643 : 33954 : default:
4644 : 33954 : return false;
4645 : : }
4646 : : }
4647 : :
4648 : : /* Emit a runtime loop:
4649 : : for (; buf.base != end; buf.base += sz)
4650 : : __builtin_clear_padding (buf.base); */
4651 : :
4652 : : static void
4653 : 99 : clear_padding_emit_loop (clear_padding_struct *buf, tree type,
4654 : : tree end, bool for_auto_init)
4655 : : {
4656 : 99 : tree l1 = create_artificial_label (buf->loc);
4657 : 99 : tree l2 = create_artificial_label (buf->loc);
4658 : 99 : tree l3 = create_artificial_label (buf->loc);
4659 : 99 : gimple *g = gimple_build_goto (l2);
4660 : 99 : gimple_set_location (g, buf->loc);
4661 : 99 : gsi_insert_before (buf->gsi, g, GSI_SAME_STMT);
4662 : 99 : g = gimple_build_label (l1);
4663 : 99 : gimple_set_location (g, buf->loc);
4664 : 99 : gsi_insert_before (buf->gsi, g, GSI_SAME_STMT);
4665 : 99 : clear_padding_type (buf, type, buf->sz, for_auto_init);
4666 : 99 : clear_padding_flush (buf, true);
4667 : 99 : g = gimple_build_assign (buf->base, POINTER_PLUS_EXPR, buf->base,
4668 : 99 : size_int (buf->sz));
4669 : 99 : gimple_set_location (g, buf->loc);
4670 : 99 : gsi_insert_before (buf->gsi, g, GSI_SAME_STMT);
4671 : 99 : g = gimple_build_label (l2);
4672 : 99 : gimple_set_location (g, buf->loc);
4673 : 99 : gsi_insert_before (buf->gsi, g, GSI_SAME_STMT);
4674 : 99 : g = gimple_build_cond (NE_EXPR, buf->base, end, l1, l3);
4675 : 99 : gimple_set_location (g, buf->loc);
4676 : 99 : gsi_insert_before (buf->gsi, g, GSI_SAME_STMT);
4677 : 99 : g = gimple_build_label (l3);
4678 : 99 : gimple_set_location (g, buf->loc);
4679 : 99 : gsi_insert_before (buf->gsi, g, GSI_SAME_STMT);
4680 : 99 : }
4681 : :
4682 : : /* Clear padding bits for TYPE. Called recursively from
4683 : : gimple_fold_builtin_clear_padding. If FOR_AUTO_INIT is true,
4684 : : the __builtin_clear_padding is not called by the end user,
4685 : : instead, it's inserted by the compiler to initialize the
4686 : : paddings of automatic variable. Therefore, we should not
4687 : : emit the error messages for flexible array members to confuse
4688 : : the end user. */
4689 : :
4690 : : static void
4691 : 33729 : clear_padding_type (clear_padding_struct *buf, tree type,
4692 : : HOST_WIDE_INT sz, bool for_auto_init)
4693 : : {
4694 : 33729 : switch (TREE_CODE (type))
4695 : : {
4696 : 1312 : case RECORD_TYPE:
4697 : 1312 : HOST_WIDE_INT cur_pos;
4698 : 1312 : cur_pos = 0;
4699 : 17053 : for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
4700 : 15741 : if (TREE_CODE (field) == FIELD_DECL && !DECL_PADDING_P (field))
4701 : : {
4702 : 3793 : tree ftype = TREE_TYPE (field);
4703 : 3793 : if (DECL_BIT_FIELD (field))
4704 : : {
4705 : 252 : HOST_WIDE_INT fldsz = TYPE_PRECISION (ftype);
4706 : 252 : if (fldsz == 0)
4707 : 0 : continue;
4708 : 252 : HOST_WIDE_INT pos = int_byte_position (field);
4709 : 252 : if (pos >= sz)
4710 : 0 : continue;
4711 : 252 : HOST_WIDE_INT bpos
4712 : 252 : = tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field));
4713 : 252 : bpos %= BITS_PER_UNIT;
4714 : 252 : HOST_WIDE_INT end
4715 : 252 : = ROUND_UP (bpos + fldsz, BITS_PER_UNIT) / BITS_PER_UNIT;
4716 : 252 : if (pos + end > cur_pos)
4717 : : {
4718 : 191 : clear_padding_add_padding (buf, pos + end - cur_pos);
4719 : 191 : cur_pos = pos + end;
4720 : : }
4721 : 252 : gcc_assert (cur_pos > pos
4722 : : && ((unsigned HOST_WIDE_INT) buf->size
4723 : : >= (unsigned HOST_WIDE_INT) cur_pos - pos));
4724 : 252 : unsigned char *p = buf->buf + buf->size - (cur_pos - pos);
4725 : 252 : if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN)
4726 : : sorry_at (buf->loc, "PDP11 bit-field handling unsupported"
4727 : : " in %qs", "__builtin_clear_padding");
4728 : 252 : else if (BYTES_BIG_ENDIAN)
4729 : : {
4730 : : /* Big endian. */
4731 : : if (bpos + fldsz <= BITS_PER_UNIT)
4732 : : *p &= ~(((1 << fldsz) - 1)
4733 : : << (BITS_PER_UNIT - bpos - fldsz));
4734 : : else
4735 : : {
4736 : : if (bpos)
4737 : : {
4738 : : *p &= ~(((1U << BITS_PER_UNIT) - 1) >> bpos);
4739 : : p++;
4740 : : fldsz -= BITS_PER_UNIT - bpos;
4741 : : }
4742 : : memset (p, 0, fldsz / BITS_PER_UNIT);
4743 : : p += fldsz / BITS_PER_UNIT;
4744 : : fldsz %= BITS_PER_UNIT;
4745 : : if (fldsz)
4746 : : *p &= ((1U << BITS_PER_UNIT) - 1) >> fldsz;
4747 : : }
4748 : : }
4749 : : else
4750 : : {
4751 : : /* Little endian. */
4752 : 252 : if (bpos + fldsz <= BITS_PER_UNIT)
4753 : 159 : *p &= ~(((1 << fldsz) - 1) << bpos);
4754 : : else
4755 : : {
4756 : 93 : if (bpos)
4757 : : {
4758 : 29 : *p &= ~(((1 << BITS_PER_UNIT) - 1) << bpos);
4759 : 29 : p++;
4760 : 29 : fldsz -= BITS_PER_UNIT - bpos;
4761 : : }
4762 : 93 : memset (p, 0, fldsz / BITS_PER_UNIT);
4763 : 93 : p += fldsz / BITS_PER_UNIT;
4764 : 93 : fldsz %= BITS_PER_UNIT;
4765 : 93 : if (fldsz)
4766 : 48 : *p &= ~((1 << fldsz) - 1);
4767 : : }
4768 : : }
4769 : : }
4770 : 3541 : else if (DECL_SIZE_UNIT (field) == NULL_TREE)
4771 : : {
4772 : 40 : if (ftype == error_mark_node)
4773 : 0 : continue;
4774 : 40 : gcc_assert (TREE_CODE (ftype) == ARRAY_TYPE
4775 : : && !COMPLETE_TYPE_P (ftype));
4776 : 40 : if (!buf->clear_in_mask && !for_auto_init)
4777 : 30 : error_at (buf->loc, "flexible array member %qD does not "
4778 : : "have well defined padding bits for %qs",
4779 : : field, "__builtin_clear_padding");
4780 : : }
4781 : 3501 : else if (is_empty_type (ftype))
4782 : 156 : continue;
4783 : : else
4784 : : {
4785 : 3345 : HOST_WIDE_INT pos = int_byte_position (field);
4786 : 3345 : if (pos >= sz)
4787 : 0 : continue;
4788 : 3345 : HOST_WIDE_INT fldsz = tree_to_shwi (DECL_SIZE_UNIT (field));
4789 : 3345 : gcc_assert (pos >= 0 && fldsz >= 0 && pos >= cur_pos);
4790 : 3345 : clear_padding_add_padding (buf, pos - cur_pos);
4791 : 3345 : cur_pos = pos;
4792 : 3345 : if (tree asbase = lang_hooks.types.classtype_as_base (field))
4793 : 205 : ftype = asbase;
4794 : 3345 : clear_padding_type (buf, ftype, fldsz, for_auto_init);
4795 : 3345 : cur_pos += fldsz;
4796 : : }
4797 : : }
4798 : 1312 : gcc_assert (sz >= cur_pos);
4799 : 1312 : clear_padding_add_padding (buf, sz - cur_pos);
4800 : 1312 : break;
4801 : 312 : case ARRAY_TYPE:
4802 : 312 : HOST_WIDE_INT nelts, fldsz;
4803 : 312 : fldsz = int_size_in_bytes (TREE_TYPE (type));
4804 : 312 : if (fldsz == 0)
4805 : : break;
4806 : 298 : nelts = sz / fldsz;
4807 : 298 : if (nelts > 1
4808 : 291 : && sz > 8 * UNITS_PER_WORD
4809 : 66 : && buf->union_ptr == NULL
4810 : 364 : && clear_padding_type_may_have_padding_p (TREE_TYPE (type)))
4811 : : {
4812 : : /* For sufficiently large array of more than one elements,
4813 : : emit a runtime loop to keep code size manageable. */
4814 : 51 : tree base = buf->base;
4815 : 51 : unsigned int prev_align = buf->align;
4816 : 51 : HOST_WIDE_INT off = buf->off + buf->size;
4817 : 51 : HOST_WIDE_INT prev_sz = buf->sz;
4818 : 51 : clear_padding_flush (buf, true);
4819 : 51 : tree elttype = TREE_TYPE (type);
4820 : 51 : buf->base = create_tmp_var (build_pointer_type (elttype));
4821 : 51 : tree end = make_ssa_name (TREE_TYPE (buf->base));
4822 : 51 : gimple *g = gimple_build_assign (buf->base, POINTER_PLUS_EXPR,
4823 : : base, size_int (off));
4824 : 51 : gimple_set_location (g, buf->loc);
4825 : 51 : gsi_insert_before (buf->gsi, g, GSI_SAME_STMT);
4826 : 51 : g = gimple_build_assign (end, POINTER_PLUS_EXPR, buf->base,
4827 : : size_int (sz));
4828 : 51 : gimple_set_location (g, buf->loc);
4829 : 51 : gsi_insert_before (buf->gsi, g, GSI_SAME_STMT);
4830 : 51 : buf->sz = fldsz;
4831 : 51 : buf->align = TYPE_ALIGN (elttype);
4832 : 51 : buf->off = 0;
4833 : 51 : buf->size = 0;
4834 : 51 : clear_padding_emit_loop (buf, elttype, end, for_auto_init);
4835 : 51 : buf->base = base;
4836 : 51 : buf->sz = prev_sz;
4837 : 51 : buf->align = prev_align;
4838 : 51 : buf->size = off % UNITS_PER_WORD;
4839 : 51 : buf->off = off - buf->size;
4840 : 51 : memset (buf->buf, 0, buf->size);
4841 : 51 : break;
4842 : : }
4843 : 1234 : for (HOST_WIDE_INT i = 0; i < nelts; i++)
4844 : 987 : clear_padding_type (buf, TREE_TYPE (type), fldsz, for_auto_init);
4845 : : break;
4846 : 140 : case UNION_TYPE:
4847 : 140 : clear_padding_union (buf, type, sz, for_auto_init);
4848 : 140 : break;
4849 : 28350 : case REAL_TYPE:
4850 : 28350 : gcc_assert ((size_t) sz <= clear_padding_unit);
4851 : 28350 : if ((unsigned HOST_WIDE_INT) sz + buf->size > clear_padding_buf_size)
4852 : 0 : clear_padding_flush (buf, false);
4853 : 28350 : if (clear_padding_real_needs_padding_p (type))
4854 : : {
4855 : : /* Use native_interpret_real + native_encode_expr to figure out
4856 : : which bits are padding. */
4857 : 1233 : memset (buf->buf + buf->size, ~0, sz);
4858 : 1233 : tree cst = native_interpret_real (type, buf->buf + buf->size, sz);
4859 : 1233 : gcc_assert (cst && TREE_CODE (cst) == REAL_CST);
4860 : 1233 : int len = native_encode_expr (cst, buf->buf + buf->size, sz);
4861 : 1233 : gcc_assert (len > 0 && (size_t) len == (size_t) sz);
4862 : 20961 : for (size_t i = 0; i < (size_t) sz; i++)
4863 : 19728 : buf->buf[buf->size + i] ^= ~0;
4864 : : }
4865 : : else
4866 : 27117 : memset (buf->buf + buf->size, 0, sz);
4867 : 28350 : buf->size += sz;
4868 : 28350 : break;
4869 : 0 : case COMPLEX_TYPE:
4870 : 0 : fldsz = int_size_in_bytes (TREE_TYPE (type));
4871 : 0 : clear_padding_type (buf, TREE_TYPE (type), fldsz, for_auto_init);
4872 : 0 : clear_padding_type (buf, TREE_TYPE (type), fldsz, for_auto_init);
4873 : 0 : break;
4874 : 0 : case VECTOR_TYPE:
4875 : 0 : nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
4876 : 0 : fldsz = int_size_in_bytes (TREE_TYPE (type));
4877 : 0 : for (HOST_WIDE_INT i = 0; i < nelts; i++)
4878 : 0 : clear_padding_type (buf, TREE_TYPE (type), fldsz, for_auto_init);
4879 : : break;
4880 : 7 : case NULLPTR_TYPE:
4881 : 7 : gcc_assert ((size_t) sz <= clear_padding_unit);
4882 : 7 : if ((unsigned HOST_WIDE_INT) sz + buf->size > clear_padding_buf_size)
4883 : 0 : clear_padding_flush (buf, false);
4884 : 7 : memset (buf->buf + buf->size, ~0, sz);
4885 : 7 : buf->size += sz;
4886 : 7 : break;
4887 : 4 : case BITINT_TYPE:
4888 : 4 : {
4889 : 4 : struct bitint_info info;
4890 : 4 : bool ok = targetm.c.bitint_type_info (TYPE_PRECISION (type), &info);
4891 : 4 : gcc_assert (ok);
4892 : 4 : scalar_int_mode limb_mode
4893 : 4 : = as_a <scalar_int_mode> (info.abi_limb_mode);
4894 : 4 : if (TYPE_PRECISION (type) <= GET_MODE_PRECISION (limb_mode))
4895 : : {
4896 : 2 : gcc_assert ((size_t) sz <= clear_padding_unit);
4897 : 2 : if ((unsigned HOST_WIDE_INT) sz + buf->size
4898 : : > clear_padding_buf_size)
4899 : 0 : clear_padding_flush (buf, false);
4900 : 2 : if (!info.extended
4901 : 2 : && TYPE_PRECISION (type) < GET_MODE_PRECISION (limb_mode))
4902 : : {
4903 : 2 : int tprec = GET_MODE_PRECISION (limb_mode);
4904 : 2 : int prec = TYPE_PRECISION (type);
4905 : 2 : tree t = build_nonstandard_integer_type (tprec, 1);
4906 : 2 : tree cst = wide_int_to_tree (t, wi::mask (prec, true, tprec));
4907 : 2 : int len = native_encode_expr (cst, buf->buf + buf->size, sz);
4908 : 2 : gcc_assert (len > 0 && (size_t) len == (size_t) sz);
4909 : : }
4910 : : else
4911 : 0 : memset (buf->buf + buf->size, 0, sz);
4912 : 2 : buf->size += sz;
4913 : 2 : break;
4914 : : }
4915 : 2 : tree limbtype
4916 : 2 : = build_nonstandard_integer_type (GET_MODE_PRECISION (limb_mode), 1);
4917 : 2 : fldsz = int_size_in_bytes (limbtype);
4918 : 2 : nelts = int_size_in_bytes (type) / fldsz;
4919 : 13 : for (HOST_WIDE_INT i = 0; i < nelts; i++)
4920 : : {
4921 : 11 : if (!info.extended
4922 : 11 : && i == (info.big_endian ? 0 : nelts - 1)
4923 : 13 : && (((unsigned) TYPE_PRECISION (type))
4924 : 2 : % TYPE_PRECISION (limbtype)) != 0)
4925 : : {
4926 : 2 : int tprec = GET_MODE_PRECISION (limb_mode);
4927 : 2 : int prec = (((unsigned) TYPE_PRECISION (type)) % tprec);
4928 : 2 : tree cst = wide_int_to_tree (limbtype,
4929 : 2 : wi::mask (prec, true, tprec));
4930 : 2 : int len = native_encode_expr (cst, buf->buf + buf->size,
4931 : : fldsz);
4932 : 2 : gcc_assert (len > 0 && (size_t) len == (size_t) fldsz);
4933 : 2 : buf->size += fldsz;
4934 : : }
4935 : : else
4936 : 9 : clear_padding_type (buf, limbtype, fldsz, for_auto_init);
4937 : : }
4938 : : break;
4939 : : }
4940 : 3604 : default:
4941 : 3604 : gcc_assert ((size_t) sz <= clear_padding_unit);
4942 : 3604 : if ((unsigned HOST_WIDE_INT) sz + buf->size > clear_padding_buf_size)
4943 : 0 : clear_padding_flush (buf, false);
4944 : 3604 : memset (buf->buf + buf->size, 0, sz);
4945 : 3604 : buf->size += sz;
4946 : 3604 : break;
4947 : : }
4948 : 33729 : }
4949 : :
4950 : : /* Clear padding bits of TYPE in MASK. */
4951 : :
4952 : : void
4953 : 28345 : clear_type_padding_in_mask (tree type, unsigned char *mask)
4954 : : {
4955 : 28345 : clear_padding_struct buf;
4956 : 28345 : buf.loc = UNKNOWN_LOCATION;
4957 : 28345 : buf.clear_in_mask = true;
4958 : 28345 : buf.base = NULL_TREE;
4959 : 28345 : buf.alias_type = NULL_TREE;
4960 : 28345 : buf.gsi = NULL;
4961 : 28345 : buf.align = 0;
4962 : 28345 : buf.off = 0;
4963 : 28345 : buf.padding_bytes = 0;
4964 : 28345 : buf.sz = int_size_in_bytes (type);
4965 : 28345 : buf.size = 0;
4966 : 28345 : buf.union_ptr = mask;
4967 : 28345 : clear_padding_type (&buf, type, buf.sz, false);
4968 : 28345 : clear_padding_flush (&buf, true);
4969 : 28345 : }
4970 : :
4971 : : /* Fold __builtin_clear_padding builtin. */
4972 : :
4973 : : static bool
4974 : 663 : gimple_fold_builtin_clear_padding (gimple_stmt_iterator *gsi)
4975 : : {
4976 : 663 : gimple *stmt = gsi_stmt (*gsi);
4977 : 663 : gcc_assert (gimple_call_num_args (stmt) == 2);
4978 : 663 : tree ptr = gimple_call_arg (stmt, 0);
4979 : 663 : tree typearg = gimple_call_arg (stmt, 1);
4980 : : /* The 2nd argument of __builtin_clear_padding's value is used to
4981 : : distinguish whether this call is made by the user or by the compiler
4982 : : for automatic variable initialization. */
4983 : 663 : bool for_auto_init = (bool) TREE_INT_CST_LOW (typearg);
4984 : 663 : tree type = TREE_TYPE (TREE_TYPE (typearg));
4985 : 663 : location_t loc = gimple_location (stmt);
4986 : 663 : clear_padding_struct buf;
4987 : 663 : gimple_stmt_iterator gsiprev = *gsi;
4988 : : /* This should be folded during the lower pass. */
4989 : 1326 : gcc_assert (!gimple_in_ssa_p (cfun) && cfun->cfg == NULL);
4990 : 663 : gcc_assert (COMPLETE_TYPE_P (type));
4991 : 663 : gsi_prev (&gsiprev);
4992 : :
4993 : 663 : buf.loc = loc;
4994 : 663 : buf.clear_in_mask = false;
4995 : 663 : buf.base = ptr;
4996 : 663 : buf.alias_type = NULL_TREE;
4997 : 663 : buf.gsi = gsi;
4998 : 663 : buf.align = get_pointer_alignment (ptr);
4999 : 663 : unsigned int talign = min_align_of_type (type) * BITS_PER_UNIT;
5000 : 663 : buf.align = MAX (buf.align, talign);
5001 : 663 : buf.off = 0;
5002 : 663 : buf.padding_bytes = 0;
5003 : 663 : buf.size = 0;
5004 : 663 : buf.sz = int_size_in_bytes (type);
5005 : 663 : buf.union_ptr = NULL;
5006 : 663 : if (buf.sz < 0 && int_size_in_bytes (strip_array_types (type)) < 0)
5007 : 1 : sorry_at (loc, "%s not supported for variable length aggregates",
5008 : : "__builtin_clear_padding");
5009 : : /* The implementation currently assumes 8-bit host and target
5010 : : chars which is the case for all currently supported targets
5011 : : and hosts and is required e.g. for native_{encode,interpret}* APIs. */
5012 : 662 : else if (CHAR_BIT != 8 || BITS_PER_UNIT != 8)
5013 : : sorry_at (loc, "%s not supported on this target",
5014 : : "__builtin_clear_padding");
5015 : 662 : else if (!clear_padding_type_may_have_padding_p (type))
5016 : : ;
5017 : 623 : else if (TREE_CODE (type) == ARRAY_TYPE && buf.sz < 0)
5018 : : {
5019 : 48 : tree sz = TYPE_SIZE_UNIT (type);
5020 : 48 : tree elttype = type;
5021 : : /* Only supports C/C++ VLAs and flattens all the VLA levels. */
5022 : 48 : while (TREE_CODE (elttype) == ARRAY_TYPE
5023 : 144 : && int_size_in_bytes (elttype) < 0)
5024 : 96 : elttype = TREE_TYPE (elttype);
5025 : 48 : HOST_WIDE_INT eltsz = int_size_in_bytes (elttype);
5026 : 48 : gcc_assert (eltsz >= 0);
5027 : 48 : if (eltsz)
5028 : : {
5029 : 48 : buf.base = create_tmp_var (build_pointer_type (elttype));
5030 : 48 : tree end = make_ssa_name (TREE_TYPE (buf.base));
5031 : 48 : gimple *g = gimple_build_assign (buf.base, ptr);
5032 : 48 : gimple_set_location (g, loc);
5033 : 48 : gsi_insert_before (gsi, g, GSI_SAME_STMT);
5034 : 48 : g = gimple_build_assign (end, POINTER_PLUS_EXPR, buf.base, sz);
5035 : 48 : gimple_set_location (g, loc);
5036 : 48 : gsi_insert_before (gsi, g, GSI_SAME_STMT);
5037 : 48 : buf.sz = eltsz;
5038 : 48 : buf.align = TYPE_ALIGN (elttype);
5039 : 48 : buf.alias_type = build_pointer_type (elttype);
5040 : 48 : clear_padding_emit_loop (&buf, elttype, end, for_auto_init);
5041 : : }
5042 : : }
5043 : : else
5044 : : {
5045 : 575 : if (!is_gimple_mem_ref_addr (buf.base))
5046 : : {
5047 : 28 : buf.base = make_ssa_name (TREE_TYPE (ptr));
5048 : 28 : gimple *g = gimple_build_assign (buf.base, ptr);
5049 : 28 : gimple_set_location (g, loc);
5050 : 28 : gsi_insert_before (gsi, g, GSI_SAME_STMT);
5051 : : }
5052 : 575 : buf.alias_type = build_pointer_type (type);
5053 : 575 : clear_padding_type (&buf, type, buf.sz, for_auto_init);
5054 : 575 : clear_padding_flush (&buf, true);
5055 : : }
5056 : :
5057 : 663 : gimple_stmt_iterator gsiprev2 = *gsi;
5058 : 663 : gsi_prev (&gsiprev2);
5059 : 663 : if (gsi_stmt (gsiprev) == gsi_stmt (gsiprev2))
5060 : 153 : gsi_replace (gsi, gimple_build_nop (), true);
5061 : : else
5062 : : {
5063 : 510 : gsi_remove (gsi, true);
5064 : 510 : *gsi = gsiprev2;
5065 : : }
5066 : 663 : return true;
5067 : : }
5068 : :
5069 : : /* Fold the non-target builtin at *GSI and return whether any simplification
5070 : : was made. */
5071 : :
5072 : : static bool
5073 : 11704552 : gimple_fold_builtin (gimple_stmt_iterator *gsi)
5074 : : {
5075 : 11704552 : gcall *stmt = as_a <gcall *>(gsi_stmt (*gsi));
5076 : 11704552 : tree callee = gimple_call_fndecl (stmt);
5077 : :
5078 : : /* Give up for always_inline inline builtins until they are
5079 : : inlined. */
5080 : 11704552 : if (avoid_folding_inline_builtin (callee))
5081 : : return false;
5082 : :
5083 : 11703373 : unsigned n = gimple_call_num_args (stmt);
5084 : 11703373 : enum built_in_function fcode = DECL_FUNCTION_CODE (callee);
5085 : 11703373 : switch (fcode)
5086 : : {
5087 : 142 : case BUILT_IN_BCMP:
5088 : 142 : return gimple_fold_builtin_bcmp (gsi);
5089 : 387 : case BUILT_IN_BCOPY:
5090 : 387 : return gimple_fold_builtin_bcopy (gsi);
5091 : 283 : case BUILT_IN_BZERO:
5092 : 283 : return gimple_fold_builtin_bzero (gsi);
5093 : :
5094 : 316990 : case BUILT_IN_MEMSET:
5095 : 316990 : return gimple_fold_builtin_memset (gsi,
5096 : : gimple_call_arg (stmt, 1),
5097 : 316990 : gimple_call_arg (stmt, 2));
5098 : 887673 : case BUILT_IN_MEMCPY:
5099 : 887673 : case BUILT_IN_MEMPCPY:
5100 : 887673 : case BUILT_IN_MEMMOVE:
5101 : 887673 : return gimple_fold_builtin_memory_op (gsi, gimple_call_arg (stmt, 0),
5102 : 887673 : gimple_call_arg (stmt, 1), fcode);
5103 : 5147 : case BUILT_IN_SPRINTF_CHK:
5104 : 5147 : case BUILT_IN_VSPRINTF_CHK:
5105 : 5147 : return gimple_fold_builtin_sprintf_chk (gsi, fcode);
5106 : 1872 : case BUILT_IN_STRCAT_CHK:
5107 : 1872 : return gimple_fold_builtin_strcat_chk (gsi);
5108 : 1262 : case BUILT_IN_STRNCAT_CHK:
5109 : 1262 : return gimple_fold_builtin_strncat_chk (gsi);
5110 : 155674 : case BUILT_IN_STRLEN:
5111 : 155674 : return gimple_fold_builtin_strlen (gsi);
5112 : 28415 : case BUILT_IN_STRCPY:
5113 : 28415 : return gimple_fold_builtin_strcpy (gsi,
5114 : : gimple_call_arg (stmt, 0),
5115 : 28415 : gimple_call_arg (stmt, 1));
5116 : 19902 : case BUILT_IN_STRNCPY:
5117 : 19902 : return gimple_fold_builtin_strncpy (gsi,
5118 : : gimple_call_arg (stmt, 0),
5119 : : gimple_call_arg (stmt, 1),
5120 : 19902 : gimple_call_arg (stmt, 2));
5121 : 8042 : case BUILT_IN_STRCAT:
5122 : 8042 : return gimple_fold_builtin_strcat (gsi, gimple_call_arg (stmt, 0),
5123 : 8042 : gimple_call_arg (stmt, 1));
5124 : 6605 : case BUILT_IN_STRNCAT:
5125 : 6605 : return gimple_fold_builtin_strncat (gsi);
5126 : 5308 : case BUILT_IN_INDEX:
5127 : 5308 : case BUILT_IN_STRCHR:
5128 : 5308 : return gimple_fold_builtin_strchr (gsi, false);
5129 : 805 : case BUILT_IN_RINDEX:
5130 : 805 : case BUILT_IN_STRRCHR:
5131 : 805 : return gimple_fold_builtin_strchr (gsi, true);
5132 : 4111 : case BUILT_IN_STRSTR:
5133 : 4111 : return gimple_fold_builtin_strstr (gsi);
5134 : 1405479 : case BUILT_IN_STRCMP:
5135 : 1405479 : case BUILT_IN_STRCMP_EQ:
5136 : 1405479 : case BUILT_IN_STRCASECMP:
5137 : 1405479 : case BUILT_IN_STRNCMP:
5138 : 1405479 : case BUILT_IN_STRNCMP_EQ:
5139 : 1405479 : case BUILT_IN_STRNCASECMP:
5140 : 1405479 : return gimple_fold_builtin_string_compare (gsi);
5141 : 23080 : case BUILT_IN_MEMCHR:
5142 : 23080 : return gimple_fold_builtin_memchr (gsi);
5143 : 21450 : case BUILT_IN_FPUTS:
5144 : 21450 : return gimple_fold_builtin_fputs (gsi, gimple_call_arg (stmt, 0),
5145 : 21450 : gimple_call_arg (stmt, 1), false);
5146 : 44 : case BUILT_IN_FPUTS_UNLOCKED:
5147 : 44 : return gimple_fold_builtin_fputs (gsi, gimple_call_arg (stmt, 0),
5148 : 44 : gimple_call_arg (stmt, 1), true);
5149 : 27365 : case BUILT_IN_MEMCPY_CHK:
5150 : 27365 : case BUILT_IN_MEMPCPY_CHK:
5151 : 27365 : case BUILT_IN_MEMMOVE_CHK:
5152 : 27365 : case BUILT_IN_MEMSET_CHK:
5153 : 27365 : return gimple_fold_builtin_memory_chk (gsi,
5154 : : gimple_call_arg (stmt, 0),
5155 : : gimple_call_arg (stmt, 1),
5156 : : gimple_call_arg (stmt, 2),
5157 : : gimple_call_arg (stmt, 3),
5158 : 27365 : fcode);
5159 : 4333 : case BUILT_IN_STPCPY:
5160 : 4333 : return gimple_fold_builtin_stpcpy (gsi);
5161 : 2726 : case BUILT_IN_STRCPY_CHK:
5162 : 2726 : case BUILT_IN_STPCPY_CHK:
5163 : 2726 : return gimple_fold_builtin_stxcpy_chk (gsi,
5164 : : gimple_call_arg (stmt, 0),
5165 : : gimple_call_arg (stmt, 1),
5166 : : gimple_call_arg (stmt, 2),
5167 : 2726 : fcode);
5168 : 3133 : case BUILT_IN_STRNCPY_CHK:
5169 : 3133 : case BUILT_IN_STPNCPY_CHK:
5170 : 3133 : return gimple_fold_builtin_stxncpy_chk (gsi,
5171 : : gimple_call_arg (stmt, 0),
5172 : : gimple_call_arg (stmt, 1),
5173 : : gimple_call_arg (stmt, 2),
5174 : : gimple_call_arg (stmt, 3),
5175 : 3133 : fcode);
5176 : 2966 : case BUILT_IN_SNPRINTF_CHK:
5177 : 2966 : case BUILT_IN_VSNPRINTF_CHK:
5178 : 2966 : return gimple_fold_builtin_snprintf_chk (gsi, fcode);
5179 : :
5180 : 628162 : case BUILT_IN_FPRINTF:
5181 : 628162 : case BUILT_IN_FPRINTF_UNLOCKED:
5182 : 628162 : case BUILT_IN_VFPRINTF:
5183 : 628162 : if (n == 2 || n == 3)
5184 : 92456 : return gimple_fold_builtin_fprintf (gsi,
5185 : : gimple_call_arg (stmt, 0),
5186 : : gimple_call_arg (stmt, 1),
5187 : : n == 3
5188 : 41538 : ? gimple_call_arg (stmt, 2)
5189 : : : NULL_TREE,
5190 : 50918 : fcode);
5191 : : break;
5192 : 2530 : case BUILT_IN_FPRINTF_CHK:
5193 : 2530 : case BUILT_IN_VFPRINTF_CHK:
5194 : 2530 : if (n == 3 || n == 4)
5195 : 4328 : return gimple_fold_builtin_fprintf (gsi,
5196 : : gimple_call_arg (stmt, 0),
5197 : : gimple_call_arg (stmt, 2),
5198 : : n == 4
5199 : 1980 : ? gimple_call_arg (stmt, 3)
5200 : : : NULL_TREE,
5201 : 2348 : fcode);
5202 : : break;
5203 : 196562 : case BUILT_IN_PRINTF:
5204 : 196562 : case BUILT_IN_PRINTF_UNLOCKED:
5205 : 196562 : case BUILT_IN_VPRINTF:
5206 : 196562 : if (n == 1 || n == 2)
5207 : 219523 : return gimple_fold_builtin_printf (gsi, gimple_call_arg (stmt, 0),
5208 : : n == 2
5209 : 104914 : ? gimple_call_arg (stmt, 1)
5210 : 114609 : : NULL_TREE, fcode);
5211 : : break;
5212 : 2571 : case BUILT_IN_PRINTF_CHK:
5213 : 2571 : case BUILT_IN_VPRINTF_CHK:
5214 : 2571 : if (n == 2 || n == 3)
5215 : 4401 : return gimple_fold_builtin_printf (gsi, gimple_call_arg (stmt, 1),
5216 : : n == 3
5217 : 2003 : ? gimple_call_arg (stmt, 2)
5218 : 2398 : : NULL_TREE, fcode);
5219 : : break;
5220 : 1172 : case BUILT_IN_ACC_ON_DEVICE:
5221 : 1172 : return gimple_fold_builtin_acc_on_device (gsi,
5222 : 1172 : gimple_call_arg (stmt, 0));
5223 : 28092 : case BUILT_IN_REALLOC:
5224 : 28092 : return gimple_fold_builtin_realloc (gsi);
5225 : :
5226 : 663 : case BUILT_IN_CLEAR_PADDING:
5227 : 663 : return gimple_fold_builtin_clear_padding (gsi);
5228 : :
5229 : 8569979 : default:;
5230 : : }
5231 : :
5232 : : /* Try the generic builtin folder. */
5233 : 8569979 : bool ignore = (gimple_call_lhs (stmt) == NULL);
5234 : 8569979 : tree result = fold_call_stmt (stmt, ignore);
5235 : 8569979 : if (result)
5236 : : {
5237 : 5201 : if (ignore)
5238 : 823 : STRIP_NOPS (result);
5239 : : else
5240 : 4378 : result = fold_convert (gimple_call_return_type (stmt), result);
5241 : 5201 : gimplify_and_update_call_from_tree (gsi, result);
5242 : 5201 : return true;
5243 : : }
5244 : :
5245 : : return false;
5246 : : }
5247 : :
5248 : : /* Transform IFN_GOACC_DIM_SIZE and IFN_GOACC_DIM_POS internal
5249 : : function calls to constants, where possible. */
5250 : :
5251 : : static tree
5252 : 18943 : fold_internal_goacc_dim (const gimple *call)
5253 : : {
5254 : 18943 : int axis = oacc_get_ifn_dim_arg (call);
5255 : 18943 : int size = oacc_get_fn_dim_size (current_function_decl, axis);
5256 : 18943 : tree result = NULL_TREE;
5257 : 18943 : tree type = TREE_TYPE (gimple_call_lhs (call));
5258 : :
5259 : 18943 : switch (gimple_call_internal_fn (call))
5260 : : {
5261 : 8217 : case IFN_GOACC_DIM_POS:
5262 : : /* If the size is 1, we know the answer. */
5263 : 8217 : if (size == 1)
5264 : 8217 : result = build_int_cst (type, 0);
5265 : : break;
5266 : 10726 : case IFN_GOACC_DIM_SIZE:
5267 : : /* If the size is not dynamic, we know the answer. */
5268 : 10726 : if (size)
5269 : 10726 : result = build_int_cst (type, size);
5270 : : break;
5271 : : default:
5272 : : break;
5273 : : }
5274 : :
5275 : 18943 : return result;
5276 : : }
5277 : :
5278 : : /* Return true if stmt is __atomic_compare_exchange_N call which is suitable
5279 : : for conversion into ATOMIC_COMPARE_EXCHANGE if the second argument is
5280 : : &var where var is only addressable because of such calls. */
5281 : :
5282 : : bool
5283 : 53197814 : optimize_atomic_compare_exchange_p (gimple *stmt)
5284 : : {
5285 : 53197814 : if (gimple_call_num_args (stmt) != 6
5286 : 1251731 : || !flag_inline_atomics
5287 : 1251731 : || !optimize
5288 : 1251731 : || sanitize_flags_p (SANITIZE_THREAD | SANITIZE_ADDRESS)
5289 : 1251672 : || !gimple_call_builtin_p (stmt, BUILT_IN_NORMAL)
5290 : 749588 : || !gimple_vdef (stmt)
5291 : 53866179 : || !gimple_vuse (stmt))
5292 : 52529449 : return false;
5293 : :
5294 : 668365 : tree fndecl = gimple_call_fndecl (stmt);
5295 : 668365 : switch (DECL_FUNCTION_CODE (fndecl))
5296 : : {
5297 : 52583 : case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1:
5298 : 52583 : case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2:
5299 : 52583 : case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4:
5300 : 52583 : case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8:
5301 : 52583 : case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16:
5302 : 52583 : break;
5303 : : default:
5304 : : return false;
5305 : : }
5306 : :
5307 : 52583 : tree expected = gimple_call_arg (stmt, 1);
5308 : 52583 : if (TREE_CODE (expected) != ADDR_EXPR
5309 : 52583 : || !SSA_VAR_P (TREE_OPERAND (expected, 0)))
5310 : : return false;
5311 : :
5312 : 50281 : tree etype = TREE_TYPE (TREE_OPERAND (expected, 0));
5313 : 50281 : if (!is_gimple_reg_type (etype)
5314 : 49895 : || !auto_var_in_fn_p (TREE_OPERAND (expected, 0), current_function_decl)
5315 : 47511 : || TREE_THIS_VOLATILE (etype)
5316 : 47511 : || VECTOR_TYPE_P (etype)
5317 : : || TREE_CODE (etype) == COMPLEX_TYPE
5318 : : /* Don't optimize floating point expected vars, VIEW_CONVERT_EXPRs
5319 : : might not preserve all the bits. See PR71716. */
5320 : : || SCALAR_FLOAT_TYPE_P (etype)
5321 : 68375 : || maybe_ne (TYPE_PRECISION (etype),
5322 : 36188 : GET_MODE_BITSIZE (TYPE_MODE (etype))))
5323 : 38543 : return false;
5324 : :
5325 : 11738 : tree weak = gimple_call_arg (stmt, 3);
5326 : 11738 : if (!integer_zerop (weak) && !integer_onep (weak))
5327 : : return false;
5328 : :
5329 : 11738 : tree parmt = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
5330 : 11738 : tree itype = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (parmt)));
5331 : 11738 : machine_mode mode = TYPE_MODE (itype);
5332 : :
5333 : 11738 : if (direct_optab_handler (atomic_compare_and_swap_optab, mode)
5334 : : == CODE_FOR_nothing
5335 : 11738 : && optab_handler (sync_compare_and_swap_optab, mode) == CODE_FOR_nothing)
5336 : : return false;
5337 : :
5338 : 23476 : if (maybe_ne (int_size_in_bytes (etype), GET_MODE_SIZE (mode)))
5339 : : return false;
5340 : :
5341 : : return true;
5342 : : }
5343 : :
5344 : : /* Fold
5345 : : r = __atomic_compare_exchange_N (p, &e, d, w, s, f);
5346 : : into
5347 : : _Complex uintN_t t = ATOMIC_COMPARE_EXCHANGE (p, e, d, w * 256 + N, s, f);
5348 : : i = IMAGPART_EXPR <t>;
5349 : : r = (_Bool) i;
5350 : : e = REALPART_EXPR <t>; */
5351 : :
5352 : : void
5353 : 5753 : fold_builtin_atomic_compare_exchange (gimple_stmt_iterator *gsi)
5354 : : {
5355 : 5753 : gimple *stmt = gsi_stmt (*gsi);
5356 : 5753 : tree fndecl = gimple_call_fndecl (stmt);
5357 : 5753 : tree parmt = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
5358 : 5753 : tree itype = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (parmt)));
5359 : 5753 : tree ctype = build_complex_type (itype);
5360 : 5753 : tree expected = TREE_OPERAND (gimple_call_arg (stmt, 1), 0);
5361 : 5753 : bool throws = false;
5362 : 5753 : edge e = NULL;
5363 : 5753 : gimple *g = gimple_build_assign (make_ssa_name (TREE_TYPE (expected)),
5364 : : expected);
5365 : 5753 : gsi_insert_before (gsi, g, GSI_SAME_STMT);
5366 : 5753 : gimple_stmt_iterator gsiret = gsi_for_stmt (g);
5367 : 5753 : if (!useless_type_conversion_p (itype, TREE_TYPE (expected)))
5368 : : {
5369 : 2588 : g = gimple_build_assign (make_ssa_name (itype), VIEW_CONVERT_EXPR,
5370 : : build1 (VIEW_CONVERT_EXPR, itype,
5371 : : gimple_assign_lhs (g)));
5372 : 2588 : gsi_insert_before (gsi, g, GSI_SAME_STMT);
5373 : : }
5374 : 5753 : int flag = (integer_onep (gimple_call_arg (stmt, 3)) ? 256 : 0)
5375 : 11041 : + int_size_in_bytes (itype);
5376 : 5753 : g = gimple_build_call_internal (IFN_ATOMIC_COMPARE_EXCHANGE, 6,
5377 : : gimple_call_arg (stmt, 0),
5378 : : gimple_assign_lhs (g),
5379 : : gimple_call_arg (stmt, 2),
5380 : 5753 : build_int_cst (integer_type_node, flag),
5381 : : gimple_call_arg (stmt, 4),
5382 : : gimple_call_arg (stmt, 5));
5383 : 5753 : tree lhs = make_ssa_name (ctype);
5384 : 5753 : gimple_call_set_lhs (g, lhs);
5385 : 5753 : gimple_move_vops (g, stmt);
5386 : 5753 : tree oldlhs = gimple_call_lhs (stmt);
5387 : 5753 : if (stmt_can_throw_internal (cfun, stmt))
5388 : : {
5389 : 204 : throws = true;
5390 : 204 : e = find_fallthru_edge (gsi_bb (*gsi)->succs);
5391 : : }
5392 : 5753 : gimple_call_set_nothrow (as_a <gcall *> (g),
5393 : 5753 : gimple_call_nothrow_p (as_a <gcall *> (stmt)));
5394 : 5753 : gimple_call_set_lhs (stmt, NULL_TREE);
5395 : 5753 : gsi_replace (gsi, g, true);
5396 : 5753 : if (oldlhs)
5397 : : {
5398 : 5700 : g = gimple_build_assign (make_ssa_name (itype), IMAGPART_EXPR,
5399 : : build1 (IMAGPART_EXPR, itype, lhs));
5400 : 5700 : if (throws)
5401 : : {
5402 : 198 : gsi_insert_on_edge_immediate (e, g);
5403 : 198 : *gsi = gsi_for_stmt (g);
5404 : : }
5405 : : else
5406 : 5502 : gsi_insert_after (gsi, g, GSI_NEW_STMT);
5407 : 5700 : g = gimple_build_assign (oldlhs, NOP_EXPR, gimple_assign_lhs (g));
5408 : 5700 : gsi_insert_after (gsi, g, GSI_NEW_STMT);
5409 : : }
5410 : 5753 : g = gimple_build_assign (make_ssa_name (itype), REALPART_EXPR,
5411 : : build1 (REALPART_EXPR, itype, lhs));
5412 : 5753 : if (throws && oldlhs == NULL_TREE)
5413 : : {
5414 : 6 : gsi_insert_on_edge_immediate (e, g);
5415 : 6 : *gsi = gsi_for_stmt (g);
5416 : : }
5417 : : else
5418 : 5747 : gsi_insert_after (gsi, g, GSI_NEW_STMT);
5419 : 5753 : if (!useless_type_conversion_p (TREE_TYPE (expected), itype))
5420 : : {
5421 : 5176 : g = gimple_build_assign (make_ssa_name (TREE_TYPE (expected)),
5422 : : VIEW_CONVERT_EXPR,
5423 : 2588 : build1 (VIEW_CONVERT_EXPR, TREE_TYPE (expected),
5424 : : gimple_assign_lhs (g)));
5425 : 2588 : gsi_insert_after (gsi, g, GSI_NEW_STMT);
5426 : : }
5427 : 5753 : g = gimple_build_assign (expected, SSA_NAME, gimple_assign_lhs (g));
5428 : 5753 : gsi_insert_after (gsi, g, GSI_NEW_STMT);
5429 : 5753 : *gsi = gsiret;
5430 : 5753 : }
5431 : :
5432 : : /* Return true if ARG0 CODE ARG1 in infinite signed precision operation
5433 : : doesn't fit into TYPE. The test for overflow should be regardless of
5434 : : -fwrapv, and even for unsigned types. */
5435 : :
5436 : : bool
5437 : 366971 : arith_overflowed_p (enum tree_code code, const_tree type,
5438 : : const_tree arg0, const_tree arg1)
5439 : : {
5440 : 366971 : widest2_int warg0 = widest2_int_cst (arg0);
5441 : 366971 : widest2_int warg1 = widest2_int_cst (arg1);
5442 : 366971 : widest2_int wres;
5443 : 366971 : switch (code)
5444 : : {
5445 : 95544 : case PLUS_EXPR: wres = wi::add (warg0, warg1); break;
5446 : 115078 : case MINUS_EXPR: wres = wi::sub (warg0, warg1); break;
5447 : 157526 : case MULT_EXPR: wres = wi::mul (warg0, warg1); break;
5448 : 0 : default: gcc_unreachable ();
5449 : : }
5450 : 366971 : signop sign = TYPE_SIGN (type);
5451 : 366971 : if (sign == UNSIGNED && wi::neg_p (wres))
5452 : : return true;
5453 : 295195 : return wi::min_precision (wres, sign) > TYPE_PRECISION (type);
5454 : 366983 : }
5455 : :
5456 : : /* If IFN_{MASK,LEN,MASK_LEN}_LOAD/STORE call CALL is unconditional,
5457 : : return a MEM_REF for the memory it references, otherwise return null.
5458 : : VECTYPE is the type of the memory vector. MASK_P indicates it's for
5459 : : MASK if true, otherwise it's for LEN. */
5460 : :
5461 : : static tree
5462 : 5442 : gimple_fold_partial_load_store_mem_ref (gcall *call, tree vectype, bool mask_p)
5463 : : {
5464 : 5442 : tree ptr = gimple_call_arg (call, 0);
5465 : 5442 : tree alias_align = gimple_call_arg (call, 1);
5466 : 5442 : if (!tree_fits_uhwi_p (alias_align))
5467 : : return NULL_TREE;
5468 : :
5469 : 5442 : if (mask_p)
5470 : : {
5471 : 5442 : tree mask = gimple_call_arg (call, 2);
5472 : 5442 : if (!integer_all_onesp (mask))
5473 : : return NULL_TREE;
5474 : : }
5475 : : else
5476 : : {
5477 : 0 : internal_fn ifn = gimple_call_internal_fn (call);
5478 : 0 : int len_index = internal_fn_len_index (ifn);
5479 : 0 : tree basic_len = gimple_call_arg (call, len_index);
5480 : 0 : if (!poly_int_tree_p (basic_len))
5481 : : return NULL_TREE;
5482 : 0 : tree bias = gimple_call_arg (call, len_index + 1);
5483 : 0 : gcc_assert (TREE_CODE (bias) == INTEGER_CST);
5484 : : /* For LEN_LOAD/LEN_STORE/MASK_LEN_LOAD/MASK_LEN_STORE,
5485 : : we don't fold when (bias + len) != VF. */
5486 : 0 : if (maybe_ne (wi::to_poly_widest (basic_len) + wi::to_widest (bias),
5487 : 0 : GET_MODE_NUNITS (TYPE_MODE (vectype))))
5488 : : return NULL_TREE;
5489 : :
5490 : : /* For MASK_LEN_{LOAD,STORE}, we should also check whether
5491 : : the mask is all ones mask. */
5492 : 0 : if (ifn == IFN_MASK_LEN_LOAD || ifn == IFN_MASK_LEN_STORE)
5493 : : {
5494 : 0 : tree mask = gimple_call_arg (call, internal_fn_mask_index (ifn));
5495 : 0 : if (!integer_all_onesp (mask))
5496 : : return NULL_TREE;
5497 : : }
5498 : : }
5499 : :
5500 : 25 : unsigned HOST_WIDE_INT align = tree_to_uhwi (alias_align);
5501 : 25 : if (TYPE_ALIGN (vectype) != align)
5502 : 14 : vectype = build_aligned_type (vectype, align);
5503 : 25 : tree offset = build_zero_cst (TREE_TYPE (alias_align));
5504 : 25 : return fold_build2 (MEM_REF, vectype, ptr, offset);
5505 : : }
5506 : :
5507 : : /* Try to fold IFN_{MASK,LEN}_LOAD call CALL. Return true on success.
5508 : : MASK_P indicates it's for MASK if true, otherwise it's for LEN. */
5509 : :
5510 : : static bool
5511 : 1541 : gimple_fold_partial_load (gimple_stmt_iterator *gsi, gcall *call, bool mask_p)
5512 : : {
5513 : 1541 : tree lhs = gimple_call_lhs (call);
5514 : 1541 : if (!lhs)
5515 : : return false;
5516 : :
5517 : 3082 : if (tree rhs
5518 : 1541 : = gimple_fold_partial_load_store_mem_ref (call, TREE_TYPE (lhs), mask_p))
5519 : : {
5520 : 11 : gassign *new_stmt = gimple_build_assign (lhs, rhs);
5521 : 11 : gimple_set_location (new_stmt, gimple_location (call));
5522 : 11 : gimple_move_vops (new_stmt, call);
5523 : 11 : gsi_replace (gsi, new_stmt, false);
5524 : 11 : return true;
5525 : : }
5526 : : return false;
5527 : : }
5528 : :
5529 : : /* Try to fold IFN_{MASK,LEN}_STORE call CALL. Return true on success.
5530 : : MASK_P indicates it's for MASK if true, otherwise it's for LEN. */
5531 : :
5532 : : static bool
5533 : 3901 : gimple_fold_partial_store (gimple_stmt_iterator *gsi, gcall *call,
5534 : : bool mask_p)
5535 : : {
5536 : 3901 : internal_fn ifn = gimple_call_internal_fn (call);
5537 : 3901 : tree rhs = gimple_call_arg (call, internal_fn_stored_value_index (ifn));
5538 : 7802 : if (tree lhs
5539 : 3901 : = gimple_fold_partial_load_store_mem_ref (call, TREE_TYPE (rhs), mask_p))
5540 : : {
5541 : 14 : gassign *new_stmt = gimple_build_assign (lhs, rhs);
5542 : 14 : gimple_set_location (new_stmt, gimple_location (call));
5543 : 14 : gimple_move_vops (new_stmt, call);
5544 : 14 : gsi_replace (gsi, new_stmt, false);
5545 : 14 : return true;
5546 : : }
5547 : : return false;
5548 : : }
5549 : :
5550 : : /* Attempt to fold a call statement referenced by the statement iterator GSI.
5551 : : The statement may be replaced by another statement, e.g., if the call
5552 : : simplifies to a constant value. Return true if any changes were made.
5553 : : It is assumed that the operands have been previously folded. */
5554 : :
5555 : : static bool
5556 : 51332973 : gimple_fold_call (gimple_stmt_iterator *gsi, bool inplace)
5557 : : {
5558 : 51332973 : gcall *stmt = as_a <gcall *> (gsi_stmt (*gsi));
5559 : 51332973 : tree callee;
5560 : 51332973 : bool changed = false;
5561 : :
5562 : : /* Check for virtual calls that became direct calls. */
5563 : 51332973 : callee = gimple_call_fn (stmt);
5564 : 51332973 : if (callee && TREE_CODE (callee) == OBJ_TYPE_REF)
5565 : : {
5566 : 447558 : if (gimple_call_addr_fndecl (OBJ_TYPE_REF_EXPR (callee)) != NULL_TREE)
5567 : : {
5568 : 8 : if (dump_file && virtual_method_call_p (callee)
5569 : 304 : && !possible_polymorphic_call_target_p
5570 : 8 : (callee, stmt, cgraph_node::get (gimple_call_addr_fndecl
5571 : 8 : (OBJ_TYPE_REF_EXPR (callee)))))
5572 : : {
5573 : 0 : fprintf (dump_file,
5574 : : "Type inheritance inconsistent devirtualization of ");
5575 : 0 : print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
5576 : 0 : fprintf (dump_file, " to ");
5577 : 0 : print_generic_expr (dump_file, callee, TDF_SLIM);
5578 : 0 : fprintf (dump_file, "\n");
5579 : : }
5580 : :
5581 : 296 : gimple_call_set_fn (stmt, OBJ_TYPE_REF_EXPR (callee));
5582 : 296 : changed = true;
5583 : : }
5584 : 447262 : else if (flag_devirtualize && !inplace && virtual_method_call_p (callee))
5585 : : {
5586 : 442180 : bool final;
5587 : 442180 : vec <cgraph_node *>targets
5588 : 442180 : = possible_polymorphic_call_targets (callee, stmt, &final);
5589 : 444871 : if (final && targets.length () <= 1 && dbg_cnt (devirt))
5590 : : {
5591 : 2072 : tree lhs = gimple_call_lhs (stmt);
5592 : 2072 : if (dump_enabled_p ())
5593 : : {
5594 : 44 : dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, stmt,
5595 : : "folding virtual function call to %s\n",
5596 : 44 : targets.length () == 1
5597 : 22 : ? targets[0]->name ()
5598 : : : "__builtin_unreachable");
5599 : : }
5600 : 2072 : if (targets.length () == 1)
5601 : : {
5602 : 2019 : tree fndecl = targets[0]->decl;
5603 : 2019 : gimple_call_set_fndecl (stmt, fndecl);
5604 : 2019 : changed = true;
5605 : : /* If changing the call to __cxa_pure_virtual
5606 : : or similar noreturn function, adjust gimple_call_fntype
5607 : : too. */
5608 : 2019 : if (gimple_call_noreturn_p (stmt)
5609 : 24 : && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl)))
5610 : 16 : && TYPE_ARG_TYPES (TREE_TYPE (fndecl))
5611 : 2035 : && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
5612 : 16 : == void_type_node))
5613 : 16 : gimple_call_set_fntype (stmt, TREE_TYPE (fndecl));
5614 : : /* If the call becomes noreturn, remove the lhs. */
5615 : 2019 : if (lhs
5616 : 1710 : && gimple_call_noreturn_p (stmt)
5617 : 2039 : && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (stmt)))
5618 : 8 : || should_remove_lhs_p (lhs)))
5619 : : {
5620 : 16 : if (TREE_CODE (lhs) == SSA_NAME)
5621 : : {
5622 : 0 : tree var = create_tmp_var (TREE_TYPE (lhs));
5623 : 0 : tree def = get_or_create_ssa_default_def (cfun, var);
5624 : 0 : gimple *new_stmt = gimple_build_assign (lhs, def);
5625 : 0 : gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT);
5626 : : }
5627 : 16 : gimple_call_set_lhs (stmt, NULL_TREE);
5628 : : }
5629 : 2019 : maybe_remove_unused_call_args (cfun, stmt);
5630 : : }
5631 : : else
5632 : : {
5633 : 53 : location_t loc = gimple_location (stmt);
5634 : 53 : gimple *new_stmt = gimple_build_builtin_unreachable (loc);
5635 : 53 : gimple_call_set_ctrl_altering (new_stmt, false);
5636 : : /* If the call had a SSA name as lhs morph that into
5637 : : an uninitialized value. */
5638 : 53 : if (lhs && TREE_CODE (lhs) == SSA_NAME)
5639 : : {
5640 : 15 : tree var = create_tmp_var (TREE_TYPE (lhs));
5641 : 15 : SET_SSA_NAME_VAR_OR_IDENTIFIER (lhs, var);
5642 : 15 : SSA_NAME_DEF_STMT (lhs) = gimple_build_nop ();
5643 : 15 : set_ssa_default_def (cfun, var, lhs);
5644 : : }
5645 : 53 : gimple_move_vops (new_stmt, stmt);
5646 : 53 : gsi_replace (gsi, new_stmt, false);
5647 : 53 : return true;
5648 : : }
5649 : : }
5650 : : }
5651 : : }
5652 : :
5653 : : /* Check for indirect calls that became direct calls, and then
5654 : : no longer require a static chain. */
5655 : 51332920 : if (gimple_call_chain (stmt))
5656 : : {
5657 : 244596 : tree fn = gimple_call_fndecl (stmt);
5658 : 292503 : if (fn && !DECL_STATIC_CHAIN (fn))
5659 : : {
5660 : 2021 : gimple_call_set_chain (stmt, NULL);
5661 : 2021 : changed = true;
5662 : : }
5663 : : }
5664 : :
5665 : 51332920 : if (inplace)
5666 : : return changed;
5667 : :
5668 : : /* Check for builtins that CCP can handle using information not
5669 : : available in the generic fold routines. */
5670 : 51330534 : if (gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
5671 : : {
5672 : 11704552 : if (gimple_fold_builtin (gsi))
5673 : 192952 : changed = true;
5674 : : }
5675 : 39625982 : else if (gimple_call_builtin_p (stmt, BUILT_IN_MD))
5676 : : {
5677 : 1034164 : changed |= targetm.gimple_fold_builtin (gsi);
5678 : : }
5679 : 38591818 : else if (gimple_call_internal_p (stmt))
5680 : : {
5681 : 1301028 : enum tree_code subcode = ERROR_MARK;
5682 : 1301028 : tree result = NULL_TREE;
5683 : 1301028 : bool cplx_result = false;
5684 : 1301028 : bool uaddc_usubc = false;
5685 : 1301028 : tree overflow = NULL_TREE;
5686 : 1301028 : switch (gimple_call_internal_fn (stmt))
5687 : : {
5688 : 121418 : case IFN_BUILTIN_EXPECT:
5689 : 121418 : result = fold_builtin_expect (gimple_location (stmt),
5690 : : gimple_call_arg (stmt, 0),
5691 : : gimple_call_arg (stmt, 1),
5692 : : gimple_call_arg (stmt, 2),
5693 : : NULL_TREE);
5694 : 121418 : break;
5695 : 8441 : case IFN_UBSAN_OBJECT_SIZE:
5696 : 8441 : {
5697 : 8441 : tree offset = gimple_call_arg (stmt, 1);
5698 : 8441 : tree objsize = gimple_call_arg (stmt, 2);
5699 : 8441 : if (integer_all_onesp (objsize)
5700 : 8441 : || (TREE_CODE (offset) == INTEGER_CST
5701 : 4655 : && TREE_CODE (objsize) == INTEGER_CST
5702 : 1158 : && tree_int_cst_le (offset, objsize)))
5703 : : {
5704 : 1510 : replace_call_with_value (gsi, NULL_TREE);
5705 : 1510 : return true;
5706 : : }
5707 : : }
5708 : : break;
5709 : 11328 : case IFN_UBSAN_PTR:
5710 : 11328 : if (integer_zerop (gimple_call_arg (stmt, 1)))
5711 : : {
5712 : 44 : replace_call_with_value (gsi, NULL_TREE);
5713 : 44 : return true;
5714 : : }
5715 : : break;
5716 : 6349 : case IFN_UBSAN_BOUNDS:
5717 : 6349 : {
5718 : 6349 : tree index = gimple_call_arg (stmt, 1);
5719 : 6349 : tree bound = gimple_call_arg (stmt, 2);
5720 : 6349 : if (TREE_CODE (index) == INTEGER_CST
5721 : 4192 : && TREE_CODE (bound) == INTEGER_CST)
5722 : : {
5723 : 4036 : index = fold_convert (TREE_TYPE (bound), index);
5724 : 4036 : if (TREE_CODE (index) == INTEGER_CST
5725 : 4036 : && tree_int_cst_lt (index, bound))
5726 : : {
5727 : 290 : replace_call_with_value (gsi, NULL_TREE);
5728 : 290 : return true;
5729 : : }
5730 : : }
5731 : : }
5732 : : break;
5733 : 18943 : case IFN_GOACC_DIM_SIZE:
5734 : 18943 : case IFN_GOACC_DIM_POS:
5735 : 18943 : result = fold_internal_goacc_dim (stmt);
5736 : 18943 : break;
5737 : : case IFN_UBSAN_CHECK_ADD:
5738 : 1299184 : subcode = PLUS_EXPR;
5739 : : break;
5740 : 6642 : case IFN_UBSAN_CHECK_SUB:
5741 : 6642 : subcode = MINUS_EXPR;
5742 : 6642 : break;
5743 : 5673 : case IFN_UBSAN_CHECK_MUL:
5744 : 5673 : subcode = MULT_EXPR;
5745 : 5673 : break;
5746 : 125540 : case IFN_ADD_OVERFLOW:
5747 : 125540 : subcode = PLUS_EXPR;
5748 : 125540 : cplx_result = true;
5749 : 125540 : break;
5750 : 152489 : case IFN_SUB_OVERFLOW:
5751 : 152489 : subcode = MINUS_EXPR;
5752 : 152489 : cplx_result = true;
5753 : 152489 : break;
5754 : 156192 : case IFN_MUL_OVERFLOW:
5755 : 156192 : subcode = MULT_EXPR;
5756 : 156192 : cplx_result = true;
5757 : 156192 : break;
5758 : 20032 : case IFN_UADDC:
5759 : 20032 : subcode = PLUS_EXPR;
5760 : 20032 : cplx_result = true;
5761 : 20032 : uaddc_usubc = true;
5762 : 20032 : break;
5763 : 10408 : case IFN_USUBC:
5764 : 10408 : subcode = MINUS_EXPR;
5765 : 10408 : cplx_result = true;
5766 : 10408 : uaddc_usubc = true;
5767 : 10408 : break;
5768 : 1541 : case IFN_MASK_LOAD:
5769 : 1541 : changed |= gimple_fold_partial_load (gsi, stmt, true);
5770 : 1541 : break;
5771 : 3901 : case IFN_MASK_STORE:
5772 : 3901 : changed |= gimple_fold_partial_store (gsi, stmt, true);
5773 : 3901 : break;
5774 : 0 : case IFN_LEN_LOAD:
5775 : 0 : case IFN_MASK_LEN_LOAD:
5776 : 0 : changed |= gimple_fold_partial_load (gsi, stmt, false);
5777 : 0 : break;
5778 : 0 : case IFN_LEN_STORE:
5779 : 0 : case IFN_MASK_LEN_STORE:
5780 : 0 : changed |= gimple_fold_partial_store (gsi, stmt, false);
5781 : 0 : break;
5782 : : default:
5783 : : break;
5784 : : }
5785 : 1299184 : if (subcode != ERROR_MARK)
5786 : : {
5787 : 483713 : tree arg0 = gimple_call_arg (stmt, 0);
5788 : 483713 : tree arg1 = gimple_call_arg (stmt, 1);
5789 : 483713 : tree arg2 = NULL_TREE;
5790 : 483713 : tree type = TREE_TYPE (arg0);
5791 : 483713 : if (cplx_result)
5792 : : {
5793 : 464661 : tree lhs = gimple_call_lhs (stmt);
5794 : 464661 : if (lhs == NULL_TREE)
5795 : : type = NULL_TREE;
5796 : : else
5797 : 464661 : type = TREE_TYPE (TREE_TYPE (lhs));
5798 : 464661 : if (uaddc_usubc)
5799 : 30440 : arg2 = gimple_call_arg (stmt, 2);
5800 : : }
5801 : 483713 : if (type == NULL_TREE)
5802 : : ;
5803 : 483713 : else if (uaddc_usubc)
5804 : : {
5805 : 30440 : if (!integer_zerop (arg2))
5806 : : ;
5807 : : /* x = y + 0 + 0; x = y - 0 - 0; */
5808 : 4752 : else if (integer_zerop (arg1))
5809 : : result = arg0;
5810 : : /* x = 0 + y + 0; */
5811 : 4134 : else if (subcode != MINUS_EXPR && integer_zerop (arg0))
5812 : : result = arg1;
5813 : : /* x = y - y - 0; */
5814 : 4134 : else if (subcode == MINUS_EXPR
5815 : 4134 : && operand_equal_p (arg0, arg1, 0))
5816 : 0 : result = integer_zero_node;
5817 : : }
5818 : : /* x = y + 0; x = y - 0; x = y * 0; */
5819 : 453273 : else if (integer_zerop (arg1))
5820 : 9997 : result = subcode == MULT_EXPR ? integer_zero_node : arg0;
5821 : : /* x = 0 + y; x = 0 * y; */
5822 : 443276 : else if (subcode != MINUS_EXPR && integer_zerop (arg0))
5823 : 0 : result = subcode == MULT_EXPR ? integer_zero_node : arg1;
5824 : : /* x = y - y; */
5825 : 443276 : else if (subcode == MINUS_EXPR && operand_equal_p (arg0, arg1, 0))
5826 : 6 : result = integer_zero_node;
5827 : : /* x = y * 1; x = 1 * y; */
5828 : 443270 : else if (subcode == MULT_EXPR && integer_onep (arg1))
5829 : : result = arg0;
5830 : 439954 : else if (subcode == MULT_EXPR && integer_onep (arg0))
5831 : : result = arg1;
5832 : 483713 : if (result)
5833 : : {
5834 : 13937 : if (result == integer_zero_node)
5835 : 2136 : result = build_zero_cst (type);
5836 : 11801 : else if (cplx_result && TREE_TYPE (result) != type)
5837 : : {
5838 : 9495 : if (TREE_CODE (result) == INTEGER_CST)
5839 : : {
5840 : 0 : if (arith_overflowed_p (PLUS_EXPR, type, result,
5841 : : integer_zero_node))
5842 : 0 : overflow = build_one_cst (type);
5843 : : }
5844 : 9495 : else if ((!TYPE_UNSIGNED (TREE_TYPE (result))
5845 : 6895 : && TYPE_UNSIGNED (type))
5846 : 9616 : || (TYPE_PRECISION (type)
5847 : 2721 : < (TYPE_PRECISION (TREE_TYPE (result))
5848 : 2721 : + (TYPE_UNSIGNED (TREE_TYPE (result))
5849 : 2935 : && !TYPE_UNSIGNED (type)))))
5850 : : result = NULL_TREE;
5851 : 60 : if (result)
5852 : 60 : result = fold_convert (type, result);
5853 : : }
5854 : : }
5855 : : }
5856 : :
5857 : 819973 : if (result)
5858 : : {
5859 : 25175 : if (TREE_CODE (result) == INTEGER_CST && TREE_OVERFLOW (result))
5860 : 0 : result = drop_tree_overflow (result);
5861 : 25175 : if (cplx_result)
5862 : : {
5863 : 4487 : if (overflow == NULL_TREE)
5864 : 4487 : overflow = build_zero_cst (TREE_TYPE (result));
5865 : 4487 : tree ctype = build_complex_type (TREE_TYPE (result));
5866 : 4487 : if (TREE_CODE (result) == INTEGER_CST
5867 : 2136 : && TREE_CODE (overflow) == INTEGER_CST)
5868 : 2136 : result = build_complex (ctype, result, overflow);
5869 : : else
5870 : 2351 : result = build2_loc (gimple_location (stmt), COMPLEX_EXPR,
5871 : : ctype, result, overflow);
5872 : : }
5873 : 25175 : gimplify_and_update_call_from_tree (gsi, result);
5874 : 25175 : changed = true;
5875 : : }
5876 : : }
5877 : :
5878 : : return changed;
5879 : : }
5880 : :
5881 : :
5882 : : /* Return true whether NAME has a use on STMT. Note this can return
5883 : : false even though there's a use on STMT if SSA operands are not
5884 : : up-to-date. */
5885 : :
5886 : : static bool
5887 : 1586 : has_use_on_stmt (tree name, gimple *stmt)
5888 : : {
5889 : 1586 : ssa_op_iter iter;
5890 : 1586 : tree op;
5891 : 3207 : FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
5892 : 1667 : if (op == name)
5893 : : return true;
5894 : : return false;
5895 : : }
5896 : :
5897 : : /* Worker for fold_stmt_1 dispatch to pattern based folding with
5898 : : gimple_simplify.
5899 : :
5900 : : Replaces *GSI with the simplification result in RCODE and OPS
5901 : : and the associated statements in *SEQ. Does the replacement
5902 : : according to INPLACE and returns true if the operation succeeded. */
5903 : :
5904 : : static bool
5905 : 7909093 : replace_stmt_with_simplification (gimple_stmt_iterator *gsi,
5906 : : gimple_match_op *res_op,
5907 : : gimple_seq *seq, bool inplace)
5908 : : {
5909 : 7909093 : gimple *stmt = gsi_stmt (*gsi);
5910 : 7909093 : tree *ops = res_op->ops;
5911 : 7909093 : unsigned int num_ops = res_op->num_ops;
5912 : :
5913 : : /* Play safe and do not allow abnormals to be mentioned in
5914 : : newly created statements. See also maybe_push_res_to_seq.
5915 : : As an exception allow such uses if there was a use of the
5916 : : same SSA name on the old stmt. */
5917 : 17341342 : for (unsigned int i = 0; i < num_ops; ++i)
5918 : 9433789 : if (TREE_CODE (ops[i]) == SSA_NAME
5919 : 5875451 : && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[i])
5920 : 9435375 : && !has_use_on_stmt (ops[i], stmt))
5921 : : return false;
5922 : :
5923 : 7907553 : if (num_ops > 0 && COMPARISON_CLASS_P (ops[0]))
5924 : 0 : for (unsigned int i = 0; i < 2; ++i)
5925 : 0 : if (TREE_CODE (TREE_OPERAND (ops[0], i)) == SSA_NAME
5926 : 0 : && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (ops[0], i))
5927 : 0 : && !has_use_on_stmt (TREE_OPERAND (ops[0], i), stmt))
5928 : : return false;
5929 : :
5930 : : /* Don't insert new statements when INPLACE is true, even if we could
5931 : : reuse STMT for the final statement. */
5932 : 7907553 : if (inplace && !gimple_seq_empty_p (*seq))
5933 : : return false;
5934 : :
5935 : 7907553 : if (gcond *cond_stmt = dyn_cast <gcond *> (stmt))
5936 : : {
5937 : 6046045 : gcc_assert (res_op->code.is_tree_code ());
5938 : 6046045 : auto code = tree_code (res_op->code);
5939 : 6046045 : if (TREE_CODE_CLASS (code) == tcc_comparison
5940 : : /* GIMPLE_CONDs condition may not throw. */
5941 : 6046045 : && (!flag_exceptions
5942 : 651444 : || !cfun->can_throw_non_call_exceptions
5943 : 286431 : || !operation_could_trap_p (code,
5944 : 286431 : FLOAT_TYPE_P (TREE_TYPE (ops[0])),
5945 : : false, NULL_TREE)))
5946 : 950860 : gimple_cond_set_condition (cond_stmt, code, ops[0], ops[1]);
5947 : 5095185 : else if (code == SSA_NAME)
5948 : 3605114 : gimple_cond_set_condition (cond_stmt, NE_EXPR, ops[0],
5949 : 3605114 : build_zero_cst (TREE_TYPE (ops[0])));
5950 : 1490071 : else if (code == INTEGER_CST)
5951 : : {
5952 : 963060 : if (integer_zerop (ops[0]))
5953 : 681021 : gimple_cond_make_false (cond_stmt);
5954 : : else
5955 : 282039 : gimple_cond_make_true (cond_stmt);
5956 : : }
5957 : 527011 : else if (!inplace)
5958 : : {
5959 : 527011 : tree res = maybe_push_res_to_seq (res_op, seq);
5960 : 527011 : if (!res)
5961 : : return false;
5962 : 527011 : gimple_cond_set_condition (cond_stmt, NE_EXPR, res,
5963 : 527011 : build_zero_cst (TREE_TYPE (res)));
5964 : : }
5965 : : else
5966 : : return false;
5967 : 6046045 : if (dump_file && (dump_flags & TDF_DETAILS))
5968 : : {
5969 : 963 : fprintf (dump_file, "gimple_simplified to ");
5970 : 963 : if (!gimple_seq_empty_p (*seq))
5971 : 0 : print_gimple_seq (dump_file, *seq, 0, TDF_SLIM);
5972 : 963 : print_gimple_stmt (dump_file, gsi_stmt (*gsi),
5973 : : 0, TDF_SLIM);
5974 : : }
5975 : 6046045 : gsi_insert_seq_before (gsi, *seq, GSI_SAME_STMT);
5976 : 6046045 : return true;
5977 : : }
5978 : 1861508 : else if (is_gimple_assign (stmt)
5979 : 1861508 : && res_op->code.is_tree_code ())
5980 : : {
5981 : 1781894 : auto code = tree_code (res_op->code);
5982 : 1781894 : if (!inplace
5983 : 1781894 : || gimple_num_ops (stmt) > get_gimple_rhs_num_ops (code))
5984 : : {
5985 : 1781894 : maybe_build_generic_op (res_op);
5986 : 4093979 : gimple_assign_set_rhs_with_ops (gsi, code,
5987 : : res_op->op_or_null (0),
5988 : : res_op->op_or_null (1),
5989 : : res_op->op_or_null (2));
5990 : 1781894 : if (dump_file && (dump_flags & TDF_DETAILS))
5991 : : {
5992 : 11082 : fprintf (dump_file, "gimple_simplified to ");
5993 : 11082 : if (!gimple_seq_empty_p (*seq))
5994 : 1216 : print_gimple_seq (dump_file, *seq, 0, TDF_SLIM);
5995 : 11082 : print_gimple_stmt (dump_file, gsi_stmt (*gsi),
5996 : : 0, TDF_SLIM);
5997 : : }
5998 : 1781894 : gsi_insert_seq_before (gsi, *seq, GSI_SAME_STMT);
5999 : 1781894 : return true;
6000 : : }
6001 : : }
6002 : 79614 : else if (res_op->code.is_fn_code ()
6003 : 79614 : && gimple_call_combined_fn (stmt) == combined_fn (res_op->code))
6004 : : {
6005 : 7755 : gcc_assert (num_ops == gimple_call_num_args (stmt));
6006 : 23088 : for (unsigned int i = 0; i < num_ops; ++i)
6007 : 15333 : gimple_call_set_arg (stmt, i, ops[i]);
6008 : 7755 : if (dump_file && (dump_flags & TDF_DETAILS))
6009 : : {
6010 : 0 : fprintf (dump_file, "gimple_simplified to ");
6011 : 0 : if (!gimple_seq_empty_p (*seq))
6012 : 0 : print_gimple_seq (dump_file, *seq, 0, TDF_SLIM);
6013 : 0 : print_gimple_stmt (dump_file, gsi_stmt (*gsi), 0, TDF_SLIM);
6014 : : }
6015 : 7755 : gsi_insert_seq_before (gsi, *seq, GSI_SAME_STMT);
6016 : 7755 : return true;
6017 : : }
6018 : 71859 : else if (!inplace)
6019 : : {
6020 : 142148 : if (gimple_has_lhs (stmt))
6021 : : {
6022 : 71859 : tree lhs = gimple_get_lhs (stmt);
6023 : 71859 : if (!maybe_push_res_to_seq (res_op, seq, lhs))
6024 : : return false;
6025 : 71036 : if (dump_file && (dump_flags & TDF_DETAILS))
6026 : : {
6027 : 7 : fprintf (dump_file, "gimple_simplified to ");
6028 : 7 : print_gimple_seq (dump_file, *seq, 0, TDF_SLIM);
6029 : : }
6030 : 71036 : gsi_replace_with_seq_vops (gsi, *seq);
6031 : 71036 : return true;
6032 : : }
6033 : : else
6034 : 0 : gcc_unreachable ();
6035 : : }
6036 : :
6037 : : return false;
6038 : : }
6039 : :
6040 : : /* Canonicalize MEM_REFs invariant address operand after propagation. */
6041 : :
6042 : : static bool
6043 : 162648195 : maybe_canonicalize_mem_ref_addr (tree *t, bool is_debug = false)
6044 : : {
6045 : 162648195 : bool res = false;
6046 : 162648195 : tree *orig_t = t;
6047 : :
6048 : 162648195 : if (TREE_CODE (*t) == ADDR_EXPR)
6049 : 47896404 : t = &TREE_OPERAND (*t, 0);
6050 : :
6051 : : /* The C and C++ frontends use an ARRAY_REF for indexing with their
6052 : : generic vector extension. The actual vector referenced is
6053 : : view-converted to an array type for this purpose. If the index
6054 : : is constant the canonical representation in the middle-end is a
6055 : : BIT_FIELD_REF so re-write the former to the latter here. */
6056 : 162648195 : if (TREE_CODE (*t) == ARRAY_REF
6057 : 9434499 : && TREE_CODE (TREE_OPERAND (*t, 0)) == VIEW_CONVERT_EXPR
6058 : 140908 : && TREE_CODE (TREE_OPERAND (*t, 1)) == INTEGER_CST
6059 : 162690065 : && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*t, 0), 0))))
6060 : : {
6061 : 14829 : tree vtype = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*t, 0), 0));
6062 : 14829 : if (VECTOR_TYPE_P (vtype))
6063 : : {
6064 : 14829 : tree low = array_ref_low_bound (*t);
6065 : 14829 : if (TREE_CODE (low) == INTEGER_CST)
6066 : : {
6067 : 14829 : if (tree_int_cst_le (low, TREE_OPERAND (*t, 1)))
6068 : : {
6069 : 29612 : widest_int idx = wi::sub (wi::to_widest (TREE_OPERAND (*t, 1)),
6070 : 29612 : wi::to_widest (low));
6071 : 14806 : idx = wi::mul (idx, wi::to_widest
6072 : 29612 : (TYPE_SIZE (TREE_TYPE (*t))));
6073 : 14806 : widest_int ext
6074 : 14806 : = wi::add (idx, wi::to_widest (TYPE_SIZE (TREE_TYPE (*t))));
6075 : 14806 : if (wi::les_p (ext, wi::to_widest (TYPE_SIZE (vtype))))
6076 : : {
6077 : 28988 : *t = build3_loc (EXPR_LOCATION (*t), BIT_FIELD_REF,
6078 : 14494 : TREE_TYPE (*t),
6079 : 14494 : TREE_OPERAND (TREE_OPERAND (*t, 0), 0),
6080 : 14494 : TYPE_SIZE (TREE_TYPE (*t)),
6081 : : wide_int_to_tree (bitsizetype, idx));
6082 : 14494 : res = true;
6083 : : }
6084 : 14806 : }
6085 : : }
6086 : : }
6087 : : }
6088 : :
6089 : 310840088 : while (handled_component_p (*t))
6090 : 148191893 : t = &TREE_OPERAND (*t, 0);
6091 : :
6092 : : /* Canonicalize MEM [&foo.bar, 0] which appears after propagating
6093 : : of invariant addresses into a SSA name MEM_REF address. */
6094 : 162648195 : if (TREE_CODE (*t) == MEM_REF
6095 : 162648195 : || TREE_CODE (*t) == TARGET_MEM_REF)
6096 : : {
6097 : 84962869 : tree addr = TREE_OPERAND (*t, 0);
6098 : 84962869 : if (TREE_CODE (addr) == ADDR_EXPR
6099 : 84962869 : && (TREE_CODE (TREE_OPERAND (addr, 0)) == MEM_REF
6100 : 24190375 : || handled_component_p (TREE_OPERAND (addr, 0))))
6101 : : {
6102 : 479715 : tree base;
6103 : 479715 : poly_int64 coffset;
6104 : 479715 : base = get_addr_base_and_unit_offset (TREE_OPERAND (addr, 0),
6105 : : &coffset);
6106 : 479715 : if (!base)
6107 : : {
6108 : 24 : if (is_debug)
6109 : 24 : return false;
6110 : 0 : gcc_unreachable ();
6111 : : }
6112 : :
6113 : 479691 : TREE_OPERAND (*t, 0) = build_fold_addr_expr (base);
6114 : 479691 : TREE_OPERAND (*t, 1) = int_const_binop (PLUS_EXPR,
6115 : 479691 : TREE_OPERAND (*t, 1),
6116 : 479691 : size_int (coffset));
6117 : 479691 : res = true;
6118 : : }
6119 : 84962845 : gcc_checking_assert (TREE_CODE (TREE_OPERAND (*t, 0)) == DEBUG_EXPR_DECL
6120 : : || is_gimple_mem_ref_addr (TREE_OPERAND (*t, 0)));
6121 : : }
6122 : :
6123 : : /* Canonicalize back MEM_REFs to plain reference trees if the object
6124 : : accessed is a decl that has the same access semantics as the MEM_REF. */
6125 : 162648171 : if (TREE_CODE (*t) == MEM_REF
6126 : 83259446 : && TREE_CODE (TREE_OPERAND (*t, 0)) == ADDR_EXPR
6127 : 23879962 : && integer_zerop (TREE_OPERAND (*t, 1))
6128 : 176172214 : && MR_DEPENDENCE_CLIQUE (*t) == 0)
6129 : : {
6130 : 8605553 : tree decl = TREE_OPERAND (TREE_OPERAND (*t, 0), 0);
6131 : 8605553 : tree alias_type = TREE_TYPE (TREE_OPERAND (*t, 1));
6132 : 8605553 : if (/* Same volatile qualification. */
6133 : 8605553 : TREE_THIS_VOLATILE (*t) == TREE_THIS_VOLATILE (decl)
6134 : : /* Same TBAA behavior with -fstrict-aliasing. */
6135 : 8578442 : && !TYPE_REF_CAN_ALIAS_ALL (alias_type)
6136 : 8360954 : && (TYPE_MAIN_VARIANT (TREE_TYPE (decl))
6137 : 8360954 : == TYPE_MAIN_VARIANT (TREE_TYPE (alias_type)))
6138 : : /* Same alignment. */
6139 : 3144564 : && TYPE_ALIGN (TREE_TYPE (decl)) == TYPE_ALIGN (TREE_TYPE (*t))
6140 : : /* We have to look out here to not drop a required conversion
6141 : : from the rhs to the lhs if *t appears on the lhs or vice-versa
6142 : : if it appears on the rhs. Thus require strict type
6143 : : compatibility. */
6144 : 11523660 : && types_compatible_p (TREE_TYPE (*t), TREE_TYPE (decl)))
6145 : : {
6146 : 1912745 : *t = TREE_OPERAND (TREE_OPERAND (*t, 0), 0);
6147 : 1912745 : res = true;
6148 : : }
6149 : : }
6150 : :
6151 : 154042618 : else if (TREE_CODE (*orig_t) == ADDR_EXPR
6152 : 46148014 : && TREE_CODE (*t) == MEM_REF
6153 : 170566056 : && TREE_CODE (TREE_OPERAND (*t, 0)) == INTEGER_CST)
6154 : : {
6155 : 650 : tree base;
6156 : 650 : poly_int64 coffset;
6157 : 650 : base = get_addr_base_and_unit_offset (TREE_OPERAND (*orig_t, 0),
6158 : : &coffset);
6159 : 650 : if (base)
6160 : : {
6161 : 583 : gcc_assert (TREE_CODE (base) == MEM_REF);
6162 : 583 : poly_int64 moffset;
6163 : 583 : if (mem_ref_offset (base).to_shwi (&moffset))
6164 : : {
6165 : 583 : coffset += moffset;
6166 : 583 : if (wi::to_poly_wide (TREE_OPERAND (base, 0)).to_shwi (&moffset))
6167 : : {
6168 : 583 : coffset += moffset;
6169 : 583 : *orig_t = build_int_cst (TREE_TYPE (*orig_t), coffset);
6170 : 583 : return true;
6171 : : }
6172 : : }
6173 : : }
6174 : : }
6175 : :
6176 : : /* Canonicalize TARGET_MEM_REF in particular with respect to
6177 : : the indexes becoming constant. */
6178 : 154041968 : else if (TREE_CODE (*t) == TARGET_MEM_REF)
6179 : : {
6180 : 1703399 : tree tem = maybe_fold_tmr (*t);
6181 : 1703399 : if (tem)
6182 : : {
6183 : 1236 : *t = tem;
6184 : 1236 : if (TREE_CODE (*orig_t) == ADDR_EXPR)
6185 : 0 : recompute_tree_invariant_for_addr_expr (*orig_t);
6186 : : res = true;
6187 : : }
6188 : : }
6189 : :
6190 : : return res;
6191 : : }
6192 : :
6193 : : /* Worker for both fold_stmt and fold_stmt_inplace. The INPLACE argument
6194 : : distinguishes both cases. */
6195 : :
6196 : : static bool
6197 : 629751950 : fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace, tree (*valueize) (tree))
6198 : : {
6199 : 629751950 : bool changed = false;
6200 : 629751950 : gimple *stmt = gsi_stmt (*gsi);
6201 : 629751950 : bool nowarning = warning_suppressed_p (stmt, OPT_Wstrict_overflow);
6202 : 629751950 : unsigned i;
6203 : 629751950 : fold_defer_overflow_warnings ();
6204 : :
6205 : : /* First do required canonicalization of [TARGET_]MEM_REF addresses
6206 : : after propagation.
6207 : : ??? This shouldn't be done in generic folding but in the
6208 : : propagation helpers which also know whether an address was
6209 : : propagated.
6210 : : Also canonicalize operand order. */
6211 : 629751950 : switch (gimple_code (stmt))
6212 : : {
6213 : 228119603 : case GIMPLE_ASSIGN:
6214 : 228119603 : if (gimple_assign_rhs_class (stmt) == GIMPLE_SINGLE_RHS)
6215 : : {
6216 : 151322783 : tree *rhs = gimple_assign_rhs1_ptr (stmt);
6217 : 151322783 : if ((REFERENCE_CLASS_P (*rhs)
6218 : 95813495 : || TREE_CODE (*rhs) == ADDR_EXPR)
6219 : 164766479 : && maybe_canonicalize_mem_ref_addr (rhs))
6220 : : changed = true;
6221 : 151322783 : tree *lhs = gimple_assign_lhs_ptr (stmt);
6222 : 151322783 : if (REFERENCE_CLASS_P (*lhs)
6223 : 151322783 : && maybe_canonicalize_mem_ref_addr (lhs))
6224 : : changed = true;
6225 : : /* Canonicalize &MEM[ssa_n, CST] to ssa_n p+ CST.
6226 : : This cannot be done in maybe_canonicalize_mem_ref_addr
6227 : : as the gimple now has two operands rather than one.
6228 : : The same reason why this can't be done in
6229 : : maybe_canonicalize_mem_ref_addr is the same reason why
6230 : : this can't be done inplace. */
6231 : 151322783 : if (!inplace && TREE_CODE (*rhs) == ADDR_EXPR)
6232 : : {
6233 : 13249939 : tree inner = TREE_OPERAND (*rhs, 0);
6234 : 13249939 : if (TREE_CODE (inner) == MEM_REF
6235 : 861198 : && TREE_CODE (TREE_OPERAND (inner, 0)) == SSA_NAME
6236 : 13296319 : && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6237 : : {
6238 : 46380 : tree ptr = TREE_OPERAND (inner, 0);
6239 : 46380 : tree addon = TREE_OPERAND (inner, 1);
6240 : 46380 : addon = fold_convert (sizetype, addon);
6241 : 46380 : gimple_assign_set_rhs_with_ops (gsi, POINTER_PLUS_EXPR,
6242 : : ptr, addon);
6243 : 46380 : changed = true;
6244 : 46380 : stmt = gsi_stmt (*gsi);
6245 : : }
6246 : : }
6247 : : }
6248 : : else
6249 : : {
6250 : : /* Canonicalize operand order. */
6251 : 76796820 : enum tree_code code = gimple_assign_rhs_code (stmt);
6252 : 76796820 : if (TREE_CODE_CLASS (code) == tcc_comparison
6253 : 71586556 : || commutative_tree_code (code)
6254 : 116067788 : || commutative_ternary_tree_code (code))
6255 : : {
6256 : 37526141 : tree rhs1 = gimple_assign_rhs1 (stmt);
6257 : 37526141 : tree rhs2 = gimple_assign_rhs2 (stmt);
6258 : 37526141 : if (tree_swap_operands_p (rhs1, rhs2))
6259 : : {
6260 : 2816633 : gimple_assign_set_rhs1 (stmt, rhs2);
6261 : 2816633 : gimple_assign_set_rhs2 (stmt, rhs1);
6262 : 2816633 : if (TREE_CODE_CLASS (code) == tcc_comparison)
6263 : 238386 : gimple_assign_set_rhs_code (stmt,
6264 : : swap_tree_comparison (code));
6265 : : changed = true;
6266 : : }
6267 : : }
6268 : : }
6269 : : break;
6270 : 51392445 : case GIMPLE_CALL:
6271 : 51392445 : {
6272 : 51392445 : gcall *call = as_a<gcall *> (stmt);
6273 : 155564905 : for (i = 0; i < gimple_call_num_args (call); ++i)
6274 : : {
6275 : 104172460 : tree *arg = gimple_call_arg_ptr (call, i);
6276 : 104172460 : if (REFERENCE_CLASS_P (*arg)
6277 : 104172460 : && maybe_canonicalize_mem_ref_addr (arg))
6278 : : changed = true;
6279 : : }
6280 : 51392445 : tree *lhs = gimple_call_lhs_ptr (call);
6281 : 51392445 : if (*lhs
6282 : 21053513 : && REFERENCE_CLASS_P (*lhs)
6283 : 51504027 : && maybe_canonicalize_mem_ref_addr (lhs))
6284 : : changed = true;
6285 : 51392445 : if (*lhs)
6286 : : {
6287 : 21053513 : combined_fn cfn = gimple_call_combined_fn (call);
6288 : 21053513 : internal_fn ifn = associated_internal_fn (cfn, TREE_TYPE (*lhs));
6289 : 21053513 : int opno = first_commutative_argument (ifn);
6290 : 21053513 : if (opno >= 0)
6291 : : {
6292 : 344316 : tree arg1 = gimple_call_arg (call, opno);
6293 : 344316 : tree arg2 = gimple_call_arg (call, opno + 1);
6294 : 344316 : if (tree_swap_operands_p (arg1, arg2))
6295 : : {
6296 : 23431 : gimple_call_set_arg (call, opno, arg2);
6297 : 23431 : gimple_call_set_arg (call, opno + 1, arg1);
6298 : 23431 : changed = true;
6299 : : }
6300 : : }
6301 : : }
6302 : : break;
6303 : : }
6304 : 642649 : case GIMPLE_ASM:
6305 : 642649 : {
6306 : 642649 : gasm *asm_stmt = as_a <gasm *> (stmt);
6307 : 1455451 : for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i)
6308 : : {
6309 : 812802 : tree link = gimple_asm_output_op (asm_stmt, i);
6310 : 812802 : tree op = TREE_VALUE (link);
6311 : 812802 : if (REFERENCE_CLASS_P (op)
6312 : 812802 : && maybe_canonicalize_mem_ref_addr (&TREE_VALUE (link)))
6313 : : changed = true;
6314 : : }
6315 : 1086900 : for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i)
6316 : : {
6317 : 444251 : tree link = gimple_asm_input_op (asm_stmt, i);
6318 : 444251 : tree op = TREE_VALUE (link);
6319 : 444251 : if ((REFERENCE_CLASS_P (op)
6320 : 433712 : || TREE_CODE (op) == ADDR_EXPR)
6321 : 475532 : && maybe_canonicalize_mem_ref_addr (&TREE_VALUE (link)))
6322 : : changed = true;
6323 : : }
6324 : : }
6325 : : break;
6326 : 293188154 : case GIMPLE_DEBUG:
6327 : 293188154 : if (gimple_debug_bind_p (stmt))
6328 : : {
6329 : 219287674 : tree *val = gimple_debug_bind_get_value_ptr (stmt);
6330 : 219287674 : if (*val
6331 : 126917788 : && (REFERENCE_CLASS_P (*val)
6332 : 125388499 : || TREE_CODE (*val) == ADDR_EXPR)
6333 : 255238390 : && maybe_canonicalize_mem_ref_addr (val, true))
6334 : : changed = true;
6335 : : }
6336 : : break;
6337 : 37722996 : case GIMPLE_COND:
6338 : 37722996 : {
6339 : : /* Canonicalize operand order. */
6340 : 37722996 : tree lhs = gimple_cond_lhs (stmt);
6341 : 37722996 : tree rhs = gimple_cond_rhs (stmt);
6342 : 37722996 : if (tree_swap_operands_p (lhs, rhs))
6343 : : {
6344 : 1224415 : gcond *gc = as_a <gcond *> (stmt);
6345 : 1224415 : gimple_cond_set_lhs (gc, rhs);
6346 : 1224415 : gimple_cond_set_rhs (gc, lhs);
6347 : 1224415 : gimple_cond_set_code (gc,
6348 : : swap_tree_comparison (gimple_cond_code (gc)));
6349 : 1224415 : changed = true;
6350 : : }
6351 : : }
6352 : 629751950 : default:;
6353 : : }
6354 : :
6355 : : /* Dispatch to pattern-based folding. */
6356 : 629751950 : if (!inplace
6357 : 2814883 : || is_gimple_assign (stmt)
6358 : 630456089 : || gimple_code (stmt) == GIMPLE_COND)
6359 : : {
6360 : 629047811 : gimple_seq seq = NULL;
6361 : 629047811 : gimple_match_op res_op;
6362 : 1255984878 : if (gimple_simplify (stmt, &res_op, inplace ? NULL : &seq,
6363 : : valueize, valueize))
6364 : : {
6365 : 7909093 : if (replace_stmt_with_simplification (gsi, &res_op, &seq, inplace))
6366 : : changed = true;
6367 : : else
6368 : 2363 : gimple_seq_discard (seq);
6369 : : }
6370 : : }
6371 : :
6372 : 629751950 : stmt = gsi_stmt (*gsi);
6373 : :
6374 : : /* Fold the main computation performed by the statement. */
6375 : 629751950 : switch (gimple_code (stmt))
6376 : : {
6377 : 228179075 : case GIMPLE_ASSIGN:
6378 : 228179075 : {
6379 : : /* Try to canonicalize for boolean-typed X the comparisons
6380 : : X == 0, X == 1, X != 0, and X != 1. */
6381 : 228179075 : if (gimple_assign_rhs_code (stmt) == EQ_EXPR
6382 : 228179075 : || gimple_assign_rhs_code (stmt) == NE_EXPR)
6383 : : {
6384 : 2830457 : tree lhs = gimple_assign_lhs (stmt);
6385 : 2830457 : tree op1 = gimple_assign_rhs1 (stmt);
6386 : 2830457 : tree op2 = gimple_assign_rhs2 (stmt);
6387 : 2830457 : tree type = TREE_TYPE (op1);
6388 : :
6389 : : /* Check whether the comparison operands are of the same boolean
6390 : : type as the result type is.
6391 : : Check that second operand is an integer-constant with value
6392 : : one or zero. */
6393 : 2830457 : if (TREE_CODE (op2) == INTEGER_CST
6394 : 1959317 : && (integer_zerop (op2) || integer_onep (op2))
6395 : 4288095 : && useless_type_conversion_p (TREE_TYPE (lhs), type))
6396 : : {
6397 : 6352 : enum tree_code cmp_code = gimple_assign_rhs_code (stmt);
6398 : 6352 : bool is_logical_not = false;
6399 : :
6400 : : /* X == 0 and X != 1 is a logical-not.of X
6401 : : X == 1 and X != 0 is X */
6402 : 5850 : if ((cmp_code == EQ_EXPR && integer_zerop (op2))
6403 : 6352 : || (cmp_code == NE_EXPR && integer_onep (op2)))
6404 : 6318 : is_logical_not = true;
6405 : :
6406 : 6352 : if (is_logical_not == false)
6407 : 34 : gimple_assign_set_rhs_with_ops (gsi, TREE_CODE (op1), op1);
6408 : : /* Only for one-bit precision typed X the transformation
6409 : : !X -> ~X is valied. */
6410 : 6318 : else if (TYPE_PRECISION (type) == 1)
6411 : 6318 : gimple_assign_set_rhs_with_ops (gsi, BIT_NOT_EXPR, op1);
6412 : : /* Otherwise we use !X -> X ^ 1. */
6413 : : else
6414 : 0 : gimple_assign_set_rhs_with_ops (gsi, BIT_XOR_EXPR, op1,
6415 : 0 : build_int_cst (type, 1));
6416 : : changed = true;
6417 : : break;
6418 : : }
6419 : : }
6420 : :
6421 : 228172723 : unsigned old_num_ops = gimple_num_ops (stmt);
6422 : 228172723 : tree lhs = gimple_assign_lhs (stmt);
6423 : 228172723 : tree new_rhs = fold_gimple_assign (gsi);
6424 : 228172723 : if (new_rhs
6425 : 228275920 : && !useless_type_conversion_p (TREE_TYPE (lhs),
6426 : 103197 : TREE_TYPE (new_rhs)))
6427 : 0 : new_rhs = fold_convert (TREE_TYPE (lhs), new_rhs);
6428 : 228172723 : if (new_rhs
6429 : 228172723 : && (!inplace
6430 : 785 : || get_gimple_rhs_num_ops (TREE_CODE (new_rhs)) < old_num_ops))
6431 : : {
6432 : 103197 : gimple_assign_set_rhs_from_tree (gsi, new_rhs);
6433 : 103197 : changed = true;
6434 : : }
6435 : : break;
6436 : : }
6437 : :
6438 : 51332973 : case GIMPLE_CALL:
6439 : 51332973 : changed |= gimple_fold_call (gsi, inplace);
6440 : 51332973 : break;
6441 : :
6442 : 293188154 : case GIMPLE_DEBUG:
6443 : 293188154 : if (gimple_debug_bind_p (stmt))
6444 : : {
6445 : 219287674 : tree val = gimple_debug_bind_get_value (stmt);
6446 : 219287674 : if (val && REFERENCE_CLASS_P (val))
6447 : : {
6448 : 1528808 : tree tem = maybe_fold_reference (val);
6449 : 1528808 : if (tem)
6450 : : {
6451 : 274 : gimple_debug_bind_set_value (stmt, tem);
6452 : 274 : changed = true;
6453 : : }
6454 : : }
6455 : : }
6456 : : break;
6457 : :
6458 : 9839240 : case GIMPLE_RETURN:
6459 : 9839240 : {
6460 : 9839240 : greturn *ret_stmt = as_a<greturn *> (stmt);
6461 : 9839240 : tree ret = gimple_return_retval(ret_stmt);
6462 : :
6463 : 9839240 : if (ret && TREE_CODE (ret) == SSA_NAME && valueize)
6464 : : {
6465 : 4138549 : tree val = valueize (ret);
6466 : 4138549 : if (val && val != ret
6467 : 4138549 : && may_propagate_copy (ret, val))
6468 : : {
6469 : 0 : gimple_return_set_retval (ret_stmt, val);
6470 : 0 : changed = true;
6471 : : }
6472 : : }
6473 : : }
6474 : : break;
6475 : :
6476 : 629751950 : default:;
6477 : : }
6478 : :
6479 : 629751950 : stmt = gsi_stmt (*gsi);
6480 : :
6481 : 629751950 : fold_undefer_overflow_warnings (changed && !nowarning, stmt, 0);
6482 : 629751950 : return changed;
6483 : : }
6484 : :
6485 : : /* Valueziation callback that ends up not following SSA edges. */
6486 : :
6487 : : tree
6488 : 4056932144 : no_follow_ssa_edges (tree)
6489 : : {
6490 : 4056932144 : return NULL_TREE;
6491 : : }
6492 : :
6493 : : /* Valueization callback that ends up following single-use SSA edges only. */
6494 : :
6495 : : tree
6496 : 648197065 : follow_single_use_edges (tree val)
6497 : : {
6498 : 648197065 : if (TREE_CODE (val) == SSA_NAME
6499 : 648197065 : && !has_single_use (val))
6500 : 327190838 : return NULL_TREE;
6501 : : return val;
6502 : : }
6503 : :
6504 : : /* Valueization callback that follows all SSA edges. */
6505 : :
6506 : : tree
6507 : 133574008 : follow_all_ssa_edges (tree val)
6508 : : {
6509 : 133574008 : return val;
6510 : : }
6511 : :
6512 : : /* Fold the statement pointed to by GSI. In some cases, this function may
6513 : : replace the whole statement with a new one. Returns true iff folding
6514 : : makes any changes.
6515 : : The statement pointed to by GSI should be in valid gimple form but may
6516 : : be in unfolded state as resulting from for example constant propagation
6517 : : which can produce *&x = 0. */
6518 : :
6519 : : bool
6520 : 122556747 : fold_stmt (gimple_stmt_iterator *gsi)
6521 : : {
6522 : 122556747 : return fold_stmt_1 (gsi, false, no_follow_ssa_edges);
6523 : : }
6524 : :
6525 : : bool
6526 : 504380320 : fold_stmt (gimple_stmt_iterator *gsi, tree (*valueize) (tree))
6527 : : {
6528 : 504380320 : return fold_stmt_1 (gsi, false, valueize);
6529 : : }
6530 : :
6531 : : /* Perform the minimal folding on statement *GSI. Only operations like
6532 : : *&x created by constant propagation are handled. The statement cannot
6533 : : be replaced with a new one. Return true if the statement was
6534 : : changed, false otherwise.
6535 : : The statement *GSI should be in valid gimple form but may
6536 : : be in unfolded state as resulting from for example constant propagation
6537 : : which can produce *&x = 0. */
6538 : :
6539 : : bool
6540 : 2814883 : fold_stmt_inplace (gimple_stmt_iterator *gsi)
6541 : : {
6542 : 2814883 : gimple *stmt = gsi_stmt (*gsi);
6543 : 2814883 : bool changed = fold_stmt_1 (gsi, true, no_follow_ssa_edges);
6544 : 2814883 : gcc_assert (gsi_stmt (*gsi) == stmt);
6545 : 2814883 : return changed;
6546 : : }
6547 : :
6548 : : /* Canonicalize and possibly invert the boolean EXPR; return NULL_TREE
6549 : : if EXPR is null or we don't know how.
6550 : : If non-null, the result always has boolean type. */
6551 : :
6552 : : static tree
6553 : 134077 : canonicalize_bool (tree expr, bool invert)
6554 : : {
6555 : 134077 : if (!expr)
6556 : : return NULL_TREE;
6557 : 53 : else if (invert)
6558 : : {
6559 : 38 : if (integer_nonzerop (expr))
6560 : 0 : return boolean_false_node;
6561 : 38 : else if (integer_zerop (expr))
6562 : 0 : return boolean_true_node;
6563 : 38 : else if (TREE_CODE (expr) == SSA_NAME)
6564 : 0 : return fold_build2 (EQ_EXPR, boolean_type_node, expr,
6565 : : build_int_cst (TREE_TYPE (expr), 0));
6566 : 38 : else if (COMPARISON_CLASS_P (expr))
6567 : 38 : return fold_build2 (invert_tree_comparison (TREE_CODE (expr), false),
6568 : : boolean_type_node,
6569 : : TREE_OPERAND (expr, 0),
6570 : : TREE_OPERAND (expr, 1));
6571 : : else
6572 : : return NULL_TREE;
6573 : : }
6574 : : else
6575 : : {
6576 : 15 : if (TREE_CODE (TREE_TYPE (expr)) == BOOLEAN_TYPE)
6577 : : return expr;
6578 : 0 : if (integer_nonzerop (expr))
6579 : 0 : return boolean_true_node;
6580 : 0 : else if (integer_zerop (expr))
6581 : 0 : return boolean_false_node;
6582 : 0 : else if (TREE_CODE (expr) == SSA_NAME)
6583 : 0 : return fold_build2 (NE_EXPR, boolean_type_node, expr,
6584 : : build_int_cst (TREE_TYPE (expr), 0));
6585 : 0 : else if (COMPARISON_CLASS_P (expr))
6586 : 0 : return fold_build2 (TREE_CODE (expr),
6587 : : boolean_type_node,
6588 : : TREE_OPERAND (expr, 0),
6589 : : TREE_OPERAND (expr, 1));
6590 : : else
6591 : : return NULL_TREE;
6592 : : }
6593 : : }
6594 : :
6595 : : /* Check to see if a boolean expression EXPR is logically equivalent to the
6596 : : comparison (OP1 CODE OP2). Check for various identities involving
6597 : : SSA_NAMEs. */
6598 : :
6599 : : static bool
6600 : 1247 : same_bool_comparison_p (const_tree expr, enum tree_code code,
6601 : : const_tree op1, const_tree op2)
6602 : : {
6603 : 1247 : gimple *s;
6604 : :
6605 : : /* The obvious case. */
6606 : 1247 : if (TREE_CODE (expr) == code
6607 : 36 : && operand_equal_p (TREE_OPERAND (expr, 0), op1, 0)
6608 : 1283 : && operand_equal_p (TREE_OPERAND (expr, 1), op2, 0))
6609 : : return true;
6610 : :
6611 : : /* Check for comparing (name, name != 0) and the case where expr
6612 : : is an SSA_NAME with a definition matching the comparison. */
6613 : 1243 : if (TREE_CODE (expr) == SSA_NAME
6614 : 1243 : && TREE_CODE (TREE_TYPE (expr)) == BOOLEAN_TYPE)
6615 : : {
6616 : 0 : if (operand_equal_p (expr, op1, 0))
6617 : 0 : return ((code == NE_EXPR && integer_zerop (op2))
6618 : 0 : || (code == EQ_EXPR && integer_nonzerop (op2)));
6619 : 0 : s = SSA_NAME_DEF_STMT (expr);
6620 : 0 : if (is_gimple_assign (s)
6621 : 0 : && gimple_assign_rhs_code (s) == code
6622 : 0 : && operand_equal_p (gimple_assign_rhs1 (s), op1, 0)
6623 : 0 : && operand_equal_p (gimple_assign_rhs2 (s), op2, 0))
6624 : : return true;
6625 : : }
6626 : :
6627 : : /* If op1 is of the form (name != 0) or (name == 0), and the definition
6628 : : of name is a comparison, recurse. */
6629 : 1243 : if (TREE_CODE (op1) == SSA_NAME
6630 : 1243 : && TREE_CODE (TREE_TYPE (op1)) == BOOLEAN_TYPE)
6631 : : {
6632 : 424 : s = SSA_NAME_DEF_STMT (op1);
6633 : 424 : if (is_gimple_assign (s)
6634 : 424 : && TREE_CODE_CLASS (gimple_assign_rhs_code (s)) == tcc_comparison)
6635 : : {
6636 : 0 : enum tree_code c = gimple_assign_rhs_code (s);
6637 : 0 : if ((c == NE_EXPR && integer_zerop (op2))
6638 : 0 : || (c == EQ_EXPR && integer_nonzerop (op2)))
6639 : 0 : return same_bool_comparison_p (expr, c,
6640 : 0 : gimple_assign_rhs1 (s),
6641 : 0 : gimple_assign_rhs2 (s));
6642 : 0 : if ((c == EQ_EXPR && integer_zerop (op2))
6643 : 0 : || (c == NE_EXPR && integer_nonzerop (op2)))
6644 : 0 : return same_bool_comparison_p (expr,
6645 : : invert_tree_comparison (c, false),
6646 : 0 : gimple_assign_rhs1 (s),
6647 : 0 : gimple_assign_rhs2 (s));
6648 : : }
6649 : : }
6650 : : return false;
6651 : : }
6652 : :
6653 : : /* Check to see if two boolean expressions OP1 and OP2 are logically
6654 : : equivalent. */
6655 : :
6656 : : static bool
6657 : 20 : same_bool_result_p (const_tree op1, const_tree op2)
6658 : : {
6659 : : /* Simple cases first. */
6660 : 20 : if (operand_equal_p (op1, op2, 0))
6661 : : return true;
6662 : :
6663 : : /* Check the cases where at least one of the operands is a comparison.
6664 : : These are a bit smarter than operand_equal_p in that they apply some
6665 : : identifies on SSA_NAMEs. */
6666 : 17 : if (COMPARISON_CLASS_P (op2)
6667 : 34 : && same_bool_comparison_p (op1, TREE_CODE (op2),
6668 : 17 : TREE_OPERAND (op2, 0),
6669 : 17 : TREE_OPERAND (op2, 1)))
6670 : : return true;
6671 : 17 : if (COMPARISON_CLASS_P (op1)
6672 : 34 : && same_bool_comparison_p (op2, TREE_CODE (op1),
6673 : 17 : TREE_OPERAND (op1, 0),
6674 : 17 : TREE_OPERAND (op1, 1)))
6675 : : return true;
6676 : :
6677 : : /* Default case. */
6678 : : return false;
6679 : : }
6680 : :
6681 : : /* Forward declarations for some mutually recursive functions. */
6682 : :
6683 : : static tree
6684 : : and_comparisons_1 (tree type, enum tree_code code1, tree op1a, tree op1b,
6685 : : enum tree_code code2, tree op2a, tree op2b, basic_block);
6686 : : static tree
6687 : : and_var_with_comparison (tree type, tree var, bool invert,
6688 : : enum tree_code code2, tree op2a, tree op2b,
6689 : : basic_block);
6690 : : static tree
6691 : : and_var_with_comparison_1 (tree type, gimple *stmt,
6692 : : enum tree_code code2, tree op2a, tree op2b,
6693 : : basic_block);
6694 : : static tree
6695 : : or_comparisons_1 (tree, enum tree_code code1, tree op1a, tree op1b,
6696 : : enum tree_code code2, tree op2a, tree op2b,
6697 : : basic_block);
6698 : : static tree
6699 : : or_var_with_comparison (tree, tree var, bool invert,
6700 : : enum tree_code code2, tree op2a, tree op2b,
6701 : : basic_block);
6702 : : static tree
6703 : : or_var_with_comparison_1 (tree, gimple *stmt,
6704 : : enum tree_code code2, tree op2a, tree op2b,
6705 : : basic_block);
6706 : :
6707 : : /* Helper function for and_comparisons_1: try to simplify the AND of the
6708 : : ssa variable VAR with the comparison specified by (OP2A CODE2 OP2B).
6709 : : If INVERT is true, invert the value of the VAR before doing the AND.
6710 : : Return NULL_EXPR if we can't simplify this to a single expression. */
6711 : :
6712 : : static tree
6713 : 105660 : and_var_with_comparison (tree type, tree var, bool invert,
6714 : : enum tree_code code2, tree op2a, tree op2b,
6715 : : basic_block outer_cond_bb)
6716 : : {
6717 : 105660 : tree t;
6718 : 105660 : gimple *stmt = SSA_NAME_DEF_STMT (var);
6719 : :
6720 : : /* We can only deal with variables whose definitions are assignments. */
6721 : 105660 : if (!is_gimple_assign (stmt))
6722 : : return NULL_TREE;
6723 : :
6724 : : /* If we have an inverted comparison, apply DeMorgan's law and rewrite
6725 : : !var AND (op2a code2 op2b) => !(var OR !(op2a code2 op2b))
6726 : : Then we only have to consider the simpler non-inverted cases. */
6727 : 105019 : if (invert)
6728 : 45558 : t = or_var_with_comparison_1 (type, stmt,
6729 : : invert_tree_comparison (code2, false),
6730 : : op2a, op2b, outer_cond_bb);
6731 : : else
6732 : 59461 : t = and_var_with_comparison_1 (type, stmt, code2, op2a, op2b,
6733 : : outer_cond_bb);
6734 : 105019 : return canonicalize_bool (t, invert);
6735 : : }
6736 : :
6737 : : /* Try to simplify the AND of the ssa variable defined by the assignment
6738 : : STMT with the comparison specified by (OP2A CODE2 OP2B).
6739 : : Return NULL_EXPR if we can't simplify this to a single expression. */
6740 : :
6741 : : static tree
6742 : 76170 : and_var_with_comparison_1 (tree type, gimple *stmt,
6743 : : enum tree_code code2, tree op2a, tree op2b,
6744 : : basic_block outer_cond_bb)
6745 : : {
6746 : 76170 : tree var = gimple_assign_lhs (stmt);
6747 : 76170 : tree true_test_var = NULL_TREE;
6748 : 76170 : tree false_test_var = NULL_TREE;
6749 : 76170 : enum tree_code innercode = gimple_assign_rhs_code (stmt);
6750 : :
6751 : : /* Check for identities like (var AND (var == 0)) => false. */
6752 : 76170 : if (TREE_CODE (op2a) == SSA_NAME
6753 : 76170 : && TREE_CODE (TREE_TYPE (var)) == BOOLEAN_TYPE)
6754 : : {
6755 : 4935 : if ((code2 == NE_EXPR && integer_zerop (op2b))
6756 : 15565 : || (code2 == EQ_EXPR && integer_nonzerop (op2b)))
6757 : : {
6758 : 4397 : true_test_var = op2a;
6759 : 4397 : if (var == true_test_var)
6760 : : return var;
6761 : : }
6762 : 3695 : else if ((code2 == EQ_EXPR && integer_zerop (op2b))
6763 : 12957 : || (code2 == NE_EXPR && integer_nonzerop (op2b)))
6764 : : {
6765 : 1790 : false_test_var = op2a;
6766 : 1790 : if (var == false_test_var)
6767 : 0 : return boolean_false_node;
6768 : : }
6769 : : }
6770 : :
6771 : : /* If the definition is a comparison, recurse on it. */
6772 : 76170 : if (TREE_CODE_CLASS (innercode) == tcc_comparison)
6773 : : {
6774 : 3093 : tree t = and_comparisons_1 (type, innercode,
6775 : : gimple_assign_rhs1 (stmt),
6776 : : gimple_assign_rhs2 (stmt),
6777 : : code2,
6778 : : op2a,
6779 : : op2b, outer_cond_bb);
6780 : 3093 : if (t)
6781 : : return t;
6782 : : }
6783 : :
6784 : : /* If the definition is an AND or OR expression, we may be able to
6785 : : simplify by reassociating. */
6786 : 76164 : if (TREE_CODE (TREE_TYPE (var)) == BOOLEAN_TYPE
6787 : 76164 : && (innercode == BIT_AND_EXPR || innercode == BIT_IOR_EXPR))
6788 : : {
6789 : 8490 : tree inner1 = gimple_assign_rhs1 (stmt);
6790 : 8490 : tree inner2 = gimple_assign_rhs2 (stmt);
6791 : 8490 : gimple *s;
6792 : 8490 : tree t;
6793 : 8490 : tree partial = NULL_TREE;
6794 : 8490 : bool is_and = (innercode == BIT_AND_EXPR);
6795 : :
6796 : : /* Check for boolean identities that don't require recursive examination
6797 : : of inner1/inner2:
6798 : : inner1 AND (inner1 AND inner2) => inner1 AND inner2 => var
6799 : : inner1 AND (inner1 OR inner2) => inner1
6800 : : !inner1 AND (inner1 AND inner2) => false
6801 : : !inner1 AND (inner1 OR inner2) => !inner1 AND inner2
6802 : : Likewise for similar cases involving inner2. */
6803 : 8490 : if (inner1 == true_test_var)
6804 : 0 : return (is_and ? var : inner1);
6805 : 8490 : else if (inner2 == true_test_var)
6806 : 0 : return (is_and ? var : inner2);
6807 : 8490 : else if (inner1 == false_test_var)
6808 : 0 : return (is_and
6809 : 0 : ? boolean_false_node
6810 : 0 : : and_var_with_comparison (type, inner2, false, code2, op2a,
6811 : : op2b, outer_cond_bb));
6812 : 8490 : else if (inner2 == false_test_var)
6813 : 0 : return (is_and
6814 : 0 : ? boolean_false_node
6815 : 0 : : and_var_with_comparison (type, inner1, false, code2, op2a,
6816 : : op2b, outer_cond_bb));
6817 : :
6818 : : /* Next, redistribute/reassociate the AND across the inner tests.
6819 : : Compute the first partial result, (inner1 AND (op2a code op2b)) */
6820 : 8490 : if (TREE_CODE (inner1) == SSA_NAME
6821 : 8490 : && is_gimple_assign (s = SSA_NAME_DEF_STMT (inner1))
6822 : 8036 : && TREE_CODE_CLASS (gimple_assign_rhs_code (s)) == tcc_comparison
6823 : 16238 : && (t = maybe_fold_and_comparisons (type, gimple_assign_rhs_code (s),
6824 : : gimple_assign_rhs1 (s),
6825 : : gimple_assign_rhs2 (s),
6826 : : code2, op2a, op2b,
6827 : : outer_cond_bb)))
6828 : : {
6829 : : /* Handle the AND case, where we are reassociating:
6830 : : (inner1 AND inner2) AND (op2a code2 op2b)
6831 : : => (t AND inner2)
6832 : : If the partial result t is a constant, we win. Otherwise
6833 : : continue on to try reassociating with the other inner test. */
6834 : 42 : if (is_and)
6835 : : {
6836 : 1 : if (integer_onep (t))
6837 : : return inner2;
6838 : 1 : else if (integer_zerop (t))
6839 : 0 : return boolean_false_node;
6840 : : }
6841 : :
6842 : : /* Handle the OR case, where we are redistributing:
6843 : : (inner1 OR inner2) AND (op2a code2 op2b)
6844 : : => (t OR (inner2 AND (op2a code2 op2b))) */
6845 : 41 : else if (integer_onep (t))
6846 : 0 : return boolean_true_node;
6847 : :
6848 : : /* Save partial result for later. */
6849 : : partial = t;
6850 : : }
6851 : :
6852 : : /* Compute the second partial result, (inner2 AND (op2a code op2b)) */
6853 : 8490 : if (TREE_CODE (inner2) == SSA_NAME
6854 : 8490 : && is_gimple_assign (s = SSA_NAME_DEF_STMT (inner2))
6855 : 8280 : && TREE_CODE_CLASS (gimple_assign_rhs_code (s)) == tcc_comparison
6856 : 16148 : && (t = maybe_fold_and_comparisons (type, gimple_assign_rhs_code (s),
6857 : : gimple_assign_rhs1 (s),
6858 : : gimple_assign_rhs2 (s),
6859 : : code2, op2a, op2b,
6860 : : outer_cond_bb)))
6861 : : {
6862 : : /* Handle the AND case, where we are reassociating:
6863 : : (inner1 AND inner2) AND (op2a code2 op2b)
6864 : : => (inner1 AND t) */
6865 : 33 : if (is_and)
6866 : : {
6867 : 14 : if (integer_onep (t))
6868 : : return inner1;
6869 : 14 : else if (integer_zerop (t))
6870 : 1 : return boolean_false_node;
6871 : : /* If both are the same, we can apply the identity
6872 : : (x AND x) == x. */
6873 : 13 : else if (partial && same_bool_result_p (t, partial))
6874 : : return t;
6875 : : }
6876 : :
6877 : : /* Handle the OR case. where we are redistributing:
6878 : : (inner1 OR inner2) AND (op2a code2 op2b)
6879 : : => (t OR (inner1 AND (op2a code2 op2b)))
6880 : : => (t OR partial) */
6881 : : else
6882 : : {
6883 : 19 : if (integer_onep (t))
6884 : 0 : return boolean_true_node;
6885 : 19 : else if (partial)
6886 : : {
6887 : : /* We already got a simplification for the other
6888 : : operand to the redistributed OR expression. The
6889 : : interesting case is when at least one is false.
6890 : : Or, if both are the same, we can apply the identity
6891 : : (x OR x) == x. */
6892 : 16 : if (integer_zerop (partial))
6893 : : return t;
6894 : 15 : else if (integer_zerop (t))
6895 : : return partial;
6896 : 13 : else if (same_bool_result_p (t, partial))
6897 : : return t;
6898 : : }
6899 : : }
6900 : : }
6901 : : }
6902 : : return NULL_TREE;
6903 : : }
6904 : :
6905 : : /* Try to simplify the AND of two comparisons defined by
6906 : : (OP1A CODE1 OP1B) and (OP2A CODE2 OP2B), respectively.
6907 : : If this can be done without constructing an intermediate value,
6908 : : return the resulting tree; otherwise NULL_TREE is returned.
6909 : : This function is deliberately asymmetric as it recurses on SSA_DEFs
6910 : : in the first comparison but not the second. */
6911 : :
6912 : : static tree
6913 : 479604 : and_comparisons_1 (tree type, enum tree_code code1, tree op1a, tree op1b,
6914 : : enum tree_code code2, tree op2a, tree op2b,
6915 : : basic_block outer_cond_bb)
6916 : : {
6917 : 479604 : tree truth_type = truth_type_for (TREE_TYPE (op1a));
6918 : :
6919 : : /* First check for ((x CODE1 y) AND (x CODE2 y)). */
6920 : 479604 : if (operand_equal_p (op1a, op2a, 0)
6921 : 479604 : && operand_equal_p (op1b, op2b, 0))
6922 : : {
6923 : : /* Result will be either NULL_TREE, or a combined comparison. */
6924 : 3778 : tree t = combine_comparisons (UNKNOWN_LOCATION,
6925 : : TRUTH_ANDIF_EXPR, code1, code2,
6926 : : truth_type, op1a, op1b);
6927 : 3778 : if (t)
6928 : : return t;
6929 : : }
6930 : :
6931 : : /* Likewise the swapped case of the above. */
6932 : 478794 : if (operand_equal_p (op1a, op2b, 0)
6933 : 478794 : && operand_equal_p (op1b, op2a, 0))
6934 : : {
6935 : : /* Result will be either NULL_TREE, or a combined comparison. */
6936 : 0 : tree t = combine_comparisons (UNKNOWN_LOCATION,
6937 : : TRUTH_ANDIF_EXPR, code1,
6938 : : swap_tree_comparison (code2),
6939 : : truth_type, op1a, op1b);
6940 : 0 : if (t)
6941 : : return t;
6942 : : }
6943 : :
6944 : : /* Perhaps the first comparison is (NAME != 0) or (NAME == 1) where
6945 : : NAME's definition is a truth value. See if there are any simplifications
6946 : : that can be done against the NAME's definition. */
6947 : 478794 : if (TREE_CODE (op1a) == SSA_NAME
6948 : 474135 : && (code1 == NE_EXPR || code1 == EQ_EXPR)
6949 : 754796 : && (integer_zerop (op1b) || integer_onep (op1b)))
6950 : : {
6951 : 65804 : bool invert = ((code1 == EQ_EXPR && integer_zerop (op1b))
6952 : 164316 : || (code1 == NE_EXPR && integer_onep (op1b)));
6953 : 152885 : gimple *stmt = SSA_NAME_DEF_STMT (op1a);
6954 : 152885 : switch (gimple_code (stmt))
6955 : : {
6956 : 101864 : case GIMPLE_ASSIGN:
6957 : : /* Try to simplify by copy-propagating the definition. */
6958 : 101864 : return and_var_with_comparison (type, op1a, invert, code2, op2a,
6959 : 101864 : op2b, outer_cond_bb);
6960 : :
6961 : 25214 : case GIMPLE_PHI:
6962 : : /* If every argument to the PHI produces the same result when
6963 : : ANDed with the second comparison, we win.
6964 : : Do not do this unless the type is bool since we need a bool
6965 : : result here anyway. */
6966 : 25214 : if (TREE_CODE (TREE_TYPE (op1a)) == BOOLEAN_TYPE)
6967 : : {
6968 : : tree result = NULL_TREE;
6969 : : unsigned i;
6970 : 10229 : for (i = 0; i < gimple_phi_num_args (stmt); i++)
6971 : : {
6972 : 10229 : tree arg = gimple_phi_arg_def (stmt, i);
6973 : :
6974 : : /* If this PHI has itself as an argument, ignore it.
6975 : : If all the other args produce the same result,
6976 : : we're still OK. */
6977 : 10229 : if (arg == gimple_phi_result (stmt))
6978 : 0 : continue;
6979 : 10229 : else if (TREE_CODE (arg) == INTEGER_CST)
6980 : : {
6981 : 5741 : if (invert ? integer_nonzerop (arg) : integer_zerop (arg))
6982 : : {
6983 : 2917 : if (!result)
6984 : 1433 : result = boolean_false_node;
6985 : 1484 : else if (!integer_zerop (result))
6986 : : return NULL_TREE;
6987 : : }
6988 : 2824 : else if (!result)
6989 : 1817 : result = fold_build2 (code2, boolean_type_node,
6990 : : op2a, op2b);
6991 : 1007 : else if (!same_bool_comparison_p (result,
6992 : : code2, op2a, op2b))
6993 : : return NULL_TREE;
6994 : : }
6995 : 4488 : else if (TREE_CODE (arg) == SSA_NAME
6996 : 4488 : && !SSA_NAME_IS_DEFAULT_DEF (arg))
6997 : : {
6998 : 4488 : tree temp;
6999 : 4488 : gimple *def_stmt = SSA_NAME_DEF_STMT (arg);
7000 : : /* In simple cases we can look through PHI nodes,
7001 : : but we have to be careful with loops.
7002 : : See PR49073. */
7003 : 4488 : if (! dom_info_available_p (CDI_DOMINATORS)
7004 : 4488 : || gimple_bb (def_stmt) == gimple_bb (stmt)
7005 : 8976 : || dominated_by_p (CDI_DOMINATORS,
7006 : 4488 : gimple_bb (def_stmt),
7007 : 4488 : gimple_bb (stmt)))
7008 : 692 : return NULL_TREE;
7009 : 3796 : temp = and_var_with_comparison (type, arg, invert, code2,
7010 : : op2a, op2b,
7011 : : outer_cond_bb);
7012 : 3796 : if (!temp)
7013 : : return NULL_TREE;
7014 : 0 : else if (!result)
7015 : : result = temp;
7016 : 0 : else if (!same_bool_result_p (result, temp))
7017 : : return NULL_TREE;
7018 : : }
7019 : : else
7020 : : return NULL_TREE;
7021 : : }
7022 : 0 : return result;
7023 : : }
7024 : :
7025 : : default:
7026 : : break;
7027 : : }
7028 : : }
7029 : : return NULL_TREE;
7030 : : }
7031 : :
7032 : : static basic_block fosa_bb;
7033 : : static vec<std::pair<tree, flow_sensitive_info_storage> > *fosa_unwind;
7034 : : static tree
7035 : 9311208 : follow_outer_ssa_edges (tree val)
7036 : : {
7037 : 9311208 : if (TREE_CODE (val) == SSA_NAME
7038 : 9311208 : && !SSA_NAME_IS_DEFAULT_DEF (val))
7039 : : {
7040 : 9154127 : basic_block def_bb = gimple_bb (SSA_NAME_DEF_STMT (val));
7041 : 9154127 : if (!def_bb
7042 : 2399547 : || def_bb == fosa_bb
7043 : 10599526 : || (dom_info_available_p (CDI_DOMINATORS)
7044 : 1445399 : && (def_bb == fosa_bb
7045 : 1445399 : || dominated_by_p (CDI_DOMINATORS, fosa_bb, def_bb))))
7046 : 8888296 : return val;
7047 : : /* We cannot temporarily rewrite stmts with undefined overflow
7048 : : behavior, so avoid expanding them. */
7049 : 529960 : if ((ANY_INTEGRAL_TYPE_P (TREE_TYPE (val))
7050 : 6704 : || POINTER_TYPE_P (TREE_TYPE (val)))
7051 : 527632 : && !TYPE_OVERFLOW_WRAPS (TREE_TYPE (val)))
7052 : : return NULL_TREE;
7053 : 212103 : flow_sensitive_info_storage storage;
7054 : 212103 : storage.save_and_clear (val);
7055 : : /* If the definition does not dominate fosa_bb temporarily reset
7056 : : flow-sensitive info. */
7057 : 212103 : fosa_unwind->safe_push (std::make_pair (val, storage));
7058 : 212103 : return val;
7059 : : }
7060 : : return val;
7061 : : }
7062 : :
7063 : : /* Helper function for maybe_fold_and_comparisons and maybe_fold_or_comparisons
7064 : : : try to simplify the AND/OR of the ssa variable VAR with the comparison
7065 : : specified by (OP2A CODE2 OP2B) from match.pd. Return NULL_EXPR if we can't
7066 : : simplify this to a single expression. As we are going to lower the cost
7067 : : of building SSA names / gimple stmts significantly, we need to allocate
7068 : : them ont the stack. This will cause the code to be a bit ugly. */
7069 : :
7070 : : static tree
7071 : 750079 : maybe_fold_comparisons_from_match_pd (tree type, enum tree_code code,
7072 : : enum tree_code code1,
7073 : : tree op1a, tree op1b,
7074 : : enum tree_code code2, tree op2a,
7075 : : tree op2b,
7076 : : basic_block outer_cond_bb)
7077 : : {
7078 : : /* Allocate gimple stmt1 on the stack. */
7079 : 750079 : gassign *stmt1
7080 : 750079 : = (gassign *) XALLOCAVEC (char, gimple_size (GIMPLE_ASSIGN, 3));
7081 : 750079 : gimple_init (stmt1, GIMPLE_ASSIGN, 3);
7082 : 750079 : gimple_assign_set_rhs_code (stmt1, code1);
7083 : 750079 : gimple_assign_set_rhs1 (stmt1, op1a);
7084 : 750079 : gimple_assign_set_rhs2 (stmt1, op1b);
7085 : 750079 : gimple_set_bb (stmt1, NULL);
7086 : :
7087 : : /* Allocate gimple stmt2 on the stack. */
7088 : 750079 : gassign *stmt2
7089 : 750079 : = (gassign *) XALLOCAVEC (char, gimple_size (GIMPLE_ASSIGN, 3));
7090 : 750079 : gimple_init (stmt2, GIMPLE_ASSIGN, 3);
7091 : 750079 : gimple_assign_set_rhs_code (stmt2, code2);
7092 : 750079 : gimple_assign_set_rhs1 (stmt2, op2a);
7093 : 750079 : gimple_assign_set_rhs2 (stmt2, op2b);
7094 : 750079 : gimple_set_bb (stmt2, NULL);
7095 : :
7096 : : /* Allocate SSA names(lhs1) on the stack. */
7097 : 750079 : alignas (tree_node) unsigned char lhs1buf[sizeof (tree_ssa_name)];
7098 : 750079 : tree lhs1 = (tree) &lhs1buf[0];
7099 : 750079 : memset (lhs1, 0, sizeof (tree_ssa_name));
7100 : 750079 : TREE_SET_CODE (lhs1, SSA_NAME);
7101 : 750079 : TREE_TYPE (lhs1) = type;
7102 : 750079 : init_ssa_name_imm_use (lhs1);
7103 : :
7104 : : /* Allocate SSA names(lhs2) on the stack. */
7105 : 750079 : alignas (tree_node) unsigned char lhs2buf[sizeof (tree_ssa_name)];
7106 : 750079 : tree lhs2 = (tree) &lhs2buf[0];
7107 : 750079 : memset (lhs2, 0, sizeof (tree_ssa_name));
7108 : 750079 : TREE_SET_CODE (lhs2, SSA_NAME);
7109 : 750079 : TREE_TYPE (lhs2) = type;
7110 : 750079 : init_ssa_name_imm_use (lhs2);
7111 : :
7112 : 750079 : gimple_assign_set_lhs (stmt1, lhs1);
7113 : 750079 : gimple_assign_set_lhs (stmt2, lhs2);
7114 : :
7115 : 750079 : gimple_match_op op (gimple_match_cond::UNCOND, code,
7116 : : type, gimple_assign_lhs (stmt1),
7117 : 750079 : gimple_assign_lhs (stmt2));
7118 : 750079 : fosa_bb = outer_cond_bb;
7119 : 750079 : auto_vec<std::pair<tree, flow_sensitive_info_storage>, 8> unwind_stack;
7120 : 750079 : fosa_unwind = &unwind_stack;
7121 : 904568 : if (op.resimplify (NULL, (!outer_cond_bb
7122 : : ? follow_all_ssa_edges : follow_outer_ssa_edges)))
7123 : : {
7124 : 2867 : fosa_unwind = NULL;
7125 : 9617 : for (auto p : unwind_stack)
7126 : 1016 : p.second.restore (p.first);
7127 : 2867 : if (gimple_simplified_result_is_gimple_val (&op))
7128 : : {
7129 : 2344 : tree res = op.ops[0];
7130 : 2344 : if (res == lhs1)
7131 : 2127 : return build2 (code1, type, op1a, op1b);
7132 : 217 : else if (res == lhs2)
7133 : 214 : return build2 (code2, type, op2a, op2b);
7134 : : else
7135 : : return res;
7136 : : }
7137 : 523 : else if (op.code.is_tree_code ()
7138 : 523 : && TREE_CODE_CLASS ((tree_code)op.code) == tcc_comparison)
7139 : : {
7140 : 523 : tree op0 = op.ops[0];
7141 : 523 : tree op1 = op.ops[1];
7142 : 523 : if (op0 == lhs1 || op0 == lhs2 || op1 == lhs1 || op1 == lhs2)
7143 : : return NULL_TREE; /* not simple */
7144 : :
7145 : 523 : return build2 ((enum tree_code)op.code, op.type, op0, op1);
7146 : : }
7147 : : }
7148 : 747212 : fosa_unwind = NULL;
7149 : 2452723 : for (auto p : unwind_stack)
7150 : 211087 : p.second.restore (p.first);
7151 : :
7152 : 747212 : return NULL_TREE;
7153 : 750079 : }
7154 : :
7155 : : /* Try to simplify the AND of two comparisons, specified by
7156 : : (OP1A CODE1 OP1B) and (OP2B CODE2 OP2B), respectively.
7157 : : If this can be simplified to a single expression (without requiring
7158 : : introducing more SSA variables to hold intermediate values),
7159 : : return the resulting tree. Otherwise return NULL_TREE.
7160 : : If the result expression is non-null, it has boolean type. */
7161 : :
7162 : : tree
7163 : 238675 : maybe_fold_and_comparisons (tree type,
7164 : : enum tree_code code1, tree op1a, tree op1b,
7165 : : enum tree_code code2, tree op2a, tree op2b,
7166 : : basic_block outer_cond_bb)
7167 : : {
7168 : 238675 : if (tree t = and_comparisons_1 (type, code1, op1a, op1b, code2, op2a, op2b,
7169 : : outer_cond_bb))
7170 : : return t;
7171 : :
7172 : 237836 : if (tree t = and_comparisons_1 (type, code2, op2a, op2b, code1, op1a, op1b,
7173 : : outer_cond_bb))
7174 : : return t;
7175 : :
7176 : 237823 : if (tree t = maybe_fold_comparisons_from_match_pd (type, BIT_AND_EXPR, code1,
7177 : : op1a, op1b, code2, op2a,
7178 : : op2b, outer_cond_bb))
7179 : : return t;
7180 : :
7181 : : return NULL_TREE;
7182 : : }
7183 : :
7184 : : /* Helper function for or_comparisons_1: try to simplify the OR of the
7185 : : ssa variable VAR with the comparison specified by (OP2A CODE2 OP2B).
7186 : : If INVERT is true, invert the value of VAR before doing the OR.
7187 : : Return NULL_EXPR if we can't simplify this to a single expression. */
7188 : :
7189 : : static tree
7190 : 29118 : or_var_with_comparison (tree type, tree var, bool invert,
7191 : : enum tree_code code2, tree op2a, tree op2b,
7192 : : basic_block outer_cond_bb)
7193 : : {
7194 : 29118 : tree t;
7195 : 29118 : gimple *stmt = SSA_NAME_DEF_STMT (var);
7196 : :
7197 : : /* We can only deal with variables whose definitions are assignments. */
7198 : 29118 : if (!is_gimple_assign (stmt))
7199 : : return NULL_TREE;
7200 : :
7201 : : /* If we have an inverted comparison, apply DeMorgan's law and rewrite
7202 : : !var OR (op2a code2 op2b) => !(var AND !(op2a code2 op2b))
7203 : : Then we only have to consider the simpler non-inverted cases. */
7204 : 29058 : if (invert)
7205 : 16709 : t = and_var_with_comparison_1 (type, stmt,
7206 : : invert_tree_comparison (code2, false),
7207 : : op2a, op2b, outer_cond_bb);
7208 : : else
7209 : 12349 : t = or_var_with_comparison_1 (type, stmt, code2, op2a, op2b,
7210 : : outer_cond_bb);
7211 : 29058 : return canonicalize_bool (t, invert);
7212 : : }
7213 : :
7214 : : /* Try to simplify the OR of the ssa variable defined by the assignment
7215 : : STMT with the comparison specified by (OP2A CODE2 OP2B).
7216 : : Return NULL_EXPR if we can't simplify this to a single expression. */
7217 : :
7218 : : static tree
7219 : 57907 : or_var_with_comparison_1 (tree type, gimple *stmt,
7220 : : enum tree_code code2, tree op2a, tree op2b,
7221 : : basic_block outer_cond_bb)
7222 : : {
7223 : 57907 : tree var = gimple_assign_lhs (stmt);
7224 : 57907 : tree true_test_var = NULL_TREE;
7225 : 57907 : tree false_test_var = NULL_TREE;
7226 : 57907 : enum tree_code innercode = gimple_assign_rhs_code (stmt);
7227 : :
7228 : : /* Check for identities like (var OR (var != 0)) => true . */
7229 : 57907 : if (TREE_CODE (op2a) == SSA_NAME
7230 : 57907 : && TREE_CODE (TREE_TYPE (var)) == BOOLEAN_TYPE)
7231 : : {
7232 : 7590 : if ((code2 == NE_EXPR && integer_zerop (op2b))
7233 : 32943 : || (code2 == EQ_EXPR && integer_nonzerop (op2b)))
7234 : : {
7235 : 7669 : true_test_var = op2a;
7236 : 7669 : if (var == true_test_var)
7237 : : return var;
7238 : : }
7239 : 1706 : else if ((code2 == EQ_EXPR && integer_zerop (op2b))
7240 : 22491 : || (code2 == NE_EXPR && integer_nonzerop (op2b)))
7241 : : {
7242 : 3583 : false_test_var = op2a;
7243 : 3583 : if (var == false_test_var)
7244 : 0 : return boolean_true_node;
7245 : : }
7246 : : }
7247 : :
7248 : : /* If the definition is a comparison, recurse on it. */
7249 : 57907 : if (TREE_CODE_CLASS (innercode) == tcc_comparison)
7250 : : {
7251 : 619 : tree t = or_comparisons_1 (type, innercode,
7252 : : gimple_assign_rhs1 (stmt),
7253 : : gimple_assign_rhs2 (stmt),
7254 : : code2, op2a, op2b, outer_cond_bb);
7255 : 619 : if (t)
7256 : : return t;
7257 : : }
7258 : :
7259 : : /* If the definition is an AND or OR expression, we may be able to
7260 : : simplify by reassociating. */
7261 : 57878 : if (TREE_CODE (TREE_TYPE (var)) == BOOLEAN_TYPE
7262 : 57878 : && (innercode == BIT_AND_EXPR || innercode == BIT_IOR_EXPR))
7263 : : {
7264 : 27383 : tree inner1 = gimple_assign_rhs1 (stmt);
7265 : 27383 : tree inner2 = gimple_assign_rhs2 (stmt);
7266 : 27383 : gimple *s;
7267 : 27383 : tree t;
7268 : 27383 : tree partial = NULL_TREE;
7269 : 27383 : bool is_or = (innercode == BIT_IOR_EXPR);
7270 : :
7271 : : /* Check for boolean identities that don't require recursive examination
7272 : : of inner1/inner2:
7273 : : inner1 OR (inner1 OR inner2) => inner1 OR inner2 => var
7274 : : inner1 OR (inner1 AND inner2) => inner1
7275 : : !inner1 OR (inner1 OR inner2) => true
7276 : : !inner1 OR (inner1 AND inner2) => !inner1 OR inner2
7277 : : */
7278 : 27383 : if (inner1 == true_test_var)
7279 : 0 : return (is_or ? var : inner1);
7280 : 27383 : else if (inner2 == true_test_var)
7281 : 0 : return (is_or ? var : inner2);
7282 : 27383 : else if (inner1 == false_test_var)
7283 : 0 : return (is_or
7284 : 0 : ? boolean_true_node
7285 : 0 : : or_var_with_comparison (type, inner2, false, code2, op2a,
7286 : : op2b, outer_cond_bb));
7287 : 27383 : else if (inner2 == false_test_var)
7288 : 0 : return (is_or
7289 : 0 : ? boolean_true_node
7290 : 0 : : or_var_with_comparison (type, inner1, false, code2, op2a,
7291 : : op2b, outer_cond_bb));
7292 : :
7293 : : /* Next, redistribute/reassociate the OR across the inner tests.
7294 : : Compute the first partial result, (inner1 OR (op2a code op2b)) */
7295 : 27383 : if (TREE_CODE (inner1) == SSA_NAME
7296 : 27383 : && is_gimple_assign (s = SSA_NAME_DEF_STMT (inner1))
7297 : 26796 : && TREE_CODE_CLASS (gimple_assign_rhs_code (s)) == tcc_comparison
7298 : 40088 : && (t = maybe_fold_or_comparisons (type, gimple_assign_rhs_code (s),
7299 : : gimple_assign_rhs1 (s),
7300 : : gimple_assign_rhs2 (s),
7301 : : code2, op2a, op2b,
7302 : : outer_cond_bb)))
7303 : : {
7304 : : /* Handle the OR case, where we are reassociating:
7305 : : (inner1 OR inner2) OR (op2a code2 op2b)
7306 : : => (t OR inner2)
7307 : : If the partial result t is a constant, we win. Otherwise
7308 : : continue on to try reassociating with the other inner test. */
7309 : 137 : if (is_or)
7310 : : {
7311 : 29 : if (integer_onep (t))
7312 : 0 : return boolean_true_node;
7313 : 29 : else if (integer_zerop (t))
7314 : : return inner2;
7315 : : }
7316 : :
7317 : : /* Handle the AND case, where we are redistributing:
7318 : : (inner1 AND inner2) OR (op2a code2 op2b)
7319 : : => (t AND (inner2 OR (op2a code op2b))) */
7320 : 108 : else if (integer_zerop (t))
7321 : 0 : return boolean_false_node;
7322 : :
7323 : : /* Save partial result for later. */
7324 : : partial = t;
7325 : : }
7326 : :
7327 : : /* Compute the second partial result, (inner2 OR (op2a code op2b)) */
7328 : 27383 : if (TREE_CODE (inner2) == SSA_NAME
7329 : 27383 : && is_gimple_assign (s = SSA_NAME_DEF_STMT (inner2))
7330 : 26971 : && TREE_CODE_CLASS (gimple_assign_rhs_code (s)) == tcc_comparison
7331 : 53410 : && (t = maybe_fold_or_comparisons (type, gimple_assign_rhs_code (s),
7332 : : gimple_assign_rhs1 (s),
7333 : : gimple_assign_rhs2 (s),
7334 : : code2, op2a, op2b,
7335 : : outer_cond_bb)))
7336 : : {
7337 : : /* Handle the OR case, where we are reassociating:
7338 : : (inner1 OR inner2) OR (op2a code2 op2b)
7339 : : => (inner1 OR t)
7340 : : => (t OR partial) */
7341 : 81 : if (is_or)
7342 : : {
7343 : 52 : if (integer_zerop (t))
7344 : : return inner1;
7345 : 52 : else if (integer_onep (t))
7346 : 1 : return boolean_true_node;
7347 : : /* If both are the same, we can apply the identity
7348 : : (x OR x) == x. */
7349 : 51 : else if (partial && same_bool_result_p (t, partial))
7350 : : return t;
7351 : : }
7352 : :
7353 : : /* Handle the AND case, where we are redistributing:
7354 : : (inner1 AND inner2) OR (op2a code2 op2b)
7355 : : => (t AND (inner1 OR (op2a code2 op2b)))
7356 : : => (t AND partial) */
7357 : : else
7358 : : {
7359 : 29 : if (integer_zerop (t))
7360 : 0 : return boolean_false_node;
7361 : 29 : else if (partial)
7362 : : {
7363 : : /* We already got a simplification for the other
7364 : : operand to the redistributed AND expression. The
7365 : : interesting case is when at least one is true.
7366 : : Or, if both are the same, we can apply the identity
7367 : : (x AND x) == x. */
7368 : 14 : if (integer_onep (partial))
7369 : : return t;
7370 : 14 : else if (integer_onep (t))
7371 : : return partial;
7372 : 4 : else if (same_bool_result_p (t, partial))
7373 : : return t;
7374 : : }
7375 : : }
7376 : : }
7377 : : }
7378 : : return NULL_TREE;
7379 : : }
7380 : :
7381 : : /* Try to simplify the OR of two comparisons defined by
7382 : : (OP1A CODE1 OP1B) and (OP2A CODE2 OP2B), respectively.
7383 : : If this can be done without constructing an intermediate value,
7384 : : return the resulting tree; otherwise NULL_TREE is returned.
7385 : : This function is deliberately asymmetric as it recurses on SSA_DEFs
7386 : : in the first comparison but not the second. */
7387 : :
7388 : : static tree
7389 : 1027400 : or_comparisons_1 (tree type, enum tree_code code1, tree op1a, tree op1b,
7390 : : enum tree_code code2, tree op2a, tree op2b,
7391 : : basic_block outer_cond_bb)
7392 : : {
7393 : 1027400 : tree truth_type = truth_type_for (TREE_TYPE (op1a));
7394 : :
7395 : : /* First check for ((x CODE1 y) OR (x CODE2 y)). */
7396 : 1027400 : if (operand_equal_p (op1a, op2a, 0)
7397 : 1027400 : && operand_equal_p (op1b, op2b, 0))
7398 : : {
7399 : : /* Result will be either NULL_TREE, or a combined comparison. */
7400 : 2292 : tree t = combine_comparisons (UNKNOWN_LOCATION,
7401 : : TRUTH_ORIF_EXPR, code1, code2,
7402 : : truth_type, op1a, op1b);
7403 : 2292 : if (t)
7404 : : return t;
7405 : : }
7406 : :
7407 : : /* Likewise the swapped case of the above. */
7408 : 1025112 : if (operand_equal_p (op1a, op2b, 0)
7409 : 1025112 : && operand_equal_p (op1b, op2a, 0))
7410 : : {
7411 : : /* Result will be either NULL_TREE, or a combined comparison. */
7412 : 0 : tree t = combine_comparisons (UNKNOWN_LOCATION,
7413 : : TRUTH_ORIF_EXPR, code1,
7414 : : swap_tree_comparison (code2),
7415 : : truth_type, op1a, op1b);
7416 : 0 : if (t)
7417 : : return t;
7418 : : }
7419 : :
7420 : : /* Perhaps the first comparison is (NAME != 0) or (NAME == 1) where
7421 : : NAME's definition is a truth value. See if there are any simplifications
7422 : : that can be done against the NAME's definition. */
7423 : 1025112 : if (TREE_CODE (op1a) == SSA_NAME
7424 : 1023849 : && (code1 == NE_EXPR || code1 == EQ_EXPR)
7425 : 1251873 : && (integer_zerop (op1b) || integer_onep (op1b)))
7426 : : {
7427 : 33702 : bool invert = ((code1 == EQ_EXPR && integer_zerop (op1b))
7428 : 57948 : || (code1 == NE_EXPR && integer_onep (op1b)));
7429 : 54545 : gimple *stmt = SSA_NAME_DEF_STMT (op1a);
7430 : 54545 : switch (gimple_code (stmt))
7431 : : {
7432 : 29014 : case GIMPLE_ASSIGN:
7433 : : /* Try to simplify by copy-propagating the definition. */
7434 : 29014 : return or_var_with_comparison (type, op1a, invert, code2, op2a,
7435 : 29014 : op2b, outer_cond_bb);
7436 : :
7437 : 14392 : case GIMPLE_PHI:
7438 : : /* If every argument to the PHI produces the same result when
7439 : : ORed with the second comparison, we win.
7440 : : Do not do this unless the type is bool since we need a bool
7441 : : result here anyway. */
7442 : 14392 : if (TREE_CODE (TREE_TYPE (op1a)) == BOOLEAN_TYPE)
7443 : : {
7444 : : tree result = NULL_TREE;
7445 : : unsigned i;
7446 : 872 : for (i = 0; i < gimple_phi_num_args (stmt); i++)
7447 : : {
7448 : 872 : tree arg = gimple_phi_arg_def (stmt, i);
7449 : :
7450 : : /* If this PHI has itself as an argument, ignore it.
7451 : : If all the other args produce the same result,
7452 : : we're still OK. */
7453 : 872 : if (arg == gimple_phi_result (stmt))
7454 : 0 : continue;
7455 : 872 : else if (TREE_CODE (arg) == INTEGER_CST)
7456 : : {
7457 : 752 : if (invert ? integer_zerop (arg) : integer_nonzerop (arg))
7458 : : {
7459 : 352 : if (!result)
7460 : 206 : result = boolean_true_node;
7461 : 146 : else if (!integer_onep (result))
7462 : : return NULL_TREE;
7463 : : }
7464 : 400 : else if (!result)
7465 : 194 : result = fold_build2 (code2, boolean_type_node,
7466 : : op2a, op2b);
7467 : 206 : else if (!same_bool_comparison_p (result,
7468 : : code2, op2a, op2b))
7469 : : return NULL_TREE;
7470 : : }
7471 : 120 : else if (TREE_CODE (arg) == SSA_NAME
7472 : 120 : && !SSA_NAME_IS_DEFAULT_DEF (arg))
7473 : : {
7474 : 120 : tree temp;
7475 : 120 : gimple *def_stmt = SSA_NAME_DEF_STMT (arg);
7476 : : /* In simple cases we can look through PHI nodes,
7477 : : but we have to be careful with loops.
7478 : : See PR49073. */
7479 : 120 : if (! dom_info_available_p (CDI_DOMINATORS)
7480 : 120 : || gimple_bb (def_stmt) == gimple_bb (stmt)
7481 : 240 : || dominated_by_p (CDI_DOMINATORS,
7482 : 120 : gimple_bb (def_stmt),
7483 : 120 : gimple_bb (stmt)))
7484 : 16 : return NULL_TREE;
7485 : 104 : temp = or_var_with_comparison (type, arg, invert, code2,
7486 : : op2a, op2b, outer_cond_bb);
7487 : 104 : if (!temp)
7488 : : return NULL_TREE;
7489 : 0 : else if (!result)
7490 : : result = temp;
7491 : 0 : else if (!same_bool_result_p (result, temp))
7492 : : return NULL_TREE;
7493 : : }
7494 : : else
7495 : : return NULL_TREE;
7496 : : }
7497 : 0 : return result;
7498 : : }
7499 : :
7500 : : default:
7501 : : break;
7502 : : }
7503 : : }
7504 : : return NULL_TREE;
7505 : : }
7506 : :
7507 : : /* Try to simplify the OR of two comparisons, specified by
7508 : : (OP1A CODE1 OP1B) and (OP2B CODE2 OP2B), respectively.
7509 : : If this can be simplified to a single expression (without requiring
7510 : : introducing more SSA variables to hold intermediate values),
7511 : : return the resulting tree. Otherwise return NULL_TREE.
7512 : : If the result expression is non-null, it has boolean type. */
7513 : :
7514 : : tree
7515 : 514520 : maybe_fold_or_comparisons (tree type,
7516 : : enum tree_code code1, tree op1a, tree op1b,
7517 : : enum tree_code code2, tree op2a, tree op2b,
7518 : : basic_block outer_cond_bb)
7519 : : {
7520 : 514520 : if (tree t = or_comparisons_1 (type, code1, op1a, op1b, code2, op2a, op2b,
7521 : : outer_cond_bb))
7522 : : return t;
7523 : :
7524 : 512261 : if (tree t = or_comparisons_1 (type, code2, op2a, op2b, code1, op1a, op1b,
7525 : : outer_cond_bb))
7526 : : return t;
7527 : :
7528 : 512256 : if (tree t = maybe_fold_comparisons_from_match_pd (type, BIT_IOR_EXPR, code1,
7529 : : op1a, op1b, code2, op2a,
7530 : : op2b, outer_cond_bb))
7531 : : return t;
7532 : :
7533 : : return NULL_TREE;
7534 : : }
7535 : :
7536 : : /* Fold STMT to a constant using VALUEIZE to valueize SSA names.
7537 : :
7538 : : Either NULL_TREE, a simplified but non-constant or a constant
7539 : : is returned.
7540 : :
7541 : : ??? This should go into a gimple-fold-inline.h file to be eventually
7542 : : privatized with the single valueize function used in the various TUs
7543 : : to avoid the indirect function call overhead. */
7544 : :
7545 : : tree
7546 : 371393734 : gimple_fold_stmt_to_constant_1 (gimple *stmt, tree (*valueize) (tree),
7547 : : tree (*gvalueize) (tree))
7548 : : {
7549 : 371393734 : gimple_match_op res_op;
7550 : : /* ??? The SSA propagators do not correctly deal with following SSA use-def
7551 : : edges if there are intermediate VARYING defs. For this reason
7552 : : do not follow SSA edges here even though SCCVN can technically
7553 : : just deal fine with that. */
7554 : 371393734 : if (gimple_simplify (stmt, &res_op, NULL, gvalueize, valueize))
7555 : : {
7556 : 48281329 : tree res = NULL_TREE;
7557 : 48281329 : if (gimple_simplified_result_is_gimple_val (&res_op))
7558 : 29005308 : res = res_op.ops[0];
7559 : 19276021 : else if (mprts_hook)
7560 : 6785207 : res = mprts_hook (&res_op);
7561 : 35790515 : if (res)
7562 : : {
7563 : 30632148 : if (dump_file && dump_flags & TDF_DETAILS)
7564 : : {
7565 : 9711 : fprintf (dump_file, "Match-and-simplified ");
7566 : 9711 : print_gimple_expr (dump_file, stmt, 0, TDF_SLIM);
7567 : 9711 : fprintf (dump_file, " to ");
7568 : 9711 : print_generic_expr (dump_file, res);
7569 : 9711 : fprintf (dump_file, "\n");
7570 : : }
7571 : 30632148 : return res;
7572 : : }
7573 : : }
7574 : :
7575 : 340761586 : location_t loc = gimple_location (stmt);
7576 : 340761586 : switch (gimple_code (stmt))
7577 : : {
7578 : 294747749 : case GIMPLE_ASSIGN:
7579 : 294747749 : {
7580 : 294747749 : enum tree_code subcode = gimple_assign_rhs_code (stmt);
7581 : :
7582 : 294747749 : switch (get_gimple_rhs_class (subcode))
7583 : : {
7584 : 108543883 : case GIMPLE_SINGLE_RHS:
7585 : 108543883 : {
7586 : 108543883 : tree rhs = gimple_assign_rhs1 (stmt);
7587 : 108543883 : enum tree_code_class kind = TREE_CODE_CLASS (subcode);
7588 : :
7589 : 108543883 : if (TREE_CODE (rhs) == SSA_NAME)
7590 : : {
7591 : : /* If the RHS is an SSA_NAME, return its known constant value,
7592 : : if any. */
7593 : 8278517 : return (*valueize) (rhs);
7594 : : }
7595 : : /* Handle propagating invariant addresses into address
7596 : : operations. */
7597 : 100265366 : else if (TREE_CODE (rhs) == ADDR_EXPR
7598 : 100265366 : && !is_gimple_min_invariant (rhs))
7599 : : {
7600 : 7156315 : poly_int64 offset = 0;
7601 : 7156315 : tree base;
7602 : 7156315 : base = get_addr_base_and_unit_offset_1 (TREE_OPERAND (rhs, 0),
7603 : : &offset,
7604 : : valueize);
7605 : 7156315 : if (base
7606 : 7156315 : && (CONSTANT_CLASS_P (base)
7607 : 6505470 : || decl_address_invariant_p (base)))
7608 : 171231 : return build_invariant_address (TREE_TYPE (rhs),
7609 : 171231 : base, offset);
7610 : : }
7611 : 93109051 : else if (TREE_CODE (rhs) == CONSTRUCTOR
7612 : 978286 : && TREE_CODE (TREE_TYPE (rhs)) == VECTOR_TYPE
7613 : 94570165 : && known_eq (CONSTRUCTOR_NELTS (rhs),
7614 : : TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs))))
7615 : : {
7616 : 476344 : unsigned i, nelts;
7617 : 476344 : tree val;
7618 : :
7619 : 476344 : nelts = CONSTRUCTOR_NELTS (rhs);
7620 : 476344 : tree_vector_builder vec (TREE_TYPE (rhs), nelts, 1);
7621 : 1034341 : FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), i, val)
7622 : : {
7623 : 545348 : val = (*valueize) (val);
7624 : 545348 : if (TREE_CODE (val) == INTEGER_CST
7625 : 481634 : || TREE_CODE (val) == REAL_CST
7626 : 463695 : || TREE_CODE (val) == FIXED_CST)
7627 : 81653 : vec.quick_push (val);
7628 : : else
7629 : : return NULL_TREE;
7630 : : }
7631 : :
7632 : 12649 : return vec.build ();
7633 : 476344 : }
7634 : 99617791 : if (subcode == OBJ_TYPE_REF)
7635 : : {
7636 : 131901 : tree val = (*valueize) (OBJ_TYPE_REF_EXPR (rhs));
7637 : : /* If callee is constant, we can fold away the wrapper. */
7638 : 131901 : if (is_gimple_min_invariant (val))
7639 : : return val;
7640 : : }
7641 : :
7642 : 99617748 : if (kind == tcc_reference)
7643 : : {
7644 : 66523481 : if ((TREE_CODE (rhs) == VIEW_CONVERT_EXPR
7645 : 64429587 : || TREE_CODE (rhs) == REALPART_EXPR
7646 : 63596438 : || TREE_CODE (rhs) == IMAGPART_EXPR)
7647 : 68345280 : && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
7648 : : {
7649 : 3033773 : tree val = (*valueize) (TREE_OPERAND (rhs, 0));
7650 : 3033773 : return fold_unary_loc (EXPR_LOCATION (rhs),
7651 : 3033773 : TREE_CODE (rhs),
7652 : 6067546 : TREE_TYPE (rhs), val);
7653 : : }
7654 : 63489708 : else if (TREE_CODE (rhs) == BIT_FIELD_REF
7655 : 63489708 : && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
7656 : : {
7657 : 470952 : tree val = (*valueize) (TREE_OPERAND (rhs, 0));
7658 : 470952 : return fold_ternary_loc (EXPR_LOCATION (rhs),
7659 : 470952 : TREE_CODE (rhs),
7660 : 470952 : TREE_TYPE (rhs), val,
7661 : 470952 : TREE_OPERAND (rhs, 1),
7662 : 941904 : TREE_OPERAND (rhs, 2));
7663 : : }
7664 : 63018756 : else if (TREE_CODE (rhs) == MEM_REF
7665 : 63018756 : && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
7666 : : {
7667 : 12265782 : tree val = (*valueize) (TREE_OPERAND (rhs, 0));
7668 : 12265782 : if (TREE_CODE (val) == ADDR_EXPR
7669 : 12265782 : && is_gimple_min_invariant (val))
7670 : : {
7671 : 837211 : tree tem = fold_build2 (MEM_REF, TREE_TYPE (rhs),
7672 : : unshare_expr (val),
7673 : : TREE_OPERAND (rhs, 1));
7674 : 837211 : if (tem)
7675 : 63018756 : rhs = tem;
7676 : : }
7677 : : }
7678 : 63018756 : return fold_const_aggregate_ref_1 (rhs, valueize);
7679 : : }
7680 : 33094267 : else if (kind == tcc_declaration)
7681 : 8001380 : return get_symbol_constant_value (rhs);
7682 : : return rhs;
7683 : : }
7684 : :
7685 : : case GIMPLE_UNARY_RHS:
7686 : : return NULL_TREE;
7687 : :
7688 : 137899654 : case GIMPLE_BINARY_RHS:
7689 : : /* Translate &x + CST into an invariant form suitable for
7690 : : further propagation. */
7691 : 137899654 : if (subcode == POINTER_PLUS_EXPR)
7692 : : {
7693 : 16261575 : tree op0 = (*valueize) (gimple_assign_rhs1 (stmt));
7694 : 16261575 : tree op1 = (*valueize) (gimple_assign_rhs2 (stmt));
7695 : 16261575 : if (TREE_CODE (op0) == ADDR_EXPR
7696 : 4847198 : && TREE_CODE (op1) == INTEGER_CST)
7697 : : {
7698 : 472366 : tree off = fold_convert (ptr_type_node, op1);
7699 : 472366 : return build1_loc
7700 : 944732 : (loc, ADDR_EXPR, TREE_TYPE (op0),
7701 : 472366 : fold_build2 (MEM_REF,
7702 : : TREE_TYPE (TREE_TYPE (op0)),
7703 : 472366 : unshare_expr (op0), off));
7704 : : }
7705 : : }
7706 : : /* Canonicalize bool != 0 and bool == 0 appearing after
7707 : : valueization. While gimple_simplify handles this
7708 : : it can get confused by the ~X == 1 -> X == 0 transform
7709 : : which we cant reduce to a SSA name or a constant
7710 : : (and we have no way to tell gimple_simplify to not
7711 : : consider those transforms in the first place). */
7712 : 121638079 : else if (subcode == EQ_EXPR
7713 : 121638079 : || subcode == NE_EXPR)
7714 : : {
7715 : 2955616 : tree lhs = gimple_assign_lhs (stmt);
7716 : 2955616 : tree op0 = gimple_assign_rhs1 (stmt);
7717 : 2955616 : if (useless_type_conversion_p (TREE_TYPE (lhs),
7718 : 2955616 : TREE_TYPE (op0)))
7719 : : {
7720 : 26280 : tree op1 = (*valueize) (gimple_assign_rhs2 (stmt));
7721 : 26280 : op0 = (*valueize) (op0);
7722 : 26280 : if (TREE_CODE (op0) == INTEGER_CST)
7723 : 916 : std::swap (op0, op1);
7724 : 26280 : if (TREE_CODE (op1) == INTEGER_CST
7725 : 26280 : && ((subcode == NE_EXPR && integer_zerop (op1))
7726 : 2508 : || (subcode == EQ_EXPR && integer_onep (op1))))
7727 : 258 : return op0;
7728 : : }
7729 : : }
7730 : : return NULL_TREE;
7731 : :
7732 : 494935 : case GIMPLE_TERNARY_RHS:
7733 : 494935 : {
7734 : : /* Handle ternary operators that can appear in GIMPLE form. */
7735 : 494935 : tree op0 = (*valueize) (gimple_assign_rhs1 (stmt));
7736 : 494935 : tree op1 = (*valueize) (gimple_assign_rhs2 (stmt));
7737 : 494935 : tree op2 = (*valueize) (gimple_assign_rhs3 (stmt));
7738 : 494935 : return fold_ternary_loc (loc, subcode,
7739 : 494935 : TREE_TYPE (gimple_assign_lhs (stmt)),
7740 : 494935 : op0, op1, op2);
7741 : : }
7742 : :
7743 : 0 : default:
7744 : 0 : gcc_unreachable ();
7745 : : }
7746 : : }
7747 : :
7748 : 13323913 : case GIMPLE_CALL:
7749 : 13323913 : {
7750 : 13323913 : tree fn;
7751 : 13323913 : gcall *call_stmt = as_a <gcall *> (stmt);
7752 : :
7753 : 13323913 : if (gimple_call_internal_p (stmt))
7754 : : {
7755 : 1086896 : enum tree_code subcode = ERROR_MARK;
7756 : 1086896 : switch (gimple_call_internal_fn (stmt))
7757 : : {
7758 : : case IFN_UBSAN_CHECK_ADD:
7759 : : subcode = PLUS_EXPR;
7760 : : break;
7761 : 7936 : case IFN_UBSAN_CHECK_SUB:
7762 : 7936 : subcode = MINUS_EXPR;
7763 : 7936 : break;
7764 : 6803 : case IFN_UBSAN_CHECK_MUL:
7765 : 6803 : subcode = MULT_EXPR;
7766 : 6803 : break;
7767 : 95708 : case IFN_BUILTIN_EXPECT:
7768 : 95708 : {
7769 : 95708 : tree arg0 = gimple_call_arg (stmt, 0);
7770 : 95708 : tree op0 = (*valueize) (arg0);
7771 : 95708 : if (TREE_CODE (op0) == INTEGER_CST)
7772 : : return op0;
7773 : : return NULL_TREE;
7774 : : }
7775 : : default:
7776 : : return NULL_TREE;
7777 : : }
7778 : 22849 : tree arg0 = gimple_call_arg (stmt, 0);
7779 : 22849 : tree arg1 = gimple_call_arg (stmt, 1);
7780 : 22849 : tree op0 = (*valueize) (arg0);
7781 : 22849 : tree op1 = (*valueize) (arg1);
7782 : :
7783 : 22849 : if (TREE_CODE (op0) != INTEGER_CST
7784 : 2509 : || TREE_CODE (op1) != INTEGER_CST)
7785 : : {
7786 : 22339 : switch (subcode)
7787 : : {
7788 : 6703 : case MULT_EXPR:
7789 : : /* x * 0 = 0 * x = 0 without overflow. */
7790 : 6703 : if (integer_zerop (op0) || integer_zerop (op1))
7791 : 20 : return build_zero_cst (TREE_TYPE (arg0));
7792 : : break;
7793 : 7594 : case MINUS_EXPR:
7794 : : /* y - y = 0 without overflow. */
7795 : 7594 : if (operand_equal_p (op0, op1, 0))
7796 : 0 : return build_zero_cst (TREE_TYPE (arg0));
7797 : : break;
7798 : : default:
7799 : : break;
7800 : : }
7801 : : }
7802 : 22829 : tree res
7803 : 22829 : = fold_binary_loc (loc, subcode, TREE_TYPE (arg0), op0, op1);
7804 : 22829 : if (res
7805 : 2883 : && TREE_CODE (res) == INTEGER_CST
7806 : 23339 : && !TREE_OVERFLOW (res))
7807 : : return res;
7808 : : return NULL_TREE;
7809 : : }
7810 : :
7811 : 12237017 : fn = (*valueize) (gimple_call_fn (stmt));
7812 : 12237017 : if (TREE_CODE (fn) == ADDR_EXPR
7813 : 11615728 : && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
7814 : 11615656 : && fndecl_built_in_p (TREE_OPERAND (fn, 0))
7815 : 17905544 : && gimple_builtin_call_types_compatible_p (stmt,
7816 : 5668527 : TREE_OPERAND (fn, 0)))
7817 : : {
7818 : 5578187 : tree *args = XALLOCAVEC (tree, gimple_call_num_args (stmt));
7819 : 5578187 : tree retval;
7820 : 5578187 : unsigned i;
7821 : 17505167 : for (i = 0; i < gimple_call_num_args (stmt); ++i)
7822 : 11926980 : args[i] = (*valueize) (gimple_call_arg (stmt, i));
7823 : 5578187 : retval = fold_builtin_call_array (loc,
7824 : : gimple_call_return_type (call_stmt),
7825 : : fn, gimple_call_num_args (stmt), args);
7826 : 5578187 : if (retval)
7827 : : {
7828 : : /* fold_call_expr wraps the result inside a NOP_EXPR. */
7829 : 40477 : STRIP_NOPS (retval);
7830 : 40477 : retval = fold_convert (gimple_call_return_type (call_stmt),
7831 : : retval);
7832 : : }
7833 : 5578187 : return retval;
7834 : : }
7835 : : return NULL_TREE;
7836 : : }
7837 : :
7838 : : default:
7839 : : return NULL_TREE;
7840 : : }
7841 : : }
7842 : :
7843 : : /* Fold STMT to a constant using VALUEIZE to valueize SSA names.
7844 : : Returns NULL_TREE if folding to a constant is not possible, otherwise
7845 : : returns a constant according to is_gimple_min_invariant. */
7846 : :
7847 : : tree
7848 : 4472 : gimple_fold_stmt_to_constant (gimple *stmt, tree (*valueize) (tree))
7849 : : {
7850 : 4472 : tree res = gimple_fold_stmt_to_constant_1 (stmt, valueize);
7851 : 4472 : if (res && is_gimple_min_invariant (res))
7852 : : return res;
7853 : : return NULL_TREE;
7854 : : }
7855 : :
7856 : :
7857 : : /* The following set of functions are supposed to fold references using
7858 : : their constant initializers. */
7859 : :
7860 : : /* See if we can find constructor defining value of BASE.
7861 : : When we know the consructor with constant offset (such as
7862 : : base is array[40] and we do know constructor of array), then
7863 : : BIT_OFFSET is adjusted accordingly.
7864 : :
7865 : : As a special case, return error_mark_node when constructor
7866 : : is not explicitly available, but it is known to be zero
7867 : : such as 'static const int a;'. */
7868 : : static tree
7869 : 115727555 : get_base_constructor (tree base, poly_int64 *bit_offset,
7870 : : tree (*valueize)(tree))
7871 : : {
7872 : 115818402 : poly_int64 bit_offset2, size, max_size;
7873 : 115818402 : bool reverse;
7874 : :
7875 : 115818402 : if (TREE_CODE (base) == MEM_REF)
7876 : : {
7877 : 124587194 : poly_offset_int boff = *bit_offset + mem_ref_offset (base) * BITS_PER_UNIT;
7878 : 62293597 : if (!boff.to_shwi (bit_offset))
7879 : 62029336 : return NULL_TREE;
7880 : :
7881 : 62293290 : if (valueize
7882 : 62293290 : && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
7883 : 33643571 : base = valueize (TREE_OPERAND (base, 0));
7884 : 62293290 : if (!base || TREE_CODE (base) != ADDR_EXPR)
7885 : : return NULL_TREE;
7886 : 264261 : base = TREE_OPERAND (base, 0);
7887 : : }
7888 : 53524805 : else if (valueize
7889 : 28920085 : && TREE_CODE (base) == SSA_NAME)
7890 : 0 : base = valueize (base);
7891 : :
7892 : : /* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
7893 : : DECL_INITIAL. If BASE is a nested reference into another
7894 : : ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
7895 : : the inner reference. */
7896 : 53789066 : switch (TREE_CODE (base))
7897 : : {
7898 : 47040888 : case VAR_DECL:
7899 : 47040888 : case CONST_DECL:
7900 : 47040888 : {
7901 : 47040888 : tree init = ctor_for_folding (base);
7902 : :
7903 : : /* Our semantic is exact opposite of ctor_for_folding;
7904 : : NULL means unknown, while error_mark_node is 0. */
7905 : 47040888 : if (init == error_mark_node)
7906 : : return NULL_TREE;
7907 : 945272 : if (!init)
7908 : 1038 : return error_mark_node;
7909 : : return init;
7910 : : }
7911 : :
7912 : 90847 : case VIEW_CONVERT_EXPR:
7913 : 90847 : return get_base_constructor (TREE_OPERAND (base, 0),
7914 : 90847 : bit_offset, valueize);
7915 : :
7916 : 270785 : case ARRAY_REF:
7917 : 270785 : case COMPONENT_REF:
7918 : 270785 : base = get_ref_base_and_extent (base, &bit_offset2, &size, &max_size,
7919 : : &reverse);
7920 : 270785 : if (!known_size_p (max_size) || maybe_ne (size, max_size))
7921 : : return NULL_TREE;
7922 : 209795 : *bit_offset += bit_offset2;
7923 : 209795 : return get_base_constructor (base, bit_offset, valueize);
7924 : :
7925 : : case CONSTRUCTOR:
7926 : : return base;
7927 : :
7928 : 6386546 : default:
7929 : 6386546 : if (CONSTANT_CLASS_P (base))
7930 : : return base;
7931 : :
7932 : : return NULL_TREE;
7933 : : }
7934 : : }
7935 : :
7936 : : /* CTOR is a CONSTRUCTOR of an array or vector type. Fold a reference of SIZE
7937 : : bits to the memory at bit OFFSET. If non-null, TYPE is the expected type of
7938 : : the reference; otherwise the type of the referenced element is used instead.
7939 : : When SIZE is zero, attempt to fold a reference to the entire element OFFSET
7940 : : refers to. Increment *SUBOFF by the bit offset of the accessed element. */
7941 : :
7942 : : static tree
7943 : 627791 : fold_array_ctor_reference (tree type, tree ctor,
7944 : : unsigned HOST_WIDE_INT offset,
7945 : : unsigned HOST_WIDE_INT size,
7946 : : tree from_decl,
7947 : : unsigned HOST_WIDE_INT *suboff)
7948 : : {
7949 : 627791 : offset_int low_bound;
7950 : 627791 : offset_int elt_size;
7951 : 627791 : offset_int access_index;
7952 : 627791 : tree domain_type = NULL_TREE;
7953 : 627791 : HOST_WIDE_INT inner_offset;
7954 : :
7955 : : /* Compute low bound and elt size. */
7956 : 627791 : if (TREE_CODE (TREE_TYPE (ctor)) == ARRAY_TYPE)
7957 : 627791 : domain_type = TYPE_DOMAIN (TREE_TYPE (ctor));
7958 : 627791 : if (domain_type && TYPE_MIN_VALUE (domain_type))
7959 : : {
7960 : : /* Static constructors for variably sized objects make no sense. */
7961 : 627791 : if (TREE_CODE (TYPE_MIN_VALUE (domain_type)) != INTEGER_CST)
7962 : : return NULL_TREE;
7963 : 627791 : low_bound = wi::to_offset (TYPE_MIN_VALUE (domain_type));
7964 : : }
7965 : : else
7966 : 0 : low_bound = 0;
7967 : : /* Static constructors for variably sized objects make no sense. */
7968 : 627791 : if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor)))) != INTEGER_CST)
7969 : : return NULL_TREE;
7970 : 627791 : elt_size = wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor))));
7971 : :
7972 : : /* When TYPE is non-null, verify that it specifies a constant-sized
7973 : : access of a multiple of the array element size. Avoid division
7974 : : by zero below when ELT_SIZE is zero, such as with the result of
7975 : : an initializer for a zero-length array or an empty struct. */
7976 : 627791 : if (elt_size == 0
7977 : 627791 : || (type
7978 : 627752 : && (!TYPE_SIZE_UNIT (type)
7979 : 627752 : || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST)))
7980 : 39 : return NULL_TREE;
7981 : :
7982 : : /* Compute the array index we look for. */
7983 : 627752 : access_index = wi::udiv_trunc (offset_int (offset / BITS_PER_UNIT),
7984 : : elt_size);
7985 : 627752 : access_index += low_bound;
7986 : :
7987 : : /* And offset within the access. */
7988 : 627752 : inner_offset = offset % (elt_size.to_uhwi () * BITS_PER_UNIT);
7989 : :
7990 : 627752 : unsigned HOST_WIDE_INT elt_sz = elt_size.to_uhwi ();
7991 : 627752 : if (size > elt_sz * BITS_PER_UNIT)
7992 : : {
7993 : : /* native_encode_expr constraints. */
7994 : 34092 : if (size > MAX_BITSIZE_MODE_ANY_MODE
7995 : 32661 : || size % BITS_PER_UNIT != 0
7996 : 32661 : || inner_offset % BITS_PER_UNIT != 0
7997 : 32661 : || elt_sz > MAX_BITSIZE_MODE_ANY_MODE / BITS_PER_UNIT)
7998 : : return NULL_TREE;
7999 : :
8000 : 32661 : unsigned ctor_idx;
8001 : 32661 : tree val = get_array_ctor_element_at_index (ctor, access_index,
8002 : : &ctor_idx);
8003 : 32667 : if (!val && ctor_idx >= CONSTRUCTOR_NELTS (ctor))
8004 : 2 : return build_zero_cst (type);
8005 : :
8006 : : /* native-encode adjacent ctor elements. */
8007 : 32659 : unsigned char buf[MAX_BITSIZE_MODE_ANY_MODE / BITS_PER_UNIT];
8008 : 32659 : unsigned bufoff = 0;
8009 : 32659 : offset_int index = 0;
8010 : 32659 : offset_int max_index = access_index;
8011 : 32659 : constructor_elt *elt = CONSTRUCTOR_ELT (ctor, ctor_idx);
8012 : 32659 : if (!val)
8013 : 1 : val = build_zero_cst (TREE_TYPE (TREE_TYPE (ctor)));
8014 : 32658 : else if (!CONSTANT_CLASS_P (val))
8015 : : return NULL_TREE;
8016 : 32009 : if (!elt->index)
8017 : : ;
8018 : 30021 : else if (TREE_CODE (elt->index) == RANGE_EXPR)
8019 : : {
8020 : 20 : index = wi::to_offset (TREE_OPERAND (elt->index, 0));
8021 : 20 : max_index = wi::to_offset (TREE_OPERAND (elt->index, 1));
8022 : : }
8023 : : else
8024 : 30001 : index = max_index = wi::to_offset (elt->index);
8025 : 32009 : index = wi::umax (index, access_index);
8026 : 229916 : do
8027 : : {
8028 : 229916 : if (bufoff + elt_sz > sizeof (buf))
8029 : 0 : elt_sz = sizeof (buf) - bufoff;
8030 : 459832 : int len = native_encode_expr (val, buf + bufoff, elt_sz,
8031 : 229916 : inner_offset / BITS_PER_UNIT);
8032 : 229916 : if (len != (int) elt_sz - inner_offset / BITS_PER_UNIT)
8033 : : return NULL_TREE;
8034 : 229916 : inner_offset = 0;
8035 : 229916 : bufoff += len;
8036 : :
8037 : 229916 : access_index += 1;
8038 : 229916 : if (wi::cmpu (access_index, index) == 0)
8039 : 2 : val = elt->value;
8040 : 229914 : else if (wi::cmpu (access_index, max_index) > 0)
8041 : : {
8042 : 229674 : ctor_idx++;
8043 : 459348 : if (ctor_idx >= CONSTRUCTOR_NELTS (ctor))
8044 : : {
8045 : 31067 : val = build_zero_cst (TREE_TYPE (TREE_TYPE (ctor)));
8046 : 31067 : ++max_index;
8047 : : }
8048 : : else
8049 : : {
8050 : 198607 : elt = CONSTRUCTOR_ELT (ctor, ctor_idx);
8051 : 198607 : index = 0;
8052 : 198607 : max_index = access_index;
8053 : 198607 : if (!elt->index)
8054 : : ;
8055 : 197799 : else if (TREE_CODE (elt->index) == RANGE_EXPR)
8056 : : {
8057 : 0 : index = wi::to_offset (TREE_OPERAND (elt->index, 0));
8058 : 0 : max_index = wi::to_offset (TREE_OPERAND (elt->index, 1));
8059 : : }
8060 : : else
8061 : 197799 : index = max_index = wi::to_offset (elt->index);
8062 : 198607 : index = wi::umax (index, access_index);
8063 : 198607 : if (wi::cmpu (access_index, index) == 0)
8064 : 198606 : val = elt->value;
8065 : : else
8066 : 1 : val = build_zero_cst (TREE_TYPE (TREE_TYPE (ctor)));
8067 : : }
8068 : : }
8069 : : }
8070 : 229916 : while (bufoff < size / BITS_PER_UNIT);
8071 : 32009 : *suboff += size;
8072 : 32009 : return native_interpret_expr (type, buf, size / BITS_PER_UNIT);
8073 : : }
8074 : :
8075 : 593660 : if (tree val = get_array_ctor_element_at_index (ctor, access_index))
8076 : : {
8077 : 591871 : if (!size && TREE_CODE (val) != CONSTRUCTOR)
8078 : : {
8079 : : /* For the final reference to the entire accessed element
8080 : : (SIZE is zero), reset INNER_OFFSET, disegard TYPE (which
8081 : : may be null) in favor of the type of the element, and set
8082 : : SIZE to the size of the accessed element. */
8083 : 22992 : inner_offset = 0;
8084 : 22992 : type = TREE_TYPE (val);
8085 : 22992 : size = elt_sz * BITS_PER_UNIT;
8086 : : }
8087 : 1528066 : else if (size && access_index < CONSTRUCTOR_NELTS (ctor) - 1
8088 : 428944 : && TREE_CODE (val) == CONSTRUCTOR
8089 : 8262 : && (elt_sz * BITS_PER_UNIT - inner_offset) < size)
8090 : : /* If this isn't the last element in the CTOR and a CTOR itself
8091 : : and it does not cover the whole object we are requesting give up
8092 : : since we're not set up for combining from multiple CTORs. */
8093 : 20 : return NULL_TREE;
8094 : :
8095 : 591851 : *suboff += access_index.to_uhwi () * elt_sz * BITS_PER_UNIT;
8096 : 591851 : return fold_ctor_reference (type, val, inner_offset, size, from_decl,
8097 : : suboff);
8098 : : }
8099 : :
8100 : : /* Memory not explicitly mentioned in constructor is 0 (or
8101 : : the reference is out of range). */
8102 : 1789 : return type ? build_zero_cst (type) : NULL_TREE;
8103 : : }
8104 : :
8105 : : /* CTOR is a CONSTRUCTOR of a record or union type. Fold a reference of SIZE
8106 : : bits to the memory at bit OFFSET. If non-null, TYPE is the expected type of
8107 : : the reference; otherwise the type of the referenced member is used instead.
8108 : : When SIZE is zero, attempt to fold a reference to the entire member OFFSET
8109 : : refers to. Increment *SUBOFF by the bit offset of the accessed member. */
8110 : :
8111 : : static tree
8112 : 63845 : fold_nonarray_ctor_reference (tree type, tree ctor,
8113 : : unsigned HOST_WIDE_INT offset,
8114 : : unsigned HOST_WIDE_INT size,
8115 : : tree from_decl,
8116 : : unsigned HOST_WIDE_INT *suboff)
8117 : : {
8118 : 63845 : unsigned HOST_WIDE_INT cnt;
8119 : 63845 : tree cfield, cval;
8120 : :
8121 : 101755 : FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), cnt, cfield, cval)
8122 : : {
8123 : 90348 : tree byte_offset = DECL_FIELD_OFFSET (cfield);
8124 : 90348 : tree field_offset = DECL_FIELD_BIT_OFFSET (cfield);
8125 : 90348 : tree field_size = DECL_SIZE (cfield);
8126 : :
8127 : 90348 : if (!field_size)
8128 : : {
8129 : : /* Determine the size of the flexible array member from
8130 : : the size of the initializer provided for it. */
8131 : 1134 : field_size = TYPE_SIZE (TREE_TYPE (cval));
8132 : : }
8133 : :
8134 : : /* Variable sized objects in static constructors makes no sense,
8135 : : but field_size can be NULL for flexible array members. */
8136 : 90348 : gcc_assert (TREE_CODE (field_offset) == INTEGER_CST
8137 : : && TREE_CODE (byte_offset) == INTEGER_CST
8138 : : && (field_size != NULL_TREE
8139 : : ? TREE_CODE (field_size) == INTEGER_CST
8140 : : : TREE_CODE (TREE_TYPE (cfield)) == ARRAY_TYPE));
8141 : :
8142 : : /* Compute bit offset of the field. */
8143 : 90348 : offset_int bitoffset
8144 : 90348 : = (wi::to_offset (field_offset)
8145 : 90348 : + (wi::to_offset (byte_offset) << LOG2_BITS_PER_UNIT));
8146 : : /* Compute bit offset where the field ends. */
8147 : 90348 : offset_int bitoffset_end;
8148 : 90348 : if (field_size != NULL_TREE)
8149 : 90348 : bitoffset_end = bitoffset + wi::to_offset (field_size);
8150 : : else
8151 : 0 : bitoffset_end = 0;
8152 : :
8153 : : /* Compute the bit offset of the end of the desired access.
8154 : : As a special case, if the size of the desired access is
8155 : : zero, assume the access is to the entire field (and let
8156 : : the caller make any necessary adjustments by storing
8157 : : the actual bounds of the field in FIELDBOUNDS). */
8158 : 90348 : offset_int access_end = offset_int (offset);
8159 : 90348 : if (size)
8160 : 45477 : access_end += size;
8161 : : else
8162 : 44871 : access_end = bitoffset_end;
8163 : :
8164 : : /* Is there any overlap between the desired access at
8165 : : [OFFSET, OFFSET+SIZE) and the offset of the field within
8166 : : the object at [BITOFFSET, BITOFFSET_END)? */
8167 : 90348 : if (wi::cmps (access_end, bitoffset) > 0
8168 : 90348 : && (field_size == NULL_TREE
8169 : 87200 : || wi::lts_p (offset, bitoffset_end)))
8170 : : {
8171 : 52438 : *suboff += bitoffset.to_uhwi ();
8172 : :
8173 : 52438 : if (!size && TREE_CODE (cval) != CONSTRUCTOR)
8174 : : {
8175 : : /* For the final reference to the entire accessed member
8176 : : (SIZE is zero), reset OFFSET, disegard TYPE (which may
8177 : : be null) in favor of the type of the member, and set
8178 : : SIZE to the size of the accessed member. */
8179 : 19760 : offset = bitoffset.to_uhwi ();
8180 : 19760 : type = TREE_TYPE (cval);
8181 : 19760 : size = (bitoffset_end - bitoffset).to_uhwi ();
8182 : : }
8183 : :
8184 : : /* We do have overlap. Now see if the field is large enough
8185 : : to cover the access. Give up for accesses that extend
8186 : : beyond the end of the object or that span multiple fields. */
8187 : 52438 : if (wi::cmps (access_end, bitoffset_end) > 0)
8188 : : return NULL_TREE;
8189 : 50235 : if (offset < bitoffset)
8190 : : return NULL_TREE;
8191 : :
8192 : 50235 : offset_int inner_offset = offset_int (offset) - bitoffset;
8193 : :
8194 : : /* Integral bit-fields are left-justified on big-endian targets, so
8195 : : we must arrange for native_encode_int to start at their MSB. */
8196 : 50235 : if (DECL_BIT_FIELD (cfield) && INTEGRAL_TYPE_P (TREE_TYPE (cfield)))
8197 : : {
8198 : 611 : if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN)
8199 : : return NULL_TREE;
8200 : 611 : const unsigned int encoding_size
8201 : 611 : = GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (cfield)));
8202 : 611 : if (BYTES_BIG_ENDIAN)
8203 : : inner_offset += encoding_size - wi::to_offset (field_size);
8204 : : }
8205 : :
8206 : 50235 : return fold_ctor_reference (type, cval,
8207 : 50235 : inner_offset.to_uhwi (), size,
8208 : : from_decl, suboff);
8209 : : }
8210 : : }
8211 : :
8212 : 11407 : if (!type)
8213 : : return NULL_TREE;
8214 : :
8215 : 11407 : return build_zero_cst (type);
8216 : : }
8217 : :
8218 : : /* CTOR is a value initializing memory. Fold a reference of TYPE and
8219 : : bit size POLY_SIZE to the memory at bit POLY_OFFSET. When POLY_SIZE
8220 : : is zero, attempt to fold a reference to the entire subobject
8221 : : which OFFSET refers to. This is used when folding accesses to
8222 : : string members of aggregates. When non-null, set *SUBOFF to
8223 : : the bit offset of the accessed subobject. */
8224 : :
8225 : : tree
8226 : 1447084 : fold_ctor_reference (tree type, tree ctor, const poly_uint64 &poly_offset,
8227 : : const poly_uint64 &poly_size, tree from_decl,
8228 : : unsigned HOST_WIDE_INT *suboff /* = NULL */)
8229 : : {
8230 : 1447084 : tree ret;
8231 : :
8232 : : /* We found the field with exact match. */
8233 : 1447084 : if (type
8234 : 1447084 : && useless_type_conversion_p (type, TREE_TYPE (ctor))
8235 : 2058087 : && known_eq (poly_offset, 0U))
8236 : 609801 : return canonicalize_constructor_val (unshare_expr (ctor), from_decl);
8237 : :
8238 : : /* The remaining optimizations need a constant size and offset. */
8239 : 837283 : unsigned HOST_WIDE_INT size, offset;
8240 : 837283 : if (!poly_size.is_constant (&size) || !poly_offset.is_constant (&offset))
8241 : : return NULL_TREE;
8242 : :
8243 : : /* We are at the end of walk, see if we can view convert the
8244 : : result. */
8245 : 837283 : if (!AGGREGATE_TYPE_P (TREE_TYPE (ctor)) && !offset
8246 : : /* VIEW_CONVERT_EXPR is defined only for matching sizes. */
8247 : 21980 : && known_eq (wi::to_poly_widest (TYPE_SIZE (type)), size)
8248 : 21873 : && known_eq (wi::to_poly_widest (TYPE_SIZE (TREE_TYPE (ctor))), size))
8249 : : {
8250 : 13827 : ret = canonicalize_constructor_val (unshare_expr (ctor), from_decl);
8251 : 13827 : if (ret)
8252 : : {
8253 : 13827 : ret = fold_unary (VIEW_CONVERT_EXPR, type, ret);
8254 : 13827 : if (ret)
8255 : 13827 : STRIP_USELESS_TYPE_CONVERSION (ret);
8256 : : }
8257 : 13827 : return ret;
8258 : : }
8259 : :
8260 : : /* For constants and byte-aligned/sized reads, try to go through
8261 : : native_encode/interpret. */
8262 : 823456 : if (CONSTANT_CLASS_P (ctor)
8263 : : && BITS_PER_UNIT == 8
8264 : 131016 : && offset % BITS_PER_UNIT == 0
8265 : 131012 : && offset / BITS_PER_UNIT <= INT_MAX
8266 : 130980 : && size % BITS_PER_UNIT == 0
8267 : 130971 : && size <= MAX_BITSIZE_MODE_ANY_MODE
8268 : 954137 : && can_native_interpret_type_p (type))
8269 : : {
8270 : 85058 : unsigned char buf[MAX_BITSIZE_MODE_ANY_MODE / BITS_PER_UNIT];
8271 : 170116 : int len = native_encode_expr (ctor, buf, size / BITS_PER_UNIT,
8272 : 85058 : offset / BITS_PER_UNIT);
8273 : 85058 : if (len > 0)
8274 : 84314 : return native_interpret_expr (type, buf, len);
8275 : : }
8276 : :
8277 : : /* For constructors, try first a recursive local processing, but in any case
8278 : : this requires the native storage order. */
8279 : 739142 : if (TREE_CODE (ctor) == CONSTRUCTOR
8280 : 739142 : && !(AGGREGATE_TYPE_P (TREE_TYPE (ctor))
8281 : 691866 : && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (ctor))))
8282 : : {
8283 : 691636 : unsigned HOST_WIDE_INT dummy = 0;
8284 : 691636 : if (!suboff)
8285 : 579301 : suboff = &dummy;
8286 : :
8287 : 691636 : tree ret;
8288 : 691636 : if (TREE_CODE (TREE_TYPE (ctor)) == ARRAY_TYPE
8289 : 691636 : || TREE_CODE (TREE_TYPE (ctor)) == VECTOR_TYPE)
8290 : 627791 : ret = fold_array_ctor_reference (type, ctor, offset, size,
8291 : : from_decl, suboff);
8292 : : else
8293 : 63845 : ret = fold_nonarray_ctor_reference (type, ctor, offset, size,
8294 : : from_decl, suboff);
8295 : :
8296 : : /* Otherwise fall back to native_encode_initializer. This may be done
8297 : : only from the outermost fold_ctor_reference call (because it itself
8298 : : recurses into CONSTRUCTORs and doesn't update suboff). */
8299 : 691636 : if (ret == NULL_TREE
8300 : 246384 : && suboff == &dummy
8301 : : && BITS_PER_UNIT == 8
8302 : 245454 : && offset % BITS_PER_UNIT == 0
8303 : 244750 : && offset / BITS_PER_UNIT <= INT_MAX
8304 : 244750 : && size % BITS_PER_UNIT == 0
8305 : 244039 : && size <= MAX_BITSIZE_MODE_ANY_MODE
8306 : 934244 : && can_native_interpret_type_p (type))
8307 : : {
8308 : 212045 : unsigned char buf[MAX_BITSIZE_MODE_ANY_MODE / BITS_PER_UNIT];
8309 : 424090 : int len = native_encode_initializer (ctor, buf, size / BITS_PER_UNIT,
8310 : 212045 : offset / BITS_PER_UNIT);
8311 : 212045 : if (len > 0)
8312 : 965 : return native_interpret_expr (type, buf, len);
8313 : : }
8314 : :
8315 : 690671 : return ret;
8316 : : }
8317 : :
8318 : : return NULL_TREE;
8319 : : }
8320 : :
8321 : : /* Return the tree representing the element referenced by T if T is an
8322 : : ARRAY_REF or COMPONENT_REF into constant aggregates valuezing SSA
8323 : : names using VALUEIZE. Return NULL_TREE otherwise. */
8324 : :
8325 : : tree
8326 : 121196530 : fold_const_aggregate_ref_1 (tree t, tree (*valueize) (tree))
8327 : : {
8328 : 121196530 : tree ctor, idx, base;
8329 : 121196530 : poly_int64 offset, size, max_size;
8330 : 121196530 : tree tem;
8331 : 121196530 : bool reverse;
8332 : :
8333 : 121196530 : if (TREE_THIS_VOLATILE (t))
8334 : : return NULL_TREE;
8335 : :
8336 : 120801559 : if (DECL_P (t))
8337 : 286741 : return get_symbol_constant_value (t);
8338 : :
8339 : 120514818 : tem = fold_read_from_constant_string (t);
8340 : 120514818 : if (tem)
8341 : : return tem;
8342 : :
8343 : 120512335 : switch (TREE_CODE (t))
8344 : : {
8345 : 9046707 : case ARRAY_REF:
8346 : 9046707 : case ARRAY_RANGE_REF:
8347 : : /* Constant indexes are handled well by get_base_constructor.
8348 : : Only special case variable offsets.
8349 : : FIXME: This code can't handle nested references with variable indexes
8350 : : (they will be handled only by iteration of ccp). Perhaps we can bring
8351 : : get_ref_base_and_extent here and make it use a valueize callback. */
8352 : 9046707 : if (TREE_CODE (TREE_OPERAND (t, 1)) == SSA_NAME
8353 : 5063925 : && valueize
8354 : 3313678 : && (idx = (*valueize) (TREE_OPERAND (t, 1)))
8355 : 12360385 : && poly_int_tree_p (idx))
8356 : : {
8357 : 1420341 : tree low_bound, unit_size;
8358 : :
8359 : : /* If the resulting bit-offset is constant, track it. */
8360 : 1420341 : if ((low_bound = array_ref_low_bound (t),
8361 : 1420341 : poly_int_tree_p (low_bound))
8362 : 1420341 : && (unit_size = array_ref_element_size (t),
8363 : 1420341 : tree_fits_uhwi_p (unit_size)))
8364 : : {
8365 : 1420341 : poly_offset_int woffset
8366 : 1420341 : = wi::sext (wi::to_poly_offset (idx)
8367 : 2840682 : - wi::to_poly_offset (low_bound),
8368 : 1420341 : TYPE_PRECISION (sizetype));
8369 : 1420341 : woffset *= tree_to_uhwi (unit_size);
8370 : 1420341 : woffset *= BITS_PER_UNIT;
8371 : 1420341 : if (woffset.to_shwi (&offset))
8372 : : {
8373 : 1420229 : base = TREE_OPERAND (t, 0);
8374 : 1420229 : ctor = get_base_constructor (base, &offset, valueize);
8375 : : /* Empty constructor. Always fold to 0. */
8376 : 1420229 : if (ctor == error_mark_node)
8377 : 1420229 : return build_zero_cst (TREE_TYPE (t));
8378 : : /* Out of bound array access. Value is undefined,
8379 : : but don't fold. */
8380 : 1420154 : if (maybe_lt (offset, 0))
8381 : : return NULL_TREE;
8382 : : /* We cannot determine ctor. */
8383 : 1419662 : if (!ctor)
8384 : : return NULL_TREE;
8385 : 138641 : return fold_ctor_reference (TREE_TYPE (t), ctor, offset,
8386 : 138641 : tree_to_uhwi (unit_size)
8387 : 138641 : * BITS_PER_UNIT,
8388 : : base);
8389 : : }
8390 : : }
8391 : : }
8392 : : /* Fallthru. */
8393 : :
8394 : 114097531 : case COMPONENT_REF:
8395 : 114097531 : case BIT_FIELD_REF:
8396 : 114097531 : case TARGET_MEM_REF:
8397 : 114097531 : case MEM_REF:
8398 : 114097531 : base = get_ref_base_and_extent (t, &offset, &size, &max_size, &reverse);
8399 : 114097531 : ctor = get_base_constructor (base, &offset, valueize);
8400 : :
8401 : : /* Empty constructor. Always fold to 0. */
8402 : 114097531 : if (ctor == error_mark_node)
8403 : 963 : return build_zero_cst (TREE_TYPE (t));
8404 : : /* We do not know precise address. */
8405 : 114096568 : if (!known_size_p (max_size) || maybe_ne (max_size, size))
8406 : : return NULL_TREE;
8407 : : /* We cannot determine ctor. */
8408 : 107564582 : if (!ctor)
8409 : : return NULL_TREE;
8410 : :
8411 : : /* Out of bound array access. Value is undefined, but don't fold. */
8412 : 495590 : if (maybe_lt (offset, 0))
8413 : : return NULL_TREE;
8414 : :
8415 : 494111 : tem = fold_ctor_reference (TREE_TYPE (t), ctor, offset, size, base);
8416 : 494111 : if (tem)
8417 : : return tem;
8418 : :
8419 : : /* For bit field reads try to read the representative and
8420 : : adjust. */
8421 : 246813 : if (TREE_CODE (t) == COMPONENT_REF
8422 : 85 : && DECL_BIT_FIELD (TREE_OPERAND (t, 1))
8423 : 246897 : && DECL_BIT_FIELD_REPRESENTATIVE (TREE_OPERAND (t, 1)))
8424 : : {
8425 : 84 : HOST_WIDE_INT csize, coffset;
8426 : 84 : tree field = TREE_OPERAND (t, 1);
8427 : 84 : tree repr = DECL_BIT_FIELD_REPRESENTATIVE (field);
8428 : 168 : if (INTEGRAL_TYPE_P (TREE_TYPE (repr))
8429 : 83 : && size.is_constant (&csize)
8430 : 83 : && offset.is_constant (&coffset)
8431 : 83 : && (coffset % BITS_PER_UNIT != 0
8432 : 81 : || csize % BITS_PER_UNIT != 0)
8433 : 10 : && !reverse
8434 : 84 : && BYTES_BIG_ENDIAN == WORDS_BIG_ENDIAN)
8435 : : {
8436 : 10 : poly_int64 bitoffset;
8437 : 10 : poly_uint64 field_offset, repr_offset;
8438 : 10 : if (poly_int_tree_p (DECL_FIELD_OFFSET (field), &field_offset)
8439 : 20 : && poly_int_tree_p (DECL_FIELD_OFFSET (repr), &repr_offset))
8440 : 10 : bitoffset = (field_offset - repr_offset) * BITS_PER_UNIT;
8441 : : else
8442 : : bitoffset = 0;
8443 : 10 : bitoffset += (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field))
8444 : 10 : - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr)));
8445 : 10 : HOST_WIDE_INT bitoff;
8446 : 10 : int diff = (TYPE_PRECISION (TREE_TYPE (repr))
8447 : 10 : - TYPE_PRECISION (TREE_TYPE (field)));
8448 : 10 : if (bitoffset.is_constant (&bitoff)
8449 : 10 : && bitoff >= 0
8450 : 10 : && bitoff <= diff)
8451 : : {
8452 : 10 : offset -= bitoff;
8453 : 10 : size = tree_to_uhwi (DECL_SIZE (repr));
8454 : :
8455 : 10 : tem = fold_ctor_reference (TREE_TYPE (repr), ctor, offset,
8456 : : size, base);
8457 : 10 : if (tem && TREE_CODE (tem) == INTEGER_CST)
8458 : : {
8459 : 10 : if (!BYTES_BIG_ENDIAN)
8460 : 10 : tem = wide_int_to_tree (TREE_TYPE (field),
8461 : 10 : wi::lrshift (wi::to_wide (tem),
8462 : : bitoff));
8463 : : else
8464 : : tem = wide_int_to_tree (TREE_TYPE (field),
8465 : : wi::lrshift (wi::to_wide (tem),
8466 : : diff - bitoff));
8467 : 10 : return tem;
8468 : : }
8469 : : }
8470 : : }
8471 : : }
8472 : : break;
8473 : :
8474 : 1559297 : case REALPART_EXPR:
8475 : 1559297 : case IMAGPART_EXPR:
8476 : 1559297 : {
8477 : 1559297 : tree c = fold_const_aggregate_ref_1 (TREE_OPERAND (t, 0), valueize);
8478 : 1559297 : if (c && TREE_CODE (c) == COMPLEX_CST)
8479 : 2556 : return fold_build1_loc (EXPR_LOCATION (t),
8480 : 5112 : TREE_CODE (t), TREE_TYPE (t), c);
8481 : : break;
8482 : : }
8483 : :
8484 : : default:
8485 : : break;
8486 : : }
8487 : :
8488 : : return NULL_TREE;
8489 : : }
8490 : :
8491 : : tree
8492 : 56618477 : fold_const_aggregate_ref (tree t)
8493 : : {
8494 : 56618477 : return fold_const_aggregate_ref_1 (t, NULL);
8495 : : }
8496 : :
8497 : : /* Lookup virtual method with index TOKEN in a virtual table V
8498 : : at OFFSET.
8499 : : Set CAN_REFER if non-NULL to false if method
8500 : : is not referable or if the virtual table is ill-formed (such as rewriten
8501 : : by non-C++ produced symbol). Otherwise just return NULL in that calse. */
8502 : :
8503 : : tree
8504 : 296241 : gimple_get_virt_method_for_vtable (HOST_WIDE_INT token,
8505 : : tree v,
8506 : : unsigned HOST_WIDE_INT offset,
8507 : : bool *can_refer)
8508 : : {
8509 : 296241 : tree vtable = v, init, fn;
8510 : 296241 : unsigned HOST_WIDE_INT size;
8511 : 296241 : unsigned HOST_WIDE_INT elt_size, access_index;
8512 : 296241 : tree domain_type;
8513 : :
8514 : 296241 : if (can_refer)
8515 : 296241 : *can_refer = true;
8516 : :
8517 : : /* First of all double check we have virtual table. */
8518 : 296241 : if (!VAR_P (v) || !DECL_VIRTUAL_P (v))
8519 : : {
8520 : : /* Pass down that we lost track of the target. */
8521 : 0 : if (can_refer)
8522 : 0 : *can_refer = false;
8523 : 0 : return NULL_TREE;
8524 : : }
8525 : :
8526 : 296241 : init = ctor_for_folding (v);
8527 : :
8528 : : /* The virtual tables should always be born with constructors
8529 : : and we always should assume that they are avaialble for
8530 : : folding. At the moment we do not stream them in all cases,
8531 : : but it should never happen that ctor seem unreachable. */
8532 : 296241 : gcc_assert (init);
8533 : 296241 : if (init == error_mark_node)
8534 : : {
8535 : : /* Pass down that we lost track of the target. */
8536 : 160 : if (can_refer)
8537 : 160 : *can_refer = false;
8538 : 160 : return NULL_TREE;
8539 : : }
8540 : 296081 : gcc_checking_assert (TREE_CODE (TREE_TYPE (v)) == ARRAY_TYPE);
8541 : 296081 : size = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (v))));
8542 : 296081 : offset *= BITS_PER_UNIT;
8543 : 296081 : offset += token * size;
8544 : :
8545 : : /* Lookup the value in the constructor that is assumed to be array.
8546 : : This is equivalent to
8547 : : fn = fold_ctor_reference (TREE_TYPE (TREE_TYPE (v)), init,
8548 : : offset, size, NULL);
8549 : : but in a constant time. We expect that frontend produced a simple
8550 : : array without indexed initializers. */
8551 : :
8552 : 296081 : gcc_checking_assert (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE);
8553 : 296081 : domain_type = TYPE_DOMAIN (TREE_TYPE (init));
8554 : 296081 : gcc_checking_assert (integer_zerop (TYPE_MIN_VALUE (domain_type)));
8555 : 296081 : elt_size = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (init))));
8556 : :
8557 : 296081 : access_index = offset / BITS_PER_UNIT / elt_size;
8558 : 296081 : gcc_checking_assert (offset % (elt_size * BITS_PER_UNIT) == 0);
8559 : :
8560 : : /* The C++ FE can now produce indexed fields, and we check if the indexes
8561 : : match. */
8562 : 592162 : if (access_index < CONSTRUCTOR_NELTS (init))
8563 : : {
8564 : 296080 : fn = CONSTRUCTOR_ELT (init, access_index)->value;
8565 : 296080 : tree idx = CONSTRUCTOR_ELT (init, access_index)->index;
8566 : 296080 : gcc_checking_assert (!idx || tree_to_uhwi (idx) == access_index);
8567 : 296080 : STRIP_NOPS (fn);
8568 : : }
8569 : : else
8570 : : fn = NULL;
8571 : :
8572 : : /* For type inconsistent program we may end up looking up virtual method
8573 : : in virtual table that does not contain TOKEN entries. We may overrun
8574 : : the virtual table and pick up a constant or RTTI info pointer.
8575 : : In any case the call is undefined. */
8576 : 296080 : if (!fn
8577 : 296080 : || (TREE_CODE (fn) != ADDR_EXPR && TREE_CODE (fn) != FDESC_EXPR)
8578 : 585691 : || TREE_CODE (TREE_OPERAND (fn, 0)) != FUNCTION_DECL)
8579 : 6470 : fn = builtin_decl_unreachable ();
8580 : : else
8581 : : {
8582 : 289611 : fn = TREE_OPERAND (fn, 0);
8583 : :
8584 : : /* When cgraph node is missing and function is not public, we cannot
8585 : : devirtualize. This can happen in WHOPR when the actual method
8586 : : ends up in other partition, because we found devirtualization
8587 : : possibility too late. */
8588 : 289611 : if (!can_refer_decl_in_current_unit_p (fn, vtable))
8589 : : {
8590 : 45490 : if (can_refer)
8591 : : {
8592 : 45490 : *can_refer = false;
8593 : 45490 : return fn;
8594 : : }
8595 : : return NULL_TREE;
8596 : : }
8597 : : }
8598 : :
8599 : : /* Make sure we create a cgraph node for functions we'll reference.
8600 : : They can be non-existent if the reference comes from an entry
8601 : : of an external vtable for example. */
8602 : 250591 : cgraph_node::get_create (fn);
8603 : :
8604 : 250591 : return fn;
8605 : : }
8606 : :
8607 : : /* Return a declaration of a function which an OBJ_TYPE_REF references. TOKEN
8608 : : is integer form of OBJ_TYPE_REF_TOKEN of the reference expression.
8609 : : KNOWN_BINFO carries the binfo describing the true type of
8610 : : OBJ_TYPE_REF_OBJECT(REF).
8611 : : Set CAN_REFER if non-NULL to false if method
8612 : : is not referable or if the virtual table is ill-formed (such as rewriten
8613 : : by non-C++ produced symbol). Otherwise just return NULL in that calse. */
8614 : :
8615 : : tree
8616 : 283966 : gimple_get_virt_method_for_binfo (HOST_WIDE_INT token, tree known_binfo,
8617 : : bool *can_refer)
8618 : : {
8619 : 283966 : unsigned HOST_WIDE_INT offset;
8620 : 283966 : tree v;
8621 : :
8622 : 283966 : v = BINFO_VTABLE (known_binfo);
8623 : : /* If there is no virtual methods table, leave the OBJ_TYPE_REF alone. */
8624 : 283966 : if (!v)
8625 : : return NULL_TREE;
8626 : :
8627 : 283966 : if (!vtable_pointer_value_to_vtable (v, &v, &offset))
8628 : : {
8629 : 0 : if (can_refer)
8630 : 0 : *can_refer = false;
8631 : 0 : return NULL_TREE;
8632 : : }
8633 : 283966 : return gimple_get_virt_method_for_vtable (token, v, offset, can_refer);
8634 : : }
8635 : :
8636 : : /* Given a pointer value T, return a simplified version of an
8637 : : indirection through T, or NULL_TREE if no simplification is
8638 : : possible. Note that the resulting type may be different from
8639 : : the type pointed to in the sense that it is still compatible
8640 : : from the langhooks point of view. */
8641 : :
8642 : : tree
8643 : 1908011 : gimple_fold_indirect_ref (tree t)
8644 : : {
8645 : 1908011 : tree ptype = TREE_TYPE (t), type = TREE_TYPE (ptype);
8646 : 1908011 : tree sub = t;
8647 : 1908011 : tree subtype;
8648 : :
8649 : 1908011 : STRIP_NOPS (sub);
8650 : 1908011 : subtype = TREE_TYPE (sub);
8651 : 1908011 : if (!POINTER_TYPE_P (subtype)
8652 : 1908011 : || TYPE_REF_CAN_ALIAS_ALL (ptype))
8653 : : return NULL_TREE;
8654 : :
8655 : 1906270 : if (TREE_CODE (sub) == ADDR_EXPR)
8656 : : {
8657 : 83667 : tree op = TREE_OPERAND (sub, 0);
8658 : 83667 : tree optype = TREE_TYPE (op);
8659 : : /* *&p => p */
8660 : 83667 : if (useless_type_conversion_p (type, optype))
8661 : : return op;
8662 : :
8663 : : /* *(foo *)&fooarray => fooarray[0] */
8664 : 824 : if (TREE_CODE (optype) == ARRAY_TYPE
8665 : 235 : && TREE_CODE (TYPE_SIZE (TREE_TYPE (optype))) == INTEGER_CST
8666 : 1059 : && useless_type_conversion_p (type, TREE_TYPE (optype)))
8667 : : {
8668 : 45 : tree type_domain = TYPE_DOMAIN (optype);
8669 : 45 : tree min_val = size_zero_node;
8670 : 45 : if (type_domain && TYPE_MIN_VALUE (type_domain))
8671 : 45 : min_val = TYPE_MIN_VALUE (type_domain);
8672 : 45 : if (TREE_CODE (min_val) == INTEGER_CST)
8673 : 45 : return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
8674 : : }
8675 : : /* *(foo *)&complexfoo => __real__ complexfoo */
8676 : 779 : else if (TREE_CODE (optype) == COMPLEX_TYPE
8677 : 779 : && useless_type_conversion_p (type, TREE_TYPE (optype)))
8678 : 4 : return fold_build1 (REALPART_EXPR, type, op);
8679 : : /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
8680 : 775 : else if (TREE_CODE (optype) == VECTOR_TYPE
8681 : 775 : && useless_type_conversion_p (type, TREE_TYPE (optype)))
8682 : : {
8683 : 26 : tree part_width = TYPE_SIZE (type);
8684 : 26 : tree index = bitsize_int (0);
8685 : 26 : return fold_build3 (BIT_FIELD_REF, type, op, part_width, index);
8686 : : }
8687 : : }
8688 : :
8689 : : /* *(p + CST) -> ... */
8690 : 1823352 : if (TREE_CODE (sub) == POINTER_PLUS_EXPR
8691 : 1823352 : && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
8692 : : {
8693 : 35494 : tree addr = TREE_OPERAND (sub, 0);
8694 : 35494 : tree off = TREE_OPERAND (sub, 1);
8695 : 35494 : tree addrtype;
8696 : :
8697 : 35494 : STRIP_NOPS (addr);
8698 : 35494 : addrtype = TREE_TYPE (addr);
8699 : :
8700 : : /* ((foo*)&vectorfoo)[1] -> BIT_FIELD_REF<vectorfoo,...> */
8701 : 35494 : if (TREE_CODE (addr) == ADDR_EXPR
8702 : 92 : && TREE_CODE (TREE_TYPE (addrtype)) == VECTOR_TYPE
8703 : 38 : && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (addrtype)))
8704 : 35522 : && tree_fits_uhwi_p (off))
8705 : : {
8706 : 28 : unsigned HOST_WIDE_INT offset = tree_to_uhwi (off);
8707 : 28 : tree part_width = TYPE_SIZE (type);
8708 : 28 : unsigned HOST_WIDE_INT part_widthi
8709 : 28 : = tree_to_shwi (part_width) / BITS_PER_UNIT;
8710 : 28 : unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
8711 : 28 : tree index = bitsize_int (indexi);
8712 : 28 : if (known_lt (offset / part_widthi,
8713 : : TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype))))
8714 : 28 : return fold_build3 (BIT_FIELD_REF, type, TREE_OPERAND (addr, 0),
8715 : : part_width, index);
8716 : : }
8717 : :
8718 : : /* ((foo*)&complexfoo)[1] -> __imag__ complexfoo */
8719 : 35466 : if (TREE_CODE (addr) == ADDR_EXPR
8720 : 64 : && TREE_CODE (TREE_TYPE (addrtype)) == COMPLEX_TYPE
8721 : 35467 : && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (addrtype))))
8722 : : {
8723 : 1 : tree size = TYPE_SIZE_UNIT (type);
8724 : 1 : if (tree_int_cst_equal (size, off))
8725 : 1 : return fold_build1 (IMAGPART_EXPR, type, TREE_OPERAND (addr, 0));
8726 : : }
8727 : :
8728 : : /* *(p + CST) -> MEM_REF <p, CST>. */
8729 : 35465 : if (TREE_CODE (addr) != ADDR_EXPR
8730 : 35465 : || DECL_P (TREE_OPERAND (addr, 0)))
8731 : 35446 : return fold_build2 (MEM_REF, type,
8732 : : addr,
8733 : : wide_int_to_tree (ptype, wi::to_wide (off)));
8734 : : }
8735 : :
8736 : : /* *(foo *)fooarrptr => (*fooarrptr)[0] */
8737 : 1787877 : if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
8738 : 1952 : && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (subtype)))) == INTEGER_CST
8739 : 1789810 : && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (subtype))))
8740 : : {
8741 : 1 : tree type_domain;
8742 : 1 : tree min_val = size_zero_node;
8743 : 1 : tree osub = sub;
8744 : 1 : sub = gimple_fold_indirect_ref (sub);
8745 : 1 : if (! sub)
8746 : 1 : sub = build1 (INDIRECT_REF, TREE_TYPE (subtype), osub);
8747 : 1 : type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
8748 : 1 : if (type_domain && TYPE_MIN_VALUE (type_domain))
8749 : 1 : min_val = TYPE_MIN_VALUE (type_domain);
8750 : 1 : if (TREE_CODE (min_val) == INTEGER_CST)
8751 : 1 : return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
8752 : : }
8753 : :
8754 : : return NULL_TREE;
8755 : : }
8756 : :
8757 : : /* Return true if CODE is an operation that when operating on signed
8758 : : integer types involves undefined behavior on overflow and the
8759 : : operation can be expressed with unsigned arithmetic. */
8760 : :
8761 : : bool
8762 : 355248 : arith_code_with_undefined_signed_overflow (tree_code code)
8763 : : {
8764 : 355248 : switch (code)
8765 : : {
8766 : : case ABS_EXPR:
8767 : : case PLUS_EXPR:
8768 : : case MINUS_EXPR:
8769 : : case MULT_EXPR:
8770 : : case NEGATE_EXPR:
8771 : : case POINTER_PLUS_EXPR:
8772 : : return true;
8773 : 273233 : default:
8774 : 273233 : return false;
8775 : : }
8776 : : }
8777 : :
8778 : : /* Rewrite STMT, an assignment with a signed integer or pointer arithmetic
8779 : : operation that can be transformed to unsigned arithmetic by converting
8780 : : its operand, carrying out the operation in the corresponding unsigned
8781 : : type and converting the result back to the original type.
8782 : :
8783 : : If IN_PLACE is true, *GSI points to STMT, adjust the stmt in place and
8784 : : return NULL.
8785 : : Otherwise returns a sequence of statements that replace STMT and also
8786 : : contain a modified form of STMT itself. */
8787 : :
8788 : : static gimple_seq
8789 : 36901 : rewrite_to_defined_overflow (gimple_stmt_iterator *gsi, gimple *stmt,
8790 : : bool in_place)
8791 : : {
8792 : 36901 : if (dump_file && (dump_flags & TDF_DETAILS))
8793 : : {
8794 : 16 : fprintf (dump_file, "rewriting stmt with undefined signed "
8795 : : "overflow ");
8796 : 16 : print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
8797 : : }
8798 : :
8799 : 36901 : tree lhs = gimple_assign_lhs (stmt);
8800 : 36901 : tree type = unsigned_type_for (TREE_TYPE (lhs));
8801 : 36901 : gimple_seq stmts = NULL;
8802 : 36901 : if (gimple_assign_rhs_code (stmt) == ABS_EXPR)
8803 : 11 : gimple_assign_set_rhs_code (stmt, ABSU_EXPR);
8804 : : else
8805 : 109823 : for (unsigned i = 1; i < gimple_num_ops (stmt); ++i)
8806 : : {
8807 : 72933 : tree op = gimple_op (stmt, i);
8808 : 72933 : op = gimple_convert (&stmts, type, op);
8809 : 72933 : gimple_set_op (stmt, i, op);
8810 : : }
8811 : 36901 : gimple_assign_set_lhs (stmt, make_ssa_name (type, stmt));
8812 : 36901 : if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
8813 : 2472 : gimple_assign_set_rhs_code (stmt, PLUS_EXPR);
8814 : 36901 : gimple_set_modified (stmt, true);
8815 : 36901 : if (in_place)
8816 : : {
8817 : 18134 : if (stmts)
8818 : 8684 : gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT);
8819 : 18134 : stmts = NULL;
8820 : : }
8821 : : else
8822 : 18767 : gimple_seq_add_stmt (&stmts, stmt);
8823 : 36901 : gimple *cvt = gimple_build_assign (lhs, NOP_EXPR, gimple_assign_lhs (stmt));
8824 : 36901 : if (in_place)
8825 : : {
8826 : 18134 : gsi_insert_after (gsi, cvt, GSI_SAME_STMT);
8827 : 18134 : update_stmt (stmt);
8828 : : }
8829 : : else
8830 : 18767 : gimple_seq_add_stmt (&stmts, cvt);
8831 : :
8832 : 36901 : return stmts;
8833 : : }
8834 : :
8835 : : void
8836 : 18134 : rewrite_to_defined_overflow (gimple_stmt_iterator *gsi)
8837 : : {
8838 : 18134 : rewrite_to_defined_overflow (gsi, gsi_stmt (*gsi), true);
8839 : 18134 : }
8840 : :
8841 : : gimple_seq
8842 : 18767 : rewrite_to_defined_overflow (gimple *stmt)
8843 : : {
8844 : 18767 : return rewrite_to_defined_overflow (nullptr, stmt, false);
8845 : : }
8846 : :
8847 : : /* The valueization hook we use for the gimple_build API simplification.
8848 : : This makes us match fold_buildN behavior by only combining with
8849 : : statements in the sequence(s) we are currently building. */
8850 : :
8851 : : static tree
8852 : 15003911 : gimple_build_valueize (tree op)
8853 : : {
8854 : 15003911 : if (gimple_bb (SSA_NAME_DEF_STMT (op)) == NULL)
8855 : 3134183 : return op;
8856 : : return NULL_TREE;
8857 : : }
8858 : :
8859 : : /* Helper for gimple_build to perform the final insertion of stmts on SEQ. */
8860 : :
8861 : : static inline void
8862 : 1172960 : gimple_build_insert_seq (gimple_stmt_iterator *gsi,
8863 : : bool before, gsi_iterator_update update,
8864 : : gimple_seq seq)
8865 : : {
8866 : 1172960 : if (before)
8867 : : {
8868 : 49149 : if (gsi->bb)
8869 : 49149 : gsi_insert_seq_before (gsi, seq, update);
8870 : : else
8871 : 0 : gsi_insert_seq_before_without_update (gsi, seq, update);
8872 : : }
8873 : : else
8874 : : {
8875 : 1123811 : if (gsi->bb)
8876 : 15 : gsi_insert_seq_after (gsi, seq, update);
8877 : : else
8878 : 1123796 : gsi_insert_seq_after_without_update (gsi, seq, update);
8879 : : }
8880 : 1172960 : }
8881 : :
8882 : : /* Build the expression CODE OP0 of type TYPE with location LOC,
8883 : : simplifying it first if possible. Returns the built
8884 : : expression value and inserts statements possibly defining it
8885 : : before GSI if BEFORE is true or after GSI if false and advance
8886 : : the iterator accordingly.
8887 : : If gsi refers to a basic block simplifying is allowed to look
8888 : : at all SSA defs while when it does not it is restricted to
8889 : : SSA defs that are not associated with a basic block yet,
8890 : : indicating they belong to the currently building sequence. */
8891 : :
8892 : : tree
8893 : 249404 : gimple_build (gimple_stmt_iterator *gsi,
8894 : : bool before, gsi_iterator_update update,
8895 : : location_t loc, enum tree_code code, tree type, tree op0)
8896 : : {
8897 : 249404 : gimple_seq seq = NULL;
8898 : 249404 : tree res
8899 : 249404 : = gimple_simplify (code, type, op0, &seq,
8900 : 249404 : gsi->bb ? follow_all_ssa_edges : gimple_build_valueize);
8901 : 249404 : if (!res)
8902 : : {
8903 : 228821 : res = create_tmp_reg_or_ssa_name (type);
8904 : 228821 : gimple *stmt;
8905 : 228821 : if (code == REALPART_EXPR
8906 : : || code == IMAGPART_EXPR
8907 : 228821 : || code == VIEW_CONVERT_EXPR)
8908 : 12246 : stmt = gimple_build_assign (res, code, build1 (code, type, op0));
8909 : : else
8910 : 216575 : stmt = gimple_build_assign (res, code, op0);
8911 : 228821 : gimple_set_location (stmt, loc);
8912 : 228821 : gimple_seq_add_stmt_without_update (&seq, stmt);
8913 : : }
8914 : 249404 : gimple_build_insert_seq (gsi, before, update, seq);
8915 : 249404 : return res;
8916 : : }
8917 : :
8918 : : /* Build the expression OP0 CODE OP1 of type TYPE with location LOC,
8919 : : simplifying it first if possible. Returns the built
8920 : : expression value inserting any new statements at GSI honoring BEFORE
8921 : : and UPDATE. */
8922 : :
8923 : : tree
8924 : 695840 : gimple_build (gimple_stmt_iterator *gsi,
8925 : : bool before, gsi_iterator_update update,
8926 : : location_t loc, enum tree_code code, tree type,
8927 : : tree op0, tree op1)
8928 : : {
8929 : 695840 : gimple_seq seq = NULL;
8930 : 695840 : tree res
8931 : 695840 : = gimple_simplify (code, type, op0, op1, &seq,
8932 : 695840 : gsi->bb ? follow_all_ssa_edges : gimple_build_valueize);
8933 : 695840 : if (!res)
8934 : : {
8935 : 592631 : res = create_tmp_reg_or_ssa_name (type);
8936 : 592631 : gimple *stmt = gimple_build_assign (res, code, op0, op1);
8937 : 592631 : gimple_set_location (stmt, loc);
8938 : 592631 : gimple_seq_add_stmt_without_update (&seq, stmt);
8939 : : }
8940 : 695840 : gimple_build_insert_seq (gsi, before, update, seq);
8941 : 695840 : return res;
8942 : : }
8943 : :
8944 : : /* Build the expression (CODE OP0 OP1 OP2) of type TYPE with location LOC,
8945 : : simplifying it first if possible. Returns the built
8946 : : expression value inserting any new statements at GSI honoring BEFORE
8947 : : and UPDATE. */
8948 : :
8949 : : tree
8950 : 47179 : gimple_build (gimple_stmt_iterator *gsi,
8951 : : bool before, gsi_iterator_update update,
8952 : : location_t loc, enum tree_code code, tree type,
8953 : : tree op0, tree op1, tree op2)
8954 : : {
8955 : :
8956 : 47179 : gimple_seq seq = NULL;
8957 : 47179 : tree res
8958 : 47179 : = gimple_simplify (code, type, op0, op1, op2, &seq,
8959 : 47179 : gsi->bb ? follow_all_ssa_edges : gimple_build_valueize);
8960 : 47179 : if (!res)
8961 : : {
8962 : 35138 : res = create_tmp_reg_or_ssa_name (type);
8963 : 35138 : gimple *stmt;
8964 : 35138 : if (code == BIT_FIELD_REF)
8965 : 27096 : stmt = gimple_build_assign (res, code,
8966 : : build3 (code, type, op0, op1, op2));
8967 : : else
8968 : 8042 : stmt = gimple_build_assign (res, code, op0, op1, op2);
8969 : 35138 : gimple_set_location (stmt, loc);
8970 : 35138 : gimple_seq_add_stmt_without_update (&seq, stmt);
8971 : : }
8972 : 47179 : gimple_build_insert_seq (gsi, before, update, seq);
8973 : 47179 : return res;
8974 : : }
8975 : :
8976 : : /* Build the call FN () with a result of type TYPE (or no result if TYPE is
8977 : : void) with a location LOC. Returns the built expression value (or NULL_TREE
8978 : : if TYPE is void) inserting any new statements at GSI honoring BEFORE
8979 : : and UPDATE. */
8980 : :
8981 : : tree
8982 : 0 : gimple_build (gimple_stmt_iterator *gsi,
8983 : : bool before, gsi_iterator_update update,
8984 : : location_t loc, combined_fn fn, tree type)
8985 : : {
8986 : 0 : tree res = NULL_TREE;
8987 : 0 : gimple_seq seq = NULL;
8988 : 0 : gcall *stmt;
8989 : 0 : if (internal_fn_p (fn))
8990 : 0 : stmt = gimple_build_call_internal (as_internal_fn (fn), 0);
8991 : : else
8992 : : {
8993 : 0 : tree decl = builtin_decl_implicit (as_builtin_fn (fn));
8994 : 0 : stmt = gimple_build_call (decl, 0);
8995 : : }
8996 : 0 : if (!VOID_TYPE_P (type))
8997 : : {
8998 : 0 : res = create_tmp_reg_or_ssa_name (type);
8999 : 0 : gimple_call_set_lhs (stmt, res);
9000 : : }
9001 : 0 : gimple_set_location (stmt, loc);
9002 : 0 : gimple_seq_add_stmt_without_update (&seq, stmt);
9003 : 0 : gimple_build_insert_seq (gsi, before, update, seq);
9004 : 0 : return res;
9005 : : }
9006 : :
9007 : : /* Build the call FN (ARG0) with a result of type TYPE
9008 : : (or no result if TYPE is void) with location LOC,
9009 : : simplifying it first if possible. Returns the built
9010 : : expression value (or NULL_TREE if TYPE is void) inserting any new
9011 : : statements at GSI honoring BEFORE and UPDATE. */
9012 : :
9013 : : tree
9014 : 19205 : gimple_build (gimple_stmt_iterator *gsi,
9015 : : bool before, gsi_iterator_update update,
9016 : : location_t loc, combined_fn fn,
9017 : : tree type, tree arg0)
9018 : : {
9019 : 19205 : gimple_seq seq = NULL;
9020 : 19205 : tree res = gimple_simplify (fn, type, arg0, &seq, gimple_build_valueize);
9021 : 19205 : if (!res)
9022 : : {
9023 : 19205 : gcall *stmt;
9024 : 19205 : if (internal_fn_p (fn))
9025 : 18822 : stmt = gimple_build_call_internal (as_internal_fn (fn), 1, arg0);
9026 : : else
9027 : : {
9028 : 383 : tree decl = builtin_decl_implicit (as_builtin_fn (fn));
9029 : 383 : stmt = gimple_build_call (decl, 1, arg0);
9030 : : }
9031 : 19205 : if (!VOID_TYPE_P (type))
9032 : : {
9033 : 18822 : res = create_tmp_reg_or_ssa_name (type);
9034 : 18822 : gimple_call_set_lhs (stmt, res);
9035 : : }
9036 : 19205 : gimple_set_location (stmt, loc);
9037 : 19205 : gimple_seq_add_stmt_without_update (&seq, stmt);
9038 : : }
9039 : 19205 : gimple_build_insert_seq (gsi, before, update, seq);
9040 : 19205 : return res;
9041 : : }
9042 : :
9043 : : /* Build the call FN (ARG0, ARG1) with a result of type TYPE
9044 : : (or no result if TYPE is void) with location LOC,
9045 : : simplifying it first if possible. Returns the built
9046 : : expression value (or NULL_TREE if TYPE is void) inserting any new
9047 : : statements at GSI honoring BEFORE and UPDATE. */
9048 : :
9049 : : tree
9050 : 0 : gimple_build (gimple_stmt_iterator *gsi,
9051 : : bool before, gsi_iterator_update update,
9052 : : location_t loc, combined_fn fn,
9053 : : tree type, tree arg0, tree arg1)
9054 : : {
9055 : 0 : gimple_seq seq = NULL;
9056 : 0 : tree res = gimple_simplify (fn, type, arg0, arg1, &seq,
9057 : : gimple_build_valueize);
9058 : 0 : if (!res)
9059 : : {
9060 : 0 : gcall *stmt;
9061 : 0 : if (internal_fn_p (fn))
9062 : 0 : stmt = gimple_build_call_internal (as_internal_fn (fn), 2, arg0, arg1);
9063 : : else
9064 : : {
9065 : 0 : tree decl = builtin_decl_implicit (as_builtin_fn (fn));
9066 : 0 : stmt = gimple_build_call (decl, 2, arg0, arg1);
9067 : : }
9068 : 0 : if (!VOID_TYPE_P (type))
9069 : : {
9070 : 0 : res = create_tmp_reg_or_ssa_name (type);
9071 : 0 : gimple_call_set_lhs (stmt, res);
9072 : : }
9073 : 0 : gimple_set_location (stmt, loc);
9074 : 0 : gimple_seq_add_stmt_without_update (&seq, stmt);
9075 : : }
9076 : 0 : gimple_build_insert_seq (gsi, before, update, seq);
9077 : 0 : return res;
9078 : : }
9079 : :
9080 : : /* Build the call FN (ARG0, ARG1, ARG2) with a result of type TYPE
9081 : : (or no result if TYPE is void) with location LOC,
9082 : : simplifying it first if possible. Returns the built
9083 : : expression value (or NULL_TREE if TYPE is void) inserting any new
9084 : : statements at GSI honoring BEFORE and UPDATE. */
9085 : :
9086 : : tree
9087 : 0 : gimple_build (gimple_stmt_iterator *gsi,
9088 : : bool before, gsi_iterator_update update,
9089 : : location_t loc, combined_fn fn,
9090 : : tree type, tree arg0, tree arg1, tree arg2)
9091 : : {
9092 : 0 : gimple_seq seq = NULL;
9093 : 0 : tree res = gimple_simplify (fn, type, arg0, arg1, arg2,
9094 : : &seq, gimple_build_valueize);
9095 : 0 : if (!res)
9096 : : {
9097 : 0 : gcall *stmt;
9098 : 0 : if (internal_fn_p (fn))
9099 : 0 : stmt = gimple_build_call_internal (as_internal_fn (fn),
9100 : : 3, arg0, arg1, arg2);
9101 : : else
9102 : : {
9103 : 0 : tree decl = builtin_decl_implicit (as_builtin_fn (fn));
9104 : 0 : stmt = gimple_build_call (decl, 3, arg0, arg1, arg2);
9105 : : }
9106 : 0 : if (!VOID_TYPE_P (type))
9107 : : {
9108 : 0 : res = create_tmp_reg_or_ssa_name (type);
9109 : 0 : gimple_call_set_lhs (stmt, res);
9110 : : }
9111 : 0 : gimple_set_location (stmt, loc);
9112 : 0 : gimple_seq_add_stmt_without_update (&seq, stmt);
9113 : : }
9114 : 0 : gimple_build_insert_seq (gsi, before, update, seq);
9115 : 0 : return res;
9116 : : }
9117 : :
9118 : : /* Build CODE (OP0) with a result of type TYPE (or no result if TYPE is
9119 : : void) with location LOC, simplifying it first if possible. Returns the
9120 : : built expression value (or NULL_TREE if TYPE is void) inserting any new
9121 : : statements at GSI honoring BEFORE and UPDATE. */
9122 : :
9123 : : tree
9124 : 0 : gimple_build (gimple_stmt_iterator *gsi,
9125 : : bool before, gsi_iterator_update update,
9126 : : location_t loc, code_helper code, tree type, tree op0)
9127 : : {
9128 : 0 : if (code.is_tree_code ())
9129 : 0 : return gimple_build (gsi, before, update, loc, tree_code (code), type, op0);
9130 : 0 : return gimple_build (gsi, before, update, loc, combined_fn (code), type, op0);
9131 : : }
9132 : :
9133 : : /* Build CODE (OP0, OP1) with a result of type TYPE (or no result if TYPE is
9134 : : void) with location LOC, simplifying it first if possible. Returns the
9135 : : built expression value (or NULL_TREE if TYPE is void) inserting any new
9136 : : statements at GSI honoring BEFORE and UPDATE. */
9137 : :
9138 : : tree
9139 : 18790 : gimple_build (gimple_stmt_iterator *gsi,
9140 : : bool before, gsi_iterator_update update,
9141 : : location_t loc, code_helper code, tree type, tree op0, tree op1)
9142 : : {
9143 : 18790 : if (code.is_tree_code ())
9144 : 18790 : return gimple_build (gsi, before, update,
9145 : 18790 : loc, tree_code (code), type, op0, op1);
9146 : 0 : return gimple_build (gsi, before, update,
9147 : 0 : loc, combined_fn (code), type, op0, op1);
9148 : : }
9149 : :
9150 : : /* Build CODE (OP0, OP1, OP2) with a result of type TYPE (or no result if TYPE
9151 : : is void) with location LOC, simplifying it first if possible. Returns the
9152 : : built expression value (or NULL_TREE if TYPE is void) inserting any new
9153 : : statements at GSI honoring BEFORE and UPDATE. */
9154 : :
9155 : : tree
9156 : 0 : gimple_build (gimple_stmt_iterator *gsi,
9157 : : bool before, gsi_iterator_update update,
9158 : : location_t loc, code_helper code,
9159 : : tree type, tree op0, tree op1, tree op2)
9160 : : {
9161 : 0 : if (code.is_tree_code ())
9162 : 0 : return gimple_build (gsi, before, update,
9163 : 0 : loc, tree_code (code), type, op0, op1, op2);
9164 : 0 : return gimple_build (gsi, before, update,
9165 : 0 : loc, combined_fn (code), type, op0, op1, op2);
9166 : : }
9167 : :
9168 : : /* Build the conversion (TYPE) OP with a result of type TYPE
9169 : : with location LOC if such conversion is neccesary in GIMPLE,
9170 : : simplifying it first.
9171 : : Returns the built expression inserting any new statements
9172 : : at GSI honoring BEFORE and UPDATE. */
9173 : :
9174 : : tree
9175 : 1623622 : gimple_convert (gimple_stmt_iterator *gsi,
9176 : : bool before, gsi_iterator_update update,
9177 : : location_t loc, tree type, tree op)
9178 : : {
9179 : 1623622 : if (useless_type_conversion_p (type, TREE_TYPE (op)))
9180 : : return op;
9181 : 89024 : return gimple_build (gsi, before, update, loc, NOP_EXPR, type, op);
9182 : : }
9183 : :
9184 : : /* Build the conversion (ptrofftype) OP with a result of a type
9185 : : compatible with ptrofftype with location LOC if such conversion
9186 : : is neccesary in GIMPLE, simplifying it first.
9187 : : Returns the built expression value inserting any new statements
9188 : : at GSI honoring BEFORE and UPDATE. */
9189 : :
9190 : : tree
9191 : 203 : gimple_convert_to_ptrofftype (gimple_stmt_iterator *gsi,
9192 : : bool before, gsi_iterator_update update,
9193 : : location_t loc, tree op)
9194 : : {
9195 : 203 : if (ptrofftype_p (TREE_TYPE (op)))
9196 : : return op;
9197 : 0 : return gimple_convert (gsi, before, update, loc, sizetype, op);
9198 : : }
9199 : :
9200 : : /* Build a vector of type TYPE in which each element has the value OP.
9201 : : Return a gimple value for the result, inserting any new statements
9202 : : at GSI honoring BEFORE and UPDATE. */
9203 : :
9204 : : tree
9205 : 251489 : gimple_build_vector_from_val (gimple_stmt_iterator *gsi,
9206 : : bool before, gsi_iterator_update update,
9207 : : location_t loc, tree type, tree op)
9208 : : {
9209 : 251489 : if (!TYPE_VECTOR_SUBPARTS (type).is_constant ()
9210 : : && !CONSTANT_CLASS_P (op))
9211 : : return gimple_build (gsi, before, update,
9212 : : loc, VEC_DUPLICATE_EXPR, type, op);
9213 : :
9214 : 251489 : tree res, vec = build_vector_from_val (type, op);
9215 : 251489 : if (is_gimple_val (vec))
9216 : : return vec;
9217 : 22606 : if (gimple_in_ssa_p (cfun))
9218 : 22606 : res = make_ssa_name (type);
9219 : : else
9220 : 0 : res = create_tmp_reg (type);
9221 : 22606 : gimple_seq seq = NULL;
9222 : 22606 : gimple *stmt = gimple_build_assign (res, vec);
9223 : 22606 : gimple_set_location (stmt, loc);
9224 : 22606 : gimple_seq_add_stmt_without_update (&seq, stmt);
9225 : 22606 : gimple_build_insert_seq (gsi, before, update, seq);
9226 : 22606 : return res;
9227 : : }
9228 : :
9229 : : /* Build a vector from BUILDER, handling the case in which some elements
9230 : : are non-constant. Return a gimple value for the result, inserting
9231 : : any new instructions to GSI honoring BEFORE and UPDATE.
9232 : :
9233 : : BUILDER must not have a stepped encoding on entry. This is because
9234 : : the function is not geared up to handle the arithmetic that would
9235 : : be needed in the variable case, and any code building a vector that
9236 : : is known to be constant should use BUILDER->build () directly. */
9237 : :
9238 : : tree
9239 : 316502 : gimple_build_vector (gimple_stmt_iterator *gsi,
9240 : : bool before, gsi_iterator_update update,
9241 : : location_t loc, tree_vector_builder *builder)
9242 : : {
9243 : 316502 : gcc_assert (builder->nelts_per_pattern () <= 2);
9244 : 316502 : unsigned int encoded_nelts = builder->encoded_nelts ();
9245 : 825965 : for (unsigned int i = 0; i < encoded_nelts; ++i)
9246 : 648189 : if (!CONSTANT_CLASS_P ((*builder)[i]))
9247 : : {
9248 : 138726 : gimple_seq seq = NULL;
9249 : 138726 : tree type = builder->type ();
9250 : 138726 : unsigned int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
9251 : 138726 : vec<constructor_elt, va_gc> *v;
9252 : 138726 : vec_alloc (v, nelts);
9253 : 443324 : for (i = 0; i < nelts; ++i)
9254 : 304598 : CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, builder->elt (i));
9255 : :
9256 : 138726 : tree res;
9257 : 138726 : if (gimple_in_ssa_p (cfun))
9258 : 138726 : res = make_ssa_name (type);
9259 : : else
9260 : 0 : res = create_tmp_reg (type);
9261 : 138726 : gimple *stmt = gimple_build_assign (res, build_constructor (type, v));
9262 : 138726 : gimple_set_location (stmt, loc);
9263 : 138726 : gimple_seq_add_stmt_without_update (&seq, stmt);
9264 : 138726 : gimple_build_insert_seq (gsi, before, update, seq);
9265 : 138726 : return res;
9266 : : }
9267 : 177776 : return builder->build ();
9268 : : }
9269 : :
9270 : : /* Emit gimple statements into &stmts that take a value given in OLD_SIZE
9271 : : and generate a value guaranteed to be rounded upwards to ALIGN.
9272 : :
9273 : : Return the tree node representing this size, it is of TREE_TYPE TYPE. */
9274 : :
9275 : : tree
9276 : 0 : gimple_build_round_up (gimple_stmt_iterator *gsi,
9277 : : bool before, gsi_iterator_update update,
9278 : : location_t loc, tree type,
9279 : : tree old_size, unsigned HOST_WIDE_INT align)
9280 : : {
9281 : 0 : unsigned HOST_WIDE_INT tg_mask = align - 1;
9282 : : /* tree new_size = (old_size + tg_mask) & ~tg_mask; */
9283 : 0 : gcc_assert (INTEGRAL_TYPE_P (type));
9284 : 0 : tree tree_mask = build_int_cst (type, tg_mask);
9285 : 0 : tree oversize = gimple_build (gsi, before, update,
9286 : : loc, PLUS_EXPR, type, old_size, tree_mask);
9287 : :
9288 : 0 : tree mask = build_int_cst (type, -align);
9289 : 0 : return gimple_build (gsi, before, update,
9290 : 0 : loc, BIT_AND_EXPR, type, oversize, mask);
9291 : : }
9292 : :
9293 : : /* Return true if the result of assignment STMT is known to be non-negative.
9294 : : If the return value is based on the assumption that signed overflow is
9295 : : undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
9296 : : *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
9297 : :
9298 : : static bool
9299 : 45165357 : gimple_assign_nonnegative_warnv_p (gimple *stmt, bool *strict_overflow_p,
9300 : : int depth)
9301 : : {
9302 : 45165357 : enum tree_code code = gimple_assign_rhs_code (stmt);
9303 : 45165357 : tree type = TREE_TYPE (gimple_assign_lhs (stmt));
9304 : 45165357 : switch (get_gimple_rhs_class (code))
9305 : : {
9306 : 9976561 : case GIMPLE_UNARY_RHS:
9307 : 9976561 : return tree_unary_nonnegative_warnv_p (gimple_assign_rhs_code (stmt),
9308 : : type,
9309 : : gimple_assign_rhs1 (stmt),
9310 : 9976561 : strict_overflow_p, depth);
9311 : 30937392 : case GIMPLE_BINARY_RHS:
9312 : 30937392 : return tree_binary_nonnegative_warnv_p (gimple_assign_rhs_code (stmt),
9313 : : type,
9314 : : gimple_assign_rhs1 (stmt),
9315 : : gimple_assign_rhs2 (stmt),
9316 : 30937392 : strict_overflow_p, depth);
9317 : : case GIMPLE_TERNARY_RHS:
9318 : : return false;
9319 : 4224263 : case GIMPLE_SINGLE_RHS:
9320 : 4224263 : return tree_single_nonnegative_warnv_p (gimple_assign_rhs1 (stmt),
9321 : 4224263 : strict_overflow_p, depth);
9322 : : case GIMPLE_INVALID_RHS:
9323 : : break;
9324 : : }
9325 : 0 : gcc_unreachable ();
9326 : : }
9327 : :
9328 : : /* Return true if return value of call STMT is known to be non-negative.
9329 : : If the return value is based on the assumption that signed overflow is
9330 : : undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
9331 : : *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
9332 : :
9333 : : static bool
9334 : 19184538 : gimple_call_nonnegative_warnv_p (gimple *stmt, bool *strict_overflow_p,
9335 : : int depth)
9336 : : {
9337 : 19184538 : tree arg0 = gimple_call_num_args (stmt) > 0 ?
9338 : 17005017 : gimple_call_arg (stmt, 0) : NULL_TREE;
9339 : 19184538 : tree arg1 = gimple_call_num_args (stmt) > 1 ?
9340 : 10910616 : gimple_call_arg (stmt, 1) : NULL_TREE;
9341 : 19184538 : tree lhs = gimple_call_lhs (stmt);
9342 : 19184538 : return (lhs
9343 : 19184538 : && tree_call_nonnegative_warnv_p (TREE_TYPE (lhs),
9344 : : gimple_call_combined_fn (stmt),
9345 : : arg0, arg1,
9346 : 19184538 : strict_overflow_p, depth));
9347 : : }
9348 : :
9349 : : /* Return true if return value of call STMT is known to be non-negative.
9350 : : If the return value is based on the assumption that signed overflow is
9351 : : undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
9352 : : *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
9353 : :
9354 : : static bool
9355 : 11072846 : gimple_phi_nonnegative_warnv_p (gimple *stmt, bool *strict_overflow_p,
9356 : : int depth)
9357 : : {
9358 : 21938847 : for (unsigned i = 0; i < gimple_phi_num_args (stmt); ++i)
9359 : : {
9360 : 17833020 : tree arg = gimple_phi_arg_def (stmt, i);
9361 : 17833020 : if (!tree_single_nonnegative_warnv_p (arg, strict_overflow_p, depth + 1))
9362 : : return false;
9363 : : }
9364 : : return true;
9365 : : }
9366 : :
9367 : : /* Return true if STMT is known to compute a non-negative value.
9368 : : If the return value is based on the assumption that signed overflow is
9369 : : undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
9370 : : *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
9371 : :
9372 : : bool
9373 : 122118100 : gimple_stmt_nonnegative_warnv_p (gimple *stmt, bool *strict_overflow_p,
9374 : : int depth)
9375 : : {
9376 : 122118100 : tree type = gimple_range_type (stmt);
9377 : 122118100 : if (type && frange::supports_p (type))
9378 : : {
9379 : 1346393 : frange r;
9380 : 1346393 : bool sign;
9381 : 1346393 : if (get_global_range_query ()->range_of_stmt (r, stmt)
9382 : 1346393 : && r.signbit_p (sign))
9383 : 6893 : return !sign;
9384 : : }
9385 : 122111207 : switch (gimple_code (stmt))
9386 : : {
9387 : 45165357 : case GIMPLE_ASSIGN:
9388 : 45165357 : return gimple_assign_nonnegative_warnv_p (stmt, strict_overflow_p,
9389 : 45165357 : depth);
9390 : 19184538 : case GIMPLE_CALL:
9391 : 19184538 : return gimple_call_nonnegative_warnv_p (stmt, strict_overflow_p,
9392 : 19184538 : depth);
9393 : 11072846 : case GIMPLE_PHI:
9394 : 11072846 : return gimple_phi_nonnegative_warnv_p (stmt, strict_overflow_p,
9395 : 11072846 : depth);
9396 : : default:
9397 : : return false;
9398 : : }
9399 : : }
9400 : :
9401 : : /* Return true if the floating-point value computed by assignment STMT
9402 : : is known to have an integer value. We also allow +Inf, -Inf and NaN
9403 : : to be considered integer values. Return false for signaling NaN.
9404 : :
9405 : : DEPTH is the current nesting depth of the query. */
9406 : :
9407 : : static bool
9408 : 50596 : gimple_assign_integer_valued_real_p (gimple *stmt, int depth)
9409 : : {
9410 : 50596 : enum tree_code code = gimple_assign_rhs_code (stmt);
9411 : 50596 : switch (get_gimple_rhs_class (code))
9412 : : {
9413 : 14623 : case GIMPLE_UNARY_RHS:
9414 : 14623 : return integer_valued_real_unary_p (gimple_assign_rhs_code (stmt),
9415 : 14623 : gimple_assign_rhs1 (stmt), depth);
9416 : 13140 : case GIMPLE_BINARY_RHS:
9417 : 13140 : return integer_valued_real_binary_p (gimple_assign_rhs_code (stmt),
9418 : : gimple_assign_rhs1 (stmt),
9419 : 13140 : gimple_assign_rhs2 (stmt), depth);
9420 : : case GIMPLE_TERNARY_RHS:
9421 : : return false;
9422 : 21796 : case GIMPLE_SINGLE_RHS:
9423 : 21796 : return integer_valued_real_single_p (gimple_assign_rhs1 (stmt), depth);
9424 : : case GIMPLE_INVALID_RHS:
9425 : : break;
9426 : : }
9427 : 0 : gcc_unreachable ();
9428 : : }
9429 : :
9430 : : /* Return true if the floating-point value computed by call STMT is known
9431 : : to have an integer value. We also allow +Inf, -Inf and NaN to be
9432 : : considered integer values. Return false for signaling NaN.
9433 : :
9434 : : DEPTH is the current nesting depth of the query. */
9435 : :
9436 : : static bool
9437 : 920 : gimple_call_integer_valued_real_p (gimple *stmt, int depth)
9438 : : {
9439 : 920 : tree arg0 = (gimple_call_num_args (stmt) > 0
9440 : 920 : ? gimple_call_arg (stmt, 0)
9441 : 920 : : NULL_TREE);
9442 : 920 : tree arg1 = (gimple_call_num_args (stmt) > 1
9443 : 920 : ? gimple_call_arg (stmt, 1)
9444 : 920 : : NULL_TREE);
9445 : 920 : return integer_valued_real_call_p (gimple_call_combined_fn (stmt),
9446 : 920 : arg0, arg1, depth);
9447 : : }
9448 : :
9449 : : /* Return true if the floating-point result of phi STMT is known to have
9450 : : an integer value. We also allow +Inf, -Inf and NaN to be considered
9451 : : integer values. Return false for signaling NaN.
9452 : :
9453 : : DEPTH is the current nesting depth of the query. */
9454 : :
9455 : : static bool
9456 : 803 : gimple_phi_integer_valued_real_p (gimple *stmt, int depth)
9457 : : {
9458 : 928 : for (unsigned i = 0; i < gimple_phi_num_args (stmt); ++i)
9459 : : {
9460 : 927 : tree arg = gimple_phi_arg_def (stmt, i);
9461 : 927 : if (!integer_valued_real_single_p (arg, depth + 1))
9462 : : return false;
9463 : : }
9464 : : return true;
9465 : : }
9466 : :
9467 : : /* Return true if the floating-point value computed by STMT is known
9468 : : to have an integer value. We also allow +Inf, -Inf and NaN to be
9469 : : considered integer values. Return false for signaling NaN.
9470 : :
9471 : : DEPTH is the current nesting depth of the query. */
9472 : :
9473 : : bool
9474 : 78029 : gimple_stmt_integer_valued_real_p (gimple *stmt, int depth)
9475 : : {
9476 : 78029 : switch (gimple_code (stmt))
9477 : : {
9478 : 50596 : case GIMPLE_ASSIGN:
9479 : 50596 : return gimple_assign_integer_valued_real_p (stmt, depth);
9480 : 920 : case GIMPLE_CALL:
9481 : 920 : return gimple_call_integer_valued_real_p (stmt, depth);
9482 : 803 : case GIMPLE_PHI:
9483 : 803 : return gimple_phi_integer_valued_real_p (stmt, depth);
9484 : : default:
9485 : : return false;
9486 : : }
9487 : : }
|
