annotate gcc/ipa-icf-gimple.h @ 16:04ced10e8804

gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents
children 84e7813d76e9
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
16
kono
parents:
diff changeset
1 /* Interprocedural semantic function equality pass
kono
parents:
diff changeset
2 Copyright (C) 2014-2017 Free Software Foundation, Inc.
kono
parents:
diff changeset
3
kono
parents:
diff changeset
4 Contributed by Jan Hubicka <hubicka@ucw.cz> and Martin Liska <mliska@suse.cz>
kono
parents:
diff changeset
5
kono
parents:
diff changeset
6 This file is part of GCC.
kono
parents:
diff changeset
7
kono
parents:
diff changeset
8 GCC is free software; you can redistribute it and/or modify it under
kono
parents:
diff changeset
9 the terms of the GNU General Public License as published by the Free
kono
parents:
diff changeset
10 Software Foundation; either version 3, or (at your option) any later
kono
parents:
diff changeset
11 version.
kono
parents:
diff changeset
12
kono
parents:
diff changeset
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
kono
parents:
diff changeset
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
kono
parents:
diff changeset
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
kono
parents:
diff changeset
16 for more details.
kono
parents:
diff changeset
17
kono
parents:
diff changeset
18 You should have received a copy of the GNU General Public License
kono
parents:
diff changeset
19 along with GCC; see the file COPYING3. If not see
kono
parents:
diff changeset
20 <http://www.gnu.org/licenses/>. */
kono
parents:
diff changeset
21
kono
parents:
diff changeset
22 /* Gimple identical code folding (class func_checker) is an infastructure
kono
parents:
diff changeset
23 capable of comparing two given functions. The class compares every
kono
parents:
diff changeset
24 gimple statement and uses many dictionaries to map source and target
kono
parents:
diff changeset
25 SSA_NAMEs, declarations and other components.
kono
parents:
diff changeset
26
kono
parents:
diff changeset
27 To use the infrastructure, create an instanse of func_checker and call
kono
parents:
diff changeset
28 a comparsion function based on type of gimple statement. */
kono
parents:
diff changeset
29
kono
parents:
diff changeset
30 /* Prints string STRING to a FILE with a given number of SPACE_COUNT. */
kono
parents:
diff changeset
31 #define FPUTS_SPACES(file, space_count, string) \
kono
parents:
diff changeset
32 fprintf (file, "%*s" string, space_count, " ");
kono
parents:
diff changeset
33
kono
parents:
diff changeset
34 /* fprintf function wrapper that transforms given FORMAT to follow given
kono
parents:
diff changeset
35 number for SPACE_COUNT and call fprintf for a FILE. */
kono
parents:
diff changeset
36 #define FPRINTF_SPACES(file, space_count, format, ...) \
kono
parents:
diff changeset
37 fprintf (file, "%*s" format, space_count, " ", ##__VA_ARGS__);
kono
parents:
diff changeset
38
kono
parents:
diff changeset
39 /* Prints a MESSAGE to dump_file if exists. FUNC is name of function and
kono
parents:
diff changeset
40 LINE is location in the source file. */
kono
parents:
diff changeset
41
kono
parents:
diff changeset
42 static inline void
kono
parents:
diff changeset
43 dump_message_1 (const char *message, const char *func, unsigned int line)
kono
parents:
diff changeset
44 {
kono
parents:
diff changeset
45 if (dump_file && (dump_flags & TDF_DETAILS))
kono
parents:
diff changeset
46 fprintf (dump_file, " debug message: %s (%s:%u)\n", message, func, line);
kono
parents:
diff changeset
47 }
kono
parents:
diff changeset
48
kono
parents:
diff changeset
49 /* Prints a MESSAGE to dump_file if exists. */
kono
parents:
diff changeset
50 #define dump_message(message) dump_message_1 (message, __func__, __LINE__)
kono
parents:
diff changeset
51
kono
parents:
diff changeset
52 /* Logs a MESSAGE to dump_file if exists and returns false. FUNC is name
kono
parents:
diff changeset
53 of function and LINE is location in the source file. */
kono
parents:
diff changeset
54
kono
parents:
diff changeset
55 static inline bool
kono
parents:
diff changeset
56 return_false_with_message_1 (const char *message, const char *func,
kono
parents:
diff changeset
57 unsigned int line)
kono
parents:
diff changeset
58 {
kono
parents:
diff changeset
59 if (dump_file && (dump_flags & TDF_DETAILS))
kono
parents:
diff changeset
60 fprintf (dump_file, " false returned: '%s' (%s:%u)\n", message, func, line);
kono
parents:
diff changeset
61 return false;
kono
parents:
diff changeset
62 }
kono
parents:
diff changeset
63
kono
parents:
diff changeset
64 /* Logs a MESSAGE to dump_file if exists and returns false. */
kono
parents:
diff changeset
65 #define return_false_with_msg(message) \
kono
parents:
diff changeset
66 return_false_with_message_1 (message, __func__, __LINE__)
kono
parents:
diff changeset
67
kono
parents:
diff changeset
68 /* Return false and log that false value is returned. */
kono
parents:
diff changeset
69 #define return_false() return_false_with_msg ("")
kono
parents:
diff changeset
70
kono
parents:
diff changeset
71 /* Logs return value if RESULT is false. FUNC is name of function and LINE
kono
parents:
diff changeset
72 is location in the source file. */
kono
parents:
diff changeset
73
kono
parents:
diff changeset
74 static inline bool
kono
parents:
diff changeset
75 return_with_result (bool result, const char *func, unsigned int line)
kono
parents:
diff changeset
76 {
kono
parents:
diff changeset
77 if (!result && dump_file && (dump_flags & TDF_DETAILS))
kono
parents:
diff changeset
78 fprintf (dump_file, " false returned: (%s:%u)\n", func, line);
kono
parents:
diff changeset
79
kono
parents:
diff changeset
80 return result;
kono
parents:
diff changeset
81 }
kono
parents:
diff changeset
82
kono
parents:
diff changeset
83 /* Logs return value if RESULT is false. */
kono
parents:
diff changeset
84 #define return_with_debug(result) return_with_result (result, __func__, __LINE__)
kono
parents:
diff changeset
85
kono
parents:
diff changeset
86 /* Verbose logging function logging statements S1 and S2 of a CODE.
kono
parents:
diff changeset
87 FUNC is name of function and LINE is location in the source file. */
kono
parents:
diff changeset
88
kono
parents:
diff changeset
89 static inline bool
kono
parents:
diff changeset
90 return_different_stmts_1 (gimple *s1, gimple *s2, const char *code,
kono
parents:
diff changeset
91 const char *func, unsigned int line)
kono
parents:
diff changeset
92 {
kono
parents:
diff changeset
93 if (dump_file && (dump_flags & TDF_DETAILS))
kono
parents:
diff changeset
94 {
kono
parents:
diff changeset
95 fprintf (dump_file, " different statement for code: %s (%s:%u):\n",
kono
parents:
diff changeset
96 code, func, line);
kono
parents:
diff changeset
97
kono
parents:
diff changeset
98 print_gimple_stmt (dump_file, s1, 3, TDF_DETAILS);
kono
parents:
diff changeset
99 print_gimple_stmt (dump_file, s2, 3, TDF_DETAILS);
kono
parents:
diff changeset
100 }
kono
parents:
diff changeset
101
kono
parents:
diff changeset
102 return false;
kono
parents:
diff changeset
103 }
kono
parents:
diff changeset
104
kono
parents:
diff changeset
105 /* Verbose logging function logging statements S1 and S2 of a CODE. */
kono
parents:
diff changeset
106 #define return_different_stmts(s1, s2, code) \
kono
parents:
diff changeset
107 return_different_stmts_1 (s1, s2, code, __func__, __LINE__)
kono
parents:
diff changeset
108
kono
parents:
diff changeset
109 namespace ipa_icf_gimple {
kono
parents:
diff changeset
110
kono
parents:
diff changeset
111 /* Basic block struct for semantic equality pass. */
kono
parents:
diff changeset
112 class sem_bb
kono
parents:
diff changeset
113 {
kono
parents:
diff changeset
114 public:
kono
parents:
diff changeset
115 sem_bb (basic_block bb_, unsigned nondbg_stmt_count_, unsigned edge_count_):
kono
parents:
diff changeset
116 bb (bb_), nondbg_stmt_count (nondbg_stmt_count_), edge_count (edge_count_) {}
kono
parents:
diff changeset
117
kono
parents:
diff changeset
118 /* Basic block the structure belongs to. */
kono
parents:
diff changeset
119 basic_block bb;
kono
parents:
diff changeset
120
kono
parents:
diff changeset
121 /* Number of non-debug statements in the basic block. */
kono
parents:
diff changeset
122 unsigned nondbg_stmt_count;
kono
parents:
diff changeset
123
kono
parents:
diff changeset
124 /* Number of edges connected to the block. */
kono
parents:
diff changeset
125 unsigned edge_count;
kono
parents:
diff changeset
126 };
kono
parents:
diff changeset
127
kono
parents:
diff changeset
128 /* A class aggregating all connections and semantic equivalents
kono
parents:
diff changeset
129 for a given pair of semantic function candidates. */
kono
parents:
diff changeset
130 class func_checker
kono
parents:
diff changeset
131 {
kono
parents:
diff changeset
132 public:
kono
parents:
diff changeset
133 /* Initialize internal structures for a given SOURCE_FUNC_DECL and
kono
parents:
diff changeset
134 TARGET_FUNC_DECL. Strict polymorphic comparison is processed if
kono
parents:
diff changeset
135 an option COMPARE_POLYMORPHIC is true. For special cases, one can
kono
parents:
diff changeset
136 set IGNORE_LABELS to skip label comparison.
kono
parents:
diff changeset
137 Similarly, IGNORE_SOURCE_DECLS and IGNORE_TARGET_DECLS are sets
kono
parents:
diff changeset
138 of declarations that can be skipped. */
kono
parents:
diff changeset
139 func_checker (tree source_func_decl, tree target_func_decl,
kono
parents:
diff changeset
140 bool compare_polymorphic,
kono
parents:
diff changeset
141 bool ignore_labels = false,
kono
parents:
diff changeset
142 hash_set<symtab_node *> *ignored_source_nodes = NULL,
kono
parents:
diff changeset
143 hash_set<symtab_node *> *ignored_target_nodes = NULL);
kono
parents:
diff changeset
144
kono
parents:
diff changeset
145 /* Memory release routine. */
kono
parents:
diff changeset
146 ~func_checker();
kono
parents:
diff changeset
147
kono
parents:
diff changeset
148 /* Function visits all gimple labels and creates corresponding
kono
parents:
diff changeset
149 mapping between basic blocks and labels. */
kono
parents:
diff changeset
150 void parse_labels (sem_bb *bb);
kono
parents:
diff changeset
151
kono
parents:
diff changeset
152 /* Basic block equivalence comparison function that returns true if
kono
parents:
diff changeset
153 basic blocks BB1 and BB2 correspond. */
kono
parents:
diff changeset
154 bool compare_bb (sem_bb *bb1, sem_bb *bb2);
kono
parents:
diff changeset
155
kono
parents:
diff changeset
156 /* Verifies that trees T1 and T2 are equivalent from perspective of ICF. */
kono
parents:
diff changeset
157 bool compare_ssa_name (tree t1, tree t2);
kono
parents:
diff changeset
158
kono
parents:
diff changeset
159 /* Verification function for edges E1 and E2. */
kono
parents:
diff changeset
160 bool compare_edge (edge e1, edge e2);
kono
parents:
diff changeset
161
kono
parents:
diff changeset
162 /* Verifies for given GIMPLEs S1 and S2 that
kono
parents:
diff changeset
163 call statements are semantically equivalent. */
kono
parents:
diff changeset
164 bool compare_gimple_call (gcall *s1, gcall *s2);
kono
parents:
diff changeset
165
kono
parents:
diff changeset
166 /* Verifies for given GIMPLEs S1 and S2 that
kono
parents:
diff changeset
167 assignment statements are semantically equivalent. */
kono
parents:
diff changeset
168 bool compare_gimple_assign (gimple *s1, gimple *s2);
kono
parents:
diff changeset
169
kono
parents:
diff changeset
170 /* Verifies for given GIMPLEs S1 and S2 that
kono
parents:
diff changeset
171 condition statements are semantically equivalent. */
kono
parents:
diff changeset
172 bool compare_gimple_cond (gimple *s1, gimple *s2);
kono
parents:
diff changeset
173
kono
parents:
diff changeset
174 /* Verifies for given GIMPLE_LABEL stmts S1 and S2 that
kono
parents:
diff changeset
175 label statements are semantically equivalent. */
kono
parents:
diff changeset
176 bool compare_gimple_label (const glabel *s1, const glabel *s2);
kono
parents:
diff changeset
177
kono
parents:
diff changeset
178 /* Verifies for given GIMPLE_SWITCH stmts S1 and S2 that
kono
parents:
diff changeset
179 switch statements are semantically equivalent. */
kono
parents:
diff changeset
180 bool compare_gimple_switch (const gswitch *s1, const gswitch *s2);
kono
parents:
diff changeset
181
kono
parents:
diff changeset
182 /* Verifies for given GIMPLE_RETURN stmts S1 and S2 that
kono
parents:
diff changeset
183 return statements are semantically equivalent. */
kono
parents:
diff changeset
184 bool compare_gimple_return (const greturn *s1, const greturn *s2);
kono
parents:
diff changeset
185
kono
parents:
diff changeset
186 /* Verifies for given GIMPLEs S1 and S2 that
kono
parents:
diff changeset
187 goto statements are semantically equivalent. */
kono
parents:
diff changeset
188 bool compare_gimple_goto (gimple *s1, gimple *s2);
kono
parents:
diff changeset
189
kono
parents:
diff changeset
190 /* Verifies for given GIMPLE_RESX stmts S1 and S2 that
kono
parents:
diff changeset
191 resx statements are semantically equivalent. */
kono
parents:
diff changeset
192 bool compare_gimple_resx (const gresx *s1, const gresx *s2);
kono
parents:
diff changeset
193
kono
parents:
diff changeset
194 /* Verifies for given GIMPLE_ASM stmts S1 and S2 that ASM statements
kono
parents:
diff changeset
195 are equivalent.
kono
parents:
diff changeset
196 For the beginning, the pass only supports equality for
kono
parents:
diff changeset
197 '__asm__ __volatile__ ("", "", "", "memory")'. */
kono
parents:
diff changeset
198 bool compare_gimple_asm (const gasm *s1, const gasm *s2);
kono
parents:
diff changeset
199
kono
parents:
diff changeset
200 /* Verification function for declaration trees T1 and T2. */
kono
parents:
diff changeset
201 bool compare_decl (tree t1, tree t2);
kono
parents:
diff changeset
202
kono
parents:
diff changeset
203 /* Verifies that tree labels T1 and T2 correspond. */
kono
parents:
diff changeset
204 bool compare_tree_ssa_label (tree t1, tree t2);
kono
parents:
diff changeset
205
kono
parents:
diff changeset
206 /* Function compare for equality given memory operands T1 and T2. */
kono
parents:
diff changeset
207 bool compare_memory_operand (tree t1, tree t2);
kono
parents:
diff changeset
208
kono
parents:
diff changeset
209 /* Function compare for equality given trees T1 and T2 which
kono
parents:
diff changeset
210 can be either a constant or a declaration type. */
kono
parents:
diff changeset
211 bool compare_cst_or_decl (tree t1, tree t2);
kono
parents:
diff changeset
212
kono
parents:
diff changeset
213 /* Function responsible for comparison of various operands T1 and T2.
kono
parents:
diff changeset
214 If these components, from functions FUNC1 and FUNC2, are equal, true
kono
parents:
diff changeset
215 is returned. */
kono
parents:
diff changeset
216 bool compare_operand (tree t1, tree t2);
kono
parents:
diff changeset
217
kono
parents:
diff changeset
218 /* Compares GIMPLE ASM inputs (or outputs) where we iterate tree chain
kono
parents:
diff changeset
219 and compare both TREE_PURPOSEs and TREE_VALUEs. */
kono
parents:
diff changeset
220 bool compare_asm_inputs_outputs (tree t1, tree t2);
kono
parents:
diff changeset
221
kono
parents:
diff changeset
222 /* Verifies that trees T1 and T2, representing function declarations
kono
parents:
diff changeset
223 are equivalent from perspective of ICF. */
kono
parents:
diff changeset
224 bool compare_function_decl (tree t1, tree t2);
kono
parents:
diff changeset
225
kono
parents:
diff changeset
226 /* Verifies that trees T1 and T2 do correspond. */
kono
parents:
diff changeset
227 bool compare_variable_decl (tree t1, tree t2);
kono
parents:
diff changeset
228
kono
parents:
diff changeset
229 /* Return true if types are compatible for polymorphic call analysis.
kono
parents:
diff changeset
230 COMPARE_PTR indicates if polymorphic type comparsion should be
kono
parents:
diff changeset
231 done for pointers, too. */
kono
parents:
diff changeset
232 static bool compatible_polymorphic_types_p (tree t1, tree t2,
kono
parents:
diff changeset
233 bool compare_ptr);
kono
parents:
diff changeset
234
kono
parents:
diff changeset
235 /* Return true if types are compatible from perspective of ICF.
kono
parents:
diff changeset
236 FIRST_ARGUMENT indicates if the comparison is called for
kono
parents:
diff changeset
237 first parameter of a function. */
kono
parents:
diff changeset
238 static bool compatible_types_p (tree t1, tree t2);
kono
parents:
diff changeset
239
kono
parents:
diff changeset
240
kono
parents:
diff changeset
241 private:
kono
parents:
diff changeset
242 /* Vector mapping source SSA names to target ones. */
kono
parents:
diff changeset
243 vec <int> m_source_ssa_names;
kono
parents:
diff changeset
244
kono
parents:
diff changeset
245 /* Vector mapping target SSA names to source ones. */
kono
parents:
diff changeset
246 vec <int> m_target_ssa_names;
kono
parents:
diff changeset
247
kono
parents:
diff changeset
248 /* Source TREE function declaration. */
kono
parents:
diff changeset
249 tree m_source_func_decl;
kono
parents:
diff changeset
250
kono
parents:
diff changeset
251 /* Target TREE function declaration. */
kono
parents:
diff changeset
252 tree m_target_func_decl;
kono
parents:
diff changeset
253
kono
parents:
diff changeset
254 /* Source symbol nodes that should be skipped by
kono
parents:
diff changeset
255 declaration comparison. */
kono
parents:
diff changeset
256 hash_set<symtab_node *> *m_ignored_source_nodes;
kono
parents:
diff changeset
257
kono
parents:
diff changeset
258 /* Target symbol nodes that should be skipped by
kono
parents:
diff changeset
259 declaration comparison. */
kono
parents:
diff changeset
260 hash_set<symtab_node *> *m_ignored_target_nodes;
kono
parents:
diff changeset
261
kono
parents:
diff changeset
262 /* Source to target edge map. */
kono
parents:
diff changeset
263 hash_map <edge, edge> m_edge_map;
kono
parents:
diff changeset
264
kono
parents:
diff changeset
265 /* Source to target declaration map. */
kono
parents:
diff changeset
266 hash_map <tree, tree> m_decl_map;
kono
parents:
diff changeset
267
kono
parents:
diff changeset
268 /* Label to basic block index mapping. */
kono
parents:
diff changeset
269 hash_map <tree, int> m_label_bb_map;
kono
parents:
diff changeset
270
kono
parents:
diff changeset
271 /* Flag if polymorphic comparison should be executed. */
kono
parents:
diff changeset
272 bool m_compare_polymorphic;
kono
parents:
diff changeset
273
kono
parents:
diff changeset
274 /* Flag if ignore labels in comparison. */
kono
parents:
diff changeset
275 bool m_ignore_labels;
kono
parents:
diff changeset
276 };
kono
parents:
diff changeset
277
kono
parents:
diff changeset
278 } // ipa_icf_gimple namespace