You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
/* This file mark functions as being either const (TREE_READONLY) or
pure (DECL_IS_PURE).
#include "timevar.h"
#include "diagnostic.h"
#include "langhooks.h"
+#include "target.h"
static struct pointer_set_t *visited_nodes;
static inline funct_state
get_function_state (struct cgraph_node *node)
{
- struct ipa_dfs_info * info = node->aux;
- return info->aux;
+ struct ipa_dfs_info * info = (struct ipa_dfs_info *) node->aux;
+ return (funct_state) info->aux;
}
/* Check to see if the use (or definition when CHECHING_WRITE is true)
static void
check_tree (funct_state local, tree t, bool checking_write)
{
- if ((TREE_CODE (t) == EXC_PTR_EXPR) || (TREE_CODE (t) == FILTER_EXPR))
+ if ((TREE_CODE (t) == EXC_PTR_EXPR) || (TREE_CODE (t) == FILTER_EXPR)
+ || TREE_CODE (t) == SSA_NAME)
return;
+ /* Any tree which is volatile disqualifies thie function from being
+ const or pure. */
+ if (TREE_THIS_VOLATILE (t))
+ {
+ local->pure_const_state = IPA_NEITHER;
+ return;
+ }
+
while (TREE_CODE (t) == REALPART_EXPR
|| TREE_CODE (t) == IMAGPART_EXPR
|| handled_component_p (t))
/* Any indirect reference that occurs on the lhs
disqualifies the function from being pure or const. Any
- indirect reference that occurs on the rhs disqualifies
- the function from being const. */
+ indirect reference that occurs on the rhs disqualifies the
+ function from being const. */
if (checking_write)
- local->pure_const_state = IPA_NEITHER;
- else
- if (local->pure_const_state == IPA_CONST)
- local->pure_const_state = IPA_PURE;
+ {
+ local->pure_const_state = IPA_NEITHER;
+ return;
+ }
+ else if (local->pure_const_state == IPA_CONST)
+ local->pure_const_state = IPA_PURE;
}
if (SSA_VAR_P (t))
static void
check_call (funct_state local, tree call_expr)
{
- int flags = call_expr_flags(call_expr);
- tree operand_list = TREE_OPERAND (call_expr, 1);
+ int flags = call_expr_flags (call_expr);
tree operand;
+ call_expr_arg_iterator iter;
tree callee_t = get_callee_fndecl (call_expr);
struct cgraph_node* callee;
enum availability avail = AVAIL_NOT_AVAILABLE;
- for (operand = operand_list;
- operand != NULL_TREE;
- operand = TREE_CHAIN (operand))
- {
- tree argument = TREE_VALUE (operand);
- check_rhs_var (local, argument);
- }
+ FOR_EACH_CALL_EXPR_ARG (operand, iter, call_expr)
+ check_rhs_var (local, operand);
/* The const and pure flags are set by a variety of places in the
compiler (including here). If someone has already set the flags
int *walk_subtrees,
void *data)
{
- struct cgraph_node *fn = data;
+ struct cgraph_node *fn = (struct cgraph_node *) data;
tree t = *tp;
funct_state local = get_function_state (fn);
*walk_subtrees = 0;
break;
- case MODIFY_EXPR:
+ case GIMPLE_MODIFY_STMT:
{
/* First look on the lhs and see what variable is stored to */
- tree lhs = TREE_OPERAND (t, 0);
- tree rhs = TREE_OPERAND (t, 1);
+ tree lhs = GIMPLE_STMT_OPERAND (t, 0);
+ tree rhs = GIMPLE_STMT_OPERAND (t, 1);
check_lhs_var (local, lhs);
/* For the purposes of figuring out what the cast affects */
case ADDR_EXPR:
check_rhs_var (local, rhs);
break;
- case CALL_EXPR:
+ default:
+ break;
+ }
+ break;
+ case tcc_vl_exp:
+ switch (TREE_CODE (rhs))
+ {
+ case CALL_EXPR:
check_call (local, rhs);
break;
default:
static void
analyze_function (struct cgraph_node *fn)
{
- funct_state l = xcalloc (1, sizeof (struct funct_state_d));
+ funct_state l = XCNEW (struct funct_state_d);
tree decl = fn->decl;
- struct ipa_dfs_info * w_info = fn->aux;
+ struct ipa_dfs_info * w_info = (struct ipa_dfs_info *) fn->aux;
w_info->aux = l;
l->pure_const_state = IPA_CONST;
l->state_set_in_source = false;
- /* If this is a volatile function, do not touch this unless it has
- been marked as const or pure by the front end. */
- if (TREE_THIS_VOLATILE (decl))
+ /* If this function does not return normally or does not bind local,
+ do not touch this unless it has been marked as const or pure by the
+ front end. */
+ if (TREE_THIS_VOLATILE (decl)
+ || !targetm.binds_local_p (decl))
{
l->pure_const_state = IPA_NEITHER;
return;
walk_tree (bsi_stmt_ptr (bsi), scan_function,
fn, visited_nodes);
if (l->pure_const_state == IPA_NEITHER)
- return;
+ goto end;
}
}
pop_cfun ();
}
}
+
+end:
+ if (dump_file)
+ {
+ fprintf (dump_file, "after local analysis of %s with initial value = %d\n ",
+ cgraph_node_name (fn),
+ l->pure_const_state);
+ }
}
\f
on the local information that was produced by ipa_analyze_function
and ipa_analyze_variable. */
-static void
+static unsigned int
static_execute (void)
{
struct cgraph_node *node;
struct cgraph_node *w;
struct cgraph_node **order =
- xcalloc (cgraph_n_nodes, sizeof (struct cgraph_node *));
- int order_pos = order_pos = ipa_utils_reduced_inorder (order, true, false);
+ XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
+ int order_pos = ipa_utils_reduced_inorder (order, true, false);
int i;
struct ipa_dfs_info * w_info;
}
}
}
- w_info = w->aux;
+ w_info = (struct ipa_dfs_info *) w->aux;
w = w_info->next_cycle;
}
break;
}
}
- w_info = w->aux;
+ w_info = (struct ipa_dfs_info *) w->aux;
w = w_info->next_cycle;
}
}
/* Get rid of the aux information. */
if (node->aux)
{
+ w_info = (struct ipa_dfs_info *) node->aux;
+ if (w_info->aux)
+ free (w_info->aux);
free (node->aux);
node->aux = NULL;
}
free (order);
+ return 0;
}
static bool
struct tree_opt_pass pass_ipa_pure_const =
{
- "ipa-pure-const", /* name */
+ "pure-const", /* name */
gate_pure_const, /* gate */
static_execute, /* execute */
NULL, /* sub */