public inbox for gcc-patches@gcc.gnu.org
 help / color / mirror / Atom feed
* [RFC PATCH] ipa-prop.[ch] cleanup
@ 2008-04-07 19:31 Martin Jambor
  2008-04-08  9:30 ` Richard Guenther
  2008-04-10  5:27 ` Diego Novillo
  0 siblings, 2 replies; 6+ messages in thread
From: Martin Jambor @ 2008-04-07 19:31 UTC (permalink / raw)
  To: GCC Patches

Hi,

the following  is an untested  cleanup (which compiles)  of ipa-prop.h
and  ipa-prop.c.   Changes in  ipa-cp.c  are  only  those required  by
changes made  to ipa-prop  files.  Nevertheless, if  I get an  ACK for
(most of) these  changes, I'm ready and happy to  do a similar cleanup
in ipa-cp.c as well.

As you  see the  changelog is  rather big but  the changes  are purely
technical and  do not affect how  ipa-cp operates in  any way.  Almost
all of them fall into one of the following categories:

1) Renaming  structure  names  and  structure field  names  to what  I
   believe are more  sensible names.  ipa-cp for some  reasons did not
   use the term  lattice or jump function but  rather fancied to refer
   to  both   as  to  "cvals"   instead.   I  have   therefore  turned
   parameter_info into jump_func_value because  that is what it is and
   changed   ipcp_formal  to  ipcp_lattice.    I  have   made  similar
   clarifications with the member names.

   I  also did  not like  names ipa_node  and ipa_edge  which  I found
   confusing and  not descriptive enough.  Because my  intention is to
   store some other information  about formal parameters in the former
   and about  actual arguments in the  latter, I have  renamed them to
   ipa_node_params and ipa_edge-args.

2) I have  untangled  the  structures a  little bit  by  replacing the
   member "union  parameter_info cvalue" in  struct ipcp_formal (which
   itself  has been  renamed  to struct  ipcp_lattice)  with a  member
   called constant of type tree.   The reason is simply that the other
   member of the union was never used in this context.

3) ipa-prop.[ch] (and ipa-cp.c) uses the term method for functions.  I
   think  that is  extremely confusing  (as well  annoying)  because I
   believe  that the term  method is  and should  be used  to describe
   "member functions" of an object only (as for example in METHOD_TYPE
   tree type).  Therefore I got  rid of every reference to methods and
   replaced them by the word function.  

4) The code used access getter and setter functions excessively, up to
   a point  which made the code  terribly difficult to  read.  Most of
   them  were  trivial and  useless,  there  was  for example  even  a
   function returning cgraph_edge->callee for  a given cgraph edge.  I
   strongly disliked this  approach (if we want to  have ultra OO-like
   code, why don't we use an OO language in the first place?).  I have
   removed most of these.

5) The functions had cryptic names.  For example, function that
   counted number of parameters of a function was called
   ipa_method_formal_compute_count.  I changed it to
   ipa_count_parameters.  And this was not probably the worst
   example. See the changelog for others.

6) I have added IPA_ prefix  to the enum constant names and remove the
   _IAPTYPE   suffix  some  of   them  had.    I  have   also  changed
   FORMAL_IPATYPE  to  IPA_PASS_THROUGH  because  that  is  what  such
   functions are called in the original Callahan's paper.

7) I did some other changes  like renaming variables "i" that were not
   iterators to index because that was what they held and I have added
   some  temporary pointers  to  struct ipa_node_params  where it  was
   accessed repeatadly.  However, I have tried not to do many of these
   to keep the patch simpler.

I  have been  fairly  uncompromising  with the  cleanup  but for  good
reasons.  Once  I have  done this.  The  ipa-prop.[ch] part  of ipa-cp
seems nice,  readable and  simple, whereas it  used to be  cryptic and
ugly.  If someone objects to some  specific part of my changes, I'd be
glad to discuss it but because  IMHO the code looks much better now, I
would ask someone to pre-approve at least a majority of these changes.  

If that  happens, I will  test the patch  and I will  cleanup ipa-cp.c
too.  I  might even  prepare a  follow up patch  renaming all  mt (aka
method)  parameters to  node (aka  cgraph_node) to  reflect  what they
really mean.

Last but not least, as I  have already mentioned I would like to reuse
ipa-prop.[ch] code for other things too and cleaning it up first would
make my life a lot easier.

Thank you very much,

Martin


Changelog:

2008-04-07  Martin Jambor  <mjambor@suse.cz>

	* ipa-prop.h (struct ipcp_formal): Renamed to ipcp_lattice
	(struct ipcp_lattice): Renamed cval_type to type
	(struct ipa_node_params): ipcp_cval renamed to ipcp_lattices

	* ipa-cp.c (ipcp_cval_get_cvalue): Changed return value to tree
	(ipcp_cval_set_cvalue): Changed type of parameter value to tree
	(ipcp_insert_stage): Changed the type of variable cvalue to tree
	(ipcp_replace_map_create): Changed the type of parameter cvalue to tree
	(build_const_val): Changed the type of parameter cvalue to tree
	(ipcp_propagate_const): Changed the type of parameter cvalue to tree
	(ipcp_method_cval_set_cvalue_type): Renamed parameter cval_type1 to type
	
	* ipa-prop.h (struct ipcp_formal): Replaced cvalue with tree called 
	constant 

	* ipa-prop.c (ipa_methodlist_init): Renamed to ipa_init_func_list
	(ipa_methodlist_not_empty): Removed, the sole user now checks directly
	(ipa_add_method): Renamed to ipa_push_func_to_list
	(ipa_remove_method): Renamed to ipa_pop_func_from_list
	(ipa_callsite_param_count): Removed.
	(ipa_callsite_param_count_set): Removed.
	(ipa_callsite_param): Removed.
	(ipa_callsite_callee): Removed.
	(ipa_callsite_compute_param): Renamed to ipa_compute_jump_functions
	(ipa_callsite_compute_count): Renamed to ipa_count_arguments
	(ipa_method_formal_count): Removed.
	(ipa_method_formal_count_set): Removed.
	(ipa_method_get_tree): Removed.
	(ipa_method_tree_map_create): Removed.
	(ipa_method_compute_tree_map): Renamed to ipa_create_param_decls_array
	(ipa_create_param_decls_array): Creates the array itself
	(ipa_create_param_decls_array): Temporary variable info instead of 
	a few dereferences.
	(ipa_method_formal_compute_count): Renamed to ipa_count_formal_params
	(ipa_method_compute_modify): Renamed to ipa_detect_param_modifications
	(get_type): Removed.
	(ipa_jf_get_info_type): Removed.
	(ipa_node_create): Renamed to ipa_create_node_params
	(ipa_free): Renamed to ipa_free_all_node_params
	(ipa_nodes_create): Renamed to ipa_create_all_node_params
	(ipa_edges_create): Renamed to ipa_create_all_edge_args
	(ipa_edges_free): Renamed to ipa_free_all_edge_args
	(ipa_nodes_free): Integrated into ipa_free_all_node_params and removed
	(ipa_free_all_node_params): Deallocation to jump_functions moved to 
	ipa_free_all_edge_args
	(ipa_method_tree_print): Renamed to ipa_print_all_tree_maps
	(ipa_method_modify_print): Renamed to ipa_print_all_params_modified
	(ipa_create_methodlist_node): Removed.
	(ipa_methodlist_method): Removed.
	(ipa_methodlist_method_set): Removed.
	(ipa_methodlist_next_method): Removed.
	(ipa_methodlist_next_method_set): Removed.
	(ipa_method_is_modified): Removed.
	(ipa_method_modify_create): Removed.
	(ipa_method_modify_init): Temporary variable info instead of a few 
	dereferences.
	(ipa_detect_param_modifications): Temporary variable info instead of 
	a few dereferences.
	(ipa_compute_jump_functions): Temporary variable info instead of 
	a few dereferences.
	(ipa_method_modify_set): Removed.
	(ipa_method_tree_map): Renamed to ipa_get_param_decl_index
	(ipa_get_param_decl_index): Now accepts struct ipa_node_params rather 
	than craph_node as the first parameter.
	(ipa_method_modify_stmt): Renamed to ipa_check_stmt_modifications
	(ipa_method_modify_init): Removed.
	(ipa_compute_jump_functions): Added a temp variable instead of 
	repeatadly dereferencing the cgraph_edge.aux pointer
	(ipa_callsite_param_set_type): Removed.
	(ipa_compute_jump_functions): i renamed to index and moved to 
	an inner block
	(ipa_callsite_param_set_info_type_formal): Removed.
	(ipa_callsite_param_set_info_type): Removed.
	(ipa_callsite_param_map_create): Removed.
	(ipa_callsite_tree): Removed.
	(ipa_callsite_caller): Removed.
	(ipa_pop_func_from_list): return_method removed to return_func

	* ipa-prop.h (enum cvalue_type): Renamed to ipa_lattice_type,
	prefixed all values with IPA_. Changed all users.
	(enum jump_func_type): Rnamed UNKNOWN_IPATYPE to IPA_UNKNOWN, 
	CONST_IPATYPE to IPA_CONST, CONST_IPATYPE_REF to IPA_CONST_REF 
	and FORMAL_IPATYPE IPA_PASS_THROUGH. 
	(union parameter_info): Renamed to jump_func_value.
	(union jump_func_value): Renamed value to constant
	(struct ipa_jump_func): Renamed info_type to value
	(struct ipa_node): Renamed to ipa_node_params
	(struct ipa_node_params): Renamed ipa_arg_num to param_count
	(struct ipa_node_params): Renamed to param_decls
	(struct ipa_node_params): Renamed to modified_flags
	(struct ipa_edge): Renamed to ipa_edge_args
	(struct ipa_edge_args): Renamed ipa_param_num to argument_count
	(struct ipa_edge_args): Renamed ipa_param_map to jump_functions
	(struct ipa_methodlist): Renamed to ipa_func_list
	(struct ipa_func_list): method_p renamed to node, next_method
	renamed to next
	(ipa_methodlist_p): Removed, switched all users to struct pointer
	(IS_VALID_TREE_MAP_INDEX): Renamed to IS_VALID_JUMP_FUNC_INDEX




Index: iinln/gcc/ipa-cp.c
===================================================================
--- iinln.orig/gcc/ipa-cp.c
+++ iinln/gcc/ipa-cp.c
@@ -72,7 +72,7 @@ along with GCC; see the file COPYING3.  
    
    The jump function info, ipa_jump_func, is defined in ipa_edge
    structure (defined in ipa_prop.h and pointed to by cgraph_node->aux)
-   The modify info, ipa_modify, is defined in ipa_node structure
+   The modify info, modified_flags, is defined in ipa_node_params structure
    (defined in ipa_prop.h and pointed to by cgraph_edge->aux).
    
    -ipcp_init_stage() is the first stage driver.
@@ -89,7 +89,7 @@ along with GCC; see the file COPYING3.  
    Cval of formal f will have a constant value if all callsites to this
    function have the same constant value passed to f.
    
-   The cval info, ipcp_formal, is defined in ipa_node structure
+   The cval info, ipcp_lattice, is defined in ipa_node_params structure
    (defined in ipa_prop.h and pointed to by cgraph_edge->aux).
 
    -ipcp_iterate_stage() is the second stage driver.
@@ -145,7 +145,7 @@ along with GCC; see the file COPYING3.  
 #include "tree-dump.h"
 #include "tree-inline.h"
 
-/* Get orig node field of ipa_node associated with method MT.  */
+/* Get orig node field of ipa_node_params associated with method MT.  */
 static inline struct cgraph_node *
 ipcp_method_orig_node (struct cgraph_node *mt)
 {
@@ -173,17 +173,17 @@ static void
 ipcp_cloned_create (struct cgraph_node *orig_node,
 		    struct cgraph_node *new_node)
 {
-  ipa_node_create (new_node);
+  ipa_create_node_params (new_node);
   ipcp_method_set_orig_node (new_node, orig_node);
-  ipa_method_formal_compute_count (new_node);
-  ipa_method_compute_tree_map (new_node);
+  ipa_count_formal_params (new_node);
+  ipa_create_param_decls_array (new_node);
 }
 
 /* Return cval_type field of CVAL.  */
-static inline enum cvalue_type
-ipcp_cval_get_cvalue_type (struct ipcp_formal *cval)
+static inline enum ipa_lattice_type
+ipcp_cval_get_cvalue_type (struct ipcp_lattice *cval)
 {
-  return cval->cval_type;
+  return cval->type;
 }
 
 /* Return scale for MT.  */
@@ -202,32 +202,32 @@ ipcp_method_set_scale (struct cgraph_nod
 
 /* Set TYPE as cval_type field of CVAL.  */
 static inline void
-ipcp_cval_set_cvalue_type (struct ipcp_formal *cval, enum cvalue_type type)
+ipcp_cval_set_cvalue_type (struct ipcp_lattice *cval, enum jump_func_type type)
 {
-  cval->cval_type = type;
+  cval->type = type;
 }
 
 /* Return cvalue field of CVAL.  */
-static inline union parameter_info *
-ipcp_cval_get_cvalue (struct ipcp_formal *cval)
+static inline tree
+ipcp_cval_get_cvalue (struct ipcp_lattice *cval)
 {
-  return &(cval->cvalue);
+  return cval->constant;
 }
 
 /* Set VALUE as cvalue field  CVAL.  */
 static inline void
-ipcp_cval_set_cvalue (struct ipcp_formal *cval, union parameter_info *value,
-		      enum cvalue_type type)
+ipcp_cval_set_cvalue (struct ipcp_lattice *cval, tree value,
+		      enum ipa_lattice_type type)
 {
-  if (type == CONST_VALUE || type == CONST_VALUE_REF)
-    cval->cvalue.value = value->value;
+  if (type == IPA_CONST_VALUE || type == IPA_CONST_VALUE_REF)
+    cval->constant = value;
 }
 
 /* Return whether TYPE is a constant type.  */
 static bool
-ipcp_type_is_const (enum cvalue_type type)
+ipcp_type_is_const (enum ipa_lattice_type type)
 {
-  if (type == CONST_VALUE || type == CONST_VALUE_REF)
+  if (type == IPA_CONST_VALUE || type == IPA_CONST_VALUE_REF)
     return true;
   else
     return false;
@@ -235,43 +235,43 @@ ipcp_type_is_const (enum cvalue_type typ
 
 /* Return true if CONST_VAL1 and CONST_VAL2 are equal.  */
 static inline bool
-ipcp_cval_equal_cvalues (union parameter_info *const_val1,
-			 union parameter_info *const_val2,
-			 enum cvalue_type type1, enum cvalue_type type2)
+ipcp_cval_equal_cvalues (tree const_val1, tree const_val2,
+			 enum ipa_lattice_type type1,
+			 enum ipa_lattice_type type2)
 {
   gcc_assert (ipcp_type_is_const (type1) && ipcp_type_is_const (type2));
   if (type1 != type2)
     return false;
 
-  if (operand_equal_p (const_val1->value, const_val2->value, 0))
+  if (operand_equal_p (const_val1, const_val2, 0))
     return true;
 
   return false;
 }
 
 /* Compute Meet arithmetics:
-   Meet (BOTTOM, x) = BOTTOM
-   Meet (TOP,x) = x
-   Meet (const_a,const_b) = BOTTOM,  if const_a != const_b.  
+   Meet (IPA_BOTTOM, x) = IPA_BOTTOM
+   Meet (IPA_TOP,x) = x
+   Meet (const_a,const_b) = IPA_BOTTOM,  if const_a != const_b.
    MEET (const_a,const_b) = const_a, if const_a == const_b.*/
 static void
-ipcp_cval_meet (struct ipcp_formal *cval, struct ipcp_formal *cval1,
-		struct ipcp_formal *cval2)
+ipcp_cval_meet (struct ipcp_lattice *cval, struct ipcp_lattice *cval1,
+		struct ipcp_lattice *cval2)
 {
-  if (ipcp_cval_get_cvalue_type (cval1) == BOTTOM
-      || ipcp_cval_get_cvalue_type (cval2) == BOTTOM)
+  if (ipcp_cval_get_cvalue_type (cval1) == IPA_BOTTOM
+      || ipcp_cval_get_cvalue_type (cval2) == IPA_BOTTOM)
     {
-      ipcp_cval_set_cvalue_type (cval, BOTTOM);
+      ipcp_cval_set_cvalue_type (cval, IPA_BOTTOM);
       return;
     }
-  if (ipcp_cval_get_cvalue_type (cval1) == TOP)
+  if (ipcp_cval_get_cvalue_type (cval1) == IPA_TOP)
     {
       ipcp_cval_set_cvalue_type (cval, ipcp_cval_get_cvalue_type (cval2));
       ipcp_cval_set_cvalue (cval, ipcp_cval_get_cvalue (cval2),
 			    ipcp_cval_get_cvalue_type (cval2));
       return;
     }
-  if (ipcp_cval_get_cvalue_type (cval2) == TOP)
+  if (ipcp_cval_get_cvalue_type (cval2) == IPA_TOP)
     {
       ipcp_cval_set_cvalue_type (cval, ipcp_cval_get_cvalue_type (cval1));
       ipcp_cval_set_cvalue (cval, ipcp_cval_get_cvalue (cval1),
@@ -283,7 +283,7 @@ ipcp_cval_meet (struct ipcp_formal *cval
 				ipcp_cval_get_cvalue_type (cval1),
 				ipcp_cval_get_cvalue_type (cval2)))
     {
-      ipcp_cval_set_cvalue_type (cval, BOTTOM);
+      ipcp_cval_set_cvalue_type (cval, IPA_BOTTOM);
       return;
     }
   ipcp_cval_set_cvalue_type (cval, ipcp_cval_get_cvalue_type (cval1));
@@ -292,34 +292,35 @@ ipcp_cval_meet (struct ipcp_formal *cval
 }
 
 /* Return cval structure for the formal at index INFO_TYPE in MT.  */
-static inline struct ipcp_formal *
+static inline struct ipcp_lattice *
 ipcp_method_cval (struct cgraph_node *mt, int info_type)
 {
-  return &(IPA_NODE_REF (mt)->ipcp_cval[info_type]);
+  return &(IPA_NODE_REF (mt)->ipcp_lattices[info_type]);
 }
 
 /* Given the jump function (TYPE, INFO_TYPE), compute a new value of CVAL.  
    If TYPE is FORMAL_IPA_TYPE, the cval of the corresponding formal is 
    drawn from MT.  */
 static void
-ipcp_cval_compute (struct ipcp_formal *cval, struct cgraph_node *mt,
-		   enum jump_func_type type, union parameter_info *info_type)
+ipcp_cval_compute (struct ipcp_lattice *cval, struct cgraph_node *mt,
+		   enum jump_func_type type,
+		   union jump_func_value *info_type)
 {
-  if (type == UNKNOWN_IPATYPE)
-    ipcp_cval_set_cvalue_type (cval, BOTTOM);
-  else if (type == CONST_IPATYPE)
+  if (type == IPA_UNKNOWN)
+    ipcp_cval_set_cvalue_type (cval, IPA_BOTTOM);
+  else if (type == IPA_CONST)
     {
-      ipcp_cval_set_cvalue_type (cval, CONST_VALUE);
-      ipcp_cval_set_cvalue (cval, info_type, CONST_VALUE);
+      ipcp_cval_set_cvalue_type (cval, IPA_CONST_VALUE);
+      ipcp_cval_set_cvalue (cval, info_type->constant, IPA_CONST_VALUE);
     }
-  else if (type == CONST_IPATYPE_REF)
+  else if (type == IPA_CONST_REF)
     {
-      ipcp_cval_set_cvalue_type (cval, CONST_VALUE_REF);
-      ipcp_cval_set_cvalue (cval, info_type, CONST_VALUE_REF);
+      ipcp_cval_set_cvalue_type (cval, IPA_CONST_VALUE_REF);
+      ipcp_cval_set_cvalue (cval, info_type->constant, IPA_CONST_VALUE_REF);
     }
-  else if (type == FORMAL_IPATYPE)
+  else if (type == IPA_PASS_THROUGH)
     {
-      enum cvalue_type type =
+      enum ipa_lattice_type type =
 	ipcp_cval_get_cvalue_type (ipcp_method_cval
 				   (mt, info_type->formal_id));
       ipcp_cval_set_cvalue_type (cval, type);
@@ -332,12 +333,12 @@ ipcp_cval_compute (struct ipcp_formal *c
 
 /* True when CVAL1 and CVAL2 values are not the same.  */
 static bool
-ipcp_cval_changed (struct ipcp_formal *cval1, struct ipcp_formal *cval2)
+ipcp_cval_changed (struct ipcp_lattice *cval1, struct ipcp_lattice *cval2)
 {
   if (ipcp_cval_get_cvalue_type (cval1) == ipcp_cval_get_cvalue_type (cval2))
     {
-      if (ipcp_cval_get_cvalue_type (cval1) != CONST_VALUE &&
-	  ipcp_cval_get_cvalue_type (cval1) != CONST_VALUE_REF)
+      if (ipcp_cval_get_cvalue_type (cval1) != IPA_CONST_VALUE &&
+	  ipcp_cval_get_cvalue_type (cval1) != IPA_CONST_VALUE_REF)
 	return false;
       if (ipcp_cval_equal_cvalues (ipcp_cval_get_cvalue (cval1),
 				   ipcp_cval_get_cvalue (cval2),
@@ -352,25 +353,33 @@ ipcp_cval_changed (struct ipcp_formal *c
 static inline void
 ipcp_formal_create (struct cgraph_node *mt)
 {
-  IPA_NODE_REF (mt)->ipcp_cval =
-    XCNEWVEC (struct ipcp_formal, ipa_method_formal_count (mt));
+  IPA_NODE_REF (mt)->ipcp_lattices =
+    XCNEWVEC (struct ipcp_lattice, IPA_NODE_REF (mt)->param_count);
 }
 
 /* Set cval structure of I-th formal of MT to CVAL.  */
 static inline void
-ipcp_method_cval_set (struct cgraph_node *mt, int i, struct ipcp_formal *cval)
+ipcp_method_cval_set (struct cgraph_node *mt, int i, struct ipcp_lattice *cval)
 {
-  IPA_NODE_REF (mt)->ipcp_cval[i].cval_type = cval->cval_type;
+  IPA_NODE_REF (mt)->ipcp_lattices[i].type = cval->type;
   ipcp_cval_set_cvalue (ipcp_method_cval (mt, i),
-			ipcp_cval_get_cvalue (cval), cval->cval_type);
+			ipcp_cval_get_cvalue (cval), cval->type);
 }
 
 /* Set type of cval structure of formal I of MT to CVAL_TYPE1.  */
 static inline void
 ipcp_method_cval_set_cvalue_type (struct cgraph_node *mt, int i,
-				  enum cvalue_type cval_type1)
+				  enum ipa_lattice_type type)
 {
-  IPA_NODE_REF (mt)->ipcp_cval[i].cval_type = cval_type1;
+  IPA_NODE_REF (mt)->ipcp_lattices[i].type = type;
+}
+
+/* Set type of cval structure of formal I of MT to CVAL_TYPE1.  */
+static inline void
+ipcp_method_cval_set_lattice_type (struct cgraph_node *mt, int i,
+				   enum ipa_lattice_type type)
+{
+  IPA_NODE_REF (mt)->ipcp_lattices[i].type = type;
 }
 
 /* Print ipcp_cval data structures to F.  */
@@ -385,22 +394,22 @@ ipcp_method_cval_print (FILE * f)
   for (node = cgraph_nodes; node; node = node->next)
     {
       fprintf (f, "Printing cvals %s:\n", cgraph_node_name (node));
-      count = ipa_method_formal_count (node);
+      count = IPA_NODE_REF (node)->param_count;
       for (i = 0; i < count; i++)
 	{
 	  if (ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i))
-	      == CONST_VALUE
+	      == IPA_CONST_VALUE
 	      || ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i)) ==
-	      CONST_VALUE_REF)
+	      IPA_CONST_VALUE_REF)
 	    {
 	      fprintf (f, " param [%d]: ", i);
 	      fprintf (f, "type is CONST ");
 	      cvalue =
-		ipcp_cval_get_cvalue (ipcp_method_cval (node, i))->value;
+		ipcp_cval_get_cvalue (ipcp_method_cval (node, i));
 	      print_generic_expr (f, cvalue, 0);
 	      fprintf (f, "\n");
 	    }
-	  else if (ipcp_method_cval (node, i)->cval_type == TOP)
+	  else if (ipcp_method_cval (node, i)->type == IPA_TOP)
 	    fprintf (f, "param [%d]: type is TOP  \n", i);
 	  else
 	    fprintf (f, "param [%d]: type is BOTTOM  \n", i);
@@ -408,12 +417,12 @@ ipcp_method_cval_print (FILE * f)
     }
 }
 
-/* Initialize ipcp_cval array of MT with TOP values.
-   All cvals for a method's formal parameters are initialized to BOTTOM
+/* Initialize ipcp_cval array of MT with IPA_TOP values.
+   All cvals for a method's formal parameters are initialized to IPA_BOTTOM
    The currently supported types are integer types, real types and
    Fortran constants (i.e. references to constants defined as
    const_decls). All other types are not analyzed and therefore are
-   assigned with BOTTOM.  */
+   assigned with IPA_BOTTOM.  */
 static void
 ipcp_method_cval_init (struct cgraph_node *mt)
 {
@@ -421,15 +430,15 @@ ipcp_method_cval_init (struct cgraph_nod
   tree parm_tree;
 
   ipcp_formal_create (mt);
-  for (i = 0; i < ipa_method_formal_count (mt); i++)
+  for (i = 0; i < IPA_NODE_REF (mt)->param_count ; i++)
     {
-      parm_tree = ipa_method_get_tree (mt, i);
+      parm_tree = IPA_NODE_REF (mt)->param_decls[i];
       if (INTEGRAL_TYPE_P (TREE_TYPE (parm_tree))
 	  || SCALAR_FLOAT_TYPE_P (TREE_TYPE (parm_tree))
 	  || POINTER_TYPE_P (TREE_TYPE (parm_tree)))
-	ipcp_method_cval_set_cvalue_type (mt, i, TOP);
+	ipcp_method_cval_set_cvalue_type (mt, i, IPA_TOP);
       else
-	ipcp_method_cval_set_cvalue_type (mt, i, BOTTOM);
+	ipcp_method_cval_set_cvalue_type (mt, i, IPA_BOTTOM);
     }
 }
 
@@ -456,13 +465,12 @@ constant_val_insert (tree parm1, tree va
 /* build INTEGER_CST tree with type TREE_TYPE and 
    value according to CVALUE. Return the tree.   */
 static tree
-build_const_val (union parameter_info *cvalue, enum cvalue_type type,
-		 tree tree_type)
+build_const_val (tree cvalue, enum ipa_lattice_type type, tree tree_type)
 {
   tree const_val = NULL;
 
   gcc_assert (ipcp_type_is_const (type));
-  const_val = fold_convert (tree_type, cvalue->value);
+  const_val = fold_convert (tree_type, cvalue);
   return const_val;
 }
 
@@ -470,14 +478,14 @@ build_const_val (union parameter_info *c
    constant_val_insert().  */
 static void
 ipcp_propagate_const (struct cgraph_node *mt, int param,
-		      union parameter_info *cvalue, enum cvalue_type type)
+		      tree cvalue, enum ipa_lattice_type type)
 {
   tree const_val;
   tree parm_tree;
 
   if (dump_file)
     fprintf (dump_file, "propagating const to %s\n", cgraph_node_name (mt));
-  parm_tree = ipa_method_get_tree (mt, param);
+  parm_tree = IPA_NODE_REF (mt)->param_decls[param];
   const_val = build_const_val (cvalue, type, TREE_TYPE (parm_tree));
   constant_val_insert (parm_tree, const_val);
 }
@@ -514,10 +522,10 @@ ipcp_init_stage (void)
 
   for (node = cgraph_nodes; node; node = node->next)
     {
-      ipa_method_formal_compute_count (node);
-      ipa_method_compute_tree_map (node);
+      ipa_count_formal_params (node);
+      ipa_create_param_decls_array (node);
       ipcp_method_cval_init (node);
-      ipa_method_compute_modify (node);
+      ipa_detect_param_modifications (node);
       ipcp_method_compute_scale (node);
     }
   for (node = cgraph_nodes; node; node = node->next)
@@ -525,23 +533,23 @@ ipcp_init_stage (void)
       /* building jump functions  */
       for (cs = node->callees; cs; cs = cs->next_callee)
 	{
-	  ipa_callsite_compute_count (cs);
-	  if (ipa_callsite_param_count (cs)
-	      != ipa_method_formal_count (cs->callee))
+	  ipa_count_arguments (cs);
+	  if (IPA_EDGE_REF (cs)->argument_count
+	      != IPA_NODE_REF (cs->callee)->param_count)
 	    {
 	      /* Handle cases of functions with 
 	         a variable number of parameters.  */
-	      ipa_callsite_param_count_set (cs, 0);
-	      ipa_method_formal_count_set (cs->callee, 0);
+	      IPA_EDGE_REF (cs)->argument_count = 0;
+	      IPA_NODE_REF (cs->callee)->param_count = 0;
 	    }
 	  else
-	    ipa_callsite_compute_param (cs);
+	    ipa_compute_jump_functions (cs);
 	}
     }
 }
 
-/* Return true if there are some formal parameters whose value is TOP.
-   Change their values to BOTTOM, since they weren't determined.  */
+/* Return true if there are some formal parameters whose value is IPA_TOP.
+   Change their values to IPA_BOTTOM, since they weren't determined.  */
 static bool
 ipcp_after_propagate (void)
 {
@@ -552,12 +560,12 @@ ipcp_after_propagate (void)
   prop_again = false;
   for (node = cgraph_nodes; node; node = node->next)
     {
-      count = ipa_method_formal_count (node);
+      count = IPA_NODE_REF (node)->param_count;
       for (i = 0; i < count; i++)
-	if (ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i)) == TOP)
+	if (ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i)) == IPA_TOP)
 	  {
 	    prop_again = true;
-	    ipcp_method_cval_set_cvalue_type (node, i, BOTTOM);
+	    ipcp_method_cval_set_cvalue_type (node, i, IPA_BOTTOM);
 	  }
     }
   return prop_again;
@@ -569,37 +577,37 @@ static void
 ipcp_propagate_stage (void)
 {
   int i;
-  struct ipcp_formal cval1 = { BOTTOM, {0} }, cval = { BOTTOM, {0} };
-  struct ipcp_formal *cval2;
+  struct ipcp_lattice cval1 = { IPA_BOTTOM, NULL }, cval = { IPA_BOTTOM, NULL };
+  struct ipcp_lattice *cval2;
   struct cgraph_node *mt, *callee;
   struct cgraph_edge *cs;
   struct ipa_jump_func *jump_func;
   enum jump_func_type type;
-  union parameter_info *info_type;
-  ipa_methodlist_p wl;
+  union jump_func_value *jf_value;
+  struct ipa_func_list *wl;
   int count;
 
-  /* Initialize worklist to contain all methods.  */
-  wl = ipa_methodlist_init ();
-  while (ipa_methodlist_not_empty (wl))
+  /* Initialize worklist to contain all functions.  */
+  wl = ipa_init_func_list ();
+  while (wl)
     {
-      mt = ipa_remove_method (&wl);
+      mt = ipa_pop_func_from_list (&wl);
       for (cs = mt->callees; cs; cs = cs->next_callee)
 	{
-	  callee = ipa_callsite_callee (cs);
-	  count = ipa_callsite_param_count (cs);
+	  callee = cs->callee;
+	  count = IPA_EDGE_REF (cs)->argument_count;
 	  for (i = 0; i < count; i++)
 	    {
-	      jump_func = ipa_callsite_param (cs, i);
-	      type = get_type (jump_func);
-	      info_type = ipa_jf_get_info_type (jump_func);
-	      ipcp_cval_compute (&cval1, mt, type, info_type);
+	      jump_func = &IPA_EDGE_REF (cs)->jump_functions[i];
+	      type = jump_func->type;
+	      jf_value = &jump_func->value;
+	      ipcp_cval_compute (&cval1, mt, type, jf_value);
 	      cval2 = ipcp_method_cval (callee, i);
 	      ipcp_cval_meet (&cval, &cval1, cval2);
 	      if (ipcp_cval_changed (&cval, cval2))
 		{
 		  ipcp_method_cval_set (callee, i, &cval);
-		  ipa_add_method (&wl, callee);
+		  ipa_push_func_to_list (&wl, callee);
 		}
 	    }
 	}
@@ -613,7 +621,7 @@ ipcp_iterate_stage (void)
 {
   ipcp_propagate_stage ();
   if (ipcp_after_propagate ())
-    /* Some cvals have changed from TOP to BOTTOM.  
+    /* Some cvals have changed from IPA_TOP to IPA_BOTTOM.
        This change should be propagated.  */
     ipcp_propagate_stage ();
 }
@@ -646,27 +654,26 @@ ipcp_callsite_param_print (FILE * f)
 	{
 	  fprintf (f, "callsite  %s ", cgraph_node_name (node));
 	  fprintf (f, "-> %s :: \n", cgraph_node_name (cs->callee));
-	  count = ipa_callsite_param_count (cs);
+	  count = IPA_EDGE_REF (cs)->argument_count;
 	  for (i = 0; i < count; i++)
 	    {
-	      jump_func = ipa_callsite_param (cs, i);
-	      type = get_type (jump_func);
+	      jump_func = &IPA_EDGE_REF (cs)->jump_functions[i];
+	      type = jump_func->type;
 
 	      fprintf (f, " param %d: ", i);
-	      if (type == UNKNOWN_IPATYPE)
+	      if (type == IPA_UNKNOWN)
 		fprintf (f, "UNKNOWN\n");
-	      else if (type == CONST_IPATYPE || type == CONST_IPATYPE_REF)
+	      else if (type == IPA_CONST || type == IPA_CONST_REF)
 		{
-		  info_type = ipa_jf_get_info_type (jump_func)->value;
+		  info_type = jump_func->value.constant;
 		  fprintf (f, "CONST : ");
 		  print_generic_expr (f, info_type, 0);
 		  fprintf (f, "\n");
 		}
-	      else if (type == FORMAL_IPATYPE)
+	      else if (type == IPA_PASS_THROUGH)
 		{
-		  fprintf (f, "FORMAL : ");
-		  fprintf (f, "%d\n",
-			   ipa_jf_get_info_type (jump_func)->formal_id);
+		  fprintf (f, "PASS THROUGH : ");
+		  fprintf (f, "%d\n", jump_func->value.formal_id);
 		}
 	    }
 	}
@@ -818,8 +825,8 @@ ipcp_structures_print (FILE * f)
 {
   ipcp_method_cval_print (f);
   ipcp_method_scale_print (f);
-  ipa_method_tree_print (f);
-  ipa_method_modify_print (f);
+  ipa_print_all_tree_maps (f);
+  ipa_print_all_params_modified (f);
   ipcp_callsite_param_print (f);
 }
 
@@ -842,15 +849,15 @@ ipcp_profile_print (FILE * f)
    operates according to the flags sent.  PARM_TREE is the 
    formal's tree found to be constant.  CVALUE represents the constant.  */
 static struct ipa_replace_map *
-ipcp_replace_map_create (struct function *func, enum cvalue_type type,
-			 tree parm_tree, union parameter_info *cvalue)
+ipcp_replace_map_create (struct function *func, enum ipa_lattice_type type,
+			 tree parm_tree, tree cvalue)
 {
   struct ipa_replace_map *replace_map;
   tree const_val;
 
   replace_map = XCNEW (struct ipa_replace_map);
   gcc_assert (ipcp_type_is_const (type));
-  if (type != CONST_VALUE_REF
+  if (type != IPA_CONST_VALUE_REF
       && is_gimple_reg (parm_tree) && gimple_default_def (func, parm_tree)
 	&& !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_default_def (func, parm_tree)))
     {
@@ -882,21 +889,21 @@ ipcp_redirect (struct cgraph_edge *cs)
   int i, count;
   struct ipa_jump_func *jump_func;
   enum jump_func_type type;
-  enum cvalue_type cval_type;
+  enum ipa_lattice_type lattice_type;
 
   caller = cs->caller;
   callee = cs->callee;
   orig_callee = ipcp_method_orig_node (callee);
-  count = ipa_method_formal_count (orig_callee);
+  count = IPA_NODE_REF (orig_callee)->param_count;
   for (i = 0; i < count; i++)
     {
-      cval_type =
+      lattice_type =
 	ipcp_cval_get_cvalue_type (ipcp_method_cval (orig_callee, i));
-      if (ipcp_type_is_const (cval_type))
+      if (ipcp_type_is_const (lattice_type))
 	{
-	  jump_func = ipa_callsite_param (cs, i);
-	  type = get_type (jump_func);
-	  if (type != CONST_IPATYPE && type != CONST_IPATYPE_REF)
+	  jump_func = &IPA_EDGE_REF (cs)->jump_functions[i];
+	  type = jump_func->type;
+	  if (type != IPA_CONST && type != IPA_CONST_REF)
 	    return true;
 	}
     }
@@ -993,13 +1000,13 @@ ipcp_insert_stage (void)
 {
   struct cgraph_node *node, *node1 = NULL;
   int i, const_param;
-  union parameter_info *cvalue;
+  tree cvalue;
   VEC (cgraph_edge_p, heap) * redirect_callers;
   varray_type replace_trees;
   struct cgraph_edge *cs;
   int node_callers, count;
   tree parm_tree;
-  enum cvalue_type type;
+  enum ipa_lattice_type type;
   struct ipa_replace_map *replace_param;
 
   for (node = cgraph_nodes; node; node = node->next)
@@ -1009,7 +1016,7 @@ ipcp_insert_stage (void)
       if (!node->analyzed || ipcp_method_dont_insert_const (node))
 	continue;
       const_param = 0;
-      count = ipa_method_formal_count (node);
+      count = IPA_NODE_REF (node)->param_count;
       for (i = 0; i < count; i++)
 	{
 	  type = ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i));
@@ -1025,7 +1032,7 @@ ipcp_insert_stage (void)
 	  if (ipcp_type_is_const (type))
 	    {
 	      cvalue = ipcp_cval_get_cvalue (ipcp_method_cval (node, i));
-	      parm_tree = ipa_method_get_tree (node, i);
+	      parm_tree = IPA_NODE_REF (node)->param_decls[i];
 	      replace_param =
 		ipcp_replace_map_create (DECL_STRUCT_FUNCTION (node->decl),
 					 type, parm_tree, cvalue);
@@ -1063,8 +1070,8 @@ ipcp_insert_stage (void)
 	      if (ipcp_type_is_const (type))
 		{
 		  cvalue = ipcp_cval_get_cvalue (ipcp_method_cval (node, i));
-		  parm_tree = ipa_method_get_tree (node, i);
-		  if (type != CONST_VALUE_REF && !is_gimple_reg (parm_tree))
+		  parm_tree = IPA_NODE_REF (node)->param_decls[i];
+		  if (type != IPA_CONST_VALUE_REF && !is_gimple_reg (parm_tree))
 		    ipcp_propagate_const (node1, i, cvalue, type);
 		}
 	    }
@@ -1093,10 +1100,10 @@ ipcp_driver (void)
 {
   if (dump_file)
     fprintf (dump_file, "\nIPA constant propagation start:\n");
-  ipa_nodes_create ();
-  ipa_edges_create ();
+  ipa_create_all_node_params ();
+  ipa_create_all_edge_args ();
   /* 1. Call the init stage to initialize 
-     the ipa_node and ipa_edge structures.  */
+     the ipa_node_params and ipa_edge structures.  */
   ipcp_init_stage ();
   if (dump_file)
     {
@@ -1120,9 +1127,8 @@ ipcp_driver (void)
       ipcp_profile_print (dump_file);
     }
   /* Free all IPCP structures.  */
-  ipa_free ();
-  ipa_nodes_free ();
-  ipa_edges_free ();
+  ipa_free_all_node_params ();
+  ipa_free_all_edge_args ();
   if (dump_file)
     fprintf (dump_file, "\nIPA constant propagation end\n");
   cgraph_remove_unreachable_nodes (true, NULL);
Index: iinln/gcc/ipa-prop.c
===================================================================
--- iinln.orig/gcc/ipa-prop.c
+++ iinln/gcc/ipa-prop.c
@@ -31,197 +31,88 @@ along with GCC; see the file COPYING3.  
 #include "flags.h"
 #include "timevar.h"
 
-/* This file contains interfaces that can be used for various IPA 
-   optimizations:
-
-   - ipa_methodlist interface - It is used to create and handle a temporary 
-   worklist used in  the propagation stage of IPCP. (can be used for more 
-   IPA optimizations).  
-
-   - ipa_callsite interface - for each callsite this interface creates and 
-   handles ipa_edge structure associated with it.
-
-   - ipa_method interface - for each method this interface creates and 
-   handles ipa_node structure associated with it.  */
-
-/* ipa_methodlist interface.  */
-
-/* Create a new worklist node.  */
-static inline ipa_methodlist_p
-ipa_create_methodlist_node (void)
-{
-  return (ipa_methodlist_p) xcalloc (1, sizeof (struct ipa_methodlist));
-}
-
-/* Return true if worklist WL is empty.  */
-bool
-ipa_methodlist_not_empty (ipa_methodlist_p wl)
-{
-  return (wl != NULL);
-}
-
-/* Return the method in worklist element WL.  */
-static inline struct cgraph_node *
-ipa_methodlist_method (ipa_methodlist_p wl)
-{
-  return wl->method_p;
-}
-
-/* Make worklist element WL point to method MT in the callgraph.  */
-static inline void
-ipa_methodlist_method_set (ipa_methodlist_p wl, struct cgraph_node *mt)
-{
-  wl->method_p = mt;
-}
-
-/* Return the next element in the worklist following worklist 
-   element WL.  */
-static inline ipa_methodlist_p
-ipa_methodlist_next_method (ipa_methodlist_p wl)
-{
-  return wl->next_method;
-}
-
-/* Set worklist element WL1 to point to worklist element WL2.  */
-static inline void
-ipa_methodlist_next_method_set (ipa_methodlist_p wl1, ipa_methodlist_p wl2)
-{
-  wl1->next_method = wl2;
-}
-
-/* Initialize worklist to contain all methods.  */
-ipa_methodlist_p
-ipa_methodlist_init (void)
+/* Initialize worklist to contain all functions.  */
+struct ipa_func_list *
+ipa_init_func_list (void)
 {
   struct cgraph_node *node;
-  ipa_methodlist_p wl;
+  struct ipa_func_list * wl;
 
   wl = NULL;
   for (node = cgraph_nodes; node; node = node->next)
-    ipa_add_method (&wl, node);
+    ipa_push_func_to_list (&wl, node);
 
   return wl;
 }
 
-/* Add method MT to the worklist. Set worklist element WL  
+/* Add cgraph node MT to the worklist. Set worklist element WL
    to point to MT.  */
 void
-ipa_add_method (ipa_methodlist_p * wl, struct cgraph_node *mt)
+ipa_push_func_to_list (struct ipa_func_list **wl, struct cgraph_node *mt)
 {
-  ipa_methodlist_p temp;
+  struct ipa_func_list *temp;
 
-  temp = ipa_create_methodlist_node ();
-  ipa_methodlist_method_set (temp, mt);
-  ipa_methodlist_next_method_set (temp, *wl);
+  temp = xcalloc (1, sizeof (struct ipa_func_list));
+  temp->node = mt;
+  temp->next = *wl;
   *wl = temp;
 }
 
-/* Remove a method from the worklist. WL points to the first 
+/* Remove a function from the worklist. WL points to the first
    element in the list, which is removed.  */
 struct cgraph_node *
-ipa_remove_method (ipa_methodlist_p * wl)
+ipa_pop_func_from_list (struct ipa_func_list ** wl)
 {
-  ipa_methodlist_p first;
-  struct cgraph_node *return_method;
+  struct ipa_func_list *first;
+  struct cgraph_node *return_func;
 
   first = *wl;
-  *wl = ipa_methodlist_next_method (*wl);
-  return_method = ipa_methodlist_method (first);
+  *wl = (*wl)->next;
+  return_func = first->node;
   free (first);
-  return return_method;
-}
-
-/* ipa_method interface.  */
-
-/* Return number of formals of method MT.  */
-int
-ipa_method_formal_count (struct cgraph_node *mt)
-{
-  return IPA_NODE_REF (mt)->ipa_arg_num;
-}
-
-/* Set number of formals of method MT to I.  */
-void
-ipa_method_formal_count_set (struct cgraph_node *mt, int i)
-{
-  IPA_NODE_REF (mt)->ipa_arg_num = i;
-}
-
-/* Return whether I-th formal of MT is modified in MT.  */
-static inline bool
-ipa_method_is_modified (struct cgraph_node *mt, int i)
-{
-  return IPA_NODE_REF (mt)->ipa_mod[i];
-}
-
-/* Return the tree of I-th formal of MT.  */
-tree
-ipa_method_get_tree (struct cgraph_node *mt, int i)
-{
-  return IPA_NODE_REF (mt)->ipa_param_tree[i];
+  return return_func;
 }
 
-/* Create tree map structure for MT.  */
-static inline void
-ipa_method_tree_map_create (struct cgraph_node *mt)
-{
-  IPA_NODE_REF (mt)->ipa_param_tree =
-    XCNEWVEC (tree, ipa_method_formal_count (mt));
-}
-
-/* Create modify structure for MT.  */
-static inline void
-ipa_method_modify_create (struct cgraph_node *mt)
-{
-  ((struct ipa_node *) mt->aux)->ipa_mod =
-    XCNEWVEC (bool, ipa_method_formal_count (mt));
-}
-
-/* Set modify of I-th formal of MT to VAL.  */
-static inline void
-ipa_method_modify_set (struct cgraph_node *mt, int i, bool val)
-{
-  IPA_NODE_REF (mt)->ipa_mod[i] = val;
-}
-
-/* Return index of the formal whose tree is PTREE in method MT.  */
+/* Return index of the formal whose tree is ptree in function which corresponds
+   to info.  */
 static int
-ipa_method_tree_map (struct cgraph_node *mt, tree ptree)
+ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree)
 {
   int i, count;
 
-  count = ipa_method_formal_count (mt);
+  count = info->param_count;
   for (i = 0; i < count; i++)
-    if (IPA_NODE_REF (mt)->ipa_param_tree[i] == ptree)
+    if (info->param_decls[i] == ptree)
       return i;
 
   return -1;
 }
 
-/* Insert the formal trees to the ipa_param_tree array in method MT.  */
+/* Insert the formal trees to the param_decls array in function MT.  */
 void
-ipa_method_compute_tree_map (struct cgraph_node *mt)
+ipa_create_param_decls_array (struct cgraph_node *mt)
 {
   tree fndecl;
   tree fnargs;
   tree parm;
   int param_num;
+  struct ipa_node_params *info = IPA_NODE_REF (mt);
 
-  ipa_method_tree_map_create (mt);
+  info->param_decls = XCNEWVEC (tree, info->param_count);
   fndecl = mt->decl;
   fnargs = DECL_ARGUMENTS (fndecl);
   param_num = 0;
   for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
     {
-      IPA_NODE_REF (mt)->ipa_param_tree[param_num] = parm;
+      info->param_decls[param_num] = parm;
       param_num++;
     }
 }
 
 /* Count number of formals in MT. Insert the result to the 
-   ipa_node.  */
+   ipa_node_params.  */
 void
-ipa_method_formal_compute_count (struct cgraph_node *mt)
+ipa_count_formal_params (struct cgraph_node *mt)
 {
   tree fndecl;
   tree fnargs;
@@ -233,57 +124,48 @@ ipa_method_formal_compute_count (struct 
   param_num = 0;
   for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
     param_num++;
-  ipa_method_formal_count_set (mt, param_num);
+  IPA_NODE_REF (mt)->param_count = param_num;
 }
 
-/* Check STMT to detect whether a formal is modified within MT,
-   the appropriate entry is updated in the ipa_mod array of ipa_node
-   (associated with MT).  */
+/* 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).  */
 static void
-ipa_method_modify_stmt (struct cgraph_node *mt, tree stmt)
+ipa_check_stmt_modifications (struct cgraph_node *mt, tree stmt)
 {
-  int i, j;
+  int index, j;
   tree parm_decl;
+  struct ipa_node_params *info;
 
   switch (TREE_CODE (stmt))
     {
     case GIMPLE_MODIFY_STMT:
 	  if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == PARM_DECL)
 	{
+	  info = IPA_NODE_REF (mt);
 	  parm_decl = GIMPLE_STMT_OPERAND (stmt, 0);
-	  i = ipa_method_tree_map (mt, parm_decl);
-	  if (i >= 0)
-	    ipa_method_modify_set (mt, i, true);
+	  index = ipa_get_param_decl_index (info, parm_decl);
+	  if (index >= 0)
+	    info->modified_flags[index] = true;
 	}
       break;
     case ASM_EXPR:
       /* Asm code could modify any of the parameters.  */
-      for (j = 0; j < ipa_method_formal_count (mt); j++)
-	ipa_method_modify_set (mt, j, true);
+      info = IPA_NODE_REF (mt);
+      for (j = 0; j < IPA_NODE_REF (mt)->param_count; j++)
+	info->modified_flags[j] = true;
       break;
     default:
       break;
     }
 }
 
-/* Initialize ipa_mod array of MT.  */
-static void
-ipa_method_modify_init (struct cgraph_node *mt)
-{
-  int i, count;
-
-  ipa_method_modify_create (mt);
-  count = ipa_method_formal_count (mt);
-  for (i = 0; i < count; i++)
-    ipa_method_modify_set (mt, i, false);
-}
-
 /* The modify computation driver for MT. Compute which formal arguments 
-   of method MT are locally modified.  Formals may be modified in MT 
+   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_method_compute_modify (struct cgraph_node *mt)
+ipa_detect_param_modifications (struct cgraph_node *mt)
 {
   tree decl;
   tree body;
@@ -292,29 +174,31 @@ ipa_method_compute_modify (struct cgraph
   struct function *func;
   block_stmt_iterator bsi;
   tree stmt, parm_tree;
+  struct ipa_node_params *info = IPA_NODE_REF (mt);
 
-  if (ipa_method_formal_count (mt) == 0)
+  if (info->param_count == 0)
     return;
 
-  ipa_method_modify_init (mt);
+  info->modified_flags = XCNEWVEC (bool, info->param_count);
   decl = mt->decl;
-  count = ipa_method_formal_count (mt);
+  count = info->param_count;
   /* ??? Handle pending sizes case. Set all parameters 
-     of the method to be modified.  */
+     of the function to be modified.  */
 
   if (DECL_UNINLINABLE (decl))
     {
       for (j = 0; j < count; j++)
-	ipa_method_modify_set (mt, j, true);
+	info->modified_flags[j] = true;
+
       return;
     }
   /* Formals whose address is taken are considered modified.  */
   for (j = 0; j < count; j++)
     {
-      parm_tree = ipa_method_get_tree (mt, j);
+      parm_tree = info->param_decls[j];
       if (!is_gimple_reg (parm_tree) 
 	  && TREE_ADDRESSABLE (parm_tree))
-	ipa_method_modify_set (mt, j, true);
+	info->modified_flags[j] = true;
     }
   body = DECL_SAVED_TREE (decl);
   if (body != NULL)
@@ -325,171 +209,93 @@ ipa_method_compute_modify (struct cgraph
 	for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
 	  {
 	    stmt = bsi_stmt (bsi);
-	    ipa_method_modify_stmt (mt, stmt);
+	    ipa_check_stmt_modifications (mt, stmt);
 	  }
       }
     }
 }
 
-
-/* ipa_callsite interface.  */
-
-/* Return number of arguments in callsite CS.  */
-int
-ipa_callsite_param_count (struct cgraph_edge *cs)
-{
-  return IPA_EDGE_REF (cs)->ipa_param_num;
-}
-
-/* Set number of arguments in callsite CS to I.  */
-void
-ipa_callsite_param_count_set (struct cgraph_edge *cs, int i)
-{
-  IPA_EDGE_REF (cs)->ipa_param_num = i;
-}
-
-/* Return the jump function (ipa_jump_func struct) for argument I of 
-   callsite CS.  */
-struct ipa_jump_func *
-ipa_callsite_param (struct cgraph_edge *cs, int i)
-{
-  return &(IPA_EDGE_REF (cs)->ipa_param_map[i]);
-}
-
-/* return the callee (cgraph_node) of callsite CS.  */
-struct cgraph_node *
-ipa_callsite_callee (struct cgraph_edge *cs)
-{
-  return cs->callee;
-}
-
-/* Set field 'type' of jump function (ipa_jump_func struct) of argument I 
-   in callsite CS.  */
-static inline void
-ipa_callsite_param_set_type (struct cgraph_edge *cs, int i,
-			     enum jump_func_type type1)
-{
-  IPA_EDGE_REF (cs)->ipa_param_map[i].type = type1;
-}
-
-/* Set FORMAL as 'info_type' field of jump function (ipa_jump_func struct)
-   of argument I of callsite CS.  */
-static inline void
-ipa_callsite_param_set_info_type_formal (struct cgraph_edge *cs, int i,
-					 unsigned int formal)
-{
-  ipa_callsite_param (cs, i)->info_type.formal_id = formal;
-}
-
-/* Set int-valued INFO_TYPE1 as 'info_type' field of 
-   jump function (ipa_jump_func struct) of argument I of callsite CS.  */
-static inline void
-ipa_callsite_param_set_info_type (struct cgraph_edge *cs, int i,
-				  tree info_type1)
-{
-  ipa_callsite_param (cs, i)->info_type.value = info_type1;
-}
-
-/* Allocate space for callsite CS.  */
-static inline void
-ipa_callsite_param_map_create (struct cgraph_edge *cs)
-{
-  IPA_EDGE_REF (cs)->ipa_param_map =
-    XCNEWVEC (struct ipa_jump_func, ipa_callsite_param_count (cs));
-}
-
-/* Return the call expr tree related to callsite CS.  */
-static inline tree
-ipa_callsite_tree (struct cgraph_edge *cs)
-{
-  return cs->call_stmt;
-}
-
-/* Return the caller (cgraph_node) of CS.  */
-static inline struct cgraph_node *
-ipa_callsite_caller (struct cgraph_edge *cs)
-{
-  return cs->caller;
-}
-
 /* Count number of arguments callsite CS has and store it in 
-   ipa_edge structure corresponding to this callsite.  */
+   ipa_edge_args structure corresponding to this callsite.  */
 void
-ipa_callsite_compute_count (struct cgraph_edge *cs)
+ipa_count_arguments (struct cgraph_edge *cs)
 {
   tree call_tree;
   int arg_num;
 
-  call_tree = get_call_expr_in (ipa_callsite_tree (cs));
+  call_tree = get_call_expr_in (cs->call_stmt);
   gcc_assert (TREE_CODE (call_tree) == CALL_EXPR);
   arg_num = call_expr_nargs (call_tree);
-  ipa_callsite_param_count_set (cs, arg_num);
+  IPA_EDGE_REF (cs)->argument_count = arg_num;
 }
 
 /* Compute jump function for all arguments of callsite CS 
-   and insert the information in the ipa_param_map array 
-   in the ipa_edge corresponding to this callsite. (Explanation 
-   on jump functions is in ipa-prop.h).  */
+   and insert the information in the jump_functions array
+   in the ipa_edge_args corresponding to this callsite.  */
 void
-ipa_callsite_compute_param (struct cgraph_edge *cs)
+ipa_compute_jump_functions (struct cgraph_edge *cs)
 {
   tree call_tree;
   tree arg, cst_decl;
   int arg_num;
-  int i;
   struct cgraph_node *mt;
   tree parm_decl;
   struct function *curr_cfun;
   call_expr_arg_iterator iter;
+  struct ipa_edge_args *args = IPA_EDGE_REF (cs);
 
-  if (ipa_callsite_param_count (cs) == 0)
+  if (args->argument_count == 0)
     return;
-  ipa_callsite_param_map_create (cs);
-  call_tree = get_call_expr_in (ipa_callsite_tree (cs));
+  args->jump_functions = XCNEWVEC (struct ipa_jump_func, args->argument_count);
+  call_tree = get_call_expr_in (cs->call_stmt);
   gcc_assert (TREE_CODE (call_tree) == CALL_EXPR);
   arg_num = 0;
 
   FOR_EACH_CALL_EXPR_ARG (arg, iter, call_tree)
     {
       /* If the formal parameter was passed as argument, we store 
-         FORMAL_IPATYPE and its index in the caller as the jump function 
+         IPA_PASS_THROUGH and its index in the caller as the jump function
          of this argument.  */
       if ((TREE_CODE (arg) == SSA_NAME
 	   && TREE_CODE (SSA_NAME_VAR (arg)) == PARM_DECL)
 	  || TREE_CODE (arg) == PARM_DECL)
 	{
-	  mt = ipa_callsite_caller (cs);
+	  struct ipa_node_params *info;
+	  int index;
+
+	  mt = cs->caller;
+	  info = IPA_NODE_REF (mt);
 	  parm_decl = TREE_CODE (arg) == PARM_DECL ? arg : SSA_NAME_VAR (arg);
           
-	  i = ipa_method_tree_map (mt, parm_decl);
-	  if (TREE_CODE (arg) == SSA_NAME && IS_VALID_TREE_MAP_INDEX (i)) 
+	  index = ipa_get_param_decl_index (info, parm_decl);
+	  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) 
 	          || gimple_default_def (curr_cfun, parm_decl) != arg)
-		    ipa_method_modify_set (mt, i, true); 
+		info->modified_flags[index] = true;
 	    }
-	  if (!IS_VALID_TREE_MAP_INDEX (i) || ipa_method_is_modified (mt, i))
-	    ipa_callsite_param_set_type (cs, arg_num, UNKNOWN_IPATYPE);
+	  if (!IS_VALID_JUMP_FUNC_INDEX (index) || info->modified_flags[index])
+	    args->jump_functions[arg_num].type = IPA_UNKNOWN;
 	  else
 	    {
-	      ipa_callsite_param_set_type (cs, arg_num, FORMAL_IPATYPE);
-	      ipa_callsite_param_set_info_type_formal (cs, arg_num, i);
+	      args->jump_functions[arg_num].type = IPA_PASS_THROUGH;
+	      args->jump_functions[arg_num].value.formal_id = index;
 	    }
 	}
       /* If a constant value was passed as argument, 
-         we store CONST_IPATYPE and its value as the jump function 
+         we store IPA_CONST and its value as the jump function
          of this argument.  */
       else if (TREE_CODE (arg) == INTEGER_CST
 	       || TREE_CODE (arg) == REAL_CST
 	       || TREE_CODE (arg) == FIXED_CST)
 	{
-	  ipa_callsite_param_set_type (cs, arg_num, CONST_IPATYPE);
-	  ipa_callsite_param_set_info_type (cs, arg_num, arg);
+	  args->jump_functions[arg_num].type = IPA_CONST;
+	  args->jump_functions[arg_num].value.constant = arg;
 	}
       /* This is for the case of Fortran. If the address of a const_decl 
-         was passed as argument then we store 
-         CONST_IPATYPE_REF/CONST_IPATYPE_REF and the constant 
+         was passed as argument then we store
+         IPA_CONST_REF/IPA_CONST_REF and the constant
          value as the jump function corresponding to this argument.  */
       else if (TREE_CODE (arg) == ADDR_EXPR
 	       && TREE_CODE (TREE_OPERAND (arg, 0)) == CONST_DECL)
@@ -499,121 +305,90 @@ ipa_callsite_compute_param (struct cgrap
 	      || TREE_CODE (DECL_INITIAL (cst_decl)) == REAL_CST
 	      || TREE_CODE (DECL_INITIAL (cst_decl)) == FIXED_CST)
 	    {
-	      ipa_callsite_param_set_type (cs, arg_num,
-					   CONST_IPATYPE_REF);
-	      ipa_callsite_param_set_info_type (cs, arg_num,
-						DECL_INITIAL (cst_decl));
+	      args->jump_functions[arg_num].type = IPA_CONST_REF;
+	      args->jump_functions[arg_num].value.constant = cst_decl;
 	    }
 	}
       else
-	ipa_callsite_param_set_type (cs, arg_num, UNKNOWN_IPATYPE);
+	args->jump_functions[arg_num].type = IPA_UNKNOWN;
       arg_num++;
     }
 }
 
-/* Return type of jump function JF.  */
-enum jump_func_type
-get_type (struct ipa_jump_func *jf)
-{
-  return jf->type;
-}
-
-/* Return info type of jump function JF.  */
-union parameter_info *
-ipa_jf_get_info_type (struct ipa_jump_func *jf)
-{
-  return &(jf->info_type);
-}
-
-/* Allocate and initialize ipa_node structure.  
-   cgraph_node NODE points to the new allocated ipa_node.  */
+/* Allocate and initialize ipa_node_params structure for the given cgraph
+   node.  */
 void
-ipa_node_create (struct cgraph_node *node)
+ipa_create_node_params (struct cgraph_node *node)
 {
-  node->aux = xcalloc (1, sizeof (struct ipa_node));
+  node->aux = xcalloc (1, sizeof (struct ipa_node_params));
 }
 
-/* Allocate and initialize ipa_node structure for all
+/* Allocate and initialize ipa_node_params structure for all
    nodes in callgraph.  */
 void
-ipa_nodes_create (void)
+ipa_create_all_node_params (void)
 {
   struct cgraph_node *node;
 
   for (node = cgraph_nodes; node; node = node->next)
-    ipa_node_create (node);
+    ipa_create_node_params (node);
 }
 
 /* Allocate and initialize ipa_edge structure.  */
 void
-ipa_edges_create (void)
+ipa_create_all_edge_args (void)
 {
   struct cgraph_node *node;
   struct cgraph_edge *cs;
 
   for (node = cgraph_nodes; node; node = node->next)
     for (cs = node->callees; cs; cs = cs->next_callee)
-      cs->aux = xcalloc (1, sizeof (struct ipa_edge));
-}
-
-/* Free ipa_node structure.  */
-void
-ipa_nodes_free (void)
-{
-  struct cgraph_node *node;
-
-  for (node = cgraph_nodes; node; node = node->next)
-    {
-      free (node->aux);
-      node->aux = NULL;
-    }
+      cs->aux = xcalloc (1, sizeof (struct ipa_edge_args));
 }
 
 /* Free ipa_edge structure.  */
 void
-ipa_edges_free (void)
+ipa_free_all_edge_args (void)
 {
   struct cgraph_node *node;
   struct cgraph_edge *cs;
 
   for (node = cgraph_nodes; node; node = node->next)
     for (cs = node->callees; cs; cs = cs->next_callee)
-      {
-	free (cs->aux);
-	cs->aux = NULL;
-      }
+      if (cs->aux)
+	{
+	  if (IPA_EDGE_REF (cs)->jump_functions)
+	    free (IPA_EDGE_REF (cs)->jump_functions);
+	  free (cs->aux);
+	  cs->aux = NULL;
+	}
 }
 
-/* Free ipa data structures of ipa_node and ipa_edge.  */
+/* Free ipa data structures of ipa_node_params and ipa_edge_args.  */
 void
-ipa_free (void)
+ipa_free_all_node_params (void)
 {
   struct cgraph_node *node;
-  struct cgraph_edge *cs;
 
   for (node = cgraph_nodes; node; node = node->next)
     {
       if (node->aux == NULL)
 	continue;
-      if (IPA_NODE_REF (node)->ipcp_cval)
-	free (IPA_NODE_REF (node)->ipcp_cval);
-      if (IPA_NODE_REF (node)->ipa_param_tree)
-	free (IPA_NODE_REF (node)->ipa_param_tree);
-      if (IPA_NODE_REF (node)->ipa_mod)
-	free (IPA_NODE_REF (node)->ipa_mod);
-      for (cs = node->callees; cs; cs = cs->next_callee)
-	{
-	  if (cs->aux)
-	    if (IPA_EDGE_REF (cs)->ipa_param_map)
-	      free (IPA_EDGE_REF (cs)->ipa_param_map);
-	}
+      if (IPA_NODE_REF (node)->ipcp_lattices)
+	free (IPA_NODE_REF (node)->ipcp_lattices);
+      if (IPA_NODE_REF (node)->param_decls)
+	free (IPA_NODE_REF (node)->param_decls);
+      if (IPA_NODE_REF (node)->modified_flags)
+	free (IPA_NODE_REF (node)->modified_flags);
+      free (node->aux);
+      node->aux = NULL;
     }
 }
 
-/* Print ipa_tree_map data structures of all methods in the 
+/* Print ipa_tree_map data structures of all functions in the
    callgraph to F.  */
 void
-ipa_method_tree_print (FILE * f)
+ipa_print_all_tree_maps (FILE * f)
 {
   int i, count;
   tree temp;
@@ -622,11 +397,11 @@ ipa_method_tree_print (FILE * f)
   fprintf (f, "\nPARAM TREE MAP PRINT\n");
   for (node = cgraph_nodes; node; node = node->next)
     {
-      fprintf (f, "method  %s Trees :: \n", cgraph_node_name (node));
-      count = ipa_method_formal_count (node);
+      fprintf (f, "function  %s Trees :: \n", cgraph_node_name (node));
+      count = IPA_NODE_REF (node)->param_count;
       for (i = 0; i < count; i++)
 	{
-	  temp = ipa_method_get_tree (node, i);
+	  temp = IPA_NODE_REF (node)->param_decls[i];
 	  if (TREE_CODE (temp) == PARM_DECL)
 	    fprintf (f, "  param [%d] : %s\n", i,
 		     (*lang_hooks.decl_printable_name) (temp, 2));
@@ -635,10 +410,10 @@ ipa_method_tree_print (FILE * f)
     }
 }
 
-/* Print ipa_modify data structures of all methods in the 
+/* Print modified_flags data structures of all functions in the
    callgraph to F.  */
 void
-ipa_method_modify_print (FILE * f)
+ipa_print_all_params_modified (FILE * f)
 {
   int i, count;
   bool temp;
@@ -647,11 +422,12 @@ ipa_method_modify_print (FILE * f)
   fprintf (f, "\nMODIFY PRINT\n");
   for (node = cgraph_nodes; node; node = node->next)
     {
-      fprintf (f, "method  %s :: \n", cgraph_node_name (node));
-      count = ipa_method_formal_count (node);
+      struct ipa_node_params *info = IPA_NODE_REF (node);
+      fprintf (f, "function  %s :: \n", cgraph_node_name (node));
+      count = info->param_count;
       for (i = 0; i < count; i++)
 	{
-	  temp = ipa_method_is_modified (node, i);
+	  temp = info->modified_flags[i];
 	  if (temp)
 	    fprintf (f, " param [%d] true \n", i);
 	  else
@@ -659,3 +435,4 @@ ipa_method_modify_print (FILE * f)
 	}
     }
 }
+
Index: iinln/gcc/ipa-prop.h
===================================================================
--- iinln.orig/gcc/ipa-prop.h
+++ iinln/gcc/ipa-prop.h
@@ -30,43 +30,42 @@ along with GCC; see the file COPYING3.  
    Formal - the caller's formal parameter is passed as an actual argument.
    Constant - a constant is passed as an actual argument.
    Unknown - neither of the above.
-   Integer and real constants are represented as CONST_IPATYPE and Fortran 
-   constants are represented as CONST_IPATYPE_REF.  */
+   Integer and real constants are represented as IPA_CONST and Fortran
+   constants are represented as IPA_CONST_REF.  */
 enum jump_func_type
 {
-  UNKNOWN_IPATYPE,
-  CONST_IPATYPE,
-  CONST_IPATYPE_REF,
-  FORMAL_IPATYPE
+  IPA_UNKNOWN,
+  IPA_CONST,
+  IPA_CONST_REF,
+  IPA_PASS_THROUGH
 };
 
-/* All formal parameters in the program have a cval computed by 
-   the interprocedural stage of IPCP.  
-   There are three main values of cval :
+/* All formal parameters in the program have a lattice associated with it
+   computed by the interprocedural stage of IPCP.
+   There are three main values of the lattice:
    TOP - unknown.
    BOTTOM - non constant.
    CONSTANT_TYPE - constant value.
    Cval of formal f will have a constant value if all callsites to this
    function have the same constant value passed to f.
-   Integer and real constants are represented as CONST_IPATYPE and Fortran
-   constants are represented as CONST_IPATYPE_REF.  */
-enum cvalue_type
+   Integer and real constants are represented as IPA_CONST and Fortran
+   constants are represented as IPA_CONST_REF.  */
+enum ipa_lattice_type
 {
-  BOTTOM,
-  CONST_VALUE,
-  CONST_VALUE_REF,
-  TOP
+  IPA_BOTTOM,
+  IPA_CONST_VALUE,
+  IPA_CONST_VALUE_REF,
+  IPA_TOP
 };
 
-/* Represents the value of either jump function or cval.
+/* Represents a value of a jump function.
    value represents a constant.
    formal_id is used only in jump function context and represents 
-   pass-through parameter (the formal of caller is passed 
-   as argument).  */
-union parameter_info
+   pass-through parameter (the formal of caller is passed as argument).  */
+union jump_func_value
 {
   unsigned int formal_id;
-  tree value;
+  tree constant;
 };
 
 /* A jump function for a callsite represents the values passed as actual 
@@ -75,16 +74,16 @@ union parameter_info
 struct ipa_jump_func
 {
   enum jump_func_type type;
-  union parameter_info info_type;
+  union jump_func_value value;
 };
 
 /* All formal parameters in the program have a cval computed by 
-   the interprocedural stage of IPCP. See enum cvalue_type for 
-   the various types of cvals supported */
-struct ipcp_formal
+   the interprocedural stage of IPCP. See enum ipa_lattice_type for
+   the various types of lattices supported */
+struct ipcp_lattice
 {
-  enum cvalue_type cval_type;
-  union parameter_info cvalue;
+  enum ipa_lattice_type type;
+  tree constant;
 };
 
 /* Represent which DECL tree (or reference to such tree)
@@ -102,36 +101,33 @@ struct ipa_replace_map
 };
 
 /* Return the field in cgraph_node/cgraph_edge struct that points
-   to ipa_node/ipa_edge struct.  */
-#define IPA_NODE_REF(MT) ((struct ipa_node *)(MT)->aux)
-#define IPA_EDGE_REF(EDGE) ((struct ipa_edge *)(EDGE)->aux)
+   to ipa_node_params/ipa_edge_args struct.  */
+#define IPA_NODE_REF(MT) ((struct ipa_node_params *)(MT)->aux)
+#define IPA_EDGE_REF(EDGE) ((struct ipa_edge_args *)(EDGE)->aux)
 /* This macro checks validity of index returned by
-   ipa_method_tree_map function.  */
-#define IS_VALID_TREE_MAP_INDEX(I) ((I) != -1)
+   ipa_get_param_decl_index function.  */
+#define IS_VALID_JUMP_FUNC_INDEX(I) ((I) != -1)
 
-/* ipa_node stores information related to a method and
-   its formal parameters. It is pointed to by a field in the
-   method's corresponding cgraph_node.
+/* 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).  */
 
-   ipa_edge stores information related to a callsite and
-   its arguments. It is pointed to by a field in the
-   callsite's corresponding cgraph_edge.  */
-struct ipa_node
+struct ipa_node_params
 {
-  /* Number of formal parameters of this method.  When set to 0,
-     this method's parameters would not be analyzed by the different
+  /* Number of formal parameters of this function.  When set to 0,
+     this functions's parameters would not be analyzed by the different
      stages of IPA CP.  */
-  int ipa_arg_num;
-  /* Array of cvals.  */
-  struct ipcp_formal *ipcp_cval;
+  int param_count;
+  /* Array of lattices.  */
+  struct ipcp_lattice *ipcp_lattices;
   /* Mapping each parameter to its PARM_DECL tree.  */
-  tree *ipa_param_tree;
-  /* Indicating which parameter is modified in its method.  */
-  bool *ipa_mod;
+  tree *param_decls;
+  /* Indicating which parameter is modified in its function.  */
+  bool *modified_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;
-  /* Meaningful only for original methods.  Expresses the 
+  /* Meaningful only for original functions.  Expresses the
      ratio between the direct calls and sum of all invocations of 
      this function (given by profiling info).  It is used to calculate 
      the profiling information of the original function and the versioned
@@ -139,66 +135,50 @@ struct ipa_node
   gcov_type count_scale;
 };
 
-struct ipa_edge
+/* ipa_edge_args stores information related to a callsite and particularly
+   its arguments. It is pointed to by a field in the
+   callsite's corresponding cgraph_edge.  */
+struct ipa_edge_args
 {
   /* Number of actual arguments in this callsite.  When set to 0,
      this callsite's parameters would not be analyzed by the different
      stages of IPA CP.  */
-  int ipa_param_num;
+  int argument_count;
   /* Array of the callsite's jump function of each parameter.  */
-  struct ipa_jump_func *ipa_param_map;
+  struct ipa_jump_func *jump_functions;
 };
 
-/* A methodlist element (referred to also as methodlist node). It is used 
-   to create a temporary worklist used in 
-   the propagation stage of IPCP. (can be used for more IPA 
-   optimizations)  */
-struct ipa_methodlist
-{
-  struct cgraph_node *method_p;
-  struct ipa_methodlist *next_method;
-};
-
-/* A pointer to a methodlist element.  */
-typedef struct ipa_methodlist *ipa_methodlist_p;
-
-/* ipa_methodlist interface.  */
-ipa_methodlist_p ipa_methodlist_init (void);
-bool ipa_methodlist_not_empty (ipa_methodlist_p);
-void ipa_add_method (ipa_methodlist_p *, struct cgraph_node *);
-struct cgraph_node *ipa_remove_method (ipa_methodlist_p *);
-
-/* ipa_callsite interface.  */
-int ipa_callsite_param_count (struct cgraph_edge *);
-void ipa_callsite_param_count_set (struct cgraph_edge *, int);
-struct ipa_jump_func *ipa_callsite_param (struct cgraph_edge *, int);
-struct cgraph_node *ipa_callsite_callee (struct cgraph_edge *);
-void ipa_callsite_compute_param (struct cgraph_edge *);
-void ipa_callsite_compute_count (struct cgraph_edge *);
-
-/* ipa_method interface.  */
-int ipa_method_formal_count (struct cgraph_node *);
-void ipa_method_formal_count_set (struct cgraph_node *, int);
-tree ipa_method_get_tree (struct cgraph_node *, int);
-void ipa_method_compute_tree_map (struct cgraph_node *);
-void ipa_method_formal_compute_count (struct cgraph_node *);
-void ipa_method_compute_modify (struct cgraph_node *);
-
-/* jump function interface.  */
-enum jump_func_type get_type (struct ipa_jump_func *);
-union parameter_info *ipa_jf_get_info_type (struct ipa_jump_func *);
-
-/* ipa_node and ipa_edge interfaces.  */
-void ipa_node_create (struct cgraph_node *);
-void ipa_free (void);
-void ipa_nodes_create (void);
-void ipa_edges_create (void);
-void ipa_edges_free (void);
-void ipa_nodes_free (void);
+/* A function list element.  It is used to create a temporary worklist used in
+   the propagation stage of IPCP. (can be used for more IPA optimizations)  */
+struct ipa_func_list
+{
+  struct cgraph_node *node;
+  struct ipa_func_list *next;
+};
+
+/* ipa_func_list interface.  */
+struct ipa_func_list *ipa_init_func_list (void);
+void ipa_push_func_to_list (struct ipa_func_list **, struct cgraph_node *);
+struct cgraph_node *ipa_pop_func_from_list (struct ipa_func_list **);
+
+/* Callsite related calculations.  */
+void ipa_compute_jump_functions (struct cgraph_edge *);
+void ipa_count_arguments (struct cgraph_edge *);
+
+/* Function parameters related computations.  */
+void ipa_create_param_decls_array (struct cgraph_node *);
+void ipa_count_formal_params (struct cgraph_node *);
+void ipa_detect_param_modifications (struct cgraph_node *);
 
+/* Creating and freeing ipa_node_params and ipa_edge_args.  */
+void ipa_create_node_params (struct cgraph_node *);
+void ipa_free_all_node_params (void);
+void ipa_create_all_node_params (void);
+void ipa_create_all_edge_args (void);
+void ipa_free_all_edge_args (void);
 
 /* Debugging interface.  */
-void ipa_method_tree_print (FILE *);
-void ipa_method_modify_print (FILE *);
+void ipa_print_all_tree_maps (FILE *);
+void ipa_print_all_params_modified (FILE *);
 
 #endif /* IPA_PROP_H */

^ permalink raw reply	[flat|nested] 6+ messages in thread
end of thread, other threads:[~2008-04-30 10:05 UTC | newest]

Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2008-04-07 19:31 [RFC PATCH] ipa-prop.[ch] cleanup Martin Jambor
2008-04-08  9:30 ` Richard Guenther
2008-04-10  5:27 ` Diego Novillo
2008-04-16 15:17   ` [PATCH] " Martin Jambor
2008-04-29 17:49     ` Diego Novillo
2008-04-30 14:44       ` Martin Jambor

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).