|
111
|
1 /* Callgraph summary data structure.
|
|
|
2 Copyright (C) 2014-2017 Free Software Foundation, Inc.
|
|
|
3 Contributed by Martin Liska
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify it under
|
|
|
8 the terms of the GNU General Public License as published by the Free
|
|
|
9 Software Foundation; either version 3, or (at your option) any later
|
|
|
10 version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 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_SYMBOL_SUMMARY_H
|
|
|
22 #define GCC_SYMBOL_SUMMARY_H
|
|
|
23
|
|
|
24 /* We want to pass just pointer types as argument for function_summary
|
|
|
25 template class. */
|
|
|
26
|
|
|
27 template <class T>
|
|
|
28 class function_summary
|
|
|
29 {
|
|
|
30 private:
|
|
|
31 function_summary();
|
|
|
32 };
|
|
|
33
|
|
|
34 template <class T>
|
|
|
35 class GTY((user)) function_summary <T *>
|
|
|
36 {
|
|
|
37 public:
|
|
|
38 /* Default construction takes SYMTAB as an argument. */
|
|
|
39 function_summary (symbol_table *symtab, bool ggc = false): m_ggc (ggc),
|
|
|
40 m_insertion_enabled (true), m_released (false), m_map (13, ggc),
|
|
|
41 m_symtab (symtab)
|
|
|
42 {
|
|
|
43 m_symtab_insertion_hook =
|
|
|
44 symtab->add_cgraph_insertion_hook
|
|
|
45 (function_summary::symtab_insertion, this);
|
|
|
46
|
|
|
47 m_symtab_removal_hook =
|
|
|
48 symtab->add_cgraph_removal_hook
|
|
|
49 (function_summary::symtab_removal, this);
|
|
|
50 m_symtab_duplication_hook =
|
|
|
51 symtab->add_cgraph_duplication_hook
|
|
|
52 (function_summary::symtab_duplication, this);
|
|
|
53 }
|
|
|
54
|
|
|
55 /* Destructor. */
|
|
|
56 virtual ~function_summary ()
|
|
|
57 {
|
|
|
58 release ();
|
|
|
59 }
|
|
|
60
|
|
|
61 /* Destruction method that can be called for GGT purpose. */
|
|
|
62 void release ()
|
|
|
63 {
|
|
|
64 if (m_released)
|
|
|
65 return;
|
|
|
66
|
|
|
67 m_symtab->remove_cgraph_insertion_hook (m_symtab_insertion_hook);
|
|
|
68 m_symtab->remove_cgraph_removal_hook (m_symtab_removal_hook);
|
|
|
69 m_symtab->remove_cgraph_duplication_hook (m_symtab_duplication_hook);
|
|
|
70
|
|
|
71 /* Release all summaries. */
|
|
|
72 typedef typename hash_map <map_hash, T *>::iterator map_iterator;
|
|
|
73 for (map_iterator it = m_map.begin (); it != m_map.end (); ++it)
|
|
|
74 release ((*it).second);
|
|
|
75
|
|
|
76 m_released = true;
|
|
|
77 }
|
|
|
78
|
|
|
79 /* Traverses all summarys with a function F called with
|
|
|
80 ARG as argument. */
|
|
|
81 template<typename Arg, bool (*f)(const T &, Arg)>
|
|
|
82 void traverse (Arg a) const
|
|
|
83 {
|
|
|
84 m_map.traverse <f> (a);
|
|
|
85 }
|
|
|
86
|
|
|
87 /* Basic implementation of insert operation. */
|
|
|
88 virtual void insert (cgraph_node *, T *) {}
|
|
|
89
|
|
|
90 /* Basic implementation of removal operation. */
|
|
|
91 virtual void remove (cgraph_node *, T *) {}
|
|
|
92
|
|
|
93 /* Basic implementation of duplication operation. */
|
|
|
94 virtual void duplicate (cgraph_node *, cgraph_node *, T *, T *) {}
|
|
|
95
|
|
|
96 /* Allocates new data that are stored within map. */
|
|
|
97 T* allocate_new ()
|
|
|
98 {
|
|
|
99 /* Call gcc_internal_because we do not want to call finalizer for
|
|
|
100 a type T. We call dtor explicitly. */
|
|
|
101 return m_ggc ? new (ggc_internal_alloc (sizeof (T))) T () : new T () ;
|
|
|
102 }
|
|
|
103
|
|
|
104 /* Release an item that is stored within map. */
|
|
|
105 void release (T *item)
|
|
|
106 {
|
|
|
107 if (m_ggc)
|
|
|
108 {
|
|
|
109 item->~T ();
|
|
|
110 ggc_free (item);
|
|
|
111 }
|
|
|
112 else
|
|
|
113 delete item;
|
|
|
114 }
|
|
|
115
|
|
|
116 /* Getter for summary callgraph node pointer. */
|
|
|
117 T* get (cgraph_node *node)
|
|
|
118 {
|
|
|
119 gcc_checking_assert (node->summary_uid);
|
|
|
120 return get (node->summary_uid);
|
|
|
121 }
|
|
|
122
|
|
|
123 /* Return number of elements handled by data structure. */
|
|
|
124 size_t elements ()
|
|
|
125 {
|
|
|
126 return m_map.elements ();
|
|
|
127 }
|
|
|
128
|
|
|
129 /* Return true if a summary for the given NODE already exists. */
|
|
|
130 bool exists (cgraph_node *node)
|
|
|
131 {
|
|
|
132 return m_map.get (node->summary_uid) != NULL;
|
|
|
133 }
|
|
|
134
|
|
|
135 /* Enable insertion hook invocation. */
|
|
|
136 void enable_insertion_hook ()
|
|
|
137 {
|
|
|
138 m_insertion_enabled = true;
|
|
|
139 }
|
|
|
140
|
|
|
141 /* Enable insertion hook invocation. */
|
|
|
142 void disable_insertion_hook ()
|
|
|
143 {
|
|
|
144 m_insertion_enabled = false;
|
|
|
145 }
|
|
|
146
|
|
|
147 /* Symbol insertion hook that is registered to symbol table. */
|
|
|
148 static void symtab_insertion (cgraph_node *node, void *data)
|
|
|
149 {
|
|
|
150 gcc_checking_assert (node->summary_uid);
|
|
|
151 function_summary *summary = (function_summary <T *> *) (data);
|
|
|
152
|
|
|
153 if (summary->m_insertion_enabled)
|
|
|
154 summary->insert (node, summary->get (node));
|
|
|
155 }
|
|
|
156
|
|
|
157 /* Symbol removal hook that is registered to symbol table. */
|
|
|
158 static void symtab_removal (cgraph_node *node, void *data)
|
|
|
159 {
|
|
|
160 gcc_checking_assert (node->summary_uid);
|
|
|
161 function_summary *summary = (function_summary <T *> *) (data);
|
|
|
162
|
|
|
163 int summary_uid = node->summary_uid;
|
|
|
164 T **v = summary->m_map.get (summary_uid);
|
|
|
165
|
|
|
166 if (v)
|
|
|
167 {
|
|
|
168 summary->remove (node, *v);
|
|
|
169 summary->release (*v);
|
|
|
170 summary->m_map.remove (summary_uid);
|
|
|
171 }
|
|
|
172 }
|
|
|
173
|
|
|
174 /* Symbol duplication hook that is registered to symbol table. */
|
|
|
175 static void symtab_duplication (cgraph_node *node, cgraph_node *node2,
|
|
|
176 void *data)
|
|
|
177 {
|
|
|
178 function_summary *summary = (function_summary <T *> *) (data);
|
|
|
179 T **v = summary->m_map.get (node->summary_uid);
|
|
|
180
|
|
|
181 gcc_checking_assert (node2->summary_uid > 0);
|
|
|
182
|
|
|
183 if (v)
|
|
|
184 {
|
|
|
185 /* This load is necessary, because we insert a new value! */
|
|
|
186 T *data = *v;
|
|
|
187 T *duplicate = summary->allocate_new ();
|
|
|
188 summary->m_map.put (node2->summary_uid, duplicate);
|
|
|
189 summary->duplicate (node, node2, data, duplicate);
|
|
|
190 }
|
|
|
191 }
|
|
|
192
|
|
|
193 protected:
|
|
|
194 /* Indication if we use ggc summary. */
|
|
|
195 bool m_ggc;
|
|
|
196
|
|
|
197 private:
|
|
|
198 typedef int_hash <int, 0, -1> map_hash;
|
|
|
199
|
|
|
200 /* Getter for summary callgraph ID. */
|
|
|
201 T* get (int uid)
|
|
|
202 {
|
|
|
203 bool existed;
|
|
|
204 T **v = &m_map.get_or_insert (uid, &existed);
|
|
|
205 if (!existed)
|
|
|
206 *v = allocate_new ();
|
|
|
207
|
|
|
208 return *v;
|
|
|
209 }
|
|
|
210
|
|
|
211 /* Indicates if insertion hook is enabled. */
|
|
|
212 bool m_insertion_enabled;
|
|
|
213 /* Indicates if the summary is released. */
|
|
|
214 bool m_released;
|
|
|
215 /* Main summary store, where summary ID is used as key. */
|
|
|
216 hash_map <map_hash, T *> m_map;
|
|
|
217 /* Internal summary insertion hook pointer. */
|
|
|
218 cgraph_node_hook_list *m_symtab_insertion_hook;
|
|
|
219 /* Internal summary removal hook pointer. */
|
|
|
220 cgraph_node_hook_list *m_symtab_removal_hook;
|
|
|
221 /* Internal summary duplication hook pointer. */
|
|
|
222 cgraph_2node_hook_list *m_symtab_duplication_hook;
|
|
|
223 /* Symbol table the summary is registered to. */
|
|
|
224 symbol_table *m_symtab;
|
|
|
225
|
|
|
226 template <typename U> friend void gt_ggc_mx (function_summary <U *> * const &);
|
|
|
227 template <typename U> friend void gt_pch_nx (function_summary <U *> * const &);
|
|
|
228 template <typename U> friend void gt_pch_nx (function_summary <U *> * const &,
|
|
|
229 gt_pointer_operator, void *);
|
|
|
230 };
|
|
|
231
|
|
|
232 template <typename T>
|
|
|
233 void
|
|
|
234 gt_ggc_mx(function_summary<T *>* const &summary)
|
|
|
235 {
|
|
|
236 gcc_checking_assert (summary->m_ggc);
|
|
|
237 gt_ggc_mx (&summary->m_map);
|
|
|
238 }
|
|
|
239
|
|
|
240 template <typename T>
|
|
|
241 void
|
|
|
242 gt_pch_nx(function_summary<T *>* const &summary)
|
|
|
243 {
|
|
|
244 gcc_checking_assert (summary->m_ggc);
|
|
|
245 gt_pch_nx (&summary->m_map);
|
|
|
246 }
|
|
|
247
|
|
|
248 template <typename T>
|
|
|
249 void
|
|
|
250 gt_pch_nx(function_summary<T *>* const& summary, gt_pointer_operator op,
|
|
|
251 void *cookie)
|
|
|
252 {
|
|
|
253 gcc_checking_assert (summary->m_ggc);
|
|
|
254 gt_pch_nx (&summary->m_map, op, cookie);
|
|
|
255 }
|
|
|
256
|
|
|
257 /* An impossible class templated by non-pointers so, which makes sure that only
|
|
|
258 summaries gathering pointers can be created. */
|
|
|
259
|
|
|
260 template <class T>
|
|
|
261 class call_summary
|
|
|
262 {
|
|
|
263 private:
|
|
|
264 call_summary();
|
|
|
265 };
|
|
|
266
|
|
|
267 /* Class to store auxiliary information about call graph edges. */
|
|
|
268
|
|
|
269 template <class T>
|
|
|
270 class GTY((user)) call_summary <T *>
|
|
|
271 {
|
|
|
272 public:
|
|
|
273 /* Default construction takes SYMTAB as an argument. */
|
|
|
274 call_summary (symbol_table *symtab, bool ggc = false): m_ggc (ggc),
|
|
|
275 m_map (13, ggc), m_released (false), m_symtab (symtab)
|
|
|
276 {
|
|
|
277 m_symtab_removal_hook =
|
|
|
278 symtab->add_edge_removal_hook
|
|
|
279 (call_summary::symtab_removal, this);
|
|
|
280 m_symtab_duplication_hook =
|
|
|
281 symtab->add_edge_duplication_hook
|
|
|
282 (call_summary::symtab_duplication, this);
|
|
|
283 }
|
|
|
284
|
|
|
285 /* Destructor. */
|
|
|
286 virtual ~call_summary ()
|
|
|
287 {
|
|
|
288 release ();
|
|
|
289 }
|
|
|
290
|
|
|
291 /* Destruction method that can be called for GGT purpose. */
|
|
|
292 void release ()
|
|
|
293 {
|
|
|
294 if (m_released)
|
|
|
295 return;
|
|
|
296
|
|
|
297 m_symtab->remove_edge_removal_hook (m_symtab_removal_hook);
|
|
|
298 m_symtab->remove_edge_duplication_hook (m_symtab_duplication_hook);
|
|
|
299
|
|
|
300 /* Release all summaries. */
|
|
|
301 typedef typename hash_map <map_hash, T *>::iterator map_iterator;
|
|
|
302 for (map_iterator it = m_map.begin (); it != m_map.end (); ++it)
|
|
|
303 release ((*it).second);
|
|
|
304
|
|
|
305 m_released = true;
|
|
|
306 }
|
|
|
307
|
|
|
308 /* Traverses all summarys with a function F called with
|
|
|
309 ARG as argument. */
|
|
|
310 template<typename Arg, bool (*f)(const T &, Arg)>
|
|
|
311 void traverse (Arg a) const
|
|
|
312 {
|
|
|
313 m_map.traverse <f> (a);
|
|
|
314 }
|
|
|
315
|
|
|
316 /* Basic implementation of removal operation. */
|
|
|
317 virtual void remove (cgraph_edge *, T *) {}
|
|
|
318
|
|
|
319 /* Basic implementation of duplication operation. */
|
|
|
320 virtual void duplicate (cgraph_edge *, cgraph_edge *, T *, T *) {}
|
|
|
321
|
|
|
322 /* Allocates new data that are stored within map. */
|
|
|
323 T* allocate_new ()
|
|
|
324 {
|
|
|
325 /* Call gcc_internal_because we do not want to call finalizer for
|
|
|
326 a type T. We call dtor explicitly. */
|
|
|
327 return m_ggc ? new (ggc_internal_alloc (sizeof (T))) T () : new T () ;
|
|
|
328 }
|
|
|
329
|
|
|
330 /* Release an item that is stored within map. */
|
|
|
331 void release (T *item)
|
|
|
332 {
|
|
|
333 if (m_ggc)
|
|
|
334 {
|
|
|
335 item->~T ();
|
|
|
336 ggc_free (item);
|
|
|
337 }
|
|
|
338 else
|
|
|
339 delete item;
|
|
|
340 }
|
|
|
341
|
|
|
342 /* Getter for summary callgraph edge pointer. */
|
|
|
343 T* get (cgraph_edge *edge)
|
|
|
344 {
|
|
|
345 return get (hashable_uid (edge));
|
|
|
346 }
|
|
|
347
|
|
|
348 /* Return number of elements handled by data structure. */
|
|
|
349 size_t elements ()
|
|
|
350 {
|
|
|
351 return m_map.elements ();
|
|
|
352 }
|
|
|
353
|
|
|
354 /* Return true if a summary for the given EDGE already exists. */
|
|
|
355 bool exists (cgraph_edge *edge)
|
|
|
356 {
|
|
|
357 return m_map.get (hashable_uid (edge)) != NULL;
|
|
|
358 }
|
|
|
359
|
|
|
360 /* Symbol removal hook that is registered to symbol table. */
|
|
|
361 static void symtab_removal (cgraph_edge *edge, void *data)
|
|
|
362 {
|
|
|
363 call_summary *summary = (call_summary <T *> *) (data);
|
|
|
364
|
|
|
365 int h_uid = summary->hashable_uid (edge);
|
|
|
366 T **v = summary->m_map.get (h_uid);
|
|
|
367
|
|
|
368 if (v)
|
|
|
369 {
|
|
|
370 summary->remove (edge, *v);
|
|
|
371 summary->release (*v);
|
|
|
372 summary->m_map.remove (h_uid);
|
|
|
373 }
|
|
|
374 }
|
|
|
375
|
|
|
376 /* Symbol duplication hook that is registered to symbol table. */
|
|
|
377 static void symtab_duplication (cgraph_edge *edge1, cgraph_edge *edge2,
|
|
|
378 void *data)
|
|
|
379 {
|
|
|
380 call_summary *summary = (call_summary <T *> *) (data);
|
|
|
381 T **v = summary->m_map.get (summary->hashable_uid (edge1));
|
|
|
382
|
|
|
383 if (v)
|
|
|
384 {
|
|
|
385 /* This load is necessary, because we insert a new value! */
|
|
|
386 T *data = *v;
|
|
|
387 T *duplicate = summary->allocate_new ();
|
|
|
388 summary->m_map.put (summary->hashable_uid (edge2), duplicate);
|
|
|
389 summary->duplicate (edge1, edge2, data, duplicate);
|
|
|
390 }
|
|
|
391 }
|
|
|
392
|
|
|
393 protected:
|
|
|
394 /* Indication if we use ggc summary. */
|
|
|
395 bool m_ggc;
|
|
|
396
|
|
|
397 private:
|
|
|
398 typedef int_hash <int, 0, -1> map_hash;
|
|
|
399
|
|
|
400 /* Getter for summary callgraph ID. */
|
|
|
401 T* get (int uid)
|
|
|
402 {
|
|
|
403 bool existed;
|
|
|
404 T **v = &m_map.get_or_insert (uid, &existed);
|
|
|
405 if (!existed)
|
|
|
406 *v = allocate_new ();
|
|
|
407
|
|
|
408 return *v;
|
|
|
409 }
|
|
|
410
|
|
|
411 /* Get a hashable uid of EDGE. */
|
|
|
412 int hashable_uid (cgraph_edge *edge)
|
|
|
413 {
|
|
|
414 /* Edge uids start at zero which our hash_map does not like. */
|
|
|
415 return edge->uid + 1;
|
|
|
416 }
|
|
|
417
|
|
|
418 /* Main summary store, where summary ID is used as key. */
|
|
|
419 hash_map <map_hash, T *> m_map;
|
|
|
420 /* Internal summary removal hook pointer. */
|
|
|
421 cgraph_edge_hook_list *m_symtab_removal_hook;
|
|
|
422 /* Internal summary duplication hook pointer. */
|
|
|
423 cgraph_2edge_hook_list *m_symtab_duplication_hook;
|
|
|
424 /* Indicates if the summary is released. */
|
|
|
425 bool m_released;
|
|
|
426 /* Symbol table the summary is registered to. */
|
|
|
427 symbol_table *m_symtab;
|
|
|
428
|
|
|
429 template <typename U> friend void gt_ggc_mx (call_summary <U *> * const &);
|
|
|
430 template <typename U> friend void gt_pch_nx (call_summary <U *> * const &);
|
|
|
431 template <typename U> friend void gt_pch_nx (call_summary <U *> * const &,
|
|
|
432 gt_pointer_operator, void *);
|
|
|
433 };
|
|
|
434
|
|
|
435 template <typename T>
|
|
|
436 void
|
|
|
437 gt_ggc_mx(call_summary<T *>* const &summary)
|
|
|
438 {
|
|
|
439 gcc_checking_assert (summary->m_ggc);
|
|
|
440 gt_ggc_mx (&summary->m_map);
|
|
|
441 }
|
|
|
442
|
|
|
443 template <typename T>
|
|
|
444 void
|
|
|
445 gt_pch_nx(call_summary<T *>* const &summary)
|
|
|
446 {
|
|
|
447 gcc_checking_assert (summary->m_ggc);
|
|
|
448 gt_pch_nx (&summary->m_map);
|
|
|
449 }
|
|
|
450
|
|
|
451 template <typename T>
|
|
|
452 void
|
|
|
453 gt_pch_nx(call_summary<T *>* const& summary, gt_pointer_operator op,
|
|
|
454 void *cookie)
|
|
|
455 {
|
|
|
456 gcc_checking_assert (summary->m_ggc);
|
|
|
457 gt_pch_nx (&summary->m_map, op, cookie);
|
|
|
458 }
|
|
|
459
|
|
|
460 #endif /* GCC_SYMBOL_SUMMARY_H */
|
