X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gcc%2Fcgraph.h;h=1c952eb509466f1bdd3ed97a7292743d8d9ff119;hb=6566b0fb86addb5c28d3ff8b2631f7f9516d4054;hp=72f9702f851bde427c4e06b3d6f298142f962e87;hpb=464d01188e46ccdb19b4783c5d28ef6bc72d32f9;p=gcc.git diff --git a/gcc/cgraph.h b/gcc/cgraph.h index 72f9702f851..1c952eb5094 100644 --- a/gcc/cgraph.h +++ b/gcc/cgraph.h @@ -21,6 +21,7 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_CGRAPH_H #define GCC_CGRAPH_H +#include "profile-count.h" #include "ipa-ref.h" #include "plugin-api.h" @@ -628,17 +629,48 @@ 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. */ +/* Sub-structure of cgraph_node. Holds information about thunk, used only for + same body aliases. + + Thunks are basically wrappers around methods which are introduced in case + of multiple inheritance in order to adjust the value of the "this" pointer + or of the returned value. + + In the case of this-adjusting thunks, each back-end can override the + can_output_mi_thunk/output_mi_thunk target hooks to generate a minimal thunk + (with a tail call for instance) directly as assembly. For the default hook + or for the case where the can_output_mi_thunk hooks return false, the thunk + is gimplified and lowered using the regular machinery. */ struct GTY(()) cgraph_thunk_info { - /* Information about the thunk. */ + /* Offset used to adjust "this". */ HOST_WIDE_INT fixed_offset; + + /* Offset in the virtual table to get the offset to adjust "this". Valid iff + VIRTUAL_OFFSET_P is true. */ HOST_WIDE_INT virtual_value; + + /* Thunk target, i.e. the method that this thunk wraps. Depending on the + TARGET_USE_LOCAL_THUNK_ALIAS_P macro, this may have to be a new alias. */ tree alias; + + /* Nonzero for a "this" adjusting thunk and zero for a result adjusting + thunk. */ bool this_adjusting; + + /* If true, this thunk is what we call a virtual thunk. In this case: + * for this-adjusting thunks, after the FIXED_OFFSET based adjustment is + done, add to the result the offset found in the vtable at: + vptr + VIRTUAL_VALUE + * for result-adjusting thunks, the FIXED_OFFSET adjustment is done after + the virtual one. */ bool virtual_offset_p; + + /* ??? True for special kind of thunks, seems related to instrumentation. */ bool add_pointer_bounds_args; - /* Set to true when alias node is thunk. */ + + /* Set to true when alias node (the cgraph_node to which this struct belong) + is a thunk. Access to any other fields is invalid if this is false. */ bool thunk_p; }; @@ -910,7 +942,7 @@ public: All hooks will see this in node's global.inlined_to, when invoked. Can be NULL if the node is not inlined. SUFFIX is string that is appended to the original name. */ - cgraph_node *create_clone (tree decl, gcov_type count, int freq, + cgraph_node *create_clone (tree decl, profile_count count, bool update_original, vec redirect_callers, bool call_duplication_hook, @@ -982,7 +1014,7 @@ public: /* 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. */ + See comments in struct cgraph_thunk_info 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, @@ -1078,14 +1110,13 @@ public: /* Create edge from a given function to CALLEE in the cgraph. */ cgraph_edge *create_edge (cgraph_node *callee, - gcall *call_stmt, gcov_type count, - int freq); + gcall *call_stmt, profile_count count); /* 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. */ cgraph_edge *create_indirect_edge (gcall *call_stmt, int ecf_flags, - gcov_type count, int freq, + profile_count count, bool compute_indirect_info = true); /* Like cgraph_create_edge walk the clone tree and update all clones sharing @@ -1093,8 +1124,7 @@ public: update the edge same way as cgraph_set_call_stmt_including_clones does. */ void create_edge_including_clones (cgraph_node *callee, gimple *old_stmt, gcall *stmt, - gcov_type count, - int freq, + profile_count count, cgraph_inline_failed_t reason); /* Return the callgraph edge representing the GIMPLE_CALL statement @@ -1119,6 +1149,10 @@ public: if any to NOTHROW. */ bool set_nothrow_flag (bool nothrow); + /* SET DECL_IS_MALLOC on cgraph_node's decl and on aliases of the node + if any. */ + bool set_malloc_flag (bool malloc_p); + /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST. If SET_CONST if false, clear the flag. @@ -1240,7 +1274,7 @@ public: /* Remove the cgraph_function_version_info and cgraph_node for DECL. This DECL is a duplicate declaration. */ - static void delete_function_version (tree decl); + static void delete_function_version_by_decl (tree decl); /* Add the function FNDECL to the call graph. Unlike finalize_function, this function is intended to be used @@ -1356,7 +1390,7 @@ public: cgraph_thunk_info thunk; /* Expected number of executions: calculated in profile.c. */ - gcov_type count; + profile_count count; /* How to scale counts at materialization time; used to merge LTO units with different number of profile runs. */ int count_materialization_scale; @@ -1629,8 +1663,7 @@ struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"), /* Turn edge into speculative call calling N2. Update the profile so the direct call is taken COUNT times with FREQUENCY. */ - cgraph_edge *make_speculative (cgraph_node *n2, gcov_type direct_count, - int direct_frequency); + cgraph_edge *make_speculative (cgraph_node *n2, profile_count direct_count); /* Given speculative call edge, return all three components. */ void speculative_call_info (cgraph_edge *&direct, cgraph_edge *&indirect, @@ -1648,10 +1681,11 @@ struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"), /* Create clone of edge in the node N represented by CALL_EXPR the callgraph. */ cgraph_edge * clone (cgraph_node *n, gcall *call_stmt, unsigned stmt_uid, - gcov_type count_scale, int freq_scale, bool update_original); + profile_count num, profile_count den, + bool update_original); /* Verify edge count and frequency. */ - bool verify_count_and_frequency (); + bool verify_count (); /* Return true when call of edge can not lead to return from caller and thus it is safe to ignore its side effects for IPA analysis @@ -1673,7 +1707,7 @@ struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"), static void rebuild_references (void); /* Expected number of executions: calculated in profile.c. */ - gcov_type count; + profile_count count; cgraph_node *caller; cgraph_node *callee; cgraph_edge *prev_caller; @@ -1691,10 +1725,6 @@ struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"), /* 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. */ @@ -1732,6 +1762,13 @@ struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"), /* Return true if call must bind to current definition. */ bool binds_to_current_def_p (); + /* 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 (); + + /* Expected frequency of executions within the function. */ + sreal sreal_frequency (); private: /* Remove the edge from the list of the callers of the callee. */ void remove_caller (void); @@ -2250,7 +2287,7 @@ private: parameters of which only CALLEE can be NULL (when creating an indirect call edge). */ cgraph_edge *create_edge (cgraph_node *caller, cgraph_node *callee, - gcall *call_stmt, gcov_type count, int freq, + gcall *call_stmt, profile_count count, bool indir_unknown_callee); /* Put the edge onto the free list. */ @@ -2321,7 +2358,7 @@ void cgraphunit_c_finalize (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, gcov_type); +basic_block init_lowered_empty_function (tree, bool, profile_count); tree thunk_adjust (gimple_stmt_iterator *, tree, bool, HOST_WIDE_INT, tree); /* In cgraphclones.c */ @@ -3074,6 +3111,19 @@ cgraph_edge::binds_to_current_def_p () return false; } +/* 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. */ + +inline int +cgraph_edge::frequency () +{ + return count.to_cgraph_frequency (caller->global.inlined_to + ? caller->global.inlined_to->count + : caller->count); +} + + /* Return true if the TM_CLONE bit is set for a given FNDECL. */ static inline bool decl_is_tm_clone (const_tree fndecl)