Mercurial > hg > CbC > CbC_gcc
comparison gcc/tree-inline.h @ 0:a06113de4d67
first commit
author | kent <kent@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 17 Jul 2009 14:47:48 +0900 |
parents | |
children | 77e2b8dfacca |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a06113de4d67 |
---|---|
1 /* Tree inlining hooks and declarations. | |
2 Copyright 2001, 2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc. | |
3 Contributed by Alexandre Oliva <aoliva@redhat.com> | |
4 | |
5 This file is part of GCC. | |
6 | |
7 GCC is free software; you can redistribute it and/or modify | |
8 it under the terms of the GNU General Public License as published by | |
9 the Free Software Foundation; either version 3, or (at your option) | |
10 any later version. | |
11 | |
12 GCC is distributed in the hope that it will be useful, | |
13 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 GNU General Public License for more details. | |
16 | |
17 You should have received a copy of the GNU General Public License | |
18 along 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 "varray.h" | |
25 #include "pointer-set.h" | |
26 | |
27 | |
28 /* Data required for function body duplication. */ | |
29 | |
30 typedef struct copy_body_data | |
31 { | |
32 /* FUNCTION_DECL for function being inlined, or in general the | |
33 source function providing the original trees. */ | |
34 tree src_fn; | |
35 | |
36 /* FUNCTION_DECL for function being inlined into, or in general | |
37 the destination function receiving the new trees. */ | |
38 tree dst_fn; | |
39 | |
40 /* Callgraph node of the source function. */ | |
41 struct cgraph_node *src_node; | |
42 | |
43 /* Callgraph node of the destination function. */ | |
44 struct cgraph_node *dst_node; | |
45 | |
46 /* struct function for function being inlined. Usually this is the same | |
47 as DECL_STRUCT_FUNCTION (src_fn), but can be different if saved_cfg | |
48 and saved_eh are in use. */ | |
49 struct function *src_cfun; | |
50 | |
51 /* The VAR_DECL for the return value. */ | |
52 tree retvar; | |
53 | |
54 /* The map from local declarations in the inlined function to | |
55 equivalents in the function into which it is being inlined. */ | |
56 struct pointer_map_t *decl_map; | |
57 | |
58 /* Create a new decl to replace DECL in the destination function. */ | |
59 tree (*copy_decl) (tree, struct copy_body_data *); | |
60 | |
61 /* Current BLOCK. */ | |
62 tree block; | |
63 | |
64 /* GIMPLE_CALL if va arg parameter packs should be expanded or NULL | |
65 is not. */ | |
66 gimple gimple_call; | |
67 | |
68 /* Exception region the inlined call lie in. */ | |
69 int eh_region; | |
70 | |
71 /* Take region number in the function being copied, add this value and | |
72 get eh region number of the duplicate in the function we inline into. */ | |
73 int eh_region_offset; | |
74 | |
75 /* We use the same mechanism do all sorts of different things. Rather | |
76 than enumerating the different cases, we categorize the behavior | |
77 in the various situations. */ | |
78 | |
79 /* Indicate the desired behavior wrt call graph edges. We can either | |
80 duplicate the edge (inlining, cloning), move the edge (versioning, | |
81 parallelization), or move the edges of the clones (saving). */ | |
82 enum copy_body_cge_which { | |
83 CB_CGE_DUPLICATE, | |
84 CB_CGE_MOVE, | |
85 CB_CGE_MOVE_CLONES | |
86 } transform_call_graph_edges; | |
87 | |
88 /* True if a new CFG should be created. False for inlining, true for | |
89 everything else. */ | |
90 bool transform_new_cfg; | |
91 | |
92 /* True if RETURN_EXPRs should be transformed to just the contained | |
93 MODIFY_EXPR. The branch semantics of the return will be handled | |
94 by manipulating the CFG rather than a statement. */ | |
95 bool transform_return_to_modify; | |
96 | |
97 /* True if this statement will need to be regimplified. */ | |
98 bool regimplify; | |
99 | |
100 /* > 0 if we are remapping a type currently. */ | |
101 int remapping_type_depth; | |
102 | |
103 /* A function to be called when duplicating BLOCK nodes. */ | |
104 void (*transform_lang_insert_block) (tree); | |
105 | |
106 /* Statements that might be possibly folded. */ | |
107 struct pointer_set_t *statements_to_fold; | |
108 | |
109 /* Entry basic block to currently copied body. */ | |
110 struct basic_block_def *entry_bb; | |
111 } copy_body_data; | |
112 | |
113 /* Weights of constructions for estimate_num_insns. */ | |
114 | |
115 typedef struct eni_weights_d | |
116 { | |
117 /* Cost per call. */ | |
118 unsigned call_cost; | |
119 | |
120 /* Cost per call to a target specific builtin */ | |
121 unsigned target_builtin_call_cost; | |
122 | |
123 /* Cost of "expensive" div and mod operations. */ | |
124 unsigned div_mod_cost; | |
125 | |
126 /* Cost for omp construct. */ | |
127 unsigned omp_cost; | |
128 } eni_weights; | |
129 | |
130 /* Weights that estimate_num_insns uses for heuristics in inlining. */ | |
131 | |
132 extern eni_weights eni_inlining_weights; | |
133 | |
134 /* Weights that estimate_num_insns uses to estimate the size of the | |
135 produced code. */ | |
136 | |
137 extern eni_weights eni_size_weights; | |
138 | |
139 /* Weights that estimate_num_insns uses to estimate the time necessary | |
140 to execute the produced code. */ | |
141 | |
142 extern eni_weights eni_time_weights; | |
143 | |
144 /* Function prototypes. */ | |
145 | |
146 extern tree copy_tree_body_r (tree *, int *, void *); | |
147 extern void insert_decl_map (copy_body_data *, tree, tree); | |
148 | |
149 unsigned int optimize_inline_calls (tree); | |
150 bool tree_inlinable_function_p (tree); | |
151 tree copy_tree_r (tree *, int *, void *); | |
152 tree copy_decl_no_change (tree decl, copy_body_data *id); | |
153 void save_body (tree, tree *, tree *); | |
154 int estimate_move_cost (tree type); | |
155 int estimate_num_insns (gimple, eni_weights *); | |
156 int estimate_num_insns_fn (tree, eni_weights *); | |
157 int count_insns_seq (gimple_seq, eni_weights *); | |
158 bool tree_versionable_function_p (tree); | |
159 void tree_function_versioning (tree, tree, varray_type, bool, bitmap); | |
160 bool tree_can_inline_p (tree, tree); | |
161 | |
162 extern gimple_seq remap_gimple_seq (gimple_seq, copy_body_data *); | |
163 extern tree remap_decl (tree decl, copy_body_data *id); | |
164 extern tree remap_type (tree type, copy_body_data *id); | |
165 extern gimple_seq copy_gimple_seq_and_replace_locals (gimple_seq seq); | |
166 | |
167 extern HOST_WIDE_INT estimated_stack_frame_size (void); | |
168 | |
169 #endif /* GCC_TREE_INLINE_H */ |