CbC/CbC_gcc: gcc/tree-ssa-uninit.c comparison

comparison gcc/tree-ssa-uninit.c @ 67:f6334be47118

update gcc from gcc-4.6-20100522 to gcc-4.6-20110318

author	nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Tue, 22 Mar 2011 17:18:12 +0900
parents	b7f97abdc517
children	04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 #include "flags.h"
 #include "tm_p.h"
 #include "langhooks.h"
 #include "basic-block.h"
 #include "output.h"
-#include "expr.h"
 #include "function.h"
-#include "diagnostic.h"
 #include "gimple-pretty-print.h"
 #include "bitmap.h"
 #include "pointer-set.h"
 #include "tree-flow.h"
 #include "gimple.h"
 #include "tree-inline.h"
 #include "timevar.h"
 #include "hashtab.h"
 #include "tree-dump.h"
 #include "tree-pass.h"
-#include "toplev.h"
+#include "diagnostic-core.h"
 #include "timevar.h"
 /* This implements the pass that does predicate aware warning on uses of
 possibly uninitialized variables. The pass first collects the set of
 possibly uninitialized SSA names. For each such name, it walks through
 /* Parameters get their initial value from the function entry.  */
 if (TREE_CODE (var) == PARM_DECL)
 return false;
+/* When returning by reference the return address is actually a hidden
+parameter.  */
+if (TREE_CODE (SSA_NAME_VAR (t)) == RESULT_DECL
+&& DECL_BY_REFERENCE (SSA_NAME_VAR (t)))
+return false;
 /* Hard register variables get their initial value from the ether.  */
 if (TREE_CODE (var) == VAR_DECL && DECL_HARD_REGISTER (var))
 return false;
 /* The value is undefined iff its definition statement is empty.  */
 {
 size_t i, n;
 unsigned uninit_opnds = 0;
 n = gimple_phi_num_args (phi);
+/* Bail out for phi with too many args.  */
+if (n > 32)
+return 0;
 for (i = 0; i < n; ++i)
 {
 tree op = gimple_phi_arg_def (phi, i);
 if (TREE_CODE (op) == SSA_NAME
 for (i = 0; i < n; i++)
 {
 opnd_edge = gimple_phi_arg_edge (phi, i);
 opnd = gimple_phi_arg_def (phi, i);
-if (TREE_CODE (opnd) != SSA_NAME
+if (TREE_CODE (opnd) != SSA_NAME)
-|| !ssa_undefined_value_p (opnd))
+{
-VEC_safe_push (edge, heap, *edges, opnd_edge);
+if (dump_file && (dump_flags & TDF_DETAILS))
+{
+fprintf (dump_file, "\n[CHECK] Found def edge %d in ", (int)i);
+print_gimple_stmt (dump_file, phi, 0, 0);
+}
+VEC_safe_push (edge, heap, *edges, opnd_edge);
+}
 else
 {
 gimple def = SSA_NAME_DEF_STMT (opnd);
 if (gimple_code (def) == GIMPLE_PHI
 && dominated_by_p (CDI_DOMINATORS,
 gimple_bb (def), cd_root))
 collect_phi_def_edges (def, cd_root, edges,
 visited_phis);
+else if (!ssa_undefined_value_p (opnd))
+{
+if (dump_file && (dump_flags & TDF_DETAILS))
+{
+fprintf (dump_file, "\n[CHECK] Found def edge %d in ", (int)i);
+print_gimple_stmt (dump_file, phi, 0, 0);
+}
+VEC_safe_push (edge, heap, *edges, opnd_edge);
+}
 }
 }
 }
 /* For each use edge of PHI, computes all control dependence chains.
 basic_block use_bb,
 gimple phi,
 unsigned uninit_opnds,
 struct pointer_set_t *visited_phis);
-/* A helper function that determines if the predicate set
+/* Returns true if all uninitialized opnds are pruned. Returns false
-of the use is not overlapping with that of the uninit paths.
+otherwise. PHI is the phi node with uninitialized operands,
-The most common senario of guarded use is in Example 1:
+UNINIT_OPNDS is the bitmap of the uninitialize operand positions,
-Example 1:
+FLAG_DEF is the statement defining the flag guarding the use of the
-if (some_cond)
+PHI output, BOUNDARY_CST is the const value used in the predicate
-{
+associated with the flag, CMP_CODE is the comparison code used in
-x = ...;
+the predicate, VISITED_PHIS is the pointer set of phis visited, and
-flag = true;
+VISITED_FLAG_PHIS is the pointer to the pointer set of flag definitions
-}
+that are also phis.
-... some code ...
+Example scenario:
-if (flag)
+BB1:
-use (x);
+flag_1 = phi <0, 1>                  // (1)
+var_1  = phi <undef, some_val>
-The real world examples are usually more complicated, but similar
-and usually result from inlining:
+BB2:
-bool init_func (int * x)
+flag_2 = phi <0,   flag_1, flag_1>   // (2)
-{
+var_2  = phi <undef, var_1, var_1>
-if (some_cond)
+if (flag_2 == 1)
-return false;
+goto BB3;
-*x  =  ..
-return true;
+BB3:
-}
+use of var_2                         // (3)
-void foo(..)
+Because some flag arg in (1) is not constant, if we do not look into the
-{
+flag phis recursively, it is conservatively treated as unknown and var_1
-int x;
+is thought to be flowed into use at (3). Since var_1 is potentially uninitialized
+a false warning will be emitted. Checking recursively into (1), the compiler can
-if (!init_func(&x))
+find out that only some_val (which is defined) can flow into (3) which is OK.
-return;
+*/
-.. some_code ...
-use (x);
+static bool
-}
+prune_uninit_phi_opnds_in_unrealizable_paths (
-Another possible use scenario is in the following trivial example:
-Example 2:
-if (n > 0)
-x = 1;
-...
-if (n > 0)
-{
-if (m < 2)
-.. = x;
-}
-Predicate analysis needs to compute the composite predicate:
-1) 'x' use predicate: (n > 0) .AND. (m < 2)
-2) 'x' default value  (non-def) predicate: .NOT. (n > 0)
-(the predicate chain for phi operand defs can be computed
-starting from a bb that is control equivalent to the phi's
-bb and is dominating the operand def.)
-and check overlapping:
-(n > 0) .AND. (m < 2) .AND. (.NOT. (n > 0))
-<==> false
-This implementation provides framework that can handle
-scenarios. (Note that many simple cases are handled properly
-without the predicate analysis -- this is due to jump threading
-transformation which eliminates the merge point thus makes
-path sensitive analysis unnecessary.)
-NUM_PREDS is the number is the number predicate chains, PREDS is
-the array of chains, PHI is the phi node whose incoming (undefined)
-paths need to be pruned, and UNINIT_OPNDS is the bitmap holding
-uninit operand positions. VISITED_PHIS is the pointer set of phi
-stmts being checked.  */
-static bool
-use_pred_not_overlap_with_undef_path_pred (
-size_t num_preds,
-VEC(use_pred_info_t, heap) **preds,
 gimple phi, unsigned uninit_opnds,
-struct pointer_set_t *visited_phis)
+gimple flag_def, tree boundary_cst,
-{
+enum tree_code cmp_code,
-unsigned int i, n;
+struct pointer_set_t *visited_phis,
-gimple flag_def = 0;
+bitmap *visited_flag_phis)
-tree  boundary_cst = 0;
+{
-enum tree_code cmp_code;
+unsigned i;
-bool swap_cond = false;
-bool invert = false;
+for (i = 0; i < MIN (32, gimple_phi_num_args (flag_def)); i++)
-VEC(use_pred_info_t, heap) *the_pred_chain;
-gcc_assert (num_preds > 0);
-/* Find within the common prefix of multiple predicate chains
-a predicate that is a comparison of a flag variable against
-a constant.  */
-the_pred_chain = preds[0];
-n = VEC_length (use_pred_info_t, the_pred_chain);
-for (i = 0; i < n; i++)
-{
-gimple cond;
-tree cond_lhs, cond_rhs, flag = 0;
-use_pred_info_t the_pred
-= VEC_index (use_pred_info_t, the_pred_chain, i);
-cond = the_pred->cond;
-invert = the_pred->invert;
-cond_lhs = gimple_cond_lhs (cond);
-cond_rhs = gimple_cond_rhs (cond);
-cmp_code = gimple_cond_code (cond);
-if (cond_lhs != NULL_TREE && TREE_CODE (cond_lhs) == SSA_NAME
-&& cond_rhs != NULL_TREE && is_gimple_constant (cond_rhs))
-{
-boundary_cst = cond_rhs;
-flag = cond_lhs;
-}
-else if (cond_rhs != NULL_TREE && TREE_CODE (cond_rhs) == SSA_NAME
-&& cond_lhs != NULL_TREE && is_gimple_constant (cond_lhs))
-{
-boundary_cst = cond_lhs;
-flag = cond_rhs;
-swap_cond = true;
-}
-if (!flag)
-continue;
-flag_def = SSA_NAME_DEF_STMT (flag);
-if (!flag_def)
-continue;
-if ((gimple_code (flag_def) == GIMPLE_PHI)
-&& (gimple_bb (flag_def) == gimple_bb (phi))
-&& find_matching_predicate_in_rest_chains (
-the_pred, preds, num_preds))
-break;
-flag_def = 0;
-}
-if (!flag_def)
-return false;
-/* Now check all the uninit incoming edge has a constant flag value
-that is in conflict with the use guard/predicate.  */
-cmp_code = get_cmp_code (cmp_code, swap_cond, invert);
-if (cmp_code == ERROR_MARK)
-return false;
-for (i = 0; i < sizeof (unsigned); i++)
 {
 tree flag_arg;
 if (!MASK_TEST_BIT (uninit_opnds, i))
 continue;
 flag_arg = gimple_phi_arg_def (flag_def, i);
 if (!is_gimple_constant (flag_arg))
-return false;
+{
+gimple flag_arg_def, phi_arg_def;
+tree phi_arg;
+unsigned uninit_opnds_arg_phi;
+if (TREE_CODE (flag_arg) != SSA_NAME)
+return false;
+flag_arg_def = SSA_NAME_DEF_STMT (flag_arg);
+if (gimple_code (flag_arg_def) != GIMPLE_PHI)
+return false;
+phi_arg = gimple_phi_arg_def (phi, i);
+if (TREE_CODE (phi_arg) != SSA_NAME)
+return false;
+phi_arg_def = SSA_NAME_DEF_STMT (phi_arg);
+if (gimple_code (phi_arg_def) != GIMPLE_PHI)
+return false;
+if (gimple_bb (phi_arg_def) != gimple_bb (flag_arg_def))
+return false;
+if (!*visited_flag_phis)
+*visited_flag_phis = BITMAP_ALLOC (NULL);
+if (bitmap_bit_p (*visited_flag_phis,
+SSA_NAME_VERSION (gimple_phi_result (flag_arg_def))))
+return false;
+bitmap_set_bit (*visited_flag_phis,
+SSA_NAME_VERSION (gimple_phi_result (flag_arg_def)));
+/* Now recursively prune the uninitialized phi args.  */
+uninit_opnds_arg_phi = compute_uninit_opnds_pos (phi_arg_def);
+if (!prune_uninit_phi_opnds_in_unrealizable_paths (
+phi_arg_def, uninit_opnds_arg_phi,
+flag_arg_def, boundary_cst, cmp_code,
+visited_phis, visited_flag_phis))
+return false;
+bitmap_clear_bit (*visited_flag_phis,
+SSA_NAME_VERSION (gimple_phi_result (flag_arg_def)));
+continue;
+}
 /* Now check if the constant is in the guarded range.  */
 if (is_value_included_in (flag_arg, boundary_cst, cmp_code))
 {
 tree opnd;
 }
 return true;
 }
+/* A helper function that determines if the predicate set
+of the use is not overlapping with that of the uninit paths.
+The most common senario of guarded use is in Example 1:
+Example 1:
+if (some_cond)
+{
+x = ...;
+flag = true;
+}
+... some code ...
+if (flag)
+use (x);
+The real world examples are usually more complicated, but similar
+and usually result from inlining:
+bool init_func (int * x)
+{
+if (some_cond)
+return false;
+*x  =  ..
+return true;
+}
+void foo(..)
+{
+int x;
+if (!init_func(&x))
+return;
+.. some_code ...
+use (x);
+}
+Another possible use scenario is in the following trivial example:
+Example 2:
+if (n > 0)
+x = 1;
+...
+if (n > 0)
+{
+if (m < 2)
+.. = x;
+}
+Predicate analysis needs to compute the composite predicate:
+1) 'x' use predicate: (n > 0) .AND. (m < 2)
+2) 'x' default value  (non-def) predicate: .NOT. (n > 0)
+(the predicate chain for phi operand defs can be computed
+starting from a bb that is control equivalent to the phi's
+bb and is dominating the operand def.)
+and check overlapping:
+(n > 0) .AND. (m < 2) .AND. (.NOT. (n > 0))
+<==> false
+This implementation provides framework that can handle
+scenarios. (Note that many simple cases are handled properly
+without the predicate analysis -- this is due to jump threading
+transformation which eliminates the merge point thus makes
+path sensitive analysis unnecessary.)
+NUM_PREDS is the number is the number predicate chains, PREDS is
+the array of chains, PHI is the phi node whose incoming (undefined)
+paths need to be pruned, and UNINIT_OPNDS is the bitmap holding
+uninit operand positions. VISITED_PHIS is the pointer set of phi
+stmts being checked.  */
+static bool
+use_pred_not_overlap_with_undef_path_pred (
+size_t num_preds,
+VEC(use_pred_info_t, heap) **preds,
+gimple phi, unsigned uninit_opnds,
+struct pointer_set_t *visited_phis)
+{
+unsigned int i, n;
+gimple flag_def = 0;
+tree  boundary_cst = 0;
+enum tree_code cmp_code;
+bool swap_cond = false;
+bool invert = false;
+VEC(use_pred_info_t, heap) *the_pred_chain;
+bitmap visited_flag_phis = NULL;
+bool all_pruned = false;
+gcc_assert (num_preds > 0);
+/* Find within the common prefix of multiple predicate chains
+a predicate that is a comparison of a flag variable against
+a constant.  */
+the_pred_chain = preds[0];
+n = VEC_length (use_pred_info_t, the_pred_chain);
+for (i = 0; i < n; i++)
+{
+gimple cond;
+tree cond_lhs, cond_rhs, flag = 0;
+use_pred_info_t the_pred
+= VEC_index (use_pred_info_t, the_pred_chain, i);
+cond = the_pred->cond;
+invert = the_pred->invert;
+cond_lhs = gimple_cond_lhs (cond);
+cond_rhs = gimple_cond_rhs (cond);
+cmp_code = gimple_cond_code (cond);
+if (cond_lhs != NULL_TREE && TREE_CODE (cond_lhs) == SSA_NAME
+&& cond_rhs != NULL_TREE && is_gimple_constant (cond_rhs))
+{
+boundary_cst = cond_rhs;
+flag = cond_lhs;
+}
+else if (cond_rhs != NULL_TREE && TREE_CODE (cond_rhs) == SSA_NAME
+&& cond_lhs != NULL_TREE && is_gimple_constant (cond_lhs))
+{
+boundary_cst = cond_lhs;
+flag = cond_rhs;
+swap_cond = true;
+}
+if (!flag)
+continue;
+flag_def = SSA_NAME_DEF_STMT (flag);
+if (!flag_def)
+continue;
+if ((gimple_code (flag_def) == GIMPLE_PHI)
+&& (gimple_bb (flag_def) == gimple_bb (phi))
+&& find_matching_predicate_in_rest_chains (
+the_pred, preds, num_preds))
+break;
+flag_def = 0;
+}
+if (!flag_def)
+return false;
+/* Now check all the uninit incoming edge has a constant flag value
+that is in conflict with the use guard/predicate.  */
+cmp_code = get_cmp_code (cmp_code, swap_cond, invert);
+if (cmp_code == ERROR_MARK)
+return false;
+all_pruned = prune_uninit_phi_opnds_in_unrealizable_paths (phi,
+uninit_opnds,
+flag_def,
+boundary_cst,
+cmp_code,
+visited_phis,
+&visited_flag_phis);
+if (visited_flag_phis)
+BITMAP_FREE (visited_flag_phis);
+return all_pruned;
+}
 /* Returns true if TC is AND or OR */
 static inline bool
 is_and_or_or (enum tree_code tc, tree typ)
 {
 return false;
 }
 if (dump_file)
 dump_predicates (use_stmt, num_preds, preds,
-"Use in stmt ");
+"\nUse in stmt ");
 has_valid_preds = find_def_preds (&def_preds,
 &num_def_preds, phi);
 if (has_valid_preds)
 FOR_EACH_IMM_USE_FAST (use_p, iter, phi_result)
 {
 struct pointer_set_t *visited_phis;
 basic_block use_bb;
-use_stmt = use_p->loc.stmt;
+use_stmt = USE_STMT (use_p);
+if (is_gimple_debug (use_stmt))
+	continue;
 visited_phis = pointer_set_create ();
-use_bb = gimple_bb (use_stmt);
 if (gimple_code (use_stmt) == GIMPLE_PHI)
-{
+	use_bb = gimple_phi_arg_edge (use_stmt,
-	  unsigned i, n;
+				      PHI_ARG_INDEX_FROM_USE (use_p))->src;
-n = gimple_phi_num_args (use_stmt);
+else
+	use_bb = gimple_bb (use_stmt);
-/* Find the matching phi argument of the use.  */
-for (i = 0; i < n; ++i)
-{
-if (gimple_phi_arg_def_ptr (use_stmt, i) == use_p->use)
-	         {
-		    edge e = gimple_phi_arg_edge (use_stmt, i);
-		    use_bb = e->src;
-break;
-		 }
-	    }
-	}
 if (is_use_properly_guarded (use_stmt,
 use_bb,
 phi,
 uninit_opnds,
 pointer_set_destroy (visited_phis);
 continue;
 }
 pointer_set_destroy (visited_phis);
+if (dump_file && (dump_flags & TDF_DETAILS))
+{
+fprintf (dump_file, "[CHECK]: Found unguarded use: ");
+print_gimple_stmt (dump_file, use_stmt, 0, 0);
+}
 /* Found one real use, return.  */
 if (gimple_code (use_stmt) != GIMPLE_PHI)
 return use_stmt;
 /* Found a phi use that is not guarded,
 add the phi to the worklist.  */
 if (!pointer_set_insert (added_to_worklist,
 use_stmt))
 {
+if (dump_file && (dump_flags & TDF_DETAILS))
+{
+fprintf (dump_file, "[WORKLIST]: Update worklist with phi: ");
+print_gimple_stmt (dump_file, use_stmt, 0, 0);
+}
 VEC_safe_push (gimple, heap, *worklist, use_stmt);
 pointer_set_insert (possibly_undefined_names,
 	                      phi_result);
 }
 }
 uninit_opnds = compute_uninit_opnds_pos (phi);
 if  (MASK_EMPTY (uninit_opnds))
 return;
+if (dump_file && (dump_flags & TDF_DETAILS))
+{
+fprintf (dump_file, "[CHECK]: examining phi: ");
+print_gimple_stmt (dump_file, phi, 0, 0);
+}
 /* Now check if we have any use of the value without proper guard.  */
 uninit_use_stmt = find_uninit_use (phi, uninit_opnds,
 worklist, added_to_worklist);
 if (TREE_CODE (op) == SSA_NAME
 && ssa_undefined_value_p (op))
 {
 VEC_safe_push (gimple, heap, worklist, phi);
 		pointer_set_insert (added_to_worklist, phi);
+if (dump_file && (dump_flags & TDF_DETAILS))
+{
+fprintf (dump_file, "[WORKLIST]: add to initial list: ");
+print_gimple_stmt (dump_file, phi, 0, 0);
+}
 break;
 }
 }
 }
 {
 gimple cur_phi = 0;
 cur_phi = VEC_pop (gimple, worklist);
 warn_uninitialized_phi (cur_phi, &worklist, added_to_worklist);
 }
 VEC_free (gimple, heap, worklist);
 pointer_set_destroy (added_to_worklist);
 pointer_set_destroy (possibly_undefined_names);
 possibly_undefined_names = NULL;
 free_dominance_info (CDI_POST_DOMINATORS);

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-ssa-uninit.c @ 67:f6334be47118