1 /* SCC value numbering for trees
2 Copyright (C) 2006-2023 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)
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/>. */
23 #include "coretypes.h"
24 #include "splay-tree.h"
31 #include "insn-config.h"
35 #include "gimple-pretty-print.h"
37 #include "fold-const.h"
38 #include "stor-layout.h"
40 #include "tree-inline.h"
41 #include "internal-fn.h"
42 #include "gimple-iterator.h"
43 #include "gimple-fold.h"
57 #include "tree-ssa-propagate.h"
60 #include "gimple-match.h"
61 #include "stringpool.h"
63 #include "tree-pass.h"
64 #include "statistics.h"
65 #include "langhooks.h"
66 #include "ipa-utils.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"
73 #include "fold-const-call.h"
74 #include "ipa-modref-tree.h"
75 #include "ipa-modref.h"
76 #include "tree-ssa-sccvn.h"
77 #include "alloc-pool.h"
78 #include "symbol-summary.h"
82 /* This algorithm is based on the SCC algorithm presented by Keith
83 Cooper and L. Taylor Simpson in "SCC-Based Value numbering"
84 (http://citeseer.ist.psu.edu/41805.html). In
85 straight line code, it is equivalent to a regular hash based value
86 numbering that is performed in reverse postorder.
88 For code with cycles, there are two alternatives, both of which
89 require keeping the hashtables separate from the actual list of
90 value numbers for SSA names.
92 1. Iterate value numbering in an RPO walk of the blocks, removing
93 all the entries from the hashtable after each iteration (but
94 keeping the SSA name->value number mapping between iterations).
95 Iterate until it does not change.
97 2. Perform value numbering as part of an SCC walk on the SSA graph,
98 iterating only the cycles in the SSA graph until they do not change
99 (using a separate, optimistic hashtable for value numbering the SCC
102 The second is not just faster in practice (because most SSA graph
103 cycles do not involve all the variables in the graph), it also has
104 some nice properties.
106 One of these nice properties is that when we pop an SCC off the
107 stack, we are guaranteed to have processed all the operands coming from
108 *outside of that SCC*, so we do not need to do anything special to
109 ensure they have value numbers.
111 Another nice property is that the SCC walk is done as part of a DFS
112 of the SSA graph, which makes it easy to perform combining and
113 simplifying operations at the same time.
115 The code below is deliberately written in a way that makes it easy
116 to separate the SCC walk from the other work it does.
118 In order to propagate constants through the code, we track which
119 expressions contain constants, and use those while folding. In
120 theory, we could also track expressions whose value numbers are
121 replaced, in case we end up folding based on expression
124 In order to value number memory, we assign value numbers to vuses.
125 This enables us to note that, for example, stores to the same
126 address of the same value from the same starting memory states are
130 1. We can iterate only the changing portions of the SCC's, but
131 I have not seen an SCC big enough for this to be a win.
132 2. If you differentiate between phi nodes for loops and phi nodes
133 for if-then-else, you can properly consider phi nodes in different
134 blocks for equivalence.
135 3. We could value number vuses in more cases, particularly, whole
139 /* There's no BB_EXECUTABLE but we can use BB_VISITED. */
140 #define BB_EXECUTABLE BB_VISITED
142 static vn_lookup_kind default_vn_walk_kind
;
144 /* vn_nary_op hashtable helpers. */
146 struct vn_nary_op_hasher
: nofree_ptr_hash
<vn_nary_op_s
>
148 typedef vn_nary_op_s
*compare_type
;
149 static inline hashval_t
hash (const vn_nary_op_s
*);
150 static inline bool equal (const vn_nary_op_s
*, const vn_nary_op_s
*);
153 /* Return the computed hashcode for nary operation P1. */
156 vn_nary_op_hasher::hash (const vn_nary_op_s
*vno1
)
158 return vno1
->hashcode
;
161 /* Compare nary operations P1 and P2 and return true if they are
165 vn_nary_op_hasher::equal (const vn_nary_op_s
*vno1
, const vn_nary_op_s
*vno2
)
167 return vno1
== vno2
|| vn_nary_op_eq (vno1
, vno2
);
170 typedef hash_table
<vn_nary_op_hasher
> vn_nary_op_table_type
;
171 typedef vn_nary_op_table_type::iterator vn_nary_op_iterator_type
;
174 /* vn_phi hashtable helpers. */
177 vn_phi_eq (const_vn_phi_t
const vp1
, const_vn_phi_t
const vp2
);
179 struct vn_phi_hasher
: nofree_ptr_hash
<vn_phi_s
>
181 static inline hashval_t
hash (const vn_phi_s
*);
182 static inline bool equal (const vn_phi_s
*, const vn_phi_s
*);
185 /* Return the computed hashcode for phi operation P1. */
188 vn_phi_hasher::hash (const vn_phi_s
*vp1
)
190 return vp1
->hashcode
;
193 /* Compare two phi entries for equality, ignoring VN_TOP arguments. */
196 vn_phi_hasher::equal (const vn_phi_s
*vp1
, const vn_phi_s
*vp2
)
198 return vp1
== vp2
|| vn_phi_eq (vp1
, vp2
);
201 typedef hash_table
<vn_phi_hasher
> vn_phi_table_type
;
202 typedef vn_phi_table_type::iterator vn_phi_iterator_type
;
205 /* Compare two reference operands P1 and P2 for equality. Return true if
206 they are equal, and false otherwise. */
209 vn_reference_op_eq (const void *p1
, const void *p2
)
211 const_vn_reference_op_t
const vro1
= (const_vn_reference_op_t
) p1
;
212 const_vn_reference_op_t
const vro2
= (const_vn_reference_op_t
) p2
;
214 return (vro1
->opcode
== vro2
->opcode
215 /* We do not care for differences in type qualification. */
216 && (vro1
->type
== vro2
->type
217 || (vro1
->type
&& vro2
->type
218 && types_compatible_p (TYPE_MAIN_VARIANT (vro1
->type
),
219 TYPE_MAIN_VARIANT (vro2
->type
))))
220 && expressions_equal_p (vro1
->op0
, vro2
->op0
)
221 && expressions_equal_p (vro1
->op1
, vro2
->op1
)
222 && expressions_equal_p (vro1
->op2
, vro2
->op2
)
223 && (vro1
->opcode
!= CALL_EXPR
|| vro1
->clique
== vro2
->clique
));
226 /* Free a reference operation structure VP. */
229 free_reference (vn_reference_s
*vr
)
231 vr
->operands
.release ();
235 /* vn_reference hashtable helpers. */
237 struct vn_reference_hasher
: nofree_ptr_hash
<vn_reference_s
>
239 static inline hashval_t
hash (const vn_reference_s
*);
240 static inline bool equal (const vn_reference_s
*, const vn_reference_s
*);
243 /* Return the hashcode for a given reference operation P1. */
246 vn_reference_hasher::hash (const vn_reference_s
*vr1
)
248 return vr1
->hashcode
;
252 vn_reference_hasher::equal (const vn_reference_s
*v
, const vn_reference_s
*c
)
254 return v
== c
|| vn_reference_eq (v
, c
);
257 typedef hash_table
<vn_reference_hasher
> vn_reference_table_type
;
258 typedef vn_reference_table_type::iterator vn_reference_iterator_type
;
260 /* Pretty-print OPS to OUTFILE. */
263 print_vn_reference_ops (FILE *outfile
, const vec
<vn_reference_op_s
> ops
)
265 vn_reference_op_t vro
;
267 fprintf (outfile
, "{");
268 for (i
= 0; ops
.iterate (i
, &vro
); i
++)
270 bool closebrace
= false;
271 if (vro
->opcode
!= SSA_NAME
272 && TREE_CODE_CLASS (vro
->opcode
) != tcc_declaration
)
274 fprintf (outfile
, "%s", get_tree_code_name (vro
->opcode
));
275 if (vro
->op0
|| vro
->opcode
== CALL_EXPR
)
277 fprintf (outfile
, "<");
281 if (vro
->op0
|| vro
->opcode
== CALL_EXPR
)
284 fprintf (outfile
, internal_fn_name ((internal_fn
)vro
->clique
));
286 print_generic_expr (outfile
, vro
->op0
);
289 fprintf (outfile
, ",");
290 print_generic_expr (outfile
, vro
->op1
);
294 fprintf (outfile
, ",");
295 print_generic_expr (outfile
, vro
->op2
);
299 fprintf (outfile
, ">");
300 if (i
!= ops
.length () - 1)
301 fprintf (outfile
, ",");
303 fprintf (outfile
, "}");
307 debug_vn_reference_ops (const vec
<vn_reference_op_s
> ops
)
309 print_vn_reference_ops (stderr
, ops
);
310 fputc ('\n', stderr
);
313 /* The set of VN hashtables. */
315 typedef struct vn_tables_s
317 vn_nary_op_table_type
*nary
;
318 vn_phi_table_type
*phis
;
319 vn_reference_table_type
*references
;
323 /* vn_constant hashtable helpers. */
325 struct vn_constant_hasher
: free_ptr_hash
<vn_constant_s
>
327 static inline hashval_t
hash (const vn_constant_s
*);
328 static inline bool equal (const vn_constant_s
*, const vn_constant_s
*);
331 /* Hash table hash function for vn_constant_t. */
334 vn_constant_hasher::hash (const vn_constant_s
*vc1
)
336 return vc1
->hashcode
;
339 /* Hash table equality function for vn_constant_t. */
342 vn_constant_hasher::equal (const vn_constant_s
*vc1
, const vn_constant_s
*vc2
)
344 if (vc1
->hashcode
!= vc2
->hashcode
)
347 return vn_constant_eq_with_type (vc1
->constant
, vc2
->constant
);
350 static hash_table
<vn_constant_hasher
> *constant_to_value_id
;
353 /* Obstack we allocate the vn-tables elements from. */
354 static obstack vn_tables_obstack
;
355 /* Special obstack we never unwind. */
356 static obstack vn_tables_insert_obstack
;
358 static vn_reference_t last_inserted_ref
;
359 static vn_phi_t last_inserted_phi
;
360 static vn_nary_op_t last_inserted_nary
;
361 static vn_ssa_aux_t last_pushed_avail
;
363 /* Valid hashtables storing information we have proven to be
365 static vn_tables_t valid_info
;
368 /* Valueization hook for simplify_replace_tree. Valueize NAME if it is
369 an SSA name, otherwise just return it. */
370 tree (*vn_valueize
) (tree
);
372 vn_valueize_for_srt (tree t
, void* context ATTRIBUTE_UNUSED
)
374 basic_block saved_vn_context_bb
= vn_context_bb
;
375 /* Look for sth available at the definition block of the argument.
376 This avoids inconsistencies between availability there which
377 decides if the stmt can be removed and availability at the
378 use site. The SSA property ensures that things available
379 at the definition are also available at uses. */
380 if (!SSA_NAME_IS_DEFAULT_DEF (t
))
381 vn_context_bb
= gimple_bb (SSA_NAME_DEF_STMT (t
));
382 tree res
= vn_valueize (t
);
383 vn_context_bb
= saved_vn_context_bb
;
388 /* This represents the top of the VN lattice, which is the universal
393 /* Unique counter for our value ids. */
395 static unsigned int next_value_id
;
396 static int next_constant_value_id
;
399 /* Table of vn_ssa_aux_t's, one per ssa_name. The vn_ssa_aux_t objects
400 are allocated on an obstack for locality reasons, and to free them
401 without looping over the vec. */
403 struct vn_ssa_aux_hasher
: typed_noop_remove
<vn_ssa_aux_t
>
405 typedef vn_ssa_aux_t value_type
;
406 typedef tree compare_type
;
407 static inline hashval_t
hash (const value_type
&);
408 static inline bool equal (const value_type
&, const compare_type
&);
409 static inline void mark_deleted (value_type
&) {}
410 static const bool empty_zero_p
= true;
411 static inline void mark_empty (value_type
&e
) { e
= NULL
; }
412 static inline bool is_deleted (value_type
&) { return false; }
413 static inline bool is_empty (value_type
&e
) { return e
== NULL
; }
417 vn_ssa_aux_hasher::hash (const value_type
&entry
)
419 return SSA_NAME_VERSION (entry
->name
);
423 vn_ssa_aux_hasher::equal (const value_type
&entry
, const compare_type
&name
)
425 return name
== entry
->name
;
428 static hash_table
<vn_ssa_aux_hasher
> *vn_ssa_aux_hash
;
429 typedef hash_table
<vn_ssa_aux_hasher
>::iterator vn_ssa_aux_iterator_type
;
430 static struct obstack vn_ssa_aux_obstack
;
432 static vn_nary_op_t
vn_nary_op_insert_stmt (gimple
*, tree
);
433 static vn_nary_op_t
vn_nary_op_insert_into (vn_nary_op_t
,
434 vn_nary_op_table_type
*);
435 static void init_vn_nary_op_from_pieces (vn_nary_op_t
, unsigned int,
436 enum tree_code
, tree
, tree
*);
437 static tree
vn_lookup_simplify_result (gimple_match_op
*);
438 static vn_reference_t vn_reference_lookup_or_insert_for_pieces
439 (tree
, alias_set_type
, alias_set_type
, tree
,
440 vec
<vn_reference_op_s
, va_heap
>, tree
);
442 /* Return whether there is value numbering information for a given SSA name. */
445 has_VN_INFO (tree name
)
447 return vn_ssa_aux_hash
->find_with_hash (name
, SSA_NAME_VERSION (name
));
454 = vn_ssa_aux_hash
->find_slot_with_hash (name
, SSA_NAME_VERSION (name
),
459 vn_ssa_aux_t newinfo
= *res
= XOBNEW (&vn_ssa_aux_obstack
, struct vn_ssa_aux
);
460 memset (newinfo
, 0, sizeof (struct vn_ssa_aux
));
461 newinfo
->name
= name
;
462 newinfo
->valnum
= VN_TOP
;
463 /* We are using the visited flag to handle uses with defs not within the
464 region being value-numbered. */
465 newinfo
->visited
= false;
467 /* Given we create the VN_INFOs on-demand now we have to do initialization
468 different than VN_TOP here. */
469 if (SSA_NAME_IS_DEFAULT_DEF (name
))
470 switch (TREE_CODE (SSA_NAME_VAR (name
)))
473 /* All undefined vars are VARYING. */
474 newinfo
->valnum
= name
;
475 newinfo
->visited
= true;
479 /* Parameters are VARYING but we can record a condition
480 if we know it is a non-NULL pointer. */
481 newinfo
->visited
= true;
482 newinfo
->valnum
= name
;
483 if (POINTER_TYPE_P (TREE_TYPE (name
))
484 && nonnull_arg_p (SSA_NAME_VAR (name
)))
488 ops
[1] = build_int_cst (TREE_TYPE (name
), 0);
490 /* Allocate from non-unwinding stack. */
491 nary
= alloc_vn_nary_op_noinit (2, &vn_tables_insert_obstack
);
492 init_vn_nary_op_from_pieces (nary
, 2, NE_EXPR
,
493 boolean_type_node
, ops
);
494 nary
->predicated_values
= 0;
495 nary
->u
.result
= boolean_true_node
;
496 vn_nary_op_insert_into (nary
, valid_info
->nary
);
497 gcc_assert (nary
->unwind_to
== NULL
);
498 /* Also do not link it into the undo chain. */
499 last_inserted_nary
= nary
->next
;
500 nary
->next
= (vn_nary_op_t
)(void *)-1;
501 nary
= alloc_vn_nary_op_noinit (2, &vn_tables_insert_obstack
);
502 init_vn_nary_op_from_pieces (nary
, 2, EQ_EXPR
,
503 boolean_type_node
, ops
);
504 nary
->predicated_values
= 0;
505 nary
->u
.result
= boolean_false_node
;
506 vn_nary_op_insert_into (nary
, valid_info
->nary
);
507 gcc_assert (nary
->unwind_to
== NULL
);
508 last_inserted_nary
= nary
->next
;
509 nary
->next
= (vn_nary_op_t
)(void *)-1;
510 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
512 fprintf (dump_file
, "Recording ");
513 print_generic_expr (dump_file
, name
, TDF_SLIM
);
514 fprintf (dump_file
, " != 0\n");
520 /* If the result is passed by invisible reference the default
521 def is initialized, otherwise it's uninitialized. Still
522 undefined is varying. */
523 newinfo
->visited
= true;
524 newinfo
->valnum
= name
;
533 /* Return the SSA value of X. */
536 SSA_VAL (tree x
, bool *visited
= NULL
)
538 vn_ssa_aux_t tem
= vn_ssa_aux_hash
->find_with_hash (x
, SSA_NAME_VERSION (x
));
540 *visited
= tem
&& tem
->visited
;
541 return tem
&& tem
->visited
? tem
->valnum
: x
;
544 /* Return the SSA value of the VUSE x, supporting released VDEFs
545 during elimination which will value-number the VDEF to the
546 associated VUSE (but not substitute in the whole lattice). */
549 vuse_ssa_val (tree x
)
557 gcc_assert (x
!= VN_TOP
);
559 while (SSA_NAME_IN_FREE_LIST (x
));
564 /* Similar to the above but used as callback for walk_non_aliased_vuses
565 and thus should stop at unvisited VUSE to not walk across region
569 vuse_valueize (tree vuse
)
574 vuse
= SSA_VAL (vuse
, &visited
);
577 gcc_assert (vuse
!= VN_TOP
);
579 while (SSA_NAME_IN_FREE_LIST (vuse
));
584 /* Return the vn_kind the expression computed by the stmt should be
588 vn_get_stmt_kind (gimple
*stmt
)
590 switch (gimple_code (stmt
))
598 enum tree_code code
= gimple_assign_rhs_code (stmt
);
599 tree rhs1
= gimple_assign_rhs1 (stmt
);
600 switch (get_gimple_rhs_class (code
))
602 case GIMPLE_UNARY_RHS
:
603 case GIMPLE_BINARY_RHS
:
604 case GIMPLE_TERNARY_RHS
:
606 case GIMPLE_SINGLE_RHS
:
607 switch (TREE_CODE_CLASS (code
))
610 /* VOP-less references can go through unary case. */
611 if ((code
== REALPART_EXPR
612 || code
== IMAGPART_EXPR
613 || code
== VIEW_CONVERT_EXPR
614 || code
== BIT_FIELD_REF
)
615 && (TREE_CODE (TREE_OPERAND (rhs1
, 0)) == SSA_NAME
616 || is_gimple_min_invariant (TREE_OPERAND (rhs1
, 0))))
620 case tcc_declaration
:
627 if (code
== ADDR_EXPR
)
628 return (is_gimple_min_invariant (rhs1
)
629 ? VN_CONSTANT
: VN_REFERENCE
);
630 else if (code
== CONSTRUCTOR
)
643 /* Lookup a value id for CONSTANT and return it. If it does not
647 get_constant_value_id (tree constant
)
649 vn_constant_s
**slot
;
650 struct vn_constant_s vc
;
652 vc
.hashcode
= vn_hash_constant_with_type (constant
);
653 vc
.constant
= constant
;
654 slot
= constant_to_value_id
->find_slot (&vc
, NO_INSERT
);
656 return (*slot
)->value_id
;
660 /* Lookup a value id for CONSTANT, and if it does not exist, create a
661 new one and return it. If it does exist, return it. */
664 get_or_alloc_constant_value_id (tree constant
)
666 vn_constant_s
**slot
;
667 struct vn_constant_s vc
;
670 /* If the hashtable isn't initialized we're not running from PRE and thus
671 do not need value-ids. */
672 if (!constant_to_value_id
)
675 vc
.hashcode
= vn_hash_constant_with_type (constant
);
676 vc
.constant
= constant
;
677 slot
= constant_to_value_id
->find_slot (&vc
, INSERT
);
679 return (*slot
)->value_id
;
681 vcp
= XNEW (struct vn_constant_s
);
682 vcp
->hashcode
= vc
.hashcode
;
683 vcp
->constant
= constant
;
684 vcp
->value_id
= get_next_constant_value_id ();
686 return vcp
->value_id
;
689 /* Compute the hash for a reference operand VRO1. */
692 vn_reference_op_compute_hash (const vn_reference_op_t vro1
, inchash::hash
&hstate
)
694 hstate
.add_int (vro1
->opcode
);
695 if (vro1
->opcode
== CALL_EXPR
&& !vro1
->op0
)
696 hstate
.add_int (vro1
->clique
);
698 inchash::add_expr (vro1
->op0
, hstate
);
700 inchash::add_expr (vro1
->op1
, hstate
);
702 inchash::add_expr (vro1
->op2
, hstate
);
705 /* Compute a hash for the reference operation VR1 and return it. */
708 vn_reference_compute_hash (const vn_reference_t vr1
)
710 inchash::hash hstate
;
713 vn_reference_op_t vro
;
717 FOR_EACH_VEC_ELT (vr1
->operands
, i
, vro
)
719 if (vro
->opcode
== MEM_REF
)
721 else if (vro
->opcode
!= ADDR_EXPR
)
723 if (maybe_ne (vro
->off
, -1))
725 if (known_eq (off
, -1))
731 if (maybe_ne (off
, -1)
732 && maybe_ne (off
, 0))
733 hstate
.add_poly_int (off
);
736 && vro
->opcode
== ADDR_EXPR
)
740 tree op
= TREE_OPERAND (vro
->op0
, 0);
741 hstate
.add_int (TREE_CODE (op
));
742 inchash::add_expr (op
, hstate
);
746 vn_reference_op_compute_hash (vro
, hstate
);
749 result
= hstate
.end ();
750 /* ??? We would ICE later if we hash instead of adding that in. */
752 result
+= SSA_NAME_VERSION (vr1
->vuse
);
757 /* Return true if reference operations VR1 and VR2 are equivalent. This
758 means they have the same set of operands and vuses. */
761 vn_reference_eq (const_vn_reference_t
const vr1
, const_vn_reference_t
const vr2
)
765 /* Early out if this is not a hash collision. */
766 if (vr1
->hashcode
!= vr2
->hashcode
)
769 /* The VOP needs to be the same. */
770 if (vr1
->vuse
!= vr2
->vuse
)
773 /* If the operands are the same we are done. */
774 if (vr1
->operands
== vr2
->operands
)
777 if (!vr1
->type
|| !vr2
->type
)
779 if (vr1
->type
!= vr2
->type
)
782 else if (vr1
->type
== vr2
->type
)
784 else if (COMPLETE_TYPE_P (vr1
->type
) != COMPLETE_TYPE_P (vr2
->type
)
785 || (COMPLETE_TYPE_P (vr1
->type
)
786 && !expressions_equal_p (TYPE_SIZE (vr1
->type
),
787 TYPE_SIZE (vr2
->type
))))
789 else if (vr1
->operands
[0].opcode
== CALL_EXPR
790 && !types_compatible_p (vr1
->type
, vr2
->type
))
792 else if (INTEGRAL_TYPE_P (vr1
->type
)
793 && INTEGRAL_TYPE_P (vr2
->type
))
795 if (TYPE_PRECISION (vr1
->type
) != TYPE_PRECISION (vr2
->type
))
798 else if (INTEGRAL_TYPE_P (vr1
->type
)
799 && (TYPE_PRECISION (vr1
->type
)
800 != TREE_INT_CST_LOW (TYPE_SIZE (vr1
->type
))))
802 else if (INTEGRAL_TYPE_P (vr2
->type
)
803 && (TYPE_PRECISION (vr2
->type
)
804 != TREE_INT_CST_LOW (TYPE_SIZE (vr2
->type
))))
806 else if (VECTOR_BOOLEAN_TYPE_P (vr1
->type
)
807 && VECTOR_BOOLEAN_TYPE_P (vr2
->type
))
809 /* Vector boolean types can have padding, verify we are dealing with
810 the same number of elements, aka the precision of the types.
811 For example, In most architecture the precision_size of vbool*_t
812 types are caculated like below:
813 precision_size = type_size * 8
815 Unfortunately, the RISC-V will adjust the precision_size for the
816 vbool*_t in order to align the ISA as below:
817 type_size = [1, 1, 1, 1, 2, 4, 8]
818 precision_size = [1, 2, 4, 8, 16, 32, 64]
820 Then the precision_size of RISC-V vbool*_t will not be the multiple
821 of the type_size. We take care of this case consolidated here. */
822 if (maybe_ne (TYPE_VECTOR_SUBPARTS (vr1
->type
),
823 TYPE_VECTOR_SUBPARTS (vr2
->type
)))
831 poly_int64 off1
= 0, off2
= 0;
832 vn_reference_op_t vro1
, vro2
;
833 vn_reference_op_s tem1
, tem2
;
834 bool deref1
= false, deref2
= false;
835 bool reverse1
= false, reverse2
= false;
836 for (; vr1
->operands
.iterate (i
, &vro1
); i
++)
838 if (vro1
->opcode
== MEM_REF
)
840 /* Do not look through a storage order barrier. */
841 else if (vro1
->opcode
== VIEW_CONVERT_EXPR
&& vro1
->reverse
)
843 reverse1
|= vro1
->reverse
;
844 if (known_eq (vro1
->off
, -1))
848 for (; vr2
->operands
.iterate (j
, &vro2
); j
++)
850 if (vro2
->opcode
== MEM_REF
)
852 /* Do not look through a storage order barrier. */
853 else if (vro2
->opcode
== VIEW_CONVERT_EXPR
&& vro2
->reverse
)
855 reverse2
|= vro2
->reverse
;
856 if (known_eq (vro2
->off
, -1))
860 if (maybe_ne (off1
, off2
) || reverse1
!= reverse2
)
862 if (deref1
&& vro1
->opcode
== ADDR_EXPR
)
864 memset (&tem1
, 0, sizeof (tem1
));
865 tem1
.op0
= TREE_OPERAND (vro1
->op0
, 0);
866 tem1
.type
= TREE_TYPE (tem1
.op0
);
867 tem1
.opcode
= TREE_CODE (tem1
.op0
);
871 if (deref2
&& vro2
->opcode
== ADDR_EXPR
)
873 memset (&tem2
, 0, sizeof (tem2
));
874 tem2
.op0
= TREE_OPERAND (vro2
->op0
, 0);
875 tem2
.type
= TREE_TYPE (tem2
.op0
);
876 tem2
.opcode
= TREE_CODE (tem2
.op0
);
880 if (deref1
!= deref2
)
882 if (!vn_reference_op_eq (vro1
, vro2
))
887 while (vr1
->operands
.length () != i
888 || vr2
->operands
.length () != j
);
893 /* Copy the operations present in load/store REF into RESULT, a vector of
894 vn_reference_op_s's. */
897 copy_reference_ops_from_ref (tree ref
, vec
<vn_reference_op_s
> *result
)
899 /* For non-calls, store the information that makes up the address. */
903 vn_reference_op_s temp
;
905 memset (&temp
, 0, sizeof (temp
));
906 temp
.type
= TREE_TYPE (ref
);
907 temp
.opcode
= TREE_CODE (ref
);
913 temp
.op0
= TREE_OPERAND (ref
, 1);
916 temp
.op0
= TREE_OPERAND (ref
, 1);
920 /* The base address gets its own vn_reference_op_s structure. */
921 temp
.op0
= TREE_OPERAND (ref
, 1);
922 if (!mem_ref_offset (ref
).to_shwi (&temp
.off
))
924 temp
.clique
= MR_DEPENDENCE_CLIQUE (ref
);
925 temp
.base
= MR_DEPENDENCE_BASE (ref
);
926 temp
.reverse
= REF_REVERSE_STORAGE_ORDER (ref
);
929 /* The base address gets its own vn_reference_op_s structure. */
930 temp
.op0
= TMR_INDEX (ref
);
931 temp
.op1
= TMR_STEP (ref
);
932 temp
.op2
= TMR_OFFSET (ref
);
933 temp
.clique
= MR_DEPENDENCE_CLIQUE (ref
);
934 temp
.base
= MR_DEPENDENCE_BASE (ref
);
935 result
->safe_push (temp
);
936 memset (&temp
, 0, sizeof (temp
));
937 temp
.type
= NULL_TREE
;
938 temp
.opcode
= ERROR_MARK
;
939 temp
.op0
= TMR_INDEX2 (ref
);
943 /* Record bits, position and storage order. */
944 temp
.op0
= TREE_OPERAND (ref
, 1);
945 temp
.op1
= TREE_OPERAND (ref
, 2);
946 if (!multiple_p (bit_field_offset (ref
), BITS_PER_UNIT
, &temp
.off
))
948 temp
.reverse
= REF_REVERSE_STORAGE_ORDER (ref
);
951 /* The field decl is enough to unambiguously specify the field,
952 so use its type here. */
953 temp
.type
= TREE_TYPE (TREE_OPERAND (ref
, 1));
954 temp
.op0
= TREE_OPERAND (ref
, 1);
955 temp
.op1
= TREE_OPERAND (ref
, 2);
956 temp
.reverse
= (AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (ref
, 0)))
957 && TYPE_REVERSE_STORAGE_ORDER
958 (TREE_TYPE (TREE_OPERAND (ref
, 0))));
960 tree this_offset
= component_ref_field_offset (ref
);
962 && poly_int_tree_p (this_offset
))
964 tree bit_offset
= DECL_FIELD_BIT_OFFSET (TREE_OPERAND (ref
, 1));
965 if (TREE_INT_CST_LOW (bit_offset
) % BITS_PER_UNIT
== 0)
968 = (wi::to_poly_offset (this_offset
)
969 + (wi::to_offset (bit_offset
) >> LOG2_BITS_PER_UNIT
));
970 /* Probibit value-numbering zero offset components
971 of addresses the same before the pass folding
972 __builtin_object_size had a chance to run. */
973 if (TREE_CODE (orig
) != ADDR_EXPR
975 || (cfun
->curr_properties
& PROP_objsz
))
976 off
.to_shwi (&temp
.off
);
981 case ARRAY_RANGE_REF
:
984 tree eltype
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (ref
, 0)));
985 /* Record index as operand. */
986 temp
.op0
= TREE_OPERAND (ref
, 1);
987 /* Always record lower bounds and element size. */
988 temp
.op1
= array_ref_low_bound (ref
);
989 /* But record element size in units of the type alignment. */
990 temp
.op2
= TREE_OPERAND (ref
, 3);
991 temp
.align
= eltype
->type_common
.align
;
993 temp
.op2
= size_binop (EXACT_DIV_EXPR
, TYPE_SIZE_UNIT (eltype
),
994 size_int (TYPE_ALIGN_UNIT (eltype
)));
995 if (poly_int_tree_p (temp
.op0
)
996 && poly_int_tree_p (temp
.op1
)
997 && TREE_CODE (temp
.op2
) == INTEGER_CST
)
999 poly_offset_int off
= ((wi::to_poly_offset (temp
.op0
)
1000 - wi::to_poly_offset (temp
.op1
))
1001 * wi::to_offset (temp
.op2
)
1002 * vn_ref_op_align_unit (&temp
));
1003 off
.to_shwi (&temp
.off
);
1005 temp
.reverse
= (AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (ref
, 0)))
1006 && TYPE_REVERSE_STORAGE_ORDER
1007 (TREE_TYPE (TREE_OPERAND (ref
, 0))));
1011 if (DECL_HARD_REGISTER (ref
))
1020 /* Canonicalize decls to MEM[&decl] which is what we end up with
1021 when valueizing MEM[ptr] with ptr = &decl. */
1022 temp
.opcode
= MEM_REF
;
1023 temp
.op0
= build_int_cst (build_pointer_type (TREE_TYPE (ref
)), 0);
1025 result
->safe_push (temp
);
1026 temp
.opcode
= ADDR_EXPR
;
1027 temp
.op0
= build1 (ADDR_EXPR
, TREE_TYPE (temp
.op0
), ref
);
1028 temp
.type
= TREE_TYPE (temp
.op0
);
1043 if (is_gimple_min_invariant (ref
))
1049 /* These are only interesting for their operands, their
1050 existence, and their type. They will never be the last
1051 ref in the chain of references (IE they require an
1052 operand), so we don't have to put anything
1053 for op* as it will be handled by the iteration */
1057 case VIEW_CONVERT_EXPR
:
1059 temp
.reverse
= storage_order_barrier_p (ref
);
1062 /* This is only interesting for its constant offset. */
1063 temp
.off
= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (ref
)));
1068 result
->safe_push (temp
);
1070 if (REFERENCE_CLASS_P (ref
)
1071 || TREE_CODE (ref
) == MODIFY_EXPR
1072 || TREE_CODE (ref
) == WITH_SIZE_EXPR
1073 || (TREE_CODE (ref
) == ADDR_EXPR
1074 && !is_gimple_min_invariant (ref
)))
1075 ref
= TREE_OPERAND (ref
, 0);
1081 /* Build a alias-oracle reference abstraction in *REF from the vn_reference
1082 operands in *OPS, the reference alias set SET and the reference type TYPE.
1083 Return true if something useful was produced. */
1086 ao_ref_init_from_vn_reference (ao_ref
*ref
,
1087 alias_set_type set
, alias_set_type base_set
,
1088 tree type
, const vec
<vn_reference_op_s
> &ops
)
1091 tree base
= NULL_TREE
;
1092 tree
*op0_p
= &base
;
1093 poly_offset_int offset
= 0;
1094 poly_offset_int max_size
;
1095 poly_offset_int size
= -1;
1096 tree size_tree
= NULL_TREE
;
1098 /* We don't handle calls. */
1102 machine_mode mode
= TYPE_MODE (type
);
1103 if (mode
== BLKmode
)
1104 size_tree
= TYPE_SIZE (type
);
1106 size
= GET_MODE_BITSIZE (mode
);
1107 if (size_tree
!= NULL_TREE
1108 && poly_int_tree_p (size_tree
))
1109 size
= wi::to_poly_offset (size_tree
);
1111 /* Lower the final access size from the outermost expression. */
1112 const_vn_reference_op_t cst_op
= &ops
[0];
1113 /* Cast away constness for the sake of the const-unsafe
1114 FOR_EACH_VEC_ELT(). */
1115 vn_reference_op_t op
= const_cast<vn_reference_op_t
>(cst_op
);
1116 size_tree
= NULL_TREE
;
1117 if (op
->opcode
== COMPONENT_REF
)
1118 size_tree
= DECL_SIZE (op
->op0
);
1119 else if (op
->opcode
== BIT_FIELD_REF
)
1120 size_tree
= op
->op0
;
1121 if (size_tree
!= NULL_TREE
1122 && poly_int_tree_p (size_tree
)
1123 && (!known_size_p (size
)
1124 || known_lt (wi::to_poly_offset (size_tree
), size
)))
1125 size
= wi::to_poly_offset (size_tree
);
1127 /* Initially, maxsize is the same as the accessed element size.
1128 In the following it will only grow (or become -1). */
1131 /* Compute cumulative bit-offset for nested component-refs and array-refs,
1132 and find the ultimate containing object. */
1133 FOR_EACH_VEC_ELT (ops
, i
, op
)
1137 /* These may be in the reference ops, but we cannot do anything
1138 sensible with them here. */
1140 /* Apart from ADDR_EXPR arguments to MEM_REF. */
1141 if (base
!= NULL_TREE
1142 && TREE_CODE (base
) == MEM_REF
1144 && DECL_P (TREE_OPERAND (op
->op0
, 0)))
1146 const_vn_reference_op_t pop
= &ops
[i
-1];
1147 base
= TREE_OPERAND (op
->op0
, 0);
1148 if (known_eq (pop
->off
, -1))
1154 offset
+= pop
->off
* BITS_PER_UNIT
;
1162 /* Record the base objects. */
1164 *op0_p
= build2 (MEM_REF
, op
->type
,
1165 NULL_TREE
, op
->op0
);
1166 MR_DEPENDENCE_CLIQUE (*op0_p
) = op
->clique
;
1167 MR_DEPENDENCE_BASE (*op0_p
) = op
->base
;
1168 op0_p
= &TREE_OPERAND (*op0_p
, 0);
1179 /* And now the usual component-reference style ops. */
1181 offset
+= wi::to_poly_offset (op
->op1
);
1186 tree field
= op
->op0
;
1187 /* We do not have a complete COMPONENT_REF tree here so we
1188 cannot use component_ref_field_offset. Do the interesting
1190 tree this_offset
= DECL_FIELD_OFFSET (field
);
1192 if (op
->op1
|| !poly_int_tree_p (this_offset
))
1196 poly_offset_int woffset
= (wi::to_poly_offset (this_offset
)
1197 << LOG2_BITS_PER_UNIT
);
1198 woffset
+= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
1204 case ARRAY_RANGE_REF
:
1206 /* We recorded the lower bound and the element size. */
1207 if (!poly_int_tree_p (op
->op0
)
1208 || !poly_int_tree_p (op
->op1
)
1209 || TREE_CODE (op
->op2
) != INTEGER_CST
)
1213 poly_offset_int woffset
1214 = wi::sext (wi::to_poly_offset (op
->op0
)
1215 - wi::to_poly_offset (op
->op1
),
1216 TYPE_PRECISION (sizetype
));
1217 woffset
*= wi::to_offset (op
->op2
) * vn_ref_op_align_unit (op
);
1218 woffset
<<= LOG2_BITS_PER_UNIT
;
1230 case VIEW_CONVERT_EXPR
:
1247 if (base
== NULL_TREE
)
1250 ref
->ref
= NULL_TREE
;
1252 ref
->ref_alias_set
= set
;
1253 ref
->base_alias_set
= base_set
;
1254 /* We discount volatiles from value-numbering elsewhere. */
1255 ref
->volatile_p
= false;
1257 if (!size
.to_shwi (&ref
->size
) || maybe_lt (ref
->size
, 0))
1265 if (!offset
.to_shwi (&ref
->offset
))
1272 if (!max_size
.to_shwi (&ref
->max_size
) || maybe_lt (ref
->max_size
, 0))
1278 /* Copy the operations present in load/store/call REF into RESULT, a vector of
1279 vn_reference_op_s's. */
1282 copy_reference_ops_from_call (gcall
*call
,
1283 vec
<vn_reference_op_s
> *result
)
1285 vn_reference_op_s temp
;
1287 tree lhs
= gimple_call_lhs (call
);
1290 /* If 2 calls have a different non-ssa lhs, vdef value numbers should be
1291 different. By adding the lhs here in the vector, we ensure that the
1292 hashcode is different, guaranteeing a different value number. */
1293 if (lhs
&& TREE_CODE (lhs
) != SSA_NAME
)
1295 memset (&temp
, 0, sizeof (temp
));
1296 temp
.opcode
= MODIFY_EXPR
;
1297 temp
.type
= TREE_TYPE (lhs
);
1300 result
->safe_push (temp
);
1303 /* Copy the type, opcode, function, static chain and EH region, if any. */
1304 memset (&temp
, 0, sizeof (temp
));
1305 temp
.type
= gimple_call_fntype (call
);
1306 temp
.opcode
= CALL_EXPR
;
1307 temp
.op0
= gimple_call_fn (call
);
1308 if (gimple_call_internal_p (call
))
1309 temp
.clique
= gimple_call_internal_fn (call
);
1310 temp
.op1
= gimple_call_chain (call
);
1311 if (stmt_could_throw_p (cfun
, call
) && (lr
= lookup_stmt_eh_lp (call
)) > 0)
1312 temp
.op2
= size_int (lr
);
1314 result
->safe_push (temp
);
1316 /* Copy the call arguments. As they can be references as well,
1317 just chain them together. */
1318 for (i
= 0; i
< gimple_call_num_args (call
); ++i
)
1320 tree callarg
= gimple_call_arg (call
, i
);
1321 copy_reference_ops_from_ref (callarg
, result
);
1325 /* Fold *& at position *I_P in a vn_reference_op_s vector *OPS. Updates
1326 *I_P to point to the last element of the replacement. */
1328 vn_reference_fold_indirect (vec
<vn_reference_op_s
> *ops
,
1331 unsigned int i
= *i_p
;
1332 vn_reference_op_t op
= &(*ops
)[i
];
1333 vn_reference_op_t mem_op
= &(*ops
)[i
- 1];
1335 poly_int64 addr_offset
= 0;
1337 /* The only thing we have to do is from &OBJ.foo.bar add the offset
1338 from .foo.bar to the preceding MEM_REF offset and replace the
1339 address with &OBJ. */
1340 addr_base
= get_addr_base_and_unit_offset_1 (TREE_OPERAND (op
->op0
, 0),
1341 &addr_offset
, vn_valueize
);
1342 gcc_checking_assert (addr_base
&& TREE_CODE (addr_base
) != MEM_REF
);
1343 if (addr_base
!= TREE_OPERAND (op
->op0
, 0))
1346 = (poly_offset_int::from (wi::to_poly_wide (mem_op
->op0
),
1349 mem_op
->op0
= wide_int_to_tree (TREE_TYPE (mem_op
->op0
), off
);
1350 op
->op0
= build_fold_addr_expr (addr_base
);
1351 if (tree_fits_shwi_p (mem_op
->op0
))
1352 mem_op
->off
= tree_to_shwi (mem_op
->op0
);
1360 /* Fold *& at position *I_P in a vn_reference_op_s vector *OPS. Updates
1361 *I_P to point to the last element of the replacement. */
1363 vn_reference_maybe_forwprop_address (vec
<vn_reference_op_s
> *ops
,
1366 bool changed
= false;
1367 vn_reference_op_t op
;
1371 unsigned int i
= *i_p
;
1373 vn_reference_op_t mem_op
= &(*ops
)[i
- 1];
1375 enum tree_code code
;
1376 poly_offset_int off
;
1378 def_stmt
= SSA_NAME_DEF_STMT (op
->op0
);
1379 if (!is_gimple_assign (def_stmt
))
1382 code
= gimple_assign_rhs_code (def_stmt
);
1383 if (code
!= ADDR_EXPR
1384 && code
!= POINTER_PLUS_EXPR
)
1387 off
= poly_offset_int::from (wi::to_poly_wide (mem_op
->op0
), SIGNED
);
1389 /* The only thing we have to do is from &OBJ.foo.bar add the offset
1390 from .foo.bar to the preceding MEM_REF offset and replace the
1391 address with &OBJ. */
1392 if (code
== ADDR_EXPR
)
1394 tree addr
, addr_base
;
1395 poly_int64 addr_offset
;
1397 addr
= gimple_assign_rhs1 (def_stmt
);
1398 addr_base
= get_addr_base_and_unit_offset_1 (TREE_OPERAND (addr
, 0),
1401 /* If that didn't work because the address isn't invariant propagate
1402 the reference tree from the address operation in case the current
1403 dereference isn't offsetted. */
1405 && *i_p
== ops
->length () - 1
1406 && known_eq (off
, 0)
1407 /* This makes us disable this transform for PRE where the
1408 reference ops might be also used for code insertion which
1410 && default_vn_walk_kind
== VN_WALKREWRITE
)
1412 auto_vec
<vn_reference_op_s
, 32> tem
;
1413 copy_reference_ops_from_ref (TREE_OPERAND (addr
, 0), &tem
);
1414 /* Make sure to preserve TBAA info. The only objects not
1415 wrapped in MEM_REFs that can have their address taken are
1417 if (tem
.length () >= 2
1418 && tem
[tem
.length () - 2].opcode
== MEM_REF
)
1420 vn_reference_op_t new_mem_op
= &tem
[tem
.length () - 2];
1422 = wide_int_to_tree (TREE_TYPE (mem_op
->op0
),
1423 wi::to_poly_wide (new_mem_op
->op0
));
1426 gcc_assert (tem
.last ().opcode
== STRING_CST
);
1429 ops
->safe_splice (tem
);
1434 || TREE_CODE (addr_base
) != MEM_REF
1435 || (TREE_CODE (TREE_OPERAND (addr_base
, 0)) == SSA_NAME
1436 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (addr_base
,
1441 off
+= mem_ref_offset (addr_base
);
1442 op
->op0
= TREE_OPERAND (addr_base
, 0);
1447 ptr
= gimple_assign_rhs1 (def_stmt
);
1448 ptroff
= gimple_assign_rhs2 (def_stmt
);
1449 if (TREE_CODE (ptr
) != SSA_NAME
1450 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ptr
)
1451 /* Make sure to not endlessly recurse.
1452 See gcc.dg/tree-ssa/20040408-1.c for an example. Can easily
1453 happen when we value-number a PHI to its backedge value. */
1454 || SSA_VAL (ptr
) == op
->op0
1455 || !poly_int_tree_p (ptroff
))
1458 off
+= wi::to_poly_offset (ptroff
);
1462 mem_op
->op0
= wide_int_to_tree (TREE_TYPE (mem_op
->op0
), off
);
1463 if (tree_fits_shwi_p (mem_op
->op0
))
1464 mem_op
->off
= tree_to_shwi (mem_op
->op0
);
1467 /* ??? Can end up with endless recursion here!?
1468 gcc.c-torture/execute/strcmp-1.c */
1469 if (TREE_CODE (op
->op0
) == SSA_NAME
)
1470 op
->op0
= SSA_VAL (op
->op0
);
1471 if (TREE_CODE (op
->op0
) != SSA_NAME
)
1472 op
->opcode
= TREE_CODE (op
->op0
);
1477 while (TREE_CODE (op
->op0
) == SSA_NAME
);
1479 /* Fold a remaining *&. */
1480 if (TREE_CODE (op
->op0
) == ADDR_EXPR
)
1481 vn_reference_fold_indirect (ops
, i_p
);
1486 /* Optimize the reference REF to a constant if possible or return
1487 NULL_TREE if not. */
1490 fully_constant_vn_reference_p (vn_reference_t ref
)
1492 vec
<vn_reference_op_s
> operands
= ref
->operands
;
1493 vn_reference_op_t op
;
1495 /* Try to simplify the translated expression if it is
1496 a call to a builtin function with at most two arguments. */
1498 if (op
->opcode
== CALL_EXPR
1500 || (TREE_CODE (op
->op0
) == ADDR_EXPR
1501 && TREE_CODE (TREE_OPERAND (op
->op0
, 0)) == FUNCTION_DECL
1502 && fndecl_built_in_p (TREE_OPERAND (op
->op0
, 0),
1504 && operands
.length () >= 2
1505 && operands
.length () <= 3)
1507 vn_reference_op_t arg0
, arg1
= NULL
;
1508 bool anyconst
= false;
1509 arg0
= &operands
[1];
1510 if (operands
.length () > 2)
1511 arg1
= &operands
[2];
1512 if (TREE_CODE_CLASS (arg0
->opcode
) == tcc_constant
1513 || (arg0
->opcode
== ADDR_EXPR
1514 && is_gimple_min_invariant (arg0
->op0
)))
1517 && (TREE_CODE_CLASS (arg1
->opcode
) == tcc_constant
1518 || (arg1
->opcode
== ADDR_EXPR
1519 && is_gimple_min_invariant (arg1
->op0
))))
1525 fn
= as_combined_fn (DECL_FUNCTION_CODE
1526 (TREE_OPERAND (op
->op0
, 0)));
1528 fn
= as_combined_fn ((internal_fn
) op
->clique
);
1531 folded
= fold_const_call (fn
, ref
->type
, arg0
->op0
, arg1
->op0
);
1533 folded
= fold_const_call (fn
, ref
->type
, arg0
->op0
);
1535 && is_gimple_min_invariant (folded
))
1540 /* Simplify reads from constants or constant initializers. */
1541 else if (BITS_PER_UNIT
== 8
1543 && COMPLETE_TYPE_P (ref
->type
)
1544 && is_gimple_reg_type (ref
->type
))
1548 if (INTEGRAL_TYPE_P (ref
->type
))
1549 size
= TYPE_PRECISION (ref
->type
);
1550 else if (tree_fits_shwi_p (TYPE_SIZE (ref
->type
)))
1551 size
= tree_to_shwi (TYPE_SIZE (ref
->type
));
1554 if (size
% BITS_PER_UNIT
!= 0
1555 || size
> MAX_BITSIZE_MODE_ANY_MODE
)
1557 size
/= BITS_PER_UNIT
;
1559 for (i
= 0; i
< operands
.length (); ++i
)
1561 if (TREE_CODE_CLASS (operands
[i
].opcode
) == tcc_constant
)
1566 if (known_eq (operands
[i
].off
, -1))
1568 off
+= operands
[i
].off
;
1569 if (operands
[i
].opcode
== MEM_REF
)
1575 vn_reference_op_t base
= &operands
[--i
];
1576 tree ctor
= error_mark_node
;
1577 tree decl
= NULL_TREE
;
1578 if (TREE_CODE_CLASS (base
->opcode
) == tcc_constant
)
1580 else if (base
->opcode
== MEM_REF
1581 && base
[1].opcode
== ADDR_EXPR
1582 && (VAR_P (TREE_OPERAND (base
[1].op0
, 0))
1583 || TREE_CODE (TREE_OPERAND (base
[1].op0
, 0)) == CONST_DECL
1584 || TREE_CODE (TREE_OPERAND (base
[1].op0
, 0)) == STRING_CST
))
1586 decl
= TREE_OPERAND (base
[1].op0
, 0);
1587 if (TREE_CODE (decl
) == STRING_CST
)
1590 ctor
= ctor_for_folding (decl
);
1592 if (ctor
== NULL_TREE
)
1593 return build_zero_cst (ref
->type
);
1594 else if (ctor
!= error_mark_node
)
1596 HOST_WIDE_INT const_off
;
1599 tree res
= fold_ctor_reference (ref
->type
, ctor
,
1600 off
* BITS_PER_UNIT
,
1601 size
* BITS_PER_UNIT
, decl
);
1604 STRIP_USELESS_TYPE_CONVERSION (res
);
1605 if (is_gimple_min_invariant (res
))
1609 else if (off
.is_constant (&const_off
))
1611 unsigned char buf
[MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
];
1612 int len
= native_encode_expr (ctor
, buf
, size
, const_off
);
1614 return native_interpret_expr (ref
->type
, buf
, len
);
1622 /* Return true if OPS contain a storage order barrier. */
1625 contains_storage_order_barrier_p (vec
<vn_reference_op_s
> ops
)
1627 vn_reference_op_t op
;
1630 FOR_EACH_VEC_ELT (ops
, i
, op
)
1631 if (op
->opcode
== VIEW_CONVERT_EXPR
&& op
->reverse
)
1637 /* Return true if OPS represent an access with reverse storage order. */
1640 reverse_storage_order_for_component_p (vec
<vn_reference_op_s
> ops
)
1643 if (ops
[i
].opcode
== REALPART_EXPR
|| ops
[i
].opcode
== IMAGPART_EXPR
)
1645 switch (ops
[i
].opcode
)
1651 return ops
[i
].reverse
;
1657 /* Transform any SSA_NAME's in a vector of vn_reference_op_s
1658 structures into their value numbers. This is done in-place, and
1659 the vector passed in is returned. *VALUEIZED_ANYTHING will specify
1660 whether any operands were valueized. */
1663 valueize_refs_1 (vec
<vn_reference_op_s
> *orig
, bool *valueized_anything
,
1664 bool with_avail
= false)
1666 *valueized_anything
= false;
1668 for (unsigned i
= 0; i
< orig
->length (); ++i
)
1671 vn_reference_op_t vro
= &(*orig
)[i
];
1672 if (vro
->opcode
== SSA_NAME
1673 || (vro
->op0
&& TREE_CODE (vro
->op0
) == SSA_NAME
))
1675 tree tem
= with_avail
? vn_valueize (vro
->op0
) : SSA_VAL (vro
->op0
);
1676 if (tem
!= vro
->op0
)
1678 *valueized_anything
= true;
1681 /* If it transforms from an SSA_NAME to a constant, update
1683 if (TREE_CODE (vro
->op0
) != SSA_NAME
&& vro
->opcode
== SSA_NAME
)
1684 vro
->opcode
= TREE_CODE (vro
->op0
);
1686 if (vro
->op1
&& TREE_CODE (vro
->op1
) == SSA_NAME
)
1688 tree tem
= with_avail
? vn_valueize (vro
->op1
) : SSA_VAL (vro
->op1
);
1689 if (tem
!= vro
->op1
)
1691 *valueized_anything
= true;
1695 if (vro
->op2
&& TREE_CODE (vro
->op2
) == SSA_NAME
)
1697 tree tem
= with_avail
? vn_valueize (vro
->op2
) : SSA_VAL (vro
->op2
);
1698 if (tem
!= vro
->op2
)
1700 *valueized_anything
= true;
1704 /* If it transforms from an SSA_NAME to an address, fold with
1705 a preceding indirect reference. */
1708 && TREE_CODE (vro
->op0
) == ADDR_EXPR
1709 && (*orig
)[i
- 1].opcode
== MEM_REF
)
1711 if (vn_reference_fold_indirect (orig
, &i
))
1712 *valueized_anything
= true;
1715 && vro
->opcode
== SSA_NAME
1716 && (*orig
)[i
- 1].opcode
== MEM_REF
)
1718 if (vn_reference_maybe_forwprop_address (orig
, &i
))
1720 *valueized_anything
= true;
1721 /* Re-valueize the current operand. */
1725 /* If it transforms a non-constant ARRAY_REF into a constant
1726 one, adjust the constant offset. */
1727 else if (vro
->opcode
== ARRAY_REF
1728 && known_eq (vro
->off
, -1)
1729 && poly_int_tree_p (vro
->op0
)
1730 && poly_int_tree_p (vro
->op1
)
1731 && TREE_CODE (vro
->op2
) == INTEGER_CST
)
1733 poly_offset_int off
= ((wi::to_poly_offset (vro
->op0
)
1734 - wi::to_poly_offset (vro
->op1
))
1735 * wi::to_offset (vro
->op2
)
1736 * vn_ref_op_align_unit (vro
));
1737 off
.to_shwi (&vro
->off
);
1743 valueize_refs (vec
<vn_reference_op_s
> *orig
)
1746 valueize_refs_1 (orig
, &tem
);
1749 static vec
<vn_reference_op_s
> shared_lookup_references
;
1751 /* Create a vector of vn_reference_op_s structures from REF, a
1752 REFERENCE_CLASS_P tree. The vector is shared among all callers of
1753 this function. *VALUEIZED_ANYTHING will specify whether any
1754 operands were valueized. */
1756 static vec
<vn_reference_op_s
>
1757 valueize_shared_reference_ops_from_ref (tree ref
, bool *valueized_anything
)
1761 shared_lookup_references
.truncate (0);
1762 copy_reference_ops_from_ref (ref
, &shared_lookup_references
);
1763 valueize_refs_1 (&shared_lookup_references
, valueized_anything
);
1764 return shared_lookup_references
;
1767 /* Create a vector of vn_reference_op_s structures from CALL, a
1768 call statement. The vector is shared among all callers of
1771 static vec
<vn_reference_op_s
>
1772 valueize_shared_reference_ops_from_call (gcall
*call
)
1776 shared_lookup_references
.truncate (0);
1777 copy_reference_ops_from_call (call
, &shared_lookup_references
);
1778 valueize_refs (&shared_lookup_references
);
1779 return shared_lookup_references
;
1782 /* Lookup a SCCVN reference operation VR in the current hash table.
1783 Returns the resulting value number if it exists in the hash table,
1784 NULL_TREE otherwise. VNRESULT will be filled in with the actual
1785 vn_reference_t stored in the hashtable if something is found. */
1788 vn_reference_lookup_1 (vn_reference_t vr
, vn_reference_t
*vnresult
)
1790 vn_reference_s
**slot
;
1793 hash
= vr
->hashcode
;
1794 slot
= valid_info
->references
->find_slot_with_hash (vr
, hash
, NO_INSERT
);
1798 *vnresult
= (vn_reference_t
)*slot
;
1799 return ((vn_reference_t
)*slot
)->result
;
1806 /* Partial definition tracking support. */
1810 HOST_WIDE_INT offset
;
1817 HOST_WIDE_INT rhs_off
;
1818 HOST_WIDE_INT offset
;
1822 /* Context for alias walking. */
1824 struct vn_walk_cb_data
1826 vn_walk_cb_data (vn_reference_t vr_
, tree orig_ref_
, tree
*last_vuse_ptr_
,
1827 vn_lookup_kind vn_walk_kind_
, bool tbaa_p_
, tree mask_
,
1828 bool redundant_store_removal_p_
)
1829 : vr (vr_
), last_vuse_ptr (last_vuse_ptr_
), last_vuse (NULL_TREE
),
1830 mask (mask_
), masked_result (NULL_TREE
), same_val (NULL_TREE
),
1831 vn_walk_kind (vn_walk_kind_
),
1832 tbaa_p (tbaa_p_
), redundant_store_removal_p (redundant_store_removal_p_
),
1833 saved_operands (vNULL
), first_set (-2), first_base_set (-2),
1837 last_vuse_ptr
= &last_vuse
;
1838 ao_ref_init (&orig_ref
, orig_ref_
);
1841 wide_int w
= wi::to_wide (mask
);
1842 unsigned int pos
= 0, prec
= w
.get_precision ();
1844 pd
.rhs
= build_constructor (NULL_TREE
, NULL
);
1846 /* When bitwise and with a constant is done on a memory load,
1847 we don't really need all the bits to be defined or defined
1848 to constants, we don't really care what is in the position
1849 corresponding to 0 bits in the mask.
1850 So, push the ranges of those 0 bits in the mask as artificial
1851 zero stores and let the partial def handling code do the
1855 int tz
= wi::ctz (w
);
1856 if (pos
+ tz
> prec
)
1860 if (BYTES_BIG_ENDIAN
)
1861 pd
.offset
= prec
- pos
- tz
;
1865 void *r
= push_partial_def (pd
, 0, 0, 0, prec
);
1866 gcc_assert (r
== NULL_TREE
);
1871 w
= wi::lrshift (w
, tz
);
1872 tz
= wi::ctz (wi::bit_not (w
));
1873 if (pos
+ tz
> prec
)
1876 w
= wi::lrshift (w
, tz
);
1880 ~vn_walk_cb_data ();
1881 void *finish (alias_set_type
, alias_set_type
, tree
);
1882 void *push_partial_def (pd_data pd
,
1883 alias_set_type
, alias_set_type
, HOST_WIDE_INT
,
1888 tree
*last_vuse_ptr
;
1893 vn_lookup_kind vn_walk_kind
;
1895 bool redundant_store_removal_p
;
1896 vec
<vn_reference_op_s
> saved_operands
;
1898 /* The VDEFs of partial defs we come along. */
1899 auto_vec
<pd_data
, 2> partial_defs
;
1900 /* The first defs range to avoid splay tree setup in most cases. */
1901 pd_range first_range
;
1902 alias_set_type first_set
;
1903 alias_set_type first_base_set
;
1904 splay_tree known_ranges
;
1905 obstack ranges_obstack
;
1906 static constexpr HOST_WIDE_INT bufsize
= 64;
1909 vn_walk_cb_data::~vn_walk_cb_data ()
1913 splay_tree_delete (known_ranges
);
1914 obstack_free (&ranges_obstack
, NULL
);
1916 saved_operands
.release ();
1920 vn_walk_cb_data::finish (alias_set_type set
, alias_set_type base_set
, tree val
)
1922 if (first_set
!= -2)
1925 base_set
= first_base_set
;
1929 masked_result
= val
;
1932 if (same_val
&& !operand_equal_p (val
, same_val
))
1934 vec
<vn_reference_op_s
> &operands
1935 = saved_operands
.exists () ? saved_operands
: vr
->operands
;
1936 return vn_reference_lookup_or_insert_for_pieces (last_vuse
, set
, base_set
,
1937 vr
->type
, operands
, val
);
1940 /* pd_range splay-tree helpers. */
1943 pd_range_compare (splay_tree_key offset1p
, splay_tree_key offset2p
)
1945 HOST_WIDE_INT offset1
= *(HOST_WIDE_INT
*)offset1p
;
1946 HOST_WIDE_INT offset2
= *(HOST_WIDE_INT
*)offset2p
;
1947 if (offset1
< offset2
)
1949 else if (offset1
> offset2
)
1955 pd_tree_alloc (int size
, void *data_
)
1957 vn_walk_cb_data
*data
= (vn_walk_cb_data
*)data_
;
1958 return obstack_alloc (&data
->ranges_obstack
, size
);
1962 pd_tree_dealloc (void *, void *)
1966 /* Push PD to the vector of partial definitions returning a
1967 value when we are ready to combine things with VUSE, SET and MAXSIZEI,
1968 NULL when we want to continue looking for partial defs or -1
1972 vn_walk_cb_data::push_partial_def (pd_data pd
,
1973 alias_set_type set
, alias_set_type base_set
,
1974 HOST_WIDE_INT offseti
,
1975 HOST_WIDE_INT maxsizei
)
1977 /* We're using a fixed buffer for encoding so fail early if the object
1978 we want to interpret is bigger. */
1979 if (maxsizei
> bufsize
* BITS_PER_UNIT
1981 || BITS_PER_UNIT
!= 8
1982 /* Not prepared to handle PDP endian. */
1983 || BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
)
1986 /* Turn too large constant stores into non-constant stores. */
1987 if (CONSTANT_CLASS_P (pd
.rhs
) && pd
.size
> bufsize
* BITS_PER_UNIT
)
1988 pd
.rhs
= error_mark_node
;
1990 /* And for non-constant or CONSTRUCTOR stores shrink them to only keep at
1991 most a partial byte before and/or after the region. */
1992 if (!CONSTANT_CLASS_P (pd
.rhs
))
1994 if (pd
.offset
< offseti
)
1996 HOST_WIDE_INT o
= ROUND_DOWN (offseti
- pd
.offset
, BITS_PER_UNIT
);
1997 gcc_assert (pd
.size
> o
);
2001 if (pd
.size
> maxsizei
)
2002 pd
.size
= maxsizei
+ ((pd
.size
- maxsizei
) % BITS_PER_UNIT
);
2005 pd
.offset
-= offseti
;
2007 bool pd_constant_p
= (TREE_CODE (pd
.rhs
) == CONSTRUCTOR
2008 || CONSTANT_CLASS_P (pd
.rhs
));
2010 if (partial_defs
.is_empty ())
2012 /* If we get a clobber upfront, fail. */
2013 if (TREE_CLOBBER_P (pd
.rhs
))
2017 partial_defs
.safe_push (pd
);
2018 first_range
.offset
= pd
.offset
;
2019 first_range
.size
= pd
.size
;
2021 first_base_set
= base_set
;
2022 last_vuse_ptr
= NULL
;
2024 /* Go check if the first partial definition was a full one in case
2025 the caller didn't optimize for this. */
2031 /* ??? Optimize the case where the 2nd partial def completes
2033 gcc_obstack_init (&ranges_obstack
);
2034 known_ranges
= splay_tree_new_with_allocator (pd_range_compare
, 0, 0,
2036 pd_tree_dealloc
, this);
2037 splay_tree_insert (known_ranges
,
2038 (splay_tree_key
)&first_range
.offset
,
2039 (splay_tree_value
)&first_range
);
2042 pd_range newr
= { pd
.offset
, pd
.size
};
2044 /* Lookup the predecessor of offset + 1 and see if we need to merge. */
2045 HOST_WIDE_INT loffset
= newr
.offset
+ 1;
2046 if ((n
= splay_tree_predecessor (known_ranges
, (splay_tree_key
)&loffset
))
2047 && ((r
= (pd_range
*)n
->value
), true)
2048 && ranges_known_overlap_p (r
->offset
, r
->size
+ 1,
2049 newr
.offset
, newr
.size
))
2051 /* Ignore partial defs already covered. Here we also drop shadowed
2052 clobbers arriving here at the floor. */
2053 if (known_subrange_p (newr
.offset
, newr
.size
, r
->offset
, r
->size
))
2056 = MAX (r
->offset
+ r
->size
, newr
.offset
+ newr
.size
) - r
->offset
;
2060 /* newr.offset wasn't covered yet, insert the range. */
2061 r
= XOBNEW (&ranges_obstack
, pd_range
);
2063 splay_tree_insert (known_ranges
, (splay_tree_key
)&r
->offset
,
2064 (splay_tree_value
)r
);
2066 /* Merge r which now contains newr and is a member of the splay tree with
2067 adjacent overlapping ranges. */
2069 while ((n
= splay_tree_successor (known_ranges
,
2070 (splay_tree_key
)&r
->offset
))
2071 && ((rafter
= (pd_range
*)n
->value
), true)
2072 && ranges_known_overlap_p (r
->offset
, r
->size
+ 1,
2073 rafter
->offset
, rafter
->size
))
2075 r
->size
= MAX (r
->offset
+ r
->size
,
2076 rafter
->offset
+ rafter
->size
) - r
->offset
;
2077 splay_tree_remove (known_ranges
, (splay_tree_key
)&rafter
->offset
);
2079 /* If we get a clobber, fail. */
2080 if (TREE_CLOBBER_P (pd
.rhs
))
2082 /* Non-constants are OK as long as they are shadowed by a constant. */
2085 partial_defs
.safe_push (pd
);
2088 /* Now we have merged newr into the range tree. When we have covered
2089 [offseti, sizei] then the tree will contain exactly one node which has
2090 the desired properties and it will be 'r'. */
2091 if (!known_subrange_p (0, maxsizei
, r
->offset
, r
->size
))
2092 /* Continue looking for partial defs. */
2095 /* Now simply native encode all partial defs in reverse order. */
2096 unsigned ndefs
= partial_defs
.length ();
2097 /* We support up to 512-bit values (for V8DFmode). */
2098 unsigned char buffer
[bufsize
+ 1];
2099 unsigned char this_buffer
[bufsize
+ 1];
2102 memset (buffer
, 0, bufsize
+ 1);
2103 unsigned needed_len
= ROUND_UP (maxsizei
, BITS_PER_UNIT
) / BITS_PER_UNIT
;
2104 while (!partial_defs
.is_empty ())
2106 pd_data pd
= partial_defs
.pop ();
2108 if (TREE_CODE (pd
.rhs
) == CONSTRUCTOR
)
2110 /* Empty CONSTRUCTOR. */
2111 if (pd
.size
>= needed_len
* BITS_PER_UNIT
)
2114 len
= ROUND_UP (pd
.size
, BITS_PER_UNIT
) / BITS_PER_UNIT
;
2115 memset (this_buffer
, 0, len
);
2117 else if (pd
.rhs_off
>= 0)
2119 len
= native_encode_expr (pd
.rhs
, this_buffer
, bufsize
,
2120 (MAX (0, -pd
.offset
)
2121 + pd
.rhs_off
) / BITS_PER_UNIT
);
2123 || len
< (ROUND_UP (pd
.size
, BITS_PER_UNIT
) / BITS_PER_UNIT
2124 - MAX (0, -pd
.offset
) / BITS_PER_UNIT
))
2126 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2127 fprintf (dump_file
, "Failed to encode %u "
2128 "partial definitions\n", ndefs
);
2132 else /* negative pd.rhs_off indicates we want to chop off first bits */
2134 if (-pd
.rhs_off
>= bufsize
)
2136 len
= native_encode_expr (pd
.rhs
,
2137 this_buffer
+ -pd
.rhs_off
/ BITS_PER_UNIT
,
2138 bufsize
- -pd
.rhs_off
/ BITS_PER_UNIT
,
2139 MAX (0, -pd
.offset
) / BITS_PER_UNIT
);
2141 || len
< (ROUND_UP (pd
.size
, BITS_PER_UNIT
) / BITS_PER_UNIT
2142 - MAX (0, -pd
.offset
) / BITS_PER_UNIT
))
2144 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2145 fprintf (dump_file
, "Failed to encode %u "
2146 "partial definitions\n", ndefs
);
2151 unsigned char *p
= buffer
;
2152 HOST_WIDE_INT size
= pd
.size
;
2154 size
-= ROUND_DOWN (-pd
.offset
, BITS_PER_UNIT
);
2155 this_buffer
[len
] = 0;
2156 if (BYTES_BIG_ENDIAN
)
2158 /* LSB of this_buffer[len - 1] byte should be at
2159 pd.offset + pd.size - 1 bits in buffer. */
2160 amnt
= ((unsigned HOST_WIDE_INT
) pd
.offset
2161 + pd
.size
) % BITS_PER_UNIT
;
2163 shift_bytes_in_array_right (this_buffer
, len
+ 1, amnt
);
2164 unsigned char *q
= this_buffer
;
2165 unsigned int off
= 0;
2169 off
= pd
.offset
/ BITS_PER_UNIT
;
2170 gcc_assert (off
< needed_len
);
2174 msk
= ((1 << size
) - 1) << (BITS_PER_UNIT
- amnt
);
2175 *p
= (*p
& ~msk
) | (this_buffer
[len
] & msk
);
2180 if (TREE_CODE (pd
.rhs
) != CONSTRUCTOR
)
2181 q
= (this_buffer
+ len
2182 - (ROUND_UP (size
- amnt
, BITS_PER_UNIT
)
2184 if (pd
.offset
% BITS_PER_UNIT
)
2186 msk
= -1U << (BITS_PER_UNIT
2187 - (pd
.offset
% BITS_PER_UNIT
));
2188 *p
= (*p
& msk
) | (*q
& ~msk
);
2192 size
-= BITS_PER_UNIT
- (pd
.offset
% BITS_PER_UNIT
);
2193 gcc_assert (size
>= 0);
2197 else if (TREE_CODE (pd
.rhs
) != CONSTRUCTOR
)
2199 q
= (this_buffer
+ len
2200 - (ROUND_UP (size
- amnt
, BITS_PER_UNIT
)
2202 if (pd
.offset
% BITS_PER_UNIT
)
2205 size
-= BITS_PER_UNIT
- ((unsigned HOST_WIDE_INT
) pd
.offset
2207 gcc_assert (size
>= 0);
2210 if ((unsigned HOST_WIDE_INT
) size
/ BITS_PER_UNIT
+ off
2212 size
= (needed_len
- off
) * BITS_PER_UNIT
;
2213 memcpy (p
, q
, size
/ BITS_PER_UNIT
);
2214 if (size
% BITS_PER_UNIT
)
2217 = -1U << (BITS_PER_UNIT
- (size
% BITS_PER_UNIT
));
2218 p
+= size
/ BITS_PER_UNIT
;
2219 q
+= size
/ BITS_PER_UNIT
;
2220 *p
= (*q
& msk
) | (*p
& ~msk
);
2227 /* LSB of this_buffer[0] byte should be at pd.offset bits
2230 size
= MIN (size
, (HOST_WIDE_INT
) needed_len
* BITS_PER_UNIT
);
2231 amnt
= pd
.offset
% BITS_PER_UNIT
;
2233 shift_bytes_in_array_left (this_buffer
, len
+ 1, amnt
);
2234 unsigned int off
= pd
.offset
/ BITS_PER_UNIT
;
2235 gcc_assert (off
< needed_len
);
2237 (HOST_WIDE_INT
) (needed_len
- off
) * BITS_PER_UNIT
);
2239 if (amnt
+ size
< BITS_PER_UNIT
)
2241 /* Low amnt bits come from *p, then size bits
2242 from this_buffer[0] and the remaining again from
2244 msk
= ((1 << size
) - 1) << amnt
;
2245 *p
= (*p
& ~msk
) | (this_buffer
[0] & msk
);
2251 *p
= (*p
& ~msk
) | (this_buffer
[0] & msk
);
2253 size
-= (BITS_PER_UNIT
- amnt
);
2258 amnt
= (unsigned HOST_WIDE_INT
) pd
.offset
% BITS_PER_UNIT
;
2260 size
-= BITS_PER_UNIT
- amnt
;
2261 size
= MIN (size
, (HOST_WIDE_INT
) needed_len
* BITS_PER_UNIT
);
2263 shift_bytes_in_array_left (this_buffer
, len
+ 1, amnt
);
2265 memcpy (p
, this_buffer
+ (amnt
!= 0), size
/ BITS_PER_UNIT
);
2266 p
+= size
/ BITS_PER_UNIT
;
2267 if (size
% BITS_PER_UNIT
)
2269 unsigned int msk
= -1U << (size
% BITS_PER_UNIT
);
2270 *p
= (this_buffer
[(amnt
!= 0) + size
/ BITS_PER_UNIT
]
2271 & ~msk
) | (*p
& msk
);
2276 tree type
= vr
->type
;
2277 /* Make sure to interpret in a type that has a range covering the whole
2279 if (INTEGRAL_TYPE_P (vr
->type
) && maxsizei
!= TYPE_PRECISION (vr
->type
))
2280 type
= build_nonstandard_integer_type (maxsizei
, TYPE_UNSIGNED (type
));
2282 if (BYTES_BIG_ENDIAN
)
2284 unsigned sz
= needed_len
;
2285 if (maxsizei
% BITS_PER_UNIT
)
2286 shift_bytes_in_array_right (buffer
, needed_len
,
2288 - (maxsizei
% BITS_PER_UNIT
));
2289 if (INTEGRAL_TYPE_P (type
))
2290 sz
= GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type
));
2291 if (sz
> needed_len
)
2293 memcpy (this_buffer
+ (sz
- needed_len
), buffer
, needed_len
);
2294 val
= native_interpret_expr (type
, this_buffer
, sz
);
2297 val
= native_interpret_expr (type
, buffer
, needed_len
);
2300 val
= native_interpret_expr (type
, buffer
, bufsize
);
2301 /* If we chop off bits because the types precision doesn't match the memory
2302 access size this is ok when optimizing reads but not when called from
2303 the DSE code during elimination. */
2304 if (val
&& type
!= vr
->type
)
2306 if (! int_fits_type_p (val
, vr
->type
))
2309 val
= fold_convert (vr
->type
, val
);
2314 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2316 "Successfully combined %u partial definitions\n", ndefs
);
2317 /* We are using the alias-set of the first store we encounter which
2318 should be appropriate here. */
2319 return finish (first_set
, first_base_set
, val
);
2323 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2325 "Failed to interpret %u encoded partial definitions\n", ndefs
);
2330 /* Callback for walk_non_aliased_vuses. Adjusts the vn_reference_t VR_
2331 with the current VUSE and performs the expression lookup. */
2334 vn_reference_lookup_2 (ao_ref
*op
, tree vuse
, void *data_
)
2336 vn_walk_cb_data
*data
= (vn_walk_cb_data
*)data_
;
2337 vn_reference_t vr
= data
->vr
;
2338 vn_reference_s
**slot
;
2341 /* If we have partial definitions recorded we have to go through
2342 vn_reference_lookup_3. */
2343 if (!data
->partial_defs
.is_empty ())
2346 if (data
->last_vuse_ptr
)
2348 *data
->last_vuse_ptr
= vuse
;
2349 data
->last_vuse
= vuse
;
2352 /* Fixup vuse and hash. */
2354 vr
->hashcode
= vr
->hashcode
- SSA_NAME_VERSION (vr
->vuse
);
2355 vr
->vuse
= vuse_ssa_val (vuse
);
2357 vr
->hashcode
= vr
->hashcode
+ SSA_NAME_VERSION (vr
->vuse
);
2359 hash
= vr
->hashcode
;
2360 slot
= valid_info
->references
->find_slot_with_hash (vr
, hash
, NO_INSERT
);
2363 if ((*slot
)->result
&& data
->saved_operands
.exists ())
2364 return data
->finish (vr
->set
, vr
->base_set
, (*slot
)->result
);
2368 if (SSA_NAME_IS_DEFAULT_DEF (vuse
))
2370 HOST_WIDE_INT op_offset
, op_size
;
2372 tree base
= ao_ref_base (op
);
2375 && op
->offset
.is_constant (&op_offset
)
2376 && op
->size
.is_constant (&op_size
)
2377 && op
->max_size_known_p ()
2378 && known_eq (op
->size
, op
->max_size
))
2380 if (TREE_CODE (base
) == PARM_DECL
)
2381 v
= ipcp_get_aggregate_const (cfun
, base
, false, op_offset
,
2383 else if (TREE_CODE (base
) == MEM_REF
2384 && integer_zerop (TREE_OPERAND (base
, 1))
2385 && TREE_CODE (TREE_OPERAND (base
, 0)) == SSA_NAME
2386 && SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (base
, 0))
2387 && (TREE_CODE (SSA_NAME_VAR (TREE_OPERAND (base
, 0)))
2389 v
= ipcp_get_aggregate_const (cfun
,
2390 SSA_NAME_VAR (TREE_OPERAND (base
, 0)),
2391 true, op_offset
, op_size
);
2394 return data
->finish (vr
->set
, vr
->base_set
, v
);
2400 /* Lookup an existing or insert a new vn_reference entry into the
2401 value table for the VUSE, SET, TYPE, OPERANDS reference which
2402 has the value VALUE which is either a constant or an SSA name. */
2404 static vn_reference_t
2405 vn_reference_lookup_or_insert_for_pieces (tree vuse
,
2407 alias_set_type base_set
,
2409 vec
<vn_reference_op_s
,
2414 vn_reference_t result
;
2416 vr1
.vuse
= vuse
? SSA_VAL (vuse
) : NULL_TREE
;
2417 vr1
.operands
= operands
;
2420 vr1
.base_set
= base_set
;
2421 vr1
.hashcode
= vn_reference_compute_hash (&vr1
);
2422 if (vn_reference_lookup_1 (&vr1
, &result
))
2424 if (TREE_CODE (value
) == SSA_NAME
)
2425 value_id
= VN_INFO (value
)->value_id
;
2427 value_id
= get_or_alloc_constant_value_id (value
);
2428 return vn_reference_insert_pieces (vuse
, set
, base_set
, type
,
2429 operands
.copy (), value
, value_id
);
2432 /* Return a value-number for RCODE OPS... either by looking up an existing
2433 value-number for the possibly simplified result or by inserting the
2434 operation if INSERT is true. If SIMPLIFY is false, return a value
2435 number for the unsimplified expression. */
2438 vn_nary_build_or_lookup_1 (gimple_match_op
*res_op
, bool insert
,
2441 tree result
= NULL_TREE
;
2442 /* We will be creating a value number for
2444 So first simplify and lookup this expression to see if it
2445 is already available. */
2446 /* For simplification valueize. */
2449 for (i
= 0; i
< res_op
->num_ops
; ++i
)
2450 if (TREE_CODE (res_op
->ops
[i
]) == SSA_NAME
)
2452 tree tem
= vn_valueize (res_op
->ops
[i
]);
2455 res_op
->ops
[i
] = tem
;
2457 /* If valueization of an operand fails (it is not available), skip
2460 if (i
== res_op
->num_ops
)
2462 mprts_hook
= vn_lookup_simplify_result
;
2463 res
= res_op
->resimplify (NULL
, vn_valueize
);
2466 gimple
*new_stmt
= NULL
;
2468 && gimple_simplified_result_is_gimple_val (res_op
))
2470 /* The expression is already available. */
2471 result
= res_op
->ops
[0];
2472 /* Valueize it, simplification returns sth in AVAIL only. */
2473 if (TREE_CODE (result
) == SSA_NAME
)
2474 result
= SSA_VAL (result
);
2478 tree val
= vn_lookup_simplify_result (res_op
);
2481 gimple_seq stmts
= NULL
;
2482 result
= maybe_push_res_to_seq (res_op
, &stmts
);
2485 gcc_assert (gimple_seq_singleton_p (stmts
));
2486 new_stmt
= gimple_seq_first_stmt (stmts
);
2490 /* The expression is already available. */
2495 /* The expression is not yet available, value-number lhs to
2496 the new SSA_NAME we created. */
2497 /* Initialize value-number information properly. */
2498 vn_ssa_aux_t result_info
= VN_INFO (result
);
2499 result_info
->valnum
= result
;
2500 result_info
->value_id
= get_next_value_id ();
2501 result_info
->visited
= 1;
2502 gimple_seq_add_stmt_without_update (&VN_INFO (result
)->expr
,
2504 result_info
->needs_insertion
= true;
2505 /* ??? PRE phi-translation inserts NARYs without corresponding
2506 SSA name result. Re-use those but set their result according
2507 to the stmt we just built. */
2508 vn_nary_op_t nary
= NULL
;
2509 vn_nary_op_lookup_stmt (new_stmt
, &nary
);
2512 gcc_assert (! nary
->predicated_values
&& nary
->u
.result
== NULL_TREE
);
2513 nary
->u
.result
= gimple_assign_lhs (new_stmt
);
2515 /* As all "inserted" statements are singleton SCCs, insert
2516 to the valid table. This is strictly needed to
2517 avoid re-generating new value SSA_NAMEs for the same
2518 expression during SCC iteration over and over (the
2519 optimistic table gets cleared after each iteration).
2520 We do not need to insert into the optimistic table, as
2521 lookups there will fall back to the valid table. */
2524 unsigned int length
= vn_nary_length_from_stmt (new_stmt
);
2526 = alloc_vn_nary_op_noinit (length
, &vn_tables_insert_obstack
);
2527 vno1
->value_id
= result_info
->value_id
;
2528 vno1
->length
= length
;
2529 vno1
->predicated_values
= 0;
2530 vno1
->u
.result
= result
;
2531 init_vn_nary_op_from_stmt (vno1
, as_a
<gassign
*> (new_stmt
));
2532 vn_nary_op_insert_into (vno1
, valid_info
->nary
);
2533 /* Also do not link it into the undo chain. */
2534 last_inserted_nary
= vno1
->next
;
2535 vno1
->next
= (vn_nary_op_t
)(void *)-1;
2537 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2539 fprintf (dump_file
, "Inserting name ");
2540 print_generic_expr (dump_file
, result
);
2541 fprintf (dump_file
, " for expression ");
2542 print_gimple_expr (dump_file
, new_stmt
, 0, TDF_SLIM
);
2543 fprintf (dump_file
, "\n");
2549 /* Return a value-number for RCODE OPS... either by looking up an existing
2550 value-number for the simplified result or by inserting the operation. */
2553 vn_nary_build_or_lookup (gimple_match_op
*res_op
)
2555 return vn_nary_build_or_lookup_1 (res_op
, true, true);
2558 /* Try to simplify the expression RCODE OPS... of type TYPE and return
2559 its value if present. */
2562 vn_nary_simplify (vn_nary_op_t nary
)
2564 if (nary
->length
> gimple_match_op::MAX_NUM_OPS
)
2566 gimple_match_op
op (gimple_match_cond::UNCOND
, nary
->opcode
,
2567 nary
->type
, nary
->length
);
2568 memcpy (op
.ops
, nary
->op
, sizeof (tree
) * nary
->length
);
2569 return vn_nary_build_or_lookup_1 (&op
, false, true);
2572 /* Elimination engine. */
2574 class eliminate_dom_walker
: public dom_walker
2577 eliminate_dom_walker (cdi_direction
, bitmap
);
2578 ~eliminate_dom_walker ();
2580 edge
before_dom_children (basic_block
) final override
;
2581 void after_dom_children (basic_block
) final override
;
2583 virtual tree
eliminate_avail (basic_block
, tree op
);
2584 virtual void eliminate_push_avail (basic_block
, tree op
);
2585 tree
eliminate_insert (basic_block
, gimple_stmt_iterator
*gsi
, tree val
);
2587 void eliminate_stmt (basic_block
, gimple_stmt_iterator
*);
2589 unsigned eliminate_cleanup (bool region_p
= false);
2592 unsigned int el_todo
;
2593 unsigned int eliminations
;
2594 unsigned int insertions
;
2596 /* SSA names that had their defs inserted by PRE if do_pre. */
2597 bitmap inserted_exprs
;
2599 /* Blocks with statements that have had their EH properties changed. */
2600 bitmap need_eh_cleanup
;
2602 /* Blocks with statements that have had their AB properties changed. */
2603 bitmap need_ab_cleanup
;
2605 /* Local state for the eliminate domwalk. */
2606 auto_vec
<gimple
*> to_remove
;
2607 auto_vec
<gimple
*> to_fixup
;
2608 auto_vec
<tree
> avail
;
2609 auto_vec
<tree
> avail_stack
;
2612 /* Adaptor to the elimination engine using RPO availability. */
2614 class rpo_elim
: public eliminate_dom_walker
2617 rpo_elim(basic_block entry_
)
2618 : eliminate_dom_walker (CDI_DOMINATORS
, NULL
), entry (entry_
),
2619 m_avail_freelist (NULL
) {}
2621 tree
eliminate_avail (basic_block
, tree op
) final override
;
2623 void eliminate_push_avail (basic_block
, tree
) final override
;
2626 /* Freelist of avail entries which are allocated from the vn_ssa_aux
2628 vn_avail
*m_avail_freelist
;
2631 /* Global RPO state for access from hooks. */
2632 static eliminate_dom_walker
*rpo_avail
;
2633 basic_block vn_context_bb
;
2635 /* Return true if BASE1 and BASE2 can be adjusted so they have the
2636 same address and adjust *OFFSET1 and *OFFSET2 accordingly.
2637 Otherwise return false. */
2640 adjust_offsets_for_equal_base_address (tree base1
, poly_int64
*offset1
,
2641 tree base2
, poly_int64
*offset2
)
2644 if (TREE_CODE (base1
) == MEM_REF
2645 && TREE_CODE (base2
) == MEM_REF
)
2647 if (mem_ref_offset (base1
).to_shwi (&soff
))
2649 base1
= TREE_OPERAND (base1
, 0);
2650 *offset1
+= soff
* BITS_PER_UNIT
;
2652 if (mem_ref_offset (base2
).to_shwi (&soff
))
2654 base2
= TREE_OPERAND (base2
, 0);
2655 *offset2
+= soff
* BITS_PER_UNIT
;
2657 return operand_equal_p (base1
, base2
, 0);
2659 return operand_equal_p (base1
, base2
, OEP_ADDRESS_OF
);
2662 /* Callback for walk_non_aliased_vuses. Tries to perform a lookup
2663 from the statement defining VUSE and if not successful tries to
2664 translate *REFP and VR_ through an aggregate copy at the definition
2665 of VUSE. If *DISAMBIGUATE_ONLY is true then do not perform translation
2666 of *REF and *VR. If only disambiguation was performed then
2667 *DISAMBIGUATE_ONLY is set to true. */
2670 vn_reference_lookup_3 (ao_ref
*ref
, tree vuse
, void *data_
,
2671 translate_flags
*disambiguate_only
)
2673 vn_walk_cb_data
*data
= (vn_walk_cb_data
*)data_
;
2674 vn_reference_t vr
= data
->vr
;
2675 gimple
*def_stmt
= SSA_NAME_DEF_STMT (vuse
);
2676 tree base
= ao_ref_base (ref
);
2677 HOST_WIDE_INT offseti
= 0, maxsizei
, sizei
= 0;
2678 static vec
<vn_reference_op_s
> lhs_ops
;
2680 bool lhs_ref_ok
= false;
2681 poly_int64 copy_size
;
2683 /* First try to disambiguate after value-replacing in the definitions LHS. */
2684 if (is_gimple_assign (def_stmt
))
2686 tree lhs
= gimple_assign_lhs (def_stmt
);
2687 bool valueized_anything
= false;
2688 /* Avoid re-allocation overhead. */
2689 lhs_ops
.truncate (0);
2690 basic_block saved_rpo_bb
= vn_context_bb
;
2691 vn_context_bb
= gimple_bb (def_stmt
);
2692 if (*disambiguate_only
<= TR_VALUEIZE_AND_DISAMBIGUATE
)
2694 copy_reference_ops_from_ref (lhs
, &lhs_ops
);
2695 valueize_refs_1 (&lhs_ops
, &valueized_anything
, true);
2697 vn_context_bb
= saved_rpo_bb
;
2698 ao_ref_init (&lhs_ref
, lhs
);
2700 if (valueized_anything
2701 && ao_ref_init_from_vn_reference
2702 (&lhs_ref
, ao_ref_alias_set (&lhs_ref
),
2703 ao_ref_base_alias_set (&lhs_ref
), TREE_TYPE (lhs
), lhs_ops
)
2704 && !refs_may_alias_p_1 (ref
, &lhs_ref
, data
->tbaa_p
))
2706 *disambiguate_only
= TR_VALUEIZE_AND_DISAMBIGUATE
;
2710 /* When the def is a CLOBBER we can optimistically disambiguate
2711 against it since any overlap it would be undefined behavior.
2712 Avoid this for obvious must aliases to save compile-time though.
2713 We also may not do this when the query is used for redundant
2715 if (!data
->redundant_store_removal_p
2716 && gimple_clobber_p (def_stmt
)
2717 && !operand_equal_p (ao_ref_base (&lhs_ref
), base
, OEP_ADDRESS_OF
))
2719 *disambiguate_only
= TR_DISAMBIGUATE
;
2723 /* Besides valueizing the LHS we can also use access-path based
2724 disambiguation on the original non-valueized ref. */
2727 && data
->orig_ref
.ref
)
2729 /* We want to use the non-valueized LHS for this, but avoid redundant
2731 ao_ref
*lref
= &lhs_ref
;
2733 if (valueized_anything
)
2735 ao_ref_init (&lref_alt
, lhs
);
2738 if (!refs_may_alias_p_1 (&data
->orig_ref
, lref
, data
->tbaa_p
))
2740 *disambiguate_only
= (valueized_anything
2741 ? TR_VALUEIZE_AND_DISAMBIGUATE
2747 /* If we reach a clobbering statement try to skip it and see if
2748 we find a VN result with exactly the same value as the
2749 possible clobber. In this case we can ignore the clobber
2750 and return the found value. */
2751 if (is_gimple_reg_type (TREE_TYPE (lhs
))
2752 && types_compatible_p (TREE_TYPE (lhs
), vr
->type
)
2753 && (ref
->ref
|| data
->orig_ref
.ref
)
2755 && data
->partial_defs
.is_empty ()
2756 && multiple_p (get_object_alignment
2757 (ref
->ref
? ref
->ref
: data
->orig_ref
.ref
),
2759 && multiple_p (get_object_alignment (lhs
), ref
->size
))
2761 tree rhs
= gimple_assign_rhs1 (def_stmt
);
2762 /* ??? We may not compare to ahead values which might be from
2763 a different loop iteration but only to loop invariants. Use
2764 CONSTANT_CLASS_P (unvalueized!) as conservative approximation.
2765 The one-hop lookup below doesn't have this issue since there's
2766 a virtual PHI before we ever reach a backedge to cross.
2767 We can skip multiple defs as long as they are from the same
2770 && !operand_equal_p (data
->same_val
, rhs
))
2772 else if (CONSTANT_CLASS_P (rhs
))
2774 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2777 "Skipping possible redundant definition ");
2778 print_gimple_stmt (dump_file
, def_stmt
, 0);
2780 /* Delay the actual compare of the values to the end of the walk
2781 but do not update last_vuse from here. */
2782 data
->last_vuse_ptr
= NULL
;
2783 data
->same_val
= rhs
;
2788 tree
*saved_last_vuse_ptr
= data
->last_vuse_ptr
;
2789 /* Do not update last_vuse_ptr in vn_reference_lookup_2. */
2790 data
->last_vuse_ptr
= NULL
;
2791 tree saved_vuse
= vr
->vuse
;
2792 hashval_t saved_hashcode
= vr
->hashcode
;
2793 void *res
= vn_reference_lookup_2 (ref
, gimple_vuse (def_stmt
),
2795 /* Need to restore vr->vuse and vr->hashcode. */
2796 vr
->vuse
= saved_vuse
;
2797 vr
->hashcode
= saved_hashcode
;
2798 data
->last_vuse_ptr
= saved_last_vuse_ptr
;
2799 if (res
&& res
!= (void *)-1)
2801 vn_reference_t vnresult
= (vn_reference_t
) res
;
2802 if (TREE_CODE (rhs
) == SSA_NAME
)
2803 rhs
= SSA_VAL (rhs
);
2804 if (vnresult
->result
2805 && operand_equal_p (vnresult
->result
, rhs
, 0))
2811 else if (*disambiguate_only
<= TR_VALUEIZE_AND_DISAMBIGUATE
2812 && gimple_call_builtin_p (def_stmt
, BUILT_IN_NORMAL
)
2813 && gimple_call_num_args (def_stmt
) <= 4)
2815 /* For builtin calls valueize its arguments and call the
2816 alias oracle again. Valueization may improve points-to
2817 info of pointers and constify size and position arguments.
2818 Originally this was motivated by PR61034 which has
2819 conditional calls to free falsely clobbering ref because
2820 of imprecise points-to info of the argument. */
2822 bool valueized_anything
= false;
2823 for (unsigned i
= 0; i
< gimple_call_num_args (def_stmt
); ++i
)
2825 oldargs
[i
] = gimple_call_arg (def_stmt
, i
);
2826 tree val
= vn_valueize (oldargs
[i
]);
2827 if (val
!= oldargs
[i
])
2829 gimple_call_set_arg (def_stmt
, i
, val
);
2830 valueized_anything
= true;
2833 if (valueized_anything
)
2835 bool res
= call_may_clobber_ref_p_1 (as_a
<gcall
*> (def_stmt
),
2837 for (unsigned i
= 0; i
< gimple_call_num_args (def_stmt
); ++i
)
2838 gimple_call_set_arg (def_stmt
, i
, oldargs
[i
]);
2841 *disambiguate_only
= TR_VALUEIZE_AND_DISAMBIGUATE
;
2847 if (*disambiguate_only
> TR_TRANSLATE
)
2850 /* If we cannot constrain the size of the reference we cannot
2851 test if anything kills it. */
2852 if (!ref
->max_size_known_p ())
2855 poly_int64 offset
= ref
->offset
;
2856 poly_int64 maxsize
= ref
->max_size
;
2858 /* def_stmt may-defs *ref. See if we can derive a value for *ref
2859 from that definition.
2861 if (is_gimple_reg_type (vr
->type
)
2862 && (gimple_call_builtin_p (def_stmt
, BUILT_IN_MEMSET
)
2863 || gimple_call_builtin_p (def_stmt
, BUILT_IN_MEMSET_CHK
))
2864 && (integer_zerop (gimple_call_arg (def_stmt
, 1))
2865 || ((TREE_CODE (gimple_call_arg (def_stmt
, 1)) == INTEGER_CST
2866 || (INTEGRAL_TYPE_P (vr
->type
) && known_eq (ref
->size
, 8)))
2868 && BITS_PER_UNIT
== 8
2869 && BYTES_BIG_ENDIAN
== WORDS_BIG_ENDIAN
2870 && offset
.is_constant (&offseti
)
2871 && ref
->size
.is_constant (&sizei
)
2872 && (offseti
% BITS_PER_UNIT
== 0
2873 || TREE_CODE (gimple_call_arg (def_stmt
, 1)) == INTEGER_CST
)))
2874 && (poly_int_tree_p (gimple_call_arg (def_stmt
, 2))
2875 || (TREE_CODE (gimple_call_arg (def_stmt
, 2)) == SSA_NAME
2876 && poly_int_tree_p (SSA_VAL (gimple_call_arg (def_stmt
, 2)))))
2877 && (TREE_CODE (gimple_call_arg (def_stmt
, 0)) == ADDR_EXPR
2878 || TREE_CODE (gimple_call_arg (def_stmt
, 0)) == SSA_NAME
))
2881 poly_int64 offset2
, size2
, maxsize2
;
2883 tree ref2
= gimple_call_arg (def_stmt
, 0);
2884 if (TREE_CODE (ref2
) == SSA_NAME
)
2886 ref2
= SSA_VAL (ref2
);
2887 if (TREE_CODE (ref2
) == SSA_NAME
2888 && (TREE_CODE (base
) != MEM_REF
2889 || TREE_OPERAND (base
, 0) != ref2
))
2891 gimple
*def_stmt
= SSA_NAME_DEF_STMT (ref2
);
2892 if (gimple_assign_single_p (def_stmt
)
2893 && gimple_assign_rhs_code (def_stmt
) == ADDR_EXPR
)
2894 ref2
= gimple_assign_rhs1 (def_stmt
);
2897 if (TREE_CODE (ref2
) == ADDR_EXPR
)
2899 ref2
= TREE_OPERAND (ref2
, 0);
2900 base2
= get_ref_base_and_extent (ref2
, &offset2
, &size2
, &maxsize2
,
2902 if (!known_size_p (maxsize2
)
2903 || !known_eq (maxsize2
, size2
)
2904 || !operand_equal_p (base
, base2
, OEP_ADDRESS_OF
))
2907 else if (TREE_CODE (ref2
) == SSA_NAME
)
2910 if (TREE_CODE (base
) != MEM_REF
2911 || !(mem_ref_offset (base
)
2912 << LOG2_BITS_PER_UNIT
).to_shwi (&soff
))
2916 if (TREE_OPERAND (base
, 0) != ref2
)
2918 gimple
*def
= SSA_NAME_DEF_STMT (ref2
);
2919 if (is_gimple_assign (def
)
2920 && gimple_assign_rhs_code (def
) == POINTER_PLUS_EXPR
2921 && gimple_assign_rhs1 (def
) == TREE_OPERAND (base
, 0)
2922 && poly_int_tree_p (gimple_assign_rhs2 (def
)))
2924 tree rhs2
= gimple_assign_rhs2 (def
);
2925 if (!(poly_offset_int::from (wi::to_poly_wide (rhs2
),
2927 << LOG2_BITS_PER_UNIT
).to_shwi (&offset2
))
2929 ref2
= gimple_assign_rhs1 (def
);
2930 if (TREE_CODE (ref2
) == SSA_NAME
)
2931 ref2
= SSA_VAL (ref2
);
2939 tree len
= gimple_call_arg (def_stmt
, 2);
2940 HOST_WIDE_INT leni
, offset2i
;
2941 if (TREE_CODE (len
) == SSA_NAME
)
2942 len
= SSA_VAL (len
);
2943 /* Sometimes the above trickery is smarter than alias analysis. Take
2944 advantage of that. */
2945 if (!ranges_maybe_overlap_p (offset
, maxsize
, offset2
,
2946 (wi::to_poly_offset (len
)
2947 << LOG2_BITS_PER_UNIT
)))
2949 if (data
->partial_defs
.is_empty ()
2950 && known_subrange_p (offset
, maxsize
, offset2
,
2951 wi::to_poly_offset (len
) << LOG2_BITS_PER_UNIT
))
2954 if (integer_zerop (gimple_call_arg (def_stmt
, 1)))
2955 val
= build_zero_cst (vr
->type
);
2956 else if (INTEGRAL_TYPE_P (vr
->type
)
2957 && known_eq (ref
->size
, 8)
2958 && offseti
% BITS_PER_UNIT
== 0)
2960 gimple_match_op
res_op (gimple_match_cond::UNCOND
, NOP_EXPR
,
2961 vr
->type
, gimple_call_arg (def_stmt
, 1));
2962 val
= vn_nary_build_or_lookup (&res_op
);
2964 || (TREE_CODE (val
) == SSA_NAME
2965 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val
)))
2970 unsigned buflen
= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (vr
->type
)) + 1;
2971 if (INTEGRAL_TYPE_P (vr
->type
))
2972 buflen
= GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (vr
->type
)) + 1;
2973 unsigned char *buf
= XALLOCAVEC (unsigned char, buflen
);
2974 memset (buf
, TREE_INT_CST_LOW (gimple_call_arg (def_stmt
, 1)),
2976 if (BYTES_BIG_ENDIAN
)
2979 = (((unsigned HOST_WIDE_INT
) offseti
+ sizei
)
2983 shift_bytes_in_array_right (buf
, buflen
,
2984 BITS_PER_UNIT
- amnt
);
2989 else if (offseti
% BITS_PER_UNIT
!= 0)
2992 = BITS_PER_UNIT
- ((unsigned HOST_WIDE_INT
) offseti
2994 shift_bytes_in_array_left (buf
, buflen
, amnt
);
2998 val
= native_interpret_expr (vr
->type
, buf
, buflen
);
3002 return data
->finish (0, 0, val
);
3004 /* For now handle clearing memory with partial defs. */
3005 else if (known_eq (ref
->size
, maxsize
)
3006 && integer_zerop (gimple_call_arg (def_stmt
, 1))
3007 && tree_fits_poly_int64_p (len
)
3008 && tree_to_poly_int64 (len
).is_constant (&leni
)
3009 && leni
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) / BITS_PER_UNIT
3010 && offset
.is_constant (&offseti
)
3011 && offset2
.is_constant (&offset2i
)
3012 && maxsize
.is_constant (&maxsizei
)
3013 && ranges_known_overlap_p (offseti
, maxsizei
, offset2i
,
3014 leni
<< LOG2_BITS_PER_UNIT
))
3017 pd
.rhs
= build_constructor (NULL_TREE
, NULL
);
3019 pd
.offset
= offset2i
;
3020 pd
.size
= leni
<< LOG2_BITS_PER_UNIT
;
3021 return data
->push_partial_def (pd
, 0, 0, offseti
, maxsizei
);
3025 /* 2) Assignment from an empty CONSTRUCTOR. */
3026 else if (is_gimple_reg_type (vr
->type
)
3027 && gimple_assign_single_p (def_stmt
)
3028 && gimple_assign_rhs_code (def_stmt
) == CONSTRUCTOR
3029 && CONSTRUCTOR_NELTS (gimple_assign_rhs1 (def_stmt
)) == 0)
3032 poly_int64 offset2
, size2
, maxsize2
;
3033 HOST_WIDE_INT offset2i
, size2i
;
3034 gcc_assert (lhs_ref_ok
);
3035 base2
= ao_ref_base (&lhs_ref
);
3036 offset2
= lhs_ref
.offset
;
3037 size2
= lhs_ref
.size
;
3038 maxsize2
= lhs_ref
.max_size
;
3039 if (known_size_p (maxsize2
)
3040 && known_eq (maxsize2
, size2
)
3041 && adjust_offsets_for_equal_base_address (base
, &offset
,
3044 if (data
->partial_defs
.is_empty ()
3045 && known_subrange_p (offset
, maxsize
, offset2
, size2
))
3047 /* While technically undefined behavior do not optimize
3048 a full read from a clobber. */
3049 if (gimple_clobber_p (def_stmt
))
3051 tree val
= build_zero_cst (vr
->type
);
3052 return data
->finish (ao_ref_alias_set (&lhs_ref
),
3053 ao_ref_base_alias_set (&lhs_ref
), val
);
3055 else if (known_eq (ref
->size
, maxsize
)
3056 && maxsize
.is_constant (&maxsizei
)
3057 && offset
.is_constant (&offseti
)
3058 && offset2
.is_constant (&offset2i
)
3059 && size2
.is_constant (&size2i
)
3060 && ranges_known_overlap_p (offseti
, maxsizei
,
3063 /* Let clobbers be consumed by the partial-def tracker
3064 which can choose to ignore them if they are shadowed
3067 pd
.rhs
= gimple_assign_rhs1 (def_stmt
);
3069 pd
.offset
= offset2i
;
3071 return data
->push_partial_def (pd
, ao_ref_alias_set (&lhs_ref
),
3072 ao_ref_base_alias_set (&lhs_ref
),
3078 /* 3) Assignment from a constant. We can use folds native encode/interpret
3079 routines to extract the assigned bits. */
3080 else if (known_eq (ref
->size
, maxsize
)
3081 && is_gimple_reg_type (vr
->type
)
3082 && !reverse_storage_order_for_component_p (vr
->operands
)
3083 && !contains_storage_order_barrier_p (vr
->operands
)
3084 && gimple_assign_single_p (def_stmt
)
3086 && BITS_PER_UNIT
== 8
3087 && BYTES_BIG_ENDIAN
== WORDS_BIG_ENDIAN
3088 /* native_encode and native_decode operate on arrays of bytes
3089 and so fundamentally need a compile-time size and offset. */
3090 && maxsize
.is_constant (&maxsizei
)
3091 && offset
.is_constant (&offseti
)
3092 && (is_gimple_min_invariant (gimple_assign_rhs1 (def_stmt
))
3093 || (TREE_CODE (gimple_assign_rhs1 (def_stmt
)) == SSA_NAME
3094 && is_gimple_min_invariant (SSA_VAL (gimple_assign_rhs1 (def_stmt
))))))
3096 tree lhs
= gimple_assign_lhs (def_stmt
);
3098 poly_int64 offset2
, size2
, maxsize2
;
3099 HOST_WIDE_INT offset2i
, size2i
;
3101 gcc_assert (lhs_ref_ok
);
3102 base2
= ao_ref_base (&lhs_ref
);
3103 offset2
= lhs_ref
.offset
;
3104 size2
= lhs_ref
.size
;
3105 maxsize2
= lhs_ref
.max_size
;
3106 reverse
= reverse_storage_order_for_component_p (lhs
);
3109 && !storage_order_barrier_p (lhs
)
3110 && known_eq (maxsize2
, size2
)
3111 && adjust_offsets_for_equal_base_address (base
, &offset
,
3113 && offset
.is_constant (&offseti
)
3114 && offset2
.is_constant (&offset2i
)
3115 && size2
.is_constant (&size2i
))
3117 if (data
->partial_defs
.is_empty ()
3118 && known_subrange_p (offseti
, maxsizei
, offset2
, size2
))
3120 /* We support up to 512-bit values (for V8DFmode). */
3121 unsigned char buffer
[65];
3124 tree rhs
= gimple_assign_rhs1 (def_stmt
);
3125 if (TREE_CODE (rhs
) == SSA_NAME
)
3126 rhs
= SSA_VAL (rhs
);
3127 len
= native_encode_expr (rhs
,
3128 buffer
, sizeof (buffer
) - 1,
3129 (offseti
- offset2i
) / BITS_PER_UNIT
);
3130 if (len
> 0 && len
* BITS_PER_UNIT
>= maxsizei
)
3132 tree type
= vr
->type
;
3133 unsigned char *buf
= buffer
;
3134 unsigned int amnt
= 0;
3135 /* Make sure to interpret in a type that has a range
3136 covering the whole access size. */
3137 if (INTEGRAL_TYPE_P (vr
->type
)
3138 && maxsizei
!= TYPE_PRECISION (vr
->type
))
3139 type
= build_nonstandard_integer_type (maxsizei
,
3140 TYPE_UNSIGNED (type
));
3141 if (BYTES_BIG_ENDIAN
)
3143 /* For big-endian native_encode_expr stored the rhs
3144 such that the LSB of it is the LSB of buffer[len - 1].
3145 That bit is stored into memory at position
3146 offset2 + size2 - 1, i.e. in byte
3147 base + (offset2 + size2 - 1) / BITS_PER_UNIT.
3148 E.g. for offset2 1 and size2 14, rhs -1 and memory
3149 previously cleared that is:
3152 Now, if we want to extract offset 2 and size 12 from
3153 it using native_interpret_expr (which actually works
3154 for integral bitfield types in terms of byte size of
3155 the mode), the native_encode_expr stored the value
3158 and returned len 2 (the X bits are outside of
3160 Let sz be maxsize / BITS_PER_UNIT if not extracting
3161 a bitfield, and GET_MODE_SIZE otherwise.
3162 We need to align the LSB of the value we want to
3163 extract as the LSB of buf[sz - 1].
3164 The LSB from memory we need to read is at position
3165 offset + maxsize - 1. */
3166 HOST_WIDE_INT sz
= maxsizei
/ BITS_PER_UNIT
;
3167 if (INTEGRAL_TYPE_P (type
))
3168 sz
= GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type
));
3169 amnt
= ((unsigned HOST_WIDE_INT
) offset2i
+ size2i
3170 - offseti
- maxsizei
) % BITS_PER_UNIT
;
3172 shift_bytes_in_array_right (buffer
, len
, amnt
);
3173 amnt
= ((unsigned HOST_WIDE_INT
) offset2i
+ size2i
3174 - offseti
- maxsizei
- amnt
) / BITS_PER_UNIT
;
3175 if ((unsigned HOST_WIDE_INT
) sz
+ amnt
> (unsigned) len
)
3179 buf
= buffer
+ len
- sz
- amnt
;
3180 len
-= (buf
- buffer
);
3185 amnt
= ((unsigned HOST_WIDE_INT
) offset2i
3186 - offseti
) % BITS_PER_UNIT
;
3190 shift_bytes_in_array_left (buffer
, len
+ 1, amnt
);
3194 tree val
= native_interpret_expr (type
, buf
, len
);
3195 /* If we chop off bits because the types precision doesn't
3196 match the memory access size this is ok when optimizing
3197 reads but not when called from the DSE code during
3200 && type
!= vr
->type
)
3202 if (! int_fits_type_p (val
, vr
->type
))
3205 val
= fold_convert (vr
->type
, val
);
3209 return data
->finish (ao_ref_alias_set (&lhs_ref
),
3210 ao_ref_base_alias_set (&lhs_ref
), val
);
3213 else if (ranges_known_overlap_p (offseti
, maxsizei
, offset2i
,
3217 tree rhs
= gimple_assign_rhs1 (def_stmt
);
3218 if (TREE_CODE (rhs
) == SSA_NAME
)
3219 rhs
= SSA_VAL (rhs
);
3222 pd
.offset
= offset2i
;
3224 return data
->push_partial_def (pd
, ao_ref_alias_set (&lhs_ref
),
3225 ao_ref_base_alias_set (&lhs_ref
),
3231 /* 4) Assignment from an SSA name which definition we may be able
3232 to access pieces from or we can combine to a larger entity. */
3233 else if (known_eq (ref
->size
, maxsize
)
3234 && is_gimple_reg_type (vr
->type
)
3235 && !reverse_storage_order_for_component_p (vr
->operands
)
3236 && !contains_storage_order_barrier_p (vr
->operands
)
3237 && gimple_assign_single_p (def_stmt
)
3238 && TREE_CODE (gimple_assign_rhs1 (def_stmt
)) == SSA_NAME
)
3240 tree lhs
= gimple_assign_lhs (def_stmt
);
3242 poly_int64 offset2
, size2
, maxsize2
;
3243 HOST_WIDE_INT offset2i
, size2i
, offseti
;
3245 gcc_assert (lhs_ref_ok
);
3246 base2
= ao_ref_base (&lhs_ref
);
3247 offset2
= lhs_ref
.offset
;
3248 size2
= lhs_ref
.size
;
3249 maxsize2
= lhs_ref
.max_size
;
3250 reverse
= reverse_storage_order_for_component_p (lhs
);
3251 tree def_rhs
= gimple_assign_rhs1 (def_stmt
);
3253 && !storage_order_barrier_p (lhs
)
3254 && known_size_p (maxsize2
)
3255 && known_eq (maxsize2
, size2
)
3256 && adjust_offsets_for_equal_base_address (base
, &offset
,
3259 if (data
->partial_defs
.is_empty ()
3260 && known_subrange_p (offset
, maxsize
, offset2
, size2
)
3261 /* ??? We can't handle bitfield precision extracts without
3262 either using an alternate type for the BIT_FIELD_REF and
3263 then doing a conversion or possibly adjusting the offset
3264 according to endianness. */
3265 && (! INTEGRAL_TYPE_P (vr
->type
)
3266 || known_eq (ref
->size
, TYPE_PRECISION (vr
->type
)))
3267 && multiple_p (ref
->size
, BITS_PER_UNIT
))
3269 tree val
= NULL_TREE
;
3270 if (! INTEGRAL_TYPE_P (TREE_TYPE (def_rhs
))
3271 || type_has_mode_precision_p (TREE_TYPE (def_rhs
)))
3273 gimple_match_op
op (gimple_match_cond::UNCOND
,
3274 BIT_FIELD_REF
, vr
->type
,
3276 bitsize_int (ref
->size
),
3277 bitsize_int (offset
- offset2
));
3278 val
= vn_nary_build_or_lookup (&op
);
3280 else if (known_eq (ref
->size
, size2
))
3282 gimple_match_op
op (gimple_match_cond::UNCOND
,
3283 VIEW_CONVERT_EXPR
, vr
->type
,
3285 val
= vn_nary_build_or_lookup (&op
);
3288 && (TREE_CODE (val
) != SSA_NAME
3289 || ! SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val
)))
3290 return data
->finish (ao_ref_alias_set (&lhs_ref
),
3291 ao_ref_base_alias_set (&lhs_ref
), val
);
3293 else if (maxsize
.is_constant (&maxsizei
)
3294 && offset
.is_constant (&offseti
)
3295 && offset2
.is_constant (&offset2i
)
3296 && size2
.is_constant (&size2i
)
3297 && ranges_known_overlap_p (offset
, maxsize
, offset2
, size2
))
3300 pd
.rhs
= SSA_VAL (def_rhs
);
3302 pd
.offset
= offset2i
;
3304 return data
->push_partial_def (pd
, ao_ref_alias_set (&lhs_ref
),
3305 ao_ref_base_alias_set (&lhs_ref
),
3311 /* 4b) Assignment done via one of the vectorizer internal store
3312 functions where we may be able to access pieces from or we can
3313 combine to a larger entity. */
3314 else if (known_eq (ref
->size
, maxsize
)
3315 && is_gimple_reg_type (vr
->type
)
3316 && !reverse_storage_order_for_component_p (vr
->operands
)
3317 && !contains_storage_order_barrier_p (vr
->operands
)
3318 && is_gimple_call (def_stmt
)
3319 && gimple_call_internal_p (def_stmt
)
3320 && internal_store_fn_p (gimple_call_internal_fn (def_stmt
)))
3322 gcall
*call
= as_a
<gcall
*> (def_stmt
);
3323 internal_fn fn
= gimple_call_internal_fn (call
);
3325 tree mask
= NULL_TREE
, len
= NULL_TREE
, bias
= NULL_TREE
;
3328 case IFN_MASK_STORE
:
3329 mask
= gimple_call_arg (call
, internal_fn_mask_index (fn
));
3330 mask
= vn_valueize (mask
);
3331 if (TREE_CODE (mask
) != VECTOR_CST
)
3336 int len_index
= internal_fn_len_index (fn
);
3337 len
= gimple_call_arg (call
, len_index
);
3338 bias
= gimple_call_arg (call
, len_index
+ 1);
3339 if (!tree_fits_uhwi_p (len
) || !tree_fits_shwi_p (bias
))
3346 tree def_rhs
= gimple_call_arg (call
,
3347 internal_fn_stored_value_index (fn
));
3348 def_rhs
= vn_valueize (def_rhs
);
3349 if (TREE_CODE (def_rhs
) != VECTOR_CST
)
3352 ao_ref_init_from_ptr_and_size (&lhs_ref
,
3353 vn_valueize (gimple_call_arg (call
, 0)),
3354 TYPE_SIZE_UNIT (TREE_TYPE (def_rhs
)));
3356 poly_int64 offset2
, size2
, maxsize2
;
3357 HOST_WIDE_INT offset2i
, size2i
, offseti
;
3358 base2
= ao_ref_base (&lhs_ref
);
3359 offset2
= lhs_ref
.offset
;
3360 size2
= lhs_ref
.size
;
3361 maxsize2
= lhs_ref
.max_size
;
3362 if (known_size_p (maxsize2
)
3363 && known_eq (maxsize2
, size2
)
3364 && adjust_offsets_for_equal_base_address (base
, &offset
,
3366 && maxsize
.is_constant (&maxsizei
)
3367 && offset
.is_constant (&offseti
)
3368 && offset2
.is_constant (&offset2i
)
3369 && size2
.is_constant (&size2i
))
3371 if (!ranges_maybe_overlap_p (offset
, maxsize
, offset2
, size2
))
3372 /* Poor-mans disambiguation. */
3374 else if (ranges_known_overlap_p (offset
, maxsize
, offset2
, size2
))
3378 tree aa
= gimple_call_arg (call
, 1);
3379 alias_set_type set
= get_deref_alias_set (TREE_TYPE (aa
));
3380 tree vectype
= TREE_TYPE (def_rhs
);
3381 unsigned HOST_WIDE_INT elsz
3382 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (vectype
)));
3385 HOST_WIDE_INT start
= 0, length
= 0;
3386 unsigned mask_idx
= 0;
3389 if (integer_zerop (VECTOR_CST_ELT (mask
, mask_idx
)))
3394 pd
.offset
= offset2i
+ start
;
3396 if (ranges_known_overlap_p
3397 (offset
, maxsize
, pd
.offset
, pd
.size
))
3399 void *res
= data
->push_partial_def
3400 (pd
, set
, set
, offseti
, maxsizei
);
3405 start
= (mask_idx
+ 1) * elsz
;
3412 while (known_lt (mask_idx
, TYPE_VECTOR_SUBPARTS (vectype
)));
3416 pd
.offset
= offset2i
+ start
;
3418 if (ranges_known_overlap_p (offset
, maxsize
,
3419 pd
.offset
, pd
.size
))
3420 return data
->push_partial_def (pd
, set
, set
,
3424 else if (fn
== IFN_LEN_STORE
)
3426 pd
.offset
= offset2i
;
3427 pd
.size
= (tree_to_uhwi (len
)
3428 + -tree_to_shwi (bias
)) * BITS_PER_UNIT
;
3429 if (BYTES_BIG_ENDIAN
)
3430 pd
.rhs_off
= pd
.size
- tree_to_uhwi (TYPE_SIZE (vectype
));
3433 if (ranges_known_overlap_p (offset
, maxsize
,
3434 pd
.offset
, pd
.size
))
3435 return data
->push_partial_def (pd
, set
, set
,
3445 /* 5) For aggregate copies translate the reference through them if
3446 the copy kills ref. */
3447 else if (data
->vn_walk_kind
== VN_WALKREWRITE
3448 && gimple_assign_single_p (def_stmt
)
3449 && (DECL_P (gimple_assign_rhs1 (def_stmt
))
3450 || TREE_CODE (gimple_assign_rhs1 (def_stmt
)) == MEM_REF
3451 || handled_component_p (gimple_assign_rhs1 (def_stmt
))))
3455 auto_vec
<vn_reference_op_s
> rhs
;
3456 vn_reference_op_t vro
;
3459 gcc_assert (lhs_ref_ok
);
3461 /* See if the assignment kills REF. */
3462 base2
= ao_ref_base (&lhs_ref
);
3463 if (!lhs_ref
.max_size_known_p ()
3465 && (TREE_CODE (base
) != MEM_REF
3466 || TREE_CODE (base2
) != MEM_REF
3467 || TREE_OPERAND (base
, 0) != TREE_OPERAND (base2
, 0)
3468 || !tree_int_cst_equal (TREE_OPERAND (base
, 1),
3469 TREE_OPERAND (base2
, 1))))
3470 || !stmt_kills_ref_p (def_stmt
, ref
))
3473 /* Find the common base of ref and the lhs. lhs_ops already
3474 contains valueized operands for the lhs. */
3475 i
= vr
->operands
.length () - 1;
3476 j
= lhs_ops
.length () - 1;
3477 while (j
>= 0 && i
>= 0
3478 && vn_reference_op_eq (&vr
->operands
[i
], &lhs_ops
[j
]))
3484 /* ??? The innermost op should always be a MEM_REF and we already
3485 checked that the assignment to the lhs kills vr. Thus for
3486 aggregate copies using char[] types the vn_reference_op_eq
3487 may fail when comparing types for compatibility. But we really
3488 don't care here - further lookups with the rewritten operands
3489 will simply fail if we messed up types too badly. */
3490 poly_int64 extra_off
= 0;
3491 if (j
== 0 && i
>= 0
3492 && lhs_ops
[0].opcode
== MEM_REF
3493 && maybe_ne (lhs_ops
[0].off
, -1))
3495 if (known_eq (lhs_ops
[0].off
, vr
->operands
[i
].off
))
3497 else if (vr
->operands
[i
].opcode
== MEM_REF
3498 && maybe_ne (vr
->operands
[i
].off
, -1))
3500 extra_off
= vr
->operands
[i
].off
- lhs_ops
[0].off
;
3505 /* i now points to the first additional op.
3506 ??? LHS may not be completely contained in VR, one or more
3507 VIEW_CONVERT_EXPRs could be in its way. We could at least
3508 try handling outermost VIEW_CONVERT_EXPRs. */
3512 /* Punt if the additional ops contain a storage order barrier. */
3513 for (k
= i
; k
>= 0; k
--)
3515 vro
= &vr
->operands
[k
];
3516 if (vro
->opcode
== VIEW_CONVERT_EXPR
&& vro
->reverse
)
3520 /* Now re-write REF to be based on the rhs of the assignment. */
3521 tree rhs1
= gimple_assign_rhs1 (def_stmt
);
3522 copy_reference_ops_from_ref (rhs1
, &rhs
);
3524 /* Apply an extra offset to the inner MEM_REF of the RHS. */
3525 bool force_no_tbaa
= false;
3526 if (maybe_ne (extra_off
, 0))
3528 if (rhs
.length () < 2)
3530 int ix
= rhs
.length () - 2;
3531 if (rhs
[ix
].opcode
!= MEM_REF
3532 || known_eq (rhs
[ix
].off
, -1))
3534 rhs
[ix
].off
+= extra_off
;
3535 rhs
[ix
].op0
= int_const_binop (PLUS_EXPR
, rhs
[ix
].op0
,
3536 build_int_cst (TREE_TYPE (rhs
[ix
].op0
),
3538 /* When we have offsetted the RHS, reading only parts of it,
3539 we can no longer use the original TBAA type, force alias-set
3541 force_no_tbaa
= true;
3544 /* Save the operands since we need to use the original ones for
3545 the hash entry we use. */
3546 if (!data
->saved_operands
.exists ())
3547 data
->saved_operands
= vr
->operands
.copy ();
3549 /* We need to pre-pend vr->operands[0..i] to rhs. */
3550 vec
<vn_reference_op_s
> old
= vr
->operands
;
3551 if (i
+ 1 + rhs
.length () > vr
->operands
.length ())
3552 vr
->operands
.safe_grow (i
+ 1 + rhs
.length (), true);
3554 vr
->operands
.truncate (i
+ 1 + rhs
.length ());
3555 FOR_EACH_VEC_ELT (rhs
, j
, vro
)
3556 vr
->operands
[i
+ 1 + j
] = *vro
;
3557 valueize_refs (&vr
->operands
);
3558 if (old
== shared_lookup_references
)
3559 shared_lookup_references
= vr
->operands
;
3560 vr
->hashcode
= vn_reference_compute_hash (vr
);
3562 /* Try folding the new reference to a constant. */
3563 tree val
= fully_constant_vn_reference_p (vr
);
3566 if (data
->partial_defs
.is_empty ())
3567 return data
->finish (ao_ref_alias_set (&lhs_ref
),
3568 ao_ref_base_alias_set (&lhs_ref
), val
);
3569 /* This is the only interesting case for partial-def handling
3570 coming from targets that like to gimplify init-ctors as
3571 aggregate copies from constant data like aarch64 for
3573 if (maxsize
.is_constant (&maxsizei
) && known_eq (ref
->size
, maxsize
))
3580 return data
->push_partial_def (pd
, ao_ref_alias_set (&lhs_ref
),
3581 ao_ref_base_alias_set (&lhs_ref
),
3586 /* Continuing with partial defs isn't easily possible here, we
3587 have to find a full def from further lookups from here. Probably
3588 not worth the special-casing everywhere. */
3589 if (!data
->partial_defs
.is_empty ())
3592 /* Adjust *ref from the new operands. */
3594 ao_ref_init (&rhs1_ref
, rhs1
);
3595 if (!ao_ref_init_from_vn_reference (&r
,
3597 : ao_ref_alias_set (&rhs1_ref
),
3599 : ao_ref_base_alias_set (&rhs1_ref
),
3600 vr
->type
, vr
->operands
))
3602 /* This can happen with bitfields. */
3603 if (maybe_ne (ref
->size
, r
.size
))
3605 /* If the access lacks some subsetting simply apply that by
3606 shortening it. That in the end can only be successful
3607 if we can pun the lookup result which in turn requires
3609 if (known_eq (r
.size
, r
.max_size
)
3610 && known_lt (ref
->size
, r
.size
))
3611 r
.size
= r
.max_size
= ref
->size
;
3617 /* Do not update last seen VUSE after translating. */
3618 data
->last_vuse_ptr
= NULL
;
3619 /* Invalidate the original access path since it now contains
3621 data
->orig_ref
.ref
= NULL_TREE
;
3622 /* Use the alias-set of this LHS for recording an eventual result. */
3623 if (data
->first_set
== -2)
3625 data
->first_set
= ao_ref_alias_set (&lhs_ref
);
3626 data
->first_base_set
= ao_ref_base_alias_set (&lhs_ref
);
3629 /* Keep looking for the adjusted *REF / VR pair. */
3633 /* 6) For memcpy copies translate the reference through them if the copy
3634 kills ref. But we cannot (easily) do this translation if the memcpy is
3635 a storage order barrier, i.e. is equivalent to a VIEW_CONVERT_EXPR that
3636 can modify the storage order of objects (see storage_order_barrier_p). */
3637 else if (data
->vn_walk_kind
== VN_WALKREWRITE
3638 && is_gimple_reg_type (vr
->type
)
3639 /* ??? Handle BCOPY as well. */
3640 && (gimple_call_builtin_p (def_stmt
, BUILT_IN_MEMCPY
)
3641 || gimple_call_builtin_p (def_stmt
, BUILT_IN_MEMCPY_CHK
)
3642 || gimple_call_builtin_p (def_stmt
, BUILT_IN_MEMPCPY
)
3643 || gimple_call_builtin_p (def_stmt
, BUILT_IN_MEMPCPY_CHK
)
3644 || gimple_call_builtin_p (def_stmt
, BUILT_IN_MEMMOVE
)
3645 || gimple_call_builtin_p (def_stmt
, BUILT_IN_MEMMOVE_CHK
))
3646 && (TREE_CODE (gimple_call_arg (def_stmt
, 0)) == ADDR_EXPR
3647 || TREE_CODE (gimple_call_arg (def_stmt
, 0)) == SSA_NAME
)
3648 && (TREE_CODE (gimple_call_arg (def_stmt
, 1)) == ADDR_EXPR
3649 || TREE_CODE (gimple_call_arg (def_stmt
, 1)) == SSA_NAME
)
3650 && (poly_int_tree_p (gimple_call_arg (def_stmt
, 2), ©_size
)
3651 || (TREE_CODE (gimple_call_arg (def_stmt
, 2)) == SSA_NAME
3652 && poly_int_tree_p (SSA_VAL (gimple_call_arg (def_stmt
, 2)),
3654 /* Handling this is more complicated, give up for now. */
3655 && data
->partial_defs
.is_empty ())
3659 poly_int64 rhs_offset
, lhs_offset
;
3660 vn_reference_op_s op
;
3661 poly_uint64 mem_offset
;
3662 poly_int64 at
, byte_maxsize
;
3664 /* Only handle non-variable, addressable refs. */
3665 if (maybe_ne (ref
->size
, maxsize
)
3666 || !multiple_p (offset
, BITS_PER_UNIT
, &at
)
3667 || !multiple_p (maxsize
, BITS_PER_UNIT
, &byte_maxsize
))
3670 /* Extract a pointer base and an offset for the destination. */
3671 lhs
= gimple_call_arg (def_stmt
, 0);
3673 if (TREE_CODE (lhs
) == SSA_NAME
)
3675 lhs
= vn_valueize (lhs
);
3676 if (TREE_CODE (lhs
) == SSA_NAME
)
3678 gimple
*def_stmt
= SSA_NAME_DEF_STMT (lhs
);
3679 if (gimple_assign_single_p (def_stmt
)
3680 && gimple_assign_rhs_code (def_stmt
) == ADDR_EXPR
)
3681 lhs
= gimple_assign_rhs1 (def_stmt
);
3684 if (TREE_CODE (lhs
) == ADDR_EXPR
)
3686 if (AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (lhs
)))
3687 && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (TREE_TYPE (lhs
))))
3689 tree tem
= get_addr_base_and_unit_offset (TREE_OPERAND (lhs
, 0),
3693 if (TREE_CODE (tem
) == MEM_REF
3694 && poly_int_tree_p (TREE_OPERAND (tem
, 1), &mem_offset
))
3696 lhs
= TREE_OPERAND (tem
, 0);
3697 if (TREE_CODE (lhs
) == SSA_NAME
)
3698 lhs
= vn_valueize (lhs
);
3699 lhs_offset
+= mem_offset
;
3701 else if (DECL_P (tem
))
3702 lhs
= build_fold_addr_expr (tem
);
3706 if (TREE_CODE (lhs
) != SSA_NAME
3707 && TREE_CODE (lhs
) != ADDR_EXPR
)
3710 /* Extract a pointer base and an offset for the source. */
3711 rhs
= gimple_call_arg (def_stmt
, 1);
3713 if (TREE_CODE (rhs
) == SSA_NAME
)
3714 rhs
= vn_valueize (rhs
);
3715 if (TREE_CODE (rhs
) == ADDR_EXPR
)
3717 if (AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (rhs
)))
3718 && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (TREE_TYPE (rhs
))))
3720 tree tem
= get_addr_base_and_unit_offset (TREE_OPERAND (rhs
, 0),
3724 if (TREE_CODE (tem
) == MEM_REF
3725 && poly_int_tree_p (TREE_OPERAND (tem
, 1), &mem_offset
))
3727 rhs
= TREE_OPERAND (tem
, 0);
3728 rhs_offset
+= mem_offset
;
3730 else if (DECL_P (tem
)
3731 || TREE_CODE (tem
) == STRING_CST
)
3732 rhs
= build_fold_addr_expr (tem
);
3736 if (TREE_CODE (rhs
) == SSA_NAME
)
3737 rhs
= SSA_VAL (rhs
);
3738 else if (TREE_CODE (rhs
) != ADDR_EXPR
)
3741 /* The bases of the destination and the references have to agree. */
3742 if (TREE_CODE (base
) == MEM_REF
)
3744 if (TREE_OPERAND (base
, 0) != lhs
3745 || !poly_int_tree_p (TREE_OPERAND (base
, 1), &mem_offset
))
3749 else if (!DECL_P (base
)
3750 || TREE_CODE (lhs
) != ADDR_EXPR
3751 || TREE_OPERAND (lhs
, 0) != base
)
3754 /* If the access is completely outside of the memcpy destination
3755 area there is no aliasing. */
3756 if (!ranges_maybe_overlap_p (lhs_offset
, copy_size
, at
, byte_maxsize
))
3758 /* And the access has to be contained within the memcpy destination. */
3759 if (!known_subrange_p (at
, byte_maxsize
, lhs_offset
, copy_size
))
3762 /* Save the operands since we need to use the original ones for
3763 the hash entry we use. */
3764 if (!data
->saved_operands
.exists ())
3765 data
->saved_operands
= vr
->operands
.copy ();
3767 /* Make room for 2 operands in the new reference. */
3768 if (vr
->operands
.length () < 2)
3770 vec
<vn_reference_op_s
> old
= vr
->operands
;
3771 vr
->operands
.safe_grow_cleared (2, true);
3772 if (old
== shared_lookup_references
)
3773 shared_lookup_references
= vr
->operands
;
3776 vr
->operands
.truncate (2);
3778 /* The looked-through reference is a simple MEM_REF. */
3779 memset (&op
, 0, sizeof (op
));
3781 op
.opcode
= MEM_REF
;
3782 op
.op0
= build_int_cst (ptr_type_node
, at
- lhs_offset
+ rhs_offset
);
3783 op
.off
= at
- lhs_offset
+ rhs_offset
;
3784 vr
->operands
[0] = op
;
3785 op
.type
= TREE_TYPE (rhs
);
3786 op
.opcode
= TREE_CODE (rhs
);
3789 vr
->operands
[1] = op
;
3790 vr
->hashcode
= vn_reference_compute_hash (vr
);
3792 /* Try folding the new reference to a constant. */
3793 tree val
= fully_constant_vn_reference_p (vr
);
3795 return data
->finish (0, 0, val
);
3797 /* Adjust *ref from the new operands. */
3798 if (!ao_ref_init_from_vn_reference (&r
, 0, 0, vr
->type
, vr
->operands
))
3800 /* This can happen with bitfields. */
3801 if (maybe_ne (ref
->size
, r
.size
))
3805 /* Do not update last seen VUSE after translating. */
3806 data
->last_vuse_ptr
= NULL
;
3807 /* Invalidate the original access path since it now contains
3809 data
->orig_ref
.ref
= NULL_TREE
;
3810 /* Use the alias-set of this stmt for recording an eventual result. */
3811 if (data
->first_set
== -2)
3813 data
->first_set
= 0;
3814 data
->first_base_set
= 0;
3817 /* Keep looking for the adjusted *REF / VR pair. */
3821 /* Bail out and stop walking. */
3825 /* Return a reference op vector from OP that can be used for
3826 vn_reference_lookup_pieces. The caller is responsible for releasing
3829 vec
<vn_reference_op_s
>
3830 vn_reference_operands_for_lookup (tree op
)
3833 return valueize_shared_reference_ops_from_ref (op
, &valueized
).copy ();
3836 /* Lookup a reference operation by it's parts, in the current hash table.
3837 Returns the resulting value number if it exists in the hash table,
3838 NULL_TREE otherwise. VNRESULT will be filled in with the actual
3839 vn_reference_t stored in the hashtable if something is found. */
3842 vn_reference_lookup_pieces (tree vuse
, alias_set_type set
,
3843 alias_set_type base_set
, tree type
,
3844 vec
<vn_reference_op_s
> operands
,
3845 vn_reference_t
*vnresult
, vn_lookup_kind kind
)
3847 struct vn_reference_s vr1
;
3855 vr1
.vuse
= vuse_ssa_val (vuse
);
3856 shared_lookup_references
.truncate (0);
3857 shared_lookup_references
.safe_grow (operands
.length (), true);
3858 memcpy (shared_lookup_references
.address (),
3859 operands
.address (),
3860 sizeof (vn_reference_op_s
)
3861 * operands
.length ());
3863 valueize_refs_1 (&shared_lookup_references
, &valueized_p
);
3864 vr1
.operands
= shared_lookup_references
;
3867 vr1
.base_set
= base_set
;
3868 vr1
.hashcode
= vn_reference_compute_hash (&vr1
);
3869 if ((cst
= fully_constant_vn_reference_p (&vr1
)))
3872 vn_reference_lookup_1 (&vr1
, vnresult
);
3874 && kind
!= VN_NOWALK
3878 unsigned limit
= param_sccvn_max_alias_queries_per_access
;
3879 vn_walk_cb_data
data (&vr1
, NULL_TREE
, NULL
, kind
, true, NULL_TREE
,
3881 vec
<vn_reference_op_s
> ops_for_ref
;
3883 ops_for_ref
= vr1
.operands
;
3886 /* For ao_ref_from_mem we have to ensure only available SSA names
3887 end up in base and the only convenient way to make this work
3888 for PRE is to re-valueize with that in mind. */
3889 ops_for_ref
.create (operands
.length ());
3890 ops_for_ref
.quick_grow (operands
.length ());
3891 memcpy (ops_for_ref
.address (),
3892 operands
.address (),
3893 sizeof (vn_reference_op_s
)
3894 * operands
.length ());
3895 valueize_refs_1 (&ops_for_ref
, &valueized_p
, true);
3897 if (ao_ref_init_from_vn_reference (&r
, set
, base_set
, type
,
3901 walk_non_aliased_vuses (&r
, vr1
.vuse
, true, vn_reference_lookup_2
,
3902 vn_reference_lookup_3
, vuse_valueize
,
3904 if (ops_for_ref
!= shared_lookup_references
)
3905 ops_for_ref
.release ();
3906 gcc_checking_assert (vr1
.operands
== shared_lookup_references
);
3909 && (!(*vnresult
)->result
3910 || !operand_equal_p ((*vnresult
)->result
, data
.same_val
)))
3918 return (*vnresult
)->result
;
3923 /* Lookup OP in the current hash table, and return the resulting value
3924 number if it exists in the hash table. Return NULL_TREE if it does
3925 not exist in the hash table or if the result field of the structure
3926 was NULL.. VNRESULT will be filled in with the vn_reference_t
3927 stored in the hashtable if one exists. When TBAA_P is false assume
3928 we are looking up a store and treat it as having alias-set zero.
3929 *LAST_VUSE_PTR will be updated with the VUSE the value lookup succeeded.
3930 MASK is either NULL_TREE, or can be an INTEGER_CST if the result of the
3931 load is bitwise anded with MASK and so we are only interested in a subset
3932 of the bits and can ignore if the other bits are uninitialized or
3933 not initialized with constants. When doing redundant store removal
3934 the caller has to set REDUNDANT_STORE_REMOVAL_P. */
3937 vn_reference_lookup (tree op
, tree vuse
, vn_lookup_kind kind
,
3938 vn_reference_t
*vnresult
, bool tbaa_p
,
3939 tree
*last_vuse_ptr
, tree mask
,
3940 bool redundant_store_removal_p
)
3942 vec
<vn_reference_op_s
> operands
;
3943 struct vn_reference_s vr1
;
3944 bool valueized_anything
;
3949 vr1
.vuse
= vuse_ssa_val (vuse
);
3950 vr1
.operands
= operands
3951 = valueize_shared_reference_ops_from_ref (op
, &valueized_anything
);
3953 /* Handle &MEM[ptr + 5].b[1].c as POINTER_PLUS_EXPR. Avoid doing
3954 this before the pass folding __builtin_object_size had a chance to run. */
3955 if ((cfun
->curr_properties
& PROP_objsz
)
3956 && operands
[0].opcode
== ADDR_EXPR
3957 && operands
.last ().opcode
== SSA_NAME
)
3960 vn_reference_op_t vro
;
3962 for (i
= 1; operands
.iterate (i
, &vro
); ++i
)
3964 if (vro
->opcode
== SSA_NAME
)
3966 else if (known_eq (vro
->off
, -1))
3970 if (i
== operands
.length () - 1
3971 /* Make sure we the offset we accumulated in a 64bit int
3972 fits the address computation carried out in target
3973 offset precision. */
3975 == sext_hwi (off
.coeffs
[0], TYPE_PRECISION (sizetype
))))
3977 gcc_assert (operands
[i
-1].opcode
== MEM_REF
);
3979 ops
[0] = operands
[i
].op0
;
3980 ops
[1] = wide_int_to_tree (sizetype
, off
);
3981 tree res
= vn_nary_op_lookup_pieces (2, POINTER_PLUS_EXPR
,
3982 TREE_TYPE (op
), ops
, NULL
);
3989 vr1
.type
= TREE_TYPE (op
);
3991 ao_ref_init (&op_ref
, op
);
3992 vr1
.set
= ao_ref_alias_set (&op_ref
);
3993 vr1
.base_set
= ao_ref_base_alias_set (&op_ref
);
3994 vr1
.hashcode
= vn_reference_compute_hash (&vr1
);
3995 if (mask
== NULL_TREE
)
3996 if (tree cst
= fully_constant_vn_reference_p (&vr1
))
3999 if (kind
!= VN_NOWALK
&& vr1
.vuse
)
4001 vn_reference_t wvnresult
;
4003 unsigned limit
= param_sccvn_max_alias_queries_per_access
;
4004 auto_vec
<vn_reference_op_s
> ops_for_ref
;
4005 if (valueized_anything
)
4007 copy_reference_ops_from_ref (op
, &ops_for_ref
);
4009 valueize_refs_1 (&ops_for_ref
, &tem
, true);
4011 /* Make sure to use a valueized reference if we valueized anything.
4012 Otherwise preserve the full reference for advanced TBAA. */
4013 if (!valueized_anything
4014 || !ao_ref_init_from_vn_reference (&r
, vr1
.set
, vr1
.base_set
,
4015 vr1
.type
, ops_for_ref
))
4016 ao_ref_init (&r
, op
);
4017 vn_walk_cb_data
data (&vr1
, r
.ref
? NULL_TREE
: op
,
4018 last_vuse_ptr
, kind
, tbaa_p
, mask
,
4019 redundant_store_removal_p
);
4023 walk_non_aliased_vuses (&r
, vr1
.vuse
, tbaa_p
, vn_reference_lookup_2
,
4024 vn_reference_lookup_3
, vuse_valueize
, limit
,
4026 gcc_checking_assert (vr1
.operands
== shared_lookup_references
);
4029 gcc_assert (mask
== NULL_TREE
);
4031 && (!wvnresult
->result
4032 || !operand_equal_p (wvnresult
->result
, data
.same_val
)))
4035 *vnresult
= wvnresult
;
4036 return wvnresult
->result
;
4039 return data
.masked_result
;
4045 *last_vuse_ptr
= vr1
.vuse
;
4048 return vn_reference_lookup_1 (&vr1
, vnresult
);
4051 /* Lookup CALL in the current hash table and return the entry in
4052 *VNRESULT if found. Populates *VR for the hashtable lookup. */
4055 vn_reference_lookup_call (gcall
*call
, vn_reference_t
*vnresult
,
4061 tree vuse
= gimple_vuse (call
);
4063 vr
->vuse
= vuse
? SSA_VAL (vuse
) : NULL_TREE
;
4064 vr
->operands
= valueize_shared_reference_ops_from_call (call
);
4065 tree lhs
= gimple_call_lhs (call
);
4066 /* For non-SSA return values the referece ops contain the LHS. */
4067 vr
->type
= ((lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
4068 ? TREE_TYPE (lhs
) : NULL_TREE
);
4072 vr
->hashcode
= vn_reference_compute_hash (vr
);
4073 vn_reference_lookup_1 (vr
, vnresult
);
4076 /* Insert OP into the current hash table with a value number of RESULT. */
4079 vn_reference_insert (tree op
, tree result
, tree vuse
, tree vdef
)
4081 vn_reference_s
**slot
;
4085 vec
<vn_reference_op_s
> operands
4086 = valueize_shared_reference_ops_from_ref (op
, &tem
);
4087 /* Handle &MEM[ptr + 5].b[1].c as POINTER_PLUS_EXPR. Avoid doing this
4088 before the pass folding __builtin_object_size had a chance to run. */
4089 if ((cfun
->curr_properties
& PROP_objsz
)
4090 && operands
[0].opcode
== ADDR_EXPR
4091 && operands
.last ().opcode
== SSA_NAME
)
4094 vn_reference_op_t vro
;
4096 for (i
= 1; operands
.iterate (i
, &vro
); ++i
)
4098 if (vro
->opcode
== SSA_NAME
)
4100 else if (known_eq (vro
->off
, -1))
4104 if (i
== operands
.length () - 1
4105 /* Make sure we the offset we accumulated in a 64bit int
4106 fits the address computation carried out in target
4107 offset precision. */
4109 == sext_hwi (off
.coeffs
[0], TYPE_PRECISION (sizetype
))))
4111 gcc_assert (operands
[i
-1].opcode
== MEM_REF
);
4113 ops
[0] = operands
[i
].op0
;
4114 ops
[1] = wide_int_to_tree (sizetype
, off
);
4115 vn_nary_op_insert_pieces (2, POINTER_PLUS_EXPR
,
4116 TREE_TYPE (op
), ops
, result
,
4117 VN_INFO (result
)->value_id
);
4122 vr1
= XOBNEW (&vn_tables_obstack
, vn_reference_s
);
4123 if (TREE_CODE (result
) == SSA_NAME
)
4124 vr1
->value_id
= VN_INFO (result
)->value_id
;
4126 vr1
->value_id
= get_or_alloc_constant_value_id (result
);
4127 vr1
->vuse
= vuse_ssa_val (vuse
);
4128 vr1
->operands
= operands
.copy ();
4129 vr1
->type
= TREE_TYPE (op
);
4130 vr1
->punned
= false;
4132 ao_ref_init (&op_ref
, op
);
4133 vr1
->set
= ao_ref_alias_set (&op_ref
);
4134 vr1
->base_set
= ao_ref_base_alias_set (&op_ref
);
4135 vr1
->hashcode
= vn_reference_compute_hash (vr1
);
4136 vr1
->result
= TREE_CODE (result
) == SSA_NAME
? SSA_VAL (result
) : result
;
4137 vr1
->result_vdef
= vdef
;
4139 slot
= valid_info
->references
->find_slot_with_hash (vr1
, vr1
->hashcode
,
4142 /* Because IL walking on reference lookup can end up visiting
4143 a def that is only to be visited later in iteration order
4144 when we are about to make an irreducible region reducible
4145 the def can be effectively processed and its ref being inserted
4146 by vn_reference_lookup_3 already. So we cannot assert (!*slot)
4147 but save a lookup if we deal with already inserted refs here. */
4150 /* We cannot assert that we have the same value either because
4151 when disentangling an irreducible region we may end up visiting
4152 a use before the corresponding def. That's a missed optimization
4153 only though. See gcc.dg/tree-ssa/pr87126.c for example. */
4154 if (dump_file
&& (dump_flags
& TDF_DETAILS
)
4155 && !operand_equal_p ((*slot
)->result
, vr1
->result
, 0))
4157 fprintf (dump_file
, "Keeping old value ");
4158 print_generic_expr (dump_file
, (*slot
)->result
);
4159 fprintf (dump_file
, " because of collision\n");
4161 free_reference (vr1
);
4162 obstack_free (&vn_tables_obstack
, vr1
);
4167 vr1
->next
= last_inserted_ref
;
4168 last_inserted_ref
= vr1
;
4171 /* Insert a reference by it's pieces into the current hash table with
4172 a value number of RESULT. Return the resulting reference
4173 structure we created. */
4176 vn_reference_insert_pieces (tree vuse
, alias_set_type set
,
4177 alias_set_type base_set
, tree type
,
4178 vec
<vn_reference_op_s
> operands
,
4179 tree result
, unsigned int value_id
)
4182 vn_reference_s
**slot
;
4185 vr1
= XOBNEW (&vn_tables_obstack
, vn_reference_s
);
4186 vr1
->value_id
= value_id
;
4187 vr1
->vuse
= vuse_ssa_val (vuse
);
4188 vr1
->operands
= operands
;
4189 valueize_refs (&vr1
->operands
);
4191 vr1
->punned
= false;
4193 vr1
->base_set
= base_set
;
4194 vr1
->hashcode
= vn_reference_compute_hash (vr1
);
4195 if (result
&& TREE_CODE (result
) == SSA_NAME
)
4196 result
= SSA_VAL (result
);
4197 vr1
->result
= result
;
4198 vr1
->result_vdef
= NULL_TREE
;
4200 slot
= valid_info
->references
->find_slot_with_hash (vr1
, vr1
->hashcode
,
4203 /* At this point we should have all the things inserted that we have
4204 seen before, and we should never try inserting something that
4206 gcc_assert (!*slot
);
4209 vr1
->next
= last_inserted_ref
;
4210 last_inserted_ref
= vr1
;
4214 /* Compute and return the hash value for nary operation VBO1. */
4217 vn_nary_op_compute_hash (const vn_nary_op_t vno1
)
4219 inchash::hash hstate
;
4222 if (((vno1
->length
== 2
4223 && commutative_tree_code (vno1
->opcode
))
4224 || (vno1
->length
== 3
4225 && commutative_ternary_tree_code (vno1
->opcode
)))
4226 && tree_swap_operands_p (vno1
->op
[0], vno1
->op
[1]))
4227 std::swap (vno1
->op
[0], vno1
->op
[1]);
4228 else if (TREE_CODE_CLASS (vno1
->opcode
) == tcc_comparison
4229 && tree_swap_operands_p (vno1
->op
[0], vno1
->op
[1]))
4231 std::swap (vno1
->op
[0], vno1
->op
[1]);
4232 vno1
->opcode
= swap_tree_comparison (vno1
->opcode
);
4235 hstate
.add_int (vno1
->opcode
);
4236 for (i
= 0; i
< vno1
->length
; ++i
)
4237 inchash::add_expr (vno1
->op
[i
], hstate
);
4239 return hstate
.end ();
4242 /* Compare nary operations VNO1 and VNO2 and return true if they are
4246 vn_nary_op_eq (const_vn_nary_op_t
const vno1
, const_vn_nary_op_t
const vno2
)
4250 if (vno1
->hashcode
!= vno2
->hashcode
)
4253 if (vno1
->length
!= vno2
->length
)
4256 if (vno1
->opcode
!= vno2
->opcode
4257 || !types_compatible_p (vno1
->type
, vno2
->type
))
4260 for (i
= 0; i
< vno1
->length
; ++i
)
4261 if (!expressions_equal_p (vno1
->op
[i
], vno2
->op
[i
]))
4264 /* BIT_INSERT_EXPR has an implict operand as the type precision
4265 of op1. Need to check to make sure they are the same. */
4266 if (vno1
->opcode
== BIT_INSERT_EXPR
4267 && TREE_CODE (vno1
->op
[1]) == INTEGER_CST
4268 && TYPE_PRECISION (TREE_TYPE (vno1
->op
[1]))
4269 != TYPE_PRECISION (TREE_TYPE (vno2
->op
[1])))
4275 /* Initialize VNO from the pieces provided. */
4278 init_vn_nary_op_from_pieces (vn_nary_op_t vno
, unsigned int length
,
4279 enum tree_code code
, tree type
, tree
*ops
)
4282 vno
->length
= length
;
4284 memcpy (&vno
->op
[0], ops
, sizeof (tree
) * length
);
4287 /* Return the number of operands for a vn_nary ops structure from STMT. */
4290 vn_nary_length_from_stmt (gimple
*stmt
)
4292 switch (gimple_assign_rhs_code (stmt
))
4296 case VIEW_CONVERT_EXPR
:
4303 return CONSTRUCTOR_NELTS (gimple_assign_rhs1 (stmt
));
4306 return gimple_num_ops (stmt
) - 1;
4310 /* Initialize VNO from STMT. */
4313 init_vn_nary_op_from_stmt (vn_nary_op_t vno
, gassign
*stmt
)
4317 vno
->opcode
= gimple_assign_rhs_code (stmt
);
4318 vno
->type
= TREE_TYPE (gimple_assign_lhs (stmt
));
4319 switch (vno
->opcode
)
4323 case VIEW_CONVERT_EXPR
:
4325 vno
->op
[0] = TREE_OPERAND (gimple_assign_rhs1 (stmt
), 0);
4330 vno
->op
[0] = TREE_OPERAND (gimple_assign_rhs1 (stmt
), 0);
4331 vno
->op
[1] = TREE_OPERAND (gimple_assign_rhs1 (stmt
), 1);
4332 vno
->op
[2] = TREE_OPERAND (gimple_assign_rhs1 (stmt
), 2);
4336 vno
->length
= CONSTRUCTOR_NELTS (gimple_assign_rhs1 (stmt
));
4337 for (i
= 0; i
< vno
->length
; ++i
)
4338 vno
->op
[i
] = CONSTRUCTOR_ELT (gimple_assign_rhs1 (stmt
), i
)->value
;
4342 gcc_checking_assert (!gimple_assign_single_p (stmt
));
4343 vno
->length
= gimple_num_ops (stmt
) - 1;
4344 for (i
= 0; i
< vno
->length
; ++i
)
4345 vno
->op
[i
] = gimple_op (stmt
, i
+ 1);
4349 /* Compute the hashcode for VNO and look for it in the hash table;
4350 return the resulting value number if it exists in the hash table.
4351 Return NULL_TREE if it does not exist in the hash table or if the
4352 result field of the operation is NULL. VNRESULT will contain the
4353 vn_nary_op_t from the hashtable if it exists. */
4356 vn_nary_op_lookup_1 (vn_nary_op_t vno
, vn_nary_op_t
*vnresult
)
4358 vn_nary_op_s
**slot
;
4363 for (unsigned i
= 0; i
< vno
->length
; ++i
)
4364 if (TREE_CODE (vno
->op
[i
]) == SSA_NAME
)
4365 vno
->op
[i
] = SSA_VAL (vno
->op
[i
]);
4367 vno
->hashcode
= vn_nary_op_compute_hash (vno
);
4368 slot
= valid_info
->nary
->find_slot_with_hash (vno
, vno
->hashcode
, NO_INSERT
);
4373 return (*slot
)->predicated_values
? NULL_TREE
: (*slot
)->u
.result
;
4376 /* Lookup a n-ary operation by its pieces and return the resulting value
4377 number if it exists in the hash table. Return NULL_TREE if it does
4378 not exist in the hash table or if the result field of the operation
4379 is NULL. VNRESULT will contain the vn_nary_op_t from the hashtable
4383 vn_nary_op_lookup_pieces (unsigned int length
, enum tree_code code
,
4384 tree type
, tree
*ops
, vn_nary_op_t
*vnresult
)
4386 vn_nary_op_t vno1
= XALLOCAVAR (struct vn_nary_op_s
,
4387 sizeof_vn_nary_op (length
));
4388 init_vn_nary_op_from_pieces (vno1
, length
, code
, type
, ops
);
4389 return vn_nary_op_lookup_1 (vno1
, vnresult
);
4392 /* Lookup the rhs of STMT in the current hash table, and return the resulting
4393 value number if it exists in the hash table. Return NULL_TREE if
4394 it does not exist in the hash table. VNRESULT will contain the
4395 vn_nary_op_t from the hashtable if it exists. */
4398 vn_nary_op_lookup_stmt (gimple
*stmt
, vn_nary_op_t
*vnresult
)
4401 = XALLOCAVAR (struct vn_nary_op_s
,
4402 sizeof_vn_nary_op (vn_nary_length_from_stmt (stmt
)));
4403 init_vn_nary_op_from_stmt (vno1
, as_a
<gassign
*> (stmt
));
4404 return vn_nary_op_lookup_1 (vno1
, vnresult
);
4407 /* Allocate a vn_nary_op_t with LENGTH operands on STACK. */
4410 alloc_vn_nary_op_noinit (unsigned int length
, struct obstack
*stack
)
4412 return (vn_nary_op_t
) obstack_alloc (stack
, sizeof_vn_nary_op (length
));
4415 /* Allocate and initialize a vn_nary_op_t on CURRENT_INFO's
4419 alloc_vn_nary_op (unsigned int length
, tree result
, unsigned int value_id
)
4421 vn_nary_op_t vno1
= alloc_vn_nary_op_noinit (length
, &vn_tables_obstack
);
4423 vno1
->value_id
= value_id
;
4424 vno1
->length
= length
;
4425 vno1
->predicated_values
= 0;
4426 vno1
->u
.result
= result
;
4431 /* Insert VNO into TABLE. */
4434 vn_nary_op_insert_into (vn_nary_op_t vno
, vn_nary_op_table_type
*table
)
4436 vn_nary_op_s
**slot
;
4438 gcc_assert (! vno
->predicated_values
4439 || (! vno
->u
.values
->next
4440 && vno
->u
.values
->n
== 1));
4442 for (unsigned i
= 0; i
< vno
->length
; ++i
)
4443 if (TREE_CODE (vno
->op
[i
]) == SSA_NAME
)
4444 vno
->op
[i
] = SSA_VAL (vno
->op
[i
]);
4446 vno
->hashcode
= vn_nary_op_compute_hash (vno
);
4447 slot
= table
->find_slot_with_hash (vno
, vno
->hashcode
, INSERT
);
4448 vno
->unwind_to
= *slot
;
4451 /* Prefer non-predicated values.
4452 ??? Only if those are constant, otherwise, with constant predicated
4453 value, turn them into predicated values with entry-block validity
4454 (??? but we always find the first valid result currently). */
4455 if ((*slot
)->predicated_values
4456 && ! vno
->predicated_values
)
4458 /* ??? We cannot remove *slot from the unwind stack list.
4459 For the moment we deal with this by skipping not found
4460 entries but this isn't ideal ... */
4462 /* ??? Maintain a stack of states we can unwind in
4463 vn_nary_op_s? But how far do we unwind? In reality
4464 we need to push change records somewhere... Or not
4465 unwind vn_nary_op_s and linking them but instead
4466 unwind the results "list", linking that, which also
4467 doesn't move on hashtable resize. */
4468 /* We can also have a ->unwind_to recording *slot there.
4469 That way we can make u.values a fixed size array with
4470 recording the number of entries but of course we then
4471 have always N copies for each unwind_to-state. Or we
4472 make sure to only ever append and each unwinding will
4473 pop off one entry (but how to deal with predicated
4474 replaced with non-predicated here?) */
4475 vno
->next
= last_inserted_nary
;
4476 last_inserted_nary
= vno
;
4479 else if (vno
->predicated_values
4480 && ! (*slot
)->predicated_values
)
4482 else if (vno
->predicated_values
4483 && (*slot
)->predicated_values
)
4485 /* ??? Factor this all into a insert_single_predicated_value
4487 gcc_assert (!vno
->u
.values
->next
&& vno
->u
.values
->n
== 1);
4489 = BASIC_BLOCK_FOR_FN (cfun
, vno
->u
.values
->valid_dominated_by_p
[0]);
4490 vn_pval
*nval
= vno
->u
.values
;
4491 vn_pval
**next
= &vno
->u
.values
;
4493 for (vn_pval
*val
= (*slot
)->u
.values
; val
; val
= val
->next
)
4495 if (expressions_equal_p (val
->result
, nval
->result
))
4498 for (unsigned i
= 0; i
< val
->n
; ++i
)
4501 = BASIC_BLOCK_FOR_FN (cfun
,
4502 val
->valid_dominated_by_p
[i
]);
4503 if (dominated_by_p (CDI_DOMINATORS
, vno_bb
, val_bb
))
4504 /* Value registered with more generic predicate. */
4506 else if (flag_checking
)
4507 /* Shouldn't happen, we insert in RPO order. */
4508 gcc_assert (!dominated_by_p (CDI_DOMINATORS
,
4512 *next
= (vn_pval
*) obstack_alloc (&vn_tables_obstack
,
4514 + val
->n
* sizeof (int));
4515 (*next
)->next
= NULL
;
4516 (*next
)->result
= val
->result
;
4517 (*next
)->n
= val
->n
+ 1;
4518 memcpy ((*next
)->valid_dominated_by_p
,
4519 val
->valid_dominated_by_p
,
4520 val
->n
* sizeof (int));
4521 (*next
)->valid_dominated_by_p
[val
->n
] = vno_bb
->index
;
4522 next
= &(*next
)->next
;
4523 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4524 fprintf (dump_file
, "Appending predicate to value.\n");
4527 /* Copy other predicated values. */
4528 *next
= (vn_pval
*) obstack_alloc (&vn_tables_obstack
,
4530 + (val
->n
-1) * sizeof (int));
4531 memcpy (*next
, val
, sizeof (vn_pval
) + (val
->n
-1) * sizeof (int));
4532 (*next
)->next
= NULL
;
4533 next
= &(*next
)->next
;
4539 vno
->next
= last_inserted_nary
;
4540 last_inserted_nary
= vno
;
4544 /* While we do not want to insert things twice it's awkward to
4545 avoid it in the case where visit_nary_op pattern-matches stuff
4546 and ends up simplifying the replacement to itself. We then
4547 get two inserts, one from visit_nary_op and one from
4548 vn_nary_build_or_lookup.
4549 So allow inserts with the same value number. */
4550 if ((*slot
)->u
.result
== vno
->u
.result
)
4554 /* ??? There's also optimistic vs. previous commited state merging
4555 that is problematic for the case of unwinding. */
4557 /* ??? We should return NULL if we do not use 'vno' and have the
4558 caller release it. */
4559 gcc_assert (!*slot
);
4562 vno
->next
= last_inserted_nary
;
4563 last_inserted_nary
= vno
;
4567 /* Insert a n-ary operation into the current hash table using it's
4568 pieces. Return the vn_nary_op_t structure we created and put in
4572 vn_nary_op_insert_pieces (unsigned int length
, enum tree_code code
,
4573 tree type
, tree
*ops
,
4574 tree result
, unsigned int value_id
)
4576 vn_nary_op_t vno1
= alloc_vn_nary_op (length
, result
, value_id
);
4577 init_vn_nary_op_from_pieces (vno1
, length
, code
, type
, ops
);
4578 return vn_nary_op_insert_into (vno1
, valid_info
->nary
);
4581 /* Return whether we can track a predicate valid when PRED_E is executed. */
4584 can_track_predicate_on_edge (edge pred_e
)
4586 /* ??? As we are currently recording the destination basic-block index in
4587 vn_pval.valid_dominated_by_p and using dominance for the
4588 validity check we cannot track predicates on all edges. */
4589 if (single_pred_p (pred_e
->dest
))
4591 /* Never record for backedges. */
4592 if (pred_e
->flags
& EDGE_DFS_BACK
)
4594 /* When there's more than one predecessor we cannot track
4595 predicate validity based on the destination block. The
4596 exception is when all other incoming edges sources are
4597 dominated by the destination block. */
4600 FOR_EACH_EDGE (e
, ei
, pred_e
->dest
->preds
)
4601 if (e
!= pred_e
&& ! dominated_by_p (CDI_DOMINATORS
, e
->src
, e
->dest
))
4607 vn_nary_op_insert_pieces_predicated (unsigned int length
, enum tree_code code
,
4608 tree type
, tree
*ops
,
4609 tree result
, unsigned int value_id
,
4612 gcc_assert (can_track_predicate_on_edge (pred_e
));
4614 if (dump_file
&& (dump_flags
& TDF_DETAILS
)
4615 /* ??? Fix dumping, but currently we only get comparisons. */
4616 && TREE_CODE_CLASS (code
) == tcc_comparison
)
4618 fprintf (dump_file
, "Recording on edge %d->%d ", pred_e
->src
->index
,
4619 pred_e
->dest
->index
);
4620 print_generic_expr (dump_file
, ops
[0], TDF_SLIM
);
4621 fprintf (dump_file
, " %s ", get_tree_code_name (code
));
4622 print_generic_expr (dump_file
, ops
[1], TDF_SLIM
);
4623 fprintf (dump_file
, " == %s\n",
4624 integer_zerop (result
) ? "false" : "true");
4626 vn_nary_op_t vno1
= alloc_vn_nary_op (length
, NULL_TREE
, value_id
);
4627 init_vn_nary_op_from_pieces (vno1
, length
, code
, type
, ops
);
4628 vno1
->predicated_values
= 1;
4629 vno1
->u
.values
= (vn_pval
*) obstack_alloc (&vn_tables_obstack
,
4631 vno1
->u
.values
->next
= NULL
;
4632 vno1
->u
.values
->result
= result
;
4633 vno1
->u
.values
->n
= 1;
4634 vno1
->u
.values
->valid_dominated_by_p
[0] = pred_e
->dest
->index
;
4635 return vn_nary_op_insert_into (vno1
, valid_info
->nary
);
4639 dominated_by_p_w_unex (basic_block bb1
, basic_block bb2
, bool);
4642 vn_nary_op_get_predicated_value (vn_nary_op_t vno
, basic_block bb
,
4645 if (! vno
->predicated_values
)
4646 return vno
->u
.result
;
4647 for (vn_pval
*val
= vno
->u
.values
; val
; val
= val
->next
)
4648 for (unsigned i
= 0; i
< val
->n
; ++i
)
4651 = BASIC_BLOCK_FOR_FN (cfun
, val
->valid_dominated_by_p
[i
]);
4652 /* Do not handle backedge executability optimistically since
4653 when figuring out whether to iterate we do not consider
4654 changed predication.
4655 When asking for predicated values on an edge avoid looking
4656 at edge executability for edges forward in our iteration
4658 if (e
&& (e
->flags
& EDGE_DFS_BACK
))
4660 if (dominated_by_p (CDI_DOMINATORS
, bb
, cand
))
4663 else if (dominated_by_p_w_unex (bb
, cand
, false))
4670 vn_nary_op_get_predicated_value (vn_nary_op_t vno
, edge e
)
4672 return vn_nary_op_get_predicated_value (vno
, e
->src
, e
);
4675 /* Insert the rhs of STMT into the current hash table with a value number of
4679 vn_nary_op_insert_stmt (gimple
*stmt
, tree result
)
4682 = alloc_vn_nary_op (vn_nary_length_from_stmt (stmt
),
4683 result
, VN_INFO (result
)->value_id
);
4684 init_vn_nary_op_from_stmt (vno1
, as_a
<gassign
*> (stmt
));
4685 return vn_nary_op_insert_into (vno1
, valid_info
->nary
);
4688 /* Compute a hashcode for PHI operation VP1 and return it. */
4690 static inline hashval_t
4691 vn_phi_compute_hash (vn_phi_t vp1
)
4693 inchash::hash hstate
;
4699 hstate
.add_int (EDGE_COUNT (vp1
->block
->preds
));
4700 switch (EDGE_COUNT (vp1
->block
->preds
))
4705 /* When this is a PHI node subject to CSE for different blocks
4706 avoid hashing the block index. */
4711 hstate
.add_int (vp1
->block
->index
);
4714 /* If all PHI arguments are constants we need to distinguish
4715 the PHI node via its type. */
4717 hstate
.merge_hash (vn_hash_type (type
));
4719 FOR_EACH_EDGE (e
, ei
, vp1
->block
->preds
)
4721 /* Don't hash backedge values they need to be handled as VN_TOP
4722 for optimistic value-numbering. */
4723 if (e
->flags
& EDGE_DFS_BACK
)
4726 phi1op
= vp1
->phiargs
[e
->dest_idx
];
4727 if (phi1op
== VN_TOP
)
4729 inchash::add_expr (phi1op
, hstate
);
4732 return hstate
.end ();
4736 /* Return true if COND1 and COND2 represent the same condition, set
4737 *INVERTED_P if one needs to be inverted to make it the same as
4741 cond_stmts_equal_p (gcond
*cond1
, tree lhs1
, tree rhs1
,
4742 gcond
*cond2
, tree lhs2
, tree rhs2
, bool *inverted_p
)
4744 enum tree_code code1
= gimple_cond_code (cond1
);
4745 enum tree_code code2
= gimple_cond_code (cond2
);
4747 *inverted_p
= false;
4750 else if (code1
== swap_tree_comparison (code2
))
4751 std::swap (lhs2
, rhs2
);
4752 else if (code1
== invert_tree_comparison (code2
, HONOR_NANS (lhs2
)))
4754 else if (code1
== invert_tree_comparison
4755 (swap_tree_comparison (code2
), HONOR_NANS (lhs2
)))
4757 std::swap (lhs2
, rhs2
);
4763 return ((expressions_equal_p (lhs1
, lhs2
)
4764 && expressions_equal_p (rhs1
, rhs2
))
4765 || (commutative_tree_code (code1
)
4766 && expressions_equal_p (lhs1
, rhs2
)
4767 && expressions_equal_p (rhs1
, lhs2
)));
4770 /* Compare two phi entries for equality, ignoring VN_TOP arguments. */
4773 vn_phi_eq (const_vn_phi_t
const vp1
, const_vn_phi_t
const vp2
)
4775 if (vp1
->hashcode
!= vp2
->hashcode
)
4778 if (vp1
->block
!= vp2
->block
)
4780 if (EDGE_COUNT (vp1
->block
->preds
) != EDGE_COUNT (vp2
->block
->preds
))
4783 switch (EDGE_COUNT (vp1
->block
->preds
))
4786 /* Single-arg PHIs are just copies. */
4791 /* Make sure both PHIs are classified as CSEable. */
4792 if (! vp1
->cclhs
|| ! vp2
->cclhs
)
4795 /* Rule out backedges into the PHI. */
4797 (vp1
->block
->loop_father
->header
!= vp1
->block
4798 && vp2
->block
->loop_father
->header
!= vp2
->block
);
4800 /* If the PHI nodes do not have compatible types
4801 they are not the same. */
4802 if (!types_compatible_p (vp1
->type
, vp2
->type
))
4805 /* If the immediate dominator end in switch stmts multiple
4806 values may end up in the same PHI arg via intermediate
4809 = get_immediate_dominator (CDI_DOMINATORS
, vp1
->block
);
4811 = get_immediate_dominator (CDI_DOMINATORS
, vp2
->block
);
4812 gcc_checking_assert (EDGE_COUNT (idom1
->succs
) == 2
4813 && EDGE_COUNT (idom2
->succs
) == 2);
4815 /* Verify the controlling stmt is the same. */
4816 gcond
*last1
= as_a
<gcond
*> (*gsi_last_bb (idom1
));
4817 gcond
*last2
= as_a
<gcond
*> (*gsi_last_bb (idom2
));
4819 if (! cond_stmts_equal_p (last1
, vp1
->cclhs
, vp1
->ccrhs
,
4820 last2
, vp2
->cclhs
, vp2
->ccrhs
,
4824 /* Get at true/false controlled edges into the PHI. */
4825 edge te1
, te2
, fe1
, fe2
;
4826 if (! extract_true_false_controlled_edges (idom1
, vp1
->block
,
4828 || ! extract_true_false_controlled_edges (idom2
, vp2
->block
,
4832 /* Swap edges if the second condition is the inverted of the
4835 std::swap (te2
, fe2
);
4837 /* Since we do not know which edge will be executed we have
4838 to be careful when matching VN_TOP. Be conservative and
4839 only match VN_TOP == VN_TOP for now, we could allow
4840 VN_TOP on the not prevailing PHI though. See for example
4842 if (! expressions_equal_p (vp1
->phiargs
[te1
->dest_idx
],
4843 vp2
->phiargs
[te2
->dest_idx
], false)
4844 || ! expressions_equal_p (vp1
->phiargs
[fe1
->dest_idx
],
4845 vp2
->phiargs
[fe2
->dest_idx
], false))
4856 /* If the PHI nodes do not have compatible types
4857 they are not the same. */
4858 if (!types_compatible_p (vp1
->type
, vp2
->type
))
4861 /* Any phi in the same block will have it's arguments in the
4862 same edge order, because of how we store phi nodes. */
4863 unsigned nargs
= EDGE_COUNT (vp1
->block
->preds
);
4864 for (unsigned i
= 0; i
< nargs
; ++i
)
4866 tree phi1op
= vp1
->phiargs
[i
];
4867 tree phi2op
= vp2
->phiargs
[i
];
4868 if (phi1op
== phi2op
)
4870 if (!expressions_equal_p (phi1op
, phi2op
, false))
4877 /* Lookup PHI in the current hash table, and return the resulting
4878 value number if it exists in the hash table. Return NULL_TREE if
4879 it does not exist in the hash table. */
4882 vn_phi_lookup (gimple
*phi
, bool backedges_varying_p
)
4885 struct vn_phi_s
*vp1
;
4889 vp1
= XALLOCAVAR (struct vn_phi_s
,
4890 sizeof (struct vn_phi_s
)
4891 + (gimple_phi_num_args (phi
) - 1) * sizeof (tree
));
4893 /* Canonicalize the SSA_NAME's to their value number. */
4894 FOR_EACH_EDGE (e
, ei
, gimple_bb (phi
)->preds
)
4896 tree def
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
4897 if (TREE_CODE (def
) == SSA_NAME
4898 && (!backedges_varying_p
|| !(e
->flags
& EDGE_DFS_BACK
)))
4900 if (!virtual_operand_p (def
)
4901 && ssa_undefined_value_p (def
, false))
4904 def
= SSA_VAL (def
);
4906 vp1
->phiargs
[e
->dest_idx
] = def
;
4908 vp1
->type
= TREE_TYPE (gimple_phi_result (phi
));
4909 vp1
->block
= gimple_bb (phi
);
4910 /* Extract values of the controlling condition. */
4911 vp1
->cclhs
= NULL_TREE
;
4912 vp1
->ccrhs
= NULL_TREE
;
4913 if (EDGE_COUNT (vp1
->block
->preds
) == 2
4914 && vp1
->block
->loop_father
->header
!= vp1
->block
)
4916 basic_block idom1
= get_immediate_dominator (CDI_DOMINATORS
, vp1
->block
);
4917 if (EDGE_COUNT (idom1
->succs
) == 2)
4918 if (gcond
*last1
= safe_dyn_cast
<gcond
*> (*gsi_last_bb (idom1
)))
4920 /* ??? We want to use SSA_VAL here. But possibly not
4922 vp1
->cclhs
= vn_valueize (gimple_cond_lhs (last1
));
4923 vp1
->ccrhs
= vn_valueize (gimple_cond_rhs (last1
));
4926 vp1
->hashcode
= vn_phi_compute_hash (vp1
);
4927 slot
= valid_info
->phis
->find_slot_with_hash (vp1
, vp1
->hashcode
, NO_INSERT
);
4930 return (*slot
)->result
;
4933 /* Insert PHI into the current hash table with a value number of
4937 vn_phi_insert (gimple
*phi
, tree result
, bool backedges_varying_p
)
4940 vn_phi_t vp1
= (vn_phi_t
) obstack_alloc (&vn_tables_obstack
,
4942 + ((gimple_phi_num_args (phi
) - 1)
4947 /* Canonicalize the SSA_NAME's to their value number. */
4948 FOR_EACH_EDGE (e
, ei
, gimple_bb (phi
)->preds
)
4950 tree def
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
4951 if (TREE_CODE (def
) == SSA_NAME
4952 && (!backedges_varying_p
|| !(e
->flags
& EDGE_DFS_BACK
)))
4954 if (!virtual_operand_p (def
)
4955 && ssa_undefined_value_p (def
, false))
4958 def
= SSA_VAL (def
);
4960 vp1
->phiargs
[e
->dest_idx
] = def
;
4962 vp1
->value_id
= VN_INFO (result
)->value_id
;
4963 vp1
->type
= TREE_TYPE (gimple_phi_result (phi
));
4964 vp1
->block
= gimple_bb (phi
);
4965 /* Extract values of the controlling condition. */
4966 vp1
->cclhs
= NULL_TREE
;
4967 vp1
->ccrhs
= NULL_TREE
;
4968 if (EDGE_COUNT (vp1
->block
->preds
) == 2
4969 && vp1
->block
->loop_father
->header
!= vp1
->block
)
4971 basic_block idom1
= get_immediate_dominator (CDI_DOMINATORS
, vp1
->block
);
4972 if (EDGE_COUNT (idom1
->succs
) == 2)
4973 if (gcond
*last1
= safe_dyn_cast
<gcond
*> (*gsi_last_bb (idom1
)))
4975 /* ??? We want to use SSA_VAL here. But possibly not
4977 vp1
->cclhs
= vn_valueize (gimple_cond_lhs (last1
));
4978 vp1
->ccrhs
= vn_valueize (gimple_cond_rhs (last1
));
4981 vp1
->result
= result
;
4982 vp1
->hashcode
= vn_phi_compute_hash (vp1
);
4984 slot
= valid_info
->phis
->find_slot_with_hash (vp1
, vp1
->hashcode
, INSERT
);
4985 gcc_assert (!*slot
);
4988 vp1
->next
= last_inserted_phi
;
4989 last_inserted_phi
= vp1
;
4994 /* Return true if BB1 is dominated by BB2 taking into account edges
4995 that are not executable. When ALLOW_BACK is false consider not
4996 executable backedges as executable. */
4999 dominated_by_p_w_unex (basic_block bb1
, basic_block bb2
, bool allow_back
)
5004 if (dominated_by_p (CDI_DOMINATORS
, bb1
, bb2
))
5007 /* Before iterating we'd like to know if there exists a
5008 (executable) path from bb2 to bb1 at all, if not we can
5009 directly return false. For now simply iterate once. */
5011 /* Iterate to the single executable bb1 predecessor. */
5012 if (EDGE_COUNT (bb1
->preds
) > 1)
5015 FOR_EACH_EDGE (e
, ei
, bb1
->preds
)
5016 if ((e
->flags
& EDGE_EXECUTABLE
)
5017 || (!allow_back
&& (e
->flags
& EDGE_DFS_BACK
)))
5030 /* Re-do the dominance check with changed bb1. */
5031 if (dominated_by_p (CDI_DOMINATORS
, bb1
, bb2
))
5036 /* Iterate to the single executable bb2 successor. */
5037 if (EDGE_COUNT (bb2
->succs
) > 1)
5040 FOR_EACH_EDGE (e
, ei
, bb2
->succs
)
5041 if ((e
->flags
& EDGE_EXECUTABLE
)
5042 || (!allow_back
&& (e
->flags
& EDGE_DFS_BACK
)))
5053 /* Verify the reached block is only reached through succe.
5054 If there is only one edge we can spare us the dominator
5055 check and iterate directly. */
5056 if (EDGE_COUNT (succe
->dest
->preds
) > 1)
5058 FOR_EACH_EDGE (e
, ei
, succe
->dest
->preds
)
5060 && ((e
->flags
& EDGE_EXECUTABLE
)
5061 || (!allow_back
&& (e
->flags
& EDGE_DFS_BACK
))))
5071 /* Re-do the dominance check with changed bb2. */
5072 if (dominated_by_p (CDI_DOMINATORS
, bb1
, bb2
))
5078 /* We could now iterate updating bb1 / bb2. */
5082 /* Set the value number of FROM to TO, return true if it has changed
5086 set_ssa_val_to (tree from
, tree to
)
5088 vn_ssa_aux_t from_info
= VN_INFO (from
);
5089 tree currval
= from_info
->valnum
; // SSA_VAL (from)
5090 poly_int64 toff
, coff
;
5091 bool curr_undefined
= false;
5092 bool curr_invariant
= false;
5094 /* The only thing we allow as value numbers are ssa_names
5095 and invariants. So assert that here. We don't allow VN_TOP
5096 as visiting a stmt should produce a value-number other than
5098 ??? Still VN_TOP can happen for unreachable code, so force
5099 it to varying in that case. Not all code is prepared to
5100 get VN_TOP on valueization. */
5103 /* ??? When iterating and visiting PHI <undef, backedge-value>
5104 for the first time we rightfully get VN_TOP and we need to
5105 preserve that to optimize for example gcc.dg/tree-ssa/ssa-sccvn-2.c.
5106 With SCCVN we were simply lucky we iterated the other PHI
5107 cycles first and thus visited the backedge-value DEF. */
5108 if (currval
== VN_TOP
)
5110 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5111 fprintf (dump_file
, "Forcing value number to varying on "
5112 "receiving VN_TOP\n");
5116 gcc_checking_assert (to
!= NULL_TREE
5117 && ((TREE_CODE (to
) == SSA_NAME
5118 && (to
== from
|| SSA_VAL (to
) == to
))
5119 || is_gimple_min_invariant (to
)));
5123 if (currval
== from
)
5125 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5127 fprintf (dump_file
, "Not changing value number of ");
5128 print_generic_expr (dump_file
, from
);
5129 fprintf (dump_file
, " from VARYING to ");
5130 print_generic_expr (dump_file
, to
);
5131 fprintf (dump_file
, "\n");
5135 curr_invariant
= is_gimple_min_invariant (currval
);
5136 curr_undefined
= (TREE_CODE (currval
) == SSA_NAME
5137 && !virtual_operand_p (currval
)
5138 && ssa_undefined_value_p (currval
, false));
5139 if (currval
!= VN_TOP
5142 && is_gimple_min_invariant (to
))
5144 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5146 fprintf (dump_file
, "Forcing VARYING instead of changing "
5147 "value number of ");
5148 print_generic_expr (dump_file
, from
);
5149 fprintf (dump_file
, " from ");
5150 print_generic_expr (dump_file
, currval
);
5151 fprintf (dump_file
, " (non-constant) to ");
5152 print_generic_expr (dump_file
, to
);
5153 fprintf (dump_file
, " (constant)\n");
5157 else if (currval
!= VN_TOP
5159 && TREE_CODE (to
) == SSA_NAME
5160 && !virtual_operand_p (to
)
5161 && ssa_undefined_value_p (to
, false))
5163 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5165 fprintf (dump_file
, "Forcing VARYING instead of changing "
5166 "value number of ");
5167 print_generic_expr (dump_file
, from
);
5168 fprintf (dump_file
, " from ");
5169 print_generic_expr (dump_file
, currval
);
5170 fprintf (dump_file
, " (non-undefined) to ");
5171 print_generic_expr (dump_file
, to
);
5172 fprintf (dump_file
, " (undefined)\n");
5176 else if (TREE_CODE (to
) == SSA_NAME
5177 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (to
))
5182 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5184 fprintf (dump_file
, "Setting value number of ");
5185 print_generic_expr (dump_file
, from
);
5186 fprintf (dump_file
, " to ");
5187 print_generic_expr (dump_file
, to
);
5191 && !operand_equal_p (currval
, to
, 0)
5192 /* Different undefined SSA names are not actually different. See
5193 PR82320 for a testcase were we'd otherwise not terminate iteration. */
5195 && TREE_CODE (to
) == SSA_NAME
5196 && !virtual_operand_p (to
)
5197 && ssa_undefined_value_p (to
, false))
5198 /* ??? For addresses involving volatile objects or types operand_equal_p
5199 does not reliably detect ADDR_EXPRs as equal. We know we are only
5200 getting invariant gimple addresses here, so can use
5201 get_addr_base_and_unit_offset to do this comparison. */
5202 && !(TREE_CODE (currval
) == ADDR_EXPR
5203 && TREE_CODE (to
) == ADDR_EXPR
5204 && (get_addr_base_and_unit_offset (TREE_OPERAND (currval
, 0), &coff
)
5205 == get_addr_base_and_unit_offset (TREE_OPERAND (to
, 0), &toff
))
5206 && known_eq (coff
, toff
)))
5209 && currval
!= VN_TOP
5211 /* We do not want to allow lattice transitions from one value
5212 to another since that may lead to not terminating iteration
5213 (see PR95049). Since there's no convenient way to check
5214 for the allowed transition of VAL -> PHI (loop entry value,
5215 same on two PHIs, to same PHI result) we restrict the check
5218 && is_gimple_min_invariant (to
))
5220 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5221 fprintf (dump_file
, " forced VARYING");
5224 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5225 fprintf (dump_file
, " (changed)\n");
5226 from_info
->valnum
= to
;
5229 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5230 fprintf (dump_file
, "\n");
5234 /* Set all definitions in STMT to value number to themselves.
5235 Return true if a value number changed. */
5238 defs_to_varying (gimple
*stmt
)
5240 bool changed
= false;
5244 FOR_EACH_SSA_DEF_OPERAND (defp
, stmt
, iter
, SSA_OP_ALL_DEFS
)
5246 tree def
= DEF_FROM_PTR (defp
);
5247 changed
|= set_ssa_val_to (def
, def
);
5252 /* Visit a copy between LHS and RHS, return true if the value number
5256 visit_copy (tree lhs
, tree rhs
)
5259 rhs
= SSA_VAL (rhs
);
5261 return set_ssa_val_to (lhs
, rhs
);
5264 /* Lookup a value for OP in type WIDE_TYPE where the value in type of OP
5268 valueized_wider_op (tree wide_type
, tree op
, bool allow_truncate
)
5270 if (TREE_CODE (op
) == SSA_NAME
)
5271 op
= vn_valueize (op
);
5273 /* Either we have the op widened available. */
5276 tree tem
= vn_nary_op_lookup_pieces (1, NOP_EXPR
,
5277 wide_type
, ops
, NULL
);
5281 /* Or the op is truncated from some existing value. */
5282 if (allow_truncate
&& TREE_CODE (op
) == SSA_NAME
)
5284 gimple
*def
= SSA_NAME_DEF_STMT (op
);
5285 if (is_gimple_assign (def
)
5286 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def
)))
5288 tem
= gimple_assign_rhs1 (def
);
5289 if (useless_type_conversion_p (wide_type
, TREE_TYPE (tem
)))
5291 if (TREE_CODE (tem
) == SSA_NAME
)
5292 tem
= vn_valueize (tem
);
5298 /* For constants simply extend it. */
5299 if (TREE_CODE (op
) == INTEGER_CST
)
5300 return wide_int_to_tree (wide_type
, wi::to_widest (op
));
5305 /* Visit a nary operator RHS, value number it, and return true if the
5306 value number of LHS has changed as a result. */
5309 visit_nary_op (tree lhs
, gassign
*stmt
)
5311 vn_nary_op_t vnresult
;
5312 tree result
= vn_nary_op_lookup_stmt (stmt
, &vnresult
);
5313 if (! result
&& vnresult
)
5314 result
= vn_nary_op_get_predicated_value (vnresult
, gimple_bb (stmt
));
5316 return set_ssa_val_to (lhs
, result
);
5318 /* Do some special pattern matching for redundancies of operations
5319 in different types. */
5320 enum tree_code code
= gimple_assign_rhs_code (stmt
);
5321 tree type
= TREE_TYPE (lhs
);
5322 tree rhs1
= gimple_assign_rhs1 (stmt
);
5326 /* Match arithmetic done in a different type where we can easily
5327 substitute the result from some earlier sign-changed or widened
5329 if (INTEGRAL_TYPE_P (type
)
5330 && TREE_CODE (rhs1
) == SSA_NAME
5331 /* We only handle sign-changes, zero-extension -> & mask or
5332 sign-extension if we know the inner operation doesn't
5334 && (((TYPE_UNSIGNED (TREE_TYPE (rhs1
))
5335 || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1
))
5336 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (rhs1
))))
5337 && TYPE_PRECISION (type
) > TYPE_PRECISION (TREE_TYPE (rhs1
)))
5338 || TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (rhs1
))))
5340 gassign
*def
= dyn_cast
<gassign
*> (SSA_NAME_DEF_STMT (rhs1
));
5342 && (gimple_assign_rhs_code (def
) == PLUS_EXPR
5343 || gimple_assign_rhs_code (def
) == MINUS_EXPR
5344 || gimple_assign_rhs_code (def
) == MULT_EXPR
))
5347 /* When requiring a sign-extension we cannot model a
5348 previous truncation with a single op so don't bother. */
5349 bool allow_truncate
= TYPE_UNSIGNED (TREE_TYPE (rhs1
));
5350 /* Either we have the op widened available. */
5351 ops
[0] = valueized_wider_op (type
, gimple_assign_rhs1 (def
),
5354 ops
[1] = valueized_wider_op (type
, gimple_assign_rhs2 (def
),
5356 if (ops
[0] && ops
[1])
5358 ops
[0] = vn_nary_op_lookup_pieces
5359 (2, gimple_assign_rhs_code (def
), type
, ops
, NULL
);
5360 /* We have wider operation available. */
5362 /* If the leader is a wrapping operation we can
5363 insert it for code hoisting w/o introducing
5364 undefined overflow. If it is not it has to
5365 be available. See PR86554. */
5366 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (ops
[0]))
5367 || (rpo_avail
&& vn_context_bb
5368 && rpo_avail
->eliminate_avail (vn_context_bb
,
5371 unsigned lhs_prec
= TYPE_PRECISION (type
);
5372 unsigned rhs_prec
= TYPE_PRECISION (TREE_TYPE (rhs1
));
5373 if (lhs_prec
== rhs_prec
5374 || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1
))
5375 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (rhs1
))))
5377 gimple_match_op
match_op (gimple_match_cond::UNCOND
,
5378 NOP_EXPR
, type
, ops
[0]);
5379 result
= vn_nary_build_or_lookup (&match_op
);
5382 bool changed
= set_ssa_val_to (lhs
, result
);
5383 vn_nary_op_insert_stmt (stmt
, result
);
5389 tree mask
= wide_int_to_tree
5390 (type
, wi::mask (rhs_prec
, false, lhs_prec
));
5391 gimple_match_op
match_op (gimple_match_cond::UNCOND
,
5395 result
= vn_nary_build_or_lookup (&match_op
);
5398 bool changed
= set_ssa_val_to (lhs
, result
);
5399 vn_nary_op_insert_stmt (stmt
, result
);
5409 if (INTEGRAL_TYPE_P (type
)
5410 && TREE_CODE (rhs1
) == SSA_NAME
5411 && TREE_CODE (gimple_assign_rhs2 (stmt
)) == INTEGER_CST
5412 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1
)
5413 && default_vn_walk_kind
!= VN_NOWALK
5415 && BITS_PER_UNIT
== 8
5416 && BYTES_BIG_ENDIAN
== WORDS_BIG_ENDIAN
5417 && TYPE_PRECISION (type
) <= vn_walk_cb_data::bufsize
* BITS_PER_UNIT
5418 && !integer_all_onesp (gimple_assign_rhs2 (stmt
))
5419 && !integer_zerop (gimple_assign_rhs2 (stmt
)))
5421 gassign
*ass
= dyn_cast
<gassign
*> (SSA_NAME_DEF_STMT (rhs1
));
5423 && !gimple_has_volatile_ops (ass
)
5424 && vn_get_stmt_kind (ass
) == VN_REFERENCE
)
5426 tree last_vuse
= gimple_vuse (ass
);
5427 tree op
= gimple_assign_rhs1 (ass
);
5428 tree result
= vn_reference_lookup (op
, gimple_vuse (ass
),
5429 default_vn_walk_kind
,
5430 NULL
, true, &last_vuse
,
5431 gimple_assign_rhs2 (stmt
));
5433 && useless_type_conversion_p (TREE_TYPE (result
),
5435 return set_ssa_val_to (lhs
, result
);
5439 case TRUNC_DIV_EXPR
:
5440 if (TYPE_UNSIGNED (type
))
5445 /* Match up ([-]a){/,*}([-])b with v=a{/,*}b, replacing it with -v. */
5446 if (! HONOR_SIGN_DEPENDENT_ROUNDING (type
))
5450 rhs
[1] = gimple_assign_rhs2 (stmt
);
5451 for (unsigned i
= 0; i
<= 1; ++i
)
5453 unsigned j
= i
== 0 ? 1 : 0;
5455 gimple_match_op
match_op (gimple_match_cond::UNCOND
,
5456 NEGATE_EXPR
, type
, rhs
[i
]);
5457 ops
[i
] = vn_nary_build_or_lookup_1 (&match_op
, false, true);
5460 && (ops
[0] = vn_nary_op_lookup_pieces (2, code
,
5463 gimple_match_op
match_op (gimple_match_cond::UNCOND
,
5464 NEGATE_EXPR
, type
, ops
[0]);
5465 result
= vn_nary_build_or_lookup_1 (&match_op
, true, false);
5468 bool changed
= set_ssa_val_to (lhs
, result
);
5469 vn_nary_op_insert_stmt (stmt
, result
);
5477 /* For X << C, use the value number of X * (1 << C). */
5478 if (INTEGRAL_TYPE_P (type
)
5479 && TYPE_OVERFLOW_WRAPS (type
)
5480 && !TYPE_SATURATING (type
))
5482 tree rhs2
= gimple_assign_rhs2 (stmt
);
5483 if (TREE_CODE (rhs2
) == INTEGER_CST
5484 && tree_fits_uhwi_p (rhs2
)
5485 && tree_to_uhwi (rhs2
) < TYPE_PRECISION (type
))
5487 wide_int w
= wi::set_bit_in_zero (tree_to_uhwi (rhs2
),
5488 TYPE_PRECISION (type
));
5489 gimple_match_op
match_op (gimple_match_cond::UNCOND
,
5490 MULT_EXPR
, type
, rhs1
,
5491 wide_int_to_tree (type
, w
));
5492 result
= vn_nary_build_or_lookup (&match_op
);
5495 bool changed
= set_ssa_val_to (lhs
, result
);
5496 if (TREE_CODE (result
) == SSA_NAME
)
5497 vn_nary_op_insert_stmt (stmt
, result
);
5507 bool changed
= set_ssa_val_to (lhs
, lhs
);
5508 vn_nary_op_insert_stmt (stmt
, lhs
);
5512 /* Visit a call STMT storing into LHS. Return true if the value number
5513 of the LHS has changed as a result. */
5516 visit_reference_op_call (tree lhs
, gcall
*stmt
)
5518 bool changed
= false;
5519 struct vn_reference_s vr1
;
5520 vn_reference_t vnresult
= NULL
;
5521 tree vdef
= gimple_vdef (stmt
);
5522 modref_summary
*summary
;
5524 /* Non-ssa lhs is handled in copy_reference_ops_from_call. */
5525 if (lhs
&& TREE_CODE (lhs
) != SSA_NAME
)
5528 vn_reference_lookup_call (stmt
, &vnresult
, &vr1
);
5530 /* If the lookup did not succeed for pure functions try to use
5531 modref info to find a candidate to CSE to. */
5532 const unsigned accesses_limit
= 8;
5536 && gimple_vuse (stmt
)
5537 && (((summary
= get_modref_function_summary (stmt
, NULL
))
5538 && !summary
->global_memory_read
5539 && summary
->load_accesses
< accesses_limit
)
5540 || gimple_call_flags (stmt
) & ECF_CONST
))
5542 /* First search if we can do someting useful and build a
5543 vector of all loads we have to check. */
5544 bool unknown_memory_access
= false;
5545 auto_vec
<ao_ref
, accesses_limit
> accesses
;
5546 unsigned load_accesses
= summary
? summary
->load_accesses
: 0;
5547 if (!unknown_memory_access
)
5548 /* Add loads done as part of setting up the call arguments.
5549 That's also necessary for CONST functions which will
5550 not have a modref summary. */
5551 for (unsigned i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
5553 tree arg
= gimple_call_arg (stmt
, i
);
5554 if (TREE_CODE (arg
) != SSA_NAME
5555 && !is_gimple_min_invariant (arg
))
5557 if (accesses
.length () >= accesses_limit
- load_accesses
)
5559 unknown_memory_access
= true;
5562 accesses
.quick_grow (accesses
.length () + 1);
5563 ao_ref_init (&accesses
.last (), arg
);
5566 if (summary
&& !unknown_memory_access
)
5568 /* Add loads as analyzed by IPA modref. */
5569 for (auto base_node
: summary
->loads
->bases
)
5570 if (unknown_memory_access
)
5572 else for (auto ref_node
: base_node
->refs
)
5573 if (unknown_memory_access
)
5575 else for (auto access_node
: ref_node
->accesses
)
5577 accesses
.quick_grow (accesses
.length () + 1);
5578 ao_ref
*r
= &accesses
.last ();
5579 if (!access_node
.get_ao_ref (stmt
, r
))
5581 /* Initialize a ref based on the argument and
5582 unknown offset if possible. */
5583 tree arg
= access_node
.get_call_arg (stmt
);
5584 if (arg
&& TREE_CODE (arg
) == SSA_NAME
)
5585 arg
= SSA_VAL (arg
);
5587 && TREE_CODE (arg
) == ADDR_EXPR
5588 && (arg
= get_base_address (arg
))
5591 ao_ref_init (r
, arg
);
5597 unknown_memory_access
= true;
5601 r
->base_alias_set
= base_node
->base
;
5602 r
->ref_alias_set
= ref_node
->ref
;
5606 /* Walk the VUSE->VDEF chain optimistically trying to find an entry
5607 for the call in the hashtable. */
5608 unsigned limit
= (unknown_memory_access
5610 : (param_sccvn_max_alias_queries_per_access
5611 / (accesses
.length () + 1)));
5612 tree saved_vuse
= vr1
.vuse
;
5613 hashval_t saved_hashcode
= vr1
.hashcode
;
5614 while (limit
> 0 && !vnresult
&& !SSA_NAME_IS_DEFAULT_DEF (vr1
.vuse
))
5616 vr1
.hashcode
= vr1
.hashcode
- SSA_NAME_VERSION (vr1
.vuse
);
5617 gimple
*def
= SSA_NAME_DEF_STMT (vr1
.vuse
);
5618 /* ??? We could use fancy stuff like in walk_non_aliased_vuses, but
5619 do not bother for now. */
5620 if (is_a
<gphi
*> (def
))
5622 vr1
.vuse
= vuse_ssa_val (gimple_vuse (def
));
5623 vr1
.hashcode
= vr1
.hashcode
+ SSA_NAME_VERSION (vr1
.vuse
);
5624 vn_reference_lookup_1 (&vr1
, &vnresult
);
5628 /* If we found a candidate to CSE to verify it is valid. */
5629 if (vnresult
&& !accesses
.is_empty ())
5631 tree vuse
= vuse_ssa_val (gimple_vuse (stmt
));
5632 while (vnresult
&& vuse
!= vr1
.vuse
)
5634 gimple
*def
= SSA_NAME_DEF_STMT (vuse
);
5635 for (auto &ref
: accesses
)
5637 /* ??? stmt_may_clobber_ref_p_1 does per stmt constant
5638 analysis overhead that we might be able to cache. */
5639 if (stmt_may_clobber_ref_p_1 (def
, &ref
, true))
5645 vuse
= vuse_ssa_val (gimple_vuse (def
));
5648 vr1
.vuse
= saved_vuse
;
5649 vr1
.hashcode
= saved_hashcode
;
5656 if (vnresult
->result_vdef
)
5657 changed
|= set_ssa_val_to (vdef
, vnresult
->result_vdef
);
5658 else if (!lhs
&& gimple_call_lhs (stmt
))
5659 /* If stmt has non-SSA_NAME lhs, value number the vdef to itself,
5660 as the call still acts as a lhs store. */
5661 changed
|= set_ssa_val_to (vdef
, vdef
);
5663 /* If the call was discovered to be pure or const reflect
5664 that as far as possible. */
5665 changed
|= set_ssa_val_to (vdef
,
5666 vuse_ssa_val (gimple_vuse (stmt
)));
5669 if (!vnresult
->result
&& lhs
)
5670 vnresult
->result
= lhs
;
5672 if (vnresult
->result
&& lhs
)
5673 changed
|= set_ssa_val_to (lhs
, vnresult
->result
);
5678 vn_reference_s
**slot
;
5679 tree vdef_val
= vdef
;
5682 /* If we value numbered an indirect functions function to
5683 one not clobbering memory value number its VDEF to its
5685 tree fn
= gimple_call_fn (stmt
);
5686 if (fn
&& TREE_CODE (fn
) == SSA_NAME
)
5689 if (TREE_CODE (fn
) == ADDR_EXPR
5690 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
5691 && (flags_from_decl_or_type (TREE_OPERAND (fn
, 0))
5692 & (ECF_CONST
| ECF_PURE
))
5693 /* If stmt has non-SSA_NAME lhs, value number the
5694 vdef to itself, as the call still acts as a lhs
5696 && (lhs
|| gimple_call_lhs (stmt
) == NULL_TREE
))
5697 vdef_val
= vuse_ssa_val (gimple_vuse (stmt
));
5699 changed
|= set_ssa_val_to (vdef
, vdef_val
);
5702 changed
|= set_ssa_val_to (lhs
, lhs
);
5703 vr2
= XOBNEW (&vn_tables_obstack
, vn_reference_s
);
5704 vr2
->vuse
= vr1
.vuse
;
5705 /* As we are not walking the virtual operand chain we know the
5706 shared_lookup_references are still original so we can re-use
5708 vr2
->operands
= vr1
.operands
.copy ();
5709 vr2
->type
= vr1
.type
;
5710 vr2
->punned
= vr1
.punned
;
5712 vr2
->base_set
= vr1
.base_set
;
5713 vr2
->hashcode
= vr1
.hashcode
;
5715 vr2
->result_vdef
= vdef_val
;
5717 slot
= valid_info
->references
->find_slot_with_hash (vr2
, vr2
->hashcode
,
5719 gcc_assert (!*slot
);
5721 vr2
->next
= last_inserted_ref
;
5722 last_inserted_ref
= vr2
;
5728 /* Visit a load from a reference operator RHS, part of STMT, value number it,
5729 and return true if the value number of the LHS has changed as a result. */
5732 visit_reference_op_load (tree lhs
, tree op
, gimple
*stmt
)
5734 bool changed
= false;
5738 tree vuse
= gimple_vuse (stmt
);
5739 tree last_vuse
= vuse
;
5740 result
= vn_reference_lookup (op
, vuse
, default_vn_walk_kind
, &res
, true, &last_vuse
);
5742 /* We handle type-punning through unions by value-numbering based
5743 on offset and size of the access. Be prepared to handle a
5744 type-mismatch here via creating a VIEW_CONVERT_EXPR. */
5746 && !useless_type_conversion_p (TREE_TYPE (result
), TREE_TYPE (op
)))
5748 /* Avoid the type punning in case the result mode has padding where
5749 the op we lookup has not. */
5750 if (maybe_lt (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (result
))),
5751 GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (op
)))))
5755 /* We will be setting the value number of lhs to the value number
5756 of VIEW_CONVERT_EXPR <TREE_TYPE (result)> (result).
5757 So first simplify and lookup this expression to see if it
5758 is already available. */
5759 gimple_match_op
res_op (gimple_match_cond::UNCOND
,
5760 VIEW_CONVERT_EXPR
, TREE_TYPE (op
), result
);
5761 result
= vn_nary_build_or_lookup (&res_op
);
5763 && TREE_CODE (result
) == SSA_NAME
5764 && VN_INFO (result
)->needs_insertion
)
5765 /* Track whether this is the canonical expression for different
5766 typed loads. We use that as a stopgap measure for code
5767 hoisting when dealing with floating point loads. */
5771 /* When building the conversion fails avoid inserting the reference
5774 return set_ssa_val_to (lhs
, lhs
);
5778 changed
= set_ssa_val_to (lhs
, result
);
5781 changed
= set_ssa_val_to (lhs
, lhs
);
5782 vn_reference_insert (op
, lhs
, last_vuse
, NULL_TREE
);
5783 if (vuse
&& SSA_VAL (last_vuse
) != SSA_VAL (vuse
))
5785 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5787 fprintf (dump_file
, "Using extra use virtual operand ");
5788 print_generic_expr (dump_file
, last_vuse
);
5789 fprintf (dump_file
, "\n");
5791 vn_reference_insert (op
, lhs
, vuse
, NULL_TREE
);
5799 /* Visit a store to a reference operator LHS, part of STMT, value number it,
5800 and return true if the value number of the LHS has changed as a result. */
5803 visit_reference_op_store (tree lhs
, tree op
, gimple
*stmt
)
5805 bool changed
= false;
5806 vn_reference_t vnresult
= NULL
;
5808 bool resultsame
= false;
5809 tree vuse
= gimple_vuse (stmt
);
5810 tree vdef
= gimple_vdef (stmt
);
5812 if (TREE_CODE (op
) == SSA_NAME
)
5815 /* First we want to lookup using the *vuses* from the store and see
5816 if there the last store to this location with the same address
5819 The vuses represent the memory state before the store. If the
5820 memory state, address, and value of the store is the same as the
5821 last store to this location, then this store will produce the
5822 same memory state as that store.
5824 In this case the vdef versions for this store are value numbered to those
5825 vuse versions, since they represent the same memory state after
5828 Otherwise, the vdefs for the store are used when inserting into
5829 the table, since the store generates a new memory state. */
5831 vn_reference_lookup (lhs
, vuse
, VN_NOWALK
, &vnresult
, false);
5833 && vnresult
->result
)
5835 tree result
= vnresult
->result
;
5836 gcc_checking_assert (TREE_CODE (result
) != SSA_NAME
5837 || result
== SSA_VAL (result
));
5838 resultsame
= expressions_equal_p (result
, op
);
5841 /* If the TBAA state isn't compatible for downstream reads
5842 we cannot value-number the VDEFs the same. */
5844 ao_ref_init (&lhs_ref
, lhs
);
5845 alias_set_type set
= ao_ref_alias_set (&lhs_ref
);
5846 alias_set_type base_set
= ao_ref_base_alias_set (&lhs_ref
);
5847 if ((vnresult
->set
!= set
5848 && ! alias_set_subset_of (set
, vnresult
->set
))
5849 || (vnresult
->base_set
!= base_set
5850 && ! alias_set_subset_of (base_set
, vnresult
->base_set
)))
5857 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5859 fprintf (dump_file
, "No store match\n");
5860 fprintf (dump_file
, "Value numbering store ");
5861 print_generic_expr (dump_file
, lhs
);
5862 fprintf (dump_file
, " to ");
5863 print_generic_expr (dump_file
, op
);
5864 fprintf (dump_file
, "\n");
5866 /* Have to set value numbers before insert, since insert is
5867 going to valueize the references in-place. */
5869 changed
|= set_ssa_val_to (vdef
, vdef
);
5871 /* Do not insert structure copies into the tables. */
5872 if (is_gimple_min_invariant (op
)
5873 || is_gimple_reg (op
))
5874 vn_reference_insert (lhs
, op
, vdef
, NULL
);
5876 /* Only perform the following when being called from PRE
5877 which embeds tail merging. */
5878 if (default_vn_walk_kind
== VN_WALK
)
5880 assign
= build2 (MODIFY_EXPR
, TREE_TYPE (lhs
), lhs
, op
);
5881 vn_reference_lookup (assign
, vuse
, VN_NOWALK
, &vnresult
, false);
5883 vn_reference_insert (assign
, lhs
, vuse
, vdef
);
5888 /* We had a match, so value number the vdef to have the value
5889 number of the vuse it came from. */
5891 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5892 fprintf (dump_file
, "Store matched earlier value, "
5893 "value numbering store vdefs to matching vuses.\n");
5895 changed
|= set_ssa_val_to (vdef
, SSA_VAL (vuse
));
5901 /* Visit and value number PHI, return true if the value number
5902 changed. When BACKEDGES_VARYING_P is true then assume all
5903 backedge values are varying. When INSERTED is not NULL then
5904 this is just a ahead query for a possible iteration, set INSERTED
5905 to true if we'd insert into the hashtable. */
5908 visit_phi (gimple
*phi
, bool *inserted
, bool backedges_varying_p
)
5910 tree result
, sameval
= VN_TOP
, seen_undef
= NULL_TREE
;
5911 tree backedge_val
= NULL_TREE
;
5912 bool seen_non_backedge
= false;
5913 tree sameval_base
= NULL_TREE
;
5914 poly_int64 soff
, doff
;
5915 unsigned n_executable
= 0;
5917 edge e
, sameval_e
= NULL
;
5919 /* TODO: We could check for this in initialization, and replace this
5920 with a gcc_assert. */
5921 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)))
5922 return set_ssa_val_to (PHI_RESULT (phi
), PHI_RESULT (phi
));
5924 /* We track whether a PHI was CSEd to to avoid excessive iterations
5925 that would be necessary only because the PHI changed arguments
5928 gimple_set_plf (phi
, GF_PLF_1
, false);
5930 /* See if all non-TOP arguments have the same value. TOP is
5931 equivalent to everything, so we can ignore it. */
5932 basic_block bb
= gimple_bb (phi
);
5933 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
5934 if (e
->flags
& EDGE_EXECUTABLE
)
5936 tree def
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
5938 if (def
== PHI_RESULT (phi
))
5941 if (TREE_CODE (def
) == SSA_NAME
)
5943 if (!backedges_varying_p
|| !(e
->flags
& EDGE_DFS_BACK
))
5944 def
= SSA_VAL (def
);
5945 if (e
->flags
& EDGE_DFS_BACK
)
5948 if (!(e
->flags
& EDGE_DFS_BACK
))
5949 seen_non_backedge
= true;
5952 /* Ignore undefined defs for sameval but record one. */
5953 else if (TREE_CODE (def
) == SSA_NAME
5954 && ! virtual_operand_p (def
)
5955 && ssa_undefined_value_p (def
, false))
5957 else if (sameval
== VN_TOP
)
5962 else if (expressions_equal_p (def
, sameval
))
5964 else if (virtual_operand_p (def
))
5966 sameval
= NULL_TREE
;
5971 /* We know we're arriving only with invariant addresses here,
5972 try harder comparing them. We can do some caching here
5973 which we cannot do in expressions_equal_p. */
5974 if (TREE_CODE (def
) == ADDR_EXPR
5975 && TREE_CODE (sameval
) == ADDR_EXPR
5976 && sameval_base
!= (void *)-1)
5979 sameval_base
= get_addr_base_and_unit_offset
5980 (TREE_OPERAND (sameval
, 0), &soff
);
5982 sameval_base
= (tree
)(void *)-1;
5983 else if ((get_addr_base_and_unit_offset
5984 (TREE_OPERAND (def
, 0), &doff
) == sameval_base
)
5985 && known_eq (soff
, doff
))
5988 /* There's also the possibility to use equivalences. */
5989 if (!FLOAT_TYPE_P (TREE_TYPE (def
))
5990 /* But only do this if we didn't force any of sameval or
5991 val to VARYING because of backedge processing rules. */
5992 && (TREE_CODE (sameval
) != SSA_NAME
5993 || SSA_VAL (sameval
) == sameval
)
5994 && (TREE_CODE (def
) != SSA_NAME
|| SSA_VAL (def
) == def
))
5996 vn_nary_op_t vnresult
;
6000 tree val
= vn_nary_op_lookup_pieces (2, EQ_EXPR
,
6003 if (! val
&& vnresult
&& vnresult
->predicated_values
)
6005 val
= vn_nary_op_get_predicated_value (vnresult
, e
);
6006 if (val
&& integer_truep (val
)
6007 && !(sameval_e
&& (sameval_e
->flags
& EDGE_DFS_BACK
)))
6009 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6011 fprintf (dump_file
, "Predication says ");
6012 print_generic_expr (dump_file
, def
, TDF_NONE
);
6013 fprintf (dump_file
, " and ");
6014 print_generic_expr (dump_file
, sameval
, TDF_NONE
);
6015 fprintf (dump_file
, " are equal on edge %d -> %d\n",
6016 e
->src
->index
, e
->dest
->index
);
6020 /* If on all previous edges the value was equal to def
6021 we can change sameval to def. */
6022 if (EDGE_COUNT (bb
->preds
) == 2
6023 && (val
= vn_nary_op_get_predicated_value
6024 (vnresult
, EDGE_PRED (bb
, 0)))
6025 && integer_truep (val
)
6026 && !(e
->flags
& EDGE_DFS_BACK
))
6028 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6030 fprintf (dump_file
, "Predication says ");
6031 print_generic_expr (dump_file
, def
, TDF_NONE
);
6032 fprintf (dump_file
, " and ");
6033 print_generic_expr (dump_file
, sameval
, TDF_NONE
);
6034 fprintf (dump_file
, " are equal on edge %d -> %d\n",
6035 EDGE_PRED (bb
, 0)->src
->index
,
6036 EDGE_PRED (bb
, 0)->dest
->index
);
6043 sameval
= NULL_TREE
;
6048 /* If the value we want to use is flowing over the backedge and we
6049 should take it as VARYING but it has a non-VARYING value drop to
6051 If we value-number a virtual operand never value-number to the
6052 value from the backedge as that confuses the alias-walking code.
6053 See gcc.dg/torture/pr87176.c. If the value is the same on a
6054 non-backedge everything is OK though. */
6057 && !seen_non_backedge
6058 && TREE_CODE (backedge_val
) == SSA_NAME
6059 && sameval
== backedge_val
6060 && (SSA_NAME_IS_VIRTUAL_OPERAND (backedge_val
)
6061 || SSA_VAL (backedge_val
) != backedge_val
))
6062 /* Do not value-number a virtual operand to sth not visited though
6063 given that allows us to escape a region in alias walking. */
6065 && TREE_CODE (sameval
) == SSA_NAME
6066 && !SSA_NAME_IS_DEFAULT_DEF (sameval
)
6067 && SSA_NAME_IS_VIRTUAL_OPERAND (sameval
)
6068 && (SSA_VAL (sameval
, &visited_p
), !visited_p
)))
6069 /* Note this just drops to VARYING without inserting the PHI into
6071 result
= PHI_RESULT (phi
);
6072 /* If none of the edges was executable keep the value-number at VN_TOP,
6073 if only a single edge is exectuable use its value. */
6074 else if (n_executable
<= 1)
6075 result
= seen_undef
? seen_undef
: sameval
;
6076 /* If we saw only undefined values and VN_TOP use one of the
6077 undefined values. */
6078 else if (sameval
== VN_TOP
)
6079 result
= seen_undef
? seen_undef
: sameval
;
6080 /* First see if it is equivalent to a phi node in this block. We prefer
6081 this as it allows IV elimination - see PRs 66502 and 67167. */
6082 else if ((result
= vn_phi_lookup (phi
, backedges_varying_p
)))
6085 && TREE_CODE (result
) == SSA_NAME
6086 && gimple_code (SSA_NAME_DEF_STMT (result
)) == GIMPLE_PHI
)
6088 gimple_set_plf (SSA_NAME_DEF_STMT (result
), GF_PLF_1
, true);
6089 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6091 fprintf (dump_file
, "Marking CSEd to PHI node ");
6092 print_gimple_expr (dump_file
, SSA_NAME_DEF_STMT (result
),
6094 fprintf (dump_file
, "\n");
6098 /* If all values are the same use that, unless we've seen undefined
6099 values as well and the value isn't constant.
6100 CCP/copyprop have the same restriction to not remove uninit warnings. */
6102 && (! seen_undef
|| is_gimple_min_invariant (sameval
)))
6106 result
= PHI_RESULT (phi
);
6107 /* Only insert PHIs that are varying, for constant value numbers
6108 we mess up equivalences otherwise as we are only comparing
6109 the immediate controlling predicates. */
6110 vn_phi_insert (phi
, result
, backedges_varying_p
);
6115 return set_ssa_val_to (PHI_RESULT (phi
), result
);
6118 /* Try to simplify RHS using equivalences and constant folding. */
6121 try_to_simplify (gassign
*stmt
)
6123 enum tree_code code
= gimple_assign_rhs_code (stmt
);
6126 /* For stores we can end up simplifying a SSA_NAME rhs. Just return
6127 in this case, there is no point in doing extra work. */
6128 if (code
== SSA_NAME
)
6131 /* First try constant folding based on our current lattice. */
6132 mprts_hook
= vn_lookup_simplify_result
;
6133 tem
= gimple_fold_stmt_to_constant_1 (stmt
, vn_valueize
, vn_valueize
);
6136 && (TREE_CODE (tem
) == SSA_NAME
6137 || is_gimple_min_invariant (tem
)))
6143 /* Visit and value number STMT, return true if the value number
6147 visit_stmt (gimple
*stmt
, bool backedges_varying_p
= false)
6149 bool changed
= false;
6151 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6153 fprintf (dump_file
, "Value numbering stmt = ");
6154 print_gimple_stmt (dump_file
, stmt
, 0);
6157 if (gimple_code (stmt
) == GIMPLE_PHI
)
6158 changed
= visit_phi (stmt
, NULL
, backedges_varying_p
);
6159 else if (gimple_has_volatile_ops (stmt
))
6160 changed
= defs_to_varying (stmt
);
6161 else if (gassign
*ass
= dyn_cast
<gassign
*> (stmt
))
6163 enum tree_code code
= gimple_assign_rhs_code (ass
);
6164 tree lhs
= gimple_assign_lhs (ass
);
6165 tree rhs1
= gimple_assign_rhs1 (ass
);
6168 /* Shortcut for copies. Simplifying copies is pointless,
6169 since we copy the expression and value they represent. */
6170 if (code
== SSA_NAME
6171 && TREE_CODE (lhs
) == SSA_NAME
)
6173 changed
= visit_copy (lhs
, rhs1
);
6176 simplified
= try_to_simplify (ass
);
6179 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6181 fprintf (dump_file
, "RHS ");
6182 print_gimple_expr (dump_file
, ass
, 0);
6183 fprintf (dump_file
, " simplified to ");
6184 print_generic_expr (dump_file
, simplified
);
6185 fprintf (dump_file
, "\n");
6188 /* Setting value numbers to constants will occasionally
6189 screw up phi congruence because constants are not
6190 uniquely associated with a single ssa name that can be
6193 && is_gimple_min_invariant (simplified
)
6194 && TREE_CODE (lhs
) == SSA_NAME
)
6196 changed
= set_ssa_val_to (lhs
, simplified
);
6200 && TREE_CODE (simplified
) == SSA_NAME
6201 && TREE_CODE (lhs
) == SSA_NAME
)
6203 changed
= visit_copy (lhs
, simplified
);
6207 if ((TREE_CODE (lhs
) == SSA_NAME
6208 /* We can substitute SSA_NAMEs that are live over
6209 abnormal edges with their constant value. */
6210 && !(gimple_assign_copy_p (ass
)
6211 && is_gimple_min_invariant (rhs1
))
6213 && is_gimple_min_invariant (simplified
))
6214 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs
))
6215 /* Stores or copies from SSA_NAMEs that are live over
6216 abnormal edges are a problem. */
6217 || (code
== SSA_NAME
6218 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1
)))
6219 changed
= defs_to_varying (ass
);
6220 else if (REFERENCE_CLASS_P (lhs
)
6222 changed
= visit_reference_op_store (lhs
, rhs1
, ass
);
6223 else if (TREE_CODE (lhs
) == SSA_NAME
)
6225 if ((gimple_assign_copy_p (ass
)
6226 && is_gimple_min_invariant (rhs1
))
6228 && is_gimple_min_invariant (simplified
)))
6231 changed
= set_ssa_val_to (lhs
, simplified
);
6233 changed
= set_ssa_val_to (lhs
, rhs1
);
6237 /* Visit the original statement. */
6238 switch (vn_get_stmt_kind (ass
))
6241 changed
= visit_nary_op (lhs
, ass
);
6244 changed
= visit_reference_op_load (lhs
, rhs1
, ass
);
6247 changed
= defs_to_varying (ass
);
6253 changed
= defs_to_varying (ass
);
6255 else if (gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
))
6257 tree lhs
= gimple_call_lhs (call_stmt
);
6258 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
6260 /* Try constant folding based on our current lattice. */
6261 tree simplified
= gimple_fold_stmt_to_constant_1 (call_stmt
,
6265 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6267 fprintf (dump_file
, "call ");
6268 print_gimple_expr (dump_file
, call_stmt
, 0);
6269 fprintf (dump_file
, " simplified to ");
6270 print_generic_expr (dump_file
, simplified
);
6271 fprintf (dump_file
, "\n");
6274 /* Setting value numbers to constants will occasionally
6275 screw up phi congruence because constants are not
6276 uniquely associated with a single ssa name that can be
6279 && is_gimple_min_invariant (simplified
))
6281 changed
= set_ssa_val_to (lhs
, simplified
);
6282 if (gimple_vdef (call_stmt
))
6283 changed
|= set_ssa_val_to (gimple_vdef (call_stmt
),
6284 SSA_VAL (gimple_vuse (call_stmt
)));
6288 && TREE_CODE (simplified
) == SSA_NAME
)
6290 changed
= visit_copy (lhs
, simplified
);
6291 if (gimple_vdef (call_stmt
))
6292 changed
|= set_ssa_val_to (gimple_vdef (call_stmt
),
6293 SSA_VAL (gimple_vuse (call_stmt
)));
6296 else if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs
))
6298 changed
= defs_to_varying (call_stmt
);
6303 /* Pick up flags from a devirtualization target. */
6304 tree fn
= gimple_call_fn (stmt
);
6305 int extra_fnflags
= 0;
6306 if (fn
&& TREE_CODE (fn
) == SSA_NAME
)
6309 if (TREE_CODE (fn
) == ADDR_EXPR
6310 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
)
6311 extra_fnflags
= flags_from_decl_or_type (TREE_OPERAND (fn
, 0));
6313 if ((/* Calls to the same function with the same vuse
6314 and the same operands do not necessarily return the same
6315 value, unless they're pure or const. */
6316 ((gimple_call_flags (call_stmt
) | extra_fnflags
)
6317 & (ECF_PURE
| ECF_CONST
))
6318 /* If calls have a vdef, subsequent calls won't have
6319 the same incoming vuse. So, if 2 calls with vdef have the
6320 same vuse, we know they're not subsequent.
6321 We can value number 2 calls to the same function with the
6322 same vuse and the same operands which are not subsequent
6323 the same, because there is no code in the program that can
6324 compare the 2 values... */
6325 || (gimple_vdef (call_stmt
)
6326 /* ... unless the call returns a pointer which does
6327 not alias with anything else. In which case the
6328 information that the values are distinct are encoded
6330 && !(gimple_call_return_flags (call_stmt
) & ERF_NOALIAS
)
6331 /* Only perform the following when being called from PRE
6332 which embeds tail merging. */
6333 && default_vn_walk_kind
== VN_WALK
))
6334 /* Do not process .DEFERRED_INIT since that confuses uninit
6336 && !gimple_call_internal_p (call_stmt
, IFN_DEFERRED_INIT
))
6337 changed
= visit_reference_op_call (lhs
, call_stmt
);
6339 changed
= defs_to_varying (call_stmt
);
6342 changed
= defs_to_varying (stmt
);
6348 /* Allocate a value number table. */
6351 allocate_vn_table (vn_tables_t table
, unsigned size
)
6353 table
->phis
= new vn_phi_table_type (size
);
6354 table
->nary
= new vn_nary_op_table_type (size
);
6355 table
->references
= new vn_reference_table_type (size
);
6358 /* Free a value number table. */
6361 free_vn_table (vn_tables_t table
)
6363 /* Walk over elements and release vectors. */
6364 vn_reference_iterator_type hir
;
6366 FOR_EACH_HASH_TABLE_ELEMENT (*table
->references
, vr
, vn_reference_t
, hir
)
6367 vr
->operands
.release ();
6372 delete table
->references
;
6373 table
->references
= NULL
;
6376 /* Set *ID according to RESULT. */
6379 set_value_id_for_result (tree result
, unsigned int *id
)
6381 if (result
&& TREE_CODE (result
) == SSA_NAME
)
6382 *id
= VN_INFO (result
)->value_id
;
6383 else if (result
&& is_gimple_min_invariant (result
))
6384 *id
= get_or_alloc_constant_value_id (result
);
6386 *id
= get_next_value_id ();
6389 /* Set the value ids in the valid hash tables. */
6392 set_hashtable_value_ids (void)
6394 vn_nary_op_iterator_type hin
;
6395 vn_phi_iterator_type hip
;
6396 vn_reference_iterator_type hir
;
6401 /* Now set the value ids of the things we had put in the hash
6404 FOR_EACH_HASH_TABLE_ELEMENT (*valid_info
->nary
, vno
, vn_nary_op_t
, hin
)
6405 if (! vno
->predicated_values
)
6406 set_value_id_for_result (vno
->u
.result
, &vno
->value_id
);
6408 FOR_EACH_HASH_TABLE_ELEMENT (*valid_info
->phis
, vp
, vn_phi_t
, hip
)
6409 set_value_id_for_result (vp
->result
, &vp
->value_id
);
6411 FOR_EACH_HASH_TABLE_ELEMENT (*valid_info
->references
, vr
, vn_reference_t
,
6413 set_value_id_for_result (vr
->result
, &vr
->value_id
);
6416 /* Return the maximum value id we have ever seen. */
6419 get_max_value_id (void)
6421 return next_value_id
;
6424 /* Return the maximum constant value id we have ever seen. */
6427 get_max_constant_value_id (void)
6429 return -next_constant_value_id
;
6432 /* Return the next unique value id. */
6435 get_next_value_id (void)
6437 gcc_checking_assert ((int)next_value_id
> 0);
6438 return next_value_id
++;
6441 /* Return the next unique value id for constants. */
6444 get_next_constant_value_id (void)
6446 gcc_checking_assert (next_constant_value_id
< 0);
6447 return next_constant_value_id
--;
6451 /* Compare two expressions E1 and E2 and return true if they are equal.
6452 If match_vn_top_optimistically is true then VN_TOP is equal to anything,
6453 otherwise VN_TOP only matches VN_TOP. */
6456 expressions_equal_p (tree e1
, tree e2
, bool match_vn_top_optimistically
)
6458 /* The obvious case. */
6462 /* If either one is VN_TOP consider them equal. */
6463 if (match_vn_top_optimistically
6464 && (e1
== VN_TOP
|| e2
== VN_TOP
))
6467 /* If only one of them is null, they cannot be equal. While in general
6468 this should not happen for operations like TARGET_MEM_REF some
6469 operands are optional and an identity value we could substitute
6470 has differing semantics. */
6474 /* SSA_NAME compare pointer equal. */
6475 if (TREE_CODE (e1
) == SSA_NAME
|| TREE_CODE (e2
) == SSA_NAME
)
6478 /* Now perform the actual comparison. */
6479 if (TREE_CODE (e1
) == TREE_CODE (e2
)
6480 && operand_equal_p (e1
, e2
, OEP_PURE_SAME
))
6487 /* Return true if the nary operation NARY may trap. This is a copy
6488 of stmt_could_throw_1_p adjusted to the SCCVN IL. */
6491 vn_nary_may_trap (vn_nary_op_t nary
)
6494 tree rhs2
= NULL_TREE
;
6495 bool honor_nans
= false;
6496 bool honor_snans
= false;
6497 bool fp_operation
= false;
6498 bool honor_trapv
= false;
6502 if (TREE_CODE_CLASS (nary
->opcode
) == tcc_comparison
6503 || TREE_CODE_CLASS (nary
->opcode
) == tcc_unary
6504 || TREE_CODE_CLASS (nary
->opcode
) == tcc_binary
)
6507 fp_operation
= FLOAT_TYPE_P (type
);
6510 honor_nans
= flag_trapping_math
&& !flag_finite_math_only
;
6511 honor_snans
= flag_signaling_nans
!= 0;
6513 else if (INTEGRAL_TYPE_P (type
) && TYPE_OVERFLOW_TRAPS (type
))
6516 if (nary
->length
>= 2)
6518 ret
= operation_could_trap_helper_p (nary
->opcode
, fp_operation
,
6519 honor_trapv
, honor_nans
, honor_snans
,
6524 for (i
= 0; i
< nary
->length
; ++i
)
6525 if (tree_could_trap_p (nary
->op
[i
]))
6531 /* Return true if the reference operation REF may trap. */
6534 vn_reference_may_trap (vn_reference_t ref
)
6536 switch (ref
->operands
[0].opcode
)
6540 /* We do not handle calls. */
6543 /* And toplevel address computations never trap. */
6548 vn_reference_op_t op
;
6550 FOR_EACH_VEC_ELT (ref
->operands
, i
, op
)
6554 case WITH_SIZE_EXPR
:
6555 case TARGET_MEM_REF
:
6556 /* Always variable. */
6559 if (op
->op1
&& TREE_CODE (op
->op1
) == SSA_NAME
)
6562 case ARRAY_RANGE_REF
:
6563 if (TREE_CODE (op
->op0
) == SSA_NAME
)
6568 if (TREE_CODE (op
->op0
) != INTEGER_CST
)
6571 /* !in_array_bounds */
6572 tree domain_type
= TYPE_DOMAIN (ref
->operands
[i
+1].type
);
6577 tree max
= TYPE_MAX_VALUE (domain_type
);
6580 || TREE_CODE (min
) != INTEGER_CST
6581 || TREE_CODE (max
) != INTEGER_CST
)
6584 if (tree_int_cst_lt (op
->op0
, min
)
6585 || tree_int_cst_lt (max
, op
->op0
))
6591 /* Nothing interesting in itself, the base is separate. */
6593 /* The following are the address bases. */
6598 return tree_could_trap_p (TREE_OPERAND (op
->op0
, 0));
6606 eliminate_dom_walker::eliminate_dom_walker (cdi_direction direction
,
6607 bitmap inserted_exprs_
)
6608 : dom_walker (direction
), do_pre (inserted_exprs_
!= NULL
),
6609 el_todo (0), eliminations (0), insertions (0),
6610 inserted_exprs (inserted_exprs_
)
6612 need_eh_cleanup
= BITMAP_ALLOC (NULL
);
6613 need_ab_cleanup
= BITMAP_ALLOC (NULL
);
6616 eliminate_dom_walker::~eliminate_dom_walker ()
6618 BITMAP_FREE (need_eh_cleanup
);
6619 BITMAP_FREE (need_ab_cleanup
);
6622 /* Return a leader for OP that is available at the current point of the
6623 eliminate domwalk. */
6626 eliminate_dom_walker::eliminate_avail (basic_block
, tree op
)
6628 tree valnum
= VN_INFO (op
)->valnum
;
6629 if (TREE_CODE (valnum
) == SSA_NAME
)
6631 if (SSA_NAME_IS_DEFAULT_DEF (valnum
))
6633 if (avail
.length () > SSA_NAME_VERSION (valnum
))
6635 tree av
= avail
[SSA_NAME_VERSION (valnum
)];
6636 /* When PRE discovers a new redundancy there's no way to unite
6637 the value classes so it instead inserts a copy old-val = new-val.
6638 Look through such copies here, providing one more level of
6639 simplification at elimination time. */
6641 if (av
&& (ass
= dyn_cast
<gassign
*> (SSA_NAME_DEF_STMT (av
))))
6642 if (gimple_assign_rhs_class (ass
) == GIMPLE_SINGLE_RHS
)
6644 tree rhs1
= gimple_assign_rhs1 (ass
);
6645 if (CONSTANT_CLASS_P (rhs1
)
6646 || (TREE_CODE (rhs1
) == SSA_NAME
6647 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1
)))
6653 else if (is_gimple_min_invariant (valnum
))
6658 /* At the current point of the eliminate domwalk make OP available. */
6661 eliminate_dom_walker::eliminate_push_avail (basic_block
, tree op
)
6663 tree valnum
= VN_INFO (op
)->valnum
;
6664 if (TREE_CODE (valnum
) == SSA_NAME
)
6666 if (avail
.length () <= SSA_NAME_VERSION (valnum
))
6667 avail
.safe_grow_cleared (SSA_NAME_VERSION (valnum
) + 1, true);
6669 if (avail
[SSA_NAME_VERSION (valnum
)])
6670 pushop
= avail
[SSA_NAME_VERSION (valnum
)];
6671 avail_stack
.safe_push (pushop
);
6672 avail
[SSA_NAME_VERSION (valnum
)] = op
;
6676 /* Insert the expression recorded by SCCVN for VAL at *GSI. Returns
6677 the leader for the expression if insertion was successful. */
6680 eliminate_dom_walker::eliminate_insert (basic_block bb
,
6681 gimple_stmt_iterator
*gsi
, tree val
)
6683 /* We can insert a sequence with a single assignment only. */
6684 gimple_seq stmts
= VN_INFO (val
)->expr
;
6685 if (!gimple_seq_singleton_p (stmts
))
6687 gassign
*stmt
= dyn_cast
<gassign
*> (gimple_seq_first_stmt (stmts
));
6689 || (!CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
))
6690 && gimple_assign_rhs_code (stmt
) != VIEW_CONVERT_EXPR
6691 && gimple_assign_rhs_code (stmt
) != NEGATE_EXPR
6692 && gimple_assign_rhs_code (stmt
) != BIT_FIELD_REF
6693 && (gimple_assign_rhs_code (stmt
) != BIT_AND_EXPR
6694 || TREE_CODE (gimple_assign_rhs2 (stmt
)) != INTEGER_CST
)))
6697 tree op
= gimple_assign_rhs1 (stmt
);
6698 if (gimple_assign_rhs_code (stmt
) == VIEW_CONVERT_EXPR
6699 || gimple_assign_rhs_code (stmt
) == BIT_FIELD_REF
)
6700 op
= TREE_OPERAND (op
, 0);
6701 tree leader
= TREE_CODE (op
) == SSA_NAME
? eliminate_avail (bb
, op
) : op
;
6707 if (gimple_assign_rhs_code (stmt
) == BIT_FIELD_REF
)
6708 res
= gimple_build (&stmts
, BIT_FIELD_REF
,
6709 TREE_TYPE (val
), leader
,
6710 TREE_OPERAND (gimple_assign_rhs1 (stmt
), 1),
6711 TREE_OPERAND (gimple_assign_rhs1 (stmt
), 2));
6712 else if (gimple_assign_rhs_code (stmt
) == BIT_AND_EXPR
)
6713 res
= gimple_build (&stmts
, BIT_AND_EXPR
,
6714 TREE_TYPE (val
), leader
, gimple_assign_rhs2 (stmt
));
6716 res
= gimple_build (&stmts
, gimple_assign_rhs_code (stmt
),
6717 TREE_TYPE (val
), leader
);
6718 if (TREE_CODE (res
) != SSA_NAME
6719 || SSA_NAME_IS_DEFAULT_DEF (res
)
6720 || gimple_bb (SSA_NAME_DEF_STMT (res
)))
6722 gimple_seq_discard (stmts
);
6724 /* During propagation we have to treat SSA info conservatively
6725 and thus we can end up simplifying the inserted expression
6726 at elimination time to sth not defined in stmts. */
6727 /* But then this is a redundancy we failed to detect. Which means
6728 res now has two values. That doesn't play well with how
6729 we track availability here, so give up. */
6730 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6732 if (TREE_CODE (res
) == SSA_NAME
)
6733 res
= eliminate_avail (bb
, res
);
6736 fprintf (dump_file
, "Failed to insert expression for value ");
6737 print_generic_expr (dump_file
, val
);
6738 fprintf (dump_file
, " which is really fully redundant to ");
6739 print_generic_expr (dump_file
, res
);
6740 fprintf (dump_file
, "\n");
6748 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
6749 vn_ssa_aux_t vn_info
= VN_INFO (res
);
6750 vn_info
->valnum
= val
;
6751 vn_info
->visited
= true;
6755 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6757 fprintf (dump_file
, "Inserted ");
6758 print_gimple_stmt (dump_file
, SSA_NAME_DEF_STMT (res
), 0);
6765 eliminate_dom_walker::eliminate_stmt (basic_block b
, gimple_stmt_iterator
*gsi
)
6767 tree sprime
= NULL_TREE
;
6768 gimple
*stmt
= gsi_stmt (*gsi
);
6769 tree lhs
= gimple_get_lhs (stmt
);
6770 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
6771 && !gimple_has_volatile_ops (stmt
)
6772 /* See PR43491. Do not replace a global register variable when
6773 it is a the RHS of an assignment. Do replace local register
6774 variables since gcc does not guarantee a local variable will
6775 be allocated in register.
6776 ??? The fix isn't effective here. This should instead
6777 be ensured by not value-numbering them the same but treating
6778 them like volatiles? */
6779 && !(gimple_assign_single_p (stmt
)
6780 && (TREE_CODE (gimple_assign_rhs1 (stmt
)) == VAR_DECL
6781 && DECL_HARD_REGISTER (gimple_assign_rhs1 (stmt
))
6782 && is_global_var (gimple_assign_rhs1 (stmt
)))))
6784 sprime
= eliminate_avail (b
, lhs
);
6787 /* If there is no existing usable leader but SCCVN thinks
6788 it has an expression it wants to use as replacement,
6790 tree val
= VN_INFO (lhs
)->valnum
;
6791 vn_ssa_aux_t vn_info
;
6793 && TREE_CODE (val
) == SSA_NAME
6794 && (vn_info
= VN_INFO (val
), true)
6795 && vn_info
->needs_insertion
6796 && vn_info
->expr
!= NULL
6797 && (sprime
= eliminate_insert (b
, gsi
, val
)) != NULL_TREE
)
6798 eliminate_push_avail (b
, sprime
);
6801 /* If this now constitutes a copy duplicate points-to
6802 and range info appropriately. This is especially
6803 important for inserted code. See tree-ssa-copy.cc
6804 for similar code. */
6806 && TREE_CODE (sprime
) == SSA_NAME
)
6808 basic_block sprime_b
= gimple_bb (SSA_NAME_DEF_STMT (sprime
));
6809 if (POINTER_TYPE_P (TREE_TYPE (lhs
))
6810 && SSA_NAME_PTR_INFO (lhs
)
6811 && ! SSA_NAME_PTR_INFO (sprime
))
6813 duplicate_ssa_name_ptr_info (sprime
,
6814 SSA_NAME_PTR_INFO (lhs
));
6816 reset_flow_sensitive_info (sprime
);
6818 else if (INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
6819 && SSA_NAME_RANGE_INFO (lhs
)
6820 && ! SSA_NAME_RANGE_INFO (sprime
)
6822 duplicate_ssa_name_range_info (sprime
, lhs
);
6825 /* Inhibit the use of an inserted PHI on a loop header when
6826 the address of the memory reference is a simple induction
6827 variable. In other cases the vectorizer won't do anything
6828 anyway (either it's loop invariant or a complicated
6831 && TREE_CODE (sprime
) == SSA_NAME
6833 && (flag_tree_loop_vectorize
|| flag_tree_parallelize_loops
> 1)
6834 && loop_outer (b
->loop_father
)
6835 && has_zero_uses (sprime
)
6836 && bitmap_bit_p (inserted_exprs
, SSA_NAME_VERSION (sprime
))
6837 && gimple_assign_load_p (stmt
))
6839 gimple
*def_stmt
= SSA_NAME_DEF_STMT (sprime
);
6840 basic_block def_bb
= gimple_bb (def_stmt
);
6841 if (gimple_code (def_stmt
) == GIMPLE_PHI
6842 && def_bb
->loop_father
->header
== def_bb
)
6844 loop_p loop
= def_bb
->loop_father
;
6848 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
6851 def_bb
= gimple_bb (SSA_NAME_DEF_STMT (op
));
6853 && flow_bb_inside_loop_p (loop
, def_bb
)
6854 && simple_iv (loop
, loop
, op
, &iv
, true))
6862 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6864 fprintf (dump_file
, "Not replacing ");
6865 print_gimple_expr (dump_file
, stmt
, 0);
6866 fprintf (dump_file
, " with ");
6867 print_generic_expr (dump_file
, sprime
);
6868 fprintf (dump_file
, " which would add a loop"
6869 " carried dependence to loop %d\n",
6872 /* Don't keep sprime available. */
6880 /* If we can propagate the value computed for LHS into
6881 all uses don't bother doing anything with this stmt. */
6882 if (may_propagate_copy (lhs
, sprime
))
6884 /* Mark it for removal. */
6885 to_remove
.safe_push (stmt
);
6887 /* ??? Don't count copy/constant propagations. */
6888 if (gimple_assign_single_p (stmt
)
6889 && (TREE_CODE (gimple_assign_rhs1 (stmt
)) == SSA_NAME
6890 || gimple_assign_rhs1 (stmt
) == sprime
))
6893 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6895 fprintf (dump_file
, "Replaced ");
6896 print_gimple_expr (dump_file
, stmt
, 0);
6897 fprintf (dump_file
, " with ");
6898 print_generic_expr (dump_file
, sprime
);
6899 fprintf (dump_file
, " in all uses of ");
6900 print_gimple_stmt (dump_file
, stmt
, 0);
6907 /* If this is an assignment from our leader (which
6908 happens in the case the value-number is a constant)
6909 then there is nothing to do. Likewise if we run into
6910 inserted code that needed a conversion because of
6911 our type-agnostic value-numbering of loads. */
6912 if ((gimple_assign_single_p (stmt
)
6913 || (is_gimple_assign (stmt
)
6914 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
))
6915 || gimple_assign_rhs_code (stmt
) == VIEW_CONVERT_EXPR
)))
6916 && sprime
== gimple_assign_rhs1 (stmt
))
6919 /* Else replace its RHS. */
6920 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6922 fprintf (dump_file
, "Replaced ");
6923 print_gimple_expr (dump_file
, stmt
, 0);
6924 fprintf (dump_file
, " with ");
6925 print_generic_expr (dump_file
, sprime
);
6926 fprintf (dump_file
, " in ");
6927 print_gimple_stmt (dump_file
, stmt
, 0);
6931 bool can_make_abnormal_goto
= (is_gimple_call (stmt
)
6932 && stmt_can_make_abnormal_goto (stmt
));
6933 gimple
*orig_stmt
= stmt
;
6934 if (!useless_type_conversion_p (TREE_TYPE (lhs
),
6935 TREE_TYPE (sprime
)))
6937 /* We preserve conversions to but not from function or method
6938 types. This asymmetry makes it necessary to re-instantiate
6939 conversions here. */
6940 if (POINTER_TYPE_P (TREE_TYPE (lhs
))
6941 && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (lhs
))))
6942 sprime
= fold_convert (TREE_TYPE (lhs
), sprime
);
6946 tree vdef
= gimple_vdef (stmt
);
6947 tree vuse
= gimple_vuse (stmt
);
6948 propagate_tree_value_into_stmt (gsi
, sprime
);
6949 stmt
= gsi_stmt (*gsi
);
6951 /* In case the VDEF on the original stmt was released, value-number
6952 it to the VUSE. This is to make vuse_ssa_val able to skip
6953 released virtual operands. */
6954 if (vdef
!= gimple_vdef (stmt
))
6956 gcc_assert (SSA_NAME_IN_FREE_LIST (vdef
));
6957 VN_INFO (vdef
)->valnum
= vuse
;
6960 /* If we removed EH side-effects from the statement, clean
6961 its EH information. */
6962 if (maybe_clean_or_replace_eh_stmt (orig_stmt
, stmt
))
6964 bitmap_set_bit (need_eh_cleanup
,
6965 gimple_bb (stmt
)->index
);
6966 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6967 fprintf (dump_file
, " Removed EH side-effects.\n");
6970 /* Likewise for AB side-effects. */
6971 if (can_make_abnormal_goto
6972 && !stmt_can_make_abnormal_goto (stmt
))
6974 bitmap_set_bit (need_ab_cleanup
,
6975 gimple_bb (stmt
)->index
);
6976 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6977 fprintf (dump_file
, " Removed AB side-effects.\n");
6984 /* If the statement is a scalar store, see if the expression
6985 has the same value number as its rhs. If so, the store is
6987 if (gimple_assign_single_p (stmt
)
6988 && !gimple_has_volatile_ops (stmt
)
6989 && !is_gimple_reg (gimple_assign_lhs (stmt
))
6990 && (TREE_CODE (gimple_assign_rhs1 (stmt
)) == SSA_NAME
6991 || is_gimple_min_invariant (gimple_assign_rhs1 (stmt
))))
6993 tree rhs
= gimple_assign_rhs1 (stmt
);
6994 vn_reference_t vnresult
;
6995 /* ??? gcc.dg/torture/pr91445.c shows that we lookup a boolean
6996 typed load of a byte known to be 0x11 as 1 so a store of
6997 a boolean 1 is detected as redundant. Because of this we
6998 have to make sure to lookup with a ref where its size
6999 matches the precision. */
7000 tree lookup_lhs
= lhs
;
7001 if (INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
7002 && (TREE_CODE (lhs
) != COMPONENT_REF
7003 || !DECL_BIT_FIELD_TYPE (TREE_OPERAND (lhs
, 1)))
7004 && !type_has_mode_precision_p (TREE_TYPE (lhs
)))
7006 if (TREE_CODE (TREE_TYPE (lhs
)) == BITINT_TYPE
7007 && TYPE_PRECISION (TREE_TYPE (lhs
)) > MAX_FIXED_MODE_SIZE
)
7008 lookup_lhs
= NULL_TREE
;
7009 else if (TREE_CODE (lhs
) == COMPONENT_REF
7010 || TREE_CODE (lhs
) == MEM_REF
)
7012 tree ltype
= build_nonstandard_integer_type
7013 (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (lhs
))),
7014 TYPE_UNSIGNED (TREE_TYPE (lhs
)));
7015 if (TREE_CODE (lhs
) == COMPONENT_REF
)
7017 tree foff
= component_ref_field_offset (lhs
);
7018 tree f
= TREE_OPERAND (lhs
, 1);
7019 if (!poly_int_tree_p (foff
))
7020 lookup_lhs
= NULL_TREE
;
7022 lookup_lhs
= build3 (BIT_FIELD_REF
, ltype
,
7023 TREE_OPERAND (lhs
, 0),
7024 TYPE_SIZE (TREE_TYPE (lhs
)),
7026 (foff
, DECL_FIELD_BIT_OFFSET (f
)));
7029 lookup_lhs
= build2 (MEM_REF
, ltype
,
7030 TREE_OPERAND (lhs
, 0),
7031 TREE_OPERAND (lhs
, 1));
7034 lookup_lhs
= NULL_TREE
;
7036 tree val
= NULL_TREE
;
7038 val
= vn_reference_lookup (lookup_lhs
, gimple_vuse (stmt
),
7039 VN_WALKREWRITE
, &vnresult
, false,
7040 NULL
, NULL_TREE
, true);
7041 if (TREE_CODE (rhs
) == SSA_NAME
)
7042 rhs
= VN_INFO (rhs
)->valnum
;
7044 && (operand_equal_p (val
, rhs
, 0)
7045 /* Due to the bitfield lookups above we can get bit
7046 interpretations of the same RHS as values here. Those
7047 are redundant as well. */
7048 || (TREE_CODE (val
) == SSA_NAME
7049 && gimple_assign_single_p (SSA_NAME_DEF_STMT (val
))
7050 && (val
= gimple_assign_rhs1 (SSA_NAME_DEF_STMT (val
)))
7051 && TREE_CODE (val
) == VIEW_CONVERT_EXPR
7052 && TREE_OPERAND (val
, 0) == rhs
)))
7054 /* We can only remove the later store if the former aliases
7055 at least all accesses the later one does or if the store
7056 was to readonly memory storing the same value. */
7058 ao_ref_init (&lhs_ref
, lhs
);
7059 alias_set_type set
= ao_ref_alias_set (&lhs_ref
);
7060 alias_set_type base_set
= ao_ref_base_alias_set (&lhs_ref
);
7062 || ((vnresult
->set
== set
7063 || alias_set_subset_of (set
, vnresult
->set
))
7064 && (vnresult
->base_set
== base_set
7065 || alias_set_subset_of (base_set
, vnresult
->base_set
))))
7067 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7069 fprintf (dump_file
, "Deleted redundant store ");
7070 print_gimple_stmt (dump_file
, stmt
, 0);
7073 /* Queue stmt for removal. */
7074 to_remove
.safe_push (stmt
);
7080 /* If this is a control statement value numbering left edges
7081 unexecuted on force the condition in a way consistent with
7083 if (gcond
*cond
= dyn_cast
<gcond
*> (stmt
))
7085 if ((EDGE_SUCC (b
, 0)->flags
& EDGE_EXECUTABLE
)
7086 ^ (EDGE_SUCC (b
, 1)->flags
& EDGE_EXECUTABLE
))
7088 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7090 fprintf (dump_file
, "Removing unexecutable edge from ");
7091 print_gimple_stmt (dump_file
, stmt
, 0);
7093 if (((EDGE_SUCC (b
, 0)->flags
& EDGE_TRUE_VALUE
) != 0)
7094 == ((EDGE_SUCC (b
, 0)->flags
& EDGE_EXECUTABLE
) != 0))
7095 gimple_cond_make_true (cond
);
7097 gimple_cond_make_false (cond
);
7099 el_todo
|= TODO_cleanup_cfg
;
7104 bool can_make_abnormal_goto
= stmt_can_make_abnormal_goto (stmt
);
7105 bool was_noreturn
= (is_gimple_call (stmt
)
7106 && gimple_call_noreturn_p (stmt
));
7107 tree vdef
= gimple_vdef (stmt
);
7108 tree vuse
= gimple_vuse (stmt
);
7110 /* If we didn't replace the whole stmt (or propagate the result
7111 into all uses), replace all uses on this stmt with their
7113 bool modified
= false;
7114 use_operand_p use_p
;
7116 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
7118 tree use
= USE_FROM_PTR (use_p
);
7119 /* ??? The call code above leaves stmt operands un-updated. */
7120 if (TREE_CODE (use
) != SSA_NAME
)
7123 if (SSA_NAME_IS_DEFAULT_DEF (use
))
7124 /* ??? For default defs BB shouldn't matter, but we have to
7125 solve the inconsistency between rpo eliminate and
7126 dom eliminate avail valueization first. */
7127 sprime
= eliminate_avail (b
, use
);
7129 /* Look for sth available at the definition block of the argument.
7130 This avoids inconsistencies between availability there which
7131 decides if the stmt can be removed and availability at the
7132 use site. The SSA property ensures that things available
7133 at the definition are also available at uses. */
7134 sprime
= eliminate_avail (gimple_bb (SSA_NAME_DEF_STMT (use
)), use
);
7135 if (sprime
&& sprime
!= use
7136 && may_propagate_copy (use
, sprime
, true)
7137 /* We substitute into debug stmts to avoid excessive
7138 debug temporaries created by removed stmts, but we need
7139 to avoid doing so for inserted sprimes as we never want
7140 to create debug temporaries for them. */
7142 || TREE_CODE (sprime
) != SSA_NAME
7143 || !is_gimple_debug (stmt
)
7144 || !bitmap_bit_p (inserted_exprs
, SSA_NAME_VERSION (sprime
))))
7146 propagate_value (use_p
, sprime
);
7151 /* Fold the stmt if modified, this canonicalizes MEM_REFs we propagated
7152 into which is a requirement for the IPA devirt machinery. */
7153 gimple
*old_stmt
= stmt
;
7156 /* If a formerly non-invariant ADDR_EXPR is turned into an
7157 invariant one it was on a separate stmt. */
7158 if (gimple_assign_single_p (stmt
)
7159 && TREE_CODE (gimple_assign_rhs1 (stmt
)) == ADDR_EXPR
)
7160 recompute_tree_invariant_for_addr_expr (gimple_assign_rhs1 (stmt
));
7161 gimple_stmt_iterator prev
= *gsi
;
7163 if (fold_stmt (gsi
, follow_all_ssa_edges
))
7165 /* fold_stmt may have created new stmts inbetween
7166 the previous stmt and the folded stmt. Mark
7167 all defs created there as varying to not confuse
7168 the SCCVN machinery as we're using that even during
7170 if (gsi_end_p (prev
))
7171 prev
= gsi_start_bb (b
);
7174 if (gsi_stmt (prev
) != gsi_stmt (*gsi
))
7179 FOR_EACH_SSA_TREE_OPERAND (def
, gsi_stmt (prev
),
7180 dit
, SSA_OP_ALL_DEFS
)
7181 /* As existing DEFs may move between stmts
7182 only process new ones. */
7183 if (! has_VN_INFO (def
))
7185 vn_ssa_aux_t vn_info
= VN_INFO (def
);
7186 vn_info
->valnum
= def
;
7187 vn_info
->visited
= true;
7189 if (gsi_stmt (prev
) == gsi_stmt (*gsi
))
7195 stmt
= gsi_stmt (*gsi
);
7196 /* In case we folded the stmt away schedule the NOP for removal. */
7197 if (gimple_nop_p (stmt
))
7198 to_remove
.safe_push (stmt
);
7201 /* Visit indirect calls and turn them into direct calls if
7202 possible using the devirtualization machinery. Do this before
7203 checking for required EH/abnormal/noreturn cleanup as devird
7204 may expose more of those. */
7205 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
))
7207 tree fn
= gimple_call_fn (call_stmt
);
7209 && flag_devirtualize
7210 && virtual_method_call_p (fn
))
7212 tree otr_type
= obj_type_ref_class (fn
);
7213 unsigned HOST_WIDE_INT otr_tok
7214 = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (fn
));
7216 ipa_polymorphic_call_context
context (current_function_decl
,
7217 fn
, stmt
, &instance
);
7218 context
.get_dynamic_type (instance
, OBJ_TYPE_REF_OBJECT (fn
),
7219 otr_type
, stmt
, NULL
);
7221 vec
<cgraph_node
*> targets
7222 = possible_polymorphic_call_targets (obj_type_ref_class (fn
),
7223 otr_tok
, context
, &final
);
7225 dump_possible_polymorphic_call_targets (dump_file
,
7226 obj_type_ref_class (fn
),
7228 if (final
&& targets
.length () <= 1 && dbg_cnt (devirt
))
7231 if (targets
.length () == 1)
7232 fn
= targets
[0]->decl
;
7234 fn
= builtin_decl_unreachable ();
7235 if (dump_enabled_p ())
7237 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, stmt
,
7238 "converting indirect call to "
7240 lang_hooks
.decl_printable_name (fn
, 2));
7242 gimple_call_set_fndecl (call_stmt
, fn
);
7243 /* If changing the call to __builtin_unreachable
7244 or similar noreturn function, adjust gimple_call_fntype
7246 if (gimple_call_noreturn_p (call_stmt
)
7247 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fn
)))
7248 && TYPE_ARG_TYPES (TREE_TYPE (fn
))
7249 && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fn
)))
7251 gimple_call_set_fntype (call_stmt
, TREE_TYPE (fn
));
7252 maybe_remove_unused_call_args (cfun
, call_stmt
);
7260 /* When changing a call into a noreturn call, cfg cleanup
7261 is needed to fix up the noreturn call. */
7263 && is_gimple_call (stmt
) && gimple_call_noreturn_p (stmt
))
7264 to_fixup
.safe_push (stmt
);
7265 /* When changing a condition or switch into one we know what
7266 edge will be executed, schedule a cfg cleanup. */
7267 if ((gimple_code (stmt
) == GIMPLE_COND
7268 && (gimple_cond_true_p (as_a
<gcond
*> (stmt
))
7269 || gimple_cond_false_p (as_a
<gcond
*> (stmt
))))
7270 || (gimple_code (stmt
) == GIMPLE_SWITCH
7271 && TREE_CODE (gimple_switch_index
7272 (as_a
<gswitch
*> (stmt
))) == INTEGER_CST
))
7273 el_todo
|= TODO_cleanup_cfg
;
7274 /* If we removed EH side-effects from the statement, clean
7275 its EH information. */
7276 if (maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
))
7278 bitmap_set_bit (need_eh_cleanup
,
7279 gimple_bb (stmt
)->index
);
7280 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7281 fprintf (dump_file
, " Removed EH side-effects.\n");
7283 /* Likewise for AB side-effects. */
7284 if (can_make_abnormal_goto
7285 && !stmt_can_make_abnormal_goto (stmt
))
7287 bitmap_set_bit (need_ab_cleanup
,
7288 gimple_bb (stmt
)->index
);
7289 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7290 fprintf (dump_file
, " Removed AB side-effects.\n");
7293 /* In case the VDEF on the original stmt was released, value-number
7294 it to the VUSE. This is to make vuse_ssa_val able to skip
7295 released virtual operands. */
7296 if (vdef
&& SSA_NAME_IN_FREE_LIST (vdef
))
7297 VN_INFO (vdef
)->valnum
= vuse
;
7300 /* Make new values available - for fully redundant LHS we
7301 continue with the next stmt above and skip this.
7302 But avoid picking up dead defs. */
7304 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, iter
, SSA_OP_DEF
)
7305 if (! has_zero_uses (def
)
7307 && bitmap_bit_p (inserted_exprs
, SSA_NAME_VERSION (def
))))
7308 eliminate_push_avail (b
, def
);
7311 /* Perform elimination for the basic-block B during the domwalk. */
7314 eliminate_dom_walker::before_dom_children (basic_block b
)
7317 avail_stack
.safe_push (NULL_TREE
);
7319 /* Skip unreachable blocks marked unreachable during the SCCVN domwalk. */
7320 if (!(b
->flags
& BB_EXECUTABLE
))
7325 for (gphi_iterator gsi
= gsi_start_phis (b
); !gsi_end_p (gsi
);)
7327 gphi
*phi
= gsi
.phi ();
7328 tree res
= PHI_RESULT (phi
);
7330 if (virtual_operand_p (res
))
7336 tree sprime
= eliminate_avail (b
, res
);
7340 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7342 fprintf (dump_file
, "Replaced redundant PHI node defining ");
7343 print_generic_expr (dump_file
, res
);
7344 fprintf (dump_file
, " with ");
7345 print_generic_expr (dump_file
, sprime
);
7346 fprintf (dump_file
, "\n");
7349 /* If we inserted this PHI node ourself, it's not an elimination. */
7350 if (! inserted_exprs
7351 || ! bitmap_bit_p (inserted_exprs
, SSA_NAME_VERSION (res
)))
7354 /* If we will propagate into all uses don't bother to do
7356 if (may_propagate_copy (res
, sprime
))
7358 /* Mark the PHI for removal. */
7359 to_remove
.safe_push (phi
);
7364 remove_phi_node (&gsi
, false);
7366 if (!useless_type_conversion_p (TREE_TYPE (res
), TREE_TYPE (sprime
)))
7367 sprime
= fold_convert (TREE_TYPE (res
), sprime
);
7368 gimple
*stmt
= gimple_build_assign (res
, sprime
);
7369 gimple_stmt_iterator gsi2
= gsi_after_labels (b
);
7370 gsi_insert_before (&gsi2
, stmt
, GSI_NEW_STMT
);
7374 eliminate_push_avail (b
, res
);
7378 for (gimple_stmt_iterator gsi
= gsi_start_bb (b
);
7381 eliminate_stmt (b
, &gsi
);
7383 /* Replace destination PHI arguments. */
7386 FOR_EACH_EDGE (e
, ei
, b
->succs
)
7387 if (e
->flags
& EDGE_EXECUTABLE
)
7388 for (gphi_iterator gsi
= gsi_start_phis (e
->dest
);
7392 gphi
*phi
= gsi
.phi ();
7393 use_operand_p use_p
= PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
);
7394 tree arg
= USE_FROM_PTR (use_p
);
7395 if (TREE_CODE (arg
) != SSA_NAME
7396 || virtual_operand_p (arg
))
7398 tree sprime
= eliminate_avail (b
, arg
);
7399 if (sprime
&& may_propagate_copy (arg
, sprime
,
7400 !(e
->flags
& EDGE_ABNORMAL
)))
7401 propagate_value (use_p
, sprime
);
7404 vn_context_bb
= NULL
;
7409 /* Make no longer available leaders no longer available. */
7412 eliminate_dom_walker::after_dom_children (basic_block
)
7415 while ((entry
= avail_stack
.pop ()) != NULL_TREE
)
7417 tree valnum
= VN_INFO (entry
)->valnum
;
7418 tree old
= avail
[SSA_NAME_VERSION (valnum
)];
7420 avail
[SSA_NAME_VERSION (valnum
)] = NULL_TREE
;
7422 avail
[SSA_NAME_VERSION (valnum
)] = entry
;
7426 /* Remove queued stmts and perform delayed cleanups. */
7429 eliminate_dom_walker::eliminate_cleanup (bool region_p
)
7431 statistics_counter_event (cfun
, "Eliminated", eliminations
);
7432 statistics_counter_event (cfun
, "Insertions", insertions
);
7434 /* We cannot remove stmts during BB walk, especially not release SSA
7435 names there as this confuses the VN machinery. The stmts ending
7436 up in to_remove are either stores or simple copies.
7437 Remove stmts in reverse order to make debug stmt creation possible. */
7438 while (!to_remove
.is_empty ())
7440 bool do_release_defs
= true;
7441 gimple
*stmt
= to_remove
.pop ();
7443 /* When we are value-numbering a region we do not require exit PHIs to
7444 be present so we have to make sure to deal with uses outside of the
7445 region of stmts that we thought are eliminated.
7446 ??? Note we may be confused by uses in dead regions we didn't run
7447 elimination on. Rather than checking individual uses we accept
7448 dead copies to be generated here (gcc.c-torture/execute/20060905-1.c
7449 contains such example). */
7452 if (gphi
*phi
= dyn_cast
<gphi
*> (stmt
))
7454 tree lhs
= gimple_phi_result (phi
);
7455 if (!has_zero_uses (lhs
))
7457 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7458 fprintf (dump_file
, "Keeping eliminated stmt live "
7459 "as copy because of out-of-region uses\n");
7460 tree sprime
= eliminate_avail (gimple_bb (stmt
), lhs
);
7461 gimple
*copy
= gimple_build_assign (lhs
, sprime
);
7462 gimple_stmt_iterator gsi
7463 = gsi_after_labels (gimple_bb (stmt
));
7464 gsi_insert_before (&gsi
, copy
, GSI_SAME_STMT
);
7465 do_release_defs
= false;
7468 else if (tree lhs
= gimple_get_lhs (stmt
))
7469 if (TREE_CODE (lhs
) == SSA_NAME
7470 && !has_zero_uses (lhs
))
7472 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7473 fprintf (dump_file
, "Keeping eliminated stmt live "
7474 "as copy because of out-of-region uses\n");
7475 tree sprime
= eliminate_avail (gimple_bb (stmt
), lhs
);
7476 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
7477 if (is_gimple_assign (stmt
))
7479 gimple_assign_set_rhs_from_tree (&gsi
, sprime
);
7480 stmt
= gsi_stmt (gsi
);
7482 if (maybe_clean_or_replace_eh_stmt (stmt
, stmt
))
7483 bitmap_set_bit (need_eh_cleanup
, gimple_bb (stmt
)->index
);
7488 gimple
*copy
= gimple_build_assign (lhs
, sprime
);
7489 gsi_insert_before (&gsi
, copy
, GSI_SAME_STMT
);
7490 do_release_defs
= false;
7495 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7497 fprintf (dump_file
, "Removing dead stmt ");
7498 print_gimple_stmt (dump_file
, stmt
, 0, TDF_NONE
);
7501 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
7502 if (gimple_code (stmt
) == GIMPLE_PHI
)
7503 remove_phi_node (&gsi
, do_release_defs
);
7506 basic_block bb
= gimple_bb (stmt
);
7507 unlink_stmt_vdef (stmt
);
7508 if (gsi_remove (&gsi
, true))
7509 bitmap_set_bit (need_eh_cleanup
, bb
->index
);
7510 if (is_gimple_call (stmt
) && stmt_can_make_abnormal_goto (stmt
))
7511 bitmap_set_bit (need_ab_cleanup
, bb
->index
);
7512 if (do_release_defs
)
7513 release_defs (stmt
);
7516 /* Removing a stmt may expose a forwarder block. */
7517 el_todo
|= TODO_cleanup_cfg
;
7520 /* Fixup stmts that became noreturn calls. This may require splitting
7521 blocks and thus isn't possible during the dominator walk. Do this
7522 in reverse order so we don't inadvertedly remove a stmt we want to
7523 fixup by visiting a dominating now noreturn call first. */
7524 while (!to_fixup
.is_empty ())
7526 gimple
*stmt
= to_fixup
.pop ();
7528 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7530 fprintf (dump_file
, "Fixing up noreturn call ");
7531 print_gimple_stmt (dump_file
, stmt
, 0);
7534 if (fixup_noreturn_call (stmt
))
7535 el_todo
|= TODO_cleanup_cfg
;
7538 bool do_eh_cleanup
= !bitmap_empty_p (need_eh_cleanup
);
7539 bool do_ab_cleanup
= !bitmap_empty_p (need_ab_cleanup
);
7542 gimple_purge_all_dead_eh_edges (need_eh_cleanup
);
7545 gimple_purge_all_dead_abnormal_call_edges (need_ab_cleanup
);
7547 if (do_eh_cleanup
|| do_ab_cleanup
)
7548 el_todo
|= TODO_cleanup_cfg
;
7553 /* Eliminate fully redundant computations. */
7556 eliminate_with_rpo_vn (bitmap inserted_exprs
)
7558 eliminate_dom_walker
walker (CDI_DOMINATORS
, inserted_exprs
);
7560 eliminate_dom_walker
*saved_rpo_avail
= rpo_avail
;
7561 rpo_avail
= &walker
;
7562 walker
.walk (cfun
->cfg
->x_entry_block_ptr
);
7563 rpo_avail
= saved_rpo_avail
;
7565 return walker
.eliminate_cleanup ();
7569 do_rpo_vn_1 (function
*fn
, edge entry
, bitmap exit_bbs
,
7570 bool iterate
, bool eliminate
, vn_lookup_kind kind
);
7573 run_rpo_vn (vn_lookup_kind kind
)
7575 do_rpo_vn_1 (cfun
, NULL
, NULL
, true, false, kind
);
7577 /* ??? Prune requirement of these. */
7578 constant_to_value_id
= new hash_table
<vn_constant_hasher
> (23);
7580 /* Initialize the value ids and prune out remaining VN_TOPs
7584 FOR_EACH_SSA_NAME (i
, name
, cfun
)
7586 vn_ssa_aux_t info
= VN_INFO (name
);
7588 || info
->valnum
== VN_TOP
)
7589 info
->valnum
= name
;
7590 if (info
->valnum
== name
)
7591 info
->value_id
= get_next_value_id ();
7592 else if (is_gimple_min_invariant (info
->valnum
))
7593 info
->value_id
= get_or_alloc_constant_value_id (info
->valnum
);
7597 FOR_EACH_SSA_NAME (i
, name
, cfun
)
7599 vn_ssa_aux_t info
= VN_INFO (name
);
7600 if (TREE_CODE (info
->valnum
) == SSA_NAME
7601 && info
->valnum
!= name
7602 && info
->value_id
!= VN_INFO (info
->valnum
)->value_id
)
7603 info
->value_id
= VN_INFO (info
->valnum
)->value_id
;
7606 set_hashtable_value_ids ();
7608 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7610 fprintf (dump_file
, "Value numbers:\n");
7611 FOR_EACH_SSA_NAME (i
, name
, cfun
)
7613 if (VN_INFO (name
)->visited
7614 && SSA_VAL (name
) != name
)
7616 print_generic_expr (dump_file
, name
);
7617 fprintf (dump_file
, " = ");
7618 print_generic_expr (dump_file
, SSA_VAL (name
));
7619 fprintf (dump_file
, " (%04d)\n", VN_INFO (name
)->value_id
);
7625 /* Free VN associated data structures. */
7630 free_vn_table (valid_info
);
7631 XDELETE (valid_info
);
7632 obstack_free (&vn_tables_obstack
, NULL
);
7633 obstack_free (&vn_tables_insert_obstack
, NULL
);
7635 vn_ssa_aux_iterator_type it
;
7637 FOR_EACH_HASH_TABLE_ELEMENT (*vn_ssa_aux_hash
, info
, vn_ssa_aux_t
, it
)
7638 if (info
->needs_insertion
)
7639 release_ssa_name (info
->name
);
7640 obstack_free (&vn_ssa_aux_obstack
, NULL
);
7641 delete vn_ssa_aux_hash
;
7643 delete constant_to_value_id
;
7644 constant_to_value_id
= NULL
;
7647 /* Hook for maybe_push_res_to_seq, lookup the expression in the VN tables. */
7650 vn_lookup_simplify_result (gimple_match_op
*res_op
)
7652 if (!res_op
->code
.is_tree_code ())
7654 tree
*ops
= res_op
->ops
;
7655 unsigned int length
= res_op
->num_ops
;
7656 if (res_op
->code
== CONSTRUCTOR
7657 /* ??? We're arriving here with SCCVNs view, decomposed CONSTRUCTOR
7658 and GIMPLEs / match-and-simplifies, CONSTRUCTOR as GENERIC tree. */
7659 && TREE_CODE (res_op
->ops
[0]) == CONSTRUCTOR
)
7661 length
= CONSTRUCTOR_NELTS (res_op
->ops
[0]);
7662 ops
= XALLOCAVEC (tree
, length
);
7663 for (unsigned i
= 0; i
< length
; ++i
)
7664 ops
[i
] = CONSTRUCTOR_ELT (res_op
->ops
[0], i
)->value
;
7666 vn_nary_op_t vnresult
= NULL
;
7667 tree res
= vn_nary_op_lookup_pieces (length
, (tree_code
) res_op
->code
,
7668 res_op
->type
, ops
, &vnresult
);
7669 /* If this is used from expression simplification make sure to
7670 return an available expression. */
7671 if (res
&& TREE_CODE (res
) == SSA_NAME
&& mprts_hook
&& rpo_avail
)
7672 res
= rpo_avail
->eliminate_avail (vn_context_bb
, res
);
7676 /* Return a leader for OPs value that is valid at BB. */
7679 rpo_elim::eliminate_avail (basic_block bb
, tree op
)
7682 tree valnum
= SSA_VAL (op
, &visited
);
7683 /* If we didn't visit OP then it must be defined outside of the
7684 region we process and also dominate it. So it is available. */
7687 if (TREE_CODE (valnum
) == SSA_NAME
)
7689 if (SSA_NAME_IS_DEFAULT_DEF (valnum
))
7691 vn_ssa_aux_t valnum_info
= VN_INFO (valnum
);
7693 if (!valnum_info
->visited
)
7695 vn_avail
*av
= valnum_info
->avail
;
7698 if (av
->location
== bb
->index
)
7699 /* On tramp3d 90% of the cases are here. */
7700 return ssa_name (av
->leader
);
7703 basic_block abb
= BASIC_BLOCK_FOR_FN (cfun
, av
->location
);
7704 /* ??? During elimination we have to use availability at the
7705 definition site of a use we try to replace. This
7706 is required to not run into inconsistencies because
7707 of dominated_by_p_w_unex behavior and removing a definition
7708 while not replacing all uses.
7709 ??? We could try to consistently walk dominators
7710 ignoring non-executable regions. The nearest common
7711 dominator of bb and abb is where we can stop walking. We
7712 may also be able to "pre-compute" (bits of) the next immediate
7713 (non-)dominator during the RPO walk when marking edges as
7715 if (dominated_by_p_w_unex (bb
, abb
, true))
7717 tree leader
= ssa_name (av
->leader
);
7718 /* Prevent eliminations that break loop-closed SSA. */
7719 if (loops_state_satisfies_p (LOOP_CLOSED_SSA
)
7720 && ! SSA_NAME_IS_DEFAULT_DEF (leader
)
7721 && ! flow_bb_inside_loop_p (gimple_bb (SSA_NAME_DEF_STMT
7722 (leader
))->loop_father
,
7725 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7727 print_generic_expr (dump_file
, leader
);
7728 fprintf (dump_file
, " is available for ");
7729 print_generic_expr (dump_file
, valnum
);
7730 fprintf (dump_file
, "\n");
7732 /* On tramp3d 99% of the _remaining_ cases succeed at
7736 /* ??? Can we somehow skip to the immediate dominator
7737 RPO index (bb_to_rpo)? Again, maybe not worth, on
7738 tramp3d the worst number of elements in the vector is 9. */
7743 else if (valnum
!= VN_TOP
)
7744 /* valnum is is_gimple_min_invariant. */
7749 /* Make LEADER a leader for its value at BB. */
7752 rpo_elim::eliminate_push_avail (basic_block bb
, tree leader
)
7754 tree valnum
= VN_INFO (leader
)->valnum
;
7755 if (valnum
== VN_TOP
7756 || is_gimple_min_invariant (valnum
))
7758 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7760 fprintf (dump_file
, "Making available beyond BB%d ", bb
->index
);
7761 print_generic_expr (dump_file
, leader
);
7762 fprintf (dump_file
, " for value ");
7763 print_generic_expr (dump_file
, valnum
);
7764 fprintf (dump_file
, "\n");
7766 vn_ssa_aux_t value
= VN_INFO (valnum
);
7768 if (m_avail_freelist
)
7770 av
= m_avail_freelist
;
7771 m_avail_freelist
= m_avail_freelist
->next
;
7774 av
= XOBNEW (&vn_ssa_aux_obstack
, vn_avail
);
7775 av
->location
= bb
->index
;
7776 av
->leader
= SSA_NAME_VERSION (leader
);
7777 av
->next
= value
->avail
;
7778 av
->next_undo
= last_pushed_avail
;
7779 last_pushed_avail
= value
;
7783 /* Valueization hook for RPO VN plus required state. */
7786 rpo_vn_valueize (tree name
)
7788 if (TREE_CODE (name
) == SSA_NAME
)
7790 vn_ssa_aux_t val
= VN_INFO (name
);
7793 tree tem
= val
->valnum
;
7794 if (tem
!= VN_TOP
&& tem
!= name
)
7796 if (TREE_CODE (tem
) != SSA_NAME
)
7798 /* For all values we only valueize to an available leader
7799 which means we can use SSA name info without restriction. */
7800 tem
= rpo_avail
->eliminate_avail (vn_context_bb
, tem
);
7809 /* Insert on PRED_E predicates derived from CODE OPS being true besides the
7810 inverted condition. */
7813 insert_related_predicates_on_edge (enum tree_code code
, tree
*ops
, edge pred_e
)
7818 /* a < b -> a {!,<}= b */
7819 vn_nary_op_insert_pieces_predicated (2, NE_EXPR
, boolean_type_node
,
7820 ops
, boolean_true_node
, 0, pred_e
);
7821 vn_nary_op_insert_pieces_predicated (2, LE_EXPR
, boolean_type_node
,
7822 ops
, boolean_true_node
, 0, pred_e
);
7823 /* a < b -> ! a {>,=} b */
7824 vn_nary_op_insert_pieces_predicated (2, GT_EXPR
, boolean_type_node
,
7825 ops
, boolean_false_node
, 0, pred_e
);
7826 vn_nary_op_insert_pieces_predicated (2, EQ_EXPR
, boolean_type_node
,
7827 ops
, boolean_false_node
, 0, pred_e
);
7830 /* a > b -> a {!,>}= b */
7831 vn_nary_op_insert_pieces_predicated (2, NE_EXPR
, boolean_type_node
,
7832 ops
, boolean_true_node
, 0, pred_e
);
7833 vn_nary_op_insert_pieces_predicated (2, GE_EXPR
, boolean_type_node
,
7834 ops
, boolean_true_node
, 0, pred_e
);
7835 /* a > b -> ! a {<,=} b */
7836 vn_nary_op_insert_pieces_predicated (2, LT_EXPR
, boolean_type_node
,
7837 ops
, boolean_false_node
, 0, pred_e
);
7838 vn_nary_op_insert_pieces_predicated (2, EQ_EXPR
, boolean_type_node
,
7839 ops
, boolean_false_node
, 0, pred_e
);
7842 /* a == b -> ! a {<,>} b */
7843 vn_nary_op_insert_pieces_predicated (2, LT_EXPR
, boolean_type_node
,
7844 ops
, boolean_false_node
, 0, pred_e
);
7845 vn_nary_op_insert_pieces_predicated (2, GT_EXPR
, boolean_type_node
,
7846 ops
, boolean_false_node
, 0, pred_e
);
7851 /* Nothing besides inverted condition. */
7857 /* Main stmt worker for RPO VN, process BB. */
7860 process_bb (rpo_elim
&avail
, basic_block bb
,
7861 bool bb_visited
, bool iterate_phis
, bool iterate
, bool eliminate
,
7862 bool do_region
, bitmap exit_bbs
, bool skip_phis
)
7870 /* If we are in loop-closed SSA preserve this state. This is
7871 relevant when called on regions from outside of FRE/PRE. */
7872 bool lc_phi_nodes
= false;
7874 && loops_state_satisfies_p (LOOP_CLOSED_SSA
))
7875 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7876 if (e
->src
->loop_father
!= e
->dest
->loop_father
7877 && flow_loop_nested_p (e
->dest
->loop_father
,
7878 e
->src
->loop_father
))
7880 lc_phi_nodes
= true;
7884 /* When we visit a loop header substitute into loop info. */
7885 if (!iterate
&& eliminate
&& bb
->loop_father
->header
== bb
)
7887 /* Keep fields in sync with substitute_in_loop_info. */
7888 if (bb
->loop_father
->nb_iterations
)
7889 bb
->loop_father
->nb_iterations
7890 = simplify_replace_tree (bb
->loop_father
->nb_iterations
,
7891 NULL_TREE
, NULL_TREE
, &vn_valueize_for_srt
);
7894 /* Value-number all defs in the basic-block. */
7896 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
7899 gphi
*phi
= gsi
.phi ();
7900 tree res
= PHI_RESULT (phi
);
7901 vn_ssa_aux_t res_info
= VN_INFO (res
);
7904 gcc_assert (!res_info
->visited
);
7905 res_info
->valnum
= VN_TOP
;
7906 res_info
->visited
= true;
7909 /* When not iterating force backedge values to varying. */
7910 visit_stmt (phi
, !iterate_phis
);
7911 if (virtual_operand_p (res
))
7915 /* The interesting case is gcc.dg/tree-ssa/pr22230.c for correctness
7916 how we handle backedges and availability.
7917 And gcc.dg/tree-ssa/ssa-sccvn-2.c for optimization. */
7918 tree val
= res_info
->valnum
;
7919 if (res
!= val
&& !iterate
&& eliminate
)
7921 if (tree leader
= avail
.eliminate_avail (bb
, res
))
7924 /* Preserve loop-closed SSA form. */
7926 || is_gimple_min_invariant (leader
)))
7928 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7930 fprintf (dump_file
, "Replaced redundant PHI node "
7932 print_generic_expr (dump_file
, res
);
7933 fprintf (dump_file
, " with ");
7934 print_generic_expr (dump_file
, leader
);
7935 fprintf (dump_file
, "\n");
7937 avail
.eliminations
++;
7939 if (may_propagate_copy (res
, leader
))
7941 /* Schedule for removal. */
7942 avail
.to_remove
.safe_push (phi
);
7945 /* ??? Else generate a copy stmt. */
7949 /* Only make defs available that not already are. But make
7950 sure loop-closed SSA PHI node defs are picked up for
7954 || ! avail
.eliminate_avail (bb
, res
))
7955 avail
.eliminate_push_avail (bb
, res
);
7958 /* For empty BBs mark outgoing edges executable. For non-empty BBs
7959 we do this when processing the last stmt as we have to do this
7960 before elimination which otherwise forces GIMPLE_CONDs to
7961 if (1 != 0) style when seeing non-executable edges. */
7962 if (gsi_end_p (gsi_start_bb (bb
)))
7964 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7966 if (!(e
->flags
& EDGE_EXECUTABLE
))
7968 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7970 "marking outgoing edge %d -> %d executable\n",
7971 e
->src
->index
, e
->dest
->index
);
7972 e
->flags
|= EDGE_EXECUTABLE
;
7973 e
->dest
->flags
|= BB_EXECUTABLE
;
7975 else if (!(e
->dest
->flags
& BB_EXECUTABLE
))
7977 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7979 "marking destination block %d reachable\n",
7981 e
->dest
->flags
|= BB_EXECUTABLE
;
7985 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
7986 !gsi_end_p (gsi
); gsi_next (&gsi
))
7992 FOR_EACH_SSA_TREE_OPERAND (op
, gsi_stmt (gsi
), i
, SSA_OP_ALL_DEFS
)
7994 vn_ssa_aux_t op_info
= VN_INFO (op
);
7995 gcc_assert (!op_info
->visited
);
7996 op_info
->valnum
= VN_TOP
;
7997 op_info
->visited
= true;
8000 /* We somehow have to deal with uses that are not defined
8001 in the processed region. Forcing unvisited uses to
8002 varying here doesn't play well with def-use following during
8003 expression simplification, so we deal with this by checking
8004 the visited flag in SSA_VAL. */
8007 visit_stmt (gsi_stmt (gsi
));
8009 gimple
*last
= gsi_stmt (gsi
);
8011 switch (gimple_code (last
))
8014 e
= find_taken_edge (bb
, vn_valueize (gimple_switch_index
8015 (as_a
<gswitch
*> (last
))));
8019 tree lhs
= vn_valueize (gimple_cond_lhs (last
));
8020 tree rhs
= vn_valueize (gimple_cond_rhs (last
));
8021 tree val
= gimple_simplify (gimple_cond_code (last
),
8022 boolean_type_node
, lhs
, rhs
,
8024 /* If the condition didn't simplfy see if we have recorded
8025 an expression from sofar taken edges. */
8026 if (! val
|| TREE_CODE (val
) != INTEGER_CST
)
8028 vn_nary_op_t vnresult
;
8032 val
= vn_nary_op_lookup_pieces (2, gimple_cond_code (last
),
8033 boolean_type_node
, ops
,
8035 /* Did we get a predicated value? */
8036 if (! val
&& vnresult
&& vnresult
->predicated_values
)
8038 val
= vn_nary_op_get_predicated_value (vnresult
, bb
);
8039 if (val
&& dump_file
&& (dump_flags
& TDF_DETAILS
))
8041 fprintf (dump_file
, "Got predicated value ");
8042 print_generic_expr (dump_file
, val
, TDF_NONE
);
8043 fprintf (dump_file
, " for ");
8044 print_gimple_stmt (dump_file
, last
, TDF_SLIM
);
8049 e
= find_taken_edge (bb
, val
);
8052 /* If we didn't manage to compute the taken edge then
8053 push predicated expressions for the condition itself
8054 and related conditions to the hashtables. This allows
8055 simplification of redundant conditions which is
8056 important as early cleanup. */
8057 edge true_e
, false_e
;
8058 extract_true_false_edges_from_block (bb
, &true_e
, &false_e
);
8059 enum tree_code code
= gimple_cond_code (last
);
8060 enum tree_code icode
8061 = invert_tree_comparison (code
, HONOR_NANS (lhs
));
8065 if ((do_region
&& bitmap_bit_p (exit_bbs
, true_e
->dest
->index
))
8066 || !can_track_predicate_on_edge (true_e
))
8068 if ((do_region
&& bitmap_bit_p (exit_bbs
, false_e
->dest
->index
))
8069 || !can_track_predicate_on_edge (false_e
))
8072 vn_nary_op_insert_pieces_predicated
8073 (2, code
, boolean_type_node
, ops
,
8074 boolean_true_node
, 0, true_e
);
8076 vn_nary_op_insert_pieces_predicated
8077 (2, code
, boolean_type_node
, ops
,
8078 boolean_false_node
, 0, false_e
);
8079 if (icode
!= ERROR_MARK
)
8082 vn_nary_op_insert_pieces_predicated
8083 (2, icode
, boolean_type_node
, ops
,
8084 boolean_false_node
, 0, true_e
);
8086 vn_nary_op_insert_pieces_predicated
8087 (2, icode
, boolean_type_node
, ops
,
8088 boolean_true_node
, 0, false_e
);
8090 /* Relax for non-integers, inverted condition handled
8092 if (INTEGRAL_TYPE_P (TREE_TYPE (lhs
)))
8095 insert_related_predicates_on_edge (code
, ops
, true_e
);
8097 insert_related_predicates_on_edge (icode
, ops
, false_e
);
8103 e
= find_taken_edge (bb
, vn_valueize (gimple_goto_dest (last
)));
8110 todo
= TODO_cleanup_cfg
;
8111 if (!(e
->flags
& EDGE_EXECUTABLE
))
8113 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8115 "marking known outgoing %sedge %d -> %d executable\n",
8116 e
->flags
& EDGE_DFS_BACK
? "back-" : "",
8117 e
->src
->index
, e
->dest
->index
);
8118 e
->flags
|= EDGE_EXECUTABLE
;
8119 e
->dest
->flags
|= BB_EXECUTABLE
;
8121 else if (!(e
->dest
->flags
& BB_EXECUTABLE
))
8123 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8125 "marking destination block %d reachable\n",
8127 e
->dest
->flags
|= BB_EXECUTABLE
;
8130 else if (gsi_one_before_end_p (gsi
))
8132 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8134 if (!(e
->flags
& EDGE_EXECUTABLE
))
8136 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8138 "marking outgoing edge %d -> %d executable\n",
8139 e
->src
->index
, e
->dest
->index
);
8140 e
->flags
|= EDGE_EXECUTABLE
;
8141 e
->dest
->flags
|= BB_EXECUTABLE
;
8143 else if (!(e
->dest
->flags
& BB_EXECUTABLE
))
8145 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8147 "marking destination block %d reachable\n",
8149 e
->dest
->flags
|= BB_EXECUTABLE
;
8154 /* Eliminate. That also pushes to avail. */
8155 if (eliminate
&& ! iterate
)
8156 avail
.eliminate_stmt (bb
, &gsi
);
8158 /* If not eliminating, make all not already available defs
8159 available. But avoid picking up dead defs. */
8160 FOR_EACH_SSA_TREE_OPERAND (op
, gsi_stmt (gsi
), i
, SSA_OP_DEF
)
8161 if (! has_zero_uses (op
)
8162 && ! avail
.eliminate_avail (bb
, op
))
8163 avail
.eliminate_push_avail (bb
, op
);
8166 /* Eliminate in destination PHI arguments. Always substitute in dest
8167 PHIs, even for non-executable edges. This handles region
8169 if (!iterate
&& eliminate
)
8170 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8171 for (gphi_iterator gsi
= gsi_start_phis (e
->dest
);
8172 !gsi_end_p (gsi
); gsi_next (&gsi
))
8174 gphi
*phi
= gsi
.phi ();
8175 use_operand_p use_p
= PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
);
8176 tree arg
= USE_FROM_PTR (use_p
);
8177 if (TREE_CODE (arg
) != SSA_NAME
8178 || virtual_operand_p (arg
))
8181 if (SSA_NAME_IS_DEFAULT_DEF (arg
))
8183 sprime
= SSA_VAL (arg
);
8184 gcc_assert (TREE_CODE (sprime
) != SSA_NAME
8185 || SSA_NAME_IS_DEFAULT_DEF (sprime
));
8188 /* Look for sth available at the definition block of the argument.
8189 This avoids inconsistencies between availability there which
8190 decides if the stmt can be removed and availability at the
8191 use site. The SSA property ensures that things available
8192 at the definition are also available at uses. */
8193 sprime
= avail
.eliminate_avail (gimple_bb (SSA_NAME_DEF_STMT (arg
)),
8197 && may_propagate_copy (arg
, sprime
, !(e
->flags
& EDGE_ABNORMAL
)))
8198 propagate_value (use_p
, sprime
);
8201 vn_context_bb
= NULL
;
8205 /* Unwind state per basic-block. */
8209 /* Times this block has been visited. */
8211 /* Whether to handle this as iteration point or whether to treat
8212 incoming backedge PHI values as varying. */
8214 /* Maximum RPO index this block is reachable from. */
8218 vn_reference_t ref_top
;
8220 vn_nary_op_t nary_top
;
8221 vn_avail
*avail_top
;
8224 /* Unwind the RPO VN state for iteration. */
8227 do_unwind (unwind_state
*to
, rpo_elim
&avail
)
8229 gcc_assert (to
->iterate
);
8230 for (; last_inserted_nary
!= to
->nary_top
;
8231 last_inserted_nary
= last_inserted_nary
->next
)
8234 slot
= valid_info
->nary
->find_slot_with_hash
8235 (last_inserted_nary
, last_inserted_nary
->hashcode
, NO_INSERT
);
8236 /* Predication causes the need to restore previous state. */
8237 if ((*slot
)->unwind_to
)
8238 *slot
= (*slot
)->unwind_to
;
8240 valid_info
->nary
->clear_slot (slot
);
8242 for (; last_inserted_phi
!= to
->phi_top
;
8243 last_inserted_phi
= last_inserted_phi
->next
)
8246 slot
= valid_info
->phis
->find_slot_with_hash
8247 (last_inserted_phi
, last_inserted_phi
->hashcode
, NO_INSERT
);
8248 valid_info
->phis
->clear_slot (slot
);
8250 for (; last_inserted_ref
!= to
->ref_top
;
8251 last_inserted_ref
= last_inserted_ref
->next
)
8253 vn_reference_t
*slot
;
8254 slot
= valid_info
->references
->find_slot_with_hash
8255 (last_inserted_ref
, last_inserted_ref
->hashcode
, NO_INSERT
);
8256 (*slot
)->operands
.release ();
8257 valid_info
->references
->clear_slot (slot
);
8259 obstack_free (&vn_tables_obstack
, to
->ob_top
);
8261 /* Prune [rpo_idx, ] from avail. */
8262 for (; last_pushed_avail
&& last_pushed_avail
->avail
!= to
->avail_top
;)
8264 vn_ssa_aux_t val
= last_pushed_avail
;
8265 vn_avail
*av
= val
->avail
;
8266 val
->avail
= av
->next
;
8267 last_pushed_avail
= av
->next_undo
;
8268 av
->next
= avail
.m_avail_freelist
;
8269 avail
.m_avail_freelist
= av
;
8273 /* Do VN on a SEME region specified by ENTRY and EXIT_BBS in FN.
8274 If ITERATE is true then treat backedges optimistically as not
8275 executed and iterate. If ELIMINATE is true then perform
8276 elimination, otherwise leave that to the caller. */
8279 do_rpo_vn_1 (function
*fn
, edge entry
, bitmap exit_bbs
,
8280 bool iterate
, bool eliminate
, vn_lookup_kind kind
)
8283 default_vn_walk_kind
= kind
;
8285 /* We currently do not support region-based iteration when
8286 elimination is requested. */
8287 gcc_assert (!entry
|| !iterate
|| !eliminate
);
8288 /* When iterating we need loop info up-to-date. */
8289 gcc_assert (!iterate
|| !loops_state_satisfies_p (LOOPS_NEED_FIXUP
));
8291 bool do_region
= entry
!= NULL
;
8294 entry
= single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (fn
));
8295 exit_bbs
= BITMAP_ALLOC (NULL
);
8296 bitmap_set_bit (exit_bbs
, EXIT_BLOCK
);
8299 /* Clear EDGE_DFS_BACK on "all" entry edges, RPO order compute will
8300 re-mark those that are contained in the region. */
8303 FOR_EACH_EDGE (e
, ei
, entry
->dest
->preds
)
8304 e
->flags
&= ~EDGE_DFS_BACK
;
8306 int *rpo
= XNEWVEC (int, n_basic_blocks_for_fn (fn
) - NUM_FIXED_BLOCKS
);
8307 auto_vec
<std::pair
<int, int> > toplevel_scc_extents
;
8308 int n
= rev_post_order_and_mark_dfs_back_seme
8309 (fn
, entry
, exit_bbs
, true, rpo
, !iterate
? &toplevel_scc_extents
: NULL
);
8312 BITMAP_FREE (exit_bbs
);
8314 /* If there are any non-DFS_BACK edges into entry->dest skip
8315 processing PHI nodes for that block. This supports
8316 value-numbering loop bodies w/o the actual loop. */
8317 FOR_EACH_EDGE (e
, ei
, entry
->dest
->preds
)
8319 && !(e
->flags
& EDGE_DFS_BACK
))
8321 bool skip_entry_phis
= e
!= NULL
;
8322 if (skip_entry_phis
&& dump_file
&& (dump_flags
& TDF_DETAILS
))
8323 fprintf (dump_file
, "Region does not contain all edges into "
8324 "the entry block, skipping its PHIs.\n");
8326 int *bb_to_rpo
= XNEWVEC (int, last_basic_block_for_fn (fn
));
8327 for (int i
= 0; i
< n
; ++i
)
8328 bb_to_rpo
[rpo
[i
]] = i
;
8330 unwind_state
*rpo_state
= XNEWVEC (unwind_state
, n
);
8332 rpo_elim
avail (entry
->dest
);
8335 /* Verify we have no extra entries into the region. */
8336 if (flag_checking
&& do_region
)
8338 auto_bb_flag
bb_in_region (fn
);
8339 for (int i
= 0; i
< n
; ++i
)
8341 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, rpo
[i
]);
8342 bb
->flags
|= bb_in_region
;
8344 /* We can't merge the first two loops because we cannot rely
8345 on EDGE_DFS_BACK for edges not within the region. But if
8346 we decide to always have the bb_in_region flag we can
8347 do the checking during the RPO walk itself (but then it's
8348 also easy to handle MEME conservatively). */
8349 for (int i
= 0; i
< n
; ++i
)
8351 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, rpo
[i
]);
8354 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
8355 gcc_assert (e
== entry
8356 || (skip_entry_phis
&& bb
== entry
->dest
)
8357 || (e
->src
->flags
& bb_in_region
));
8359 for (int i
= 0; i
< n
; ++i
)
8361 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, rpo
[i
]);
8362 bb
->flags
&= ~bb_in_region
;
8366 /* Create the VN state. For the initial size of the various hashtables
8367 use a heuristic based on region size and number of SSA names. */
8368 unsigned region_size
= (((unsigned HOST_WIDE_INT
)n
* num_ssa_names
)
8369 / (n_basic_blocks_for_fn (fn
) - NUM_FIXED_BLOCKS
));
8370 VN_TOP
= create_tmp_var_raw (void_type_node
, "vn_top");
8372 next_constant_value_id
= -1;
8374 vn_ssa_aux_hash
= new hash_table
<vn_ssa_aux_hasher
> (region_size
* 2);
8375 gcc_obstack_init (&vn_ssa_aux_obstack
);
8377 gcc_obstack_init (&vn_tables_obstack
);
8378 gcc_obstack_init (&vn_tables_insert_obstack
);
8379 valid_info
= XCNEW (struct vn_tables_s
);
8380 allocate_vn_table (valid_info
, region_size
);
8381 last_inserted_ref
= NULL
;
8382 last_inserted_phi
= NULL
;
8383 last_inserted_nary
= NULL
;
8384 last_pushed_avail
= NULL
;
8386 vn_valueize
= rpo_vn_valueize
;
8388 /* Initialize the unwind state and edge/BB executable state. */
8389 unsigned curr_scc
= 0;
8390 for (int i
= 0; i
< n
; ++i
)
8392 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, rpo
[i
]);
8393 rpo_state
[i
].visited
= 0;
8394 rpo_state
[i
].max_rpo
= i
;
8395 if (!iterate
&& curr_scc
< toplevel_scc_extents
.length ())
8397 if (i
>= toplevel_scc_extents
[curr_scc
].first
8398 && i
<= toplevel_scc_extents
[curr_scc
].second
)
8399 rpo_state
[i
].max_rpo
= toplevel_scc_extents
[curr_scc
].second
;
8400 if (i
== toplevel_scc_extents
[curr_scc
].second
)
8403 bb
->flags
&= ~BB_EXECUTABLE
;
8404 bool has_backedges
= false;
8407 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
8409 if (e
->flags
& EDGE_DFS_BACK
)
8410 has_backedges
= true;
8411 e
->flags
&= ~EDGE_EXECUTABLE
;
8412 if (iterate
|| e
== entry
|| (skip_entry_phis
&& bb
== entry
->dest
))
8415 rpo_state
[i
].iterate
= iterate
&& has_backedges
;
8417 entry
->flags
|= EDGE_EXECUTABLE
;
8418 entry
->dest
->flags
|= BB_EXECUTABLE
;
8420 /* As heuristic to improve compile-time we handle only the N innermost
8421 loops and the outermost one optimistically. */
8424 unsigned max_depth
= param_rpo_vn_max_loop_depth
;
8425 for (auto loop
: loops_list (cfun
, LI_ONLY_INNERMOST
))
8426 if (loop_depth (loop
) > max_depth
)
8427 for (unsigned i
= 2;
8428 i
< loop_depth (loop
) - max_depth
; ++i
)
8430 basic_block header
= superloop_at_depth (loop
, i
)->header
;
8431 bool non_latch_backedge
= false;
8434 FOR_EACH_EDGE (e
, ei
, header
->preds
)
8435 if (e
->flags
& EDGE_DFS_BACK
)
8437 /* There can be a non-latch backedge into the header
8438 which is part of an outer irreducible region. We
8439 cannot avoid iterating this block then. */
8440 if (!dominated_by_p (CDI_DOMINATORS
,
8443 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8444 fprintf (dump_file
, "non-latch backedge %d -> %d "
8445 "forces iteration of loop %d\n",
8446 e
->src
->index
, e
->dest
->index
, loop
->num
);
8447 non_latch_backedge
= true;
8450 e
->flags
|= EDGE_EXECUTABLE
;
8452 rpo_state
[bb_to_rpo
[header
->index
]].iterate
= non_latch_backedge
;
8459 /* Go and process all blocks, iterating as necessary. */
8462 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, rpo
[idx
]);
8464 /* If the block has incoming backedges remember unwind state. This
8465 is required even for non-executable blocks since in irreducible
8466 regions we might reach them via the backedge and re-start iterating
8468 Note we can individually mark blocks with incoming backedges to
8469 not iterate where we then handle PHIs conservatively. We do that
8470 heuristically to reduce compile-time for degenerate cases. */
8471 if (rpo_state
[idx
].iterate
)
8473 rpo_state
[idx
].ob_top
= obstack_alloc (&vn_tables_obstack
, 0);
8474 rpo_state
[idx
].ref_top
= last_inserted_ref
;
8475 rpo_state
[idx
].phi_top
= last_inserted_phi
;
8476 rpo_state
[idx
].nary_top
= last_inserted_nary
;
8477 rpo_state
[idx
].avail_top
8478 = last_pushed_avail
? last_pushed_avail
->avail
: NULL
;
8481 if (!(bb
->flags
& BB_EXECUTABLE
))
8483 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8484 fprintf (dump_file
, "Block %d: BB%d found not executable\n",
8490 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8491 fprintf (dump_file
, "Processing block %d: BB%d\n", idx
, bb
->index
);
8493 todo
|= process_bb (avail
, bb
,
8494 rpo_state
[idx
].visited
!= 0,
8495 rpo_state
[idx
].iterate
,
8496 iterate
, eliminate
, do_region
, exit_bbs
, false);
8497 rpo_state
[idx
].visited
++;
8499 /* Verify if changed values flow over executable outgoing backedges
8500 and those change destination PHI values (that's the thing we
8501 can easily verify). Reduce over all such edges to the farthest
8503 int iterate_to
= -1;
8506 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8507 if ((e
->flags
& (EDGE_DFS_BACK
|EDGE_EXECUTABLE
))
8508 == (EDGE_DFS_BACK
|EDGE_EXECUTABLE
)
8509 && rpo_state
[bb_to_rpo
[e
->dest
->index
]].iterate
)
8511 int destidx
= bb_to_rpo
[e
->dest
->index
];
8512 if (!rpo_state
[destidx
].visited
)
8514 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8515 fprintf (dump_file
, "Unvisited destination %d\n",
8517 if (iterate_to
== -1 || destidx
< iterate_to
)
8518 iterate_to
= destidx
;
8521 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8522 fprintf (dump_file
, "Looking for changed values of backedge"
8523 " %d->%d destination PHIs\n",
8524 e
->src
->index
, e
->dest
->index
);
8525 vn_context_bb
= e
->dest
;
8527 for (gsi
= gsi_start_phis (e
->dest
);
8528 !gsi_end_p (gsi
); gsi_next (&gsi
))
8530 bool inserted
= false;
8531 /* While we'd ideally just iterate on value changes
8532 we CSE PHIs and do that even across basic-block
8533 boundaries. So even hashtable state changes can
8534 be important (which is roughly equivalent to
8535 PHI argument value changes). To not excessively
8536 iterate because of that we track whether a PHI
8537 was CSEd to with GF_PLF_1. */
8538 bool phival_changed
;
8539 if ((phival_changed
= visit_phi (gsi
.phi (),
8541 || (inserted
&& gimple_plf (gsi
.phi (), GF_PLF_1
)))
8544 && dump_file
&& (dump_flags
& TDF_DETAILS
))
8545 fprintf (dump_file
, "PHI was CSEd and hashtable "
8546 "state (changed)\n");
8547 if (iterate_to
== -1 || destidx
< iterate_to
)
8548 iterate_to
= destidx
;
8552 vn_context_bb
= NULL
;
8554 if (iterate_to
!= -1)
8556 do_unwind (&rpo_state
[iterate_to
], avail
);
8558 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8559 fprintf (dump_file
, "Iterating to %d BB%d\n",
8560 iterate_to
, rpo
[iterate_to
]);
8570 /* Process all blocks greedily with a worklist that enforces RPO
8571 processing of reachable blocks. */
8572 auto_bitmap worklist
;
8573 bitmap_set_bit (worklist
, 0);
8574 while (!bitmap_empty_p (worklist
))
8576 int idx
= bitmap_clear_first_set_bit (worklist
);
8577 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, rpo
[idx
]);
8578 gcc_assert ((bb
->flags
& BB_EXECUTABLE
)
8579 && !rpo_state
[idx
].visited
);
8581 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8582 fprintf (dump_file
, "Processing block %d: BB%d\n", idx
, bb
->index
);
8584 /* When we run into predecessor edges where we cannot trust its
8585 executable state mark them executable so PHI processing will
8587 ??? Do we need to force arguments flowing over that edge
8588 to be varying or will they even always be? */
8591 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
8592 if (!(e
->flags
& EDGE_EXECUTABLE
)
8593 && (bb
== entry
->dest
8594 || (!rpo_state
[bb_to_rpo
[e
->src
->index
]].visited
8595 && (rpo_state
[bb_to_rpo
[e
->src
->index
]].max_rpo
8598 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8599 fprintf (dump_file
, "Cannot trust state of predecessor "
8600 "edge %d -> %d, marking executable\n",
8601 e
->src
->index
, e
->dest
->index
);
8602 e
->flags
|= EDGE_EXECUTABLE
;
8606 todo
|= process_bb (avail
, bb
, false, false, false, eliminate
,
8607 do_region
, exit_bbs
,
8608 skip_entry_phis
&& bb
== entry
->dest
);
8609 rpo_state
[idx
].visited
++;
8611 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8612 if ((e
->flags
& EDGE_EXECUTABLE
)
8613 && e
->dest
->index
!= EXIT_BLOCK
8614 && (!do_region
|| !bitmap_bit_p (exit_bbs
, e
->dest
->index
))
8615 && !rpo_state
[bb_to_rpo
[e
->dest
->index
]].visited
)
8616 bitmap_set_bit (worklist
, bb_to_rpo
[e
->dest
->index
]);
8620 /* If statistics or dump file active. */
8622 unsigned max_visited
= 1;
8623 for (int i
= 0; i
< n
; ++i
)
8625 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, rpo
[i
]);
8626 if (bb
->flags
& BB_EXECUTABLE
)
8628 statistics_histogram_event (cfun
, "RPO block visited times",
8629 rpo_state
[i
].visited
);
8630 if (rpo_state
[i
].visited
> max_visited
)
8631 max_visited
= rpo_state
[i
].visited
;
8633 unsigned nvalues
= 0, navail
= 0;
8634 for (hash_table
<vn_ssa_aux_hasher
>::iterator i
= vn_ssa_aux_hash
->begin ();
8635 i
!= vn_ssa_aux_hash
->end (); ++i
)
8638 vn_avail
*av
= (*i
)->avail
;
8645 statistics_counter_event (cfun
, "RPO blocks", n
);
8646 statistics_counter_event (cfun
, "RPO blocks visited", nblk
);
8647 statistics_counter_event (cfun
, "RPO blocks executable", nex
);
8648 statistics_histogram_event (cfun
, "RPO iterations", 10*nblk
/ nex
);
8649 statistics_histogram_event (cfun
, "RPO num values", nvalues
);
8650 statistics_histogram_event (cfun
, "RPO num avail", navail
);
8651 statistics_histogram_event (cfun
, "RPO num lattice",
8652 vn_ssa_aux_hash
->elements ());
8653 if (dump_file
&& (dump_flags
& (TDF_DETAILS
|TDF_STATS
)))
8655 fprintf (dump_file
, "RPO iteration over %d blocks visited %" PRIu64
8656 " blocks in total discovering %d executable blocks iterating "
8657 "%d.%d times, a block was visited max. %u times\n",
8659 (int)((10*nblk
/ nex
)/10), (int)((10*nblk
/ nex
)%10),
8661 fprintf (dump_file
, "RPO tracked %d values available at %d locations "
8662 "and %" PRIu64
" lattice elements\n",
8663 nvalues
, navail
, (uint64_t) vn_ssa_aux_hash
->elements ());
8668 /* When !iterate we already performed elimination during the RPO
8672 /* Elimination for region-based VN needs to be done within the
8674 gcc_assert (! do_region
);
8675 /* Note we can't use avail.walk here because that gets confused
8676 by the existing availability and it will be less efficient
8678 todo
|= eliminate_with_rpo_vn (NULL
);
8681 todo
|= avail
.eliminate_cleanup (do_region
);
8687 XDELETEVEC (bb_to_rpo
);
8689 XDELETEVEC (rpo_state
);
8694 /* Region-based entry for RPO VN. Performs value-numbering and elimination
8695 on the SEME region specified by ENTRY and EXIT_BBS. If ENTRY is not
8696 the only edge into the region at ENTRY->dest PHI nodes in ENTRY->dest
8698 If ITERATE is true then treat backedges optimistically as not
8699 executed and iterate. If ELIMINATE is true then perform
8700 elimination, otherwise leave that to the caller.
8701 KIND specifies the amount of work done for handling memory operations. */
8704 do_rpo_vn (function
*fn
, edge entry
, bitmap exit_bbs
,
8705 bool iterate
, bool eliminate
, vn_lookup_kind kind
)
8707 auto_timevar
tv (TV_TREE_RPO_VN
);
8708 unsigned todo
= do_rpo_vn_1 (fn
, entry
, exit_bbs
, iterate
, eliminate
, kind
);
8716 const pass_data pass_data_fre
=
8718 GIMPLE_PASS
, /* type */
8720 OPTGROUP_NONE
, /* optinfo_flags */
8721 TV_TREE_FRE
, /* tv_id */
8722 ( PROP_cfg
| PROP_ssa
), /* properties_required */
8723 0, /* properties_provided */
8724 0, /* properties_destroyed */
8725 0, /* todo_flags_start */
8726 0, /* todo_flags_finish */
8729 class pass_fre
: public gimple_opt_pass
8732 pass_fre (gcc::context
*ctxt
)
8733 : gimple_opt_pass (pass_data_fre
, ctxt
), may_iterate (true)
8736 /* opt_pass methods: */
8737 opt_pass
* clone () final override
{ return new pass_fre (m_ctxt
); }
8738 void set_pass_param (unsigned int n
, bool param
) final override
8740 gcc_assert (n
== 0);
8741 may_iterate
= param
;
8743 bool gate (function
*) final override
8745 return flag_tree_fre
!= 0 && (may_iterate
|| optimize
> 1);
8747 unsigned int execute (function
*) final override
;
8751 }; // class pass_fre
8754 pass_fre::execute (function
*fun
)
8758 /* At -O[1g] use the cheap non-iterating mode. */
8759 bool iterate_p
= may_iterate
&& (optimize
> 1);
8760 calculate_dominance_info (CDI_DOMINATORS
);
8762 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
8764 todo
= do_rpo_vn_1 (fun
, NULL
, NULL
, iterate_p
, true, VN_WALKREWRITE
);
8768 loop_optimizer_finalize ();
8770 if (scev_initialized_p ())
8773 /* For late FRE after IVOPTs and unrolling, see if we can
8774 remove some TREE_ADDRESSABLE and rewrite stuff into SSA. */
8776 todo
|= TODO_update_address_taken
;
8784 make_pass_fre (gcc::context
*ctxt
)
8786 return new pass_fre (ctxt
);
8789 #undef BB_EXECUTABLE