diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 66368d3207b..1a04191a0fc 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,8 @@ +2015-11-27 Martin Liska + + * tree-ssa-uninit.c: Fix whitespaces in the source file. + The change is just automatical. + 2015-11-27 Martin Liska * tree-chkp.c (chkp_make_static_bounds): Release buffer diff --git a/gcc/tree-ssa-uninit.c b/gcc/tree-ssa-uninit.c index 0709cce7561..50bfb0361f1 100644 --- a/gcc/tree-ssa-uninit.c +++ b/gcc/tree-ssa-uninit.c @@ -76,8 +76,8 @@ static bool has_undefined_value_p (tree t) { return (ssa_undefined_value_p (t) - || (possibly_undefined_names - && possibly_undefined_names->contains (t))); + || (possibly_undefined_names + && possibly_undefined_names->contains (t))); } @@ -270,9 +270,9 @@ can_skip_redundant_opnd (tree opnd, gimple *phi) { tree op = gimple_phi_arg_def (op_def, i); if (TREE_CODE (op) != SSA_NAME) - continue; + continue; if (op != phi_def && uninit_undefined_value_p (op)) - return false; + return false; } return true; @@ -296,10 +296,10 @@ compute_uninit_opnds_pos (gphi *phi) { tree op = gimple_phi_arg_def (phi, i); if (TREE_CODE (op) == SSA_NAME - && uninit_undefined_value_p (op) - && !can_skip_redundant_opnd (op, phi)) + && uninit_undefined_value_p (op) + && !can_skip_redundant_opnd (op, phi)) { - if (cfun->has_nonlocal_label || cfun->calls_setjmp) + if (cfun->has_nonlocal_label || cfun->calls_setjmp) { /* Ignore SSA_NAMEs that appear on abnormal edges somewhere. */ @@ -323,7 +323,7 @@ find_pdom (basic_block block) else { basic_block bb - = get_immediate_dominator (CDI_POST_DOMINATORS, block); + = get_immediate_dominator (CDI_POST_DOMINATORS, block); if (! bb) return EXIT_BLOCK_PTR_FOR_FN (cfun); return bb; @@ -398,8 +398,8 @@ find_control_equiv_block (basic_block bb) static bool compute_control_dep_chain (basic_block bb, basic_block dep_bb, - vec *cd_chains, - size_t *num_chains, + vec *cd_chains, + size_t *num_chains, vec *cur_cd_chain, int *num_calls) { @@ -426,7 +426,7 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb, edge e = (*cur_cd_chain)[i]; /* Cycle detected. */ if (e->src == bb) - return false; + return false; } FOR_EACH_EDGE (e, ei, bb->succs) @@ -434,39 +434,39 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb, basic_block cd_bb; int post_dom_check = 0; if (e->flags & (EDGE_FAKE | EDGE_ABNORMAL)) - continue; + continue; cd_bb = e->dest; cur_cd_chain->safe_push (e); while (!is_non_loop_exit_postdominating (cd_bb, bb)) - { - if (cd_bb == dep_bb) - { - /* Found a direct control dependence. */ - if (*num_chains < MAX_NUM_CHAINS) - { - cd_chains[*num_chains] = cur_cd_chain->copy (); - (*num_chains)++; - } - found_cd_chain = true; - /* Check path from next edge. */ - break; - } + { + if (cd_bb == dep_bb) + { + /* Found a direct control dependence. */ + if (*num_chains < MAX_NUM_CHAINS) + { + cd_chains[*num_chains] = cur_cd_chain->copy (); + (*num_chains)++; + } + found_cd_chain = true; + /* Check path from next edge. */ + break; + } - /* Now check if DEP_BB is indirectly control dependent on BB. */ - if (compute_control_dep_chain (cd_bb, dep_bb, cd_chains, + /* Now check if DEP_BB is indirectly control dependent on BB. */ + if (compute_control_dep_chain (cd_bb, dep_bb, cd_chains, num_chains, cur_cd_chain, num_calls)) - { - found_cd_chain = true; - break; - } + { + found_cd_chain = true; + break; + } - cd_bb = find_pdom (cd_bb); - post_dom_check++; + cd_bb = find_pdom (cd_bb); + post_dom_check++; if (cd_bb == EXIT_BLOCK_PTR_FOR_FN (cfun) || post_dom_check > MAX_POSTDOM_CHECK) - break; - } + break; + } cur_cd_chain->pop (); gcc_assert (cur_cd_chain->length () == cur_chain_len); } @@ -508,8 +508,8 @@ typedef vec pred_chain_union; static bool convert_control_dep_chain_into_preds (vec *dep_chains, - size_t num_chains, - pred_chain_union *preds) + size_t num_chains, + pred_chain_union *preds) { bool has_valid_pred = false; size_t i, j; @@ -527,48 +527,48 @@ convert_control_dep_chain_into_preds (vec *dep_chains, has_valid_pred = false; pred_chain t_chain = vNULL; for (j = 0; j < one_cd_chain.length (); j++) - { + { gimple *cond_stmt; - gimple_stmt_iterator gsi; - basic_block guard_bb; - pred_info one_pred; - edge e; + gimple_stmt_iterator gsi; + basic_block guard_bb; + pred_info one_pred; + edge e; - e = one_cd_chain[j]; - guard_bb = e->src; - gsi = gsi_last_bb (guard_bb); - if (gsi_end_p (gsi)) - { - has_valid_pred = false; - break; - } - cond_stmt = gsi_stmt (gsi); - if (is_gimple_call (cond_stmt) - && EDGE_COUNT (e->src->succs) >= 2) - { - /* Ignore EH edge. Can add assertion - on the other edge's flag. */ - continue; - } - /* Skip if there is essentially one succesor. */ - if (EDGE_COUNT (e->src->succs) == 2) - { - edge e1; - edge_iterator ei1; - bool skip = false; + e = one_cd_chain[j]; + guard_bb = e->src; + gsi = gsi_last_bb (guard_bb); + if (gsi_end_p (gsi)) + { + has_valid_pred = false; + break; + } + cond_stmt = gsi_stmt (gsi); + if (is_gimple_call (cond_stmt) + && EDGE_COUNT (e->src->succs) >= 2) + { + /* Ignore EH edge. Can add assertion + on the other edge's flag. */ + continue; + } + /* Skip if there is essentially one succesor. */ + if (EDGE_COUNT (e->src->succs) == 2) + { + edge e1; + edge_iterator ei1; + bool skip = false; - FOR_EACH_EDGE (e1, ei1, e->src->succs) - { - if (EDGE_COUNT (e1->dest->succs) == 0) - { - skip = true; - break; - } - } - if (skip) - continue; - } - if (gimple_code (cond_stmt) == GIMPLE_COND) + FOR_EACH_EDGE (e1, ei1, e->src->succs) + { + if (EDGE_COUNT (e1->dest->succs) == 0) + { + skip = true; + break; + } + } + if (skip) + continue; + } + if (gimple_code (cond_stmt) == GIMPLE_COND) { one_pred.pred_lhs = gimple_cond_lhs (cond_stmt); one_pred.pred_rhs = gimple_cond_rhs (cond_stmt); @@ -603,7 +603,7 @@ convert_control_dep_chain_into_preds (vec *dep_chains, } } /* If more than one label reaches this block or the case - label doesn't have a single value (like the default one) + label doesn't have a single value (like the default one) fail. */ if (!l || !CASE_LOW (l) @@ -621,11 +621,11 @@ convert_control_dep_chain_into_preds (vec *dep_chains, has_valid_pred = true; } else - { - has_valid_pred = false; - break; - } - } + { + has_valid_pred = false; + break; + } + } if (!has_valid_pred) break; @@ -642,8 +642,8 @@ convert_control_dep_chain_into_preds (vec *dep_chains, static bool find_predicates (pred_chain_union *preds, - basic_block phi_bb, - basic_block use_bb) + basic_block phi_bb, + basic_block use_bb) { size_t num_chains = 0, i; int num_calls = 0; @@ -659,9 +659,9 @@ find_predicates (pred_chain_union *preds, { basic_block ctrl_eq_bb = find_control_equiv_block (cd_root); if (ctrl_eq_bb && dominated_by_p (CDI_DOMINATORS, use_bb, ctrl_eq_bb)) - cd_root = ctrl_eq_bb; + cd_root = ctrl_eq_bb; else - break; + break; } compute_control_dep_chain (cd_root, use_bb, dep_chains, &num_chains, @@ -699,33 +699,33 @@ collect_phi_def_edges (gphi *phi, basic_block cd_root, opnd = gimple_phi_arg_def (phi, i); if (TREE_CODE (opnd) != SSA_NAME) - { - 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); - } - edges->safe_push (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); + } + edges->safe_push (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 (as_a (def), cd_root, edges, - visited_phis); - else if (!uninit_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); - } - edges->safe_push (opnd_edge); - } - } + if (gimple_code (def) == GIMPLE_PHI + && dominated_by_p (CDI_DOMINATORS, + gimple_bb (def), cd_root)) + collect_phi_def_edges (as_a (def), cd_root, edges, + visited_phis); + else if (!uninit_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); + } + edges->safe_push (opnd_edge); + } + } } } @@ -769,14 +769,14 @@ find_def_preds (pred_chain_union *preds, gphi *phi) &num_chains, &cur_chain, &num_calls); /* Now update the newly added chains with - the phi operand edge: */ + the phi operand edge: */ if (EDGE_COUNT (opnd_edge->src->succs) > 1) - { + { if (prev_nc == num_chains && num_chains < MAX_NUM_CHAINS) dep_chains[num_chains++] = vNULL; - for (j = prev_nc; j < num_chains; j++) + for (j = prev_nc; j < num_chains; j++) dep_chains[j].safe_push (opnd_edge); - } + } } has_valid_pred @@ -790,7 +790,7 @@ find_def_preds (pred_chain_union *preds, gphi *phi) static void dump_predicates (gimple *usestmt, pred_chain_union preds, - const char* msg) + const char* msg) { size_t i, j; pred_chain one_pred_chain = vNULL; @@ -807,22 +807,22 @@ dump_predicates (gimple *usestmt, pred_chain_union preds, np = one_pred_chain.length (); for (j = 0; j < np; j++) - { - pred_info one_pred = one_pred_chain[j]; - if (one_pred.invert) - fprintf (dump_file, " (.NOT.) "); - print_generic_expr (dump_file, one_pred.pred_lhs, 0); - fprintf (dump_file, " %s ", op_symbol_code (one_pred.cond_code)); - print_generic_expr (dump_file, one_pred.pred_rhs, 0); - if (j < np - 1) - fprintf (dump_file, " (.AND.) "); - else - fprintf (dump_file, "\n"); - } + { + pred_info one_pred = one_pred_chain[j]; + if (one_pred.invert) + fprintf (dump_file, " (.NOT.) "); + print_generic_expr (dump_file, one_pred.pred_lhs, 0); + fprintf (dump_file, " %s ", op_symbol_code (one_pred.cond_code)); + print_generic_expr (dump_file, one_pred.pred_rhs, 0); + if (j < np - 1) + fprintf (dump_file, " (.AND.) "); + else + fprintf (dump_file, "\n"); + } if (i < num_preds - 1) - fprintf (dump_file, "(.OR.)\n"); + fprintf (dump_file, "(.OR.)\n"); else - fprintf (dump_file, "\n\n"); + fprintf (dump_file, "\n\n"); } } @@ -845,7 +845,7 @@ destroy_predicate_vecs (pred_chain_union *preds) static enum tree_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; @@ -896,27 +896,27 @@ is_value_included_in (tree val, tree boundary, enum tree_code cmpc) if (is_unsigned) { if (cmpc == EQ_EXPR) - result = tree_int_cst_equal (val, boundary); + result = tree_int_cst_equal (val, boundary); else if (cmpc == LT_EXPR) - result = tree_int_cst_lt (val, boundary); + result = tree_int_cst_lt (val, boundary); else - { - gcc_assert (cmpc == LE_EXPR); - result = tree_int_cst_le (val, boundary); - } + { + gcc_assert (cmpc == LE_EXPR); + result = tree_int_cst_le (val, boundary); + } } else { if (cmpc == EQ_EXPR) - result = tree_int_cst_equal (val, boundary); + result = tree_int_cst_equal (val, boundary); else if (cmpc == LT_EXPR) - result = tree_int_cst_lt (val, boundary); + result = tree_int_cst_lt (val, boundary); else - { - gcc_assert (cmpc == LE_EXPR); - result = (tree_int_cst_equal (val, boundary) - || tree_int_cst_lt (val, boundary)); - } + { + gcc_assert (cmpc == LE_EXPR); + result = (tree_int_cst_equal (val, boundary) + || tree_int_cst_lt (val, boundary)); + } } if (inverted) @@ -931,8 +931,8 @@ is_value_included_in (tree val, tree boundary, enum tree_code cmpc) static bool find_matching_predicate_in_rest_chains (pred_info pred, - pred_chain_union preds, - size_t num_pred_chains) + pred_chain_union preds, + size_t num_pred_chains) { size_t i, j, n; @@ -946,24 +946,24 @@ find_matching_predicate_in_rest_chains (pred_info pred, pred_chain one_chain = preds[i]; n = one_chain.length (); for (j = 0; j < n; j++) - { - pred_info pred2 = one_chain[j]; - /* Can relax the condition comparison to not - use address comparison. However, the most common - case is that multiple control dependent paths share - a common path prefix, so address comparison should - be ok. */ + { + pred_info pred2 = one_chain[j]; + /* Can relax the condition comparison to not + use address comparison. However, the most common + case is that multiple control dependent paths share + a common path prefix, so address comparison should + be ok. */ - if (operand_equal_p (pred2.pred_lhs, pred.pred_lhs, 0) - && operand_equal_p (pred2.pred_rhs, pred.pred_rhs, 0) - && pred2.invert == pred.invert) - { - found = true; - break; - } - } + if (operand_equal_p (pred2.pred_lhs, pred.pred_lhs, 0) + && operand_equal_p (pred2.pred_rhs, pred.pred_rhs, 0) + && pred2.invert == pred.invert) + { + found = true; + break; + } + } if (!found) - return false; + return false; } return true; } @@ -971,11 +971,11 @@ find_matching_predicate_in_rest_chains (pred_info pred, /* Forward declaration. */ static bool is_use_properly_guarded (gimple *use_stmt, - basic_block use_bb, - gphi *phi, - unsigned uninit_opnds, + basic_block use_bb, + gphi *phi, + unsigned uninit_opnds, pred_chain_union *def_preds, - hash_set *visited_phis); + hash_set *visited_phis); /* Returns true if all uninitialized opnds are pruned. Returns false otherwise. PHI is the phi node with uninitialized operands, @@ -990,7 +990,7 @@ is_use_properly_guarded (gimple *use_stmt, Example scenario: BB1: - flag_1 = phi <0, 1> // (1) + flag_1 = phi <0, 1> // (1) var_1 = phi @@ -1001,7 +1001,7 @@ is_use_properly_guarded (gimple *use_stmt, goto 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 flag phis recursively, it is conservatively treated as unknown and var_1 @@ -1027,77 +1027,77 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, tree flag_arg; if (!MASK_TEST_BIT (uninit_opnds, i)) - continue; + continue; flag_arg = gimple_phi_arg_def (flag_def, i); if (!is_gimple_constant (flag_arg)) - { - gphi *flag_arg_def, *phi_arg_def; - tree phi_arg; - unsigned uninit_opnds_arg_phi; + { + gphi *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 = dyn_cast (SSA_NAME_DEF_STMT (flag_arg)); + if (TREE_CODE (flag_arg) != SSA_NAME) + return false; + flag_arg_def = dyn_cast (SSA_NAME_DEF_STMT (flag_arg)); if (!flag_arg_def) - return false; + return false; - phi_arg = gimple_phi_arg_def (phi, i); - if (TREE_CODE (phi_arg) != SSA_NAME) - return false; + phi_arg = gimple_phi_arg_def (phi, i); + if (TREE_CODE (phi_arg) != SSA_NAME) + return false; - phi_arg_def = dyn_cast (SSA_NAME_DEF_STMT (phi_arg)); + phi_arg_def = dyn_cast (SSA_NAME_DEF_STMT (phi_arg)); if (!phi_arg_def) - return false; + return false; - if (gimple_bb (phi_arg_def) != gimple_bb (flag_arg_def)) - 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 (!*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; + 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))); + 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 + /* 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; + return false; - bitmap_clear_bit (*visited_flag_phis, - SSA_NAME_VERSION (gimple_phi_result (flag_arg_def))); - continue; - } + 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; + { + tree opnd; gimple *opnd_def; - /* Now that we know that this undefined edge is not - pruned. If the operand is defined by another phi, - we can further prune the incoming edges of that - phi by checking the predicates of this operands. */ + /* Now that we know that this undefined edge is not + pruned. If the operand is defined by another phi, + we can further prune the incoming edges of that + phi by checking the predicates of this operands. */ - opnd = gimple_phi_arg_def (phi, i); - opnd_def = SSA_NAME_DEF_STMT (opnd); - if (gphi *opnd_def_phi = dyn_cast (opnd_def)) - { - edge opnd_edge; - unsigned uninit_opnds2 - = compute_uninit_opnds_pos (opnd_def_phi); - pred_chain_union def_preds = vNULL; - bool ok; - gcc_assert (!MASK_EMPTY (uninit_opnds2)); - opnd_edge = gimple_phi_arg_edge (phi, i); - ok = is_use_properly_guarded (phi, + opnd = gimple_phi_arg_def (phi, i); + opnd_def = SSA_NAME_DEF_STMT (opnd); + if (gphi *opnd_def_phi = dyn_cast (opnd_def)) + { + edge opnd_edge; + unsigned uninit_opnds2 + = compute_uninit_opnds_pos (opnd_def_phi); + pred_chain_union def_preds = vNULL; + bool ok; + gcc_assert (!MASK_EMPTY (uninit_opnds2)); + opnd_edge = gimple_phi_arg_edge (phi, i); + ok = is_use_properly_guarded (phi, opnd_edge->src, opnd_def_phi, uninit_opnds2, @@ -1106,10 +1106,10 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, destroy_predicate_vecs (&def_preds); if (!ok) return false; - } - else - return false; - } + } + else + return false; + } } return true; @@ -1119,50 +1119,50 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, 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; - } + if (some_cond) + { + x = ...; + flag = true; + } - ... some code ... + ... some code ... - if (flag) - use (x); + 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; - } + bool init_func (int * x) + { + if (some_cond) + return false; + *x = .. + return true; + } - void foo(..) - { - int x; + void foo(..) + { + int x; - if (!init_func(&x)) - return; + if (!init_func(&x)) + return; - .. some_code ... - use (x); - } + .. 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; - } + if (n > 0) + x = 1; + ... + if (n > 0) + { + if (m < 2) + .. = x; + } Predicate analysis needs to compute the composite predicate: @@ -1173,8 +1173,8 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, bb and is dominating the operand def.) and check overlapping: - (n > 0) .AND. (m < 2) .AND. (.NOT. (n > 0)) - <==> false + (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 @@ -1191,7 +1191,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi, static bool use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds, - gphi *phi, unsigned uninit_opnds, + gphi *phi, unsigned uninit_opnds, hash_set *visited_phis) { unsigned int i, n; @@ -1223,32 +1223,32 @@ use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds, cmp_code = the_pred.cond_code; 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; - } + && 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; - } + && cond_lhs != NULL_TREE && is_gimple_constant (cond_lhs)) + { + boundary_cst = cond_lhs; + flag = cond_rhs; + swap_cond = true; + } if (!flag) - continue; + continue; flag_def = SSA_NAME_DEF_STMT (flag); if (!flag_def) - continue; + continue; if ((gimple_code (flag_def) == GIMPLE_PHI) - && (gimple_bb (flag_def) == gimple_bb (phi)) - && find_matching_predicate_in_rest_chains (the_pred, preds, + && (gimple_bb (flag_def) == gimple_bb (phi)) + && find_matching_predicate_in_rest_chains (the_pred, preds, num_preds)) - break; + break; flag_def = 0; } @@ -1264,12 +1264,12 @@ use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds, return false; all_pruned = prune_uninit_phi_opnds_in_unrealizable_paths (phi, - uninit_opnds, - as_a (flag_def), - boundary_cst, - cmp_code, - visited_phis, - &visited_flag_phis); + uninit_opnds, + as_a (flag_def), + boundary_cst, + cmp_code, + visited_phis, + &visited_flag_phis); if (visited_flag_phis) BITMAP_FREE (visited_flag_phis); @@ -1305,13 +1305,13 @@ static inline bool is_neq_relop_p (pred_info pred) { - return (pred.cond_code == NE_EXPR && !pred.invert) - || (pred.cond_code == EQ_EXPR && pred.invert); + return (pred.cond_code == NE_EXPR && !pred.invert) + || (pred.cond_code == EQ_EXPR && pred.invert); } /* Returns true if pred is of the form X != 0. */ -static inline bool +static inline bool is_neq_zero_form_p (pred_info pred) { if (!is_neq_relop_p (pred) || !integer_zerop (pred.pred_rhs) @@ -1377,7 +1377,7 @@ is_pred_expr_subset_of (pred_info expr1, pred_info expr2) static bool is_pred_chain_subset_of (pred_chain pred1, - pred_chain pred2) + pred_chain pred2) { size_t np1, np2, i1, i2; @@ -1389,16 +1389,16 @@ is_pred_chain_subset_of (pred_chain pred1, bool found = false; pred_info info2 = pred2[i2]; for (i1 = 0; i1 < np1; i1++) - { - pred_info info1 = pred1[i1]; - if (is_pred_expr_subset_of (info1, info2)) - { - found = true; - break; - } - } + { + pred_info info1 = pred1[i1]; + if (is_pred_expr_subset_of (info1, info2)) + { + found = true; + break; + } + } if (!found) - return false; + return false; } return true; } @@ -1421,7 +1421,7 @@ is_included_in (pred_chain one_pred, pred_chain_union preds) for (i = 0; i < n; i++) { if (is_pred_chain_subset_of (one_pred, preds[i])) - return true; + return true; } return false; @@ -1452,7 +1452,7 @@ is_superset_of (pred_chain_union preds1, pred_chain_union preds2) { one_pred_chain = preds2[i]; if (!is_included_in (one_pred_chain, preds1)) - return false; + return false; } return true; @@ -1464,8 +1464,8 @@ static inline bool is_and_or_or_p (enum tree_code tc, tree type) { return (tc == BIT_IOR_EXPR - || (tc == BIT_AND_EXPR - && (type == 0 || TREE_CODE (type) == BOOLEAN_TYPE))); + || (tc == BIT_AND_EXPR + && (type == 0 || TREE_CODE (type) == BOOLEAN_TYPE))); } /* Returns true if X1 is the negate of X2. */ @@ -1477,7 +1477,7 @@ pred_neg_p (pred_info x1, pred_info x2) if (!operand_equal_p (x1.pred_lhs, x2.pred_lhs, 0) || !operand_equal_p (x1.pred_rhs, x2.pred_rhs, 0)) return false; - + c1 = x1.cond_code; if (x1.invert == x2.invert) c2 = invert_tree_comparison (x2.cond_code, false); @@ -1493,7 +1493,7 @@ pred_neg_p (pred_info x1, pred_info x2) 4) ((x IAND y) != 0) || (x != 0 AND y != 0)) is equivalent to (x != 0 AND y != 0) 5) (X AND Y) OR (!X AND Z) OR (!Y AND Z) is equivalent to - (X AND Y) OR Z + (X AND Y) OR Z PREDS is the predicate chains, and N is the number of chains. */ @@ -1514,35 +1514,35 @@ simplify_pred (pred_chain *one_chain) pred_info *a_pred = &(*one_chain)[i]; if (!a_pred->pred_lhs) - continue; + continue; if (!is_neq_zero_form_p (*a_pred)) - continue; + continue; gimple *def_stmt = SSA_NAME_DEF_STMT (a_pred->pred_lhs); if (gimple_code (def_stmt) != GIMPLE_ASSIGN) - continue; + continue; if (gimple_assign_rhs_code (def_stmt) == BIT_IOR_EXPR) - { - for (j = 0; j < n; j++) - { - pred_info *b_pred = &(*one_chain)[j]; + { + for (j = 0; j < n; j++) + { + pred_info *b_pred = &(*one_chain)[j]; - if (!b_pred->pred_lhs) - continue; - if (!is_neq_zero_form_p (*b_pred)) - continue; + if (!b_pred->pred_lhs) + continue; + if (!is_neq_zero_form_p (*b_pred)) + continue; - if (pred_expr_equal_p (*b_pred, gimple_assign_rhs1 (def_stmt)) - || pred_expr_equal_p (*b_pred, gimple_assign_rhs2 (def_stmt))) - { - /* Mark a_pred for removal. */ - a_pred->pred_lhs = NULL; - a_pred->pred_rhs = NULL; - simplified = true; - break; - } - } - } + if (pred_expr_equal_p (*b_pred, gimple_assign_rhs1 (def_stmt)) + || pred_expr_equal_p (*b_pred, gimple_assign_rhs2 (def_stmt))) + { + /* Mark a_pred for removal. */ + a_pred->pred_lhs = NULL; + a_pred->pred_rhs = NULL; + simplified = true; + break; + } + } + } } if (!simplified) @@ -1552,7 +1552,7 @@ simplify_pred (pred_chain *one_chain) { pred_info *a_pred = &(*one_chain)[i]; if (!a_pred->pred_lhs) - continue; + continue; s_chain.safe_push (*a_pred); } @@ -1572,7 +1572,7 @@ simplify_preds_2 (pred_chain_union *preds) bool simplified = false; pred_chain_union s_preds = vNULL; - /* (X AND Y) OR (!X AND Y) is equivalent to Y. + /* (X AND Y) OR (!X AND Y) is equivalent to Y. (X AND Y) OR (X AND !Y) is equivalent to X. */ n = preds->length (); @@ -1582,55 +1582,55 @@ simplify_preds_2 (pred_chain_union *preds) pred_chain *a_chain = &(*preds)[i]; if (a_chain->length () != 2) - continue; + continue; x = (*a_chain)[0]; y = (*a_chain)[1]; for (j = 0; j < n; j++) - { - pred_chain *b_chain; - pred_info x2, y2; + { + pred_chain *b_chain; + pred_info x2, y2; - if (j == i) - continue; + if (j == i) + continue; - b_chain = &(*preds)[j]; - if (b_chain->length () != 2) - continue; + b_chain = &(*preds)[j]; + if (b_chain->length () != 2) + continue; - x2 = (*b_chain)[0]; - y2 = (*b_chain)[1]; + x2 = (*b_chain)[0]; + y2 = (*b_chain)[1]; - if (pred_equal_p (x, x2) && pred_neg_p (y, y2)) - { - /* Kill a_chain. */ - a_chain->release (); - b_chain->release (); - b_chain->safe_push (x); - simplified = true; - break; - } - if (pred_neg_p (x, x2) && pred_equal_p (y, y2)) - { - /* Kill a_chain. */ - a_chain->release (); - b_chain->release (); - b_chain->safe_push (y); - simplified = true; - break; - } - } + if (pred_equal_p (x, x2) && pred_neg_p (y, y2)) + { + /* Kill a_chain. */ + a_chain->release (); + b_chain->release (); + b_chain->safe_push (x); + simplified = true; + break; + } + if (pred_neg_p (x, x2) && pred_equal_p (y, y2)) + { + /* Kill a_chain. */ + a_chain->release (); + b_chain->release (); + b_chain->safe_push (y); + simplified = true; + break; + } + } } /* Now clean up the chain. */ if (simplified) { for (i = 0; i < n; i++) - { - if ((*preds)[i].is_empty ()) - continue; - s_preds.safe_push ((*preds)[i]); - } + { + if ((*preds)[i].is_empty ()) + continue; + s_preds.safe_push ((*preds)[i]); + } preds->release (); (*preds) = s_preds; s_preds = vNULL; @@ -1663,34 +1663,34 @@ simplify_preds_3 (pred_chain_union *preds) pred_chain *a_chain = &(*preds)[i]; if (a_chain->length () != 1) - continue; + continue; x = (*a_chain)[0]; for (j = 0; j < n; j++) - { - pred_chain *b_chain; - pred_info x2; - size_t k; + { + pred_chain *b_chain; + pred_info x2; + size_t k; - if (j == i) - continue; + if (j == i) + continue; - b_chain = &(*preds)[j]; - if (b_chain->length () < 2) - continue; + b_chain = &(*preds)[j]; + if (b_chain->length () < 2) + continue; - for (k = 0; k < b_chain->length (); k++) - { - x2 = (*b_chain)[k]; - if (pred_neg_p (x, x2)) - { - b_chain->unordered_remove (k); - simplified = true; - break; - } - } - } + for (k = 0; k < b_chain->length (); k++) + { + x2 = (*b_chain)[k]; + if (pred_neg_p (x, x2)) + { + b_chain->unordered_remove (k); + simplified = true; + break; + } + } + } } return simplified; } @@ -1716,59 +1716,59 @@ simplify_preds_4 (pred_chain_union *preds) pred_chain *a_chain = &(*preds)[i]; if (a_chain->length () != 1) - continue; + continue; z = (*a_chain)[0]; if (!is_neq_zero_form_p (z)) - continue; + continue; def_stmt = SSA_NAME_DEF_STMT (z.pred_lhs); if (gimple_code (def_stmt) != GIMPLE_ASSIGN) - continue; + continue; if (gimple_assign_rhs_code (def_stmt) != BIT_AND_EXPR) - continue; + continue; for (j = 0; j < n; j++) - { - pred_chain *b_chain; - pred_info x2, y2; + { + pred_chain *b_chain; + pred_info x2, y2; - if (j == i) - continue; + if (j == i) + continue; - b_chain = &(*preds)[j]; - if (b_chain->length () != 2) - continue; + b_chain = &(*preds)[j]; + if (b_chain->length () != 2) + continue; - x2 = (*b_chain)[0]; - y2 = (*b_chain)[1]; - if (!is_neq_zero_form_p (x2) - || !is_neq_zero_form_p (y2)) - continue; + x2 = (*b_chain)[0]; + y2 = (*b_chain)[1]; + if (!is_neq_zero_form_p (x2) + || !is_neq_zero_form_p (y2)) + continue; - if ((pred_expr_equal_p (x2, gimple_assign_rhs1 (def_stmt)) - && pred_expr_equal_p (y2, gimple_assign_rhs2 (def_stmt))) - || (pred_expr_equal_p (x2, gimple_assign_rhs2 (def_stmt)) - && pred_expr_equal_p (y2, gimple_assign_rhs1 (def_stmt)))) - { - /* Kill a_chain. */ - a_chain->release (); - simplified = true; - break; - } - } + if ((pred_expr_equal_p (x2, gimple_assign_rhs1 (def_stmt)) + && pred_expr_equal_p (y2, gimple_assign_rhs2 (def_stmt))) + || (pred_expr_equal_p (x2, gimple_assign_rhs2 (def_stmt)) + && pred_expr_equal_p (y2, gimple_assign_rhs1 (def_stmt)))) + { + /* Kill a_chain. */ + a_chain->release (); + simplified = true; + break; + } + } } /* Now clean up the chain. */ if (simplified) { for (i = 0; i < n; i++) - { - if ((*preds)[i].is_empty ()) - continue; - s_preds.safe_push ((*preds)[i]); - } + { + if ((*preds)[i].is_empty ()) + continue; + s_preds.safe_push ((*preds)[i]); + } destroy_predicate_vecs (preds); (*preds) = s_preds; @@ -1804,15 +1804,15 @@ simplify_preds (pred_chain_union *preds, gimple *use_or_def, bool is_use) { changed = false; if (simplify_preds_2 (preds)) - changed = true; + changed = true; /* Now iteratively simplify X OR (!X AND Z ..) into X OR (Z ...). */ if (simplify_preds_3 (preds)) - changed = true; + changed = true; if (simplify_preds_4 (preds)) - changed = true; + changed = true; } while (changed); @@ -1821,7 +1821,7 @@ simplify_preds (pred_chain_union *preds, gimple *use_or_def, bool is_use) /* 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 - 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. Example: @@ -1846,7 +1846,7 @@ simplify_preds (pred_chain_union *preds, gimple *use_or_def, bool is_use) then _t != 0 will be normalized into a pred_chain: (_2 RELOP1 _1) AND (_5 RELOP2 _4) AND (_8 RELOP3 _7) AND (_0 != 0) - + */ /* This is a helper function that stores a PRED into NORM_PREDS. */ @@ -1864,7 +1864,7 @@ push_pred (pred_chain_union *norm_preds, pred_info pred) inline static void push_to_worklist (tree op, vec *work_list, - hash_set *mark_set) + hash_set *mark_set) { if (mark_set->contains (op)) return; @@ -1925,52 +1925,52 @@ is_degenerated_phi (gimple *phi, pred_info *pred_p) tree op = gimple_phi_arg_def (phi, i); if (TREE_CODE (op) != SSA_NAME) - return false; + return false; def = SSA_NAME_DEF_STMT (op); if (gimple_code (def) != GIMPLE_ASSIGN) - return false; + return false; if (TREE_CODE_CLASS (gimple_assign_rhs_code (def)) - != tcc_comparison) - return false; + != tcc_comparison) + return false; pred = get_pred_info_from_cmp (def); if (!pred_equal_p (pred, pred0)) - return false; + return false; } *pred_p = pred0; return true; } -/* Normalize one predicate PRED +/* Normalize one predicate PRED 1) if PRED can no longer be normlized, put it into NORM_PREDS. 2) otherwise if PRED is of the form x != 0, follow x's definition and put normalized predicates into WORK_LIST. */ - + static void -normalize_one_pred_1 (pred_chain_union *norm_preds, - pred_chain *norm_chain, - pred_info pred, - enum tree_code and_or_code, - vec *work_list, +normalize_one_pred_1 (pred_chain_union *norm_preds, + pred_chain *norm_chain, + pred_info pred, + enum tree_code and_or_code, + vec *work_list, hash_set *mark_set) { if (!is_neq_zero_form_p (pred)) { if (and_or_code == BIT_IOR_EXPR) - push_pred (norm_preds, pred); + push_pred (norm_preds, pred); else - norm_chain->safe_push (pred); + norm_chain->safe_push (pred); return; } gimple *def_stmt = SSA_NAME_DEF_STMT (pred.pred_lhs); - + if (gimple_code (def_stmt) == GIMPLE_PHI && is_degenerated_phi (def_stmt, &pred)) work_list->safe_push (pred); else if (gimple_code (def_stmt) == GIMPLE_PHI - && and_or_code == BIT_IOR_EXPR) + && and_or_code == BIT_IOR_EXPR) { int i, n; n = gimple_phi_num_args (def_stmt); @@ -1978,23 +1978,23 @@ normalize_one_pred_1 (pred_chain_union *norm_preds, /* If we see non zero constant, we should punt. The predicate * should be one guarding the phi edge. */ for (i = 0; i < n; ++i) - { - tree op = gimple_phi_arg_def (def_stmt, i); - if (TREE_CODE (op) == INTEGER_CST && !integer_zerop (op)) - { - push_pred (norm_preds, pred); - return; - } - } + { + tree op = gimple_phi_arg_def (def_stmt, i); + if (TREE_CODE (op) == INTEGER_CST && !integer_zerop (op)) + { + push_pred (norm_preds, pred); + return; + } + } for (i = 0; i < n; ++i) - { - tree op = gimple_phi_arg_def (def_stmt, i); - if (integer_zerop (op)) - continue; + { + tree op = gimple_phi_arg_def (def_stmt, i); + if (integer_zerop (op)) + continue; - push_to_worklist (op, work_list, mark_set); - } + push_to_worklist (op, work_list, mark_set); + } } else if (gimple_code (def_stmt) != GIMPLE_ASSIGN) { @@ -2047,7 +2047,7 @@ normalize_one_pred_1 (pred_chain_union *norm_preds, static void normalize_one_pred (pred_chain_union *norm_preds, - pred_info pred) + pred_info pred) { vec work_list = vNULL; enum tree_code and_or_code = ERROR_MARK; @@ -2066,13 +2066,13 @@ normalize_one_pred (pred_chain_union *norm_preds, && and_or_code != BIT_AND_EXPR) { if (TREE_CODE_CLASS (and_or_code) - == tcc_comparison) - { - pred_info n_pred = get_pred_info_from_cmp (def_stmt); - push_pred (norm_preds, n_pred); - } + == tcc_comparison) + { + pred_info n_pred = get_pred_info_from_cmp (def_stmt); + push_pred (norm_preds, n_pred); + } else - push_pred (norm_preds, pred); + push_pred (norm_preds, pred); return; } @@ -2083,7 +2083,7 @@ normalize_one_pred (pred_chain_union *norm_preds, { pred_info a_pred = work_list.pop (); normalize_one_pred_1 (norm_preds, &norm_chain, a_pred, - and_or_code, &work_list, &mark_set); + and_or_code, &work_list, &mark_set); } if (and_or_code == BIT_AND_EXPR) norm_preds->safe_push (norm_chain); @@ -2093,7 +2093,7 @@ normalize_one_pred (pred_chain_union *norm_preds, static void normalize_one_pred_chain (pred_chain_union *norm_preds, - pred_chain one_chain) + pred_chain one_chain) { vec work_list = vNULL; hash_set mark_set; @@ -2110,7 +2110,7 @@ normalize_one_pred_chain (pred_chain_union *norm_preds, { pred_info a_pred = work_list.pop (); normalize_one_pred_1 (0, &norm_chain, a_pred, - BIT_AND_EXPR, &work_list, &mark_set); + BIT_AND_EXPR, &work_list, &mark_set); } norm_preds->safe_push (norm_chain); @@ -2135,12 +2135,12 @@ normalize_preds (pred_chain_union preds, gimple *use_or_def, bool is_use) for (i = 0; i < n; i++) { if (preds[i].length () != 1) - normalize_one_pred_chain (&norm_preds, preds[i]); + normalize_one_pred_chain (&norm_preds, preds[i]); else - { - normalize_one_pred (&norm_preds, preds[i][0]); - preds[i].release (); - } + { + normalize_one_pred (&norm_preds, preds[i][0]); + preds[i].release (); + } } if (dump_file) @@ -2177,11 +2177,11 @@ normalize_preds (pred_chain_union preds, gimple *use_or_def, bool is_use) static bool is_use_properly_guarded (gimple *use_stmt, - basic_block use_bb, - gphi *phi, - unsigned uninit_opnds, + basic_block use_bb, + gphi *phi, + unsigned uninit_opnds, pred_chain_union *def_preds, - hash_set *visited_phis) + hash_set *visited_phis) { basic_block phi_bb; pred_chain_union preds = vNULL; @@ -2249,7 +2249,7 @@ is_use_properly_guarded (gimple *use_stmt, static gimple * find_uninit_use (gphi *phi, unsigned uninit_opnds, - vec *worklist, + vec *worklist, hash_set *added_to_worklist) { tree phi_result; @@ -2281,10 +2281,10 @@ find_uninit_use (gphi *phi, unsigned uninit_opnds, continue; if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "[CHECK]: Found unguarded use: "); - print_gimple_stmt (dump_file, use_stmt, 0, 0); - } + { + 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) { @@ -2293,18 +2293,18 @@ find_uninit_use (gphi *phi, unsigned uninit_opnds, } /* 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 (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); - } + { + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "[WORKLIST]: Update worklist with phi: "); + print_gimple_stmt (dump_file, use_stmt, 0, 0); + } - worklist->safe_push (as_a (use_stmt)); - possibly_undefined_names->add (phi_result); - } + worklist->safe_push (as_a (use_stmt)); + possibly_undefined_names->add (phi_result); + } } destroy_predicate_vecs (&def_preds); @@ -2321,7 +2321,7 @@ find_uninit_use (gphi *phi, unsigned uninit_opnds, static void warn_uninitialized_phi (gphi *phi, vec *worklist, - hash_set *added_to_worklist) + hash_set *added_to_worklist) { unsigned uninit_opnds; gimple *uninit_use_stmt = 0; @@ -2346,7 +2346,7 @@ warn_uninitialized_phi (gphi *phi, vec *worklist, /* 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); + worklist, added_to_worklist); /* All uses are properly guarded. */ if (!uninit_use_stmt) @@ -2362,8 +2362,8 @@ warn_uninitialized_phi (gphi *phi, vec *worklist, loc = UNKNOWN_LOCATION; warn_uninit (OPT_Wmaybe_uninitialized, uninit_op, SSA_NAME_VAR (uninit_op), SSA_NAME_VAR (uninit_op), - "%qD may be used uninitialized in this function", - uninit_use_stmt, loc); + "%qD may be used uninitialized in this function", + uninit_use_stmt, loc); }