[middle-end, patch 4/9] Overhaul of modification analysis

This patch is a rewrite of modification analysis done by ipa-cp. It
is not really crucial for ipa-cp itself but is hopefully cleaner and
has extended capabilities required for indirect inlining. In
particular, it does not mark all addressable parameters as modified
but only those that are really modified or their address was
explicitly taken in the given function. This is necessary so that we
do not consider all member pointers modified.


2008-07-03 Martin Jambor <mjambor@???>

* ipa-prop.h (struct ipa_param_flags): New structure.
(struct ipa_node_params): New field modification_analysis_done,
modified_flags changed into param_flags.
(ipa_is_ith_param_modified): Changed to use new flags.

    * ipa-prop.c: Include diagnostic.h.
    (ipa_detect_param_modifications): Don't care about function
    inlinability or parameter addressability.
(ipa_check_stmt_modifications): Check GIMPLE_MODIFY_EXPRs properly,
    check calls, changed formal parameters.
(ipa_check_call_modifications): New function.
(ipa_check_operand_modifications): New function.
    (ipa_compute_jump_functions): Changed accesses to modification flags.
    (ipa_node_duplication_hook): Update flags duplication.
    (ipa_free_node_params_substructures): Update flags destruction.

* ipa-cp.c (ipcp_initialize_node_lattices): Initialize lattices to
bottom if the function is not inlinable.


Index: iinln/gcc/ipa-cp.c
===================================================================
--- iinln.orig/gcc/ipa-cp.c
+++ iinln/gcc/ipa-cp.c
@@ -329,18 +329,26 @@ ipcp_initialize_node_lattices (struct cg

info->ipcp_lattices = XCNEWVEC (struct ipcp_lattice,
                 ipa_get_param_count (info));
- for (i = 0; i < ipa_get_param_count (info) ; i++)
- {
- tree parm_tree = ipa_get_ith_param (info, i);
- struct ipcp_lattice *lat = ipcp_get_ith_lattice (info, i);

- if (INTEGRAL_TYPE_P (TREE_TYPE (parm_tree))
-     || SCALAR_FLOAT_TYPE_P (TREE_TYPE (parm_tree))
-     || POINTER_TYPE_P (TREE_TYPE (parm_tree)))
-    lat->type = IPA_TOP;
- else
+ if (DECL_UNINLINABLE (node->decl))
+ for (i = 0; i < ipa_get_param_count (info) ; i++)
+ {
+    struct ipcp_lattice *lat = ipcp_get_ith_lattice (info, i);
    lat->type = IPA_BOTTOM;
- }
+ }
+ else
+ for (i = 0; i < ipa_get_param_count (info) ; i++)
+ {
+    tree parm_tree = ipa_get_ith_param (info, i);
+    struct ipcp_lattice *lat = ipcp_get_ith_lattice (info, i);
+
+    if (INTEGRAL_TYPE_P (TREE_TYPE (parm_tree))
+     || SCALAR_FLOAT_TYPE_P (TREE_TYPE (parm_tree))
+     || POINTER_TYPE_P (TREE_TYPE (parm_tree)))
+     lat->type = IPA_TOP;
+    else
+     lat->type = IPA_BOTTOM;
+ }
}

/* Create a new assignment statement and make it the first statement in the
Index: iinln/gcc/ipa-prop.c
===================================================================
--- iinln.orig/gcc/ipa-prop.c
+++ iinln/gcc/ipa-prop.c
@@ -32,6 +32,7 @@ along with GCC; see the file COPYING3.
#include "flags.h"
#include "timevar.h"
#include "flags.h"
+#include "diagnostic.h"

/* To avoid frequent reallocation the size of arrays is greater than needed,
the number of elements is (not less than) 1.25 * size_wanted. */
@@ -149,95 +150,134 @@ ipa_count_formal_params (struct cgraph_n
ipa_set_param_count (IPA_NODE_REF (mt), param_num);
}

-/* Check STMT to detect whether a formal is modified within MT, the appropriate
- entry is updated in the modified_flags array of ipa_node_params (associated
- with MT). */
+/* This function checks whether OP which is an operand of an expression on the
+ right hand side of a modify statement or an argument of call expr takes an
+ address of a parameter of the function characterized by INFO. If it does,
+ the parameter is marked as modified. */
static void
-ipa_check_stmt_modifications (struct cgraph_node *mt, tree stmt)
+ipa_check_operand_modifications (struct ipa_node_params *info, tree op)
{
- int index, j;
- tree parm_decl;
- struct ipa_node_params *info;
+ while (UNARY_CLASS_P (op)
+     || TREE_CODE (op) == TRUTH_NOT_EXPR)
+ op = TREE_OPERAND (op, 0);
+
+ if (TREE_CODE (op) == ADDR_EXPR)
+ {
+ int index;
+
+ op = TREE_OPERAND (op, 0);
+ while (handled_component_p (op))
+    op = TREE_OPERAND (op, 0);
+ index = ipa_get_param_decl_index (info, op);
+ if (index >= 0)
+    info->param_flags[index].modified = true;
+ }
+}
+
+/* Check whether any of the arguments passed in a CALL is an ADDR_EXPR and if
+ yes, marked it as modified. INFO is characterizes the callers formal
+ parameters. */
+static void
+ipa_check_call_modifications (struct ipa_node_params *info, tree call)
+{
+ call_expr_arg_iterator iter;
+ tree arg;
+
+ FOR_EACH_CALL_EXPR_ARG (arg, iter, call)
+ ipa_check_operand_modifications (info, arg);
+}
+
+/* Check STMT to detect whether a formal parameter is modified within NODE, the
+ appropriate entry is updated in the modified flags of INFO. */
+static void
+ipa_check_stmt_modifications (struct ipa_node_params *info, tree stmt)
+{
+ int j;
+ int index;
+ tree lhs;
+ tree rhs;

switch (TREE_CODE (stmt))
{
case GIMPLE_MODIFY_STMT:
-     if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == PARM_DECL)
+ lhs = GIMPLE_STMT_OPERAND (stmt, 0);
+ rhs = GIMPLE_STMT_OPERAND (stmt, 1);
+
+ while (handled_component_p (lhs))
+    lhs = TREE_OPERAND (lhs, 0);
+ if (TREE_CODE (lhs) == SSA_NAME)
+    lhs = SSA_NAME_VAR (lhs);
+ index = ipa_get_param_decl_index (info, lhs);
+ if (index >= 0)
+    info->param_flags[index].modified = true;
+
+ if (TREE_CODE (rhs) == CALL_EXPR)
    {
-     info = IPA_NODE_REF (mt);
-     parm_decl = GIMPLE_STMT_OPERAND (stmt, 0);
-     index = ipa_get_param_decl_index (info, parm_decl);
-     if (index >= 0)
-     info->modified_flags[index] = true;
+     ipa_check_call_modifications (info, rhs);
+     break;
    }
+
+ if (BINARY_CLASS_P (rhs) || COMPARISON_CLASS_P (rhs)
+     || TREE_CODE (rhs) == TRUTH_AND_EXPR
+     || TREE_CODE (rhs) == TRUTH_OR_EXPR
+     || TREE_CODE (rhs) == TRUTH_XOR_EXPR)
+
+    {
+     ipa_check_operand_modifications (info, TREE_OPERAND (rhs, 0));
+     ipa_check_operand_modifications (info, TREE_OPERAND (rhs, 1));
+    }
+ else
+    ipa_check_operand_modifications (info, rhs);
+
+ break;
+ case CALL_EXPR:
+ ipa_check_call_modifications (info, stmt);
break;
case ASM_EXPR:
/* Asm code could modify any of the parameters. */
- info = IPA_NODE_REF (mt);
- for (j = 0; j < ipa_get_param_count (IPA_NODE_REF (mt)); j++)
-    info->modified_flags[j] = true;
+ for (j = 0; j < ipa_get_param_count (info); j++)
+    info->param_flags[j].modified = true;
break;
default:
break;
}
}

-/* The modify computation driver for MT. Compute which formal arguments
- of function MT are locally modified. Formals may be modified in MT
- if their address is taken, or if
- they appear on the left hand side of an assignment. */
-void
-ipa_detect_param_modifications (struct cgraph_node *mt)
-{
- tree decl;
- tree body;
- int j, count;
+/* Compute which formal parameters of function associated with NODE are locally
+ modified. Parameters may be modified in NODE if their address is taken, or
+ if they appear on the left hand side of an assignment. */
+void
+ipa_detect_param_modifications (struct cgraph_node *node)
+{
+ tree decl = node->decl;
basic_block bb;
struct function *func;
block_stmt_iterator bsi;
- tree stmt, parm_tree;
- struct ipa_node_params *info = IPA_NODE_REF (mt);
+ tree stmt;
+ struct ipa_node_params *info = IPA_NODE_REF (node);

- if (ipa_get_param_count (info) == 0 || info->modified_flags)
+ if (ipa_get_param_count (info) == 0 || info->modification_analysis_done
+ || !DECL_SAVED_TREE (decl))
return;

- count = ipa_get_param_count (info);
- info->modified_flags = XCNEWVEC (bool, count);
- decl = mt->decl;
- /* ??? Handle pending sizes case. Set all parameters
- of the function to be modified. */
+ if (!info->param_flags)
+ info->param_flags = XCNEWVEC (struct ipa_param_flags,
+                 ipa_get_param_count (info));

- if (DECL_UNINLINABLE (decl))
+ func = DECL_STRUCT_FUNCTION (decl);
+ FOR_EACH_BB_FN (bb, func)
{
- for (j = 0; j < count; j++)
-    info->modified_flags[j] = true;
-
- return;
- }
- /* Formals whose address is taken are considered modified. */
- for (j = 0; j < count; j++)
- {
- parm_tree = ipa_get_ith_param (info, j);
- if (!is_gimple_reg (parm_tree)
-     && TREE_ADDRESSABLE (parm_tree))
-    info->modified_flags[j] = true;
- }
- body = DECL_SAVED_TREE (decl);
- if (body != NULL)
- {
- func = DECL_STRUCT_FUNCTION (decl);
- FOR_EACH_BB_FN (bb, func)
- {
-    for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
-     {
-     stmt = bsi_stmt (bsi);
-     ipa_check_stmt_modifications (mt, stmt);
-     }
- }
+ for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
+    {
+     stmt = bsi_stmt (bsi);
+     ipa_check_stmt_modifications (info, stmt);
+    }
}
+
+ info->modification_analysis_done = 1;
}

-/* Count number of arguments callsite CS has and store it in
+/* Count number of arguments callsite CS has and store it in
ipa_edge_args structure corresponding to this callsite. */
void
ipa_count_arguments (struct cgraph_edge *cs)
@@ -294,11 +334,12 @@ ipa_compute_jump_functions (struct cgrap
     if (TREE_CODE (arg) == SSA_NAME && IS_VALID_JUMP_FUNC_INDEX (index))
     {
     curr_cfun = DECL_STRUCT_FUNCTION (mt->decl);
-     if (!gimple_default_def (curr_cfun, parm_decl)
+     if (!gimple_default_def (curr_cfun, parm_decl)
     || gimple_default_def (curr_cfun, parm_decl) != arg)
-        info->modified_flags[index] = true;
+        info->param_flags[index].modified = true;
     }
-     if (!IS_VALID_JUMP_FUNC_INDEX (index) || info->modified_flags[index])
+     if (!IS_VALID_JUMP_FUNC_INDEX (index)
+     || ipa_is_ith_param_modified (info, index))
     args->jump_functions[arg_num].type = IPA_UNKNOWN;
     else
     {
@@ -403,8 +444,8 @@ ipa_free_node_params_substructures (stru
free (info->ipcp_lattices);
if (info->param_decls)
free (info->param_decls);
- if (info->modified_flags)
- free (info->modified_flags);
+ if (info->param_flags)
+ free (info->param_flags);

memset (info, 0, sizeof (*info));
}
@@ -495,8 +536,9 @@ ipa_node_duplication_hook (struct cgraph
         sizeof (struct ipcp_lattice) * param_count);
new_info->param_decls = (tree *)
duplicate_array (old_info->param_decls, sizeof (tree) * param_count);
- new_info->modified_flags = (bool *)
- duplicate_array (old_info->modified_flags, sizeof (bool) * param_count);
+ new_info->param_flags = (struct ipa_param_flags *)
+ duplicate_array (old_info->param_flags,
+         sizeof (struct ipa_param_flags) * param_count);

new_info->ipcp_orig_node = old_info->ipcp_orig_node;
new_info->count_scale = old_info->count_scale;
@@ -597,7 +639,7 @@ ipa_print_all_params_modified (FILE * f)
count = ipa_get_param_count (info);
for (i = 0; i < count; i++)
    {
-     temp = info->modified_flags[i];
+     temp = info->param_flags[i].modified;
     if (temp)
     fprintf (f, " param [%d] true \n", i);
     else
Index: iinln/gcc/ipa-prop.h
===================================================================
--- iinln.orig/gcc/ipa-prop.h
+++ iinln/gcc/ipa-prop.h
@@ -100,6 +100,15 @@ struct ipa_replace_map
bool ref_p;
};

+/* ipa_param_flags contains various flags that describe how the associated
+ parameter is treated within a function. */
+struct ipa_param_flags
+{
+ /* Whether the value parameter has been modified within the function. */
+ unsigned modified : 1;
+
+};
+
/* ipa_node_params stores information related to formal parameters of functions
and some other information for interprocedural passes that operate on
parameters (such as ipa-cp). */
@@ -114,8 +123,8 @@ struct ipa_node_params
struct ipcp_lattice *ipcp_lattices;
/* Mapping each parameter to its PARM_DECL tree. */
tree *param_decls;
- /* Indicating which parameter is modified in its function. */
- bool *modified_flags;
+ /* Various flags describing individual parameters. */
+ struct ipa_param_flags *param_flags;
/* Only for versioned nodes this field would not be NULL,
it points to the node that IPA cp cloned from. */
struct cgraph_node *ipcp_orig_node;
@@ -129,6 +138,8 @@ struct ipa_node_params
/* Whether this function is called with variable number of actual
arguments. */
unsigned called_with_var_arguments : 1;
+ /* Whether the modification analysis has already been performed. */
+ unsigned modification_analysis_done : 1;
};

/* ipa_node_params access functions. Please use these to access fields that
@@ -163,7 +174,7 @@ ipa_get_ith_param (struct ipa_node_param
static inline bool
ipa_is_ith_param_modified (struct ipa_node_params *info, int i)
{
- return info->modified_flags[i];
+ return info->param_flags[i].modified;
}

/* Flag this node as having callers with variable number of arguments. */

--