From: Jakub Jelinek Date: Thu, 6 Mar 2014 08:12:02 +0000 (+0100) Subject: re PR tree-optimization/56490 (-Wall triggering infinite loop) X-Git-Tag: releases/gcc-4.8.3~283 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=e58a193f9c988f6ecd6472c6c8c2aba393baddb5;p=thirdparty%2Fgcc.git re PR tree-optimization/56490 (-Wall triggering infinite loop) * Makefile.in (tree-ssa-uninit.o): Depend on $(PARAMS_H). Backport from mainline 2014-02-21 Jakub Jelinek PR tree-optimization/56490 * params.def (PARAM_UNINIT_CONTROL_DEP_ATTEMPTS): New param. * tree-ssa-uninit.c: Include params.h. (compute_control_dep_chain): Add num_calls argument, return false if it exceed PARAM_UNINIT_CONTROL_DEP_ATTEMPTS param, pass num_calls to recursive call. (find_predicates): Change dep_chain into normal array, add num_calls variable and adjust compute_control_dep_chain caller. (find_def_preds): Likewise. From-SVN: r208372 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index ac038e41555a..546b1142afd1 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,6 +1,20 @@ 2014-03-06 Jakub Jelinek + * Makefile.in (tree-ssa-uninit.o): Depend on $(PARAMS_H). + Backport from mainline + 2014-02-21 Jakub Jelinek + + PR tree-optimization/56490 + * params.def (PARAM_UNINIT_CONTROL_DEP_ATTEMPTS): New param. + * tree-ssa-uninit.c: Include params.h. + (compute_control_dep_chain): Add num_calls argument, return false + if it exceed PARAM_UNINIT_CONTROL_DEP_ATTEMPTS param, pass + num_calls to recursive call. + (find_predicates): Change dep_chain into normal array, add num_calls + variable and adjust compute_control_dep_chain caller. + (find_def_preds): Likewise. + 2014-02-13 Jakub Jelinek PR target/43546 diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 2194dd4c2d17..8b303a62e9b6 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -2256,7 +2256,7 @@ tree-ssa-uninit.o : tree-ssa-uninit.c $(TREE_FLOW_H) $(CONFIG_H) $(SYSTEM_H) \ $(FUNCTION_H) $(TM_H) coretypes.h \ $(TREE_PASS_H) $(BASIC_BLOCK_H) $(BITMAP_H) \ $(FLAGS_H) $(HASHTAB_H) pointer-set.h \ - $(GIMPLE_H) $(TREE_INLINE_H) $(GIMPLE_PRETTY_PRINT_H) + $(GIMPLE_H) $(TREE_INLINE_H) $(GIMPLE_PRETTY_PRINT_H) $(PARAMS_H) tree-ssa.o : tree-ssa.c $(TREE_FLOW_H) $(CONFIG_H) $(SYSTEM_H) \ $(TREE_H) $(TM_P_H) $(EXPR_H) $(DIAGNOSTIC_H) \ toplev.h $(FUNCTION_H) $(TM_H) coretypes.h \ diff --git a/gcc/params.def b/gcc/params.def index cb25def32fb4..e51b847a7c46 100644 --- a/gcc/params.def +++ b/gcc/params.def @@ -1014,6 +1014,12 @@ DEFPARAM (PARAM_MAX_SLSR_CANDIDATE_SCAN, "strength reduction", 50, 1, 999999) +DEFPARAM (PARAM_UNINIT_CONTROL_DEP_ATTEMPTS, + "uninit-control-dep-attempts", + "Maximum number of nested calls to search for control dependencies " + "during uninitialized variable analysis", + 1000, 1, 0) + /* Local variables: mode:c diff --git a/gcc/tree-ssa-uninit.c b/gcc/tree-ssa-uninit.c index 2c47fe90b5d7..2379f9c908c6 100644 --- a/gcc/tree-ssa-uninit.c +++ b/gcc/tree-ssa-uninit.c @@ -36,6 +36,7 @@ along with GCC; see the file COPYING3. If not see #include "hashtab.h" #include "tree-pass.h" #include "diagnostic-core.h" +#include "params.h" /* This implements the pass that does predicate aware warning on uses of possibly uninitialized variables. The pass first collects the set of @@ -246,8 +247,8 @@ find_control_equiv_block (basic_block bb) /* 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 a - dynamic array holding the result chains. CUR_CD_CHAIN is the current + 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. */ @@ -256,7 +257,8 @@ static bool compute_control_dep_chain (basic_block bb, basic_block dep_bb, vec *cd_chains, size_t *num_chains, - vec *cur_cd_chain) + vec *cur_cd_chain, + int *num_calls) { edge_iterator ei; edge e; @@ -267,6 +269,10 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb, if (EDGE_COUNT (bb->succs) < 2) return false; + if (*num_calls > PARAM_VALUE (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) @@ -306,7 +312,7 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb, /* 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_chains, cur_cd_chain, num_calls)) { found_cd_chain = true; break; @@ -438,14 +444,12 @@ find_predicates (vec **preds, basic_block use_bb) { size_t num_chains = 0, i; - vec *dep_chains = 0; + int num_calls = 0; + vec dep_chains[MAX_NUM_CHAINS]; vec cur_chain = vNULL; bool has_valid_pred = false; basic_block cd_root = 0; - typedef vec vec_edge_heap; - dep_chains = XCNEWVEC (vec_edge_heap, MAX_NUM_CHAINS); - /* First find the closest bb that is control equivalent to PHI_BB that also dominates USE_BB. */ cd_root = phi_bb; @@ -458,20 +462,16 @@ find_predicates (vec **preds, break; } - compute_control_dep_chain (cd_root, use_bb, - dep_chains, &num_chains, - &cur_chain); + 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, - num_preds); + = convert_control_dep_chain_into_preds (dep_chains, num_chains, preds, + num_preds); /* Free individual chain */ cur_chain.release (); for (i = 0; i < num_chains; i++) dep_chains[i].release (); - free (dep_chains); return has_valid_pred; } @@ -539,16 +539,13 @@ find_def_preds (vec **preds, size_t *num_preds, gimple phi) { size_t num_chains = 0, i, n; - vec *dep_chains = 0; + vec dep_chains[MAX_NUM_CHAINS]; vec cur_chain = vNULL; vec def_edges = vNULL; bool has_valid_pred = false; basic_block phi_bb, cd_root = 0; struct pointer_set_t *visited_phis; - typedef vec vec_edge_heap; - dep_chains = XCNEWVEC (vec_edge_heap, MAX_NUM_CHAINS); - phi_bb = gimple_bb (phi); /* First find the closest dominating bb to be the control dependence root */ @@ -567,38 +564,33 @@ find_def_preds (vec **preds, 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); - /* Free individual chain */ - cur_chain.release (); + 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) - num_chains++; + 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); - } + dep_chains[j].safe_push (opnd_edge); } } + /* Free individual chain */ + cur_chain.release (); + has_valid_pred - = convert_control_dep_chain_into_preds (dep_chains, - num_chains, - preds, - num_preds); + = convert_control_dep_chain_into_preds (dep_chains, num_chains, preds, + num_preds); for (i = 0; i < num_chains; i++) dep_chains[i].release (); - free (dep_chains); return has_valid_pred; }