1/* Miscellaneous SSA utility functions.
2 Copyright (C) 2001-2017 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 3, or (at your option)
9any later version.
10
11GCC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#include "config.h"
21#include "system.h"
22#include "coretypes.h"
23#include "backend.h"
24#include "tree.h"
25#include "gimple.h"
26#include "cfghooks.h"
27#include "tree-pass.h"
28#include "ssa.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"
34#include "gimplify.h"
35#include "gimple-iterator.h"
36#include "gimple-walk.h"
37#include "tree-ssa-loop-manip.h"
38#include "tree-into-ssa.h"
39#include "tree-ssa.h"
40#include "cfgloop.h"
41#include "cfgexpand.h"
42#include "tree-cfg.h"
43#include "tree-dfa.h"
44#include "stringpool.h"
45#include "attribs.h"
46#include "asan.h"
47
48/* Pointer map of variable mappings, keyed by edge. */
49static hash_map<edge, auto_vec<edge_var_map> > *edge_var_maps;
50
51
52/* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
53
54void
55redirect_edge_var_map_add (edge e, tree result, tree def, source_location locus)
56{
57 edge_var_map new_node;
58
59 if (edge_var_maps == NULL)
60 edge_var_maps = new hash_map<edge, auto_vec<edge_var_map> >;
61
62 auto_vec<edge_var_map> &slot = edge_var_maps->get_or_insert (e);
63 new_node.def = def;
64 new_node.result = result;
65 new_node.locus = locus;
66
67 slot.safe_push (new_node);
68}
69
70
71/* Clear the var mappings in edge E. */
72
73void
74redirect_edge_var_map_clear (edge e)
75{
76 if (!edge_var_maps)
77 return;
78
79 auto_vec<edge_var_map> *head = edge_var_maps->get (e);
80
81 if (head)
82 head->release ();
83}
84
85
86/* Duplicate the redirected var mappings in OLDE in NEWE.
87
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.
90 */
91
92void
93redirect_edge_var_map_dup (edge newe, edge olde)
94{
95 if (!edge_var_maps)
96 return;
97
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);
100 if (!old_head)
101 return;
102
103 new_head->safe_splice (*old_head);
104}
105
106
107/* Return the variable mappings for a given edge. If there is none, return
108 NULL. */
109
110vec<edge_var_map> *
111redirect_edge_var_map_vector (edge e)
112{
113 /* Hey, what kind of idiot would... you'd be surprised. */
114 if (!edge_var_maps)
115 return NULL;
116
117 auto_vec<edge_var_map> *slot = edge_var_maps->get (e);
118 if (!slot)
119 return NULL;
120
121 return slot;
122}
123
124/* Clear the edge variable mappings. */
125
126void
127redirect_edge_var_map_empty (void)
128{
129 if (edge_var_maps)
130 edge_var_maps->empty ();
131}
132
133
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. */
138
139edge
140ssa_redirect_edge (edge e, basic_block dest)
141{
142 gphi_iterator gsi;
143 gphi *phi;
144
145 redirect_edge_var_map_clear (e);
146
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))
152 {
153 tree def;
154 source_location locus ;
155
156 phi = gsi.phi ();
157 def = gimple_phi_arg_def (phi, e->dest_idx);
158 locus = gimple_phi_arg_location (phi, e->dest_idx);
159
160 if (def == NULL_TREE)
161 continue;
162
163 redirect_edge_var_map_add (e, gimple_phi_result (phi), def, locus);
164 }
165
166 e = redirect_edge_succ_nodup (e, dest);
167
168 return e;
169}
170
171
172/* Add PHI arguments queued in PENDING_STMT list on edge E to edge
173 E->dest. */
174
175void
176flush_pending_stmts (edge e)
177{
178 gphi *phi;
179 edge_var_map *vm;
180 int i;
181 gphi_iterator gsi;
182
183 vec<edge_var_map> *v = redirect_edge_var_map_vector (e);
184 if (!v)
185 return;
186
187 for (gsi = gsi_start_phis (e->dest), i = 0;
188 !gsi_end_p (gsi) && v->iterate (i, &vm);
189 gsi_next (&gsi), i++)
190 {
191 tree def;
192
193 phi = gsi.phi ();
194 def = redirect_edge_var_map_def (vm);
195 add_phi_arg (phi, def, e, redirect_edge_var_map_location (vm));
196 }
197
198 redirect_edge_var_map_clear (e);
199}
200
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.
204
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
209 an equivalent value.
210
211 Adjusting any non-annotation uses of the LHS, if needed, is a
212 responsibility of the caller.
213
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. */
219
220void
221gimple_replace_ssa_lhs (gimple *stmt, tree nlhs)
222{
223 if (MAY_HAVE_DEBUG_BIND_STMTS)
224 {
225 tree lhs = gimple_get_lhs (stmt);
226
227 gcc_assert (SSA_NAME_DEF_STMT (lhs) == stmt);
228
229 insert_debug_temp_for_var_def (NULL, lhs);
230 }
231
232 gimple_set_lhs (stmt, nlhs);
233}
234
235
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. */
241
242tree
243target_for_debug_bind (tree var)
244{
245 if (!MAY_HAVE_DEBUG_BIND_STMTS)
246 return NULL_TREE;
247
248 if (TREE_CODE (var) == SSA_NAME)
249 {
250 var = SSA_NAME_VAR (var);
251 if (var == NULL_TREE)
252 return NULL_TREE;
253 }
254
255 if ((!VAR_P (var) || VAR_DECL_IS_VIRTUAL_OPERAND (var))
256 && TREE_CODE (var) != PARM_DECL)
257 return NULL_TREE;
258
259 if (DECL_HAS_VALUE_EXPR_P (var))
260 return target_for_debug_bind (DECL_VALUE_EXPR (var));
261
262 if (DECL_IGNORED_P (var))
263 return NULL_TREE;
264
265 /* var-tracking only tracks registers. */
266 if (!is_gimple_reg_type (TREE_TYPE (var)))
267 return NULL_TREE;
268
269 return var;
270}
271
272/* Called via walk_tree, look for SSA_NAMEs that have already been
273 released. */
274
275static tree
276find_released_ssa_name (tree *tp, int *walk_subtrees, void *data_)
277{
278 struct walk_stmt_info *wi = (struct walk_stmt_info *) data_;
279
280 if (wi && wi->is_lhs)
281 return NULL_TREE;
282
283 if (TREE_CODE (*tp) == SSA_NAME)
284 {
285 if (SSA_NAME_IN_FREE_LIST (*tp))
286 return *tp;
287
288 *walk_subtrees = 0;
289 }
290 else if (IS_TYPE_OR_DECL_P (*tp))
291 *walk_subtrees = 0;
292
293 return NULL_TREE;
294}
295
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. */
299
300void
301insert_debug_temp_for_var_def (gimple_stmt_iterator *gsi, tree var)
302{
303 imm_use_iterator imm_iter;
304 use_operand_p use_p;
305 gimple *stmt;
306 gimple *def_stmt = NULL;
307 int usecount = 0;
308 tree value = NULL;
309
310 if (!MAY_HAVE_DEBUG_BIND_STMTS)
311 return;
312
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))
316 return;
317
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)
321 {
322 stmt = USE_STMT (use_p);
323
324 if (!gimple_debug_bind_p (stmt))
325 continue;
326
327 if (usecount++)
328 break;
329
330 if (gimple_debug_bind_get_value (stmt) != var)
331 {
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
334 can be shared. */
335 usecount++;
336 break;
337 }
338 }
339
340 if (!usecount)
341 return;
342
343 if (gsi)
344 def_stmt = gsi_stmt (*gsi);
345 else
346 def_stmt = SSA_NAME_DEF_STMT (var);
347
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)
352 {
353 value = degenerate_phi_result (as_a <gphi *> (def_stmt));
354 if (value && walk_tree (&value, find_released_ssa_name, NULL, NULL))
355 value = NULL;
356 /* error_mark_node is what fixup_noreturn_call changes PHI arguments
357 to. */
358 else if (value == error_mark_node)
359 value = NULL;
360 }
361 else if (is_gimple_assign (def_stmt))
362 {
363 bool no_value = false;
364
365 if (!dom_info_available_p (CDI_DOMINATORS))
366 {
367 struct walk_stmt_info wi;
368
369 memset (&wi, 0, sizeof (wi));
370
371 /* When removing blocks without following reverse dominance
372 order, we may sometimes encounter SSA_NAMEs that have
373 already been released, referenced in other SSA_DEFs that
374 we're about to release. Consider:
375
376 <bb X>:
377 v_1 = foo;
378
379 <bb Y>:
380 w_2 = v_1 + bar;
381 # DEBUG w => w_2
382
383 If we deleted BB X first, propagating the value of w_2
384 won't do us any good. It's too late to recover their
385 original definition of v_1: when it was deleted, it was
386 only referenced in other DEFs, it couldn't possibly know
387 it should have been retained, and propagating every
388 single DEF just in case it might have to be propagated
389 into a DEBUG STMT would probably be too wasteful.
390
391 When dominator information is not readily available, we
392 check for and accept some loss of debug information. But
393 if it is available, there's no excuse for us to remove
394 blocks in the wrong order, so we don't even check for
395 dead SSA NAMEs. SSA verification shall catch any
396 errors. */
397 if ((!gsi && !gimple_bb (def_stmt))
398 || walk_gimple_op (def_stmt, find_released_ssa_name, &wi))
399 no_value = true;
400 }
401
402 if (!no_value)
403 value = gimple_assign_rhs_to_tree (def_stmt);
404 }
405
406 if (value)
407 {
408 /* If there's a single use of VAR, and VAR is the entire debug
409 expression (usecount would have been incremented again
410 otherwise), and the definition involves only constants and
411 SSA names, then we can propagate VALUE into this single use,
412 avoiding the temp.
413
414 We can also avoid using a temp if VALUE can be shared and
415 propagated into all uses, without generating expressions that
416 wouldn't be valid gimple RHSs.
417
418 Other cases that would require unsharing or non-gimple RHSs
419 are deferred to a debug temp, although we could avoid temps
420 at the expense of duplication of expressions. */
421
422 if (CONSTANT_CLASS_P (value)
423 || gimple_code (def_stmt) == GIMPLE_PHI
424 || (usecount == 1
425 && (!gimple_assign_single_p (def_stmt)
426 || is_gimple_min_invariant (value)))
427 || is_gimple_reg (value))
428 ;
429 else
430 {
431 gdebug *def_temp;
432 tree vexpr = make_node (DEBUG_EXPR_DECL);
433
434 def_temp = gimple_build_debug_bind (vexpr,
435 unshare_expr (value),
436 def_stmt);
437
438 DECL_ARTIFICIAL (vexpr) = 1;
439 TREE_TYPE (vexpr) = TREE_TYPE (value);
440 if (DECL_P (value))
441 SET_DECL_MODE (vexpr, DECL_MODE (value));
442 else
443 SET_DECL_MODE (vexpr, TYPE_MODE (TREE_TYPE (value)));
444
445 if (gsi)
446 gsi_insert_before (gsi, def_temp, GSI_SAME_STMT);
447 else
448 {
449 gimple_stmt_iterator ngsi = gsi_for_stmt (def_stmt);
450 gsi_insert_before (&ngsi, def_temp, GSI_SAME_STMT);
451 }
452
453 value = vexpr;
454 }
455 }
456
457 FOR_EACH_IMM_USE_STMT (stmt, imm_iter, var)
458 {
459 if (!gimple_debug_bind_p (stmt))
460 continue;
461
462 if (value)
463 {
464 FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
465 /* unshare_expr is not needed here. vexpr is either a
466 SINGLE_RHS, that can be safely shared, some other RHS
467 that was unshared when we found it had a single debug
468 use, or a DEBUG_EXPR_DECL, that can be safely
469 shared. */
470 SET_USE (use_p, unshare_expr (value));
471 /* If we didn't replace uses with a debug decl fold the
472 resulting expression. Otherwise we end up with invalid IL. */
473 if (TREE_CODE (value) != DEBUG_EXPR_DECL)
474 {
475 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
476 fold_stmt_inplace (&gsi);
477 }
478 }
479 else
480 gimple_debug_bind_reset_value (stmt);
481
482 update_stmt (stmt);
483 }
484}
485
486
487/* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
488 other DEBUG stmts, and replace uses of the DEF with the
489 newly-created debug temp. */
490
491void
492insert_debug_temps_for_defs (gimple_stmt_iterator *gsi)
493{
494 gimple *stmt;
495 ssa_op_iter op_iter;
496 def_operand_p def_p;
497
498 if (!MAY_HAVE_DEBUG_BIND_STMTS)
499 return;
500
501 stmt = gsi_stmt (*gsi);
502
503 FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF)
504 {
505 tree var = DEF_FROM_PTR (def_p);
506
507 if (TREE_CODE (var) != SSA_NAME)
508 continue;
509
510 insert_debug_temp_for_var_def (gsi, var);
511 }
512}
513
514/* Reset all debug stmts that use SSA_NAME(s) defined in STMT. */
515
516void
517reset_debug_uses (gimple *stmt)
518{
519 ssa_op_iter op_iter;
520 def_operand_p def_p;
521 imm_use_iterator imm_iter;
522 gimple *use_stmt;
523
524 if (!MAY_HAVE_DEBUG_BIND_STMTS)
525 return;
526
527 FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF)
528 {
529 tree var = DEF_FROM_PTR (def_p);
530
531 if (TREE_CODE (var) != SSA_NAME)
532 continue;
533
534 FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, var)
535 {
536 if (!gimple_debug_bind_p (use_stmt))
537 continue;
538
539 gimple_debug_bind_reset_value (use_stmt);
540 update_stmt (use_stmt);
541 }
542 }
543}
544
545/* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
546 dominated stmts before their dominators, so that release_ssa_defs
547 stands a chance of propagating DEFs into debug bind stmts. */
548
549void
550release_defs_bitset (bitmap toremove)
551{
552 unsigned j;
553 bitmap_iterator bi;
554
555 /* Performing a topological sort is probably overkill, this will
556 most likely run in slightly superlinear time, rather than the
557 pathological quadratic worst case. */
558 while (!bitmap_empty_p (toremove))
559 {
560 unsigned to_remove_bit = -1U;
561 EXECUTE_IF_SET_IN_BITMAP (toremove, 0, j, bi)
562 {
563 if (to_remove_bit != -1U)
564 {
565 bitmap_clear_bit (toremove, to_remove_bit);
566 to_remove_bit = -1U;
567 }
568
569 bool remove_now = true;
570 tree var = ssa_name (j);
571 gimple *stmt;
572 imm_use_iterator uit;
573
574 FOR_EACH_IMM_USE_STMT (stmt, uit, var)
575 {
576 ssa_op_iter dit;
577 def_operand_p def_p;
578
579 /* We can't propagate PHI nodes into debug stmts. */
580 if (gimple_code (stmt) == GIMPLE_PHI
581 || is_gimple_debug (stmt))
582 continue;
583
584 /* If we find another definition to remove that uses
585 the one we're looking at, defer the removal of this
586 one, so that it can be propagated into debug stmts
587 after the other is. */
588 FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, dit, SSA_OP_DEF)
589 {
590 tree odef = DEF_FROM_PTR (def_p);
591
592 if (bitmap_bit_p (toremove, SSA_NAME_VERSION (odef)))
593 {
594 remove_now = false;
595 break;
596 }
597 }
598
599 if (!remove_now)
600 BREAK_FROM_IMM_USE_STMT (uit);
601 }
602
603 if (remove_now)
604 {
605 gimple *def = SSA_NAME_DEF_STMT (var);
606 gimple_stmt_iterator gsi = gsi_for_stmt (def);
607
608 if (gimple_code (def) == GIMPLE_PHI)
609 remove_phi_node (&gsi, true);
610 else
611 {
612 gsi_remove (&gsi, true);
613 release_defs (def);
614 }
615
616 to_remove_bit = j;
617 }
618 }
619 if (to_remove_bit != -1U)
620 bitmap_clear_bit (toremove, to_remove_bit);
621 }
622
623}
624
625/* Verify virtual SSA form. */
626
627bool
628verify_vssa (basic_block bb, tree current_vdef, sbitmap visited)
629{
630 bool err = false;
631
632 if (bitmap_bit_p (visited, bb->index))
633 return false;
634
635 bitmap_set_bit (visited, bb->index);
636
637 /* Pick up the single virtual PHI def. */
638 gphi *phi = NULL;
639 for (gphi_iterator si = gsi_start_phis (bb); !gsi_end_p (si);
640 gsi_next (&si))
641 {
642 tree res = gimple_phi_result (si.phi ());
643 if (virtual_operand_p (res))
644 {
645 if (phi)
646 {
647 error ("multiple virtual PHI nodes in BB %d", bb->index);
648 print_gimple_stmt (stderr, phi, 0);
649 print_gimple_stmt (stderr, si.phi (), 0);
650 err = true;
651 }
652 else
653 phi = si.phi ();
654 }
655 }
656 if (phi)
657 {
658 current_vdef = gimple_phi_result (phi);
659 if (TREE_CODE (current_vdef) != SSA_NAME)
660 {
661 error ("virtual definition is not an SSA name");
662 print_gimple_stmt (stderr, phi, 0);
663 err = true;
664 }
665 }
666
667 /* Verify stmts. */
668 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
669 gsi_next (&gsi))
670 {
671 gimple *stmt = gsi_stmt (gsi);
672 tree vuse = gimple_vuse (stmt);
673 if (vuse)
674 {
675 if (vuse != current_vdef)
676 {
677 error ("stmt with wrong VUSE");
678 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
679 fprintf (stderr, "expected ");
680 print_generic_expr (stderr, current_vdef);
681 fprintf (stderr, "\n");
682 err = true;
683 }
684 tree vdef = gimple_vdef (stmt);
685 if (vdef)
686 {
687 current_vdef = vdef;
688 if (TREE_CODE (current_vdef) != SSA_NAME)
689 {
690 error ("virtual definition is not an SSA name");
691 print_gimple_stmt (stderr, phi, 0);
692 err = true;
693 }
694 }
695 }
696 }
697
698 /* Verify destination PHI uses and recurse. */
699 edge_iterator ei;
700 edge e;
701 FOR_EACH_EDGE (e, ei, bb->succs)
702 {
703 gphi *phi = get_virtual_phi (e->dest);
704 if (phi
705 && PHI_ARG_DEF_FROM_EDGE (phi, e) != current_vdef)
706 {
707 error ("PHI node with wrong VUSE on edge from BB %d",
708 e->src->index);
709 print_gimple_stmt (stderr, phi, 0, TDF_VOPS);
710 fprintf (stderr, "expected ");
711 print_generic_expr (stderr, current_vdef);
712 fprintf (stderr, "\n");
713 err = true;
714 }
715
716 /* Recurse. */
717 err |= verify_vssa (e->dest, current_vdef, visited);
718 }
719
720 return err;
721}
722
723/* Return true if SSA_NAME is malformed and mark it visited.
724
725 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
726 operand. */
727
728static bool
729verify_ssa_name (tree ssa_name, bool is_virtual)
730{
731 if (TREE_CODE (ssa_name) != SSA_NAME)
732 {
733 error ("expected an SSA_NAME object");
734 return true;
735 }
736
737 if (SSA_NAME_IN_FREE_LIST (ssa_name))
738 {
739 error ("found an SSA_NAME that had been released into the free pool");
740 return true;
741 }
742
743 if (SSA_NAME_VAR (ssa_name) != NULL_TREE
744 && TREE_TYPE (ssa_name) != TREE_TYPE (SSA_NAME_VAR (ssa_name)))
745 {
746 error ("type mismatch between an SSA_NAME and its symbol");
747 return true;
748 }
749
750 if (is_virtual && !virtual_operand_p (ssa_name))
751 {
752 error ("found a virtual definition for a GIMPLE register");
753 return true;
754 }
755
756 if (is_virtual && SSA_NAME_VAR (ssa_name) != gimple_vop (cfun))
757 {
758 error ("virtual SSA name for non-VOP decl");
759 return true;
760 }
761
762 if (!is_virtual && virtual_operand_p (ssa_name))
763 {
764 error ("found a real definition for a non-register");
765 return true;
766 }
767
768 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name)
769 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name)))
770 {
771 error ("found a default name with a non-empty defining statement");
772 return true;
773 }
774
775 return false;
776}
777
778
779/* Return true if the definition of SSA_NAME at block BB is malformed.
780
781 STMT is the statement where SSA_NAME is created.
782
783 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
784 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
785 it means that the block in that array slot contains the
786 definition of SSA_NAME.
787
788 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
789
790static bool
791verify_def (basic_block bb, basic_block *definition_block, tree ssa_name,
792 gimple *stmt, bool is_virtual)
793{
794 if (verify_ssa_name (ssa_name, is_virtual))
795 goto err;
796
797 if (SSA_NAME_VAR (ssa_name)
798 && TREE_CODE (SSA_NAME_VAR (ssa_name)) == RESULT_DECL
799 && DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name)))
800 {
801 error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
802 goto err;
803 }
804
805 if (definition_block[SSA_NAME_VERSION (ssa_name)])
806 {
807 error ("SSA_NAME created in two different blocks %i and %i",
808 definition_block[SSA_NAME_VERSION (ssa_name)]->index, bb->index);
809 goto err;
810 }
811
812 definition_block[SSA_NAME_VERSION (ssa_name)] = bb;
813
814 if (SSA_NAME_DEF_STMT (ssa_name) != stmt)
815 {
816 error ("SSA_NAME_DEF_STMT is wrong");
817 fprintf (stderr, "Expected definition statement:\n");
818 print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (ssa_name), 4, TDF_VOPS);
819 fprintf (stderr, "\nActual definition statement:\n");
820 print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
821 goto err;
822 }
823
824 return false;
825
826err:
827 fprintf (stderr, "while verifying SSA_NAME ");
828 print_generic_expr (stderr, ssa_name);
829 fprintf (stderr, " in statement\n");
830 print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
831
832 return true;
833}
834
835
836/* Return true if the use of SSA_NAME at statement STMT in block BB is
837 malformed.
838
839 DEF_BB is the block where SSA_NAME was found to be created.
840
841 IDOM contains immediate dominator information for the flowgraph.
842
843 CHECK_ABNORMAL is true if the caller wants to check whether this use
844 is flowing through an abnormal edge (only used when checking PHI
845 arguments).
846
847 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
848 that are defined before STMT in basic block BB. */
849
850static bool
851verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
852 gimple *stmt, bool check_abnormal, bitmap names_defined_in_bb)
853{
854 bool err = false;
855 tree ssa_name = USE_FROM_PTR (use_p);
856
857 if (!TREE_VISITED (ssa_name))
858 if (verify_imm_links (stderr, ssa_name))
859 err = true;
860
861 TREE_VISITED (ssa_name) = 1;
862
863 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name))
864 && SSA_NAME_IS_DEFAULT_DEF (ssa_name))
865 ; /* Default definitions have empty statements. Nothing to do. */
866 else if (!def_bb)
867 {
868 error ("missing definition");
869 err = true;
870 }
871 else if (bb != def_bb
872 && !dominated_by_p (CDI_DOMINATORS, bb, def_bb))
873 {
874 error ("definition in block %i does not dominate use in block %i",
875 def_bb->index, bb->index);
876 err = true;
877 }
878 else if (bb == def_bb
879 && names_defined_in_bb != NULL
880 && !bitmap_bit_p (names_defined_in_bb, SSA_NAME_VERSION (ssa_name)))
881 {
882 error ("definition in block %i follows the use", def_bb->index);
883 err = true;
884 }
885
886 if (check_abnormal
887 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name))
888 {
889 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
890 err = true;
891 }
892
893 /* Make sure the use is in an appropriate list by checking the previous
894 element to make sure it's the same. */
895 if (use_p->prev == NULL)
896 {
897 error ("no immediate_use list");
898 err = true;
899 }
900 else
901 {
902 tree listvar;
903 if (use_p->prev->use == NULL)
904 listvar = use_p->prev->loc.ssa_name;
905 else
906 listvar = USE_FROM_PTR (use_p->prev);
907 if (listvar != ssa_name)
908 {
909 error ("wrong immediate use list");
910 err = true;
911 }
912 }
913
914 if (err)
915 {
916 fprintf (stderr, "for SSA_NAME: ");
917 print_generic_expr (stderr, ssa_name, TDF_VOPS);
918 fprintf (stderr, " in statement:\n");
919 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
920 }
921
922 return err;
923}
924
925
926/* Return true if any of the arguments for PHI node PHI at block BB is
927 malformed.
928
929 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
930 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
931 it means that the block in that array slot contains the
932 definition of SSA_NAME. */
933
934static bool
935verify_phi_args (gphi *phi, basic_block bb, basic_block *definition_block)
936{
937 edge e;
938 bool err = false;
939 size_t i, phi_num_args = gimple_phi_num_args (phi);
940
941 if (EDGE_COUNT (bb->preds) != phi_num_args)
942 {
943 error ("incoming edge count does not match number of PHI arguments");
944 err = true;
945 goto error;
946 }
947
948 for (i = 0; i < phi_num_args; i++)
949 {
950 use_operand_p op_p = gimple_phi_arg_imm_use_ptr (phi, i);
951 tree op = USE_FROM_PTR (op_p);
952
953 e = EDGE_PRED (bb, i);
954
955 if (op == NULL_TREE)
956 {
957 error ("PHI argument is missing for edge %d->%d",
958 e->src->index,
959 e->dest->index);
960 err = true;
961 goto error;
962 }
963
964 if (TREE_CODE (op) != SSA_NAME && !is_gimple_min_invariant (op))
965 {
966 error ("PHI argument is not SSA_NAME, or invariant");
967 err = true;
968 }
969
970 if (TREE_CODE (op) == SSA_NAME)
971 {
972 err = verify_ssa_name (op, virtual_operand_p (gimple_phi_result (phi)));
973 err |= verify_use (e->src, definition_block[SSA_NAME_VERSION (op)],
974 op_p, phi, e->flags & EDGE_ABNORMAL, NULL);
975 }
976
977 if (TREE_CODE (op) == ADDR_EXPR)
978 {
979 tree base = TREE_OPERAND (op, 0);
980 while (handled_component_p (base))
981 base = TREE_OPERAND (base, 0);
982 if ((VAR_P (base)
983 || TREE_CODE (base) == PARM_DECL
984 || TREE_CODE (base) == RESULT_DECL)
985 && !TREE_ADDRESSABLE (base))
986 {
987 error ("address taken, but ADDRESSABLE bit not set");
988 err = true;
989 }
990 }
991
992 if (e->dest != bb)
993 {
994 error ("wrong edge %d->%d for PHI argument",
995 e->src->index, e->dest->index);
996 err = true;
997 }
998
999 if (err)
1000 {
1001 fprintf (stderr, "PHI argument\n");
1002 print_generic_stmt (stderr, op, TDF_VOPS);
1003 goto error;
1004 }
1005 }
1006
1007error:
1008 if (err)
1009 {
1010 fprintf (stderr, "for PHI node\n");
1011 print_gimple_stmt (stderr, phi, 0, TDF_VOPS|TDF_MEMSYMS);
1012 }
1013
1014
1015 return err;
1016}
1017
1018
1019/* Verify common invariants in the SSA web.
1020 TODO: verify the variable annotations. */
1021
1022DEBUG_FUNCTION void
1023verify_ssa (bool check_modified_stmt, bool check_ssa_operands)
1024{
1025 basic_block bb;
1026 basic_block *definition_block = XCNEWVEC (basic_block, num_ssa_names);
1027 ssa_op_iter iter;
1028 tree op;
1029 enum dom_state orig_dom_state = dom_info_state (CDI_DOMINATORS);
1030 auto_bitmap names_defined_in_bb;
1031
1032 gcc_assert (!need_ssa_update_p (cfun));
1033
1034 timevar_push (TV_TREE_SSA_VERIFY);
1035
1036 {
1037 /* Keep track of SSA names present in the IL. */
1038 size_t i;
1039 tree name;
1040 hash_map <void *, tree> ssa_info;
1041
1042 FOR_EACH_SSA_NAME (i, name, cfun)
1043 {
1044 gimple *stmt;
1045 TREE_VISITED (name) = 0;
1046
1047 verify_ssa_name (name, virtual_operand_p (name));
1048
1049 stmt = SSA_NAME_DEF_STMT (name);
1050 if (!gimple_nop_p (stmt))
1051 {
1052 basic_block bb = gimple_bb (stmt);
1053 if (verify_def (bb, definition_block,
1054 name, stmt, virtual_operand_p (name)))
1055 goto err;
1056 }
1057
1058 void *info = NULL;
1059 if (POINTER_TYPE_P (TREE_TYPE (name)))
1060 info = SSA_NAME_PTR_INFO (name);
1061 else if (INTEGRAL_TYPE_P (TREE_TYPE (name)))
1062 info = SSA_NAME_RANGE_INFO (name);
1063 if (info)
1064 {
1065 bool existed;
1066 tree &val = ssa_info.get_or_insert (info, &existed);
1067 if (existed)
1068 {
1069 error ("shared SSA name info");
1070 print_generic_expr (stderr, val);
1071 fprintf (stderr, " and ");
1072 print_generic_expr (stderr, name);
1073 fprintf (stderr, "\n");
1074 goto err;
1075 }
1076 else
1077 val = name;
1078 }
1079 }
1080 }
1081
1082 calculate_dominance_info (CDI_DOMINATORS);
1083
1084 /* Now verify all the uses and make sure they agree with the definitions
1085 found in the previous pass. */
1086 FOR_EACH_BB_FN (bb, cfun)
1087 {
1088 edge e;
1089 edge_iterator ei;
1090
1091 /* Make sure that all edges have a clear 'aux' field. */
1092 FOR_EACH_EDGE (e, ei, bb->preds)
1093 {
1094 if (e->aux)
1095 {
1096 error ("AUX pointer initialized for edge %d->%d", e->src->index,
1097 e->dest->index);
1098 goto err;
1099 }
1100 }
1101
1102 /* Verify the arguments for every PHI node in the block. */
1103 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1104 {
1105 gphi *phi = gsi.phi ();
1106 if (verify_phi_args (phi, bb, definition_block))
1107 goto err;
1108
1109 bitmap_set_bit (names_defined_in_bb,
1110 SSA_NAME_VERSION (gimple_phi_result (phi)));
1111 }
1112
1113 /* Now verify all the uses and vuses in every statement of the block. */
1114 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
1115 gsi_next (&gsi))
1116 {
1117 gimple *stmt = gsi_stmt (gsi);
1118 use_operand_p use_p;
1119
1120 if (check_modified_stmt && gimple_modified_p (stmt))
1121 {
1122 error ("stmt (%p) marked modified after optimization pass: ",
1123 (void *)stmt);
1124 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
1125 goto err;
1126 }
1127
1128 if (check_ssa_operands && verify_ssa_operands (cfun, stmt))
1129 {
1130 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
1131 goto err;
1132 }
1133
1134 if (gimple_debug_bind_p (stmt)
1135 && !gimple_debug_bind_has_value_p (stmt))
1136 continue;
1137
1138 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE|SSA_OP_VUSE)
1139 {
1140 op = USE_FROM_PTR (use_p);
1141 if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
1142 use_p, stmt, false, names_defined_in_bb))
1143 goto err;
1144 }
1145
1146 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_DEFS)
1147 {
1148 if (SSA_NAME_DEF_STMT (op) != stmt)
1149 {
1150 error ("SSA_NAME_DEF_STMT is wrong");
1151 fprintf (stderr, "Expected definition statement:\n");
1152 print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
1153 fprintf (stderr, "\nActual definition statement:\n");
1154 print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (op),
1155 4, TDF_VOPS);
1156 goto err;
1157 }
1158 bitmap_set_bit (names_defined_in_bb, SSA_NAME_VERSION (op));
1159 }
1160 }
1161
1162 bitmap_clear (names_defined_in_bb);
1163 }
1164
1165 free (definition_block);
1166
1167 if (gimple_vop (cfun)
1168 && ssa_default_def (cfun, gimple_vop (cfun)))
1169 {
1170 auto_sbitmap visited (last_basic_block_for_fn (cfun) + 1);
1171 bitmap_clear (visited);
1172 if (verify_vssa (ENTRY_BLOCK_PTR_FOR_FN (cfun),
1173 ssa_default_def (cfun, gimple_vop (cfun)), visited))
1174 goto err;
1175 }
1176
1177 /* Restore the dominance information to its prior known state, so
1178 that we do not perturb the compiler's subsequent behavior. */
1179 if (orig_dom_state == DOM_NONE)
1180 free_dominance_info (CDI_DOMINATORS);
1181 else
1182 set_dom_info_availability (CDI_DOMINATORS, orig_dom_state);
1183
1184 timevar_pop (TV_TREE_SSA_VERIFY);
1185 return;
1186
1187err:
1188 internal_error ("verify_ssa failed");
1189}
1190
1191
1192/* Initialize global DFA and SSA structures. */
1193
1194void
1195init_tree_ssa (struct function *fn)
1196{
1197 fn->gimple_df = ggc_cleared_alloc<gimple_df> ();
1198 fn->gimple_df->default_defs = hash_table<ssa_name_hasher>::create_ggc (20);
1199 pt_solution_reset (&fn->gimple_df->escaped);
1200 init_ssanames (fn, 0);
1201}
1202
1203/* Deallocate memory associated with SSA data structures for FNDECL. */
1204
1205void
1206delete_tree_ssa (struct function *fn)
1207{
1208 fini_ssanames (fn);
1209
1210 /* We no longer maintain the SSA operand cache at this point. */
1211 if (ssa_operands_active (fn))
1212 fini_ssa_operands (fn);
1213
1214 fn->gimple_df->default_defs->empty ();
1215 fn->gimple_df->default_defs = NULL;
1216 pt_solution_reset (&fn->gimple_df->escaped);
1217 if (fn->gimple_df->decls_to_pointers != NULL)
1218 delete fn->gimple_df->decls_to_pointers;
1219 fn->gimple_df->decls_to_pointers = NULL;
1220 fn->gimple_df = NULL;
1221
1222 /* We no longer need the edge variable maps. */
1223 redirect_edge_var_map_empty ();
1224}
1225
1226/* Return true if EXPR is a useless type conversion, otherwise return
1227 false. */
1228
1229bool
1230tree_ssa_useless_type_conversion (tree expr)
1231{
1232 /* If we have an assignment that merely uses a NOP_EXPR to change
1233 the top of the RHS to the type of the LHS and the type conversion
1234 is "safe", then strip away the type conversion so that we can
1235 enter LHS = RHS into the const_and_copies table. */
1236 if (CONVERT_EXPR_P (expr)
1237 || TREE_CODE (expr) == VIEW_CONVERT_EXPR
1238 || TREE_CODE (expr) == NON_LVALUE_EXPR)
1239 return useless_type_conversion_p
1240 (TREE_TYPE (expr),
1241 TREE_TYPE (TREE_OPERAND (expr, 0)));
1242
1243 return false;
1244}
1245
1246/* Strip conversions from EXP according to
1247 tree_ssa_useless_type_conversion and return the resulting
1248 expression. */
1249
1250tree
1251tree_ssa_strip_useless_type_conversions (tree exp)
1252{
1253 while (tree_ssa_useless_type_conversion (exp))
1254 exp = TREE_OPERAND (exp, 0);
1255 return exp;
1256}
1257
1258/* Return true if T, as SSA_NAME, has an implicit default defined value. */
1259
1260bool
1261ssa_defined_default_def_p (tree t)
1262{
1263 tree var = SSA_NAME_VAR (t);
1264
1265 if (!var)
1266 ;
1267 /* Parameters get their initial value from the function entry. */
1268 else if (TREE_CODE (var) == PARM_DECL)
1269 return true;
1270 /* When returning by reference the return address is actually a hidden
1271 parameter. */
1272 else if (TREE_CODE (var) == RESULT_DECL && DECL_BY_REFERENCE (var))
1273 return true;
1274 /* Hard register variables get their initial value from the ether. */
1275 else if (VAR_P (var) && DECL_HARD_REGISTER (var))
1276 return true;
1277
1278 return false;
1279}
1280
1281
1282/* Return true if T, an SSA_NAME, has an undefined value. PARTIAL is what
1283 should be returned if the value is only partially undefined. */
1284
1285bool
1286ssa_undefined_value_p (tree t, bool partial)
1287{
1288 gimple *def_stmt;
1289
1290 if (ssa_defined_default_def_p (t))
1291 return false;
1292
1293 /* The value is undefined iff its definition statement is empty. */
1294 def_stmt = SSA_NAME_DEF_STMT (t);
1295 if (gimple_nop_p (def_stmt))
1296 return true;
1297
1298 /* Check if the complex was not only partially defined. */
1299 if (partial && is_gimple_assign (def_stmt)
1300 && gimple_assign_rhs_code (def_stmt) == COMPLEX_EXPR)
1301 {
1302 tree rhs1, rhs2;
1303
1304 rhs1 = gimple_assign_rhs1 (def_stmt);
1305 rhs2 = gimple_assign_rhs2 (def_stmt);
1306 return (TREE_CODE (rhs1) == SSA_NAME && ssa_undefined_value_p (rhs1))
1307 || (TREE_CODE (rhs2) == SSA_NAME && ssa_undefined_value_p (rhs2));
1308 }
1309 return false;
1310}
1311
1312
1313/* Return TRUE iff STMT, a gimple statement, references an undefined
1314 SSA name. */
1315
1316bool
1317gimple_uses_undefined_value_p (gimple *stmt)
1318{
1319 ssa_op_iter iter;
1320 tree op;
1321
1322 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
1323 if (ssa_undefined_value_p (op))
1324 return true;
1325
1326 return false;
1327}
1328
1329
1330
1331/* If necessary, rewrite the base of the reference tree *TP from
1332 a MEM_REF to a plain or converted symbol. */
1333
1334static void
1335maybe_rewrite_mem_ref_base (tree *tp, bitmap suitable_for_renaming)
1336{
1337 tree sym;
1338
1339 while (handled_component_p (*tp))
1340 tp = &TREE_OPERAND (*tp, 0);
1341 if (TREE_CODE (*tp) == MEM_REF
1342 && TREE_CODE (TREE_OPERAND (*tp, 0)) == ADDR_EXPR
1343 && (sym = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0))
1344 && DECL_P (sym)
1345 && !TREE_ADDRESSABLE (sym)
1346 && bitmap_bit_p (suitable_for_renaming, DECL_UID (sym))
1347 && is_gimple_reg_type (TREE_TYPE (*tp))
1348 && ! VOID_TYPE_P (TREE_TYPE (*tp)))
1349 {
1350 if (TREE_CODE (TREE_TYPE (sym)) == VECTOR_TYPE
1351 && useless_type_conversion_p (TREE_TYPE (*tp),
1352 TREE_TYPE (TREE_TYPE (sym)))
1353 && multiple_of_p (sizetype, TREE_OPERAND (*tp, 1),
1354 TYPE_SIZE_UNIT (TREE_TYPE (*tp))))
1355 {
1356 *tp = build3 (BIT_FIELD_REF, TREE_TYPE (*tp), sym,
1357 TYPE_SIZE (TREE_TYPE (*tp)),
1358 int_const_binop (MULT_EXPR,
1359 bitsize_int (BITS_PER_UNIT),
1360 TREE_OPERAND (*tp, 1)));
1361 }
1362 else if (TREE_CODE (TREE_TYPE (sym)) == COMPLEX_TYPE
1363 && useless_type_conversion_p (TREE_TYPE (*tp),
1364 TREE_TYPE (TREE_TYPE (sym))))
1365 {
1366 *tp = build1 (integer_zerop (TREE_OPERAND (*tp, 1))
1367 ? REALPART_EXPR : IMAGPART_EXPR,
1368 TREE_TYPE (*tp), sym);
1369 }
1370 else if (integer_zerop (TREE_OPERAND (*tp, 1))
1371 && DECL_SIZE (sym) == TYPE_SIZE (TREE_TYPE (*tp)))
1372 {
1373 if (!useless_type_conversion_p (TREE_TYPE (*tp),
1374 TREE_TYPE (sym)))
1375 *tp = build1 (VIEW_CONVERT_EXPR,
1376 TREE_TYPE (*tp), sym);
1377 else
1378 *tp = sym;
1379 }
1380 else if (DECL_SIZE (sym)
1381 && TREE_CODE (DECL_SIZE (sym)) == INTEGER_CST
1382 && mem_ref_offset (*tp) >= 0
1383 && wi::leu_p (mem_ref_offset (*tp)
1384 + wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (*tp))),
1385 wi::to_offset (DECL_SIZE_UNIT (sym)))
1386 && (! INTEGRAL_TYPE_P (TREE_TYPE (*tp))
1387 || (wi::to_offset (TYPE_SIZE (TREE_TYPE (*tp)))
1388 == TYPE_PRECISION (TREE_TYPE (*tp))))
1389 && wi::umod_trunc (wi::to_offset (TYPE_SIZE (TREE_TYPE (*tp))),
1390 BITS_PER_UNIT) == 0)
1391 {
1392 *tp = build3 (BIT_FIELD_REF, TREE_TYPE (*tp), sym,
1393 TYPE_SIZE (TREE_TYPE (*tp)),
1394 wide_int_to_tree (bitsizetype,
1395 mem_ref_offset (*tp)
1396 << LOG2_BITS_PER_UNIT));
1397 }
1398 }
1399}
1400
1401/* For a tree REF return its base if it is the base of a MEM_REF
1402 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1403
1404static tree
1405non_rewritable_mem_ref_base (tree ref)
1406{
1407 tree base;
1408
1409 /* A plain decl does not need it set. */
1410 if (DECL_P (ref))
1411 return NULL_TREE;
1412
1413 if (! (base = CONST_CAST_TREE (strip_invariant_refs (ref))))
1414 {
1415 base = get_base_address (ref);
1416 if (DECL_P (base))
1417 return base;
1418 return NULL_TREE;
1419 }
1420
1421 /* But watch out for MEM_REFs we cannot lower to a
1422 VIEW_CONVERT_EXPR or a BIT_FIELD_REF. */
1423 if (TREE_CODE (base) == MEM_REF
1424 && TREE_CODE (TREE_OPERAND (base, 0)) == ADDR_EXPR)
1425 {
1426 tree decl = TREE_OPERAND (TREE_OPERAND (base, 0), 0);
1427 if (! DECL_P (decl))
1428 return NULL_TREE;
1429 if (! is_gimple_reg_type (TREE_TYPE (base))
1430 || VOID_TYPE_P (TREE_TYPE (base)))
1431 return decl;
1432 if ((TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE
1433 || TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE)
1434 && useless_type_conversion_p (TREE_TYPE (base),
1435 TREE_TYPE (TREE_TYPE (decl)))
1436 && wi::fits_uhwi_p (mem_ref_offset (base))
1437 && wi::gtu_p (wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl))),
1438 mem_ref_offset (base))
1439 && multiple_of_p (sizetype, TREE_OPERAND (base, 1),
1440 TYPE_SIZE_UNIT (TREE_TYPE (base))))
1441 return NULL_TREE;
1442 /* For same sizes and zero offset we can use a VIEW_CONVERT_EXPR. */
1443 if (integer_zerop (TREE_OPERAND (base, 1))
1444 && DECL_SIZE (decl) == TYPE_SIZE (TREE_TYPE (base)))
1445 return NULL_TREE;
1446 /* For integral typed extracts we can use a BIT_FIELD_REF. */
1447 if (DECL_SIZE (decl)
1448 && TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST
1449 && mem_ref_offset (base) >= 0
1450 && wi::leu_p (mem_ref_offset (base)
1451 + wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (base))),
1452 wi::to_offset (DECL_SIZE_UNIT (decl)))
1453 /* ??? We can't handle bitfield precision extracts without
1454 either using an alternate type for the BIT_FIELD_REF and
1455 then doing a conversion or possibly adjusting the offset
1456 according to endianness. */
1457 && (! INTEGRAL_TYPE_P (TREE_TYPE (base))
1458 || (wi::to_offset (TYPE_SIZE (TREE_TYPE (base)))
1459 == TYPE_PRECISION (TREE_TYPE (base))))
1460 && wi::umod_trunc (wi::to_offset (TYPE_SIZE (TREE_TYPE (base))),
1461 BITS_PER_UNIT) == 0)
1462 return NULL_TREE;
1463 return decl;
1464 }
1465
1466 return NULL_TREE;
1467}
1468
1469/* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
1470 Otherwise return true. */
1471
1472static bool
1473non_rewritable_lvalue_p (tree lhs)
1474{
1475 /* A plain decl is always rewritable. */
1476 if (DECL_P (lhs))
1477 return false;
1478
1479 /* We can re-write REALPART_EXPR and IMAGPART_EXPR sets in
1480 a reasonably efficient manner... */
1481 if ((TREE_CODE (lhs) == REALPART_EXPR
1482 || TREE_CODE (lhs) == IMAGPART_EXPR)
1483 && DECL_P (TREE_OPERAND (lhs, 0)))
1484 return false;
1485
1486 /* ??? The following could be relaxed allowing component
1487 references that do not change the access size. */
1488 if (TREE_CODE (lhs) == MEM_REF
1489 && TREE_CODE (TREE_OPERAND (lhs, 0)) == ADDR_EXPR)
1490 {
1491 tree decl = TREE_OPERAND (TREE_OPERAND (lhs, 0), 0);
1492
1493 /* A decl that is wrapped inside a MEM-REF that covers
1494 it full is also rewritable. */
1495 if (integer_zerop (TREE_OPERAND (lhs, 1))
1496 && DECL_P (decl)
1497 && DECL_SIZE (decl) == TYPE_SIZE (TREE_TYPE (lhs))
1498 /* If the dynamic type of the decl has larger precision than
1499 the decl itself we can't use the decls type for SSA rewriting. */
1500 && ((! INTEGRAL_TYPE_P (TREE_TYPE (decl))
1501 || compare_tree_int (DECL_SIZE (decl),
1502 TYPE_PRECISION (TREE_TYPE (decl))) == 0)
1503 || (INTEGRAL_TYPE_P (TREE_TYPE (lhs))
1504 && (TYPE_PRECISION (TREE_TYPE (decl))
1505 >= TYPE_PRECISION (TREE_TYPE (lhs)))))
1506 /* Make sure we are not re-writing non-float copying into float
1507 copying as that can incur normalization. */
1508 && (! FLOAT_TYPE_P (TREE_TYPE (decl))
1509 || types_compatible_p (TREE_TYPE (lhs), TREE_TYPE (decl)))
1510 && (TREE_THIS_VOLATILE (decl) == TREE_THIS_VOLATILE (lhs)))
1511 return false;
1512
1513 /* A vector-insert using a MEM_REF or ARRAY_REF is rewritable
1514 using a BIT_INSERT_EXPR. */
1515 if (DECL_P (decl)
1516 && VECTOR_TYPE_P (TREE_TYPE (decl))
1517 && TYPE_MODE (TREE_TYPE (decl)) != BLKmode
1518 && operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (lhs)),
1519 TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl))), 0)
1520 && tree_fits_uhwi_p (TREE_OPERAND (lhs, 1))
1521 && tree_int_cst_lt (TREE_OPERAND (lhs, 1),
1522 TYPE_SIZE_UNIT (TREE_TYPE (decl)))
1523 && (tree_to_uhwi (TREE_OPERAND (lhs, 1))
1524 % tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (lhs)))) == 0)
1525 return false;
1526 }
1527
1528 /* A vector-insert using a BIT_FIELD_REF is rewritable using
1529 BIT_INSERT_EXPR. */
1530 if (TREE_CODE (lhs) == BIT_FIELD_REF
1531 && DECL_P (TREE_OPERAND (lhs, 0))
1532 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs, 0)))
1533 && TYPE_MODE (TREE_TYPE (TREE_OPERAND (lhs, 0))) != BLKmode
1534 && operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (lhs)),
1535 TYPE_SIZE_UNIT
1536 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (lhs, 0)))), 0)
1537 && (tree_to_uhwi (TREE_OPERAND (lhs, 2))
1538 % tree_to_uhwi (TYPE_SIZE (TREE_TYPE (lhs)))) == 0)
1539 return false;
1540
1541 return true;
1542}
1543
1544/* When possible, clear TREE_ADDRESSABLE bit or set DECL_GIMPLE_REG_P bit and
1545 mark the variable VAR for conversion into SSA. Return true when updating
1546 stmts is required. */
1547
1548static void
1549maybe_optimize_var (tree var, bitmap addresses_taken, bitmap not_reg_needs,
1550 bitmap suitable_for_renaming)
1551{
1552 /* Global Variables, result decls cannot be changed. */
1553 if (is_global_var (var)
1554 || TREE_CODE (var) == RESULT_DECL
1555 || bitmap_bit_p (addresses_taken, DECL_UID (var)))
1556 return;
1557
1558 if (TREE_ADDRESSABLE (var)
1559 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1560 a non-register. Otherwise we are confused and forget to
1561 add virtual operands for it. */
1562 && (!is_gimple_reg_type (TREE_TYPE (var))
1563 || TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE
1564 || TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
1565 || !bitmap_bit_p (not_reg_needs, DECL_UID (var))))
1566 {
1567 TREE_ADDRESSABLE (var) = 0;
1568 if (is_gimple_reg (var))
1569 bitmap_set_bit (suitable_for_renaming, DECL_UID (var));
1570 if (dump_file)
1571 {
1572 fprintf (dump_file, "No longer having address taken: ");
1573 print_generic_expr (dump_file, var);
1574 fprintf (dump_file, "\n");
1575 }
1576 }
1577
1578 if (!DECL_GIMPLE_REG_P (var)
1579 && !bitmap_bit_p (not_reg_needs, DECL_UID (var))
1580 && (TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
1581 || TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE)
1582 && !TREE_THIS_VOLATILE (var)
1583 && (!VAR_P (var) || !DECL_HARD_REGISTER (var)))
1584 {
1585 DECL_GIMPLE_REG_P (var) = 1;
1586 bitmap_set_bit (suitable_for_renaming, DECL_UID (var));
1587 if (dump_file)
1588 {
1589 fprintf (dump_file, "Now a gimple register: ");
1590 print_generic_expr (dump_file, var);
1591 fprintf (dump_file, "\n");
1592 }
1593 }
1594}
1595
1596/* Return true when STMT is ASAN mark where second argument is an address
1597 of a local variable. */
1598
1599static bool
1600is_asan_mark_p (gimple *stmt)
1601{
1602 if (!gimple_call_internal_p (stmt, IFN_ASAN_MARK))
1603 return false;
1604
1605 tree addr = get_base_address (gimple_call_arg (stmt, 1));
1606 if (TREE_CODE (addr) == ADDR_EXPR
1607 && VAR_P (TREE_OPERAND (addr, 0)))
1608 {
1609 tree var = TREE_OPERAND (addr, 0);
1610 if (lookup_attribute (ASAN_USE_AFTER_SCOPE_ATTRIBUTE,
1611 DECL_ATTRIBUTES (var)))
1612 return false;
1613
1614 unsigned addressable = TREE_ADDRESSABLE (var);
1615 TREE_ADDRESSABLE (var) = 0;
1616 bool r = is_gimple_reg (var);
1617 TREE_ADDRESSABLE (var) = addressable;
1618 return r;
1619 }
1620
1621 return false;
1622}
1623
1624/* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1625
1626void
1627execute_update_addresses_taken (void)
1628{
1629 basic_block bb;
1630 auto_bitmap addresses_taken;
1631 auto_bitmap not_reg_needs;
1632 auto_bitmap suitable_for_renaming;
1633 tree var;
1634 unsigned i;
1635
1636 timevar_push (TV_ADDRESS_TAKEN);
1637
1638 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1639 the function body. */
1640 FOR_EACH_BB_FN (bb, cfun)
1641 {
1642 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
1643 gsi_next (&gsi))
1644 {
1645 gimple *stmt = gsi_stmt (gsi);
1646 enum gimple_code code = gimple_code (stmt);
1647 tree decl;
1648
1649 if (code == GIMPLE_CALL)
1650 {
1651 if (optimize_atomic_compare_exchange_p (stmt))
1652 {
1653 /* For __atomic_compare_exchange_N if the second argument
1654 is &var, don't mark var addressable;
1655 if it becomes non-addressable, we'll rewrite it into
1656 ATOMIC_COMPARE_EXCHANGE call. */
1657 tree arg = gimple_call_arg (stmt, 1);
1658 gimple_call_set_arg (stmt, 1, null_pointer_node);
1659 gimple_ior_addresses_taken (addresses_taken, stmt);
1660 gimple_call_set_arg (stmt, 1, arg);
1661 }
1662 else if (is_asan_mark_p (stmt)
1663 || gimple_call_internal_p (stmt, IFN_GOMP_SIMT_ENTER))
1664 ;
1665 else
1666 gimple_ior_addresses_taken (addresses_taken, stmt);
1667 }
1668 else
1669 /* Note all addresses taken by the stmt. */
1670 gimple_ior_addresses_taken (addresses_taken, stmt);
1671
1672 /* If we have a call or an assignment, see if the lhs contains
1673 a local decl that requires not to be a gimple register. */
1674 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
1675 {
1676 tree lhs = gimple_get_lhs (stmt);
1677 if (lhs
1678 && TREE_CODE (lhs) != SSA_NAME
1679 && ((code == GIMPLE_CALL && ! DECL_P (lhs))
1680 || non_rewritable_lvalue_p (lhs)))
1681 {
1682 decl = get_base_address (lhs);
1683 if (DECL_P (decl))
1684 bitmap_set_bit (not_reg_needs, DECL_UID (decl));
1685 }
1686 }
1687
1688 if (gimple_assign_single_p (stmt))
1689 {
1690 tree rhs = gimple_assign_rhs1 (stmt);
1691 if ((decl = non_rewritable_mem_ref_base (rhs)))
1692 bitmap_set_bit (not_reg_needs, DECL_UID (decl));
1693 }
1694
1695 else if (code == GIMPLE_CALL)
1696 {
1697 for (i = 0; i < gimple_call_num_args (stmt); ++i)
1698 {
1699 tree arg = gimple_call_arg (stmt, i);
1700 if ((decl = non_rewritable_mem_ref_base (arg)))
1701 bitmap_set_bit (not_reg_needs, DECL_UID (decl));
1702 }
1703 }
1704
1705 else if (code == GIMPLE_ASM)
1706 {
1707 gasm *asm_stmt = as_a <gasm *> (stmt);
1708 for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i)
1709 {
1710 tree link = gimple_asm_output_op (asm_stmt, i);
1711 tree lhs = TREE_VALUE (link);
1712 if (TREE_CODE (lhs) != SSA_NAME)
1713 {
1714 decl = get_base_address (lhs);
1715 if (DECL_P (decl)
1716 && (non_rewritable_lvalue_p (lhs)
1717 /* We cannot move required conversions from
1718 the lhs to the rhs in asm statements, so
1719 require we do not need any. */
1720 || !useless_type_conversion_p
1721 (TREE_TYPE (lhs), TREE_TYPE (decl))))
1722 bitmap_set_bit (not_reg_needs, DECL_UID (decl));
1723 }
1724 }
1725 for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i)
1726 {
1727 tree link = gimple_asm_input_op (asm_stmt, i);
1728 if ((decl = non_rewritable_mem_ref_base (TREE_VALUE (link))))
1729 bitmap_set_bit (not_reg_needs, DECL_UID (decl));
1730 }
1731 }
1732 }
1733
1734 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
1735 gsi_next (&gsi))
1736 {
1737 size_t i;
1738 gphi *phi = gsi.phi ();
1739
1740 for (i = 0; i < gimple_phi_num_args (phi); i++)
1741 {
1742 tree op = PHI_ARG_DEF (phi, i), var;
1743 if (TREE_CODE (op) == ADDR_EXPR
1744 && (var = get_base_address (TREE_OPERAND (op, 0))) != NULL
1745 && DECL_P (var))
1746 bitmap_set_bit (addresses_taken, DECL_UID (var));
1747 }
1748 }
1749 }
1750
1751 /* We cannot iterate over all referenced vars because that can contain
1752 unused vars from BLOCK trees, which causes code generation differences
1753 for -g vs. -g0. */
1754 for (var = DECL_ARGUMENTS (cfun->decl); var; var = DECL_CHAIN (var))
1755 maybe_optimize_var (var, addresses_taken, not_reg_needs,
1756 suitable_for_renaming);
1757
1758 FOR_EACH_VEC_SAFE_ELT (cfun->local_decls, i, var)
1759 maybe_optimize_var (var, addresses_taken, not_reg_needs,
1760 suitable_for_renaming);
1761
1762 /* Operand caches need to be recomputed for operands referencing the updated
1763 variables and operands need to be rewritten to expose bare symbols. */
1764 if (!bitmap_empty_p (suitable_for_renaming))
1765 {
1766 FOR_EACH_BB_FN (bb, cfun)
1767 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
1768 {
1769 gimple *stmt = gsi_stmt (gsi);
1770
1771 /* Re-write TARGET_MEM_REFs of symbols we want to
1772 rewrite into SSA form. */
1773 if (gimple_assign_single_p (stmt))
1774 {
1775 tree lhs = gimple_assign_lhs (stmt);
1776 tree rhs, *rhsp = gimple_assign_rhs1_ptr (stmt);
1777 tree sym;
1778
1779 /* Rewrite LHS IMAG/REALPART_EXPR similar to
1780 gimplify_modify_expr_complex_part. */
1781 if ((TREE_CODE (lhs) == IMAGPART_EXPR
1782 || TREE_CODE (lhs) == REALPART_EXPR)
1783 && DECL_P (TREE_OPERAND (lhs, 0))
1784 && bitmap_bit_p (suitable_for_renaming,
1785 DECL_UID (TREE_OPERAND (lhs, 0))))
1786 {
1787 tree other = make_ssa_name (TREE_TYPE (lhs));
1788 tree lrhs = build1 (TREE_CODE (lhs) == IMAGPART_EXPR
1789 ? REALPART_EXPR : IMAGPART_EXPR,
1790 TREE_TYPE (other),
1791 TREE_OPERAND (lhs, 0));
1792 gimple *load = gimple_build_assign (other, lrhs);
1793 location_t loc = gimple_location (stmt);
1794 gimple_set_location (load, loc);
1795 gimple_set_vuse (load, gimple_vuse (stmt));
1796 gsi_insert_before (&gsi, load, GSI_SAME_STMT);
1797 gimple_assign_set_lhs (stmt, TREE_OPERAND (lhs, 0));
1798 gimple_assign_set_rhs_with_ops
1799 (&gsi, COMPLEX_EXPR,
1800 TREE_CODE (lhs) == IMAGPART_EXPR
1801 ? other : gimple_assign_rhs1 (stmt),
1802 TREE_CODE (lhs) == IMAGPART_EXPR
1803 ? gimple_assign_rhs1 (stmt) : other, NULL_TREE);
1804 stmt = gsi_stmt (gsi);
1805 unlink_stmt_vdef (stmt);
1806 update_stmt (stmt);
1807 continue;
1808 }
1809
1810 /* Rewrite a vector insert via a BIT_FIELD_REF on the LHS
1811 into a BIT_INSERT_EXPR. */
1812 if (TREE_CODE (lhs) == BIT_FIELD_REF
1813 && DECL_P (TREE_OPERAND (lhs, 0))
1814 && bitmap_bit_p (suitable_for_renaming,
1815 DECL_UID (TREE_OPERAND (lhs, 0)))
1816 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs, 0)))
1817 && TYPE_MODE (TREE_TYPE (TREE_OPERAND (lhs, 0))) != BLKmode
1818 && operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (lhs)),
1819 TYPE_SIZE_UNIT (TREE_TYPE
1820 (TREE_TYPE (TREE_OPERAND (lhs, 0)))),
1821 0)
1822 && (tree_to_uhwi (TREE_OPERAND (lhs, 2))
1823 % tree_to_uhwi (TYPE_SIZE (TREE_TYPE (lhs))) == 0))
1824 {
1825 tree var = TREE_OPERAND (lhs, 0);
1826 tree val = gimple_assign_rhs1 (stmt);
1827 if (! types_compatible_p (TREE_TYPE (TREE_TYPE (var)),
1828 TREE_TYPE (val)))
1829 {
1830 tree tem = make_ssa_name (TREE_TYPE (TREE_TYPE (var)));
1831 gimple *pun
1832 = gimple_build_assign (tem,
1833 build1 (VIEW_CONVERT_EXPR,
1834 TREE_TYPE (tem), val));
1835 gsi_insert_before (&gsi, pun, GSI_SAME_STMT);
1836 val = tem;
1837 }
1838 tree bitpos = TREE_OPERAND (lhs, 2);
1839 gimple_assign_set_lhs (stmt, var);
1840 gimple_assign_set_rhs_with_ops
1841 (&gsi, BIT_INSERT_EXPR, var, val, bitpos);
1842 stmt = gsi_stmt (gsi);
1843 unlink_stmt_vdef (stmt);
1844 update_stmt (stmt);
1845 continue;
1846 }
1847
1848 /* Rewrite a vector insert using a MEM_REF on the LHS
1849 into a BIT_INSERT_EXPR. */
1850 if (TREE_CODE (lhs) == MEM_REF
1851 && TREE_CODE (TREE_OPERAND (lhs, 0)) == ADDR_EXPR
1852 && (sym = TREE_OPERAND (TREE_OPERAND (lhs, 0), 0))
1853 && DECL_P (sym)
1854 && bitmap_bit_p (suitable_for_renaming, DECL_UID (sym))
1855 && VECTOR_TYPE_P (TREE_TYPE (sym))
1856 && TYPE_MODE (TREE_TYPE (sym)) != BLKmode
1857 && operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (lhs)),
1858 TYPE_SIZE_UNIT
1859 (TREE_TYPE (TREE_TYPE (sym))), 0)
1860 && tree_fits_uhwi_p (TREE_OPERAND (lhs, 1))
1861 && tree_int_cst_lt (TREE_OPERAND (lhs, 1),
1862 TYPE_SIZE_UNIT (TREE_TYPE (sym)))
1863 && (tree_to_uhwi (TREE_OPERAND (lhs, 1))
1864 % tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (lhs)))) == 0)
1865 {
1866 tree val = gimple_assign_rhs1 (stmt);
1867 if (! types_compatible_p (TREE_TYPE (val),
1868 TREE_TYPE (TREE_TYPE (sym))))
1869 {
1870 tree tem = make_ssa_name (TREE_TYPE (TREE_TYPE (sym)));
1871 gimple *pun
1872 = gimple_build_assign (tem,
1873 build1 (VIEW_CONVERT_EXPR,
1874 TREE_TYPE (tem), val));
1875 gsi_insert_before (&gsi, pun, GSI_SAME_STMT);
1876 val = tem;
1877 }
1878 tree bitpos
1879 = wide_int_to_tree (bitsizetype,
1880 mem_ref_offset (lhs) * BITS_PER_UNIT);
1881 gimple_assign_set_lhs (stmt, sym);
1882 gimple_assign_set_rhs_with_ops
1883 (&gsi, BIT_INSERT_EXPR, sym, val, bitpos);
1884 stmt = gsi_stmt (gsi);
1885 unlink_stmt_vdef (stmt);
1886 update_stmt (stmt);
1887 continue;
1888 }
1889
1890 /* We shouldn't have any fancy wrapping of
1891 component-refs on the LHS, but look through
1892 VIEW_CONVERT_EXPRs as that is easy. */
1893 while (TREE_CODE (lhs) == VIEW_CONVERT_EXPR)
1894 lhs = TREE_OPERAND (lhs, 0);
1895 if (TREE_CODE (lhs) == MEM_REF
1896 && TREE_CODE (TREE_OPERAND (lhs, 0)) == ADDR_EXPR
1897 && integer_zerop (TREE_OPERAND (lhs, 1))
1898 && (sym = TREE_OPERAND (TREE_OPERAND (lhs, 0), 0))
1899 && DECL_P (sym)
1900 && !TREE_ADDRESSABLE (sym)
1901 && bitmap_bit_p (suitable_for_renaming, DECL_UID (sym)))
1902 lhs = sym;
1903 else
1904 lhs = gimple_assign_lhs (stmt);
1905
1906 /* Rewrite the RHS and make sure the resulting assignment
1907 is validly typed. */
1908 maybe_rewrite_mem_ref_base (rhsp, suitable_for_renaming);
1909 rhs = gimple_assign_rhs1 (stmt);
1910 if (gimple_assign_lhs (stmt) != lhs
1911 && !useless_type_conversion_p (TREE_TYPE (lhs),
1912 TREE_TYPE (rhs)))
1913 {
1914 if (gimple_clobber_p (stmt))
1915 {
1916 rhs = build_constructor (TREE_TYPE (lhs), NULL);
1917 TREE_THIS_VOLATILE (rhs) = 1;
1918 }
1919 else
1920 rhs = fold_build1 (VIEW_CONVERT_EXPR,
1921 TREE_TYPE (lhs), rhs);
1922 }
1923 if (gimple_assign_lhs (stmt) != lhs)
1924 gimple_assign_set_lhs (stmt, lhs);
1925
1926 if (gimple_assign_rhs1 (stmt) != rhs)
1927 {
1928 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
1929 gimple_assign_set_rhs_from_tree (&gsi, rhs);
1930 }
1931 }
1932
1933 else if (gimple_code (stmt) == GIMPLE_CALL)
1934 {
1935 unsigned i;
1936 if (optimize_atomic_compare_exchange_p (stmt))
1937 {
1938 tree expected = gimple_call_arg (stmt, 1);
1939 if (bitmap_bit_p (suitable_for_renaming,
1940 DECL_UID (TREE_OPERAND (expected, 0))))
1941 {
1942 fold_builtin_atomic_compare_exchange (&gsi);
1943 continue;
1944 }
1945 }
1946 else if (is_asan_mark_p (stmt))
1947 {
1948 tree var = TREE_OPERAND (gimple_call_arg (stmt, 1), 0);
1949 if (bitmap_bit_p (suitable_for_renaming, DECL_UID (var)))
1950 {
1951 unlink_stmt_vdef (stmt);
1952 if (asan_mark_p (stmt, ASAN_MARK_POISON))
1953 {
1954 gcall *call
1955 = gimple_build_call_internal (IFN_ASAN_POISON, 0);
1956 gimple_call_set_lhs (call, var);
1957 gsi_replace (&gsi, call, GSI_SAME_STMT);
1958 }
1959 else
1960 {
1961 /* In ASAN_MARK (UNPOISON, &b, ...) the variable
1962 is uninitialized. Avoid dependencies on
1963 previous out of scope value. */
1964 tree clobber
1965 = build_constructor (TREE_TYPE (var), NULL);
1966 TREE_THIS_VOLATILE (clobber) = 1;
1967 gimple *g = gimple_build_assign (var, clobber);
1968 gsi_replace (&gsi, g, GSI_SAME_STMT);
1969 }
1970 continue;
1971 }
1972 }
1973 else if (gimple_call_internal_p (stmt, IFN_GOMP_SIMT_ENTER))
1974 for (i = 1; i < gimple_call_num_args (stmt); i++)
1975 {
1976 tree *argp = gimple_call_arg_ptr (stmt, i);
1977 if (*argp == null_pointer_node)
1978 continue;
1979 gcc_assert (TREE_CODE (*argp) == ADDR_EXPR
1980 && VAR_P (TREE_OPERAND (*argp, 0)));
1981 tree var = TREE_OPERAND (*argp, 0);
1982 if (bitmap_bit_p (suitable_for_renaming, DECL_UID (var)))
1983 *argp = null_pointer_node;
1984 }
1985 for (i = 0; i < gimple_call_num_args (stmt); ++i)
1986 {
1987 tree *argp = gimple_call_arg_ptr (stmt, i);
1988 maybe_rewrite_mem_ref_base (argp, suitable_for_renaming);
1989 }
1990 }
1991
1992 else if (gimple_code (stmt) == GIMPLE_ASM)
1993 {
1994 gasm *asm_stmt = as_a <gasm *> (stmt);
1995 unsigned i;
1996 for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i)
1997 {
1998 tree link = gimple_asm_output_op (asm_stmt, i);
1999 maybe_rewrite_mem_ref_base (&TREE_VALUE (link),
2000 suitable_for_renaming);
2001 }
2002 for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i)
2003 {
2004 tree link = gimple_asm_input_op (asm_stmt, i);
2005 maybe_rewrite_mem_ref_base (&TREE_VALUE (link),
2006 suitable_for_renaming);
2007 }
2008 }
2009
2010 else if (gimple_debug_bind_p (stmt)
2011 && gimple_debug_bind_has_value_p (stmt))
2012 {
2013 tree *valuep = gimple_debug_bind_get_value_ptr (stmt);
2014 tree decl;
2015 maybe_rewrite_mem_ref_base (valuep, suitable_for_renaming);
2016 decl = non_rewritable_mem_ref_base (*valuep);
2017 if (decl
2018 && bitmap_bit_p (suitable_for_renaming, DECL_UID (decl)))
2019 gimple_debug_bind_reset_value (stmt);
2020 }
2021
2022 if (gimple_references_memory_p (stmt)
2023 || is_gimple_debug (stmt))
2024 update_stmt (stmt);
2025
2026 gsi_next (&gsi);
2027 }
2028
2029 /* Update SSA form here, we are called as non-pass as well. */
2030 if (number_of_loops (cfun) > 1
2031 && loops_state_satisfies_p (LOOP_CLOSED_SSA))
2032 rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa);
2033 else
2034 update_ssa (TODO_update_ssa);
2035 }
2036
2037 timevar_pop (TV_ADDRESS_TAKEN);
2038}
2039
2040namespace {
2041
2042const pass_data pass_data_update_address_taken =
2043{
2044 GIMPLE_PASS, /* type */
2045 "addressables", /* name */
2046 OPTGROUP_NONE, /* optinfo_flags */
2047 TV_ADDRESS_TAKEN, /* tv_id */
2048 PROP_ssa, /* properties_required */
2049 0, /* properties_provided */
2050 0, /* properties_destroyed */
2051 0, /* todo_flags_start */
2052 TODO_update_address_taken, /* todo_flags_finish */
2053};
2054
2055class pass_update_address_taken : public gimple_opt_pass
2056{
2057public:
2058 pass_update_address_taken (gcc::context *ctxt)
2059 : gimple_opt_pass (pass_data_update_address_taken, ctxt)
2060 {}
2061
2062 /* opt_pass methods: */
2063
2064}; // class pass_update_address_taken
2065
2066} // anon namespace
2067
2068gimple_opt_pass *
2069make_pass_update_address_taken (gcc::context *ctxt)
2070{
2071 return new pass_update_address_taken (ctxt);
2072}
2073