1/* Tree inlining hooks and declarations. 2 Copyright (C) 2001-2015 Free Software Foundation, Inc. 3 Contributed by Alexandre Oliva <aoliva@redhat.com> 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 3, or (at your option) 10any later version. 11 12GCC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING3. If not see 19<http://www.gnu.org/licenses/>. */ 20 21#ifndef GCC_TREE_INLINE_H 22#define GCC_TREE_INLINE_H 23 24#include "hash-map.h" 25#include "hash-set.h" 26 27struct cgraph_edge; 28 29/* Indicate the desired behavior wrt call graph edges. We can either 30 duplicate the edge (inlining, cloning), move the edge (versioning, 31 parallelization), or move the edges of the clones (saving). */ 32 33enum copy_body_cge_which 34{ 35 CB_CGE_DUPLICATE, 36 CB_CGE_MOVE, 37 CB_CGE_MOVE_CLONES 38}; 39 40struct dependence_hasher : default_hashmap_traits 41{ 42 template<typename T> 43 static void 44 mark_deleted (T &e) 45 { gcc_unreachable (); } 46 47 template<typename T> 48 static void 49 mark_empty (T &e) 50 { e.m_key = 0; } 51 52 template<typename T> 53 static bool 54 is_deleted (T &) 55 { return false; } 56 57 template<typename T> static bool is_empty (T &e) { return e.m_key == 0; } 58}; 59 60/* Data required for function body duplication. */ 61 62struct copy_body_data 63{ 64 /* FUNCTION_DECL for function being inlined, or in general the 65 source function providing the original trees. */ 66 tree src_fn; 67 68 /* FUNCTION_DECL for function being inlined into, or in general 69 the destination function receiving the new trees. */ 70 tree dst_fn; 71 72 /* Callgraph node of the source function. */ 73 struct cgraph_node *src_node; 74 75 /* Callgraph node of the destination function. */ 76 struct cgraph_node *dst_node; 77 78 /* struct function for function being inlined. Usually this is the same 79 as DECL_STRUCT_FUNCTION (src_fn), but can be different if saved_cfg 80 and saved_eh are in use. */ 81 struct function *src_cfun; 82 83 /* The VAR_DECL for the return value. */ 84 tree retvar; 85 86 /* The VAR_DECL for the return bounds. */ 87 tree retbnd; 88 89 /* Assign statements that need bounds copy. */ 90 vec<gimple> assign_stmts; 91 92 /* The map from local declarations in the inlined function to 93 equivalents in the function into which it is being inlined. */ 94 hash_map<tree, tree> *decl_map; 95 96 /* Create a new decl to replace DECL in the destination function. */ 97 tree (*copy_decl) (tree, struct copy_body_data *); 98 99 /* Current BLOCK. */ 100 tree block; 101 102 /* GIMPLE_CALL if va arg parameter packs should be expanded or NULL 103 is not. */ 104 gimple call_stmt; 105 106 /* Exception landing pad the inlined call lies in. */ 107 int eh_lp_nr; 108 109 /* Maps region and landing pad structures from the function being copied 110 to duplicates created within the function we inline into. */ 111 hash_map<void *, void *> *eh_map; 112 113 /* We use the same mechanism do all sorts of different things. Rather 114 than enumerating the different cases, we categorize the behavior 115 in the various situations. */ 116 117 /* What to do with call graph edges. */ 118 enum copy_body_cge_which transform_call_graph_edges; 119 120 /* True if a new CFG should be created. False for inlining, true for 121 everything else. */ 122 bool transform_new_cfg; 123 124 /* True if RETURN_EXPRs should be transformed to just the contained 125 MODIFY_EXPR. The branch semantics of the return will be handled 126 by manipulating the CFG rather than a statement. */ 127 bool transform_return_to_modify; 128 129 /* True if the parameters of the source function are transformed. 130 Only true for inlining. */ 131 bool transform_parameter; 132 133 /* True if this statement will need to be regimplified. */ 134 bool regimplify; 135 136 /* True if trees should not be unshared. */ 137 bool do_not_unshare; 138 139 /* > 0 if we are remapping a type currently. */ 140 int remapping_type_depth; 141 142 /* A function to be called when duplicating BLOCK nodes. */ 143 void (*transform_lang_insert_block) (tree); 144 145 /* Statements that might be possibly folded. */ 146 hash_set<gimple> *statements_to_fold; 147 148 /* Entry basic block to currently copied body. */ 149 basic_block entry_bb; 150 151 /* For partial function versioning, bitmap of bbs to be copied, 152 otherwise NULL. */ 153 bitmap blocks_to_copy; 154 155 /* Debug statements that need processing. */ 156 vec<gdebug *> debug_stmts; 157 158 /* A map from local declarations in the inlined function to 159 equivalents in the function into which it is being inlined, where 160 the originals have been mapped to a value rather than to a 161 variable. */ 162 hash_map<tree, tree> *debug_map; 163 164 /* Cilk keywords currently need to replace some variables that 165 ordinary nested functions do not. */ 166 bool remap_var_for_cilk; 167 168 /* A map from the inlined functions dependence info cliques to 169 equivalents in the function into which it is being inlined. */ 170 hash_map<unsigned short, unsigned short, dependence_hasher> *dependence_map; 171}; 172 173/* Weights of constructions for estimate_num_insns. */ 174 175typedef struct eni_weights_d 176{ 177 /* Cost per call. */ 178 unsigned call_cost; 179 180 /* Cost per indirect call. */ 181 unsigned indirect_call_cost; 182 183 /* Cost per call to a target specific builtin */ 184 unsigned target_builtin_call_cost; 185 186 /* Cost of "expensive" div and mod operations. */ 187 unsigned div_mod_cost; 188 189 /* Cost for omp construct. */ 190 unsigned omp_cost; 191 192 /* Cost for tm transaction. */ 193 unsigned tm_cost; 194 195 /* Cost of return. */ 196 unsigned return_cost; 197 198 /* True when time of statement should be estimated. Thus, the 199 cost of a switch statement is logarithmic rather than linear in number 200 of cases. */ 201 bool time_based; 202} eni_weights; 203 204/* Weights that estimate_num_insns uses for heuristics in inlining. */ 205 206extern eni_weights eni_inlining_weights; 207 208/* Weights that estimate_num_insns uses to estimate the size of the 209 produced code. */ 210 211extern eni_weights eni_size_weights; 212 213/* Weights that estimate_num_insns uses to estimate the time necessary 214 to execute the produced code. */ 215 216extern eni_weights eni_time_weights; 217 218/* Function prototypes. */ 219void init_inline_once (void); 220extern tree copy_tree_body_r (tree *, int *, void *); 221extern void insert_decl_map (copy_body_data *, tree, tree); 222unsigned int optimize_inline_calls (tree); 223tree maybe_inline_call_in_expr (tree); 224bool tree_inlinable_function_p (tree); 225tree copy_tree_r (tree *, int *, void *); 226tree copy_decl_no_change (tree decl, copy_body_data *id); 227int estimate_move_cost (tree type, bool); 228int estimate_num_insns (gimple, eni_weights *); 229int estimate_num_insns_fn (tree, eni_weights *); 230int count_insns_seq (gimple_seq, eni_weights *); 231bool tree_versionable_function_p (tree); 232extern tree remap_decl (tree decl, copy_body_data *id); 233extern tree remap_type (tree type, copy_body_data *id); 234extern gimple_seq copy_gimple_seq_and_replace_locals (gimple_seq seq); 235extern bool debug_find_tree (tree, tree); 236extern tree copy_fn (tree, tree&, tree&); 237extern const char *copy_forbidden (struct function *fun, tree fndecl); 238 239/* This is in tree-inline.c since the routine uses 240 data structures from the inliner. */ 241extern tree build_duplicate_type (tree); 242 243#endif /* GCC_TREE_INLINE_H */ 244