1 /* Miscellaneous SSA utility functions.
2 Copyright (C) 2001-2022 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
27 #include "tree-pass.h"
29 #include "gimple-pretty-print.h"
30 #include "diagnostic-core.h"
31 #include "fold-const.h"
32 #include "stor-layout.h"
33 #include "gimple-fold.h"
35 #include "gimple-iterator.h"
36 #include "gimple-walk.h"
37 #include "tree-ssa-loop-manip.h"
38 #include "tree-into-ssa.h"
41 #include "cfgexpand.h"
44 #include "stringpool.h"
48 /* Pointer map of variable mappings, keyed by edge. */
49 static hash_map
<edge
, auto_vec
<edge_var_map
> > *edge_var_maps
;
52 /* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
55 redirect_edge_var_map_add (edge e
, tree result
, tree def
, location_t locus
)
57 edge_var_map new_node
;
59 if (edge_var_maps
== NULL
)
60 edge_var_maps
= new hash_map
<edge
, auto_vec
<edge_var_map
> >;
62 auto_vec
<edge_var_map
> &slot
= edge_var_maps
->get_or_insert (e
);
64 new_node
.result
= result
;
65 new_node
.locus
= locus
;
67 slot
.safe_push (new_node
);
71 /* Clear the var mappings in edge E. */
74 redirect_edge_var_map_clear (edge e
)
79 auto_vec
<edge_var_map
> *head
= edge_var_maps
->get (e
);
86 /* Duplicate the redirected var mappings in OLDE in NEWE.
88 This assumes a hash_map can have multiple edges mapping to the same
89 var_map (many to one mapping), since we don't remove the previous mappings.
93 redirect_edge_var_map_dup (edge newe
, edge olde
)
98 auto_vec
<edge_var_map
> *new_head
= &edge_var_maps
->get_or_insert (newe
);
99 auto_vec
<edge_var_map
> *old_head
= edge_var_maps
->get (olde
);
103 new_head
->safe_splice (*old_head
);
107 /* Return the variable mappings for a given edge. If there is none, return
111 redirect_edge_var_map_vector (edge e
)
113 /* Hey, what kind of idiot would... you'd be surprised. */
117 auto_vec
<edge_var_map
> *slot
= edge_var_maps
->get (e
);
124 /* Clear the edge variable mappings. */
127 redirect_edge_var_map_empty (void)
130 edge_var_maps
->empty ();
134 /* Remove the corresponding arguments from the PHI nodes in E's
135 destination block and redirect it to DEST. Return redirected edge.
136 The list of removed arguments is stored in a vector accessed
137 through edge_var_maps. */
140 ssa_redirect_edge (edge e
, basic_block dest
)
145 redirect_edge_var_map_clear (e
);
147 /* Remove the appropriate PHI arguments in E's destination block.
148 If we are redirecting a copied edge the destination has not
149 got PHI argument space reserved nor an interesting argument. */
150 if (! (e
->dest
->flags
& BB_DUPLICATED
))
151 for (gsi
= gsi_start_phis (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
157 def
= gimple_phi_arg_def (phi
, e
->dest_idx
);
158 locus
= gimple_phi_arg_location (phi
, e
->dest_idx
);
160 if (def
== NULL_TREE
)
163 redirect_edge_var_map_add (e
, gimple_phi_result (phi
), def
, locus
);
166 e
= redirect_edge_succ_nodup (e
, dest
);
172 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
176 flush_pending_stmts (edge e
)
183 vec
<edge_var_map
> *v
= redirect_edge_var_map_vector (e
);
187 for (gsi
= gsi_start_phis (e
->dest
), i
= 0;
188 !gsi_end_p (gsi
) && v
->iterate (i
, &vm
);
189 gsi_next (&gsi
), i
++)
194 def
= redirect_edge_var_map_def (vm
);
195 add_phi_arg (phi
, def
, e
, redirect_edge_var_map_location (vm
));
198 redirect_edge_var_map_clear (e
);
201 /* Replace the LHS of STMT, an assignment, either a GIMPLE_ASSIGN or a
202 GIMPLE_CALL, with NLHS, in preparation for modifying the RHS to an
203 expression with a different value.
205 This will update any annotations (say debug bind stmts) referring
206 to the original LHS, so that they use the RHS instead. This is
207 done even if NLHS and LHS are the same, for it is understood that
208 the RHS will be modified afterwards, and NLHS will not be assigned
211 Adjusting any non-annotation uses of the LHS, if needed, is a
212 responsibility of the caller.
214 The effect of this call should be pretty much the same as that of
215 inserting a copy of STMT before STMT, and then removing the
216 original stmt, at which time gsi_remove() would have update
217 annotations, but using this function saves all the inserting,
218 copying and removing. */
221 gimple_replace_ssa_lhs (gimple
*stmt
, tree nlhs
)
223 if (MAY_HAVE_DEBUG_BIND_STMTS
)
225 tree lhs
= gimple_get_lhs (stmt
);
227 gcc_assert (SSA_NAME_DEF_STMT (lhs
) == stmt
);
229 insert_debug_temp_for_var_def (NULL
, lhs
);
232 gimple_set_lhs (stmt
, nlhs
);
236 /* Given a tree for an expression for which we might want to emit
237 locations or values in debug information (generally a variable, but
238 we might deal with other kinds of trees in the future), return the
239 tree that should be used as the variable of a DEBUG_BIND STMT or
240 VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */
243 target_for_debug_bind (tree var
)
245 if (!MAY_HAVE_DEBUG_BIND_STMTS
)
248 if (TREE_CODE (var
) == SSA_NAME
)
250 var
= SSA_NAME_VAR (var
);
251 if (var
== NULL_TREE
)
255 if ((!VAR_P (var
) || VAR_DECL_IS_VIRTUAL_OPERAND (var
))
256 && TREE_CODE (var
) != PARM_DECL
)
259 if (DECL_HAS_VALUE_EXPR_P (var
))
260 return target_for_debug_bind (DECL_VALUE_EXPR (var
));
262 if (DECL_IGNORED_P (var
))
265 /* var-tracking only tracks registers. */
266 if (!is_gimple_reg_type (TREE_TYPE (var
)))
272 /* Called via walk_tree, look for SSA_NAMEs that have already been
276 find_released_ssa_name (tree
*tp
, int *walk_subtrees
, void *data_
)
278 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data_
;
280 if (wi
&& wi
->is_lhs
)
283 if (TREE_CODE (*tp
) == SSA_NAME
)
285 if (SSA_NAME_IN_FREE_LIST (*tp
))
290 else if (IS_TYPE_OR_DECL_P (*tp
))
296 /* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced
297 by other DEBUG stmts, and replace uses of the DEF with the
298 newly-created debug temp. */
301 insert_debug_temp_for_var_def (gimple_stmt_iterator
*gsi
, tree var
)
303 imm_use_iterator imm_iter
;
306 gimple
*def_stmt
= NULL
;
310 if (!MAY_HAVE_DEBUG_BIND_STMTS
)
313 /* If this name has already been registered for replacement, do nothing
314 as anything that uses this name isn't in SSA form. */
315 if (name_registered_for_update_p (var
))
318 /* Check whether there are debug stmts that reference this variable and,
319 if there are, decide whether we should use a debug temp. */
320 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, var
)
322 stmt
= USE_STMT (use_p
);
324 if (!gimple_debug_bind_p (stmt
))
330 if (gimple_debug_bind_get_value (stmt
) != var
)
332 /* Count this as an additional use, so as to make sure we
333 use a temp unless VAR's definition has a SINGLE_RHS that
344 def_stmt
= gsi_stmt (*gsi
);
346 def_stmt
= SSA_NAME_DEF_STMT (var
);
348 /* If we didn't get an insertion point, and the stmt has already
349 been removed, we won't be able to insert the debug bind stmt, so
350 we'll have to drop debug information. */
351 if (gimple_code (def_stmt
) == GIMPLE_PHI
)
353 value
= degenerate_phi_result (as_a
<gphi
*> (def_stmt
));
354 if (value
&& walk_tree (&value
, find_released_ssa_name
, NULL
, NULL
))
356 /* error_mark_node is what fixup_noreturn_call changes PHI arguments
358 else if (value
== error_mark_node
)
361 else if (gimple_clobber_p (def_stmt
))
362 /* We can end up here when rewriting a decl into SSA and coming
363 along a clobber for the original decl. Turn that into
364 # DEBUG decl => NULL */
366 else if (is_gimple_assign (def_stmt
))
368 bool no_value
= false;
370 if (!dom_info_available_p (CDI_DOMINATORS
))
372 struct walk_stmt_info wi
;
374 memset (&wi
, 0, sizeof (wi
));
376 /* When removing blocks without following reverse dominance
377 order, we may sometimes encounter SSA_NAMEs that have
378 already been released, referenced in other SSA_DEFs that
379 we're about to release. Consider:
388 If we deleted BB X first, propagating the value of w_2
389 won't do us any good. It's too late to recover their
390 original definition of v_1: when it was deleted, it was
391 only referenced in other DEFs, it couldn't possibly know
392 it should have been retained, and propagating every
393 single DEF just in case it might have to be propagated
394 into a DEBUG STMT would probably be too wasteful.
396 When dominator information is not readily available, we
397 check for and accept some loss of debug information. But
398 if it is available, there's no excuse for us to remove
399 blocks in the wrong order, so we don't even check for
400 dead SSA NAMEs. SSA verification shall catch any
402 if ((!gsi
&& !gimple_bb (def_stmt
))
403 || walk_gimple_op (def_stmt
, find_released_ssa_name
, &wi
))
408 value
= gimple_assign_rhs_to_tree (def_stmt
);
413 /* If there's a single use of VAR, and VAR is the entire debug
414 expression (usecount would have been incremented again
415 otherwise), and the definition involves only constants and
416 SSA names, then we can propagate VALUE into this single use,
419 We can also avoid using a temp if VALUE can be shared and
420 propagated into all uses, without generating expressions that
421 wouldn't be valid gimple RHSs.
423 Other cases that would require unsharing or non-gimple RHSs
424 are deferred to a debug temp, although we could avoid temps
425 at the expense of duplication of expressions. */
427 if (CONSTANT_CLASS_P (value
)
428 || gimple_code (def_stmt
) == GIMPLE_PHI
430 && (!gimple_assign_single_p (def_stmt
)
431 || is_gimple_min_invariant (value
)))
432 || is_gimple_reg (value
))
437 tree vexpr
= build_debug_expr_decl (TREE_TYPE (value
));
439 def_temp
= gimple_build_debug_bind (vexpr
,
440 unshare_expr (value
),
443 /* FIXME: Is setting the mode really necessary? */
445 SET_DECL_MODE (vexpr
, DECL_MODE (value
));
447 SET_DECL_MODE (vexpr
, TYPE_MODE (TREE_TYPE (value
)));
450 gsi_insert_before (gsi
, def_temp
, GSI_SAME_STMT
);
453 gimple_stmt_iterator ngsi
= gsi_for_stmt (def_stmt
);
454 gsi_insert_before (&ngsi
, def_temp
, GSI_SAME_STMT
);
461 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, var
)
463 if (!gimple_debug_bind_p (stmt
))
468 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
469 /* unshare_expr is not needed here. vexpr is either a
470 SINGLE_RHS, that can be safely shared, some other RHS
471 that was unshared when we found it had a single debug
472 use, or a DEBUG_EXPR_DECL, that can be safely
474 SET_USE (use_p
, unshare_expr (value
));
475 /* If we didn't replace uses with a debug decl fold the
476 resulting expression. Otherwise we end up with invalid IL. */
477 if (TREE_CODE (value
) != DEBUG_EXPR_DECL
)
479 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
480 fold_stmt_inplace (&gsi
);
484 gimple_debug_bind_reset_value (stmt
);
491 /* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
492 other DEBUG stmts, and replace uses of the DEF with the
493 newly-created debug temp. */
496 insert_debug_temps_for_defs (gimple_stmt_iterator
*gsi
)
502 if (!MAY_HAVE_DEBUG_BIND_STMTS
)
505 stmt
= gsi_stmt (*gsi
);
507 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
509 tree var
= DEF_FROM_PTR (def_p
);
511 if (TREE_CODE (var
) != SSA_NAME
)
514 insert_debug_temp_for_var_def (gsi
, var
);
518 /* Reset all debug stmts that use SSA_NAME(s) defined in STMT. */
521 reset_debug_uses (gimple
*stmt
)
525 imm_use_iterator imm_iter
;
528 if (!MAY_HAVE_DEBUG_BIND_STMTS
)
531 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
533 tree var
= DEF_FROM_PTR (def_p
);
535 if (TREE_CODE (var
) != SSA_NAME
)
538 FOR_EACH_IMM_USE_STMT (use_stmt
, imm_iter
, var
)
540 if (!gimple_debug_bind_p (use_stmt
))
543 gimple_debug_bind_reset_value (use_stmt
);
544 update_stmt (use_stmt
);
549 /* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
550 dominated stmts before their dominators, so that release_ssa_defs
551 stands a chance of propagating DEFs into debug bind stmts. */
554 release_defs_bitset (bitmap toremove
)
559 /* Performing a topological sort is probably overkill, this will
560 most likely run in slightly superlinear time, rather than the
561 pathological quadratic worst case.
562 But iterate from max SSA name version to min one because
563 that mimics allocation order during code generation behavior best.
564 Use an array for this which we compact on-the-fly with a NULL
565 marker moving towards the end of the vector. */
566 auto_vec
<tree
, 16> names
;
567 names
.reserve (bitmap_count_bits (toremove
) + 1);
568 names
.quick_push (NULL_TREE
);
569 EXECUTE_IF_SET_IN_BITMAP (toremove
, 0, j
, bi
)
570 names
.quick_push (ssa_name (j
));
572 bitmap_tree_view (toremove
);
573 while (!bitmap_empty_p (toremove
))
575 j
= names
.length () - 1;
576 for (unsigned i
= names
.length () - 1; names
[i
];)
578 bool remove_now
= true;
581 imm_use_iterator uit
;
583 FOR_EACH_IMM_USE_STMT (stmt
, uit
, var
)
588 /* We can't propagate PHI nodes into debug stmts. */
589 if (gimple_code (stmt
) == GIMPLE_PHI
590 || is_gimple_debug (stmt
))
593 /* If we find another definition to remove that uses
594 the one we're looking at, defer the removal of this
595 one, so that it can be propagated into debug stmts
596 after the other is. */
597 FOR_EACH_SSA_DEF_OPERAND (def_p
, stmt
, dit
, SSA_OP_DEF
)
599 tree odef
= DEF_FROM_PTR (def_p
);
601 if (bitmap_bit_p (toremove
, SSA_NAME_VERSION (odef
)))
614 gimple
*def
= SSA_NAME_DEF_STMT (var
);
615 gimple_stmt_iterator gsi
= gsi_for_stmt (def
);
617 if (gimple_code (def
) == GIMPLE_PHI
)
618 remove_phi_node (&gsi
, true);
621 gsi_remove (&gsi
, true);
624 bitmap_clear_bit (toremove
, SSA_NAME_VERSION (var
));
632 bitmap_list_view (toremove
);
635 /* Disable warnings about missing quoting in GCC diagnostics for
636 the verification errors. Their format strings don't follow GCC
637 diagnostic conventions and the calls are ultimately followed by
638 one to internal_error. */
640 # pragma GCC diagnostic push
641 # pragma GCC diagnostic ignored "-Wformat-diag"
644 /* Verify virtual SSA form. */
647 verify_vssa (basic_block bb
, tree current_vdef
, sbitmap visited
)
651 if (!bitmap_set_bit (visited
, bb
->index
))
654 /* Pick up the single virtual PHI def. */
656 for (gphi_iterator si
= gsi_start_phis (bb
); !gsi_end_p (si
);
659 tree res
= gimple_phi_result (si
.phi ());
660 if (virtual_operand_p (res
))
664 error ("multiple virtual PHI nodes in BB %d", bb
->index
);
665 print_gimple_stmt (stderr
, phi
, 0);
666 print_gimple_stmt (stderr
, si
.phi (), 0);
675 current_vdef
= gimple_phi_result (phi
);
676 if (TREE_CODE (current_vdef
) != SSA_NAME
)
678 error ("virtual definition is not an SSA name");
679 print_gimple_stmt (stderr
, phi
, 0);
685 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
688 gimple
*stmt
= gsi_stmt (gsi
);
689 tree vuse
= gimple_vuse (stmt
);
692 if (vuse
!= current_vdef
)
694 error ("stmt with wrong VUSE");
695 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
696 fprintf (stderr
, "expected ");
697 print_generic_expr (stderr
, current_vdef
);
698 fprintf (stderr
, "\n");
701 tree vdef
= gimple_vdef (stmt
);
705 if (TREE_CODE (current_vdef
) != SSA_NAME
)
707 error ("virtual definition is not an SSA name");
708 print_gimple_stmt (stderr
, phi
, 0);
715 /* Verify destination PHI uses and recurse. */
718 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
720 gphi
*phi
= get_virtual_phi (e
->dest
);
722 && PHI_ARG_DEF_FROM_EDGE (phi
, e
) != current_vdef
)
724 error ("PHI node with wrong VUSE on edge from BB %d",
726 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
);
727 fprintf (stderr
, "expected ");
728 print_generic_expr (stderr
, current_vdef
);
729 fprintf (stderr
, "\n");
734 err
|= verify_vssa (e
->dest
, current_vdef
, visited
);
740 /* Return true if SSA_NAME is malformed and mark it visited.
742 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
746 verify_ssa_name (tree ssa_name
, bool is_virtual
)
748 if (TREE_CODE (ssa_name
) != SSA_NAME
)
750 error ("expected an SSA_NAME object");
754 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
756 error ("found an SSA_NAME that had been released into the free pool");
760 if (SSA_NAME_VAR (ssa_name
) != NULL_TREE
761 && TREE_TYPE (ssa_name
) != TREE_TYPE (SSA_NAME_VAR (ssa_name
)))
763 error ("type mismatch between an SSA_NAME and its symbol");
767 if (is_virtual
&& !virtual_operand_p (ssa_name
))
769 error ("found a virtual definition for a GIMPLE register");
773 if (is_virtual
&& SSA_NAME_VAR (ssa_name
) != gimple_vop (cfun
))
775 error ("virtual SSA name for non-VOP decl");
779 if (!is_virtual
&& virtual_operand_p (ssa_name
))
781 error ("found a real definition for a non-register");
785 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
786 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
)))
788 error ("found a default name with a non-empty defining statement");
796 /* Return true if the definition of SSA_NAME at block BB is malformed.
798 STMT is the statement where SSA_NAME is created.
800 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
801 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
802 it means that the block in that array slot contains the
803 definition of SSA_NAME.
805 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
808 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
809 gimple
*stmt
, bool is_virtual
)
811 if (verify_ssa_name (ssa_name
, is_virtual
))
814 if (SSA_NAME_VAR (ssa_name
)
815 && TREE_CODE (SSA_NAME_VAR (ssa_name
)) == RESULT_DECL
816 && DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name
)))
818 error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
822 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
824 error ("SSA_NAME created in two different blocks %i and %i",
825 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
829 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
831 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
833 error ("SSA_NAME_DEF_STMT is wrong");
834 fprintf (stderr
, "Expected definition statement:\n");
835 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (ssa_name
), 4, TDF_VOPS
);
836 fprintf (stderr
, "\nActual definition statement:\n");
837 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
844 fprintf (stderr
, "while verifying SSA_NAME ");
845 print_generic_expr (stderr
, ssa_name
);
846 fprintf (stderr
, " in statement\n");
847 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
853 /* Return true if the use of SSA_NAME at statement STMT in block BB is
856 DEF_BB is the block where SSA_NAME was found to be created.
858 IDOM contains immediate dominator information for the flowgraph.
860 CHECK_ABNORMAL is true if the caller wants to check whether this use
861 is flowing through an abnormal edge (only used when checking PHI
864 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
865 that are defined before STMT in basic block BB. */
868 verify_use (basic_block bb
, basic_block def_bb
, use_operand_p use_p
,
869 gimple
*stmt
, bool check_abnormal
, bitmap names_defined_in_bb
)
872 tree ssa_name
= USE_FROM_PTR (use_p
);
874 if (!TREE_VISITED (ssa_name
))
875 if (verify_imm_links (stderr
, ssa_name
))
878 TREE_VISITED (ssa_name
) = 1;
880 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
))
881 && SSA_NAME_IS_DEFAULT_DEF (ssa_name
))
882 ; /* Default definitions have empty statements. Nothing to do. */
885 error ("missing definition");
888 else if (bb
!= def_bb
889 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
891 error ("definition in block %i does not dominate use in block %i",
892 def_bb
->index
, bb
->index
);
895 else if (bb
== def_bb
896 && names_defined_in_bb
!= NULL
897 && !bitmap_bit_p (names_defined_in_bb
, SSA_NAME_VERSION (ssa_name
)))
899 error ("definition in block %i follows the use", def_bb
->index
);
904 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
906 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
910 /* Make sure the use is in an appropriate list by checking the previous
911 element to make sure it's the same. */
912 if (use_p
->prev
== NULL
)
914 error ("no immediate_use list");
920 if (use_p
->prev
->use
== NULL
)
921 listvar
= use_p
->prev
->loc
.ssa_name
;
923 listvar
= USE_FROM_PTR (use_p
->prev
);
924 if (listvar
!= ssa_name
)
926 error ("wrong immediate use list");
933 fprintf (stderr
, "for SSA_NAME: ");
934 print_generic_expr (stderr
, ssa_name
, TDF_VOPS
);
935 fprintf (stderr
, " in statement:\n");
936 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
943 /* Return true if any of the arguments for PHI node PHI at block BB is
946 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
947 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
948 it means that the block in that array slot contains the
949 definition of SSA_NAME. */
952 verify_phi_args (gphi
*phi
, basic_block bb
, basic_block
*definition_block
)
956 size_t i
, phi_num_args
= gimple_phi_num_args (phi
);
958 if (EDGE_COUNT (bb
->preds
) != phi_num_args
)
960 error ("incoming edge count does not match number of PHI arguments");
965 for (i
= 0; i
< phi_num_args
; i
++)
967 use_operand_p op_p
= gimple_phi_arg_imm_use_ptr (phi
, i
);
968 tree op
= USE_FROM_PTR (op_p
);
970 e
= EDGE_PRED (bb
, i
);
974 error ("PHI argument is missing for edge %d->%d",
981 if (TREE_CODE (op
) != SSA_NAME
&& !is_gimple_min_invariant (op
))
983 error ("PHI argument is not SSA_NAME, or invariant");
987 if ((e
->flags
& EDGE_ABNORMAL
) && TREE_CODE (op
) != SSA_NAME
)
989 error ("PHI argument on abnormal edge is not SSA_NAME");
993 if (TREE_CODE (op
) == SSA_NAME
)
995 err
= verify_ssa_name (op
, virtual_operand_p (gimple_phi_result (phi
)));
996 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)],
997 op_p
, phi
, e
->flags
& EDGE_ABNORMAL
, NULL
);
1000 if (TREE_CODE (op
) == ADDR_EXPR
)
1002 tree base
= TREE_OPERAND (op
, 0);
1003 while (handled_component_p (base
))
1004 base
= TREE_OPERAND (base
, 0);
1006 || TREE_CODE (base
) == PARM_DECL
1007 || TREE_CODE (base
) == RESULT_DECL
)
1008 && !TREE_ADDRESSABLE (base
))
1010 error ("address taken, but ADDRESSABLE bit not set");
1017 error ("wrong edge %d->%d for PHI argument",
1018 e
->src
->index
, e
->dest
->index
);
1024 fprintf (stderr
, "PHI argument\n");
1025 print_generic_stmt (stderr
, op
, TDF_VOPS
);
1033 fprintf (stderr
, "for PHI node\n");
1034 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
|TDF_MEMSYMS
);
1042 /* Verify common invariants in the SSA web.
1043 TODO: verify the variable annotations. */
1046 verify_ssa (bool check_modified_stmt
, bool check_ssa_operands
)
1049 basic_block
*definition_block
= XCNEWVEC (basic_block
, num_ssa_names
);
1052 enum dom_state orig_dom_state
= dom_info_state (CDI_DOMINATORS
);
1053 auto_bitmap names_defined_in_bb
;
1055 gcc_assert (!need_ssa_update_p (cfun
));
1057 timevar_push (TV_TREE_SSA_VERIFY
);
1060 /* Keep track of SSA names present in the IL. */
1063 hash_map
<void *, tree
> ssa_info
;
1065 FOR_EACH_SSA_NAME (i
, name
, cfun
)
1068 TREE_VISITED (name
) = 0;
1070 verify_ssa_name (name
, virtual_operand_p (name
));
1072 stmt
= SSA_NAME_DEF_STMT (name
);
1073 if (!gimple_nop_p (stmt
))
1075 basic_block bb
= gimple_bb (stmt
);
1076 if (verify_def (bb
, definition_block
,
1077 name
, stmt
, virtual_operand_p (name
)))
1082 if (POINTER_TYPE_P (TREE_TYPE (name
)))
1083 info
= SSA_NAME_PTR_INFO (name
);
1084 else if (INTEGRAL_TYPE_P (TREE_TYPE (name
)))
1085 info
= SSA_NAME_RANGE_INFO (name
);
1089 tree
&val
= ssa_info
.get_or_insert (info
, &existed
);
1092 error ("shared SSA name info");
1093 print_generic_expr (stderr
, val
);
1094 fprintf (stderr
, " and ");
1095 print_generic_expr (stderr
, name
);
1096 fprintf (stderr
, "\n");
1105 calculate_dominance_info (CDI_DOMINATORS
);
1107 /* Now verify all the uses and make sure they agree with the definitions
1108 found in the previous pass. */
1109 FOR_EACH_BB_FN (bb
, cfun
)
1114 /* Make sure that all edges have a clear 'aux' field. */
1115 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1119 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
1125 /* Verify the arguments for every PHI node in the block. */
1126 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1128 gphi
*phi
= gsi
.phi ();
1129 if (verify_phi_args (phi
, bb
, definition_block
))
1132 bitmap_set_bit (names_defined_in_bb
,
1133 SSA_NAME_VERSION (gimple_phi_result (phi
)));
1136 /* Now verify all the uses and vuses in every statement of the block. */
1137 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
1140 gimple
*stmt
= gsi_stmt (gsi
);
1141 use_operand_p use_p
;
1143 if (check_modified_stmt
&& gimple_modified_p (stmt
))
1145 error ("stmt (%p) marked modified after optimization pass: ",
1147 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1151 if (check_ssa_operands
&& verify_ssa_operands (cfun
, stmt
))
1153 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1157 if (gimple_debug_bind_p (stmt
)
1158 && !gimple_debug_bind_has_value_p (stmt
))
1161 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
1163 op
= USE_FROM_PTR (use_p
);
1164 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
1165 use_p
, stmt
, false, names_defined_in_bb
))
1169 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
1171 if (SSA_NAME_DEF_STMT (op
) != stmt
)
1173 error ("SSA_NAME_DEF_STMT is wrong");
1174 fprintf (stderr
, "Expected definition statement:\n");
1175 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
1176 fprintf (stderr
, "\nActual definition statement:\n");
1177 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (op
),
1181 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
1185 bitmap_clear (names_defined_in_bb
);
1188 free (definition_block
);
1190 if (gimple_vop (cfun
)
1191 && ssa_default_def (cfun
, gimple_vop (cfun
)))
1193 auto_sbitmap
visited (last_basic_block_for_fn (cfun
) + 1);
1194 bitmap_clear (visited
);
1195 if (verify_vssa (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
1196 ssa_default_def (cfun
, gimple_vop (cfun
)), visited
))
1200 /* Restore the dominance information to its prior known state, so
1201 that we do not perturb the compiler's subsequent behavior. */
1202 if (orig_dom_state
== DOM_NONE
)
1203 free_dominance_info (CDI_DOMINATORS
);
1205 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
1207 timevar_pop (TV_TREE_SSA_VERIFY
);
1211 internal_error ("verify_ssa failed");
1215 # pragma GCC diagnostic pop
1218 /* Initialize global DFA and SSA structures.
1219 If SIZE is non-zero allocated ssa names array of a given size. */
1222 init_tree_ssa (struct function
*fn
, int size
)
1224 fn
->gimple_df
= ggc_cleared_alloc
<gimple_df
> ();
1225 fn
->gimple_df
->default_defs
= hash_table
<ssa_name_hasher
>::create_ggc (20);
1226 pt_solution_reset (&fn
->gimple_df
->escaped
);
1227 init_ssanames (fn
, size
);
1230 /* Deallocate memory associated with SSA data structures for FNDECL. */
1233 delete_tree_ssa (struct function
*fn
)
1237 /* We no longer maintain the SSA operand cache at this point. */
1238 if (ssa_operands_active (fn
))
1239 fini_ssa_operands (fn
);
1241 fn
->gimple_df
->default_defs
->empty ();
1242 fn
->gimple_df
->default_defs
= NULL
;
1243 pt_solution_reset (&fn
->gimple_df
->escaped
);
1244 if (fn
->gimple_df
->decls_to_pointers
!= NULL
)
1245 delete fn
->gimple_df
->decls_to_pointers
;
1246 fn
->gimple_df
->decls_to_pointers
= NULL
;
1247 fn
->gimple_df
= NULL
;
1249 /* We no longer need the edge variable maps. */
1250 redirect_edge_var_map_empty ();
1253 /* Return true if EXPR is a useless type conversion, otherwise return
1257 tree_ssa_useless_type_conversion (tree expr
)
1259 /* If we have an assignment that merely uses a NOP_EXPR to change
1260 the top of the RHS to the type of the LHS and the type conversion
1261 is "safe", then strip away the type conversion so that we can
1262 enter LHS = RHS into the const_and_copies table. */
1263 if (CONVERT_EXPR_P (expr
)
1264 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1265 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1266 return useless_type_conversion_p
1268 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1273 /* Strip conversions from EXP according to
1274 tree_ssa_useless_type_conversion and return the resulting
1278 tree_ssa_strip_useless_type_conversions (tree exp
)
1280 while (tree_ssa_useless_type_conversion (exp
))
1281 exp
= TREE_OPERAND (exp
, 0);
1285 /* Return true if T, as SSA_NAME, has an implicit default defined value. */
1288 ssa_defined_default_def_p (tree t
)
1290 tree var
= SSA_NAME_VAR (t
);
1294 /* Parameters get their initial value from the function entry. */
1295 else if (TREE_CODE (var
) == PARM_DECL
)
1297 /* When returning by reference the return address is actually a hidden
1299 else if (TREE_CODE (var
) == RESULT_DECL
&& DECL_BY_REFERENCE (var
))
1301 /* Hard register variables get their initial value from the ether. */
1302 else if (VAR_P (var
) && DECL_HARD_REGISTER (var
))
1309 /* Return true if T, an SSA_NAME, has an undefined value. PARTIAL is what
1310 should be returned if the value is only partially undefined. */
1313 ssa_undefined_value_p (tree t
, bool partial
)
1317 if (ssa_defined_default_def_p (t
))
1320 /* The value is undefined iff its definition statement is empty. */
1321 def_stmt
= SSA_NAME_DEF_STMT (t
);
1322 if (gimple_nop_p (def_stmt
))
1325 /* The value is undefined if the definition statement is a call
1326 to .DEFERRED_INIT function. */
1327 if (gimple_call_internal_p (def_stmt
, IFN_DEFERRED_INIT
))
1330 /* The value is partially undefined if the definition statement is
1331 a REALPART_EXPR or IMAGPART_EXPR and its operand is defined by
1332 the call to .DEFERRED_INIT function. This is for handling the
1335 1 typedef _Complex float C;
1348 with -ftrivial-auto-var-init, compiler will insert the following
1349 artificial initialization:
1350 f = .DEFERRED_INIT (f, 2);
1351 _1 = REALPART_EXPR <f>;
1353 we should treat the definition _1 = REALPART_EXPR <f> as undefined. */
1354 if (partial
&& is_gimple_assign (def_stmt
)
1355 && (gimple_assign_rhs_code (def_stmt
) == REALPART_EXPR
1356 || gimple_assign_rhs_code (def_stmt
) == IMAGPART_EXPR
))
1358 tree real_imag_part
= TREE_OPERAND (gimple_assign_rhs1 (def_stmt
), 0);
1359 if (TREE_CODE (real_imag_part
) == SSA_NAME
1360 && gimple_call_internal_p (SSA_NAME_DEF_STMT (real_imag_part
),
1365 /* Check if the complex was not only partially defined. */
1366 if (partial
&& is_gimple_assign (def_stmt
)
1367 && gimple_assign_rhs_code (def_stmt
) == COMPLEX_EXPR
)
1371 rhs1
= gimple_assign_rhs1 (def_stmt
);
1372 rhs2
= gimple_assign_rhs2 (def_stmt
);
1373 return (TREE_CODE (rhs1
) == SSA_NAME
&& ssa_undefined_value_p (rhs1
))
1374 || (TREE_CODE (rhs2
) == SSA_NAME
&& ssa_undefined_value_p (rhs2
));
1380 /* Return TRUE iff STMT, a gimple statement, references an undefined
1384 gimple_uses_undefined_value_p (gimple
*stmt
)
1389 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
1390 if (ssa_undefined_value_p (op
))
1398 /* If necessary, rewrite the base of the reference tree *TP from
1399 a MEM_REF to a plain or converted symbol. */
1402 maybe_rewrite_mem_ref_base (tree
*tp
, bitmap suitable_for_renaming
)
1406 while (handled_component_p (*tp
))
1407 tp
= &TREE_OPERAND (*tp
, 0);
1408 if (TREE_CODE (*tp
) == MEM_REF
1409 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == ADDR_EXPR
1410 && (sym
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0))
1412 && !TREE_ADDRESSABLE (sym
)
1413 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
))
1414 && is_gimple_reg_type (TREE_TYPE (*tp
))
1415 && ! VOID_TYPE_P (TREE_TYPE (*tp
)))
1417 if (TREE_CODE (TREE_TYPE (sym
)) == VECTOR_TYPE
1418 && useless_type_conversion_p (TREE_TYPE (*tp
),
1419 TREE_TYPE (TREE_TYPE (sym
)))
1420 && multiple_of_p (sizetype
, TREE_OPERAND (*tp
, 1),
1421 TYPE_SIZE_UNIT (TREE_TYPE (*tp
))))
1423 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1424 TYPE_SIZE (TREE_TYPE (*tp
)),
1425 int_const_binop (MULT_EXPR
,
1426 bitsize_int (BITS_PER_UNIT
),
1427 TREE_OPERAND (*tp
, 1)));
1429 else if (TREE_CODE (TREE_TYPE (sym
)) == COMPLEX_TYPE
1430 && useless_type_conversion_p (TREE_TYPE (*tp
),
1431 TREE_TYPE (TREE_TYPE (sym
))))
1433 *tp
= build1 (integer_zerop (TREE_OPERAND (*tp
, 1))
1434 ? REALPART_EXPR
: IMAGPART_EXPR
,
1435 TREE_TYPE (*tp
), sym
);
1437 else if (integer_zerop (TREE_OPERAND (*tp
, 1))
1438 && DECL_SIZE (sym
) == TYPE_SIZE (TREE_TYPE (*tp
)))
1440 if (!useless_type_conversion_p (TREE_TYPE (*tp
),
1442 *tp
= build1 (VIEW_CONVERT_EXPR
,
1443 TREE_TYPE (*tp
), sym
);
1447 else if (DECL_SIZE (sym
)
1448 && TREE_CODE (DECL_SIZE (sym
)) == INTEGER_CST
1449 && (known_subrange_p
1450 (mem_ref_offset (*tp
),
1451 wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (*tp
))),
1452 0, wi::to_offset (DECL_SIZE_UNIT (sym
))))
1453 && (! INTEGRAL_TYPE_P (TREE_TYPE (*tp
))
1454 || (wi::to_offset (TYPE_SIZE (TREE_TYPE (*tp
)))
1455 == TYPE_PRECISION (TREE_TYPE (*tp
))))
1456 && wi::umod_trunc (wi::to_offset (TYPE_SIZE (TREE_TYPE (*tp
))),
1457 BITS_PER_UNIT
) == 0)
1459 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1460 TYPE_SIZE (TREE_TYPE (*tp
)),
1461 wide_int_to_tree (bitsizetype
,
1462 mem_ref_offset (*tp
)
1463 << LOG2_BITS_PER_UNIT
));
1468 /* For a tree REF return its base if it is the base of a MEM_REF
1469 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1472 non_rewritable_mem_ref_base (tree ref
)
1476 /* A plain decl does not need it set. */
1480 if (! (base
= CONST_CAST_TREE (strip_invariant_refs (ref
))))
1482 base
= get_base_address (ref
);
1488 /* But watch out for MEM_REFs we cannot lower to a
1489 VIEW_CONVERT_EXPR or a BIT_FIELD_REF. */
1490 if (TREE_CODE (base
) == MEM_REF
1491 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1493 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1494 if (! DECL_P (decl
))
1496 if (! is_gimple_reg_type (TREE_TYPE (base
))
1497 || VOID_TYPE_P (TREE_TYPE (base
))
1498 || TREE_THIS_VOLATILE (decl
) != TREE_THIS_VOLATILE (base
))
1500 if ((TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
1501 || TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
)
1502 && useless_type_conversion_p (TREE_TYPE (base
),
1503 TREE_TYPE (TREE_TYPE (decl
)))
1504 && known_ge (mem_ref_offset (base
), 0)
1505 && known_gt (wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl
))),
1506 mem_ref_offset (base
))
1507 && multiple_of_p (sizetype
, TREE_OPERAND (base
, 1),
1508 TYPE_SIZE_UNIT (TREE_TYPE (base
))))
1510 /* For same sizes and zero offset we can use a VIEW_CONVERT_EXPR. */
1511 if (integer_zerop (TREE_OPERAND (base
, 1))
1512 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (base
)))
1514 /* For integral typed extracts we can use a BIT_FIELD_REF. */
1515 if (DECL_SIZE (decl
)
1516 && TREE_CODE (DECL_SIZE_UNIT (decl
)) == INTEGER_CST
1517 && (known_subrange_p
1518 (mem_ref_offset (base
),
1519 wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (base
))),
1520 0, wi::to_poly_offset (DECL_SIZE_UNIT (decl
))))
1521 /* ??? We can't handle bitfield precision extracts without
1522 either using an alternate type for the BIT_FIELD_REF and
1523 then doing a conversion or possibly adjusting the offset
1524 according to endianness. */
1525 && (! INTEGRAL_TYPE_P (TREE_TYPE (base
))
1526 || (wi::to_offset (TYPE_SIZE (TREE_TYPE (base
)))
1527 == TYPE_PRECISION (TREE_TYPE (base
))))
1528 && wi::umod_trunc (wi::to_offset (TYPE_SIZE (TREE_TYPE (base
))),
1529 BITS_PER_UNIT
) == 0)
1534 /* We cannot rewrite TARGET_MEM_REFs. */
1535 if (TREE_CODE (base
) == TARGET_MEM_REF
1536 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1538 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1539 if (! DECL_P (decl
))
1547 /* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
1548 Otherwise return true. */
1551 non_rewritable_lvalue_p (tree lhs
)
1553 /* A plain decl is always rewritable. */
1557 /* We can re-write REALPART_EXPR and IMAGPART_EXPR sets in
1558 a reasonably efficient manner... */
1559 if ((TREE_CODE (lhs
) == REALPART_EXPR
1560 || TREE_CODE (lhs
) == IMAGPART_EXPR
)
1561 && DECL_P (TREE_OPERAND (lhs
, 0)))
1564 /* ??? The following could be relaxed allowing component
1565 references that do not change the access size. */
1566 if (TREE_CODE (lhs
) == MEM_REF
1567 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
)
1569 tree decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
1571 /* A decl that is wrapped inside a MEM-REF that covers
1572 it full is also rewritable. */
1573 if (integer_zerop (TREE_OPERAND (lhs
, 1))
1575 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (lhs
))
1576 /* If the dynamic type of the decl has larger precision than
1577 the decl itself we can't use the decls type for SSA rewriting. */
1578 && ((! INTEGRAL_TYPE_P (TREE_TYPE (decl
))
1579 || compare_tree_int (DECL_SIZE (decl
),
1580 TYPE_PRECISION (TREE_TYPE (decl
))) == 0)
1581 || (INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
1582 && (TYPE_PRECISION (TREE_TYPE (decl
))
1583 >= TYPE_PRECISION (TREE_TYPE (lhs
)))))
1584 /* Make sure we are not re-writing non-float copying into float
1585 copying as that can incur normalization. */
1586 && (! FLOAT_TYPE_P (TREE_TYPE (decl
))
1587 || types_compatible_p (TREE_TYPE (lhs
), TREE_TYPE (decl
)))
1588 && (TREE_THIS_VOLATILE (decl
) == TREE_THIS_VOLATILE (lhs
)))
1591 /* A vector-insert using a MEM_REF or ARRAY_REF is rewritable
1592 using a BIT_INSERT_EXPR. */
1594 && VECTOR_TYPE_P (TREE_TYPE (decl
))
1595 && TYPE_MODE (TREE_TYPE (decl
)) != BLKmode
1596 && known_ge (mem_ref_offset (lhs
), 0)
1597 && known_gt (wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl
))),
1598 mem_ref_offset (lhs
))
1599 && multiple_of_p (sizetype
, TREE_OPERAND (lhs
, 1),
1600 TYPE_SIZE_UNIT (TREE_TYPE (lhs
)))
1601 && known_ge (wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (decl
))),
1602 wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (lhs
)))))
1604 poly_uint64 lhs_bits
, nelts
;
1605 if (poly_int_tree_p (TYPE_SIZE (TREE_TYPE (lhs
)), &lhs_bits
)
1606 && multiple_p (lhs_bits
,
1608 (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl
)))),
1610 && valid_vector_subparts_p (nelts
))
1612 if (known_eq (nelts
, 1u))
1614 /* For sub-vector inserts the insert vector mode has to be
1616 tree vtype
= build_vector_type (TREE_TYPE (TREE_TYPE (decl
)),
1618 if (TYPE_MODE (vtype
) != BLKmode
)
1624 /* A vector-insert using a BIT_FIELD_REF is rewritable using
1626 if (TREE_CODE (lhs
) == BIT_FIELD_REF
1627 && DECL_P (TREE_OPERAND (lhs
, 0))
1628 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
1629 && TYPE_MODE (TREE_TYPE (TREE_OPERAND (lhs
, 0))) != BLKmode
1630 && operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (lhs
)),
1632 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (lhs
, 0)))), 0)
1633 && (tree_to_uhwi (TREE_OPERAND (lhs
, 2))
1634 % tree_to_uhwi (TYPE_SIZE (TREE_TYPE (lhs
)))) == 0)
1640 /* When possible, clear TREE_ADDRESSABLE bit, set or clear DECL_NOT_GIMPLE_REG_P
1641 and mark the variable VAR for conversion into SSA. Return true when updating
1642 stmts is required. */
1645 maybe_optimize_var (tree var
, bitmap addresses_taken
, bitmap not_reg_needs
,
1646 bitmap suitable_for_renaming
)
1648 /* Global Variables, result decls cannot be changed. */
1649 if (is_global_var (var
)
1650 || TREE_CODE (var
) == RESULT_DECL
1651 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1654 bool maybe_reg
= false;
1655 if (TREE_ADDRESSABLE (var
))
1657 TREE_ADDRESSABLE (var
) = 0;
1661 fprintf (dump_file
, "No longer having address taken: ");
1662 print_generic_expr (dump_file
, var
);
1663 fprintf (dump_file
, "\n");
1667 /* For register type decls if we do not have any partial defs
1668 we cannot express in SSA form mark them as DECL_NOT_GIMPLE_REG_P
1669 as to avoid SSA rewrite. For the others go ahead and mark
1670 them for renaming. */
1671 if (is_gimple_reg_type (TREE_TYPE (var
)))
1673 if (bitmap_bit_p (not_reg_needs
, DECL_UID (var
)))
1675 DECL_NOT_GIMPLE_REG_P (var
) = 1;
1678 fprintf (dump_file
, "Has partial defs: ");
1679 print_generic_expr (dump_file
, var
);
1680 fprintf (dump_file
, "\n");
1683 else if (DECL_NOT_GIMPLE_REG_P (var
))
1686 DECL_NOT_GIMPLE_REG_P (var
) = 0;
1688 if (maybe_reg
&& is_gimple_reg (var
))
1692 fprintf (dump_file
, "Now a gimple register: ");
1693 print_generic_expr (dump_file
, var
);
1694 fprintf (dump_file
, "\n");
1696 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1701 /* Return true when STMT is ASAN mark where second argument is an address
1702 of a local variable. */
1705 is_asan_mark_p (gimple
*stmt
)
1707 if (!gimple_call_internal_p (stmt
, IFN_ASAN_MARK
))
1710 tree addr
= get_base_address (gimple_call_arg (stmt
, 1));
1711 if (TREE_CODE (addr
) == ADDR_EXPR
1712 && VAR_P (TREE_OPERAND (addr
, 0)))
1714 tree var
= TREE_OPERAND (addr
, 0);
1715 if (lookup_attribute (ASAN_USE_AFTER_SCOPE_ATTRIBUTE
,
1716 DECL_ATTRIBUTES (var
)))
1719 unsigned addressable
= TREE_ADDRESSABLE (var
);
1720 TREE_ADDRESSABLE (var
) = 0;
1721 bool r
= is_gimple_reg (var
);
1722 TREE_ADDRESSABLE (var
) = addressable
;
1729 /* Compute TREE_ADDRESSABLE and whether we have unhandled partial defs
1730 for local variables. */
1733 execute_update_addresses_taken (void)
1736 auto_bitmap addresses_taken
;
1737 auto_bitmap not_reg_needs
;
1738 auto_bitmap suitable_for_renaming
;
1742 timevar_push (TV_ADDRESS_TAKEN
);
1744 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1745 the function body. */
1746 FOR_EACH_BB_FN (bb
, cfun
)
1748 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
1751 gimple
*stmt
= gsi_stmt (gsi
);
1752 enum gimple_code code
= gimple_code (stmt
);
1755 if (code
== GIMPLE_CALL
)
1757 if (optimize_atomic_compare_exchange_p (stmt
))
1759 /* For __atomic_compare_exchange_N if the second argument
1760 is &var, don't mark var addressable;
1761 if it becomes non-addressable, we'll rewrite it into
1762 ATOMIC_COMPARE_EXCHANGE call. */
1763 tree arg
= gimple_call_arg (stmt
, 1);
1764 gimple_call_set_arg (stmt
, 1, null_pointer_node
);
1765 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1766 gimple_call_set_arg (stmt
, 1, arg
);
1768 else if (is_asan_mark_p (stmt
)
1769 || gimple_call_internal_p (stmt
, IFN_GOMP_SIMT_ENTER
))
1772 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1775 /* Note all addresses taken by the stmt. */
1776 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1778 /* If we have a call or an assignment, see if the lhs contains
1779 a local decl that requires not to be a gimple register. */
1780 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1782 tree lhs
= gimple_get_lhs (stmt
);
1784 && TREE_CODE (lhs
) != SSA_NAME
1785 && ((code
== GIMPLE_CALL
&& ! DECL_P (lhs
))
1786 || non_rewritable_lvalue_p (lhs
)))
1788 decl
= get_base_address (lhs
);
1790 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1794 if (gimple_assign_single_p (stmt
))
1796 tree rhs
= gimple_assign_rhs1 (stmt
);
1797 if ((decl
= non_rewritable_mem_ref_base (rhs
)))
1798 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1801 else if (code
== GIMPLE_CALL
)
1803 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1805 tree arg
= gimple_call_arg (stmt
, i
);
1806 if ((decl
= non_rewritable_mem_ref_base (arg
)))
1807 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1811 else if (code
== GIMPLE_ASM
)
1813 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
1814 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
1816 tree link
= gimple_asm_output_op (asm_stmt
, i
);
1817 tree lhs
= TREE_VALUE (link
);
1818 if (TREE_CODE (lhs
) != SSA_NAME
)
1820 decl
= get_base_address (lhs
);
1822 && (non_rewritable_lvalue_p (lhs
)
1823 /* We cannot move required conversions from
1824 the lhs to the rhs in asm statements, so
1825 require we do not need any. */
1826 || !useless_type_conversion_p
1827 (TREE_TYPE (lhs
), TREE_TYPE (decl
))))
1828 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1831 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
1833 tree link
= gimple_asm_input_op (asm_stmt
, i
);
1834 if ((decl
= non_rewritable_mem_ref_base (TREE_VALUE (link
))))
1835 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1840 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
1844 gphi
*phi
= gsi
.phi ();
1846 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1848 tree op
= PHI_ARG_DEF (phi
, i
), var
;
1849 if (TREE_CODE (op
) == ADDR_EXPR
1850 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
1852 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
1857 /* We cannot iterate over all referenced vars because that can contain
1858 unused vars from BLOCK trees, which causes code generation differences
1860 for (var
= DECL_ARGUMENTS (cfun
->decl
); var
; var
= DECL_CHAIN (var
))
1861 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1862 suitable_for_renaming
);
1864 FOR_EACH_VEC_SAFE_ELT (cfun
->local_decls
, i
, var
)
1865 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1866 suitable_for_renaming
);
1868 /* Operand caches need to be recomputed for operands referencing the updated
1869 variables and operands need to be rewritten to expose bare symbols. */
1870 if (!bitmap_empty_p (suitable_for_renaming
))
1872 FOR_EACH_BB_FN (bb
, cfun
)
1873 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
1875 gimple
*stmt
= gsi_stmt (gsi
);
1877 /* Re-write TARGET_MEM_REFs of symbols we want to
1878 rewrite into SSA form. */
1879 if (gimple_assign_single_p (stmt
))
1881 tree lhs
= gimple_assign_lhs (stmt
);
1882 tree rhs
, *rhsp
= gimple_assign_rhs1_ptr (stmt
);
1885 /* Rewrite LHS IMAG/REALPART_EXPR similar to
1886 gimplify_modify_expr_complex_part. */
1887 if ((TREE_CODE (lhs
) == IMAGPART_EXPR
1888 || TREE_CODE (lhs
) == REALPART_EXPR
)
1889 && DECL_P (TREE_OPERAND (lhs
, 0))
1890 && bitmap_bit_p (suitable_for_renaming
,
1891 DECL_UID (TREE_OPERAND (lhs
, 0))))
1893 tree other
= make_ssa_name (TREE_TYPE (lhs
));
1894 tree lrhs
= build1 (TREE_CODE (lhs
) == IMAGPART_EXPR
1895 ? REALPART_EXPR
: IMAGPART_EXPR
,
1897 TREE_OPERAND (lhs
, 0));
1898 gimple
*load
= gimple_build_assign (other
, lrhs
);
1899 location_t loc
= gimple_location (stmt
);
1900 gimple_set_location (load
, loc
);
1901 gimple_set_vuse (load
, gimple_vuse (stmt
));
1902 gsi_insert_before (&gsi
, load
, GSI_SAME_STMT
);
1903 gimple_assign_set_lhs (stmt
, TREE_OPERAND (lhs
, 0));
1904 gimple_assign_set_rhs_with_ops
1905 (&gsi
, COMPLEX_EXPR
,
1906 TREE_CODE (lhs
) == IMAGPART_EXPR
1907 ? other
: gimple_assign_rhs1 (stmt
),
1908 TREE_CODE (lhs
) == IMAGPART_EXPR
1909 ? gimple_assign_rhs1 (stmt
) : other
, NULL_TREE
);
1910 stmt
= gsi_stmt (gsi
);
1911 unlink_stmt_vdef (stmt
);
1916 /* Rewrite a vector insert via a BIT_FIELD_REF on the LHS
1917 into a BIT_INSERT_EXPR. */
1918 if (TREE_CODE (lhs
) == BIT_FIELD_REF
1919 && DECL_P (TREE_OPERAND (lhs
, 0))
1920 && bitmap_bit_p (suitable_for_renaming
,
1921 DECL_UID (TREE_OPERAND (lhs
, 0)))
1922 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
1923 && TYPE_MODE (TREE_TYPE (TREE_OPERAND (lhs
, 0))) != BLKmode
1924 && operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (lhs
)),
1925 TYPE_SIZE_UNIT (TREE_TYPE
1926 (TREE_TYPE (TREE_OPERAND (lhs
, 0)))),
1928 && (tree_to_uhwi (TREE_OPERAND (lhs
, 2))
1929 % tree_to_uhwi (TYPE_SIZE (TREE_TYPE (lhs
))) == 0))
1931 tree var
= TREE_OPERAND (lhs
, 0);
1932 tree val
= gimple_assign_rhs1 (stmt
);
1933 if (! types_compatible_p (TREE_TYPE (TREE_TYPE (var
)),
1936 tree tem
= make_ssa_name (TREE_TYPE (TREE_TYPE (var
)));
1938 = gimple_build_assign (tem
,
1939 build1 (VIEW_CONVERT_EXPR
,
1940 TREE_TYPE (tem
), val
));
1941 gsi_insert_before (&gsi
, pun
, GSI_SAME_STMT
);
1944 tree bitpos
= TREE_OPERAND (lhs
, 2);
1945 gimple_assign_set_lhs (stmt
, var
);
1946 gimple_assign_set_rhs_with_ops
1947 (&gsi
, BIT_INSERT_EXPR
, var
, val
, bitpos
);
1948 stmt
= gsi_stmt (gsi
);
1949 unlink_stmt_vdef (stmt
);
1954 /* Rewrite a vector insert using a MEM_REF on the LHS
1955 into a BIT_INSERT_EXPR. */
1956 if (TREE_CODE (lhs
) == MEM_REF
1957 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1958 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
1960 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
))
1961 && VECTOR_TYPE_P (TREE_TYPE (sym
))
1962 && TYPE_MODE (TREE_TYPE (sym
)) != BLKmode
1963 /* If it is a full replacement we can do better below. */
1964 && maybe_ne (wi::to_poly_offset
1965 (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))),
1967 (TYPE_SIZE_UNIT (TREE_TYPE (sym
))))
1968 && known_ge (mem_ref_offset (lhs
), 0)
1969 && known_gt (wi::to_poly_offset
1970 (TYPE_SIZE_UNIT (TREE_TYPE (sym
))),
1971 mem_ref_offset (lhs
))
1972 && multiple_of_p (sizetype
,
1973 TREE_OPERAND (lhs
, 1),
1974 TYPE_SIZE_UNIT (TREE_TYPE (lhs
))))
1976 tree val
= gimple_assign_rhs1 (stmt
);
1977 if (! types_compatible_p (TREE_TYPE (val
),
1978 TREE_TYPE (TREE_TYPE (sym
))))
1980 poly_uint64 lhs_bits
, nelts
;
1981 tree temtype
= TREE_TYPE (TREE_TYPE (sym
));
1982 if (poly_int_tree_p (TYPE_SIZE (TREE_TYPE (lhs
)),
1984 && multiple_p (lhs_bits
,
1986 (TYPE_SIZE (TREE_TYPE
1987 (TREE_TYPE (sym
)))),
1989 && maybe_ne (nelts
, 1u)
1990 && valid_vector_subparts_p (nelts
))
1991 temtype
= build_vector_type (temtype
, nelts
);
1992 tree tem
= make_ssa_name (temtype
);
1994 = gimple_build_assign (tem
,
1995 build1 (VIEW_CONVERT_EXPR
,
1996 TREE_TYPE (tem
), val
));
1997 gsi_insert_before (&gsi
, pun
, GSI_SAME_STMT
);
2001 = wide_int_to_tree (bitsizetype
,
2002 mem_ref_offset (lhs
) * BITS_PER_UNIT
);
2003 gimple_assign_set_lhs (stmt
, sym
);
2004 gimple_assign_set_rhs_with_ops
2005 (&gsi
, BIT_INSERT_EXPR
, sym
, val
, bitpos
);
2006 stmt
= gsi_stmt (gsi
);
2007 unlink_stmt_vdef (stmt
);
2012 /* We shouldn't have any fancy wrapping of
2013 component-refs on the LHS, but look through
2014 VIEW_CONVERT_EXPRs as that is easy. */
2015 while (TREE_CODE (lhs
) == VIEW_CONVERT_EXPR
)
2016 lhs
= TREE_OPERAND (lhs
, 0);
2017 if (TREE_CODE (lhs
) == MEM_REF
2018 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
2019 && integer_zerop (TREE_OPERAND (lhs
, 1))
2020 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
2022 && !TREE_ADDRESSABLE (sym
)
2023 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
2026 lhs
= gimple_assign_lhs (stmt
);
2028 /* Rewrite the RHS and make sure the resulting assignment
2029 is validly typed. */
2030 maybe_rewrite_mem_ref_base (rhsp
, suitable_for_renaming
);
2031 rhs
= gimple_assign_rhs1 (stmt
);
2032 if (gimple_assign_lhs (stmt
) != lhs
2033 && !useless_type_conversion_p (TREE_TYPE (lhs
),
2036 if (gimple_clobber_p (stmt
))
2038 rhs
= build_constructor (TREE_TYPE (lhs
), NULL
);
2039 TREE_THIS_VOLATILE (rhs
) = 1;
2042 rhs
= fold_build1 (VIEW_CONVERT_EXPR
,
2043 TREE_TYPE (lhs
), rhs
);
2045 if (gimple_assign_lhs (stmt
) != lhs
)
2046 gimple_assign_set_lhs (stmt
, lhs
);
2048 if (gimple_assign_rhs1 (stmt
) != rhs
)
2050 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
2051 gimple_assign_set_rhs_from_tree (&gsi
, rhs
);
2055 else if (gimple_code (stmt
) == GIMPLE_CALL
)
2058 if (optimize_atomic_compare_exchange_p (stmt
))
2060 tree expected
= gimple_call_arg (stmt
, 1);
2061 if (bitmap_bit_p (suitable_for_renaming
,
2062 DECL_UID (TREE_OPERAND (expected
, 0))))
2064 fold_builtin_atomic_compare_exchange (&gsi
);
2068 else if (is_asan_mark_p (stmt
))
2070 tree var
= TREE_OPERAND (gimple_call_arg (stmt
, 1), 0);
2071 if (bitmap_bit_p (suitable_for_renaming
, DECL_UID (var
)))
2073 unlink_stmt_vdef (stmt
);
2074 if (asan_mark_p (stmt
, ASAN_MARK_POISON
))
2077 = gimple_build_call_internal (IFN_ASAN_POISON
, 0);
2078 gimple_call_set_lhs (call
, var
);
2079 gsi_replace (&gsi
, call
, true);
2083 /* In ASAN_MARK (UNPOISON, &b, ...) the variable
2084 is uninitialized. Avoid dependencies on
2085 previous out of scope value. */
2086 tree clobber
= build_clobber (TREE_TYPE (var
));
2087 gimple
*g
= gimple_build_assign (var
, clobber
);
2088 gsi_replace (&gsi
, g
, true);
2093 else if (gimple_call_internal_p (stmt
, IFN_GOMP_SIMT_ENTER
))
2094 for (i
= 1; i
< gimple_call_num_args (stmt
); i
++)
2096 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
2097 if (*argp
== null_pointer_node
)
2099 gcc_assert (TREE_CODE (*argp
) == ADDR_EXPR
2100 && VAR_P (TREE_OPERAND (*argp
, 0)));
2101 tree var
= TREE_OPERAND (*argp
, 0);
2102 if (bitmap_bit_p (suitable_for_renaming
, DECL_UID (var
)))
2103 *argp
= null_pointer_node
;
2105 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
2107 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
2108 maybe_rewrite_mem_ref_base (argp
, suitable_for_renaming
);
2112 else if (gimple_code (stmt
) == GIMPLE_ASM
)
2114 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
2116 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
2118 tree link
= gimple_asm_output_op (asm_stmt
, i
);
2119 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
2120 suitable_for_renaming
);
2122 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
2124 tree link
= gimple_asm_input_op (asm_stmt
, i
);
2125 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
2126 suitable_for_renaming
);
2130 else if (gimple_debug_bind_p (stmt
)
2131 && gimple_debug_bind_has_value_p (stmt
))
2133 tree
*valuep
= gimple_debug_bind_get_value_ptr (stmt
);
2135 maybe_rewrite_mem_ref_base (valuep
, suitable_for_renaming
);
2136 decl
= non_rewritable_mem_ref_base (*valuep
);
2138 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (decl
)))
2139 gimple_debug_bind_reset_value (stmt
);
2142 if (gimple_references_memory_p (stmt
)
2143 || is_gimple_debug (stmt
))
2149 /* Update SSA form here, we are called as non-pass as well. */
2150 if (number_of_loops (cfun
) > 1
2151 && loops_state_satisfies_p (LOOP_CLOSED_SSA
))
2152 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
2154 update_ssa (TODO_update_ssa
);
2157 timevar_pop (TV_ADDRESS_TAKEN
);
2162 const pass_data pass_data_update_address_taken
=
2164 GIMPLE_PASS
, /* type */
2165 "addressables", /* name */
2166 OPTGROUP_NONE
, /* optinfo_flags */
2167 TV_ADDRESS_TAKEN
, /* tv_id */
2168 PROP_ssa
, /* properties_required */
2169 0, /* properties_provided */
2170 0, /* properties_destroyed */
2171 0, /* todo_flags_start */
2172 TODO_update_address_taken
, /* todo_flags_finish */
2175 class pass_update_address_taken
: public gimple_opt_pass
2178 pass_update_address_taken (gcc::context
*ctxt
)
2179 : gimple_opt_pass (pass_data_update_address_taken
, ctxt
)
2182 /* opt_pass methods: */
2184 }; // class pass_update_address_taken
2189 make_pass_update_address_taken (gcc::context
*ctxt
)
2191 return new pass_update_address_taken (ctxt
);