CbC/CbC_gcc: gcc/cgraph.h comparison

comparison gcc/cgraph.h @ 67:f6334be47118

update gcc from gcc-4.6-20100522 to gcc-4.6-20110318

author	nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Tue, 22 Mar 2011 17:18:12 +0900
parents	b7f97abdc517
children	04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 /* Callgraph handling code.
-Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
 Free Software Foundation, Inc.
 Contributed by Jan Hubicka
 This file is part of GCC.
 <http://www.gnu.org/licenses/>.  */
 #ifndef GCC_CGRAPH_H
 #define GCC_CGRAPH_H
+#include "plugin-api.h"
 #include "vec.h"
 #include "tree.h"
 #include "basic-block.h"
 #include "function.h"
 #include "ipa-ref.h"	/* FIXME: inappropriate dependency of cgraph on IPA.  */
 /* 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[];
 /* Function inlining information.  */
 struct GTY(()) inline_summary
 {
 and its address is never taken.  */
 unsigned local : 1;
 /* Set when function is visible by other units.  */
 unsigned externally_visible : 1;
 /* Set once it has been finalized so we consider it to be output.  */
 unsigned finalized : 1;
 /* False when there something makes inlining impossible (such as va_arg).  */
 unsigned inlinable : 1;
 /* False when there something makes versioning impossible.
 Currently computed and used only by ipa-cp.  */
 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 function should be inlined independently on its size.  */
 unsigned disregard_inline_limits : 1;
 /* True when the function has been originally extern inline, but it is
 struct GTY(()) cgraph_clone_info
 {
 VEC(ipa_replace_map_p,gc)* tree_map;
 bitmap args_to_skip;
 bitmap combined_args_to_skip;
-};
-enum node_frequency {
-/* This function most likely won't be executed at all.
-(set only when profile feedback is available or via function attribute). */
-NODE_FREQUENCY_UNLIKELY_EXECUTED,
-/* For functions that are known to be executed once (i.e. constructors, destructors
-and main function.  */
-NODE_FREQUENCY_EXECUTED_ONCE,
-/* The default value.  */
-NODE_FREQUENCY_NORMAL,
-/* Optimize this function hard
-(set only when profile feedback is available or via function attribute). */
-NODE_FREQUENCY_HOT
 };
 /* The cgraph data structure.
 Each function decl has assigned cgraph_node listing callees and callers.  */
 /* Circular list of nodes in the same comdat group if non-NULL.  */
 struct cgraph_node *same_comdat_group;
 /* 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;
 PTR GTY ((skip)) aux;
 /* Interprocedural passes scheduled to have their transform functions
 applied next time we execute local pass on them.  We maintain it
 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;
 /* Ordering of all cgraph nodes.  */
 int order;
 /* unique id for profiling. pid is not suitable because of different
 number of cfg nodes with -fprofile-generate and -fprofile-use */
 int pid;
+enum ld_plugin_symbol_resolution resolution;
 /* Set when function must be output for some reason.  The primary
 use of this flag is to mark functions needed to be output for
 non-standard reason.  Functions that are externally visible
 or reachable from functions needed to be output are marked
 /* 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 analyzed : 1;
-/* Set when function is available in the other LTRANS partition.  */
+/* 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;
 /* Set when function is scheduled to be processed by local passes.  */
 unsigned process : 1;
 /* Set for aliases once they got through assemble_alias.  */
 unsigned alias : 1;
 of and they are linked through the next/previous pointers.  */
 unsigned same_body_alias : 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;
 };
 typedef struct cgraph_node *cgraph_node_ptr;
 DEF_VEC_P(cgraph_node_ptr);
 can appear in multiple sets.  */
 struct GTY(()) cgraph_node_set_def
 {
 htab_t GTY((param_is (struct cgraph_node_set_element_def))) hashtab;
 VEC(cgraph_node_ptr, gc) *nodes;
-PTR GTY ((skip)) aux;
 };
 typedef struct varpool_node *varpool_node_ptr;
 DEF_VEC_P(varpool_node_ptr);
 can appear in multiple sets.  */
 struct GTY(()) varpool_node_set_def
 {
 htab_t GTY((param_is (struct varpool_node_set_element_def))) hashtab;
 VEC(varpool_node_ptr, gc) *nodes;
-PTR GTY ((skip)) aux;
 };
 typedef struct cgraph_node_set_def *cgraph_node_set;
 DEF_VEC_P(cgraph_node_set);
 /* Offset accumulated from ancestor jump functions of inlined call graph
 edges.  */
 HOST_WIDE_INT anc_offset;
 /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set).  */
 HOST_WIDE_INT otr_token;
+/* Delta by which must be added to this parameter to compensate for a skipped
+this adjusting thunk.  */
+HOST_WIDE_INT thunk_delta;
 /* Type of the object from OBJ_TYPE_REF_OBJECT. */
 tree otr_type;
 /* Index of the parameter that is called.  */
 int param_index;
 /* ECF flags determined from the caller.  */
 nodes a pointer to the normal node.  */
 struct varpool_node *extra_name;
 /* Circular list of nodes in the same comdat group if non-NULL.  */
 struct varpool_node *same_comdat_group;
 struct ipa_ref_list ref_list;
+/* File stream where this node is being written to.  */
+struct lto_file_decl_data * lto_file_data;
 PTR GTY ((skip)) aux;
 /* Ordering of all cgraph nodes.  */
 int order;
+enum ld_plugin_symbol_resolution resolution;
 /* Set when function must be output - it is externally visible
 or its address is taken.  */
 unsigned needed : 1;
 /* Needed variables might become dead by optimization.  This flag
 /* Set for aliases once they got through assemble_alias.  Also set for
 extra name aliases in varpool_extra_name_alias.  */
 unsigned alias : 1;
 /* Set when variable is used from other LTRANS partition.  */
 unsigned used_from_other_partition : 1;
-/* Set when variable is available in the other LTRANS partition.  */
+/* Set when variable 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;
 };
 /* Every top level asm statement is put into a cgraph_asm_node.  */
 void cgraph_release_function_body (struct cgraph_node *);
 void cgraph_node_remove_callees (struct cgraph_node *node);
 struct cgraph_edge *cgraph_create_edge (struct cgraph_node *,
 					struct cgraph_node *,
 					gimple, gcov_type, int, int);
-struct cgraph_edge *cgraph_create_indirect_edge (struct cgraph_node *, gimple, int,
+struct cgraph_edge *cgraph_create_indirect_edge (struct cgraph_node *, gimple,
-						 gcov_type, int, int);
+						 int, gcov_type, int, int);
-struct cgraph_node * cgraph_get_node (tree);
+struct cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void);
-struct cgraph_node *cgraph_node (tree);
+struct cgraph_node * cgraph_get_node (const_tree);
-bool cgraph_same_body_alias (tree, tree);
+struct cgraph_node * cgraph_get_node_or_alias (const_tree);
-void cgraph_add_thunk (tree, tree, bool, HOST_WIDE_INT, HOST_WIDE_INT, tree, tree);
+struct cgraph_node * cgraph_node (tree);
+struct cgraph_node * cgraph_same_body_alias (struct cgraph_node *, tree, tree);
+struct cgraph_node * cgraph_add_thunk (struct cgraph_node *, tree, tree, bool, HOST_WIDE_INT,
+				       HOST_WIDE_INT, tree, tree);
 void cgraph_remove_same_body_alias (struct cgraph_node *);
 struct cgraph_node *cgraph_node_for_asm (tree);
 struct cgraph_edge *cgraph_edge (struct cgraph_node *, gimple);
 void cgraph_set_call_stmt (struct cgraph_edge *, gimple);
 void cgraph_set_call_stmt_including_clones (struct cgraph_node *, gimple, gimple);
 					unsigned, gcov_type, int, int, bool);
 struct cgraph_node * cgraph_clone_node (struct cgraph_node *, tree, gcov_type, int,
 					int, bool, VEC(cgraph_edge_p,heap) *);
 void cgraph_redirect_edge_callee (struct cgraph_edge *, struct cgraph_node *);
-void cgraph_make_edge_direct (struct cgraph_edge *, struct cgraph_node *);
+void cgraph_make_edge_direct (struct cgraph_edge *, struct cgraph_node *,
+			      HOST_WIDE_INT);
 struct cgraph_asm_node *cgraph_add_asm_node (tree);
 bool cgraph_function_possibly_inlined_p (tree);
 void cgraph_unnest_node (struct cgraph_node *);
 void cgraph_add_new_function (tree, bool);
 const char* cgraph_inline_failed_string (cgraph_inline_failed_t);
 struct cgraph_node * cgraph_create_virtual_clone (struct cgraph_node *old_node,
 			                          VEC(cgraph_edge_p,heap)*,
 			                          VEC(ipa_replace_map_p,gc)* tree_map,
-			                          bitmap args_to_skip);
+			                          bitmap args_to_skip,
+						  const char *clone_name);
 void cgraph_set_nothrow_flag (struct cgraph_node *, bool);
-void cgraph_set_readonly_flag (struct cgraph_node *, bool);
+void cgraph_set_const_flag (struct cgraph_node *, bool, bool);
-void cgraph_set_pure_flag (struct cgraph_node *, bool);
+void cgraph_set_pure_flag (struct cgraph_node *, bool, bool);
-void cgraph_set_looping_const_or_pure_flag (struct cgraph_node *, bool);
+tree clone_function_name (tree decl, const char *);
+bool cgraph_node_cannot_return (struct cgraph_node *);
+bool cgraph_edge_cannot_lead_to_return (struct cgraph_edge *);
+bool cgraph_will_be_removed_from_program_if_no_direct_calls
+(struct cgraph_node *node);
+bool cgraph_can_remove_if_no_direct_calls_and_refs_p
+(struct cgraph_node *node);
+bool resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution);
+bool cgraph_used_from_object_file_p (struct cgraph_node *node);
+bool varpool_used_from_object_file_p (struct varpool_node *node);
 /* In cgraphunit.c  */
+extern FILE *cgraph_dump_file;
 void cgraph_finalize_function (tree, bool);
 void cgraph_mark_if_needed (tree);
 void cgraph_finalize_compilation_unit (void);
 void cgraph_optimize (void);
 void cgraph_mark_needed_node (struct cgraph_node *);
 void cgraph_reset_static_var_maps (void);
 void init_cgraph (void);
 struct cgraph_node *cgraph_function_versioning (struct cgraph_node *,
 						VEC(cgraph_edge_p,heap)*,
 						VEC(ipa_replace_map_p,gc)*,
-						bitmap);
+						bitmap, bitmap, basic_block,
-void tree_function_versioning (tree, tree, VEC (ipa_replace_map_p,gc)*, bool, bitmap);
+						const char *);
+void tree_function_versioning (tree, tree, VEC (ipa_replace_map_p,gc)*, bool, bitmap,
+			       bitmap, basic_block);
 struct cgraph_node *save_inline_function_body (struct cgraph_node *);
 void record_references_in_initializer (tree, bool);
 bool cgraph_process_new_functions (void);
 bool cgraph_decide_is_function_needed (struct cgraph_node *, tree);
 void varpool_node_set_add (varpool_node_set, struct varpool_node *);
 void varpool_node_set_remove (varpool_node_set, struct varpool_node *);
 void dump_varpool_node_set (FILE *, varpool_node_set);
 void debug_varpool_node_set (varpool_node_set);
 void ipa_discover_readonly_nonaddressable_vars (void);
+bool cgraph_comdat_can_be_unshared_p (struct cgraph_node *);
 /* In predict.c  */
 bool cgraph_maybe_hot_edge_p (struct cgraph_edge *e);
 /* In varpool.c  */
 void cgraph_make_decl_local (tree);
 void cgraph_make_node_local (struct cgraph_node *);
 bool cgraph_node_can_be_local_p (struct cgraph_node *);
-struct varpool_node * varpool_get_node (tree decl);
+struct varpool_node * varpool_get_node (const_tree decl);
 void varpool_remove_node (struct varpool_node *node);
+void varpool_finalize_named_section_flags (struct varpool_node *node);
 bool varpool_assemble_pending_decls (void);
 bool varpool_assemble_decl (struct varpool_node *node);
 bool varpool_analyze_pending_decls (void);
 void varpool_remove_unreferenced_decls (void);
 void varpool_empty_needed_queue (void);
-bool varpool_extra_name_alias (tree, tree);
+struct varpool_node * varpool_extra_name_alias (tree, tree);
 const char * varpool_node_name (struct varpool_node *node);
 void varpool_reset_queue (void);
+bool const_value_known_p (tree);
 /* Walk all reachable static variables.  */
 #define FOR_EACH_STATIC_VARIABLE(node) \
 for ((node) = varpool_nodes_queue; (node); (node) = (node)->next_needed)
 varpool_first_static_initializer (void)
 {
 struct varpool_node *node;
 for (node = varpool_nodes_queue; node; node = node->next_needed)
 {
-gcc_assert (TREE_CODE (node->decl) == VAR_DECL);
+gcc_checking_assert (TREE_CODE (node->decl) == VAR_DECL);
 if (DECL_INITIAL (node->decl))
 	return node;
 }
 return NULL;
 }
 static inline struct varpool_node *
 varpool_next_static_initializer (struct varpool_node *node)
 {
 for (node = node->next_needed; node; node = node->next_needed)
 {
-gcc_assert (TREE_CODE (node->decl) == VAR_DECL);
+gcc_checking_assert (TREE_CODE (node->decl) == VAR_DECL);
 if (DECL_INITIAL (node->decl))
 	return node;
 }
 return NULL;
 }
 for ((node) = varpool_first_static_initializer (); (node); \
 (node) = varpool_next_static_initializer (node))
 /* In ipa-inline.c  */
 void cgraph_clone_inlined_nodes (struct cgraph_edge *, bool, bool);
-unsigned int compute_inline_parameters (struct cgraph_node *);
+void compute_inline_parameters (struct cgraph_node *);
 /* Create a new static variable of type TYPE.  */
 tree add_new_static_var (tree type);
 /* Return true if set is nonempty.  */
 static inline bool
 cgraph_node_set_nonempty_p (cgraph_node_set set)
 {
-return VEC_length (cgraph_node_ptr, set->nodes);
+return !VEC_empty (cgraph_node_ptr, set->nodes);
 }
 /* Return true if set is nonempty.  */
 static inline bool
 varpool_node_set_nonempty_p (varpool_node_set set)
 {
-return VEC_length (varpool_node_ptr, set->nodes);
+return !VEC_empty (varpool_node_ptr, set->nodes);
 }
 /* Return true when function NODE is 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.  */
 static inline bool
 cgraph_only_called_directly_p (struct cgraph_node *node)
 {
-return !node->needed && !node->address_taken && !node->local.externally_visible;
+gcc_assert (!node->global.inlined_to);
+return (!node->needed && !node->address_taken
+	  && !node->reachable_from_other_partition
+	  && !DECL_STATIC_CONSTRUCTOR (node->decl)
+	  && !DECL_STATIC_DESTRUCTOR (node->decl)
+	  && !node->local.externally_visible);
 }
 /* Return true when function NODE can be removed from callgraph
 if all direct calls are eliminated.  */
 static inline bool
-cgraph_can_remove_if_no_direct_calls_and_refs_p (struct cgraph_node *node)
+cgraph_can_remove_if_no_direct_calls_p (struct cgraph_node *node)
 {
-return (!node->needed && !node->reachable_from_other_partition
+/* Extern inlines can always go, we will use the external definition.  */
-	  && (DECL_COMDAT (node->decl) || !node->local.externally_visible));
+if (DECL_EXTERNAL (node->decl))
+return true;
+return !node->address_taken && cgraph_can_remove_if_no_direct_calls_and_refs_p (node);
 }
 /* Return true when function NODE can be removed from callgraph
 if all direct calls are eliminated.  */
 static inline bool
-cgraph_can_remove_if_no_direct_calls_p (struct cgraph_node *node)
+varpool_can_remove_if_no_refs (struct varpool_node *node)
 {
-return !node->address_taken && cgraph_can_remove_if_no_direct_calls_and_refs_p (node);
+return (!node->force_output && !node->used_from_other_partition
+	  && (flag_toplevel_reorder || DECL_COMDAT (node->decl)
+	      || DECL_ARTIFICIAL (node->decl))
+	  && (DECL_COMDAT (node->decl) || !node->externally_visible));
 }
 /* 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 sumarized in force_output flag.  */
+The magic uses are all summarized in force_output flag.  */
 static inline bool
 varpool_all_refs_explicit_p (struct varpool_node *vnode)
 {
 return (!vnode->externally_visible

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cgraph.h @ 67:f6334be47118