1 /* Predicate aware uninitialized variable warning.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008 Free Software
4 Contributed by Xinliang David Li <davidxl@google.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
31 #include "langhooks.h"
32 #include "hard-reg-set.h"
33 #include "basic-block.h"
37 #include "diagnostic.h"
39 #include "pointer-set.h"
40 #include "tree-flow.h"
42 #include "tree-inline.h"
45 #include "tree-dump.h"
46 #include "tree-pass.h"
50 /* This implements the pass that does predicate aware warning on uses of
51 possibly uninitialized variables. The pass first collects the set of
52 possibly uninitialized SSA names. For each such name, it walks through
53 all its immediate uses. For each immediate use, it rebuilds the condition
54 expression (the predicate) that guards the use. The predicate is then
55 examined to see if the variable is always defined under that same condition.
56 This is done either by pruning the unrealizable paths that lead to the
57 default definitions or by checking if the predicate set that guards the
58 defining paths is a superset of the use predicate. */
61 /* Pointer set of potentially undefined ssa names, i.e.,
62 ssa names that are defined by phi with operands that
63 are not defined or potentially undefined. */
64 static struct pointer_set_t *possibly_undefined_names = 0;
66 /* Bit mask handling macros. */
67 #define MASK_SET_BIT(mask, pos) mask |= (1 << pos)
68 #define MASK_TEST_BIT(mask, pos) (mask & (1 << pos))
69 #define MASK_EMPTY(mask) (mask == 0)
71 /* Returns the first bit position (starting from LSB)
72 in mask that is non zero. Returns -1 if the mask is empty. */
74 get_mask_first_set_bit (unsigned mask)
80 while ((mask & (1 << pos)) == 0)
85 #define MASK_FIRST_SET_BIT(mask) get_mask_first_set_bit (mask)
88 /* Return true if T, an SSA_NAME, has an undefined value. */
91 ssa_undefined_value_p (tree t)
93 tree var = SSA_NAME_VAR (t);
95 /* Parameters get their initial value from the function entry. */
96 if (TREE_CODE (var) == PARM_DECL)
99 /* Hard register variables get their initial value from the ether. */
100 if (TREE_CODE (var) == VAR_DECL && DECL_HARD_REGISTER (var))
103 /* The value is undefined iff its definition statement is empty. */
104 return (gimple_nop_p (SSA_NAME_DEF_STMT (t))
105 || (possibly_undefined_names
106 && pointer_set_contains (possibly_undefined_names, t)));
109 /* Checks if the operand OPND of PHI is defined by
110 another phi with one operand defined by this PHI,
111 but the rest operands are all defined. If yes,
112 returns true to skip this this operand as being
113 redundant. Can be enhanced to be more general. */
116 can_skip_redundant_opnd (tree opnd, gimple phi)
122 phi_def = gimple_phi_result (phi);
123 op_def = SSA_NAME_DEF_STMT (opnd);
124 if (gimple_code (op_def) != GIMPLE_PHI)
126 n = gimple_phi_num_args (op_def);
127 for (i = 0; i < n; ++i)
129 tree op = gimple_phi_arg_def (op_def, i);
130 if (TREE_CODE (op) != SSA_NAME)
132 if (op != phi_def && ssa_undefined_value_p (op))
139 /* Returns a bit mask holding the positions of arguments in PHI
140 that have empty (or possibly empty) definitions. */
143 compute_uninit_opnds_pos (gimple phi)
146 unsigned uninit_opnds = 0;
148 n = gimple_phi_num_args (phi);
150 for (i = 0; i < n; ++i)
152 tree op = gimple_phi_arg_def (phi, i);
153 if (TREE_CODE (op) == SSA_NAME
154 && ssa_undefined_value_p (op)
155 && !can_skip_redundant_opnd (op, phi))
156 MASK_SET_BIT (uninit_opnds, i);
161 /* Find the immediate postdominator PDOM of the specified
162 basic block BLOCK. */
164 static inline basic_block
165 find_pdom (basic_block block)
167 if (block == EXIT_BLOCK_PTR)
168 return EXIT_BLOCK_PTR;
172 = get_immediate_dominator (CDI_POST_DOMINATORS, block);
174 return EXIT_BLOCK_PTR;
179 /* Find the immediate DOM of the specified
180 basic block BLOCK. */
182 static inline basic_block
183 find_dom (basic_block block)
185 if (block == ENTRY_BLOCK_PTR)
186 return ENTRY_BLOCK_PTR;
189 basic_block bb = get_immediate_dominator (CDI_DOMINATORS, block);
191 return ENTRY_BLOCK_PTR;
196 /* Returns true if BB1 is postdominating BB2 and BB1 is
197 not a loop exit bb. The loop exit bb check is simple and does
198 not cover all cases. */
201 is_non_loop_exit_postdominating (basic_block bb1, basic_block bb2)
203 if (!dominated_by_p (CDI_POST_DOMINATORS, bb2, bb1))
206 if (single_pred_p (bb1) && !single_succ_p (bb2))
212 /* Find the closest postdominator of a specified BB, which is control
215 static inline basic_block
216 find_control_equiv_block (basic_block bb)
220 pdom = find_pdom (bb);
222 /* Skip the postdominating bb that is also loop exit. */
223 if (!is_non_loop_exit_postdominating (pdom, bb))
226 if (dominated_by_p (CDI_DOMINATORS, pdom, bb))
232 #define MAX_NUM_CHAINS 8
233 #define MAX_CHAIN_LEN 5
235 /* Computes the control dependence chains (paths of edges)
236 for DEP_BB up to the dominating basic block BB (the head node of a
237 chain should be dominated by it). CD_CHAINS is pointer to a
238 dynamic array holding the result chains. CUR_CD_CHAIN is the current
239 chain being computed. *NUM_CHAINS is total number of chains. The
240 function returns true if the information is successfully computed,
241 return false if there is no control dependence or not computed. */
244 compute_control_dep_chain (basic_block bb, basic_block dep_bb,
245 VEC(edge, heap) **cd_chains,
247 VEC(edge, heap) **cur_cd_chain)
252 bool found_cd_chain = false;
253 size_t cur_chain_len = 0;
255 if (EDGE_COUNT (bb->succs) < 2)
258 /* Could use a set instead. */
259 cur_chain_len = VEC_length (edge, *cur_cd_chain);
260 if (cur_chain_len > MAX_CHAIN_LEN)
263 for (i = 0; i < cur_chain_len; i++)
265 edge e = VEC_index (edge, *cur_cd_chain, i);
266 /* cycle detected. */
271 FOR_EACH_EDGE (e, ei, bb->succs)
274 if (e->flags & (EDGE_FAKE | EDGE_ABNORMAL))
278 VEC_safe_push (edge, heap, *cur_cd_chain, e);
279 while (!is_non_loop_exit_postdominating (cd_bb, bb))
283 /* Found a direct control dependence. */
284 if (*num_chains < MAX_NUM_CHAINS)
286 cd_chains[*num_chains]
287 = VEC_copy (edge, heap, *cur_cd_chain);
290 found_cd_chain = true;
291 /* check path from next edge. */
295 /* Now check if DEP_BB is indirectly control dependent on BB. */
296 if (compute_control_dep_chain (cd_bb, dep_bb, cd_chains,
297 num_chains, cur_cd_chain))
299 found_cd_chain = true;
303 cd_bb = find_pdom (cd_bb);
304 if (cd_bb == EXIT_BLOCK_PTR)
307 VEC_pop (edge, *cur_cd_chain);
308 gcc_assert (VEC_length (edge, *cur_cd_chain) == cur_chain_len);
310 gcc_assert (VEC_length (edge, *cur_cd_chain) == cur_chain_len);
312 return found_cd_chain;
315 typedef struct use_pred_info
321 DEF_VEC_P(use_pred_info_t);
322 DEF_VEC_ALLOC_P(use_pred_info_t, heap);
325 /* Converts the chains of control dependence edges into a set of
326 predicates. A control dependence chain is represented by a vector
327 edges. DEP_CHAINS points to an array of dependence chains.
328 NUM_CHAINS is the size of the chain array. One edge in a dependence
329 chain is mapped to predicate expression represented by use_pred_info_t
330 type. One dependence chain is converted to a composite predicate that
331 is the result of AND operation of use_pred_info_t mapped to each edge.
332 A composite predicate is presented by a vector of use_pred_info_t. On
333 return, *PREDS points to the resulting array of composite predicates.
334 *NUM_PREDS is the number of composite predictes. */
337 convert_control_dep_chain_into_preds (VEC(edge, heap) **dep_chains,
339 VEC(use_pred_info_t, heap) ***preds,
342 bool has_valid_pred = false;
344 if (num_chains == 0 || num_chains >= MAX_NUM_CHAINS)
347 /* Now convert CD chains into predicates */
348 has_valid_pred = true;
350 /* Now convert the control dep chain into a set
352 *preds = XCNEWVEC (VEC(use_pred_info_t, heap) *,
354 *num_preds = num_chains;
356 for (i = 0; i < num_chains; i++)
358 VEC(edge, heap) *one_cd_chain = dep_chains[i];
359 for (j = 0; j < VEC_length (edge, one_cd_chain); j++)
362 gimple_stmt_iterator gsi;
363 basic_block guard_bb;
364 use_pred_info_t one_pred;
367 e = VEC_index (edge, one_cd_chain, j);
369 gsi = gsi_last_bb (guard_bb);
372 has_valid_pred = false;
375 cond_stmt = gsi_stmt (gsi);
376 if (gimple_code (cond_stmt) == GIMPLE_CALL
377 && EDGE_COUNT (e->src->succs) >= 2)
379 /* Ignore EH edge. Can add assertion
380 on the other edge's flag. */
383 /* Skip if there is essentially one succesor. */
384 if (EDGE_COUNT (e->src->succs) == 2)
390 FOR_EACH_EDGE (e1, ei1, e->src->succs)
392 if (EDGE_COUNT (e1->dest->succs) == 0)
401 if (gimple_code (cond_stmt) != GIMPLE_COND)
403 has_valid_pred = false;
406 one_pred = XNEW (struct use_pred_info);
407 one_pred->cond = cond_stmt;
408 one_pred->invert = !!(e->flags & EDGE_FALSE_VALUE);
409 VEC_safe_push (use_pred_info_t, heap, (*preds)[i], one_pred);
415 return has_valid_pred;
418 /* Computes all control dependence chains for USE_BB. The control
419 dependence chains are then converted to an array of composite
420 predicates pointed to by PREDS. PHI_BB is the basic block of
421 the phi whose result is used in USE_BB. */
424 find_predicates (VEC(use_pred_info_t, heap) ***preds,
429 size_t num_chains = 0, i;
430 VEC(edge, heap) **dep_chains = 0;
431 VEC(edge, heap) *cur_chain = 0;
432 bool has_valid_pred = false;
433 basic_block cd_root = 0;
435 dep_chains = XCNEWVEC (VEC(edge, heap) *, MAX_NUM_CHAINS);
437 /* First find the closest bb that is control equivalent to PHI_BB
438 that also dominates USE_BB. */
440 while (dominated_by_p (CDI_DOMINATORS, use_bb, cd_root))
442 basic_block ctrl_eq_bb = find_control_equiv_block (cd_root);
443 if (ctrl_eq_bb && dominated_by_p (CDI_DOMINATORS, use_bb, ctrl_eq_bb))
444 cd_root = ctrl_eq_bb;
449 compute_control_dep_chain (cd_root, use_bb,
450 dep_chains, &num_chains,
454 = convert_control_dep_chain_into_preds (dep_chains,
458 /* Free individual chain */
459 VEC_free (edge, heap, cur_chain);
460 for (i = 0; i < num_chains; i++)
461 VEC_free (edge, heap, dep_chains[i]);
463 return has_valid_pred;
466 /* Computes the set of incoming edges of PHI that have non empty
467 definitions of a phi chain. The collection will be done
468 recursively on operands that are defined by phis. CD_ROOT
469 is the control dependence root. *EDGES holds the result, and
470 VISITED_PHIS is a pointer set for detecting cycles. */
473 collect_phi_def_edges (gimple phi, basic_block cd_root,
474 VEC(edge, heap) **edges,
475 struct pointer_set_t *visited_phis)
481 if (pointer_set_insert (visited_phis, phi))
484 n = gimple_phi_num_args (phi);
485 for (i = 0; i < n; i++)
487 opnd_edge = gimple_phi_arg_edge (phi, i);
488 opnd = gimple_phi_arg_def (phi, i);
490 if (TREE_CODE (opnd) != SSA_NAME
491 || !ssa_undefined_value_p (opnd))
492 VEC_safe_push (edge, heap, *edges, opnd_edge);
495 gimple def = SSA_NAME_DEF_STMT (opnd);
496 if (gimple_code (def) == GIMPLE_PHI
497 && dominated_by_p (CDI_DOMINATORS,
498 gimple_bb (def), cd_root))
499 collect_phi_def_edges (def, cd_root, edges,
505 /* For each use edge of PHI, computes all control dependence chains.
506 The control dependence chains are then converted to an array of
507 composite predicates pointed to by PREDS. */
510 find_def_preds (VEC(use_pred_info_t, heap) ***preds,
511 size_t *num_preds, gimple phi)
513 size_t num_chains = 0, i, n;
514 VEC(edge, heap) **dep_chains = 0;
515 VEC(edge, heap) *cur_chain = 0;
516 VEC(edge, heap) *def_edges = 0;
517 bool has_valid_pred = false;
518 basic_block phi_bb, cd_root = 0;
519 struct pointer_set_t *visited_phis;
521 dep_chains = XCNEWVEC (VEC(edge, heap) *, MAX_NUM_CHAINS);
523 phi_bb = gimple_bb (phi);
524 /* First find the closest dominating bb to be
525 the control dependence root */
526 cd_root = find_dom (phi_bb);
530 visited_phis = pointer_set_create ();
531 collect_phi_def_edges (phi, cd_root, &def_edges, visited_phis);
532 pointer_set_destroy (visited_phis);
534 n = VEC_length (edge, def_edges);
538 for (i = 0; i < n; i++)
543 opnd_edge = VEC_index (edge, def_edges, i);
544 prev_nc = num_chains;
545 compute_control_dep_chain (cd_root, opnd_edge->src,
546 dep_chains, &num_chains,
548 /* Free individual chain */
549 VEC_free (edge, heap, cur_chain);
552 /* Now update the newly added chains with
553 the phi operand edge: */
554 if (EDGE_COUNT (opnd_edge->src->succs) > 1)
556 if (prev_nc == num_chains
557 && num_chains < MAX_NUM_CHAINS)
559 for (j = prev_nc; j < num_chains; j++)
561 VEC_safe_push (edge, heap, dep_chains[j], opnd_edge);
567 = convert_control_dep_chain_into_preds (dep_chains,
571 for (i = 0; i < num_chains; i++)
572 VEC_free (edge, heap, dep_chains[i]);
574 return has_valid_pred;
577 /* Dumps the predicates (PREDS) for USESTMT. */
580 dump_predicates (gimple usestmt, size_t num_preds,
581 VEC(use_pred_info_t, heap) **preds,
585 VEC(use_pred_info_t, heap) *one_pred_chain;
586 fprintf (dump_file, msg);
587 print_gimple_stmt (dump_file, usestmt, 0, 0);
588 fprintf (dump_file, "is guarded by :\n");
589 /* do some dumping here: */
590 for (i = 0; i < num_preds; i++)
594 one_pred_chain = preds[i];
595 np = VEC_length (use_pred_info_t, one_pred_chain);
597 for (j = 0; j < np; j++)
599 use_pred_info_t one_pred
600 = VEC_index (use_pred_info_t, one_pred_chain, j);
601 if (one_pred->invert)
602 fprintf (dump_file, " (.NOT.) ");
603 print_gimple_stmt (dump_file, one_pred->cond, 0, 0);
605 fprintf (dump_file, "(.AND.)\n");
607 if (i < num_preds - 1)
608 fprintf (dump_file, "(.OR.)\n");
612 /* Destroys the predicate set *PREDS. */
615 destroy_predicate_vecs (size_t n,
616 VEC(use_pred_info_t, heap) ** preds)
619 for (i = 0; i < n; i++)
621 for (j = 0; j < VEC_length (use_pred_info_t, preds[i]); j++)
622 free (VEC_index (use_pred_info_t, preds[i], j));
623 VEC_free (use_pred_info_t, heap, preds[i]);
629 /* Computes the 'normalized' conditional code with operand
630 swapping and condition inversion. */
632 static enum tree_code
633 get_cmp_code (enum tree_code orig_cmp_code,
634 bool swap_cond, bool invert)
636 enum tree_code tc = orig_cmp_code;
639 tc = swap_tree_comparison (orig_cmp_code);
641 tc = invert_tree_comparison (tc, false);
658 /* Returns true if VAL falls in the range defined by BOUNDARY and CMPC, i.e.
659 all values in the range satisfies (x CMPC BOUNDARY) == true. */
662 is_value_included_in (tree val, tree boundary, enum tree_code cmpc)
664 bool inverted = false;
668 /* Only handle integer constant here. */
669 if (TREE_CODE (val) != INTEGER_CST
670 || TREE_CODE (boundary) != INTEGER_CST)
673 is_unsigned = TYPE_UNSIGNED (TREE_TYPE (val));
675 if (cmpc == GE_EXPR || cmpc == GT_EXPR
678 cmpc = invert_tree_comparison (cmpc, false);
685 result = tree_int_cst_equal (val, boundary);
686 else if (cmpc == LT_EXPR)
687 result = INT_CST_LT_UNSIGNED (val, boundary);
690 gcc_assert (cmpc == LE_EXPR);
691 result = (tree_int_cst_equal (val, boundary)
692 || INT_CST_LT_UNSIGNED (val, boundary));
698 result = tree_int_cst_equal (val, boundary);
699 else if (cmpc == LT_EXPR)
700 result = INT_CST_LT (val, boundary);
703 gcc_assert (cmpc == LE_EXPR);
704 result = (tree_int_cst_equal (val, boundary)
705 || INT_CST_LT (val, boundary));
715 /* Returns true if PRED is common among all the predicate
716 chains (PREDS) (and therefore can be factored out).
717 NUM_PRED_CHAIN is the size of array PREDS. */
720 find_matching_predicate_in_rest_chains (use_pred_info_t pred,
721 VEC(use_pred_info_t, heap) **preds,
722 size_t num_pred_chains)
727 if (num_pred_chains == 1)
730 for (i = 1; i < num_pred_chains; i++)
733 VEC(use_pred_info_t, heap) *one_chain = preds[i];
734 n = VEC_length (use_pred_info_t, one_chain);
735 for (j = 0; j < n; j++)
737 use_pred_info_t pred2
738 = VEC_index (use_pred_info_t, one_chain, j);
739 /* can relax the condition comparison to not
740 use address comparison. However, the most common
741 case is that multiple control dependent paths share
742 a common path prefix, so address comparison should
745 if (pred2->cond == pred->cond
746 && pred2->invert == pred->invert)
758 /* Forward declaration. */
760 is_use_properly_guarded (gimple use_stmt,
763 unsigned uninit_opnds,
764 struct pointer_set_t *visited_phis);
766 /* A helper function that determines if the predicate set
767 of the use is not overlapping with that of the uninit paths.
768 The most common senario of guarded use is in Example 1:
781 The real world examples are usually more complicated, but similar
782 and usually result from inlining:
784 bool init_func (int * x)
803 Another possible use scenario is in the following trivial example:
815 Predicate analysis needs to compute the composite predicate:
817 1) 'x' use predicate: (n > 0) .AND. (m < 2)
818 2) 'x' default value (non-def) predicate: .NOT. (n > 0)
819 (the predicate chain for phi operand defs can be computed
820 starting from a bb that is control equivalent to the phi's
821 bb and is dominating the operand def.)
823 and check overlapping:
824 (n > 0) .AND. (m < 2) .AND. (.NOT. (n > 0))
827 This implementation provides framework that can handle
828 scenarios. (Note that many simple cases are handled properly
829 without the predicate analysis -- this is due to jump threading
830 transformation which eliminates the merge point thus makes
831 path sensitive analysis unnecessary.)
833 NUM_PREDS is the number is the number predicate chains, PREDS is
834 the array of chains, PHI is the phi node whose incoming (undefined)
835 paths need to be pruned, and UNINIT_OPNDS is the bitmap holding
836 uninit operand positions. VISITED_PHIS is the pointer set of phi
837 stmts being checked. */
841 use_pred_not_overlap_with_undef_path_pred (
843 VEC(use_pred_info_t, heap) **preds,
844 gimple phi, unsigned uninit_opnds,
845 struct pointer_set_t *visited_phis)
849 tree boundary_cst = 0;
850 enum tree_code cmp_code;
851 bool swap_cond = false;
853 VEC(use_pred_info_t, heap) *the_pred_chain;
855 gcc_assert (num_preds > 0);
856 /* Find within the common prefix of multiple predicate chains
857 a predicate that is a comparison of a flag variable against
859 the_pred_chain = preds[0];
860 n = VEC_length (use_pred_info_t, the_pred_chain);
861 for (i = 0; i < n; i++)
864 tree cond_lhs, cond_rhs, flag = 0;
866 use_pred_info_t the_pred
867 = VEC_index (use_pred_info_t, the_pred_chain, i);
869 cond = the_pred->cond;
870 invert = the_pred->invert;
871 cond_lhs = gimple_cond_lhs (cond);
872 cond_rhs = gimple_cond_rhs (cond);
873 cmp_code = gimple_cond_code (cond);
875 if (cond_lhs != NULL_TREE && TREE_CODE (cond_lhs) == SSA_NAME
876 && cond_rhs != NULL_TREE && is_gimple_constant (cond_rhs))
878 boundary_cst = cond_rhs;
881 else if (cond_rhs != NULL_TREE && TREE_CODE (cond_rhs) == SSA_NAME
882 && cond_lhs != NULL_TREE && is_gimple_constant (cond_lhs))
884 boundary_cst = cond_lhs;
892 flag_def = SSA_NAME_DEF_STMT (flag);
897 if ((gimple_code (flag_def) == GIMPLE_PHI)
898 && (gimple_bb (flag_def) == gimple_bb (phi))
899 && find_matching_predicate_in_rest_chains (
900 the_pred, preds, num_preds))
909 /* Now check all the uninit incoming edge has a constant flag value
910 that is in conflict with the use guard/predicate. */
911 cmp_code = get_cmp_code (cmp_code, swap_cond, invert);
913 if (cmp_code == ERROR_MARK)
916 for (i = 0; i < sizeof (unsigned); i++)
920 if (!MASK_TEST_BIT (uninit_opnds, i))
923 flag_arg = gimple_phi_arg_def (flag_def, i);
924 if (!is_gimple_constant (flag_arg))
927 /* Now check if the constant is in the guarded range. */
928 if (is_value_included_in (flag_arg, boundary_cst, cmp_code))
933 /* Now that we know that this undefined edge is not
934 pruned. If the operand is defined by another phi,
935 we can further prune the incoming edges of that
936 phi by checking the predicates of this operands. */
938 opnd = gimple_phi_arg_def (phi, i);
939 opnd_def = SSA_NAME_DEF_STMT (opnd);
940 if (gimple_code (opnd_def) == GIMPLE_PHI)
943 unsigned uninit_opnds2
944 = compute_uninit_opnds_pos (opnd_def);
945 gcc_assert (!MASK_EMPTY (uninit_opnds2));
946 opnd_edge = gimple_phi_arg_edge (phi, i);
947 if (!is_use_properly_guarded (phi,
962 /* Returns true if TC is AND or OR */
965 is_and_or_or (enum tree_code tc, tree typ)
967 return (tc == TRUTH_AND_EXPR
968 || tc == TRUTH_OR_EXPR
969 || tc == BIT_IOR_EXPR
970 || (tc == BIT_AND_EXPR
971 && (typ == 0 || TREE_CODE (typ) == BOOLEAN_TYPE)));
974 typedef struct norm_cond
976 VEC(gimple, heap) *conds;
977 enum tree_code cond_code;
982 /* Normalizes gimple condition COND. The normalization follows
983 UD chains to form larger condition expression trees. NORM_COND
984 holds the normalized result. COND_CODE is the logical opcode
985 (AND or OR) of the normalized tree. */
988 normalize_cond_1 (gimple cond,
989 norm_cond_t norm_cond,
990 enum tree_code cond_code)
993 enum tree_code cur_cond_code;
996 gc = gimple_code (cond);
997 if (gc != GIMPLE_ASSIGN)
999 VEC_safe_push (gimple, heap, norm_cond->conds, cond);
1003 cur_cond_code = gimple_assign_rhs_code (cond);
1004 rhs1 = gimple_assign_rhs1 (cond);
1005 rhs2 = gimple_assign_rhs2 (cond);
1006 if (cur_cond_code == NE_EXPR)
1008 if (integer_zerop (rhs2)
1009 && (TREE_CODE (rhs1) == SSA_NAME))
1011 SSA_NAME_DEF_STMT (rhs1),
1012 norm_cond, cond_code);
1013 else if (integer_zerop (rhs1)
1014 && (TREE_CODE (rhs2) == SSA_NAME))
1016 SSA_NAME_DEF_STMT (rhs2),
1017 norm_cond, cond_code);
1019 VEC_safe_push (gimple, heap, norm_cond->conds, cond);
1024 if (is_and_or_or (cur_cond_code, TREE_TYPE (rhs1))
1025 && (cond_code == cur_cond_code || cond_code == ERROR_MARK)
1026 && (TREE_CODE (rhs1) == SSA_NAME && TREE_CODE (rhs2) == SSA_NAME))
1028 normalize_cond_1 (SSA_NAME_DEF_STMT (rhs1),
1029 norm_cond, cur_cond_code);
1030 normalize_cond_1 (SSA_NAME_DEF_STMT (rhs2),
1031 norm_cond, cur_cond_code);
1032 norm_cond->cond_code = cur_cond_code;
1035 VEC_safe_push (gimple, heap, norm_cond->conds, cond);
1038 /* See normalize_cond_1 for details. INVERT is a flag to indicate
1039 if COND needs to be inverted or not. */
1042 normalize_cond (gimple cond, norm_cond_t norm_cond, bool invert)
1044 enum tree_code cond_code;
1046 norm_cond->cond_code = ERROR_MARK;
1047 norm_cond->invert = false;
1048 norm_cond->conds = NULL;
1049 gcc_assert (gimple_code (cond) == GIMPLE_COND);
1050 cond_code = gimple_cond_code (cond);
1052 cond_code = invert_tree_comparison (cond_code, false);
1054 if (cond_code == NE_EXPR)
1056 if (integer_zerop (gimple_cond_rhs (cond))
1057 && (TREE_CODE (gimple_cond_lhs (cond)) == SSA_NAME))
1059 SSA_NAME_DEF_STMT (gimple_cond_lhs (cond)),
1060 norm_cond, ERROR_MARK);
1061 else if (integer_zerop (gimple_cond_lhs (cond))
1062 && (TREE_CODE (gimple_cond_rhs (cond)) == SSA_NAME))
1064 SSA_NAME_DEF_STMT (gimple_cond_rhs (cond)),
1065 norm_cond, ERROR_MARK);
1068 VEC_safe_push (gimple, heap, norm_cond->conds, cond);
1069 norm_cond->invert = invert;
1074 VEC_safe_push (gimple, heap, norm_cond->conds, cond);
1075 norm_cond->invert = invert;
1078 gcc_assert (VEC_length (gimple, norm_cond->conds) == 1
1079 || is_and_or_or (norm_cond->cond_code, NULL));
1082 /* Returns true if the domain for condition COND1 is a subset of
1083 COND2. REVERSE is a flag. when it is true the function checks
1084 if COND1 is a superset of COND2. INVERT1 and INVERT2 are flags
1085 to indicate if COND1 and COND2 need to be inverted or not. */
1088 is_gcond_subset_of (gimple cond1, bool invert1,
1089 gimple cond2, bool invert2,
1092 enum gimple_code gc1, gc2;
1093 enum tree_code cond1_code, cond2_code;
1095 tree cond1_lhs, cond1_rhs, cond2_lhs, cond2_rhs;
1097 /* Take the short cut. */
1108 gc1 = gimple_code (cond1);
1109 gc2 = gimple_code (cond2);
1111 if ((gc1 != GIMPLE_ASSIGN && gc1 != GIMPLE_COND)
1112 || (gc2 != GIMPLE_ASSIGN && gc2 != GIMPLE_COND))
1113 return cond1 == cond2;
1115 cond1_code = ((gc1 == GIMPLE_ASSIGN)
1116 ? gimple_assign_rhs_code (cond1)
1117 : gimple_cond_code (cond1));
1119 cond2_code = ((gc2 == GIMPLE_ASSIGN)
1120 ? gimple_assign_rhs_code (cond2)
1121 : gimple_cond_code (cond2));
1123 if (TREE_CODE_CLASS (cond1_code) != tcc_comparison
1124 || TREE_CODE_CLASS (cond2_code) != tcc_comparison)
1128 cond1_code = invert_tree_comparison (cond1_code, false);
1130 cond2_code = invert_tree_comparison (cond2_code, false);
1132 cond1_lhs = ((gc1 == GIMPLE_ASSIGN)
1133 ? gimple_assign_rhs1 (cond1)
1134 : gimple_cond_lhs (cond1));
1135 cond1_rhs = ((gc1 == GIMPLE_ASSIGN)
1136 ? gimple_assign_rhs2 (cond1)
1137 : gimple_cond_rhs (cond1));
1138 cond2_lhs = ((gc2 == GIMPLE_ASSIGN)
1139 ? gimple_assign_rhs1 (cond2)
1140 : gimple_cond_lhs (cond2));
1141 cond2_rhs = ((gc2 == GIMPLE_ASSIGN)
1142 ? gimple_assign_rhs2 (cond2)
1143 : gimple_cond_rhs (cond2));
1145 /* Assuming const operands have been swapped to the
1146 rhs at this point of the analysis. */
1148 if (cond1_lhs != cond2_lhs)
1151 if (!is_gimple_constant (cond1_rhs)
1152 || TREE_CODE (cond1_rhs) != INTEGER_CST)
1153 return (cond1_rhs == cond2_rhs);
1155 if (!is_gimple_constant (cond2_rhs)
1156 || TREE_CODE (cond2_rhs) != INTEGER_CST)
1157 return (cond1_rhs == cond2_rhs);
1159 if (cond1_code == EQ_EXPR)
1160 return is_value_included_in (cond1_rhs,
1161 cond2_rhs, cond2_code);
1162 if (cond1_code == NE_EXPR || cond2_code == EQ_EXPR)
1163 return ((cond2_code == cond1_code)
1164 && tree_int_cst_equal (cond1_rhs, cond2_rhs));
1166 if (((cond1_code == GE_EXPR || cond1_code == GT_EXPR)
1167 && (cond2_code == LE_EXPR || cond2_code == LT_EXPR))
1168 || ((cond1_code == LE_EXPR || cond1_code == LT_EXPR)
1169 && (cond2_code == GE_EXPR || cond2_code == GT_EXPR)))
1172 if (cond1_code != GE_EXPR && cond1_code != GT_EXPR
1173 && cond1_code != LE_EXPR && cond1_code != LT_EXPR)
1176 if (cond1_code == GT_EXPR)
1178 cond1_code = GE_EXPR;
1179 cond1_rhs = fold_binary (PLUS_EXPR, TREE_TYPE (cond1_rhs),
1181 fold_convert (TREE_TYPE (cond1_rhs),
1184 else if (cond1_code == LT_EXPR)
1186 cond1_code = LE_EXPR;
1187 cond1_rhs = fold_binary (MINUS_EXPR, TREE_TYPE (cond1_rhs),
1189 fold_convert (TREE_TYPE (cond1_rhs),
1196 gcc_assert (cond1_code == GE_EXPR || cond1_code == LE_EXPR);
1198 if (cond2_code == GE_EXPR || cond2_code == GT_EXPR ||
1199 cond2_code == LE_EXPR || cond2_code == LT_EXPR)
1200 return is_value_included_in (cond1_rhs,
1201 cond2_rhs, cond2_code);
1202 else if (cond2_code == NE_EXPR)
1204 (is_value_included_in (cond1_rhs,
1205 cond2_rhs, cond2_code)
1206 && !is_value_included_in (cond2_rhs,
1207 cond1_rhs, cond1_code));
1211 /* Returns true if the domain of the condition expression
1212 in COND is a subset of any of the sub-conditions
1213 of the normalized condtion NORM_COND. INVERT is a flag
1214 to indicate of the COND needs to be inverted.
1215 REVERSE is a flag. When it is true, the check is reversed --
1216 it returns true if COND is a superset of any of the subconditions
1220 is_subset_of_any (gimple cond, bool invert,
1221 norm_cond_t norm_cond, bool reverse)
1224 size_t len = VEC_length (gimple, norm_cond->conds);
1226 for (i = 0; i < len; i++)
1228 if (is_gcond_subset_of (cond, invert,
1229 VEC_index (gimple, norm_cond->conds, i),
1236 /* NORM_COND1 and NORM_COND2 are normalized logical/BIT OR
1237 expressions (formed by following UD chains not control
1238 dependence chains). The function returns true of domain
1239 of and expression NORM_COND1 is a subset of NORM_COND2's.
1240 The implementation is conservative, and it returns false if
1241 it the inclusion relationship may not hold. */
1244 is_or_set_subset_of (norm_cond_t norm_cond1,
1245 norm_cond_t norm_cond2)
1248 size_t len = VEC_length (gimple, norm_cond1->conds);
1250 for (i = 0; i < len; i++)
1252 if (!is_subset_of_any (VEC_index (gimple, norm_cond1->conds, i),
1253 false, norm_cond2, false))
1259 /* NORM_COND1 and NORM_COND2 are normalized logical AND
1260 expressions (formed by following UD chains not control
1261 dependence chains). The function returns true of domain
1262 of and expression NORM_COND1 is a subset of NORM_COND2's. */
1265 is_and_set_subset_of (norm_cond_t norm_cond1,
1266 norm_cond_t norm_cond2)
1269 size_t len = VEC_length (gimple, norm_cond2->conds);
1271 for (i = 0; i < len; i++)
1273 if (!is_subset_of_any (VEC_index (gimple, norm_cond2->conds, i),
1274 false, norm_cond1, true))
1280 /* Returns true of the domain if NORM_COND1 is a subset
1281 of that of NORM_COND2. Returns false if it can not be
1285 is_norm_cond_subset_of (norm_cond_t norm_cond1,
1286 norm_cond_t norm_cond2)
1289 enum tree_code code1, code2;
1291 code1 = norm_cond1->cond_code;
1292 code2 = norm_cond2->cond_code;
1294 if (code1 == TRUTH_AND_EXPR || code1 == BIT_AND_EXPR)
1296 /* Both conditions are AND expressions. */
1297 if (code2 == TRUTH_AND_EXPR || code2 == BIT_AND_EXPR)
1298 return is_and_set_subset_of (norm_cond1, norm_cond2);
1299 /* NORM_COND1 is an AND expression, and NORM_COND2 is an OR
1300 expression. In this case, returns true if any subexpression
1301 of NORM_COND1 is a subset of any subexpression of NORM_COND2. */
1302 else if (code2 == TRUTH_OR_EXPR || code2 == BIT_IOR_EXPR)
1305 len1 = VEC_length (gimple, norm_cond1->conds);
1306 for (i = 0; i < len1; i++)
1308 gimple cond1 = VEC_index (gimple, norm_cond1->conds, i);
1309 if (is_subset_of_any (cond1, false, norm_cond2, false))
1316 gcc_assert (code2 == ERROR_MARK);
1317 gcc_assert (VEC_length (gimple, norm_cond2->conds) == 1);
1318 return is_subset_of_any (VEC_index (gimple, norm_cond2->conds, 0),
1319 norm_cond2->invert, norm_cond1, true);
1322 /* NORM_COND1 is an OR expression */
1323 else if (code1 == TRUTH_OR_EXPR || code1 == BIT_IOR_EXPR)
1328 return is_or_set_subset_of (norm_cond1, norm_cond2);
1332 gcc_assert (code1 == ERROR_MARK);
1333 gcc_assert (VEC_length (gimple, norm_cond1->conds) == 1);
1334 /* Conservatively returns false if NORM_COND1 is non-decomposible
1335 and NORM_COND2 is an AND expression. */
1336 if (code2 == TRUTH_AND_EXPR || code2 == BIT_AND_EXPR)
1339 if (code2 == TRUTH_OR_EXPR || code2 == BIT_IOR_EXPR)
1340 return is_subset_of_any (VEC_index (gimple, norm_cond1->conds, 0),
1341 norm_cond1->invert, norm_cond2, false);
1343 gcc_assert (code2 == ERROR_MARK);
1344 gcc_assert (VEC_length (gimple, norm_cond2->conds) == 1);
1345 return is_gcond_subset_of (VEC_index (gimple, norm_cond1->conds, 0),
1347 VEC_index (gimple, norm_cond2->conds, 0),
1348 norm_cond2->invert, false);
1352 /* Returns true of the domain of single predicate expression
1353 EXPR1 is a subset of that of EXPR2. Returns false if it
1354 can not be proved. */
1357 is_pred_expr_subset_of (use_pred_info_t expr1,
1358 use_pred_info_t expr2)
1360 gimple cond1, cond2;
1361 enum tree_code code1, code2;
1362 struct norm_cond norm_cond1, norm_cond2;
1363 bool is_subset = false;
1365 cond1 = expr1->cond;
1366 cond2 = expr2->cond;
1367 code1 = gimple_cond_code (cond1);
1368 code2 = gimple_cond_code (cond2);
1371 code1 = invert_tree_comparison (code1, false);
1373 code2 = invert_tree_comparison (code2, false);
1375 /* Fast path -- match exactly */
1376 if ((gimple_cond_lhs (cond1) == gimple_cond_lhs (cond2))
1377 && (gimple_cond_rhs (cond1) == gimple_cond_rhs (cond2))
1378 && (code1 == code2))
1381 /* Normalize conditions. To keep NE_EXPR, do not invert
1382 with both need inversion. */
1383 normalize_cond (cond1, &norm_cond1, (expr1->invert));
1384 normalize_cond (cond2, &norm_cond2, (expr2->invert));
1386 is_subset = is_norm_cond_subset_of (&norm_cond1, &norm_cond2);
1389 VEC_free (gimple, heap, norm_cond1.conds);
1390 VEC_free (gimple, heap, norm_cond2.conds);
1394 /* Returns true if the domain of PRED1 is a subset
1395 of that of PRED2. Returns false if it can not be proved so. */
1398 is_pred_chain_subset_of (VEC(use_pred_info_t, heap) *pred1,
1399 VEC(use_pred_info_t, heap) *pred2)
1401 size_t np1, np2, i1, i2;
1403 np1 = VEC_length (use_pred_info_t, pred1);
1404 np2 = VEC_length (use_pred_info_t, pred2);
1406 for (i2 = 0; i2 < np2; i2++)
1409 use_pred_info_t info2
1410 = VEC_index (use_pred_info_t, pred2, i2);
1411 for (i1 = 0; i1 < np1; i1++)
1413 use_pred_info_t info1
1414 = VEC_index (use_pred_info_t, pred1, i1);
1415 if (is_pred_expr_subset_of (info1, info2))
1427 /* Returns true if the domain defined by
1428 one pred chain ONE_PRED is a subset of the domain
1429 of *PREDS. It returns false if ONE_PRED's domain is
1430 not a subset of any of the sub-domains of PREDS (
1431 corresponding to each individual chains in it), even
1432 though it may be still be a subset of whole domain
1433 of PREDS which is the union (ORed) of all its subdomains.
1434 In other words, the result is conservative. */
1437 is_included_in (VEC(use_pred_info_t, heap) *one_pred,
1438 VEC(use_pred_info_t, heap) **preds,
1443 for (i = 0; i < n; i++)
1445 if (is_pred_chain_subset_of (one_pred, preds[i]))
1452 /* compares two predicate sets PREDS1 and PREDS2 and returns
1453 true if the domain defined by PREDS1 is a superset
1454 of PREDS2's domain. N1 and N2 are array sizes of PREDS1 and
1455 PREDS2 respectively. The implementation chooses not to build
1456 generic trees (and relying on the folding capability of the
1457 compiler), but instead performs brute force comparison of
1458 individual predicate chains (won't be a compile time problem
1459 as the chains are pretty short). When the function returns
1460 false, it does not necessarily mean *PREDS1 is not a superset
1461 of *PREDS2, but mean it may not be so since the analysis can
1462 not prove it. In such cases, false warnings may still be
1466 is_superset_of (VEC(use_pred_info_t, heap) **preds1,
1468 VEC(use_pred_info_t, heap) **preds2,
1472 VEC(use_pred_info_t, heap) *one_pred_chain;
1474 for (i = 0; i < n2; i++)
1476 one_pred_chain = preds2[i];
1477 if (!is_included_in (one_pred_chain, preds1, n1))
1484 /* Computes the predicates that guard the use and checks
1485 if the incoming paths that have empty (or possibly
1486 empty) defintion can be pruned/filtered. The function returns
1487 true if it can be determined that the use of PHI's def in
1488 USE_STMT is guarded with a predicate set not overlapping with
1489 predicate sets of all runtime paths that do not have a definition.
1490 Returns false if it is not or it can not be determined. USE_BB is
1491 the bb of the use (for phi operand use, the bb is not the bb of
1492 the phi stmt, but the src bb of the operand edge). UNINIT_OPNDS
1493 is a bit vector. If an operand of PHI is uninitialized, the
1494 correponding bit in the vector is 1. VISIED_PHIS is a pointer
1495 set of phis being visted. */
1498 is_use_properly_guarded (gimple use_stmt,
1501 unsigned uninit_opnds,
1502 struct pointer_set_t *visited_phis)
1505 VEC(use_pred_info_t, heap) **preds = 0;
1506 VEC(use_pred_info_t, heap) **def_preds = 0;
1507 size_t num_preds = 0, num_def_preds = 0;
1508 bool has_valid_preds = false;
1509 bool is_properly_guarded = false;
1511 if (pointer_set_insert (visited_phis, phi))
1514 phi_bb = gimple_bb (phi);
1516 if (is_non_loop_exit_postdominating (use_bb, phi_bb))
1519 has_valid_preds = find_predicates (&preds, &num_preds,
1522 if (!has_valid_preds)
1524 destroy_predicate_vecs (num_preds, preds);
1529 dump_predicates (use_stmt, num_preds, preds,
1532 has_valid_preds = find_def_preds (&def_preds,
1533 &num_def_preds, phi);
1535 if (has_valid_preds)
1538 dump_predicates (phi, num_def_preds, def_preds,
1539 "Operand defs of phi ");
1540 is_properly_guarded =
1541 is_superset_of (def_preds, num_def_preds,
1545 /* further prune the dead incoming phi edges. */
1546 if (!is_properly_guarded)
1548 = use_pred_not_overlap_with_undef_path_pred (
1549 num_preds, preds, phi, uninit_opnds, visited_phis);
1551 destroy_predicate_vecs (num_preds, preds);
1552 destroy_predicate_vecs (num_def_preds, def_preds);
1553 return is_properly_guarded;
1556 /* Searches through all uses of a potentially
1557 uninitialized variable defined by PHI and returns a use
1558 statement if the use is not properly guarded. It returns
1559 NULL if all uses are guarded. UNINIT_OPNDS is a bitvector
1560 holding the position(s) of uninit PHI operands. WORKLIST
1561 is the vector of candidate phis that may be updated by this
1562 function. ADDED_TO_WORKLIST is the pointer set tracking
1563 if the new phi is already in the worklist. */
1566 find_uninit_use (gimple phi, unsigned uninit_opnds,
1567 VEC(gimple, heap) **worklist,
1568 struct pointer_set_t *added_to_worklist)
1571 use_operand_p use_p;
1573 imm_use_iterator iter;
1575 phi_result = gimple_phi_result (phi);
1577 FOR_EACH_IMM_USE_FAST (use_p, iter, phi_result)
1579 struct pointer_set_t *visited_phis;
1582 use_stmt = use_p->loc.stmt;
1584 visited_phis = pointer_set_create ();
1586 use_bb = gimple_bb (use_stmt);
1587 if (gimple_code (use_stmt) == GIMPLE_PHI)
1590 n = gimple_phi_num_args (use_stmt);
1592 /* Find the matching phi argument of the use. */
1593 for (i = 0; i < n; ++i)
1595 if (gimple_phi_arg_def_ptr (use_stmt, i) == use_p->use)
1597 edge e = gimple_phi_arg_edge (use_stmt, i);
1604 if (is_use_properly_guarded (use_stmt,
1610 pointer_set_destroy (visited_phis);
1613 pointer_set_destroy (visited_phis);
1615 /* Found one real use, return. */
1616 if (gimple_code (use_stmt) != GIMPLE_PHI)
1619 /* Found a phi use that is not guarded,
1620 add the phi to the worklist. */
1621 if (!pointer_set_insert (added_to_worklist,
1624 VEC_safe_push (gimple, heap, *worklist, use_stmt);
1625 pointer_set_insert (possibly_undefined_names,
1633 /* Look for inputs to PHI that are SSA_NAMEs that have empty definitions
1634 and gives warning if there exists a runtime path from the entry to a
1635 use of the PHI def that does not contain a definition. In other words,
1636 the warning is on the real use. The more dead paths that can be pruned
1637 by the compiler, the fewer false positives the warning is. WORKLIST
1638 is a vector of candidate phis to be examined. ADDED_TO_WORKLIST is
1639 a pointer set tracking if the new phi is added to the worklist or not. */
1642 warn_uninitialized_phi (gimple phi, VEC(gimple, heap) **worklist,
1643 struct pointer_set_t *added_to_worklist)
1645 unsigned uninit_opnds;
1646 gimple uninit_use_stmt = 0;
1649 /* Don't look at memory tags. */
1650 if (!is_gimple_reg (gimple_phi_result (phi)))
1653 uninit_opnds = compute_uninit_opnds_pos (phi);
1655 if (MASK_EMPTY (uninit_opnds))
1658 /* Now check if we have any use of the value without proper guard. */
1659 uninit_use_stmt = find_uninit_use (phi, uninit_opnds,
1660 worklist, added_to_worklist);
1662 /* All uses are properly guarded. */
1663 if (!uninit_use_stmt)
1666 uninit_op = gimple_phi_arg_def (phi, MASK_FIRST_SET_BIT (uninit_opnds));
1667 warn_uninit (uninit_op,
1668 "%qD may be used uninitialized in this function",
1674 /* Entry point to the late uninitialized warning pass. */
1677 execute_late_warn_uninitialized (void)
1680 gimple_stmt_iterator gsi;
1681 VEC(gimple, heap) *worklist = 0;
1682 struct pointer_set_t *added_to_worklist;
1684 calculate_dominance_info (CDI_DOMINATORS);
1685 calculate_dominance_info (CDI_POST_DOMINATORS);
1686 /* Re-do the plain uninitialized variable check, as optimization may have
1687 straightened control flow. Do this first so that we don't accidentally
1688 get a "may be" warning when we'd have seen an "is" warning later. */
1689 warn_uninitialized_vars (/*warn_possibly_uninitialized=*/1);
1691 timevar_push (TV_TREE_UNINIT);
1693 possibly_undefined_names = pointer_set_create ();
1694 added_to_worklist = pointer_set_create ();
1696 /* Initialize worklist */
1698 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1700 gimple phi = gsi_stmt (gsi);
1703 n = gimple_phi_num_args (phi);
1705 /* Don't look at memory tags. */
1706 if (!is_gimple_reg (gimple_phi_result (phi)))
1709 for (i = 0; i < n; ++i)
1711 tree op = gimple_phi_arg_def (phi, i);
1712 if (TREE_CODE (op) == SSA_NAME
1713 && ssa_undefined_value_p (op))
1715 VEC_safe_push (gimple, heap, worklist, phi);
1716 pointer_set_insert (added_to_worklist, phi);
1722 while (VEC_length (gimple, worklist) != 0)
1725 cur_phi = VEC_pop (gimple, worklist);
1726 warn_uninitialized_phi (cur_phi, &worklist, added_to_worklist);
1729 VEC_free (gimple, heap, worklist);
1730 pointer_set_destroy (added_to_worklist);
1731 pointer_set_destroy (possibly_undefined_names);
1732 possibly_undefined_names = NULL;
1733 free_dominance_info (CDI_POST_DOMINATORS);
1734 timevar_pop (TV_TREE_UNINIT);
1739 gate_warn_uninitialized (void)
1741 return warn_uninitialized != 0;
1744 struct gimple_opt_pass pass_late_warn_uninitialized =
1748 "uninit", /* name */
1749 gate_warn_uninitialized, /* gate */
1750 execute_late_warn_uninitialized, /* execute */
1753 0, /* static_pass_number */
1754 TV_NONE, /* tv_id */
1755 PROP_ssa, /* properties_required */
1756 0, /* properties_provided */
1757 0, /* properties_destroyed */
1758 0, /* todo_flags_start */
1759 0 /* todo_flags_finish */