[RFC, PATCH 1/n] IPA C++ refactoring

[RFC, PATCH 1/n] IPA C++ refactoring

[Martin Liška]

[-- Attachment #1: Type: text/plain, Size: 625 bytes --]

Hi,
    this first patch continues with rafactoring of IPA infrastructure so that we will have C++ API. In the patch, I transformed many global functions to members of symtab_node and cgraph_node.

Example:
cgraph_remove_node (struct cgraph_node *node) -> cgraph_node::remove (void)
symtab_unregister_node (symtab_node *node) -> symtab_node::unregister (void)

The patch is being consulted with Honza and will iterate. We want to inform folk that we plan to do following changes.

After the patch is applied, I would like to transform varpool_node and cgraph_edge in the following patch.

Thank you for your comments,
Martin

[-- Attachment #2: ipa-ref-symtab-node2.patch.bz2 --]
[-- Type: application/x-bzip, Size: 71775 bytes --]

Re: [RFC, PATCH 1/n] IPA C++ refactoring

[Jan Hubicka]

> Hi,
>    this first patch continues with rafactoring of IPA infrastructure so that we will have C++ API. In the patch, I transformed many global functions to members of symtab_node and cgraph_node.
> 
> Example:
> cgraph_remove_node (struct cgraph_node *node) -> cgraph_node::remove (void)
> symtab_unregister_node (symtab_node *node) -> symtab_node::unregister (void)
> 
> The patch is being consulted with Honza and will iterate. We want to inform folk that we plan to do following changes.
> 
> After the patch is applied, I would like to transform varpool_node and cgraph_edge in the following patch.
> 
> Thank you for your comments,
> Martin

 
 /* Remove the node from cgraph.  */

Perhaps Remove function from symbol table.
(similarly for varpool, perhaps few other block comments needs revisiting.
We may do that incrementally.)
 
+  /* Add node into symbol table.  This function is not used directly, but via
+     cgraph/varpool node creation routines.  */
+  void register_symbol (void);
+
+  /* Remove symtab node from the symbol table.  */
+  void remove (void);
+
+  /* Dump symtab node to F.  */
+  void dump (FILE *f);
+
+  /* Dump symtab node to stderr.  */
+  void DEBUG_FUNCTION debug (void);
+
+  /* Verify consistency of node.  */
+  void DEBUG_FUNCTION verify (void);
+
+  /* Return ipa reference from this symtab_node to
+     REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
+     of the use and STMT the statement (if it exists).  */
+  struct ipa_ref *add_reference (symtab_node *referred_node,
+				enum ipa_ref_use use_type);
+
+  /* Return ipa reference from this symtab_node to
+     REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
+     of the use and STMT the statement (if it exists).  */
+  struct ipa_ref *add_reference (symtab_node *referred_node,
+				 enum ipa_ref_use use_type, gimple stmt);
+
+  /* If VAL is a reference to a function or a variable, add a reference from
+     this symtab_node to the corresponding symbol table node.  USE_TYPE specify
+     type of the use and STMT the statement (if it exists).  Return the new
+     reference or NULL if none was created.  */
+  struct ipa_ref *maybe_add_reference (tree val, enum ipa_ref_use use_type,
+				       gimple stmt);
+
+  /* Clone all references from symtab NODE to this symtab_node.  */
+  void clone_references (symtab_node *node);
+
+  /* Remove all stmt references in non-speculative references.
+     Those are not maintained during inlining & clonning.
+     The exception are speculative references that are updated along
+     with callgraph edges associated with them.  */
+  void clone_referring (symtab_node *node);
+
+  /* Clone reference REF to this symtab_node and set its stmt to STMT.  */
+  struct ipa_ref *clone_reference (struct ipa_ref *ref, gimple stmt);
+
+  /* Find the structure describing a reference to REFERRED_NODE
+     and associated with statement STMT.  */
+  struct ipa_ref *find_reference (symtab_node *, gimple, unsigned int);
+
+  /* Remove all references that are associated with statement STMT.  */
+  void remove_stmt_references (gimple stmt);
+
+  /* Remove all stmt references in non-speculative references.
+     Those are not maintained during inlining & clonning.
+     The exception are speculative references that are updated along
+     with callgraph edges associated with them.  */
+  void clear_stmts_in_references (void);
+
+  /* Remove all references in ref list.  */
+  void remove_all_references (void);
+
+  /* Remove all referring items in ref list.  */
+  void remove_all_referring (void);
+
+  /* Dump references in ref list to FILE.  */
+  void dump_references (FILE *file);
+
+  /* Dump referring in list to FILE.  */
+  void dump_referring (FILE *);
+
+  /* Return true if symtab node and TARGET represents
+     semantically equivalent symbols.  */
+  bool semantically_equivalent_p (symtab_node *target);
+
+  /* Classify symbol symtab node for partitioning.  */
+  enum symbol_partitioning_class get_partitioning_class (void);
+
+  /* Return comdat group.  */
+  tree get_comdat_group ()
+    {
+      return x_comdat_group;
+    }
+
+  /* Return comdat group as identifier_node.  */
+  tree get_comdat_group_id ()
+    {
+      if (x_comdat_group && TREE_CODE (x_comdat_group) != IDENTIFIER_NODE)
+	x_comdat_group = DECL_ASSEMBLER_NAME (x_comdat_group);
+      return x_comdat_group;
+    }
+
+  /* Set comdat group.  */
+  void set_comdat_group (tree group)
+    {
+      gcc_checking_assert (!group || TREE_CODE (group) == IDENTIFIER_NODE
+			   || DECL_P (group));
+      x_comdat_group = group;
+    }
+
+  /* Return section as string.  */
+  const char * get_section ()
+    {
+      if (!x_section)
+	return NULL;
+      return x_section->name;
+    }
+
+  /* Remove node from same comdat group.   */
+  void remove_from_same_comdat_group (void);
+
+  /* Add this symtab_node to the same comdat group that OLD is in.  */
+  void add_to_same_comdat_group (symtab_node *old_node);
+
+  /* Dissolve the same_comdat_group list in which NODE resides.  */
+  void dissolve_same_comdat_group_list (void);
+
+  /* Return true when symtab_node is known to be used from other (non-LTO)
+     object file. Known only when doing LTO via linker plugin.  */
+  bool used_from_object_file_p (void);
+
+  /* Walk the alias chain to return the symbol NODE is alias of.
+     If NODE is not an alias, return NODE.
+     When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
+  symtab_node *ultimate_alias_target (enum availability *avail = NULL);
+
+  /* Return next reachable static symbol with initializer after NODE.  */
+  inline symtab_node *next_defined_symbol (void);
+
+  /* Add reference recording that symtab node is alias of TARGET.
+     The function can fail in the case of aliasing cycles; in this case
+     it returns false.  */
+  bool resolve_alias (symtab_node *target);
+
+  /* C++ FE sometimes change linkage flags after producing same
+     body aliases.  */
+  void fixup_same_cpp_alias_visibility (symtab_node *target);
+
+  /* Call calback on symtab node and aliases associated to this node.
+     When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
+     skipped. */
+  bool call_for_symbol_and_aliases (bool (*callback) (symtab_node *, void *),
+				  void *data,
+				  bool include_overwrite);
+
+  /* If node can not be interposable by static or dynamic linker to point to
+     different definition, return this symbol. Otherwise look for alias with
+     such property and if none exists, introduce new one.  */
+  symtab_node *noninterposable_alias (void);
+
+  /* Return node that alias N is aliasing.  */
+  inline symtab_node *get_alias_target (void);
+
+  /* Iterates I-th reference in the list, REF is also set.  */
+  struct ipa_ref *iterate_reference (unsigned i, struct ipa_ref *&ref);
+
+  /* Iterates I-th referring item in the list, REF is also set.  */
+  struct ipa_ref *iterate_referring (unsigned i, struct ipa_ref *&ref);

The iterators probably should go along with other reference API methods
earlier.
+
+  /* Iterates I-th referring alias item in the list, REF is also set.  */
+  struct ipa_ref *iterate_direct_aliases (unsigned i, struct ipa_ref *&ref);
+
+  /* Set section for symbol and its aliases.  */
+  void set_section (const char *section);
+
+  /* Set section, do not recurse into aliases.
+     When one wants to change section of symbol and its aliases,
+     use set_section.  */
+  void set_section_for_node (const char *section);
+
+  /* Set initialization priority to PRIORITY.  */
+  void set_init_priority (priority_type priority);
+
+  /* Return the initialization priority.  */
+  priority_type get_init_priority ();
+
+  /* Return availability of NODE.  */
+  enum availability get_availability (void);
+
+  /* Make DECL local.  */
+  void make_decl_local (void);
+
+  /* Return true if list contains an alias.  */
+  bool has_aliases_p (void);
+
+  /* Return true when the symbol is real symbol, i.e. it is not inline clone
+     or abstract function kept for debug info purposes only.  */
+  bool real_symbol_p (void);
+
+  /* Return true if NODE can be discarded by linker from the binary.  */
+  inline bool
+  can_be_discarded_p (void)
+  {
+    return (DECL_EXTERNAL (decl)
+	    || (get_comdat_group ()
+		&& resolution != LDPR_PREVAILING_DEF
+		&& resolution != LDPR_PREVAILING_DEF_IRONLY
+		&& resolution != LDPR_PREVAILING_DEF_IRONLY_EXP));
+  }
+
+  /* Return true if NODE is local to a particular COMDAT group, and must not
+     be named from outside the COMDAT.  This is used for C++ decloned
+     constructors.  */
+  inline bool
+  comdat_local_p (void)
+  {
+    return (same_comdat_group && !TREE_PUBLIC (decl));
+  }
+
+  /* Return true if ONE and TWO are part of the same COMDAT group.  */
+  inline bool in_same_comdat_group_p (symtab_node *target);
+
+  /* Return true when there is a reference to node and it is not vtable.  */
+  bool address_taken_from_non_vtable_p (void);
+
+  /* Return symbol table node associated with DECL, if any,
+     and NULL otherwise.  */
+  static inline symtab_node *get (const_tree decl)
+  {
+#ifdef ENABLE_CHECKING
+    /* Check that we are called for sane type of object - functions
+       and static or external variables.  */
+    gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL
+			 || (TREE_CODE (decl) == VAR_DECL
+			     && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
+				 || in_lto_p)));
+    /* Check that the mapping is sane - perhaps this check can go away,
+       but at the moment frontends tends to corrupt the mapping by calling
+       memcpy/memset on the tree nodes.  */
+    gcc_checking_assert (!decl->decl_with_vis.symtab_node
+			 || decl->decl_with_vis.symtab_node->decl == decl);
+#endif
+    return decl->decl_with_vis.symtab_node;
+  }
+
+  /* Dump symbol table to F.  */
+  static void dump_table (FILE *);
+
+  /* Dump symbol table to stderr.  */
+  static inline DEBUG_FUNCTION void debug_symtab (void)
+  {
+    dump_table (stderr);
+  }
+
+  /* Verify symbol table for internal consistency.  */
+  static DEBUG_FUNCTION void verify_symtab_nodes (void);
+
+  /* Return true when NODE is known to be used from other (non-LTO)
+     object file. Known only when doing LTO via linker plugin.  */
+  static bool used_from_object_file_p_worker (symtab_node *node);
+
   /* Type of the symbol.  */
   ENUM_BITFIELD (symtab_type) type : 8;
 
...

+  /* Given function symbol, walk the alias chain to return the function node
+     is alias of. Do not walk through thunks.
+     When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
+
+  cgraph_node *function_or_thunk (enum availability *availability = NULL);

function_or_thunk_symbol I guess
+
+  /* Walk the alias chain to return the function cgraph_node is alias of.
+     Walk through thunk, too.
+     When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
+  cgraph_node *function_node (enum availability *avail = NULL);

function_symbol
+
+  /* Add thunk alias into callgraph.  The alias declaration is ALIAS and it
+     aliases DECL with an adjustments made into the first parameter.
+     See comments in thunk_adjust for detail on the parameters.  */
+  cgraph_node * create_thunk (tree alias, tree, bool this_adjusting,
+			      HOST_WIDE_INT fixed_offset,
+			      HOST_WIDE_INT virtual_value,
+			      tree virtual_offset,
+			      tree real_alias);

Here I would put basic manipulation fifrst (create/get/remove), clones next
and thunks last.
+
+  /* Create node representing clone of N executed COUNT times.  Decrease
+     the execution counts from original node too.
+     The new clone will have decl set to DECL that may or may not be the same
+     as decl of N.
+
+     When UPDATE_ORIGINAL is true, the counts are subtracted from the original
+     function's profile to reflect the fact that part of execution is handled
+     by node.
+     When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
+     the new clone. Otherwise the caller is responsible for doing so later.
+
+     If the new node is being inlined into another one, NEW_INLINED_TO should be
+     the outline function the new one is (even indirectly) inlined to.
+     All hooks will see this in node's global.inlined_to, when invoked.
+     Can be NULL if the node is not inlined.  */
+  cgraph_node *clone_node (tree decl, gcov_type count, int freq,

create_clone
+			   bool update_original,
+			   vec<cgraph_edge *> redirect_callers,
+			   bool call_duplication_hook,
+			   struct cgraph_node *new_inlined_to,
+			   bitmap args_to_skip);
+
+  /* Create callgraph node clone with new declaration.  The actual body will
+     be copied later at compilation stage.  */
+  cgraph_node *create_virtual_clone (vec<cgraph_edge *> redirect_callers,
+				     vec<ipa_replace_map *, va_gc> *tree_map,
+				     bitmap args_to_skip, const char * suffix);
+
+  /* cgraph node being removed from symbol table; see if its entry can be
+   replaced by other inline clone.  */
+  cgraph_node *find_replacement (void);

Shouldn't this be protected?
+
+  /* Create a new cgraph node which is the new version of
+     callgraph node.  REDIRECT_CALLERS holds the callers
+     edges which should be redirected to point to
+     NEW_VERSION.  ALL the callees edges of the node
+     are cloned to the new version node.  Return the new
+     version node.
+
+     If non-NULL BLOCK_TO_COPY determine what basic blocks
+     was copied to prevent duplications of calls that are dead
+     in the clone.  */
+
+  cgraph_node *copy_for_versioning (tree new_decl,
+				    vec<cgraph_edge *> redirect_callers,
+				    bitmap bbs_to_copy);

Hmm, perhaps better as create_version_clone (still bad name, but it should be
merged with clone)
+
+  /* Perform function versioning.
+     Function versioning includes copying of the tree and
+     a callgraph update (creating a new cgraph node and updating
+     its callees and callers).
+
+     REDIRECT_CALLERS varray includes the edges to be redirected
+     to the new version.
+
+     TREE_MAP is a mapping of tree nodes we want to replace with
+     new ones (according to results of prior analysis).
+
+     If non-NULL ARGS_TO_SKIP determine function parameters to remove
+     from new version.
+     If SKIP_RETURN is true, the new version will return void.
+     If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
+     If non_NULL NEW_ENTRY determine new entry BB of the clone.
+
+     Return the new version's cgraph node.  */
+  cgraph_node *function_versioning (vec<cgraph_edge *> redirect_callers,
+				    vec<ipa_replace_map *, va_gc> *tree_map,
+				    bitmap args_to_skip,
+				    bool skip_return,
+				    bitmap bbs_to_copy,
+				    basic_block new_entry_block,
+				    const char *clone_name);

create_version_clone_with_body
+
+  /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
+     corresponding to cgraph_node.  */
+  struct cgraph_function_version_info *insert_new_function_version (void);

It such that function_version here has nothing to do with function version above,
but I guess I will need to clean up incrementally.

Perhaps create_new_function_version as we use create for edges/symbols and others.
+
+  /* Discover all functions and variables that are trivially needed, analyze
+     them as well as all functions and variables referred by them  */
+  void analyze (void);
+
+  /* Expand thunk NODE to gimple if possible.
+     When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
+     no assembler is produced.
+     When OUTPUT_ASM_THUNK is true, also produce assembler for
+     thunks that are not lowered.  */
+  bool expand_thunk (bool output_asm_thunks, bool force_gimple_thunk);
+
+  /* As an GCC extension we allow redefinition of the function.  The
+     semantics when both copies of bodies differ is not well defined.
+     We replace the old body with new body so in unit at a time mode
+     we always use new body, while in normal mode we may end up with
+     old body inlined into some functions and new body expanded and
+     inlined in others.  */
+  void reset (void);

THese three probably would better become protected if we reorgnanize cgraphunit
bit more, but incrementally.
+
+  /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
+     kind of wrapper method.  */
+  void make_wrapper (cgraph_node *target);

create_wrapper
+
+  /* Verify cgraph nodes of the cgraph node.  */
+  void DEBUG_FUNCTION verify_node (void);
+
+  /* Remove the node from cgraph.  */
+  void remove (void);
+
+  /* Dump call graph node to file F.  */
+  void dump (FILE *f);
+
+  /* Dump call graph node to stderr.  */
+  void DEBUG_FUNCTION debug (void);
+
+  /* When doing LTO, read cgraph_node's body from disk if it is not already
+     present.  */
+  bool get_body (void);
+
+  /* Release memory used to represent body of function.
+     Use this only for functions that are released before being translated to
+     target code (i.e. RTL).  Functions that are compiled to RTL and beyond
+     are free'd in final.c via free_after_compilation().  */
+  void release_body (void);

Those probably should go to start
+
+  /* Remove the node from cgraph and all inline clones inlined into it.
+     Skip however removal of FORBIDDEN_NODE and return true if it needs to be
+     removed.  This allows to call the function from outer loop walking clone
+     tree.  */
+  bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL);
+
+  /* Record all references from cgraph_node that are taken
+     in statement STMT.  */
+  void record_stmt_references (gimple stmt);
+
+  /* Like cgraph_set_call_stmt but walk the clone tree and update all
+     clones sharing the same function body.
+     When WHOLE_SPECULATIVE_EDGES is true, all three components of
+     speculative edge gets updated.  Otherwise we update only direct
+     call.  */
+  void set_call_stmt_including_clones (gimple old_stmt, gimple new_stmt,
+				       bool update_speculative = true);

Those performing operations on function and its clones should be grouped together.
+
+  /* cgraph_node is no longer nested function; update cgraph accordingly.  */
+  void unnest (void);
+
+  /* Bring cgraph node local.  */
+  void make_local (void);
+
+  /* Likewise indicate that a node is having address taken.  */
+  void mark_address_taken (void);
+
+  /* Set fialization priority to PRIORITY.  */
+  void set_fini_priority (priority_type priority);
+
+  /* Return the finalization priority.  */
+  priority_type get_fini_priority ();
+
+  /* Remove all callees from the node.  */
+  void remove_callees (void);
+
+  /* Create edge from a given function to CALLEE in the cgraph.  */
+  struct cgraph_edge *create_edge (cgraph_node *callee,
+				   gimple call_stmt, gcov_type count,
+				   int freq);
+  /* Create an indirect edge with a yet-undetermined callee where the call
+     statement destination is a formal parameter of the caller with index
+     PARAM_INDEX. */
+  struct cgraph_edge *
+  create_indirect_edge (gimple call_stmt, int ecf_flags, gcov_type count,
+			int freq);
+
+  /* Like cgraph_create_edge walk the clone tree and update all clones sharing
+   same function body.  If clones already have edge for OLD_STMT; only
+   update the edge same way as cgraph_set_call_stmt_including_clones does.  */
+  void create_edge_including_clones (struct cgraph_node *callee,
+				     gimple old_stmt, gimple stmt,
+				     gcov_type count,
+				     int freq,
+				     cgraph_inline_failed_t reason);
+
+  /* Return the callgraph edge representing the GIMPLE_CALL statement
+     CALL_STMT.  */
+  cgraph_edge *get_edge (gimple call_stmt);
+
+  /* Collect all callers of cgraph_node and its aliases that are known to lead
+     to NODE (i.e. are not overwritable).  */
+  vec<cgraph_edge *> collect_callers (void);
+
+  /* Return function availability.  See cgraph.h for description of individual
+     return values.  */
+  enum availability get_body_availability (void);

This should be get_availability and shared with symtab/varpool equivalent.

+
+  /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node
+     if any to NOTHROW.  */
+  void set_nothrow_flag (bool nothrow);
+
+  /* Set TREE_READONLY on cgraph_node's decl and on aliases of the node
+     if any to READONLY.  */
+  void set_const_flag (bool readonly, bool looping);
+
+  /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
+     if any to PURE.  */
+  void set_pure_flag (bool pure, bool looping);
+
+  /* Call all node duplication hooks.  */
+  void call_duplication_hooks (cgraph_node *node2);

Can't it be private?
+
+  /* Call calback on function and aliases associated to the function.
+     When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
+     skipped. */
+
+  bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
+						      void *),
+				    void *data, bool include_overwritable);
+
+  /* Call calback on cgraph_node, thunks and aliases associated to NODE.
+     When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
+     skipped.  */
+  bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node,
+							   void *data),
+					 void *data,
+					 bool include_overwritable);
+
+  /* Call all node insertion hooks.  */
+  void call_function_insertion_hooks (void);

Likewise
+
+  /* Return true when function can be marked local.  */
+  bool local_p (void);

Probably also private? Because users should use local flag.
+
+  /* Return true if cgraph_node can be made local for API change.
+     Extern inline functions and C++ COMDAT functions can be made local
+     at the expense of possible code size growth if function is used in multiple
+     compilation units.  */
+  bool can_be_local_p (void);
+
+  /* Return true when cgraph_node can not return or throw and thus
+     it is safe to ignore its side effects for IPA analysis.  */
+  bool cannot_return_p (void);
+
+  /* Return true when function cgraph_node and all its aliases are only called
+     directly.
+     i.e. it is not externally visible, address was not taken and
+     it is not used in any other non-standard way.  */
+  bool only_called_directly_p (void);
+
+  /* Return true when function cgraph_node can be expected to be removed
+     from program when direct calls in this compilation unit are removed.
+
+     As a special case COMDAT functions are
+     cgraph_can_remove_if_no_direct_calls_p while the are not
+     cgraph_only_called_directly_p (it is possible they are called from other
+     unit)
+
+     This function behaves as cgraph_only_called_directly_p because eliminating
+     all uses of COMDAT function does not make it necessarily disappear from
+     the program unless we are compiling whole program or we do LTO.  In this
+     case we know we win since dynamic linking will not really discard the
+     linkonce section.  */
+
+  bool will_be_removed_from_program_if_no_direct_calls_p (void);
+
+  /* Return true when function can be removed from callgraph
+     if all direct calls are eliminated.  */
+  bool can_remove_if_no_direct_calls_and_refs_p (void);
+
+  /* Return true when function cgraph_node and its aliases can be removed from
+     callgraph if all direct calls are eliminated.  */
+  bool can_remove_if_no_direct_calls_p (void);
+
+  /* Get the cgraph_function_version_info node corresponding to node.  */
+  struct cgraph_function_version_info *function_version (void);

Group it with the version creation.
+
+  /* Dump the callgraph to file F.  */
+  static void dump_cgraph (FILE *f);
+
+  /* Dump the call graph to stderr.  */
+  static inline void debug_cgraph (void)
+  {
+    dump_cgraph (stderr);
+  }

Dumping and debug should go first into the basic manipulation.
+
+  /* Record that DECL1 and DECL2 are semantically identical function
+     versions.  */
+  static void record_function_versions (tree decl1, tree decl2);
+
+  /* Remove the cgraph_function_version_info and cgraph_node for DECL.  This
+     DECL is a duplicate declaration.  */
+  static void delete_function_version (tree decl);

also these two
+
+  /* Add the function FNDECL to the call graph.
+     Unlike cgraph_finalize_function, this function is intended to be used
+     by middle end and allows insertion of new function at arbitrary point
+     of compilation.  The function can be either in high, low or SSA form
+     GIMPLE.
+
+     The function is assumed to be reachable and have address taken (so no
+     API breaking optimizations are performed on it).
+
+     Main work done by this function is to enqueue the function for later
+     processing to avoid need the passes to be re-entrant.  */
+  static void add_new_function (tree fndecl, bool lowered);
+
+  /* Return callgraph node for given symbol and check it is a function. */
+  static inline cgraph_node *get (const_tree decl)
+  {
+    gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL);
+    return dyn_cast <cgraph_node *> (symtab_node::get (decl));
+  }
+
+  /* Return cgraph node assigned to DECL.  Create new one when needed.  */
+  static cgraph_node * create (tree decl);

So should these three
+
+  /* Allocate new callgraph node and insert it into basic data structures.  */
+  static cgraph_node * create_empty (void);

private/protected?
+
+  /* Try to find a call graph node for declaration DECL and if it does not
+     exist or if it corresponds to an inline clone, create a new one.  */
+  static cgraph_node * get_create (tree);

Also to begginig, next to get and create.
+
+  /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
+     Return NULL if there's no such node.  */
+  static cgraph_node *get_for_asmname (tree asmname);

Likewise
+
+  /* Attempt to mark ALIAS as an alias to DECL.  Return alias node if
+     successful and NULL otherwise.
+     Same body aliases are output whenever the body of DECL is output,
+     and cgraph_node::get (ALIAS) transparently
+     returns cgraph_node::get (DECL).  */
+  static cgraph_node * create_same_body_alias (tree alias, tree decl);

To alias API
+
+  /* Worker for cgraph_can_remove_if_no_direct_calls_p.  */
+  static bool used_from_object_file_p_worker (cgraph_node *node,
+					      void *data ATTRIBUTE_UNUSED)
+  {
+    return node->used_from_object_file_p ();
+  }
+
+  /* Return true when cgraph_node can not be local.
+     Worker for cgraph_local_node_p.  */
cgraph_local_node_p was probably renamed, but we should sanify predicates here.
Please group all functions dealing with local functions togehter, too.
+  static bool non_local_p (cgraph_node *node, void *data ATTRIBUTE_UNUSED);
+
+  /* Verify whole cgraph structure.  */
+  static void DEBUG_FUNCTION verify_cgraph_nodes (void);
+
+  /* Worker to bring NODE local.  */
+  static bool make_local (cgraph_node *node, void *data ATTRIBUTE_UNUSED);
+
+  /* Mark ALIAS as an alias to DECL.  DECL_NODE is cgraph node representing
+     the function body is associated
+     with (not necessarily cgraph_node (DECL).  */
+  static cgraph_node *create_alias (tree alias, tree target);
+
+  static cgraph_edge * create_edge (cgraph_node *caller, cgraph_node *callee,
+				    gimple call_stmt, gcov_type count,
+				    int freq,
+				    bool indir_unknown_callee);

Also edges and aliases should be grouped.

With these changes patch looks good. Probably we will need one additional cleanup pass, but it would be better
to do it incrementally.  Please write changelog that carefuly records what was renamed to what.

Honza

Re: [RFC, PATCH 1/n] IPA C++ refactoring

[Martin Liška]

Hello

On 07/11/2014 12:07 PM, Jan Hubicka wrote:
>> Hi,
>>     this first patch continues with rafactoring of IPA infrastructure so that we will have C++ API. In the patch, I transformed many global functions to members of symtab_node and cgraph_node.
>>
>> Example:
>> cgraph_remove_node (struct cgraph_node *node) -> cgraph_node::remove (void)
>> symtab_unregister_node (symtab_node *node) -> symtab_node::unregister (void)
>>
>> The patch is being consulted with Honza and will iterate. We want to inform folk that we plan to do following changes.
>>
>> After the patch is applied, I would like to transform varpool_node and cgraph_edge in the following patch.
>>
>> Thank you for your comments,
>> Martin
>   
>   /* Remove the node from cgraph.  */
>
> Perhaps Remove function from symbol table.
> (similarly for varpool, perhaps few other block comments needs revisiting.
> We may do that incrementally.)
>   
> +  /* Add node into symbol table.  This function is not used directly, but via
> +     cgraph/varpool node creation routines.  */
> +  void register_symbol (void);
> +
> +  /* Remove symtab node from the symbol table.  */
> +  void remove (void);
> +
> +  /* Dump symtab node to F.  */
> +  void dump (FILE *f);
> +
> +  /* Dump symtab node to stderr.  */
> +  void DEBUG_FUNCTION debug (void);
> +
> +  /* Verify consistency of node.  */
> +  void DEBUG_FUNCTION verify (void);
> +
> +  /* Return ipa reference from this symtab_node to
> +     REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
> +     of the use and STMT the statement (if it exists).  */
> +  struct ipa_ref *add_reference (symtab_node *referred_node,
> +				enum ipa_ref_use use_type);
> +
> +  /* Return ipa reference from this symtab_node to
> +     REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
> +     of the use and STMT the statement (if it exists).  */
> +  struct ipa_ref *add_reference (symtab_node *referred_node,
> +				 enum ipa_ref_use use_type, gimple stmt);
> +
> +  /* If VAL is a reference to a function or a variable, add a reference from
> +     this symtab_node to the corresponding symbol table node.  USE_TYPE specify
> +     type of the use and STMT the statement (if it exists).  Return the new
> +     reference or NULL if none was created.  */
> +  struct ipa_ref *maybe_add_reference (tree val, enum ipa_ref_use use_type,
> +				       gimple stmt);
> +
> +  /* Clone all references from symtab NODE to this symtab_node.  */
> +  void clone_references (symtab_node *node);
> +
> +  /* Remove all stmt references in non-speculative references.
> +     Those are not maintained during inlining & clonning.
> +     The exception are speculative references that are updated along
> +     with callgraph edges associated with them.  */
> +  void clone_referring (symtab_node *node);
> +
> +  /* Clone reference REF to this symtab_node and set its stmt to STMT.  */
> +  struct ipa_ref *clone_reference (struct ipa_ref *ref, gimple stmt);
> +
> +  /* Find the structure describing a reference to REFERRED_NODE
> +     and associated with statement STMT.  */
> +  struct ipa_ref *find_reference (symtab_node *, gimple, unsigned int);
> +
> +  /* Remove all references that are associated with statement STMT.  */
> +  void remove_stmt_references (gimple stmt);
> +
> +  /* Remove all stmt references in non-speculative references.
> +     Those are not maintained during inlining & clonning.
> +     The exception are speculative references that are updated along
> +     with callgraph edges associated with them.  */
> +  void clear_stmts_in_references (void);
> +
> +  /* Remove all references in ref list.  */
> +  void remove_all_references (void);
> +
> +  /* Remove all referring items in ref list.  */
> +  void remove_all_referring (void);
> +
> +  /* Dump references in ref list to FILE.  */
> +  void dump_references (FILE *file);
> +
> +  /* Dump referring in list to FILE.  */
> +  void dump_referring (FILE *);
> +
> +  /* Return true if symtab node and TARGET represents
> +     semantically equivalent symbols.  */
> +  bool semantically_equivalent_p (symtab_node *target);
> +
> +  /* Classify symbol symtab node for partitioning.  */
> +  enum symbol_partitioning_class get_partitioning_class (void);
> +
> +  /* Return comdat group.  */
> +  tree get_comdat_group ()
> +    {
> +      return x_comdat_group;
> +    }
> +
> +  /* Return comdat group as identifier_node.  */
> +  tree get_comdat_group_id ()
> +    {
> +      if (x_comdat_group && TREE_CODE (x_comdat_group) != IDENTIFIER_NODE)
> +	x_comdat_group = DECL_ASSEMBLER_NAME (x_comdat_group);
> +      return x_comdat_group;
> +    }
> +
> +  /* Set comdat group.  */
> +  void set_comdat_group (tree group)
> +    {
> +      gcc_checking_assert (!group || TREE_CODE (group) == IDENTIFIER_NODE
> +			   || DECL_P (group));
> +      x_comdat_group = group;
> +    }
> +
> +  /* Return section as string.  */
> +  const char * get_section ()
> +    {
> +      if (!x_section)
> +	return NULL;
> +      return x_section->name;
> +    }
> +
> +  /* Remove node from same comdat group.   */
> +  void remove_from_same_comdat_group (void);
> +
> +  /* Add this symtab_node to the same comdat group that OLD is in.  */
> +  void add_to_same_comdat_group (symtab_node *old_node);
> +
> +  /* Dissolve the same_comdat_group list in which NODE resides.  */
> +  void dissolve_same_comdat_group_list (void);
> +
> +  /* Return true when symtab_node is known to be used from other (non-LTO)
> +     object file. Known only when doing LTO via linker plugin.  */
> +  bool used_from_object_file_p (void);
> +
> +  /* Walk the alias chain to return the symbol NODE is alias of.
> +     If NODE is not an alias, return NODE.
> +     When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
> +  symtab_node *ultimate_alias_target (enum availability *avail = NULL);
> +
> +  /* Return next reachable static symbol with initializer after NODE.  */
> +  inline symtab_node *next_defined_symbol (void);
> +
> +  /* Add reference recording that symtab node is alias of TARGET.
> +     The function can fail in the case of aliasing cycles; in this case
> +     it returns false.  */
> +  bool resolve_alias (symtab_node *target);
> +
> +  /* C++ FE sometimes change linkage flags after producing same
> +     body aliases.  */
> +  void fixup_same_cpp_alias_visibility (symtab_node *target);
> +
> +  /* Call calback on symtab node and aliases associated to this node.
> +     When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
> +     skipped. */
> +  bool call_for_symbol_and_aliases (bool (*callback) (symtab_node *, void *),
> +				  void *data,
> +				  bool include_overwrite);
> +
> +  /* If node can not be interposable by static or dynamic linker to point to
> +     different definition, return this symbol. Otherwise look for alias with
> +     such property and if none exists, introduce new one.  */
> +  symtab_node *noninterposable_alias (void);
> +
> +  /* Return node that alias N is aliasing.  */
> +  inline symtab_node *get_alias_target (void);
> +
> +  /* Iterates I-th reference in the list, REF is also set.  */
> +  struct ipa_ref *iterate_reference (unsigned i, struct ipa_ref *&ref);
> +
> +  /* Iterates I-th referring item in the list, REF is also set.  */
> +  struct ipa_ref *iterate_referring (unsigned i, struct ipa_ref *&ref);
>
> The iterators probably should go along with other reference API methods
> earlier.
> +
> +  /* Iterates I-th referring alias item in the list, REF is also set.  */
> +  struct ipa_ref *iterate_direct_aliases (unsigned i, struct ipa_ref *&ref);
> +
> +  /* Set section for symbol and its aliases.  */
> +  void set_section (const char *section);
> +
> +  /* Set section, do not recurse into aliases.
> +     When one wants to change section of symbol and its aliases,
> +     use set_section.  */
> +  void set_section_for_node (const char *section);
> +
> +  /* Set initialization priority to PRIORITY.  */
> +  void set_init_priority (priority_type priority);
> +
> +  /* Return the initialization priority.  */
> +  priority_type get_init_priority ();
> +
> +  /* Return availability of NODE.  */
> +  enum availability get_availability (void);
> +
> +  /* Make DECL local.  */
> +  void make_decl_local (void);
> +
> +  /* Return true if list contains an alias.  */
> +  bool has_aliases_p (void);
> +
> +  /* Return true when the symbol is real symbol, i.e. it is not inline clone
> +     or abstract function kept for debug info purposes only.  */
> +  bool real_symbol_p (void);
> +
> +  /* Return true if NODE can be discarded by linker from the binary.  */
> +  inline bool
> +  can_be_discarded_p (void)
> +  {
> +    return (DECL_EXTERNAL (decl)
> +	    || (get_comdat_group ()
> +		&& resolution != LDPR_PREVAILING_DEF
> +		&& resolution != LDPR_PREVAILING_DEF_IRONLY
> +		&& resolution != LDPR_PREVAILING_DEF_IRONLY_EXP));
> +  }
> +
> +  /* Return true if NODE is local to a particular COMDAT group, and must not
> +     be named from outside the COMDAT.  This is used for C++ decloned
> +     constructors.  */
> +  inline bool
> +  comdat_local_p (void)
> +  {
> +    return (same_comdat_group && !TREE_PUBLIC (decl));
> +  }
> +
> +  /* Return true if ONE and TWO are part of the same COMDAT group.  */
> +  inline bool in_same_comdat_group_p (symtab_node *target);
> +
> +  /* Return true when there is a reference to node and it is not vtable.  */
> +  bool address_taken_from_non_vtable_p (void);
> +
> +  /* Return symbol table node associated with DECL, if any,
> +     and NULL otherwise.  */
> +  static inline symtab_node *get (const_tree decl)
> +  {
> +#ifdef ENABLE_CHECKING
> +    /* Check that we are called for sane type of object - functions
> +       and static or external variables.  */
> +    gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL
> +			 || (TREE_CODE (decl) == VAR_DECL
> +			     && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
> +				 || in_lto_p)));
> +    /* Check that the mapping is sane - perhaps this check can go away,
> +       but at the moment frontends tends to corrupt the mapping by calling
> +       memcpy/memset on the tree nodes.  */
> +    gcc_checking_assert (!decl->decl_with_vis.symtab_node
> +			 || decl->decl_with_vis.symtab_node->decl == decl);
> +#endif
> +    return decl->decl_with_vis.symtab_node;
> +  }
> +
> +  /* Dump symbol table to F.  */
> +  static void dump_table (FILE *);
> +
> +  /* Dump symbol table to stderr.  */
> +  static inline DEBUG_FUNCTION void debug_symtab (void)
> +  {
> +    dump_table (stderr);
> +  }
> +
> +  /* Verify symbol table for internal consistency.  */
> +  static DEBUG_FUNCTION void verify_symtab_nodes (void);
> +
> +  /* Return true when NODE is known to be used from other (non-LTO)
> +     object file. Known only when doing LTO via linker plugin.  */
> +  static bool used_from_object_file_p_worker (symtab_node *node);
> +
>     /* Type of the symbol.  */
>     ENUM_BITFIELD (symtab_type) type : 8;
>   
> ...
>
> +  /* Given function symbol, walk the alias chain to return the function node
> +     is alias of. Do not walk through thunks.
> +     When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
> +
> +  cgraph_node *function_or_thunk (enum availability *availability = NULL);
>
> function_or_thunk_symbol I guess
> +
> +  /* Walk the alias chain to return the function cgraph_node is alias of.
> +     Walk through thunk, too.
> +     When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
> +  cgraph_node *function_node (enum availability *avail = NULL);
>
> function_symbol
> +
> +  /* Add thunk alias into callgraph.  The alias declaration is ALIAS and it
> +     aliases DECL with an adjustments made into the first parameter.
> +     See comments in thunk_adjust for detail on the parameters.  */
> +  cgraph_node * create_thunk (tree alias, tree, bool this_adjusting,
> +			      HOST_WIDE_INT fixed_offset,
> +			      HOST_WIDE_INT virtual_value,
> +			      tree virtual_offset,
> +			      tree real_alias);
>
> Here I would put basic manipulation fifrst (create/get/remove), clones next
> and thunks last.
> +
> +  /* Create node representing clone of N executed COUNT times.  Decrease
> +     the execution counts from original node too.
> +     The new clone will have decl set to DECL that may or may not be the same
> +     as decl of N.
> +
> +     When UPDATE_ORIGINAL is true, the counts are subtracted from the original
> +     function's profile to reflect the fact that part of execution is handled
> +     by node.
> +     When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
> +     the new clone. Otherwise the caller is responsible for doing so later.
> +
> +     If the new node is being inlined into another one, NEW_INLINED_TO should be
> +     the outline function the new one is (even indirectly) inlined to.
> +     All hooks will see this in node's global.inlined_to, when invoked.
> +     Can be NULL if the node is not inlined.  */
> +  cgraph_node *clone_node (tree decl, gcov_type count, int freq,
>
> create_clone
> +			   bool update_original,
> +			   vec<cgraph_edge *> redirect_callers,
> +			   bool call_duplication_hook,
> +			   struct cgraph_node *new_inlined_to,
> +			   bitmap args_to_skip);
> +
> +  /* Create callgraph node clone with new declaration.  The actual body will
> +     be copied later at compilation stage.  */
> +  cgraph_node *create_virtual_clone (vec<cgraph_edge *> redirect_callers,
> +				     vec<ipa_replace_map *, va_gc> *tree_map,
> +				     bitmap args_to_skip, const char * suffix);
> +
> +  /* cgraph node being removed from symbol table; see if its entry can be
> +   replaced by other inline clone.  */
> +  cgraph_node *find_replacement (void);
>
> Shouldn't this be protected?
I tried to mark it as protected, by there's usage that blocks that:

In file included from ../../gcc/symtab.c:40:0:
../../gcc/cgraph.h: In member function ‘void symtab_node::unregister()’:
../../gcc/cgraph.h:1178:16: error: ‘cgraph_node* cgraph_node::find_replacement()’ is protected
    cgraph_node *find_replacement (void);
                 ^
../../gcc/symtab.c:462:46: error: within this context
   replacement_node = cnode->find_replacement ();

> +
> +  /* Create a new cgraph node which is the new version of
> +     callgraph node.  REDIRECT_CALLERS holds the callers
> +     edges which should be redirected to point to
> +     NEW_VERSION.  ALL the callees edges of the node
> +     are cloned to the new version node.  Return the new
> +     version node.
> +
> +     If non-NULL BLOCK_TO_COPY determine what basic blocks
> +     was copied to prevent duplications of calls that are dead
> +     in the clone.  */
> +
> +  cgraph_node *copy_for_versioning (tree new_decl,
> +				    vec<cgraph_edge *> redirect_callers,
> +				    bitmap bbs_to_copy);
>
> Hmm, perhaps better as create_version_clone (still bad name, but it should be
> merged with clone)
> +
> +  /* Perform function versioning.
> +     Function versioning includes copying of the tree and
> +     a callgraph update (creating a new cgraph node and updating
> +     its callees and callers).
> +
> +     REDIRECT_CALLERS varray includes the edges to be redirected
> +     to the new version.
> +
> +     TREE_MAP is a mapping of tree nodes we want to replace with
> +     new ones (according to results of prior analysis).
> +
> +     If non-NULL ARGS_TO_SKIP determine function parameters to remove
> +     from new version.
> +     If SKIP_RETURN is true, the new version will return void.
> +     If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
> +     If non_NULL NEW_ENTRY determine new entry BB of the clone.
> +
> +     Return the new version's cgraph node.  */
> +  cgraph_node *function_versioning (vec<cgraph_edge *> redirect_callers,
> +				    vec<ipa_replace_map *, va_gc> *tree_map,
> +				    bitmap args_to_skip,
> +				    bool skip_return,
> +				    bitmap bbs_to_copy,
> +				    basic_block new_entry_block,
> +				    const char *clone_name);
>
> create_version_clone_with_body
> +
> +  /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
> +     corresponding to cgraph_node.  */
> +  struct cgraph_function_version_info *insert_new_function_version (void);
>
> It such that function_version here has nothing to do with function version above,
> but I guess I will need to clean up incrementally.
>
> Perhaps create_new_function_version as we use create for edges/symbols and others.
> +
> +  /* Discover all functions and variables that are trivially needed, analyze
> +     them as well as all functions and variables referred by them  */
> +  void analyze (void);
> +
> +  /* Expand thunk NODE to gimple if possible.
> +     When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
> +     no assembler is produced.
> +     When OUTPUT_ASM_THUNK is true, also produce assembler for
> +     thunks that are not lowered.  */
> +  bool expand_thunk (bool output_asm_thunks, bool force_gimple_thunk);
> +
> +  /* As an GCC extension we allow redefinition of the function.  The
> +     semantics when both copies of bodies differ is not well defined.
> +     We replace the old body with new body so in unit at a time mode
> +     we always use new body, while in normal mode we may end up with
> +     old body inlined into some functions and new body expanded and
> +     inlined in others.  */
> +  void reset (void);
>
> THese three probably would better become protected if we reorgnanize cgraphunit
> bit more, but incrementally.
> +
> +  /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
> +     kind of wrapper method.  */
> +  void make_wrapper (cgraph_node *target);
>
> create_wrapper
> +
> +  /* Verify cgraph nodes of the cgraph node.  */
> +  void DEBUG_FUNCTION verify_node (void);
> +
> +  /* Remove the node from cgraph.  */
> +  void remove (void);
> +
> +  /* Dump call graph node to file F.  */
> +  void dump (FILE *f);
> +
> +  /* Dump call graph node to stderr.  */
> +  void DEBUG_FUNCTION debug (void);
> +
> +  /* When doing LTO, read cgraph_node's body from disk if it is not already
> +     present.  */
> +  bool get_body (void);
> +
> +  /* Release memory used to represent body of function.
> +     Use this only for functions that are released before being translated to
> +     target code (i.e. RTL).  Functions that are compiled to RTL and beyond
> +     are free'd in final.c via free_after_compilation().  */
> +  void release_body (void);
>
> Those probably should go to start
> +
> +  /* Remove the node from cgraph and all inline clones inlined into it.
> +     Skip however removal of FORBIDDEN_NODE and return true if it needs to be
> +     removed.  This allows to call the function from outer loop walking clone
> +     tree.  */
> +  bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL);
> +
> +  /* Record all references from cgraph_node that are taken
> +     in statement STMT.  */
> +  void record_stmt_references (gimple stmt);
> +
> +  /* Like cgraph_set_call_stmt but walk the clone tree and update all
> +     clones sharing the same function body.
> +     When WHOLE_SPECULATIVE_EDGES is true, all three components of
> +     speculative edge gets updated.  Otherwise we update only direct
> +     call.  */
> +  void set_call_stmt_including_clones (gimple old_stmt, gimple new_stmt,
> +				       bool update_speculative = true);
>
> Those performing operations on function and its clones should be grouped together.
> +
> +  /* cgraph_node is no longer nested function; update cgraph accordingly.  */
> +  void unnest (void);
> +
> +  /* Bring cgraph node local.  */
> +  void make_local (void);
> +
> +  /* Likewise indicate that a node is having address taken.  */
> +  void mark_address_taken (void);
> +
> +  /* Set fialization priority to PRIORITY.  */
> +  void set_fini_priority (priority_type priority);
> +
> +  /* Return the finalization priority.  */
> +  priority_type get_fini_priority ();
> +
> +  /* Remove all callees from the node.  */
> +  void remove_callees (void);
> +
> +  /* Create edge from a given function to CALLEE in the cgraph.  */
> +  struct cgraph_edge *create_edge (cgraph_node *callee,
> +				   gimple call_stmt, gcov_type count,
> +				   int freq);
> +  /* Create an indirect edge with a yet-undetermined callee where the call
> +     statement destination is a formal parameter of the caller with index
> +     PARAM_INDEX. */
> +  struct cgraph_edge *
> +  create_indirect_edge (gimple call_stmt, int ecf_flags, gcov_type count,
> +			int freq);
> +
> +  /* Like cgraph_create_edge walk the clone tree and update all clones sharing
> +   same function body.  If clones already have edge for OLD_STMT; only
> +   update the edge same way as cgraph_set_call_stmt_including_clones does.  */
> +  void create_edge_including_clones (struct cgraph_node *callee,
> +				     gimple old_stmt, gimple stmt,
> +				     gcov_type count,
> +				     int freq,
> +				     cgraph_inline_failed_t reason);
> +
> +  /* Return the callgraph edge representing the GIMPLE_CALL statement
> +     CALL_STMT.  */
> +  cgraph_edge *get_edge (gimple call_stmt);
> +
> +  /* Collect all callers of cgraph_node and its aliases that are known to lead
> +     to NODE (i.e. are not overwritable).  */
> +  vec<cgraph_edge *> collect_callers (void);
> +
> +  /* Return function availability.  See cgraph.h for description of individual
> +     return values.  */
> +  enum availability get_body_availability (void);
>
> This should be get_availability and shared with symtab/varpool equivalent.
> +
> +  /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node
> +     if any to NOTHROW.  */
> +  void set_nothrow_flag (bool nothrow);
> +
> +  /* Set TREE_READONLY on cgraph_node's decl and on aliases of the node
> +     if any to READONLY.  */
> +  void set_const_flag (bool readonly, bool looping);
> +
> +  /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
> +     if any to PURE.  */
> +  void set_pure_flag (bool pure, bool looping);
> +
> +  /* Call all node duplication hooks.  */
> +  void call_duplication_hooks (cgraph_node *node2);
>
> Can't it be private?
duplicate_thunk_for_node calls the function for thunk->call_duplication_hooks.
> +
> +  /* Call calback on function and aliases associated to the function.
> +     When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
> +     skipped. */
> +
> +  bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
> +						      void *),
> +				    void *data, bool include_overwritable);
> +
> +  /* Call calback on cgraph_node, thunks and aliases associated to NODE.
> +     When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
> +     skipped.  */
> +  bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node,
> +							   void *data),
> +					 void *data,
> +					 bool include_overwritable);
> +
> +  /* Call all node insertion hooks.  */
> +  void call_function_insertion_hooks (void);
>
> Likewise
create_version_clone_with_body calls: new_version_node->call_function_insertion_hooks ();

> +
> +  /* Return true when function can be marked local.  */
> +  bool local_p (void);
>
> Probably also private? Because users should use local flag.
> +
> +  /* Return true if cgraph_node can be made local for API change.
> +     Extern inline functions and C++ COMDAT functions can be made local
> +     at the expense of possible code size growth if function is used in multiple
> +     compilation units.  */
> +  bool can_be_local_p (void);
> +
> +  /* Return true when cgraph_node can not return or throw and thus
> +     it is safe to ignore its side effects for IPA analysis.  */
> +  bool cannot_return_p (void);
> +
> +  /* Return true when function cgraph_node and all its aliases are only called
> +     directly.
> +     i.e. it is not externally visible, address was not taken and
> +     it is not used in any other non-standard way.  */
> +  bool only_called_directly_p (void);
> +
> +  /* Return true when function cgraph_node can be expected to be removed
> +     from program when direct calls in this compilation unit are removed.
> +
> +     As a special case COMDAT functions are
> +     cgraph_can_remove_if_no_direct_calls_p while the are not
> +     cgraph_only_called_directly_p (it is possible they are called from other
> +     unit)
> +
> +     This function behaves as cgraph_only_called_directly_p because eliminating
> +     all uses of COMDAT function does not make it necessarily disappear from
> +     the program unless we are compiling whole program or we do LTO.  In this
> +     case we know we win since dynamic linking will not really discard the
> +     linkonce section.  */
> +
> +  bool will_be_removed_from_program_if_no_direct_calls_p (void);
> +
> +  /* Return true when function can be removed from callgraph
> +     if all direct calls are eliminated.  */
> +  bool can_remove_if_no_direct_calls_and_refs_p (void);
> +
> +  /* Return true when function cgraph_node and its aliases can be removed from
> +     callgraph if all direct calls are eliminated.  */
> +  bool can_remove_if_no_direct_calls_p (void);
> +
> +  /* Get the cgraph_function_version_info node corresponding to node.  */
> +  struct cgraph_function_version_info *function_version (void);
>
> Group it with the version creation.
> +
> +  /* Dump the callgraph to file F.  */
> +  static void dump_cgraph (FILE *f);
> +
> +  /* Dump the call graph to stderr.  */
> +  static inline void debug_cgraph (void)
> +  {
> +    dump_cgraph (stderr);
> +  }
>
> Dumping and debug should go first into the basic manipulation.
> +
> +  /* Record that DECL1 and DECL2 are semantically identical function
> +     versions.  */
> +  static void record_function_versions (tree decl1, tree decl2);
> +
> +  /* Remove the cgraph_function_version_info and cgraph_node for DECL.  This
> +     DECL is a duplicate declaration.  */
> +  static void delete_function_version (tree decl);
>
> also these two
> +
> +  /* Add the function FNDECL to the call graph.
> +     Unlike cgraph_finalize_function, this function is intended to be used
> +     by middle end and allows insertion of new function at arbitrary point
> +     of compilation.  The function can be either in high, low or SSA form
> +     GIMPLE.
> +
> +     The function is assumed to be reachable and have address taken (so no
> +     API breaking optimizations are performed on it).
> +
> +     Main work done by this function is to enqueue the function for later
> +     processing to avoid need the passes to be re-entrant.  */
> +  static void add_new_function (tree fndecl, bool lowered);
> +
> +  /* Return callgraph node for given symbol and check it is a function. */
> +  static inline cgraph_node *get (const_tree decl)
> +  {
> +    gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL);
> +    return dyn_cast <cgraph_node *> (symtab_node::get (decl));
> +  }
> +
> +  /* Return cgraph node assigned to DECL.  Create new one when needed.  */
> +  static cgraph_node * create (tree decl);
>
> So should these three
> +
> +  /* Allocate new callgraph node and insert it into basic data structures.  */
> +  static cgraph_node * create_empty (void);
All these functions are static and so are placed after all member functions. Is that coding style rule correct?
>
> private/protected?

Usages from outside of cgraph_node:

cgraph.c:cgraph_node::create_empty (void)
cgraph.c:  struct cgraph_node *node = cgraph_node::create_empty ();
cgraphclones.c:  struct cgraph_node *new_node = cgraph_node::create_empty ();
lto-cgraph.c:      node = cgraph_node::create_empty ();

I will go through class members and check grouping one more.
What do  you think about 'static' class functions, should be placed after all member functions?

Thanks,
Martin
> +
> +  /* Try to find a call graph node for declaration DECL and if it does not
> +     exist or if it corresponds to an inline clone, create a new one.  */
> +  static cgraph_node * get_create (tree);
>
> Also to begginig, next to get and create.
> +
> +  /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
> +     Return NULL if there's no such node.  */
> +  static cgraph_node *get_for_asmname (tree asmname);
>
> Likewise
> +
> +  /* Attempt to mark ALIAS as an alias to DECL.  Return alias node if
> +     successful and NULL otherwise.
> +     Same body aliases are output whenever the body of DECL is output,
> +     and cgraph_node::get (ALIAS) transparently
> +     returns cgraph_node::get (DECL).  */
> +  static cgraph_node * create_same_body_alias (tree alias, tree decl);
>
> To alias API
> +
> +  /* Worker for cgraph_can_remove_if_no_direct_calls_p.  */
> +  static bool used_from_object_file_p_worker (cgraph_node *node,
> +					      void *data ATTRIBUTE_UNUSED)
> +  {
> +    return node->used_from_object_file_p ();
> +  }
> +
> +  /* Return true when cgraph_node can not be local.
> +     Worker for cgraph_local_node_p.  */
> cgraph_local_node_p was probably renamed, but we should sanify predicates here.
> Please group all functions dealing with local functions togehter, too.
> +  static bool non_local_p (cgraph_node *node, void *data ATTRIBUTE_UNUSED);
> +
> +  /* Verify whole cgraph structure.  */
> +  static void DEBUG_FUNCTION verify_cgraph_nodes (void);
> +
> +  /* Worker to bring NODE local.  */
> +  static bool make_local (cgraph_node *node, void *data ATTRIBUTE_UNUSED);
> +
> +  /* Mark ALIAS as an alias to DECL.  DECL_NODE is cgraph node representing
> +     the function body is associated
> +     with (not necessarily cgraph_node (DECL).  */
> +  static cgraph_node *create_alias (tree alias, tree target);
> +
> +  static cgraph_edge * create_edge (cgraph_node *caller, cgraph_node *callee,
> +				    gimple call_stmt, gcov_type count,
> +				    int freq,
> +				    bool indir_unknown_callee);
>
> Also edges and aliases should be grouped.
>
> With these changes patch looks good. Probably we will need one additional cleanup pass, but it would be better
> to do it incrementally.  Please write changelog that carefuly records what was renamed to what.
>
> Honza

Re: [RFC, PATCH 1/n] IPA C++ refactoring

[Jan Hubicka]

> I tried to mark it as protected, by there's usage that blocks that:
> 
> In file included from ../../gcc/symtab.c:40:0:
> ../../gcc/cgraph.h: In member function ?void symtab_node::unregister()?:
> ../../gcc/cgraph.h:1178:16: error: ?cgraph_node* cgraph_node::find_replacement()? is protected
>    cgraph_node *find_replacement (void);
>                 ^
> ../../gcc/symtab.c:462:46: error: within this context
>   replacement_node = cnode->find_replacement ();

OK, lets keep it public for now then.

> >Likewise
> create_version_clone_with_body calls: new_version_node->call_function_insertion_hooks ();

OK.
> 
> Usages from outside of cgraph_node:
> 
> cgraph.c:cgraph_node::create_empty (void)
> cgraph.c:  struct cgraph_node *node = cgraph_node::create_empty ();
> cgraphclones.c:  struct cgraph_node *new_node = cgraph_node::create_empty ();
> lto-cgraph.c:      node = cgraph_node::create_empty ();
> 
> I will go through class members and check grouping one more.
> What do  you think about 'static' class functions, should be placed after all member functions?

Sounds fine for me.

Honza
> 
> Thanks,
> Martin
> >+
> >+  /* Try to find a call graph node for declaration DECL and if it does not
> >+     exist or if it corresponds to an inline clone, create a new one.  */
> >+  static cgraph_node * get_create (tree);
> >
> >Also to begginig, next to get and create.
> >+
> >+  /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
> >+     Return NULL if there's no such node.  */
> >+  static cgraph_node *get_for_asmname (tree asmname);
> >
> >Likewise
> >+
> >+  /* Attempt to mark ALIAS as an alias to DECL.  Return alias node if
> >+     successful and NULL otherwise.
> >+     Same body aliases are output whenever the body of DECL is output,
> >+     and cgraph_node::get (ALIAS) transparently
> >+     returns cgraph_node::get (DECL).  */
> >+  static cgraph_node * create_same_body_alias (tree alias, tree decl);
> >
> >To alias API
> >+
> >+  /* Worker for cgraph_can_remove_if_no_direct_calls_p.  */
> >+  static bool used_from_object_file_p_worker (cgraph_node *node,
> >+					      void *data ATTRIBUTE_UNUSED)
> >+  {
> >+    return node->used_from_object_file_p ();
> >+  }
> >+
> >+  /* Return true when cgraph_node can not be local.
> >+     Worker for cgraph_local_node_p.  */
> >cgraph_local_node_p was probably renamed, but we should sanify predicates here.
> >Please group all functions dealing with local functions togehter, too.
> >+  static bool non_local_p (cgraph_node *node, void *data ATTRIBUTE_UNUSED);
> >+
> >+  /* Verify whole cgraph structure.  */
> >+  static void DEBUG_FUNCTION verify_cgraph_nodes (void);
> >+
> >+  /* Worker to bring NODE local.  */
> >+  static bool make_local (cgraph_node *node, void *data ATTRIBUTE_UNUSED);
> >+
> >+  /* Mark ALIAS as an alias to DECL.  DECL_NODE is cgraph node representing
> >+     the function body is associated
> >+     with (not necessarily cgraph_node (DECL).  */
> >+  static cgraph_node *create_alias (tree alias, tree target);
> >+
> >+  static cgraph_edge * create_edge (cgraph_node *caller, cgraph_node *callee,
> >+				    gimple call_stmt, gcov_type count,
> >+				    int freq,
> >+				    bool indir_unknown_callee);
> >
> >Also edges and aliases should be grouped.
> >
> >With these changes patch looks good. Probably we will need one additional cleanup pass, but it would be better
> >to do it incrementally.  Please write changelog that carefuly records what was renamed to what.
> >
> >Honza

Re: [RFC, PATCH 1/n] IPA C++ refactoring

[Martin Liška]

[-- Attachment #1: Type: text/plain, Size: 14617 bytes --]


On 07/15/2014 12:00 PM, Jan Hubicka wrote:
>> I tried to mark it as protected, by there's usage that blocks that:
>>
>> In file included from ../../gcc/symtab.c:40:0:
>> ../../gcc/cgraph.h: In member function ?void symtab_node::unregister()?:
>> ../../gcc/cgraph.h:1178:16: error: ?cgraph_node* cgraph_node::find_replacement()? is protected
>>     cgraph_node *find_replacement (void);
>>                  ^
>> ../../gcc/symtab.c:462:46: error: within this context
>>    replacement_node = cnode->find_replacement ();
> OK, lets keep it public for now then.
>
>>> Likewise
>> create_version_clone_with_body calls: new_version_node->call_function_insertion_hooks ();
> OK.
>> Usages from outside of cgraph_node:
>>
>> cgraph.c:cgraph_node::create_empty (void)
>> cgraph.c:  struct cgraph_node *node = cgraph_node::create_empty ();
>> cgraphclones.c:  struct cgraph_node *new_node = cgraph_node::create_empty ();
>> lto-cgraph.c:      node = cgraph_node::create_empty ();
>>
>> I will go through class members and check grouping one more.
>> What do  you think about 'static' class functions, should be placed after all member functions?
> Sounds fine for me.
>
> Honza
Hi,
    this email contains final version of that patch, cosmetic changes were applied.

I prepared list of all function that have been transformed:

SYMTAB_NODE

public:
   void register_symbol (void) created from: symtab_register_node
   void remove (void) created from: symtab_remove_node
   void dump (FILE *f) created from: dump_symtab_node
   void DEBUG_FUNCTION debug (void) created from: debug_symtab_node
   void DEBUG_FUNCTION verify (void) created from: verify_symtab_node
   struct ipa_ref *add_reference (symtab_node *referred_node, enum ipa_ref_use use_type) created from: add_reference
   struct ipa_ref *add_reference (symtab_node *referred_node, enum ipa_ref_use use_type, gimple stmt) created from: add_reference
   struct ipa_ref *maybe_add_reference (tree val, enum ipa_ref_use use_type, gimple stmt) created from: maybe_add_reference
   bool semantically_equivalent_p (symtab_node *target) created from: symtab_semantically_equivalent_p
   void remove_from_same_comdat_group (void) created from: remove_from_same_comdat_group
   void add_to_same_comdat_group (symtab_node *old_node) created from: symtab_add_to_same_comdat_group
   void dissolve_same_comdat_group_list (void) created from: symtab_dissolve_same_comdat_group_list
   bool used_from_object_file_p (void) created from: symtab_used_from_object_file_p
   symtab_node *ultimate_alias_target (enum availability *avail = NULL) created from: symtab_alias_ultimate_target
   inline symtab_node *next_defined_symbol (void) created from: symtab_next_defined_symbol
   bool resolve_alias (symtab_node *target) created from: symtab_resolve_alias
   bool call_for_symbol_and_aliases (bool (*callback) (symtab_node *, void *), void *data, bool include_overwrite) created from: symtab_for_node_and_aliases
   symtab_node *noninterposable_alias (void) created from: symtab_nonoverwritable_alias
   inline symtab_node *get_alias_target (void) created from: symtab_alias_target
   void set_section (const char *section) created from: set_section_1
   enum availability get_availability (void) created from: symtab_node_availability
   void make_decl_local (void) created from: symtab_make_decl_local
   bool real_symbol_p (void) created from: symtab_read_node
   can_be_discarded_p (void) created from: symtab_can_be_discarded
   inline bool comdat_local_p (void) created from: symtab_comdat_local_p
   inline bool in_same_comdat_group_p (symtab_node *target) created from: symtab_in_same_comdat_p;
   bool address_taken_from_non_vtable_p (void) created from: address_taken_from_non_vtable_p
   static inline symtab_node *get (const_tree decl) created from: symtab_get_node
   static void dump_table (FILE *) created from: dump_symtab
   static inline DEBUG_FUNCTION void debug_symtab (void) created from: debug_symtab
   static DEBUG_FUNCTION void verify_symtab_nodes (void) created from: verify_symtab
   static bool used_from_object_file_p_worker (symtab_node *node) created from: symtab_used_from_object_file_p

protected:
   void dump_base (FILE *) created from: dump_symtab_base
   bool DEBUG_FUNCTION verify_base (void) created from: verify_symtab_base
   void unregister (void) created from: symtab_unregister_node
   struct symbol_priority_map *priority_info (void) created from: symtab_priority_info

private:
   static bool set_implicit_section (symtab_node *n, void *) created from: set_implicit_section
   static bool noninterposable_alias (symtab_node *node, void *data) created from: symtab_nonoverwritable_alias_1


CGRAPH_NODE

public:
   bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL) created from: cgraph_remove_node_and_inline_clones
   void record_stmt_references (gimple stmt) created from: ipa_record_stmt_references
   void set_call_stmt_including_clones (gimple old_stmt, gimple new_stmt, bool update_speculative = true) created from: cgraph_set_call_stmt_including_clones
   cgraph_node *function_symbol (enum availability *avail = NULL) created from: cgraph_function_node
   cgraph_node *create_clone (tree decl, gcov_type count, int freq, bool update_original, vec<cgraph_edge *> redirect_callers, bool call_duplication_hook, struct cgraph_node *new_inlined_to, bitmap args_to_skip) created from: cgraph_create_clone
   cgraph_node *create_virtual_clone (vec<cgraph_edge *> redirect_callers, vec<ipa_replace_map *, va_gc> *tree_map, bitmap args_to_skip, const char * suffix) created from: cgraph_create_virtual_clone
   cgraph_node *find_replacement (void) created from: cgraph_find_replacement_node
   cgraph_node *create_version_clone (tree new_decl, vec<cgraph_edge *> redirect_callers, bitmap bbs_to_copy) created from: cgraph_copy_node_for_versioning
   cgraph_node *create_version_clone_with_body (vec<cgraph_edge *> redirect_callers, vec<ipa_replace_map *, va_gc> *tree_map, bitmap args_to_skip, bool skip_return, bitmap bbs_to_copy, basic_block new_entry_block, const char *clone_name) created from: cgraph_function_version_info
   struct cgraph_function_version_info *insert_new_function_version (void) created from: insert_new_cgraph_node_version
   struct cgraph_function_version_info *function_version (void) created from: get_cgraph_node_version
   void analyze (void) created from: analyze_function
   cgraph_node * create_thunk (tree alias, tree, bool this_adjusting, HOST_WIDE_INT fixed_offset, HOST_WIDE_INT virtual_value, tree virtual_offset, tree real_alias) cgraph_add_thunk
   inline cgraph_node *get_alias_target (void) created from: cgraph_alias_target
   cgraph_node *ultimate_alias_target (availability *availability = NULL) created from: cgraph_function_or_thunk_node
   bool expand_thunk (bool output_asm_thunks, bool force_gimple_thunk) created from: expand_thunk
   void reset (void) created from: cgraph_reset_node
   void create_wrapper (cgraph_node *target) created from: cgraph_make_wrapper
   void DEBUG_FUNCTION verify_node (void) created from: verify_cgraph_node
   void remove (void) created from: cgraph_remove_node
   void dump (FILE *f) created from: dump_cgraph_node
   void DEBUG_FUNCTION debug (void) created from: debug_cgraph_node
   bool get_body (void) created from: cgraph_get_body
   void release_body (void) created from: cgraph_release_function_body
   void unnest (void) created from: cgraph_unnest_node
   void make_local (void) created from: cgraph_make_node_local
   void mark_address_taken (void) created from: cgraph_mark_address_taken_node
   struct cgraph_edge *create_edge (cgraph_node *callee, gimple call_stmt, gcov_type count, int freq) created from: cgraph_create_edge
   struct cgraph_edge *create_indirect_edge (gimple call_stmt, int ecf_flags, gcov_type count, int freq) created from: cgraph_create_indirect_edge
   void create_edge_including_clones (struct cgraph_node *callee, gimple old_stmt, gimple stmt, gcov_type count, int freq, cgraph_inline_failed_t reason) created from: cgraph_create_edge_including_clones
   cgraph_edge *get_edge (gimple call_stmt) created from: cgraph_edge
   vec<cgraph_edge *> collect_callers (void) created from: collect_callers_of_node
   void remove_callers (void) created from: cgraph_node_remove_callers
   void remove_callees (void) created from: cgraph_node_remove_callees
   enum availability get_availability (void) created from: cgraph_function_body_availability
   void set_nothrow_flag (bool nothrow) created from: cgraph_set_nothrow_flag
   void set_const_flag (bool readonly, bool looping) created from: cgraph_set_const_flag
   void set_pure_flag (bool pure, bool looping) created from: cgraph_set_pure_flag
   void call_duplication_hooks (cgraph_node *node2) created from: cgraph_call_node_duplication_hooks
   bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *, void *), void *data, bool include_overwritable) created from: cgraph_for_node_and_aliases
   bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node, void *data), void *data, bool include_overwritable) created from: cgraph_for_node_thunks_and_aliases
   void call_function_insertion_hooks (void) created from: cgraph_call_function_insertion_hooks
   inline void mark_force_output (void) created from: cgraph_mark_force_output_node
   bool local_p (void) created from: cgraph_local_node
   bool can_be_local_p (void) created from: cgraph_node_can_be_local_p
   bool cannot_return_p (void) created from: cgraph_node_cannot_return
   bool only_called_directly_p (void) created from: cgraph_only_called_directly_p
   inline bool only_called_directly_or_aliased_p (void) created from: cgraph_only_called_directly_or_aliased_p
   bool will_be_removed_from_program_if_no_direct_calls_p (void) created from: cgraph_will_be_removed_from_program_if_no_direct_calls
   bool can_remove_if_no_direct_calls_and_refs_p (void) created from: cgraph_can_remove_if_no_direct_calls_and_refs_p
   bool can_remove_if_no_direct_calls_p (void) created from: cgraph_can_remove_if_no_direct_calls_p
   inline bool has_gimple_body_p (void) created from: cgraph_function_with_gimple_body_p
   bool optimize_for_size_p (void) created from: cgraph_optimize_for_size_p
   static void dump_cgraph (FILE *f) created from: dump_cgraph
   static inline void debug_cgraph (void) created from: debug_cgraph
   static void record_function_versions (tree decl1, tree decl2) created from: record_function_versions
   static void delete_function_version (tree decl) created from: delete_function_version
   static void add_new_function (tree fndecl, bool lowered) created from: cgraph_add_new_function
   static inline cgraph_node *get (const_tree decl) created from: cgraph_get_node
   static cgraph_node * create (tree decl) created from: cgraph_create_node
   static cgraph_node * create_empty (void) created from: cgraph_create_empty_node
   static cgraph_node * get_create (tree) created from: cgraph_get_create_node
   static cgraph_node *get_for_asmname (tree asmname) created from: cgraph_node_for_asm
   static cgraph_node * create_same_body_alias (tree alias, tree decl) created from: cgraph_same_body_alias
   static bool used_from_object_file_p_worker (cgraph_node *node, void *) new function
   static bool non_local_p (cgraph_node *node, void *) created from: cgraph_non_local_node_p_1
   static void DEBUG_FUNCTION verify_cgraph_nodes (void) created from: verify_cgraph
   static bool make_local (cgraph_node *node, void *) created from: cgraph_make_node_local
   static cgraph_node *create_alias (tree alias, tree target) created from: cgraph_create_function_alias
   static cgraph_edge * create_edge (cgraph_node *caller, cgraph_node *callee, gimple call_stmt, gcov_type count, int freq, bool indir_unknown_callee) created from: cgraph_create_edge_1

VARPOOL_NODE

public:
   void remove (void) created from: varpool_remove_node
   void dump (FILE *f) created from: dump_varpool_node

Can you please advise me how to create a ChangeLog entry based on such transformation?

For being sure, I've been running testsuite for all supported languages.

Thank you,
Martin
>> Thanks,
>> Martin
>>> +
>>> +  /* Try to find a call graph node for declaration DECL and if it does not
>>> +     exist or if it corresponds to an inline clone, create a new one.  */
>>> +  static cgraph_node * get_create (tree);
>>>
>>> Also to begginig, next to get and create.
>>> +
>>> +  /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
>>> +     Return NULL if there's no such node.  */
>>> +  static cgraph_node *get_for_asmname (tree asmname);
>>>
>>> Likewise
>>> +
>>> +  /* Attempt to mark ALIAS as an alias to DECL.  Return alias node if
>>> +     successful and NULL otherwise.
>>> +     Same body aliases are output whenever the body of DECL is output,
>>> +     and cgraph_node::get (ALIAS) transparently
>>> +     returns cgraph_node::get (DECL).  */
>>> +  static cgraph_node * create_same_body_alias (tree alias, tree decl);
>>>
>>> To alias API
>>> +
>>> +  /* Worker for cgraph_can_remove_if_no_direct_calls_p.  */
>>> +  static bool used_from_object_file_p_worker (cgraph_node *node,
>>> +					      void *data ATTRIBUTE_UNUSED)
>>> +  {
>>> +    return node->used_from_object_file_p ();
>>> +  }
>>> +
>>> +  /* Return true when cgraph_node can not be local.
>>> +     Worker for cgraph_local_node_p.  */
>>> cgraph_local_node_p was probably renamed, but we should sanify predicates here.
>>> Please group all functions dealing with local functions togehter, too.
>>> +  static bool non_local_p (cgraph_node *node, void *data ATTRIBUTE_UNUSED);
>>> +
>>> +  /* Verify whole cgraph structure.  */
>>> +  static void DEBUG_FUNCTION verify_cgraph_nodes (void);
>>> +
>>> +  /* Worker to bring NODE local.  */
>>> +  static bool make_local (cgraph_node *node, void *data ATTRIBUTE_UNUSED);
>>> +
>>> +  /* Mark ALIAS as an alias to DECL.  DECL_NODE is cgraph node representing
>>> +     the function body is associated
>>> +     with (not necessarily cgraph_node (DECL).  */
>>> +  static cgraph_node *create_alias (tree alias, tree target);
>>> +
>>> +  static cgraph_edge * create_edge (cgraph_node *caller, cgraph_node *callee,
>>> +				    gimple call_stmt, gcov_type count,
>>> +				    int freq,
>>> +				    bool indir_unknown_callee);
>>>
>>> Also edges and aliases should be grouped.
>>>
>>> With these changes patch looks good. Probably we will need one additional cleanup pass, but it would be better
>>> to do it incrementally.  Please write changelog that carefuly records what was renamed to what.
>>>
>>> Honza


[-- Attachment #2: cgraph.h --]
[-- Type: text/x-chdr, Size: 73013 bytes --]

/* Callgraph handling code.
   Copyright (C) 2003-2014 Free Software Foundation, Inc.
   Contributed by Jan Hubicka

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#ifndef GCC_CGRAPH_H
#define GCC_CGRAPH_H

#include "is-a.h"
#include "plugin-api.h"
#include "vec.h"
#include "basic-block.h"
#include "function.h"
#include "ipa-ref.h"

/* Symbol table consists of functions and variables.
   TODO: add labels and CONST_DECLs.  */
enum symtab_type
{
  SYMTAB_SYMBOL,
  SYMTAB_FUNCTION,
  SYMTAB_VARIABLE
};

/* Section names are stored as reference counted strings in GGC safe hashtable
   (to make them survive through PCH).  */

struct GTY(()) section_hash_entry_d
{
  int ref_count;
  char *name;  /* As long as this datastructure stays in GGC, we can not put
		  string at the tail of structure of GGC dies in horrible
		  way  */
};

typedef struct section_hash_entry_d section_hash_entry;

enum availability
{
  /* Not yet set by cgraph_function_body_availability.  */
  AVAIL_UNSET,
  /* Function body/variable initializer is unknown.  */
  AVAIL_NOT_AVAILABLE,
  /* Function body/variable initializer is known but might be replaced
     by a different one from other compilation unit and thus needs to
     be dealt with a care.  Like AVAIL_NOT_AVAILABLE it can have
     arbitrary side effects on escaping variables and functions, while
     like AVAILABLE it might access static variables.  */
  AVAIL_INTERPOSABLE,
  /* Function body/variable initializer is known and will be used in final
     program.  */
  AVAIL_AVAILABLE,
  /* Function body/variable initializer is known and all it's uses are
     explicitly visible within current unit (ie it's address is never taken and
     it is not exported to other units). Currently used only for functions.  */
  AVAIL_LOCAL
};

/* Classification of symbols WRT partitioning.  */
enum symbol_partitioning_class
{
   /* External declarations are ignored by partitioning algorithms and they are
      added into the boundary later via compute_ltrans_boundary.  */
   SYMBOL_EXTERNAL,
   /* Partitioned symbols are pur into one of partitions.  */
   SYMBOL_PARTITION,
   /* Duplicated symbols (such as comdat or constant pool references) are
      copied into every node needing them via add_symbol_to_partition.  */
   SYMBOL_DUPLICATE
};

/* Base of all entries in the symbol table.
   The symtab_node is inherited by cgraph and varpol nodes.  */
class GTY((desc ("%h.type"), tag ("SYMTAB_SYMBOL"),
	   chain_next ("%h.next"), chain_prev ("%h.previous")))
  symtab_node
{
public:
  /* Return name.  */
  const char *name () const;

  /* Return asm name.  */
  const char * asm_name () const;

  /* Add node into symbol table.  This function is not used directly, but via
     cgraph/varpool node creation routines.  */
  void register_symbol (void);

  /* Remove symbol from symbol table.  */
  void remove (void);

  /* Dump symtab node to F.  */
  void dump (FILE *f);

  /* Dump symtab node to stderr.  */
  void DEBUG_FUNCTION debug (void);

  /* Verify consistency of node.  */
  void DEBUG_FUNCTION verify (void);

  /* Return ipa reference from this symtab_node to
     REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
     of the use and STMT the statement (if it exists).  */
  struct ipa_ref *add_reference (symtab_node *referred_node,
				 enum ipa_ref_use use_type);

  /* Return ipa reference from this symtab_node to
     REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
     of the use and STMT the statement (if it exists).  */
  struct ipa_ref *add_reference (symtab_node *referred_node,
				 enum ipa_ref_use use_type, gimple stmt);

  /* If VAL is a reference to a function or a variable, add a reference from
     this symtab_node to the corresponding symbol table node.  USE_TYPE specify
     type of the use and STMT the statement (if it exists).  Return the new
     reference or NULL if none was created.  */
  struct ipa_ref *maybe_add_reference (tree val, enum ipa_ref_use use_type,
				       gimple stmt);

  /* Clone all references from symtab NODE to this symtab_node.  */
  void clone_references (symtab_node *node);

  /* Remove all stmt references in non-speculative references.
     Those are not maintained during inlining & clonning.
     The exception are speculative references that are updated along
     with callgraph edges associated with them.  */
  void clone_referring (symtab_node *node);

  /* Clone reference REF to this symtab_node and set its stmt to STMT.  */
  struct ipa_ref *clone_reference (struct ipa_ref *ref, gimple stmt);

  /* Find the structure describing a reference to REFERRED_NODE
     and associated with statement STMT.  */
  struct ipa_ref *find_reference (symtab_node *referred_node, gimple stmt,
				  unsigned int lto_stmt_uid);

  /* Remove all references that are associated with statement STMT.  */
  void remove_stmt_references (gimple stmt);

  /* Remove all stmt references in non-speculative references.
     Those are not maintained during inlining & clonning.
     The exception are speculative references that are updated along
     with callgraph edges associated with them.  */
  void clear_stmts_in_references (void);

  /* Remove all references in ref list.  */
  void remove_all_references (void);

  /* Remove all referring items in ref list.  */
  void remove_all_referring (void);

  /* Dump references in ref list to FILE.  */
  void dump_references (FILE *file);

  /* Dump referring in list to FILE.  */
  void dump_referring (FILE *);

  /* Iterates I-th reference in the list, REF is also set.  */
  struct ipa_ref *iterate_reference (unsigned i, struct ipa_ref *&ref);

  /* Iterates I-th referring item in the list, REF is also set.  */
  struct ipa_ref *iterate_referring (unsigned i, struct ipa_ref *&ref);

  /* Iterates I-th referring alias item in the list, REF is also set.  */
  struct ipa_ref *iterate_direct_aliases (unsigned i, struct ipa_ref *&ref);

  /* Return true if symtab node and TARGET represents
     semantically equivalent symbols.  */
  bool semantically_equivalent_p (symtab_node *target);

  /* Classify symbol symtab node for partitioning.  */
  enum symbol_partitioning_class get_partitioning_class (void);

  /* Return comdat group.  */
  tree get_comdat_group ()
    {
      return x_comdat_group;
    }

  /* Return comdat group as identifier_node.  */
  tree get_comdat_group_id ()
    {
      if (x_comdat_group && TREE_CODE (x_comdat_group) != IDENTIFIER_NODE)
	x_comdat_group = DECL_ASSEMBLER_NAME (x_comdat_group);
      return x_comdat_group;
    }

  /* Set comdat group.  */
  void set_comdat_group (tree group)
    {
      gcc_checking_assert (!group || TREE_CODE (group) == IDENTIFIER_NODE
			   || DECL_P (group));
      x_comdat_group = group;
    }

  /* Return section as string.  */
  const char * get_section ()
    {
      if (!x_section)
	return NULL;
      return x_section->name;
    }

  /* Remove node from same comdat group.   */
  void remove_from_same_comdat_group (void);

  /* Add this symtab_node to the same comdat group that OLD is in.  */
  void add_to_same_comdat_group (symtab_node *old_node);

  /* Dissolve the same_comdat_group list in which NODE resides.  */
  void dissolve_same_comdat_group_list (void);

  /* Return true when symtab_node is known to be used from other (non-LTO)
     object file. Known only when doing LTO via linker plugin.  */
  bool used_from_object_file_p (void);

  /* Walk the alias chain to return the symbol NODE is alias of.
     If NODE is not an alias, return NODE.
     When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
  symtab_node *ultimate_alias_target (enum availability *avail = NULL);

  /* Return next reachable static symbol with initializer after NODE.  */
  inline symtab_node *next_defined_symbol (void);

  /* Add reference recording that symtab node is alias of TARGET.
     The function can fail in the case of aliasing cycles; in this case
     it returns false.  */
  bool resolve_alias (symtab_node *target);

  /* C++ FE sometimes change linkage flags after producing same
     body aliases.  */
  void fixup_same_cpp_alias_visibility (symtab_node *target);

  /* Call calback on symtab node and aliases associated to this node.
     When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
     skipped. */
  bool call_for_symbol_and_aliases (bool (*callback) (symtab_node *, void *),
				  void *data,
				  bool include_overwrite);

  /* If node can not be interposable by static or dynamic linker to point to
     different definition, return this symbol. Otherwise look for alias with
     such property and if none exists, introduce new one.  */
  symtab_node *noninterposable_alias (void);

  /* Return node that alias is aliasing.  */
  inline symtab_node *get_alias_target (void);

  /* Set section for symbol and its aliases.  */
  void set_section (const char *section);

  /* Set section, do not recurse into aliases.
     When one wants to change section of symbol and its aliases,
     use set_section.  */
  void set_section_for_node (const char *section);

  /* Set initialization priority to PRIORITY.  */
  void set_init_priority (priority_type priority);

  /* Return the initialization priority.  */
  priority_type get_init_priority ();

  /* Return availability of NODE.  */
  enum availability get_availability (void);

  /* Make DECL local.  */
  void make_decl_local (void);

  /* Return true if list contains an alias.  */
  bool has_aliases_p (void);

  /* Return true when the symbol is real symbol, i.e. it is not inline clone
     or abstract function kept for debug info purposes only.  */
  bool real_symbol_p (void);

  /* Return true if NODE can be discarded by linker from the binary.  */
  inline bool
  can_be_discarded_p (void)
  {
    return (DECL_EXTERNAL (decl)
	    || (get_comdat_group ()
		&& resolution != LDPR_PREVAILING_DEF
		&& resolution != LDPR_PREVAILING_DEF_IRONLY
		&& resolution != LDPR_PREVAILING_DEF_IRONLY_EXP));
  }

  /* Return true if NODE is local to a particular COMDAT group, and must not
     be named from outside the COMDAT.  This is used for C++ decloned
     constructors.  */
  inline bool comdat_local_p (void)
  {
    return (same_comdat_group && !TREE_PUBLIC (decl));
  }

  /* Return true if ONE and TWO are part of the same COMDAT group.  */
  inline bool in_same_comdat_group_p (symtab_node *target);

  /* Return true when there is a reference to node and it is not vtable.  */
  bool address_taken_from_non_vtable_p (void);

  /* Return true if symbol is known to be nonzero.  */
  bool nonzero_address ();

  /* Return symbol table node associated with DECL, if any,
     and NULL otherwise.  */
  static inline symtab_node *get (const_tree decl)
  {
#ifdef ENABLE_CHECKING
    /* Check that we are called for sane type of object - functions
       and static or external variables.  */
    gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL
			 || (TREE_CODE (decl) == VAR_DECL
			     && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
				 || in_lto_p)));
    /* Check that the mapping is sane - perhaps this check can go away,
       but at the moment frontends tends to corrupt the mapping by calling
       memcpy/memset on the tree nodes.  */
    gcc_checking_assert (!decl->decl_with_vis.symtab_node
			 || decl->decl_with_vis.symtab_node->decl == decl);
#endif
    return decl->decl_with_vis.symtab_node;
  }

  /* Dump symbol table to F.  */
  static void dump_table (FILE *);

  /* Dump symbol table to stderr.  */
  static inline DEBUG_FUNCTION void debug_symtab (void)
  {
    dump_table (stderr);
  }

  /* Verify symbol table for internal consistency.  */
  static DEBUG_FUNCTION void verify_symtab_nodes (void);

  /* Return true when NODE is known to be used from other (non-LTO)
     object file. Known only when doing LTO via linker plugin.  */
  static bool used_from_object_file_p_worker (symtab_node *node);

  /* Type of the symbol.  */
  ENUM_BITFIELD (symtab_type) type : 8;

  /* The symbols resolution.  */
  ENUM_BITFIELD (ld_plugin_symbol_resolution) resolution : 8;

  /*** Flags representing the symbol type.  ***/

  /* True when symbol corresponds to a definition in current unit.
     set via cgraph_finalize_function or varpool_finalize_decl  */
  unsigned definition : 1;
  /* True when symbol is an alias.  
     Set by assemble_alias.  */
  unsigned alias : 1;
  /* True when alias is a weakref.  */
  unsigned weakref : 1;
  /* C++ frontend produce same body aliases and extra name aliases for
     virtual functions and vtables that are obviously equivalent.
     Those aliases are bit special, especially because C++ frontend
     visibility code is so ugly it can not get them right at first time
     and their visibility needs to be copied from their "masters" at
     the end of parsing.  */
  unsigned cpp_implicit_alias : 1;
  /* Set once the definition was analyzed.  The list of references and
     other properties are built during analysis.  */
  unsigned analyzed : 1;
  /* Set for write-only variables.  */
  unsigned writeonly : 1;


  /*** Visibility and linkage flags.  ***/

  /* Set when function is visible by other units.  */
  unsigned externally_visible : 1;
  /* The symbol will be assumed to be used in an invisible way (like
     by an toplevel asm statement).  */
  unsigned force_output : 1;
  /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be
     exported.  Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted
     to static and it does not inhibit optimization.  */
  unsigned forced_by_abi : 1;
  /* True when the name is known to be unique and thus it does not need mangling.  */
  unsigned unique_name : 1;
  /* Specify whether the section was set by user or by
     compiler via -ffunction-sections.  */
  unsigned implicit_section : 1;
  /* True when body and other characteristics have been removed by
     symtab_remove_unreachable_nodes. */
  unsigned body_removed : 1;

  /*** WHOPR Partitioning flags.
       These flags are used at ltrans stage when only part of the callgraph is
       available. ***/

  /* Set when variable is used from other LTRANS partition.  */
  unsigned used_from_other_partition : 1;
  /* Set when function is available in the other LTRANS partition.  
     During WPA output it is used to mark nodes that are present in
     multiple partitions.  */
  unsigned in_other_partition : 1;



  /*** other flags.  ***/

  /* Set when symbol has address taken. */
  unsigned address_taken : 1;
  /* Set when init priority is set.  */
  unsigned in_init_priority_hash : 1;


  /* Ordering of all symtab entries.  */
  int order;

  /* Declaration representing the symbol.  */
  tree decl;

  /* Linked list of symbol table entries starting with symtab_nodes.  */
  symtab_node *next;
  symtab_node *previous;

  /* Linked list of symbols with the same asm name.  There may be multiple
     entries for single symbol name during LTO, because symbols are renamed
     only after partitioning.

     Because inline clones are kept in the assembler name has, they also produce
     duplicate entries.

     There are also several long standing bugs where frontends and builtin
     code produce duplicated decls.  */
  symtab_node *next_sharing_asm_name;
  symtab_node *previous_sharing_asm_name;

  /* Circular list of nodes in the same comdat group if non-NULL.  */
  symtab_node *same_comdat_group;

  /* Vectors of referring and referenced entities.  */
  struct ipa_ref_list ref_list;

  /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer
     depending to what was known to frontend on the creation time.
     Once alias is resolved, this pointer become NULL.  */
  tree alias_target;

  /* File stream where this node is being written to.  */
  struct lto_file_decl_data * lto_file_data;

  PTR GTY ((skip)) aux;

  /* Comdat group the symbol is in.  Can be private if GGC allowed that.  */
  tree x_comdat_group;

  /* Section name. Again can be private, if allowed.  */
  section_hash_entry *x_section;

protected:
  /* Dump base fields of symtab nodes to F.  Not to be used directly.  */
  void dump_base (FILE *);

  /* Verify common part of symtab node.  */
  bool DEBUG_FUNCTION verify_base (void);

  /* Remove node from symbol table.  This function is not used directly, but via
     cgraph/varpool node removal routines.  */
  void unregister (void);

  /* Return the initialization and finalization priority information for
     DECL.  If there is no previous priority information, a freshly
     allocated structure is returned.  */
  struct symbol_priority_map *priority_info (void);

private:
  /* Worker for set_section.  */
  static bool set_section (symtab_node *n, void *s);

  /* Worker for symtab_resolve_alias.  */
  static bool set_implicit_section (symtab_node *n, void *);

  /* Worker searching noninterposable alias.  */
  static bool noninterposable_alias (symtab_node *node, void *data);
};

/* Walk all aliases for NODE.  */
#define FOR_EACH_ALIAS(node, alias) \
  for (unsigned x_i = 0; node->iterate_direct_aliases (x_i, alias); x_i++)

/* This is the information that is put into the cgraph local structure
   to recover a function.  */
struct lto_file_decl_data;

extern const char * const cgraph_availability_names[];
extern const char * const ld_plugin_symbol_resolution_names[];
extern const char * const tls_model_names[];

/* Information about thunk, used only for same body aliases.  */

struct GTY(()) cgraph_thunk_info {
  /* Information about the thunk.  */
  HOST_WIDE_INT fixed_offset;
  HOST_WIDE_INT virtual_value;
  tree alias;
  bool this_adjusting;
  bool virtual_offset_p;
  /* Set to true when alias node is thunk.  */
  bool thunk_p;
};

/* Information about the function collected locally.
   Available after function is analyzed.  */

struct GTY(()) cgraph_local_info {
  /* Set when function function is visible in current compilation unit only
     and its address is never taken.  */
  unsigned local : 1;

  /* False when there is something makes versioning impossible.  */
  unsigned versionable : 1;

  /* False when function calling convention and signature can not be changed.
     This is the case when __builtin_apply_args is used.  */
  unsigned can_change_signature : 1;

  /* True when the function has been originally extern inline, but it is
     redefined now.  */
  unsigned redefined_extern_inline : 1;

  /* True if the function may enter serial irrevocable mode.  */
  unsigned tm_may_enter_irr : 1;
};

/* Information about the function that needs to be computed globally
   once compilation is finished.  Available only with -funit-at-a-time.  */

struct GTY(()) cgraph_global_info {
  /* For inline clones this points to the function they will be
     inlined into.  */
  cgraph_node *inlined_to;
};

/* Information about the function that is propagated by the RTL backend.
   Available only for functions that has been already assembled.  */

struct GTY(()) cgraph_rtl_info {
   unsigned int preferred_incoming_stack_boundary;

  /* Call unsaved hard registers really used by the corresponding
     function (including ones used by functions called by the
     function).  */
  HARD_REG_SET function_used_regs;
  /* Set if function_used_regs is valid.  */
  unsigned function_used_regs_valid: 1;
};

/* Represent which DECL tree (or reference to such tree)
   will be replaced by another tree while versioning.  */
struct GTY(()) ipa_replace_map
{
  /* The tree that will be replaced.  */
  tree old_tree;
  /* The new (replacing) tree.  */
  tree new_tree;
  /* Parameter number to replace, when old_tree is NULL.  */
  int parm_num;
  /* True when a substitution should be done, false otherwise.  */
  bool replace_p;
  /* True when we replace a reference to old_tree.  */
  bool ref_p;
};

struct GTY(()) cgraph_clone_info
{
  vec<ipa_replace_map *, va_gc> *tree_map;
  bitmap args_to_skip;
  bitmap combined_args_to_skip;
};

enum cgraph_simd_clone_arg_type
{
  SIMD_CLONE_ARG_TYPE_VECTOR,
  SIMD_CLONE_ARG_TYPE_UNIFORM,
  SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP,
  SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP,
  SIMD_CLONE_ARG_TYPE_MASK
};

/* Function arguments in the original function of a SIMD clone.
   Supplementary data for `struct simd_clone'.  */

struct GTY(()) cgraph_simd_clone_arg {
  /* Original function argument as it originally existed in
     DECL_ARGUMENTS.  */
  tree orig_arg;

  /* orig_arg's function (or for extern functions type from
     TYPE_ARG_TYPES).  */
  tree orig_type;

  /* If argument is a vector, this holds the vector version of
     orig_arg that after adjusting the argument types will live in
     DECL_ARGUMENTS.  Otherwise, this is NULL.

     This basically holds:
       vector(simdlen) __typeof__(orig_arg) new_arg.  */
  tree vector_arg;

  /* vector_arg's type (or for extern functions new vector type.  */
  tree vector_type;

  /* If argument is a vector, this holds the array where the simd
     argument is held while executing the simd clone function.  This
     is a local variable in the cloned function.  Its content is
     copied from vector_arg upon entry to the clone.

     This basically holds:
       __typeof__(orig_arg) simd_array[simdlen].  */
  tree simd_array;

  /* A SIMD clone's argument can be either linear (constant or
     variable), uniform, or vector.  */
  enum cgraph_simd_clone_arg_type arg_type;

  /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP this is
     the constant linear step, if arg_type is
     SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP, this is index of
     the uniform argument holding the step, otherwise 0.  */
  HOST_WIDE_INT linear_step;

  /* Variable alignment if available, otherwise 0.  */
  unsigned int alignment;
};

/* Specific data for a SIMD function clone.  */

struct GTY(()) cgraph_simd_clone {
  /* Number of words in the SIMD lane associated with this clone.  */
  unsigned int simdlen;

  /* Number of annotated function arguments in `args'.  This is
     usually the number of named arguments in FNDECL.  */
  unsigned int nargs;

  /* Max hardware vector size in bits for integral vectors.  */
  unsigned int vecsize_int;

  /* Max hardware vector size in bits for floating point vectors.  */
  unsigned int vecsize_float;

  /* The mangling character for a given vector size.  This is is used
     to determine the ISA mangling bit as specified in the Intel
     Vector ABI.  */
  unsigned char vecsize_mangle;

  /* True if this is the masked, in-branch version of the clone,
     otherwise false.  */
  unsigned int inbranch : 1;

  /* True if this is a Cilk Plus variant.  */
  unsigned int cilk_elemental : 1;

  /* Doubly linked list of SIMD clones.  */
  cgraph_node *prev_clone, *next_clone;

  /* Original cgraph node the SIMD clones were created for.  */
  cgraph_node *origin;

  /* Annotated function arguments for the original function.  */
  struct cgraph_simd_clone_arg GTY((length ("%h.nargs"))) args[1];
};

/* Function Multiversioning info.  */
struct GTY(()) cgraph_function_version_info {
  /* The cgraph_node for which the function version info is stored.  */
  cgraph_node *this_node;
  /* Chains all the semantically identical function versions.  The
     first function in this chain is the version_info node of the
     default function.  */
  struct cgraph_function_version_info *prev;
  /* If this version node corresponds to a dispatcher for function
     versions, this points to the version info node of the default
     function, the first node in the chain.  */
  struct cgraph_function_version_info *next;
  /* If this node corresponds to a function version, this points
     to the dispatcher function decl, which is the function that must
     be called to execute the right function version at run-time.

     If this cgraph node is a dispatcher (if dispatcher_function is
     true, in the cgraph_node struct) for function versions, this
     points to resolver function, which holds the function body of the
     dispatcher. The dispatcher decl is an alias to the resolver
     function decl.  */
  tree dispatcher_resolver;
};

#define DEFCIFCODE(code, type, string)	CIF_ ## code,
/* Reasons for inlining failures.  */

enum cgraph_inline_failed_t {
#include "cif-code.def"
  CIF_N_REASONS
};

enum cgraph_inline_failed_type_t
{
  CIF_FINAL_NORMAL = 0,
  CIF_FINAL_ERROR
};

struct cgraph_edge;

/* The cgraph data structure.
   Each function decl has assigned cgraph_node listing callees and callers.  */

struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node {
public:
  /* Remove the node from cgraph and all inline clones inlined into it.
     Skip however removal of FORBIDDEN_NODE and return true if it needs to be
     removed.  This allows to call the function from outer loop walking clone
     tree.  */
  bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL);

  /* Record all references from cgraph_node that are taken
     in statement STMT.  */
  void record_stmt_references (gimple stmt);

  /* Like cgraph_set_call_stmt but walk the clone tree and update all
     clones sharing the same function body.
     When WHOLE_SPECULATIVE_EDGES is true, all three components of
     speculative edge gets updated.  Otherwise we update only direct
     call.  */
  void set_call_stmt_including_clones (gimple old_stmt, gimple new_stmt,
				       bool update_speculative = true);

  /* Walk the alias chain to return the function cgraph_node is alias of.
     Walk through thunk, too.
     When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
  cgraph_node *function_symbol (enum availability *avail = NULL);

  /* Create node representing clone of N executed COUNT times.  Decrease
     the execution counts from original node too.
     The new clone will have decl set to DECL that may or may not be the same
     as decl of N.

     When UPDATE_ORIGINAL is true, the counts are subtracted from the original
     function's profile to reflect the fact that part of execution is handled
     by node.
     When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
     the new clone. Otherwise the caller is responsible for doing so later.

     If the new node is being inlined into another one, NEW_INLINED_TO should be
     the outline function the new one is (even indirectly) inlined to.
     All hooks will see this in node's global.inlined_to, when invoked.
     Can be NULL if the node is not inlined.  */
  cgraph_node *create_clone (tree decl, gcov_type count, int freq,
			     bool update_original,
			     vec<cgraph_edge *> redirect_callers,
			     bool call_duplication_hook,
			     struct cgraph_node *new_inlined_to,
			     bitmap args_to_skip);

  /* Create callgraph node clone with new declaration.  The actual body will
     be copied later at compilation stage.  */
  cgraph_node *create_virtual_clone (vec<cgraph_edge *> redirect_callers,
				     vec<ipa_replace_map *, va_gc> *tree_map,
				     bitmap args_to_skip, const char * suffix);

  /* cgraph node being removed from symbol table; see if its entry can be
   replaced by other inline clone.  */
  cgraph_node *find_replacement (void);

  /* Create a new cgraph node which is the new version of
     callgraph node.  REDIRECT_CALLERS holds the callers
     edges which should be redirected to point to
     NEW_VERSION.  ALL the callees edges of the node
     are cloned to the new version node.  Return the new
     version node.

     If non-NULL BLOCK_TO_COPY determine what basic blocks
     was copied to prevent duplications of calls that are dead
     in the clone.  */

  cgraph_node *create_version_clone (tree new_decl,
				    vec<cgraph_edge *> redirect_callers,
				    bitmap bbs_to_copy);

  /* Perform function versioning.
     Function versioning includes copying of the tree and
     a callgraph update (creating a new cgraph node and updating
     its callees and callers).

     REDIRECT_CALLERS varray includes the edges to be redirected
     to the new version.

     TREE_MAP is a mapping of tree nodes we want to replace with
     new ones (according to results of prior analysis).

     If non-NULL ARGS_TO_SKIP determine function parameters to remove
     from new version.
     If SKIP_RETURN is true, the new version will return void.
     If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
     If non_NULL NEW_ENTRY determine new entry BB of the clone.

     Return the new version's cgraph node.  */
  cgraph_node *create_version_clone_with_body
    (vec<cgraph_edge *> redirect_callers,
     vec<ipa_replace_map *, va_gc> *tree_map, bitmap args_to_skip,
     bool skip_return, bitmap bbs_to_copy, basic_block new_entry_block,
     const char *clone_name);

  /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
     corresponding to cgraph_node.  */
  struct cgraph_function_version_info *insert_new_function_version (void);

  /* Get the cgraph_function_version_info node corresponding to node.  */
  struct cgraph_function_version_info *function_version (void);

  /* Discover all functions and variables that are trivially needed, analyze
     them as well as all functions and variables referred by them  */
  void analyze (void);

  /* Add thunk alias into callgraph.  The alias declaration is ALIAS and it
     aliases DECL with an adjustments made into the first parameter.
     See comments in thunk_adjust for detail on the parameters.  */
  cgraph_node * create_thunk (tree alias, tree, bool this_adjusting,
			      HOST_WIDE_INT fixed_offset,
			      HOST_WIDE_INT virtual_value,
			      tree virtual_offset,
			      tree real_alias);


  /* Return node that alias is aliasing.  */
  inline cgraph_node *get_alias_target (void);

  /* Given function symbol, walk the alias chain to return the function node
     is alias of. Do not walk through thunks.
     When AVAILABILITY is non-NULL, get minimal availability in the chain.  */

  cgraph_node *ultimate_alias_target (availability *availability = NULL);

  /* Expand thunk NODE to gimple if possible.
     When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
     no assembler is produced.
     When OUTPUT_ASM_THUNK is true, also produce assembler for
     thunks that are not lowered.  */
  bool expand_thunk (bool output_asm_thunks, bool force_gimple_thunk);

  /* As an GCC extension we allow redefinition of the function.  The
     semantics when both copies of bodies differ is not well defined.
     We replace the old body with new body so in unit at a time mode
     we always use new body, while in normal mode we may end up with
     old body inlined into some functions and new body expanded and
     inlined in others.  */
  void reset (void);

  /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
     kind of wrapper method.  */
  void create_wrapper (cgraph_node *target);

  /* Verify cgraph nodes of the cgraph node.  */
  void DEBUG_FUNCTION verify_node (void);

  /* Remove function from symbol table.  */
  void remove (void);

  /* Dump call graph node to file F.  */
  void dump (FILE *f);

  /* Dump call graph node to stderr.  */
  void DEBUG_FUNCTION debug (void);

  /* When doing LTO, read cgraph_node's body from disk if it is not already
     present.  */
  bool get_body (void);

  /* Release memory used to represent body of function.
     Use this only for functions that are released before being translated to
     target code (i.e. RTL).  Functions that are compiled to RTL and beyond
     are free'd in final.c via free_after_compilation().  */
  void release_body (void);

  /* cgraph_node is no longer nested function; update cgraph accordingly.  */
  void unnest (void);

  /* Bring cgraph node local.  */
  void make_local (void);

  /* Likewise indicate that a node is having address taken.  */
  void mark_address_taken (void);

  /* Set fialization priority to PRIORITY.  */
  void set_fini_priority (priority_type priority);

  /* Return the finalization priority.  */
  priority_type get_fini_priority (void);

  /* Create edge from a given function to CALLEE in the cgraph.  */
  struct cgraph_edge *create_edge (cgraph_node *callee,
				   gimple call_stmt, gcov_type count,
				   int freq);
  /* Create an indirect edge with a yet-undetermined callee where the call
     statement destination is a formal parameter of the caller with index
     PARAM_INDEX. */
  struct cgraph_edge *create_indirect_edge (gimple call_stmt, int ecf_flags,
					    gcov_type count, int freq);

  /* Like cgraph_create_edge walk the clone tree and update all clones sharing
   same function body.  If clones already have edge for OLD_STMT; only
   update the edge same way as cgraph_set_call_stmt_including_clones does.  */
  void create_edge_including_clones (struct cgraph_node *callee,
				     gimple old_stmt, gimple stmt,
				     gcov_type count,
				     int freq,
				     cgraph_inline_failed_t reason);

  /* Return the callgraph edge representing the GIMPLE_CALL statement
     CALL_STMT.  */
  cgraph_edge *get_edge (gimple call_stmt);

  /* Collect all callers of cgraph_node and its aliases that are known to lead
     to NODE (i.e. are not overwritable).  */
  vec<cgraph_edge *> collect_callers (void);

  /* Remove all callers from the node.  */
  void remove_callers (void);

  /* Remove all callees from the node.  */
  void remove_callees (void);

  /* Return function availability.  See cgraph.h for description of individual
     return values.  */
  enum availability get_availability (void);

  /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node
     if any to NOTHROW.  */
  void set_nothrow_flag (bool nothrow);

  /* Set TREE_READONLY on cgraph_node's decl and on aliases of the node
     if any to READONLY.  */
  void set_const_flag (bool readonly, bool looping);

  /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
     if any to PURE.  */
  void set_pure_flag (bool pure, bool looping);

  /* Call all node duplication hooks.  */
  void call_duplication_hooks (cgraph_node *node2);

  /* Call calback on function and aliases associated to the function.
     When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
     skipped. */

  bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
						      void *),
				    void *data, bool include_overwritable);

  /* Call calback on cgraph_node, thunks and aliases associated to NODE.
     When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
     skipped.  */
  bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node,
							   void *data),
					 void *data,
					 bool include_overwritable);

  /* Call all node insertion hooks.  */
  void call_function_insertion_hooks (void);

  /* Likewise indicate that a node is needed, i.e. reachable via some
     external means.  */
  inline void mark_force_output (void);

  /* Return true when function can be marked local.  */
  bool local_p (void);

  /* Return true if cgraph_node can be made local for API change.
     Extern inline functions and C++ COMDAT functions can be made local
     at the expense of possible code size growth if function is used in multiple
     compilation units.  */
  bool can_be_local_p (void);

  /* Return true when cgraph_node can not return or throw and thus
     it is safe to ignore its side effects for IPA analysis.  */
  bool cannot_return_p (void);

  /* Return true when function cgraph_node and all its aliases are only called
     directly.
     i.e. it is not externally visible, address was not taken and
     it is not used in any other non-standard way.  */
  bool only_called_directly_p (void);

  /* Return true when function is only called directly or it has alias.
     i.e. it is not externally visible, address was not taken and
     it is not used in any other non-standard way.  */
  inline bool only_called_directly_or_aliased_p (void);

  /* Return true when function cgraph_node can be expected to be removed
     from program when direct calls in this compilation unit are removed.

     As a special case COMDAT functions are
     cgraph_can_remove_if_no_direct_calls_p while the are not
     cgraph_only_called_directly_p (it is possible they are called from other
     unit)

     This function behaves as cgraph_only_called_directly_p because eliminating
     all uses of COMDAT function does not make it necessarily disappear from
     the program unless we are compiling whole program or we do LTO.  In this
     case we know we win since dynamic linking will not really discard the
     linkonce section.  */
  bool will_be_removed_from_program_if_no_direct_calls_p (void);

  /* Return true when function can be removed from callgraph
     if all direct calls are eliminated.  */
  bool can_remove_if_no_direct_calls_and_refs_p (void);

  /* Return true when function cgraph_node and its aliases can be removed from
     callgraph if all direct calls are eliminated.  */
  bool can_remove_if_no_direct_calls_p (void);

  /* Return true when callgraph node is a function with Gimple body defined
     in current unit.  Functions can also be define externally or they
     can be thunks with no Gimple representation.

     Note that at WPA stage, the function body may not be present in memory.  */
  inline bool has_gimple_body_p (void);

  /* Return true if function should be optimized for size.  */
  bool optimize_for_size_p (void);

  /* Dump the callgraph to file F.  */
  static void dump_cgraph (FILE *f);

  /* Dump the call graph to stderr.  */
  static inline void debug_cgraph (void)
  {
    dump_cgraph (stderr);
  }

  /* Record that DECL1 and DECL2 are semantically identical function
     versions.  */
  static void record_function_versions (tree decl1, tree decl2);

  /* Remove the cgraph_function_version_info and cgraph_node for DECL.  This
     DECL is a duplicate declaration.  */
  static void delete_function_version (tree decl);

  /* Add the function FNDECL to the call graph.
     Unlike cgraph_finalize_function, this function is intended to be used
     by middle end and allows insertion of new function at arbitrary point
     of compilation.  The function can be either in high, low or SSA form
     GIMPLE.

     The function is assumed to be reachable and have address taken (so no
     API breaking optimizations are performed on it).

     Main work done by this function is to enqueue the function for later
     processing to avoid need the passes to be re-entrant.  */
  static void add_new_function (tree fndecl, bool lowered);

  /* Return callgraph node for given symbol and check it is a function. */
  static inline cgraph_node *get (const_tree decl)
  {
    gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL);
    return dyn_cast <cgraph_node *> (symtab_node::get (decl));
  }

  /* Return cgraph node assigned to DECL.  Create new one when needed.  */
  static cgraph_node * create (tree decl);

  /* Allocate new callgraph node and insert it into basic data structures.  */
  static cgraph_node * create_empty (void);

  /* Try to find a call graph node for declaration DECL and if it does not
     exist or if it corresponds to an inline clone, create a new one.  */
  static cgraph_node * get_create (tree);

  /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
     Return NULL if there's no such node.  */
  static cgraph_node *get_for_asmname (tree asmname);

  /* Attempt to mark ALIAS as an alias to DECL.  Return alias node if
     successful and NULL otherwise.
     Same body aliases are output whenever the body of DECL is output,
     and cgraph_node::get (ALIAS) transparently
     returns cgraph_node::get (DECL).  */
  static cgraph_node * create_same_body_alias (tree alias, tree decl);

  /* Worker for cgraph_can_remove_if_no_direct_calls_p.  */
  static bool used_from_object_file_p_worker (cgraph_node *node, void *)
  {
    return node->used_from_object_file_p ();
  }

  /* Return true when cgraph_node can not be local.
     Worker for cgraph_local_node_p.  */
  static bool non_local_p (cgraph_node *node, void *);

  /* Verify whole cgraph structure.  */
  static void DEBUG_FUNCTION verify_cgraph_nodes (void);

  /* Worker to bring NODE local.  */
  static bool make_local (cgraph_node *node, void *);

  /* Mark ALIAS as an alias to DECL.  DECL_NODE is cgraph node representing
     the function body is associated
     with (not necessarily cgraph_node (DECL).  */
  static cgraph_node *create_alias (tree alias, tree target);

  static cgraph_edge * create_edge (cgraph_node *caller, cgraph_node *callee,
				    gimple call_stmt, gcov_type count,
				    int freq,
				    bool indir_unknown_callee);

  struct cgraph_edge *callees;
  struct cgraph_edge *callers;
  /* List of edges representing indirect calls with a yet undetermined
     callee.  */
  struct cgraph_edge *indirect_calls;
  /* For nested functions points to function the node is nested in.  */
  cgraph_node *origin;
  /* Points to first nested function, if any.  */
  cgraph_node *nested;
  /* Pointer to the next function with same origin, if any.  */
  cgraph_node *next_nested;
  /* Pointer to the next clone.  */
  cgraph_node *next_sibling_clone;
  cgraph_node *prev_sibling_clone;
  cgraph_node *clones;
  cgraph_node *clone_of;
  /* For functions with many calls sites it holds map from call expression
     to the edge to speed up cgraph_edge function.  */
  htab_t GTY((param_is (struct cgraph_edge))) call_site_hash;
  /* Declaration node used to be clone of. */
  tree former_clone_of;

  /* If this is a SIMD clone, this points to the SIMD specific
     information for it.  */
  struct cgraph_simd_clone *simdclone;
  /* If this function has SIMD clones, this points to the first clone.  */
  cgraph_node *simd_clones;

  /* Interprocedural passes scheduled to have their transform functions
     applied next time we execute local pass on them.  We maintain it
     per-function in order to allow IPA passes to introduce new functions.  */
  vec<ipa_opt_pass> GTY((skip)) ipa_transforms_to_apply;

  struct cgraph_local_info local;
  struct cgraph_global_info global;
  struct cgraph_rtl_info rtl;
  struct cgraph_clone_info clone;
  struct cgraph_thunk_info thunk;

  /* Expected number of executions: calculated in profile.c.  */
  gcov_type count;
  /* How to scale counts at materialization time; used to merge
     LTO units with different number of profile runs.  */
  int count_materialization_scale;
  /* Unique id of the node.  */
  int uid;
  /* ID assigned by the profiling.  */
  unsigned int profile_id;
  /* Time profiler: first run of function.  */
  int tp_first_run;

  /* Set when decl is an abstract function pointed to by the
     ABSTRACT_DECL_ORIGIN of a reachable function.  */
  unsigned used_as_abstract_origin : 1;
  /* Set once the function is lowered (i.e. its CFG is built).  */
  unsigned lowered : 1;
  /* Set once the function has been instantiated and its callee
     lists created.  */
  unsigned process : 1;
  /* How commonly executed the node is.  Initialized during branch
     probabilities pass.  */
  ENUM_BITFIELD (node_frequency) frequency : 2;
  /* True when function can only be called at startup (from static ctor).  */
  unsigned only_called_at_startup : 1;
  /* True when function can only be called at startup (from static dtor).  */
  unsigned only_called_at_exit : 1;
  /* True when function is the transactional clone of a function which
     is called only from inside transactions.  */
  /* ?? We should be able to remove this.  We have enough bits in
     cgraph to calculate it.  */
  unsigned tm_clone : 1;
  /* True if this decl is a dispatcher for function versions.  */
  unsigned dispatcher_function : 1;
  /* True if this decl calls a COMDAT-local function.  This is set up in
     compute_inline_parameters and inline_call.  */
  unsigned calls_comdat_local : 1;
};

/* A cgraph node set is a collection of cgraph nodes.  A cgraph node
   can appear in multiple sets.  */
struct cgraph_node_set_def
{
  struct pointer_map_t *map;
  vec<cgraph_node *> nodes;
};

typedef cgraph_node_set_def *cgraph_node_set;
typedef struct varpool_node_set_def *varpool_node_set;

class varpool_node;

/* A varpool node set is a collection of varpool nodes.  A varpool node
   can appear in multiple sets.  */
struct varpool_node_set_def
{
  struct pointer_map_t * map;
  vec<varpool_node *> nodes;
};

/* Iterator structure for cgraph node sets.  */
struct cgraph_node_set_iterator
{
  cgraph_node_set set;
  unsigned index;
};

/* Iterator structure for varpool node sets.  */
struct varpool_node_set_iterator
{
  varpool_node_set set;
  unsigned index;
};

/* Structure containing additional information about an indirect call.  */

struct GTY(()) cgraph_indirect_call_info
{
  /* When polymorphic is set, this field contains offset where the object which
     was actually used in the polymorphic resides within a larger structure.
     If agg_contents is set, the field contains the offset within the aggregate
     from which the address to call was loaded.  */
  HOST_WIDE_INT offset;
  /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set).  */
  HOST_WIDE_INT otr_token;
  /* Type of the object from OBJ_TYPE_REF_OBJECT. */
  tree otr_type, outer_type;
  /* Index of the parameter that is called.  */
  int param_index;
  /* ECF flags determined from the caller.  */
  int ecf_flags;
  /* Profile_id of common target obtrained from profile.  */
  int common_target_id;
  /* Probability that call will land in function with COMMON_TARGET_ID.  */
  int common_target_probability;

  /* Set when the call is a virtual call with the parameter being the
     associated object pointer rather than a simple direct call.  */
  unsigned polymorphic : 1;
  /* Set when the call is a call of a pointer loaded from contents of an
     aggregate at offset.  */
  unsigned agg_contents : 1;
  /* Set when this is a call through a member pointer.  */
  unsigned member_ptr : 1;
  /* When the previous bit is set, this one determines whether the destination
     is loaded from a parameter passed by reference. */
  unsigned by_ref : 1;
  unsigned int maybe_in_construction : 1;
  unsigned int maybe_derived_type : 1;
};

struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"))) cgraph_edge {
  /* Expected number of executions: calculated in profile.c.  */
  gcov_type count;
  cgraph_node *caller;
  cgraph_node *callee;
  struct cgraph_edge *prev_caller;
  struct cgraph_edge *next_caller;
  struct cgraph_edge *prev_callee;
  struct cgraph_edge *next_callee;
  gimple call_stmt;
  /* Additional information about an indirect call.  Not cleared when an edge
     becomes direct.  */
  struct cgraph_indirect_call_info *indirect_info;
  PTR GTY ((skip (""))) aux;
  /* When equal to CIF_OK, inline this call.  Otherwise, points to the
     explanation why function was not inlined.  */
  enum cgraph_inline_failed_t inline_failed;
  /* The stmt_uid of call_stmt.  This is used by LTO to recover the call_stmt
     when the function is serialized in.  */
  unsigned int lto_stmt_uid;
  /* Expected frequency of executions within the function.
     When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
     per function call.  The range is 0 to CGRAPH_FREQ_MAX.  */
  int frequency;
  /* Unique id of the edge.  */
  int uid;
  /* Whether this edge was made direct by indirect inlining.  */
  unsigned int indirect_inlining_edge : 1;
  /* Whether this edge describes an indirect call with an undetermined
     callee.  */
  unsigned int indirect_unknown_callee : 1;
  /* Whether this edge is still a dangling  */
  /* True if the corresponding CALL stmt cannot be inlined.  */
  unsigned int call_stmt_cannot_inline_p : 1;
  /* Can this call throw externally?  */
  unsigned int can_throw_external : 1;
  /* Edges with SPECULATIVE flag represents indirect calls that was
     speculatively turned into direct (i.e. by profile feedback).
     The final code sequence will have form:

     if (call_target == expected_fn)
       expected_fn ();
     else
       call_target ();

     Every speculative call is represented by three components attached
     to a same call statement:
     1) a direct call (to expected_fn)
     2) an indirect call (to call_target)
     3) a IPA_REF_ADDR refrence to expected_fn.

     Optimizers may later redirect direct call to clone, so 1) and 3)
     do not need to necesarily agree with destination.  */
  unsigned int speculative : 1;
};

#define CGRAPH_FREQ_BASE 1000
#define CGRAPH_FREQ_MAX 100000

/* The varpool data structure.
   Each static variable decl has assigned varpool_node.  */

class GTY((tag ("SYMTAB_VARIABLE"))) varpool_node : public symtab_node {
public:
  /* Set when variable is scheduled to be assembled.  */
  unsigned output : 1;

  /* Set if the variable is dynamically initialized, except for
     function local statics.   */
  unsigned dynamically_initialized : 1;

  ENUM_BITFIELD(tls_model) tls_model : 3;

  /* Set if the variable is known to be used by single function only.
     This is computed by ipa_signle_use pass and used by late optimizations
     in places where optimization would be valid for local static variable
     if we did not do any inter-procedural code movement.  */
  unsigned used_by_single_function : 1;

  /* Dump given cgraph node to F.  */
  void dump (FILE *f);

  /* Remove variable from symbol table.  */
  void remove (void);
};

/* Every top level asm statement is put into a asm_node.  */

struct GTY(()) asm_node {
  /* Next asm node.  */
  struct asm_node *next;
  /* String for this asm node.  */
  tree asm_str;
  /* Ordering of all cgraph nodes.  */
  int order;
};

/* Report whether or not THIS symtab node is a function, aka cgraph_node.  */

template <>
template <>
inline bool
is_a_helper <cgraph_node *>::test (symtab_node *p)
{
  return p && p->type == SYMTAB_FUNCTION;
}

/* Report whether or not THIS symtab node is a vriable, aka varpool_node.  */

template <>
template <>
inline bool
is_a_helper <varpool_node *>::test (symtab_node *p)
{
  return p && p->type == SYMTAB_VARIABLE;
}

extern GTY(()) symtab_node *symtab_nodes;
extern GTY(()) int cgraph_n_nodes;
extern GTY(()) int cgraph_max_uid;
extern GTY(()) int cgraph_edge_max_uid;
extern bool cgraph_global_info_ready;
enum cgraph_state
{
  /* Frontend is parsing and finalizing functions.  */
  CGRAPH_STATE_PARSING,
  /* Callgraph is being constructed.  It is safe to add new functions.  */
  CGRAPH_STATE_CONSTRUCTION,
  /* Callgraph is being at LTO time.  */
  CGRAPH_LTO_STREAMING,
  /* Callgraph is built and IPA passes are being run.  */
  CGRAPH_STATE_IPA,
  /* Callgraph is built and all functions are transformed to SSA form.  */
  CGRAPH_STATE_IPA_SSA,
  /* Functions are now ordered and being passed to RTL expanders.  */
  CGRAPH_STATE_EXPANSION,
  /* All cgraph expansion is done.  */
  CGRAPH_STATE_FINISHED
};
extern enum cgraph_state cgraph_state;
extern bool cgraph_function_flags_ready;
extern cgraph_node_set cgraph_new_nodes;

extern GTY(()) struct asm_node *asm_nodes;
extern GTY(()) int symtab_order;
extern bool cpp_implicit_aliases_done;

/* In symtab.c  */
symtab_node *symtab_node_for_asm (const_tree asmname);

/* In cgraph.c  */
void release_function_body (tree);
struct cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void);
void cgraph_remove_edge (struct cgraph_edge *);

void cgraph_set_call_stmt (struct cgraph_edge *, gimple, bool update_speculative = true);
void cgraph_update_edges_for_call_stmt (gimple, tree, gimple);
struct cgraph_local_info *cgraph_local_info (tree);
struct cgraph_global_info *cgraph_global_info (tree);
struct cgraph_rtl_info *cgraph_rtl_info (tree);
void cgraph_call_edge_duplication_hooks (struct cgraph_edge *,
				         struct cgraph_edge *);

bool cgraph_function_possibly_inlined_p (tree);
bool cgraph_edge_cannot_lead_to_return (struct cgraph_edge *);
void cgraph_redirect_edge_callee (struct cgraph_edge *, cgraph_node *);
struct cgraph_edge *cgraph_make_edge_direct (struct cgraph_edge *,
					     cgraph_node *);

const char* cgraph_inline_failed_string (cgraph_inline_failed_t);
cgraph_inline_failed_type_t cgraph_inline_failed_type (cgraph_inline_failed_t);

bool resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution);
typedef void (*cgraph_edge_hook)(struct cgraph_edge *, void *);
typedef void (*cgraph_node_hook)(cgraph_node *, void *);
typedef void (*varpool_node_hook)(varpool_node *, void *);
typedef void (*cgraph_2edge_hook)(struct cgraph_edge *, struct cgraph_edge *,
				  void *);
typedef void (*cgraph_2node_hook)(cgraph_node *, cgraph_node *,
				  void *);
struct cgraph_edge_hook_list;
struct cgraph_node_hook_list;
struct varpool_node_hook_list;
struct cgraph_2edge_hook_list;
struct cgraph_2node_hook_list;
struct cgraph_edge_hook_list *cgraph_add_edge_removal_hook (cgraph_edge_hook, void *);
void cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list *);
cgraph_node_hook_list *cgraph_add_node_removal_hook (cgraph_node_hook,
							    void *);
void cgraph_remove_node_removal_hook (cgraph_node_hook_list *);
struct varpool_node_hook_list *varpool_add_node_removal_hook (varpool_node_hook,
							      void *);
void varpool_remove_node_removal_hook (struct varpool_node_hook_list *);
cgraph_node_hook_list *cgraph_add_function_insertion_hook (cgraph_node_hook,
							          void *);
void cgraph_remove_function_insertion_hook (cgraph_node_hook_list *);
struct varpool_node_hook_list *varpool_add_variable_insertion_hook (varpool_node_hook,
							            void *);
void varpool_remove_variable_insertion_hook (struct varpool_node_hook_list *);
struct cgraph_2edge_hook_list *cgraph_add_edge_duplication_hook (cgraph_2edge_hook, void *);
void cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list *);
struct cgraph_2node_hook_list *cgraph_add_node_duplication_hook (cgraph_2node_hook, void *);
void cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list *);
gimple cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *);
struct cgraph_edge *
cgraph_turn_edge_to_speculative (struct cgraph_edge *,
				 cgraph_node *,
				 gcov_type, int);
void cgraph_speculative_call_info (struct cgraph_edge *,
				   struct cgraph_edge *&,
				   struct cgraph_edge *&,
				   struct ipa_ref *&);
extern bool gimple_check_call_matching_types (gimple, tree, bool);

/* In cgraphunit.c  */
struct asm_node *add_asm_node (tree);
extern FILE *cgraph_dump_file;
void cgraph_finalize_function (tree, bool);
void finalize_compilation_unit (void);
void compile (void);
void init_cgraph (void);
void cgraph_process_new_functions (void);
void cgraph_process_same_body_aliases (void);
/*  Initialize datastructures so DECL is a function in lowered gimple form.
    IN_SSA is true if the gimple is in SSA.  */
basic_block init_lowered_empty_function (tree, bool);

/* In cgraphclones.c  */

struct cgraph_edge * cgraph_clone_edge (struct cgraph_edge *,
					cgraph_node *, gimple,
					unsigned, gcov_type, int, bool);
tree clone_function_name (tree decl, const char *);

void cgraph_materialize_all_clones (void);
void tree_function_versioning (tree, tree, vec<ipa_replace_map *, va_gc> *,
			       bool, bitmap, bool, bitmap, basic_block);
struct cgraph_edge *cgraph_resolve_speculation (struct cgraph_edge *, tree);

/* In cgraphbuild.c  */
unsigned int rebuild_cgraph_edges (void);
void cgraph_rebuild_references (void);
int compute_call_stmt_bb_frequency (tree, basic_block bb);
void record_references_in_initializer (tree, bool);

/* In ipa.c  */
bool symtab_remove_unreachable_nodes (bool, FILE *);
cgraph_node_set cgraph_node_set_new (void);
cgraph_node_set_iterator cgraph_node_set_find (cgraph_node_set,
					       cgraph_node *);
void cgraph_node_set_add (cgraph_node_set, cgraph_node *);
void cgraph_node_set_remove (cgraph_node_set, cgraph_node *);
void dump_cgraph_node_set (FILE *, cgraph_node_set);
void debug_cgraph_node_set (cgraph_node_set);
void free_cgraph_node_set (cgraph_node_set);
void cgraph_build_static_cdtor (char which, tree body, int priority);

varpool_node_set varpool_node_set_new (void);
varpool_node_set_iterator varpool_node_set_find (varpool_node_set,
						 varpool_node *);
void varpool_node_set_add (varpool_node_set, varpool_node *);
void varpool_node_set_remove (varpool_node_set, varpool_node *);
void dump_varpool_node_set (FILE *, varpool_node_set);
void debug_varpool_node_set (varpool_node_set);
void free_varpool_node_set (varpool_node_set);
void ipa_discover_readonly_nonaddressable_vars (void);
bool varpool_externally_visible_p (varpool_node *);

/* In predict.c  */
bool cgraph_maybe_hot_edge_p (struct cgraph_edge *e);

/* In varpool.c  */
varpool_node *varpool_create_empty_node (void);
varpool_node *varpool_node_for_decl (tree);
varpool_node *varpool_node_for_asm (tree asmname);
void varpool_mark_needed_node (varpool_node *);
void debug_varpool (void);
void dump_varpool (FILE *);

void varpool_finalize_decl (tree);
enum availability cgraph_variable_initializer_availability (varpool_node *);

void varpool_finalize_named_section_flags (varpool_node *node);
bool varpool_output_variables (void);
bool varpool_assemble_decl (varpool_node *node);
void varpool_analyze_node (varpool_node *);
varpool_node * varpool_extra_name_alias (tree, tree);
varpool_node * varpool_create_variable_alias (tree, tree);
void varpool_reset_queue (void);
bool varpool_ctor_useable_for_folding_p (varpool_node *);
tree ctor_for_folding (tree);
bool varpool_for_node_and_aliases (varpool_node *,
		                   bool (*) (varpool_node *, void *),
			           void *, bool);
void varpool_add_new_variable (tree);
void symtab_initialize_asm_name_hash (void);
void symtab_prevail_in_asm_name_hash (symtab_node *node);
void varpool_remove_initializer (varpool_node *);
tree varpool_get_constructor (struct varpool_node *node);

/* In cgraph.c */
extern void change_decl_assembler_name (tree, tree);

/* Return true when the symbol is real symbol, i.e. it is not inline clone
   or abstract function kept for debug info purposes only.  */
inline bool
symtab_node::real_symbol_p (void)
{
  cgraph_node *cnode;

  if (DECL_ABSTRACT (decl))
    return false;
  if (!is_a <cgraph_node *> (this))
    return true;
  cnode = dyn_cast <cgraph_node *> (this);
  if (cnode->global.inlined_to)
    return false;
  return true;
}

/* Return true if DECL should have entry in symbol table if used.
   Those are functions and static & external veriables*/

static inline bool
decl_in_symtab_p (const_tree decl)
{
  return (TREE_CODE (decl) == FUNCTION_DECL
          || (TREE_CODE (decl) == VAR_DECL
	      && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))));
}

inline bool
symtab_node::in_same_comdat_group_p (symtab_node *target)
{
  symtab_node *source = this;

  if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
    {
      if (cn->global.inlined_to)
	source = cn->global.inlined_to;
    }
  if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
    {
      if (cn->global.inlined_to)
	target = cn->global.inlined_to;
    }

  return source->get_comdat_group () == target->get_comdat_group ();
}

/* Return node that alias is aliasing.  */

inline symtab_node *
symtab_node::get_alias_target (void)
{
  struct ipa_ref *ref = NULL;
  iterate_reference (0, ref);
  gcc_checking_assert (ref->use == IPA_REF_ALIAS);
  return ref->referred;
}

/* Return next reachable static symbol with initializer after the node.  */
inline symtab_node *
symtab_node::next_defined_symbol (void)
{
  symtab_node *node1 = next;

  for (; node1; node1 = node1->next)
    if (node1->definition)
      return node1;

  return NULL;
}

/* Return varpool node for given symbol and check it is a function. */
static inline varpool_node *
varpool_get_node (const_tree decl)
{
  gcc_checking_assert (TREE_CODE (decl) == VAR_DECL);
  return dyn_cast<varpool_node *> (symtab_node::get (decl));
}

/* Walk all symbols.  */
#define FOR_EACH_SYMBOL(node) \
   for ((node) = symtab_nodes; (node); (node) = (node)->next)

/* Return first static symbol with definition.  */
static inline symtab_node *
symtab_first_defined_symbol (void)
{
  symtab_node *node;

  for (node = symtab_nodes; node; node = node->next)
    if (node->definition)
      return node;

  return NULL;
}

/* Walk all symbols with definitions in current unit.  */
#define FOR_EACH_DEFINED_SYMBOL(node) \
   for ((node) = symtab_first_defined_symbol (); (node); \
	(node) = node->next_defined_symbol ())

/* Return first variable.  */
static inline varpool_node *
varpool_first_variable (void)
{
  symtab_node *node;
  for (node = symtab_nodes; node; node = node->next)
    if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
      return vnode;
  return NULL;
}

/* Return next variable after NODE.  */
static inline varpool_node *
varpool_next_variable (varpool_node *node)
{
  symtab_node *node1 = node->next;
  for (; node1; node1 = node1->next)
    if (varpool_node *vnode1 = dyn_cast <varpool_node *> (node1))
      return vnode1;
  return NULL;
}
/* Walk all variables.  */
#define FOR_EACH_VARIABLE(node) \
   for ((node) = varpool_first_variable (); \
        (node); \
	(node) = varpool_next_variable ((node)))

/* Return first static variable with initializer.  */
static inline varpool_node *
varpool_first_static_initializer (void)
{
  symtab_node *node;
  for (node = symtab_nodes; node; node = node->next)
    {
      varpool_node *vnode = dyn_cast <varpool_node *> (node);
      if (vnode && DECL_INITIAL (node->decl))
	return vnode;
    }
  return NULL;
}

/* Return next static variable with initializer after NODE.  */
static inline varpool_node *
varpool_next_static_initializer (varpool_node *node)
{
  symtab_node *node1 = node->next;
  for (; node1; node1 = node1->next)
    {
      varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
      if (vnode1 && DECL_INITIAL (node1->decl))
	return vnode1;
    }
  return NULL;
}

/* Walk all static variables with initializer set.  */
#define FOR_EACH_STATIC_INITIALIZER(node) \
   for ((node) = varpool_first_static_initializer (); (node); \
        (node) = varpool_next_static_initializer (node))

/* Return first static variable with definition.  */
static inline varpool_node *
varpool_first_defined_variable (void)
{
  symtab_node *node;
  for (node = symtab_nodes; node; node = node->next)
    {
      varpool_node *vnode = dyn_cast <varpool_node *> (node);
      if (vnode && vnode->definition)
	return vnode;
    }
  return NULL;
}

/* Return next static variable with definition after NODE.  */
static inline varpool_node *
varpool_next_defined_variable (varpool_node *node)
{
  symtab_node *node1 = node->next;
  for (; node1; node1 = node1->next)
    {
      varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
      if (vnode1 && vnode1->definition)
	return vnode1;
    }
  return NULL;
}
/* Walk all variables with definitions in current unit.  */
#define FOR_EACH_DEFINED_VARIABLE(node) \
   for ((node) = varpool_first_defined_variable (); (node); \
        (node) = varpool_next_defined_variable (node))

/* Return first function with body defined.  */
static inline cgraph_node *
cgraph_first_defined_function (void)
{
  symtab_node *node;
  for (node = symtab_nodes; node; node = node->next)
    {
      cgraph_node *cn = dyn_cast <cgraph_node *> (node);
      if (cn && cn->definition)
	return cn;
    }
  return NULL;
}

/* Return next function with body defined after NODE.  */
static inline cgraph_node *
cgraph_next_defined_function (cgraph_node *node)
{
  symtab_node *node1 = node->next;
  for (; node1; node1 = node1->next)
    {
      cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
      if (cn1 && cn1->definition)
	return cn1;
    }
  return NULL;
}

/* Walk all functions with body defined.  */
#define FOR_EACH_DEFINED_FUNCTION(node) \
   for ((node) = cgraph_first_defined_function (); (node); \
        (node) = cgraph_next_defined_function ((node)))

/* Return first function.  */
static inline cgraph_node *
cgraph_first_function (void)
{
  symtab_node *node;
  for (node = symtab_nodes; node; node = node->next)
    if (cgraph_node *cn = dyn_cast <cgraph_node *> (node))
      return cn;
  return NULL;
}

/* Return next function.  */
static inline cgraph_node *
cgraph_next_function (cgraph_node *node)
{
  symtab_node *node1 = node->next;
  for (; node1; node1 = node1->next)
    if (cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1))
      return cn1;
  return NULL;
}
/* Walk all functions.  */
#define FOR_EACH_FUNCTION(node) \
   for ((node) = cgraph_first_function (); (node); \
        (node) = cgraph_next_function ((node)))

/* Return true when callgraph node is a function with Gimple body defined
   in current unit.  Functions can also be define externally or they
   can be thunks with no Gimple representation.

   Note that at WPA stage, the function body may not be present in memory.  */

inline bool
cgraph_node::has_gimple_body_p (void)
{
  return definition && !thunk.thunk_p && !alias;
}

/* Return first function with body defined.  */
static inline cgraph_node *
cgraph_first_function_with_gimple_body (void)
{
  symtab_node *node;
  for (node = symtab_nodes; node; node = node->next)
    {
      cgraph_node *cn = dyn_cast <cgraph_node *> (node);
      if (cn && cn->has_gimple_body_p ())
	return cn;
    }
  return NULL;
}

/* Return next reachable static variable with initializer after NODE.  */
static inline cgraph_node *
cgraph_next_function_with_gimple_body (cgraph_node *node)
{
  symtab_node *node1 = node->next;
  for (; node1; node1 = node1->next)
    {
      cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
      if (cn1 && cn1->has_gimple_body_p ())
	return cn1;
    }
  return NULL;
}

/* Walk all functions with body defined.  */
#define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
   for ((node) = cgraph_first_function_with_gimple_body (); (node); \
        (node) = cgraph_next_function_with_gimple_body (node))

/* Create a new static variable of type TYPE.  */
tree add_new_static_var (tree type);

/* Return true if iterator CSI points to nothing.  */
static inline bool
csi_end_p (cgraph_node_set_iterator csi)
{
  return csi.index >= csi.set->nodes.length ();
}

/* Advance iterator CSI.  */
static inline void
csi_next (cgraph_node_set_iterator *csi)
{
  csi->index++;
}

/* Return the node pointed to by CSI.  */
static inline cgraph_node *
csi_node (cgraph_node_set_iterator csi)
{
  return csi.set->nodes[csi.index];
}

/* Return an iterator to the first node in SET.  */
static inline cgraph_node_set_iterator
csi_start (cgraph_node_set set)
{
  cgraph_node_set_iterator csi;

  csi.set = set;
  csi.index = 0;
  return csi;
}

/* Return true if SET contains NODE.  */
static inline bool
cgraph_node_in_set_p (cgraph_node *node, cgraph_node_set set)
{
  cgraph_node_set_iterator csi;
  csi = cgraph_node_set_find (set, node);
  return !csi_end_p (csi);
}

/* Return number of nodes in SET.  */
static inline size_t
cgraph_node_set_size (cgraph_node_set set)
{
  return set->nodes.length ();
}

/* Return true if iterator VSI points to nothing.  */
static inline bool
vsi_end_p (varpool_node_set_iterator vsi)
{
  return vsi.index >= vsi.set->nodes.length ();
}

/* Advance iterator VSI.  */
static inline void
vsi_next (varpool_node_set_iterator *vsi)
{
  vsi->index++;
}

/* Return the node pointed to by VSI.  */
static inline varpool_node *
vsi_node (varpool_node_set_iterator vsi)
{
  return vsi.set->nodes[vsi.index];
}

/* Return an iterator to the first node in SET.  */
static inline varpool_node_set_iterator
vsi_start (varpool_node_set set)
{
  varpool_node_set_iterator vsi;

  vsi.set = set;
  vsi.index = 0;
  return vsi;
}

/* Return number of nodes in SET.  */
static inline size_t
varpool_node_set_size (varpool_node_set set)
{
  return set->nodes.length ();
}

/* Uniquize all constants that appear in memory.
   Each constant in memory thus far output is recorded
   in `const_desc_table'.  */

struct GTY(()) constant_descriptor_tree {
  /* A MEM for the constant.  */
  rtx rtl;

  /* The value of the constant.  */
  tree value;

  /* Hash of value.  Computing the hash from value each time
     hashfn is called can't work properly, as that means recursive
     use of the hash table during hash table expansion.  */
  hashval_t hash;
};

/* Return true if set is nonempty.  */
static inline bool
cgraph_node_set_nonempty_p (cgraph_node_set set)
{
  return !set->nodes.is_empty ();
}

/* Return true if set is nonempty.  */
static inline bool
varpool_node_set_nonempty_p (varpool_node_set set)
{
  return !set->nodes.is_empty ();
}

/* Return true when function is only called directly or it has alias.
   i.e. it is not externally visible, address was not taken and
   it is not used in any other non-standard way.  */

inline bool
cgraph_node::only_called_directly_or_aliased_p (void)
{
  gcc_assert (!global.inlined_to);
  return (!force_output && !address_taken
	  && !used_from_other_partition
	  && !DECL_VIRTUAL_P (decl)
	  && !DECL_STATIC_CONSTRUCTOR (decl)
	  && !DECL_STATIC_DESTRUCTOR (decl)
	  && !externally_visible);
}

/* Return true when function NODE can be removed from callgraph
   if all direct calls are eliminated.  */

static inline bool
varpool_can_remove_if_no_refs (varpool_node *node)
{
  if (DECL_EXTERNAL (node->decl))
    return true;
  return (!node->force_output && !node->used_from_other_partition
  	  && ((DECL_COMDAT (node->decl)
	       && !node->forced_by_abi
	       && !node->used_from_object_file_p ())
	      || !node->externally_visible
	      || DECL_HAS_VALUE_EXPR_P (node->decl)));
}

/* Return true when all references to VNODE must be visible in ipa_ref_list.
   i.e. if the variable is not externally visible or not used in some magic
   way (asm statement or such).
   The magic uses are all summarized in force_output flag.  */

static inline bool
varpool_all_refs_explicit_p (varpool_node *vnode)
{
  return (vnode->definition
	  && !vnode->externally_visible
	  && !vnode->used_from_other_partition
	  && !vnode->force_output);
}

/* Constant pool accessor function.  */
htab_t constant_pool_htab (void);

/* Return node that alias is aliasing.  */

inline cgraph_node *
cgraph_node::get_alias_target (void)
{
  return dyn_cast <cgraph_node *> (symtab_node::get_alias_target ());
}

static inline varpool_node *
varpool_alias_target (varpool_node *n)
{
  return dyn_cast <varpool_node *> (n->get_alias_target ());
}

/* Given function symbol, walk the alias chain to return the function node
   is alias of. Do not walk through thunks.
   When AVAILABILITY is non-NULL, get minimal availability in the chain.  */

inline cgraph_node *
cgraph_node::ultimate_alias_target (enum availability *availability)
{
  cgraph_node *n = dyn_cast <cgraph_node *> (symtab_node::ultimate_alias_target
    (availability));
  if (!n && availability)
    *availability = AVAIL_NOT_AVAILABLE;
  return n;
}
/* Given NODE, walk the alias chain to return the function NODE is alias of.
   Do not walk through thunks.
   When AVAILABILITY is non-NULL, get minimal availability in the chain.  */

static inline varpool_node *
varpool_variable_node (varpool_node *node,
		       enum availability *availability = NULL)
{
  varpool_node *n;

  if (node)
    n = dyn_cast <varpool_node *> (node->ultimate_alias_target (availability));
  else
    n = NULL;

  if (!n && availability)
    *availability = AVAIL_NOT_AVAILABLE;
  return n;
}

/* Return true when the edge E represents a direct recursion.  */
static inline bool
cgraph_edge_recursive_p (struct cgraph_edge *e)
{
  cgraph_node *callee = e->callee->ultimate_alias_target ();
  if (e->caller->global.inlined_to)
    return e->caller->global.inlined_to->decl == callee->decl;
  else
    return e->caller->decl == callee->decl;
}

/* Return true if the TM_CLONE bit is set for a given FNDECL.  */
static inline bool
decl_is_tm_clone (const_tree fndecl)
{
  cgraph_node *n = cgraph_node::get (fndecl);
  if (n)
    return n->tm_clone;
  return false;
}

/* Likewise indicate that a node is needed, i.e. reachable via some
   external means.  */

inline void
cgraph_node::mark_force_output (void)
{
  force_output = 1;
  gcc_checking_assert (!global.inlined_to);
}

#endif  /* GCC_CGRAPH_H  */

[-- Attachment #3: ipa-ref-symtab-node3.patch.bz2 --]
[-- Type: application/x-bzip, Size: 73732 bytes --]

Re: [RFC, PATCH 1/n] IPA C++ refactoring

[Jan Hubicka]

> Can you please advise me how to create a ChangeLog entry based on such transformation?

I think we usually go with somethin glike
	(old_foo): Rename to ...
	(new_foo): ... this one and turn into symtab_node method.

OK with Changelog.

honza
> 
> For being sure, I've been running testsuite for all supported languages.
> 
> Thank you,
> Martin
> >>Thanks,
> >>Martin
> >>>+
> >>>+  /* Try to find a call graph node for declaration DECL and if it does not
> >>>+     exist or if it corresponds to an inline clone, create a new one.  */
> >>>+  static cgraph_node * get_create (tree);
> >>>
> >>>Also to begginig, next to get and create.
> >>>+
> >>>+  /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
> >>>+     Return NULL if there's no such node.  */
> >>>+  static cgraph_node *get_for_asmname (tree asmname);
> >>>
> >>>Likewise
> >>>+
> >>>+  /* Attempt to mark ALIAS as an alias to DECL.  Return alias node if
> >>>+     successful and NULL otherwise.
> >>>+     Same body aliases are output whenever the body of DECL is output,
> >>>+     and cgraph_node::get (ALIAS) transparently
> >>>+     returns cgraph_node::get (DECL).  */
> >>>+  static cgraph_node * create_same_body_alias (tree alias, tree decl);
> >>>
> >>>To alias API
> >>>+
> >>>+  /* Worker for cgraph_can_remove_if_no_direct_calls_p.  */
> >>>+  static bool used_from_object_file_p_worker (cgraph_node *node,
> >>>+					      void *data ATTRIBUTE_UNUSED)
> >>>+  {
> >>>+    return node->used_from_object_file_p ();
> >>>+  }
> >>>+
> >>>+  /* Return true when cgraph_node can not be local.
> >>>+     Worker for cgraph_local_node_p.  */
> >>>cgraph_local_node_p was probably renamed, but we should sanify predicates here.
> >>>Please group all functions dealing with local functions togehter, too.
> >>>+  static bool non_local_p (cgraph_node *node, void *data ATTRIBUTE_UNUSED);
> >>>+
> >>>+  /* Verify whole cgraph structure.  */
> >>>+  static void DEBUG_FUNCTION verify_cgraph_nodes (void);
> >>>+
> >>>+  /* Worker to bring NODE local.  */
> >>>+  static bool make_local (cgraph_node *node, void *data ATTRIBUTE_UNUSED);
> >>>+
> >>>+  /* Mark ALIAS as an alias to DECL.  DECL_NODE is cgraph node representing
> >>>+     the function body is associated
> >>>+     with (not necessarily cgraph_node (DECL).  */
> >>>+  static cgraph_node *create_alias (tree alias, tree target);
> >>>+
> >>>+  static cgraph_edge * create_edge (cgraph_node *caller, cgraph_node *callee,
> >>>+				    gimple call_stmt, gcov_type count,
> >>>+				    int freq,
> >>>+				    bool indir_unknown_callee);
> >>>
> >>>Also edges and aliases should be grouped.
> >>>
> >>>With these changes patch looks good. Probably we will need one additional cleanup pass, but it would be better
> >>>to do it incrementally.  Please write changelog that carefuly records what was renamed to what.
> >>>
> >>>Honza
> 

> /* Callgraph handling code.
>    Copyright (C) 2003-2014 Free Software Foundation, Inc.
>    Contributed by Jan Hubicka
> 
> This file is part of GCC.
> 
> GCC is free software; you can redistribute it and/or modify it under
> the terms of the GNU General Public License as published by the Free
> Software Foundation; either version 3, or (at your option) any later
> version.
> 
> GCC is distributed in the hope that it will be useful, but WITHOUT ANY
> WARRANTY; without even the implied warranty of MERCHANTABILITY or
> FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
> for more details.
> 
> You should have received a copy of the GNU General Public License
> along with GCC; see the file COPYING3.  If not see
> <http://www.gnu.org/licenses/>.  */
> 
> #ifndef GCC_CGRAPH_H
> #define GCC_CGRAPH_H
> 
> #include "is-a.h"
> #include "plugin-api.h"
> #include "vec.h"
> #include "basic-block.h"
> #include "function.h"
> #include "ipa-ref.h"
> 
> /* Symbol table consists of functions and variables.
>    TODO: add labels and CONST_DECLs.  */
> enum symtab_type
> {
>   SYMTAB_SYMBOL,
>   SYMTAB_FUNCTION,
>   SYMTAB_VARIABLE
> };
> 
> /* Section names are stored as reference counted strings in GGC safe hashtable
>    (to make them survive through PCH).  */
> 
> struct GTY(()) section_hash_entry_d
> {
>   int ref_count;
>   char *name;  /* As long as this datastructure stays in GGC, we can not put
> 		  string at the tail of structure of GGC dies in horrible
> 		  way  */
> };
> 
> typedef struct section_hash_entry_d section_hash_entry;
> 
> enum availability
> {
>   /* Not yet set by cgraph_function_body_availability.  */
>   AVAIL_UNSET,
>   /* Function body/variable initializer is unknown.  */
>   AVAIL_NOT_AVAILABLE,
>   /* Function body/variable initializer is known but might be replaced
>      by a different one from other compilation unit and thus needs to
>      be dealt with a care.  Like AVAIL_NOT_AVAILABLE it can have
>      arbitrary side effects on escaping variables and functions, while
>      like AVAILABLE it might access static variables.  */
>   AVAIL_INTERPOSABLE,
>   /* Function body/variable initializer is known and will be used in final
>      program.  */
>   AVAIL_AVAILABLE,
>   /* Function body/variable initializer is known and all it's uses are
>      explicitly visible within current unit (ie it's address is never taken and
>      it is not exported to other units). Currently used only for functions.  */
>   AVAIL_LOCAL
> };
> 
> /* Classification of symbols WRT partitioning.  */
> enum symbol_partitioning_class
> {
>    /* External declarations are ignored by partitioning algorithms and they are
>       added into the boundary later via compute_ltrans_boundary.  */
>    SYMBOL_EXTERNAL,
>    /* Partitioned symbols are pur into one of partitions.  */
>    SYMBOL_PARTITION,
>    /* Duplicated symbols (such as comdat or constant pool references) are
>       copied into every node needing them via add_symbol_to_partition.  */
>    SYMBOL_DUPLICATE
> };
> 
> /* Base of all entries in the symbol table.
>    The symtab_node is inherited by cgraph and varpol nodes.  */
> class GTY((desc ("%h.type"), tag ("SYMTAB_SYMBOL"),
> 	   chain_next ("%h.next"), chain_prev ("%h.previous")))
>   symtab_node
> {
> public:
>   /* Return name.  */
>   const char *name () const;
> 
>   /* Return asm name.  */
>   const char * asm_name () const;
> 
>   /* Add node into symbol table.  This function is not used directly, but via
>      cgraph/varpool node creation routines.  */
>   void register_symbol (void);
> 
>   /* Remove symbol from symbol table.  */
>   void remove (void);
> 
>   /* Dump symtab node to F.  */
>   void dump (FILE *f);
> 
>   /* Dump symtab node to stderr.  */
>   void DEBUG_FUNCTION debug (void);
> 
>   /* Verify consistency of node.  */
>   void DEBUG_FUNCTION verify (void);
> 
>   /* Return ipa reference from this symtab_node to
>      REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
>      of the use and STMT the statement (if it exists).  */
>   struct ipa_ref *add_reference (symtab_node *referred_node,
> 				 enum ipa_ref_use use_type);
> 
>   /* Return ipa reference from this symtab_node to
>      REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
>      of the use and STMT the statement (if it exists).  */
>   struct ipa_ref *add_reference (symtab_node *referred_node,
> 				 enum ipa_ref_use use_type, gimple stmt);
> 
>   /* If VAL is a reference to a function or a variable, add a reference from
>      this symtab_node to the corresponding symbol table node.  USE_TYPE specify
>      type of the use and STMT the statement (if it exists).  Return the new
>      reference or NULL if none was created.  */
>   struct ipa_ref *maybe_add_reference (tree val, enum ipa_ref_use use_type,
> 				       gimple stmt);
> 
>   /* Clone all references from symtab NODE to this symtab_node.  */
>   void clone_references (symtab_node *node);
> 
>   /* Remove all stmt references in non-speculative references.
>      Those are not maintained during inlining & clonning.
>      The exception are speculative references that are updated along
>      with callgraph edges associated with them.  */
>   void clone_referring (symtab_node *node);
> 
>   /* Clone reference REF to this symtab_node and set its stmt to STMT.  */
>   struct ipa_ref *clone_reference (struct ipa_ref *ref, gimple stmt);
> 
>   /* Find the structure describing a reference to REFERRED_NODE
>      and associated with statement STMT.  */
>   struct ipa_ref *find_reference (symtab_node *referred_node, gimple stmt,
> 				  unsigned int lto_stmt_uid);
> 
>   /* Remove all references that are associated with statement STMT.  */
>   void remove_stmt_references (gimple stmt);
> 
>   /* Remove all stmt references in non-speculative references.
>      Those are not maintained during inlining & clonning.
>      The exception are speculative references that are updated along
>      with callgraph edges associated with them.  */
>   void clear_stmts_in_references (void);
> 
>   /* Remove all references in ref list.  */
>   void remove_all_references (void);
> 
>   /* Remove all referring items in ref list.  */
>   void remove_all_referring (void);
> 
>   /* Dump references in ref list to FILE.  */
>   void dump_references (FILE *file);
> 
>   /* Dump referring in list to FILE.  */
>   void dump_referring (FILE *);
> 
>   /* Iterates I-th reference in the list, REF is also set.  */
>   struct ipa_ref *iterate_reference (unsigned i, struct ipa_ref *&ref);
> 
>   /* Iterates I-th referring item in the list, REF is also set.  */
>   struct ipa_ref *iterate_referring (unsigned i, struct ipa_ref *&ref);
> 
>   /* Iterates I-th referring alias item in the list, REF is also set.  */
>   struct ipa_ref *iterate_direct_aliases (unsigned i, struct ipa_ref *&ref);
> 
>   /* Return true if symtab node and TARGET represents
>      semantically equivalent symbols.  */
>   bool semantically_equivalent_p (symtab_node *target);
> 
>   /* Classify symbol symtab node for partitioning.  */
>   enum symbol_partitioning_class get_partitioning_class (void);
> 
>   /* Return comdat group.  */
>   tree get_comdat_group ()
>     {
>       return x_comdat_group;
>     }
> 
>   /* Return comdat group as identifier_node.  */
>   tree get_comdat_group_id ()
>     {
>       if (x_comdat_group && TREE_CODE (x_comdat_group) != IDENTIFIER_NODE)
> 	x_comdat_group = DECL_ASSEMBLER_NAME (x_comdat_group);
>       return x_comdat_group;
>     }
> 
>   /* Set comdat group.  */
>   void set_comdat_group (tree group)
>     {
>       gcc_checking_assert (!group || TREE_CODE (group) == IDENTIFIER_NODE
> 			   || DECL_P (group));
>       x_comdat_group = group;
>     }
> 
>   /* Return section as string.  */
>   const char * get_section ()
>     {
>       if (!x_section)
> 	return NULL;
>       return x_section->name;
>     }
> 
>   /* Remove node from same comdat group.   */
>   void remove_from_same_comdat_group (void);
> 
>   /* Add this symtab_node to the same comdat group that OLD is in.  */
>   void add_to_same_comdat_group (symtab_node *old_node);
> 
>   /* Dissolve the same_comdat_group list in which NODE resides.  */
>   void dissolve_same_comdat_group_list (void);
> 
>   /* Return true when symtab_node is known to be used from other (non-LTO)
>      object file. Known only when doing LTO via linker plugin.  */
>   bool used_from_object_file_p (void);
> 
>   /* Walk the alias chain to return the symbol NODE is alias of.
>      If NODE is not an alias, return NODE.
>      When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
>   symtab_node *ultimate_alias_target (enum availability *avail = NULL);
> 
>   /* Return next reachable static symbol with initializer after NODE.  */
>   inline symtab_node *next_defined_symbol (void);
> 
>   /* Add reference recording that symtab node is alias of TARGET.
>      The function can fail in the case of aliasing cycles; in this case
>      it returns false.  */
>   bool resolve_alias (symtab_node *target);
> 
>   /* C++ FE sometimes change linkage flags after producing same
>      body aliases.  */
>   void fixup_same_cpp_alias_visibility (symtab_node *target);
> 
>   /* Call calback on symtab node and aliases associated to this node.
>      When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
>      skipped. */
>   bool call_for_symbol_and_aliases (bool (*callback) (symtab_node *, void *),
> 				  void *data,
> 				  bool include_overwrite);
> 
>   /* If node can not be interposable by static or dynamic linker to point to
>      different definition, return this symbol. Otherwise look for alias with
>      such property and if none exists, introduce new one.  */
>   symtab_node *noninterposable_alias (void);
> 
>   /* Return node that alias is aliasing.  */
>   inline symtab_node *get_alias_target (void);
> 
>   /* Set section for symbol and its aliases.  */
>   void set_section (const char *section);
> 
>   /* Set section, do not recurse into aliases.
>      When one wants to change section of symbol and its aliases,
>      use set_section.  */
>   void set_section_for_node (const char *section);
> 
>   /* Set initialization priority to PRIORITY.  */
>   void set_init_priority (priority_type priority);
> 
>   /* Return the initialization priority.  */
>   priority_type get_init_priority ();
> 
>   /* Return availability of NODE.  */
>   enum availability get_availability (void);
> 
>   /* Make DECL local.  */
>   void make_decl_local (void);
> 
>   /* Return true if list contains an alias.  */
>   bool has_aliases_p (void);
> 
>   /* Return true when the symbol is real symbol, i.e. it is not inline clone
>      or abstract function kept for debug info purposes only.  */
>   bool real_symbol_p (void);
> 
>   /* Return true if NODE can be discarded by linker from the binary.  */
>   inline bool
>   can_be_discarded_p (void)
>   {
>     return (DECL_EXTERNAL (decl)
> 	    || (get_comdat_group ()
> 		&& resolution != LDPR_PREVAILING_DEF
> 		&& resolution != LDPR_PREVAILING_DEF_IRONLY
> 		&& resolution != LDPR_PREVAILING_DEF_IRONLY_EXP));
>   }
> 
>   /* Return true if NODE is local to a particular COMDAT group, and must not
>      be named from outside the COMDAT.  This is used for C++ decloned
>      constructors.  */
>   inline bool comdat_local_p (void)
>   {
>     return (same_comdat_group && !TREE_PUBLIC (decl));
>   }
> 
>   /* Return true if ONE and TWO are part of the same COMDAT group.  */
>   inline bool in_same_comdat_group_p (symtab_node *target);
> 
>   /* Return true when there is a reference to node and it is not vtable.  */
>   bool address_taken_from_non_vtable_p (void);
> 
>   /* Return true if symbol is known to be nonzero.  */
>   bool nonzero_address ();
> 
>   /* Return symbol table node associated with DECL, if any,
>      and NULL otherwise.  */
>   static inline symtab_node *get (const_tree decl)
>   {
> #ifdef ENABLE_CHECKING
>     /* Check that we are called for sane type of object - functions
>        and static or external variables.  */
>     gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL
> 			 || (TREE_CODE (decl) == VAR_DECL
> 			     && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
> 				 || in_lto_p)));
>     /* Check that the mapping is sane - perhaps this check can go away,
>        but at the moment frontends tends to corrupt the mapping by calling
>        memcpy/memset on the tree nodes.  */
>     gcc_checking_assert (!decl->decl_with_vis.symtab_node
> 			 || decl->decl_with_vis.symtab_node->decl == decl);
> #endif
>     return decl->decl_with_vis.symtab_node;
>   }
> 
>   /* Dump symbol table to F.  */
>   static void dump_table (FILE *);
> 
>   /* Dump symbol table to stderr.  */
>   static inline DEBUG_FUNCTION void debug_symtab (void)
>   {
>     dump_table (stderr);
>   }
> 
>   /* Verify symbol table for internal consistency.  */
>   static DEBUG_FUNCTION void verify_symtab_nodes (void);
> 
>   /* Return true when NODE is known to be used from other (non-LTO)
>      object file. Known only when doing LTO via linker plugin.  */
>   static bool used_from_object_file_p_worker (symtab_node *node);
> 
>   /* Type of the symbol.  */
>   ENUM_BITFIELD (symtab_type) type : 8;
> 
>   /* The symbols resolution.  */
>   ENUM_BITFIELD (ld_plugin_symbol_resolution) resolution : 8;
> 
>   /*** Flags representing the symbol type.  ***/
> 
>   /* True when symbol corresponds to a definition in current unit.
>      set via cgraph_finalize_function or varpool_finalize_decl  */
>   unsigned definition : 1;
>   /* True when symbol is an alias.  
>      Set by assemble_alias.  */
>   unsigned alias : 1;
>   /* True when alias is a weakref.  */
>   unsigned weakref : 1;
>   /* C++ frontend produce same body aliases and extra name aliases for
>      virtual functions and vtables that are obviously equivalent.
>      Those aliases are bit special, especially because C++ frontend
>      visibility code is so ugly it can not get them right at first time
>      and their visibility needs to be copied from their "masters" at
>      the end of parsing.  */
>   unsigned cpp_implicit_alias : 1;
>   /* Set once the definition was analyzed.  The list of references and
>      other properties are built during analysis.  */
>   unsigned analyzed : 1;
>   /* Set for write-only variables.  */
>   unsigned writeonly : 1;
> 
> 
>   /*** Visibility and linkage flags.  ***/
> 
>   /* Set when function is visible by other units.  */
>   unsigned externally_visible : 1;
>   /* The symbol will be assumed to be used in an invisible way (like
>      by an toplevel asm statement).  */
>   unsigned force_output : 1;
>   /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be
>      exported.  Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted
>      to static and it does not inhibit optimization.  */
>   unsigned forced_by_abi : 1;
>   /* True when the name is known to be unique and thus it does not need mangling.  */
>   unsigned unique_name : 1;
>   /* Specify whether the section was set by user or by
>      compiler via -ffunction-sections.  */
>   unsigned implicit_section : 1;
>   /* True when body and other characteristics have been removed by
>      symtab_remove_unreachable_nodes. */
>   unsigned body_removed : 1;
> 
>   /*** WHOPR Partitioning flags.
>        These flags are used at ltrans stage when only part of the callgraph is
>        available. ***/
> 
>   /* Set when variable is used from other LTRANS partition.  */
>   unsigned used_from_other_partition : 1;
>   /* Set when function is available in the other LTRANS partition.  
>      During WPA output it is used to mark nodes that are present in
>      multiple partitions.  */
>   unsigned in_other_partition : 1;
> 
> 
> 
>   /*** other flags.  ***/
> 
>   /* Set when symbol has address taken. */
>   unsigned address_taken : 1;
>   /* Set when init priority is set.  */
>   unsigned in_init_priority_hash : 1;
> 
> 
>   /* Ordering of all symtab entries.  */
>   int order;
> 
>   /* Declaration representing the symbol.  */
>   tree decl;
> 
>   /* Linked list of symbol table entries starting with symtab_nodes.  */
>   symtab_node *next;
>   symtab_node *previous;
> 
>   /* Linked list of symbols with the same asm name.  There may be multiple
>      entries for single symbol name during LTO, because symbols are renamed
>      only after partitioning.
> 
>      Because inline clones are kept in the assembler name has, they also produce
>      duplicate entries.
> 
>      There are also several long standing bugs where frontends and builtin
>      code produce duplicated decls.  */
>   symtab_node *next_sharing_asm_name;
>   symtab_node *previous_sharing_asm_name;
> 
>   /* Circular list of nodes in the same comdat group if non-NULL.  */
>   symtab_node *same_comdat_group;
> 
>   /* Vectors of referring and referenced entities.  */
>   struct ipa_ref_list ref_list;
> 
>   /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer
>      depending to what was known to frontend on the creation time.
>      Once alias is resolved, this pointer become NULL.  */
>   tree alias_target;
> 
>   /* File stream where this node is being written to.  */
>   struct lto_file_decl_data * lto_file_data;
> 
>   PTR GTY ((skip)) aux;
> 
>   /* Comdat group the symbol is in.  Can be private if GGC allowed that.  */
>   tree x_comdat_group;
> 
>   /* Section name. Again can be private, if allowed.  */
>   section_hash_entry *x_section;
> 
> protected:
>   /* Dump base fields of symtab nodes to F.  Not to be used directly.  */
>   void dump_base (FILE *);
> 
>   /* Verify common part of symtab node.  */
>   bool DEBUG_FUNCTION verify_base (void);
> 
>   /* Remove node from symbol table.  This function is not used directly, but via
>      cgraph/varpool node removal routines.  */
>   void unregister (void);
> 
>   /* Return the initialization and finalization priority information for
>      DECL.  If there is no previous priority information, a freshly
>      allocated structure is returned.  */
>   struct symbol_priority_map *priority_info (void);
> 
> private:
>   /* Worker for set_section.  */
>   static bool set_section (symtab_node *n, void *s);
> 
>   /* Worker for symtab_resolve_alias.  */
>   static bool set_implicit_section (symtab_node *n, void *);
> 
>   /* Worker searching noninterposable alias.  */
>   static bool noninterposable_alias (symtab_node *node, void *data);
> };
> 
> /* Walk all aliases for NODE.  */
> #define FOR_EACH_ALIAS(node, alias) \
>   for (unsigned x_i = 0; node->iterate_direct_aliases (x_i, alias); x_i++)
> 
> /* This is the information that is put into the cgraph local structure
>    to recover a function.  */
> struct lto_file_decl_data;
> 
> extern const char * const cgraph_availability_names[];
> extern const char * const ld_plugin_symbol_resolution_names[];
> extern const char * const tls_model_names[];
> 
> /* Information about thunk, used only for same body aliases.  */
> 
> struct GTY(()) cgraph_thunk_info {
>   /* Information about the thunk.  */
>   HOST_WIDE_INT fixed_offset;
>   HOST_WIDE_INT virtual_value;
>   tree alias;
>   bool this_adjusting;
>   bool virtual_offset_p;
>   /* Set to true when alias node is thunk.  */
>   bool thunk_p;
> };
> 
> /* Information about the function collected locally.
>    Available after function is analyzed.  */
> 
> struct GTY(()) cgraph_local_info {
>   /* Set when function function is visible in current compilation unit only
>      and its address is never taken.  */
>   unsigned local : 1;
> 
>   /* False when there is something makes versioning impossible.  */
>   unsigned versionable : 1;
> 
>   /* False when function calling convention and signature can not be changed.
>      This is the case when __builtin_apply_args is used.  */
>   unsigned can_change_signature : 1;
> 
>   /* True when the function has been originally extern inline, but it is
>      redefined now.  */
>   unsigned redefined_extern_inline : 1;
> 
>   /* True if the function may enter serial irrevocable mode.  */
>   unsigned tm_may_enter_irr : 1;
> };
> 
> /* Information about the function that needs to be computed globally
>    once compilation is finished.  Available only with -funit-at-a-time.  */
> 
> struct GTY(()) cgraph_global_info {
>   /* For inline clones this points to the function they will be
>      inlined into.  */
>   cgraph_node *inlined_to;
> };
> 
> /* Information about the function that is propagated by the RTL backend.
>    Available only for functions that has been already assembled.  */
> 
> struct GTY(()) cgraph_rtl_info {
>    unsigned int preferred_incoming_stack_boundary;
> 
>   /* Call unsaved hard registers really used by the corresponding
>      function (including ones used by functions called by the
>      function).  */
>   HARD_REG_SET function_used_regs;
>   /* Set if function_used_regs is valid.  */
>   unsigned function_used_regs_valid: 1;
> };
> 
> /* Represent which DECL tree (or reference to such tree)
>    will be replaced by another tree while versioning.  */
> struct GTY(()) ipa_replace_map
> {
>   /* The tree that will be replaced.  */
>   tree old_tree;
>   /* The new (replacing) tree.  */
>   tree new_tree;
>   /* Parameter number to replace, when old_tree is NULL.  */
>   int parm_num;
>   /* True when a substitution should be done, false otherwise.  */
>   bool replace_p;
>   /* True when we replace a reference to old_tree.  */
>   bool ref_p;
> };
> 
> struct GTY(()) cgraph_clone_info
> {
>   vec<ipa_replace_map *, va_gc> *tree_map;
>   bitmap args_to_skip;
>   bitmap combined_args_to_skip;
> };
> 
> enum cgraph_simd_clone_arg_type
> {
>   SIMD_CLONE_ARG_TYPE_VECTOR,
>   SIMD_CLONE_ARG_TYPE_UNIFORM,
>   SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP,
>   SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP,
>   SIMD_CLONE_ARG_TYPE_MASK
> };
> 
> /* Function arguments in the original function of a SIMD clone.
>    Supplementary data for `struct simd_clone'.  */
> 
> struct GTY(()) cgraph_simd_clone_arg {
>   /* Original function argument as it originally existed in
>      DECL_ARGUMENTS.  */
>   tree orig_arg;
> 
>   /* orig_arg's function (or for extern functions type from
>      TYPE_ARG_TYPES).  */
>   tree orig_type;
> 
>   /* If argument is a vector, this holds the vector version of
>      orig_arg that after adjusting the argument types will live in
>      DECL_ARGUMENTS.  Otherwise, this is NULL.
> 
>      This basically holds:
>        vector(simdlen) __typeof__(orig_arg) new_arg.  */
>   tree vector_arg;
> 
>   /* vector_arg's type (or for extern functions new vector type.  */
>   tree vector_type;
> 
>   /* If argument is a vector, this holds the array where the simd
>      argument is held while executing the simd clone function.  This
>      is a local variable in the cloned function.  Its content is
>      copied from vector_arg upon entry to the clone.
> 
>      This basically holds:
>        __typeof__(orig_arg) simd_array[simdlen].  */
>   tree simd_array;
> 
>   /* A SIMD clone's argument can be either linear (constant or
>      variable), uniform, or vector.  */
>   enum cgraph_simd_clone_arg_type arg_type;
> 
>   /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP this is
>      the constant linear step, if arg_type is
>      SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP, this is index of
>      the uniform argument holding the step, otherwise 0.  */
>   HOST_WIDE_INT linear_step;
> 
>   /* Variable alignment if available, otherwise 0.  */
>   unsigned int alignment;
> };
> 
> /* Specific data for a SIMD function clone.  */
> 
> struct GTY(()) cgraph_simd_clone {
>   /* Number of words in the SIMD lane associated with this clone.  */
>   unsigned int simdlen;
> 
>   /* Number of annotated function arguments in `args'.  This is
>      usually the number of named arguments in FNDECL.  */
>   unsigned int nargs;
> 
>   /* Max hardware vector size in bits for integral vectors.  */
>   unsigned int vecsize_int;
> 
>   /* Max hardware vector size in bits for floating point vectors.  */
>   unsigned int vecsize_float;
> 
>   /* The mangling character for a given vector size.  This is is used
>      to determine the ISA mangling bit as specified in the Intel
>      Vector ABI.  */
>   unsigned char vecsize_mangle;
> 
>   /* True if this is the masked, in-branch version of the clone,
>      otherwise false.  */
>   unsigned int inbranch : 1;
> 
>   /* True if this is a Cilk Plus variant.  */
>   unsigned int cilk_elemental : 1;
> 
>   /* Doubly linked list of SIMD clones.  */
>   cgraph_node *prev_clone, *next_clone;
> 
>   /* Original cgraph node the SIMD clones were created for.  */
>   cgraph_node *origin;
> 
>   /* Annotated function arguments for the original function.  */
>   struct cgraph_simd_clone_arg GTY((length ("%h.nargs"))) args[1];
> };
> 
> /* Function Multiversioning info.  */
> struct GTY(()) cgraph_function_version_info {
>   /* The cgraph_node for which the function version info is stored.  */
>   cgraph_node *this_node;
>   /* Chains all the semantically identical function versions.  The
>      first function in this chain is the version_info node of the
>      default function.  */
>   struct cgraph_function_version_info *prev;
>   /* If this version node corresponds to a dispatcher for function
>      versions, this points to the version info node of the default
>      function, the first node in the chain.  */
>   struct cgraph_function_version_info *next;
>   /* If this node corresponds to a function version, this points
>      to the dispatcher function decl, which is the function that must
>      be called to execute the right function version at run-time.
> 
>      If this cgraph node is a dispatcher (if dispatcher_function is
>      true, in the cgraph_node struct) for function versions, this
>      points to resolver function, which holds the function body of the
>      dispatcher. The dispatcher decl is an alias to the resolver
>      function decl.  */
>   tree dispatcher_resolver;
> };
> 
> #define DEFCIFCODE(code, type, string)	CIF_ ## code,
> /* Reasons for inlining failures.  */
> 
> enum cgraph_inline_failed_t {
> #include "cif-code.def"
>   CIF_N_REASONS
> };
> 
> enum cgraph_inline_failed_type_t
> {
>   CIF_FINAL_NORMAL = 0,
>   CIF_FINAL_ERROR
> };
> 
> struct cgraph_edge;
> 
> /* The cgraph data structure.
>    Each function decl has assigned cgraph_node listing callees and callers.  */
> 
> struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node {
> public:
>   /* Remove the node from cgraph and all inline clones inlined into it.
>      Skip however removal of FORBIDDEN_NODE and return true if it needs to be
>      removed.  This allows to call the function from outer loop walking clone
>      tree.  */
>   bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL);
> 
>   /* Record all references from cgraph_node that are taken
>      in statement STMT.  */
>   void record_stmt_references (gimple stmt);
> 
>   /* Like cgraph_set_call_stmt but walk the clone tree and update all
>      clones sharing the same function body.
>      When WHOLE_SPECULATIVE_EDGES is true, all three components of
>      speculative edge gets updated.  Otherwise we update only direct
>      call.  */
>   void set_call_stmt_including_clones (gimple old_stmt, gimple new_stmt,
> 				       bool update_speculative = true);
> 
>   /* Walk the alias chain to return the function cgraph_node is alias of.
>      Walk through thunk, too.
>      When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
>   cgraph_node *function_symbol (enum availability *avail = NULL);
> 
>   /* Create node representing clone of N executed COUNT times.  Decrease
>      the execution counts from original node too.
>      The new clone will have decl set to DECL that may or may not be the same
>      as decl of N.
> 
>      When UPDATE_ORIGINAL is true, the counts are subtracted from the original
>      function's profile to reflect the fact that part of execution is handled
>      by node.
>      When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
>      the new clone. Otherwise the caller is responsible for doing so later.
> 
>      If the new node is being inlined into another one, NEW_INLINED_TO should be
>      the outline function the new one is (even indirectly) inlined to.
>      All hooks will see this in node's global.inlined_to, when invoked.
>      Can be NULL if the node is not inlined.  */
>   cgraph_node *create_clone (tree decl, gcov_type count, int freq,
> 			     bool update_original,
> 			     vec<cgraph_edge *> redirect_callers,
> 			     bool call_duplication_hook,
> 			     struct cgraph_node *new_inlined_to,
> 			     bitmap args_to_skip);
> 
>   /* Create callgraph node clone with new declaration.  The actual body will
>      be copied later at compilation stage.  */
>   cgraph_node *create_virtual_clone (vec<cgraph_edge *> redirect_callers,
> 				     vec<ipa_replace_map *, va_gc> *tree_map,
> 				     bitmap args_to_skip, const char * suffix);
> 
>   /* cgraph node being removed from symbol table; see if its entry can be
>    replaced by other inline clone.  */
>   cgraph_node *find_replacement (void);
> 
>   /* Create a new cgraph node which is the new version of
>      callgraph node.  REDIRECT_CALLERS holds the callers
>      edges which should be redirected to point to
>      NEW_VERSION.  ALL the callees edges of the node
>      are cloned to the new version node.  Return the new
>      version node.
> 
>      If non-NULL BLOCK_TO_COPY determine what basic blocks
>      was copied to prevent duplications of calls that are dead
>      in the clone.  */
> 
>   cgraph_node *create_version_clone (tree new_decl,
> 				    vec<cgraph_edge *> redirect_callers,
> 				    bitmap bbs_to_copy);
> 
>   /* Perform function versioning.
>      Function versioning includes copying of the tree and
>      a callgraph update (creating a new cgraph node and updating
>      its callees and callers).
> 
>      REDIRECT_CALLERS varray includes the edges to be redirected
>      to the new version.
> 
>      TREE_MAP is a mapping of tree nodes we want to replace with
>      new ones (according to results of prior analysis).
> 
>      If non-NULL ARGS_TO_SKIP determine function parameters to remove
>      from new version.
>      If SKIP_RETURN is true, the new version will return void.
>      If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
>      If non_NULL NEW_ENTRY determine new entry BB of the clone.
> 
>      Return the new version's cgraph node.  */
>   cgraph_node *create_version_clone_with_body
>     (vec<cgraph_edge *> redirect_callers,
>      vec<ipa_replace_map *, va_gc> *tree_map, bitmap args_to_skip,
>      bool skip_return, bitmap bbs_to_copy, basic_block new_entry_block,
>      const char *clone_name);
> 
>   /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
>      corresponding to cgraph_node.  */
>   struct cgraph_function_version_info *insert_new_function_version (void);
> 
>   /* Get the cgraph_function_version_info node corresponding to node.  */
>   struct cgraph_function_version_info *function_version (void);
> 
>   /* Discover all functions and variables that are trivially needed, analyze
>      them as well as all functions and variables referred by them  */
>   void analyze (void);
> 
>   /* Add thunk alias into callgraph.  The alias declaration is ALIAS and it
>      aliases DECL with an adjustments made into the first parameter.
>      See comments in thunk_adjust for detail on the parameters.  */
>   cgraph_node * create_thunk (tree alias, tree, bool this_adjusting,
> 			      HOST_WIDE_INT fixed_offset,
> 			      HOST_WIDE_INT virtual_value,
> 			      tree virtual_offset,
> 			      tree real_alias);
> 
> 
>   /* Return node that alias is aliasing.  */
>   inline cgraph_node *get_alias_target (void);
> 
>   /* Given function symbol, walk the alias chain to return the function node
>      is alias of. Do not walk through thunks.
>      When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
> 
>   cgraph_node *ultimate_alias_target (availability *availability = NULL);
> 
>   /* Expand thunk NODE to gimple if possible.
>      When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
>      no assembler is produced.
>      When OUTPUT_ASM_THUNK is true, also produce assembler for
>      thunks that are not lowered.  */
>   bool expand_thunk (bool output_asm_thunks, bool force_gimple_thunk);
> 
>   /* As an GCC extension we allow redefinition of the function.  The
>      semantics when both copies of bodies differ is not well defined.
>      We replace the old body with new body so in unit at a time mode
>      we always use new body, while in normal mode we may end up with
>      old body inlined into some functions and new body expanded and
>      inlined in others.  */
>   void reset (void);
> 
>   /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
>      kind of wrapper method.  */
>   void create_wrapper (cgraph_node *target);
> 
>   /* Verify cgraph nodes of the cgraph node.  */
>   void DEBUG_FUNCTION verify_node (void);
> 
>   /* Remove function from symbol table.  */
>   void remove (void);
> 
>   /* Dump call graph node to file F.  */
>   void dump (FILE *f);
> 
>   /* Dump call graph node to stderr.  */
>   void DEBUG_FUNCTION debug (void);
> 
>   /* When doing LTO, read cgraph_node's body from disk if it is not already
>      present.  */
>   bool get_body (void);
> 
>   /* Release memory used to represent body of function.
>      Use this only for functions that are released before being translated to
>      target code (i.e. RTL).  Functions that are compiled to RTL and beyond
>      are free'd in final.c via free_after_compilation().  */
>   void release_body (void);
> 
>   /* cgraph_node is no longer nested function; update cgraph accordingly.  */
>   void unnest (void);
> 
>   /* Bring cgraph node local.  */
>   void make_local (void);
> 
>   /* Likewise indicate that a node is having address taken.  */
>   void mark_address_taken (void);
> 
>   /* Set fialization priority to PRIORITY.  */
>   void set_fini_priority (priority_type priority);
> 
>   /* Return the finalization priority.  */
>   priority_type get_fini_priority (void);
> 
>   /* Create edge from a given function to CALLEE in the cgraph.  */
>   struct cgraph_edge *create_edge (cgraph_node *callee,
> 				   gimple call_stmt, gcov_type count,
> 				   int freq);
>   /* Create an indirect edge with a yet-undetermined callee where the call
>      statement destination is a formal parameter of the caller with index
>      PARAM_INDEX. */
>   struct cgraph_edge *create_indirect_edge (gimple call_stmt, int ecf_flags,
> 					    gcov_type count, int freq);
> 
>   /* Like cgraph_create_edge walk the clone tree and update all clones sharing
>    same function body.  If clones already have edge for OLD_STMT; only
>    update the edge same way as cgraph_set_call_stmt_including_clones does.  */
>   void create_edge_including_clones (struct cgraph_node *callee,
> 				     gimple old_stmt, gimple stmt,
> 				     gcov_type count,
> 				     int freq,
> 				     cgraph_inline_failed_t reason);
> 
>   /* Return the callgraph edge representing the GIMPLE_CALL statement
>      CALL_STMT.  */
>   cgraph_edge *get_edge (gimple call_stmt);
> 
>   /* Collect all callers of cgraph_node and its aliases that are known to lead
>      to NODE (i.e. are not overwritable).  */
>   vec<cgraph_edge *> collect_callers (void);
> 
>   /* Remove all callers from the node.  */
>   void remove_callers (void);
> 
>   /* Remove all callees from the node.  */
>   void remove_callees (void);
> 
>   /* Return function availability.  See cgraph.h for description of individual
>      return values.  */
>   enum availability get_availability (void);
> 
>   /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node
>      if any to NOTHROW.  */
>   void set_nothrow_flag (bool nothrow);
> 
>   /* Set TREE_READONLY on cgraph_node's decl and on aliases of the node
>      if any to READONLY.  */
>   void set_const_flag (bool readonly, bool looping);
> 
>   /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
>      if any to PURE.  */
>   void set_pure_flag (bool pure, bool looping);
> 
>   /* Call all node duplication hooks.  */
>   void call_duplication_hooks (cgraph_node *node2);
> 
>   /* Call calback on function and aliases associated to the function.
>      When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
>      skipped. */
> 
>   bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
> 						      void *),
> 				    void *data, bool include_overwritable);
> 
>   /* Call calback on cgraph_node, thunks and aliases associated to NODE.
>      When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
>      skipped.  */
>   bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node,
> 							   void *data),
> 					 void *data,
> 					 bool include_overwritable);
> 
>   /* Call all node insertion hooks.  */
>   void call_function_insertion_hooks (void);
> 
>   /* Likewise indicate that a node is needed, i.e. reachable via some
>      external means.  */
>   inline void mark_force_output (void);
> 
>   /* Return true when function can be marked local.  */
>   bool local_p (void);
> 
>   /* Return true if cgraph_node can be made local for API change.
>      Extern inline functions and C++ COMDAT functions can be made local
>      at the expense of possible code size growth if function is used in multiple
>      compilation units.  */
>   bool can_be_local_p (void);
> 
>   /* Return true when cgraph_node can not return or throw and thus
>      it is safe to ignore its side effects for IPA analysis.  */
>   bool cannot_return_p (void);
> 
>   /* Return true when function cgraph_node and all its aliases are only called
>      directly.
>      i.e. it is not externally visible, address was not taken and
>      it is not used in any other non-standard way.  */
>   bool only_called_directly_p (void);
> 
>   /* Return true when function is only called directly or it has alias.
>      i.e. it is not externally visible, address was not taken and
>      it is not used in any other non-standard way.  */
>   inline bool only_called_directly_or_aliased_p (void);
> 
>   /* Return true when function cgraph_node can be expected to be removed
>      from program when direct calls in this compilation unit are removed.
> 
>      As a special case COMDAT functions are
>      cgraph_can_remove_if_no_direct_calls_p while the are not
>      cgraph_only_called_directly_p (it is possible they are called from other
>      unit)
> 
>      This function behaves as cgraph_only_called_directly_p because eliminating
>      all uses of COMDAT function does not make it necessarily disappear from
>      the program unless we are compiling whole program or we do LTO.  In this
>      case we know we win since dynamic linking will not really discard the
>      linkonce section.  */
>   bool will_be_removed_from_program_if_no_direct_calls_p (void);
> 
>   /* Return true when function can be removed from callgraph
>      if all direct calls are eliminated.  */
>   bool can_remove_if_no_direct_calls_and_refs_p (void);
> 
>   /* Return true when function cgraph_node and its aliases can be removed from
>      callgraph if all direct calls are eliminated.  */
>   bool can_remove_if_no_direct_calls_p (void);
> 
>   /* Return true when callgraph node is a function with Gimple body defined
>      in current unit.  Functions can also be define externally or they
>      can be thunks with no Gimple representation.
> 
>      Note that at WPA stage, the function body may not be present in memory.  */
>   inline bool has_gimple_body_p (void);
> 
>   /* Return true if function should be optimized for size.  */
>   bool optimize_for_size_p (void);
> 
>   /* Dump the callgraph to file F.  */
>   static void dump_cgraph (FILE *f);
> 
>   /* Dump the call graph to stderr.  */
>   static inline void debug_cgraph (void)
>   {
>     dump_cgraph (stderr);
>   }
> 
>   /* Record that DECL1 and DECL2 are semantically identical function
>      versions.  */
>   static void record_function_versions (tree decl1, tree decl2);
> 
>   /* Remove the cgraph_function_version_info and cgraph_node for DECL.  This
>      DECL is a duplicate declaration.  */
>   static void delete_function_version (tree decl);
> 
>   /* Add the function FNDECL to the call graph.
>      Unlike cgraph_finalize_function, this function is intended to be used
>      by middle end and allows insertion of new function at arbitrary point
>      of compilation.  The function can be either in high, low or SSA form
>      GIMPLE.
> 
>      The function is assumed to be reachable and have address taken (so no
>      API breaking optimizations are performed on it).
> 
>      Main work done by this function is to enqueue the function for later
>      processing to avoid need the passes to be re-entrant.  */
>   static void add_new_function (tree fndecl, bool lowered);
> 
>   /* Return callgraph node for given symbol and check it is a function. */
>   static inline cgraph_node *get (const_tree decl)
>   {
>     gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL);
>     return dyn_cast <cgraph_node *> (symtab_node::get (decl));
>   }
> 
>   /* Return cgraph node assigned to DECL.  Create new one when needed.  */
>   static cgraph_node * create (tree decl);
> 
>   /* Allocate new callgraph node and insert it into basic data structures.  */
>   static cgraph_node * create_empty (void);
> 
>   /* Try to find a call graph node for declaration DECL and if it does not
>      exist or if it corresponds to an inline clone, create a new one.  */
>   static cgraph_node * get_create (tree);
> 
>   /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
>      Return NULL if there's no such node.  */
>   static cgraph_node *get_for_asmname (tree asmname);
> 
>   /* Attempt to mark ALIAS as an alias to DECL.  Return alias node if
>      successful and NULL otherwise.
>      Same body aliases are output whenever the body of DECL is output,
>      and cgraph_node::get (ALIAS) transparently
>      returns cgraph_node::get (DECL).  */
>   static cgraph_node * create_same_body_alias (tree alias, tree decl);
> 
>   /* Worker for cgraph_can_remove_if_no_direct_calls_p.  */
>   static bool used_from_object_file_p_worker (cgraph_node *node, void *)
>   {
>     return node->used_from_object_file_p ();
>   }
> 
>   /* Return true when cgraph_node can not be local.
>      Worker for cgraph_local_node_p.  */
>   static bool non_local_p (cgraph_node *node, void *);
> 
>   /* Verify whole cgraph structure.  */
>   static void DEBUG_FUNCTION verify_cgraph_nodes (void);
> 
>   /* Worker to bring NODE local.  */
>   static bool make_local (cgraph_node *node, void *);
> 
>   /* Mark ALIAS as an alias to DECL.  DECL_NODE is cgraph node representing
>      the function body is associated
>      with (not necessarily cgraph_node (DECL).  */
>   static cgraph_node *create_alias (tree alias, tree target);
> 
>   static cgraph_edge * create_edge (cgraph_node *caller, cgraph_node *callee,
> 				    gimple call_stmt, gcov_type count,
> 				    int freq,
> 				    bool indir_unknown_callee);
> 
>   struct cgraph_edge *callees;
>   struct cgraph_edge *callers;
>   /* List of edges representing indirect calls with a yet undetermined
>      callee.  */
>   struct cgraph_edge *indirect_calls;
>   /* For nested functions points to function the node is nested in.  */
>   cgraph_node *origin;
>   /* Points to first nested function, if any.  */
>   cgraph_node *nested;
>   /* Pointer to the next function with same origin, if any.  */
>   cgraph_node *next_nested;
>   /* Pointer to the next clone.  */
>   cgraph_node *next_sibling_clone;
>   cgraph_node *prev_sibling_clone;
>   cgraph_node *clones;
>   cgraph_node *clone_of;
>   /* For functions with many calls sites it holds map from call expression
>      to the edge to speed up cgraph_edge function.  */
>   htab_t GTY((param_is (struct cgraph_edge))) call_site_hash;
>   /* Declaration node used to be clone of. */
>   tree former_clone_of;
> 
>   /* If this is a SIMD clone, this points to the SIMD specific
>      information for it.  */
>   struct cgraph_simd_clone *simdclone;
>   /* If this function has SIMD clones, this points to the first clone.  */
>   cgraph_node *simd_clones;
> 
>   /* Interprocedural passes scheduled to have their transform functions
>      applied next time we execute local pass on them.  We maintain it
>      per-function in order to allow IPA passes to introduce new functions.  */
>   vec<ipa_opt_pass> GTY((skip)) ipa_transforms_to_apply;
> 
>   struct cgraph_local_info local;
>   struct cgraph_global_info global;
>   struct cgraph_rtl_info rtl;
>   struct cgraph_clone_info clone;
>   struct cgraph_thunk_info thunk;
> 
>   /* Expected number of executions: calculated in profile.c.  */
>   gcov_type count;
>   /* How to scale counts at materialization time; used to merge
>      LTO units with different number of profile runs.  */
>   int count_materialization_scale;
>   /* Unique id of the node.  */
>   int uid;
>   /* ID assigned by the profiling.  */
>   unsigned int profile_id;
>   /* Time profiler: first run of function.  */
>   int tp_first_run;
> 
>   /* Set when decl is an abstract function pointed to by the
>      ABSTRACT_DECL_ORIGIN of a reachable function.  */
>   unsigned used_as_abstract_origin : 1;
>   /* Set once the function is lowered (i.e. its CFG is built).  */
>   unsigned lowered : 1;
>   /* Set once the function has been instantiated and its callee
>      lists created.  */
>   unsigned process : 1;
>   /* How commonly executed the node is.  Initialized during branch
>      probabilities pass.  */
>   ENUM_BITFIELD (node_frequency) frequency : 2;
>   /* True when function can only be called at startup (from static ctor).  */
>   unsigned only_called_at_startup : 1;
>   /* True when function can only be called at startup (from static dtor).  */
>   unsigned only_called_at_exit : 1;
>   /* True when function is the transactional clone of a function which
>      is called only from inside transactions.  */
>   /* ?? We should be able to remove this.  We have enough bits in
>      cgraph to calculate it.  */
>   unsigned tm_clone : 1;
>   /* True if this decl is a dispatcher for function versions.  */
>   unsigned dispatcher_function : 1;
>   /* True if this decl calls a COMDAT-local function.  This is set up in
>      compute_inline_parameters and inline_call.  */
>   unsigned calls_comdat_local : 1;
> };
> 
> /* A cgraph node set is a collection of cgraph nodes.  A cgraph node
>    can appear in multiple sets.  */
> struct cgraph_node_set_def
> {
>   struct pointer_map_t *map;
>   vec<cgraph_node *> nodes;
> };
> 
> typedef cgraph_node_set_def *cgraph_node_set;
> typedef struct varpool_node_set_def *varpool_node_set;
> 
> class varpool_node;
> 
> /* A varpool node set is a collection of varpool nodes.  A varpool node
>    can appear in multiple sets.  */
> struct varpool_node_set_def
> {
>   struct pointer_map_t * map;
>   vec<varpool_node *> nodes;
> };
> 
> /* Iterator structure for cgraph node sets.  */
> struct cgraph_node_set_iterator
> {
>   cgraph_node_set set;
>   unsigned index;
> };
> 
> /* Iterator structure for varpool node sets.  */
> struct varpool_node_set_iterator
> {
>   varpool_node_set set;
>   unsigned index;
> };
> 
> /* Structure containing additional information about an indirect call.  */
> 
> struct GTY(()) cgraph_indirect_call_info
> {
>   /* When polymorphic is set, this field contains offset where the object which
>      was actually used in the polymorphic resides within a larger structure.
>      If agg_contents is set, the field contains the offset within the aggregate
>      from which the address to call was loaded.  */
>   HOST_WIDE_INT offset;
>   /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set).  */
>   HOST_WIDE_INT otr_token;
>   /* Type of the object from OBJ_TYPE_REF_OBJECT. */
>   tree otr_type, outer_type;
>   /* Index of the parameter that is called.  */
>   int param_index;
>   /* ECF flags determined from the caller.  */
>   int ecf_flags;
>   /* Profile_id of common target obtrained from profile.  */
>   int common_target_id;
>   /* Probability that call will land in function with COMMON_TARGET_ID.  */
>   int common_target_probability;
> 
>   /* Set when the call is a virtual call with the parameter being the
>      associated object pointer rather than a simple direct call.  */
>   unsigned polymorphic : 1;
>   /* Set when the call is a call of a pointer loaded from contents of an
>      aggregate at offset.  */
>   unsigned agg_contents : 1;
>   /* Set when this is a call through a member pointer.  */
>   unsigned member_ptr : 1;
>   /* When the previous bit is set, this one determines whether the destination
>      is loaded from a parameter passed by reference. */
>   unsigned by_ref : 1;
>   unsigned int maybe_in_construction : 1;
>   unsigned int maybe_derived_type : 1;
> };
> 
> struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"))) cgraph_edge {
>   /* Expected number of executions: calculated in profile.c.  */
>   gcov_type count;
>   cgraph_node *caller;
>   cgraph_node *callee;
>   struct cgraph_edge *prev_caller;
>   struct cgraph_edge *next_caller;
>   struct cgraph_edge *prev_callee;
>   struct cgraph_edge *next_callee;
>   gimple call_stmt;
>   /* Additional information about an indirect call.  Not cleared when an edge
>      becomes direct.  */
>   struct cgraph_indirect_call_info *indirect_info;
>   PTR GTY ((skip (""))) aux;
>   /* When equal to CIF_OK, inline this call.  Otherwise, points to the
>      explanation why function was not inlined.  */
>   enum cgraph_inline_failed_t inline_failed;
>   /* The stmt_uid of call_stmt.  This is used by LTO to recover the call_stmt
>      when the function is serialized in.  */
>   unsigned int lto_stmt_uid;
>   /* Expected frequency of executions within the function.
>      When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
>      per function call.  The range is 0 to CGRAPH_FREQ_MAX.  */
>   int frequency;
>   /* Unique id of the edge.  */
>   int uid;
>   /* Whether this edge was made direct by indirect inlining.  */
>   unsigned int indirect_inlining_edge : 1;
>   /* Whether this edge describes an indirect call with an undetermined
>      callee.  */
>   unsigned int indirect_unknown_callee : 1;
>   /* Whether this edge is still a dangling  */
>   /* True if the corresponding CALL stmt cannot be inlined.  */
>   unsigned int call_stmt_cannot_inline_p : 1;
>   /* Can this call throw externally?  */
>   unsigned int can_throw_external : 1;
>   /* Edges with SPECULATIVE flag represents indirect calls that was
>      speculatively turned into direct (i.e. by profile feedback).
>      The final code sequence will have form:
> 
>      if (call_target == expected_fn)
>        expected_fn ();
>      else
>        call_target ();
> 
>      Every speculative call is represented by three components attached
>      to a same call statement:
>      1) a direct call (to expected_fn)
>      2) an indirect call (to call_target)
>      3) a IPA_REF_ADDR refrence to expected_fn.
> 
>      Optimizers may later redirect direct call to clone, so 1) and 3)
>      do not need to necesarily agree with destination.  */
>   unsigned int speculative : 1;
> };
> 
> #define CGRAPH_FREQ_BASE 1000
> #define CGRAPH_FREQ_MAX 100000
> 
> /* The varpool data structure.
>    Each static variable decl has assigned varpool_node.  */
> 
> class GTY((tag ("SYMTAB_VARIABLE"))) varpool_node : public symtab_node {
> public:
>   /* Set when variable is scheduled to be assembled.  */
>   unsigned output : 1;
> 
>   /* Set if the variable is dynamically initialized, except for
>      function local statics.   */
>   unsigned dynamically_initialized : 1;
> 
>   ENUM_BITFIELD(tls_model) tls_model : 3;
> 
>   /* Set if the variable is known to be used by single function only.
>      This is computed by ipa_signle_use pass and used by late optimizations
>      in places where optimization would be valid for local static variable
>      if we did not do any inter-procedural code movement.  */
>   unsigned used_by_single_function : 1;
> 
>   /* Dump given cgraph node to F.  */
>   void dump (FILE *f);
> 
>   /* Remove variable from symbol table.  */
>   void remove (void);
> };
> 
> /* Every top level asm statement is put into a asm_node.  */
> 
> struct GTY(()) asm_node {
>   /* Next asm node.  */
>   struct asm_node *next;
>   /* String for this asm node.  */
>   tree asm_str;
>   /* Ordering of all cgraph nodes.  */
>   int order;
> };
> 
> /* Report whether or not THIS symtab node is a function, aka cgraph_node.  */
> 
> template <>
> template <>
> inline bool
> is_a_helper <cgraph_node *>::test (symtab_node *p)
> {
>   return p && p->type == SYMTAB_FUNCTION;
> }
> 
> /* Report whether or not THIS symtab node is a vriable, aka varpool_node.  */
> 
> template <>
> template <>
> inline bool
> is_a_helper <varpool_node *>::test (symtab_node *p)
> {
>   return p && p->type == SYMTAB_VARIABLE;
> }
> 
> extern GTY(()) symtab_node *symtab_nodes;
> extern GTY(()) int cgraph_n_nodes;
> extern GTY(()) int cgraph_max_uid;
> extern GTY(()) int cgraph_edge_max_uid;
> extern bool cgraph_global_info_ready;
> enum cgraph_state
> {
>   /* Frontend is parsing and finalizing functions.  */
>   CGRAPH_STATE_PARSING,
>   /* Callgraph is being constructed.  It is safe to add new functions.  */
>   CGRAPH_STATE_CONSTRUCTION,
>   /* Callgraph is being at LTO time.  */
>   CGRAPH_LTO_STREAMING,
>   /* Callgraph is built and IPA passes are being run.  */
>   CGRAPH_STATE_IPA,
>   /* Callgraph is built and all functions are transformed to SSA form.  */
>   CGRAPH_STATE_IPA_SSA,
>   /* Functions are now ordered and being passed to RTL expanders.  */
>   CGRAPH_STATE_EXPANSION,
>   /* All cgraph expansion is done.  */
>   CGRAPH_STATE_FINISHED
> };
> extern enum cgraph_state cgraph_state;
> extern bool cgraph_function_flags_ready;
> extern cgraph_node_set cgraph_new_nodes;
> 
> extern GTY(()) struct asm_node *asm_nodes;
> extern GTY(()) int symtab_order;
> extern bool cpp_implicit_aliases_done;
> 
> /* In symtab.c  */
> symtab_node *symtab_node_for_asm (const_tree asmname);
> 
> /* In cgraph.c  */
> void release_function_body (tree);
> struct cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void);
> void cgraph_remove_edge (struct cgraph_edge *);
> 
> void cgraph_set_call_stmt (struct cgraph_edge *, gimple, bool update_speculative = true);
> void cgraph_update_edges_for_call_stmt (gimple, tree, gimple);
> struct cgraph_local_info *cgraph_local_info (tree);
> struct cgraph_global_info *cgraph_global_info (tree);
> struct cgraph_rtl_info *cgraph_rtl_info (tree);
> void cgraph_call_edge_duplication_hooks (struct cgraph_edge *,
> 				         struct cgraph_edge *);
> 
> bool cgraph_function_possibly_inlined_p (tree);
> bool cgraph_edge_cannot_lead_to_return (struct cgraph_edge *);
> void cgraph_redirect_edge_callee (struct cgraph_edge *, cgraph_node *);
> struct cgraph_edge *cgraph_make_edge_direct (struct cgraph_edge *,
> 					     cgraph_node *);
> 
> const char* cgraph_inline_failed_string (cgraph_inline_failed_t);
> cgraph_inline_failed_type_t cgraph_inline_failed_type (cgraph_inline_failed_t);
> 
> bool resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution);
> typedef void (*cgraph_edge_hook)(struct cgraph_edge *, void *);
> typedef void (*cgraph_node_hook)(cgraph_node *, void *);
> typedef void (*varpool_node_hook)(varpool_node *, void *);
> typedef void (*cgraph_2edge_hook)(struct cgraph_edge *, struct cgraph_edge *,
> 				  void *);
> typedef void (*cgraph_2node_hook)(cgraph_node *, cgraph_node *,
> 				  void *);
> struct cgraph_edge_hook_list;
> struct cgraph_node_hook_list;
> struct varpool_node_hook_list;
> struct cgraph_2edge_hook_list;
> struct cgraph_2node_hook_list;
> struct cgraph_edge_hook_list *cgraph_add_edge_removal_hook (cgraph_edge_hook, void *);
> void cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list *);
> cgraph_node_hook_list *cgraph_add_node_removal_hook (cgraph_node_hook,
> 							    void *);
> void cgraph_remove_node_removal_hook (cgraph_node_hook_list *);
> struct varpool_node_hook_list *varpool_add_node_removal_hook (varpool_node_hook,
> 							      void *);
> void varpool_remove_node_removal_hook (struct varpool_node_hook_list *);
> cgraph_node_hook_list *cgraph_add_function_insertion_hook (cgraph_node_hook,
> 							          void *);
> void cgraph_remove_function_insertion_hook (cgraph_node_hook_list *);
> struct varpool_node_hook_list *varpool_add_variable_insertion_hook (varpool_node_hook,
> 							            void *);
> void varpool_remove_variable_insertion_hook (struct varpool_node_hook_list *);
> struct cgraph_2edge_hook_list *cgraph_add_edge_duplication_hook (cgraph_2edge_hook, void *);
> void cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list *);
> struct cgraph_2node_hook_list *cgraph_add_node_duplication_hook (cgraph_2node_hook, void *);
> void cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list *);
> gimple cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *);
> struct cgraph_edge *
> cgraph_turn_edge_to_speculative (struct cgraph_edge *,
> 				 cgraph_node *,
> 				 gcov_type, int);
> void cgraph_speculative_call_info (struct cgraph_edge *,
> 				   struct cgraph_edge *&,
> 				   struct cgraph_edge *&,
> 				   struct ipa_ref *&);
> extern bool gimple_check_call_matching_types (gimple, tree, bool);
> 
> /* In cgraphunit.c  */
> struct asm_node *add_asm_node (tree);
> extern FILE *cgraph_dump_file;
> void cgraph_finalize_function (tree, bool);
> void finalize_compilation_unit (void);
> void compile (void);
> void init_cgraph (void);
> void cgraph_process_new_functions (void);
> void cgraph_process_same_body_aliases (void);
> /*  Initialize datastructures so DECL is a function in lowered gimple form.
>     IN_SSA is true if the gimple is in SSA.  */
> basic_block init_lowered_empty_function (tree, bool);
> 
> /* In cgraphclones.c  */
> 
> struct cgraph_edge * cgraph_clone_edge (struct cgraph_edge *,
> 					cgraph_node *, gimple,
> 					unsigned, gcov_type, int, bool);
> tree clone_function_name (tree decl, const char *);
> 
> void cgraph_materialize_all_clones (void);
> void tree_function_versioning (tree, tree, vec<ipa_replace_map *, va_gc> *,
> 			       bool, bitmap, bool, bitmap, basic_block);
> struct cgraph_edge *cgraph_resolve_speculation (struct cgraph_edge *, tree);
> 
> /* In cgraphbuild.c  */
> unsigned int rebuild_cgraph_edges (void);
> void cgraph_rebuild_references (void);
> int compute_call_stmt_bb_frequency (tree, basic_block bb);
> void record_references_in_initializer (tree, bool);
> 
> /* In ipa.c  */
> bool symtab_remove_unreachable_nodes (bool, FILE *);
> cgraph_node_set cgraph_node_set_new (void);
> cgraph_node_set_iterator cgraph_node_set_find (cgraph_node_set,
> 					       cgraph_node *);
> void cgraph_node_set_add (cgraph_node_set, cgraph_node *);
> void cgraph_node_set_remove (cgraph_node_set, cgraph_node *);
> void dump_cgraph_node_set (FILE *, cgraph_node_set);
> void debug_cgraph_node_set (cgraph_node_set);
> void free_cgraph_node_set (cgraph_node_set);
> void cgraph_build_static_cdtor (char which, tree body, int priority);
> 
> varpool_node_set varpool_node_set_new (void);
> varpool_node_set_iterator varpool_node_set_find (varpool_node_set,
> 						 varpool_node *);
> void varpool_node_set_add (varpool_node_set, varpool_node *);
> void varpool_node_set_remove (varpool_node_set, varpool_node *);
> void dump_varpool_node_set (FILE *, varpool_node_set);
> void debug_varpool_node_set (varpool_node_set);
> void free_varpool_node_set (varpool_node_set);
> void ipa_discover_readonly_nonaddressable_vars (void);
> bool varpool_externally_visible_p (varpool_node *);
> 
> /* In predict.c  */
> bool cgraph_maybe_hot_edge_p (struct cgraph_edge *e);
> 
> /* In varpool.c  */
> varpool_node *varpool_create_empty_node (void);
> varpool_node *varpool_node_for_decl (tree);
> varpool_node *varpool_node_for_asm (tree asmname);
> void varpool_mark_needed_node (varpool_node *);
> void debug_varpool (void);
> void dump_varpool (FILE *);
> 
> void varpool_finalize_decl (tree);
> enum availability cgraph_variable_initializer_availability (varpool_node *);
> 
> void varpool_finalize_named_section_flags (varpool_node *node);
> bool varpool_output_variables (void);
> bool varpool_assemble_decl (varpool_node *node);
> void varpool_analyze_node (varpool_node *);
> varpool_node * varpool_extra_name_alias (tree, tree);
> varpool_node * varpool_create_variable_alias (tree, tree);
> void varpool_reset_queue (void);
> bool varpool_ctor_useable_for_folding_p (varpool_node *);
> tree ctor_for_folding (tree);
> bool varpool_for_node_and_aliases (varpool_node *,
> 		                   bool (*) (varpool_node *, void *),
> 			           void *, bool);
> void varpool_add_new_variable (tree);
> void symtab_initialize_asm_name_hash (void);
> void symtab_prevail_in_asm_name_hash (symtab_node *node);
> void varpool_remove_initializer (varpool_node *);
> tree varpool_get_constructor (struct varpool_node *node);
> 
> /* In cgraph.c */
> extern void change_decl_assembler_name (tree, tree);
> 
> /* Return true when the symbol is real symbol, i.e. it is not inline clone
>    or abstract function kept for debug info purposes only.  */
> inline bool
> symtab_node::real_symbol_p (void)
> {
>   cgraph_node *cnode;
> 
>   if (DECL_ABSTRACT (decl))
>     return false;
>   if (!is_a <cgraph_node *> (this))
>     return true;
>   cnode = dyn_cast <cgraph_node *> (this);
>   if (cnode->global.inlined_to)
>     return false;
>   return true;
> }
> 
> /* Return true if DECL should have entry in symbol table if used.
>    Those are functions and static & external veriables*/
> 
> static inline bool
> decl_in_symtab_p (const_tree decl)
> {
>   return (TREE_CODE (decl) == FUNCTION_DECL
>           || (TREE_CODE (decl) == VAR_DECL
> 	      && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))));
> }
> 
> inline bool
> symtab_node::in_same_comdat_group_p (symtab_node *target)
> {
>   symtab_node *source = this;
> 
>   if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
>     {
>       if (cn->global.inlined_to)
> 	source = cn->global.inlined_to;
>     }
>   if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
>     {
>       if (cn->global.inlined_to)
> 	target = cn->global.inlined_to;
>     }
> 
>   return source->get_comdat_group () == target->get_comdat_group ();
> }
> 
> /* Return node that alias is aliasing.  */
> 
> inline symtab_node *
> symtab_node::get_alias_target (void)
> {
>   struct ipa_ref *ref = NULL;
>   iterate_reference (0, ref);
>   gcc_checking_assert (ref->use == IPA_REF_ALIAS);
>   return ref->referred;
> }
> 
> /* Return next reachable static symbol with initializer after the node.  */
> inline symtab_node *
> symtab_node::next_defined_symbol (void)
> {
>   symtab_node *node1 = next;
> 
>   for (; node1; node1 = node1->next)
>     if (node1->definition)
>       return node1;
> 
>   return NULL;
> }
> 
> /* Return varpool node for given symbol and check it is a function. */
> static inline varpool_node *
> varpool_get_node (const_tree decl)
> {
>   gcc_checking_assert (TREE_CODE (decl) == VAR_DECL);
>   return dyn_cast<varpool_node *> (symtab_node::get (decl));
> }
> 
> /* Walk all symbols.  */
> #define FOR_EACH_SYMBOL(node) \
>    for ((node) = symtab_nodes; (node); (node) = (node)->next)
> 
> /* Return first static symbol with definition.  */
> static inline symtab_node *
> symtab_first_defined_symbol (void)
> {
>   symtab_node *node;
> 
>   for (node = symtab_nodes; node; node = node->next)
>     if (node->definition)
>       return node;
> 
>   return NULL;
> }
> 
> /* Walk all symbols with definitions in current unit.  */
> #define FOR_EACH_DEFINED_SYMBOL(node) \
>    for ((node) = symtab_first_defined_symbol (); (node); \
> 	(node) = node->next_defined_symbol ())
> 
> /* Return first variable.  */
> static inline varpool_node *
> varpool_first_variable (void)
> {
>   symtab_node *node;
>   for (node = symtab_nodes; node; node = node->next)
>     if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
>       return vnode;
>   return NULL;
> }
> 
> /* Return next variable after NODE.  */
> static inline varpool_node *
> varpool_next_variable (varpool_node *node)
> {
>   symtab_node *node1 = node->next;
>   for (; node1; node1 = node1->next)
>     if (varpool_node *vnode1 = dyn_cast <varpool_node *> (node1))
>       return vnode1;
>   return NULL;
> }
> /* Walk all variables.  */
> #define FOR_EACH_VARIABLE(node) \
>    for ((node) = varpool_first_variable (); \
>         (node); \
> 	(node) = varpool_next_variable ((node)))
> 
> /* Return first static variable with initializer.  */
> static inline varpool_node *
> varpool_first_static_initializer (void)
> {
>   symtab_node *node;
>   for (node = symtab_nodes; node; node = node->next)
>     {
>       varpool_node *vnode = dyn_cast <varpool_node *> (node);
>       if (vnode && DECL_INITIAL (node->decl))
> 	return vnode;
>     }
>   return NULL;
> }
> 
> /* Return next static variable with initializer after NODE.  */
> static inline varpool_node *
> varpool_next_static_initializer (varpool_node *node)
> {
>   symtab_node *node1 = node->next;
>   for (; node1; node1 = node1->next)
>     {
>       varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
>       if (vnode1 && DECL_INITIAL (node1->decl))
> 	return vnode1;
>     }
>   return NULL;
> }
> 
> /* Walk all static variables with initializer set.  */
> #define FOR_EACH_STATIC_INITIALIZER(node) \
>    for ((node) = varpool_first_static_initializer (); (node); \
>         (node) = varpool_next_static_initializer (node))
> 
> /* Return first static variable with definition.  */
> static inline varpool_node *
> varpool_first_defined_variable (void)
> {
>   symtab_node *node;
>   for (node = symtab_nodes; node; node = node->next)
>     {
>       varpool_node *vnode = dyn_cast <varpool_node *> (node);
>       if (vnode && vnode->definition)
> 	return vnode;
>     }
>   return NULL;
> }
> 
> /* Return next static variable with definition after NODE.  */
> static inline varpool_node *
> varpool_next_defined_variable (varpool_node *node)
> {
>   symtab_node *node1 = node->next;
>   for (; node1; node1 = node1->next)
>     {
>       varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
>       if (vnode1 && vnode1->definition)
> 	return vnode1;
>     }
>   return NULL;
> }
> /* Walk all variables with definitions in current unit.  */
> #define FOR_EACH_DEFINED_VARIABLE(node) \
>    for ((node) = varpool_first_defined_variable (); (node); \
>         (node) = varpool_next_defined_variable (node))
> 
> /* Return first function with body defined.  */
> static inline cgraph_node *
> cgraph_first_defined_function (void)
> {
>   symtab_node *node;
>   for (node = symtab_nodes; node; node = node->next)
>     {
>       cgraph_node *cn = dyn_cast <cgraph_node *> (node);
>       if (cn && cn->definition)
> 	return cn;
>     }
>   return NULL;
> }
> 
> /* Return next function with body defined after NODE.  */
> static inline cgraph_node *
> cgraph_next_defined_function (cgraph_node *node)
> {
>   symtab_node *node1 = node->next;
>   for (; node1; node1 = node1->next)
>     {
>       cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
>       if (cn1 && cn1->definition)
> 	return cn1;
>     }
>   return NULL;
> }
> 
> /* Walk all functions with body defined.  */
> #define FOR_EACH_DEFINED_FUNCTION(node) \
>    for ((node) = cgraph_first_defined_function (); (node); \
>         (node) = cgraph_next_defined_function ((node)))
> 
> /* Return first function.  */
> static inline cgraph_node *
> cgraph_first_function (void)
> {
>   symtab_node *node;
>   for (node = symtab_nodes; node; node = node->next)
>     if (cgraph_node *cn = dyn_cast <cgraph_node *> (node))
>       return cn;
>   return NULL;
> }
> 
> /* Return next function.  */
> static inline cgraph_node *
> cgraph_next_function (cgraph_node *node)
> {
>   symtab_node *node1 = node->next;
>   for (; node1; node1 = node1->next)
>     if (cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1))
>       return cn1;
>   return NULL;
> }
> /* Walk all functions.  */
> #define FOR_EACH_FUNCTION(node) \
>    for ((node) = cgraph_first_function (); (node); \
>         (node) = cgraph_next_function ((node)))
> 
> /* Return true when callgraph node is a function with Gimple body defined
>    in current unit.  Functions can also be define externally or they
>    can be thunks with no Gimple representation.
> 
>    Note that at WPA stage, the function body may not be present in memory.  */
> 
> inline bool
> cgraph_node::has_gimple_body_p (void)
> {
>   return definition && !thunk.thunk_p && !alias;
> }
> 
> /* Return first function with body defined.  */
> static inline cgraph_node *
> cgraph_first_function_with_gimple_body (void)
> {
>   symtab_node *node;
>   for (node = symtab_nodes; node; node = node->next)
>     {
>       cgraph_node *cn = dyn_cast <cgraph_node *> (node);
>       if (cn && cn->has_gimple_body_p ())
> 	return cn;
>     }
>   return NULL;
> }
> 
> /* Return next reachable static variable with initializer after NODE.  */
> static inline cgraph_node *
> cgraph_next_function_with_gimple_body (cgraph_node *node)
> {
>   symtab_node *node1 = node->next;
>   for (; node1; node1 = node1->next)
>     {
>       cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
>       if (cn1 && cn1->has_gimple_body_p ())
> 	return cn1;
>     }
>   return NULL;
> }
> 
> /* Walk all functions with body defined.  */
> #define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
>    for ((node) = cgraph_first_function_with_gimple_body (); (node); \
>         (node) = cgraph_next_function_with_gimple_body (node))
> 
> /* Create a new static variable of type TYPE.  */
> tree add_new_static_var (tree type);
> 
> /* Return true if iterator CSI points to nothing.  */
> static inline bool
> csi_end_p (cgraph_node_set_iterator csi)
> {
>   return csi.index >= csi.set->nodes.length ();
> }
> 
> /* Advance iterator CSI.  */
> static inline void
> csi_next (cgraph_node_set_iterator *csi)
> {
>   csi->index++;
> }
> 
> /* Return the node pointed to by CSI.  */
> static inline cgraph_node *
> csi_node (cgraph_node_set_iterator csi)
> {
>   return csi.set->nodes[csi.index];
> }
> 
> /* Return an iterator to the first node in SET.  */
> static inline cgraph_node_set_iterator
> csi_start (cgraph_node_set set)
> {
>   cgraph_node_set_iterator csi;
> 
>   csi.set = set;
>   csi.index = 0;
>   return csi;
> }
> 
> /* Return true if SET contains NODE.  */
> static inline bool
> cgraph_node_in_set_p (cgraph_node *node, cgraph_node_set set)
> {
>   cgraph_node_set_iterator csi;
>   csi = cgraph_node_set_find (set, node);
>   return !csi_end_p (csi);
> }
> 
> /* Return number of nodes in SET.  */
> static inline size_t
> cgraph_node_set_size (cgraph_node_set set)
> {
>   return set->nodes.length ();
> }
> 
> /* Return true if iterator VSI points to nothing.  */
> static inline bool
> vsi_end_p (varpool_node_set_iterator vsi)
> {
>   return vsi.index >= vsi.set->nodes.length ();
> }
> 
> /* Advance iterator VSI.  */
> static inline void
> vsi_next (varpool_node_set_iterator *vsi)
> {
>   vsi->index++;
> }
> 
> /* Return the node pointed to by VSI.  */
> static inline varpool_node *
> vsi_node (varpool_node_set_iterator vsi)
> {
>   return vsi.set->nodes[vsi.index];
> }
> 
> /* Return an iterator to the first node in SET.  */
> static inline varpool_node_set_iterator
> vsi_start (varpool_node_set set)
> {
>   varpool_node_set_iterator vsi;
> 
>   vsi.set = set;
>   vsi.index = 0;
>   return vsi;
> }
> 
> /* Return number of nodes in SET.  */
> static inline size_t
> varpool_node_set_size (varpool_node_set set)
> {
>   return set->nodes.length ();
> }
> 
> /* Uniquize all constants that appear in memory.
>    Each constant in memory thus far output is recorded
>    in `const_desc_table'.  */
> 
> struct GTY(()) constant_descriptor_tree {
>   /* A MEM for the constant.  */
>   rtx rtl;
> 
>   /* The value of the constant.  */
>   tree value;
> 
>   /* Hash of value.  Computing the hash from value each time
>      hashfn is called can't work properly, as that means recursive
>      use of the hash table during hash table expansion.  */
>   hashval_t hash;
> };
> 
> /* Return true if set is nonempty.  */
> static inline bool
> cgraph_node_set_nonempty_p (cgraph_node_set set)
> {
>   return !set->nodes.is_empty ();
> }
> 
> /* Return true if set is nonempty.  */
> static inline bool
> varpool_node_set_nonempty_p (varpool_node_set set)
> {
>   return !set->nodes.is_empty ();
> }
> 
> /* Return true when function is only called directly or it has alias.
>    i.e. it is not externally visible, address was not taken and
>    it is not used in any other non-standard way.  */
> 
> inline bool
> cgraph_node::only_called_directly_or_aliased_p (void)
> {
>   gcc_assert (!global.inlined_to);
>   return (!force_output && !address_taken
> 	  && !used_from_other_partition
> 	  && !DECL_VIRTUAL_P (decl)
> 	  && !DECL_STATIC_CONSTRUCTOR (decl)
> 	  && !DECL_STATIC_DESTRUCTOR (decl)
> 	  && !externally_visible);
> }
> 
> /* Return true when function NODE can be removed from callgraph
>    if all direct calls are eliminated.  */
> 
> static inline bool
> varpool_can_remove_if_no_refs (varpool_node *node)
> {
>   if (DECL_EXTERNAL (node->decl))
>     return true;
>   return (!node->force_output && !node->used_from_other_partition
>   	  && ((DECL_COMDAT (node->decl)
> 	       && !node->forced_by_abi
> 	       && !node->used_from_object_file_p ())
> 	      || !node->externally_visible
> 	      || DECL_HAS_VALUE_EXPR_P (node->decl)));
> }
> 
> /* Return true when all references to VNODE must be visible in ipa_ref_list.
>    i.e. if the variable is not externally visible or not used in some magic
>    way (asm statement or such).
>    The magic uses are all summarized in force_output flag.  */
> 
> static inline bool
> varpool_all_refs_explicit_p (varpool_node *vnode)
> {
>   return (vnode->definition
> 	  && !vnode->externally_visible
> 	  && !vnode->used_from_other_partition
> 	  && !vnode->force_output);
> }
> 
> /* Constant pool accessor function.  */
> htab_t constant_pool_htab (void);
> 
> /* Return node that alias is aliasing.  */
> 
> inline cgraph_node *
> cgraph_node::get_alias_target (void)
> {
>   return dyn_cast <cgraph_node *> (symtab_node::get_alias_target ());
> }
> 
> static inline varpool_node *
> varpool_alias_target (varpool_node *n)
> {
>   return dyn_cast <varpool_node *> (n->get_alias_target ());
> }
> 
> /* Given function symbol, walk the alias chain to return the function node
>    is alias of. Do not walk through thunks.
>    When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
> 
> inline cgraph_node *
> cgraph_node::ultimate_alias_target (enum availability *availability)
> {
>   cgraph_node *n = dyn_cast <cgraph_node *> (symtab_node::ultimate_alias_target
>     (availability));
>   if (!n && availability)
>     *availability = AVAIL_NOT_AVAILABLE;
>   return n;
> }
> /* Given NODE, walk the alias chain to return the function NODE is alias of.
>    Do not walk through thunks.
>    When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
> 
> static inline varpool_node *
> varpool_variable_node (varpool_node *node,
> 		       enum availability *availability = NULL)
> {
>   varpool_node *n;
> 
>   if (node)
>     n = dyn_cast <varpool_node *> (node->ultimate_alias_target (availability));
>   else
>     n = NULL;
> 
>   if (!n && availability)
>     *availability = AVAIL_NOT_AVAILABLE;
>   return n;
> }
> 
> /* Return true when the edge E represents a direct recursion.  */
> static inline bool
> cgraph_edge_recursive_p (struct cgraph_edge *e)
> {
>   cgraph_node *callee = e->callee->ultimate_alias_target ();
>   if (e->caller->global.inlined_to)
>     return e->caller->global.inlined_to->decl == callee->decl;
>   else
>     return e->caller->decl == callee->decl;
> }
> 
> /* Return true if the TM_CLONE bit is set for a given FNDECL.  */
> static inline bool
> decl_is_tm_clone (const_tree fndecl)
> {
>   cgraph_node *n = cgraph_node::get (fndecl);
>   if (n)
>     return n->tm_clone;
>   return false;
> }
> 
> /* Likewise indicate that a node is needed, i.e. reachable via some
>    external means.  */
> 
> inline void
> cgraph_node::mark_force_output (void)
> {
>   force_output = 1;
>   gcc_checking_assert (!global.inlined_to);
> }
> 
> #endif  /* GCC_CGRAPH_H  */

Re: [RFC, PATCH 1/n] IPA C++ refactoring

[Martin Liška]

[-- Attachment #1: Type: text/plain, Size: 26297 bytes --]


On 07/16/2014 02:00 PM, Martin Liška wrote:
>
> On 07/15/2014 12:00 PM, Jan Hubicka wrote:
>>> I tried to mark it as protected, by there's usage that blocks that:
>>>
>>> In file included from ../../gcc/symtab.c:40:0:
>>> ../../gcc/cgraph.h: In member function ?void symtab_node::unregister()?:
>>> ../../gcc/cgraph.h:1178:16: error: ?cgraph_node* cgraph_node::find_replacement()? is protected
>>>     cgraph_node *find_replacement (void);
>>>                  ^
>>> ../../gcc/symtab.c:462:46: error: within this context
>>>    replacement_node = cnode->find_replacement ();
>> OK, lets keep it public for now then.
>>
>>>> Likewise
>>> create_version_clone_with_body calls: new_version_node->call_function_insertion_hooks ();
>> OK.
>>> Usages from outside of cgraph_node:
>>>
>>> cgraph.c:cgraph_node::create_empty (void)
>>> cgraph.c:  struct cgraph_node *node = cgraph_node::create_empty ();
>>> cgraphclones.c:  struct cgraph_node *new_node = cgraph_node::create_empty ();
>>> lto-cgraph.c:      node = cgraph_node::create_empty ();
>>>
>>> I will go through class members and check grouping one more.
>>> What do  you think about 'static' class functions, should be placed after all member functions?
>> Sounds fine for me.
>>
>> Honza
> Hi,
>    this email contains final version of that patch, cosmetic changes were applied.
>
> I prepared list of all function that have been transformed:
>
> SYMTAB_NODE
>
> public:
>   void register_symbol (void) created from: symtab_register_node
>   void remove (void) created from: symtab_remove_node
>   void dump (FILE *f) created from: dump_symtab_node
>   void DEBUG_FUNCTION debug (void) created from: debug_symtab_node
>   void DEBUG_FUNCTION verify (void) created from: verify_symtab_node
>   struct ipa_ref *add_reference (symtab_node *referred_node, enum ipa_ref_use use_type) created from: add_reference
>   struct ipa_ref *add_reference (symtab_node *referred_node, enum ipa_ref_use use_type, gimple stmt) created from: add_reference
>   struct ipa_ref *maybe_add_reference (tree val, enum ipa_ref_use use_type, gimple stmt) created from: maybe_add_reference
>   bool semantically_equivalent_p (symtab_node *target) created from: symtab_semantically_equivalent_p
>   void remove_from_same_comdat_group (void) created from: remove_from_same_comdat_group
>   void add_to_same_comdat_group (symtab_node *old_node) created from: symtab_add_to_same_comdat_group
>   void dissolve_same_comdat_group_list (void) created from: symtab_dissolve_same_comdat_group_list
>   bool used_from_object_file_p (void) created from: symtab_used_from_object_file_p
>   symtab_node *ultimate_alias_target (enum availability *avail = NULL) created from: symtab_alias_ultimate_target
>   inline symtab_node *next_defined_symbol (void) created from: symtab_next_defined_symbol
>   bool resolve_alias (symtab_node *target) created from: symtab_resolve_alias
>   bool call_for_symbol_and_aliases (bool (*callback) (symtab_node *, void *), void *data, bool include_overwrite) created from: symtab_for_node_and_aliases
>   symtab_node *noninterposable_alias (void) created from: symtab_nonoverwritable_alias
>   inline symtab_node *get_alias_target (void) created from: symtab_alias_target
>   void set_section (const char *section) created from: set_section_1
>   enum availability get_availability (void) created from: symtab_node_availability
>   void make_decl_local (void) created from: symtab_make_decl_local
>   bool real_symbol_p (void) created from: symtab_read_node
>   can_be_discarded_p (void) created from: symtab_can_be_discarded
>   inline bool comdat_local_p (void) created from: symtab_comdat_local_p
>   inline bool in_same_comdat_group_p (symtab_node *target) created from: symtab_in_same_comdat_p;
>   bool address_taken_from_non_vtable_p (void) created from: address_taken_from_non_vtable_p
>   static inline symtab_node *get (const_tree decl) created from: symtab_get_node
>   static void dump_table (FILE *) created from: dump_symtab
>   static inline DEBUG_FUNCTION void debug_symtab (void) created from: debug_symtab
>   static DEBUG_FUNCTION void verify_symtab_nodes (void) created from: verify_symtab
>   static bool used_from_object_file_p_worker (symtab_node *node) created from: symtab_used_from_object_file_p
>
> protected:
>   void dump_base (FILE *) created from: dump_symtab_base
>   bool DEBUG_FUNCTION verify_base (void) created from: verify_symtab_base
>   void unregister (void) created from: symtab_unregister_node
>   struct symbol_priority_map *priority_info (void) created from: symtab_priority_info
>
> private:
>   static bool set_implicit_section (symtab_node *n, void *) created from: set_implicit_section
>   static bool noninterposable_alias (symtab_node *node, void *data) created from: symtab_nonoverwritable_alias_1
>
>
> CGRAPH_NODE
>
> public:
>   bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL) created from: cgraph_remove_node_and_inline_clones
>   void record_stmt_references (gimple stmt) created from: ipa_record_stmt_references
>   void set_call_stmt_including_clones (gimple old_stmt, gimple new_stmt, bool update_speculative = true) created from: cgraph_set_call_stmt_including_clones
>   cgraph_node *function_symbol (enum availability *avail = NULL) created from: cgraph_function_node
>   cgraph_node *create_clone (tree decl, gcov_type count, int freq, bool update_original, vec<cgraph_edge *> redirect_callers, bool call_duplication_hook, struct cgraph_node *new_inlined_to, bitmap args_to_skip) created from: cgraph_create_clone
>   cgraph_node *create_virtual_clone (vec<cgraph_edge *> redirect_callers, vec<ipa_replace_map *, va_gc> *tree_map, bitmap args_to_skip, const char * suffix) created from: cgraph_create_virtual_clone
>   cgraph_node *find_replacement (void) created from: cgraph_find_replacement_node
>   cgraph_node *create_version_clone (tree new_decl, vec<cgraph_edge *> redirect_callers, bitmap bbs_to_copy) created from: cgraph_copy_node_for_versioning
>   cgraph_node *create_version_clone_with_body (vec<cgraph_edge *> redirect_callers, vec<ipa_replace_map *, va_gc> *tree_map, bitmap args_to_skip, bool skip_return, bitmap bbs_to_copy, basic_block new_entry_block, const char *clone_name) created from: cgraph_function_version_info
>   struct cgraph_function_version_info *insert_new_function_version (void) created from: insert_new_cgraph_node_version
>   struct cgraph_function_version_info *function_version (void) created from: get_cgraph_node_version
>   void analyze (void) created from: analyze_function
>   cgraph_node * create_thunk (tree alias, tree, bool this_adjusting, HOST_WIDE_INT fixed_offset, HOST_WIDE_INT virtual_value, tree virtual_offset, tree real_alias) cgraph_add_thunk
>   inline cgraph_node *get_alias_target (void) created from: cgraph_alias_target
>   cgraph_node *ultimate_alias_target (availability *availability = NULL) created from: cgraph_function_or_thunk_node
>   bool expand_thunk (bool output_asm_thunks, bool force_gimple_thunk) created from: expand_thunk
>   void reset (void) created from: cgraph_reset_node
>   void create_wrapper (cgraph_node *target) created from: cgraph_make_wrapper
>   void DEBUG_FUNCTION verify_node (void) created from: verify_cgraph_node
>   void remove (void) created from: cgraph_remove_node
>   void dump (FILE *f) created from: dump_cgraph_node
>   void DEBUG_FUNCTION debug (void) created from: debug_cgraph_node
>   bool get_body (void) created from: cgraph_get_body
>   void release_body (void) created from: cgraph_release_function_body
>   void unnest (void) created from: cgraph_unnest_node
>   void make_local (void) created from: cgraph_make_node_local
>   void mark_address_taken (void) created from: cgraph_mark_address_taken_node
>   struct cgraph_edge *create_edge (cgraph_node *callee, gimple call_stmt, gcov_type count, int freq) created from: cgraph_create_edge
>   struct cgraph_edge *create_indirect_edge (gimple call_stmt, int ecf_flags, gcov_type count, int freq) created from: cgraph_create_indirect_edge
>   void create_edge_including_clones (struct cgraph_node *callee, gimple old_stmt, gimple stmt, gcov_type count, int freq, cgraph_inline_failed_t reason) created from: cgraph_create_edge_including_clones
>   cgraph_edge *get_edge (gimple call_stmt) created from: cgraph_edge
>   vec<cgraph_edge *> collect_callers (void) created from: collect_callers_of_node
>   void remove_callers (void) created from: cgraph_node_remove_callers
>   void remove_callees (void) created from: cgraph_node_remove_callees
>   enum availability get_availability (void) created from: cgraph_function_body_availability
>   void set_nothrow_flag (bool nothrow) created from: cgraph_set_nothrow_flag
>   void set_const_flag (bool readonly, bool looping) created from: cgraph_set_const_flag
>   void set_pure_flag (bool pure, bool looping) created from: cgraph_set_pure_flag
>   void call_duplication_hooks (cgraph_node *node2) created from: cgraph_call_node_duplication_hooks
>   bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *, void *), void *data, bool include_overwritable) created from: cgraph_for_node_and_aliases
>   bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node, void *data), void *data, bool include_overwritable) created from: cgraph_for_node_thunks_and_aliases
>   void call_function_insertion_hooks (void) created from: cgraph_call_function_insertion_hooks
>   inline void mark_force_output (void) created from: cgraph_mark_force_output_node
>   bool local_p (void) created from: cgraph_local_node
>   bool can_be_local_p (void) created from: cgraph_node_can_be_local_p
>   bool cannot_return_p (void) created from: cgraph_node_cannot_return
>   bool only_called_directly_p (void) created from: cgraph_only_called_directly_p
>   inline bool only_called_directly_or_aliased_p (void) created from: cgraph_only_called_directly_or_aliased_p
>   bool will_be_removed_from_program_if_no_direct_calls_p (void) created from: cgraph_will_be_removed_from_program_if_no_direct_calls
>   bool can_remove_if_no_direct_calls_and_refs_p (void) created from: cgraph_can_remove_if_no_direct_calls_and_refs_p
>   bool can_remove_if_no_direct_calls_p (void) created from: cgraph_can_remove_if_no_direct_calls_p
>   inline bool has_gimple_body_p (void) created from: cgraph_function_with_gimple_body_p
>   bool optimize_for_size_p (void) created from: cgraph_optimize_for_size_p
>   static void dump_cgraph (FILE *f) created from: dump_cgraph
>   static inline void debug_cgraph (void) created from: debug_cgraph
>   static void record_function_versions (tree decl1, tree decl2) created from: record_function_versions
>   static void delete_function_version (tree decl) created from: delete_function_version
>   static void add_new_function (tree fndecl, bool lowered) created from: cgraph_add_new_function
>   static inline cgraph_node *get (const_tree decl) created from: cgraph_get_node
>   static cgraph_node * create (tree decl) created from: cgraph_create_node
>   static cgraph_node * create_empty (void) created from: cgraph_create_empty_node
>   static cgraph_node * get_create (tree) created from: cgraph_get_create_node
>   static cgraph_node *get_for_asmname (tree asmname) created from: cgraph_node_for_asm
>   static cgraph_node * create_same_body_alias (tree alias, tree decl) created from: cgraph_same_body_alias
>   static bool used_from_object_file_p_worker (cgraph_node *node, void *) new function
>   static bool non_local_p (cgraph_node *node, void *) created from: cgraph_non_local_node_p_1
>   static void DEBUG_FUNCTION verify_cgraph_nodes (void) created from: verify_cgraph
>   static bool make_local (cgraph_node *node, void *) created from: cgraph_make_node_local
>   static cgraph_node *create_alias (tree alias, tree target) created from: cgraph_create_function_alias
>   static cgraph_edge * create_edge (cgraph_node *caller, cgraph_node *callee, gimple call_stmt, gcov_type count, int freq, bool indir_unknown_callee) created from: cgraph_create_edge_1
>
> VARPOOL_NODE
>
> public:
>   void remove (void) created from: varpool_remove_node
>   void dump (FILE *f) created from: dump_varpool_node
>
> Can you please advise me how to create a ChangeLog entry based on such transformation?
>
> For being sure, I've been running testsuite for all supported languages.
>
> Thank you,
> Martin
Hello,
    following final version has been just regtested and can bootstrap without any regression.
gcc/ChangeLog:

2014-07-17  Martin Liska  <mliska@suse.cz>

   * cgraph.h (symtab_node):
   (void register_symbol (void)): created from symtab_register_node
   (void remove (void)): created from symtab_remove_node
   (void dump (FILE *f)): created from dump_symtab_node
   (void DEBUG_FUNCTION debug (void)): created from debug_symtab_node
   (void DEBUG_FUNCTION verify (void)): created from verify_symtab_node
   (struct ipa_ref *add_reference (symtab_node *referred_node,
     enum ipa_ref_use use_type)): created from add_reference
   (struct ipa_ref *add_reference (symtab_node *referred_node,
     enum ipa_ref_use use_type, gimple stmt)): created from add_reference
   (struct ipa_ref *maybe_add_reference (tree val, enum ipa_ref_use use_type,
     gimple stmt)): created from maybe_add_reference
   (bool semantically_equivalent_p (symtab_node *target)): created from
     symtab_semantically_equivalent_p
   (void remove_from_same_comdat_group (void)): created from
     remove_from_same_comdat_group
   (void add_to_same_comdat_group (symtab_node *old_node)): created from
     symtab_add_to_same_comdat_group
   (void dissolve_same_comdat_group_list (void)): created from
     symtab_dissolve_same_comdat_group_list
   (bool used_from_object_file_p (void)): created from symtab_used_from_object_file_p
   (symtab_node *ultimate_alias_target (enum availability *avail = NULL)):
     created from symtab_alias_ultimate_target
   (inline symtab_node *next_defined_symbol (void)): created from
     symtab_next_defined_symbol
   (bool resolve_alias (symtab_node *target)): created from
     symtab_resolve_alias
   (bool call_for_symbol_and_aliases (bool (*callback) (symtab_node *, void *),
     void *data, bool include_overwrite)): created from symtab_for_node_and_aliases
   (symtab_node *noninterposable_alias (void)): created from symtab_nonoverwritable_alias
   (inline symtab_node *get_alias_target (void)): created from symtab_alias_target
   (void set_section (const char *section)): created from set_section_1
   (enum availability get_availability (void)): created from symtab_node_availability
   (void make_decl_local (void)): created from symtab_make_decl_local
   (bool real_symbol_p (void)): created from symtab_read_node
   (can_be_discarded_p (void)): created from symtab_can_be_discarded
   (inline bool comdat_local_p (void)): created from symtab_comdat_local_p
   (inline bool in_same_comdat_group_p (symtab_node *target)): created from
     symtab_in_same_comdat_p;
   (bool address_taken_from_non_vtable_p (void)): created from
     address_taken_from_non_vtable_p
   (static inline symtab_node *get (const_tree decl)): created from symtab_get_node
   (static void dump_table (FILE *)): created from dump_symtab
   (static inline DEBUG_FUNCTION void debug_symtab (void)): created from debug_symtab
   (static DEBUG_FUNCTION void verify_symtab_nodes (void)): created from verify_symtab
   (static bool used_from_object_file_p_worker (symtab_node *node)): created from
     symtab_used_from_object_file_p
   (void dump_base (FILE *)): created from dump_symtab_base
   (bool DEBUG_FUNCTION verify_base (void)): created from verify_symtab_base
   (void unregister (void)): created from symtab_unregister_node
   (struct symbol_priority_map *priority_info (void)): created from symtab_priority_info
   (static bool set_implicit_section (symtab_node *n, void *)): created from set_implicit_section
   (static bool noninterposable_alias (symtab_node *node, void *data)): created from
     symtab_nonoverwritable_alias_1
   * cgraph.h (cgraph_node):
   (bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL)):
     created from cgraph_remove_node_and_inline_clones
   (void record_stmt_references (gimple stmt)): created from ipa_record_stmt_references
   (void set_call_stmt_including_clones (gimple old_stmt, gimple new_stmt,
     bool update_speculative = true)): created from cgraph_set_call_stmt_including_clones
   (cgraph_node *function_symbol (enum availability *avail = NULL)):
     created from cgraph_function_node
   (cgraph_node *create_clone (tree decl, gcov_type count, int freq, bool update_original,
     vec<cgraph_edge *> redirect_callers, bool call_duplication_hook,
     struct cgraph_node *new_inlined_to, bitmap args_to_skip)):
     created from cgraph_create_clone
   (cgraph_node *create_virtual_clone (vec<cgraph_edge *> redirect_callers,
     vec<ipa_replace_map *, va_gc> *tree_map, bitmap args_to_skip, const char * suffix)):
     created from cgraph_create_virtual_clone
   (cgraph_node *find_replacement (void)): created from cgraph_find_replacement_node
   (cgraph_node *create_version_clone (tree new_decl, vec<cgraph_edge *> redirect_callers,
     bitmap bbs_to_copy)): created from cgraph_copy_node_for_versioning
   (cgraph_node *create_version_clone_with_body (vec<cgraph_edge *> redirect_callers,
     vec<ipa_replace_map *, va_gc> *tree_map, bitmap args_to_skip, bool skip_return,
     bitmap bbs_to_copy, basic_block new_entry_block, const char *clone_name)):
     created from cgraph_function_version_info
   (struct cgraph_function_version_info *insert_new_function_version (void)):
     created from insert_new_cgraph_node_version
   (struct cgraph_function_version_info *function_version (void)): created from
     get_cgraph_node_version
   (void analyze (void)): created from analyze_function
   (cgraph_node * create_thunk (tree alias, tree, bool this_adjusting,
     HOST_WIDE_INT fixed_offset, HOST_WIDE_INT virtual_value, tree virtual_offset,
     tree real_alias) cgraph_add_thunk
   (inline cgraph_node *get_alias_target (void)): created from cgraph_alias_target
   (cgraph_node *ultimate_alias_target (availability *availability = NULL)):
     created from cgraph_function_or_thunk_node
   (bool expand_thunk (bool output_asm_thunks, bool force_gimple_thunk)):
     created from expand_thunk
   (void reset (void)): created from cgraph_reset_node
   (void create_wrapper (cgraph_node *target)): created from cgraph_make_wrapper
   (void DEBUG_FUNCTION verify_node (void)): created from verify_cgraph_node
   (void remove (void)): created from cgraph_remove_node
   (void dump (FILE *f)): created from dump_cgraph_node
   (void DEBUG_FUNCTION debug (void)): created from debug_cgraph_node
   (bool get_body (void)): created from cgraph_get_body
   (void release_body (void)): created from cgraph_release_function_body
   (void unnest (void)): created from cgraph_unnest_node
   (void make_local (void)): created from cgraph_make_node_local
   (void mark_address_taken (void)): created from cgraph_mark_address_taken_node
   (struct cgraph_edge *create_edge (cgraph_node *callee, gimple call_stmt,
     gcov_type count, int freq)): created from cgraph_create_edge
   (struct cgraph_edge *create_indirect_edge (gimple call_stmt, int ecf_flags,
     gcov_type count, int freq)): created from cgraph_create_indirect_edge
   (void create_edge_including_clones (struct cgraph_node *callee, gimple old_stmt,
     gimple stmt, gcov_type count, int freq, cgraph_inline_failed_t reason)):
     created from cgraph_create_edge_including_clones
   (cgraph_edge *get_edge (gimple call_stmt)): created from cgraph_edge
   (vec<cgraph_edge *> collect_callers (void)): created from collect_callers_of_node
   (void remove_callers (void)): created from cgraph_node_remove_callers
   (void remove_callees (void)): created from cgraph_node_remove_callees
   (enum availability get_availability (void)): created from cgraph_function_body_availability
   (void set_nothrow_flag (bool nothrow)): created from cgraph_set_nothrow_flag
   (void set_const_flag (bool readonly, bool looping)): created from cgraph_set_const_flag
   (void set_pure_flag (bool pure, bool looping)): created from cgraph_set_pure_flag
   (void call_duplication_hooks (cgraph_node *node2)): created from
     cgraph_call_node_duplication_hooks
   (bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *, void *),
     void *data, bool include_overwritable)): created from cgraph_for_node_and_aliases
   (bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node, void *data),
     void *data, bool include_overwritable)): created from cgraph_for_node_thunks_and_aliases
   (void call_function_insertion_hooks (void)):
     created from cgraph_call_function_insertion_hooks
   (inline void mark_force_output (void)): created from cgraph_mark_force_output_node
   (bool local_p (void)): created from cgraph_local_node
   (bool can_be_local_p (void)): created from cgraph_node_can_be_local_p
   (bool cannot_return_p (void)): created from cgraph_node_cannot_return
   (bool only_called_directly_p (void)): created from cgraph_only_called_directly_p
   (inline bool only_called_directly_or_aliased_p (void)):
     created from cgraph_only_called_directly_or_aliased_p
   (bool will_be_removed_from_program_if_no_direct_calls_p (void)):
     created from cgraph_will_be_removed_from_program_if_no_direct_calls
   (bool can_remove_if_no_direct_calls_and_refs_p (void)):
     created from cgraph_can_remove_if_no_direct_calls_and_refs_p
   (bool can_remove_if_no_direct_calls_p (void)):
     created from cgraph_can_remove_if_no_direct_calls_p
   (inline bool has_gimple_body_p (void)):
     created from cgraph_function_with_gimple_body_p
   (bool optimize_for_size_p (void)): created from cgraph_optimize_for_size_p
   (static void dump_cgraph (FILE *f)): created from dump_cgraph
   (static inline void debug_cgraph (void)): created from debug_cgraph
   (static void record_function_versions (tree decl1, tree decl2)):
     created from record_function_versions
   (static void delete_function_version (tree decl)):
     created from delete_function_version
   (static void add_new_function (tree fndecl, bool lowered)):
     created from cgraph_add_new_function
   (static inline cgraph_node *get (const_tree decl)): created from cgraph_get_node
   (static cgraph_node * create (tree decl)): created from cgraph_create_node
   (static cgraph_node * create_empty (void)): created from cgraph_create_empty_node
   (static cgraph_node * get_create (tree)): created from cgraph_get_create_node
   (static cgraph_node *get_for_asmname (tree asmname)):
     created from cgraph_node_for_asm
   (static cgraph_node * create_same_body_alias (tree alias, tree decl)):
     created from cgraph_same_body_alias
   (static bool used_from_object_file_p_worker (cgraph_node *node,
     void *): new function
   (static bool non_local_p (cgraph_node *node, void *)):
     created from cgraph_non_local_node_p_1
   (static void DEBUG_FUNCTION verify_cgraph_nodes (void)):
     created from verify_cgraph
   (static bool make_local (cgraph_node *node, void *)):
     created from cgraph_make_node_local
   (static cgraph_node *create_alias (tree alias, tree target)):
     created from cgraph_create_function_alias
   (static cgraph_edge * create_edge (cgraph_node *caller, cgraph_node *callee,
     gimple call_stmt, gcov_type count, int freq, bool indir_unknown_callee)):
     created from cgraph_create_edge_1
   * cgraph.h (varpool_node):
   (void remove (void)): created from varpool_remove_node
   (void dump (FILE *f)): created from dump_varpool_node


Ready for trunk?
Martin
>>> Thanks,
>>> Martin
>>>> +
>>>> +  /* Try to find a call graph node for declaration DECL and if it does not
>>>> +     exist or if it corresponds to an inline clone, create a new one.  */
>>>> +  static cgraph_node * get_create (tree);
>>>>
>>>> Also to begginig, next to get and create.
>>>> +
>>>> +  /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
>>>> +     Return NULL if there's no such node.  */
>>>> +  static cgraph_node *get_for_asmname (tree asmname);
>>>>
>>>> Likewise
>>>> +
>>>> +  /* Attempt to mark ALIAS as an alias to DECL.  Return alias node if
>>>> +     successful and NULL otherwise.
>>>> +     Same body aliases are output whenever the body of DECL is output,
>>>> +     and cgraph_node::get (ALIAS) transparently
>>>> +     returns cgraph_node::get (DECL).  */
>>>> +  static cgraph_node * create_same_body_alias (tree alias, tree decl);
>>>>
>>>> To alias API
>>>> +
>>>> +  /* Worker for cgraph_can_remove_if_no_direct_calls_p.  */
>>>> +  static bool used_from_object_file_p_worker (cgraph_node *node,
>>>> +                          void *data ATTRIBUTE_UNUSED)
>>>> +  {
>>>> +    return node->used_from_object_file_p ();
>>>> +  }
>>>> +
>>>> +  /* Return true when cgraph_node can not be local.
>>>> +     Worker for cgraph_local_node_p.  */
>>>> cgraph_local_node_p was probably renamed, but we should sanify predicates here.
>>>> Please group all functions dealing with local functions togehter, too.
>>>> +  static bool non_local_p (cgraph_node *node, void *data ATTRIBUTE_UNUSED);
>>>> +
>>>> +  /* Verify whole cgraph structure.  */
>>>> +  static void DEBUG_FUNCTION verify_cgraph_nodes (void);
>>>> +
>>>> +  /* Worker to bring NODE local.  */
>>>> +  static bool make_local (cgraph_node *node, void *data ATTRIBUTE_UNUSED);
>>>> +
>>>> +  /* Mark ALIAS as an alias to DECL.  DECL_NODE is cgraph node representing
>>>> +     the function body is associated
>>>> +     with (not necessarily cgraph_node (DECL).  */
>>>> +  static cgraph_node *create_alias (tree alias, tree target);
>>>> +
>>>> +  static cgraph_edge * create_edge (cgraph_node *caller, cgraph_node *callee,
>>>> +                    gimple call_stmt, gcov_type count,
>>>> +                    int freq,
>>>> +                    bool indir_unknown_callee);
>>>>
>>>> Also edges and aliases should be grouped.
>>>>
>>>> With these changes patch looks good. Probably we will need one additional cleanup pass, but it would be better
>>>> to do it incrementally.  Please write changelog that carefuly records what was renamed to what.
>>>>
>>>> Honza
>


[-- Attachment #2: ipa-ref-symtab-node4.patch.bz2 --]
[-- Type: application/x-bzip, Size: 73716 bytes --]