gcc/
[official-gcc.git] / gcc / tree-ssa.c
blobcab627daa1534665cdca4c4c6812126942737f12
1 /* Miscellaneous SSA utility functions.
2 Copyright (C) 2001-2015 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)
9 any later version.
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/>. */
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "tm.h"
24 #include "alias.h"
25 #include "symtab.h"
26 #include "tree.h"
27 #include "fold-const.h"
28 #include "stor-layout.h"
29 #include "flags.h"
30 #include "tm_p.h"
31 #include "target.h"
32 #include "langhooks.h"
33 #include "predict.h"
34 #include "hard-reg-set.h"
35 #include "function.h"
36 #include "dominance.h"
37 #include "cfg.h"
38 #include "basic-block.h"
39 #include "gimple-pretty-print.h"
40 #include "tree-ssa-alias.h"
41 #include "internal-fn.h"
42 #include "gimple-fold.h"
43 #include "gimple-expr.h"
44 #include "gimple.h"
45 #include "gimplify.h"
46 #include "gimple-iterator.h"
47 #include "gimple-walk.h"
48 #include "gimple-ssa.h"
49 #include "tree-phinodes.h"
50 #include "ssa-iterators.h"
51 #include "stringpool.h"
52 #include "tree-ssanames.h"
53 #include "tree-ssa-loop-manip.h"
54 #include "tree-into-ssa.h"
55 #include "tree-ssa.h"
56 #include "tree-inline.h"
57 #include "tree-pass.h"
58 #include "diagnostic-core.h"
59 #include "cfgloop.h"
60 #include "cfgexpand.h"
62 /* Pointer map of variable mappings, keyed by edge. */
63 static hash_map<edge, auto_vec<edge_var_map> > *edge_var_maps;
66 /* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
68 void
69 redirect_edge_var_map_add (edge e, tree result, tree def, source_location locus)
71 edge_var_map new_node;
73 if (edge_var_maps == NULL)
74 edge_var_maps = new hash_map<edge, auto_vec<edge_var_map> >;
76 auto_vec<edge_var_map> &slot = edge_var_maps->get_or_insert (e);
77 new_node.def = def;
78 new_node.result = result;
79 new_node.locus = locus;
81 slot.safe_push (new_node);
85 /* Clear the var mappings in edge E. */
87 void
88 redirect_edge_var_map_clear (edge e)
90 if (!edge_var_maps)
91 return;
93 auto_vec<edge_var_map> *head = edge_var_maps->get (e);
95 if (head)
96 head->release ();
100 /* Duplicate the redirected var mappings in OLDE in NEWE.
102 This assumes a hash_map can have multiple edges mapping to the same
103 var_map (many to one mapping), since we don't remove the previous mappings.
106 void
107 redirect_edge_var_map_dup (edge newe, edge olde)
109 if (!edge_var_maps)
110 return;
112 auto_vec<edge_var_map> *new_head = &edge_var_maps->get_or_insert (newe);
113 auto_vec<edge_var_map> *old_head = edge_var_maps->get (olde);
114 if (!old_head)
115 return;
117 new_head->safe_splice (*old_head);
121 /* Return the variable mappings for a given edge. If there is none, return
122 NULL. */
124 vec<edge_var_map> *
125 redirect_edge_var_map_vector (edge e)
127 /* Hey, what kind of idiot would... you'd be surprised. */
128 if (!edge_var_maps)
129 return NULL;
131 auto_vec<edge_var_map> *slot = edge_var_maps->get (e);
132 if (!slot)
133 return NULL;
135 return slot;
138 /* Clear the edge variable mappings. */
140 void
141 redirect_edge_var_map_destroy (void)
143 delete edge_var_maps;
144 edge_var_maps = NULL;
148 /* Remove the corresponding arguments from the PHI nodes in E's
149 destination block and redirect it to DEST. Return redirected edge.
150 The list of removed arguments is stored in a vector accessed
151 through edge_var_maps. */
153 edge
154 ssa_redirect_edge (edge e, basic_block dest)
156 gphi_iterator gsi;
157 gphi *phi;
159 redirect_edge_var_map_clear (e);
161 /* Remove the appropriate PHI arguments in E's destination block. */
162 for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
164 tree def;
165 source_location locus ;
167 phi = gsi.phi ();
168 def = gimple_phi_arg_def (phi, e->dest_idx);
169 locus = gimple_phi_arg_location (phi, e->dest_idx);
171 if (def == NULL_TREE)
172 continue;
174 redirect_edge_var_map_add (e, gimple_phi_result (phi), def, locus);
177 e = redirect_edge_succ_nodup (e, dest);
179 return e;
183 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
184 E->dest. */
186 void
187 flush_pending_stmts (edge e)
189 gphi *phi;
190 edge_var_map *vm;
191 int i;
192 gphi_iterator gsi;
194 vec<edge_var_map> *v = redirect_edge_var_map_vector (e);
195 if (!v)
196 return;
198 for (gsi = gsi_start_phis (e->dest), i = 0;
199 !gsi_end_p (gsi) && v->iterate (i, &vm);
200 gsi_next (&gsi), i++)
202 tree def;
204 phi = gsi.phi ();
205 def = redirect_edge_var_map_def (vm);
206 add_phi_arg (phi, def, e, redirect_edge_var_map_location (vm));
209 redirect_edge_var_map_clear (e);
212 /* Replace the LHS of STMT, an assignment, either a GIMPLE_ASSIGN or a
213 GIMPLE_CALL, with NLHS, in preparation for modifying the RHS to an
214 expression with a different value.
216 This will update any annotations (say debug bind stmts) referring
217 to the original LHS, so that they use the RHS instead. This is
218 done even if NLHS and LHS are the same, for it is understood that
219 the RHS will be modified afterwards, and NLHS will not be assigned
220 an equivalent value.
222 Adjusting any non-annotation uses of the LHS, if needed, is a
223 responsibility of the caller.
225 The effect of this call should be pretty much the same as that of
226 inserting a copy of STMT before STMT, and then removing the
227 original stmt, at which time gsi_remove() would have update
228 annotations, but using this function saves all the inserting,
229 copying and removing. */
231 void
232 gimple_replace_ssa_lhs (gimple stmt, tree nlhs)
234 if (MAY_HAVE_DEBUG_STMTS)
236 tree lhs = gimple_get_lhs (stmt);
238 gcc_assert (SSA_NAME_DEF_STMT (lhs) == stmt);
240 insert_debug_temp_for_var_def (NULL, lhs);
243 gimple_set_lhs (stmt, nlhs);
247 /* Given a tree for an expression for which we might want to emit
248 locations or values in debug information (generally a variable, but
249 we might deal with other kinds of trees in the future), return the
250 tree that should be used as the variable of a DEBUG_BIND STMT or
251 VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */
253 tree
254 target_for_debug_bind (tree var)
256 if (!MAY_HAVE_DEBUG_STMTS)
257 return NULL_TREE;
259 if (TREE_CODE (var) == SSA_NAME)
261 var = SSA_NAME_VAR (var);
262 if (var == NULL_TREE)
263 return NULL_TREE;
266 if ((TREE_CODE (var) != VAR_DECL
267 || VAR_DECL_IS_VIRTUAL_OPERAND (var))
268 && TREE_CODE (var) != PARM_DECL)
269 return NULL_TREE;
271 if (DECL_HAS_VALUE_EXPR_P (var))
272 return target_for_debug_bind (DECL_VALUE_EXPR (var));
274 if (DECL_IGNORED_P (var))
275 return NULL_TREE;
277 /* var-tracking only tracks registers. */
278 if (!is_gimple_reg_type (TREE_TYPE (var)))
279 return NULL_TREE;
281 return var;
284 /* Called via walk_tree, look for SSA_NAMEs that have already been
285 released. */
287 static tree
288 find_released_ssa_name (tree *tp, int *walk_subtrees, void *data_)
290 struct walk_stmt_info *wi = (struct walk_stmt_info *) data_;
292 if (wi && wi->is_lhs)
293 return NULL_TREE;
295 if (TREE_CODE (*tp) == SSA_NAME)
297 if (SSA_NAME_IN_FREE_LIST (*tp))
298 return *tp;
300 *walk_subtrees = 0;
302 else if (IS_TYPE_OR_DECL_P (*tp))
303 *walk_subtrees = 0;
305 return NULL_TREE;
308 /* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced
309 by other DEBUG stmts, and replace uses of the DEF with the
310 newly-created debug temp. */
312 void
313 insert_debug_temp_for_var_def (gimple_stmt_iterator *gsi, tree var)
315 imm_use_iterator imm_iter;
316 use_operand_p use_p;
317 gimple stmt;
318 gimple def_stmt = NULL;
319 int usecount = 0;
320 tree value = NULL;
322 if (!MAY_HAVE_DEBUG_STMTS)
323 return;
325 /* If this name has already been registered for replacement, do nothing
326 as anything that uses this name isn't in SSA form. */
327 if (name_registered_for_update_p (var))
328 return;
330 /* Check whether there are debug stmts that reference this variable and,
331 if there are, decide whether we should use a debug temp. */
332 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, var)
334 stmt = USE_STMT (use_p);
336 if (!gimple_debug_bind_p (stmt))
337 continue;
339 if (usecount++)
340 break;
342 if (gimple_debug_bind_get_value (stmt) != var)
344 /* Count this as an additional use, so as to make sure we
345 use a temp unless VAR's definition has a SINGLE_RHS that
346 can be shared. */
347 usecount++;
348 break;
352 if (!usecount)
353 return;
355 if (gsi)
356 def_stmt = gsi_stmt (*gsi);
357 else
358 def_stmt = SSA_NAME_DEF_STMT (var);
360 /* If we didn't get an insertion point, and the stmt has already
361 been removed, we won't be able to insert the debug bind stmt, so
362 we'll have to drop debug information. */
363 if (gimple_code (def_stmt) == GIMPLE_PHI)
365 value = degenerate_phi_result (as_a <gphi *> (def_stmt));
366 if (value && walk_tree (&value, find_released_ssa_name, NULL, NULL))
367 value = NULL;
368 /* error_mark_node is what fixup_noreturn_call changes PHI arguments
369 to. */
370 else if (value == error_mark_node)
371 value = NULL;
373 else if (is_gimple_assign (def_stmt))
375 bool no_value = false;
377 if (!dom_info_available_p (CDI_DOMINATORS))
379 struct walk_stmt_info wi;
381 memset (&wi, 0, sizeof (wi));
383 /* When removing blocks without following reverse dominance
384 order, we may sometimes encounter SSA_NAMEs that have
385 already been released, referenced in other SSA_DEFs that
386 we're about to release. Consider:
388 <bb X>:
389 v_1 = foo;
391 <bb Y>:
392 w_2 = v_1 + bar;
393 # DEBUG w => w_2
395 If we deleted BB X first, propagating the value of w_2
396 won't do us any good. It's too late to recover their
397 original definition of v_1: when it was deleted, it was
398 only referenced in other DEFs, it couldn't possibly know
399 it should have been retained, and propagating every
400 single DEF just in case it might have to be propagated
401 into a DEBUG STMT would probably be too wasteful.
403 When dominator information is not readily available, we
404 check for and accept some loss of debug information. But
405 if it is available, there's no excuse for us to remove
406 blocks in the wrong order, so we don't even check for
407 dead SSA NAMEs. SSA verification shall catch any
408 errors. */
409 if ((!gsi && !gimple_bb (def_stmt))
410 || walk_gimple_op (def_stmt, find_released_ssa_name, &wi))
411 no_value = true;
414 if (!no_value)
415 value = gimple_assign_rhs_to_tree (def_stmt);
418 if (value)
420 /* If there's a single use of VAR, and VAR is the entire debug
421 expression (usecount would have been incremented again
422 otherwise), and the definition involves only constants and
423 SSA names, then we can propagate VALUE into this single use,
424 avoiding the temp.
426 We can also avoid using a temp if VALUE can be shared and
427 propagated into all uses, without generating expressions that
428 wouldn't be valid gimple RHSs.
430 Other cases that would require unsharing or non-gimple RHSs
431 are deferred to a debug temp, although we could avoid temps
432 at the expense of duplication of expressions. */
434 if (CONSTANT_CLASS_P (value)
435 || gimple_code (def_stmt) == GIMPLE_PHI
436 || (usecount == 1
437 && (!gimple_assign_single_p (def_stmt)
438 || is_gimple_min_invariant (value)))
439 || is_gimple_reg (value))
441 else
443 gdebug *def_temp;
444 tree vexpr = make_node (DEBUG_EXPR_DECL);
446 def_temp = gimple_build_debug_bind (vexpr,
447 unshare_expr (value),
448 def_stmt);
450 DECL_ARTIFICIAL (vexpr) = 1;
451 TREE_TYPE (vexpr) = TREE_TYPE (value);
452 if (DECL_P (value))
453 DECL_MODE (vexpr) = DECL_MODE (value);
454 else
455 DECL_MODE (vexpr) = TYPE_MODE (TREE_TYPE (value));
457 if (gsi)
458 gsi_insert_before (gsi, def_temp, GSI_SAME_STMT);
459 else
461 gimple_stmt_iterator ngsi = gsi_for_stmt (def_stmt);
462 gsi_insert_before (&ngsi, def_temp, GSI_SAME_STMT);
465 value = vexpr;
469 FOR_EACH_IMM_USE_STMT (stmt, imm_iter, var)
471 if (!gimple_debug_bind_p (stmt))
472 continue;
474 if (value)
476 FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
477 /* unshare_expr is not needed here. vexpr is either a
478 SINGLE_RHS, that can be safely shared, some other RHS
479 that was unshared when we found it had a single debug
480 use, or a DEBUG_EXPR_DECL, that can be safely
481 shared. */
482 SET_USE (use_p, unshare_expr (value));
483 /* If we didn't replace uses with a debug decl fold the
484 resulting expression. Otherwise we end up with invalid IL. */
485 if (TREE_CODE (value) != DEBUG_EXPR_DECL)
487 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
488 fold_stmt_inplace (&gsi);
491 else
492 gimple_debug_bind_reset_value (stmt);
494 update_stmt (stmt);
499 /* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
500 other DEBUG stmts, and replace uses of the DEF with the
501 newly-created debug temp. */
503 void
504 insert_debug_temps_for_defs (gimple_stmt_iterator *gsi)
506 gimple stmt;
507 ssa_op_iter op_iter;
508 def_operand_p def_p;
510 if (!MAY_HAVE_DEBUG_STMTS)
511 return;
513 stmt = gsi_stmt (*gsi);
515 FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF)
517 tree var = DEF_FROM_PTR (def_p);
519 if (TREE_CODE (var) != SSA_NAME)
520 continue;
522 insert_debug_temp_for_var_def (gsi, var);
526 /* Reset all debug stmts that use SSA_NAME(s) defined in STMT. */
528 void
529 reset_debug_uses (gimple stmt)
531 ssa_op_iter op_iter;
532 def_operand_p def_p;
533 imm_use_iterator imm_iter;
534 gimple use_stmt;
536 if (!MAY_HAVE_DEBUG_STMTS)
537 return;
539 FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF)
541 tree var = DEF_FROM_PTR (def_p);
543 if (TREE_CODE (var) != SSA_NAME)
544 continue;
546 FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, var)
548 if (!gimple_debug_bind_p (use_stmt))
549 continue;
551 gimple_debug_bind_reset_value (use_stmt);
552 update_stmt (use_stmt);
557 /* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
558 dominated stmts before their dominators, so that release_ssa_defs
559 stands a chance of propagating DEFs into debug bind stmts. */
561 void
562 release_defs_bitset (bitmap toremove)
564 unsigned j;
565 bitmap_iterator bi;
567 /* Performing a topological sort is probably overkill, this will
568 most likely run in slightly superlinear time, rather than the
569 pathological quadratic worst case. */
570 while (!bitmap_empty_p (toremove))
571 EXECUTE_IF_SET_IN_BITMAP (toremove, 0, j, bi)
573 bool remove_now = true;
574 tree var = ssa_name (j);
575 gimple stmt;
576 imm_use_iterator uit;
578 FOR_EACH_IMM_USE_STMT (stmt, uit, var)
580 ssa_op_iter dit;
581 def_operand_p def_p;
583 /* We can't propagate PHI nodes into debug stmts. */
584 if (gimple_code (stmt) == GIMPLE_PHI
585 || is_gimple_debug (stmt))
586 continue;
588 /* If we find another definition to remove that uses
589 the one we're looking at, defer the removal of this
590 one, so that it can be propagated into debug stmts
591 after the other is. */
592 FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, dit, SSA_OP_DEF)
594 tree odef = DEF_FROM_PTR (def_p);
596 if (bitmap_bit_p (toremove, SSA_NAME_VERSION (odef)))
598 remove_now = false;
599 break;
603 if (!remove_now)
604 BREAK_FROM_IMM_USE_STMT (uit);
607 if (remove_now)
609 gimple def = SSA_NAME_DEF_STMT (var);
610 gimple_stmt_iterator gsi = gsi_for_stmt (def);
612 if (gimple_code (def) == GIMPLE_PHI)
613 remove_phi_node (&gsi, true);
614 else
616 gsi_remove (&gsi, true);
617 release_defs (def);
620 bitmap_clear_bit (toremove, j);
625 /* Return true if SSA_NAME is malformed and mark it visited.
627 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
628 operand. */
630 static bool
631 verify_ssa_name (tree ssa_name, bool is_virtual)
633 if (TREE_CODE (ssa_name) != SSA_NAME)
635 error ("expected an SSA_NAME object");
636 return true;
639 if (SSA_NAME_IN_FREE_LIST (ssa_name))
641 error ("found an SSA_NAME that had been released into the free pool");
642 return true;
645 if (SSA_NAME_VAR (ssa_name) != NULL_TREE
646 && TREE_TYPE (ssa_name) != TREE_TYPE (SSA_NAME_VAR (ssa_name)))
648 error ("type mismatch between an SSA_NAME and its symbol");
649 return true;
652 if (is_virtual && !virtual_operand_p (ssa_name))
654 error ("found a virtual definition for a GIMPLE register");
655 return true;
658 if (is_virtual && SSA_NAME_VAR (ssa_name) != gimple_vop (cfun))
660 error ("virtual SSA name for non-VOP decl");
661 return true;
664 if (!is_virtual && virtual_operand_p (ssa_name))
666 error ("found a real definition for a non-register");
667 return true;
670 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name)
671 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name)))
673 error ("found a default name with a non-empty defining statement");
674 return true;
677 return false;
681 /* Return true if the definition of SSA_NAME at block BB is malformed.
683 STMT is the statement where SSA_NAME is created.
685 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
686 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
687 it means that the block in that array slot contains the
688 definition of SSA_NAME.
690 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
692 static bool
693 verify_def (basic_block bb, basic_block *definition_block, tree ssa_name,
694 gimple stmt, bool is_virtual)
696 if (verify_ssa_name (ssa_name, is_virtual))
697 goto err;
699 if (SSA_NAME_VAR (ssa_name)
700 && TREE_CODE (SSA_NAME_VAR (ssa_name)) == RESULT_DECL
701 && DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name)))
703 error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
704 goto err;
707 if (definition_block[SSA_NAME_VERSION (ssa_name)])
709 error ("SSA_NAME created in two different blocks %i and %i",
710 definition_block[SSA_NAME_VERSION (ssa_name)]->index, bb->index);
711 goto err;
714 definition_block[SSA_NAME_VERSION (ssa_name)] = bb;
716 if (SSA_NAME_DEF_STMT (ssa_name) != stmt)
718 error ("SSA_NAME_DEF_STMT is wrong");
719 fprintf (stderr, "Expected definition statement:\n");
720 print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (ssa_name), 4, TDF_VOPS);
721 fprintf (stderr, "\nActual definition statement:\n");
722 print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
723 goto err;
726 return false;
728 err:
729 fprintf (stderr, "while verifying SSA_NAME ");
730 print_generic_expr (stderr, ssa_name, 0);
731 fprintf (stderr, " in statement\n");
732 print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
734 return true;
738 /* Return true if the use of SSA_NAME at statement STMT in block BB is
739 malformed.
741 DEF_BB is the block where SSA_NAME was found to be created.
743 IDOM contains immediate dominator information for the flowgraph.
745 CHECK_ABNORMAL is true if the caller wants to check whether this use
746 is flowing through an abnormal edge (only used when checking PHI
747 arguments).
749 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
750 that are defined before STMT in basic block BB. */
752 static bool
753 verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
754 gimple stmt, bool check_abnormal, bitmap names_defined_in_bb)
756 bool err = false;
757 tree ssa_name = USE_FROM_PTR (use_p);
759 if (!TREE_VISITED (ssa_name))
760 if (verify_imm_links (stderr, ssa_name))
761 err = true;
763 TREE_VISITED (ssa_name) = 1;
765 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name))
766 && SSA_NAME_IS_DEFAULT_DEF (ssa_name))
767 ; /* Default definitions have empty statements. Nothing to do. */
768 else if (!def_bb)
770 error ("missing definition");
771 err = true;
773 else if (bb != def_bb
774 && !dominated_by_p (CDI_DOMINATORS, bb, def_bb))
776 error ("definition in block %i does not dominate use in block %i",
777 def_bb->index, bb->index);
778 err = true;
780 else if (bb == def_bb
781 && names_defined_in_bb != NULL
782 && !bitmap_bit_p (names_defined_in_bb, SSA_NAME_VERSION (ssa_name)))
784 error ("definition in block %i follows the use", def_bb->index);
785 err = true;
788 if (check_abnormal
789 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name))
791 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
792 err = true;
795 /* Make sure the use is in an appropriate list by checking the previous
796 element to make sure it's the same. */
797 if (use_p->prev == NULL)
799 error ("no immediate_use list");
800 err = true;
802 else
804 tree listvar;
805 if (use_p->prev->use == NULL)
806 listvar = use_p->prev->loc.ssa_name;
807 else
808 listvar = USE_FROM_PTR (use_p->prev);
809 if (listvar != ssa_name)
811 error ("wrong immediate use list");
812 err = true;
816 if (err)
818 fprintf (stderr, "for SSA_NAME: ");
819 print_generic_expr (stderr, ssa_name, TDF_VOPS);
820 fprintf (stderr, " in statement:\n");
821 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
824 return err;
828 /* Return true if any of the arguments for PHI node PHI at block BB is
829 malformed.
831 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
832 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
833 it means that the block in that array slot contains the
834 definition of SSA_NAME. */
836 static bool
837 verify_phi_args (gphi *phi, basic_block bb, basic_block *definition_block)
839 edge e;
840 bool err = false;
841 size_t i, phi_num_args = gimple_phi_num_args (phi);
843 if (EDGE_COUNT (bb->preds) != phi_num_args)
845 error ("incoming edge count does not match number of PHI arguments");
846 err = true;
847 goto error;
850 for (i = 0; i < phi_num_args; i++)
852 use_operand_p op_p = gimple_phi_arg_imm_use_ptr (phi, i);
853 tree op = USE_FROM_PTR (op_p);
855 e = EDGE_PRED (bb, i);
857 if (op == NULL_TREE)
859 error ("PHI argument is missing for edge %d->%d",
860 e->src->index,
861 e->dest->index);
862 err = true;
863 goto error;
866 if (TREE_CODE (op) != SSA_NAME && !is_gimple_min_invariant (op))
868 error ("PHI argument is not SSA_NAME, or invariant");
869 err = true;
872 if (TREE_CODE (op) == SSA_NAME)
874 err = verify_ssa_name (op, virtual_operand_p (gimple_phi_result (phi)));
875 err |= verify_use (e->src, definition_block[SSA_NAME_VERSION (op)],
876 op_p, phi, e->flags & EDGE_ABNORMAL, NULL);
879 if (TREE_CODE (op) == ADDR_EXPR)
881 tree base = TREE_OPERAND (op, 0);
882 while (handled_component_p (base))
883 base = TREE_OPERAND (base, 0);
884 if ((TREE_CODE (base) == VAR_DECL
885 || TREE_CODE (base) == PARM_DECL
886 || TREE_CODE (base) == RESULT_DECL)
887 && !TREE_ADDRESSABLE (base))
889 error ("address taken, but ADDRESSABLE bit not set");
890 err = true;
894 if (e->dest != bb)
896 error ("wrong edge %d->%d for PHI argument",
897 e->src->index, e->dest->index);
898 err = true;
901 if (err)
903 fprintf (stderr, "PHI argument\n");
904 print_generic_stmt (stderr, op, TDF_VOPS);
905 goto error;
909 error:
910 if (err)
912 fprintf (stderr, "for PHI node\n");
913 print_gimple_stmt (stderr, phi, 0, TDF_VOPS|TDF_MEMSYMS);
917 return err;
921 /* Verify common invariants in the SSA web.
922 TODO: verify the variable annotations. */
924 DEBUG_FUNCTION void
925 verify_ssa (bool check_modified_stmt, bool check_ssa_operands)
927 size_t i;
928 basic_block bb;
929 basic_block *definition_block = XCNEWVEC (basic_block, num_ssa_names);
930 ssa_op_iter iter;
931 tree op;
932 enum dom_state orig_dom_state = dom_info_state (CDI_DOMINATORS);
933 bitmap names_defined_in_bb = BITMAP_ALLOC (NULL);
935 gcc_assert (!need_ssa_update_p (cfun));
937 timevar_push (TV_TREE_SSA_VERIFY);
939 /* Keep track of SSA names present in the IL. */
940 for (i = 1; i < num_ssa_names; i++)
942 tree name = ssa_name (i);
943 if (name)
945 gimple stmt;
946 TREE_VISITED (name) = 0;
948 verify_ssa_name (name, virtual_operand_p (name));
950 stmt = SSA_NAME_DEF_STMT (name);
951 if (!gimple_nop_p (stmt))
953 basic_block bb = gimple_bb (stmt);
954 if (verify_def (bb, definition_block,
955 name, stmt, virtual_operand_p (name)))
956 goto err;
961 calculate_dominance_info (CDI_DOMINATORS);
963 /* Now verify all the uses and make sure they agree with the definitions
964 found in the previous pass. */
965 FOR_EACH_BB_FN (bb, cfun)
967 edge e;
968 edge_iterator ei;
970 /* Make sure that all edges have a clear 'aux' field. */
971 FOR_EACH_EDGE (e, ei, bb->preds)
973 if (e->aux)
975 error ("AUX pointer initialized for edge %d->%d", e->src->index,
976 e->dest->index);
977 goto err;
981 /* Verify the arguments for every PHI node in the block. */
982 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
984 gphi *phi = gsi.phi ();
985 if (verify_phi_args (phi, bb, definition_block))
986 goto err;
988 bitmap_set_bit (names_defined_in_bb,
989 SSA_NAME_VERSION (gimple_phi_result (phi)));
992 /* Now verify all the uses and vuses in every statement of the block. */
993 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
994 gsi_next (&gsi))
996 gimple stmt = gsi_stmt (gsi);
997 use_operand_p use_p;
999 if (check_modified_stmt && gimple_modified_p (stmt))
1001 error ("stmt (%p) marked modified after optimization pass: ",
1002 (void *)stmt);
1003 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
1004 goto err;
1007 if (check_ssa_operands && verify_ssa_operands (cfun, stmt))
1009 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
1010 goto err;
1013 if (gimple_debug_bind_p (stmt)
1014 && !gimple_debug_bind_has_value_p (stmt))
1015 continue;
1017 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE|SSA_OP_VUSE)
1019 op = USE_FROM_PTR (use_p);
1020 if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
1021 use_p, stmt, false, names_defined_in_bb))
1022 goto err;
1025 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_DEFS)
1027 if (SSA_NAME_DEF_STMT (op) != stmt)
1029 error ("SSA_NAME_DEF_STMT is wrong");
1030 fprintf (stderr, "Expected definition statement:\n");
1031 print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
1032 fprintf (stderr, "\nActual definition statement:\n");
1033 print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (op),
1034 4, TDF_VOPS);
1035 goto err;
1037 bitmap_set_bit (names_defined_in_bb, SSA_NAME_VERSION (op));
1041 bitmap_clear (names_defined_in_bb);
1044 free (definition_block);
1046 /* Restore the dominance information to its prior known state, so
1047 that we do not perturb the compiler's subsequent behavior. */
1048 if (orig_dom_state == DOM_NONE)
1049 free_dominance_info (CDI_DOMINATORS);
1050 else
1051 set_dom_info_availability (CDI_DOMINATORS, orig_dom_state);
1053 BITMAP_FREE (names_defined_in_bb);
1054 timevar_pop (TV_TREE_SSA_VERIFY);
1055 return;
1057 err:
1058 internal_error ("verify_ssa failed");
1062 /* Initialize global DFA and SSA structures. */
1064 void
1065 init_tree_ssa (struct function *fn)
1067 fn->gimple_df = ggc_cleared_alloc<gimple_df> ();
1068 fn->gimple_df->default_defs = hash_table<ssa_name_hasher>::create_ggc (20);
1069 pt_solution_reset (&fn->gimple_df->escaped);
1070 init_ssanames (fn, 0);
1073 /* Do the actions required to initialize internal data structures used
1074 in tree-ssa optimization passes. */
1076 static unsigned int
1077 execute_init_datastructures (void)
1079 /* Allocate hash tables, arrays and other structures. */
1080 gcc_assert (!cfun->gimple_df);
1081 init_tree_ssa (cfun);
1082 return 0;
1085 namespace {
1087 const pass_data pass_data_init_datastructures =
1089 GIMPLE_PASS, /* type */
1090 "*init_datastructures", /* name */
1091 OPTGROUP_NONE, /* optinfo_flags */
1092 TV_NONE, /* tv_id */
1093 PROP_cfg, /* properties_required */
1094 0, /* properties_provided */
1095 0, /* properties_destroyed */
1096 0, /* todo_flags_start */
1097 0, /* todo_flags_finish */
1100 class pass_init_datastructures : public gimple_opt_pass
1102 public:
1103 pass_init_datastructures (gcc::context *ctxt)
1104 : gimple_opt_pass (pass_data_init_datastructures, ctxt)
1107 /* opt_pass methods: */
1108 virtual bool gate (function *fun)
1110 /* Do nothing for funcions that was produced already in SSA form. */
1111 return !(fun->curr_properties & PROP_ssa);
1114 virtual unsigned int execute (function *)
1116 return execute_init_datastructures ();
1119 }; // class pass_init_datastructures
1121 } // anon namespace
1123 gimple_opt_pass *
1124 make_pass_init_datastructures (gcc::context *ctxt)
1126 return new pass_init_datastructures (ctxt);
1129 /* Deallocate memory associated with SSA data structures for FNDECL. */
1131 void
1132 delete_tree_ssa (void)
1134 fini_ssanames ();
1136 /* We no longer maintain the SSA operand cache at this point. */
1137 if (ssa_operands_active (cfun))
1138 fini_ssa_operands (cfun);
1140 cfun->gimple_df->default_defs->empty ();
1141 cfun->gimple_df->default_defs = NULL;
1142 pt_solution_reset (&cfun->gimple_df->escaped);
1143 if (cfun->gimple_df->decls_to_pointers != NULL)
1144 delete cfun->gimple_df->decls_to_pointers;
1145 cfun->gimple_df->decls_to_pointers = NULL;
1146 cfun->gimple_df->modified_noreturn_calls = NULL;
1147 cfun->gimple_df = NULL;
1149 /* We no longer need the edge variable maps. */
1150 redirect_edge_var_map_destroy ();
1153 /* Return true if EXPR is a useless type conversion, otherwise return
1154 false. */
1156 bool
1157 tree_ssa_useless_type_conversion (tree expr)
1159 /* If we have an assignment that merely uses a NOP_EXPR to change
1160 the top of the RHS to the type of the LHS and the type conversion
1161 is "safe", then strip away the type conversion so that we can
1162 enter LHS = RHS into the const_and_copies table. */
1163 if (CONVERT_EXPR_P (expr)
1164 || TREE_CODE (expr) == VIEW_CONVERT_EXPR
1165 || TREE_CODE (expr) == NON_LVALUE_EXPR)
1166 return useless_type_conversion_p
1167 (TREE_TYPE (expr),
1168 TREE_TYPE (TREE_OPERAND (expr, 0)));
1170 return false;
1173 /* Strip conversions from EXP according to
1174 tree_ssa_useless_type_conversion and return the resulting
1175 expression. */
1177 tree
1178 tree_ssa_strip_useless_type_conversions (tree exp)
1180 while (tree_ssa_useless_type_conversion (exp))
1181 exp = TREE_OPERAND (exp, 0);
1182 return exp;
1186 /* Return true if T, an SSA_NAME, has an undefined value. PARTIAL is what
1187 should be returned if the value is only partially undefined. */
1189 bool
1190 ssa_undefined_value_p (tree t, bool partial)
1192 gimple def_stmt;
1193 tree var = SSA_NAME_VAR (t);
1195 if (!var)
1197 /* Parameters get their initial value from the function entry. */
1198 else if (TREE_CODE (var) == PARM_DECL)
1199 return false;
1200 /* When returning by reference the return address is actually a hidden
1201 parameter. */
1202 else if (TREE_CODE (var) == RESULT_DECL && DECL_BY_REFERENCE (var))
1203 return false;
1204 /* Hard register variables get their initial value from the ether. */
1205 else if (TREE_CODE (var) == VAR_DECL && DECL_HARD_REGISTER (var))
1206 return false;
1208 /* The value is undefined iff its definition statement is empty. */
1209 def_stmt = SSA_NAME_DEF_STMT (t);
1210 if (gimple_nop_p (def_stmt))
1211 return true;
1213 /* Check if the complex was not only partially defined. */
1214 if (partial && is_gimple_assign (def_stmt)
1215 && gimple_assign_rhs_code (def_stmt) == COMPLEX_EXPR)
1217 tree rhs1, rhs2;
1219 rhs1 = gimple_assign_rhs1 (def_stmt);
1220 rhs2 = gimple_assign_rhs2 (def_stmt);
1221 return (TREE_CODE (rhs1) == SSA_NAME && ssa_undefined_value_p (rhs1))
1222 || (TREE_CODE (rhs2) == SSA_NAME && ssa_undefined_value_p (rhs2));
1224 return false;
1228 /* If necessary, rewrite the base of the reference tree *TP from
1229 a MEM_REF to a plain or converted symbol. */
1231 static void
1232 maybe_rewrite_mem_ref_base (tree *tp, bitmap suitable_for_renaming)
1234 tree sym;
1236 while (handled_component_p (*tp))
1237 tp = &TREE_OPERAND (*tp, 0);
1238 if (TREE_CODE (*tp) == MEM_REF
1239 && TREE_CODE (TREE_OPERAND (*tp, 0)) == ADDR_EXPR
1240 && (sym = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0))
1241 && DECL_P (sym)
1242 && !TREE_ADDRESSABLE (sym)
1243 && bitmap_bit_p (suitable_for_renaming, DECL_UID (sym)))
1245 if (TREE_CODE (TREE_TYPE (sym)) == VECTOR_TYPE
1246 && useless_type_conversion_p (TREE_TYPE (*tp),
1247 TREE_TYPE (TREE_TYPE (sym)))
1248 && multiple_of_p (sizetype, TREE_OPERAND (*tp, 1),
1249 TYPE_SIZE_UNIT (TREE_TYPE (*tp))))
1251 *tp = build3 (BIT_FIELD_REF, TREE_TYPE (*tp), sym,
1252 TYPE_SIZE (TREE_TYPE (*tp)),
1253 int_const_binop (MULT_EXPR,
1254 bitsize_int (BITS_PER_UNIT),
1255 TREE_OPERAND (*tp, 1)));
1257 else if (TREE_CODE (TREE_TYPE (sym)) == COMPLEX_TYPE
1258 && useless_type_conversion_p (TREE_TYPE (*tp),
1259 TREE_TYPE (TREE_TYPE (sym))))
1261 *tp = build1 (integer_zerop (TREE_OPERAND (*tp, 1))
1262 ? REALPART_EXPR : IMAGPART_EXPR,
1263 TREE_TYPE (*tp), sym);
1265 else if (integer_zerop (TREE_OPERAND (*tp, 1)))
1267 if (!useless_type_conversion_p (TREE_TYPE (*tp),
1268 TREE_TYPE (sym)))
1269 *tp = build1 (VIEW_CONVERT_EXPR,
1270 TREE_TYPE (*tp), sym);
1271 else
1272 *tp = sym;
1277 /* For a tree REF return its base if it is the base of a MEM_REF
1278 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1280 static tree
1281 non_rewritable_mem_ref_base (tree ref)
1283 tree base = ref;
1285 /* A plain decl does not need it set. */
1286 if (DECL_P (ref))
1287 return NULL_TREE;
1289 while (handled_component_p (base))
1290 base = TREE_OPERAND (base, 0);
1292 /* But watch out for MEM_REFs we cannot lower to a
1293 VIEW_CONVERT_EXPR or a BIT_FIELD_REF. */
1294 if (TREE_CODE (base) == MEM_REF
1295 && TREE_CODE (TREE_OPERAND (base, 0)) == ADDR_EXPR)
1297 tree decl = TREE_OPERAND (TREE_OPERAND (base, 0), 0);
1298 if ((TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE
1299 || TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE)
1300 && useless_type_conversion_p (TREE_TYPE (base),
1301 TREE_TYPE (TREE_TYPE (decl)))
1302 && wi::fits_uhwi_p (mem_ref_offset (base))
1303 && wi::gtu_p (wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl))),
1304 mem_ref_offset (base))
1305 && multiple_of_p (sizetype, TREE_OPERAND (base, 1),
1306 TYPE_SIZE_UNIT (TREE_TYPE (base))))
1307 return NULL_TREE;
1308 if (DECL_P (decl)
1309 && (!integer_zerop (TREE_OPERAND (base, 1))
1310 || (DECL_SIZE (decl)
1311 != TYPE_SIZE (TREE_TYPE (base)))
1312 || TREE_THIS_VOLATILE (decl) != TREE_THIS_VOLATILE (base)))
1313 return decl;
1316 return NULL_TREE;
1319 /* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
1320 Otherwise return true. */
1322 static bool
1323 non_rewritable_lvalue_p (tree lhs)
1325 /* A plain decl is always rewritable. */
1326 if (DECL_P (lhs))
1327 return false;
1329 /* We can re-write REALPART_EXPR and IMAGPART_EXPR sets in
1330 a reasonably efficient manner... */
1331 if ((TREE_CODE (lhs) == REALPART_EXPR
1332 || TREE_CODE (lhs) == IMAGPART_EXPR)
1333 && DECL_P (TREE_OPERAND (lhs, 0)))
1334 return false;
1336 /* A decl that is wrapped inside a MEM-REF that covers
1337 it full is also rewritable.
1338 ??? The following could be relaxed allowing component
1339 references that do not change the access size. */
1340 if (TREE_CODE (lhs) == MEM_REF
1341 && TREE_CODE (TREE_OPERAND (lhs, 0)) == ADDR_EXPR
1342 && integer_zerop (TREE_OPERAND (lhs, 1)))
1344 tree decl = TREE_OPERAND (TREE_OPERAND (lhs, 0), 0);
1345 if (DECL_P (decl)
1346 && DECL_SIZE (decl) == TYPE_SIZE (TREE_TYPE (lhs))
1347 && (TREE_THIS_VOLATILE (decl) == TREE_THIS_VOLATILE (lhs)))
1348 return false;
1351 return true;
1354 /* When possible, clear TREE_ADDRESSABLE bit or set DECL_GIMPLE_REG_P bit and
1355 mark the variable VAR for conversion into SSA. Return true when updating
1356 stmts is required. */
1358 static void
1359 maybe_optimize_var (tree var, bitmap addresses_taken, bitmap not_reg_needs,
1360 bitmap suitable_for_renaming)
1362 /* Global Variables, result decls cannot be changed. */
1363 if (is_global_var (var)
1364 || TREE_CODE (var) == RESULT_DECL
1365 || bitmap_bit_p (addresses_taken, DECL_UID (var)))
1366 return;
1368 if (TREE_ADDRESSABLE (var)
1369 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1370 a non-register. Otherwise we are confused and forget to
1371 add virtual operands for it. */
1372 && (!is_gimple_reg_type (TREE_TYPE (var))
1373 || TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE
1374 || TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
1375 || !bitmap_bit_p (not_reg_needs, DECL_UID (var))))
1377 TREE_ADDRESSABLE (var) = 0;
1378 if (is_gimple_reg (var))
1379 bitmap_set_bit (suitable_for_renaming, DECL_UID (var));
1380 if (dump_file)
1382 fprintf (dump_file, "No longer having address taken: ");
1383 print_generic_expr (dump_file, var, 0);
1384 fprintf (dump_file, "\n");
1388 if (!DECL_GIMPLE_REG_P (var)
1389 && !bitmap_bit_p (not_reg_needs, DECL_UID (var))
1390 && (TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
1391 || TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE)
1392 && !TREE_THIS_VOLATILE (var)
1393 && (TREE_CODE (var) != VAR_DECL || !DECL_HARD_REGISTER (var)))
1395 DECL_GIMPLE_REG_P (var) = 1;
1396 bitmap_set_bit (suitable_for_renaming, DECL_UID (var));
1397 if (dump_file)
1399 fprintf (dump_file, "Now a gimple register: ");
1400 print_generic_expr (dump_file, var, 0);
1401 fprintf (dump_file, "\n");
1406 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1408 void
1409 execute_update_addresses_taken (void)
1411 basic_block bb;
1412 bitmap addresses_taken = BITMAP_ALLOC (NULL);
1413 bitmap not_reg_needs = BITMAP_ALLOC (NULL);
1414 bitmap suitable_for_renaming = BITMAP_ALLOC (NULL);
1415 tree var;
1416 unsigned i;
1418 timevar_push (TV_ADDRESS_TAKEN);
1420 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1421 the function body. */
1422 FOR_EACH_BB_FN (bb, cfun)
1424 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
1425 gsi_next (&gsi))
1427 gimple stmt = gsi_stmt (gsi);
1428 enum gimple_code code = gimple_code (stmt);
1429 tree decl;
1431 /* Note all addresses taken by the stmt. */
1432 gimple_ior_addresses_taken (addresses_taken, stmt);
1434 /* If we have a call or an assignment, see if the lhs contains
1435 a local decl that requires not to be a gimple register. */
1436 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
1438 tree lhs = gimple_get_lhs (stmt);
1439 if (lhs
1440 && TREE_CODE (lhs) != SSA_NAME
1441 && non_rewritable_lvalue_p (lhs))
1443 decl = get_base_address (lhs);
1444 if (DECL_P (decl))
1445 bitmap_set_bit (not_reg_needs, DECL_UID (decl));
1449 if (gimple_assign_single_p (stmt))
1451 tree rhs = gimple_assign_rhs1 (stmt);
1452 if ((decl = non_rewritable_mem_ref_base (rhs)))
1453 bitmap_set_bit (not_reg_needs, DECL_UID (decl));
1456 else if (code == GIMPLE_CALL)
1458 for (i = 0; i < gimple_call_num_args (stmt); ++i)
1460 tree arg = gimple_call_arg (stmt, i);
1461 if ((decl = non_rewritable_mem_ref_base (arg)))
1462 bitmap_set_bit (not_reg_needs, DECL_UID (decl));
1466 else if (code == GIMPLE_ASM)
1468 gasm *asm_stmt = as_a <gasm *> (stmt);
1469 for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i)
1471 tree link = gimple_asm_output_op (asm_stmt, i);
1472 tree lhs = TREE_VALUE (link);
1473 if (TREE_CODE (lhs) != SSA_NAME)
1475 decl = get_base_address (lhs);
1476 if (DECL_P (decl)
1477 && (non_rewritable_lvalue_p (lhs)
1478 /* We cannot move required conversions from
1479 the lhs to the rhs in asm statements, so
1480 require we do not need any. */
1481 || !useless_type_conversion_p
1482 (TREE_TYPE (lhs), TREE_TYPE (decl))))
1483 bitmap_set_bit (not_reg_needs, DECL_UID (decl));
1486 for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i)
1488 tree link = gimple_asm_input_op (asm_stmt, i);
1489 if ((decl = non_rewritable_mem_ref_base (TREE_VALUE (link))))
1490 bitmap_set_bit (not_reg_needs, DECL_UID (decl));
1495 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
1496 gsi_next (&gsi))
1498 size_t i;
1499 gphi *phi = gsi.phi ();
1501 for (i = 0; i < gimple_phi_num_args (phi); i++)
1503 tree op = PHI_ARG_DEF (phi, i), var;
1504 if (TREE_CODE (op) == ADDR_EXPR
1505 && (var = get_base_address (TREE_OPERAND (op, 0))) != NULL
1506 && DECL_P (var))
1507 bitmap_set_bit (addresses_taken, DECL_UID (var));
1512 /* We cannot iterate over all referenced vars because that can contain
1513 unused vars from BLOCK trees, which causes code generation differences
1514 for -g vs. -g0. */
1515 for (var = DECL_ARGUMENTS (cfun->decl); var; var = DECL_CHAIN (var))
1516 maybe_optimize_var (var, addresses_taken, not_reg_needs,
1517 suitable_for_renaming);
1519 FOR_EACH_VEC_SAFE_ELT (cfun->local_decls, i, var)
1520 maybe_optimize_var (var, addresses_taken, not_reg_needs,
1521 suitable_for_renaming);
1523 /* Operand caches need to be recomputed for operands referencing the updated
1524 variables and operands need to be rewritten to expose bare symbols. */
1525 if (!bitmap_empty_p (suitable_for_renaming))
1527 FOR_EACH_BB_FN (bb, cfun)
1528 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
1530 gimple stmt = gsi_stmt (gsi);
1532 /* Re-write TARGET_MEM_REFs of symbols we want to
1533 rewrite into SSA form. */
1534 if (gimple_assign_single_p (stmt))
1536 tree lhs = gimple_assign_lhs (stmt);
1537 tree rhs, *rhsp = gimple_assign_rhs1_ptr (stmt);
1538 tree sym;
1540 /* Rewrite LHS IMAG/REALPART_EXPR similar to
1541 gimplify_modify_expr_complex_part. */
1542 if ((TREE_CODE (lhs) == IMAGPART_EXPR
1543 || TREE_CODE (lhs) == REALPART_EXPR)
1544 && DECL_P (TREE_OPERAND (lhs, 0))
1545 && bitmap_bit_p (suitable_for_renaming,
1546 DECL_UID (TREE_OPERAND (lhs, 0))))
1548 tree other = make_ssa_name (TREE_TYPE (lhs));
1549 tree lrhs = build1 (TREE_CODE (lhs) == IMAGPART_EXPR
1550 ? REALPART_EXPR : IMAGPART_EXPR,
1551 TREE_TYPE (other),
1552 TREE_OPERAND (lhs, 0));
1553 gimple load = gimple_build_assign (other, lrhs);
1554 location_t loc = gimple_location (stmt);
1555 gimple_set_location (load, loc);
1556 gimple_set_vuse (load, gimple_vuse (stmt));
1557 gsi_insert_before (&gsi, load, GSI_SAME_STMT);
1558 gimple_assign_set_lhs (stmt, TREE_OPERAND (lhs, 0));
1559 gimple_assign_set_rhs_with_ops
1560 (&gsi, COMPLEX_EXPR,
1561 TREE_CODE (lhs) == IMAGPART_EXPR
1562 ? other : gimple_assign_rhs1 (stmt),
1563 TREE_CODE (lhs) == IMAGPART_EXPR
1564 ? gimple_assign_rhs1 (stmt) : other, NULL_TREE);
1565 stmt = gsi_stmt (gsi);
1566 unlink_stmt_vdef (stmt);
1567 update_stmt (stmt);
1568 continue;
1571 /* We shouldn't have any fancy wrapping of
1572 component-refs on the LHS, but look through
1573 VIEW_CONVERT_EXPRs as that is easy. */
1574 while (TREE_CODE (lhs) == VIEW_CONVERT_EXPR)
1575 lhs = TREE_OPERAND (lhs, 0);
1576 if (TREE_CODE (lhs) == MEM_REF
1577 && TREE_CODE (TREE_OPERAND (lhs, 0)) == ADDR_EXPR
1578 && integer_zerop (TREE_OPERAND (lhs, 1))
1579 && (sym = TREE_OPERAND (TREE_OPERAND (lhs, 0), 0))
1580 && DECL_P (sym)
1581 && !TREE_ADDRESSABLE (sym)
1582 && bitmap_bit_p (suitable_for_renaming, DECL_UID (sym)))
1583 lhs = sym;
1584 else
1585 lhs = gimple_assign_lhs (stmt);
1587 /* Rewrite the RHS and make sure the resulting assignment
1588 is validly typed. */
1589 maybe_rewrite_mem_ref_base (rhsp, suitable_for_renaming);
1590 rhs = gimple_assign_rhs1 (stmt);
1591 if (gimple_assign_lhs (stmt) != lhs
1592 && !useless_type_conversion_p (TREE_TYPE (lhs),
1593 TREE_TYPE (rhs)))
1594 rhs = fold_build1 (VIEW_CONVERT_EXPR,
1595 TREE_TYPE (lhs), rhs);
1597 if (gimple_assign_lhs (stmt) != lhs)
1598 gimple_assign_set_lhs (stmt, lhs);
1600 if (gimple_assign_rhs1 (stmt) != rhs)
1602 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
1603 gimple_assign_set_rhs_from_tree (&gsi, rhs);
1607 else if (gimple_code (stmt) == GIMPLE_CALL)
1609 unsigned i;
1610 for (i = 0; i < gimple_call_num_args (stmt); ++i)
1612 tree *argp = gimple_call_arg_ptr (stmt, i);
1613 maybe_rewrite_mem_ref_base (argp, suitable_for_renaming);
1617 else if (gimple_code (stmt) == GIMPLE_ASM)
1619 gasm *asm_stmt = as_a <gasm *> (stmt);
1620 unsigned i;
1621 for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i)
1623 tree link = gimple_asm_output_op (asm_stmt, i);
1624 maybe_rewrite_mem_ref_base (&TREE_VALUE (link),
1625 suitable_for_renaming);
1627 for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i)
1629 tree link = gimple_asm_input_op (asm_stmt, i);
1630 maybe_rewrite_mem_ref_base (&TREE_VALUE (link),
1631 suitable_for_renaming);
1635 else if (gimple_debug_bind_p (stmt)
1636 && gimple_debug_bind_has_value_p (stmt))
1638 tree *valuep = gimple_debug_bind_get_value_ptr (stmt);
1639 tree decl;
1640 maybe_rewrite_mem_ref_base (valuep, suitable_for_renaming);
1641 decl = non_rewritable_mem_ref_base (*valuep);
1642 if (decl
1643 && bitmap_bit_p (suitable_for_renaming, DECL_UID (decl)))
1644 gimple_debug_bind_reset_value (stmt);
1647 if (gimple_references_memory_p (stmt)
1648 || is_gimple_debug (stmt))
1649 update_stmt (stmt);
1651 gsi_next (&gsi);
1654 /* Update SSA form here, we are called as non-pass as well. */
1655 if (number_of_loops (cfun) > 1
1656 && loops_state_satisfies_p (LOOP_CLOSED_SSA))
1657 rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa);
1658 else
1659 update_ssa (TODO_update_ssa);
1662 BITMAP_FREE (not_reg_needs);
1663 BITMAP_FREE (addresses_taken);
1664 BITMAP_FREE (suitable_for_renaming);
1665 timevar_pop (TV_ADDRESS_TAKEN);
1668 namespace {
1670 const pass_data pass_data_update_address_taken =
1672 GIMPLE_PASS, /* type */
1673 "addressables", /* name */
1674 OPTGROUP_NONE, /* optinfo_flags */
1675 TV_ADDRESS_TAKEN, /* tv_id */
1676 PROP_ssa, /* properties_required */
1677 0, /* properties_provided */
1678 0, /* properties_destroyed */
1679 0, /* todo_flags_start */
1680 TODO_update_address_taken, /* todo_flags_finish */
1683 class pass_update_address_taken : public gimple_opt_pass
1685 public:
1686 pass_update_address_taken (gcc::context *ctxt)
1687 : gimple_opt_pass (pass_data_update_address_taken, ctxt)
1690 /* opt_pass methods: */
1692 }; // class pass_update_address_taken
1694 } // anon namespace
1696 gimple_opt_pass *
1697 make_pass_update_address_taken (gcc::context *ctxt)
1699 return new pass_update_address_taken (ctxt);