| /* Predicate aware uninitialized variable warning. |
| Copyright (C) 2001-2021 Free Software Foundation, Inc. |
| Contributed by Xinliang David Li <davidxl@google.com> |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3, or (at your option) |
| any later version. |
| |
| GCC is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GCC; see the file COPYING3. If not see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #define INCLUDE_STRING |
| #include "config.h" |
| #include "system.h" |
| #include "coretypes.h" |
| #include "backend.h" |
| #include "tree.h" |
| #include "gimple.h" |
| #include "tree-pass.h" |
| #include "ssa.h" |
| #include "gimple-pretty-print.h" |
| #include "diagnostic-core.h" |
| #include "fold-const.h" |
| #include "gimple-iterator.h" |
| #include "tree-ssa.h" |
| #include "tree-cfg.h" |
| #include "cfghooks.h" |
| #include "attribs.h" |
| #include "builtins.h" |
| #include "calls.h" |
| |
| /* This implements the pass that does predicate aware warning on uses of |
| possibly uninitialized variables. The pass first collects the set of |
| possibly uninitialized SSA names. For each such name, it walks through |
| all its immediate uses. For each immediate use, it rebuilds the condition |
| expression (the predicate) that guards the use. The predicate is then |
| 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 |
| default definitions or by checking if the predicate set that guards the |
| defining paths is a superset of the use predicate. */ |
| |
| /* Max PHI args we can handle in pass. */ |
| const unsigned max_phi_args = 32; |
| |
| /* Pointer set of potentially undefined ssa names, i.e., |
| ssa names that are defined by phi with operands that |
| are not defined or potentially undefined. */ |
| static hash_set<tree> *possibly_undefined_names = 0; |
| |
| /* Bit mask handling macros. */ |
| #define MASK_SET_BIT(mask, pos) mask |= (1 << pos) |
| #define MASK_TEST_BIT(mask, pos) (mask & (1 << pos)) |
| #define MASK_EMPTY(mask) (mask == 0) |
| |
| /* Returns the first bit position (starting from LSB) |
| in mask that is non zero. Returns -1 if the mask is empty. */ |
| static int |
| get_mask_first_set_bit (unsigned mask) |
| { |
| int pos = 0; |
| if (mask == 0) |
| return -1; |
| |
| while ((mask & (1 << pos)) == 0) |
| pos++; |
| |
| return pos; |
| } |
| #define MASK_FIRST_SET_BIT(mask) get_mask_first_set_bit (mask) |
| |
| /* Return true if T, an SSA_NAME, has an undefined value. */ |
| static bool |
| has_undefined_value_p (tree t) |
| { |
| return (ssa_undefined_value_p (t) |
| || (possibly_undefined_names |
| && possibly_undefined_names->contains (t))); |
| } |
| |
| /* Like has_undefined_value_p, but don't return true if TREE_NO_WARNING |
| is set on SSA_NAME_VAR. */ |
| |
| static inline bool |
| uninit_undefined_value_p (tree t) |
| { |
| if (!has_undefined_value_p (t)) |
| return false; |
| if (SSA_NAME_VAR (t) && TREE_NO_WARNING (SSA_NAME_VAR (t))) |
| return false; |
| return true; |
| } |
| |
| /* Emit warnings for uninitialized variables. This is done in two passes. |
| |
| The first pass notices real uses of SSA names with undefined values. |
| Such uses are unconditionally uninitialized, and we can be certain that |
| such a use is a mistake. This pass is run before most optimizations, |
| so that we catch as many as we can. |
| |
| The second pass follows PHI nodes to find uses that are potentially |
| uninitialized. In this case we can't necessarily prove that the use |
| is really uninitialized. This pass is run after most optimizations, |
| so that we thread as many jumps and possible, and delete as much dead |
| code as possible, in order to reduce false positives. We also look |
| again for plain uninitialized variables, since optimization may have |
| changed conditionally uninitialized to unconditionally uninitialized. */ |
| |
| /* 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 |
| 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 |
| gives which argument of the phi node to take the location from. WC |
| is the warning code. */ |
| |
| static void |
| warn_uninit (enum opt_code wc, tree t, tree expr, tree var, |
| const char *gmsgid, void *data, location_t phiarg_loc) |
| { |
| gimple *context = (gimple *) data; |
| location_t location, cfun_loc; |
| expanded_location xloc, floc; |
| |
| /* Ignore COMPLEX_EXPR as initializing only a part of a complex |
| turns in a COMPLEX_EXPR with the not initialized part being |
| set to its previous (undefined) value. */ |
| if (is_gimple_assign (context) |
| && gimple_assign_rhs_code (context) == COMPLEX_EXPR) |
| return; |
| if (!has_undefined_value_p (t)) |
| return; |
| |
| /* Anonymous SSA_NAMEs shouldn't be uninitialized, but ssa_undefined_value_p |
| can return true if the def stmt of anonymous SSA_NAME is COMPLEX_EXPR |
| created for conversion from scalar to complex. Use the underlying var of |
| the COMPLEX_EXPRs real part in that case. See PR71581. */ |
| if (expr == NULL_TREE |
| && var == NULL_TREE |
| && SSA_NAME_VAR (t) == NULL_TREE |
| && is_gimple_assign (SSA_NAME_DEF_STMT (t)) |
| && gimple_assign_rhs_code (SSA_NAME_DEF_STMT (t)) == COMPLEX_EXPR) |
| { |
| tree v = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (t)); |
| if (TREE_CODE (v) == SSA_NAME |
| && has_undefined_value_p (v) |
| && zerop (gimple_assign_rhs2 (SSA_NAME_DEF_STMT (t)))) |
| { |
| expr = SSA_NAME_VAR (v); |
| var = expr; |
| } |
| } |
| |
| if (expr == NULL_TREE) |
| return; |
| |
| /* TREE_NO_WARNING either means we already warned, or the front end |
| wishes to suppress the warning. */ |
| if ((context |
| && (gimple_no_warning_p (context) |
| || (gimple_assign_single_p (context) |
| && TREE_NO_WARNING (gimple_assign_rhs1 (context))))) |
| || TREE_NO_WARNING (expr)) |
| return; |
| |
| if (context != NULL && gimple_has_location (context)) |
| location = gimple_location (context); |
| else if (phiarg_loc != UNKNOWN_LOCATION) |
| location = phiarg_loc; |
| else |
| location = DECL_SOURCE_LOCATION (var); |
| location = linemap_resolve_location (line_table, location, |
| LRK_SPELLING_LOCATION, NULL); |
| cfun_loc = DECL_SOURCE_LOCATION (cfun->decl); |
| xloc = expand_location (location); |
| floc = expand_location (cfun_loc); |
| auto_diagnostic_group d; |
| if (warning_at (location, wc, gmsgid, expr)) |
| { |
| TREE_NO_WARNING (expr) = 1; |
| |
| if (location == DECL_SOURCE_LOCATION (var)) |
| return; |
| if (xloc.file != floc.file |
| || linemap_location_before_p (line_table, location, cfun_loc) |
| || linemap_location_before_p (line_table, cfun->function_end_locus, |
| location)) |
| inform (DECL_SOURCE_LOCATION (var), "%qD was declared here", var); |
| } |
| } |
| |
| struct check_defs_data |
| { |
| /* If we found any may-defs besides must-def clobbers. */ |
| bool found_may_defs; |
| }; |
| |
| /* Callback for walk_aliased_vdefs. */ |
| |
| static bool |
| check_defs (ao_ref *ref, tree vdef, void *data_) |
| { |
| check_defs_data *data = (check_defs_data *)data_; |
| gimple *def_stmt = SSA_NAME_DEF_STMT (vdef); |
| /* If this is a clobber then if it is not a kill walk past it. */ |
| if (gimple_clobber_p (def_stmt)) |
| { |
| if (stmt_kills_ref_p (def_stmt, ref)) |
| return true; |
| return false; |
| } |
| /* Found a may-def on this path. */ |
| data->found_may_defs = true; |
| return true; |
| } |
| |
| /* Counters and limits controlling the the depth of analysis and |
| strictness of the warning. */ |
| struct wlimits |
| { |
| /* Number of VDEFs encountered. */ |
| unsigned int vdef_cnt; |
| /* Number of statements examined by walk_aliased_vdefs. */ |
| unsigned int oracle_cnt; |
| /* Limit on the number of statements visited by walk_aliased_vdefs. */ |
| unsigned limit; |
| /* Set when basic block with statement is executed unconditionally. */ |
| bool always_executed; |
| /* Set to issue -Wmaybe-uninitialized. */ |
| bool wmaybe_uninit; |
| }; |
| |
| /* Determine if REF references an uninitialized operand and diagnose |
| it if so. */ |
| |
| static tree |
| maybe_warn_operand (ao_ref &ref, gimple *stmt, tree lhs, tree rhs, |
| wlimits &wlims) |
| { |
| bool has_bit_insert = false; |
| use_operand_p luse_p; |
| imm_use_iterator liter; |
| |
| if (TREE_NO_WARNING (rhs)) |
| return NULL_TREE; |
| |
| /* Do not warn if the base was marked so or this is a |
| hard register var. */ |
| tree base = ao_ref_base (&ref); |
| if ((VAR_P (base) |
| && DECL_HARD_REGISTER (base)) |
| || TREE_NO_WARNING (base)) |
| return NULL_TREE; |
| |
| /* Do not warn if the access is fully outside of the variable. */ |
| poly_int64 decl_size; |
| if (DECL_P (base) |
| && ((known_size_p (ref.size) |
| && known_eq (ref.max_size, ref.size) |
| && known_le (ref.offset + ref.size, 0)) |
| || (known_ge (ref.offset, 0) |
| && DECL_SIZE (base) |
| && poly_int_tree_p (DECL_SIZE (base), &decl_size) |
| && known_le (decl_size, ref.offset)))) |
| return NULL_TREE; |
| |
| /* Do not warn if the result of the access is then used for |
| a BIT_INSERT_EXPR. */ |
| if (lhs && TREE_CODE (lhs) == SSA_NAME) |
| FOR_EACH_IMM_USE_FAST (luse_p, liter, lhs) |
| { |
| gimple *use_stmt = USE_STMT (luse_p); |
| /* BIT_INSERT_EXPR first operand should not be considered |
| a use for the purpose of uninit warnings. */ |
| if (gassign *ass = dyn_cast <gassign *> (use_stmt)) |
| { |
| if (gimple_assign_rhs_code (ass) == BIT_INSERT_EXPR |
| && luse_p->use == gimple_assign_rhs1_ptr (ass)) |
| { |
| has_bit_insert = true; |
| break; |
| } |
| } |
| } |
| |
| if (has_bit_insert) |
| return NULL_TREE; |
| |
| /* Limit the walking to a constant number of stmts after |
| we overcommit quadratic behavior for small functions |
| and O(n) behavior. */ |
| if (wlims.oracle_cnt > 128 * 128 |
| && wlims.oracle_cnt > wlims.vdef_cnt * 2) |
| wlims.limit = 32; |
| |
| check_defs_data data; |
| bool fentry_reached = false; |
| data.found_may_defs = false; |
| tree use = gimple_vuse (stmt); |
| if (!use) |
| return NULL_TREE; |
| int res = walk_aliased_vdefs (&ref, use, |
| check_defs, &data, NULL, |
| &fentry_reached, wlims.limit); |
| if (res == -1) |
| { |
| wlims.oracle_cnt += wlims.limit; |
| return NULL_TREE; |
| } |
| |
| wlims.oracle_cnt += res; |
| if (data.found_may_defs) |
| return NULL_TREE; |
| |
| bool found_alloc = false; |
| |
| if (fentry_reached) |
| { |
| if (TREE_CODE (base) == MEM_REF) |
| base = TREE_OPERAND (base, 0); |
| |
| /* Follow the chain of SSA_NAME assignments looking for an alloca |
| call (or VLA) or malloc/realloc, or for decls. If any is found |
| (and in the latter case, the operand is a local variable) issue |
| a warning. */ |
| while (TREE_CODE (base) == SSA_NAME) |
| { |
| gimple *def_stmt = SSA_NAME_DEF_STMT (base); |
| |
| if (is_gimple_call (def_stmt) |
| && gimple_call_builtin_p (def_stmt)) |
| { |
| /* Detect uses of uninitialized alloca/VLAs. */ |
| tree fndecl = gimple_call_fndecl (def_stmt); |
| const built_in_function fncode = DECL_FUNCTION_CODE (fndecl); |
| if (fncode == BUILT_IN_ALLOCA |
| || fncode == BUILT_IN_ALLOCA_WITH_ALIGN |
| || fncode == BUILT_IN_MALLOC) |
| found_alloc = true; |
| break; |
| } |
| |
| if (!is_gimple_assign (def_stmt)) |
| break; |
| |
| tree_code code = gimple_assign_rhs_code (def_stmt); |
| if (code != ADDR_EXPR && code != POINTER_PLUS_EXPR) |
| break; |
| |
| base = gimple_assign_rhs1 (def_stmt); |
| if (TREE_CODE (base) == ADDR_EXPR) |
| base = TREE_OPERAND (base, 0); |
| |
| if (DECL_P (base) |
| || TREE_CODE (base) == COMPONENT_REF) |
| rhs = base; |
| |
| if (TREE_CODE (base) == MEM_REF) |
| base = TREE_OPERAND (base, 0); |
| |
| if (tree ba = get_base_address (base)) |
| base = ba; |
| } |
| |
| /* Replace the RHS expression with BASE so that it |
| refers to it in the diagnostic (instead of to |
| '<unknown>'). */ |
| if (DECL_P (base) |
| && EXPR_P (rhs) |
| && TREE_CODE (rhs) != COMPONENT_REF) |
| rhs = base; |
| } |
| |
| /* Do not warn if it can be initialized outside this function. |
| If we did not reach function entry then we found killing |
| clobbers on all paths to entry. */ |
| if (!found_alloc |
| && fentry_reached |
| /* ??? We'd like to use ref_may_alias_global_p but that |
| excludes global readonly memory and thus we get bogus |
| warnings from p = cond ? "a" : "b" for example. */ |
| && (!VAR_P (base) |
| || is_global_var (base))) |
| return NULL_TREE; |
| |
| /* Strip the address-of expression from arrays passed to functions. */ |
| if (TREE_CODE (rhs) == ADDR_EXPR) |
| rhs = TREE_OPERAND (rhs, 0); |
| |
| /* Check again since RHS may have changed above. */ |
| if (TREE_NO_WARNING (rhs)) |
| return NULL_TREE; |
| |
| /* Avoid warning about empty types such as structs with no members. |
| The first_field() test is important for C++ where the predicate |
| alone isn't always sufficient. */ |
| tree rhstype = TREE_TYPE (rhs); |
| if (POINTER_TYPE_P (rhstype)) |
| rhstype = TREE_TYPE (rhstype); |
| if (is_empty_type (rhstype)) |
| return NULL_TREE; |
| |
| bool warned = false; |
| /* We didn't find any may-defs so on all paths either |
| reached function entry or a killing clobber. */ |
| location_t location |
| = linemap_resolve_location (line_table, gimple_location (stmt), |
| LRK_SPELLING_LOCATION, NULL); |
| if (wlims.always_executed) |
| { |
| if (warning_at (location, OPT_Wuninitialized, |
| "%G%qE is used uninitialized", stmt, rhs)) |
| { |
| /* ??? This is only effective for decls as in |
| gcc.dg/uninit-B-O0.c. Avoid doing this for maybe-uninit |
| uses or accesses by functions as it may hide important |
| locations. */ |
| if (lhs) |
| TREE_NO_WARNING (rhs) = 1; |
| warned = true; |
| } |
| } |
| else if (wlims.wmaybe_uninit) |
| warned = warning_at (location, OPT_Wmaybe_uninitialized, |
| "%G%qE may be used uninitialized", stmt, rhs); |
| |
| return warned ? base : NULL_TREE; |
| } |
| |
| |
| /* Diagnose passing addresses of uninitialized objects to either const |
| pointer arguments to functions, or to functions declared with attribute |
| access implying read access to those objects. */ |
| |
| static void |
| maybe_warn_pass_by_reference (gcall *stmt, wlimits &wlims) |
| { |
| if (!wlims.wmaybe_uninit) |
| return; |
| |
| unsigned nargs = gimple_call_num_args (stmt); |
| if (!nargs) |
| return; |
| |
| tree fndecl = gimple_call_fndecl (stmt); |
| tree fntype = gimple_call_fntype (stmt); |
| if (!fntype) |
| return; |
| |
| /* Const function do not read their arguments. */ |
| if (gimple_call_flags (stmt) & ECF_CONST) |
| return; |
| |
| const built_in_function fncode |
| = (fndecl && gimple_call_builtin_p (stmt, BUILT_IN_NORMAL) |
| ? DECL_FUNCTION_CODE (fndecl) : (built_in_function)BUILT_IN_LAST); |
| |
| if (fncode == BUILT_IN_MEMCPY || fncode == BUILT_IN_MEMMOVE) |
| /* Avoid diagnosing calls to raw memory functions (this is overly |
| permissive; consider tightening it up). */ |
| return; |
| |
| /* Save the current warning setting and replace it either a "maybe" |
| when passing addresses of uninitialized variables to const-qualified |
| pointers or arguments declared with attribute read_write, or with |
| a "certain" when passing them to arguments declared with attribute |
| read_only. */ |
| const bool save_always_executed = wlims.always_executed; |
| |
| /* Initialize a map of attribute access specifications for arguments |
| to the function function call. */ |
| rdwr_map rdwr_idx; |
| init_attr_rdwr_indices (&rdwr_idx, TYPE_ATTRIBUTES (fntype)); |
| |
| tree argtype; |
| unsigned argno = 0; |
| function_args_iterator it; |
| |
| FOREACH_FUNCTION_ARGS (fntype, argtype, it) |
| { |
| ++argno; |
| |
| if (!POINTER_TYPE_P (argtype)) |
| continue; |
| |
| tree access_size = NULL_TREE; |
| const attr_access* access = rdwr_idx.get (argno - 1); |
| if (access) |
| { |
| if (access->mode == access_none |
| || access->mode == access_write_only) |
| continue; |
| |
| if (access->mode == access_deferred |
| && !TYPE_READONLY (TREE_TYPE (argtype))) |
| continue; |
| |
| if (save_always_executed && access->mode == access_read_only) |
| /* Attribute read_only arguments imply read access. */ |
| wlims.always_executed = true; |
| else |
| /* Attribute read_write arguments are documented as requiring |
| initialized objects but it's expected that aggregates may |
| be only partially initialized regardless. */ |
| wlims.always_executed = false; |
| |
| if (access->sizarg < nargs) |
| access_size = gimple_call_arg (stmt, access->sizarg); |
| } |
| else if (!TYPE_READONLY (TREE_TYPE (argtype))) |
| continue; |
| else if (save_always_executed && fncode != BUILT_IN_LAST) |
| /* Const-qualified arguments to built-ins imply read access. */ |
| wlims.always_executed = true; |
| else |
| /* Const-qualified arguments to ordinary functions imply a likely |
| (but not definitive) read access. */ |
| wlims.always_executed = false; |
| |
| /* Ignore args we are not going to read from. */ |
| if (gimple_call_arg_flags (stmt, argno - 1) & EAF_UNUSED) |
| continue; |
| |
| tree arg = gimple_call_arg (stmt, argno - 1); |
| if (!POINTER_TYPE_P (TREE_TYPE (arg))) |
| /* Avoid actual arguments with invalid types. */ |
| continue; |
| |
| ao_ref ref; |
| ao_ref_init_from_ptr_and_size (&ref, arg, access_size); |
| tree argbase = maybe_warn_operand (ref, stmt, NULL_TREE, arg, wlims); |
| if (!argbase) |
| continue; |
| |
| if (access && access->mode != access_deferred) |
| { |
| const char* const access_str = |
| TREE_STRING_POINTER (access->to_external_string ()); |
| |
| if (fndecl) |
| { |
| location_t loc = DECL_SOURCE_LOCATION (fndecl); |
| inform (loc, "in a call to %qD declared with " |
| "attribute %<%s%> here", fndecl, access_str); |
| } |
| else |
| { |
| /* Handle calls through function pointers. */ |
| location_t loc = gimple_location (stmt); |
| inform (loc, "in a call to %qT declared with " |
| "attribute %<%s%>", fntype, access_str); |
| } |
| } |
| else |
| { |
| /* For a declaration with no relevant attribute access create |
| a dummy object and use the formatting function to avoid |
| having to complicate things here. */ |
| attr_access ptr_access = { }; |
| if (!access) |
| access = &ptr_access; |
| const std::string argtypestr = access->array_as_string (argtype); |
| if (fndecl) |
| { |
| location_t loc (DECL_SOURCE_LOCATION (fndecl)); |
| inform (loc, "by argument %u of type %s to %qD " |
| "declared here", |
| argno, argtypestr.c_str (), fndecl); |
| } |
| else |
| { |
| /* Handle calls through function pointers. */ |
| location_t loc (gimple_location (stmt)); |
| inform (loc, "by argument %u of type %s to %qT", |
| argno, argtypestr.c_str (), fntype); |
| } |
| } |
| |
| if (DECL_P (argbase)) |
| { |
| location_t loc = DECL_SOURCE_LOCATION (argbase); |
| inform (loc, "%qD declared here", argbase); |
| } |
| } |
| |
| wlims.always_executed = save_always_executed; |
| } |
| |
| |
| static unsigned int |
| warn_uninitialized_vars (bool wmaybe_uninit) |
| { |
| /* Counters and limits controlling the the depth of the warning. */ |
| wlimits wlims = { }; |
| wlims.wmaybe_uninit = wmaybe_uninit; |
| |
| gimple_stmt_iterator gsi; |
| basic_block bb; |
| FOR_EACH_BB_FN (bb, cfun) |
| { |
| basic_block succ = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)); |
| wlims.always_executed = dominated_by_p (CDI_POST_DOMINATORS, succ, bb); |
| for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) |
| { |
| gimple *stmt = gsi_stmt (gsi); |
| use_operand_p use_p; |
| ssa_op_iter op_iter; |
| tree use; |
| |
| if (is_gimple_debug (stmt)) |
| continue; |
| |
| /* We only do data flow with SSA_NAMEs, so that's all we |
| can warn about. */ |
| FOR_EACH_SSA_USE_OPERAND (use_p, stmt, op_iter, SSA_OP_USE) |
| { |
| /* BIT_INSERT_EXPR first operand should not be considered |
| a use for the purpose of uninit warnings. */ |
| if (gassign *ass = dyn_cast <gassign *> (stmt)) |
| { |
| if (gimple_assign_rhs_code (ass) == BIT_INSERT_EXPR |
| && use_p->use == gimple_assign_rhs1_ptr (ass)) |
| continue; |
| } |
| use = USE_FROM_PTR (use_p); |
| if (wlims.always_executed) |
| warn_uninit (OPT_Wuninitialized, use, SSA_NAME_VAR (use), |
| SSA_NAME_VAR (use), |
| "%qD is used uninitialized", stmt, |
| UNKNOWN_LOCATION); |
| else if (wmaybe_uninit) |
| warn_uninit (OPT_Wmaybe_uninitialized, use, SSA_NAME_VAR (use), |
| SSA_NAME_VAR (use), |
| "%qD may be used uninitialized", |
| stmt, UNKNOWN_LOCATION); |
| } |
| |
| /* For limiting the alias walk below we count all |
| vdefs in the function. */ |
| if (gimple_vdef (stmt)) |
| wlims.vdef_cnt++; |
| |
| if (gcall *call = dyn_cast <gcall *> (stmt)) |
| maybe_warn_pass_by_reference (call, wlims); |
| else if (gimple_assign_load_p (stmt) |
| && gimple_has_location (stmt)) |
| { |
| tree rhs = gimple_assign_rhs1 (stmt); |
| tree lhs = gimple_assign_lhs (stmt); |
| |
| ao_ref ref; |
| ao_ref_init (&ref, rhs); |
| tree var = maybe_warn_operand (ref, stmt, lhs, rhs, wlims); |
| if (!var) |
| continue; |
| |
| if (DECL_P (var)) |
| { |
| location_t loc = DECL_SOURCE_LOCATION (var); |
| inform (loc, "%qD declared here", var); |
| } |
| } |
| } |
| } |
| |
| return 0; |
| } |
| |
| /* Checks if the operand OPND of PHI is defined by |
| another phi with one operand defined by this PHI, |
| but the rest operands are all defined. If yes, |
| returns true to skip this operand as being |
| redundant. Can be enhanced to be more general. */ |
| |
| static bool |
| can_skip_redundant_opnd (tree opnd, gimple *phi) |
| { |
| gimple *op_def; |
| tree phi_def; |
| int i, n; |
| |
| phi_def = gimple_phi_result (phi); |
| op_def = SSA_NAME_DEF_STMT (opnd); |
| if (gimple_code (op_def) != GIMPLE_PHI) |
| return false; |
| n = gimple_phi_num_args (op_def); |
| for (i = 0; i < n; ++i) |
| { |
| tree op = gimple_phi_arg_def (op_def, i); |
| if (TREE_CODE (op) != SSA_NAME) |
| continue; |
| if (op != phi_def && uninit_undefined_value_p (op)) |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /* Returns a bit mask holding the positions of arguments in PHI |
| that have empty (or possibly empty) definitions. */ |
| |
| static unsigned |
| compute_uninit_opnds_pos (gphi *phi) |
| { |
| size_t i, n; |
| unsigned uninit_opnds = 0; |
| |
| n = gimple_phi_num_args (phi); |
| /* Bail out for phi with too many args. */ |
| if (n > max_phi_args) |
| return 0; |
| |
| for (i = 0; i < n; ++i) |
| { |
| 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)) |
| { |
| if (cfun->has_nonlocal_label || cfun->calls_setjmp) |
| { |
| /* Ignore SSA_NAMEs that appear on abnormal edges |
| somewhere. */ |
| if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op)) |
| continue; |
| } |
| MASK_SET_BIT (uninit_opnds, i); |
| } |
| } |
| return uninit_opnds; |
| } |
| |
| /* Find the immediate postdominator PDOM of the specified |
| basic block BLOCK. */ |
| |
| static inline basic_block |
| find_pdom (basic_block block) |
| { |
| if (block == EXIT_BLOCK_PTR_FOR_FN (cfun)) |
| return EXIT_BLOCK_PTR_FOR_FN (cfun); |
| else |
| { |
| basic_block bb = get_immediate_dominator (CDI_POST_DOMINATORS, block); |
| if (!bb) |
| return EXIT_BLOCK_PTR_FOR_FN (cfun); |
| return bb; |
| } |
| } |
| |
| /* Find the immediate DOM of the specified basic block BLOCK. */ |
| |
| static inline basic_block |
| find_dom (basic_block block) |
| { |
| if (block == ENTRY_BLOCK_PTR_FOR_FN (cfun)) |
| return ENTRY_BLOCK_PTR_FOR_FN (cfun); |
| else |
| { |
| basic_block bb = get_immediate_dominator (CDI_DOMINATORS, block); |
| if (!bb) |
| return ENTRY_BLOCK_PTR_FOR_FN (cfun); |
| return bb; |
| } |
| } |
| |
| /* 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 cover all cases. */ |
| |
| static bool |
| is_non_loop_exit_postdominating (basic_block bb1, basic_block bb2) |
| { |
| if (!dominated_by_p (CDI_POST_DOMINATORS, bb2, bb1)) |
| return false; |
| |
| if (single_pred_p (bb1) && !single_succ_p (bb2)) |
| return false; |
| |
| return true; |
| } |
| |
| /* Find the closest postdominator of a specified BB, which is control |
| equivalent to BB. */ |
| |
| static inline basic_block |
| find_control_equiv_block (basic_block bb) |
| { |
| basic_block pdom; |
| |
| pdom = find_pdom (bb); |
| |
| /* Skip the postdominating bb that is also loop exit. */ |
| if (!is_non_loop_exit_postdominating (pdom, bb)) |
| return NULL; |
| |
| if (dominated_by_p (CDI_DOMINATORS, pdom, bb)) |
| return pdom; |
| |
| return NULL; |
| } |
| |
| #define MAX_NUM_CHAINS 8 |
| #define MAX_CHAIN_LEN 5 |
| #define MAX_POSTDOM_CHECK 8 |
| #define MAX_SWITCH_CASES 40 |
| |
| /* Computes the control dependence chains (paths of edges) |
| for DEP_BB up to the dominating basic block BB (the head node of a |
| chain should be dominated by it). CD_CHAINS is pointer to an |
| array holding the result chains. CUR_CD_CHAIN is the current |
| chain being computed. *NUM_CHAINS is total number of chains. The |
| function returns true if the information is successfully computed, |
| return false if there is no control dependence or not computed. */ |
| |
| static bool |
| compute_control_dep_chain (basic_block bb, basic_block dep_bb, |
| vec<edge> *cd_chains, |
| size_t *num_chains, |
| vec<edge> *cur_cd_chain, |
| int *num_calls) |
| { |
| edge_iterator ei; |
| edge e; |
| size_t i; |
| bool found_cd_chain = false; |
| size_t cur_chain_len = 0; |
| |
| if (*num_calls > param_uninit_control_dep_attempts) |
| return false; |
| ++*num_calls; |
| |
| /* Could use a set instead. */ |
| cur_chain_len = cur_cd_chain->length (); |
| if (cur_chain_len > MAX_CHAIN_LEN) |
| return false; |
| |
| for (i = 0; i < cur_chain_len; i++) |
| { |
| edge e = (*cur_cd_chain)[i]; |
| /* Cycle detected. */ |
| if (e->src == bb) |
| return false; |
| } |
| |
| FOR_EACH_EDGE (e, ei, bb->succs) |
| { |
| basic_block cd_bb; |
| int post_dom_check = 0; |
| if (e->flags & (EDGE_FAKE | EDGE_ABNORMAL)) |
| 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; |
| } |
| |
| /* 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; |
| } |
| |
| 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; |
| } |
| cur_cd_chain->pop (); |
| gcc_assert (cur_cd_chain->length () == cur_chain_len); |
| } |
| gcc_assert (cur_cd_chain->length () == cur_chain_len); |
| |
| return found_cd_chain; |
| } |
| |
| /* The type to represent a simple predicate. */ |
| |
| struct pred_info |
| { |
| tree pred_lhs; |
| tree pred_rhs; |
| enum tree_code cond_code; |
| bool invert; |
| }; |
| |
| /* The type to represent a sequence of predicates grouped |
| with .AND. operation. */ |
| |
| typedef vec<pred_info, va_heap, vl_ptr> pred_chain; |
| |
| /* The type to represent a sequence of pred_chains grouped |
| with .OR. operation. */ |
| |
| typedef vec<pred_chain, va_heap, vl_ptr> pred_chain_union; |
| |
| /* Converts the chains of control dependence edges into a set of |
| predicates. A control dependence chain is represented by a vector |
| edges. DEP_CHAINS points to an array of dependence chains. |
| NUM_CHAINS is the size of the chain array. One edge in a dependence |
| chain is mapped to predicate expression represented by pred_info |
| type. One dependence chain is converted to a composite predicate that |
| 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 |
| return, *PREDS points to the resulting array of composite predicates. |
| *NUM_PREDS is the number of composite predictes. */ |
| |
| static bool |
| convert_control_dep_chain_into_preds (vec<edge> *dep_chains, |
| size_t num_chains, |
| pred_chain_union *preds) |
| { |
| bool has_valid_pred = false; |
| size_t i, j; |
| if (num_chains == 0 || num_chains >= MAX_NUM_CHAINS) |
| return false; |
| |
| /* Now convert the control dep chain into a set |
| of predicates. */ |
| preds->reserve (num_chains); |
| |
| for (i = 0; i < num_chains; i++) |
| { |
| vec<edge> one_cd_chain = dep_chains[i]; |
| |
| 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; |
| |
| e = one_cd_chain[j]; |
| guard_bb = e->src; |
| gsi = gsi_last_bb (guard_bb); |
| /* Ignore empty forwarder blocks. */ |
| if (empty_block_p (guard_bb) && single_succ_p (guard_bb)) |
| continue; |
| /* An empty basic block here is likely a PHI, and is not one |
| of the cases we handle below. */ |
| 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) |
| { |
| one_pred.pred_lhs = gimple_cond_lhs (cond_stmt); |
| one_pred.pred_rhs = gimple_cond_rhs (cond_stmt); |
| one_pred.cond_code = gimple_cond_code (cond_stmt); |
| one_pred.invert = !!(e->flags & EDGE_FALSE_VALUE); |
| t_chain.safe_push (one_pred); |
| has_valid_pred = true; |
| } |
| else if (gswitch *gs = dyn_cast<gswitch *> (cond_stmt)) |
| { |
| /* Avoid quadratic behavior. */ |
| if (gimple_switch_num_labels (gs) > MAX_SWITCH_CASES) |
| { |
| has_valid_pred = false; |
| break; |
| } |
| /* Find the case label. */ |
| tree l = NULL_TREE; |
| unsigned idx; |
| for (idx = 0; idx < gimple_switch_num_labels (gs); ++idx) |
| { |
| tree tl = gimple_switch_label (gs, idx); |
| if (e->dest == label_to_block (cfun, CASE_LABEL (tl))) |
| { |
| if (!l) |
| l = tl; |
| else |
| { |
| l = NULL_TREE; |
| break; |
| } |
| } |
| } |
| /* If more than one label reaches this block or the case |
| label doesn't have a single value (like the default one) |
| fail. */ |
| if (!l |
| || !CASE_LOW (l) |
| || (CASE_HIGH (l) |
| && !operand_equal_p (CASE_LOW (l), CASE_HIGH (l), 0))) |
| { |
| has_valid_pred = false; |
| break; |
| } |
| one_pred.pred_lhs = gimple_switch_index (gs); |
| one_pred.pred_rhs = CASE_LOW (l); |
| one_pred.cond_code = EQ_EXPR; |
| one_pred.invert = false; |
| t_chain.safe_push (one_pred); |
| has_valid_pred = true; |
| } |
| else |
| { |
| has_valid_pred = false; |
| break; |
| } |
| } |
| |
| if (!has_valid_pred) |
| break; |
| else |
| preds->safe_push (t_chain); |
| } |
| return has_valid_pred; |
| } |
| |
| /* Computes all control dependence chains for USE_BB. The control |
| dependence chains are then converted to an array of composite |
| predicates pointed to by PREDS. PHI_BB is the basic block of |
| the phi whose result is used in USE_BB. */ |
| |
| static bool |
| find_predicates (pred_chain_union *preds, |
| basic_block phi_bb, |
| basic_block use_bb) |
| { |
| size_t num_chains = 0, i; |
| int num_calls = 0; |
| vec<edge> dep_chains[MAX_NUM_CHAINS]; |
| auto_vec<edge, MAX_CHAIN_LEN + 1> cur_chain; |
| bool has_valid_pred = false; |
| basic_block cd_root = 0; |
| |
| /* First find the closest bb that is control equivalent to PHI_BB |
| that also dominates USE_BB. */ |
| cd_root = phi_bb; |
| while (dominated_by_p (CDI_DOMINATORS, use_bb, cd_root)) |
| { |
| 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; |
| else |
| break; |
| } |
| |
| compute_control_dep_chain (cd_root, use_bb, dep_chains, &num_chains, |
| &cur_chain, &num_calls); |
| |
| has_valid_pred |
| = convert_control_dep_chain_into_preds (dep_chains, num_chains, preds); |
| for (i = 0; i < num_chains; i++) |
| dep_chains[i].release (); |
| return has_valid_pred; |
| } |
| |
| /* Computes the set of incoming edges of PHI that have non empty |
| definitions of a phi chain. The collection will be done |
| recursively on operands that are defined by phis. CD_ROOT |
| is the control dependence root. *EDGES holds the result, and |
| VISITED_PHIS is a pointer set for detecting cycles. */ |
| |
| static void |
| collect_phi_def_edges (gphi *phi, basic_block cd_root, |
| auto_vec<edge> *edges, |
| hash_set<gimple *> *visited_phis) |
| { |
| size_t i, n; |
| edge opnd_edge; |
| tree opnd; |
| |
| if (visited_phis->add (phi)) |
| return; |
| |
| n = gimple_phi_num_args (phi); |
| for (i = 0; i < n; i++) |
| { |
| opnd_edge = gimple_phi_arg_edge (phi, i); |
| opnd = gimple_phi_arg_def (phi, i); |
| |
| if (TREE_CODE (opnd) != SSA_NAME) |
| { |
| if (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); |
| } |
| 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<gphi *> (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); |
| } |
| edges->safe_push (opnd_edge); |
| } |
| } |
| } |
| } |
| |
| /* For each use edge of PHI, computes all control dependence chains. |
| The control dependence chains are then converted to an array of |
| composite predicates pointed to by PREDS. */ |
| |
| static bool |
| find_def_preds (pred_chain_union *preds, gphi *phi) |
| { |
| size_t num_chains = 0, i, n; |
| vec<edge> dep_chains[MAX_NUM_CHAINS]; |
| auto_vec<edge, MAX_CHAIN_LEN + 1> cur_chain; |
| auto_vec<edge> def_edges; |
| bool has_valid_pred = false; |
| basic_block phi_bb, cd_root = 0; |
| |
| phi_bb = gimple_bb (phi); |
| /* First find the closest dominating bb to be |
| the control dependence root. */ |
| cd_root = find_dom (phi_bb); |
| if (!cd_root) |
| return false; |
| |
| hash_set<gimple *> visited_phis; |
| collect_phi_def_edges (phi, cd_root, &def_edges, &visited_phis); |
| |
| n = def_edges.length (); |
| if (n == 0) |
| return false; |
| |
| for (i = 0; i < n; i++) |
| { |
| size_t prev_nc, j; |
| int num_calls = 0; |
| edge opnd_edge; |
| |
| opnd_edge = def_edges[i]; |
| prev_nc = num_chains; |
| compute_control_dep_chain (cd_root, opnd_edge->src, dep_chains, |
| &num_chains, &cur_chain, &num_calls); |
| |
| /* Now update the newly added chains with |
| 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++) |
| dep_chains[j].safe_push (opnd_edge); |
| } |
| } |
| |
| has_valid_pred |
| = convert_control_dep_chain_into_preds (dep_chains, num_chains, preds); |
| for (i = 0; i < num_chains; i++) |
| dep_chains[i].release (); |
| return has_valid_pred; |
| } |
| |
| /* Dump a pred_info. */ |
| |
| static void |
| dump_pred_info (pred_info one_pred) |
| { |
| if (one_pred.invert) |
| fprintf (dump_file, " (.NOT.) "); |
| print_generic_expr (dump_file, one_pred.pred_lhs); |
| fprintf (dump_file, " %s ", op_symbol_code (one_pred.cond_code)); |
| print_generic_expr (dump_file, one_pred.pred_rhs); |
| } |
| |
| /* Dump a pred_chain. */ |
| |
| static void |
| dump_pred_chain (pred_chain one_pred_chain) |
| { |
| size_t np = one_pred_chain.length (); |
| for (size_t j = 0; j < np; j++) |
| { |
| dump_pred_info (one_pred_chain[j]); |
| if (j < np - 1) |
| fprintf (dump_file, " (.AND.) "); |
| else |
| fprintf (dump_file, "\n"); |
| } |
| } |
| |
| /* Dumps the predicates (PREDS) for USESTMT. */ |
| |
| static void |
| dump_predicates (gimple *usestmt, pred_chain_union preds, const char *msg) |
| { |
| fprintf (dump_file, "%s", msg); |
| if (usestmt) |
| { |
| print_gimple_stmt (dump_file, usestmt, 0); |
| fprintf (dump_file, "is guarded by :\n\n"); |
| } |
| size_t num_preds = preds.length (); |
| for (size_t i = 0; i < num_preds; i++) |
| { |
| dump_pred_chain (preds[i]); |
| if (i < num_preds - 1) |
| fprintf (dump_file, "(.OR.)\n"); |
| else |
| fprintf (dump_file, "\n\n"); |
| } |
| } |
| |
| /* Destroys the predicate set *PREDS. */ |
| |
| static void |
| destroy_predicate_vecs (pred_chain_union *preds) |
| { |
| size_t i; |
| |
| size_t n = preds->length (); |
| for (i = 0; i < n; i++) |
| (*preds)[i].release (); |
| preds->release (); |
| } |
| |
| /* Computes the 'normalized' conditional code with operand |
| swapping and condition inversion. */ |
| |
| static enum tree_code |
| get_cmp_code (enum tree_code orig_cmp_code, bool swap_cond, bool invert) |
| { |
| enum tree_code tc = orig_cmp_code; |
| |
| if (swap_cond) |
| tc = swap_tree_comparison (orig_cmp_code); |
| if (invert) |
| tc = invert_tree_comparison (tc, false); |
| |
| switch (tc) |
| { |
| case LT_EXPR: |
| case LE_EXPR: |
| case GT_EXPR: |
| case GE_EXPR: |
| case EQ_EXPR: |
| case NE_EXPR: |
| break; |
| default: |
| return ERROR_MARK; |
| } |
| return tc; |
| } |
| |
| /* Returns whether VAL CMPC BOUNDARY is true. */ |
| |
| static bool |
| is_value_included_in (tree val, tree boundary, enum tree_code cmpc) |
| { |
| bool inverted = false; |
| bool result; |
| |
| /* Only handle integer constant here. */ |
| if (TREE_CODE (val) != INTEGER_CST || TREE_CODE (boundary) != INTEGER_CST) |
| return true; |
| |
| if (cmpc == GE_EXPR || cmpc == GT_EXPR || cmpc == NE_EXPR) |
| { |
| cmpc = invert_tree_comparison (cmpc, false); |
| inverted = true; |
| } |
| |
| if (cmpc == EQ_EXPR) |
| result = tree_int_cst_equal (val, boundary); |
| else if (cmpc == LT_EXPR) |
| result = tree_int_cst_lt (val, boundary); |
| else |
| { |
| gcc_assert (cmpc == LE_EXPR); |
| result = tree_int_cst_le (val, boundary); |
| } |
| |
| if (inverted) |
| result ^= 1; |
| |
| return result; |
| } |
| |
| /* Returns whether VAL satisfies (x CMPC BOUNDARY) predicate. CMPC can be |
| either one of the range comparison codes ({GE,LT,EQ,NE}_EXPR and the like), |
| or BIT_AND_EXPR. EXACT_P is only meaningful for the latter. It modifies the |
| question from whether VAL & BOUNDARY != 0 to whether VAL & BOUNDARY == VAL. |
| For other values of CMPC, EXACT_P is ignored. */ |
| |
| static bool |
| value_sat_pred_p (tree val, tree boundary, enum tree_code cmpc, |
| bool exact_p = false) |
| { |
| if (cmpc != BIT_AND_EXPR) |
| return is_value_included_in (val, boundary, cmpc); |
| |
| wide_int andw = wi::to_wide (val) & wi::to_wide (boundary); |
| if (exact_p) |
| return andw == wi::to_wide (val); |
| else |
| return andw.to_uhwi (); |
| } |
| |
| /* Returns true if PRED is common among all the predicate |
| chains (PREDS) (and therefore can be factored out). */ |
| |
| static bool |
| find_matching_predicate_in_rest_chains (pred_info pred, pred_chain_union preds) |
| { |
| size_t i, j, n; |
| |
| /* Trival case. */ |
| if (preds.length () == 1) |
| return true; |
| |
| for (i = 1; i < preds.length (); i++) |
| { |
| bool found = false; |
| 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. */ |
| |
| 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 true; |
| } |
| |
| /* Forward declaration. */ |
| static bool is_use_properly_guarded (gimple *use_stmt, |
| basic_block use_bb, |
| gphi *phi, |
| unsigned uninit_opnds, |
| pred_chain_union *def_preds, |
| hash_set<gphi *> *visited_phis); |
| |
| /* Returns true if all uninitialized opnds are pruned. Returns false |
| otherwise. PHI is the phi node with uninitialized operands, |
| UNINIT_OPNDS is the bitmap of the uninitialize operand positions, |
| 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 |
| associated with the flag, CMP_CODE is the comparison code used in |
| the predicate, VISITED_PHIS is the pointer set of phis visited, and |
| VISITED_FLAG_PHIS is the pointer to the pointer set of flag definitions |
| that are also phis. |
| |
| Example scenario: |
| |
| BB1: |
| flag_1 = phi <0, 1> // (1) |
| var_1 = phi <undef, some_val> |
| |
| |
| BB2: |
| flag_2 = phi <0, flag_1, flag_1> // (2) |
| var_2 = phi <undef, var_1, var_1> |
| if (flag_2 == 1) |
| goto BB3; |
| |
| BB3: |
| 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 |
| is thought to be flowed into use at (3). Since var_1 is potentially |
| uninitialized a false warning will be emitted. |
| Checking recursively into (1), the compiler can find out that only some_val |
| (which is defined) can flow into (3) which is OK. */ |
| |
| static bool |
| prune_uninit_phi_opnds (gphi *phi, unsigned uninit_opnds, gphi *flag_def, |
| tree boundary_cst, enum tree_code cmp_code, |
| hash_set<gphi *> *visited_phis, |
| bitmap *visited_flag_phis) |
| { |
| unsigned i; |
| |
| for (i = 0; i < MIN (max_phi_args, gimple_phi_num_args (flag_def)); i++) |
| { |
| tree flag_arg; |
| |
| if (!MASK_TEST_BIT (uninit_opnds, i)) |
| continue; |
| |
| flag_arg = gimple_phi_arg_def (flag_def, i); |
| if (!is_gimple_constant (flag_arg)) |
| { |
| 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<gphi *> (SSA_NAME_DEF_STMT (flag_arg)); |
| if (!flag_arg_def) |
| return false; |
| |
| phi_arg = gimple_phi_arg_def (phi, i); |
| if (TREE_CODE (phi_arg) != SSA_NAME) |
| return false; |
| |
| phi_arg_def = dyn_cast<gphi *> (SSA_NAME_DEF_STMT (phi_arg)); |
| if (!phi_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); |
| |
| tree phi_result = gimple_phi_result (flag_arg_def); |
| if (bitmap_bit_p (*visited_flag_phis, SSA_NAME_VERSION (phi_result))) |
| return false; |
| |
| bitmap_set_bit (*visited_flag_phis, |
| SSA_NAME_VERSION (gimple_phi_result (flag_arg_def))); |
| |
| /* Now recursively prune the uninitialized phi args. */ |
| uninit_opnds_arg_phi = compute_uninit_opnds_pos (phi_arg_def); |
| if (!prune_uninit_phi_opnds |
| (phi_arg_def, uninit_opnds_arg_phi, flag_arg_def, boundary_cst, |
| cmp_code, visited_phis, visited_flag_phis)) |
| return false; |
| |
| phi_result = gimple_phi_result (flag_arg_def); |
| bitmap_clear_bit (*visited_flag_phis, SSA_NAME_VERSION (phi_result)); |
| continue; |
| } |
| |
| /* Now check if the constant is in the guarded range. */ |
| if (is_value_included_in (flag_arg, boundary_cst, cmp_code)) |
| { |
| 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. */ |
| |
| opnd = gimple_phi_arg_def (phi, i); |
| opnd_def = SSA_NAME_DEF_STMT (opnd); |
| if (gphi *opnd_def_phi = dyn_cast <gphi *> (opnd_def)) |
| { |
| edge opnd_edge; |
| unsigned uninit_opnds2 = compute_uninit_opnds_pos (opnd_def_phi); |
| if (!MASK_EMPTY (uninit_opnds2)) |
| { |
| pred_chain_union def_preds = vNULL; |
| bool ok; |
| opnd_edge = gimple_phi_arg_edge (phi, i); |
| ok = is_use_properly_guarded (phi, |
| opnd_edge->src, |
| opnd_def_phi, |
| uninit_opnds2, |
| &def_preds, |
| visited_phis); |
| destroy_predicate_vecs (&def_preds); |
| if (!ok) |
| return false; |
| } |
| } |
| else |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| /* A helper function finds predicate which will be examined against uninit |
| paths. If there is no "flag_var cmp const" form predicate, the function |
| tries to find predicate of form like "flag_var cmp flag_var" with value |
| range info. PHI is the phi node whose incoming (undefined) paths need to |
| be examined. On success, the function returns the comparsion code, sets |
| defintion gimple of the flag_var to FLAG_DEF, sets boundary_cst to |
| BOUNDARY_CST. On fail, the function returns ERROR_MARK. */ |
| |
| static enum tree_code |
| find_var_cmp_const (pred_chain_union preds, gphi *phi, gimple **flag_def, |
| tree *boundary_cst) |
| { |
| enum tree_code vrinfo_code = ERROR_MARK, code; |
| gimple *vrinfo_def = NULL; |
| tree vrinfo_cst = NULL, cond_lhs, cond_rhs; |
| |
| gcc_assert (preds.length () > 0); |
| pred_chain the_pred_chain = preds[0]; |
| for (unsigned i = 0; i < the_pred_chain.length (); i++) |
| { |
| bool use_vrinfo_p = false; |
| pred_info the_pred = the_pred_chain[i]; |
| cond_lhs = the_pred.pred_lhs; |
| cond_rhs = the_pred.pred_rhs; |
| if (cond_lhs == NULL_TREE || cond_rhs == NULL_TREE) |
| continue; |
| |
| code = get_cmp_code (the_pred.cond_code, false, the_pred.invert); |
| if (code == ERROR_MARK) |
| continue; |
| |
| if (TREE_CODE (cond_lhs) == SSA_NAME && is_gimple_constant (cond_rhs)) |
| ; |
| else if (TREE_CODE (cond_rhs) == SSA_NAME |
| && is_gimple_constant (cond_lhs)) |
| { |
| std::swap (cond_lhs, cond_rhs); |
| if ((code = get_cmp_code (code, true, false)) == ERROR_MARK) |
| continue; |
| } |
| /* Check if we can take advantage of "flag_var comp flag_var" predicate |
| with value range info. Note only first of such case is handled. */ |
| else if (vrinfo_code == ERROR_MARK |
| && TREE_CODE (cond_lhs) == SSA_NAME |
| && TREE_CODE (cond_rhs) == SSA_NAME) |
| { |
| gimple* lhs_def = SSA_NAME_DEF_STMT (cond_lhs); |
| if (!lhs_def || gimple_code (lhs_def) != GIMPLE_PHI |
| || gimple_bb (lhs_def) != gimple_bb (phi)) |
| { |
| std::swap (cond_lhs, cond_rhs); |
| if ((code = get_cmp_code (code, true, false)) == ERROR_MARK) |
| continue; |
| } |
| |
| /* Check value range info of rhs, do following transforms: |
| flag_var < [min, max] -> flag_var < max |
| flag_var > [min, max] -> flag_var > min |
| |
| We can also transform LE_EXPR/GE_EXPR to LT_EXPR/GT_EXPR: |
| flag_var <= [min, max] -> flag_var < [min, max+1] |
| flag_var >= [min, max] -> flag_var > [min-1, max] |
| if no overflow/wrap. */ |
| wide_int min, max; |
| tree type = TREE_TYPE (cond_lhs); |
| if (!INTEGRAL_TYPE_P (type) |
| || get_range_info (cond_rhs, &min, &max) != VR_RANGE) |
| continue; |
| if (code == LE_EXPR |
| && max != wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type))) |
| { |
| code = LT_EXPR; |
| max = max + 1; |
| } |
| if (code == GE_EXPR |
| && min != wi::min_value (TYPE_PRECISION (type), TYPE_SIGN (type))) |
| { |
| code = GT_EXPR; |
| min = min - 1; |
| } |
| if (code == LT_EXPR) |
| cond_rhs = wide_int_to_tree (type, max); |
| else if (code == GT_EXPR) |
| cond_rhs = wide_int_to_tree (type, min); |
| else |
| continue; |
| |
| use_vrinfo_p = true; |
| } |
| else |
| continue; |
| |
| if ((*flag_def = SSA_NAME_DEF_STMT (cond_lhs)) == NULL) |
| continue; |
| |
| if (gimple_code (*flag_def) != GIMPLE_PHI |
| || gimple_bb (*flag_def) != gimple_bb (phi) |
| || !find_matching_predicate_in_rest_chains (the_pred, preds)) |
| continue; |
| |
| /* Return if any "flag_var comp const" predicate is found. */ |
| if (!use_vrinfo_p) |
| { |
| *boundary_cst = cond_rhs; |
| return code; |
| } |
| /* Record if any "flag_var comp flag_var[vinfo]" predicate is found. */ |
| else if (vrinfo_code == ERROR_MARK) |
| { |
| vrinfo_code = code; |
| vrinfo_def = *flag_def; |
| vrinfo_cst = cond_rhs; |
| } |
| } |
| /* Return the "flag_var cmp flag_var[vinfo]" predicate we found. */ |
| if (vrinfo_code != ERROR_MARK) |
| { |
| *flag_def = vrinfo_def; |
| *boundary_cst = vrinfo_cst; |
| } |
| return vrinfo_code; |
| } |
| |
| /* A helper function that determines if the predicate set |
| of the use is not overlapping with that of the uninit paths. |
| The most common senario of guarded use is in Example 1: |
| Example 1: |
| if (some_cond) |
| { |
| x = ...; |
| flag = true; |
| } |
| |
| ... some code ... |
| |
| if (flag) |
| use (x); |
| |
| The real world examples are usually more complicated, but similar |
| and usually result from inlining: |
| |
| bool init_func (int * x) |
| { |
| if (some_cond) |
| return false; |
| *x = .. |
| return true; |
| } |
| |
| void foo (..) |
| { |
| int x; |
| |
| if (!init_func (&x)) |
| return; |
| |
| .. some_code ... |
| use (x); |
| } |
| |
| Another possible use scenario is in the following trivial example: |
| |
| Example 2: |
| if (n > 0) |
| x = 1; |
| ... |
| if (n > 0) |
| { |
| if (m < 2) |
| .. = x; |
| } |
| |
| Predicate analysis needs to compute the composite predicate: |
| |
| 1) 'x' use predicate: (n > 0) .AND. (m < 2) |
| 2) 'x' default value (non-def) predicate: .NOT. (n > 0) |
| (the predicate chain for phi operand defs can be computed |
| starting from a bb that is control equivalent to the phi's |
| bb and is dominating the operand def.) |
| |
| and check overlapping: |
| (n > 0) .AND. (m < 2) .AND. (.NOT. (n > 0)) |
| <==> false |
| |
| This implementation provides framework that can handle |
| scenarios. (Note that many simple cases are handled properly |
| without the predicate analysis -- this is due to jump threading |
| transformation which eliminates the merge point thus makes |
| path sensitive analysis unnecessary.) |
| |
| PHI is the phi node whose incoming (undefined) paths need to be |
| pruned, and UNINIT_OPNDS is the bitmap holding uninit operand |
| positions. VISITED_PHIS is the pointer set of phi stmts being |
| checked. */ |
| |
| static bool |
| use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds, |
| gphi *phi, unsigned uninit_opnds, |
| hash_set<gphi *> *visited_phis) |
| { |
| gimple *flag_def = 0; |
| tree boundary_cst = 0; |
| enum tree_code cmp_code; |
| bitmap visited_flag_phis = NULL; |
| bool all_pruned = false; |
| |
| /* Find within the common prefix of multiple predicate chains |
| a predicate that is a comparison of a flag variable against |
| a constant. */ |
| cmp_code = find_var_cmp_const (preds, phi, &flag_def, &boundary_cst); |
| if (cmp_code == ERROR_MARK) |
| return false; |
| |
| /* Now check all the uninit incoming edge has a constant flag value |
| that is in conflict with the use guard/predicate. */ |
| all_pruned = prune_uninit_phi_opnds |
| (phi, uninit_opnds, as_a<gphi *> (flag_def), boundary_cst, cmp_code, |
| visited_phis, &visited_flag_phis); |
| |
| if (visited_flag_phis) |
| BITMAP_FREE (visited_flag_phis); |
| |
| return all_pruned; |
| } |
| |
| /* The helper function returns true if two predicates X1 and X2 |
| are equivalent. It assumes the expressions have already |
| properly re-associated. */ |
| |
| static inline bool |
| pred_equal_p (pred_info x1, pred_info x2) |
| { |
| enum tree_code c1, c2; |
| 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 |
| && TREE_CODE_CLASS (x2.cond_code) == tcc_comparison) |
| c2 = invert_tree_comparison (x2.cond_code, false); |
| else |
| c2 = x2.cond_code; |
| |
| return c1 == c2; |
| } |
| |
| /* Returns true if the predication is testing !=. */ |
| |
| 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)); |
| } |
| |
| /* Returns true if pred is of the form X != 0. */ |
| |
| static inline bool |
| is_neq_zero_form_p (pred_info pred) |
| { |
| if (!is_neq_relop_p (pred) || !integer_zerop (pred.pred_rhs) |
| || TREE_CODE (pred.pred_lhs) != SSA_NAME) |
| return false; |
| return true; |
| } |
| |
| /* The helper function returns true if two predicates X1 |
| is equivalent to X2 != 0. */ |
| |
| static inline bool |
| pred_expr_equal_p (pred_info x1, tree x2) |
| { |
| if (!is_neq_zero_form_p (x1)) |
| return false; |
| |
| return operand_equal_p (x1.pred_lhs, x2, 0); |
| } |
| |
| /* Returns true of the domain of single predicate expression |
| EXPR1 is a subset of that of EXPR2. Returns false if it |
| cannot be proved. */ |
| |
| static bool |
| is_pred_expr_subset_of (pred_info expr1, pred_info expr2) |
| { |
| enum tree_code code1, code2; |
| |
| if (pred_equal_p (expr1, expr2)) |
| return true; |
| |
| if ((TREE_CODE (expr1.pred_rhs) != INTEGER_CST) |
| || (TREE_CODE (expr2.pred_rhs) != INTEGER_CST)) |
| return false; |
| |
| if (!operand_equal_p (expr1.pred_lhs, expr2.pred_lhs, 0)) |
| return false; |
| |
| code1 = expr1.cond_code; |
| if (expr1.invert) |
| code1 = invert_tree_comparison (code1, false); |
| code2 = expr2.cond_code; |
| if (expr2.invert) |
| code2 = invert_tree_comparison (code2, false); |
| |
| if (code2 == NE_EXPR && code1 == NE_EXPR) |
| return false; |
| |
| if (code2 == NE_EXPR) |
| return !value_sat_pred_p (expr2.pred_rhs, expr1.pred_rhs, code1); |
| |
| if (code1 == EQ_EXPR) |
| return value_sat_pred_p (expr1.pred_rhs, expr2.pred_rhs, code2); |
| |
| if (code1 == code2) |
| return value_sat_pred_p (expr1.pred_rhs, expr2.pred_rhs, code2, |
| code1 == BIT_AND_EXPR); |
| |
| return false; |
| } |
| |
| /* Returns true if the domain of PRED1 is a subset |
| of that of PRED2. Returns false if it cannot be proved so. */ |
| |
| static bool |
| is_pred_chain_subset_of (pred_chain pred1, pred_chain pred2) |
| { |
| size_t np1, np2, i1, i2; |
| |
| np1 = pred1.length (); |
| np2 = pred2.length (); |
| |
| for (i2 = 0; i2 < np2; i2++) |
| { |
| 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; |
| } |
| } |
| if (!found) |
| return false; |
| } |
| return true; |
| } |
| |
| /* Returns true if the domain defined by |
| one pred chain ONE_PRED is a subset of the domain |
| of *PREDS. It returns false if ONE_PRED's domain is |
| not a subset of any of the sub-domains of PREDS |
| (corresponding to each individual chains in it), even |
| though it may be still be a subset of whole domain |
| of PREDS which is the union (ORed) of all its subdomains. |
| In other words, the result is conservative. */ |
| |
| static bool |
| is_included_in (pred_chain one_pred, pred_chain_union preds) |
| { |
| size_t i; |
| size_t n = preds.length (); |
| |
| for (i = 0; i < n; i++) |
| { |
| if (is_pred_chain_subset_of (one_pred, preds[i])) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /* Compares two predicate sets PREDS1 and PREDS2 and returns |
| true if the domain defined by PREDS1 is a superset |
| of PREDS2's domain. N1 and N2 are array sizes of PREDS1 and |
| PREDS2 respectively. The implementation chooses not to build |
| generic trees (and relying on the folding capability of the |
| compiler), but instead performs brute force comparison of |
| individual predicate chains (won't be a compile time problem |
| as the chains are pretty short). When the function returns |
| false, it does not necessarily mean *PREDS1 is not a superset |
| of *PREDS2, but mean it may not be so since the analysis cannot |
| prove it. In such cases, false warnings may still be |
| emitted. */ |
| |
| static bool |
| is_superset_of (pred_chain_union preds1, pred_chain_union preds2) |
| { |
| size_t i, n2; |
| pred_chain one_pred_chain = vNULL; |
| |
| n2 = preds2.length (); |
| |
| for (i = 0; i < n2; i++) |
| { |
| one_pred_chain = preds2[i]; |
| if (!is_included_in (one_pred_chain, preds1)) |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /* Returns true if X1 is the negate of X2. */ |
| |
| static inline bool |
| pred_neg_p (pred_info x1, pred_info x2) |
| { |
| enum tree_code c1, c2; |
| 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); |
| else |
| c2 = x2.cond_code; |
| |
| return c1 == c2; |
| } |
| |
| /* 1) ((x IOR y) != 0) AND (x != 0) is equivalent to (x != 0); |
| 2) (X AND Y) OR (!X AND Y) is equivalent to Y; |
| 3) X OR (!X AND Y) is equivalent to (X OR Y); |
| 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 |
| |
| PREDS is the predicate chains, and N is the number of chains. */ |
| |
| /* Helper function to implement rule 1 above. ONE_CHAIN is |
| the AND predication to be simplified. */ |
| |
| static void |
| simplify_pred (pred_chain *one_chain) |
| { |
| size_t i, j, n; |
| bool simplified = false; |
| pred_chain s_chain = vNULL; |
| |
| n = one_chain->length (); |
| |
| for (i = 0; i < n; i++) |
| { |
| pred_info *a_pred = &(*one_chain)[i]; |
| |
| if (!a_pred->pred_lhs) |
| continue; |
| if (!is_neq_zero_form_p (*a_pred)) |
| continue; |
| |
| gimple *def_stmt = SSA_NAME_DEF_STMT (a_pred->pred_lhs); |
| if (gimple_code (def_stmt) != GIMPLE_ASSIGN) |
| continue; |
| if (gimple_assign_rhs_code (def_stmt) == BIT_IOR_EXPR) |
| { |
| 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 (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) |
| return; |
| |
| for (i = 0; i < n; i++) |
| { |
| pred_info *a_pred = &(*one_chain)[i]; |
| if (!a_pred->pred_lhs) |
| continue; |
| s_chain.safe_push (*a_pred); |
| } |
| |
| one_chain->release (); |
| *one_chain = s_chain; |
| } |
| |
| /* The helper function implements the rule 2 for the |
| OR predicate PREDS. |
| |
| 2) (X AND Y) OR (!X AND Y) is equivalent to Y. */ |
| |
| static bool |
| simplify_preds_2 (pred_chain_union *preds) |
| { |
| size_t i, j, n; |
| 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 X. */ |
| |
| n = preds->length (); |
| for (i = 0; i < n; i++) |
| { |
| pred_info x, y; |
| pred_chain *a_chain = &(*preds)[i]; |
| |
| if (a_chain->length () != 2) |
| continue; |
| |
| x = (*a_chain)[0]; |
| y = (*a_chain)[1]; |
| |
| for (j = 0; j < n; j++) |
| { |
| pred_chain *b_chain; |
| pred_info x2, y2; |
| |
| if (j == i) |
| continue; |
| |
| b_chain = &(*preds)[j]; |
| if (b_chain->length () != 2) |
| continue; |
| |
| 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; |
| } |
| } |
| } |
| /* 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]); |
| } |
| preds->release (); |
| (*preds) = s_preds; |
| s_preds = vNULL; |
| } |
| |
| return simplified; |
| } |
| |
| /* The helper function implements the rule 2 for the |
| OR predicate PREDS. |
| |
| 3) x OR (!x AND y) is equivalent to x OR y. */ |
| |
| static bool |
| simplify_preds_3 (pred_chain_union *preds) |
| { |
| size_t i, j, n; |
| bool simplified = false; |
| |
| /* Now iteratively simplify X OR (!X AND Z ..) |
| into X OR (Z ...). */ |
| |
| n = preds->length (); |
| if (n < 2) |
| return false; |
| |
| for (i = 0; i < n; i++) |
| { |
| pred_info x; |
| pred_chain *a_chain = &(*preds)[i]; |
| |
| if (a_chain->length () != 1) |
| continue; |
| |
| x = (*a_chain)[0]; |
| |
| for (j = 0; j < n; j++) |
| { |
| pred_chain *b_chain; |
| pred_info x2; |
| size_t k; |
| |
| if (j == i) |
| 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; |
| } |
| } |
| } |
| } |
| return simplified; |
| } |
| |
| /* The helper function implements the rule 4 for the |
| OR predicate PREDS. |
| |
| 2) ((x AND y) != 0) OR (x != 0 AND y != 0) is equivalent to |
| (x != 0 ANd y != 0). */ |
| |
| static bool |
| simplify_preds_4 (pred_chain_union *preds) |
| { |
| size_t i, j, n; |
| bool simplified = false; |
| pred_chain_union s_preds = vNULL; |
| gimple *def_stmt; |
| |
| n = preds->length (); |
| for (i = 0; i < n; i++) |
| { |
| pred_info z; |
| pred_chain *a_chain = &(*preds)[i]; |
| |
| if (a_chain->length () != 1) |
| continue; |
| |
| z = (*a_chain)[0]; |
| |
| if (!is_neq_zero_form_p (z)) |
| continue; |
| |
| def_stmt = SSA_NAME_DEF_STMT (z.pred_lhs); |
| if (gimple_code (def_stmt) != GIMPLE_ASSIGN) |
| continue; |
| |
| if (gimple_assign_rhs_code (def_stmt) != BIT_AND_EXPR) |
| continue; |
| |
| for (j = 0; j < n; j++) |
| { |
| pred_chain *b_chain; |
| pred_info x2, y2; |
| |
| if (j == i) |
| 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; |
| |
| 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]); |
| } |
| |
| preds->release (); |
| (*preds) = s_preds; |
| s_preds = vNULL; |
| } |
| |
| return simplified; |
| } |
| |
| /* This function simplifies predicates in PREDS. */ |
| |
| static void |
| simplify_preds (pred_chain_union *preds, gimple *use_or_def, bool is_use) |
| { |
| size_t i, n; |
| bool changed = false; |
| |
| if (dump_file && dump_flags & TDF_DETAILS) |
| { |
| fprintf (dump_file, "[BEFORE SIMPLICATION -- "); |
| dump_predicates (use_or_def, *preds, is_use ? "[USE]:\n" : "[DEF]:\n"); |
| } |
| |
| for (i = 0; i < preds->length (); i++) |
| simplify_pred (&(*preds)[i]); |
| |
| n = preds->length (); |
| if (n < 2) |
| return; |
| |
| do |
| { |
| changed = false; |
| if (simplify_preds_2 (preds)) |
| changed = true; |
| |
| /* Now iteratively simplify X OR (!X AND Z ..) |
| into X OR (Z ...). */ |
| if (simplify_preds_3 (preds)) |
| changed = true; |
| |
| if (simplify_preds_4 (preds)) |
| changed = true; |
| } |
| while (changed); |
| |
| return; |
| } |
| |
| /* 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 |
| pred_chain_union or BIT_AND tree into a pred_chain. |
| Example: |
| |
| _3 = _2 RELOP1 _1; |
| _6 = _5 RELOP2 _4; |
| _9 = _8 RELOP3 _7; |
| _10 = _3 | _6; |
| _12 = _9 | _0; |
| _t = _10 | _12; |
| |
| then _t != 0 will be normalized into a pred_chain_union |
| |
| (_2 RELOP1 _1) OR (_5 RELOP2 _4) OR (_8 RELOP3 _7) OR (_0 != 0) |
| |
| Similarly given, |
| |
| _3 = _2 RELOP1 _1; |
| _6 = _5 RELOP2 _4; |
| _9 = _8 RELOP3 _7; |
| _10 = _3 & _6; |
| _12 = _9 & _0; |
| |
| 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. */ |
| |
| inline static void |
| push_pred (pred_chain_union *norm_preds, pred_info pred) |
| { |
| pred_chain pred_chain = vNULL; |
| pred_chain.safe_push (pred); |
| norm_preds->safe_push (pred_chain); |
| } |
| |
| /* A helper function that creates a predicate of the form |
| OP != 0 and push it WORK_LIST. */ |
| |
| inline static void |
| push_to_worklist (tree op, vec<pred_info, va_heap, vl_ptr> *work_list, |
| hash_set<tree> *mark_set) |
| { |
| if (mark_set->contains (op)) |
| return; |
| mark_set->add (op); |
| |
| pred_info arg_pred; |
| arg_pred.pred_lhs = op; |
| arg_pred.pred_rhs = integer_zero_node; |
| arg_pred.cond_code = NE_EXPR; |
| arg_pred.invert = false; |
| work_list->safe_push (arg_pred); |
| } |
| |
| /* A helper that generates a pred_info from a gimple assignment |
| CMP_ASSIGN with comparison rhs. */ |
| |
| static pred_info |
| get_pred_info_from_cmp (gimple *cmp_assign) |
| { |
| pred_info n_pred; |
| n_pred.pred_lhs = gimple_assign_rhs1 (cmp_assign); |
| n_pred.pred_rhs = gimple_assign_rhs2 (cmp_assign); |
| n_pred.cond_code = gimple_assign_rhs_code (cmp_assign); |
| n_pred.invert = false; |
| return n_pred; |
| } |
| |
| /* Returns true if the PHI is a degenerated phi with |
| all args with the same value (relop). In that case, *PRED |
| will be updated to that value. */ |
| |
| static bool |
| is_degenerated_phi (gimple *phi, pred_info *pred_p) |
| { |
| int i, n; |
| tree op0; |
| gimple *def0; |
| pred_info pred0; |
| |
| n = gimple_phi_num_args (phi); |
| op0 = gimple_phi_arg_def (phi, 0); |
| |
| if (TREE_CODE (op0) != SSA_NAME) |
| return false; |
| |
| def0 = SSA_NAME_DEF_STMT (op0); |
| if (gimple_code (def0) != GIMPLE_ASSIGN) |
| return false; |
| if (TREE_CODE_CLASS (gimple_assign_rhs_code (def0)) != tcc_comparison) |
| return false; |
| pred0 = get_pred_info_from_cmp (def0); |
| |
| for (i = 1; i < n; ++i) |
| { |
| gimple *def; |
| pred_info pred; |
| tree op = gimple_phi_arg_def (phi, i); |
| |
| if (TREE_CODE (op) != SSA_NAME) |
| return false; |
| |
| def = SSA_NAME_DEF_STMT (op); |
| if (gimple_code (def) != GIMPLE_ASSIGN) |
| return false; |
| if (TREE_CODE_CLASS (gimple_assign_rhs_code (def)) != tcc_comparison) |
| return false; |
| pred = get_pred_info_from_cmp (def); |
| if (!pred_equal_p (pred, pred0)) |
| return false; |
| } |
| |
| *pred_p = pred0; |
| return true; |
| } |
| |
| /* 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<pred_info, va_heap, vl_ptr> *work_list, |
| hash_set<tree> *mark_set) |
| { |
| if (!is_neq_zero_form_p (pred)) |
| { |
| if (and_or_code == BIT_IOR_EXPR) |
| push_pred (norm_preds, pred); |
| else |
| 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) |
| { |
| int i, n; |
| n = gimple_phi_num_args (def_stmt); |
| |
| /* 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; |
| } |
| } |
| |
| for (i = 0; i < n; ++i) |
| { |
| tree op = gimple_phi_arg_def (def_stmt, i); |
| if (integer_zerop (op)) |
| continue; |
| |
| push_to_worklist (op, work_list, mark_set); |
| } |
| } |
| else if (gimple_code (def_stmt) != GIMPLE_ASSIGN) |
| { |
| if (and_or_code == BIT_IOR_EXPR) |
| push_pred (norm_preds, pred); |
| else |
| norm_chain->safe_push (pred); |
| } |
| else if (gimple_assign_rhs_code (def_stmt) == and_or_code) |
| { |
| /* Avoid splitting up bit manipulations like x & 3 or y | 1. */ |
| if (is_gimple_min_invariant (gimple_assign_rhs2 (def_stmt))) |
| { |
| /* But treat x & 3 as condition. */ |
| if (and_or_code == BIT_AND_EXPR) |
| { |
| pred_info n_pred; |
| n_pred.pred_lhs = gimple_assign_rhs1 (def_stmt); |
| n_pred.pred_rhs = gimple_assign_rhs2 (def_stmt); |
| n_pred.cond_code = and_or_code; |
| n_pred.invert = false; |
| norm_chain->safe_push (n_pred); |
| } |
| } |
| else |
| { |
| push_to_worklist (gimple_assign_rhs1 (def_stmt), work_list, mark_set); |
| push_to_worklist (gimple_assign_rhs2 (def_stmt), work_list, mark_set); |
| } |
| } |
| else if (TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt)) |
| == tcc_comparison) |
| { |
| pred_info n_pred = get_pred_info_from_cmp (def_stmt); |
| if (and_or_code == BIT_IOR_EXPR) |
| push_pred (norm_preds, n_pred); |
| else |
| norm_chain->safe_push (n_pred); |
| } |
| else |
| { |
| if (and_or_code == BIT_IOR_EXPR) |
| push_pred (norm_preds, pred); |
| else |
| norm_chain->safe_push (pred); |
| } |
| } |
| |
| /* Normalize PRED and store the normalized predicates into NORM_PREDS. */ |
| |
| static void |
| normalize_one_pred (pred_chain_union *norm_preds, pred_info pred) |
| { |
| vec<pred_info, va_heap, vl_ptr> work_list = vNULL; |
| enum tree_code and_or_code = ERROR_MARK; |
| pred_chain norm_chain = vNULL; |
| |
| if (!is_neq_zero_form_p (pred)) |
| { |
| push_pred (norm_preds, pred); |
| return; |
| } |
| |
| gimple *def_stmt = SSA_NAME_DEF_STMT (pred.pred_lhs); |
| if (gimple_code (def_stmt) == GIMPLE_ASSIGN) |
| and_or_code = gimple_assign_rhs_code (def_stmt); |
| if (and_or_code != BIT_IOR_EXPR && 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); |
| } |
| else |
| push_pred (norm_preds, pred); |
| return; |
| } |
| |
| work_list.safe_push (pred); |
| hash_set<tree> mark_set; |
| |
| while (!work_list.is_empty ()) |
| { |
| pred_info a_pred = work_list.pop (); |
| normalize_one_pred_1 (norm_preds, &norm_chain, a_pred, and_or_code, |
| &work_list, &mark_set); |
| } |
| if (and_or_code == BIT_AND_EXPR) |
| norm_preds->safe_push (norm_chain); |
| |
| work_list.release (); |
| } |
| |
| static void |
| normalize_one_pred_chain (pred_chain_union *norm_preds, pred_chain one_chain) |
| { |
| vec<pred_info, va_heap, vl_ptr> work_list = vNULL; |
| hash_set<tree> mark_set; |
| pred_chain norm_chain = vNULL; |
| size_t i; |
| |
| for (i = 0; i < one_chain.length (); i++) |
| { |
| work_list.safe_push (one_chain[i]); |
| mark_set.add (one_chain[i].pred_lhs); |
| } |
| |
| while (!work_list.is_empty ()) |
| { |
| pred_info a_pred = work_list.pop (); |
| normalize_one_pred_1 (0, &norm_chain, a_pred, BIT_AND_EXPR, &work_list, |
| &mark_set); |
| } |
| |
| norm_preds->safe_push (norm_chain); |
| work_list.release (); |
| } |
| |
| /* Normalize predicate chains PREDS and returns the normalized one. */ |
| |
| static pred_chain_union |
| normalize_preds (pred_chain_union preds, gimple *use_or_def, bool is_use) |
| { |
| pred_chain_union norm_preds = vNULL; |
| size_t n = preds.length (); |
| size_t i; |
| |
| if (dump_file && dump_flags & TDF_DETAILS) |
| { |
| fprintf (dump_file, "[BEFORE NORMALIZATION --"); |
| dump_predicates (use_or_def, preds, is_use ? "[USE]:\n" : "[DEF]:\n"); |
| } |
| |
| for (i = 0; i < n; i++) |
| { |
| if (preds[i].length () != 1) |
| normalize_one_pred_chain (&norm_preds, preds[i]); |
| else |
| { |
| normalize_one_pred (&norm_preds, preds[i][0]); |
| preds[i].release (); |
| } |
| } |
| |
| if (dump_file) |
| { |
| fprintf (dump_file, "[AFTER NORMALIZATION -- "); |
| dump_predicates (use_or_def, norm_preds, |
| is_use ? "[USE]:\n" : "[DEF]:\n"); |
| } |
| |
| destroy_predicate_vecs (&preds); |
| return norm_preds; |
| } |
| |
| /* Return TRUE if PREDICATE can be invalidated by any individual |
| predicate in USE_GUARD. */ |
| |
| static bool |
| can_one_predicate_be_invalidated_p (pred_info predicate, |
| pred_chain use_guard) |
| { |
| if (dump_file && dump_flags & TDF_DETAILS) |
| { |
| fprintf (dump_file, "Testing if this predicate: "); |
| dump_pred_info (predicate); |
| fprintf (dump_file, "\n...can be invalidated by a USE guard of: "); |
| dump_pred_chain (use_guard); |
| } |
| for (size_t i = 0; i < use_guard.length (); ++i) |
| { |
| /* NOTE: This is a very simple check, and only understands an |
| exact opposite. So, [i == 0] is currently only invalidated |
| by [.NOT. i == 0] or [i != 0]. Ideally we should also |
| invalidate with say [i > 5] or [i == 8]. There is certainly |
| room for improvement here. */ |
| if (pred_neg_p (predicate, use_guard[i])) |
| { |
| if (dump_file && dump_flags & TDF_DETAILS) |
| { |
| fprintf (dump_file, " Predicate was invalidated by: "); |
| dump_pred_info (use_guard[i]); |
| fputc ('\n', dump_file); |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /* Return TRUE if all predicates in UNINIT_PRED are invalidated by |
| USE_GUARD being true. */ |
| |
| static bool |
| can_chain_union_be_invalidated_p (pred_chain_union uninit_pred, |
| pred_chain use_guard) |
| { |
| if (uninit_pred.is_empty ()) |
| return false; |
| if (dump_file && dump_flags & TDF_DETAILS) |
| dump_predicates (NULL, uninit_pred, |
| "Testing if anything here can be invalidated: "); |
| for (size_t i = 0; i < uninit_pred.length (); ++i) |
| { |
| pred_chain c = uninit_pred[i]; |
| size_t j; |
| for (j = 0; j < c.length (); ++j) |
| if (can_one_predicate_be_invalidated_p (c[j], use_guard)) |
| break; |
| |
| /* If we were unable to invalidate any predicate in C, then there |
| is a viable path from entry to the PHI where the PHI takes |
| an uninitialized value and continues to a use of the PHI. */ |
| if (j == c.length ()) |
| return false; |
| } |
| return true; |
| } |
| |
| /* Return TRUE if none of the uninitialized operands in UNINT_OPNDS |
| can actually happen if we arrived at a use for PHI. |
| |
| PHI_USE_GUARDS are the guard conditions for the use of the PHI. */ |
| |
| static bool |
| uninit_uses_cannot_happen (gphi *phi, unsigned uninit_opnds, |
| pred_chain_union phi_use_guards) |
| { |
| unsigned phi_args = gimple_phi_num_args (phi); |
| if (phi_args > max_phi_args) |
| return false; |
| |
| /* PHI_USE_GUARDS are OR'ed together. If we have more than one |
| possible guard, there's no way of knowing which guard was true. |
| Since we need to be absolutely sure that the uninitialized |
| operands will be invalidated, bail. */ |
| if (phi_use_guards.length () != 1) |
| return false; |
| |
| /* Look for the control dependencies of all the uninitialized |
| operands and build guard predicates describing them. */ |
| pred_chain_union uninit_preds; |
| bool ret = true; |
| for (unsigned i = 0; i < phi_args; ++i) |
| { |
| if (!MASK_TEST_BIT (uninit_opnds, i)) |
| continue; |
| |
| edge e = gimple_phi_arg_edge (phi, i); |
| vec<edge> dep_chains[MAX_NUM_CHAINS]; |
| auto_vec<edge, MAX_CHAIN_LEN + 1> cur_chain; |
| size_t num_chains = 0; |
| int num_calls = 0; |
| |
| /* Build the control dependency chain for uninit operand `i'... */ |
| uninit_preds = vNULL; |
| if (!compute_control_dep_chain (ENTRY_BLOCK_PTR_FOR_FN (cfun), |
| e->src, dep_chains, &num_chains, |
| &cur_chain, &num_calls)) |
| { |
| ret = false; |
| break; |
| } |
| /* ...and convert it into a set of predicates. */ |
| bool has_valid_preds |
| = convert_control_dep_chain_into_preds (dep_chains, num_chains, |
| &uninit_preds); |
| for (size_t j = 0; j < num_chains; ++j) |
| dep_chains[j].release (); |
| if (!has_valid_preds) |
| { |
| ret = false; |
| break; |
| } |
| simplify_preds (&uninit_preds, NULL, false); |
| uninit_preds = normalize_preds (uninit_preds, NULL, false); |
| |
| /* Can the guard for this uninitialized operand be invalidated |
| by the PHI use? */ |
| if (!can_chain_union_be_invalidated_p (uninit_preds, phi_use_guards[0])) |
| { |
| ret = false; |
| break; |
| } |
| } |
| destroy_predicate_vecs (&uninit_preds); |
| return ret; |
| } |
| |
| /* Computes the predicates that guard the use and checks |
| if the incoming paths that have empty (or possibly |
| empty) definition can be pruned/filtered. The function returns |
| 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 |
| predicate sets of all runtime paths that do not have a definition. |
| |
| Returns false if it is not or it cannot be determined. USE_BB is |
| 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). |
| |
| 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 |
| set of phis being visited. |
| |
| *DEF_PREDS contains the (memoized) defining predicate chains of PHI. |
| If *DEF_PREDS is the empty vector, the defining predicate chains of |
| PHI will be computed and stored into *DEF_PREDS as needed. |
| |
| VISITED_PHIS is a pointer set of phis being visited. */ |
| |
| static bool |
| is_use_properly_guarded (gimple *use_stmt, |
| basic_block use_bb, |
| gphi *phi, |
| unsigned uninit_opnds, |
| pred_chain_union *def_preds, |
| hash_set<gphi *> *visited_phis) |
| { |
| basic_block phi_bb; |
| pred_chain_union preds = vNULL; |
| bool has_valid_preds = false; |
| bool is_properly_guarded = false; |
| |
| if (visited_phis->add (phi)) |
| return false; |
| |
| phi_bb = gimple_bb (phi); |
| |
| if (is_non_loop_exit_postdominating (use_bb, phi_bb)) |
| return false; |
| |
| has_valid_preds = find_predicates (&preds, phi_bb, use_bb); |
| |
| if (!has_valid_preds) |
| { |
| destroy_predicate_vecs (&preds); |
| return false; |
| } |
| |
| /* Try to prune the dead incoming phi edges. */ |
| is_properly_guarded |
| = use_pred_not_overlap_with_undef_path_pred (preds, phi, uninit_opnds, |
| visited_phis); |
| |
| /* We might be able to prove that if the control dependencies |
| for UNINIT_OPNDS are true, that the control dependencies for |
| USE_STMT can never be true. */ |
| if (!is_properly_guarded) |
| is_properly_guarded |= uninit_uses_cannot_happen (phi, uninit_opnds, |
| preds); |
| |
| if (is_properly_guarded) |
| { |
| destroy_predicate_vecs (&preds); |
| return true; |
| } |
| |
| if (def_preds->is_empty ()) |
| { |
| has_valid_preds = find_def_preds (def_preds, phi); |
| |
| if (!has_valid_preds) |
| { |
| destroy_predicate_vecs (&preds); |
| return false; |
| } |
| |
| simplify_preds (def_preds, phi, false); |
| *def_preds = normalize_preds (*def_preds, phi, false); |
| } |
| |
| simplify_preds (&preds, use_stmt, true); |
| preds = normalize_preds (preds, use_stmt, true); |
| |
| is_properly_guarded = is_superset_of (*def_preds, preds); |
| |
| destroy_predicate_vecs (&preds); |
| return is_properly_guarded; |
| } |
| |
| /* Searches through all uses of a potentially |
| uninitialized variable defined by PHI and returns a use |
| statement if the use is not properly guarded. It returns |
| NULL if all uses are guarded. UNINIT_OPNDS is a bitvector |
| holding the position(s) of uninit PHI operands. WORKLIST |
| is the vector of candidate phis that may be updated by this |
| function. ADDED_TO_WORKLIST is the pointer set tracking |
| if the new phi is already in the worklist. */ |
| |
| static gimple * |
| find_uninit_use (gphi *phi, unsigned uninit_opnds, |
| vec<gphi *> *worklist, |
| hash_set<gphi *> *added_to_worklist) |
| { |
| tree phi_result; |
| use_operand_p use_p; |
| gimple *use_stmt; |
| imm_use_iterator iter; |
| pred_chain_union def_preds = vNULL; |
| gimple *ret = NULL; |
| |
| phi_result = gimple_phi_result (phi); |
| |
| FOR_EACH_IMM_USE_FAST (use_p, iter, phi_result) |
| { |
| basic_block use_bb; |
| |
| use_stmt = USE_STMT (use_p); |
| if (is_gimple_debug (use_stmt)) |
| continue; |
| |
| if (gphi *use_phi = dyn_cast<gphi *> (use_stmt)) |
| use_bb = gimple_phi_arg_edge (use_phi, |
| PHI_ARG_INDEX_FROM_USE (use_p))->src; |
| else |
| use_bb = gimple_bb (use_stmt); |
| |
| hash_set<gphi *> visited_phis; |
| if (is_use_properly_guarded (use_stmt, use_bb, phi, uninit_opnds, |
| &def_preds, &visited_phis)) |
| continue; |
| |
| if (dump_file && (dump_flags & TDF_DETAILS)) |
| { |
| fprintf (dump_file, "[CHECK]: Found unguarded use: "); |
| print_gimple_stmt (dump_file, use_stmt, 0); |
| } |
| /* Found one real use, return. */ |
| if (gimple_code (use_stmt) != GIMPLE_PHI) |
| { |
| ret = use_stmt; |
| break; |
| } |
| |
| /* Found a phi use that is not guarded, |
| add the phi to the worklist. */ |
| if (!added_to_worklist->add (as_a<gphi *> (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); |
| } |
| |
| worklist->safe_push (as_a<gphi *> (use_stmt)); |
| possibly_undefined_names->add (phi_result); |
| } |
| } |
| |
| destroy_predicate_vecs (&def_preds); |
| return ret; |
| } |
| |
| /* 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 |
| 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 |
| by the compiler, the fewer false positives the warning is. WORKLIST |
| 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. */ |
| |
| static void |
| warn_uninitialized_phi (gphi *phi, vec<gphi *> *worklist, |
| hash_set<gphi *> *added_to_worklist) |
| { |
| unsigned uninit_opnds; |
| gimple *uninit_use_stmt = 0; |
| tree uninit_op; |
| int phiarg_index; |
| location_t loc; |
| |
| /* Don't look at virtual operands. */ |
| if (virtual_operand_p (gimple_phi_result (phi))) |
| return; |
| |
| uninit_opnds = compute_uninit_opnds_pos (phi); |
| |
| if (MASK_EMPTY (uninit_opnds)) |
| return; |
| |
| if (dump_file && (dump_flags & TDF_DETAILS)) |
| { |
| fprintf (dump_file, "[CHECK]: examining phi: "); |
| print_gimple_stmt (dump_file, phi, 0); |
| } |
| |
| /* 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); |
| |
| /* All uses are properly guarded. */ |
| if (!uninit_use_stmt) |
| return; |
| |
| phiarg_index = MASK_FIRST_SET_BIT (uninit_opnds); |
| uninit_op = gimple_phi_arg_def (phi, phiarg_index); |
| if (SSA_NAME_VAR (uninit_op) == NULL_TREE) |
| return; |
| if (gimple_phi_arg_has_location (phi, phiarg_index)) |
| loc = gimple_phi_arg_location (phi, phiarg_index); |
| else |
| 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); |
| } |
| |
| static bool |
| gate_warn_uninitialized (void) |
| { |
| return warn_uninitialized || warn_maybe_uninitialized; |
| } |
| |
| namespace { |
| |
| const pass_data pass_data_late_warn_uninitialized = |
| { |
| GIMPLE_PASS, /* type */ |
| "uninit", /* name */ |
| OPTGROUP_NONE, /* optinfo_flags */ |
| TV_NONE, /* tv_id */ |
| PROP_ssa, /* properties_required */ |
| 0, /* properties_provided */ |
| 0, /* properties_destroyed */ |
| 0, /* todo_flags_start */ |
| 0, /* todo_flags_finish */ |
| }; |
| |
| class pass_late_warn_uninitialized : public gimple_opt_pass |
| { |
| public: |
| pass_late_warn_uninitialized (gcc::context *ctxt) |
| : gimple_opt_pass (pass_data_late_warn_uninitialized, ctxt) |
| {} |
| |
| /* opt_pass methods: */ |
| opt_pass *clone () { return new pass_late_warn_uninitialized (m_ctxt); } |
| virtual bool gate (function *) { return gate_warn_uninitialized (); } |
| virtual unsigned int execute (function *); |
| |
| }; // class pass_late_warn_uninitialized |
| |
| unsigned int |
| pass_late_warn_uninitialized::execute (function *fun) |
| { |
| basic_block bb; |
| gphi_iterator gsi; |
| vec<gphi *> worklist = vNULL; |
| |
| calculate_dominance_info (CDI_DOMINATORS); |
| calculate_dominance_info (CDI_POST_DOMINATORS); |
| /* Re-do the plain uninitialized variable check, as optimization may have |
| straightened control flow. Do this first so that we don't accidentally |
| get a "may be" warning when we'd have seen an "is" warning later. */ |
| warn_uninitialized_vars (/*warn_maybe_uninitialized=*/1); |
| |
| timevar_push (TV_TREE_UNINIT); |
| |
| possibly_undefined_names = new hash_set<tree>; |
| hash_set<gphi *> added_to_worklist; |
| |
| /* Initialize worklist */ |
| FOR_EACH_BB_FN (bb, fun) |
| for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) |
| { |
| gphi *phi = gsi.phi (); |
| size_t n, i; |
| |
| n = gimple_phi_num_args (phi); |
| |
| /* Don't look at virtual operands. */ |
| if (virtual_operand_p (gimple_phi_result (phi))) |
| continue; |
| |
| for (i = 0; i < n; ++i) |
| { |
| tree op = gimple_phi_arg_def (phi, i); |
| if (TREE_CODE (op) == SSA_NAME && uninit_undefined_value_p (op)) |
| { |
| worklist.safe_push (phi); |
| added_to_worklist.add (phi); |
| if (dump_file && (dump_flags & TDF_DETAILS)) |
| { |
| fprintf (dump_file, "[WORKLIST]: add to initial list: "); |
| print_gimple_stmt (dump_file, phi, 0); |
| } |
| break; |
| } |
| } |
| } |
| |
| while (worklist.length () != 0) |
| { |
| gphi *cur_phi = 0; |
| cur_phi = worklist.pop (); |
| warn_uninitialized_phi (cur_phi, &worklist, &added_to_worklist); |
| } |
| |
| worklist.release (); |
| delete possibly_undefined_names; |
| possibly_undefined_names = NULL; |
| free_dominance_info (CDI_POST_DOMINATORS); |
| timevar_pop (TV_TREE_UNINIT); |
| return 0; |
| } |
| |
| } // anon namespace |
| |
| gimple_opt_pass * |
| make_pass_late_warn_uninitialized (gcc::context *ctxt) |
| { |
| return new pass_late_warn_uninitialized (ctxt); |
| } |
| |
| static unsigned int |
| execute_early_warn_uninitialized (void) |
| { |
| /* Currently, this pass runs always but |
| execute_late_warn_uninitialized only runs with optimization. With |
| optimization we want to warn about possible uninitialized as late |
| as possible, thus don't do it here. However, without |
| optimization we need to warn here about "may be uninitialized". */ |
| calculate_dominance_info (CDI_POST_DOMINATORS); |
| |
| warn_uninitialized_vars (/*warn_maybe_uninitialized=*/!optimize); |
| |
| /* Post-dominator information cannot be reliably updated. Free it |
| after the use. */ |
| |
| free_dominance_info (CDI_POST_DOMINATORS); |
| return 0; |
| } |
| |
| namespace { |
| |
| const pass_data pass_data_early_warn_uninitialized = |
| { |
| GIMPLE_PASS, /* type */ |
| "*early_warn_uninitialized", /* name */ |
| OPTGROUP_NONE, /* optinfo_flags */ |
| TV_TREE_UNINIT, /* tv_id */ |
| PROP_ssa, /* properties_required */ |
| 0, /* properties_provided */ |
| 0, /* properties_destroyed */ |
| 0, /* todo_flags_start */ |
| 0, /* todo_flags_finish */ |
| }; |
| |
| class pass_early_warn_uninitialized : public gimple_opt_pass |
| { |
| public: |
| pass_early_warn_uninitialized (gcc::context *ctxt) |
| : gimple_opt_pass (pass_data_early_warn_uninitialized, ctxt) |
| {} |
| |
| /* opt_pass methods: */ |
| virtual bool gate (function *) { return gate_warn_uninitialized (); } |
| virtual unsigned int execute (function *) |
| { |
| return execute_early_warn_uninitialized (); |
| } |
| |
| }; // class pass_early_warn_uninitialized |
| |
| } // anon namespace |
| |
| gimple_opt_pass * |
| make_pass_early_warn_uninitialized (gcc::context *ctxt) |
| { |
| return new pass_early_warn_uninitialized (ctxt); |
| } |