Skip -fwhole-program when merging LTO options.
[official-gcc.git] / gcc / tree-ssa-sccvn.cc
blobfa2f65df159330cf884350d22edd859bbde5faa3
1 /* SCC value numbering for trees
2 Copyright (C) 2006-2022 Free Software Foundation, Inc.
3 Contributed by Daniel Berlin <dan@dberlin.org>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
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/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "splay-tree.h"
25 #include "backend.h"
26 #include "rtl.h"
27 #include "tree.h"
28 #include "gimple.h"
29 #include "ssa.h"
30 #include "expmed.h"
31 #include "insn-config.h"
32 #include "memmodel.h"
33 #include "emit-rtl.h"
34 #include "cgraph.h"
35 #include "gimple-pretty-print.h"
36 #include "alias.h"
37 #include "fold-const.h"
38 #include "stor-layout.h"
39 #include "cfganal.h"
40 #include "tree-inline.h"
41 #include "internal-fn.h"
42 #include "gimple-iterator.h"
43 #include "gimple-fold.h"
44 #include "tree-eh.h"
45 #include "gimplify.h"
46 #include "flags.h"
47 #include "dojump.h"
48 #include "explow.h"
49 #include "calls.h"
50 #include "varasm.h"
51 #include "stmt.h"
52 #include "expr.h"
53 #include "tree-dfa.h"
54 #include "tree-ssa.h"
55 #include "dumpfile.h"
56 #include "cfgloop.h"
57 #include "tree-ssa-propagate.h"
58 #include "tree-cfg.h"
59 #include "domwalk.h"
60 #include "gimple-match.h"
61 #include "stringpool.h"
62 #include "attribs.h"
63 #include "tree-pass.h"
64 #include "statistics.h"
65 #include "langhooks.h"
66 #include "ipa-utils.h"
67 #include "dbgcnt.h"
68 #include "tree-cfgcleanup.h"
69 #include "tree-ssa-loop.h"
70 #include "tree-scalar-evolution.h"
71 #include "tree-ssa-loop-niter.h"
72 #include "builtins.h"
73 #include "fold-const-call.h"
74 #include "ipa-modref-tree.h"
75 #include "ipa-modref.h"
76 #include "tree-ssa-sccvn.h"
78 /* This algorithm is based on the SCC algorithm presented by Keith
79 Cooper and L. Taylor Simpson in "SCC-Based Value numbering"
80 (http://citeseer.ist.psu.edu/41805.html). In
81 straight line code, it is equivalent to a regular hash based value
82 numbering that is performed in reverse postorder.
84 For code with cycles, there are two alternatives, both of which
85 require keeping the hashtables separate from the actual list of
86 value numbers for SSA names.
88 1. Iterate value numbering in an RPO walk of the blocks, removing
89 all the entries from the hashtable after each iteration (but
90 keeping the SSA name->value number mapping between iterations).
91 Iterate until it does not change.
93 2. Perform value numbering as part of an SCC walk on the SSA graph,
94 iterating only the cycles in the SSA graph until they do not change
95 (using a separate, optimistic hashtable for value numbering the SCC
96 operands).
98 The second is not just faster in practice (because most SSA graph
99 cycles do not involve all the variables in the graph), it also has
100 some nice properties.
102 One of these nice properties is that when we pop an SCC off the
103 stack, we are guaranteed to have processed all the operands coming from
104 *outside of that SCC*, so we do not need to do anything special to
105 ensure they have value numbers.
107 Another nice property is that the SCC walk is done as part of a DFS
108 of the SSA graph, which makes it easy to perform combining and
109 simplifying operations at the same time.
111 The code below is deliberately written in a way that makes it easy
112 to separate the SCC walk from the other work it does.
114 In order to propagate constants through the code, we track which
115 expressions contain constants, and use those while folding. In
116 theory, we could also track expressions whose value numbers are
117 replaced, in case we end up folding based on expression
118 identities.
120 In order to value number memory, we assign value numbers to vuses.
121 This enables us to note that, for example, stores to the same
122 address of the same value from the same starting memory states are
123 equivalent.
124 TODO:
126 1. We can iterate only the changing portions of the SCC's, but
127 I have not seen an SCC big enough for this to be a win.
128 2. If you differentiate between phi nodes for loops and phi nodes
129 for if-then-else, you can properly consider phi nodes in different
130 blocks for equivalence.
131 3. We could value number vuses in more cases, particularly, whole
132 structure copies.
135 /* There's no BB_EXECUTABLE but we can use BB_VISITED. */
136 #define BB_EXECUTABLE BB_VISITED
138 static vn_lookup_kind default_vn_walk_kind;
140 /* vn_nary_op hashtable helpers. */
142 struct vn_nary_op_hasher : nofree_ptr_hash <vn_nary_op_s>
144 typedef vn_nary_op_s *compare_type;
145 static inline hashval_t hash (const vn_nary_op_s *);
146 static inline bool equal (const vn_nary_op_s *, const vn_nary_op_s *);
149 /* Return the computed hashcode for nary operation P1. */
151 inline hashval_t
152 vn_nary_op_hasher::hash (const vn_nary_op_s *vno1)
154 return vno1->hashcode;
157 /* Compare nary operations P1 and P2 and return true if they are
158 equivalent. */
160 inline bool
161 vn_nary_op_hasher::equal (const vn_nary_op_s *vno1, const vn_nary_op_s *vno2)
163 return vno1 == vno2 || vn_nary_op_eq (vno1, vno2);
166 typedef hash_table<vn_nary_op_hasher> vn_nary_op_table_type;
167 typedef vn_nary_op_table_type::iterator vn_nary_op_iterator_type;
170 /* vn_phi hashtable helpers. */
172 static int
173 vn_phi_eq (const_vn_phi_t const vp1, const_vn_phi_t const vp2);
175 struct vn_phi_hasher : nofree_ptr_hash <vn_phi_s>
177 static inline hashval_t hash (const vn_phi_s *);
178 static inline bool equal (const vn_phi_s *, const vn_phi_s *);
181 /* Return the computed hashcode for phi operation P1. */
183 inline hashval_t
184 vn_phi_hasher::hash (const vn_phi_s *vp1)
186 return vp1->hashcode;
189 /* Compare two phi entries for equality, ignoring VN_TOP arguments. */
191 inline bool
192 vn_phi_hasher::equal (const vn_phi_s *vp1, const vn_phi_s *vp2)
194 return vp1 == vp2 || vn_phi_eq (vp1, vp2);
197 typedef hash_table<vn_phi_hasher> vn_phi_table_type;
198 typedef vn_phi_table_type::iterator vn_phi_iterator_type;
201 /* Compare two reference operands P1 and P2 for equality. Return true if
202 they are equal, and false otherwise. */
204 static int
205 vn_reference_op_eq (const void *p1, const void *p2)
207 const_vn_reference_op_t const vro1 = (const_vn_reference_op_t) p1;
208 const_vn_reference_op_t const vro2 = (const_vn_reference_op_t) p2;
210 return (vro1->opcode == vro2->opcode
211 /* We do not care for differences in type qualification. */
212 && (vro1->type == vro2->type
213 || (vro1->type && vro2->type
214 && types_compatible_p (TYPE_MAIN_VARIANT (vro1->type),
215 TYPE_MAIN_VARIANT (vro2->type))))
216 && expressions_equal_p (vro1->op0, vro2->op0)
217 && expressions_equal_p (vro1->op1, vro2->op1)
218 && expressions_equal_p (vro1->op2, vro2->op2)
219 && (vro1->opcode != CALL_EXPR || vro1->clique == vro2->clique));
222 /* Free a reference operation structure VP. */
224 static inline void
225 free_reference (vn_reference_s *vr)
227 vr->operands.release ();
231 /* vn_reference hashtable helpers. */
233 struct vn_reference_hasher : nofree_ptr_hash <vn_reference_s>
235 static inline hashval_t hash (const vn_reference_s *);
236 static inline bool equal (const vn_reference_s *, const vn_reference_s *);
239 /* Return the hashcode for a given reference operation P1. */
241 inline hashval_t
242 vn_reference_hasher::hash (const vn_reference_s *vr1)
244 return vr1->hashcode;
247 inline bool
248 vn_reference_hasher::equal (const vn_reference_s *v, const vn_reference_s *c)
250 return v == c || vn_reference_eq (v, c);
253 typedef hash_table<vn_reference_hasher> vn_reference_table_type;
254 typedef vn_reference_table_type::iterator vn_reference_iterator_type;
256 /* Pretty-print OPS to OUTFILE. */
258 void
259 print_vn_reference_ops (FILE *outfile, const vec<vn_reference_op_s> ops)
261 vn_reference_op_t vro;
262 unsigned int i;
263 fprintf (outfile, "{");
264 for (i = 0; ops.iterate (i, &vro); i++)
266 bool closebrace = false;
267 if (vro->opcode != SSA_NAME
268 && TREE_CODE_CLASS (vro->opcode) != tcc_declaration)
270 fprintf (outfile, "%s", get_tree_code_name (vro->opcode));
271 if (vro->op0 || vro->opcode == CALL_EXPR)
273 fprintf (outfile, "<");
274 closebrace = true;
277 if (vro->op0 || vro->opcode == CALL_EXPR)
279 if (!vro->op0)
280 fprintf (outfile, internal_fn_name ((internal_fn)vro->clique));
281 else
282 print_generic_expr (outfile, vro->op0);
283 if (vro->op1)
285 fprintf (outfile, ",");
286 print_generic_expr (outfile, vro->op1);
288 if (vro->op2)
290 fprintf (outfile, ",");
291 print_generic_expr (outfile, vro->op2);
294 if (closebrace)
295 fprintf (outfile, ">");
296 if (i != ops.length () - 1)
297 fprintf (outfile, ",");
299 fprintf (outfile, "}");
302 DEBUG_FUNCTION void
303 debug_vn_reference_ops (const vec<vn_reference_op_s> ops)
305 print_vn_reference_ops (stderr, ops);
306 fputc ('\n', stderr);
309 /* The set of VN hashtables. */
311 typedef struct vn_tables_s
313 vn_nary_op_table_type *nary;
314 vn_phi_table_type *phis;
315 vn_reference_table_type *references;
316 } *vn_tables_t;
319 /* vn_constant hashtable helpers. */
321 struct vn_constant_hasher : free_ptr_hash <vn_constant_s>
323 static inline hashval_t hash (const vn_constant_s *);
324 static inline bool equal (const vn_constant_s *, const vn_constant_s *);
327 /* Hash table hash function for vn_constant_t. */
329 inline hashval_t
330 vn_constant_hasher::hash (const vn_constant_s *vc1)
332 return vc1->hashcode;
335 /* Hash table equality function for vn_constant_t. */
337 inline bool
338 vn_constant_hasher::equal (const vn_constant_s *vc1, const vn_constant_s *vc2)
340 if (vc1->hashcode != vc2->hashcode)
341 return false;
343 return vn_constant_eq_with_type (vc1->constant, vc2->constant);
346 static hash_table<vn_constant_hasher> *constant_to_value_id;
349 /* Obstack we allocate the vn-tables elements from. */
350 static obstack vn_tables_obstack;
351 /* Special obstack we never unwind. */
352 static obstack vn_tables_insert_obstack;
354 static vn_reference_t last_inserted_ref;
355 static vn_phi_t last_inserted_phi;
356 static vn_nary_op_t last_inserted_nary;
357 static vn_ssa_aux_t last_pushed_avail;
359 /* Valid hashtables storing information we have proven to be
360 correct. */
361 static vn_tables_t valid_info;
364 /* Valueization hook for simplify_replace_tree. Valueize NAME if it is
365 an SSA name, otherwise just return it. */
366 tree (*vn_valueize) (tree);
367 static tree
368 vn_valueize_for_srt (tree t, void* context ATTRIBUTE_UNUSED)
370 basic_block saved_vn_context_bb = vn_context_bb;
371 /* Look for sth available at the definition block of the argument.
372 This avoids inconsistencies between availability there which
373 decides if the stmt can be removed and availability at the
374 use site. The SSA property ensures that things available
375 at the definition are also available at uses. */
376 if (!SSA_NAME_IS_DEFAULT_DEF (t))
377 vn_context_bb = gimple_bb (SSA_NAME_DEF_STMT (t));
378 tree res = vn_valueize (t);
379 vn_context_bb = saved_vn_context_bb;
380 return res;
384 /* This represents the top of the VN lattice, which is the universal
385 value. */
387 tree VN_TOP;
389 /* Unique counter for our value ids. */
391 static unsigned int next_value_id;
392 static int next_constant_value_id;
395 /* Table of vn_ssa_aux_t's, one per ssa_name. The vn_ssa_aux_t objects
396 are allocated on an obstack for locality reasons, and to free them
397 without looping over the vec. */
399 struct vn_ssa_aux_hasher : typed_noop_remove <vn_ssa_aux_t>
401 typedef vn_ssa_aux_t value_type;
402 typedef tree compare_type;
403 static inline hashval_t hash (const value_type &);
404 static inline bool equal (const value_type &, const compare_type &);
405 static inline void mark_deleted (value_type &) {}
406 static const bool empty_zero_p = true;
407 static inline void mark_empty (value_type &e) { e = NULL; }
408 static inline bool is_deleted (value_type &) { return false; }
409 static inline bool is_empty (value_type &e) { return e == NULL; }
412 hashval_t
413 vn_ssa_aux_hasher::hash (const value_type &entry)
415 return SSA_NAME_VERSION (entry->name);
418 bool
419 vn_ssa_aux_hasher::equal (const value_type &entry, const compare_type &name)
421 return name == entry->name;
424 static hash_table<vn_ssa_aux_hasher> *vn_ssa_aux_hash;
425 typedef hash_table<vn_ssa_aux_hasher>::iterator vn_ssa_aux_iterator_type;
426 static struct obstack vn_ssa_aux_obstack;
428 static vn_nary_op_t vn_nary_op_insert_stmt (gimple *, tree);
429 static vn_nary_op_t vn_nary_op_insert_into (vn_nary_op_t,
430 vn_nary_op_table_type *);
431 static void init_vn_nary_op_from_pieces (vn_nary_op_t, unsigned int,
432 enum tree_code, tree, tree *);
433 static tree vn_lookup_simplify_result (gimple_match_op *);
434 static vn_reference_t vn_reference_lookup_or_insert_for_pieces
435 (tree, alias_set_type, alias_set_type, tree,
436 vec<vn_reference_op_s, va_heap>, tree);
438 /* Return whether there is value numbering information for a given SSA name. */
440 bool
441 has_VN_INFO (tree name)
443 return vn_ssa_aux_hash->find_with_hash (name, SSA_NAME_VERSION (name));
446 vn_ssa_aux_t
447 VN_INFO (tree name)
449 vn_ssa_aux_t *res
450 = vn_ssa_aux_hash->find_slot_with_hash (name, SSA_NAME_VERSION (name),
451 INSERT);
452 if (*res != NULL)
453 return *res;
455 vn_ssa_aux_t newinfo = *res = XOBNEW (&vn_ssa_aux_obstack, struct vn_ssa_aux);
456 memset (newinfo, 0, sizeof (struct vn_ssa_aux));
457 newinfo->name = name;
458 newinfo->valnum = VN_TOP;
459 /* We are using the visited flag to handle uses with defs not within the
460 region being value-numbered. */
461 newinfo->visited = false;
463 /* Given we create the VN_INFOs on-demand now we have to do initialization
464 different than VN_TOP here. */
465 if (SSA_NAME_IS_DEFAULT_DEF (name))
466 switch (TREE_CODE (SSA_NAME_VAR (name)))
468 case VAR_DECL:
469 /* All undefined vars are VARYING. */
470 newinfo->valnum = name;
471 newinfo->visited = true;
472 break;
474 case PARM_DECL:
475 /* Parameters are VARYING but we can record a condition
476 if we know it is a non-NULL pointer. */
477 newinfo->visited = true;
478 newinfo->valnum = name;
479 if (POINTER_TYPE_P (TREE_TYPE (name))
480 && nonnull_arg_p (SSA_NAME_VAR (name)))
482 tree ops[2];
483 ops[0] = name;
484 ops[1] = build_int_cst (TREE_TYPE (name), 0);
485 vn_nary_op_t nary;
486 /* Allocate from non-unwinding stack. */
487 nary = alloc_vn_nary_op_noinit (2, &vn_tables_insert_obstack);
488 init_vn_nary_op_from_pieces (nary, 2, NE_EXPR,
489 boolean_type_node, ops);
490 nary->predicated_values = 0;
491 nary->u.result = boolean_true_node;
492 vn_nary_op_insert_into (nary, valid_info->nary);
493 gcc_assert (nary->unwind_to == NULL);
494 /* Also do not link it into the undo chain. */
495 last_inserted_nary = nary->next;
496 nary->next = (vn_nary_op_t)(void *)-1;
497 nary = alloc_vn_nary_op_noinit (2, &vn_tables_insert_obstack);
498 init_vn_nary_op_from_pieces (nary, 2, EQ_EXPR,
499 boolean_type_node, ops);
500 nary->predicated_values = 0;
501 nary->u.result = boolean_false_node;
502 vn_nary_op_insert_into (nary, valid_info->nary);
503 gcc_assert (nary->unwind_to == NULL);
504 last_inserted_nary = nary->next;
505 nary->next = (vn_nary_op_t)(void *)-1;
506 if (dump_file && (dump_flags & TDF_DETAILS))
508 fprintf (dump_file, "Recording ");
509 print_generic_expr (dump_file, name, TDF_SLIM);
510 fprintf (dump_file, " != 0\n");
513 break;
515 case RESULT_DECL:
516 /* If the result is passed by invisible reference the default
517 def is initialized, otherwise it's uninitialized. Still
518 undefined is varying. */
519 newinfo->visited = true;
520 newinfo->valnum = name;
521 break;
523 default:
524 gcc_unreachable ();
526 return newinfo;
529 /* Return the SSA value of X. */
531 inline tree
532 SSA_VAL (tree x, bool *visited = NULL)
534 vn_ssa_aux_t tem = vn_ssa_aux_hash->find_with_hash (x, SSA_NAME_VERSION (x));
535 if (visited)
536 *visited = tem && tem->visited;
537 return tem && tem->visited ? tem->valnum : x;
540 /* Return the SSA value of the VUSE x, supporting released VDEFs
541 during elimination which will value-number the VDEF to the
542 associated VUSE (but not substitute in the whole lattice). */
544 static inline tree
545 vuse_ssa_val (tree x)
547 if (!x)
548 return NULL_TREE;
552 x = SSA_VAL (x);
553 gcc_assert (x != VN_TOP);
555 while (SSA_NAME_IN_FREE_LIST (x));
557 return x;
560 /* Similar to the above but used as callback for walk_non_aliased_vuses
561 and thus should stop at unvisited VUSE to not walk across region
562 boundaries. */
564 static tree
565 vuse_valueize (tree vuse)
569 bool visited;
570 vuse = SSA_VAL (vuse, &visited);
571 if (!visited)
572 return NULL_TREE;
573 gcc_assert (vuse != VN_TOP);
575 while (SSA_NAME_IN_FREE_LIST (vuse));
576 return vuse;
580 /* Return the vn_kind the expression computed by the stmt should be
581 associated with. */
583 enum vn_kind
584 vn_get_stmt_kind (gimple *stmt)
586 switch (gimple_code (stmt))
588 case GIMPLE_CALL:
589 return VN_REFERENCE;
590 case GIMPLE_PHI:
591 return VN_PHI;
592 case GIMPLE_ASSIGN:
594 enum tree_code code = gimple_assign_rhs_code (stmt);
595 tree rhs1 = gimple_assign_rhs1 (stmt);
596 switch (get_gimple_rhs_class (code))
598 case GIMPLE_UNARY_RHS:
599 case GIMPLE_BINARY_RHS:
600 case GIMPLE_TERNARY_RHS:
601 return VN_NARY;
602 case GIMPLE_SINGLE_RHS:
603 switch (TREE_CODE_CLASS (code))
605 case tcc_reference:
606 /* VOP-less references can go through unary case. */
607 if ((code == REALPART_EXPR
608 || code == IMAGPART_EXPR
609 || code == VIEW_CONVERT_EXPR
610 || code == BIT_FIELD_REF)
611 && (TREE_CODE (TREE_OPERAND (rhs1, 0)) == SSA_NAME
612 || is_gimple_min_invariant (TREE_OPERAND (rhs1, 0))))
613 return VN_NARY;
615 /* Fallthrough. */
616 case tcc_declaration:
617 return VN_REFERENCE;
619 case tcc_constant:
620 return VN_CONSTANT;
622 default:
623 if (code == ADDR_EXPR)
624 return (is_gimple_min_invariant (rhs1)
625 ? VN_CONSTANT : VN_REFERENCE);
626 else if (code == CONSTRUCTOR)
627 return VN_NARY;
628 return VN_NONE;
630 default:
631 return VN_NONE;
634 default:
635 return VN_NONE;
639 /* Lookup a value id for CONSTANT and return it. If it does not
640 exist returns 0. */
642 unsigned int
643 get_constant_value_id (tree constant)
645 vn_constant_s **slot;
646 struct vn_constant_s vc;
648 vc.hashcode = vn_hash_constant_with_type (constant);
649 vc.constant = constant;
650 slot = constant_to_value_id->find_slot (&vc, NO_INSERT);
651 if (slot)
652 return (*slot)->value_id;
653 return 0;
656 /* Lookup a value id for CONSTANT, and if it does not exist, create a
657 new one and return it. If it does exist, return it. */
659 unsigned int
660 get_or_alloc_constant_value_id (tree constant)
662 vn_constant_s **slot;
663 struct vn_constant_s vc;
664 vn_constant_t vcp;
666 /* If the hashtable isn't initialized we're not running from PRE and thus
667 do not need value-ids. */
668 if (!constant_to_value_id)
669 return 0;
671 vc.hashcode = vn_hash_constant_with_type (constant);
672 vc.constant = constant;
673 slot = constant_to_value_id->find_slot (&vc, INSERT);
674 if (*slot)
675 return (*slot)->value_id;
677 vcp = XNEW (struct vn_constant_s);
678 vcp->hashcode = vc.hashcode;
679 vcp->constant = constant;
680 vcp->value_id = get_next_constant_value_id ();
681 *slot = vcp;
682 return vcp->value_id;
685 /* Compute the hash for a reference operand VRO1. */
687 static void
688 vn_reference_op_compute_hash (const vn_reference_op_t vro1, inchash::hash &hstate)
690 hstate.add_int (vro1->opcode);
691 if (vro1->opcode == CALL_EXPR && !vro1->op0)
692 hstate.add_int (vro1->clique);
693 if (vro1->op0)
694 inchash::add_expr (vro1->op0, hstate);
695 if (vro1->op1)
696 inchash::add_expr (vro1->op1, hstate);
697 if (vro1->op2)
698 inchash::add_expr (vro1->op2, hstate);
701 /* Compute a hash for the reference operation VR1 and return it. */
703 static hashval_t
704 vn_reference_compute_hash (const vn_reference_t vr1)
706 inchash::hash hstate;
707 hashval_t result;
708 int i;
709 vn_reference_op_t vro;
710 poly_int64 off = -1;
711 bool deref = false;
713 FOR_EACH_VEC_ELT (vr1->operands, i, vro)
715 if (vro->opcode == MEM_REF)
716 deref = true;
717 else if (vro->opcode != ADDR_EXPR)
718 deref = false;
719 if (maybe_ne (vro->off, -1))
721 if (known_eq (off, -1))
722 off = 0;
723 off += vro->off;
725 else
727 if (maybe_ne (off, -1)
728 && maybe_ne (off, 0))
729 hstate.add_poly_int (off);
730 off = -1;
731 if (deref
732 && vro->opcode == ADDR_EXPR)
734 if (vro->op0)
736 tree op = TREE_OPERAND (vro->op0, 0);
737 hstate.add_int (TREE_CODE (op));
738 inchash::add_expr (op, hstate);
741 else
742 vn_reference_op_compute_hash (vro, hstate);
745 result = hstate.end ();
746 /* ??? We would ICE later if we hash instead of adding that in. */
747 if (vr1->vuse)
748 result += SSA_NAME_VERSION (vr1->vuse);
750 return result;
753 /* Return true if reference operations VR1 and VR2 are equivalent. This
754 means they have the same set of operands and vuses. */
756 bool
757 vn_reference_eq (const_vn_reference_t const vr1, const_vn_reference_t const vr2)
759 unsigned i, j;
761 /* Early out if this is not a hash collision. */
762 if (vr1->hashcode != vr2->hashcode)
763 return false;
765 /* The VOP needs to be the same. */
766 if (vr1->vuse != vr2->vuse)
767 return false;
769 /* If the operands are the same we are done. */
770 if (vr1->operands == vr2->operands)
771 return true;
773 if (!vr1->type || !vr2->type)
775 if (vr1->type != vr2->type)
776 return false;
778 else if (vr1->type == vr2->type)
780 else if (COMPLETE_TYPE_P (vr1->type) != COMPLETE_TYPE_P (vr2->type)
781 || (COMPLETE_TYPE_P (vr1->type)
782 && !expressions_equal_p (TYPE_SIZE (vr1->type),
783 TYPE_SIZE (vr2->type))))
784 return false;
785 else if (vr1->operands[0].opcode == CALL_EXPR
786 && !types_compatible_p (vr1->type, vr2->type))
787 return false;
788 else if (INTEGRAL_TYPE_P (vr1->type)
789 && INTEGRAL_TYPE_P (vr2->type))
791 if (TYPE_PRECISION (vr1->type) != TYPE_PRECISION (vr2->type))
792 return false;
794 else if (INTEGRAL_TYPE_P (vr1->type)
795 && (TYPE_PRECISION (vr1->type)
796 != TREE_INT_CST_LOW (TYPE_SIZE (vr1->type))))
797 return false;
798 else if (INTEGRAL_TYPE_P (vr2->type)
799 && (TYPE_PRECISION (vr2->type)
800 != TREE_INT_CST_LOW (TYPE_SIZE (vr2->type))))
801 return false;
803 i = 0;
804 j = 0;
807 poly_int64 off1 = 0, off2 = 0;
808 vn_reference_op_t vro1, vro2;
809 vn_reference_op_s tem1, tem2;
810 bool deref1 = false, deref2 = false;
811 bool reverse1 = false, reverse2 = false;
812 for (; vr1->operands.iterate (i, &vro1); i++)
814 if (vro1->opcode == MEM_REF)
815 deref1 = true;
816 /* Do not look through a storage order barrier. */
817 else if (vro1->opcode == VIEW_CONVERT_EXPR && vro1->reverse)
818 return false;
819 reverse1 |= vro1->reverse;
820 if (known_eq (vro1->off, -1))
821 break;
822 off1 += vro1->off;
824 for (; vr2->operands.iterate (j, &vro2); j++)
826 if (vro2->opcode == MEM_REF)
827 deref2 = true;
828 /* Do not look through a storage order barrier. */
829 else if (vro2->opcode == VIEW_CONVERT_EXPR && vro2->reverse)
830 return false;
831 reverse2 |= vro2->reverse;
832 if (known_eq (vro2->off, -1))
833 break;
834 off2 += vro2->off;
836 if (maybe_ne (off1, off2) || reverse1 != reverse2)
837 return false;
838 if (deref1 && vro1->opcode == ADDR_EXPR)
840 memset (&tem1, 0, sizeof (tem1));
841 tem1.op0 = TREE_OPERAND (vro1->op0, 0);
842 tem1.type = TREE_TYPE (tem1.op0);
843 tem1.opcode = TREE_CODE (tem1.op0);
844 vro1 = &tem1;
845 deref1 = false;
847 if (deref2 && vro2->opcode == ADDR_EXPR)
849 memset (&tem2, 0, sizeof (tem2));
850 tem2.op0 = TREE_OPERAND (vro2->op0, 0);
851 tem2.type = TREE_TYPE (tem2.op0);
852 tem2.opcode = TREE_CODE (tem2.op0);
853 vro2 = &tem2;
854 deref2 = false;
856 if (deref1 != deref2)
857 return false;
858 if (!vn_reference_op_eq (vro1, vro2))
859 return false;
860 ++j;
861 ++i;
863 while (vr1->operands.length () != i
864 || vr2->operands.length () != j);
866 return true;
869 /* Copy the operations present in load/store REF into RESULT, a vector of
870 vn_reference_op_s's. */
872 static void
873 copy_reference_ops_from_ref (tree ref, vec<vn_reference_op_s> *result)
875 /* For non-calls, store the information that makes up the address. */
876 tree orig = ref;
877 while (ref)
879 vn_reference_op_s temp;
881 memset (&temp, 0, sizeof (temp));
882 temp.type = TREE_TYPE (ref);
883 temp.opcode = TREE_CODE (ref);
884 temp.off = -1;
886 switch (temp.opcode)
888 case MODIFY_EXPR:
889 temp.op0 = TREE_OPERAND (ref, 1);
890 break;
891 case WITH_SIZE_EXPR:
892 temp.op0 = TREE_OPERAND (ref, 1);
893 temp.off = 0;
894 break;
895 case MEM_REF:
896 /* The base address gets its own vn_reference_op_s structure. */
897 temp.op0 = TREE_OPERAND (ref, 1);
898 if (!mem_ref_offset (ref).to_shwi (&temp.off))
899 temp.off = -1;
900 temp.clique = MR_DEPENDENCE_CLIQUE (ref);
901 temp.base = MR_DEPENDENCE_BASE (ref);
902 temp.reverse = REF_REVERSE_STORAGE_ORDER (ref);
903 break;
904 case TARGET_MEM_REF:
905 /* The base address gets its own vn_reference_op_s structure. */
906 temp.op0 = TMR_INDEX (ref);
907 temp.op1 = TMR_STEP (ref);
908 temp.op2 = TMR_OFFSET (ref);
909 temp.clique = MR_DEPENDENCE_CLIQUE (ref);
910 temp.base = MR_DEPENDENCE_BASE (ref);
911 result->safe_push (temp);
912 memset (&temp, 0, sizeof (temp));
913 temp.type = NULL_TREE;
914 temp.opcode = ERROR_MARK;
915 temp.op0 = TMR_INDEX2 (ref);
916 temp.off = -1;
917 break;
918 case BIT_FIELD_REF:
919 /* Record bits, position and storage order. */
920 temp.op0 = TREE_OPERAND (ref, 1);
921 temp.op1 = TREE_OPERAND (ref, 2);
922 if (!multiple_p (bit_field_offset (ref), BITS_PER_UNIT, &temp.off))
923 temp.off = -1;
924 temp.reverse = REF_REVERSE_STORAGE_ORDER (ref);
925 break;
926 case COMPONENT_REF:
927 /* The field decl is enough to unambiguously specify the field,
928 so use its type here. */
929 temp.type = TREE_TYPE (TREE_OPERAND (ref, 1));
930 temp.op0 = TREE_OPERAND (ref, 1);
931 temp.op1 = TREE_OPERAND (ref, 2);
932 temp.reverse = (AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (ref, 0)))
933 && TYPE_REVERSE_STORAGE_ORDER
934 (TREE_TYPE (TREE_OPERAND (ref, 0))));
936 tree this_offset = component_ref_field_offset (ref);
937 if (this_offset
938 && poly_int_tree_p (this_offset))
940 tree bit_offset = DECL_FIELD_BIT_OFFSET (TREE_OPERAND (ref, 1));
941 if (TREE_INT_CST_LOW (bit_offset) % BITS_PER_UNIT == 0)
943 poly_offset_int off
944 = (wi::to_poly_offset (this_offset)
945 + (wi::to_offset (bit_offset) >> LOG2_BITS_PER_UNIT));
946 /* Probibit value-numbering zero offset components
947 of addresses the same before the pass folding
948 __builtin_object_size had a chance to run. */
949 if (TREE_CODE (orig) != ADDR_EXPR
950 || maybe_ne (off, 0)
951 || (cfun->curr_properties & PROP_objsz))
952 off.to_shwi (&temp.off);
956 break;
957 case ARRAY_RANGE_REF:
958 case ARRAY_REF:
960 tree eltype = TREE_TYPE (TREE_TYPE (TREE_OPERAND (ref, 0)));
961 /* Record index as operand. */
962 temp.op0 = TREE_OPERAND (ref, 1);
963 /* Always record lower bounds and element size. */
964 temp.op1 = array_ref_low_bound (ref);
965 /* But record element size in units of the type alignment. */
966 temp.op2 = TREE_OPERAND (ref, 3);
967 temp.align = eltype->type_common.align;
968 if (! temp.op2)
969 temp.op2 = size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (eltype),
970 size_int (TYPE_ALIGN_UNIT (eltype)));
971 if (poly_int_tree_p (temp.op0)
972 && poly_int_tree_p (temp.op1)
973 && TREE_CODE (temp.op2) == INTEGER_CST)
975 poly_offset_int off = ((wi::to_poly_offset (temp.op0)
976 - wi::to_poly_offset (temp.op1))
977 * wi::to_offset (temp.op2)
978 * vn_ref_op_align_unit (&temp));
979 off.to_shwi (&temp.off);
981 temp.reverse = (AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (ref, 0)))
982 && TYPE_REVERSE_STORAGE_ORDER
983 (TREE_TYPE (TREE_OPERAND (ref, 0))));
985 break;
986 case VAR_DECL:
987 if (DECL_HARD_REGISTER (ref))
989 temp.op0 = ref;
990 break;
992 /* Fallthru. */
993 case PARM_DECL:
994 case CONST_DECL:
995 case RESULT_DECL:
996 /* Canonicalize decls to MEM[&decl] which is what we end up with
997 when valueizing MEM[ptr] with ptr = &decl. */
998 temp.opcode = MEM_REF;
999 temp.op0 = build_int_cst (build_pointer_type (TREE_TYPE (ref)), 0);
1000 temp.off = 0;
1001 result->safe_push (temp);
1002 temp.opcode = ADDR_EXPR;
1003 temp.op0 = build1 (ADDR_EXPR, TREE_TYPE (temp.op0), ref);
1004 temp.type = TREE_TYPE (temp.op0);
1005 temp.off = -1;
1006 break;
1007 case STRING_CST:
1008 case INTEGER_CST:
1009 case POLY_INT_CST:
1010 case COMPLEX_CST:
1011 case VECTOR_CST:
1012 case REAL_CST:
1013 case FIXED_CST:
1014 case CONSTRUCTOR:
1015 case SSA_NAME:
1016 temp.op0 = ref;
1017 break;
1018 case ADDR_EXPR:
1019 if (is_gimple_min_invariant (ref))
1021 temp.op0 = ref;
1022 break;
1024 break;
1025 /* These are only interesting for their operands, their
1026 existence, and their type. They will never be the last
1027 ref in the chain of references (IE they require an
1028 operand), so we don't have to put anything
1029 for op* as it will be handled by the iteration */
1030 case REALPART_EXPR:
1031 temp.off = 0;
1032 break;
1033 case VIEW_CONVERT_EXPR:
1034 temp.off = 0;
1035 temp.reverse = storage_order_barrier_p (ref);
1036 break;
1037 case IMAGPART_EXPR:
1038 /* This is only interesting for its constant offset. */
1039 temp.off = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (ref)));
1040 break;
1041 default:
1042 gcc_unreachable ();
1044 result->safe_push (temp);
1046 if (REFERENCE_CLASS_P (ref)
1047 || TREE_CODE (ref) == MODIFY_EXPR
1048 || TREE_CODE (ref) == WITH_SIZE_EXPR
1049 || (TREE_CODE (ref) == ADDR_EXPR
1050 && !is_gimple_min_invariant (ref)))
1051 ref = TREE_OPERAND (ref, 0);
1052 else
1053 ref = NULL_TREE;
1057 /* Build a alias-oracle reference abstraction in *REF from the vn_reference
1058 operands in *OPS, the reference alias set SET and the reference type TYPE.
1059 Return true if something useful was produced. */
1061 bool
1062 ao_ref_init_from_vn_reference (ao_ref *ref,
1063 alias_set_type set, alias_set_type base_set,
1064 tree type, const vec<vn_reference_op_s> &ops)
1066 unsigned i;
1067 tree base = NULL_TREE;
1068 tree *op0_p = &base;
1069 poly_offset_int offset = 0;
1070 poly_offset_int max_size;
1071 poly_offset_int size = -1;
1072 tree size_tree = NULL_TREE;
1074 /* We don't handle calls. */
1075 if (!type)
1076 return false;
1078 machine_mode mode = TYPE_MODE (type);
1079 if (mode == BLKmode)
1080 size_tree = TYPE_SIZE (type);
1081 else
1082 size = GET_MODE_BITSIZE (mode);
1083 if (size_tree != NULL_TREE
1084 && poly_int_tree_p (size_tree))
1085 size = wi::to_poly_offset (size_tree);
1087 /* Lower the final access size from the outermost expression. */
1088 const_vn_reference_op_t cst_op = &ops[0];
1089 /* Cast away constness for the sake of the const-unsafe
1090 FOR_EACH_VEC_ELT(). */
1091 vn_reference_op_t op = const_cast<vn_reference_op_t>(cst_op);
1092 size_tree = NULL_TREE;
1093 if (op->opcode == COMPONENT_REF)
1094 size_tree = DECL_SIZE (op->op0);
1095 else if (op->opcode == BIT_FIELD_REF)
1096 size_tree = op->op0;
1097 if (size_tree != NULL_TREE
1098 && poly_int_tree_p (size_tree)
1099 && (!known_size_p (size)
1100 || known_lt (wi::to_poly_offset (size_tree), size)))
1101 size = wi::to_poly_offset (size_tree);
1103 /* Initially, maxsize is the same as the accessed element size.
1104 In the following it will only grow (or become -1). */
1105 max_size = size;
1107 /* Compute cumulative bit-offset for nested component-refs and array-refs,
1108 and find the ultimate containing object. */
1109 FOR_EACH_VEC_ELT (ops, i, op)
1111 switch (op->opcode)
1113 /* These may be in the reference ops, but we cannot do anything
1114 sensible with them here. */
1115 case ADDR_EXPR:
1116 /* Apart from ADDR_EXPR arguments to MEM_REF. */
1117 if (base != NULL_TREE
1118 && TREE_CODE (base) == MEM_REF
1119 && op->op0
1120 && DECL_P (TREE_OPERAND (op->op0, 0)))
1122 const_vn_reference_op_t pop = &ops[i-1];
1123 base = TREE_OPERAND (op->op0, 0);
1124 if (known_eq (pop->off, -1))
1126 max_size = -1;
1127 offset = 0;
1129 else
1130 offset += pop->off * BITS_PER_UNIT;
1131 op0_p = NULL;
1132 break;
1134 /* Fallthru. */
1135 case CALL_EXPR:
1136 return false;
1138 /* Record the base objects. */
1139 case MEM_REF:
1140 *op0_p = build2 (MEM_REF, op->type,
1141 NULL_TREE, op->op0);
1142 MR_DEPENDENCE_CLIQUE (*op0_p) = op->clique;
1143 MR_DEPENDENCE_BASE (*op0_p) = op->base;
1144 op0_p = &TREE_OPERAND (*op0_p, 0);
1145 break;
1147 case VAR_DECL:
1148 case PARM_DECL:
1149 case RESULT_DECL:
1150 case SSA_NAME:
1151 *op0_p = op->op0;
1152 op0_p = NULL;
1153 break;
1155 /* And now the usual component-reference style ops. */
1156 case BIT_FIELD_REF:
1157 offset += wi::to_poly_offset (op->op1);
1158 break;
1160 case COMPONENT_REF:
1162 tree field = op->op0;
1163 /* We do not have a complete COMPONENT_REF tree here so we
1164 cannot use component_ref_field_offset. Do the interesting
1165 parts manually. */
1166 tree this_offset = DECL_FIELD_OFFSET (field);
1168 if (op->op1 || !poly_int_tree_p (this_offset))
1169 max_size = -1;
1170 else
1172 poly_offset_int woffset = (wi::to_poly_offset (this_offset)
1173 << LOG2_BITS_PER_UNIT);
1174 woffset += wi::to_offset (DECL_FIELD_BIT_OFFSET (field));
1175 offset += woffset;
1177 break;
1180 case ARRAY_RANGE_REF:
1181 case ARRAY_REF:
1182 /* We recorded the lower bound and the element size. */
1183 if (!poly_int_tree_p (op->op0)
1184 || !poly_int_tree_p (op->op1)
1185 || TREE_CODE (op->op2) != INTEGER_CST)
1186 max_size = -1;
1187 else
1189 poly_offset_int woffset
1190 = wi::sext (wi::to_poly_offset (op->op0)
1191 - wi::to_poly_offset (op->op1),
1192 TYPE_PRECISION (sizetype));
1193 woffset *= wi::to_offset (op->op2) * vn_ref_op_align_unit (op);
1194 woffset <<= LOG2_BITS_PER_UNIT;
1195 offset += woffset;
1197 break;
1199 case REALPART_EXPR:
1200 break;
1202 case IMAGPART_EXPR:
1203 offset += size;
1204 break;
1206 case VIEW_CONVERT_EXPR:
1207 break;
1209 case STRING_CST:
1210 case INTEGER_CST:
1211 case COMPLEX_CST:
1212 case VECTOR_CST:
1213 case REAL_CST:
1214 case CONSTRUCTOR:
1215 case CONST_DECL:
1216 return false;
1218 default:
1219 return false;
1223 if (base == NULL_TREE)
1224 return false;
1226 ref->ref = NULL_TREE;
1227 ref->base = base;
1228 ref->ref_alias_set = set;
1229 ref->base_alias_set = base_set;
1230 /* We discount volatiles from value-numbering elsewhere. */
1231 ref->volatile_p = false;
1233 if (!size.to_shwi (&ref->size) || maybe_lt (ref->size, 0))
1235 ref->offset = 0;
1236 ref->size = -1;
1237 ref->max_size = -1;
1238 return true;
1241 if (!offset.to_shwi (&ref->offset))
1243 ref->offset = 0;
1244 ref->max_size = -1;
1245 return true;
1248 if (!max_size.to_shwi (&ref->max_size) || maybe_lt (ref->max_size, 0))
1249 ref->max_size = -1;
1251 return true;
1254 /* Copy the operations present in load/store/call REF into RESULT, a vector of
1255 vn_reference_op_s's. */
1257 static void
1258 copy_reference_ops_from_call (gcall *call,
1259 vec<vn_reference_op_s> *result)
1261 vn_reference_op_s temp;
1262 unsigned i;
1263 tree lhs = gimple_call_lhs (call);
1264 int lr;
1266 /* If 2 calls have a different non-ssa lhs, vdef value numbers should be
1267 different. By adding the lhs here in the vector, we ensure that the
1268 hashcode is different, guaranteeing a different value number. */
1269 if (lhs && TREE_CODE (lhs) != SSA_NAME)
1271 memset (&temp, 0, sizeof (temp));
1272 temp.opcode = MODIFY_EXPR;
1273 temp.type = TREE_TYPE (lhs);
1274 temp.op0 = lhs;
1275 temp.off = -1;
1276 result->safe_push (temp);
1279 /* Copy the type, opcode, function, static chain and EH region, if any. */
1280 memset (&temp, 0, sizeof (temp));
1281 temp.type = gimple_call_fntype (call);
1282 temp.opcode = CALL_EXPR;
1283 temp.op0 = gimple_call_fn (call);
1284 if (gimple_call_internal_p (call))
1285 temp.clique = gimple_call_internal_fn (call);
1286 temp.op1 = gimple_call_chain (call);
1287 if (stmt_could_throw_p (cfun, call) && (lr = lookup_stmt_eh_lp (call)) > 0)
1288 temp.op2 = size_int (lr);
1289 temp.off = -1;
1290 result->safe_push (temp);
1292 /* Copy the call arguments. As they can be references as well,
1293 just chain them together. */
1294 for (i = 0; i < gimple_call_num_args (call); ++i)
1296 tree callarg = gimple_call_arg (call, i);
1297 copy_reference_ops_from_ref (callarg, result);
1301 /* Fold *& at position *I_P in a vn_reference_op_s vector *OPS. Updates
1302 *I_P to point to the last element of the replacement. */
1303 static bool
1304 vn_reference_fold_indirect (vec<vn_reference_op_s> *ops,
1305 unsigned int *i_p)
1307 unsigned int i = *i_p;
1308 vn_reference_op_t op = &(*ops)[i];
1309 vn_reference_op_t mem_op = &(*ops)[i - 1];
1310 tree addr_base;
1311 poly_int64 addr_offset = 0;
1313 /* The only thing we have to do is from &OBJ.foo.bar add the offset
1314 from .foo.bar to the preceding MEM_REF offset and replace the
1315 address with &OBJ. */
1316 addr_base = get_addr_base_and_unit_offset_1 (TREE_OPERAND (op->op0, 0),
1317 &addr_offset, vn_valueize);
1318 gcc_checking_assert (addr_base && TREE_CODE (addr_base) != MEM_REF);
1319 if (addr_base != TREE_OPERAND (op->op0, 0))
1321 poly_offset_int off
1322 = (poly_offset_int::from (wi::to_poly_wide (mem_op->op0),
1323 SIGNED)
1324 + addr_offset);
1325 mem_op->op0 = wide_int_to_tree (TREE_TYPE (mem_op->op0), off);
1326 op->op0 = build_fold_addr_expr (addr_base);
1327 if (tree_fits_shwi_p (mem_op->op0))
1328 mem_op->off = tree_to_shwi (mem_op->op0);
1329 else
1330 mem_op->off = -1;
1331 return true;
1333 return false;
1336 /* Fold *& at position *I_P in a vn_reference_op_s vector *OPS. Updates
1337 *I_P to point to the last element of the replacement. */
1338 static bool
1339 vn_reference_maybe_forwprop_address (vec<vn_reference_op_s> *ops,
1340 unsigned int *i_p)
1342 bool changed = false;
1343 vn_reference_op_t op;
1347 unsigned int i = *i_p;
1348 op = &(*ops)[i];
1349 vn_reference_op_t mem_op = &(*ops)[i - 1];
1350 gimple *def_stmt;
1351 enum tree_code code;
1352 poly_offset_int off;
1354 def_stmt = SSA_NAME_DEF_STMT (op->op0);
1355 if (!is_gimple_assign (def_stmt))
1356 return changed;
1358 code = gimple_assign_rhs_code (def_stmt);
1359 if (code != ADDR_EXPR
1360 && code != POINTER_PLUS_EXPR)
1361 return changed;
1363 off = poly_offset_int::from (wi::to_poly_wide (mem_op->op0), SIGNED);
1365 /* The only thing we have to do is from &OBJ.foo.bar add the offset
1366 from .foo.bar to the preceding MEM_REF offset and replace the
1367 address with &OBJ. */
1368 if (code == ADDR_EXPR)
1370 tree addr, addr_base;
1371 poly_int64 addr_offset;
1373 addr = gimple_assign_rhs1 (def_stmt);
1374 addr_base = get_addr_base_and_unit_offset_1 (TREE_OPERAND (addr, 0),
1375 &addr_offset,
1376 vn_valueize);
1377 /* If that didn't work because the address isn't invariant propagate
1378 the reference tree from the address operation in case the current
1379 dereference isn't offsetted. */
1380 if (!addr_base
1381 && *i_p == ops->length () - 1
1382 && known_eq (off, 0)
1383 /* This makes us disable this transform for PRE where the
1384 reference ops might be also used for code insertion which
1385 is invalid. */
1386 && default_vn_walk_kind == VN_WALKREWRITE)
1388 auto_vec<vn_reference_op_s, 32> tem;
1389 copy_reference_ops_from_ref (TREE_OPERAND (addr, 0), &tem);
1390 /* Make sure to preserve TBAA info. The only objects not
1391 wrapped in MEM_REFs that can have their address taken are
1392 STRING_CSTs. */
1393 if (tem.length () >= 2
1394 && tem[tem.length () - 2].opcode == MEM_REF)
1396 vn_reference_op_t new_mem_op = &tem[tem.length () - 2];
1397 new_mem_op->op0
1398 = wide_int_to_tree (TREE_TYPE (mem_op->op0),
1399 wi::to_poly_wide (new_mem_op->op0));
1401 else
1402 gcc_assert (tem.last ().opcode == STRING_CST);
1403 ops->pop ();
1404 ops->pop ();
1405 ops->safe_splice (tem);
1406 --*i_p;
1407 return true;
1409 if (!addr_base
1410 || TREE_CODE (addr_base) != MEM_REF
1411 || (TREE_CODE (TREE_OPERAND (addr_base, 0)) == SSA_NAME
1412 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (addr_base,
1413 0))))
1414 return changed;
1416 off += addr_offset;
1417 off += mem_ref_offset (addr_base);
1418 op->op0 = TREE_OPERAND (addr_base, 0);
1420 else
1422 tree ptr, ptroff;
1423 ptr = gimple_assign_rhs1 (def_stmt);
1424 ptroff = gimple_assign_rhs2 (def_stmt);
1425 if (TREE_CODE (ptr) != SSA_NAME
1426 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ptr)
1427 /* Make sure to not endlessly recurse.
1428 See gcc.dg/tree-ssa/20040408-1.c for an example. Can easily
1429 happen when we value-number a PHI to its backedge value. */
1430 || SSA_VAL (ptr) == op->op0
1431 || !poly_int_tree_p (ptroff))
1432 return changed;
1434 off += wi::to_poly_offset (ptroff);
1435 op->op0 = ptr;
1438 mem_op->op0 = wide_int_to_tree (TREE_TYPE (mem_op->op0), off);
1439 if (tree_fits_shwi_p (mem_op->op0))
1440 mem_op->off = tree_to_shwi (mem_op->op0);
1441 else
1442 mem_op->off = -1;
1443 /* ??? Can end up with endless recursion here!?
1444 gcc.c-torture/execute/strcmp-1.c */
1445 if (TREE_CODE (op->op0) == SSA_NAME)
1446 op->op0 = SSA_VAL (op->op0);
1447 if (TREE_CODE (op->op0) != SSA_NAME)
1448 op->opcode = TREE_CODE (op->op0);
1450 changed = true;
1452 /* Tail-recurse. */
1453 while (TREE_CODE (op->op0) == SSA_NAME);
1455 /* Fold a remaining *&. */
1456 if (TREE_CODE (op->op0) == ADDR_EXPR)
1457 vn_reference_fold_indirect (ops, i_p);
1459 return changed;
1462 /* Optimize the reference REF to a constant if possible or return
1463 NULL_TREE if not. */
1465 tree
1466 fully_constant_vn_reference_p (vn_reference_t ref)
1468 vec<vn_reference_op_s> operands = ref->operands;
1469 vn_reference_op_t op;
1471 /* Try to simplify the translated expression if it is
1472 a call to a builtin function with at most two arguments. */
1473 op = &operands[0];
1474 if (op->opcode == CALL_EXPR
1475 && (!op->op0
1476 || (TREE_CODE (op->op0) == ADDR_EXPR
1477 && TREE_CODE (TREE_OPERAND (op->op0, 0)) == FUNCTION_DECL
1478 && fndecl_built_in_p (TREE_OPERAND (op->op0, 0),
1479 BUILT_IN_NORMAL)))
1480 && operands.length () >= 2
1481 && operands.length () <= 3)
1483 vn_reference_op_t arg0, arg1 = NULL;
1484 bool anyconst = false;
1485 arg0 = &operands[1];
1486 if (operands.length () > 2)
1487 arg1 = &operands[2];
1488 if (TREE_CODE_CLASS (arg0->opcode) == tcc_constant
1489 || (arg0->opcode == ADDR_EXPR
1490 && is_gimple_min_invariant (arg0->op0)))
1491 anyconst = true;
1492 if (arg1
1493 && (TREE_CODE_CLASS (arg1->opcode) == tcc_constant
1494 || (arg1->opcode == ADDR_EXPR
1495 && is_gimple_min_invariant (arg1->op0))))
1496 anyconst = true;
1497 if (anyconst)
1499 combined_fn fn;
1500 if (op->op0)
1501 fn = as_combined_fn (DECL_FUNCTION_CODE
1502 (TREE_OPERAND (op->op0, 0)));
1503 else
1504 fn = as_combined_fn ((internal_fn) op->clique);
1505 tree folded;
1506 if (arg1)
1507 folded = fold_const_call (fn, ref->type, arg0->op0, arg1->op0);
1508 else
1509 folded = fold_const_call (fn, ref->type, arg0->op0);
1510 if (folded
1511 && is_gimple_min_invariant (folded))
1512 return folded;
1516 /* Simplify reads from constants or constant initializers. */
1517 else if (BITS_PER_UNIT == 8
1518 && ref->type
1519 && COMPLETE_TYPE_P (ref->type)
1520 && is_gimple_reg_type (ref->type))
1522 poly_int64 off = 0;
1523 HOST_WIDE_INT size;
1524 if (INTEGRAL_TYPE_P (ref->type))
1525 size = TYPE_PRECISION (ref->type);
1526 else if (tree_fits_shwi_p (TYPE_SIZE (ref->type)))
1527 size = tree_to_shwi (TYPE_SIZE (ref->type));
1528 else
1529 return NULL_TREE;
1530 if (size % BITS_PER_UNIT != 0
1531 || size > MAX_BITSIZE_MODE_ANY_MODE)
1532 return NULL_TREE;
1533 size /= BITS_PER_UNIT;
1534 unsigned i;
1535 for (i = 0; i < operands.length (); ++i)
1537 if (TREE_CODE_CLASS (operands[i].opcode) == tcc_constant)
1539 ++i;
1540 break;
1542 if (known_eq (operands[i].off, -1))
1543 return NULL_TREE;
1544 off += operands[i].off;
1545 if (operands[i].opcode == MEM_REF)
1547 ++i;
1548 break;
1551 vn_reference_op_t base = &operands[--i];
1552 tree ctor = error_mark_node;
1553 tree decl = NULL_TREE;
1554 if (TREE_CODE_CLASS (base->opcode) == tcc_constant)
1555 ctor = base->op0;
1556 else if (base->opcode == MEM_REF
1557 && base[1].opcode == ADDR_EXPR
1558 && (TREE_CODE (TREE_OPERAND (base[1].op0, 0)) == VAR_DECL
1559 || TREE_CODE (TREE_OPERAND (base[1].op0, 0)) == CONST_DECL
1560 || TREE_CODE (TREE_OPERAND (base[1].op0, 0)) == STRING_CST))
1562 decl = TREE_OPERAND (base[1].op0, 0);
1563 if (TREE_CODE (decl) == STRING_CST)
1564 ctor = decl;
1565 else
1566 ctor = ctor_for_folding (decl);
1568 if (ctor == NULL_TREE)
1569 return build_zero_cst (ref->type);
1570 else if (ctor != error_mark_node)
1572 HOST_WIDE_INT const_off;
1573 if (decl)
1575 tree res = fold_ctor_reference (ref->type, ctor,
1576 off * BITS_PER_UNIT,
1577 size * BITS_PER_UNIT, decl);
1578 if (res)
1580 STRIP_USELESS_TYPE_CONVERSION (res);
1581 if (is_gimple_min_invariant (res))
1582 return res;
1585 else if (off.is_constant (&const_off))
1587 unsigned char buf[MAX_BITSIZE_MODE_ANY_MODE / BITS_PER_UNIT];
1588 int len = native_encode_expr (ctor, buf, size, const_off);
1589 if (len > 0)
1590 return native_interpret_expr (ref->type, buf, len);
1595 return NULL_TREE;
1598 /* Return true if OPS contain a storage order barrier. */
1600 static bool
1601 contains_storage_order_barrier_p (vec<vn_reference_op_s> ops)
1603 vn_reference_op_t op;
1604 unsigned i;
1606 FOR_EACH_VEC_ELT (ops, i, op)
1607 if (op->opcode == VIEW_CONVERT_EXPR && op->reverse)
1608 return true;
1610 return false;
1613 /* Return true if OPS represent an access with reverse storage order. */
1615 static bool
1616 reverse_storage_order_for_component_p (vec<vn_reference_op_s> ops)
1618 unsigned i = 0;
1619 if (ops[i].opcode == REALPART_EXPR || ops[i].opcode == IMAGPART_EXPR)
1620 ++i;
1621 switch (ops[i].opcode)
1623 case ARRAY_REF:
1624 case COMPONENT_REF:
1625 case BIT_FIELD_REF:
1626 case MEM_REF:
1627 return ops[i].reverse;
1628 default:
1629 return false;
1633 /* Transform any SSA_NAME's in a vector of vn_reference_op_s
1634 structures into their value numbers. This is done in-place, and
1635 the vector passed in is returned. *VALUEIZED_ANYTHING will specify
1636 whether any operands were valueized. */
1638 static void
1639 valueize_refs_1 (vec<vn_reference_op_s> *orig, bool *valueized_anything,
1640 bool with_avail = false)
1642 *valueized_anything = false;
1644 for (unsigned i = 0; i < orig->length (); ++i)
1646 re_valueize:
1647 vn_reference_op_t vro = &(*orig)[i];
1648 if (vro->opcode == SSA_NAME
1649 || (vro->op0 && TREE_CODE (vro->op0) == SSA_NAME))
1651 tree tem = with_avail ? vn_valueize (vro->op0) : SSA_VAL (vro->op0);
1652 if (tem != vro->op0)
1654 *valueized_anything = true;
1655 vro->op0 = tem;
1657 /* If it transforms from an SSA_NAME to a constant, update
1658 the opcode. */
1659 if (TREE_CODE (vro->op0) != SSA_NAME && vro->opcode == SSA_NAME)
1660 vro->opcode = TREE_CODE (vro->op0);
1662 if (vro->op1 && TREE_CODE (vro->op1) == SSA_NAME)
1664 tree tem = with_avail ? vn_valueize (vro->op1) : SSA_VAL (vro->op1);
1665 if (tem != vro->op1)
1667 *valueized_anything = true;
1668 vro->op1 = tem;
1671 if (vro->op2 && TREE_CODE (vro->op2) == SSA_NAME)
1673 tree tem = with_avail ? vn_valueize (vro->op2) : SSA_VAL (vro->op2);
1674 if (tem != vro->op2)
1676 *valueized_anything = true;
1677 vro->op2 = tem;
1680 /* If it transforms from an SSA_NAME to an address, fold with
1681 a preceding indirect reference. */
1682 if (i > 0
1683 && vro->op0
1684 && TREE_CODE (vro->op0) == ADDR_EXPR
1685 && (*orig)[i - 1].opcode == MEM_REF)
1687 if (vn_reference_fold_indirect (orig, &i))
1688 *valueized_anything = true;
1690 else if (i > 0
1691 && vro->opcode == SSA_NAME
1692 && (*orig)[i - 1].opcode == MEM_REF)
1694 if (vn_reference_maybe_forwprop_address (orig, &i))
1696 *valueized_anything = true;
1697 /* Re-valueize the current operand. */
1698 goto re_valueize;
1701 /* If it transforms a non-constant ARRAY_REF into a constant
1702 one, adjust the constant offset. */
1703 else if (vro->opcode == ARRAY_REF
1704 && known_eq (vro->off, -1)
1705 && poly_int_tree_p (vro->op0)
1706 && poly_int_tree_p (vro->op1)
1707 && TREE_CODE (vro->op2) == INTEGER_CST)
1709 poly_offset_int off = ((wi::to_poly_offset (vro->op0)
1710 - wi::to_poly_offset (vro->op1))
1711 * wi::to_offset (vro->op2)
1712 * vn_ref_op_align_unit (vro));
1713 off.to_shwi (&vro->off);
1718 static void
1719 valueize_refs (vec<vn_reference_op_s> *orig)
1721 bool tem;
1722 valueize_refs_1 (orig, &tem);
1725 static vec<vn_reference_op_s> shared_lookup_references;
1727 /* Create a vector of vn_reference_op_s structures from REF, a
1728 REFERENCE_CLASS_P tree. The vector is shared among all callers of
1729 this function. *VALUEIZED_ANYTHING will specify whether any
1730 operands were valueized. */
1732 static vec<vn_reference_op_s>
1733 valueize_shared_reference_ops_from_ref (tree ref, bool *valueized_anything)
1735 if (!ref)
1736 return vNULL;
1737 shared_lookup_references.truncate (0);
1738 copy_reference_ops_from_ref (ref, &shared_lookup_references);
1739 valueize_refs_1 (&shared_lookup_references, valueized_anything);
1740 return shared_lookup_references;
1743 /* Create a vector of vn_reference_op_s structures from CALL, a
1744 call statement. The vector is shared among all callers of
1745 this function. */
1747 static vec<vn_reference_op_s>
1748 valueize_shared_reference_ops_from_call (gcall *call)
1750 if (!call)
1751 return vNULL;
1752 shared_lookup_references.truncate (0);
1753 copy_reference_ops_from_call (call, &shared_lookup_references);
1754 valueize_refs (&shared_lookup_references);
1755 return shared_lookup_references;
1758 /* Lookup a SCCVN reference operation VR in the current hash table.
1759 Returns the resulting value number if it exists in the hash table,
1760 NULL_TREE otherwise. VNRESULT will be filled in with the actual
1761 vn_reference_t stored in the hashtable if something is found. */
1763 static tree
1764 vn_reference_lookup_1 (vn_reference_t vr, vn_reference_t *vnresult)
1766 vn_reference_s **slot;
1767 hashval_t hash;
1769 hash = vr->hashcode;
1770 slot = valid_info->references->find_slot_with_hash (vr, hash, NO_INSERT);
1771 if (slot)
1773 if (vnresult)
1774 *vnresult = (vn_reference_t)*slot;
1775 return ((vn_reference_t)*slot)->result;
1778 return NULL_TREE;
1782 /* Partial definition tracking support. */
1784 struct pd_range
1786 HOST_WIDE_INT offset;
1787 HOST_WIDE_INT size;
1790 struct pd_data
1792 tree rhs;
1793 HOST_WIDE_INT rhs_off;
1794 HOST_WIDE_INT offset;
1795 HOST_WIDE_INT size;
1798 /* Context for alias walking. */
1800 struct vn_walk_cb_data
1802 vn_walk_cb_data (vn_reference_t vr_, tree orig_ref_, tree *last_vuse_ptr_,
1803 vn_lookup_kind vn_walk_kind_, bool tbaa_p_, tree mask_,
1804 bool redundant_store_removal_p_)
1805 : vr (vr_), last_vuse_ptr (last_vuse_ptr_), last_vuse (NULL_TREE),
1806 mask (mask_), masked_result (NULL_TREE), same_val (NULL_TREE),
1807 vn_walk_kind (vn_walk_kind_),
1808 tbaa_p (tbaa_p_), redundant_store_removal_p (redundant_store_removal_p_),
1809 saved_operands (vNULL), first_set (-2), first_base_set (-2),
1810 known_ranges (NULL)
1812 if (!last_vuse_ptr)
1813 last_vuse_ptr = &last_vuse;
1814 ao_ref_init (&orig_ref, orig_ref_);
1815 if (mask)
1817 wide_int w = wi::to_wide (mask);
1818 unsigned int pos = 0, prec = w.get_precision ();
1819 pd_data pd;
1820 pd.rhs = build_constructor (NULL_TREE, NULL);
1821 pd.rhs_off = 0;
1822 /* When bitwise and with a constant is done on a memory load,
1823 we don't really need all the bits to be defined or defined
1824 to constants, we don't really care what is in the position
1825 corresponding to 0 bits in the mask.
1826 So, push the ranges of those 0 bits in the mask as artificial
1827 zero stores and let the partial def handling code do the
1828 rest. */
1829 while (pos < prec)
1831 int tz = wi::ctz (w);
1832 if (pos + tz > prec)
1833 tz = prec - pos;
1834 if (tz)
1836 if (BYTES_BIG_ENDIAN)
1837 pd.offset = prec - pos - tz;
1838 else
1839 pd.offset = pos;
1840 pd.size = tz;
1841 void *r = push_partial_def (pd, 0, 0, 0, prec);
1842 gcc_assert (r == NULL_TREE);
1844 pos += tz;
1845 if (pos == prec)
1846 break;
1847 w = wi::lrshift (w, tz);
1848 tz = wi::ctz (wi::bit_not (w));
1849 if (pos + tz > prec)
1850 tz = prec - pos;
1851 pos += tz;
1852 w = wi::lrshift (w, tz);
1856 ~vn_walk_cb_data ();
1857 void *finish (alias_set_type, alias_set_type, tree);
1858 void *push_partial_def (pd_data pd,
1859 alias_set_type, alias_set_type, HOST_WIDE_INT,
1860 HOST_WIDE_INT);
1862 vn_reference_t vr;
1863 ao_ref orig_ref;
1864 tree *last_vuse_ptr;
1865 tree last_vuse;
1866 tree mask;
1867 tree masked_result;
1868 tree same_val;
1869 vn_lookup_kind vn_walk_kind;
1870 bool tbaa_p;
1871 bool redundant_store_removal_p;
1872 vec<vn_reference_op_s> saved_operands;
1874 /* The VDEFs of partial defs we come along. */
1875 auto_vec<pd_data, 2> partial_defs;
1876 /* The first defs range to avoid splay tree setup in most cases. */
1877 pd_range first_range;
1878 alias_set_type first_set;
1879 alias_set_type first_base_set;
1880 splay_tree known_ranges;
1881 obstack ranges_obstack;
1884 vn_walk_cb_data::~vn_walk_cb_data ()
1886 if (known_ranges)
1888 splay_tree_delete (known_ranges);
1889 obstack_free (&ranges_obstack, NULL);
1891 saved_operands.release ();
1894 void *
1895 vn_walk_cb_data::finish (alias_set_type set, alias_set_type base_set, tree val)
1897 if (first_set != -2)
1899 set = first_set;
1900 base_set = first_base_set;
1902 if (mask)
1904 masked_result = val;
1905 return (void *) -1;
1907 if (same_val && !operand_equal_p (val, same_val))
1908 return (void *) -1;
1909 vec<vn_reference_op_s> &operands
1910 = saved_operands.exists () ? saved_operands : vr->operands;
1911 return vn_reference_lookup_or_insert_for_pieces (last_vuse, set, base_set,
1912 vr->type, operands, val);
1915 /* pd_range splay-tree helpers. */
1917 static int
1918 pd_range_compare (splay_tree_key offset1p, splay_tree_key offset2p)
1920 HOST_WIDE_INT offset1 = *(HOST_WIDE_INT *)offset1p;
1921 HOST_WIDE_INT offset2 = *(HOST_WIDE_INT *)offset2p;
1922 if (offset1 < offset2)
1923 return -1;
1924 else if (offset1 > offset2)
1925 return 1;
1926 return 0;
1929 static void *
1930 pd_tree_alloc (int size, void *data_)
1932 vn_walk_cb_data *data = (vn_walk_cb_data *)data_;
1933 return obstack_alloc (&data->ranges_obstack, size);
1936 static void
1937 pd_tree_dealloc (void *, void *)
1941 /* Push PD to the vector of partial definitions returning a
1942 value when we are ready to combine things with VUSE, SET and MAXSIZEI,
1943 NULL when we want to continue looking for partial defs or -1
1944 on failure. */
1946 void *
1947 vn_walk_cb_data::push_partial_def (pd_data pd,
1948 alias_set_type set, alias_set_type base_set,
1949 HOST_WIDE_INT offseti,
1950 HOST_WIDE_INT maxsizei)
1952 const HOST_WIDE_INT bufsize = 64;
1953 /* We're using a fixed buffer for encoding so fail early if the object
1954 we want to interpret is bigger. */
1955 if (maxsizei > bufsize * BITS_PER_UNIT
1956 || CHAR_BIT != 8
1957 || BITS_PER_UNIT != 8
1958 /* Not prepared to handle PDP endian. */
1959 || BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN)
1960 return (void *)-1;
1962 /* Turn too large constant stores into non-constant stores. */
1963 if (CONSTANT_CLASS_P (pd.rhs) && pd.size > bufsize * BITS_PER_UNIT)
1964 pd.rhs = error_mark_node;
1966 /* And for non-constant or CONSTRUCTOR stores shrink them to only keep at
1967 most a partial byte before and/or after the region. */
1968 if (!CONSTANT_CLASS_P (pd.rhs))
1970 if (pd.offset < offseti)
1972 HOST_WIDE_INT o = ROUND_DOWN (offseti - pd.offset, BITS_PER_UNIT);
1973 gcc_assert (pd.size > o);
1974 pd.size -= o;
1975 pd.offset += o;
1977 if (pd.size > maxsizei)
1978 pd.size = maxsizei + ((pd.size - maxsizei) % BITS_PER_UNIT);
1981 pd.offset -= offseti;
1983 bool pd_constant_p = (TREE_CODE (pd.rhs) == CONSTRUCTOR
1984 || CONSTANT_CLASS_P (pd.rhs));
1985 pd_range *r;
1986 if (partial_defs.is_empty ())
1988 /* If we get a clobber upfront, fail. */
1989 if (TREE_CLOBBER_P (pd.rhs))
1990 return (void *)-1;
1991 if (!pd_constant_p)
1992 return (void *)-1;
1993 partial_defs.safe_push (pd);
1994 first_range.offset = pd.offset;
1995 first_range.size = pd.size;
1996 first_set = set;
1997 first_base_set = base_set;
1998 last_vuse_ptr = NULL;
1999 r = &first_range;
2000 /* Go check if the first partial definition was a full one in case
2001 the caller didn't optimize for this. */
2003 else
2005 if (!known_ranges)
2007 /* ??? Optimize the case where the 2nd partial def completes
2008 things. */
2009 gcc_obstack_init (&ranges_obstack);
2010 known_ranges = splay_tree_new_with_allocator (pd_range_compare, 0, 0,
2011 pd_tree_alloc,
2012 pd_tree_dealloc, this);
2013 splay_tree_insert (known_ranges,
2014 (splay_tree_key)&first_range.offset,
2015 (splay_tree_value)&first_range);
2018 pd_range newr = { pd.offset, pd.size };
2019 splay_tree_node n;
2020 /* Lookup the predecessor of offset + 1 and see if we need to merge. */
2021 HOST_WIDE_INT loffset = newr.offset + 1;
2022 if ((n = splay_tree_predecessor (known_ranges, (splay_tree_key)&loffset))
2023 && ((r = (pd_range *)n->value), true)
2024 && ranges_known_overlap_p (r->offset, r->size + 1,
2025 newr.offset, newr.size))
2027 /* Ignore partial defs already covered. Here we also drop shadowed
2028 clobbers arriving here at the floor. */
2029 if (known_subrange_p (newr.offset, newr.size, r->offset, r->size))
2030 return NULL;
2031 r->size
2032 = MAX (r->offset + r->size, newr.offset + newr.size) - r->offset;
2034 else
2036 /* newr.offset wasn't covered yet, insert the range. */
2037 r = XOBNEW (&ranges_obstack, pd_range);
2038 *r = newr;
2039 splay_tree_insert (known_ranges, (splay_tree_key)&r->offset,
2040 (splay_tree_value)r);
2042 /* Merge r which now contains newr and is a member of the splay tree with
2043 adjacent overlapping ranges. */
2044 pd_range *rafter;
2045 while ((n = splay_tree_successor (known_ranges,
2046 (splay_tree_key)&r->offset))
2047 && ((rafter = (pd_range *)n->value), true)
2048 && ranges_known_overlap_p (r->offset, r->size + 1,
2049 rafter->offset, rafter->size))
2051 r->size = MAX (r->offset + r->size,
2052 rafter->offset + rafter->size) - r->offset;
2053 splay_tree_remove (known_ranges, (splay_tree_key)&rafter->offset);
2055 /* If we get a clobber, fail. */
2056 if (TREE_CLOBBER_P (pd.rhs))
2057 return (void *)-1;
2058 /* Non-constants are OK as long as they are shadowed by a constant. */
2059 if (!pd_constant_p)
2060 return (void *)-1;
2061 partial_defs.safe_push (pd);
2064 /* Now we have merged newr into the range tree. When we have covered
2065 [offseti, sizei] then the tree will contain exactly one node which has
2066 the desired properties and it will be 'r'. */
2067 if (!known_subrange_p (0, maxsizei, r->offset, r->size))
2068 /* Continue looking for partial defs. */
2069 return NULL;
2071 /* Now simply native encode all partial defs in reverse order. */
2072 unsigned ndefs = partial_defs.length ();
2073 /* We support up to 512-bit values (for V8DFmode). */
2074 unsigned char buffer[bufsize + 1];
2075 unsigned char this_buffer[bufsize + 1];
2076 int len;
2078 memset (buffer, 0, bufsize + 1);
2079 unsigned needed_len = ROUND_UP (maxsizei, BITS_PER_UNIT) / BITS_PER_UNIT;
2080 while (!partial_defs.is_empty ())
2082 pd_data pd = partial_defs.pop ();
2083 unsigned int amnt;
2084 if (TREE_CODE (pd.rhs) == CONSTRUCTOR)
2086 /* Empty CONSTRUCTOR. */
2087 if (pd.size >= needed_len * BITS_PER_UNIT)
2088 len = needed_len;
2089 else
2090 len = ROUND_UP (pd.size, BITS_PER_UNIT) / BITS_PER_UNIT;
2091 memset (this_buffer, 0, len);
2093 else if (pd.rhs_off >= 0)
2095 len = native_encode_expr (pd.rhs, this_buffer, bufsize,
2096 (MAX (0, -pd.offset)
2097 + pd.rhs_off) / BITS_PER_UNIT);
2098 if (len <= 0
2099 || len < (ROUND_UP (pd.size, BITS_PER_UNIT) / BITS_PER_UNIT
2100 - MAX (0, -pd.offset) / BITS_PER_UNIT))
2102 if (dump_file && (dump_flags & TDF_DETAILS))
2103 fprintf (dump_file, "Failed to encode %u "
2104 "partial definitions\n", ndefs);
2105 return (void *)-1;
2108 else /* negative pd.rhs_off indicates we want to chop off first bits */
2110 if (-pd.rhs_off >= bufsize)
2111 return (void *)-1;
2112 len = native_encode_expr (pd.rhs,
2113 this_buffer + -pd.rhs_off / BITS_PER_UNIT,
2114 bufsize - -pd.rhs_off / BITS_PER_UNIT,
2115 MAX (0, -pd.offset) / BITS_PER_UNIT);
2116 if (len <= 0
2117 || len < (ROUND_UP (pd.size, BITS_PER_UNIT) / BITS_PER_UNIT
2118 - MAX (0, -pd.offset) / BITS_PER_UNIT))
2120 if (dump_file && (dump_flags & TDF_DETAILS))
2121 fprintf (dump_file, "Failed to encode %u "
2122 "partial definitions\n", ndefs);
2123 return (void *)-1;
2127 unsigned char *p = buffer;
2128 HOST_WIDE_INT size = pd.size;
2129 if (pd.offset < 0)
2130 size -= ROUND_DOWN (-pd.offset, BITS_PER_UNIT);
2131 this_buffer[len] = 0;
2132 if (BYTES_BIG_ENDIAN)
2134 /* LSB of this_buffer[len - 1] byte should be at
2135 pd.offset + pd.size - 1 bits in buffer. */
2136 amnt = ((unsigned HOST_WIDE_INT) pd.offset
2137 + pd.size) % BITS_PER_UNIT;
2138 if (amnt)
2139 shift_bytes_in_array_right (this_buffer, len + 1, amnt);
2140 unsigned char *q = this_buffer;
2141 unsigned int off = 0;
2142 if (pd.offset >= 0)
2144 unsigned int msk;
2145 off = pd.offset / BITS_PER_UNIT;
2146 gcc_assert (off < needed_len);
2147 p = buffer + off;
2148 if (size <= amnt)
2150 msk = ((1 << size) - 1) << (BITS_PER_UNIT - amnt);
2151 *p = (*p & ~msk) | (this_buffer[len] & msk);
2152 size = 0;
2154 else
2156 if (TREE_CODE (pd.rhs) != CONSTRUCTOR)
2157 q = (this_buffer + len
2158 - (ROUND_UP (size - amnt, BITS_PER_UNIT)
2159 / BITS_PER_UNIT));
2160 if (pd.offset % BITS_PER_UNIT)
2162 msk = -1U << (BITS_PER_UNIT
2163 - (pd.offset % BITS_PER_UNIT));
2164 *p = (*p & msk) | (*q & ~msk);
2165 p++;
2166 q++;
2167 off++;
2168 size -= BITS_PER_UNIT - (pd.offset % BITS_PER_UNIT);
2169 gcc_assert (size >= 0);
2173 else if (TREE_CODE (pd.rhs) != CONSTRUCTOR)
2175 q = (this_buffer + len
2176 - (ROUND_UP (size - amnt, BITS_PER_UNIT)
2177 / BITS_PER_UNIT));
2178 if (pd.offset % BITS_PER_UNIT)
2180 q++;
2181 size -= BITS_PER_UNIT - ((unsigned HOST_WIDE_INT) pd.offset
2182 % BITS_PER_UNIT);
2183 gcc_assert (size >= 0);
2186 if ((unsigned HOST_WIDE_INT) size / BITS_PER_UNIT + off
2187 > needed_len)
2188 size = (needed_len - off) * BITS_PER_UNIT;
2189 memcpy (p, q, size / BITS_PER_UNIT);
2190 if (size % BITS_PER_UNIT)
2192 unsigned int msk
2193 = -1U << (BITS_PER_UNIT - (size % BITS_PER_UNIT));
2194 p += size / BITS_PER_UNIT;
2195 q += size / BITS_PER_UNIT;
2196 *p = (*q & msk) | (*p & ~msk);
2199 else
2201 if (pd.offset >= 0)
2203 /* LSB of this_buffer[0] byte should be at pd.offset bits
2204 in buffer. */
2205 unsigned int msk;
2206 size = MIN (size, (HOST_WIDE_INT) needed_len * BITS_PER_UNIT);
2207 amnt = pd.offset % BITS_PER_UNIT;
2208 if (amnt)
2209 shift_bytes_in_array_left (this_buffer, len + 1, amnt);
2210 unsigned int off = pd.offset / BITS_PER_UNIT;
2211 gcc_assert (off < needed_len);
2212 size = MIN (size,
2213 (HOST_WIDE_INT) (needed_len - off) * BITS_PER_UNIT);
2214 p = buffer + off;
2215 if (amnt + size < BITS_PER_UNIT)
2217 /* Low amnt bits come from *p, then size bits
2218 from this_buffer[0] and the remaining again from
2219 *p. */
2220 msk = ((1 << size) - 1) << amnt;
2221 *p = (*p & ~msk) | (this_buffer[0] & msk);
2222 size = 0;
2224 else if (amnt)
2226 msk = -1U << amnt;
2227 *p = (*p & ~msk) | (this_buffer[0] & msk);
2228 p++;
2229 size -= (BITS_PER_UNIT - amnt);
2232 else
2234 amnt = (unsigned HOST_WIDE_INT) pd.offset % BITS_PER_UNIT;
2235 if (amnt)
2236 size -= BITS_PER_UNIT - amnt;
2237 size = MIN (size, (HOST_WIDE_INT) needed_len * BITS_PER_UNIT);
2238 if (amnt)
2239 shift_bytes_in_array_left (this_buffer, len + 1, amnt);
2241 memcpy (p, this_buffer + (amnt != 0), size / BITS_PER_UNIT);
2242 p += size / BITS_PER_UNIT;
2243 if (size % BITS_PER_UNIT)
2245 unsigned int msk = -1U << (size % BITS_PER_UNIT);
2246 *p = (this_buffer[(amnt != 0) + size / BITS_PER_UNIT]
2247 & ~msk) | (*p & msk);
2252 tree type = vr->type;
2253 /* Make sure to interpret in a type that has a range covering the whole
2254 access size. */
2255 if (INTEGRAL_TYPE_P (vr->type) && maxsizei != TYPE_PRECISION (vr->type))
2256 type = build_nonstandard_integer_type (maxsizei, TYPE_UNSIGNED (type));
2257 tree val;
2258 if (BYTES_BIG_ENDIAN)
2260 unsigned sz = needed_len;
2261 if (maxsizei % BITS_PER_UNIT)
2262 shift_bytes_in_array_right (buffer, needed_len,
2263 BITS_PER_UNIT
2264 - (maxsizei % BITS_PER_UNIT));
2265 if (INTEGRAL_TYPE_P (type))
2266 sz = GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type));
2267 if (sz > needed_len)
2269 memcpy (this_buffer + (sz - needed_len), buffer, needed_len);
2270 val = native_interpret_expr (type, this_buffer, sz);
2272 else
2273 val = native_interpret_expr (type, buffer, needed_len);
2275 else
2276 val = native_interpret_expr (type, buffer, bufsize);
2277 /* If we chop off bits because the types precision doesn't match the memory
2278 access size this is ok when optimizing reads but not when called from
2279 the DSE code during elimination. */
2280 if (val && type != vr->type)
2282 if (! int_fits_type_p (val, vr->type))
2283 val = NULL_TREE;
2284 else
2285 val = fold_convert (vr->type, val);
2288 if (val)
2290 if (dump_file && (dump_flags & TDF_DETAILS))
2291 fprintf (dump_file,
2292 "Successfully combined %u partial definitions\n", ndefs);
2293 /* We are using the alias-set of the first store we encounter which
2294 should be appropriate here. */
2295 return finish (first_set, first_base_set, val);
2297 else
2299 if (dump_file && (dump_flags & TDF_DETAILS))
2300 fprintf (dump_file,
2301 "Failed to interpret %u encoded partial definitions\n", ndefs);
2302 return (void *)-1;
2306 /* Callback for walk_non_aliased_vuses. Adjusts the vn_reference_t VR_
2307 with the current VUSE and performs the expression lookup. */
2309 static void *
2310 vn_reference_lookup_2 (ao_ref *op ATTRIBUTE_UNUSED, tree vuse, void *data_)
2312 vn_walk_cb_data *data = (vn_walk_cb_data *)data_;
2313 vn_reference_t vr = data->vr;
2314 vn_reference_s **slot;
2315 hashval_t hash;
2317 /* If we have partial definitions recorded we have to go through
2318 vn_reference_lookup_3. */
2319 if (!data->partial_defs.is_empty ())
2320 return NULL;
2322 if (data->last_vuse_ptr)
2324 *data->last_vuse_ptr = vuse;
2325 data->last_vuse = vuse;
2328 /* Fixup vuse and hash. */
2329 if (vr->vuse)
2330 vr->hashcode = vr->hashcode - SSA_NAME_VERSION (vr->vuse);
2331 vr->vuse = vuse_ssa_val (vuse);
2332 if (vr->vuse)
2333 vr->hashcode = vr->hashcode + SSA_NAME_VERSION (vr->vuse);
2335 hash = vr->hashcode;
2336 slot = valid_info->references->find_slot_with_hash (vr, hash, NO_INSERT);
2337 if (slot)
2339 if ((*slot)->result && data->saved_operands.exists ())
2340 return data->finish (vr->set, vr->base_set, (*slot)->result);
2341 return *slot;
2344 return NULL;
2347 /* Lookup an existing or insert a new vn_reference entry into the
2348 value table for the VUSE, SET, TYPE, OPERANDS reference which
2349 has the value VALUE which is either a constant or an SSA name. */
2351 static vn_reference_t
2352 vn_reference_lookup_or_insert_for_pieces (tree vuse,
2353 alias_set_type set,
2354 alias_set_type base_set,
2355 tree type,
2356 vec<vn_reference_op_s,
2357 va_heap> operands,
2358 tree value)
2360 vn_reference_s vr1;
2361 vn_reference_t result;
2362 unsigned value_id;
2363 vr1.vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
2364 vr1.operands = operands;
2365 vr1.type = type;
2366 vr1.set = set;
2367 vr1.base_set = base_set;
2368 vr1.hashcode = vn_reference_compute_hash (&vr1);
2369 if (vn_reference_lookup_1 (&vr1, &result))
2370 return result;
2371 if (TREE_CODE (value) == SSA_NAME)
2372 value_id = VN_INFO (value)->value_id;
2373 else
2374 value_id = get_or_alloc_constant_value_id (value);
2375 return vn_reference_insert_pieces (vuse, set, base_set, type,
2376 operands.copy (), value, value_id);
2379 /* Return a value-number for RCODE OPS... either by looking up an existing
2380 value-number for the possibly simplified result or by inserting the
2381 operation if INSERT is true. If SIMPLIFY is false, return a value
2382 number for the unsimplified expression. */
2384 static tree
2385 vn_nary_build_or_lookup_1 (gimple_match_op *res_op, bool insert,
2386 bool simplify)
2388 tree result = NULL_TREE;
2389 /* We will be creating a value number for
2390 RCODE (OPS...).
2391 So first simplify and lookup this expression to see if it
2392 is already available. */
2393 /* For simplification valueize. */
2394 unsigned i = 0;
2395 if (simplify)
2396 for (i = 0; i < res_op->num_ops; ++i)
2397 if (TREE_CODE (res_op->ops[i]) == SSA_NAME)
2399 tree tem = vn_valueize (res_op->ops[i]);
2400 if (!tem)
2401 break;
2402 res_op->ops[i] = tem;
2404 /* If valueization of an operand fails (it is not available), skip
2405 simplification. */
2406 bool res = false;
2407 if (i == res_op->num_ops)
2409 mprts_hook = vn_lookup_simplify_result;
2410 res = res_op->resimplify (NULL, vn_valueize);
2411 mprts_hook = NULL;
2413 gimple *new_stmt = NULL;
2414 if (res
2415 && gimple_simplified_result_is_gimple_val (res_op))
2417 /* The expression is already available. */
2418 result = res_op->ops[0];
2419 /* Valueize it, simplification returns sth in AVAIL only. */
2420 if (TREE_CODE (result) == SSA_NAME)
2421 result = SSA_VAL (result);
2423 else
2425 tree val = vn_lookup_simplify_result (res_op);
2426 if (!val && insert)
2428 gimple_seq stmts = NULL;
2429 result = maybe_push_res_to_seq (res_op, &stmts);
2430 if (result)
2432 gcc_assert (gimple_seq_singleton_p (stmts));
2433 new_stmt = gimple_seq_first_stmt (stmts);
2436 else
2437 /* The expression is already available. */
2438 result = val;
2440 if (new_stmt)
2442 /* The expression is not yet available, value-number lhs to
2443 the new SSA_NAME we created. */
2444 /* Initialize value-number information properly. */
2445 vn_ssa_aux_t result_info = VN_INFO (result);
2446 result_info->valnum = result;
2447 result_info->value_id = get_next_value_id ();
2448 result_info->visited = 1;
2449 gimple_seq_add_stmt_without_update (&VN_INFO (result)->expr,
2450 new_stmt);
2451 result_info->needs_insertion = true;
2452 /* ??? PRE phi-translation inserts NARYs without corresponding
2453 SSA name result. Re-use those but set their result according
2454 to the stmt we just built. */
2455 vn_nary_op_t nary = NULL;
2456 vn_nary_op_lookup_stmt (new_stmt, &nary);
2457 if (nary)
2459 gcc_assert (! nary->predicated_values && nary->u.result == NULL_TREE);
2460 nary->u.result = gimple_assign_lhs (new_stmt);
2462 /* As all "inserted" statements are singleton SCCs, insert
2463 to the valid table. This is strictly needed to
2464 avoid re-generating new value SSA_NAMEs for the same
2465 expression during SCC iteration over and over (the
2466 optimistic table gets cleared after each iteration).
2467 We do not need to insert into the optimistic table, as
2468 lookups there will fall back to the valid table. */
2469 else
2471 unsigned int length = vn_nary_length_from_stmt (new_stmt);
2472 vn_nary_op_t vno1
2473 = alloc_vn_nary_op_noinit (length, &vn_tables_insert_obstack);
2474 vno1->value_id = result_info->value_id;
2475 vno1->length = length;
2476 vno1->predicated_values = 0;
2477 vno1->u.result = result;
2478 init_vn_nary_op_from_stmt (vno1, as_a <gassign *> (new_stmt));
2479 vn_nary_op_insert_into (vno1, valid_info->nary);
2480 /* Also do not link it into the undo chain. */
2481 last_inserted_nary = vno1->next;
2482 vno1->next = (vn_nary_op_t)(void *)-1;
2484 if (dump_file && (dump_flags & TDF_DETAILS))
2486 fprintf (dump_file, "Inserting name ");
2487 print_generic_expr (dump_file, result);
2488 fprintf (dump_file, " for expression ");
2489 print_gimple_expr (dump_file, new_stmt, 0, TDF_SLIM);
2490 fprintf (dump_file, "\n");
2493 return result;
2496 /* Return a value-number for RCODE OPS... either by looking up an existing
2497 value-number for the simplified result or by inserting the operation. */
2499 static tree
2500 vn_nary_build_or_lookup (gimple_match_op *res_op)
2502 return vn_nary_build_or_lookup_1 (res_op, true, true);
2505 /* Try to simplify the expression RCODE OPS... of type TYPE and return
2506 its value if present. */
2508 tree
2509 vn_nary_simplify (vn_nary_op_t nary)
2511 if (nary->length > gimple_match_op::MAX_NUM_OPS)
2512 return NULL_TREE;
2513 gimple_match_op op (gimple_match_cond::UNCOND, nary->opcode,
2514 nary->type, nary->length);
2515 memcpy (op.ops, nary->op, sizeof (tree) * nary->length);
2516 return vn_nary_build_or_lookup_1 (&op, false, true);
2519 /* Elimination engine. */
2521 class eliminate_dom_walker : public dom_walker
2523 public:
2524 eliminate_dom_walker (cdi_direction, bitmap);
2525 ~eliminate_dom_walker ();
2527 edge before_dom_children (basic_block) final override;
2528 void after_dom_children (basic_block) final override;
2530 virtual tree eliminate_avail (basic_block, tree op);
2531 virtual void eliminate_push_avail (basic_block, tree op);
2532 tree eliminate_insert (basic_block, gimple_stmt_iterator *gsi, tree val);
2534 void eliminate_stmt (basic_block, gimple_stmt_iterator *);
2536 unsigned eliminate_cleanup (bool region_p = false);
2538 bool do_pre;
2539 unsigned int el_todo;
2540 unsigned int eliminations;
2541 unsigned int insertions;
2543 /* SSA names that had their defs inserted by PRE if do_pre. */
2544 bitmap inserted_exprs;
2546 /* Blocks with statements that have had their EH properties changed. */
2547 bitmap need_eh_cleanup;
2549 /* Blocks with statements that have had their AB properties changed. */
2550 bitmap need_ab_cleanup;
2552 /* Local state for the eliminate domwalk. */
2553 auto_vec<gimple *> to_remove;
2554 auto_vec<gimple *> to_fixup;
2555 auto_vec<tree> avail;
2556 auto_vec<tree> avail_stack;
2559 /* Adaptor to the elimination engine using RPO availability. */
2561 class rpo_elim : public eliminate_dom_walker
2563 public:
2564 rpo_elim(basic_block entry_)
2565 : eliminate_dom_walker (CDI_DOMINATORS, NULL), entry (entry_),
2566 m_avail_freelist (NULL) {}
2568 tree eliminate_avail (basic_block, tree op) final override;
2570 void eliminate_push_avail (basic_block, tree) final override;
2572 basic_block entry;
2573 /* Freelist of avail entries which are allocated from the vn_ssa_aux
2574 obstack. */
2575 vn_avail *m_avail_freelist;
2578 /* Global RPO state for access from hooks. */
2579 static eliminate_dom_walker *rpo_avail;
2580 basic_block vn_context_bb;
2582 /* Return true if BASE1 and BASE2 can be adjusted so they have the
2583 same address and adjust *OFFSET1 and *OFFSET2 accordingly.
2584 Otherwise return false. */
2586 static bool
2587 adjust_offsets_for_equal_base_address (tree base1, poly_int64 *offset1,
2588 tree base2, poly_int64 *offset2)
2590 poly_int64 soff;
2591 if (TREE_CODE (base1) == MEM_REF
2592 && TREE_CODE (base2) == MEM_REF)
2594 if (mem_ref_offset (base1).to_shwi (&soff))
2596 base1 = TREE_OPERAND (base1, 0);
2597 *offset1 += soff * BITS_PER_UNIT;
2599 if (mem_ref_offset (base2).to_shwi (&soff))
2601 base2 = TREE_OPERAND (base2, 0);
2602 *offset2 += soff * BITS_PER_UNIT;
2604 return operand_equal_p (base1, base2, 0);
2606 return operand_equal_p (base1, base2, OEP_ADDRESS_OF);
2609 /* Callback for walk_non_aliased_vuses. Tries to perform a lookup
2610 from the statement defining VUSE and if not successful tries to
2611 translate *REFP and VR_ through an aggregate copy at the definition
2612 of VUSE. If *DISAMBIGUATE_ONLY is true then do not perform translation
2613 of *REF and *VR. If only disambiguation was performed then
2614 *DISAMBIGUATE_ONLY is set to true. */
2616 static void *
2617 vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
2618 translate_flags *disambiguate_only)
2620 vn_walk_cb_data *data = (vn_walk_cb_data *)data_;
2621 vn_reference_t vr = data->vr;
2622 gimple *def_stmt = SSA_NAME_DEF_STMT (vuse);
2623 tree base = ao_ref_base (ref);
2624 HOST_WIDE_INT offseti = 0, maxsizei, sizei = 0;
2625 static vec<vn_reference_op_s> lhs_ops;
2626 ao_ref lhs_ref;
2627 bool lhs_ref_ok = false;
2628 poly_int64 copy_size;
2630 /* First try to disambiguate after value-replacing in the definitions LHS. */
2631 if (is_gimple_assign (def_stmt))
2633 tree lhs = gimple_assign_lhs (def_stmt);
2634 bool valueized_anything = false;
2635 /* Avoid re-allocation overhead. */
2636 lhs_ops.truncate (0);
2637 basic_block saved_rpo_bb = vn_context_bb;
2638 vn_context_bb = gimple_bb (def_stmt);
2639 if (*disambiguate_only <= TR_VALUEIZE_AND_DISAMBIGUATE)
2641 copy_reference_ops_from_ref (lhs, &lhs_ops);
2642 valueize_refs_1 (&lhs_ops, &valueized_anything, true);
2644 vn_context_bb = saved_rpo_bb;
2645 ao_ref_init (&lhs_ref, lhs);
2646 lhs_ref_ok = true;
2647 if (valueized_anything
2648 && ao_ref_init_from_vn_reference
2649 (&lhs_ref, ao_ref_alias_set (&lhs_ref),
2650 ao_ref_base_alias_set (&lhs_ref), TREE_TYPE (lhs), lhs_ops)
2651 && !refs_may_alias_p_1 (ref, &lhs_ref, data->tbaa_p))
2653 *disambiguate_only = TR_VALUEIZE_AND_DISAMBIGUATE;
2654 return NULL;
2657 /* When the def is a CLOBBER we can optimistically disambiguate
2658 against it since any overlap it would be undefined behavior.
2659 Avoid this for obvious must aliases to save compile-time though.
2660 We also may not do this when the query is used for redundant
2661 store removal. */
2662 if (!data->redundant_store_removal_p
2663 && gimple_clobber_p (def_stmt)
2664 && !operand_equal_p (ao_ref_base (&lhs_ref), base, OEP_ADDRESS_OF))
2666 *disambiguate_only = TR_DISAMBIGUATE;
2667 return NULL;
2670 /* Besides valueizing the LHS we can also use access-path based
2671 disambiguation on the original non-valueized ref. */
2672 if (!ref->ref
2673 && lhs_ref_ok
2674 && data->orig_ref.ref)
2676 /* We want to use the non-valueized LHS for this, but avoid redundant
2677 work. */
2678 ao_ref *lref = &lhs_ref;
2679 ao_ref lref_alt;
2680 if (valueized_anything)
2682 ao_ref_init (&lref_alt, lhs);
2683 lref = &lref_alt;
2685 if (!refs_may_alias_p_1 (&data->orig_ref, lref, data->tbaa_p))
2687 *disambiguate_only = (valueized_anything
2688 ? TR_VALUEIZE_AND_DISAMBIGUATE
2689 : TR_DISAMBIGUATE);
2690 return NULL;
2694 /* If we reach a clobbering statement try to skip it and see if
2695 we find a VN result with exactly the same value as the
2696 possible clobber. In this case we can ignore the clobber
2697 and return the found value. */
2698 if (is_gimple_reg_type (TREE_TYPE (lhs))
2699 && types_compatible_p (TREE_TYPE (lhs), vr->type)
2700 && (ref->ref || data->orig_ref.ref)
2701 && !data->mask
2702 && data->partial_defs.is_empty ()
2703 && multiple_p (get_object_alignment
2704 (ref->ref ? ref->ref : data->orig_ref.ref),
2705 ref->size)
2706 && multiple_p (get_object_alignment (lhs), ref->size))
2708 tree rhs = gimple_assign_rhs1 (def_stmt);
2709 /* ??? We may not compare to ahead values which might be from
2710 a different loop iteration but only to loop invariants. Use
2711 CONSTANT_CLASS_P (unvalueized!) as conservative approximation.
2712 The one-hop lookup below doesn't have this issue since there's
2713 a virtual PHI before we ever reach a backedge to cross.
2714 We can skip multiple defs as long as they are from the same
2715 value though. */
2716 if (data->same_val
2717 && !operand_equal_p (data->same_val, rhs))
2719 else if (CONSTANT_CLASS_P (rhs))
2721 if (dump_file && (dump_flags & TDF_DETAILS))
2723 fprintf (dump_file,
2724 "Skipping possible redundant definition ");
2725 print_gimple_stmt (dump_file, def_stmt, 0);
2727 /* Delay the actual compare of the values to the end of the walk
2728 but do not update last_vuse from here. */
2729 data->last_vuse_ptr = NULL;
2730 data->same_val = rhs;
2731 return NULL;
2733 else
2735 tree *saved_last_vuse_ptr = data->last_vuse_ptr;
2736 /* Do not update last_vuse_ptr in vn_reference_lookup_2. */
2737 data->last_vuse_ptr = NULL;
2738 tree saved_vuse = vr->vuse;
2739 hashval_t saved_hashcode = vr->hashcode;
2740 void *res = vn_reference_lookup_2 (ref, gimple_vuse (def_stmt),
2741 data);
2742 /* Need to restore vr->vuse and vr->hashcode. */
2743 vr->vuse = saved_vuse;
2744 vr->hashcode = saved_hashcode;
2745 data->last_vuse_ptr = saved_last_vuse_ptr;
2746 if (res && res != (void *)-1)
2748 vn_reference_t vnresult = (vn_reference_t) res;
2749 if (TREE_CODE (rhs) == SSA_NAME)
2750 rhs = SSA_VAL (rhs);
2751 if (vnresult->result
2752 && operand_equal_p (vnresult->result, rhs, 0))
2753 return res;
2758 else if (*disambiguate_only <= TR_VALUEIZE_AND_DISAMBIGUATE
2759 && gimple_call_builtin_p (def_stmt, BUILT_IN_NORMAL)
2760 && gimple_call_num_args (def_stmt) <= 4)
2762 /* For builtin calls valueize its arguments and call the
2763 alias oracle again. Valueization may improve points-to
2764 info of pointers and constify size and position arguments.
2765 Originally this was motivated by PR61034 which has
2766 conditional calls to free falsely clobbering ref because
2767 of imprecise points-to info of the argument. */
2768 tree oldargs[4];
2769 bool valueized_anything = false;
2770 for (unsigned i = 0; i < gimple_call_num_args (def_stmt); ++i)
2772 oldargs[i] = gimple_call_arg (def_stmt, i);
2773 tree val = vn_valueize (oldargs[i]);
2774 if (val != oldargs[i])
2776 gimple_call_set_arg (def_stmt, i, val);
2777 valueized_anything = true;
2780 if (valueized_anything)
2782 bool res = call_may_clobber_ref_p_1 (as_a <gcall *> (def_stmt),
2783 ref, data->tbaa_p);
2784 for (unsigned i = 0; i < gimple_call_num_args (def_stmt); ++i)
2785 gimple_call_set_arg (def_stmt, i, oldargs[i]);
2786 if (!res)
2788 *disambiguate_only = TR_VALUEIZE_AND_DISAMBIGUATE;
2789 return NULL;
2794 if (*disambiguate_only > TR_TRANSLATE)
2795 return (void *)-1;
2797 /* If we cannot constrain the size of the reference we cannot
2798 test if anything kills it. */
2799 if (!ref->max_size_known_p ())
2800 return (void *)-1;
2802 poly_int64 offset = ref->offset;
2803 poly_int64 maxsize = ref->max_size;
2805 /* def_stmt may-defs *ref. See if we can derive a value for *ref
2806 from that definition.
2807 1) Memset. */
2808 if (is_gimple_reg_type (vr->type)
2809 && (gimple_call_builtin_p (def_stmt, BUILT_IN_MEMSET)
2810 || gimple_call_builtin_p (def_stmt, BUILT_IN_MEMSET_CHK))
2811 && (integer_zerop (gimple_call_arg (def_stmt, 1))
2812 || ((TREE_CODE (gimple_call_arg (def_stmt, 1)) == INTEGER_CST
2813 || (INTEGRAL_TYPE_P (vr->type) && known_eq (ref->size, 8)))
2814 && CHAR_BIT == 8
2815 && BITS_PER_UNIT == 8
2816 && BYTES_BIG_ENDIAN == WORDS_BIG_ENDIAN
2817 && offset.is_constant (&offseti)
2818 && ref->size.is_constant (&sizei)
2819 && (offseti % BITS_PER_UNIT == 0
2820 || TREE_CODE (gimple_call_arg (def_stmt, 1)) == INTEGER_CST)))
2821 && (poly_int_tree_p (gimple_call_arg (def_stmt, 2))
2822 || (TREE_CODE (gimple_call_arg (def_stmt, 2)) == SSA_NAME
2823 && poly_int_tree_p (SSA_VAL (gimple_call_arg (def_stmt, 2)))))
2824 && (TREE_CODE (gimple_call_arg (def_stmt, 0)) == ADDR_EXPR
2825 || TREE_CODE (gimple_call_arg (def_stmt, 0)) == SSA_NAME))
2827 tree base2;
2828 poly_int64 offset2, size2, maxsize2;
2829 bool reverse;
2830 tree ref2 = gimple_call_arg (def_stmt, 0);
2831 if (TREE_CODE (ref2) == SSA_NAME)
2833 ref2 = SSA_VAL (ref2);
2834 if (TREE_CODE (ref2) == SSA_NAME
2835 && (TREE_CODE (base) != MEM_REF
2836 || TREE_OPERAND (base, 0) != ref2))
2838 gimple *def_stmt = SSA_NAME_DEF_STMT (ref2);
2839 if (gimple_assign_single_p (def_stmt)
2840 && gimple_assign_rhs_code (def_stmt) == ADDR_EXPR)
2841 ref2 = gimple_assign_rhs1 (def_stmt);
2844 if (TREE_CODE (ref2) == ADDR_EXPR)
2846 ref2 = TREE_OPERAND (ref2, 0);
2847 base2 = get_ref_base_and_extent (ref2, &offset2, &size2, &maxsize2,
2848 &reverse);
2849 if (!known_size_p (maxsize2)
2850 || !known_eq (maxsize2, size2)
2851 || !operand_equal_p (base, base2, OEP_ADDRESS_OF))
2852 return (void *)-1;
2854 else if (TREE_CODE (ref2) == SSA_NAME)
2856 poly_int64 soff;
2857 if (TREE_CODE (base) != MEM_REF
2858 || !(mem_ref_offset (base)
2859 << LOG2_BITS_PER_UNIT).to_shwi (&soff))
2860 return (void *)-1;
2861 offset += soff;
2862 offset2 = 0;
2863 if (TREE_OPERAND (base, 0) != ref2)
2865 gimple *def = SSA_NAME_DEF_STMT (ref2);
2866 if (is_gimple_assign (def)
2867 && gimple_assign_rhs_code (def) == POINTER_PLUS_EXPR
2868 && gimple_assign_rhs1 (def) == TREE_OPERAND (base, 0)
2869 && poly_int_tree_p (gimple_assign_rhs2 (def)))
2871 tree rhs2 = gimple_assign_rhs2 (def);
2872 if (!(poly_offset_int::from (wi::to_poly_wide (rhs2),
2873 SIGNED)
2874 << LOG2_BITS_PER_UNIT).to_shwi (&offset2))
2875 return (void *)-1;
2876 ref2 = gimple_assign_rhs1 (def);
2877 if (TREE_CODE (ref2) == SSA_NAME)
2878 ref2 = SSA_VAL (ref2);
2880 else
2881 return (void *)-1;
2884 else
2885 return (void *)-1;
2886 tree len = gimple_call_arg (def_stmt, 2);
2887 HOST_WIDE_INT leni, offset2i;
2888 if (TREE_CODE (len) == SSA_NAME)
2889 len = SSA_VAL (len);
2890 /* Sometimes the above trickery is smarter than alias analysis. Take
2891 advantage of that. */
2892 if (!ranges_maybe_overlap_p (offset, maxsize, offset2,
2893 (wi::to_poly_offset (len)
2894 << LOG2_BITS_PER_UNIT)))
2895 return NULL;
2896 if (data->partial_defs.is_empty ()
2897 && known_subrange_p (offset, maxsize, offset2,
2898 wi::to_poly_offset (len) << LOG2_BITS_PER_UNIT))
2900 tree val;
2901 if (integer_zerop (gimple_call_arg (def_stmt, 1)))
2902 val = build_zero_cst (vr->type);
2903 else if (INTEGRAL_TYPE_P (vr->type)
2904 && known_eq (ref->size, 8)
2905 && offseti % BITS_PER_UNIT == 0)
2907 gimple_match_op res_op (gimple_match_cond::UNCOND, NOP_EXPR,
2908 vr->type, gimple_call_arg (def_stmt, 1));
2909 val = vn_nary_build_or_lookup (&res_op);
2910 if (!val
2911 || (TREE_CODE (val) == SSA_NAME
2912 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val)))
2913 return (void *)-1;
2915 else
2917 unsigned buflen = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (vr->type)) + 1;
2918 if (INTEGRAL_TYPE_P (vr->type))
2919 buflen = GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (vr->type)) + 1;
2920 unsigned char *buf = XALLOCAVEC (unsigned char, buflen);
2921 memset (buf, TREE_INT_CST_LOW (gimple_call_arg (def_stmt, 1)),
2922 buflen);
2923 if (BYTES_BIG_ENDIAN)
2925 unsigned int amnt
2926 = (((unsigned HOST_WIDE_INT) offseti + sizei)
2927 % BITS_PER_UNIT);
2928 if (amnt)
2930 shift_bytes_in_array_right (buf, buflen,
2931 BITS_PER_UNIT - amnt);
2932 buf++;
2933 buflen--;
2936 else if (offseti % BITS_PER_UNIT != 0)
2938 unsigned int amnt
2939 = BITS_PER_UNIT - ((unsigned HOST_WIDE_INT) offseti
2940 % BITS_PER_UNIT);
2941 shift_bytes_in_array_left (buf, buflen, amnt);
2942 buf++;
2943 buflen--;
2945 val = native_interpret_expr (vr->type, buf, buflen);
2946 if (!val)
2947 return (void *)-1;
2949 return data->finish (0, 0, val);
2951 /* For now handle clearing memory with partial defs. */
2952 else if (known_eq (ref->size, maxsize)
2953 && integer_zerop (gimple_call_arg (def_stmt, 1))
2954 && tree_fits_poly_int64_p (len)
2955 && tree_to_poly_int64 (len).is_constant (&leni)
2956 && leni <= INTTYPE_MAXIMUM (HOST_WIDE_INT) / BITS_PER_UNIT
2957 && offset.is_constant (&offseti)
2958 && offset2.is_constant (&offset2i)
2959 && maxsize.is_constant (&maxsizei)
2960 && ranges_known_overlap_p (offseti, maxsizei, offset2i,
2961 leni << LOG2_BITS_PER_UNIT))
2963 pd_data pd;
2964 pd.rhs = build_constructor (NULL_TREE, NULL);
2965 pd.rhs_off = 0;
2966 pd.offset = offset2i;
2967 pd.size = leni << LOG2_BITS_PER_UNIT;
2968 return data->push_partial_def (pd, 0, 0, offseti, maxsizei);
2972 /* 2) Assignment from an empty CONSTRUCTOR. */
2973 else if (is_gimple_reg_type (vr->type)
2974 && gimple_assign_single_p (def_stmt)
2975 && gimple_assign_rhs_code (def_stmt) == CONSTRUCTOR
2976 && CONSTRUCTOR_NELTS (gimple_assign_rhs1 (def_stmt)) == 0)
2978 tree base2;
2979 poly_int64 offset2, size2, maxsize2;
2980 HOST_WIDE_INT offset2i, size2i;
2981 gcc_assert (lhs_ref_ok);
2982 base2 = ao_ref_base (&lhs_ref);
2983 offset2 = lhs_ref.offset;
2984 size2 = lhs_ref.size;
2985 maxsize2 = lhs_ref.max_size;
2986 if (known_size_p (maxsize2)
2987 && known_eq (maxsize2, size2)
2988 && adjust_offsets_for_equal_base_address (base, &offset,
2989 base2, &offset2))
2991 if (data->partial_defs.is_empty ()
2992 && known_subrange_p (offset, maxsize, offset2, size2))
2994 /* While technically undefined behavior do not optimize
2995 a full read from a clobber. */
2996 if (gimple_clobber_p (def_stmt))
2997 return (void *)-1;
2998 tree val = build_zero_cst (vr->type);
2999 return data->finish (ao_ref_alias_set (&lhs_ref),
3000 ao_ref_base_alias_set (&lhs_ref), val);
3002 else if (known_eq (ref->size, maxsize)
3003 && maxsize.is_constant (&maxsizei)
3004 && offset.is_constant (&offseti)
3005 && offset2.is_constant (&offset2i)
3006 && size2.is_constant (&size2i)
3007 && ranges_known_overlap_p (offseti, maxsizei,
3008 offset2i, size2i))
3010 /* Let clobbers be consumed by the partial-def tracker
3011 which can choose to ignore them if they are shadowed
3012 by a later def. */
3013 pd_data pd;
3014 pd.rhs = gimple_assign_rhs1 (def_stmt);
3015 pd.rhs_off = 0;
3016 pd.offset = offset2i;
3017 pd.size = size2i;
3018 return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
3019 ao_ref_base_alias_set (&lhs_ref),
3020 offseti, maxsizei);
3025 /* 3) Assignment from a constant. We can use folds native encode/interpret
3026 routines to extract the assigned bits. */
3027 else if (known_eq (ref->size, maxsize)
3028 && is_gimple_reg_type (vr->type)
3029 && !reverse_storage_order_for_component_p (vr->operands)
3030 && !contains_storage_order_barrier_p (vr->operands)
3031 && gimple_assign_single_p (def_stmt)
3032 && CHAR_BIT == 8
3033 && BITS_PER_UNIT == 8
3034 && BYTES_BIG_ENDIAN == WORDS_BIG_ENDIAN
3035 /* native_encode and native_decode operate on arrays of bytes
3036 and so fundamentally need a compile-time size and offset. */
3037 && maxsize.is_constant (&maxsizei)
3038 && offset.is_constant (&offseti)
3039 && (is_gimple_min_invariant (gimple_assign_rhs1 (def_stmt))
3040 || (TREE_CODE (gimple_assign_rhs1 (def_stmt)) == SSA_NAME
3041 && is_gimple_min_invariant (SSA_VAL (gimple_assign_rhs1 (def_stmt))))))
3043 tree lhs = gimple_assign_lhs (def_stmt);
3044 tree base2;
3045 poly_int64 offset2, size2, maxsize2;
3046 HOST_WIDE_INT offset2i, size2i;
3047 bool reverse;
3048 gcc_assert (lhs_ref_ok);
3049 base2 = ao_ref_base (&lhs_ref);
3050 offset2 = lhs_ref.offset;
3051 size2 = lhs_ref.size;
3052 maxsize2 = lhs_ref.max_size;
3053 reverse = reverse_storage_order_for_component_p (lhs);
3054 if (base2
3055 && !reverse
3056 && !storage_order_barrier_p (lhs)
3057 && known_eq (maxsize2, size2)
3058 && adjust_offsets_for_equal_base_address (base, &offset,
3059 base2, &offset2)
3060 && offset.is_constant (&offseti)
3061 && offset2.is_constant (&offset2i)
3062 && size2.is_constant (&size2i))
3064 if (data->partial_defs.is_empty ()
3065 && known_subrange_p (offseti, maxsizei, offset2, size2))
3067 /* We support up to 512-bit values (for V8DFmode). */
3068 unsigned char buffer[65];
3069 int len;
3071 tree rhs = gimple_assign_rhs1 (def_stmt);
3072 if (TREE_CODE (rhs) == SSA_NAME)
3073 rhs = SSA_VAL (rhs);
3074 len = native_encode_expr (rhs,
3075 buffer, sizeof (buffer) - 1,
3076 (offseti - offset2i) / BITS_PER_UNIT);
3077 if (len > 0 && len * BITS_PER_UNIT >= maxsizei)
3079 tree type = vr->type;
3080 unsigned char *buf = buffer;
3081 unsigned int amnt = 0;
3082 /* Make sure to interpret in a type that has a range
3083 covering the whole access size. */
3084 if (INTEGRAL_TYPE_P (vr->type)
3085 && maxsizei != TYPE_PRECISION (vr->type))
3086 type = build_nonstandard_integer_type (maxsizei,
3087 TYPE_UNSIGNED (type));
3088 if (BYTES_BIG_ENDIAN)
3090 /* For big-endian native_encode_expr stored the rhs
3091 such that the LSB of it is the LSB of buffer[len - 1].
3092 That bit is stored into memory at position
3093 offset2 + size2 - 1, i.e. in byte
3094 base + (offset2 + size2 - 1) / BITS_PER_UNIT.
3095 E.g. for offset2 1 and size2 14, rhs -1 and memory
3096 previously cleared that is:
3098 01111111|11111110
3099 Now, if we want to extract offset 2 and size 12 from
3100 it using native_interpret_expr (which actually works
3101 for integral bitfield types in terms of byte size of
3102 the mode), the native_encode_expr stored the value
3103 into buffer as
3104 XX111111|11111111
3105 and returned len 2 (the X bits are outside of
3106 precision).
3107 Let sz be maxsize / BITS_PER_UNIT if not extracting
3108 a bitfield, and GET_MODE_SIZE otherwise.
3109 We need to align the LSB of the value we want to
3110 extract as the LSB of buf[sz - 1].
3111 The LSB from memory we need to read is at position
3112 offset + maxsize - 1. */
3113 HOST_WIDE_INT sz = maxsizei / BITS_PER_UNIT;
3114 if (INTEGRAL_TYPE_P (type))
3115 sz = GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type));
3116 amnt = ((unsigned HOST_WIDE_INT) offset2i + size2i
3117 - offseti - maxsizei) % BITS_PER_UNIT;
3118 if (amnt)
3119 shift_bytes_in_array_right (buffer, len, amnt);
3120 amnt = ((unsigned HOST_WIDE_INT) offset2i + size2i
3121 - offseti - maxsizei - amnt) / BITS_PER_UNIT;
3122 if ((unsigned HOST_WIDE_INT) sz + amnt > (unsigned) len)
3123 len = 0;
3124 else
3126 buf = buffer + len - sz - amnt;
3127 len -= (buf - buffer);
3130 else
3132 amnt = ((unsigned HOST_WIDE_INT) offset2i
3133 - offseti) % BITS_PER_UNIT;
3134 if (amnt)
3136 buffer[len] = 0;
3137 shift_bytes_in_array_left (buffer, len + 1, amnt);
3138 buf = buffer + 1;
3141 tree val = native_interpret_expr (type, buf, len);
3142 /* If we chop off bits because the types precision doesn't
3143 match the memory access size this is ok when optimizing
3144 reads but not when called from the DSE code during
3145 elimination. */
3146 if (val
3147 && type != vr->type)
3149 if (! int_fits_type_p (val, vr->type))
3150 val = NULL_TREE;
3151 else
3152 val = fold_convert (vr->type, val);
3155 if (val)
3156 return data->finish (ao_ref_alias_set (&lhs_ref),
3157 ao_ref_base_alias_set (&lhs_ref), val);
3160 else if (ranges_known_overlap_p (offseti, maxsizei, offset2i,
3161 size2i))
3163 pd_data pd;
3164 tree rhs = gimple_assign_rhs1 (def_stmt);
3165 if (TREE_CODE (rhs) == SSA_NAME)
3166 rhs = SSA_VAL (rhs);
3167 pd.rhs = rhs;
3168 pd.rhs_off = 0;
3169 pd.offset = offset2i;
3170 pd.size = size2i;
3171 return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
3172 ao_ref_base_alias_set (&lhs_ref),
3173 offseti, maxsizei);
3178 /* 4) Assignment from an SSA name which definition we may be able
3179 to access pieces from or we can combine to a larger entity. */
3180 else if (known_eq (ref->size, maxsize)
3181 && is_gimple_reg_type (vr->type)
3182 && !reverse_storage_order_for_component_p (vr->operands)
3183 && !contains_storage_order_barrier_p (vr->operands)
3184 && gimple_assign_single_p (def_stmt)
3185 && TREE_CODE (gimple_assign_rhs1 (def_stmt)) == SSA_NAME)
3187 tree lhs = gimple_assign_lhs (def_stmt);
3188 tree base2;
3189 poly_int64 offset2, size2, maxsize2;
3190 HOST_WIDE_INT offset2i, size2i, offseti;
3191 bool reverse;
3192 gcc_assert (lhs_ref_ok);
3193 base2 = ao_ref_base (&lhs_ref);
3194 offset2 = lhs_ref.offset;
3195 size2 = lhs_ref.size;
3196 maxsize2 = lhs_ref.max_size;
3197 reverse = reverse_storage_order_for_component_p (lhs);
3198 tree def_rhs = gimple_assign_rhs1 (def_stmt);
3199 if (!reverse
3200 && !storage_order_barrier_p (lhs)
3201 && known_size_p (maxsize2)
3202 && known_eq (maxsize2, size2)
3203 && adjust_offsets_for_equal_base_address (base, &offset,
3204 base2, &offset2))
3206 if (data->partial_defs.is_empty ()
3207 && known_subrange_p (offset, maxsize, offset2, size2)
3208 /* ??? We can't handle bitfield precision extracts without
3209 either using an alternate type for the BIT_FIELD_REF and
3210 then doing a conversion or possibly adjusting the offset
3211 according to endianness. */
3212 && (! INTEGRAL_TYPE_P (vr->type)
3213 || known_eq (ref->size, TYPE_PRECISION (vr->type)))
3214 && multiple_p (ref->size, BITS_PER_UNIT))
3216 tree val = NULL_TREE;
3217 if (! INTEGRAL_TYPE_P (TREE_TYPE (def_rhs))
3218 || type_has_mode_precision_p (TREE_TYPE (def_rhs)))
3220 gimple_match_op op (gimple_match_cond::UNCOND,
3221 BIT_FIELD_REF, vr->type,
3222 SSA_VAL (def_rhs),
3223 bitsize_int (ref->size),
3224 bitsize_int (offset - offset2));
3225 val = vn_nary_build_or_lookup (&op);
3227 else if (known_eq (ref->size, size2))
3229 gimple_match_op op (gimple_match_cond::UNCOND,
3230 VIEW_CONVERT_EXPR, vr->type,
3231 SSA_VAL (def_rhs));
3232 val = vn_nary_build_or_lookup (&op);
3234 if (val
3235 && (TREE_CODE (val) != SSA_NAME
3236 || ! SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val)))
3237 return data->finish (ao_ref_alias_set (&lhs_ref),
3238 ao_ref_base_alias_set (&lhs_ref), val);
3240 else if (maxsize.is_constant (&maxsizei)
3241 && offset.is_constant (&offseti)
3242 && offset2.is_constant (&offset2i)
3243 && size2.is_constant (&size2i)
3244 && ranges_known_overlap_p (offset, maxsize, offset2, size2))
3246 pd_data pd;
3247 pd.rhs = SSA_VAL (def_rhs);
3248 pd.rhs_off = 0;
3249 pd.offset = offset2i;
3250 pd.size = size2i;
3251 return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
3252 ao_ref_base_alias_set (&lhs_ref),
3253 offseti, maxsizei);
3258 /* 4b) Assignment done via one of the vectorizer internal store
3259 functions where we may be able to access pieces from or we can
3260 combine to a larger entity. */
3261 else if (known_eq (ref->size, maxsize)
3262 && is_gimple_reg_type (vr->type)
3263 && !reverse_storage_order_for_component_p (vr->operands)
3264 && !contains_storage_order_barrier_p (vr->operands)
3265 && is_gimple_call (def_stmt)
3266 && gimple_call_internal_p (def_stmt)
3267 && internal_store_fn_p (gimple_call_internal_fn (def_stmt)))
3269 gcall *call = as_a <gcall *> (def_stmt);
3270 internal_fn fn = gimple_call_internal_fn (call);
3272 tree mask = NULL_TREE, len = NULL_TREE, bias = NULL_TREE;
3273 switch (fn)
3275 case IFN_MASK_STORE:
3276 mask = gimple_call_arg (call, internal_fn_mask_index (fn));
3277 mask = vn_valueize (mask);
3278 if (TREE_CODE (mask) != VECTOR_CST)
3279 return (void *)-1;
3280 break;
3281 case IFN_LEN_STORE:
3282 len = gimple_call_arg (call, 2);
3283 bias = gimple_call_arg (call, 4);
3284 if (!tree_fits_uhwi_p (len) || !tree_fits_shwi_p (bias))
3285 return (void *)-1;
3286 break;
3287 default:
3288 return (void *)-1;
3290 tree def_rhs = gimple_call_arg (call,
3291 internal_fn_stored_value_index (fn));
3292 def_rhs = vn_valueize (def_rhs);
3293 if (TREE_CODE (def_rhs) != VECTOR_CST)
3294 return (void *)-1;
3296 ao_ref_init_from_ptr_and_size (&lhs_ref,
3297 vn_valueize (gimple_call_arg (call, 0)),
3298 TYPE_SIZE_UNIT (TREE_TYPE (def_rhs)));
3299 tree base2;
3300 poly_int64 offset2, size2, maxsize2;
3301 HOST_WIDE_INT offset2i, size2i, offseti;
3302 base2 = ao_ref_base (&lhs_ref);
3303 offset2 = lhs_ref.offset;
3304 size2 = lhs_ref.size;
3305 maxsize2 = lhs_ref.max_size;
3306 if (known_size_p (maxsize2)
3307 && known_eq (maxsize2, size2)
3308 && adjust_offsets_for_equal_base_address (base, &offset,
3309 base2, &offset2)
3310 && maxsize.is_constant (&maxsizei)
3311 && offset.is_constant (&offseti)
3312 && offset2.is_constant (&offset2i)
3313 && size2.is_constant (&size2i))
3315 if (!ranges_maybe_overlap_p (offset, maxsize, offset2, size2))
3316 /* Poor-mans disambiguation. */
3317 return NULL;
3318 else if (ranges_known_overlap_p (offset, maxsize, offset2, size2))
3320 pd_data pd;
3321 pd.rhs = def_rhs;
3322 tree aa = gimple_call_arg (call, 1);
3323 alias_set_type set = get_deref_alias_set (TREE_TYPE (aa));
3324 tree vectype = TREE_TYPE (def_rhs);
3325 unsigned HOST_WIDE_INT elsz
3326 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (vectype)));
3327 if (mask)
3329 HOST_WIDE_INT start = 0, len = 0;
3330 unsigned mask_idx = 0;
3333 if (integer_zerop (VECTOR_CST_ELT (mask, mask_idx)))
3335 if (len != 0)
3337 pd.rhs_off = start;
3338 pd.offset = offset2i + start;
3339 pd.size = len;
3340 if (ranges_known_overlap_p
3341 (offset, maxsize, pd.offset, pd.size))
3343 void *res = data->push_partial_def
3344 (pd, set, set, offseti, maxsizei);
3345 if (res != NULL)
3346 return res;
3349 start = (mask_idx + 1) * elsz;
3350 len = 0;
3352 else
3353 len += elsz;
3354 mask_idx++;
3356 while (known_lt (mask_idx, TYPE_VECTOR_SUBPARTS (vectype)));
3357 if (len != 0)
3359 pd.rhs_off = start;
3360 pd.offset = offset2i + start;
3361 pd.size = len;
3362 if (ranges_known_overlap_p (offset, maxsize,
3363 pd.offset, pd.size))
3364 return data->push_partial_def (pd, set, set,
3365 offseti, maxsizei);
3368 else if (fn == IFN_LEN_STORE)
3370 pd.offset = offset2i;
3371 pd.size = (tree_to_uhwi (len)
3372 + -tree_to_shwi (bias)) * BITS_PER_UNIT;
3373 if (BYTES_BIG_ENDIAN)
3374 pd.rhs_off = pd.size - tree_to_uhwi (TYPE_SIZE (vectype));
3375 else
3376 pd.rhs_off = 0;
3377 if (ranges_known_overlap_p (offset, maxsize,
3378 pd.offset, pd.size))
3379 return data->push_partial_def (pd, set, set,
3380 offseti, maxsizei);
3382 else
3383 gcc_unreachable ();
3384 return NULL;
3389 /* 5) For aggregate copies translate the reference through them if
3390 the copy kills ref. */
3391 else if (data->vn_walk_kind == VN_WALKREWRITE
3392 && gimple_assign_single_p (def_stmt)
3393 && (DECL_P (gimple_assign_rhs1 (def_stmt))
3394 || TREE_CODE (gimple_assign_rhs1 (def_stmt)) == MEM_REF
3395 || handled_component_p (gimple_assign_rhs1 (def_stmt))))
3397 tree base2;
3398 int i, j, k;
3399 auto_vec<vn_reference_op_s> rhs;
3400 vn_reference_op_t vro;
3401 ao_ref r;
3403 gcc_assert (lhs_ref_ok);
3405 /* See if the assignment kills REF. */
3406 base2 = ao_ref_base (&lhs_ref);
3407 if (!lhs_ref.max_size_known_p ()
3408 || (base != base2
3409 && (TREE_CODE (base) != MEM_REF
3410 || TREE_CODE (base2) != MEM_REF
3411 || TREE_OPERAND (base, 0) != TREE_OPERAND (base2, 0)
3412 || !tree_int_cst_equal (TREE_OPERAND (base, 1),
3413 TREE_OPERAND (base2, 1))))
3414 || !stmt_kills_ref_p (def_stmt, ref))
3415 return (void *)-1;
3417 /* Find the common base of ref and the lhs. lhs_ops already
3418 contains valueized operands for the lhs. */
3419 i = vr->operands.length () - 1;
3420 j = lhs_ops.length () - 1;
3421 while (j >= 0 && i >= 0
3422 && vn_reference_op_eq (&vr->operands[i], &lhs_ops[j]))
3424 i--;
3425 j--;
3428 /* ??? The innermost op should always be a MEM_REF and we already
3429 checked that the assignment to the lhs kills vr. Thus for
3430 aggregate copies using char[] types the vn_reference_op_eq
3431 may fail when comparing types for compatibility. But we really
3432 don't care here - further lookups with the rewritten operands
3433 will simply fail if we messed up types too badly. */
3434 poly_int64 extra_off = 0;
3435 if (j == 0 && i >= 0
3436 && lhs_ops[0].opcode == MEM_REF
3437 && maybe_ne (lhs_ops[0].off, -1))
3439 if (known_eq (lhs_ops[0].off, vr->operands[i].off))
3440 i--, j--;
3441 else if (vr->operands[i].opcode == MEM_REF
3442 && maybe_ne (vr->operands[i].off, -1))
3444 extra_off = vr->operands[i].off - lhs_ops[0].off;
3445 i--, j--;
3449 /* i now points to the first additional op.
3450 ??? LHS may not be completely contained in VR, one or more
3451 VIEW_CONVERT_EXPRs could be in its way. We could at least
3452 try handling outermost VIEW_CONVERT_EXPRs. */
3453 if (j != -1)
3454 return (void *)-1;
3456 /* Punt if the additional ops contain a storage order barrier. */
3457 for (k = i; k >= 0; k--)
3459 vro = &vr->operands[k];
3460 if (vro->opcode == VIEW_CONVERT_EXPR && vro->reverse)
3461 return (void *)-1;
3464 /* Now re-write REF to be based on the rhs of the assignment. */
3465 tree rhs1 = gimple_assign_rhs1 (def_stmt);
3466 copy_reference_ops_from_ref (rhs1, &rhs);
3468 /* Apply an extra offset to the inner MEM_REF of the RHS. */
3469 bool force_no_tbaa = false;
3470 if (maybe_ne (extra_off, 0))
3472 if (rhs.length () < 2)
3473 return (void *)-1;
3474 int ix = rhs.length () - 2;
3475 if (rhs[ix].opcode != MEM_REF
3476 || known_eq (rhs[ix].off, -1))
3477 return (void *)-1;
3478 rhs[ix].off += extra_off;
3479 rhs[ix].op0 = int_const_binop (PLUS_EXPR, rhs[ix].op0,
3480 build_int_cst (TREE_TYPE (rhs[ix].op0),
3481 extra_off));
3482 /* When we have offsetted the RHS, reading only parts of it,
3483 we can no longer use the original TBAA type, force alias-set
3484 zero. */
3485 force_no_tbaa = true;
3488 /* Save the operands since we need to use the original ones for
3489 the hash entry we use. */
3490 if (!data->saved_operands.exists ())
3491 data->saved_operands = vr->operands.copy ();
3493 /* We need to pre-pend vr->operands[0..i] to rhs. */
3494 vec<vn_reference_op_s> old = vr->operands;
3495 if (i + 1 + rhs.length () > vr->operands.length ())
3496 vr->operands.safe_grow (i + 1 + rhs.length (), true);
3497 else
3498 vr->operands.truncate (i + 1 + rhs.length ());
3499 FOR_EACH_VEC_ELT (rhs, j, vro)
3500 vr->operands[i + 1 + j] = *vro;
3501 valueize_refs (&vr->operands);
3502 if (old == shared_lookup_references)
3503 shared_lookup_references = vr->operands;
3504 vr->hashcode = vn_reference_compute_hash (vr);
3506 /* Try folding the new reference to a constant. */
3507 tree val = fully_constant_vn_reference_p (vr);
3508 if (val)
3510 if (data->partial_defs.is_empty ())
3511 return data->finish (ao_ref_alias_set (&lhs_ref),
3512 ao_ref_base_alias_set (&lhs_ref), val);
3513 /* This is the only interesting case for partial-def handling
3514 coming from targets that like to gimplify init-ctors as
3515 aggregate copies from constant data like aarch64 for
3516 PR83518. */
3517 if (maxsize.is_constant (&maxsizei) && known_eq (ref->size, maxsize))
3519 pd_data pd;
3520 pd.rhs = val;
3521 pd.rhs_off = 0;
3522 pd.offset = 0;
3523 pd.size = maxsizei;
3524 return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
3525 ao_ref_base_alias_set (&lhs_ref),
3526 0, maxsizei);
3530 /* Continuing with partial defs isn't easily possible here, we
3531 have to find a full def from further lookups from here. Probably
3532 not worth the special-casing everywhere. */
3533 if (!data->partial_defs.is_empty ())
3534 return (void *)-1;
3536 /* Adjust *ref from the new operands. */
3537 ao_ref rhs1_ref;
3538 ao_ref_init (&rhs1_ref, rhs1);
3539 if (!ao_ref_init_from_vn_reference (&r,
3540 force_no_tbaa ? 0
3541 : ao_ref_alias_set (&rhs1_ref),
3542 force_no_tbaa ? 0
3543 : ao_ref_base_alias_set (&rhs1_ref),
3544 vr->type, vr->operands))
3545 return (void *)-1;
3546 /* This can happen with bitfields. */
3547 if (maybe_ne (ref->size, r.size))
3549 /* If the access lacks some subsetting simply apply that by
3550 shortening it. That in the end can only be successful
3551 if we can pun the lookup result which in turn requires
3552 exact offsets. */
3553 if (known_eq (r.size, r.max_size)
3554 && known_lt (ref->size, r.size))
3555 r.size = r.max_size = ref->size;
3556 else
3557 return (void *)-1;
3559 *ref = r;
3561 /* Do not update last seen VUSE after translating. */
3562 data->last_vuse_ptr = NULL;
3563 /* Invalidate the original access path since it now contains
3564 the wrong base. */
3565 data->orig_ref.ref = NULL_TREE;
3566 /* Use the alias-set of this LHS for recording an eventual result. */
3567 if (data->first_set == -2)
3569 data->first_set = ao_ref_alias_set (&lhs_ref);
3570 data->first_base_set = ao_ref_base_alias_set (&lhs_ref);
3573 /* Keep looking for the adjusted *REF / VR pair. */
3574 return NULL;
3577 /* 6) For memcpy copies translate the reference through them if the copy
3578 kills ref. But we cannot (easily) do this translation if the memcpy is
3579 a storage order barrier, i.e. is equivalent to a VIEW_CONVERT_EXPR that
3580 can modify the storage order of objects (see storage_order_barrier_p). */
3581 else if (data->vn_walk_kind == VN_WALKREWRITE
3582 && is_gimple_reg_type (vr->type)
3583 /* ??? Handle BCOPY as well. */
3584 && (gimple_call_builtin_p (def_stmt, BUILT_IN_MEMCPY)
3585 || gimple_call_builtin_p (def_stmt, BUILT_IN_MEMCPY_CHK)
3586 || gimple_call_builtin_p (def_stmt, BUILT_IN_MEMPCPY)
3587 || gimple_call_builtin_p (def_stmt, BUILT_IN_MEMPCPY_CHK)
3588 || gimple_call_builtin_p (def_stmt, BUILT_IN_MEMMOVE)
3589 || gimple_call_builtin_p (def_stmt, BUILT_IN_MEMMOVE_CHK))
3590 && (TREE_CODE (gimple_call_arg (def_stmt, 0)) == ADDR_EXPR
3591 || TREE_CODE (gimple_call_arg (def_stmt, 0)) == SSA_NAME)
3592 && (TREE_CODE (gimple_call_arg (def_stmt, 1)) == ADDR_EXPR
3593 || TREE_CODE (gimple_call_arg (def_stmt, 1)) == SSA_NAME)
3594 && (poly_int_tree_p (gimple_call_arg (def_stmt, 2), &copy_size)
3595 || (TREE_CODE (gimple_call_arg (def_stmt, 2)) == SSA_NAME
3596 && poly_int_tree_p (SSA_VAL (gimple_call_arg (def_stmt, 2)),
3597 &copy_size)))
3598 /* Handling this is more complicated, give up for now. */
3599 && data->partial_defs.is_empty ())
3601 tree lhs, rhs;
3602 ao_ref r;
3603 poly_int64 rhs_offset, lhs_offset;
3604 vn_reference_op_s op;
3605 poly_uint64 mem_offset;
3606 poly_int64 at, byte_maxsize;
3608 /* Only handle non-variable, addressable refs. */
3609 if (maybe_ne (ref->size, maxsize)
3610 || !multiple_p (offset, BITS_PER_UNIT, &at)
3611 || !multiple_p (maxsize, BITS_PER_UNIT, &byte_maxsize))
3612 return (void *)-1;
3614 /* Extract a pointer base and an offset for the destination. */
3615 lhs = gimple_call_arg (def_stmt, 0);
3616 lhs_offset = 0;
3617 if (TREE_CODE (lhs) == SSA_NAME)
3619 lhs = vn_valueize (lhs);
3620 if (TREE_CODE (lhs) == SSA_NAME)
3622 gimple *def_stmt = SSA_NAME_DEF_STMT (lhs);
3623 if (gimple_assign_single_p (def_stmt)
3624 && gimple_assign_rhs_code (def_stmt) == ADDR_EXPR)
3625 lhs = gimple_assign_rhs1 (def_stmt);
3628 if (TREE_CODE (lhs) == ADDR_EXPR)
3630 if (AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (lhs)))
3631 && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (TREE_TYPE (lhs))))
3632 return (void *)-1;
3633 tree tem = get_addr_base_and_unit_offset (TREE_OPERAND (lhs, 0),
3634 &lhs_offset);
3635 if (!tem)
3636 return (void *)-1;
3637 if (TREE_CODE (tem) == MEM_REF
3638 && poly_int_tree_p (TREE_OPERAND (tem, 1), &mem_offset))
3640 lhs = TREE_OPERAND (tem, 0);
3641 if (TREE_CODE (lhs) == SSA_NAME)
3642 lhs = vn_valueize (lhs);
3643 lhs_offset += mem_offset;
3645 else if (DECL_P (tem))
3646 lhs = build_fold_addr_expr (tem);
3647 else
3648 return (void *)-1;
3650 if (TREE_CODE (lhs) != SSA_NAME
3651 && TREE_CODE (lhs) != ADDR_EXPR)
3652 return (void *)-1;
3654 /* Extract a pointer base and an offset for the source. */
3655 rhs = gimple_call_arg (def_stmt, 1);
3656 rhs_offset = 0;
3657 if (TREE_CODE (rhs) == SSA_NAME)
3658 rhs = vn_valueize (rhs);
3659 if (TREE_CODE (rhs) == ADDR_EXPR)
3661 if (AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (rhs)))
3662 && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (TREE_TYPE (rhs))))
3663 return (void *)-1;
3664 tree tem = get_addr_base_and_unit_offset (TREE_OPERAND (rhs, 0),
3665 &rhs_offset);
3666 if (!tem)
3667 return (void *)-1;
3668 if (TREE_CODE (tem) == MEM_REF
3669 && poly_int_tree_p (TREE_OPERAND (tem, 1), &mem_offset))
3671 rhs = TREE_OPERAND (tem, 0);
3672 rhs_offset += mem_offset;
3674 else if (DECL_P (tem)
3675 || TREE_CODE (tem) == STRING_CST)
3676 rhs = build_fold_addr_expr (tem);
3677 else
3678 return (void *)-1;
3680 if (TREE_CODE (rhs) == SSA_NAME)
3681 rhs = SSA_VAL (rhs);
3682 else if (TREE_CODE (rhs) != ADDR_EXPR)
3683 return (void *)-1;
3685 /* The bases of the destination and the references have to agree. */
3686 if (TREE_CODE (base) == MEM_REF)
3688 if (TREE_OPERAND (base, 0) != lhs
3689 || !poly_int_tree_p (TREE_OPERAND (base, 1), &mem_offset))
3690 return (void *) -1;
3691 at += mem_offset;
3693 else if (!DECL_P (base)
3694 || TREE_CODE (lhs) != ADDR_EXPR
3695 || TREE_OPERAND (lhs, 0) != base)
3696 return (void *)-1;
3698 /* If the access is completely outside of the memcpy destination
3699 area there is no aliasing. */
3700 if (!ranges_maybe_overlap_p (lhs_offset, copy_size, at, byte_maxsize))
3701 return NULL;
3702 /* And the access has to be contained within the memcpy destination. */
3703 if (!known_subrange_p (at, byte_maxsize, lhs_offset, copy_size))
3704 return (void *)-1;
3706 /* Save the operands since we need to use the original ones for
3707 the hash entry we use. */
3708 if (!data->saved_operands.exists ())
3709 data->saved_operands = vr->operands.copy ();
3711 /* Make room for 2 operands in the new reference. */
3712 if (vr->operands.length () < 2)
3714 vec<vn_reference_op_s> old = vr->operands;
3715 vr->operands.safe_grow_cleared (2, true);
3716 if (old == shared_lookup_references)
3717 shared_lookup_references = vr->operands;
3719 else
3720 vr->operands.truncate (2);
3722 /* The looked-through reference is a simple MEM_REF. */
3723 memset (&op, 0, sizeof (op));
3724 op.type = vr->type;
3725 op.opcode = MEM_REF;
3726 op.op0 = build_int_cst (ptr_type_node, at - lhs_offset + rhs_offset);
3727 op.off = at - lhs_offset + rhs_offset;
3728 vr->operands[0] = op;
3729 op.type = TREE_TYPE (rhs);
3730 op.opcode = TREE_CODE (rhs);
3731 op.op0 = rhs;
3732 op.off = -1;
3733 vr->operands[1] = op;
3734 vr->hashcode = vn_reference_compute_hash (vr);
3736 /* Try folding the new reference to a constant. */
3737 tree val = fully_constant_vn_reference_p (vr);
3738 if (val)
3739 return data->finish (0, 0, val);
3741 /* Adjust *ref from the new operands. */
3742 if (!ao_ref_init_from_vn_reference (&r, 0, 0, vr->type, vr->operands))
3743 return (void *)-1;
3744 /* This can happen with bitfields. */
3745 if (maybe_ne (ref->size, r.size))
3746 return (void *)-1;
3747 *ref = r;
3749 /* Do not update last seen VUSE after translating. */
3750 data->last_vuse_ptr = NULL;
3751 /* Invalidate the original access path since it now contains
3752 the wrong base. */
3753 data->orig_ref.ref = NULL_TREE;
3754 /* Use the alias-set of this stmt for recording an eventual result. */
3755 if (data->first_set == -2)
3757 data->first_set = 0;
3758 data->first_base_set = 0;
3761 /* Keep looking for the adjusted *REF / VR pair. */
3762 return NULL;
3765 /* Bail out and stop walking. */
3766 return (void *)-1;
3769 /* Return a reference op vector from OP that can be used for
3770 vn_reference_lookup_pieces. The caller is responsible for releasing
3771 the vector. */
3773 vec<vn_reference_op_s>
3774 vn_reference_operands_for_lookup (tree op)
3776 bool valueized;
3777 return valueize_shared_reference_ops_from_ref (op, &valueized).copy ();
3780 /* Lookup a reference operation by it's parts, in the current hash table.
3781 Returns the resulting value number if it exists in the hash table,
3782 NULL_TREE otherwise. VNRESULT will be filled in with the actual
3783 vn_reference_t stored in the hashtable if something is found. */
3785 tree
3786 vn_reference_lookup_pieces (tree vuse, alias_set_type set,
3787 alias_set_type base_set, tree type,
3788 vec<vn_reference_op_s> operands,
3789 vn_reference_t *vnresult, vn_lookup_kind kind)
3791 struct vn_reference_s vr1;
3792 vn_reference_t tmp;
3793 tree cst;
3795 if (!vnresult)
3796 vnresult = &tmp;
3797 *vnresult = NULL;
3799 vr1.vuse = vuse_ssa_val (vuse);
3800 shared_lookup_references.truncate (0);
3801 shared_lookup_references.safe_grow (operands.length (), true);
3802 memcpy (shared_lookup_references.address (),
3803 operands.address (),
3804 sizeof (vn_reference_op_s)
3805 * operands.length ());
3806 bool valueized_p;
3807 valueize_refs_1 (&shared_lookup_references, &valueized_p);
3808 vr1.operands = shared_lookup_references;
3809 vr1.type = type;
3810 vr1.set = set;
3811 vr1.base_set = base_set;
3812 vr1.hashcode = vn_reference_compute_hash (&vr1);
3813 if ((cst = fully_constant_vn_reference_p (&vr1)))
3814 return cst;
3816 vn_reference_lookup_1 (&vr1, vnresult);
3817 if (!*vnresult
3818 && kind != VN_NOWALK
3819 && vr1.vuse)
3821 ao_ref r;
3822 unsigned limit = param_sccvn_max_alias_queries_per_access;
3823 vn_walk_cb_data data (&vr1, NULL_TREE, NULL, kind, true, NULL_TREE,
3824 false);
3825 vec<vn_reference_op_s> ops_for_ref;
3826 if (!valueized_p)
3827 ops_for_ref = vr1.operands;
3828 else
3830 /* For ao_ref_from_mem we have to ensure only available SSA names
3831 end up in base and the only convenient way to make this work
3832 for PRE is to re-valueize with that in mind. */
3833 ops_for_ref.create (operands.length ());
3834 ops_for_ref.quick_grow (operands.length ());
3835 memcpy (ops_for_ref.address (),
3836 operands.address (),
3837 sizeof (vn_reference_op_s)
3838 * operands.length ());
3839 valueize_refs_1 (&ops_for_ref, &valueized_p, true);
3841 if (ao_ref_init_from_vn_reference (&r, set, base_set, type,
3842 ops_for_ref))
3843 *vnresult
3844 = ((vn_reference_t)
3845 walk_non_aliased_vuses (&r, vr1.vuse, true, vn_reference_lookup_2,
3846 vn_reference_lookup_3, vuse_valueize,
3847 limit, &data));
3848 if (ops_for_ref != shared_lookup_references)
3849 ops_for_ref.release ();
3850 gcc_checking_assert (vr1.operands == shared_lookup_references);
3851 if (*vnresult
3852 && data.same_val
3853 && (!(*vnresult)->result
3854 || !operand_equal_p ((*vnresult)->result, data.same_val)))
3856 *vnresult = NULL;
3857 return NULL_TREE;
3861 if (*vnresult)
3862 return (*vnresult)->result;
3864 return NULL_TREE;
3867 /* Lookup OP in the current hash table, and return the resulting value
3868 number if it exists in the hash table. Return NULL_TREE if it does
3869 not exist in the hash table or if the result field of the structure
3870 was NULL.. VNRESULT will be filled in with the vn_reference_t
3871 stored in the hashtable if one exists. When TBAA_P is false assume
3872 we are looking up a store and treat it as having alias-set zero.
3873 *LAST_VUSE_PTR will be updated with the VUSE the value lookup succeeded.
3874 MASK is either NULL_TREE, or can be an INTEGER_CST if the result of the
3875 load is bitwise anded with MASK and so we are only interested in a subset
3876 of the bits and can ignore if the other bits are uninitialized or
3877 not initialized with constants. When doing redundant store removal
3878 the caller has to set REDUNDANT_STORE_REMOVAL_P. */
3880 tree
3881 vn_reference_lookup (tree op, tree vuse, vn_lookup_kind kind,
3882 vn_reference_t *vnresult, bool tbaa_p,
3883 tree *last_vuse_ptr, tree mask,
3884 bool redundant_store_removal_p)
3886 vec<vn_reference_op_s> operands;
3887 struct vn_reference_s vr1;
3888 bool valueized_anything;
3890 if (vnresult)
3891 *vnresult = NULL;
3893 vr1.vuse = vuse_ssa_val (vuse);
3894 vr1.operands = operands
3895 = valueize_shared_reference_ops_from_ref (op, &valueized_anything);
3897 /* Handle &MEM[ptr + 5].b[1].c as POINTER_PLUS_EXPR. Avoid doing
3898 this before the pass folding __builtin_object_size had a chance to run. */
3899 if ((cfun->curr_properties & PROP_objsz)
3900 && operands[0].opcode == ADDR_EXPR
3901 && operands.last ().opcode == SSA_NAME)
3903 poly_int64 off = 0;
3904 vn_reference_op_t vro;
3905 unsigned i;
3906 for (i = 1; operands.iterate (i, &vro); ++i)
3908 if (vro->opcode == SSA_NAME)
3909 break;
3910 else if (known_eq (vro->off, -1))
3911 break;
3912 off += vro->off;
3914 if (i == operands.length () - 1
3915 /* Make sure we the offset we accumulated in a 64bit int
3916 fits the address computation carried out in target
3917 offset precision. */
3918 && (off.coeffs[0]
3919 == sext_hwi (off.coeffs[0], TYPE_PRECISION (sizetype))))
3921 gcc_assert (operands[i-1].opcode == MEM_REF);
3922 tree ops[2];
3923 ops[0] = operands[i].op0;
3924 ops[1] = wide_int_to_tree (sizetype, off);
3925 tree res = vn_nary_op_lookup_pieces (2, POINTER_PLUS_EXPR,
3926 TREE_TYPE (op), ops, NULL);
3927 if (res)
3928 return res;
3929 return NULL_TREE;
3933 vr1.type = TREE_TYPE (op);
3934 ao_ref op_ref;
3935 ao_ref_init (&op_ref, op);
3936 vr1.set = ao_ref_alias_set (&op_ref);
3937 vr1.base_set = ao_ref_base_alias_set (&op_ref);
3938 vr1.hashcode = vn_reference_compute_hash (&vr1);
3939 if (mask == NULL_TREE)
3940 if (tree cst = fully_constant_vn_reference_p (&vr1))
3941 return cst;
3943 if (kind != VN_NOWALK && vr1.vuse)
3945 vn_reference_t wvnresult;
3946 ao_ref r;
3947 unsigned limit = param_sccvn_max_alias_queries_per_access;
3948 auto_vec<vn_reference_op_s> ops_for_ref;
3949 if (valueized_anything)
3951 copy_reference_ops_from_ref (op, &ops_for_ref);
3952 bool tem;
3953 valueize_refs_1 (&ops_for_ref, &tem, true);
3955 /* Make sure to use a valueized reference if we valueized anything.
3956 Otherwise preserve the full reference for advanced TBAA. */
3957 if (!valueized_anything
3958 || !ao_ref_init_from_vn_reference (&r, vr1.set, vr1.base_set,
3959 vr1.type, ops_for_ref))
3960 ao_ref_init (&r, op);
3961 vn_walk_cb_data data (&vr1, r.ref ? NULL_TREE : op,
3962 last_vuse_ptr, kind, tbaa_p, mask,
3963 redundant_store_removal_p);
3965 wvnresult
3966 = ((vn_reference_t)
3967 walk_non_aliased_vuses (&r, vr1.vuse, tbaa_p, vn_reference_lookup_2,
3968 vn_reference_lookup_3, vuse_valueize, limit,
3969 &data));
3970 gcc_checking_assert (vr1.operands == shared_lookup_references);
3971 if (wvnresult)
3973 gcc_assert (mask == NULL_TREE);
3974 if (data.same_val
3975 && (!wvnresult->result
3976 || !operand_equal_p (wvnresult->result, data.same_val)))
3977 return NULL_TREE;
3978 if (vnresult)
3979 *vnresult = wvnresult;
3980 return wvnresult->result;
3982 else if (mask)
3983 return data.masked_result;
3985 return NULL_TREE;
3988 if (last_vuse_ptr)
3989 *last_vuse_ptr = vr1.vuse;
3990 if (mask)
3991 return NULL_TREE;
3992 return vn_reference_lookup_1 (&vr1, vnresult);
3995 /* Lookup CALL in the current hash table and return the entry in
3996 *VNRESULT if found. Populates *VR for the hashtable lookup. */
3998 void
3999 vn_reference_lookup_call (gcall *call, vn_reference_t *vnresult,
4000 vn_reference_t vr)
4002 if (vnresult)
4003 *vnresult = NULL;
4005 tree vuse = gimple_vuse (call);
4007 vr->vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
4008 vr->operands = valueize_shared_reference_ops_from_call (call);
4009 tree lhs = gimple_call_lhs (call);
4010 /* For non-SSA return values the referece ops contain the LHS. */
4011 vr->type = ((lhs && TREE_CODE (lhs) == SSA_NAME)
4012 ? TREE_TYPE (lhs) : NULL_TREE);
4013 vr->punned = false;
4014 vr->set = 0;
4015 vr->base_set = 0;
4016 vr->hashcode = vn_reference_compute_hash (vr);
4017 vn_reference_lookup_1 (vr, vnresult);
4020 /* Insert OP into the current hash table with a value number of RESULT. */
4022 static void
4023 vn_reference_insert (tree op, tree result, tree vuse, tree vdef)
4025 vn_reference_s **slot;
4026 vn_reference_t vr1;
4027 bool tem;
4029 vec<vn_reference_op_s> operands
4030 = valueize_shared_reference_ops_from_ref (op, &tem);
4031 /* Handle &MEM[ptr + 5].b[1].c as POINTER_PLUS_EXPR. Avoid doing this
4032 before the pass folding __builtin_object_size had a chance to run. */
4033 if ((cfun->curr_properties & PROP_objsz)
4034 && operands[0].opcode == ADDR_EXPR
4035 && operands.last ().opcode == SSA_NAME)
4037 poly_int64 off = 0;
4038 vn_reference_op_t vro;
4039 unsigned i;
4040 for (i = 1; operands.iterate (i, &vro); ++i)
4042 if (vro->opcode == SSA_NAME)
4043 break;
4044 else if (known_eq (vro->off, -1))
4045 break;
4046 off += vro->off;
4048 if (i == operands.length () - 1
4049 /* Make sure we the offset we accumulated in a 64bit int
4050 fits the address computation carried out in target
4051 offset precision. */
4052 && (off.coeffs[0]
4053 == sext_hwi (off.coeffs[0], TYPE_PRECISION (sizetype))))
4055 gcc_assert (operands[i-1].opcode == MEM_REF);
4056 tree ops[2];
4057 ops[0] = operands[i].op0;
4058 ops[1] = wide_int_to_tree (sizetype, off);
4059 vn_nary_op_insert_pieces (2, POINTER_PLUS_EXPR,
4060 TREE_TYPE (op), ops, result,
4061 VN_INFO (result)->value_id);
4062 return;
4066 vr1 = XOBNEW (&vn_tables_obstack, vn_reference_s);
4067 if (TREE_CODE (result) == SSA_NAME)
4068 vr1->value_id = VN_INFO (result)->value_id;
4069 else
4070 vr1->value_id = get_or_alloc_constant_value_id (result);
4071 vr1->vuse = vuse_ssa_val (vuse);
4072 vr1->operands = operands.copy ();
4073 vr1->type = TREE_TYPE (op);
4074 vr1->punned = false;
4075 ao_ref op_ref;
4076 ao_ref_init (&op_ref, op);
4077 vr1->set = ao_ref_alias_set (&op_ref);
4078 vr1->base_set = ao_ref_base_alias_set (&op_ref);
4079 vr1->hashcode = vn_reference_compute_hash (vr1);
4080 vr1->result = TREE_CODE (result) == SSA_NAME ? SSA_VAL (result) : result;
4081 vr1->result_vdef = vdef;
4083 slot = valid_info->references->find_slot_with_hash (vr1, vr1->hashcode,
4084 INSERT);
4086 /* Because IL walking on reference lookup can end up visiting
4087 a def that is only to be visited later in iteration order
4088 when we are about to make an irreducible region reducible
4089 the def can be effectively processed and its ref being inserted
4090 by vn_reference_lookup_3 already. So we cannot assert (!*slot)
4091 but save a lookup if we deal with already inserted refs here. */
4092 if (*slot)
4094 /* We cannot assert that we have the same value either because
4095 when disentangling an irreducible region we may end up visiting
4096 a use before the corresponding def. That's a missed optimization
4097 only though. See gcc.dg/tree-ssa/pr87126.c for example. */
4098 if (dump_file && (dump_flags & TDF_DETAILS)
4099 && !operand_equal_p ((*slot)->result, vr1->result, 0))
4101 fprintf (dump_file, "Keeping old value ");
4102 print_generic_expr (dump_file, (*slot)->result);
4103 fprintf (dump_file, " because of collision\n");
4105 free_reference (vr1);
4106 obstack_free (&vn_tables_obstack, vr1);
4107 return;
4110 *slot = vr1;
4111 vr1->next = last_inserted_ref;
4112 last_inserted_ref = vr1;
4115 /* Insert a reference by it's pieces into the current hash table with
4116 a value number of RESULT. Return the resulting reference
4117 structure we created. */
4119 vn_reference_t
4120 vn_reference_insert_pieces (tree vuse, alias_set_type set,
4121 alias_set_type base_set, tree type,
4122 vec<vn_reference_op_s> operands,
4123 tree result, unsigned int value_id)
4126 vn_reference_s **slot;
4127 vn_reference_t vr1;
4129 vr1 = XOBNEW (&vn_tables_obstack, vn_reference_s);
4130 vr1->value_id = value_id;
4131 vr1->vuse = vuse_ssa_val (vuse);
4132 vr1->operands = operands;
4133 valueize_refs (&vr1->operands);
4134 vr1->type = type;
4135 vr1->punned = false;
4136 vr1->set = set;
4137 vr1->base_set = base_set;
4138 vr1->hashcode = vn_reference_compute_hash (vr1);
4139 if (result && TREE_CODE (result) == SSA_NAME)
4140 result = SSA_VAL (result);
4141 vr1->result = result;
4142 vr1->result_vdef = NULL_TREE;
4144 slot = valid_info->references->find_slot_with_hash (vr1, vr1->hashcode,
4145 INSERT);
4147 /* At this point we should have all the things inserted that we have
4148 seen before, and we should never try inserting something that
4149 already exists. */
4150 gcc_assert (!*slot);
4152 *slot = vr1;
4153 vr1->next = last_inserted_ref;
4154 last_inserted_ref = vr1;
4155 return vr1;
4158 /* Compute and return the hash value for nary operation VBO1. */
4160 hashval_t
4161 vn_nary_op_compute_hash (const vn_nary_op_t vno1)
4163 inchash::hash hstate;
4164 unsigned i;
4166 if (((vno1->length == 2
4167 && commutative_tree_code (vno1->opcode))
4168 || (vno1->length == 3
4169 && commutative_ternary_tree_code (vno1->opcode)))
4170 && tree_swap_operands_p (vno1->op[0], vno1->op[1]))
4171 std::swap (vno1->op[0], vno1->op[1]);
4172 else if (TREE_CODE_CLASS (vno1->opcode) == tcc_comparison
4173 && tree_swap_operands_p (vno1->op[0], vno1->op[1]))
4175 std::swap (vno1->op[0], vno1->op[1]);
4176 vno1->opcode = swap_tree_comparison (vno1->opcode);
4179 hstate.add_int (vno1->opcode);
4180 for (i = 0; i < vno1->length; ++i)
4181 inchash::add_expr (vno1->op[i], hstate);
4183 return hstate.end ();
4186 /* Compare nary operations VNO1 and VNO2 and return true if they are
4187 equivalent. */
4189 bool
4190 vn_nary_op_eq (const_vn_nary_op_t const vno1, const_vn_nary_op_t const vno2)
4192 unsigned i;
4194 if (vno1->hashcode != vno2->hashcode)
4195 return false;
4197 if (vno1->length != vno2->length)
4198 return false;
4200 if (vno1->opcode != vno2->opcode
4201 || !types_compatible_p (vno1->type, vno2->type))
4202 return false;
4204 for (i = 0; i < vno1->length; ++i)
4205 if (!expressions_equal_p (vno1->op[i], vno2->op[i]))
4206 return false;
4208 /* BIT_INSERT_EXPR has an implict operand as the type precision
4209 of op1. Need to check to make sure they are the same. */
4210 if (vno1->opcode == BIT_INSERT_EXPR
4211 && TREE_CODE (vno1->op[1]) == INTEGER_CST
4212 && TYPE_PRECISION (TREE_TYPE (vno1->op[1]))
4213 != TYPE_PRECISION (TREE_TYPE (vno2->op[1])))
4214 return false;
4216 return true;
4219 /* Initialize VNO from the pieces provided. */
4221 static void
4222 init_vn_nary_op_from_pieces (vn_nary_op_t vno, unsigned int length,
4223 enum tree_code code, tree type, tree *ops)
4225 vno->opcode = code;
4226 vno->length = length;
4227 vno->type = type;
4228 memcpy (&vno->op[0], ops, sizeof (tree) * length);
4231 /* Return the number of operands for a vn_nary ops structure from STMT. */
4233 unsigned int
4234 vn_nary_length_from_stmt (gimple *stmt)
4236 switch (gimple_assign_rhs_code (stmt))
4238 case REALPART_EXPR:
4239 case IMAGPART_EXPR:
4240 case VIEW_CONVERT_EXPR:
4241 return 1;
4243 case BIT_FIELD_REF:
4244 return 3;
4246 case CONSTRUCTOR:
4247 return CONSTRUCTOR_NELTS (gimple_assign_rhs1 (stmt));
4249 default:
4250 return gimple_num_ops (stmt) - 1;
4254 /* Initialize VNO from STMT. */
4256 void
4257 init_vn_nary_op_from_stmt (vn_nary_op_t vno, gassign *stmt)
4259 unsigned i;
4261 vno->opcode = gimple_assign_rhs_code (stmt);
4262 vno->type = TREE_TYPE (gimple_assign_lhs (stmt));
4263 switch (vno->opcode)
4265 case REALPART_EXPR:
4266 case IMAGPART_EXPR:
4267 case VIEW_CONVERT_EXPR:
4268 vno->length = 1;
4269 vno->op[0] = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0);
4270 break;
4272 case BIT_FIELD_REF:
4273 vno->length = 3;
4274 vno->op[0] = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0);
4275 vno->op[1] = TREE_OPERAND (gimple_assign_rhs1 (stmt), 1);
4276 vno->op[2] = TREE_OPERAND (gimple_assign_rhs1 (stmt), 2);
4277 break;
4279 case CONSTRUCTOR:
4280 vno->length = CONSTRUCTOR_NELTS (gimple_assign_rhs1 (stmt));
4281 for (i = 0; i < vno->length; ++i)
4282 vno->op[i] = CONSTRUCTOR_ELT (gimple_assign_rhs1 (stmt), i)->value;
4283 break;
4285 default:
4286 gcc_checking_assert (!gimple_assign_single_p (stmt));
4287 vno->length = gimple_num_ops (stmt) - 1;
4288 for (i = 0; i < vno->length; ++i)
4289 vno->op[i] = gimple_op (stmt, i + 1);
4293 /* Compute the hashcode for VNO and look for it in the hash table;
4294 return the resulting value number if it exists in the hash table.
4295 Return NULL_TREE if it does not exist in the hash table or if the
4296 result field of the operation is NULL. VNRESULT will contain the
4297 vn_nary_op_t from the hashtable if it exists. */
4299 static tree
4300 vn_nary_op_lookup_1 (vn_nary_op_t vno, vn_nary_op_t *vnresult)
4302 vn_nary_op_s **slot;
4304 if (vnresult)
4305 *vnresult = NULL;
4307 for (unsigned i = 0; i < vno->length; ++i)
4308 if (TREE_CODE (vno->op[i]) == SSA_NAME)
4309 vno->op[i] = SSA_VAL (vno->op[i]);
4311 vno->hashcode = vn_nary_op_compute_hash (vno);
4312 slot = valid_info->nary->find_slot_with_hash (vno, vno->hashcode, NO_INSERT);
4313 if (!slot)
4314 return NULL_TREE;
4315 if (vnresult)
4316 *vnresult = *slot;
4317 return (*slot)->predicated_values ? NULL_TREE : (*slot)->u.result;
4320 /* Lookup a n-ary operation by its pieces and return the resulting value
4321 number if it exists in the hash table. Return NULL_TREE if it does
4322 not exist in the hash table or if the result field of the operation
4323 is NULL. VNRESULT will contain the vn_nary_op_t from the hashtable
4324 if it exists. */
4326 tree
4327 vn_nary_op_lookup_pieces (unsigned int length, enum tree_code code,
4328 tree type, tree *ops, vn_nary_op_t *vnresult)
4330 vn_nary_op_t vno1 = XALLOCAVAR (struct vn_nary_op_s,
4331 sizeof_vn_nary_op (length));
4332 init_vn_nary_op_from_pieces (vno1, length, code, type, ops);
4333 return vn_nary_op_lookup_1 (vno1, vnresult);
4336 /* Lookup the rhs of STMT in the current hash table, and return the resulting
4337 value number if it exists in the hash table. Return NULL_TREE if
4338 it does not exist in the hash table. VNRESULT will contain the
4339 vn_nary_op_t from the hashtable if it exists. */
4341 tree
4342 vn_nary_op_lookup_stmt (gimple *stmt, vn_nary_op_t *vnresult)
4344 vn_nary_op_t vno1
4345 = XALLOCAVAR (struct vn_nary_op_s,
4346 sizeof_vn_nary_op (vn_nary_length_from_stmt (stmt)));
4347 init_vn_nary_op_from_stmt (vno1, as_a <gassign *> (stmt));
4348 return vn_nary_op_lookup_1 (vno1, vnresult);
4351 /* Allocate a vn_nary_op_t with LENGTH operands on STACK. */
4353 vn_nary_op_t
4354 alloc_vn_nary_op_noinit (unsigned int length, struct obstack *stack)
4356 return (vn_nary_op_t) obstack_alloc (stack, sizeof_vn_nary_op (length));
4359 /* Allocate and initialize a vn_nary_op_t on CURRENT_INFO's
4360 obstack. */
4362 static vn_nary_op_t
4363 alloc_vn_nary_op (unsigned int length, tree result, unsigned int value_id)
4365 vn_nary_op_t vno1 = alloc_vn_nary_op_noinit (length, &vn_tables_obstack);
4367 vno1->value_id = value_id;
4368 vno1->length = length;
4369 vno1->predicated_values = 0;
4370 vno1->u.result = result;
4372 return vno1;
4375 /* Insert VNO into TABLE. */
4377 static vn_nary_op_t
4378 vn_nary_op_insert_into (vn_nary_op_t vno, vn_nary_op_table_type *table)
4380 vn_nary_op_s **slot;
4382 gcc_assert (! vno->predicated_values
4383 || (! vno->u.values->next
4384 && vno->u.values->n == 1));
4386 for (unsigned i = 0; i < vno->length; ++i)
4387 if (TREE_CODE (vno->op[i]) == SSA_NAME)
4388 vno->op[i] = SSA_VAL (vno->op[i]);
4390 vno->hashcode = vn_nary_op_compute_hash (vno);
4391 slot = table->find_slot_with_hash (vno, vno->hashcode, INSERT);
4392 vno->unwind_to = *slot;
4393 if (*slot)
4395 /* Prefer non-predicated values.
4396 ??? Only if those are constant, otherwise, with constant predicated
4397 value, turn them into predicated values with entry-block validity
4398 (??? but we always find the first valid result currently). */
4399 if ((*slot)->predicated_values
4400 && ! vno->predicated_values)
4402 /* ??? We cannot remove *slot from the unwind stack list.
4403 For the moment we deal with this by skipping not found
4404 entries but this isn't ideal ... */
4405 *slot = vno;
4406 /* ??? Maintain a stack of states we can unwind in
4407 vn_nary_op_s? But how far do we unwind? In reality
4408 we need to push change records somewhere... Or not
4409 unwind vn_nary_op_s and linking them but instead
4410 unwind the results "list", linking that, which also
4411 doesn't move on hashtable resize. */
4412 /* We can also have a ->unwind_to recording *slot there.
4413 That way we can make u.values a fixed size array with
4414 recording the number of entries but of course we then
4415 have always N copies for each unwind_to-state. Or we
4416 make sure to only ever append and each unwinding will
4417 pop off one entry (but how to deal with predicated
4418 replaced with non-predicated here?) */
4419 vno->next = last_inserted_nary;
4420 last_inserted_nary = vno;
4421 return vno;
4423 else if (vno->predicated_values
4424 && ! (*slot)->predicated_values)
4425 return *slot;
4426 else if (vno->predicated_values
4427 && (*slot)->predicated_values)
4429 /* ??? Factor this all into a insert_single_predicated_value
4430 routine. */
4431 gcc_assert (!vno->u.values->next && vno->u.values->n == 1);
4432 basic_block vno_bb
4433 = BASIC_BLOCK_FOR_FN (cfun, vno->u.values->valid_dominated_by_p[0]);
4434 vn_pval *nval = vno->u.values;
4435 vn_pval **next = &vno->u.values;
4436 bool found = false;
4437 for (vn_pval *val = (*slot)->u.values; val; val = val->next)
4439 if (expressions_equal_p (val->result, nval->result))
4441 found = true;
4442 for (unsigned i = 0; i < val->n; ++i)
4444 basic_block val_bb
4445 = BASIC_BLOCK_FOR_FN (cfun,
4446 val->valid_dominated_by_p[i]);
4447 if (dominated_by_p (CDI_DOMINATORS, vno_bb, val_bb))
4448 /* Value registered with more generic predicate. */
4449 return *slot;
4450 else if (flag_checking)
4451 /* Shouldn't happen, we insert in RPO order. */
4452 gcc_assert (!dominated_by_p (CDI_DOMINATORS,
4453 val_bb, vno_bb));
4455 /* Append value. */
4456 *next = (vn_pval *) obstack_alloc (&vn_tables_obstack,
4457 sizeof (vn_pval)
4458 + val->n * sizeof (int));
4459 (*next)->next = NULL;
4460 (*next)->result = val->result;
4461 (*next)->n = val->n + 1;
4462 memcpy ((*next)->valid_dominated_by_p,
4463 val->valid_dominated_by_p,
4464 val->n * sizeof (int));
4465 (*next)->valid_dominated_by_p[val->n] = vno_bb->index;
4466 next = &(*next)->next;
4467 if (dump_file && (dump_flags & TDF_DETAILS))
4468 fprintf (dump_file, "Appending predicate to value.\n");
4469 continue;
4471 /* Copy other predicated values. */
4472 *next = (vn_pval *) obstack_alloc (&vn_tables_obstack,
4473 sizeof (vn_pval)
4474 + (val->n-1) * sizeof (int));
4475 memcpy (*next, val, sizeof (vn_pval) + (val->n-1) * sizeof (int));
4476 (*next)->next = NULL;
4477 next = &(*next)->next;
4479 if (!found)
4480 *next = nval;
4482 *slot = vno;
4483 vno->next = last_inserted_nary;
4484 last_inserted_nary = vno;
4485 return vno;
4488 /* While we do not want to insert things twice it's awkward to
4489 avoid it in the case where visit_nary_op pattern-matches stuff
4490 and ends up simplifying the replacement to itself. We then
4491 get two inserts, one from visit_nary_op and one from
4492 vn_nary_build_or_lookup.
4493 So allow inserts with the same value number. */
4494 if ((*slot)->u.result == vno->u.result)
4495 return *slot;
4498 /* ??? There's also optimistic vs. previous commited state merging
4499 that is problematic for the case of unwinding. */
4501 /* ??? We should return NULL if we do not use 'vno' and have the
4502 caller release it. */
4503 gcc_assert (!*slot);
4505 *slot = vno;
4506 vno->next = last_inserted_nary;
4507 last_inserted_nary = vno;
4508 return vno;
4511 /* Insert a n-ary operation into the current hash table using it's
4512 pieces. Return the vn_nary_op_t structure we created and put in
4513 the hashtable. */
4515 vn_nary_op_t
4516 vn_nary_op_insert_pieces (unsigned int length, enum tree_code code,
4517 tree type, tree *ops,
4518 tree result, unsigned int value_id)
4520 vn_nary_op_t vno1 = alloc_vn_nary_op (length, result, value_id);
4521 init_vn_nary_op_from_pieces (vno1, length, code, type, ops);
4522 return vn_nary_op_insert_into (vno1, valid_info->nary);
4525 /* Return whether we can track a predicate valid when PRED_E is executed. */
4527 static bool
4528 can_track_predicate_on_edge (edge pred_e)
4530 /* ??? As we are currently recording a basic-block index in
4531 vn_pval.valid_dominated_by_p and using dominance for the
4532 validity check we cannot track predicates on all edges. */
4533 if (single_pred_p (pred_e->dest))
4534 return true;
4535 /* Never record for backedges. */
4536 if (pred_e->flags & EDGE_DFS_BACK)
4537 return false;
4538 /* When there's more than one predecessor we cannot track
4539 predicate validity based on the destination block. The
4540 exception is when all other incoming edges are backedges. */
4541 edge_iterator ei;
4542 edge e;
4543 int cnt = 0;
4544 FOR_EACH_EDGE (e, ei, pred_e->dest->preds)
4545 if (! dominated_by_p (CDI_DOMINATORS, e->src, e->dest))
4546 cnt++;
4547 return cnt == 1;
4550 static vn_nary_op_t
4551 vn_nary_op_insert_pieces_predicated (unsigned int length, enum tree_code code,
4552 tree type, tree *ops,
4553 tree result, unsigned int value_id,
4554 edge pred_e)
4556 if (!can_track_predicate_on_edge (pred_e))
4557 return NULL;
4558 if (dump_file && (dump_flags & TDF_DETAILS)
4559 /* ??? Fix dumping, but currently we only get comparisons. */
4560 && TREE_CODE_CLASS (code) == tcc_comparison)
4562 fprintf (dump_file, "Recording on edge %d->%d ", pred_e->src->index,
4563 pred_e->dest->index);
4564 print_generic_expr (dump_file, ops[0], TDF_SLIM);
4565 fprintf (dump_file, " %s ", get_tree_code_name (code));
4566 print_generic_expr (dump_file, ops[1], TDF_SLIM);
4567 fprintf (dump_file, " == %s\n",
4568 integer_zerop (result) ? "false" : "true");
4570 vn_nary_op_t vno1 = alloc_vn_nary_op (length, NULL_TREE, value_id);
4571 init_vn_nary_op_from_pieces (vno1, length, code, type, ops);
4572 vno1->predicated_values = 1;
4573 vno1->u.values = (vn_pval *) obstack_alloc (&vn_tables_obstack,
4574 sizeof (vn_pval));
4575 vno1->u.values->next = NULL;
4576 vno1->u.values->result = result;
4577 vno1->u.values->n = 1;
4578 vno1->u.values->valid_dominated_by_p[0] = pred_e->dest->index;
4579 return vn_nary_op_insert_into (vno1, valid_info->nary);
4582 static bool
4583 dominated_by_p_w_unex (basic_block bb1, basic_block bb2, bool);
4585 static tree
4586 vn_nary_op_get_predicated_value (vn_nary_op_t vno, basic_block bb)
4588 if (! vno->predicated_values)
4589 return vno->u.result;
4590 for (vn_pval *val = vno->u.values; val; val = val->next)
4591 for (unsigned i = 0; i < val->n; ++i)
4592 /* Do not handle backedge executability optimistically since
4593 when figuring out whether to iterate we do not consider
4594 changed predication. */
4595 if (dominated_by_p_w_unex
4596 (bb, BASIC_BLOCK_FOR_FN (cfun, val->valid_dominated_by_p[i]),
4597 false))
4598 return val->result;
4599 return NULL_TREE;
4602 /* Insert the rhs of STMT into the current hash table with a value number of
4603 RESULT. */
4605 static vn_nary_op_t
4606 vn_nary_op_insert_stmt (gimple *stmt, tree result)
4608 vn_nary_op_t vno1
4609 = alloc_vn_nary_op (vn_nary_length_from_stmt (stmt),
4610 result, VN_INFO (result)->value_id);
4611 init_vn_nary_op_from_stmt (vno1, as_a <gassign *> (stmt));
4612 return vn_nary_op_insert_into (vno1, valid_info->nary);
4615 /* Compute a hashcode for PHI operation VP1 and return it. */
4617 static inline hashval_t
4618 vn_phi_compute_hash (vn_phi_t vp1)
4620 inchash::hash hstate;
4621 tree phi1op;
4622 tree type;
4623 edge e;
4624 edge_iterator ei;
4626 hstate.add_int (EDGE_COUNT (vp1->block->preds));
4627 switch (EDGE_COUNT (vp1->block->preds))
4629 case 1:
4630 break;
4631 case 2:
4632 if (vp1->block->loop_father->header == vp1->block)
4634 else
4635 break;
4636 /* Fallthru. */
4637 default:
4638 hstate.add_int (vp1->block->index);
4641 /* If all PHI arguments are constants we need to distinguish
4642 the PHI node via its type. */
4643 type = vp1->type;
4644 hstate.merge_hash (vn_hash_type (type));
4646 FOR_EACH_EDGE (e, ei, vp1->block->preds)
4648 /* Don't hash backedge values they need to be handled as VN_TOP
4649 for optimistic value-numbering. */
4650 if (e->flags & EDGE_DFS_BACK)
4651 continue;
4653 phi1op = vp1->phiargs[e->dest_idx];
4654 if (phi1op == VN_TOP)
4655 continue;
4656 inchash::add_expr (phi1op, hstate);
4659 return hstate.end ();
4663 /* Return true if COND1 and COND2 represent the same condition, set
4664 *INVERTED_P if one needs to be inverted to make it the same as
4665 the other. */
4667 static bool
4668 cond_stmts_equal_p (gcond *cond1, tree lhs1, tree rhs1,
4669 gcond *cond2, tree lhs2, tree rhs2, bool *inverted_p)
4671 enum tree_code code1 = gimple_cond_code (cond1);
4672 enum tree_code code2 = gimple_cond_code (cond2);
4674 *inverted_p = false;
4675 if (code1 == code2)
4677 else if (code1 == swap_tree_comparison (code2))
4678 std::swap (lhs2, rhs2);
4679 else if (code1 == invert_tree_comparison (code2, HONOR_NANS (lhs2)))
4680 *inverted_p = true;
4681 else if (code1 == invert_tree_comparison
4682 (swap_tree_comparison (code2), HONOR_NANS (lhs2)))
4684 std::swap (lhs2, rhs2);
4685 *inverted_p = true;
4687 else
4688 return false;
4690 return ((expressions_equal_p (lhs1, lhs2)
4691 && expressions_equal_p (rhs1, rhs2))
4692 || (commutative_tree_code (code1)
4693 && expressions_equal_p (lhs1, rhs2)
4694 && expressions_equal_p (rhs1, lhs2)));
4697 /* Compare two phi entries for equality, ignoring VN_TOP arguments. */
4699 static int
4700 vn_phi_eq (const_vn_phi_t const vp1, const_vn_phi_t const vp2)
4702 if (vp1->hashcode != vp2->hashcode)
4703 return false;
4705 if (vp1->block != vp2->block)
4707 if (EDGE_COUNT (vp1->block->preds) != EDGE_COUNT (vp2->block->preds))
4708 return false;
4710 switch (EDGE_COUNT (vp1->block->preds))
4712 case 1:
4713 /* Single-arg PHIs are just copies. */
4714 break;
4716 case 2:
4718 /* Rule out backedges into the PHI. */
4719 if (vp1->block->loop_father->header == vp1->block
4720 || vp2->block->loop_father->header == vp2->block)
4721 return false;
4723 /* If the PHI nodes do not have compatible types
4724 they are not the same. */
4725 if (!types_compatible_p (vp1->type, vp2->type))
4726 return false;
4728 basic_block idom1
4729 = get_immediate_dominator (CDI_DOMINATORS, vp1->block);
4730 basic_block idom2
4731 = get_immediate_dominator (CDI_DOMINATORS, vp2->block);
4732 /* If the immediate dominator end in switch stmts multiple
4733 values may end up in the same PHI arg via intermediate
4734 CFG merges. */
4735 if (EDGE_COUNT (idom1->succs) != 2
4736 || EDGE_COUNT (idom2->succs) != 2)
4737 return false;
4739 /* Verify the controlling stmt is the same. */
4740 gcond *last1 = safe_dyn_cast <gcond *> (last_stmt (idom1));
4741 gcond *last2 = safe_dyn_cast <gcond *> (last_stmt (idom2));
4742 if (! last1 || ! last2)
4743 return false;
4744 bool inverted_p;
4745 if (! cond_stmts_equal_p (last1, vp1->cclhs, vp1->ccrhs,
4746 last2, vp2->cclhs, vp2->ccrhs,
4747 &inverted_p))
4748 return false;
4750 /* Get at true/false controlled edges into the PHI. */
4751 edge te1, te2, fe1, fe2;
4752 if (! extract_true_false_controlled_edges (idom1, vp1->block,
4753 &te1, &fe1)
4754 || ! extract_true_false_controlled_edges (idom2, vp2->block,
4755 &te2, &fe2))
4756 return false;
4758 /* Swap edges if the second condition is the inverted of the
4759 first. */
4760 if (inverted_p)
4761 std::swap (te2, fe2);
4763 /* Since we do not know which edge will be executed we have
4764 to be careful when matching VN_TOP. Be conservative and
4765 only match VN_TOP == VN_TOP for now, we could allow
4766 VN_TOP on the not prevailing PHI though. See for example
4767 PR102920. */
4768 if (! expressions_equal_p (vp1->phiargs[te1->dest_idx],
4769 vp2->phiargs[te2->dest_idx], false)
4770 || ! expressions_equal_p (vp1->phiargs[fe1->dest_idx],
4771 vp2->phiargs[fe2->dest_idx], false))
4772 return false;
4774 return true;
4777 default:
4778 return false;
4782 /* If the PHI nodes do not have compatible types
4783 they are not the same. */
4784 if (!types_compatible_p (vp1->type, vp2->type))
4785 return false;
4787 /* Any phi in the same block will have it's arguments in the
4788 same edge order, because of how we store phi nodes. */
4789 unsigned nargs = EDGE_COUNT (vp1->block->preds);
4790 for (unsigned i = 0; i < nargs; ++i)
4792 tree phi1op = vp1->phiargs[i];
4793 tree phi2op = vp2->phiargs[i];
4794 if (phi1op == phi2op)
4795 continue;
4796 if (!expressions_equal_p (phi1op, phi2op, false))
4797 return false;
4800 return true;
4803 /* Lookup PHI in the current hash table, and return the resulting
4804 value number if it exists in the hash table. Return NULL_TREE if
4805 it does not exist in the hash table. */
4807 static tree
4808 vn_phi_lookup (gimple *phi, bool backedges_varying_p)
4810 vn_phi_s **slot;
4811 struct vn_phi_s *vp1;
4812 edge e;
4813 edge_iterator ei;
4815 vp1 = XALLOCAVAR (struct vn_phi_s,
4816 sizeof (struct vn_phi_s)
4817 + (gimple_phi_num_args (phi) - 1) * sizeof (tree));
4819 /* Canonicalize the SSA_NAME's to their value number. */
4820 FOR_EACH_EDGE (e, ei, gimple_bb (phi)->preds)
4822 tree def = PHI_ARG_DEF_FROM_EDGE (phi, e);
4823 if (TREE_CODE (def) == SSA_NAME
4824 && (!backedges_varying_p || !(e->flags & EDGE_DFS_BACK)))
4826 if (ssa_undefined_value_p (def, false))
4827 def = VN_TOP;
4828 else
4829 def = SSA_VAL (def);
4831 vp1->phiargs[e->dest_idx] = def;
4833 vp1->type = TREE_TYPE (gimple_phi_result (phi));
4834 vp1->block = gimple_bb (phi);
4835 /* Extract values of the controlling condition. */
4836 vp1->cclhs = NULL_TREE;
4837 vp1->ccrhs = NULL_TREE;
4838 basic_block idom1 = get_immediate_dominator (CDI_DOMINATORS, vp1->block);
4839 if (EDGE_COUNT (idom1->succs) == 2)
4840 if (gcond *last1 = safe_dyn_cast <gcond *> (last_stmt (idom1)))
4842 /* ??? We want to use SSA_VAL here. But possibly not
4843 allow VN_TOP. */
4844 vp1->cclhs = vn_valueize (gimple_cond_lhs (last1));
4845 vp1->ccrhs = vn_valueize (gimple_cond_rhs (last1));
4847 vp1->hashcode = vn_phi_compute_hash (vp1);
4848 slot = valid_info->phis->find_slot_with_hash (vp1, vp1->hashcode, NO_INSERT);
4849 if (!slot)
4850 return NULL_TREE;
4851 return (*slot)->result;
4854 /* Insert PHI into the current hash table with a value number of
4855 RESULT. */
4857 static vn_phi_t
4858 vn_phi_insert (gimple *phi, tree result, bool backedges_varying_p)
4860 vn_phi_s **slot;
4861 vn_phi_t vp1 = (vn_phi_t) obstack_alloc (&vn_tables_obstack,
4862 sizeof (vn_phi_s)
4863 + ((gimple_phi_num_args (phi) - 1)
4864 * sizeof (tree)));
4865 edge e;
4866 edge_iterator ei;
4868 /* Canonicalize the SSA_NAME's to their value number. */
4869 FOR_EACH_EDGE (e, ei, gimple_bb (phi)->preds)
4871 tree def = PHI_ARG_DEF_FROM_EDGE (phi, e);
4872 if (TREE_CODE (def) == SSA_NAME
4873 && (!backedges_varying_p || !(e->flags & EDGE_DFS_BACK)))
4875 if (ssa_undefined_value_p (def, false))
4876 def = VN_TOP;
4877 else
4878 def = SSA_VAL (def);
4880 vp1->phiargs[e->dest_idx] = def;
4882 vp1->value_id = VN_INFO (result)->value_id;
4883 vp1->type = TREE_TYPE (gimple_phi_result (phi));
4884 vp1->block = gimple_bb (phi);
4885 /* Extract values of the controlling condition. */
4886 vp1->cclhs = NULL_TREE;
4887 vp1->ccrhs = NULL_TREE;
4888 basic_block idom1 = get_immediate_dominator (CDI_DOMINATORS, vp1->block);
4889 if (EDGE_COUNT (idom1->succs) == 2)
4890 if (gcond *last1 = safe_dyn_cast <gcond *> (last_stmt (idom1)))
4892 /* ??? We want to use SSA_VAL here. But possibly not
4893 allow VN_TOP. */
4894 vp1->cclhs = vn_valueize (gimple_cond_lhs (last1));
4895 vp1->ccrhs = vn_valueize (gimple_cond_rhs (last1));
4897 vp1->result = result;
4898 vp1->hashcode = vn_phi_compute_hash (vp1);
4900 slot = valid_info->phis->find_slot_with_hash (vp1, vp1->hashcode, INSERT);
4901 gcc_assert (!*slot);
4903 *slot = vp1;
4904 vp1->next = last_inserted_phi;
4905 last_inserted_phi = vp1;
4906 return vp1;
4910 /* Return true if BB1 is dominated by BB2 taking into account edges
4911 that are not executable. When ALLOW_BACK is false consider not
4912 executable backedges as executable. */
4914 static bool
4915 dominated_by_p_w_unex (basic_block bb1, basic_block bb2, bool allow_back)
4917 edge_iterator ei;
4918 edge e;
4920 if (dominated_by_p (CDI_DOMINATORS, bb1, bb2))
4921 return true;
4923 /* Before iterating we'd like to know if there exists a
4924 (executable) path from bb2 to bb1 at all, if not we can
4925 directly return false. For now simply iterate once. */
4927 /* Iterate to the single executable bb1 predecessor. */
4928 if (EDGE_COUNT (bb1->preds) > 1)
4930 edge prede = NULL;
4931 FOR_EACH_EDGE (e, ei, bb1->preds)
4932 if ((e->flags & EDGE_EXECUTABLE)
4933 || (!allow_back && (e->flags & EDGE_DFS_BACK)))
4935 if (prede)
4937 prede = NULL;
4938 break;
4940 prede = e;
4942 if (prede)
4944 bb1 = prede->src;
4946 /* Re-do the dominance check with changed bb1. */
4947 if (dominated_by_p (CDI_DOMINATORS, bb1, bb2))
4948 return true;
4952 /* Iterate to the single executable bb2 successor. */
4953 if (EDGE_COUNT (bb2->succs) > 1)
4955 edge succe = NULL;
4956 FOR_EACH_EDGE (e, ei, bb2->succs)
4957 if ((e->flags & EDGE_EXECUTABLE)
4958 || (!allow_back && (e->flags & EDGE_DFS_BACK)))
4960 if (succe)
4962 succe = NULL;
4963 break;
4965 succe = e;
4967 if (succe)
4969 /* Verify the reached block is only reached through succe.
4970 If there is only one edge we can spare us the dominator
4971 check and iterate directly. */
4972 if (EDGE_COUNT (succe->dest->preds) > 1)
4974 FOR_EACH_EDGE (e, ei, succe->dest->preds)
4975 if (e != succe
4976 && ((e->flags & EDGE_EXECUTABLE)
4977 || (!allow_back && (e->flags & EDGE_DFS_BACK))))
4979 succe = NULL;
4980 break;
4983 if (succe)
4985 bb2 = succe->dest;
4987 /* Re-do the dominance check with changed bb2. */
4988 if (dominated_by_p (CDI_DOMINATORS, bb1, bb2))
4989 return true;
4994 /* We could now iterate updating bb1 / bb2. */
4995 return false;
4998 /* Set the value number of FROM to TO, return true if it has changed
4999 as a result. */
5001 static inline bool
5002 set_ssa_val_to (tree from, tree to)
5004 vn_ssa_aux_t from_info = VN_INFO (from);
5005 tree currval = from_info->valnum; // SSA_VAL (from)
5006 poly_int64 toff, coff;
5007 bool curr_undefined = false;
5008 bool curr_invariant = false;
5010 /* The only thing we allow as value numbers are ssa_names
5011 and invariants. So assert that here. We don't allow VN_TOP
5012 as visiting a stmt should produce a value-number other than
5013 that.
5014 ??? Still VN_TOP can happen for unreachable code, so force
5015 it to varying in that case. Not all code is prepared to
5016 get VN_TOP on valueization. */
5017 if (to == VN_TOP)
5019 /* ??? When iterating and visiting PHI <undef, backedge-value>
5020 for the first time we rightfully get VN_TOP and we need to
5021 preserve that to optimize for example gcc.dg/tree-ssa/ssa-sccvn-2.c.
5022 With SCCVN we were simply lucky we iterated the other PHI
5023 cycles first and thus visited the backedge-value DEF. */
5024 if (currval == VN_TOP)
5025 goto set_and_exit;
5026 if (dump_file && (dump_flags & TDF_DETAILS))
5027 fprintf (dump_file, "Forcing value number to varying on "
5028 "receiving VN_TOP\n");
5029 to = from;
5032 gcc_checking_assert (to != NULL_TREE
5033 && ((TREE_CODE (to) == SSA_NAME
5034 && (to == from || SSA_VAL (to) == to))
5035 || is_gimple_min_invariant (to)));
5037 if (from != to)
5039 if (currval == from)
5041 if (dump_file && (dump_flags & TDF_DETAILS))
5043 fprintf (dump_file, "Not changing value number of ");
5044 print_generic_expr (dump_file, from);
5045 fprintf (dump_file, " from VARYING to ");
5046 print_generic_expr (dump_file, to);
5047 fprintf (dump_file, "\n");
5049 return false;
5051 curr_invariant = is_gimple_min_invariant (currval);
5052 curr_undefined = (TREE_CODE (currval) == SSA_NAME
5053 && ssa_undefined_value_p (currval, false));
5054 if (currval != VN_TOP
5055 && !curr_invariant
5056 && !curr_undefined
5057 && is_gimple_min_invariant (to))
5059 if (dump_file && (dump_flags & TDF_DETAILS))
5061 fprintf (dump_file, "Forcing VARYING instead of changing "
5062 "value number of ");
5063 print_generic_expr (dump_file, from);
5064 fprintf (dump_file, " from ");
5065 print_generic_expr (dump_file, currval);
5066 fprintf (dump_file, " (non-constant) to ");
5067 print_generic_expr (dump_file, to);
5068 fprintf (dump_file, " (constant)\n");
5070 to = from;
5072 else if (currval != VN_TOP
5073 && !curr_undefined
5074 && TREE_CODE (to) == SSA_NAME
5075 && ssa_undefined_value_p (to, false))
5077 if (dump_file && (dump_flags & TDF_DETAILS))
5079 fprintf (dump_file, "Forcing VARYING instead of changing "
5080 "value number of ");
5081 print_generic_expr (dump_file, from);
5082 fprintf (dump_file, " from ");
5083 print_generic_expr (dump_file, currval);
5084 fprintf (dump_file, " (non-undefined) to ");
5085 print_generic_expr (dump_file, to);
5086 fprintf (dump_file, " (undefined)\n");
5088 to = from;
5090 else if (TREE_CODE (to) == SSA_NAME
5091 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (to))
5092 to = from;
5095 set_and_exit:
5096 if (dump_file && (dump_flags & TDF_DETAILS))
5098 fprintf (dump_file, "Setting value number of ");
5099 print_generic_expr (dump_file, from);
5100 fprintf (dump_file, " to ");
5101 print_generic_expr (dump_file, to);
5104 if (currval != to
5105 && !operand_equal_p (currval, to, 0)
5106 /* Different undefined SSA names are not actually different. See
5107 PR82320 for a testcase were we'd otherwise not terminate iteration. */
5108 && !(curr_undefined
5109 && TREE_CODE (to) == SSA_NAME
5110 && ssa_undefined_value_p (to, false))
5111 /* ??? For addresses involving volatile objects or types operand_equal_p
5112 does not reliably detect ADDR_EXPRs as equal. We know we are only
5113 getting invariant gimple addresses here, so can use
5114 get_addr_base_and_unit_offset to do this comparison. */
5115 && !(TREE_CODE (currval) == ADDR_EXPR
5116 && TREE_CODE (to) == ADDR_EXPR
5117 && (get_addr_base_and_unit_offset (TREE_OPERAND (currval, 0), &coff)
5118 == get_addr_base_and_unit_offset (TREE_OPERAND (to, 0), &toff))
5119 && known_eq (coff, toff)))
5121 if (to != from
5122 && currval != VN_TOP
5123 && !curr_undefined
5124 /* We do not want to allow lattice transitions from one value
5125 to another since that may lead to not terminating iteration
5126 (see PR95049). Since there's no convenient way to check
5127 for the allowed transition of VAL -> PHI (loop entry value,
5128 same on two PHIs, to same PHI result) we restrict the check
5129 to invariants. */
5130 && curr_invariant
5131 && is_gimple_min_invariant (to))
5133 if (dump_file && (dump_flags & TDF_DETAILS))
5134 fprintf (dump_file, " forced VARYING");
5135 to = from;
5137 if (dump_file && (dump_flags & TDF_DETAILS))
5138 fprintf (dump_file, " (changed)\n");
5139 from_info->valnum = to;
5140 return true;
5142 if (dump_file && (dump_flags & TDF_DETAILS))
5143 fprintf (dump_file, "\n");
5144 return false;
5147 /* Set all definitions in STMT to value number to themselves.
5148 Return true if a value number changed. */
5150 static bool
5151 defs_to_varying (gimple *stmt)
5153 bool changed = false;
5154 ssa_op_iter iter;
5155 def_operand_p defp;
5157 FOR_EACH_SSA_DEF_OPERAND (defp, stmt, iter, SSA_OP_ALL_DEFS)
5159 tree def = DEF_FROM_PTR (defp);
5160 changed |= set_ssa_val_to (def, def);
5162 return changed;
5165 /* Visit a copy between LHS and RHS, return true if the value number
5166 changed. */
5168 static bool
5169 visit_copy (tree lhs, tree rhs)
5171 /* Valueize. */
5172 rhs = SSA_VAL (rhs);
5174 return set_ssa_val_to (lhs, rhs);
5177 /* Lookup a value for OP in type WIDE_TYPE where the value in type of OP
5178 is the same. */
5180 static tree
5181 valueized_wider_op (tree wide_type, tree op, bool allow_truncate)
5183 if (TREE_CODE (op) == SSA_NAME)
5184 op = vn_valueize (op);
5186 /* Either we have the op widened available. */
5187 tree ops[3] = {};
5188 ops[0] = op;
5189 tree tem = vn_nary_op_lookup_pieces (1, NOP_EXPR,
5190 wide_type, ops, NULL);
5191 if (tem)
5192 return tem;
5194 /* Or the op is truncated from some existing value. */
5195 if (allow_truncate && TREE_CODE (op) == SSA_NAME)
5197 gimple *def = SSA_NAME_DEF_STMT (op);
5198 if (is_gimple_assign (def)
5199 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
5201 tem = gimple_assign_rhs1 (def);
5202 if (useless_type_conversion_p (wide_type, TREE_TYPE (tem)))
5204 if (TREE_CODE (tem) == SSA_NAME)
5205 tem = vn_valueize (tem);
5206 return tem;
5211 /* For constants simply extend it. */
5212 if (TREE_CODE (op) == INTEGER_CST)
5213 return wide_int_to_tree (wide_type, wi::to_widest (op));
5215 return NULL_TREE;
5218 /* Visit a nary operator RHS, value number it, and return true if the
5219 value number of LHS has changed as a result. */
5221 static bool
5222 visit_nary_op (tree lhs, gassign *stmt)
5224 vn_nary_op_t vnresult;
5225 tree result = vn_nary_op_lookup_stmt (stmt, &vnresult);
5226 if (! result && vnresult)
5227 result = vn_nary_op_get_predicated_value (vnresult, gimple_bb (stmt));
5228 if (result)
5229 return set_ssa_val_to (lhs, result);
5231 /* Do some special pattern matching for redundancies of operations
5232 in different types. */
5233 enum tree_code code = gimple_assign_rhs_code (stmt);
5234 tree type = TREE_TYPE (lhs);
5235 tree rhs1 = gimple_assign_rhs1 (stmt);
5236 switch (code)
5238 CASE_CONVERT:
5239 /* Match arithmetic done in a different type where we can easily
5240 substitute the result from some earlier sign-changed or widened
5241 operation. */
5242 if (INTEGRAL_TYPE_P (type)
5243 && TREE_CODE (rhs1) == SSA_NAME
5244 /* We only handle sign-changes, zero-extension -> & mask or
5245 sign-extension if we know the inner operation doesn't
5246 overflow. */
5247 && (((TYPE_UNSIGNED (TREE_TYPE (rhs1))
5248 || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))
5249 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (rhs1))))
5250 && TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (rhs1)))
5251 || TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (rhs1))))
5253 gassign *def = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (rhs1));
5254 if (def
5255 && (gimple_assign_rhs_code (def) == PLUS_EXPR
5256 || gimple_assign_rhs_code (def) == MINUS_EXPR
5257 || gimple_assign_rhs_code (def) == MULT_EXPR))
5259 tree ops[3] = {};
5260 /* When requiring a sign-extension we cannot model a
5261 previous truncation with a single op so don't bother. */
5262 bool allow_truncate = TYPE_UNSIGNED (TREE_TYPE (rhs1));
5263 /* Either we have the op widened available. */
5264 ops[0] = valueized_wider_op (type, gimple_assign_rhs1 (def),
5265 allow_truncate);
5266 if (ops[0])
5267 ops[1] = valueized_wider_op (type, gimple_assign_rhs2 (def),
5268 allow_truncate);
5269 if (ops[0] && ops[1])
5271 ops[0] = vn_nary_op_lookup_pieces
5272 (2, gimple_assign_rhs_code (def), type, ops, NULL);
5273 /* We have wider operation available. */
5274 if (ops[0]
5275 /* If the leader is a wrapping operation we can
5276 insert it for code hoisting w/o introducing
5277 undefined overflow. If it is not it has to
5278 be available. See PR86554. */
5279 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (ops[0]))
5280 || (rpo_avail && vn_context_bb
5281 && rpo_avail->eliminate_avail (vn_context_bb,
5282 ops[0]))))
5284 unsigned lhs_prec = TYPE_PRECISION (type);
5285 unsigned rhs_prec = TYPE_PRECISION (TREE_TYPE (rhs1));
5286 if (lhs_prec == rhs_prec
5287 || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))
5288 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (rhs1))))
5290 gimple_match_op match_op (gimple_match_cond::UNCOND,
5291 NOP_EXPR, type, ops[0]);
5292 result = vn_nary_build_or_lookup (&match_op);
5293 if (result)
5295 bool changed = set_ssa_val_to (lhs, result);
5296 vn_nary_op_insert_stmt (stmt, result);
5297 return changed;
5300 else
5302 tree mask = wide_int_to_tree
5303 (type, wi::mask (rhs_prec, false, lhs_prec));
5304 gimple_match_op match_op (gimple_match_cond::UNCOND,
5305 BIT_AND_EXPR,
5306 TREE_TYPE (lhs),
5307 ops[0], mask);
5308 result = vn_nary_build_or_lookup (&match_op);
5309 if (result)
5311 bool changed = set_ssa_val_to (lhs, result);
5312 vn_nary_op_insert_stmt (stmt, result);
5313 return changed;
5320 break;
5321 case BIT_AND_EXPR:
5322 if (INTEGRAL_TYPE_P (type)
5323 && TREE_CODE (rhs1) == SSA_NAME
5324 && TREE_CODE (gimple_assign_rhs2 (stmt)) == INTEGER_CST
5325 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1)
5326 && default_vn_walk_kind != VN_NOWALK
5327 && CHAR_BIT == 8
5328 && BITS_PER_UNIT == 8
5329 && BYTES_BIG_ENDIAN == WORDS_BIG_ENDIAN
5330 && !integer_all_onesp (gimple_assign_rhs2 (stmt))
5331 && !integer_zerop (gimple_assign_rhs2 (stmt)))
5333 gassign *ass = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (rhs1));
5334 if (ass
5335 && !gimple_has_volatile_ops (ass)
5336 && vn_get_stmt_kind (ass) == VN_REFERENCE)
5338 tree last_vuse = gimple_vuse (ass);
5339 tree op = gimple_assign_rhs1 (ass);
5340 tree result = vn_reference_lookup (op, gimple_vuse (ass),
5341 default_vn_walk_kind,
5342 NULL, true, &last_vuse,
5343 gimple_assign_rhs2 (stmt));
5344 if (result
5345 && useless_type_conversion_p (TREE_TYPE (result),
5346 TREE_TYPE (op)))
5347 return set_ssa_val_to (lhs, result);
5350 break;
5351 case TRUNC_DIV_EXPR:
5352 if (TYPE_UNSIGNED (type))
5353 break;
5354 /* Fallthru. */
5355 case RDIV_EXPR:
5356 case MULT_EXPR:
5357 /* Match up ([-]a){/,*}([-])b with v=a{/,*}b, replacing it with -v. */
5358 if (! HONOR_SIGN_DEPENDENT_ROUNDING (type))
5360 tree rhs[2];
5361 rhs[0] = rhs1;
5362 rhs[1] = gimple_assign_rhs2 (stmt);
5363 for (unsigned i = 0; i <= 1; ++i)
5365 unsigned j = i == 0 ? 1 : 0;
5366 tree ops[2];
5367 gimple_match_op match_op (gimple_match_cond::UNCOND,
5368 NEGATE_EXPR, type, rhs[i]);
5369 ops[i] = vn_nary_build_or_lookup_1 (&match_op, false, true);
5370 ops[j] = rhs[j];
5371 if (ops[i]
5372 && (ops[0] = vn_nary_op_lookup_pieces (2, code,
5373 type, ops, NULL)))
5375 gimple_match_op match_op (gimple_match_cond::UNCOND,
5376 NEGATE_EXPR, type, ops[0]);
5377 result = vn_nary_build_or_lookup_1 (&match_op, true, false);
5378 if (result)
5380 bool changed = set_ssa_val_to (lhs, result);
5381 vn_nary_op_insert_stmt (stmt, result);
5382 return changed;
5387 break;
5388 default:
5389 break;
5392 bool changed = set_ssa_val_to (lhs, lhs);
5393 vn_nary_op_insert_stmt (stmt, lhs);
5394 return changed;
5397 /* Visit a call STMT storing into LHS. Return true if the value number
5398 of the LHS has changed as a result. */
5400 static bool
5401 visit_reference_op_call (tree lhs, gcall *stmt)
5403 bool changed = false;
5404 struct vn_reference_s vr1;
5405 vn_reference_t vnresult = NULL;
5406 tree vdef = gimple_vdef (stmt);
5407 modref_summary *summary;
5409 /* Non-ssa lhs is handled in copy_reference_ops_from_call. */
5410 if (lhs && TREE_CODE (lhs) != SSA_NAME)
5411 lhs = NULL_TREE;
5413 vn_reference_lookup_call (stmt, &vnresult, &vr1);
5415 /* If the lookup did not succeed for pure functions try to use
5416 modref info to find a candidate to CSE to. */
5417 const unsigned accesses_limit = 8;
5418 if (!vnresult
5419 && !vdef
5420 && lhs
5421 && gimple_vuse (stmt)
5422 && (((summary = get_modref_function_summary (stmt, NULL))
5423 && !summary->global_memory_read
5424 && summary->load_accesses < accesses_limit)
5425 || gimple_call_flags (stmt) & ECF_CONST))
5427 /* First search if we can do someting useful and build a
5428 vector of all loads we have to check. */
5429 bool unknown_memory_access = false;
5430 auto_vec<ao_ref, accesses_limit> accesses;
5431 unsigned load_accesses = summary ? summary->load_accesses : 0;
5432 if (!unknown_memory_access)
5433 /* Add loads done as part of setting up the call arguments.
5434 That's also necessary for CONST functions which will
5435 not have a modref summary. */
5436 for (unsigned i = 0; i < gimple_call_num_args (stmt); ++i)
5438 tree arg = gimple_call_arg (stmt, i);
5439 if (TREE_CODE (arg) != SSA_NAME
5440 && !is_gimple_min_invariant (arg))
5442 if (accesses.length () >= accesses_limit - load_accesses)
5444 unknown_memory_access = true;
5445 break;
5447 accesses.quick_grow (accesses.length () + 1);
5448 ao_ref_init (&accesses.last (), arg);
5451 if (summary && !unknown_memory_access)
5453 /* Add loads as analyzed by IPA modref. */
5454 for (auto base_node : summary->loads->bases)
5455 if (unknown_memory_access)
5456 break;
5457 else for (auto ref_node : base_node->refs)
5458 if (unknown_memory_access)
5459 break;
5460 else for (auto access_node : ref_node->accesses)
5462 accesses.quick_grow (accesses.length () + 1);
5463 ao_ref *r = &accesses.last ();
5464 if (!access_node.get_ao_ref (stmt, r))
5466 /* Initialize a ref based on the argument and
5467 unknown offset if possible. */
5468 tree arg = access_node.get_call_arg (stmt);
5469 if (arg && TREE_CODE (arg) == SSA_NAME)
5470 arg = SSA_VAL (arg);
5471 if (arg
5472 && TREE_CODE (arg) == ADDR_EXPR
5473 && (arg = get_base_address (arg))
5474 && DECL_P (arg))
5476 ao_ref_init (r, arg);
5477 r->ref = NULL_TREE;
5478 r->base = arg;
5480 else
5482 unknown_memory_access = true;
5483 break;
5486 r->base_alias_set = base_node->base;
5487 r->ref_alias_set = ref_node->ref;
5491 /* Walk the VUSE->VDEF chain optimistically trying to find an entry
5492 for the call in the hashtable. */
5493 unsigned limit = (unknown_memory_access
5495 : (param_sccvn_max_alias_queries_per_access
5496 / (accesses.length () + 1)));
5497 tree saved_vuse = vr1.vuse;
5498 hashval_t saved_hashcode = vr1.hashcode;
5499 while (limit > 0 && !vnresult && !SSA_NAME_IS_DEFAULT_DEF (vr1.vuse))
5501 vr1.hashcode = vr1.hashcode - SSA_NAME_VERSION (vr1.vuse);
5502 gimple *def = SSA_NAME_DEF_STMT (vr1.vuse);
5503 /* ??? We could use fancy stuff like in walk_non_aliased_vuses, but
5504 do not bother for now. */
5505 if (is_a <gphi *> (def))
5506 break;
5507 vr1.vuse = vuse_ssa_val (gimple_vuse (def));
5508 vr1.hashcode = vr1.hashcode + SSA_NAME_VERSION (vr1.vuse);
5509 vn_reference_lookup_1 (&vr1, &vnresult);
5510 limit--;
5513 /* If we found a candidate to CSE to verify it is valid. */
5514 if (vnresult && !accesses.is_empty ())
5516 tree vuse = vuse_ssa_val (gimple_vuse (stmt));
5517 while (vnresult && vuse != vr1.vuse)
5519 gimple *def = SSA_NAME_DEF_STMT (vuse);
5520 for (auto &ref : accesses)
5522 /* ??? stmt_may_clobber_ref_p_1 does per stmt constant
5523 analysis overhead that we might be able to cache. */
5524 if (stmt_may_clobber_ref_p_1 (def, &ref, true))
5526 vnresult = NULL;
5527 break;
5530 vuse = vuse_ssa_val (gimple_vuse (def));
5533 vr1.vuse = saved_vuse;
5534 vr1.hashcode = saved_hashcode;
5537 if (vnresult)
5539 if (vdef)
5541 if (vnresult->result_vdef)
5542 changed |= set_ssa_val_to (vdef, vnresult->result_vdef);
5543 else if (!lhs && gimple_call_lhs (stmt))
5544 /* If stmt has non-SSA_NAME lhs, value number the vdef to itself,
5545 as the call still acts as a lhs store. */
5546 changed |= set_ssa_val_to (vdef, vdef);
5547 else
5548 /* If the call was discovered to be pure or const reflect
5549 that as far as possible. */
5550 changed |= set_ssa_val_to (vdef,
5551 vuse_ssa_val (gimple_vuse (stmt)));
5554 if (!vnresult->result && lhs)
5555 vnresult->result = lhs;
5557 if (vnresult->result && lhs)
5558 changed |= set_ssa_val_to (lhs, vnresult->result);
5560 else
5562 vn_reference_t vr2;
5563 vn_reference_s **slot;
5564 tree vdef_val = vdef;
5565 if (vdef)
5567 /* If we value numbered an indirect functions function to
5568 one not clobbering memory value number its VDEF to its
5569 VUSE. */
5570 tree fn = gimple_call_fn (stmt);
5571 if (fn && TREE_CODE (fn) == SSA_NAME)
5573 fn = SSA_VAL (fn);
5574 if (TREE_CODE (fn) == ADDR_EXPR
5575 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
5576 && (flags_from_decl_or_type (TREE_OPERAND (fn, 0))
5577 & (ECF_CONST | ECF_PURE))
5578 /* If stmt has non-SSA_NAME lhs, value number the
5579 vdef to itself, as the call still acts as a lhs
5580 store. */
5581 && (lhs || gimple_call_lhs (stmt) == NULL_TREE))
5582 vdef_val = vuse_ssa_val (gimple_vuse (stmt));
5584 changed |= set_ssa_val_to (vdef, vdef_val);
5586 if (lhs)
5587 changed |= set_ssa_val_to (lhs, lhs);
5588 vr2 = XOBNEW (&vn_tables_obstack, vn_reference_s);
5589 vr2->vuse = vr1.vuse;
5590 /* As we are not walking the virtual operand chain we know the
5591 shared_lookup_references are still original so we can re-use
5592 them here. */
5593 vr2->operands = vr1.operands.copy ();
5594 vr2->type = vr1.type;
5595 vr2->punned = vr1.punned;
5596 vr2->set = vr1.set;
5597 vr2->base_set = vr1.base_set;
5598 vr2->hashcode = vr1.hashcode;
5599 vr2->result = lhs;
5600 vr2->result_vdef = vdef_val;
5601 vr2->value_id = 0;
5602 slot = valid_info->references->find_slot_with_hash (vr2, vr2->hashcode,
5603 INSERT);
5604 gcc_assert (!*slot);
5605 *slot = vr2;
5606 vr2->next = last_inserted_ref;
5607 last_inserted_ref = vr2;
5610 return changed;
5613 /* Visit a load from a reference operator RHS, part of STMT, value number it,
5614 and return true if the value number of the LHS has changed as a result. */
5616 static bool
5617 visit_reference_op_load (tree lhs, tree op, gimple *stmt)
5619 bool changed = false;
5620 tree result;
5621 vn_reference_t res;
5623 tree vuse = gimple_vuse (stmt);
5624 tree last_vuse = vuse;
5625 result = vn_reference_lookup (op, vuse, default_vn_walk_kind, &res, true, &last_vuse);
5627 /* We handle type-punning through unions by value-numbering based
5628 on offset and size of the access. Be prepared to handle a
5629 type-mismatch here via creating a VIEW_CONVERT_EXPR. */
5630 if (result
5631 && !useless_type_conversion_p (TREE_TYPE (result), TREE_TYPE (op)))
5633 /* Avoid the type punning in case the result mode has padding where
5634 the op we lookup has not. */
5635 if (maybe_lt (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (result))),
5636 GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (op)))))
5637 result = NULL_TREE;
5638 else
5640 /* We will be setting the value number of lhs to the value number
5641 of VIEW_CONVERT_EXPR <TREE_TYPE (result)> (result).
5642 So first simplify and lookup this expression to see if it
5643 is already available. */
5644 gimple_match_op res_op (gimple_match_cond::UNCOND,
5645 VIEW_CONVERT_EXPR, TREE_TYPE (op), result);
5646 result = vn_nary_build_or_lookup (&res_op);
5647 if (result
5648 && TREE_CODE (result) == SSA_NAME
5649 && VN_INFO (result)->needs_insertion)
5650 /* Track whether this is the canonical expression for different
5651 typed loads. We use that as a stopgap measure for code
5652 hoisting when dealing with floating point loads. */
5653 res->punned = true;
5656 /* When building the conversion fails avoid inserting the reference
5657 again. */
5658 if (!result)
5659 return set_ssa_val_to (lhs, lhs);
5662 if (result)
5663 changed = set_ssa_val_to (lhs, result);
5664 else
5666 changed = set_ssa_val_to (lhs, lhs);
5667 vn_reference_insert (op, lhs, last_vuse, NULL_TREE);
5668 if (vuse && SSA_VAL (last_vuse) != SSA_VAL (vuse))
5670 if (dump_file && (dump_flags & TDF_DETAILS))
5672 fprintf (dump_file, "Using extra use virtual operand ");
5673 print_generic_expr (dump_file, last_vuse);
5674 fprintf (dump_file, "\n");
5676 vn_reference_insert (op, lhs, vuse, NULL_TREE);
5680 return changed;
5684 /* Visit a store to a reference operator LHS, part of STMT, value number it,
5685 and return true if the value number of the LHS has changed as a result. */
5687 static bool
5688 visit_reference_op_store (tree lhs, tree op, gimple *stmt)
5690 bool changed = false;
5691 vn_reference_t vnresult = NULL;
5692 tree assign;
5693 bool resultsame = false;
5694 tree vuse = gimple_vuse (stmt);
5695 tree vdef = gimple_vdef (stmt);
5697 if (TREE_CODE (op) == SSA_NAME)
5698 op = SSA_VAL (op);
5700 /* First we want to lookup using the *vuses* from the store and see
5701 if there the last store to this location with the same address
5702 had the same value.
5704 The vuses represent the memory state before the store. If the
5705 memory state, address, and value of the store is the same as the
5706 last store to this location, then this store will produce the
5707 same memory state as that store.
5709 In this case the vdef versions for this store are value numbered to those
5710 vuse versions, since they represent the same memory state after
5711 this store.
5713 Otherwise, the vdefs for the store are used when inserting into
5714 the table, since the store generates a new memory state. */
5716 vn_reference_lookup (lhs, vuse, VN_NOWALK, &vnresult, false);
5717 if (vnresult
5718 && vnresult->result)
5720 tree result = vnresult->result;
5721 gcc_checking_assert (TREE_CODE (result) != SSA_NAME
5722 || result == SSA_VAL (result));
5723 resultsame = expressions_equal_p (result, op);
5724 if (resultsame)
5726 /* If the TBAA state isn't compatible for downstream reads
5727 we cannot value-number the VDEFs the same. */
5728 ao_ref lhs_ref;
5729 ao_ref_init (&lhs_ref, lhs);
5730 alias_set_type set = ao_ref_alias_set (&lhs_ref);
5731 alias_set_type base_set = ao_ref_base_alias_set (&lhs_ref);
5732 if ((vnresult->set != set
5733 && ! alias_set_subset_of (set, vnresult->set))
5734 || (vnresult->base_set != base_set
5735 && ! alias_set_subset_of (base_set, vnresult->base_set)))
5736 resultsame = false;
5740 if (!resultsame)
5742 if (dump_file && (dump_flags & TDF_DETAILS))
5744 fprintf (dump_file, "No store match\n");
5745 fprintf (dump_file, "Value numbering store ");
5746 print_generic_expr (dump_file, lhs);
5747 fprintf (dump_file, " to ");
5748 print_generic_expr (dump_file, op);
5749 fprintf (dump_file, "\n");
5751 /* Have to set value numbers before insert, since insert is
5752 going to valueize the references in-place. */
5753 if (vdef)
5754 changed |= set_ssa_val_to (vdef, vdef);
5756 /* Do not insert structure copies into the tables. */
5757 if (is_gimple_min_invariant (op)
5758 || is_gimple_reg (op))
5759 vn_reference_insert (lhs, op, vdef, NULL);
5761 /* Only perform the following when being called from PRE
5762 which embeds tail merging. */
5763 if (default_vn_walk_kind == VN_WALK)
5765 assign = build2 (MODIFY_EXPR, TREE_TYPE (lhs), lhs, op);
5766 vn_reference_lookup (assign, vuse, VN_NOWALK, &vnresult, false);
5767 if (!vnresult)
5768 vn_reference_insert (assign, lhs, vuse, vdef);
5771 else
5773 /* We had a match, so value number the vdef to have the value
5774 number of the vuse it came from. */
5776 if (dump_file && (dump_flags & TDF_DETAILS))
5777 fprintf (dump_file, "Store matched earlier value, "
5778 "value numbering store vdefs to matching vuses.\n");
5780 changed |= set_ssa_val_to (vdef, SSA_VAL (vuse));
5783 return changed;
5786 /* Visit and value number PHI, return true if the value number
5787 changed. When BACKEDGES_VARYING_P is true then assume all
5788 backedge values are varying. When INSERTED is not NULL then
5789 this is just a ahead query for a possible iteration, set INSERTED
5790 to true if we'd insert into the hashtable. */
5792 static bool
5793 visit_phi (gimple *phi, bool *inserted, bool backedges_varying_p)
5795 tree result, sameval = VN_TOP, seen_undef = NULL_TREE;
5796 tree backedge_val = NULL_TREE;
5797 bool seen_non_backedge = false;
5798 tree sameval_base = NULL_TREE;
5799 poly_int64 soff, doff;
5800 unsigned n_executable = 0;
5801 edge_iterator ei;
5802 edge e;
5804 /* TODO: We could check for this in initialization, and replace this
5805 with a gcc_assert. */
5806 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi)))
5807 return set_ssa_val_to (PHI_RESULT (phi), PHI_RESULT (phi));
5809 /* We track whether a PHI was CSEd to to avoid excessive iterations
5810 that would be necessary only because the PHI changed arguments
5811 but not value. */
5812 if (!inserted)
5813 gimple_set_plf (phi, GF_PLF_1, false);
5815 /* See if all non-TOP arguments have the same value. TOP is
5816 equivalent to everything, so we can ignore it. */
5817 basic_block bb = gimple_bb (phi);
5818 FOR_EACH_EDGE (e, ei, bb->preds)
5819 if (e->flags & EDGE_EXECUTABLE)
5821 tree def = PHI_ARG_DEF_FROM_EDGE (phi, e);
5823 if (def == PHI_RESULT (phi))
5824 continue;
5825 ++n_executable;
5826 if (TREE_CODE (def) == SSA_NAME)
5828 if (!backedges_varying_p || !(e->flags & EDGE_DFS_BACK))
5829 def = SSA_VAL (def);
5830 if (e->flags & EDGE_DFS_BACK)
5831 backedge_val = def;
5833 if (!(e->flags & EDGE_DFS_BACK))
5834 seen_non_backedge = true;
5835 if (def == VN_TOP)
5837 /* Ignore undefined defs for sameval but record one. */
5838 else if (TREE_CODE (def) == SSA_NAME
5839 && ! virtual_operand_p (def)
5840 && ssa_undefined_value_p (def, false))
5841 seen_undef = def;
5842 else if (sameval == VN_TOP)
5843 sameval = def;
5844 else if (!expressions_equal_p (def, sameval))
5846 /* We know we're arriving only with invariant addresses here,
5847 try harder comparing them. We can do some caching here
5848 which we cannot do in expressions_equal_p. */
5849 if (TREE_CODE (def) == ADDR_EXPR
5850 && TREE_CODE (sameval) == ADDR_EXPR
5851 && sameval_base != (void *)-1)
5853 if (!sameval_base)
5854 sameval_base = get_addr_base_and_unit_offset
5855 (TREE_OPERAND (sameval, 0), &soff);
5856 if (!sameval_base)
5857 sameval_base = (tree)(void *)-1;
5858 else if ((get_addr_base_and_unit_offset
5859 (TREE_OPERAND (def, 0), &doff) == sameval_base)
5860 && known_eq (soff, doff))
5861 continue;
5863 /* There's also the possibility to use equivalences. */
5864 if (!FLOAT_TYPE_P (TREE_TYPE (def))
5865 /* But only do this if we didn't force any of sameval or
5866 val to VARYING because of backedge processing rules. */
5867 && (TREE_CODE (sameval) != SSA_NAME
5868 || SSA_VAL (sameval) == sameval)
5869 && (TREE_CODE (def) != SSA_NAME || SSA_VAL (def) == def))
5871 vn_nary_op_t vnresult;
5872 tree ops[2];
5873 ops[0] = def;
5874 ops[1] = sameval;
5875 tree val = vn_nary_op_lookup_pieces (2, EQ_EXPR,
5876 boolean_type_node,
5877 ops, &vnresult);
5878 if (! val && vnresult && vnresult->predicated_values)
5880 val = vn_nary_op_get_predicated_value (vnresult, e->src);
5881 if (val && integer_truep (val))
5883 if (dump_file && (dump_flags & TDF_DETAILS))
5885 fprintf (dump_file, "Predication says ");
5886 print_generic_expr (dump_file, def, TDF_NONE);
5887 fprintf (dump_file, " and ");
5888 print_generic_expr (dump_file, sameval, TDF_NONE);
5889 fprintf (dump_file, " are equal on edge %d -> %d\n",
5890 e->src->index, e->dest->index);
5892 continue;
5894 /* If on all previous edges the value was equal to def
5895 we can change sameval to def. */
5896 if (EDGE_COUNT (bb->preds) == 2
5897 && (val = vn_nary_op_get_predicated_value
5898 (vnresult, EDGE_PRED (bb, 0)->src))
5899 && integer_truep (val))
5901 if (dump_file && (dump_flags & TDF_DETAILS))
5903 fprintf (dump_file, "Predication says ");
5904 print_generic_expr (dump_file, def, TDF_NONE);
5905 fprintf (dump_file, " and ");
5906 print_generic_expr (dump_file, sameval, TDF_NONE);
5907 fprintf (dump_file, " are equal on edge %d -> %d\n",
5908 EDGE_PRED (bb, 0)->src->index,
5909 EDGE_PRED (bb, 0)->dest->index);
5911 sameval = def;
5912 continue;
5916 sameval = NULL_TREE;
5917 break;
5921 /* If the value we want to use is flowing over the backedge and we
5922 should take it as VARYING but it has a non-VARYING value drop to
5923 VARYING.
5924 If we value-number a virtual operand never value-number to the
5925 value from the backedge as that confuses the alias-walking code.
5926 See gcc.dg/torture/pr87176.c. If the value is the same on a
5927 non-backedge everything is OK though. */
5928 bool visited_p;
5929 if ((backedge_val
5930 && !seen_non_backedge
5931 && TREE_CODE (backedge_val) == SSA_NAME
5932 && sameval == backedge_val
5933 && (SSA_NAME_IS_VIRTUAL_OPERAND (backedge_val)
5934 || SSA_VAL (backedge_val) != backedge_val))
5935 /* Do not value-number a virtual operand to sth not visited though
5936 given that allows us to escape a region in alias walking. */
5937 || (sameval
5938 && TREE_CODE (sameval) == SSA_NAME
5939 && !SSA_NAME_IS_DEFAULT_DEF (sameval)
5940 && SSA_NAME_IS_VIRTUAL_OPERAND (sameval)
5941 && (SSA_VAL (sameval, &visited_p), !visited_p)))
5942 /* Note this just drops to VARYING without inserting the PHI into
5943 the hashes. */
5944 result = PHI_RESULT (phi);
5945 /* If none of the edges was executable keep the value-number at VN_TOP,
5946 if only a single edge is exectuable use its value. */
5947 else if (n_executable <= 1)
5948 result = seen_undef ? seen_undef : sameval;
5949 /* If we saw only undefined values and VN_TOP use one of the
5950 undefined values. */
5951 else if (sameval == VN_TOP)
5952 result = seen_undef ? seen_undef : sameval;
5953 /* First see if it is equivalent to a phi node in this block. We prefer
5954 this as it allows IV elimination - see PRs 66502 and 67167. */
5955 else if ((result = vn_phi_lookup (phi, backedges_varying_p)))
5957 if (!inserted
5958 && TREE_CODE (result) == SSA_NAME
5959 && gimple_code (SSA_NAME_DEF_STMT (result)) == GIMPLE_PHI)
5961 gimple_set_plf (SSA_NAME_DEF_STMT (result), GF_PLF_1, true);
5962 if (dump_file && (dump_flags & TDF_DETAILS))
5964 fprintf (dump_file, "Marking CSEd to PHI node ");
5965 print_gimple_expr (dump_file, SSA_NAME_DEF_STMT (result),
5966 0, TDF_SLIM);
5967 fprintf (dump_file, "\n");
5971 /* If all values are the same use that, unless we've seen undefined
5972 values as well and the value isn't constant.
5973 CCP/copyprop have the same restriction to not remove uninit warnings. */
5974 else if (sameval
5975 && (! seen_undef || is_gimple_min_invariant (sameval)))
5976 result = sameval;
5977 else
5979 result = PHI_RESULT (phi);
5980 /* Only insert PHIs that are varying, for constant value numbers
5981 we mess up equivalences otherwise as we are only comparing
5982 the immediate controlling predicates. */
5983 vn_phi_insert (phi, result, backedges_varying_p);
5984 if (inserted)
5985 *inserted = true;
5988 return set_ssa_val_to (PHI_RESULT (phi), result);
5991 /* Try to simplify RHS using equivalences and constant folding. */
5993 static tree
5994 try_to_simplify (gassign *stmt)
5996 enum tree_code code = gimple_assign_rhs_code (stmt);
5997 tree tem;
5999 /* For stores we can end up simplifying a SSA_NAME rhs. Just return
6000 in this case, there is no point in doing extra work. */
6001 if (code == SSA_NAME)
6002 return NULL_TREE;
6004 /* First try constant folding based on our current lattice. */
6005 mprts_hook = vn_lookup_simplify_result;
6006 tem = gimple_fold_stmt_to_constant_1 (stmt, vn_valueize, vn_valueize);
6007 mprts_hook = NULL;
6008 if (tem
6009 && (TREE_CODE (tem) == SSA_NAME
6010 || is_gimple_min_invariant (tem)))
6011 return tem;
6013 return NULL_TREE;
6016 /* Visit and value number STMT, return true if the value number
6017 changed. */
6019 static bool
6020 visit_stmt (gimple *stmt, bool backedges_varying_p = false)
6022 bool changed = false;
6024 if (dump_file && (dump_flags & TDF_DETAILS))
6026 fprintf (dump_file, "Value numbering stmt = ");
6027 print_gimple_stmt (dump_file, stmt, 0);
6030 if (gimple_code (stmt) == GIMPLE_PHI)
6031 changed = visit_phi (stmt, NULL, backedges_varying_p);
6032 else if (gimple_has_volatile_ops (stmt))
6033 changed = defs_to_varying (stmt);
6034 else if (gassign *ass = dyn_cast <gassign *> (stmt))
6036 enum tree_code code = gimple_assign_rhs_code (ass);
6037 tree lhs = gimple_assign_lhs (ass);
6038 tree rhs1 = gimple_assign_rhs1 (ass);
6039 tree simplified;
6041 /* Shortcut for copies. Simplifying copies is pointless,
6042 since we copy the expression and value they represent. */
6043 if (code == SSA_NAME
6044 && TREE_CODE (lhs) == SSA_NAME)
6046 changed = visit_copy (lhs, rhs1);
6047 goto done;
6049 simplified = try_to_simplify (ass);
6050 if (simplified)
6052 if (dump_file && (dump_flags & TDF_DETAILS))
6054 fprintf (dump_file, "RHS ");
6055 print_gimple_expr (dump_file, ass, 0);
6056 fprintf (dump_file, " simplified to ");
6057 print_generic_expr (dump_file, simplified);
6058 fprintf (dump_file, "\n");
6061 /* Setting value numbers to constants will occasionally
6062 screw up phi congruence because constants are not
6063 uniquely associated with a single ssa name that can be
6064 looked up. */
6065 if (simplified
6066 && is_gimple_min_invariant (simplified)
6067 && TREE_CODE (lhs) == SSA_NAME)
6069 changed = set_ssa_val_to (lhs, simplified);
6070 goto done;
6072 else if (simplified
6073 && TREE_CODE (simplified) == SSA_NAME
6074 && TREE_CODE (lhs) == SSA_NAME)
6076 changed = visit_copy (lhs, simplified);
6077 goto done;
6080 if ((TREE_CODE (lhs) == SSA_NAME
6081 /* We can substitute SSA_NAMEs that are live over
6082 abnormal edges with their constant value. */
6083 && !(gimple_assign_copy_p (ass)
6084 && is_gimple_min_invariant (rhs1))
6085 && !(simplified
6086 && is_gimple_min_invariant (simplified))
6087 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
6088 /* Stores or copies from SSA_NAMEs that are live over
6089 abnormal edges are a problem. */
6090 || (code == SSA_NAME
6091 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1)))
6092 changed = defs_to_varying (ass);
6093 else if (REFERENCE_CLASS_P (lhs)
6094 || DECL_P (lhs))
6095 changed = visit_reference_op_store (lhs, rhs1, ass);
6096 else if (TREE_CODE (lhs) == SSA_NAME)
6098 if ((gimple_assign_copy_p (ass)
6099 && is_gimple_min_invariant (rhs1))
6100 || (simplified
6101 && is_gimple_min_invariant (simplified)))
6103 if (simplified)
6104 changed = set_ssa_val_to (lhs, simplified);
6105 else
6106 changed = set_ssa_val_to (lhs, rhs1);
6108 else
6110 /* Visit the original statement. */
6111 switch (vn_get_stmt_kind (ass))
6113 case VN_NARY:
6114 changed = visit_nary_op (lhs, ass);
6115 break;
6116 case VN_REFERENCE:
6117 changed = visit_reference_op_load (lhs, rhs1, ass);
6118 break;
6119 default:
6120 changed = defs_to_varying (ass);
6121 break;
6125 else
6126 changed = defs_to_varying (ass);
6128 else if (gcall *call_stmt = dyn_cast <gcall *> (stmt))
6130 tree lhs = gimple_call_lhs (call_stmt);
6131 if (lhs && TREE_CODE (lhs) == SSA_NAME)
6133 /* Try constant folding based on our current lattice. */
6134 tree simplified = gimple_fold_stmt_to_constant_1 (call_stmt,
6135 vn_valueize);
6136 if (simplified)
6138 if (dump_file && (dump_flags & TDF_DETAILS))
6140 fprintf (dump_file, "call ");
6141 print_gimple_expr (dump_file, call_stmt, 0);
6142 fprintf (dump_file, " simplified to ");
6143 print_generic_expr (dump_file, simplified);
6144 fprintf (dump_file, "\n");
6147 /* Setting value numbers to constants will occasionally
6148 screw up phi congruence because constants are not
6149 uniquely associated with a single ssa name that can be
6150 looked up. */
6151 if (simplified
6152 && is_gimple_min_invariant (simplified))
6154 changed = set_ssa_val_to (lhs, simplified);
6155 if (gimple_vdef (call_stmt))
6156 changed |= set_ssa_val_to (gimple_vdef (call_stmt),
6157 SSA_VAL (gimple_vuse (call_stmt)));
6158 goto done;
6160 else if (simplified
6161 && TREE_CODE (simplified) == SSA_NAME)
6163 changed = visit_copy (lhs, simplified);
6164 if (gimple_vdef (call_stmt))
6165 changed |= set_ssa_val_to (gimple_vdef (call_stmt),
6166 SSA_VAL (gimple_vuse (call_stmt)));
6167 goto done;
6169 else if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
6171 changed = defs_to_varying (call_stmt);
6172 goto done;
6176 /* Pick up flags from a devirtualization target. */
6177 tree fn = gimple_call_fn (stmt);
6178 int extra_fnflags = 0;
6179 if (fn && TREE_CODE (fn) == SSA_NAME)
6181 fn = SSA_VAL (fn);
6182 if (TREE_CODE (fn) == ADDR_EXPR
6183 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL)
6184 extra_fnflags = flags_from_decl_or_type (TREE_OPERAND (fn, 0));
6186 if ((/* Calls to the same function with the same vuse
6187 and the same operands do not necessarily return the same
6188 value, unless they're pure or const. */
6189 ((gimple_call_flags (call_stmt) | extra_fnflags)
6190 & (ECF_PURE | ECF_CONST))
6191 /* If calls have a vdef, subsequent calls won't have
6192 the same incoming vuse. So, if 2 calls with vdef have the
6193 same vuse, we know they're not subsequent.
6194 We can value number 2 calls to the same function with the
6195 same vuse and the same operands which are not subsequent
6196 the same, because there is no code in the program that can
6197 compare the 2 values... */
6198 || (gimple_vdef (call_stmt)
6199 /* ... unless the call returns a pointer which does
6200 not alias with anything else. In which case the
6201 information that the values are distinct are encoded
6202 in the IL. */
6203 && !(gimple_call_return_flags (call_stmt) & ERF_NOALIAS)
6204 /* Only perform the following when being called from PRE
6205 which embeds tail merging. */
6206 && default_vn_walk_kind == VN_WALK))
6207 /* Do not process .DEFERRED_INIT since that confuses uninit
6208 analysis. */
6209 && !gimple_call_internal_p (call_stmt, IFN_DEFERRED_INIT))
6210 changed = visit_reference_op_call (lhs, call_stmt);
6211 else
6212 changed = defs_to_varying (call_stmt);
6214 else
6215 changed = defs_to_varying (stmt);
6216 done:
6217 return changed;
6221 /* Allocate a value number table. */
6223 static void
6224 allocate_vn_table (vn_tables_t table, unsigned size)
6226 table->phis = new vn_phi_table_type (size);
6227 table->nary = new vn_nary_op_table_type (size);
6228 table->references = new vn_reference_table_type (size);
6231 /* Free a value number table. */
6233 static void
6234 free_vn_table (vn_tables_t table)
6236 /* Walk over elements and release vectors. */
6237 vn_reference_iterator_type hir;
6238 vn_reference_t vr;
6239 FOR_EACH_HASH_TABLE_ELEMENT (*table->references, vr, vn_reference_t, hir)
6240 vr->operands.release ();
6241 delete table->phis;
6242 table->phis = NULL;
6243 delete table->nary;
6244 table->nary = NULL;
6245 delete table->references;
6246 table->references = NULL;
6249 /* Set *ID according to RESULT. */
6251 static void
6252 set_value_id_for_result (tree result, unsigned int *id)
6254 if (result && TREE_CODE (result) == SSA_NAME)
6255 *id = VN_INFO (result)->value_id;
6256 else if (result && is_gimple_min_invariant (result))
6257 *id = get_or_alloc_constant_value_id (result);
6258 else
6259 *id = get_next_value_id ();
6262 /* Set the value ids in the valid hash tables. */
6264 static void
6265 set_hashtable_value_ids (void)
6267 vn_nary_op_iterator_type hin;
6268 vn_phi_iterator_type hip;
6269 vn_reference_iterator_type hir;
6270 vn_nary_op_t vno;
6271 vn_reference_t vr;
6272 vn_phi_t vp;
6274 /* Now set the value ids of the things we had put in the hash
6275 table. */
6277 FOR_EACH_HASH_TABLE_ELEMENT (*valid_info->nary, vno, vn_nary_op_t, hin)
6278 if (! vno->predicated_values)
6279 set_value_id_for_result (vno->u.result, &vno->value_id);
6281 FOR_EACH_HASH_TABLE_ELEMENT (*valid_info->phis, vp, vn_phi_t, hip)
6282 set_value_id_for_result (vp->result, &vp->value_id);
6284 FOR_EACH_HASH_TABLE_ELEMENT (*valid_info->references, vr, vn_reference_t,
6285 hir)
6286 set_value_id_for_result (vr->result, &vr->value_id);
6289 /* Return the maximum value id we have ever seen. */
6291 unsigned int
6292 get_max_value_id (void)
6294 return next_value_id;
6297 /* Return the maximum constant value id we have ever seen. */
6299 unsigned int
6300 get_max_constant_value_id (void)
6302 return -next_constant_value_id;
6305 /* Return the next unique value id. */
6307 unsigned int
6308 get_next_value_id (void)
6310 gcc_checking_assert ((int)next_value_id > 0);
6311 return next_value_id++;
6314 /* Return the next unique value id for constants. */
6316 unsigned int
6317 get_next_constant_value_id (void)
6319 gcc_checking_assert (next_constant_value_id < 0);
6320 return next_constant_value_id--;
6324 /* Compare two expressions E1 and E2 and return true if they are equal.
6325 If match_vn_top_optimistically is true then VN_TOP is equal to anything,
6326 otherwise VN_TOP only matches VN_TOP. */
6328 bool
6329 expressions_equal_p (tree e1, tree e2, bool match_vn_top_optimistically)
6331 /* The obvious case. */
6332 if (e1 == e2)
6333 return true;
6335 /* If either one is VN_TOP consider them equal. */
6336 if (match_vn_top_optimistically
6337 && (e1 == VN_TOP || e2 == VN_TOP))
6338 return true;
6340 /* SSA_NAME compare pointer equal. */
6341 if (TREE_CODE (e1) == SSA_NAME || TREE_CODE (e2) == SSA_NAME)
6342 return false;
6344 /* Now perform the actual comparison. */
6345 if (TREE_CODE (e1) == TREE_CODE (e2)
6346 && operand_equal_p (e1, e2, OEP_PURE_SAME))
6347 return true;
6349 return false;
6353 /* Return true if the nary operation NARY may trap. This is a copy
6354 of stmt_could_throw_1_p adjusted to the SCCVN IL. */
6356 bool
6357 vn_nary_may_trap (vn_nary_op_t nary)
6359 tree type;
6360 tree rhs2 = NULL_TREE;
6361 bool honor_nans = false;
6362 bool honor_snans = false;
6363 bool fp_operation = false;
6364 bool honor_trapv = false;
6365 bool handled, ret;
6366 unsigned i;
6368 if (TREE_CODE_CLASS (nary->opcode) == tcc_comparison
6369 || TREE_CODE_CLASS (nary->opcode) == tcc_unary
6370 || TREE_CODE_CLASS (nary->opcode) == tcc_binary)
6372 type = nary->type;
6373 fp_operation = FLOAT_TYPE_P (type);
6374 if (fp_operation)
6376 honor_nans = flag_trapping_math && !flag_finite_math_only;
6377 honor_snans = flag_signaling_nans != 0;
6379 else if (INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type))
6380 honor_trapv = true;
6382 if (nary->length >= 2)
6383 rhs2 = nary->op[1];
6384 ret = operation_could_trap_helper_p (nary->opcode, fp_operation,
6385 honor_trapv, honor_nans, honor_snans,
6386 rhs2, &handled);
6387 if (handled && ret)
6388 return true;
6390 for (i = 0; i < nary->length; ++i)
6391 if (tree_could_trap_p (nary->op[i]))
6392 return true;
6394 return false;
6397 /* Return true if the reference operation REF may trap. */
6399 bool
6400 vn_reference_may_trap (vn_reference_t ref)
6402 switch (ref->operands[0].opcode)
6404 case MODIFY_EXPR:
6405 case CALL_EXPR:
6406 /* We do not handle calls. */
6407 return true;
6408 case ADDR_EXPR:
6409 /* And toplevel address computations never trap. */
6410 return false;
6411 default:;
6414 vn_reference_op_t op;
6415 unsigned i;
6416 FOR_EACH_VEC_ELT (ref->operands, i, op)
6418 switch (op->opcode)
6420 case WITH_SIZE_EXPR:
6421 case TARGET_MEM_REF:
6422 /* Always variable. */
6423 return true;
6424 case COMPONENT_REF:
6425 if (op->op1 && TREE_CODE (op->op1) == SSA_NAME)
6426 return true;
6427 break;
6428 case ARRAY_RANGE_REF:
6429 if (TREE_CODE (op->op0) == SSA_NAME)
6430 return true;
6431 break;
6432 case ARRAY_REF:
6434 if (TREE_CODE (op->op0) != INTEGER_CST)
6435 return true;
6437 /* !in_array_bounds */
6438 tree domain_type = TYPE_DOMAIN (ref->operands[i+1].type);
6439 if (!domain_type)
6440 return true;
6442 tree min = op->op1;
6443 tree max = TYPE_MAX_VALUE (domain_type);
6444 if (!min
6445 || !max
6446 || TREE_CODE (min) != INTEGER_CST
6447 || TREE_CODE (max) != INTEGER_CST)
6448 return true;
6450 if (tree_int_cst_lt (op->op0, min)
6451 || tree_int_cst_lt (max, op->op0))
6452 return true;
6454 break;
6456 case MEM_REF:
6457 /* Nothing interesting in itself, the base is separate. */
6458 break;
6459 /* The following are the address bases. */
6460 case SSA_NAME:
6461 return true;
6462 case ADDR_EXPR:
6463 if (op->op0)
6464 return tree_could_trap_p (TREE_OPERAND (op->op0, 0));
6465 return false;
6466 default:;
6469 return false;
6472 eliminate_dom_walker::eliminate_dom_walker (cdi_direction direction,
6473 bitmap inserted_exprs_)
6474 : dom_walker (direction), do_pre (inserted_exprs_ != NULL),
6475 el_todo (0), eliminations (0), insertions (0),
6476 inserted_exprs (inserted_exprs_)
6478 need_eh_cleanup = BITMAP_ALLOC (NULL);
6479 need_ab_cleanup = BITMAP_ALLOC (NULL);
6482 eliminate_dom_walker::~eliminate_dom_walker ()
6484 BITMAP_FREE (need_eh_cleanup);
6485 BITMAP_FREE (need_ab_cleanup);
6488 /* Return a leader for OP that is available at the current point of the
6489 eliminate domwalk. */
6491 tree
6492 eliminate_dom_walker::eliminate_avail (basic_block, tree op)
6494 tree valnum = VN_INFO (op)->valnum;
6495 if (TREE_CODE (valnum) == SSA_NAME)
6497 if (SSA_NAME_IS_DEFAULT_DEF (valnum))
6498 return valnum;
6499 if (avail.length () > SSA_NAME_VERSION (valnum))
6500 return avail[SSA_NAME_VERSION (valnum)];
6502 else if (is_gimple_min_invariant (valnum))
6503 return valnum;
6504 return NULL_TREE;
6507 /* At the current point of the eliminate domwalk make OP available. */
6509 void
6510 eliminate_dom_walker::eliminate_push_avail (basic_block, tree op)
6512 tree valnum = VN_INFO (op)->valnum;
6513 if (TREE_CODE (valnum) == SSA_NAME)
6515 if (avail.length () <= SSA_NAME_VERSION (valnum))
6516 avail.safe_grow_cleared (SSA_NAME_VERSION (valnum) + 1, true);
6517 tree pushop = op;
6518 if (avail[SSA_NAME_VERSION (valnum)])
6519 pushop = avail[SSA_NAME_VERSION (valnum)];
6520 avail_stack.safe_push (pushop);
6521 avail[SSA_NAME_VERSION (valnum)] = op;
6525 /* Insert the expression recorded by SCCVN for VAL at *GSI. Returns
6526 the leader for the expression if insertion was successful. */
6528 tree
6529 eliminate_dom_walker::eliminate_insert (basic_block bb,
6530 gimple_stmt_iterator *gsi, tree val)
6532 /* We can insert a sequence with a single assignment only. */
6533 gimple_seq stmts = VN_INFO (val)->expr;
6534 if (!gimple_seq_singleton_p (stmts))
6535 return NULL_TREE;
6536 gassign *stmt = dyn_cast <gassign *> (gimple_seq_first_stmt (stmts));
6537 if (!stmt
6538 || (!CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
6539 && gimple_assign_rhs_code (stmt) != VIEW_CONVERT_EXPR
6540 && gimple_assign_rhs_code (stmt) != NEGATE_EXPR
6541 && gimple_assign_rhs_code (stmt) != BIT_FIELD_REF
6542 && (gimple_assign_rhs_code (stmt) != BIT_AND_EXPR
6543 || TREE_CODE (gimple_assign_rhs2 (stmt)) != INTEGER_CST)))
6544 return NULL_TREE;
6546 tree op = gimple_assign_rhs1 (stmt);
6547 if (gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR
6548 || gimple_assign_rhs_code (stmt) == BIT_FIELD_REF)
6549 op = TREE_OPERAND (op, 0);
6550 tree leader = TREE_CODE (op) == SSA_NAME ? eliminate_avail (bb, op) : op;
6551 if (!leader)
6552 return NULL_TREE;
6554 tree res;
6555 stmts = NULL;
6556 if (gimple_assign_rhs_code (stmt) == BIT_FIELD_REF)
6557 res = gimple_build (&stmts, BIT_FIELD_REF,
6558 TREE_TYPE (val), leader,
6559 TREE_OPERAND (gimple_assign_rhs1 (stmt), 1),
6560 TREE_OPERAND (gimple_assign_rhs1 (stmt), 2));
6561 else if (gimple_assign_rhs_code (stmt) == BIT_AND_EXPR)
6562 res = gimple_build (&stmts, BIT_AND_EXPR,
6563 TREE_TYPE (val), leader, gimple_assign_rhs2 (stmt));
6564 else
6565 res = gimple_build (&stmts, gimple_assign_rhs_code (stmt),
6566 TREE_TYPE (val), leader);
6567 if (TREE_CODE (res) != SSA_NAME
6568 || SSA_NAME_IS_DEFAULT_DEF (res)
6569 || gimple_bb (SSA_NAME_DEF_STMT (res)))
6571 gimple_seq_discard (stmts);
6573 /* During propagation we have to treat SSA info conservatively
6574 and thus we can end up simplifying the inserted expression
6575 at elimination time to sth not defined in stmts. */
6576 /* But then this is a redundancy we failed to detect. Which means
6577 res now has two values. That doesn't play well with how
6578 we track availability here, so give up. */
6579 if (dump_file && (dump_flags & TDF_DETAILS))
6581 if (TREE_CODE (res) == SSA_NAME)
6582 res = eliminate_avail (bb, res);
6583 if (res)
6585 fprintf (dump_file, "Failed to insert expression for value ");
6586 print_generic_expr (dump_file, val);
6587 fprintf (dump_file, " which is really fully redundant to ");
6588 print_generic_expr (dump_file, res);
6589 fprintf (dump_file, "\n");
6593 return NULL_TREE;
6595 else
6597 gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT);
6598 vn_ssa_aux_t vn_info = VN_INFO (res);
6599 vn_info->valnum = val;
6600 vn_info->visited = true;
6603 insertions++;
6604 if (dump_file && (dump_flags & TDF_DETAILS))
6606 fprintf (dump_file, "Inserted ");
6607 print_gimple_stmt (dump_file, SSA_NAME_DEF_STMT (res), 0);
6610 return res;
6613 void
6614 eliminate_dom_walker::eliminate_stmt (basic_block b, gimple_stmt_iterator *gsi)
6616 tree sprime = NULL_TREE;
6617 gimple *stmt = gsi_stmt (*gsi);
6618 tree lhs = gimple_get_lhs (stmt);
6619 if (lhs && TREE_CODE (lhs) == SSA_NAME
6620 && !gimple_has_volatile_ops (stmt)
6621 /* See PR43491. Do not replace a global register variable when
6622 it is a the RHS of an assignment. Do replace local register
6623 variables since gcc does not guarantee a local variable will
6624 be allocated in register.
6625 ??? The fix isn't effective here. This should instead
6626 be ensured by not value-numbering them the same but treating
6627 them like volatiles? */
6628 && !(gimple_assign_single_p (stmt)
6629 && (TREE_CODE (gimple_assign_rhs1 (stmt)) == VAR_DECL
6630 && DECL_HARD_REGISTER (gimple_assign_rhs1 (stmt))
6631 && is_global_var (gimple_assign_rhs1 (stmt)))))
6633 sprime = eliminate_avail (b, lhs);
6634 if (!sprime)
6636 /* If there is no existing usable leader but SCCVN thinks
6637 it has an expression it wants to use as replacement,
6638 insert that. */
6639 tree val = VN_INFO (lhs)->valnum;
6640 vn_ssa_aux_t vn_info;
6641 if (val != VN_TOP
6642 && TREE_CODE (val) == SSA_NAME
6643 && (vn_info = VN_INFO (val), true)
6644 && vn_info->needs_insertion
6645 && vn_info->expr != NULL
6646 && (sprime = eliminate_insert (b, gsi, val)) != NULL_TREE)
6647 eliminate_push_avail (b, sprime);
6650 /* If this now constitutes a copy duplicate points-to
6651 and range info appropriately. This is especially
6652 important for inserted code. See tree-ssa-copy.cc
6653 for similar code. */
6654 if (sprime
6655 && TREE_CODE (sprime) == SSA_NAME)
6657 basic_block sprime_b = gimple_bb (SSA_NAME_DEF_STMT (sprime));
6658 if (POINTER_TYPE_P (TREE_TYPE (lhs))
6659 && SSA_NAME_PTR_INFO (lhs)
6660 && ! SSA_NAME_PTR_INFO (sprime))
6662 duplicate_ssa_name_ptr_info (sprime,
6663 SSA_NAME_PTR_INFO (lhs));
6664 if (b != sprime_b)
6665 reset_flow_sensitive_info (sprime);
6667 else if (INTEGRAL_TYPE_P (TREE_TYPE (lhs))
6668 && SSA_NAME_RANGE_INFO (lhs)
6669 && ! SSA_NAME_RANGE_INFO (sprime)
6670 && b == sprime_b)
6671 duplicate_ssa_name_range_info (sprime, lhs);
6674 /* Inhibit the use of an inserted PHI on a loop header when
6675 the address of the memory reference is a simple induction
6676 variable. In other cases the vectorizer won't do anything
6677 anyway (either it's loop invariant or a complicated
6678 expression). */
6679 if (sprime
6680 && TREE_CODE (sprime) == SSA_NAME
6681 && do_pre
6682 && (flag_tree_loop_vectorize || flag_tree_parallelize_loops > 1)
6683 && loop_outer (b->loop_father)
6684 && has_zero_uses (sprime)
6685 && bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (sprime))
6686 && gimple_assign_load_p (stmt))
6688 gimple *def_stmt = SSA_NAME_DEF_STMT (sprime);
6689 basic_block def_bb = gimple_bb (def_stmt);
6690 if (gimple_code (def_stmt) == GIMPLE_PHI
6691 && def_bb->loop_father->header == def_bb)
6693 loop_p loop = def_bb->loop_father;
6694 ssa_op_iter iter;
6695 tree op;
6696 bool found = false;
6697 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
6699 affine_iv iv;
6700 def_bb = gimple_bb (SSA_NAME_DEF_STMT (op));
6701 if (def_bb
6702 && flow_bb_inside_loop_p (loop, def_bb)
6703 && simple_iv (loop, loop, op, &iv, true))
6705 found = true;
6706 break;
6709 if (found)
6711 if (dump_file && (dump_flags & TDF_DETAILS))
6713 fprintf (dump_file, "Not replacing ");
6714 print_gimple_expr (dump_file, stmt, 0);
6715 fprintf (dump_file, " with ");
6716 print_generic_expr (dump_file, sprime);
6717 fprintf (dump_file, " which would add a loop"
6718 " carried dependence to loop %d\n",
6719 loop->num);
6721 /* Don't keep sprime available. */
6722 sprime = NULL_TREE;
6727 if (sprime)
6729 /* If we can propagate the value computed for LHS into
6730 all uses don't bother doing anything with this stmt. */
6731 if (may_propagate_copy (lhs, sprime))
6733 /* Mark it for removal. */
6734 to_remove.safe_push (stmt);
6736 /* ??? Don't count copy/constant propagations. */
6737 if (gimple_assign_single_p (stmt)
6738 && (TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
6739 || gimple_assign_rhs1 (stmt) == sprime))
6740 return;
6742 if (dump_file && (dump_flags & TDF_DETAILS))
6744 fprintf (dump_file, "Replaced ");
6745 print_gimple_expr (dump_file, stmt, 0);
6746 fprintf (dump_file, " with ");
6747 print_generic_expr (dump_file, sprime);
6748 fprintf (dump_file, " in all uses of ");
6749 print_gimple_stmt (dump_file, stmt, 0);
6752 eliminations++;
6753 return;
6756 /* If this is an assignment from our leader (which
6757 happens in the case the value-number is a constant)
6758 then there is nothing to do. Likewise if we run into
6759 inserted code that needed a conversion because of
6760 our type-agnostic value-numbering of loads. */
6761 if ((gimple_assign_single_p (stmt)
6762 || (is_gimple_assign (stmt)
6763 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
6764 || gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR)))
6765 && sprime == gimple_assign_rhs1 (stmt))
6766 return;
6768 /* Else replace its RHS. */
6769 if (dump_file && (dump_flags & TDF_DETAILS))
6771 fprintf (dump_file, "Replaced ");
6772 print_gimple_expr (dump_file, stmt, 0);
6773 fprintf (dump_file, " with ");
6774 print_generic_expr (dump_file, sprime);
6775 fprintf (dump_file, " in ");
6776 print_gimple_stmt (dump_file, stmt, 0);
6778 eliminations++;
6780 bool can_make_abnormal_goto = (is_gimple_call (stmt)
6781 && stmt_can_make_abnormal_goto (stmt));
6782 gimple *orig_stmt = stmt;
6783 if (!useless_type_conversion_p (TREE_TYPE (lhs),
6784 TREE_TYPE (sprime)))
6786 /* We preserve conversions to but not from function or method
6787 types. This asymmetry makes it necessary to re-instantiate
6788 conversions here. */
6789 if (POINTER_TYPE_P (TREE_TYPE (lhs))
6790 && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (lhs))))
6791 sprime = fold_convert (TREE_TYPE (lhs), sprime);
6792 else
6793 gcc_unreachable ();
6795 tree vdef = gimple_vdef (stmt);
6796 tree vuse = gimple_vuse (stmt);
6797 propagate_tree_value_into_stmt (gsi, sprime);
6798 stmt = gsi_stmt (*gsi);
6799 update_stmt (stmt);
6800 /* In case the VDEF on the original stmt was released, value-number
6801 it to the VUSE. This is to make vuse_ssa_val able to skip
6802 released virtual operands. */
6803 if (vdef != gimple_vdef (stmt))
6805 gcc_assert (SSA_NAME_IN_FREE_LIST (vdef));
6806 VN_INFO (vdef)->valnum = vuse;
6809 /* If we removed EH side-effects from the statement, clean
6810 its EH information. */
6811 if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt))
6813 bitmap_set_bit (need_eh_cleanup,
6814 gimple_bb (stmt)->index);
6815 if (dump_file && (dump_flags & TDF_DETAILS))
6816 fprintf (dump_file, " Removed EH side-effects.\n");
6819 /* Likewise for AB side-effects. */
6820 if (can_make_abnormal_goto
6821 && !stmt_can_make_abnormal_goto (stmt))
6823 bitmap_set_bit (need_ab_cleanup,
6824 gimple_bb (stmt)->index);
6825 if (dump_file && (dump_flags & TDF_DETAILS))
6826 fprintf (dump_file, " Removed AB side-effects.\n");
6829 return;
6833 /* If the statement is a scalar store, see if the expression
6834 has the same value number as its rhs. If so, the store is
6835 dead. */
6836 if (gimple_assign_single_p (stmt)
6837 && !gimple_has_volatile_ops (stmt)
6838 && !is_gimple_reg (gimple_assign_lhs (stmt))
6839 && (TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
6840 || is_gimple_min_invariant (gimple_assign_rhs1 (stmt))))
6842 tree rhs = gimple_assign_rhs1 (stmt);
6843 vn_reference_t vnresult;
6844 /* ??? gcc.dg/torture/pr91445.c shows that we lookup a boolean
6845 typed load of a byte known to be 0x11 as 1 so a store of
6846 a boolean 1 is detected as redundant. Because of this we
6847 have to make sure to lookup with a ref where its size
6848 matches the precision. */
6849 tree lookup_lhs = lhs;
6850 if (INTEGRAL_TYPE_P (TREE_TYPE (lhs))
6851 && (TREE_CODE (lhs) != COMPONENT_REF
6852 || !DECL_BIT_FIELD_TYPE (TREE_OPERAND (lhs, 1)))
6853 && !type_has_mode_precision_p (TREE_TYPE (lhs)))
6855 if (TREE_CODE (lhs) == COMPONENT_REF
6856 || TREE_CODE (lhs) == MEM_REF)
6858 tree ltype = build_nonstandard_integer_type
6859 (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (lhs))),
6860 TYPE_UNSIGNED (TREE_TYPE (lhs)));
6861 if (TREE_CODE (lhs) == COMPONENT_REF)
6863 tree foff = component_ref_field_offset (lhs);
6864 tree f = TREE_OPERAND (lhs, 1);
6865 if (!poly_int_tree_p (foff))
6866 lookup_lhs = NULL_TREE;
6867 else
6868 lookup_lhs = build3 (BIT_FIELD_REF, ltype,
6869 TREE_OPERAND (lhs, 0),
6870 TYPE_SIZE (TREE_TYPE (lhs)),
6871 bit_from_pos
6872 (foff, DECL_FIELD_BIT_OFFSET (f)));
6874 else
6875 lookup_lhs = build2 (MEM_REF, ltype,
6876 TREE_OPERAND (lhs, 0),
6877 TREE_OPERAND (lhs, 1));
6879 else
6880 lookup_lhs = NULL_TREE;
6882 tree val = NULL_TREE;
6883 if (lookup_lhs)
6884 val = vn_reference_lookup (lookup_lhs, gimple_vuse (stmt),
6885 VN_WALKREWRITE, &vnresult, false,
6886 NULL, NULL_TREE, true);
6887 if (TREE_CODE (rhs) == SSA_NAME)
6888 rhs = VN_INFO (rhs)->valnum;
6889 if (val
6890 && (operand_equal_p (val, rhs, 0)
6891 /* Due to the bitfield lookups above we can get bit
6892 interpretations of the same RHS as values here. Those
6893 are redundant as well. */
6894 || (TREE_CODE (val) == SSA_NAME
6895 && gimple_assign_single_p (SSA_NAME_DEF_STMT (val))
6896 && (val = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (val)))
6897 && TREE_CODE (val) == VIEW_CONVERT_EXPR
6898 && TREE_OPERAND (val, 0) == rhs)))
6900 /* We can only remove the later store if the former aliases
6901 at least all accesses the later one does or if the store
6902 was to readonly memory storing the same value. */
6903 ao_ref lhs_ref;
6904 ao_ref_init (&lhs_ref, lhs);
6905 alias_set_type set = ao_ref_alias_set (&lhs_ref);
6906 alias_set_type base_set = ao_ref_base_alias_set (&lhs_ref);
6907 if (! vnresult
6908 || ((vnresult->set == set
6909 || alias_set_subset_of (set, vnresult->set))
6910 && (vnresult->base_set == base_set
6911 || alias_set_subset_of (base_set, vnresult->base_set))))
6913 if (dump_file && (dump_flags & TDF_DETAILS))
6915 fprintf (dump_file, "Deleted redundant store ");
6916 print_gimple_stmt (dump_file, stmt, 0);
6919 /* Queue stmt for removal. */
6920 to_remove.safe_push (stmt);
6921 return;
6926 /* If this is a control statement value numbering left edges
6927 unexecuted on force the condition in a way consistent with
6928 that. */
6929 if (gcond *cond = dyn_cast <gcond *> (stmt))
6931 if ((EDGE_SUCC (b, 0)->flags & EDGE_EXECUTABLE)
6932 ^ (EDGE_SUCC (b, 1)->flags & EDGE_EXECUTABLE))
6934 if (dump_file && (dump_flags & TDF_DETAILS))
6936 fprintf (dump_file, "Removing unexecutable edge from ");
6937 print_gimple_stmt (dump_file, stmt, 0);
6939 if (((EDGE_SUCC (b, 0)->flags & EDGE_TRUE_VALUE) != 0)
6940 == ((EDGE_SUCC (b, 0)->flags & EDGE_EXECUTABLE) != 0))
6941 gimple_cond_make_true (cond);
6942 else
6943 gimple_cond_make_false (cond);
6944 update_stmt (cond);
6945 el_todo |= TODO_cleanup_cfg;
6946 return;
6950 bool can_make_abnormal_goto = stmt_can_make_abnormal_goto (stmt);
6951 bool was_noreturn = (is_gimple_call (stmt)
6952 && gimple_call_noreturn_p (stmt));
6953 tree vdef = gimple_vdef (stmt);
6954 tree vuse = gimple_vuse (stmt);
6956 /* If we didn't replace the whole stmt (or propagate the result
6957 into all uses), replace all uses on this stmt with their
6958 leaders. */
6959 bool modified = false;
6960 use_operand_p use_p;
6961 ssa_op_iter iter;
6962 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
6964 tree use = USE_FROM_PTR (use_p);
6965 /* ??? The call code above leaves stmt operands un-updated. */
6966 if (TREE_CODE (use) != SSA_NAME)
6967 continue;
6968 tree sprime;
6969 if (SSA_NAME_IS_DEFAULT_DEF (use))
6970 /* ??? For default defs BB shouldn't matter, but we have to
6971 solve the inconsistency between rpo eliminate and
6972 dom eliminate avail valueization first. */
6973 sprime = eliminate_avail (b, use);
6974 else
6975 /* Look for sth available at the definition block of the argument.
6976 This avoids inconsistencies between availability there which
6977 decides if the stmt can be removed and availability at the
6978 use site. The SSA property ensures that things available
6979 at the definition are also available at uses. */
6980 sprime = eliminate_avail (gimple_bb (SSA_NAME_DEF_STMT (use)), use);
6981 if (sprime && sprime != use
6982 && may_propagate_copy (use, sprime, true)
6983 /* We substitute into debug stmts to avoid excessive
6984 debug temporaries created by removed stmts, but we need
6985 to avoid doing so for inserted sprimes as we never want
6986 to create debug temporaries for them. */
6987 && (!inserted_exprs
6988 || TREE_CODE (sprime) != SSA_NAME
6989 || !is_gimple_debug (stmt)
6990 || !bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (sprime))))
6992 propagate_value (use_p, sprime);
6993 modified = true;
6997 /* Fold the stmt if modified, this canonicalizes MEM_REFs we propagated
6998 into which is a requirement for the IPA devirt machinery. */
6999 gimple *old_stmt = stmt;
7000 if (modified)
7002 /* If a formerly non-invariant ADDR_EXPR is turned into an
7003 invariant one it was on a separate stmt. */
7004 if (gimple_assign_single_p (stmt)
7005 && TREE_CODE (gimple_assign_rhs1 (stmt)) == ADDR_EXPR)
7006 recompute_tree_invariant_for_addr_expr (gimple_assign_rhs1 (stmt));
7007 gimple_stmt_iterator prev = *gsi;
7008 gsi_prev (&prev);
7009 if (fold_stmt (gsi, follow_all_ssa_edges))
7011 /* fold_stmt may have created new stmts inbetween
7012 the previous stmt and the folded stmt. Mark
7013 all defs created there as varying to not confuse
7014 the SCCVN machinery as we're using that even during
7015 elimination. */
7016 if (gsi_end_p (prev))
7017 prev = gsi_start_bb (b);
7018 else
7019 gsi_next (&prev);
7020 if (gsi_stmt (prev) != gsi_stmt (*gsi))
7023 tree def;
7024 ssa_op_iter dit;
7025 FOR_EACH_SSA_TREE_OPERAND (def, gsi_stmt (prev),
7026 dit, SSA_OP_ALL_DEFS)
7027 /* As existing DEFs may move between stmts
7028 only process new ones. */
7029 if (! has_VN_INFO (def))
7031 vn_ssa_aux_t vn_info = VN_INFO (def);
7032 vn_info->valnum = def;
7033 vn_info->visited = true;
7035 if (gsi_stmt (prev) == gsi_stmt (*gsi))
7036 break;
7037 gsi_next (&prev);
7039 while (1);
7041 stmt = gsi_stmt (*gsi);
7042 /* In case we folded the stmt away schedule the NOP for removal. */
7043 if (gimple_nop_p (stmt))
7044 to_remove.safe_push (stmt);
7047 /* Visit indirect calls and turn them into direct calls if
7048 possible using the devirtualization machinery. Do this before
7049 checking for required EH/abnormal/noreturn cleanup as devird
7050 may expose more of those. */
7051 if (gcall *call_stmt = dyn_cast <gcall *> (stmt))
7053 tree fn = gimple_call_fn (call_stmt);
7054 if (fn
7055 && flag_devirtualize
7056 && virtual_method_call_p (fn))
7058 tree otr_type = obj_type_ref_class (fn);
7059 unsigned HOST_WIDE_INT otr_tok
7060 = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (fn));
7061 tree instance;
7062 ipa_polymorphic_call_context context (current_function_decl,
7063 fn, stmt, &instance);
7064 context.get_dynamic_type (instance, OBJ_TYPE_REF_OBJECT (fn),
7065 otr_type, stmt, NULL);
7066 bool final;
7067 vec <cgraph_node *> targets
7068 = possible_polymorphic_call_targets (obj_type_ref_class (fn),
7069 otr_tok, context, &final);
7070 if (dump_file)
7071 dump_possible_polymorphic_call_targets (dump_file,
7072 obj_type_ref_class (fn),
7073 otr_tok, context);
7074 if (final && targets.length () <= 1 && dbg_cnt (devirt))
7076 tree fn;
7077 if (targets.length () == 1)
7078 fn = targets[0]->decl;
7079 else
7080 fn = builtin_decl_unreachable ();
7081 if (dump_enabled_p ())
7083 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, stmt,
7084 "converting indirect call to "
7085 "function %s\n",
7086 lang_hooks.decl_printable_name (fn, 2));
7088 gimple_call_set_fndecl (call_stmt, fn);
7089 /* If changing the call to __builtin_unreachable
7090 or similar noreturn function, adjust gimple_call_fntype
7091 too. */
7092 if (gimple_call_noreturn_p (call_stmt)
7093 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fn)))
7094 && TYPE_ARG_TYPES (TREE_TYPE (fn))
7095 && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fn)))
7096 == void_type_node))
7097 gimple_call_set_fntype (call_stmt, TREE_TYPE (fn));
7098 maybe_remove_unused_call_args (cfun, call_stmt);
7099 modified = true;
7104 if (modified)
7106 /* When changing a call into a noreturn call, cfg cleanup
7107 is needed to fix up the noreturn call. */
7108 if (!was_noreturn
7109 && is_gimple_call (stmt) && gimple_call_noreturn_p (stmt))
7110 to_fixup.safe_push (stmt);
7111 /* When changing a condition or switch into one we know what
7112 edge will be executed, schedule a cfg cleanup. */
7113 if ((gimple_code (stmt) == GIMPLE_COND
7114 && (gimple_cond_true_p (as_a <gcond *> (stmt))
7115 || gimple_cond_false_p (as_a <gcond *> (stmt))))
7116 || (gimple_code (stmt) == GIMPLE_SWITCH
7117 && TREE_CODE (gimple_switch_index
7118 (as_a <gswitch *> (stmt))) == INTEGER_CST))
7119 el_todo |= TODO_cleanup_cfg;
7120 /* If we removed EH side-effects from the statement, clean
7121 its EH information. */
7122 if (maybe_clean_or_replace_eh_stmt (old_stmt, stmt))
7124 bitmap_set_bit (need_eh_cleanup,
7125 gimple_bb (stmt)->index);
7126 if (dump_file && (dump_flags & TDF_DETAILS))
7127 fprintf (dump_file, " Removed EH side-effects.\n");
7129 /* Likewise for AB side-effects. */
7130 if (can_make_abnormal_goto
7131 && !stmt_can_make_abnormal_goto (stmt))
7133 bitmap_set_bit (need_ab_cleanup,
7134 gimple_bb (stmt)->index);
7135 if (dump_file && (dump_flags & TDF_DETAILS))
7136 fprintf (dump_file, " Removed AB side-effects.\n");
7138 update_stmt (stmt);
7139 /* In case the VDEF on the original stmt was released, value-number
7140 it to the VUSE. This is to make vuse_ssa_val able to skip
7141 released virtual operands. */
7142 if (vdef && SSA_NAME_IN_FREE_LIST (vdef))
7143 VN_INFO (vdef)->valnum = vuse;
7146 /* Make new values available - for fully redundant LHS we
7147 continue with the next stmt above and skip this. */
7148 def_operand_p defp;
7149 FOR_EACH_SSA_DEF_OPERAND (defp, stmt, iter, SSA_OP_DEF)
7150 eliminate_push_avail (b, DEF_FROM_PTR (defp));
7153 /* Perform elimination for the basic-block B during the domwalk. */
7155 edge
7156 eliminate_dom_walker::before_dom_children (basic_block b)
7158 /* Mark new bb. */
7159 avail_stack.safe_push (NULL_TREE);
7161 /* Skip unreachable blocks marked unreachable during the SCCVN domwalk. */
7162 if (!(b->flags & BB_EXECUTABLE))
7163 return NULL;
7165 vn_context_bb = b;
7167 for (gphi_iterator gsi = gsi_start_phis (b); !gsi_end_p (gsi);)
7169 gphi *phi = gsi.phi ();
7170 tree res = PHI_RESULT (phi);
7172 if (virtual_operand_p (res))
7174 gsi_next (&gsi);
7175 continue;
7178 tree sprime = eliminate_avail (b, res);
7179 if (sprime
7180 && sprime != res)
7182 if (dump_file && (dump_flags & TDF_DETAILS))
7184 fprintf (dump_file, "Replaced redundant PHI node defining ");
7185 print_generic_expr (dump_file, res);
7186 fprintf (dump_file, " with ");
7187 print_generic_expr (dump_file, sprime);
7188 fprintf (dump_file, "\n");
7191 /* If we inserted this PHI node ourself, it's not an elimination. */
7192 if (! inserted_exprs
7193 || ! bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (res)))
7194 eliminations++;
7196 /* If we will propagate into all uses don't bother to do
7197 anything. */
7198 if (may_propagate_copy (res, sprime))
7200 /* Mark the PHI for removal. */
7201 to_remove.safe_push (phi);
7202 gsi_next (&gsi);
7203 continue;
7206 remove_phi_node (&gsi, false);
7208 if (!useless_type_conversion_p (TREE_TYPE (res), TREE_TYPE (sprime)))
7209 sprime = fold_convert (TREE_TYPE (res), sprime);
7210 gimple *stmt = gimple_build_assign (res, sprime);
7211 gimple_stmt_iterator gsi2 = gsi_after_labels (b);
7212 gsi_insert_before (&gsi2, stmt, GSI_NEW_STMT);
7213 continue;
7216 eliminate_push_avail (b, res);
7217 gsi_next (&gsi);
7220 for (gimple_stmt_iterator gsi = gsi_start_bb (b);
7221 !gsi_end_p (gsi);
7222 gsi_next (&gsi))
7223 eliminate_stmt (b, &gsi);
7225 /* Replace destination PHI arguments. */
7226 edge_iterator ei;
7227 edge e;
7228 FOR_EACH_EDGE (e, ei, b->succs)
7229 if (e->flags & EDGE_EXECUTABLE)
7230 for (gphi_iterator gsi = gsi_start_phis (e->dest);
7231 !gsi_end_p (gsi);
7232 gsi_next (&gsi))
7234 gphi *phi = gsi.phi ();
7235 use_operand_p use_p = PHI_ARG_DEF_PTR_FROM_EDGE (phi, e);
7236 tree arg = USE_FROM_PTR (use_p);
7237 if (TREE_CODE (arg) != SSA_NAME
7238 || virtual_operand_p (arg))
7239 continue;
7240 tree sprime = eliminate_avail (b, arg);
7241 if (sprime && may_propagate_copy (arg, sprime))
7242 propagate_value (use_p, sprime);
7245 vn_context_bb = NULL;
7247 return NULL;
7250 /* Make no longer available leaders no longer available. */
7252 void
7253 eliminate_dom_walker::after_dom_children (basic_block)
7255 tree entry;
7256 while ((entry = avail_stack.pop ()) != NULL_TREE)
7258 tree valnum = VN_INFO (entry)->valnum;
7259 tree old = avail[SSA_NAME_VERSION (valnum)];
7260 if (old == entry)
7261 avail[SSA_NAME_VERSION (valnum)] = NULL_TREE;
7262 else
7263 avail[SSA_NAME_VERSION (valnum)] = entry;
7267 /* Remove queued stmts and perform delayed cleanups. */
7269 unsigned
7270 eliminate_dom_walker::eliminate_cleanup (bool region_p)
7272 statistics_counter_event (cfun, "Eliminated", eliminations);
7273 statistics_counter_event (cfun, "Insertions", insertions);
7275 /* We cannot remove stmts during BB walk, especially not release SSA
7276 names there as this confuses the VN machinery. The stmts ending
7277 up in to_remove are either stores or simple copies.
7278 Remove stmts in reverse order to make debug stmt creation possible. */
7279 while (!to_remove.is_empty ())
7281 bool do_release_defs = true;
7282 gimple *stmt = to_remove.pop ();
7284 /* When we are value-numbering a region we do not require exit PHIs to
7285 be present so we have to make sure to deal with uses outside of the
7286 region of stmts that we thought are eliminated.
7287 ??? Note we may be confused by uses in dead regions we didn't run
7288 elimination on. Rather than checking individual uses we accept
7289 dead copies to be generated here (gcc.c-torture/execute/20060905-1.c
7290 contains such example). */
7291 if (region_p)
7293 if (gphi *phi = dyn_cast <gphi *> (stmt))
7295 tree lhs = gimple_phi_result (phi);
7296 if (!has_zero_uses (lhs))
7298 if (dump_file && (dump_flags & TDF_DETAILS))
7299 fprintf (dump_file, "Keeping eliminated stmt live "
7300 "as copy because of out-of-region uses\n");
7301 tree sprime = eliminate_avail (gimple_bb (stmt), lhs);
7302 gimple *copy = gimple_build_assign (lhs, sprime);
7303 gimple_stmt_iterator gsi
7304 = gsi_after_labels (gimple_bb (stmt));
7305 gsi_insert_before (&gsi, copy, GSI_SAME_STMT);
7306 do_release_defs = false;
7309 else if (tree lhs = gimple_get_lhs (stmt))
7310 if (TREE_CODE (lhs) == SSA_NAME
7311 && !has_zero_uses (lhs))
7313 if (dump_file && (dump_flags & TDF_DETAILS))
7314 fprintf (dump_file, "Keeping eliminated stmt live "
7315 "as copy because of out-of-region uses\n");
7316 tree sprime = eliminate_avail (gimple_bb (stmt), lhs);
7317 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
7318 if (is_gimple_assign (stmt))
7320 gimple_assign_set_rhs_from_tree (&gsi, sprime);
7321 stmt = gsi_stmt (gsi);
7322 update_stmt (stmt);
7323 if (maybe_clean_or_replace_eh_stmt (stmt, stmt))
7324 bitmap_set_bit (need_eh_cleanup, gimple_bb (stmt)->index);
7325 continue;
7327 else
7329 gimple *copy = gimple_build_assign (lhs, sprime);
7330 gsi_insert_before (&gsi, copy, GSI_SAME_STMT);
7331 do_release_defs = false;
7336 if (dump_file && (dump_flags & TDF_DETAILS))
7338 fprintf (dump_file, "Removing dead stmt ");
7339 print_gimple_stmt (dump_file, stmt, 0, TDF_NONE);
7342 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
7343 if (gimple_code (stmt) == GIMPLE_PHI)
7344 remove_phi_node (&gsi, do_release_defs);
7345 else
7347 basic_block bb = gimple_bb (stmt);
7348 unlink_stmt_vdef (stmt);
7349 if (gsi_remove (&gsi, true))
7350 bitmap_set_bit (need_eh_cleanup, bb->index);
7351 if (is_gimple_call (stmt) && stmt_can_make_abnormal_goto (stmt))
7352 bitmap_set_bit (need_ab_cleanup, bb->index);
7353 if (do_release_defs)
7354 release_defs (stmt);
7357 /* Removing a stmt may expose a forwarder block. */
7358 el_todo |= TODO_cleanup_cfg;
7361 /* Fixup stmts that became noreturn calls. This may require splitting
7362 blocks and thus isn't possible during the dominator walk. Do this
7363 in reverse order so we don't inadvertedly remove a stmt we want to
7364 fixup by visiting a dominating now noreturn call first. */
7365 while (!to_fixup.is_empty ())
7367 gimple *stmt = to_fixup.pop ();
7369 if (dump_file && (dump_flags & TDF_DETAILS))
7371 fprintf (dump_file, "Fixing up noreturn call ");
7372 print_gimple_stmt (dump_file, stmt, 0);
7375 if (fixup_noreturn_call (stmt))
7376 el_todo |= TODO_cleanup_cfg;
7379 bool do_eh_cleanup = !bitmap_empty_p (need_eh_cleanup);
7380 bool do_ab_cleanup = !bitmap_empty_p (need_ab_cleanup);
7382 if (do_eh_cleanup)
7383 gimple_purge_all_dead_eh_edges (need_eh_cleanup);
7385 if (do_ab_cleanup)
7386 gimple_purge_all_dead_abnormal_call_edges (need_ab_cleanup);
7388 if (do_eh_cleanup || do_ab_cleanup)
7389 el_todo |= TODO_cleanup_cfg;
7391 return el_todo;
7394 /* Eliminate fully redundant computations. */
7396 unsigned
7397 eliminate_with_rpo_vn (bitmap inserted_exprs)
7399 eliminate_dom_walker walker (CDI_DOMINATORS, inserted_exprs);
7401 eliminate_dom_walker *saved_rpo_avail = rpo_avail;
7402 rpo_avail = &walker;
7403 walker.walk (cfun->cfg->x_entry_block_ptr);
7404 rpo_avail = saved_rpo_avail;
7406 return walker.eliminate_cleanup ();
7409 static unsigned
7410 do_rpo_vn_1 (function *fn, edge entry, bitmap exit_bbs,
7411 bool iterate, bool eliminate, vn_lookup_kind kind);
7413 void
7414 run_rpo_vn (vn_lookup_kind kind)
7416 do_rpo_vn_1 (cfun, NULL, NULL, true, false, kind);
7418 /* ??? Prune requirement of these. */
7419 constant_to_value_id = new hash_table<vn_constant_hasher> (23);
7421 /* Initialize the value ids and prune out remaining VN_TOPs
7422 from dead code. */
7423 tree name;
7424 unsigned i;
7425 FOR_EACH_SSA_NAME (i, name, cfun)
7427 vn_ssa_aux_t info = VN_INFO (name);
7428 if (!info->visited
7429 || info->valnum == VN_TOP)
7430 info->valnum = name;
7431 if (info->valnum == name)
7432 info->value_id = get_next_value_id ();
7433 else if (is_gimple_min_invariant (info->valnum))
7434 info->value_id = get_or_alloc_constant_value_id (info->valnum);
7437 /* Propagate. */
7438 FOR_EACH_SSA_NAME (i, name, cfun)
7440 vn_ssa_aux_t info = VN_INFO (name);
7441 if (TREE_CODE (info->valnum) == SSA_NAME
7442 && info->valnum != name
7443 && info->value_id != VN_INFO (info->valnum)->value_id)
7444 info->value_id = VN_INFO (info->valnum)->value_id;
7447 set_hashtable_value_ids ();
7449 if (dump_file && (dump_flags & TDF_DETAILS))
7451 fprintf (dump_file, "Value numbers:\n");
7452 FOR_EACH_SSA_NAME (i, name, cfun)
7454 if (VN_INFO (name)->visited
7455 && SSA_VAL (name) != name)
7457 print_generic_expr (dump_file, name);
7458 fprintf (dump_file, " = ");
7459 print_generic_expr (dump_file, SSA_VAL (name));
7460 fprintf (dump_file, " (%04d)\n", VN_INFO (name)->value_id);
7466 /* Free VN associated data structures. */
7468 void
7469 free_rpo_vn (void)
7471 free_vn_table (valid_info);
7472 XDELETE (valid_info);
7473 obstack_free (&vn_tables_obstack, NULL);
7474 obstack_free (&vn_tables_insert_obstack, NULL);
7476 vn_ssa_aux_iterator_type it;
7477 vn_ssa_aux_t info;
7478 FOR_EACH_HASH_TABLE_ELEMENT (*vn_ssa_aux_hash, info, vn_ssa_aux_t, it)
7479 if (info->needs_insertion)
7480 release_ssa_name (info->name);
7481 obstack_free (&vn_ssa_aux_obstack, NULL);
7482 delete vn_ssa_aux_hash;
7484 delete constant_to_value_id;
7485 constant_to_value_id = NULL;
7488 /* Hook for maybe_push_res_to_seq, lookup the expression in the VN tables. */
7490 static tree
7491 vn_lookup_simplify_result (gimple_match_op *res_op)
7493 if (!res_op->code.is_tree_code ())
7494 return NULL_TREE;
7495 tree *ops = res_op->ops;
7496 unsigned int length = res_op->num_ops;
7497 if (res_op->code == CONSTRUCTOR
7498 /* ??? We're arriving here with SCCVNs view, decomposed CONSTRUCTOR
7499 and GIMPLEs / match-and-simplifies, CONSTRUCTOR as GENERIC tree. */
7500 && TREE_CODE (res_op->ops[0]) == CONSTRUCTOR)
7502 length = CONSTRUCTOR_NELTS (res_op->ops[0]);
7503 ops = XALLOCAVEC (tree, length);
7504 for (unsigned i = 0; i < length; ++i)
7505 ops[i] = CONSTRUCTOR_ELT (res_op->ops[0], i)->value;
7507 vn_nary_op_t vnresult = NULL;
7508 tree res = vn_nary_op_lookup_pieces (length, (tree_code) res_op->code,
7509 res_op->type, ops, &vnresult);
7510 /* If this is used from expression simplification make sure to
7511 return an available expression. */
7512 if (res && TREE_CODE (res) == SSA_NAME && mprts_hook && rpo_avail)
7513 res = rpo_avail->eliminate_avail (vn_context_bb, res);
7514 return res;
7517 /* Return a leader for OPs value that is valid at BB. */
7519 tree
7520 rpo_elim::eliminate_avail (basic_block bb, tree op)
7522 bool visited;
7523 tree valnum = SSA_VAL (op, &visited);
7524 /* If we didn't visit OP then it must be defined outside of the
7525 region we process and also dominate it. So it is available. */
7526 if (!visited)
7527 return op;
7528 if (TREE_CODE (valnum) == SSA_NAME)
7530 if (SSA_NAME_IS_DEFAULT_DEF (valnum))
7531 return valnum;
7532 vn_avail *av = VN_INFO (valnum)->avail;
7533 if (!av)
7534 return NULL_TREE;
7535 if (av->location == bb->index)
7536 /* On tramp3d 90% of the cases are here. */
7537 return ssa_name (av->leader);
7540 basic_block abb = BASIC_BLOCK_FOR_FN (cfun, av->location);
7541 /* ??? During elimination we have to use availability at the
7542 definition site of a use we try to replace. This
7543 is required to not run into inconsistencies because
7544 of dominated_by_p_w_unex behavior and removing a definition
7545 while not replacing all uses.
7546 ??? We could try to consistently walk dominators
7547 ignoring non-executable regions. The nearest common
7548 dominator of bb and abb is where we can stop walking. We
7549 may also be able to "pre-compute" (bits of) the next immediate
7550 (non-)dominator during the RPO walk when marking edges as
7551 executable. */
7552 if (dominated_by_p_w_unex (bb, abb, true))
7554 tree leader = ssa_name (av->leader);
7555 /* Prevent eliminations that break loop-closed SSA. */
7556 if (loops_state_satisfies_p (LOOP_CLOSED_SSA)
7557 && ! SSA_NAME_IS_DEFAULT_DEF (leader)
7558 && ! flow_bb_inside_loop_p (gimple_bb (SSA_NAME_DEF_STMT
7559 (leader))->loop_father,
7560 bb))
7561 return NULL_TREE;
7562 if (dump_file && (dump_flags & TDF_DETAILS))
7564 print_generic_expr (dump_file, leader);
7565 fprintf (dump_file, " is available for ");
7566 print_generic_expr (dump_file, valnum);
7567 fprintf (dump_file, "\n");
7569 /* On tramp3d 99% of the _remaining_ cases succeed at
7570 the first enty. */
7571 return leader;
7573 /* ??? Can we somehow skip to the immediate dominator
7574 RPO index (bb_to_rpo)? Again, maybe not worth, on
7575 tramp3d the worst number of elements in the vector is 9. */
7576 av = av->next;
7578 while (av);
7580 else if (valnum != VN_TOP)
7581 /* valnum is is_gimple_min_invariant. */
7582 return valnum;
7583 return NULL_TREE;
7586 /* Make LEADER a leader for its value at BB. */
7588 void
7589 rpo_elim::eliminate_push_avail (basic_block bb, tree leader)
7591 tree valnum = VN_INFO (leader)->valnum;
7592 if (valnum == VN_TOP
7593 || is_gimple_min_invariant (valnum))
7594 return;
7595 if (dump_file && (dump_flags & TDF_DETAILS))
7597 fprintf (dump_file, "Making available beyond BB%d ", bb->index);
7598 print_generic_expr (dump_file, leader);
7599 fprintf (dump_file, " for value ");
7600 print_generic_expr (dump_file, valnum);
7601 fprintf (dump_file, "\n");
7603 vn_ssa_aux_t value = VN_INFO (valnum);
7604 vn_avail *av;
7605 if (m_avail_freelist)
7607 av = m_avail_freelist;
7608 m_avail_freelist = m_avail_freelist->next;
7610 else
7611 av = XOBNEW (&vn_ssa_aux_obstack, vn_avail);
7612 av->location = bb->index;
7613 av->leader = SSA_NAME_VERSION (leader);
7614 av->next = value->avail;
7615 av->next_undo = last_pushed_avail;
7616 last_pushed_avail = value;
7617 value->avail = av;
7620 /* Valueization hook for RPO VN plus required state. */
7622 tree
7623 rpo_vn_valueize (tree name)
7625 if (TREE_CODE (name) == SSA_NAME)
7627 vn_ssa_aux_t val = VN_INFO (name);
7628 if (val)
7630 tree tem = val->valnum;
7631 if (tem != VN_TOP && tem != name)
7633 if (TREE_CODE (tem) != SSA_NAME)
7634 return tem;
7635 /* For all values we only valueize to an available leader
7636 which means we can use SSA name info without restriction. */
7637 tem = rpo_avail->eliminate_avail (vn_context_bb, tem);
7638 if (tem)
7639 return tem;
7643 return name;
7646 /* Insert on PRED_E predicates derived from CODE OPS being true besides the
7647 inverted condition. */
7649 static void
7650 insert_related_predicates_on_edge (enum tree_code code, tree *ops, edge pred_e)
7652 switch (code)
7654 case LT_EXPR:
7655 /* a < b -> a {!,<}= b */
7656 vn_nary_op_insert_pieces_predicated (2, NE_EXPR, boolean_type_node,
7657 ops, boolean_true_node, 0, pred_e);
7658 vn_nary_op_insert_pieces_predicated (2, LE_EXPR, boolean_type_node,
7659 ops, boolean_true_node, 0, pred_e);
7660 /* a < b -> ! a {>,=} b */
7661 vn_nary_op_insert_pieces_predicated (2, GT_EXPR, boolean_type_node,
7662 ops, boolean_false_node, 0, pred_e);
7663 vn_nary_op_insert_pieces_predicated (2, EQ_EXPR, boolean_type_node,
7664 ops, boolean_false_node, 0, pred_e);
7665 break;
7666 case GT_EXPR:
7667 /* a > b -> a {!,>}= b */
7668 vn_nary_op_insert_pieces_predicated (2, NE_EXPR, boolean_type_node,
7669 ops, boolean_true_node, 0, pred_e);
7670 vn_nary_op_insert_pieces_predicated (2, GE_EXPR, boolean_type_node,
7671 ops, boolean_true_node, 0, pred_e);
7672 /* a > b -> ! a {<,=} b */
7673 vn_nary_op_insert_pieces_predicated (2, LT_EXPR, boolean_type_node,
7674 ops, boolean_false_node, 0, pred_e);
7675 vn_nary_op_insert_pieces_predicated (2, EQ_EXPR, boolean_type_node,
7676 ops, boolean_false_node, 0, pred_e);
7677 break;
7678 case EQ_EXPR:
7679 /* a == b -> ! a {<,>} b */
7680 vn_nary_op_insert_pieces_predicated (2, LT_EXPR, boolean_type_node,
7681 ops, boolean_false_node, 0, pred_e);
7682 vn_nary_op_insert_pieces_predicated (2, GT_EXPR, boolean_type_node,
7683 ops, boolean_false_node, 0, pred_e);
7684 break;
7685 case LE_EXPR:
7686 case GE_EXPR:
7687 case NE_EXPR:
7688 /* Nothing besides inverted condition. */
7689 break;
7690 default:;
7694 /* Main stmt worker for RPO VN, process BB. */
7696 static unsigned
7697 process_bb (rpo_elim &avail, basic_block bb,
7698 bool bb_visited, bool iterate_phis, bool iterate, bool eliminate,
7699 bool do_region, bitmap exit_bbs, bool skip_phis)
7701 unsigned todo = 0;
7702 edge_iterator ei;
7703 edge e;
7705 vn_context_bb = bb;
7707 /* If we are in loop-closed SSA preserve this state. This is
7708 relevant when called on regions from outside of FRE/PRE. */
7709 bool lc_phi_nodes = false;
7710 if (!skip_phis
7711 && loops_state_satisfies_p (LOOP_CLOSED_SSA))
7712 FOR_EACH_EDGE (e, ei, bb->preds)
7713 if (e->src->loop_father != e->dest->loop_father
7714 && flow_loop_nested_p (e->dest->loop_father,
7715 e->src->loop_father))
7717 lc_phi_nodes = true;
7718 break;
7721 /* When we visit a loop header substitute into loop info. */
7722 if (!iterate && eliminate && bb->loop_father->header == bb)
7724 /* Keep fields in sync with substitute_in_loop_info. */
7725 if (bb->loop_father->nb_iterations)
7726 bb->loop_father->nb_iterations
7727 = simplify_replace_tree (bb->loop_father->nb_iterations,
7728 NULL_TREE, NULL_TREE, &vn_valueize_for_srt);
7731 /* Value-number all defs in the basic-block. */
7732 if (!skip_phis)
7733 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
7734 gsi_next (&gsi))
7736 gphi *phi = gsi.phi ();
7737 tree res = PHI_RESULT (phi);
7738 vn_ssa_aux_t res_info = VN_INFO (res);
7739 if (!bb_visited)
7741 gcc_assert (!res_info->visited);
7742 res_info->valnum = VN_TOP;
7743 res_info->visited = true;
7746 /* When not iterating force backedge values to varying. */
7747 visit_stmt (phi, !iterate_phis);
7748 if (virtual_operand_p (res))
7749 continue;
7751 /* Eliminate */
7752 /* The interesting case is gcc.dg/tree-ssa/pr22230.c for correctness
7753 how we handle backedges and availability.
7754 And gcc.dg/tree-ssa/ssa-sccvn-2.c for optimization. */
7755 tree val = res_info->valnum;
7756 if (res != val && !iterate && eliminate)
7758 if (tree leader = avail.eliminate_avail (bb, res))
7760 if (leader != res
7761 /* Preserve loop-closed SSA form. */
7762 && (! lc_phi_nodes
7763 || is_gimple_min_invariant (leader)))
7765 if (dump_file && (dump_flags & TDF_DETAILS))
7767 fprintf (dump_file, "Replaced redundant PHI node "
7768 "defining ");
7769 print_generic_expr (dump_file, res);
7770 fprintf (dump_file, " with ");
7771 print_generic_expr (dump_file, leader);
7772 fprintf (dump_file, "\n");
7774 avail.eliminations++;
7776 if (may_propagate_copy (res, leader))
7778 /* Schedule for removal. */
7779 avail.to_remove.safe_push (phi);
7780 continue;
7782 /* ??? Else generate a copy stmt. */
7786 /* Only make defs available that not already are. But make
7787 sure loop-closed SSA PHI node defs are picked up for
7788 downstream uses. */
7789 if (lc_phi_nodes
7790 || res == val
7791 || ! avail.eliminate_avail (bb, res))
7792 avail.eliminate_push_avail (bb, res);
7795 /* For empty BBs mark outgoing edges executable. For non-empty BBs
7796 we do this when processing the last stmt as we have to do this
7797 before elimination which otherwise forces GIMPLE_CONDs to
7798 if (1 != 0) style when seeing non-executable edges. */
7799 if (gsi_end_p (gsi_start_bb (bb)))
7801 FOR_EACH_EDGE (e, ei, bb->succs)
7803 if (!(e->flags & EDGE_EXECUTABLE))
7805 if (dump_file && (dump_flags & TDF_DETAILS))
7806 fprintf (dump_file,
7807 "marking outgoing edge %d -> %d executable\n",
7808 e->src->index, e->dest->index);
7809 e->flags |= EDGE_EXECUTABLE;
7810 e->dest->flags |= BB_EXECUTABLE;
7812 else if (!(e->dest->flags & BB_EXECUTABLE))
7814 if (dump_file && (dump_flags & TDF_DETAILS))
7815 fprintf (dump_file,
7816 "marking destination block %d reachable\n",
7817 e->dest->index);
7818 e->dest->flags |= BB_EXECUTABLE;
7822 for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
7823 !gsi_end_p (gsi); gsi_next (&gsi))
7825 ssa_op_iter i;
7826 tree op;
7827 if (!bb_visited)
7829 FOR_EACH_SSA_TREE_OPERAND (op, gsi_stmt (gsi), i, SSA_OP_ALL_DEFS)
7831 vn_ssa_aux_t op_info = VN_INFO (op);
7832 gcc_assert (!op_info->visited);
7833 op_info->valnum = VN_TOP;
7834 op_info->visited = true;
7837 /* We somehow have to deal with uses that are not defined
7838 in the processed region. Forcing unvisited uses to
7839 varying here doesn't play well with def-use following during
7840 expression simplification, so we deal with this by checking
7841 the visited flag in SSA_VAL. */
7844 visit_stmt (gsi_stmt (gsi));
7846 gimple *last = gsi_stmt (gsi);
7847 e = NULL;
7848 switch (gimple_code (last))
7850 case GIMPLE_SWITCH:
7851 e = find_taken_edge (bb, vn_valueize (gimple_switch_index
7852 (as_a <gswitch *> (last))));
7853 break;
7854 case GIMPLE_COND:
7856 tree lhs = vn_valueize (gimple_cond_lhs (last));
7857 tree rhs = vn_valueize (gimple_cond_rhs (last));
7858 tree val = gimple_simplify (gimple_cond_code (last),
7859 boolean_type_node, lhs, rhs,
7860 NULL, vn_valueize);
7861 /* If the condition didn't simplfy see if we have recorded
7862 an expression from sofar taken edges. */
7863 if (! val || TREE_CODE (val) != INTEGER_CST)
7865 vn_nary_op_t vnresult;
7866 tree ops[2];
7867 ops[0] = lhs;
7868 ops[1] = rhs;
7869 val = vn_nary_op_lookup_pieces (2, gimple_cond_code (last),
7870 boolean_type_node, ops,
7871 &vnresult);
7872 /* Did we get a predicated value? */
7873 if (! val && vnresult && vnresult->predicated_values)
7875 val = vn_nary_op_get_predicated_value (vnresult, bb);
7876 if (val && dump_file && (dump_flags & TDF_DETAILS))
7878 fprintf (dump_file, "Got predicated value ");
7879 print_generic_expr (dump_file, val, TDF_NONE);
7880 fprintf (dump_file, " for ");
7881 print_gimple_stmt (dump_file, last, TDF_SLIM);
7885 if (val)
7886 e = find_taken_edge (bb, val);
7887 if (! e)
7889 /* If we didn't manage to compute the taken edge then
7890 push predicated expressions for the condition itself
7891 and related conditions to the hashtables. This allows
7892 simplification of redundant conditions which is
7893 important as early cleanup. */
7894 edge true_e, false_e;
7895 extract_true_false_edges_from_block (bb, &true_e, &false_e);
7896 enum tree_code code = gimple_cond_code (last);
7897 enum tree_code icode
7898 = invert_tree_comparison (code, HONOR_NANS (lhs));
7899 tree ops[2];
7900 ops[0] = lhs;
7901 ops[1] = rhs;
7902 if (do_region
7903 && bitmap_bit_p (exit_bbs, true_e->dest->index))
7904 true_e = NULL;
7905 if (do_region
7906 && bitmap_bit_p (exit_bbs, false_e->dest->index))
7907 false_e = NULL;
7908 if (true_e)
7909 vn_nary_op_insert_pieces_predicated
7910 (2, code, boolean_type_node, ops,
7911 boolean_true_node, 0, true_e);
7912 if (false_e)
7913 vn_nary_op_insert_pieces_predicated
7914 (2, code, boolean_type_node, ops,
7915 boolean_false_node, 0, false_e);
7916 if (icode != ERROR_MARK)
7918 if (true_e)
7919 vn_nary_op_insert_pieces_predicated
7920 (2, icode, boolean_type_node, ops,
7921 boolean_false_node, 0, true_e);
7922 if (false_e)
7923 vn_nary_op_insert_pieces_predicated
7924 (2, icode, boolean_type_node, ops,
7925 boolean_true_node, 0, false_e);
7927 /* Relax for non-integers, inverted condition handled
7928 above. */
7929 if (INTEGRAL_TYPE_P (TREE_TYPE (lhs)))
7931 if (true_e)
7932 insert_related_predicates_on_edge (code, ops, true_e);
7933 if (false_e)
7934 insert_related_predicates_on_edge (icode, ops, false_e);
7937 break;
7939 case GIMPLE_GOTO:
7940 e = find_taken_edge (bb, vn_valueize (gimple_goto_dest (last)));
7941 break;
7942 default:
7943 e = NULL;
7945 if (e)
7947 todo = TODO_cleanup_cfg;
7948 if (!(e->flags & EDGE_EXECUTABLE))
7950 if (dump_file && (dump_flags & TDF_DETAILS))
7951 fprintf (dump_file,
7952 "marking known outgoing %sedge %d -> %d executable\n",
7953 e->flags & EDGE_DFS_BACK ? "back-" : "",
7954 e->src->index, e->dest->index);
7955 e->flags |= EDGE_EXECUTABLE;
7956 e->dest->flags |= BB_EXECUTABLE;
7958 else if (!(e->dest->flags & BB_EXECUTABLE))
7960 if (dump_file && (dump_flags & TDF_DETAILS))
7961 fprintf (dump_file,
7962 "marking destination block %d reachable\n",
7963 e->dest->index);
7964 e->dest->flags |= BB_EXECUTABLE;
7967 else if (gsi_one_before_end_p (gsi))
7969 FOR_EACH_EDGE (e, ei, bb->succs)
7971 if (!(e->flags & EDGE_EXECUTABLE))
7973 if (dump_file && (dump_flags & TDF_DETAILS))
7974 fprintf (dump_file,
7975 "marking outgoing edge %d -> %d executable\n",
7976 e->src->index, e->dest->index);
7977 e->flags |= EDGE_EXECUTABLE;
7978 e->dest->flags |= BB_EXECUTABLE;
7980 else if (!(e->dest->flags & BB_EXECUTABLE))
7982 if (dump_file && (dump_flags & TDF_DETAILS))
7983 fprintf (dump_file,
7984 "marking destination block %d reachable\n",
7985 e->dest->index);
7986 e->dest->flags |= BB_EXECUTABLE;
7991 /* Eliminate. That also pushes to avail. */
7992 if (eliminate && ! iterate)
7993 avail.eliminate_stmt (bb, &gsi);
7994 else
7995 /* If not eliminating, make all not already available defs
7996 available. */
7997 FOR_EACH_SSA_TREE_OPERAND (op, gsi_stmt (gsi), i, SSA_OP_DEF)
7998 if (! avail.eliminate_avail (bb, op))
7999 avail.eliminate_push_avail (bb, op);
8002 /* Eliminate in destination PHI arguments. Always substitute in dest
8003 PHIs, even for non-executable edges. This handles region
8004 exits PHIs. */
8005 if (!iterate && eliminate)
8006 FOR_EACH_EDGE (e, ei, bb->succs)
8007 for (gphi_iterator gsi = gsi_start_phis (e->dest);
8008 !gsi_end_p (gsi); gsi_next (&gsi))
8010 gphi *phi = gsi.phi ();
8011 use_operand_p use_p = PHI_ARG_DEF_PTR_FROM_EDGE (phi, e);
8012 tree arg = USE_FROM_PTR (use_p);
8013 if (TREE_CODE (arg) != SSA_NAME
8014 || virtual_operand_p (arg))
8015 continue;
8016 tree sprime;
8017 if (SSA_NAME_IS_DEFAULT_DEF (arg))
8019 sprime = SSA_VAL (arg);
8020 gcc_assert (TREE_CODE (sprime) != SSA_NAME
8021 || SSA_NAME_IS_DEFAULT_DEF (sprime));
8023 else
8024 /* Look for sth available at the definition block of the argument.
8025 This avoids inconsistencies between availability there which
8026 decides if the stmt can be removed and availability at the
8027 use site. The SSA property ensures that things available
8028 at the definition are also available at uses. */
8029 sprime = avail.eliminate_avail (gimple_bb (SSA_NAME_DEF_STMT (arg)),
8030 arg);
8031 if (sprime
8032 && sprime != arg
8033 && may_propagate_copy (arg, sprime))
8034 propagate_value (use_p, sprime);
8037 vn_context_bb = NULL;
8038 return todo;
8041 /* Unwind state per basic-block. */
8043 struct unwind_state
8045 /* Times this block has been visited. */
8046 unsigned visited;
8047 /* Whether to handle this as iteration point or whether to treat
8048 incoming backedge PHI values as varying. */
8049 bool iterate;
8050 /* Maximum RPO index this block is reachable from. */
8051 int max_rpo;
8052 /* Unwind state. */
8053 void *ob_top;
8054 vn_reference_t ref_top;
8055 vn_phi_t phi_top;
8056 vn_nary_op_t nary_top;
8057 vn_avail *avail_top;
8060 /* Unwind the RPO VN state for iteration. */
8062 static void
8063 do_unwind (unwind_state *to, rpo_elim &avail)
8065 gcc_assert (to->iterate);
8066 for (; last_inserted_nary != to->nary_top;
8067 last_inserted_nary = last_inserted_nary->next)
8069 vn_nary_op_t *slot;
8070 slot = valid_info->nary->find_slot_with_hash
8071 (last_inserted_nary, last_inserted_nary->hashcode, NO_INSERT);
8072 /* Predication causes the need to restore previous state. */
8073 if ((*slot)->unwind_to)
8074 *slot = (*slot)->unwind_to;
8075 else
8076 valid_info->nary->clear_slot (slot);
8078 for (; last_inserted_phi != to->phi_top;
8079 last_inserted_phi = last_inserted_phi->next)
8081 vn_phi_t *slot;
8082 slot = valid_info->phis->find_slot_with_hash
8083 (last_inserted_phi, last_inserted_phi->hashcode, NO_INSERT);
8084 valid_info->phis->clear_slot (slot);
8086 for (; last_inserted_ref != to->ref_top;
8087 last_inserted_ref = last_inserted_ref->next)
8089 vn_reference_t *slot;
8090 slot = valid_info->references->find_slot_with_hash
8091 (last_inserted_ref, last_inserted_ref->hashcode, NO_INSERT);
8092 (*slot)->operands.release ();
8093 valid_info->references->clear_slot (slot);
8095 obstack_free (&vn_tables_obstack, to->ob_top);
8097 /* Prune [rpo_idx, ] from avail. */
8098 for (; last_pushed_avail && last_pushed_avail->avail != to->avail_top;)
8100 vn_ssa_aux_t val = last_pushed_avail;
8101 vn_avail *av = val->avail;
8102 val->avail = av->next;
8103 last_pushed_avail = av->next_undo;
8104 av->next = avail.m_avail_freelist;
8105 avail.m_avail_freelist = av;
8109 /* Do VN on a SEME region specified by ENTRY and EXIT_BBS in FN.
8110 If ITERATE is true then treat backedges optimistically as not
8111 executed and iterate. If ELIMINATE is true then perform
8112 elimination, otherwise leave that to the caller. */
8114 static unsigned
8115 do_rpo_vn_1 (function *fn, edge entry, bitmap exit_bbs,
8116 bool iterate, bool eliminate, vn_lookup_kind kind)
8118 unsigned todo = 0;
8119 default_vn_walk_kind = kind;
8121 /* We currently do not support region-based iteration when
8122 elimination is requested. */
8123 gcc_assert (!entry || !iterate || !eliminate);
8124 /* When iterating we need loop info up-to-date. */
8125 gcc_assert (!iterate || !loops_state_satisfies_p (LOOPS_NEED_FIXUP));
8127 bool do_region = entry != NULL;
8128 if (!do_region)
8130 entry = single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (fn));
8131 exit_bbs = BITMAP_ALLOC (NULL);
8132 bitmap_set_bit (exit_bbs, EXIT_BLOCK);
8135 /* Clear EDGE_DFS_BACK on "all" entry edges, RPO order compute will
8136 re-mark those that are contained in the region. */
8137 edge_iterator ei;
8138 edge e;
8139 FOR_EACH_EDGE (e, ei, entry->dest->preds)
8140 e->flags &= ~EDGE_DFS_BACK;
8142 int *rpo = XNEWVEC (int, n_basic_blocks_for_fn (fn) - NUM_FIXED_BLOCKS);
8143 auto_vec<std::pair<int, int> > toplevel_scc_extents;
8144 int n = rev_post_order_and_mark_dfs_back_seme
8145 (fn, entry, exit_bbs, true, rpo, !iterate ? &toplevel_scc_extents : NULL);
8147 if (!do_region)
8148 BITMAP_FREE (exit_bbs);
8150 /* If there are any non-DFS_BACK edges into entry->dest skip
8151 processing PHI nodes for that block. This supports
8152 value-numbering loop bodies w/o the actual loop. */
8153 FOR_EACH_EDGE (e, ei, entry->dest->preds)
8154 if (e != entry
8155 && !(e->flags & EDGE_DFS_BACK))
8156 break;
8157 bool skip_entry_phis = e != NULL;
8158 if (skip_entry_phis && dump_file && (dump_flags & TDF_DETAILS))
8159 fprintf (dump_file, "Region does not contain all edges into "
8160 "the entry block, skipping its PHIs.\n");
8162 int *bb_to_rpo = XNEWVEC (int, last_basic_block_for_fn (fn));
8163 for (int i = 0; i < n; ++i)
8164 bb_to_rpo[rpo[i]] = i;
8166 unwind_state *rpo_state = XNEWVEC (unwind_state, n);
8168 rpo_elim avail (entry->dest);
8169 rpo_avail = &avail;
8171 /* Verify we have no extra entries into the region. */
8172 if (flag_checking && do_region)
8174 auto_bb_flag bb_in_region (fn);
8175 for (int i = 0; i < n; ++i)
8177 basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[i]);
8178 bb->flags |= bb_in_region;
8180 /* We can't merge the first two loops because we cannot rely
8181 on EDGE_DFS_BACK for edges not within the region. But if
8182 we decide to always have the bb_in_region flag we can
8183 do the checking during the RPO walk itself (but then it's
8184 also easy to handle MEME conservatively). */
8185 for (int i = 0; i < n; ++i)
8187 basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[i]);
8188 edge e;
8189 edge_iterator ei;
8190 FOR_EACH_EDGE (e, ei, bb->preds)
8191 gcc_assert (e == entry
8192 || (skip_entry_phis && bb == entry->dest)
8193 || (e->src->flags & bb_in_region));
8195 for (int i = 0; i < n; ++i)
8197 basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[i]);
8198 bb->flags &= ~bb_in_region;
8202 /* Create the VN state. For the initial size of the various hashtables
8203 use a heuristic based on region size and number of SSA names. */
8204 unsigned region_size = (((unsigned HOST_WIDE_INT)n * num_ssa_names)
8205 / (n_basic_blocks_for_fn (fn) - NUM_FIXED_BLOCKS));
8206 VN_TOP = create_tmp_var_raw (void_type_node, "vn_top");
8207 next_value_id = 1;
8208 next_constant_value_id = -1;
8210 vn_ssa_aux_hash = new hash_table <vn_ssa_aux_hasher> (region_size * 2);
8211 gcc_obstack_init (&vn_ssa_aux_obstack);
8213 gcc_obstack_init (&vn_tables_obstack);
8214 gcc_obstack_init (&vn_tables_insert_obstack);
8215 valid_info = XCNEW (struct vn_tables_s);
8216 allocate_vn_table (valid_info, region_size);
8217 last_inserted_ref = NULL;
8218 last_inserted_phi = NULL;
8219 last_inserted_nary = NULL;
8220 last_pushed_avail = NULL;
8222 vn_valueize = rpo_vn_valueize;
8224 /* Initialize the unwind state and edge/BB executable state. */
8225 unsigned curr_scc = 0;
8226 for (int i = 0; i < n; ++i)
8228 basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[i]);
8229 rpo_state[i].visited = 0;
8230 rpo_state[i].max_rpo = i;
8231 if (!iterate && curr_scc < toplevel_scc_extents.length ())
8233 if (i >= toplevel_scc_extents[curr_scc].first
8234 && i <= toplevel_scc_extents[curr_scc].second)
8235 rpo_state[i].max_rpo = toplevel_scc_extents[curr_scc].second;
8236 if (i == toplevel_scc_extents[curr_scc].second)
8237 curr_scc++;
8239 bb->flags &= ~BB_EXECUTABLE;
8240 bool has_backedges = false;
8241 edge e;
8242 edge_iterator ei;
8243 FOR_EACH_EDGE (e, ei, bb->preds)
8245 if (e->flags & EDGE_DFS_BACK)
8246 has_backedges = true;
8247 e->flags &= ~EDGE_EXECUTABLE;
8248 if (iterate || e == entry || (skip_entry_phis && bb == entry->dest))
8249 continue;
8251 rpo_state[i].iterate = iterate && has_backedges;
8253 entry->flags |= EDGE_EXECUTABLE;
8254 entry->dest->flags |= BB_EXECUTABLE;
8256 /* As heuristic to improve compile-time we handle only the N innermost
8257 loops and the outermost one optimistically. */
8258 if (iterate)
8260 unsigned max_depth = param_rpo_vn_max_loop_depth;
8261 for (auto loop : loops_list (cfun, LI_ONLY_INNERMOST))
8262 if (loop_depth (loop) > max_depth)
8263 for (unsigned i = 2;
8264 i < loop_depth (loop) - max_depth; ++i)
8266 basic_block header = superloop_at_depth (loop, i)->header;
8267 bool non_latch_backedge = false;
8268 edge e;
8269 edge_iterator ei;
8270 FOR_EACH_EDGE (e, ei, header->preds)
8271 if (e->flags & EDGE_DFS_BACK)
8273 /* There can be a non-latch backedge into the header
8274 which is part of an outer irreducible region. We
8275 cannot avoid iterating this block then. */
8276 if (!dominated_by_p (CDI_DOMINATORS,
8277 e->src, e->dest))
8279 if (dump_file && (dump_flags & TDF_DETAILS))
8280 fprintf (dump_file, "non-latch backedge %d -> %d "
8281 "forces iteration of loop %d\n",
8282 e->src->index, e->dest->index, loop->num);
8283 non_latch_backedge = true;
8285 else
8286 e->flags |= EDGE_EXECUTABLE;
8288 rpo_state[bb_to_rpo[header->index]].iterate = non_latch_backedge;
8292 uint64_t nblk = 0;
8293 int idx = 0;
8294 if (iterate)
8295 /* Go and process all blocks, iterating as necessary. */
8298 basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[idx]);
8300 /* If the block has incoming backedges remember unwind state. This
8301 is required even for non-executable blocks since in irreducible
8302 regions we might reach them via the backedge and re-start iterating
8303 from there.
8304 Note we can individually mark blocks with incoming backedges to
8305 not iterate where we then handle PHIs conservatively. We do that
8306 heuristically to reduce compile-time for degenerate cases. */
8307 if (rpo_state[idx].iterate)
8309 rpo_state[idx].ob_top = obstack_alloc (&vn_tables_obstack, 0);
8310 rpo_state[idx].ref_top = last_inserted_ref;
8311 rpo_state[idx].phi_top = last_inserted_phi;
8312 rpo_state[idx].nary_top = last_inserted_nary;
8313 rpo_state[idx].avail_top
8314 = last_pushed_avail ? last_pushed_avail->avail : NULL;
8317 if (!(bb->flags & BB_EXECUTABLE))
8319 if (dump_file && (dump_flags & TDF_DETAILS))
8320 fprintf (dump_file, "Block %d: BB%d found not executable\n",
8321 idx, bb->index);
8322 idx++;
8323 continue;
8326 if (dump_file && (dump_flags & TDF_DETAILS))
8327 fprintf (dump_file, "Processing block %d: BB%d\n", idx, bb->index);
8328 nblk++;
8329 todo |= process_bb (avail, bb,
8330 rpo_state[idx].visited != 0,
8331 rpo_state[idx].iterate,
8332 iterate, eliminate, do_region, exit_bbs, false);
8333 rpo_state[idx].visited++;
8335 /* Verify if changed values flow over executable outgoing backedges
8336 and those change destination PHI values (that's the thing we
8337 can easily verify). Reduce over all such edges to the farthest
8338 away PHI. */
8339 int iterate_to = -1;
8340 edge_iterator ei;
8341 edge e;
8342 FOR_EACH_EDGE (e, ei, bb->succs)
8343 if ((e->flags & (EDGE_DFS_BACK|EDGE_EXECUTABLE))
8344 == (EDGE_DFS_BACK|EDGE_EXECUTABLE)
8345 && rpo_state[bb_to_rpo[e->dest->index]].iterate)
8347 int destidx = bb_to_rpo[e->dest->index];
8348 if (!rpo_state[destidx].visited)
8350 if (dump_file && (dump_flags & TDF_DETAILS))
8351 fprintf (dump_file, "Unvisited destination %d\n",
8352 e->dest->index);
8353 if (iterate_to == -1 || destidx < iterate_to)
8354 iterate_to = destidx;
8355 continue;
8357 if (dump_file && (dump_flags & TDF_DETAILS))
8358 fprintf (dump_file, "Looking for changed values of backedge"
8359 " %d->%d destination PHIs\n",
8360 e->src->index, e->dest->index);
8361 vn_context_bb = e->dest;
8362 gphi_iterator gsi;
8363 for (gsi = gsi_start_phis (e->dest);
8364 !gsi_end_p (gsi); gsi_next (&gsi))
8366 bool inserted = false;
8367 /* While we'd ideally just iterate on value changes
8368 we CSE PHIs and do that even across basic-block
8369 boundaries. So even hashtable state changes can
8370 be important (which is roughly equivalent to
8371 PHI argument value changes). To not excessively
8372 iterate because of that we track whether a PHI
8373 was CSEd to with GF_PLF_1. */
8374 bool phival_changed;
8375 if ((phival_changed = visit_phi (gsi.phi (),
8376 &inserted, false))
8377 || (inserted && gimple_plf (gsi.phi (), GF_PLF_1)))
8379 if (!phival_changed
8380 && dump_file && (dump_flags & TDF_DETAILS))
8381 fprintf (dump_file, "PHI was CSEd and hashtable "
8382 "state (changed)\n");
8383 if (iterate_to == -1 || destidx < iterate_to)
8384 iterate_to = destidx;
8385 break;
8388 vn_context_bb = NULL;
8390 if (iterate_to != -1)
8392 do_unwind (&rpo_state[iterate_to], avail);
8393 idx = iterate_to;
8394 if (dump_file && (dump_flags & TDF_DETAILS))
8395 fprintf (dump_file, "Iterating to %d BB%d\n",
8396 iterate_to, rpo[iterate_to]);
8397 continue;
8400 idx++;
8402 while (idx < n);
8404 else /* !iterate */
8406 /* Process all blocks greedily with a worklist that enforces RPO
8407 processing of reachable blocks. */
8408 auto_bitmap worklist;
8409 bitmap_set_bit (worklist, 0);
8410 while (!bitmap_empty_p (worklist))
8412 int idx = bitmap_first_set_bit (worklist);
8413 bitmap_clear_bit (worklist, idx);
8414 basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[idx]);
8415 gcc_assert ((bb->flags & BB_EXECUTABLE)
8416 && !rpo_state[idx].visited);
8418 if (dump_file && (dump_flags & TDF_DETAILS))
8419 fprintf (dump_file, "Processing block %d: BB%d\n", idx, bb->index);
8421 /* When we run into predecessor edges where we cannot trust its
8422 executable state mark them executable so PHI processing will
8423 be conservative.
8424 ??? Do we need to force arguments flowing over that edge
8425 to be varying or will they even always be? */
8426 edge_iterator ei;
8427 edge e;
8428 FOR_EACH_EDGE (e, ei, bb->preds)
8429 if (!(e->flags & EDGE_EXECUTABLE)
8430 && (bb == entry->dest
8431 || (!rpo_state[bb_to_rpo[e->src->index]].visited
8432 && (rpo_state[bb_to_rpo[e->src->index]].max_rpo
8433 >= (int)idx))))
8435 if (dump_file && (dump_flags & TDF_DETAILS))
8436 fprintf (dump_file, "Cannot trust state of predecessor "
8437 "edge %d -> %d, marking executable\n",
8438 e->src->index, e->dest->index);
8439 e->flags |= EDGE_EXECUTABLE;
8442 nblk++;
8443 todo |= process_bb (avail, bb, false, false, false, eliminate,
8444 do_region, exit_bbs,
8445 skip_entry_phis && bb == entry->dest);
8446 rpo_state[idx].visited++;
8448 FOR_EACH_EDGE (e, ei, bb->succs)
8449 if ((e->flags & EDGE_EXECUTABLE)
8450 && e->dest->index != EXIT_BLOCK
8451 && (!do_region || !bitmap_bit_p (exit_bbs, e->dest->index))
8452 && !rpo_state[bb_to_rpo[e->dest->index]].visited)
8453 bitmap_set_bit (worklist, bb_to_rpo[e->dest->index]);
8457 /* If statistics or dump file active. */
8458 int nex = 0;
8459 unsigned max_visited = 1;
8460 for (int i = 0; i < n; ++i)
8462 basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[i]);
8463 if (bb->flags & BB_EXECUTABLE)
8464 nex++;
8465 statistics_histogram_event (cfun, "RPO block visited times",
8466 rpo_state[i].visited);
8467 if (rpo_state[i].visited > max_visited)
8468 max_visited = rpo_state[i].visited;
8470 unsigned nvalues = 0, navail = 0;
8471 for (hash_table<vn_ssa_aux_hasher>::iterator i = vn_ssa_aux_hash->begin ();
8472 i != vn_ssa_aux_hash->end (); ++i)
8474 nvalues++;
8475 vn_avail *av = (*i)->avail;
8476 while (av)
8478 navail++;
8479 av = av->next;
8482 statistics_counter_event (cfun, "RPO blocks", n);
8483 statistics_counter_event (cfun, "RPO blocks visited", nblk);
8484 statistics_counter_event (cfun, "RPO blocks executable", nex);
8485 statistics_histogram_event (cfun, "RPO iterations", 10*nblk / nex);
8486 statistics_histogram_event (cfun, "RPO num values", nvalues);
8487 statistics_histogram_event (cfun, "RPO num avail", navail);
8488 statistics_histogram_event (cfun, "RPO num lattice",
8489 vn_ssa_aux_hash->elements ());
8490 if (dump_file && (dump_flags & (TDF_DETAILS|TDF_STATS)))
8492 fprintf (dump_file, "RPO iteration over %d blocks visited %" PRIu64
8493 " blocks in total discovering %d executable blocks iterating "
8494 "%d.%d times, a block was visited max. %u times\n",
8495 n, nblk, nex,
8496 (int)((10*nblk / nex)/10), (int)((10*nblk / nex)%10),
8497 max_visited);
8498 fprintf (dump_file, "RPO tracked %d values available at %d locations "
8499 "and %" PRIu64 " lattice elements\n",
8500 nvalues, navail, (uint64_t) vn_ssa_aux_hash->elements ());
8503 if (eliminate)
8505 /* When !iterate we already performed elimination during the RPO
8506 walk. */
8507 if (iterate)
8509 /* Elimination for region-based VN needs to be done within the
8510 RPO walk. */
8511 gcc_assert (! do_region);
8512 /* Note we can't use avail.walk here because that gets confused
8513 by the existing availability and it will be less efficient
8514 as well. */
8515 todo |= eliminate_with_rpo_vn (NULL);
8517 else
8518 todo |= avail.eliminate_cleanup (do_region);
8521 vn_valueize = NULL;
8522 rpo_avail = NULL;
8524 XDELETEVEC (bb_to_rpo);
8525 XDELETEVEC (rpo);
8526 XDELETEVEC (rpo_state);
8528 return todo;
8531 /* Region-based entry for RPO VN. Performs value-numbering and elimination
8532 on the SEME region specified by ENTRY and EXIT_BBS. If ENTRY is not
8533 the only edge into the region at ENTRY->dest PHI nodes in ENTRY->dest
8534 are not considered.
8535 If ITERATE is true then treat backedges optimistically as not
8536 executed and iterate. If ELIMINATE is true then perform
8537 elimination, otherwise leave that to the caller.
8538 KIND specifies the amount of work done for handling memory operations. */
8540 unsigned
8541 do_rpo_vn (function *fn, edge entry, bitmap exit_bbs,
8542 bool iterate, bool eliminate, vn_lookup_kind kind)
8544 auto_timevar tv (TV_TREE_RPO_VN);
8545 unsigned todo = do_rpo_vn_1 (fn, entry, exit_bbs, iterate, eliminate, kind);
8546 free_rpo_vn ();
8547 return todo;
8551 namespace {
8553 const pass_data pass_data_fre =
8555 GIMPLE_PASS, /* type */
8556 "fre", /* name */
8557 OPTGROUP_NONE, /* optinfo_flags */
8558 TV_TREE_FRE, /* tv_id */
8559 ( PROP_cfg | PROP_ssa ), /* properties_required */
8560 0, /* properties_provided */
8561 0, /* properties_destroyed */
8562 0, /* todo_flags_start */
8563 0, /* todo_flags_finish */
8566 class pass_fre : public gimple_opt_pass
8568 public:
8569 pass_fre (gcc::context *ctxt)
8570 : gimple_opt_pass (pass_data_fre, ctxt), may_iterate (true)
8573 /* opt_pass methods: */
8574 opt_pass * clone () final override { return new pass_fre (m_ctxt); }
8575 void set_pass_param (unsigned int n, bool param) final override
8577 gcc_assert (n == 0);
8578 may_iterate = param;
8580 bool gate (function *) final override
8582 return flag_tree_fre != 0 && (may_iterate || optimize > 1);
8584 unsigned int execute (function *) final override;
8586 private:
8587 bool may_iterate;
8588 }; // class pass_fre
8590 unsigned int
8591 pass_fre::execute (function *fun)
8593 unsigned todo = 0;
8595 /* At -O[1g] use the cheap non-iterating mode. */
8596 bool iterate_p = may_iterate && (optimize > 1);
8597 calculate_dominance_info (CDI_DOMINATORS);
8598 if (iterate_p)
8599 loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
8601 todo = do_rpo_vn_1 (fun, NULL, NULL, iterate_p, true, VN_WALKREWRITE);
8602 free_rpo_vn ();
8604 if (iterate_p)
8605 loop_optimizer_finalize ();
8607 if (scev_initialized_p ())
8608 scev_reset_htab ();
8610 /* For late FRE after IVOPTs and unrolling, see if we can
8611 remove some TREE_ADDRESSABLE and rewrite stuff into SSA. */
8612 if (!may_iterate)
8613 todo |= TODO_update_address_taken;
8615 return todo;
8618 } // anon namespace
8620 gimple_opt_pass *
8621 make_pass_fre (gcc::context *ctxt)
8623 return new pass_fre (ctxt);
8626 #undef BB_EXECUTABLE