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