Skip to content

R
riscv-gcc-1
Commit ac0e4fde by Martin Liska Committed by Martin Liska
Options

Manual changes to GCC coding style in tree-ssa-uninit.c 

	* tree-ssa-uninit.c: Apply manual changes
	to the GNU coding style.
	(prune_uninit_phi_opnds): Rename from
	prune_uninit_phi_opnds_in_unrealizable_paths.

From-SVN: r235961
parent d8997c44
Showing with 186 additions and 222 deletions
gcc/ChangeLog
2016-05-06 Martin Liska <mliska@suse.cz>
* tree-ssa-uninit.c: Apply manual changes
to the GNU coding style.
(prune_uninit_phi_opnds): Rename from
prune_uninit_phi_opnds_in_unrealizable_paths.
2016-05-06 Oleg Endo <olegendo@gcc.gnu.org> 2016-05-06 Oleg Endo <olegendo@gcc.gnu.org>
* config/sh/sh.opt (madjust-unroll, minvalid-symbols, msoft-atomic, * config/sh/sh.opt (madjust-unroll, minvalid-symbols, msoft-atomic,
......
gcc/tree-ssa-uninit.c
...@@ -35,16 +35,15 @@ along with GCC; see the file COPYING3. If not see ...@@ -35,16 +35,15 @@ along with GCC; see the file COPYING3. If not see
#include "tree-cfg.h" #include "tree-cfg.h"
/* This implements the pass that does predicate aware warning on uses of /* This implements the pass that does predicate aware warning on uses of
possibly uninitialized variables. The pass first collects the set of possibly uninitialized variables. The pass first collects the set of
possibly uninitialized SSA names. For each such name, it walks through possibly uninitialized SSA names. For each such name, it walks through
all its immediate uses. For each immediate use, it rebuilds the condition all its immediate uses. For each immediate use, it rebuilds the condition
expression (the predicate) that guards the use. The predicate is then expression (the predicate) that guards the use. The predicate is then
examined to see if the variable is always defined under that same condition. examined to see if the variable is always defined under that same condition.
This is done either by pruning the unrealizable paths that lead to the This is done either by pruning the unrealizable paths that lead to the
default definitions or by checking if the predicate set that guards the default definitions or by checking if the predicate set that guards the
defining paths is a superset of the use predicate. */ defining paths is a superset of the use predicate. */
/* Pointer set of potentially undefined ssa names, i.e., /* Pointer set of potentially undefined ssa names, i.e.,
ssa names that are defined by phi with operands that ssa names that are defined by phi with operands that
are not defined or potentially undefined. */ are not defined or potentially undefined. */
...@@ -56,7 +55,7 @@ static hash_set<tree> *possibly_undefined_names = 0; ...@@ -56,7 +55,7 @@ static hash_set<tree> *possibly_undefined_names = 0;
#define MASK_EMPTY(mask) (mask == 0) #define MASK_EMPTY(mask) (mask == 0)
/* Returns the first bit position (starting from LSB) /* Returns the first bit position (starting from LSB)
in mask that is non zero. Returns -1 if the mask is empty. */ in mask that is non zero. Returns -1 if the mask is empty. */
static int static int
get_mask_first_set_bit (unsigned mask) get_mask_first_set_bit (unsigned mask)
{ {
...@@ -80,13 +79,12 @@ has_undefined_value_p (tree t) ...@@ -80,13 +79,12 @@ has_undefined_value_p (tree t)
&& possibly_undefined_names->contains (t))); && possibly_undefined_names->contains (t)));
} }
/* Like has_undefined_value_p, but don't return true if TREE_NO_WARNING /* Like has_undefined_value_p, but don't return true if TREE_NO_WARNING
is set on SSA_NAME_VAR. */ is set on SSA_NAME_VAR. */
static inline bool static inline bool
uninit_undefined_value_p (tree t) { uninit_undefined_value_p (tree t)
{
if (!has_undefined_value_p (t)) if (!has_undefined_value_p (t))
return false; return false;
if (SSA_NAME_VAR (t) && TREE_NO_WARNING (SSA_NAME_VAR (t))) if (SSA_NAME_VAR (t) && TREE_NO_WARNING (SSA_NAME_VAR (t)))
...@@ -112,7 +110,7 @@ uninit_undefined_value_p (tree t) { ...@@ -112,7 +110,7 @@ uninit_undefined_value_p (tree t) {
/* Emit a warning for EXPR based on variable VAR at the point in the /* Emit a warning for EXPR based on variable VAR at the point in the
program T, an SSA_NAME, is used being uninitialized. The exact program T, an SSA_NAME, is used being uninitialized. The exact
warning text is in MSGID and DATA is the gimple stmt with info about warning text is in MSGID and DATA is the gimple stmt with info about
the location in source code. When DATA is a GIMPLE_PHI, PHIARG_IDX the location in source code. When DATA is a GIMPLE_PHI, PHIARG_IDX
gives which argument of the phi node to take the location from. WC gives which argument of the phi node to take the location from. WC
is the warning code. */ is the warning code. */
...@@ -149,8 +147,7 @@ warn_uninit (enum opt_code wc, tree t, tree expr, tree var, ...@@ -149,8 +147,7 @@ warn_uninit (enum opt_code wc, tree t, tree expr, tree var,
else else
location = DECL_SOURCE_LOCATION (var); location = DECL_SOURCE_LOCATION (var);
location = linemap_resolve_location (line_table, location, location = linemap_resolve_location (line_table, location,
LRK_SPELLING_LOCATION, LRK_SPELLING_LOCATION, NULL);
NULL);
cfun_loc = DECL_SOURCE_LOCATION (cfun->decl); cfun_loc = DECL_SOURCE_LOCATION (cfun->decl);
xloc = expand_location (location); xloc = expand_location (location);
floc = expand_location (cfun_loc); floc = expand_location (cfun_loc);
...@@ -161,10 +158,8 @@ warn_uninit (enum opt_code wc, tree t, tree expr, tree var, ...@@ -161,10 +158,8 @@ warn_uninit (enum opt_code wc, tree t, tree expr, tree var,
if (location == DECL_SOURCE_LOCATION (var)) if (location == DECL_SOURCE_LOCATION (var))
return; return;
if (xloc.file != floc.file if (xloc.file != floc.file
|| linemap_location_before_p (line_table, || linemap_location_before_p (line_table, location, cfun_loc)
location, cfun_loc) || linemap_location_before_p (line_table, cfun->function_end_locus,
|| linemap_location_before_p (line_table,
cfun->function_end_locus,
location)) location))
inform (DECL_SOURCE_LOCATION (var), "%qD was declared here", var); inform (DECL_SOURCE_LOCATION (var), "%qD was declared here", var);
} }
...@@ -178,8 +173,8 @@ warn_uninitialized_vars (bool warn_possibly_uninitialized) ...@@ -178,8 +173,8 @@ warn_uninitialized_vars (bool warn_possibly_uninitialized)
FOR_EACH_BB_FN (bb, cfun) FOR_EACH_BB_FN (bb, cfun)
{ {
bool always_executed = dominated_by_p (CDI_POST_DOMINATORS, basic_block succ = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)), bb); bool always_executed = dominated_by_p (CDI_POST_DOMINATORS, succ, bb);
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{ {
gimple *stmt = gsi_stmt (gsi); gimple *stmt = gsi_stmt (gsi);
...@@ -196,13 +191,13 @@ warn_uninitialized_vars (bool warn_possibly_uninitialized) ...@@ -196,13 +191,13 @@ warn_uninitialized_vars (bool warn_possibly_uninitialized)
{ {
use = USE_FROM_PTR (use_p); use = USE_FROM_PTR (use_p);
if (always_executed) if (always_executed)
warn_uninit (OPT_Wuninitialized, use, warn_uninit (OPT_Wuninitialized, use, SSA_NAME_VAR (use),
SSA_NAME_VAR (use), SSA_NAME_VAR (use), SSA_NAME_VAR (use),
"%qD is used uninitialized in this function", "%qD is used uninitialized in this function", stmt,
stmt, UNKNOWN_LOCATION); UNKNOWN_LOCATION);
else if (warn_possibly_uninitialized) else if (warn_possibly_uninitialized)
warn_uninit (OPT_Wmaybe_uninitialized, use, warn_uninit (OPT_Wmaybe_uninitialized, use, SSA_NAME_VAR (use),
SSA_NAME_VAR (use), SSA_NAME_VAR (use), SSA_NAME_VAR (use),
"%qD may be used uninitialized in this function", "%qD may be used uninitialized in this function",
stmt, UNKNOWN_LOCATION); stmt, UNKNOWN_LOCATION);
} }
...@@ -232,9 +227,8 @@ warn_uninitialized_vars (bool warn_possibly_uninitialized) ...@@ -232,9 +227,8 @@ warn_uninitialized_vars (bool warn_possibly_uninitialized)
continue; continue;
if (always_executed) if (always_executed)
warn_uninit (OPT_Wuninitialized, use, warn_uninit (OPT_Wuninitialized, use, gimple_assign_rhs1 (stmt),
gimple_assign_rhs1 (stmt), base, base, "%qE is used uninitialized in this function",
"%qE is used uninitialized in this function",
stmt, UNKNOWN_LOCATION); stmt, UNKNOWN_LOCATION);
else if (warn_possibly_uninitialized) else if (warn_possibly_uninitialized)
warn_uninit (OPT_Wmaybe_uninitialized, use, warn_uninit (OPT_Wmaybe_uninitialized, use,
...@@ -250,9 +244,9 @@ warn_uninitialized_vars (bool warn_possibly_uninitialized) ...@@ -250,9 +244,9 @@ warn_uninitialized_vars (bool warn_possibly_uninitialized)
/* Checks if the operand OPND of PHI is defined by /* Checks if the operand OPND of PHI is defined by
another phi with one operand defined by this PHI, another phi with one operand defined by this PHI,
but the rest operands are all defined. If yes, but the rest operands are all defined. If yes,
returns true to skip this operand as being returns true to skip this operand as being
redundant. Can be enhanced to be more general. */ redundant. Can be enhanced to be more general. */
static bool static bool
can_skip_redundant_opnd (tree opnd, gimple *phi) can_skip_redundant_opnd (tree opnd, gimple *phi)
...@@ -318,37 +312,35 @@ compute_uninit_opnds_pos (gphi *phi) ...@@ -318,37 +312,35 @@ compute_uninit_opnds_pos (gphi *phi)
static inline basic_block static inline basic_block
find_pdom (basic_block block) find_pdom (basic_block block)
{ {
if (block == EXIT_BLOCK_PTR_FOR_FN (cfun)) if (block == EXIT_BLOCK_PTR_FOR_FN (cfun))
return EXIT_BLOCK_PTR_FOR_FN (cfun); return EXIT_BLOCK_PTR_FOR_FN (cfun);
else else
{ {
basic_block bb basic_block bb = get_immediate_dominator (CDI_POST_DOMINATORS, block);
= get_immediate_dominator (CDI_POST_DOMINATORS, block); if (!bb)
if (! bb) return EXIT_BLOCK_PTR_FOR_FN (cfun);
return EXIT_BLOCK_PTR_FOR_FN (cfun); return bb;
return bb; }
}
} }
/* Find the immediate DOM of the specified /* Find the immediate DOM of the specified basic block BLOCK. */
basic block BLOCK. */
static inline basic_block static inline basic_block
find_dom (basic_block block) find_dom (basic_block block)
{ {
if (block == ENTRY_BLOCK_PTR_FOR_FN (cfun)) if (block == ENTRY_BLOCK_PTR_FOR_FN (cfun))
return ENTRY_BLOCK_PTR_FOR_FN (cfun); return ENTRY_BLOCK_PTR_FOR_FN (cfun);
else else
{ {
basic_block bb = get_immediate_dominator (CDI_DOMINATORS, block); basic_block bb = get_immediate_dominator (CDI_DOMINATORS, block);
if (! bb) if (!bb)
return ENTRY_BLOCK_PTR_FOR_FN (cfun); return ENTRY_BLOCK_PTR_FOR_FN (cfun);
return bb; return bb;
} }
} }
/* Returns true if BB1 is postdominating BB2 and BB1 is /* Returns true if BB1 is postdominating BB2 and BB1 is
not a loop exit bb. The loop exit bb check is simple and does not a loop exit bb. The loop exit bb check is simple and does
not cover all cases. */ not cover all cases. */
static bool static bool
...@@ -366,7 +358,7 @@ is_non_loop_exit_postdominating (basic_block bb1, basic_block bb2) ...@@ -366,7 +358,7 @@ is_non_loop_exit_postdominating (basic_block bb1, basic_block bb2)
/* Find the closest postdominator of a specified BB, which is control /* Find the closest postdominator of a specified BB, which is control
equivalent to BB. */ equivalent to BB. */
static inline basic_block static inline basic_block
find_control_equiv_block (basic_block bb) find_control_equiv_block (basic_block bb)
{ {
basic_block pdom; basic_block pdom;
...@@ -424,7 +416,7 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb, ...@@ -424,7 +416,7 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb,
for (i = 0; i < cur_chain_len; i++) for (i = 0; i < cur_chain_len; i++)
{ {
edge e = (*cur_cd_chain)[i]; edge e = (*cur_cd_chain)[i];
/* Cycle detected. */ /* Cycle detected. */
if (e->src == bb) if (e->src == bb)
return false; return false;
} }
...@@ -454,8 +446,8 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb, ...@@ -454,8 +446,8 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb,
} }
/* Now check if DEP_BB is indirectly control dependent on BB. */ /* Now check if DEP_BB is indirectly control dependent on BB. */
if (compute_control_dep_chain (cd_bb, dep_bb, cd_chains, if (compute_control_dep_chain (cd_bb, dep_bb, cd_chains, num_chains,
num_chains, cur_cd_chain, num_calls)) cur_cd_chain, num_calls))
{ {
found_cd_chain = true; found_cd_chain = true;
break; break;
...@@ -463,8 +455,8 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb, ...@@ -463,8 +455,8 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb,
cd_bb = find_pdom (cd_bb); cd_bb = find_pdom (cd_bb);
post_dom_check++; post_dom_check++;
if (cd_bb == EXIT_BLOCK_PTR_FOR_FN (cfun) || post_dom_check > if (cd_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)
MAX_POSTDOM_CHECK) || post_dom_check > MAX_POSTDOM_CHECK)
break; break;
} }
cur_cd_chain->pop (); cur_cd_chain->pop ();
...@@ -475,7 +467,7 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb, ...@@ -475,7 +467,7 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb,
return found_cd_chain; return found_cd_chain;
} }
/* The type to represent a simple predicate */ /* The type to represent a simple predicate. */
struct pred_info struct pred_info
{ {
...@@ -496,13 +488,13 @@ typedef vec<pred_info, va_heap, vl_ptr> pred_chain; ...@@ -496,13 +488,13 @@ typedef vec<pred_info, va_heap, vl_ptr> pred_chain;
typedef vec<pred_chain, va_heap, vl_ptr> pred_chain_union; typedef vec<pred_chain, va_heap, vl_ptr> pred_chain_union;
/* Converts the chains of control dependence edges into a set of /* Converts the chains of control dependence edges into a set of
predicates. A control dependence chain is represented by a vector predicates. A control dependence chain is represented by a vector
edges. DEP_CHAINS points to an array of dependence chains. edges. DEP_CHAINS points to an array of dependence chains.
NUM_CHAINS is the size of the chain array. One edge in a dependence NUM_CHAINS is the size of the chain array. One edge in a dependence
chain is mapped to predicate expression represented by pred_info chain is mapped to predicate expression represented by pred_info
type. One dependence chain is converted to a composite predicate that type. One dependence chain is converted to a composite predicate that
is the result of AND operation of pred_info mapped to each edge. is the result of AND operation of pred_info mapped to each edge.
A composite predicate is presented by a vector of pred_info. On A composite predicate is presented by a vector of pred_info. On
return, *PREDS points to the resulting array of composite predicates. return, *PREDS points to the resulting array of composite predicates.
*NUM_PREDS is the number of composite predictes. */ *NUM_PREDS is the number of composite predictes. */
...@@ -543,13 +535,9 @@ convert_control_dep_chain_into_preds (vec<edge> *dep_chains, ...@@ -543,13 +535,9 @@ convert_control_dep_chain_into_preds (vec<edge> *dep_chains,
break; break;
} }
cond_stmt = gsi_stmt (gsi); cond_stmt = gsi_stmt (gsi);
if (is_gimple_call (cond_stmt) if (is_gimple_call (cond_stmt) && EDGE_COUNT (e->src->succs) >= 2)
&& EDGE_COUNT (e->src->succs) >= 2) /* Ignore EH edge. Can add assertion on the other edge's flag. */
{ continue;
/* Ignore EH edge. Can add assertion
on the other edge's flag. */
continue;
}
/* Skip if there is essentially one succesor. */ /* Skip if there is essentially one succesor. */
if (EDGE_COUNT (e->src->succs) == 2) if (EDGE_COUNT (e->src->succs) == 2)
{ {
...@@ -577,7 +565,7 @@ convert_control_dep_chain_into_preds (vec<edge> *dep_chains, ...@@ -577,7 +565,7 @@ convert_control_dep_chain_into_preds (vec<edge> *dep_chains,
t_chain.safe_push (one_pred); t_chain.safe_push (one_pred);
has_valid_pred = true; has_valid_pred = true;
} }
else if (gswitch *gs = dyn_cast <gswitch *> (cond_stmt)) else if (gswitch *gs = dyn_cast<gswitch *> (cond_stmt))
{ {
/* Avoid quadratic behavior. */ /* Avoid quadratic behavior. */
if (gimple_switch_num_labels (gs) > MAX_SWITCH_CASES) if (gimple_switch_num_labels (gs) > MAX_SWITCH_CASES)
...@@ -607,8 +595,8 @@ convert_control_dep_chain_into_preds (vec<edge> *dep_chains, ...@@ -607,8 +595,8 @@ convert_control_dep_chain_into_preds (vec<edge> *dep_chains,
fail. */ fail. */
if (!l if (!l
|| !CASE_LOW (l) || !CASE_LOW (l)
|| (CASE_HIGH (l) && !operand_equal_p (CASE_LOW (l), || (CASE_HIGH (l)
CASE_HIGH (l), 0))) && !operand_equal_p (CASE_LOW (l), CASE_HIGH (l), 0)))
{ {
has_valid_pred = false; has_valid_pred = false;
break; break;
...@@ -635,7 +623,7 @@ convert_control_dep_chain_into_preds (vec<edge> *dep_chains, ...@@ -635,7 +623,7 @@ convert_control_dep_chain_into_preds (vec<edge> *dep_chains,
return has_valid_pred; return has_valid_pred;
} }
/* Computes all control dependence chains for USE_BB. The control /* Computes all control dependence chains for USE_BB. The control
dependence chains are then converted to an array of composite dependence chains are then converted to an array of composite
predicates pointed to by PREDS. PHI_BB is the basic block of predicates pointed to by PREDS. PHI_BB is the basic block of
the phi whose result is used in USE_BB. */ the phi whose result is used in USE_BB. */
...@@ -676,8 +664,8 @@ find_predicates (pred_chain_union *preds, ...@@ -676,8 +664,8 @@ find_predicates (pred_chain_union *preds,
/* Computes the set of incoming edges of PHI that have non empty /* Computes the set of incoming edges of PHI that have non empty
definitions of a phi chain. The collection will be done definitions of a phi chain. The collection will be done
recursively on operands that are defined by phis. CD_ROOT recursively on operands that are defined by phis. CD_ROOT
is the control dependence root. *EDGES holds the result, and is the control dependence root. *EDGES holds the result, and
VISITED_PHIS is a pointer set for detecting cycles. */ VISITED_PHIS is a pointer set for detecting cycles. */
static void static void
...@@ -702,7 +690,7 @@ collect_phi_def_edges (gphi *phi, basic_block cd_root, ...@@ -702,7 +690,7 @@ collect_phi_def_edges (gphi *phi, basic_block cd_root,
{ {
if (dump_file && (dump_flags & TDF_DETAILS)) if (dump_file && (dump_flags & TDF_DETAILS))
{ {
fprintf (dump_file, "\n[CHECK] Found def edge %d in ", (int)i); fprintf (dump_file, "\n[CHECK] Found def edge %d in ", (int) i);
print_gimple_stmt (dump_file, phi, 0, 0); print_gimple_stmt (dump_file, phi, 0, 0);
} }
edges->safe_push (opnd_edge); edges->safe_push (opnd_edge);
...@@ -712,15 +700,15 @@ collect_phi_def_edges (gphi *phi, basic_block cd_root, ...@@ -712,15 +700,15 @@ collect_phi_def_edges (gphi *phi, basic_block cd_root,
gimple *def = SSA_NAME_DEF_STMT (opnd); gimple *def = SSA_NAME_DEF_STMT (opnd);
if (gimple_code (def) == GIMPLE_PHI if (gimple_code (def) == GIMPLE_PHI
&& dominated_by_p (CDI_DOMINATORS, && dominated_by_p (CDI_DOMINATORS, gimple_bb (def), cd_root))
gimple_bb (def), cd_root)) collect_phi_def_edges (as_a<gphi *> (def), cd_root, edges,
collect_phi_def_edges (as_a <gphi *> (def), cd_root, edges,
visited_phis); visited_phis);
else if (!uninit_undefined_value_p (opnd)) else if (!uninit_undefined_value_p (opnd))
{ {
if (dump_file && (dump_flags & TDF_DETAILS)) if (dump_file && (dump_flags & TDF_DETAILS))
{ {
fprintf (dump_file, "\n[CHECK] Found def edge %d in ", (int)i); fprintf (dump_file, "\n[CHECK] Found def edge %d in ",
(int) i);
print_gimple_stmt (dump_file, phi, 0, 0); print_gimple_stmt (dump_file, phi, 0, 0);
} }
edges->safe_push (opnd_edge); edges->safe_push (opnd_edge);
...@@ -745,7 +733,7 @@ find_def_preds (pred_chain_union *preds, gphi *phi) ...@@ -745,7 +733,7 @@ find_def_preds (pred_chain_union *preds, gphi *phi)
phi_bb = gimple_bb (phi); phi_bb = gimple_bb (phi);
/* First find the closest dominating bb to be /* First find the closest dominating bb to be
the control dependence root */ the control dependence root. */
cd_root = find_dom (phi_bb); cd_root = find_dom (phi_bb);
if (!cd_root) if (!cd_root)
return false; return false;
...@@ -789,8 +777,7 @@ find_def_preds (pred_chain_union *preds, gphi *phi) ...@@ -789,8 +777,7 @@ find_def_preds (pred_chain_union *preds, gphi *phi)
/* Dumps the predicates (PREDS) for USESTMT. */ /* Dumps the predicates (PREDS) for USESTMT. */
static void static void
dump_predicates (gimple *usestmt, pred_chain_union preds, dump_predicates (gimple *usestmt, pred_chain_union preds, const char *msg)
const char* msg)
{ {
size_t i, j; size_t i, j;
pred_chain one_pred_chain = vNULL; pred_chain one_pred_chain = vNULL;
...@@ -839,13 +826,11 @@ destroy_predicate_vecs (pred_chain_union *preds) ...@@ -839,13 +826,11 @@ destroy_predicate_vecs (pred_chain_union *preds)
preds->release (); preds->release ();
} }
/* Computes the 'normalized' conditional code with operand /* Computes the 'normalized' conditional code with operand
swapping and condition inversion. */ swapping and condition inversion. */
static enum tree_code static enum tree_code
get_cmp_code (enum tree_code orig_cmp_code, get_cmp_code (enum tree_code orig_cmp_code, bool swap_cond, bool invert)
bool swap_cond, bool invert)
{ {
enum tree_code tc = orig_cmp_code; enum tree_code tc = orig_cmp_code;
...@@ -880,14 +865,12 @@ is_value_included_in (tree val, tree boundary, enum tree_code cmpc) ...@@ -880,14 +865,12 @@ is_value_included_in (tree val, tree boundary, enum tree_code cmpc)
bool result; bool result;
/* Only handle integer constant here. */ /* Only handle integer constant here. */
if (TREE_CODE (val) != INTEGER_CST if (TREE_CODE (val) != INTEGER_CST || TREE_CODE (boundary) != INTEGER_CST)
|| TREE_CODE (boundary) != INTEGER_CST)
return true; return true;
is_unsigned = TYPE_UNSIGNED (TREE_TYPE (val)); is_unsigned = TYPE_UNSIGNED (TREE_TYPE (val));
if (cmpc == GE_EXPR || cmpc == GT_EXPR if (cmpc == GE_EXPR || cmpc == GT_EXPR || cmpc == NE_EXPR)
|| cmpc == NE_EXPR)
{ {
cmpc = invert_tree_comparison (cmpc, false); cmpc = invert_tree_comparison (cmpc, false);
inverted = true; inverted = true;
...@@ -949,7 +932,7 @@ find_matching_predicate_in_rest_chains (pred_info pred, ...@@ -949,7 +932,7 @@ find_matching_predicate_in_rest_chains (pred_info pred,
{ {
pred_info pred2 = one_chain[j]; pred_info pred2 = one_chain[j];
/* Can relax the condition comparison to not /* Can relax the condition comparison to not
use address comparison. However, the most common use address comparison. However, the most common
case is that multiple control dependent paths share case is that multiple control dependent paths share
a common path prefix, so address comparison should a common path prefix, so address comparison should
be ok. */ be ok. */
...@@ -969,16 +952,15 @@ find_matching_predicate_in_rest_chains (pred_info pred, ...@@ -969,16 +952,15 @@ find_matching_predicate_in_rest_chains (pred_info pred,
} }
/* Forward declaration. */ /* Forward declaration. */
static bool static bool is_use_properly_guarded (gimple *use_stmt,
is_use_properly_guarded (gimple *use_stmt, basic_block use_bb,
basic_block use_bb, gphi *phi,
gphi *phi, unsigned uninit_opnds,
unsigned uninit_opnds, pred_chain_union *def_preds,
pred_chain_union *def_preds, hash_set<gphi *> *visited_phis);
hash_set<gphi *> *visited_phis);
/* Returns true if all uninitialized opnds are pruned. Returns false
/* Returns true if all uninitialized opnds are pruned. Returns false otherwise. PHI is the phi node with uninitialized operands,
otherwise. PHI is the phi node with uninitialized operands,
UNINIT_OPNDS is the bitmap of the uninitialize operand positions, UNINIT_OPNDS is the bitmap of the uninitialize operand positions,
FLAG_DEF is the statement defining the flag guarding the use of the FLAG_DEF is the statement defining the flag guarding the use of the
PHI output, BOUNDARY_CST is the const value used in the predicate PHI output, BOUNDARY_CST is the const value used in the predicate
...@@ -990,7 +972,7 @@ is_use_properly_guarded (gimple *use_stmt, ...@@ -990,7 +972,7 @@ is_use_properly_guarded (gimple *use_stmt,
Example scenario: Example scenario:
BB1: BB1:
flag_1 = phi <0, 1> // (1) flag_1 = phi <0, 1> // (1)
var_1 = phi <undef, some_val> var_1 = phi <undef, some_val>
...@@ -1001,24 +983,20 @@ is_use_properly_guarded (gimple *use_stmt, ...@@ -1001,24 +983,20 @@ is_use_properly_guarded (gimple *use_stmt,
goto BB3; goto BB3;
BB3: BB3:
use of var_2 // (3) use of var_2 // (3)
Because some flag arg in (1) is not constant, if we do not look into the 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 flag phis recursively, it is conservatively treated as unknown and var_1
is thought to be flowed into use at (3). Since var_1 is potentially uninitialized is thought to be flowed into use at (3). Since var_1 is potentially
a false warning will be emitted. Checking recursively into (1), the compiler can uninitialized a false warning will be emitted.
find out that only some_val (which is defined) can flow into (3) which is OK. Checking recursively into (1), the compiler can find out that only some_val
(which is defined) can flow into (3) which is OK. */
*/
static bool static bool
prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, prune_uninit_phi_opnds (gphi *phi, unsigned uninit_opnds, gphi *flag_def,
unsigned uninit_opnds, tree boundary_cst, enum tree_code cmp_code,
gphi *flag_def, hash_set<gphi *> *visited_phis,
tree boundary_cst, bitmap *visited_flag_phis)
enum tree_code cmp_code,
hash_set<gphi *> *visited_phis,
bitmap *visited_flag_phis)
{ {
unsigned i; unsigned i;
...@@ -1038,7 +1016,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, ...@@ -1038,7 +1016,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi,
if (TREE_CODE (flag_arg) != SSA_NAME) if (TREE_CODE (flag_arg) != SSA_NAME)
return false; return false;
flag_arg_def = dyn_cast <gphi *> (SSA_NAME_DEF_STMT (flag_arg)); flag_arg_def = dyn_cast<gphi *> (SSA_NAME_DEF_STMT (flag_arg));
if (!flag_arg_def) if (!flag_arg_def)
return false; return false;
...@@ -1046,7 +1024,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, ...@@ -1046,7 +1024,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi,
if (TREE_CODE (phi_arg) != SSA_NAME) if (TREE_CODE (phi_arg) != SSA_NAME)
return false; return false;
phi_arg_def = dyn_cast <gphi *> (SSA_NAME_DEF_STMT (phi_arg)); phi_arg_def = dyn_cast<gphi *> (SSA_NAME_DEF_STMT (phi_arg));
if (!phi_arg_def) if (!phi_arg_def)
return false; return false;
...@@ -1056,8 +1034,8 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, ...@@ -1056,8 +1034,8 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi,
if (!*visited_flag_phis) if (!*visited_flag_phis)
*visited_flag_phis = BITMAP_ALLOC (NULL); *visited_flag_phis = BITMAP_ALLOC (NULL);
if (bitmap_bit_p (*visited_flag_phis, tree phi_result = gimple_phi_result (flag_arg_def);
SSA_NAME_VERSION (gimple_phi_result (flag_arg_def)))) if (bitmap_bit_p (*visited_flag_phis, SSA_NAME_VERSION (phi_result)))
return false; return false;
bitmap_set_bit (*visited_flag_phis, bitmap_set_bit (*visited_flag_phis,
...@@ -1065,13 +1043,13 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, ...@@ -1065,13 +1043,13 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi,
/* Now recursively prune the uninitialized phi args. */ /* Now recursively prune the uninitialized phi args. */
uninit_opnds_arg_phi = compute_uninit_opnds_pos (phi_arg_def); uninit_opnds_arg_phi = compute_uninit_opnds_pos (phi_arg_def);
if (!prune_uninit_phi_opnds_in_unrealizable_paths if (!prune_uninit_phi_opnds
(phi_arg_def, uninit_opnds_arg_phi, flag_arg_def, (phi_arg_def, uninit_opnds_arg_phi, flag_arg_def, boundary_cst,
boundary_cst, cmp_code, visited_phis, visited_flag_phis)) cmp_code, visited_phis, visited_flag_phis))
return false; return false;
bitmap_clear_bit (*visited_flag_phis, phi_result = gimple_phi_result (flag_arg_def);
SSA_NAME_VERSION (gimple_phi_result (flag_arg_def))); bitmap_clear_bit (*visited_flag_phis, SSA_NAME_VERSION (phi_result));
continue; continue;
} }
...@@ -1082,7 +1060,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, ...@@ -1082,7 +1060,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi,
gimple *opnd_def; gimple *opnd_def;
/* Now that we know that this undefined edge is not /* Now that we know that this undefined edge is not
pruned. If the operand is defined by another phi, pruned. If the operand is defined by another phi,
we can further prune the incoming edges of that we can further prune the incoming edges of that
phi by checking the predicates of this operands. */ phi by checking the predicates of this operands. */
...@@ -1091,8 +1069,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, ...@@ -1091,8 +1069,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi,
if (gphi *opnd_def_phi = dyn_cast <gphi *> (opnd_def)) if (gphi *opnd_def_phi = dyn_cast <gphi *> (opnd_def))
{ {
edge opnd_edge; edge opnd_edge;
unsigned uninit_opnds2 unsigned uninit_opnds2 = compute_uninit_opnds_pos (opnd_def_phi);
= compute_uninit_opnds_pos (opnd_def_phi);
if (!MASK_EMPTY (uninit_opnds2)) if (!MASK_EMPTY (uninit_opnds2))
{ {
pred_chain_union def_preds = vNULL; pred_chain_union def_preds = vNULL;
...@@ -1143,11 +1120,11 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, ...@@ -1143,11 +1120,11 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi,
return true; return true;
} }
void foo(..) void foo (..)
{ {
int x; int x;
if (!init_func(&x)) if (!init_func (&x))
return; return;
.. some_code ... .. some_code ...
...@@ -1179,7 +1156,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, ...@@ -1179,7 +1156,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi,
<==> false <==> false
This implementation provides framework that can handle This implementation provides framework that can handle
scenarios. (Note that many simple cases are handled properly scenarios. (Note that many simple cases are handled properly
without the predicate analysis -- this is due to jump threading without the predicate analysis -- this is due to jump threading
transformation which eliminates the merge point thus makes transformation which eliminates the merge point thus makes
path sensitive analysis unnecessary.) path sensitive analysis unnecessary.)
...@@ -1187,10 +1164,9 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, ...@@ -1187,10 +1164,9 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi,
NUM_PREDS is the number is the number predicate chains, PREDS is NUM_PREDS is the number is the number predicate chains, PREDS is
the array of chains, PHI is the phi node whose incoming (undefined) the array of chains, PHI is the phi node whose incoming (undefined)
paths need to be pruned, and UNINIT_OPNDS is the bitmap holding paths need to be pruned, and UNINIT_OPNDS is the bitmap holding
uninit operand positions. VISITED_PHIS is the pointer set of phi uninit operand positions. VISITED_PHIS is the pointer set of phi
stmts being checked. */ stmts being checked. */
static bool static bool
use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds, use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds,
gphi *phi, unsigned uninit_opnds, gphi *phi, unsigned uninit_opnds,
...@@ -1198,7 +1174,7 @@ use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds, ...@@ -1198,7 +1174,7 @@ use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds,
{ {
unsigned int i, n; unsigned int i, n;
gimple *flag_def = 0; gimple *flag_def = 0;
tree boundary_cst = 0; tree boundary_cst = 0;
enum tree_code cmp_code; enum tree_code cmp_code;
bool swap_cond = false; bool swap_cond = false;
bool invert = false; bool invert = false;
...@@ -1265,13 +1241,9 @@ use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds, ...@@ -1265,13 +1241,9 @@ use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds,
if (cmp_code == ERROR_MARK) if (cmp_code == ERROR_MARK)
return false; return false;
all_pruned = prune_uninit_phi_opnds_in_unrealizable_paths (phi, all_pruned = prune_uninit_phi_opnds
uninit_opnds, (phi, uninit_opnds, as_a<gphi *> (flag_def), boundary_cst, cmp_code,
as_a <gphi *> (flag_def), visited_phis, &visited_flag_phis);
boundary_cst,
cmp_code,
visited_phis,
&visited_flag_phis);
if (visited_flag_phis) if (visited_flag_phis)
BITMAP_FREE (visited_flag_phis); BITMAP_FREE (visited_flag_phis);
...@@ -1280,7 +1252,7 @@ use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds, ...@@ -1280,7 +1252,7 @@ use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds,
} }
/* The helper function returns true if two predicates X1 and X2 /* The helper function returns true if two predicates X1 and X2
are equivalent. It assumes the expressions have already are equivalent. It assumes the expressions have already
properly re-associated. */ properly re-associated. */
static inline bool static inline bool
...@@ -1307,8 +1279,8 @@ static inline bool ...@@ -1307,8 +1279,8 @@ static inline bool
is_neq_relop_p (pred_info pred) is_neq_relop_p (pred_info pred)
{ {
return (pred.cond_code == NE_EXPR && !pred.invert) return ((pred.cond_code == NE_EXPR && !pred.invert)
|| (pred.cond_code == EQ_EXPR && pred.invert); || (pred.cond_code == EQ_EXPR && pred.invert));
} }
/* Returns true if pred is of the form X != 0. */ /* Returns true if pred is of the form X != 0. */
...@@ -1335,7 +1307,7 @@ pred_expr_equal_p (pred_info x1, tree x2) ...@@ -1335,7 +1307,7 @@ pred_expr_equal_p (pred_info x1, tree x2)
} }
/* Returns true of the domain of single predicate expression /* Returns true of the domain of single predicate expression
EXPR1 is a subset of that of EXPR2. Returns false if it EXPR1 is a subset of that of EXPR2. Returns false if it
can not be proved. */ can not be proved. */
static bool static bool
...@@ -1360,8 +1332,7 @@ is_pred_expr_subset_of (pred_info expr1, pred_info expr2) ...@@ -1360,8 +1332,7 @@ is_pred_expr_subset_of (pred_info expr1, pred_info expr2)
if (expr2.invert) if (expr2.invert)
code2 = invert_tree_comparison (code2, false); code2 = invert_tree_comparison (code2, false);
if ((code1 == EQ_EXPR || code1 == BIT_AND_EXPR) if ((code1 == EQ_EXPR || code1 == BIT_AND_EXPR) && code2 == BIT_AND_EXPR)
&& code2 == BIT_AND_EXPR)
return wi::eq_p (expr1.pred_rhs, return wi::eq_p (expr1.pred_rhs,
wi::bit_and (expr1.pred_rhs, expr2.pred_rhs)); wi::bit_and (expr1.pred_rhs, expr2.pred_rhs));
...@@ -1375,11 +1346,10 @@ is_pred_expr_subset_of (pred_info expr1, pred_info expr2) ...@@ -1375,11 +1346,10 @@ is_pred_expr_subset_of (pred_info expr1, pred_info expr2)
} }
/* Returns true if the domain of PRED1 is a subset /* Returns true if the domain of PRED1 is a subset
of that of PRED2. Returns false if it can not be proved so. */ of that of PRED2. Returns false if it can not be proved so. */
static bool static bool
is_pred_chain_subset_of (pred_chain pred1, is_pred_chain_subset_of (pred_chain pred1, pred_chain pred2)
pred_chain pred2)
{ {
size_t np1, np2, i1, i2; size_t np1, np2, i1, i2;
...@@ -1407,7 +1377,7 @@ is_pred_chain_subset_of (pred_chain pred1, ...@@ -1407,7 +1377,7 @@ is_pred_chain_subset_of (pred_chain pred1,
/* Returns true if the domain defined by /* Returns true if the domain defined by
one pred chain ONE_PRED is a subset of the domain one pred chain ONE_PRED is a subset of the domain
of *PREDS. It returns false if ONE_PRED's domain is of *PREDS. It returns false if ONE_PRED's domain is
not a subset of any of the sub-domains of PREDS not a subset of any of the sub-domains of PREDS
(corresponding to each individual chains in it), even (corresponding to each individual chains in it), even
though it may be still be a subset of whole domain though it may be still be a subset of whole domain
...@@ -1431,15 +1401,15 @@ is_included_in (pred_chain one_pred, pred_chain_union preds) ...@@ -1431,15 +1401,15 @@ is_included_in (pred_chain one_pred, pred_chain_union preds)
/* Compares two predicate sets PREDS1 and PREDS2 and returns /* Compares two predicate sets PREDS1 and PREDS2 and returns
true if the domain defined by PREDS1 is a superset true if the domain defined by PREDS1 is a superset
of PREDS2's domain. N1 and N2 are array sizes of PREDS1 and of PREDS2's domain. N1 and N2 are array sizes of PREDS1 and
PREDS2 respectively. The implementation chooses not to build PREDS2 respectively. The implementation chooses not to build
generic trees (and relying on the folding capability of the generic trees (and relying on the folding capability of the
compiler), but instead performs brute force comparison of compiler), but instead performs brute force comparison of
individual predicate chains (won't be a compile time problem individual predicate chains (won't be a compile time problem
as the chains are pretty short). When the function returns as the chains are pretty short). When the function returns
false, it does not necessarily mean *PREDS1 is not a superset false, it does not necessarily mean *PREDS1 is not a superset
of *PREDS2, but mean it may not be so since the analysis can of *PREDS2, but mean it may not be so since the analysis can
not prove it. In such cases, false warnings may still be not prove it. In such cases, false warnings may still be
emitted. */ emitted. */
static bool static bool
...@@ -1536,19 +1506,19 @@ simplify_pred (pred_chain *one_chain) ...@@ -1536,19 +1506,19 @@ simplify_pred (pred_chain *one_chain)
if (pred_expr_equal_p (*b_pred, gimple_assign_rhs1 (def_stmt)) if (pred_expr_equal_p (*b_pred, gimple_assign_rhs1 (def_stmt))
|| pred_expr_equal_p (*b_pred, gimple_assign_rhs2 (def_stmt))) || pred_expr_equal_p (*b_pred, gimple_assign_rhs2 (def_stmt)))
{ {
/* Mark a_pred for removal. */ /* Mark a_pred for removal. */
a_pred->pred_lhs = NULL; a_pred->pred_lhs = NULL;
a_pred->pred_rhs = NULL; a_pred->pred_rhs = NULL;
simplified = true; simplified = true;
break; break;
} }
} }
} }
} }
if (!simplified) if (!simplified)
return; return;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
...@@ -1558,8 +1528,8 @@ simplify_pred (pred_chain *one_chain) ...@@ -1558,8 +1528,8 @@ simplify_pred (pred_chain *one_chain)
s_chain.safe_push (*a_pred); s_chain.safe_push (*a_pred);
} }
one_chain->release (); one_chain->release ();
*one_chain = s_chain; *one_chain = s_chain;
} }
/* The helper function implements the rule 2 for the /* The helper function implements the rule 2 for the
...@@ -1746,8 +1716,7 @@ simplify_preds_4 (pred_chain_union *preds) ...@@ -1746,8 +1716,7 @@ simplify_preds_4 (pred_chain_union *preds)
x2 = (*b_chain)[0]; x2 = (*b_chain)[0];
y2 = (*b_chain)[1]; y2 = (*b_chain)[1];
if (!is_neq_zero_form_p (x2) if (!is_neq_zero_form_p (x2) || !is_neq_zero_form_p (y2))
|| !is_neq_zero_form_p (y2))
continue; continue;
if ((pred_expr_equal_p (x2, gimple_assign_rhs1 (def_stmt)) if ((pred_expr_equal_p (x2, gimple_assign_rhs1 (def_stmt))
...@@ -1780,7 +1749,6 @@ simplify_preds_4 (pred_chain_union *preds) ...@@ -1780,7 +1749,6 @@ simplify_preds_4 (pred_chain_union *preds)
return simplified; return simplified;
} }
/* This function simplifies predicates in PREDS. */ /* This function simplifies predicates in PREDS. */
static void static void
...@@ -1815,14 +1783,14 @@ simplify_preds (pred_chain_union *preds, gimple *use_or_def, bool is_use) ...@@ -1815,14 +1783,14 @@ simplify_preds (pred_chain_union *preds, gimple *use_or_def, bool is_use)
if (simplify_preds_4 (preds)) if (simplify_preds_4 (preds))
changed = true; changed = true;
}
} while (changed); while (changed);
return; return;
} }
/* This is a helper function which attempts to normalize predicate chains /* This is a helper function which attempts to normalize predicate chains
by following UD chains. It basically builds up a big tree of either IOR by following UD chains. It basically builds up a big tree of either IOR
operations or AND operations, and convert the IOR tree into a operations or AND operations, and convert the IOR tree into a
pred_chain_union or BIT_AND tree into a pred_chain. pred_chain_union or BIT_AND tree into a pred_chain.
Example: Example:
...@@ -1895,7 +1863,7 @@ get_pred_info_from_cmp (gimple *cmp_assign) ...@@ -1895,7 +1863,7 @@ get_pred_info_from_cmp (gimple *cmp_assign)
} }
/* Returns true if the PHI is a degenerated phi with /* Returns true if the PHI is a degenerated phi with
all args with the same value (relop). In that case, *PRED all args with the same value (relop). In that case, *PRED
will be updated to that value. */ will be updated to that value. */
static bool static bool
...@@ -1915,8 +1883,7 @@ is_degenerated_phi (gimple *phi, pred_info *pred_p) ...@@ -1915,8 +1883,7 @@ is_degenerated_phi (gimple *phi, pred_info *pred_p)
def0 = SSA_NAME_DEF_STMT (op0); def0 = SSA_NAME_DEF_STMT (op0);
if (gimple_code (def0) != GIMPLE_ASSIGN) if (gimple_code (def0) != GIMPLE_ASSIGN)
return false; return false;
if (TREE_CODE_CLASS (gimple_assign_rhs_code (def0)) if (TREE_CODE_CLASS (gimple_assign_rhs_code (def0)) != tcc_comparison)
!= tcc_comparison)
return false; return false;
pred0 = get_pred_info_from_cmp (def0); pred0 = get_pred_info_from_cmp (def0);
...@@ -1932,8 +1899,7 @@ is_degenerated_phi (gimple *phi, pred_info *pred_p) ...@@ -1932,8 +1899,7 @@ is_degenerated_phi (gimple *phi, pred_info *pred_p)
def = SSA_NAME_DEF_STMT (op); def = SSA_NAME_DEF_STMT (op);
if (gimple_code (def) != GIMPLE_ASSIGN) if (gimple_code (def) != GIMPLE_ASSIGN)
return false; return false;
if (TREE_CODE_CLASS (gimple_assign_rhs_code (def)) if (TREE_CODE_CLASS (gimple_assign_rhs_code (def)) != tcc_comparison)
!= tcc_comparison)
return false; return false;
pred = get_pred_info_from_cmp (def); pred = get_pred_info_from_cmp (def);
if (!pred_equal_p (pred, pred0)) if (!pred_equal_p (pred, pred0))
...@@ -1971,13 +1937,12 @@ normalize_one_pred_1 (pred_chain_union *norm_preds, ...@@ -1971,13 +1937,12 @@ normalize_one_pred_1 (pred_chain_union *norm_preds,
if (gimple_code (def_stmt) == GIMPLE_PHI if (gimple_code (def_stmt) == GIMPLE_PHI
&& is_degenerated_phi (def_stmt, &pred)) && is_degenerated_phi (def_stmt, &pred))
work_list->safe_push (pred); work_list->safe_push (pred);
else if (gimple_code (def_stmt) == GIMPLE_PHI else if (gimple_code (def_stmt) == GIMPLE_PHI && and_or_code == BIT_IOR_EXPR)
&& and_or_code == BIT_IOR_EXPR)
{ {
int i, n; int i, n;
n = gimple_phi_num_args (def_stmt); n = gimple_phi_num_args (def_stmt);
/* If we see non zero constant, we should punt. The predicate /* If we see non zero constant, we should punt. The predicate
* should be one guarding the phi edge. */ * should be one guarding the phi edge. */
for (i = 0; i < n; ++i) for (i = 0; i < n; ++i)
{ {
...@@ -2048,8 +2013,7 @@ normalize_one_pred_1 (pred_chain_union *norm_preds, ...@@ -2048,8 +2013,7 @@ normalize_one_pred_1 (pred_chain_union *norm_preds,
/* Normalize PRED and store the normalized predicates into NORM_PREDS. */ /* Normalize PRED and store the normalized predicates into NORM_PREDS. */
static void static void
normalize_one_pred (pred_chain_union *norm_preds, normalize_one_pred (pred_chain_union *norm_preds, pred_info pred)
pred_info pred)
{ {
vec<pred_info, va_heap, vl_ptr> work_list = vNULL; vec<pred_info, va_heap, vl_ptr> work_list = vNULL;
enum tree_code and_or_code = ERROR_MARK; enum tree_code and_or_code = ERROR_MARK;
...@@ -2064,17 +2028,15 @@ normalize_one_pred (pred_chain_union *norm_preds, ...@@ -2064,17 +2028,15 @@ normalize_one_pred (pred_chain_union *norm_preds,
gimple *def_stmt = SSA_NAME_DEF_STMT (pred.pred_lhs); gimple *def_stmt = SSA_NAME_DEF_STMT (pred.pred_lhs);
if (gimple_code (def_stmt) == GIMPLE_ASSIGN) if (gimple_code (def_stmt) == GIMPLE_ASSIGN)
and_or_code = gimple_assign_rhs_code (def_stmt); and_or_code = gimple_assign_rhs_code (def_stmt);
if (and_or_code != BIT_IOR_EXPR if (and_or_code != BIT_IOR_EXPR && and_or_code != BIT_AND_EXPR)
&& and_or_code != BIT_AND_EXPR)
{ {
if (TREE_CODE_CLASS (and_or_code) if (TREE_CODE_CLASS (and_or_code) == tcc_comparison)
== tcc_comparison)
{ {
pred_info n_pred = get_pred_info_from_cmp (def_stmt); pred_info n_pred = get_pred_info_from_cmp (def_stmt);
push_pred (norm_preds, n_pred); push_pred (norm_preds, n_pred);
} }
else else
push_pred (norm_preds, pred); push_pred (norm_preds, pred);
return; return;
} }
...@@ -2084,8 +2046,8 @@ normalize_one_pred (pred_chain_union *norm_preds, ...@@ -2084,8 +2046,8 @@ normalize_one_pred (pred_chain_union *norm_preds,
while (!work_list.is_empty ()) while (!work_list.is_empty ())
{ {
pred_info a_pred = work_list.pop (); pred_info a_pred = work_list.pop ();
normalize_one_pred_1 (norm_preds, &norm_chain, a_pred, normalize_one_pred_1 (norm_preds, &norm_chain, a_pred, and_or_code,
and_or_code, &work_list, &mark_set); &work_list, &mark_set);
} }
if (and_or_code == BIT_AND_EXPR) if (and_or_code == BIT_AND_EXPR)
norm_preds->safe_push (norm_chain); norm_preds->safe_push (norm_chain);
...@@ -2094,8 +2056,7 @@ normalize_one_pred (pred_chain_union *norm_preds, ...@@ -2094,8 +2056,7 @@ normalize_one_pred (pred_chain_union *norm_preds,
} }
static void static void
normalize_one_pred_chain (pred_chain_union *norm_preds, normalize_one_pred_chain (pred_chain_union *norm_preds, pred_chain one_chain)
pred_chain one_chain)
{ {
vec<pred_info, va_heap, vl_ptr> work_list = vNULL; vec<pred_info, va_heap, vl_ptr> work_list = vNULL;
hash_set<tree> mark_set; hash_set<tree> mark_set;
...@@ -2111,8 +2072,8 @@ normalize_one_pred_chain (pred_chain_union *norm_preds, ...@@ -2111,8 +2072,8 @@ normalize_one_pred_chain (pred_chain_union *norm_preds,
while (!work_list.is_empty ()) while (!work_list.is_empty ())
{ {
pred_info a_pred = work_list.pop (); pred_info a_pred = work_list.pop ();
normalize_one_pred_1 (0, &norm_chain, a_pred, normalize_one_pred_1 (0, &norm_chain, a_pred, BIT_AND_EXPR, &work_list,
BIT_AND_EXPR, &work_list, &mark_set); &mark_set);
} }
norm_preds->safe_push (norm_chain); norm_preds->safe_push (norm_chain);
...@@ -2148,26 +2109,26 @@ normalize_preds (pred_chain_union preds, gimple *use_or_def, bool is_use) ...@@ -2148,26 +2109,26 @@ normalize_preds (pred_chain_union preds, gimple *use_or_def, bool is_use)
if (dump_file) if (dump_file)
{ {
fprintf (dump_file, "[AFTER NORMALIZATION -- "); fprintf (dump_file, "[AFTER NORMALIZATION -- ");
dump_predicates (use_or_def, norm_preds, is_use ? "[USE]:\n" : "[DEF]:\n"); dump_predicates (use_or_def, norm_preds,
is_use ? "[USE]:\n" : "[DEF]:\n");
} }
destroy_predicate_vecs (&preds); destroy_predicate_vecs (&preds);
return norm_preds; return norm_preds;
} }
/* Computes the predicates that guard the use and checks /* Computes the predicates that guard the use and checks
if the incoming paths that have empty (or possibly if the incoming paths that have empty (or possibly
empty) definition can be pruned/filtered. The function returns empty) definition can be pruned/filtered. The function returns
true if it can be determined that the use of PHI's def in true if it can be determined that the use of PHI's def in
USE_STMT is guarded with a predicate set not overlapping with USE_STMT is guarded with a predicate set not overlapping with
predicate sets of all runtime paths that do not have a definition. predicate sets of all runtime paths that do not have a definition.
Returns false if it is not or it can not be determined. USE_BB is Returns false if it is not or it can not be determined. USE_BB is
the bb of the use (for phi operand use, the bb is not the bb of the bb of the use (for phi operand use, the bb is not the bb of
the phi stmt, but the src bb of the operand edge). the phi stmt, but the src bb of the operand edge).
UNINIT_OPNDS is a bit vector. If an operand of PHI is uninitialized, the UNINIT_OPNDS is a bit vector. If an operand of PHI is uninitialized, the
corresponding bit in the vector is 1. VISITED_PHIS is a pointer corresponding bit in the vector is 1. VISITED_PHIS is a pointer
set of phis being visited. set of phis being visited.
...@@ -2206,7 +2167,7 @@ is_use_properly_guarded (gimple *use_stmt, ...@@ -2206,7 +2167,7 @@ is_use_properly_guarded (gimple *use_stmt,
return false; return false;
} }
/* Try to prune the dead incoming phi edges. */ /* Try to prune the dead incoming phi edges. */
is_properly_guarded is_properly_guarded
= use_pred_not_overlap_with_undef_path_pred (preds, phi, uninit_opnds, = use_pred_not_overlap_with_undef_path_pred (preds, phi, uninit_opnds,
visited_phis); visited_phis);
...@@ -2242,11 +2203,11 @@ is_use_properly_guarded (gimple *use_stmt, ...@@ -2242,11 +2203,11 @@ is_use_properly_guarded (gimple *use_stmt,
/* Searches through all uses of a potentially /* Searches through all uses of a potentially
uninitialized variable defined by PHI and returns a use uninitialized variable defined by PHI and returns a use
statement if the use is not properly guarded. It returns statement if the use is not properly guarded. It returns
NULL if all uses are guarded. UNINIT_OPNDS is a bitvector NULL if all uses are guarded. UNINIT_OPNDS is a bitvector
holding the position(s) of uninit PHI operands. WORKLIST holding the position(s) of uninit PHI operands. WORKLIST
is the vector of candidate phis that may be updated by this is the vector of candidate phis that may be updated by this
function. ADDED_TO_WORKLIST is the pointer set tracking function. ADDED_TO_WORKLIST is the pointer set tracking
if the new phi is already in the worklist. */ if the new phi is already in the worklist. */
static gimple * static gimple *
...@@ -2271,7 +2232,7 @@ find_uninit_use (gphi *phi, unsigned uninit_opnds, ...@@ -2271,7 +2232,7 @@ find_uninit_use (gphi *phi, unsigned uninit_opnds,
if (is_gimple_debug (use_stmt)) if (is_gimple_debug (use_stmt))
continue; continue;
if (gphi *use_phi = dyn_cast <gphi *> (use_stmt)) if (gphi *use_phi = dyn_cast<gphi *> (use_stmt))
use_bb = gimple_phi_arg_edge (use_phi, use_bb = gimple_phi_arg_edge (use_phi,
PHI_ARG_INDEX_FROM_USE (use_p))->src; PHI_ARG_INDEX_FROM_USE (use_p))->src;
else else
...@@ -2296,7 +2257,7 @@ find_uninit_use (gphi *phi, unsigned uninit_opnds, ...@@ -2296,7 +2257,7 @@ find_uninit_use (gphi *phi, unsigned uninit_opnds,
/* Found a phi use that is not guarded, /* Found a phi use that is not guarded,
add the phi to the worklist. */ add the phi to the worklist. */
if (!added_to_worklist->add (as_a <gphi *> (use_stmt))) if (!added_to_worklist->add (as_a<gphi *> (use_stmt)))
{ {
if (dump_file && (dump_flags & TDF_DETAILS)) if (dump_file && (dump_flags & TDF_DETAILS))
{ {
...@@ -2304,7 +2265,7 @@ find_uninit_use (gphi *phi, unsigned uninit_opnds, ...@@ -2304,7 +2265,7 @@ find_uninit_use (gphi *phi, unsigned uninit_opnds,
print_gimple_stmt (dump_file, use_stmt, 0, 0); print_gimple_stmt (dump_file, use_stmt, 0, 0);
} }
worklist->safe_push (as_a <gphi *> (use_stmt)); worklist->safe_push (as_a<gphi *> (use_stmt));
possibly_undefined_names->add (phi_result); possibly_undefined_names->add (phi_result);
} }
} }
...@@ -2315,10 +2276,10 @@ find_uninit_use (gphi *phi, unsigned uninit_opnds, ...@@ -2315,10 +2276,10 @@ find_uninit_use (gphi *phi, unsigned uninit_opnds,
/* Look for inputs to PHI that are SSA_NAMEs that have empty definitions /* Look for inputs to PHI that are SSA_NAMEs that have empty definitions
and gives warning if there exists a runtime path from the entry to a and gives warning if there exists a runtime path from the entry to a
use of the PHI def that does not contain a definition. In other words, use of the PHI def that does not contain a definition. In other words,
the warning is on the real use. The more dead paths that can be pruned the warning is on the real use. The more dead paths that can be pruned
by the compiler, the fewer false positives the warning is. WORKLIST by the compiler, the fewer false positives the warning is. WORKLIST
is a vector of candidate phis to be examined. ADDED_TO_WORKLIST is is a vector of candidate phis to be examined. ADDED_TO_WORKLIST is
a pointer set tracking if the new phi is added to the worklist or not. */ a pointer set tracking if the new phi is added to the worklist or not. */
static void static void
...@@ -2337,7 +2298,7 @@ warn_uninitialized_phi (gphi *phi, vec<gphi *> *worklist, ...@@ -2337,7 +2298,7 @@ warn_uninitialized_phi (gphi *phi, vec<gphi *> *worklist,
uninit_opnds = compute_uninit_opnds_pos (phi); uninit_opnds = compute_uninit_opnds_pos (phi);
if (MASK_EMPTY (uninit_opnds)) if (MASK_EMPTY (uninit_opnds))
return; return;
if (dump_file && (dump_flags & TDF_DETAILS)) if (dump_file && (dump_flags & TDF_DETAILS))
...@@ -2366,7 +2327,6 @@ warn_uninitialized_phi (gphi *phi, vec<gphi *> *worklist, ...@@ -2366,7 +2327,6 @@ warn_uninitialized_phi (gphi *phi, vec<gphi *> *worklist,
SSA_NAME_VAR (uninit_op), SSA_NAME_VAR (uninit_op),
"%qD may be used uninitialized in this function", "%qD may be used uninitialized in this function",
uninit_use_stmt, loc); uninit_use_stmt, loc);
} }
static bool static bool
...@@ -2398,7 +2358,7 @@ public: ...@@ -2398,7 +2358,7 @@ public:
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
opt_pass * clone () { return new pass_late_warn_uninitialized (m_ctxt); } opt_pass *clone () { return new pass_late_warn_uninitialized (m_ctxt); }
virtual bool gate (function *) { return gate_warn_uninitialized (); } virtual bool gate (function *) { return gate_warn_uninitialized (); }
virtual unsigned int execute (function *); virtual unsigned int execute (function *);
...@@ -2439,8 +2399,7 @@ pass_late_warn_uninitialized::execute (function *fun) ...@@ -2439,8 +2399,7 @@ pass_late_warn_uninitialized::execute (function *fun)
for (i = 0; i < n; ++i) for (i = 0; i < n; ++i)
{ {
tree op = gimple_phi_arg_def (phi, i); tree op = gimple_phi_arg_def (phi, i);
if (TREE_CODE (op) == SSA_NAME if (TREE_CODE (op) == SSA_NAME && uninit_undefined_value_p (op))
&& uninit_undefined_value_p (op))
{ {
worklist.safe_push (phi); worklist.safe_push (phi);
added_to_worklist.add (phi); added_to_worklist.add (phi);
...@@ -2477,12 +2436,11 @@ make_pass_late_warn_uninitialized (gcc::context *ctxt) ...@@ -2477,12 +2436,11 @@ make_pass_late_warn_uninitialized (gcc::context *ctxt)
return new pass_late_warn_uninitialized (ctxt); return new pass_late_warn_uninitialized (ctxt);
} }
static unsigned int static unsigned int
execute_early_warn_uninitialized (void) execute_early_warn_uninitialized (void)
{ {
/* Currently, this pass runs always but /* Currently, this pass runs always but
execute_late_warn_uninitialized only runs with optimization. With execute_late_warn_uninitialized only runs with optimization. With
optimization we want to warn about possible uninitialized as late optimization we want to warn about possible uninitialized as late
as possible, thus don't do it here. However, without as possible, thus don't do it here. However, without
optimization we need to warn here about "may be uninitialized". */ optimization we need to warn here about "may be uninitialized". */
...@@ -2490,14 +2448,13 @@ execute_early_warn_uninitialized (void) ...@@ -2490,14 +2448,13 @@ execute_early_warn_uninitialized (void)
warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize); warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize);
/* Post-dominator information can not be reliably updated. Free it /* Post-dominator information can not be reliably updated. Free it
after the use. */ after the use. */
free_dominance_info (CDI_POST_DOMINATORS); free_dominance_info (CDI_POST_DOMINATORS);
return 0; return 0;
} }
namespace { namespace {
const pass_data pass_data_early_warn_uninitialized = const pass_data pass_data_early_warn_uninitialized =
...@@ -2523,9 +2480,9 @@ public: ...@@ -2523,9 +2480,9 @@ public:
/* opt_pass methods: */ /* opt_pass methods: */
virtual bool gate (function *) { return gate_warn_uninitialized (); } virtual bool gate (function *) { return gate_warn_uninitialized (); }
virtual unsigned int execute (function *) virtual unsigned int execute (function *)
{ {
return execute_early_warn_uninitialized (); return execute_early_warn_uninitialized ();
} }
}; // class pass_early_warn_uninitialized }; // class pass_early_warn_uninitialized
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment