--- a/gcc/ipa-prop.h	Fri Feb 12 23:41:23 2010 +0900
+++ b/gcc/ipa-prop.h	Mon May 24 12:47:05 2010 +0900
@@ -1,5 +1,6 @@
 /* Interprocedural analyses.
-   Copyright (C) 2005, 2007, 2008 Free Software Foundation, Inc.
+   Copyright (C) 2005, 2007, 2008, 2009
+   Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -38,38 +39,40 @@
                   argument.
    Unknown      - neither of the above.
 
-   IPA_JF_CONST_MEMBER_PTR stands for C++ member pointers, other constants are
-   represented with IPA_JF_CONST.
+   IPA_JF_CONST_MEMBER_PTR stands for C++ member pointers, it is a special
+   constant in this regard.  Other constants are represented with IPA_JF_CONST.
+
+   IPA_JF_ANCESTOR is a special pass-through jump function, which means that
+   the result is an address of a part of the object pointed to by the formal
+   parameter to which the function refers.  It is mainly intended to represent
+   getting addresses of of ancestor fields in C++
+   (e.g. &this_1(D)->D.1766.D.1756).  Note that if the original pointer is
+   NULL, ancestor jump function must behave like a simple pass-through.
 
-   In addition to "ordinary" pass through functions represented by
-   IPA_JF_PASS_THROUGH, IPA_JF_ANCESTOR represents getting addresses of of
-   ancestor fields in C++ (e.g. &this_1(D)->D.1766.D.1756).  */
+   Other pass-through functions can either simply pass on an unchanged formal
+   parameter or can apply one simple binary operation to it (such jump
+   functions are called polynomial).
+
+   IPA_JF_KNOWN_TYPE is a special type of an "unknown" function that applies
+   only to pointer parameters.  It means that even though we cannot prove that
+   the passed value is an interprocedural constant, we still know the exact
+   type of the containing object which may be valuable for devirtualization.
+
+   Jump functions are computed in ipa-prop.c by function
+   update_call_notes_after_inlining.  Some information can be lost and jump
+   functions degraded accordingly when inlining, see
+   update_call_notes_after_inlining in the same file.  */
+
 enum jump_func_type
 {
   IPA_JF_UNKNOWN = 0,  /* newly allocated and zeroed jump functions default */
-  IPA_JF_CONST,
-  IPA_JF_CONST_MEMBER_PTR,
-  IPA_JF_PASS_THROUGH,
-  IPA_JF_ANCESTOR
+  IPA_JF_KNOWN_TYPE,        /* represented by field base_binfo */
+  IPA_JF_CONST,             /* represented by field costant */
+  IPA_JF_CONST_MEMBER_PTR,  /* represented by field member_cst */
+  IPA_JF_PASS_THROUGH,	    /* represented by field pass_through */
+  IPA_JF_ANCESTOR	    /* represented by field ancestor */
 };
 
-/* 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:
-   IPA_TOP - unknown,
-   IPA_BOTTOM - non constant,
-   IPA_CONST_VALUE - simple scalar constant,
-   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 IPA_CONST_VALUE.  */
-enum ipa_lattice_type
-{
-  IPA_BOTTOM,
-  IPA_CONST_VALUE,
-  IPA_TOP
-};
-
-
 /* Structure holding data required to describe a pass-through jump function.  */
 
 struct GTY(()) ipa_pass_through_data
@@ -86,8 +89,8 @@
   enum tree_code operation;
 };
 
-/* Structure holding data required to describe and ancestor pass throu
-   funkci.  */
+/* Structure holding data required to describe an ancestor pass-through
+   jump function.  */
 
 struct GTY(()) ipa_ancestor_jf_data
 {
@@ -118,13 +121,30 @@
      functions and member_cst holds constant c++ member functions.  */
   union jump_func_value
   {
+    tree GTY ((tag ("IPA_JF_KNOWN_TYPE"))) base_binfo;
     tree GTY ((tag ("IPA_JF_CONST"))) constant;
+    struct ipa_member_ptr_cst GTY ((tag ("IPA_JF_CONST_MEMBER_PTR"))) member_cst;
     struct ipa_pass_through_data GTY ((tag ("IPA_JF_PASS_THROUGH"))) pass_through;
     struct ipa_ancestor_jf_data GTY ((tag ("IPA_JF_ANCESTOR"))) ancestor;
-    struct ipa_member_ptr_cst GTY ((tag ("IPA_JF_CONST_MEMBER_PTR"))) member_cst;
   } GTY ((desc ("%1.type"))) value;
 };
 
+/* 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:
+   IPA_TOP - unknown,
+   IPA_BOTTOM - non constant,
+   IPA_CONST_VALUE - simple scalar constant,
+   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 IPA_CONST_VALUE.  */
+enum ipa_lattice_type
+{
+  IPA_BOTTOM,
+  IPA_CONST_VALUE,
+  IPA_TOP
+};
+
 /* All formal parameters in the program have a cval computed by
    the interprocedural stage of IPCP. See enum ipa_lattice_type for
    the various types of lattices supported */
@@ -134,32 +154,6 @@
   tree constant;
 };
 
-/* Each instance of the following  structure describes a statement that calls a
-   function parameter.  Those referring  to statements within the same function
-   are linked in a list.  */
-struct ipa_param_call_note
-{
-  /* Expected number of executions: calculated in profile.c.  */
-  gcov_type count;
-  /* Linked list's next */
-  struct ipa_param_call_note *next;
-  /* Statement that contains the call to the parameter above.  */
-  gimple stmt;
-  /* When in LTO, we the above stmt will be NULL and we need an uid. */
-  unsigned int lto_stmt_uid;
-  /* Index of the parameter that is called.  */
-  int formal_id;
-  /* Expected frequency of executions within the function. see cgraph_edge in
-     cgraph.h for more on this. */
-  int frequency;
-  /* Depth of loop nest, 1 means no loop nest.  */
-  unsigned short int loop_nest;
-  /* Set when we have already found the target to be a compile time constant
-     and turned this into an edge or when the note was found unusable for some
-     reason.  */
-  bool processed;
-};
-
 /* Structure describing a single formal parameter.  */
 struct ipa_param_descriptor
 {
@@ -169,8 +163,8 @@
   tree decl;
   /* Whether the value parameter has been modified within the function.  */
   unsigned modified : 1;
-  /* Whether the parameter has been used as a call destination. */
-  unsigned called : 1;
+  /* The parameter is used.  */
+  unsigned used : 1;
 };
 
 /* ipa_node_params stores information related to formal parameters of functions
@@ -182,11 +176,18 @@
      this function's parameters would not be analyzed by the different
      stages of IPA CP.  */
   int param_count;
+  /* 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;
+  /* Whether the param uses analysis has already been performed.  */
+  unsigned uses_analysis_done : 1;
+  /* Whether the function is enqueued in an ipa_func_list.  */
+  unsigned node_enqueued : 1;
   /* Pointer to an array of structures describing individual formal
      parameters.  */
   struct ipa_param_descriptor *params;
-  /* List of structures enumerating calls to a formal parameter.  */
-  struct ipa_param_call_note *param_calls;
   /* 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;
@@ -196,16 +197,6 @@
      the profiling information of the original function and the versioned
      one.  */
   gcov_type count_scale;
-
-  /* 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;
-  /* Whether the param uses analysis has already been performed.  */
-  unsigned uses_analysis_done : 1;
-  /* Whether the function is enqueued in an ipa_func_list.  */
-  unsigned node_enqueued : 1;
 };
 
 /* ipa_node_params access functions.  Please use these to access fields that
@@ -248,15 +239,13 @@
   return info->params[i].modified;
 }
 
-/* Return the called flag corresponding to the Ith formal parameter of the
-   function associated with INFO.  Note that there is no setter method as the
-   goal is to set all flags when building the array in
-   ipa_detect_called_params.  */
+/* Return the used flag corresponding to the Ith formal parameter of
+   the function associated with INFO.  */
 
 static inline bool
-ipa_is_param_called (struct ipa_node_params *info, int i)
+ipa_is_param_used (struct ipa_node_params *info, int i)
 {
-  return info->params[i].called;
+  return info->params[i].used;
 }
 
 /* Flag this node as having callers with variable number of arguments.  */
@@ -350,8 +339,9 @@
 void ipa_free_node_params_substructures (struct ipa_node_params *);
 void ipa_free_all_node_params (void);
 void ipa_free_all_edge_args (void);
-void free_all_ipa_structures_after_ipa_cp (void);
-void free_all_ipa_structures_after_iinln (void);
+void ipa_create_all_structures_for_iinln (void);
+void ipa_free_all_structures_after_ipa_cp (void);
+void ipa_free_all_structures_after_iinln (void);
 void ipa_register_cgraph_hooks (void);
 
 /* This function ensures the array of node param infos is big enough to
@@ -423,7 +413,7 @@
 }
 
 /* Callsite related calculations.  */
-void ipa_compute_jump_functions (struct cgraph_edge *);
+void ipa_compute_jump_functions (struct cgraph_node *);
 void ipa_count_arguments (struct cgraph_edge *);
 
 /* Function formal parameters related computations.  */
@@ -510,7 +500,6 @@
 void ipa_prop_write_jump_functions (cgraph_node_set set);
 void ipa_prop_read_jump_functions (void);
 void ipa_update_after_lto_read (void);
-void lto_ipa_fixup_call_notes (struct cgraph_node *, gimple *);
 
 /* From tree-sra.c:  */
 bool build_ref_for_offset (tree *, tree, HOST_WIDE_INT, tree, bool);