gcc/symbol-summary.h

   1 /* Callgraph summary data structure.
   2    Copyright (C) 2014-2023 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 /* Base class for function_summary and fast_function_summary classes.  */
  25
  26 template <class T>
  27 class function_summary_base
  28 {
  29 public:
  30   /* Default construction takes SYMTAB as an argument.  */
  31   function_summary_base (symbol_table *symtab,
  32                          cgraph_node_hook symtab_insertion,
  33                          cgraph_node_hook symtab_removal,
  34                          cgraph_2node_hook symtab_duplication
  35                          CXX_MEM_STAT_INFO):
  36   m_symtab (symtab), m_symtab_insertion (symtab_insertion),
  37   m_symtab_removal (symtab_removal),
  38   m_symtab_duplication (symtab_duplication),
  39   m_symtab_insertion_hook (NULL), m_symtab_duplication_hook (NULL),
  40   m_allocator ("function summary" PASS_MEM_STAT)
  41   {
  42     enable_insertion_hook ();
  43     m_symtab_removal_hook
  44       = m_symtab->add_cgraph_removal_hook (m_symtab_removal, this);
  45     enable_duplication_hook ();
  46   }
  47
  48   /* Basic implementation of insert operation.  */
  49   virtual void insert (cgraph_node *, T *)
  50   {
  51     /* In most cases, it makes no sense to create summaries without
  52        initializing them.  */
  53     gcc_unreachable ();
  54   }
  55
  56   /* Basic implementation of removal operation.  */
  57   virtual void remove (cgraph_node *, T *) {}
  58
  59   /* Basic implementation of duplication operation.  */
  60   virtual void duplicate (cgraph_node *, cgraph_node *, T *, T *)
  61   {
  62     /* It makes no sense to not copy anything during duplication.  */
  63     gcc_unreachable ();
  64   }
  65
  66   /* Enable insertion hook invocation.  */
  67   void enable_insertion_hook ()
  68   {
  69     if (m_symtab_insertion_hook == NULL)
  70       m_symtab_insertion_hook
  71         = m_symtab->add_cgraph_insertion_hook (m_symtab_insertion, this);
  72   }
  73
  74   /* Enable insertion hook invocation.  */
  75   void disable_insertion_hook ()
  76   {
  77     if (m_symtab_insertion_hook != NULL)
  78       {
  79         m_symtab->remove_cgraph_insertion_hook (m_symtab_insertion_hook);
  80         m_symtab_insertion_hook = NULL;
  81       }
  82   }
  83
  84   /* Enable duplication hook invocation.  */
  85   void enable_duplication_hook ()
  86   {
  87     if (m_symtab_duplication_hook == NULL)
  88       m_symtab_duplication_hook
  89         = m_symtab->add_cgraph_duplication_hook (m_symtab_duplication, this);
  90   }
  91
  92   /* Enable duplication hook invocation.  */
  93   void disable_duplication_hook ()
  94   {
  95     if (m_symtab_duplication_hook != NULL)
  96       {
  97         m_symtab->remove_cgraph_duplication_hook (m_symtab_duplication_hook);
  98         m_symtab_duplication_hook = NULL;
  99       }
 100   }
 101
 102 protected:
 103   /* Allocates new data that are stored within map.  */
 104   T* allocate_new ()
 105   {
 106     /* Call gcc_internal_because we do not want to call finalizer for
 107        a type T.  We call dtor explicitly.  */
 108     return is_ggc () ? new (ggc_internal_alloc (sizeof (T))) T ()
 109                      : m_allocator.allocate () ;
 110   }
 111
 112   /* Release an item that is stored within map.  */
 113   void release (T *item)
 114   {
 115     if (is_ggc ())
 116       ggc_delete (item);
 117     else
 118       m_allocator.remove (item);
 119   }
 120
 121   /* Unregister all call-graph hooks.  */
 122   void unregister_hooks ();
 123
 124   /* Symbol table the summary is registered to.  */
 125   symbol_table *m_symtab;
 126
 127   /* Insertion function defined by a summary.  */
 128   cgraph_node_hook m_symtab_insertion;
 129   /* Removal function defined by a summary.  */
 130   cgraph_node_hook m_symtab_removal;
 131   /* Duplication function defined by a summary.  */
 132   cgraph_2node_hook m_symtab_duplication;
 133
 134   /* Internal summary insertion hook pointer.  */
 135   cgraph_node_hook_list *m_symtab_insertion_hook;
 136   /* Internal summary removal hook pointer.  */
 137   cgraph_node_hook_list *m_symtab_removal_hook;
 138   /* Internal summary duplication hook pointer.  */
 139   cgraph_2node_hook_list *m_symtab_duplication_hook;
 140
 141 private:
 142   /* Return true when the summary uses GGC memory for allocation.  */
 143   virtual bool is_ggc () = 0;
 144
 145   /* Object allocator for heap allocation.  */
 146   object_allocator<T> m_allocator;
 147 };
 148
 149 template <typename T>
 150 void
 151 function_summary_base<T>::unregister_hooks ()
 152 {
 153   disable_insertion_hook ();
 154   m_symtab->remove_cgraph_removal_hook (m_symtab_removal_hook);
 155   disable_duplication_hook ();
 156 }
 157
 158 /* We want to pass just pointer types as argument for function_summary
 159    template class.  */
 160
 161 template <class T>
 162 class function_summary
 163 {
 164 private:
 165   function_summary();
 166 };
 167
 168 /* Function summary is a helper class that is used to associate a data structure
 169    related to a callgraph node.  Typical usage can be seen in IPA passes which
 170    create a temporary pass-related structures.  The summary class registers
 171    hooks that are triggered when a new node is inserted, duplicated and deleted.
 172    A user of a summary class can ovewrite virtual methods than are triggered by
 173    the summary if such hook is triggered.  Apart from a callgraph node, the user
 174    is given a data structure tied to the node.
 175
 176    The function summary class can work both with a heap-allocated memory and
 177    a memory gained by garbage collected memory.  */
 178
 179 template <class T>
 180 class GTY((user)) function_summary <T *>: public function_summary_base<T>
 181 {
 182 public:
 183   /* Default construction takes SYMTAB as an argument.  */
 184   function_summary (symbol_table *symtab, bool ggc = false CXX_MEM_STAT_INFO);
 185
 186   /* Destructor.  */
 187   virtual ~function_summary ();
 188
 189   /* Traverses all summarys with a function F called with
 190      ARG as argument.  */
 191   template<typename Arg, bool (*f)(const T &, Arg)>
 192   void traverse (Arg a) const
 193   {
 194     m_map.template traverse <f> (a);
 195   }
 196
 197   /* Getter for summary callgraph node pointer.  If a summary for a node
 198      does not exist it will be created.  */
 199   T* get_create (cgraph_node *node)
 200   {
 201     bool existed;
 202     T **v = &m_map.get_or_insert (node->get_uid (), &existed);
 203     if (!existed)
 204       *v = this->allocate_new ();
 205
 206     return *v;
 207   }
 208
 209   /* Getter for summary callgraph node pointer.  */
 210   T* get (cgraph_node *node) ATTRIBUTE_PURE
 211   {
 212     T **v = m_map.get (node->get_uid ());
 213     return v == NULL ? NULL : *v;
 214   }
 215
 216   /* Remove node from summary.  */
 217   using function_summary_base<T>::remove;
 218   void remove (cgraph_node *node)
 219   {
 220     int uid = node->get_uid ();
 221     T **v = m_map.get (uid);
 222     if (v)
 223       {
 224         m_map.remove (uid);
 225         this->release (*v);
 226       }
 227   }
 228
 229   /* Return true if a summary for the given NODE already exists.  */
 230   bool exists (cgraph_node *node)
 231   {
 232     return m_map.get (node->get_uid ()) != NULL;
 233   }
 234
 235   /* Symbol insertion hook that is registered to symbol table.  */
 236   static void symtab_insertion (cgraph_node *node, void *data);
 237
 238   /* Symbol removal hook that is registered to symbol table.  */
 239   static void symtab_removal (cgraph_node *node, void *data);
 240
 241   /* Symbol duplication hook that is registered to symbol table.  */
 242   static void symtab_duplication (cgraph_node *node, cgraph_node *node2,
 243                                   void *data);
 244
 245 protected:
 246   /* Indication if we use ggc summary.  */
 247   bool m_ggc;
 248
 249 private:
 250   /* Indication if we use ggc summary.  */
 251   bool is_ggc () final override
 252   {
 253     return m_ggc;
 254   }
 255
 256   typedef int_hash <int, 0, -1> map_hash;
 257
 258   /* Main summary store, where summary ID is used as key.  */
 259   hash_map <map_hash, T *> m_map;
 260
 261   template <typename U> friend void gt_ggc_mx (function_summary <U *> * const &);
 262   template <typename U> friend void gt_pch_nx (function_summary <U *> * const &);
 263   template <typename U> friend void gt_pch_nx (function_summary <U *> * const &,
 264       gt_pointer_operator, void *);
 265 };
 266
 267 template <typename T>
 268 function_summary<T *>::function_summary (symbol_table *symtab, bool ggc
 269                                          MEM_STAT_DECL):
 270   function_summary_base<T> (symtab, function_summary::symtab_insertion,
 271                             function_summary::symtab_removal,
 272                             function_summary::symtab_duplication
 273                             PASS_MEM_STAT),
 274   m_ggc (ggc), m_map (13, ggc, true, GATHER_STATISTICS PASS_MEM_STAT) {}
 275
 276 template <typename T>
 277 function_summary<T *>::~function_summary ()
 278 {
 279   this->unregister_hooks ();
 280
 281   /* Release all summaries.  */
 282   typedef typename hash_map <map_hash, T *>::iterator map_iterator;
 283   for (map_iterator it = m_map.begin (); it != m_map.end (); ++it)
 284     this->release ((*it).second);
 285 }
 286
 287 template <typename T>
 288 void
 289 function_summary<T *>::symtab_insertion (cgraph_node *node, void *data)
 290 {
 291   gcc_checking_assert (node->get_uid ());
 292   function_summary *summary = (function_summary <T *> *) (data);
 293   summary->insert (node, summary->get_create (node));
 294 }
 295
 296 template <typename T>
 297 void
 298 function_summary<T *>::symtab_removal (cgraph_node *node, void *data)
 299 {
 300   gcc_checking_assert (node->get_uid ());
 301   function_summary *summary = (function_summary <T *> *) (data);
 302   summary->remove (node);
 303 }
 304
 305 template <typename T>
 306 void
 307 function_summary<T *>::symtab_duplication (cgraph_node *node,
 308                                            cgraph_node *node2, void *data)
 309 {
 310   function_summary *summary = (function_summary <T *> *) (data);
 311   T *v = summary->get (node);
 312
 313   if (v)
 314     summary->duplicate (node, node2, v, summary->get_create (node2));
 315 }
 316
 317 template <typename T>
 318 void
 319 gt_ggc_mx(function_summary<T *>* const &summary)
 320 {
 321   gcc_checking_assert (summary->m_ggc);
 322   gt_ggc_mx (&summary->m_map);
 323 }
 324
 325 template <typename T>
 326 void
 327 gt_pch_nx (function_summary<T *> *const &)
 328 {
 329   gcc_unreachable ();
 330 }
 331
 332 template <typename T>
 333 void
 334 gt_pch_nx (function_summary<T *> *const &, gt_pointer_operator, void *)
 335 {
 336   gcc_unreachable ();
 337 }
 338
 339 /* Help template from std c++11.  */
 340
 341 template<typename T, typename U>
 342 struct is_same
 343 {
 344     static const bool value = false;
 345 };
 346
 347 template<typename T>
 348 struct is_same<T,T>  //specialization
 349 {
 350    static const bool value = true;
 351 };
 352
 353 /* We want to pass just pointer types as argument for fast_function_summary
 354    template class.  */
 355
 356 template <class T, class V>
 357 class fast_function_summary
 358 {
 359 private:
 360   fast_function_summary ();
 361 };
 362
 363 /* Function vector summary is a fast implementation of function_summary that
 364    utilizes vector as primary storage of summaries.  */
 365
 366 template <class T, class V>
 367 class GTY((user)) fast_function_summary <T *, V>
 368   : public function_summary_base<T>
 369 {
 370 public:
 371   /* Default construction takes SYMTAB as an argument.  */
 372   fast_function_summary (symbol_table *symtab CXX_MEM_STAT_INFO);
 373
 374   /* Destructor.  */
 375   virtual ~fast_function_summary ();
 376
 377   /* Traverses all summarys with a function F called with
 378      ARG as argument.  */
 379   template<typename Arg, bool (*f)(const T &, Arg)>
 380   void traverse (Arg a) const
 381   {
 382     for (unsigned i = 0; i < m_vector->length (); i++)
 383       if ((*m_vector[i]) != NULL)
 384         f ((*m_vector)[i], a);
 385   }
 386
 387   /* Getter for summary callgraph node pointer.  If a summary for a node
 388      does not exist it will be created.  */
 389   T* get_create (cgraph_node *node)
 390   {
 391     int id = node->get_summary_id ();
 392     if (id == -1)
 393       id = this->m_symtab->assign_summary_id (node);
 394
 395     if ((unsigned int)id >= m_vector->length ())
 396       vec_safe_grow_cleared (m_vector,
 397                              this->m_symtab->cgraph_max_summary_id);
 398
 399     if ((*m_vector)[id] == NULL)
 400       (*m_vector)[id] = this->allocate_new ();
 401
 402     return (*m_vector)[id];
 403   }
 404
 405   /* Getter for summary callgraph node pointer.  */
 406   T* get (cgraph_node *node) ATTRIBUTE_PURE
 407   {
 408     return exists (node) ? (*m_vector)[node->get_summary_id ()] : NULL;
 409   }
 410
 411   using function_summary_base<T>::remove;
 412   void remove (cgraph_node *node)
 413   {
 414     if (exists (node))
 415       {
 416         int id = node->get_summary_id ();
 417         this->release ((*m_vector)[id]);
 418         (*m_vector)[id] = NULL;
 419       }
 420   }
 421
 422   /* Return true if a summary for the given NODE already exists.  */
 423   bool exists (cgraph_node *node)
 424   {
 425     int id = node->get_summary_id ();
 426     return (id != -1
 427             && (unsigned int)id < m_vector->length ()
 428             && (*m_vector)[id] != NULL);
 429   }
 430
 431   /* Symbol insertion hook that is registered to symbol table.  */
 432   static void symtab_insertion (cgraph_node *node, void *data);
 433
 434   /* Symbol removal hook that is registered to symbol table.  */
 435   static void symtab_removal (cgraph_node *node, void *data);
 436
 437   /* Symbol duplication hook that is registered to symbol table.  */
 438   static void symtab_duplication (cgraph_node *node, cgraph_node *node2,
 439                                   void *data);
 440
 441 private:
 442   bool is_ggc () final override;
 443
 444   /* Summary is stored in the vector.  */
 445   vec <T *, V> *m_vector;
 446
 447   template <typename U> friend void gt_ggc_mx (fast_function_summary <U *, va_gc> * const &);
 448   template <typename U> friend void gt_pch_nx (fast_function_summary <U *, va_gc> * const &);
 449   template <typename U> friend void gt_pch_nx (fast_function_summary <U *, va_gc> * const &,
 450       gt_pointer_operator, void *);
 451 };
 452
 453 template <typename T, typename V>
 454 fast_function_summary<T *, V>::fast_function_summary (symbol_table *symtab
 455                                                       MEM_STAT_DECL):
 456   function_summary_base<T> (symtab,
 457                             fast_function_summary::symtab_insertion,
 458                             fast_function_summary::symtab_removal,
 459                             fast_function_summary::symtab_duplication
 460                             PASS_MEM_STAT), m_vector (NULL)
 461 {
 462   vec_alloc (m_vector, 13 PASS_MEM_STAT);
 463 }
 464
 465 template <typename T, typename V>
 466 fast_function_summary<T *, V>::~fast_function_summary ()
 467 {
 468   this->unregister_hooks ();
 469
 470   /* Release all summaries.  */
 471   for (unsigned i = 0; i < m_vector->length (); i++)
 472     if ((*m_vector)[i] != NULL)
 473       this->release ((*m_vector)[i]);
 474   vec_free (m_vector);
 475 }
 476
 477 template <typename T, typename V>
 478 void
 479 fast_function_summary<T *, V>::symtab_insertion (cgraph_node *node, void *data)
 480 {
 481   gcc_checking_assert (node->get_uid ());
 482   fast_function_summary *summary = (fast_function_summary <T *, V> *) (data);
 483   summary->insert (node, summary->get_create (node));
 484 }
 485
 486 template <typename T, typename V>
 487 void
 488 fast_function_summary<T *, V>::symtab_removal (cgraph_node *node, void *data)
 489 {
 490   gcc_checking_assert (node->get_uid ());
 491   fast_function_summary *summary = (fast_function_summary <T *, V> *) (data);
 492
 493   if (summary->exists (node))
 494     summary->remove (node);
 495 }
 496
 497 template <typename T, typename V>
 498 void
 499 fast_function_summary<T *, V>::symtab_duplication (cgraph_node *node,
 500                                                    cgraph_node *node2,
 501                                                    void *data)
 502 {
 503   fast_function_summary *summary = (fast_function_summary <T *, V> *) (data);
 504   T *v = summary->get (node);
 505
 506   if (v)
 507     {
 508       T *duplicate = summary->get_create (node2);
 509       summary->duplicate (node, node2, v, duplicate);
 510     }
 511 }
 512
 513 template <typename T, typename V>
 514 inline bool
 515 fast_function_summary<T *, V>::is_ggc ()
 516 {
 517   return is_same<V, va_gc>::value;
 518 }
 519
 520 template <typename T>
 521 void
 522 gt_ggc_mx (fast_function_summary<T *, va_heap>* const &)
 523 {
 524 }
 525
 526 template <typename T>
 527 void
 528 gt_pch_nx (fast_function_summary<T *, va_heap>* const &)
 529 {
 530 }
 531
 532 template <typename T>
 533 void
 534 gt_pch_nx (fast_function_summary<T *, va_heap>* const&, gt_pointer_operator,
 535            void *)
 536 {
 537 }
 538
 539 template <typename T>
 540 void
 541 gt_ggc_mx (fast_function_summary<T *, va_gc>* const &summary)
 542 {
 543   ggc_test_and_set_mark (summary->m_vector);
 544   gt_ggc_mx (summary->m_vector);
 545 }
 546
 547 template <typename T>
 548 void
 549 gt_pch_nx (fast_function_summary<T *, va_gc> *const &)
 550 {
 551   gcc_unreachable ();
 552 }
 553
 554 template <typename T>
 555 void
 556 gt_pch_nx (fast_function_summary<T *, va_gc> *const &, gt_pointer_operator,
 557            void *)
 558 {
 559   gcc_unreachable ();
 560 }
 561
 562 /* Base class for call_summary and fast_call_summary classes.  */
 563
 564 template <class T>
 565 class call_summary_base
 566 {
 567 public:
 568   /* Default construction takes SYMTAB as an argument.  */
 569   call_summary_base (symbol_table *symtab, cgraph_edge_hook symtab_removal,
 570                      cgraph_2edge_hook symtab_duplication CXX_MEM_STAT_INFO):
 571   m_symtab (symtab), m_symtab_removal (symtab_removal),
 572   m_symtab_duplication (symtab_duplication), m_symtab_duplication_hook (NULL),
 573   m_initialize_when_cloning (false),
 574   m_allocator ("call summary" PASS_MEM_STAT)
 575   {
 576     m_symtab_removal_hook
 577       = m_symtab->add_edge_removal_hook (m_symtab_removal, this);
 578     enable_duplication_hook ();
 579   }
 580
 581   /* Basic implementation of removal operation.  */
 582   virtual void remove (cgraph_edge *, T *) {}
 583
 584   /* Basic implementation of duplication operation.  */
 585   virtual void duplicate (cgraph_edge *, cgraph_edge *, T *, T *)
 586   {
 587     gcc_unreachable ();
 588   }
 589
 590   /* Enable duplication hook invocation.  */
 591   void enable_duplication_hook ()
 592   {
 593     if (m_symtab_duplication_hook == NULL)
 594       m_symtab_duplication_hook
 595         = m_symtab->add_edge_duplication_hook (m_symtab_duplication,
 596                                                this);
 597   }
 598
 599   /* Enable duplication hook invocation.  */
 600   void disable_duplication_hook ()
 601   {
 602     if (m_symtab_duplication_hook != NULL)
 603       {
 604         m_symtab->remove_edge_duplication_hook (m_symtab_duplication_hook);
 605         m_symtab_duplication_hook = NULL;
 606       }
 607   }
 608
 609 protected:
 610   /* Allocates new data that are stored within map.  */
 611   T* allocate_new ()
 612   {
 613     /* Call gcc_internal_because we do not want to call finalizer for
 614        a type T.  We call dtor explicitly.  */
 615     return is_ggc () ? new (ggc_internal_alloc (sizeof (T))) T ()
 616                      : m_allocator.allocate ();
 617   }
 618
 619   /* Release an item that is stored within map.  */
 620   void release (T *item)
 621   {
 622     if (is_ggc ())
 623       ggc_delete (item);
 624     else
 625       m_allocator.remove (item);
 626   }
 627
 628   /* Unregister all call-graph hooks.  */
 629   void unregister_hooks ();
 630
 631   /* Symbol table the summary is registered to.  */
 632   symbol_table *m_symtab;
 633
 634   /* Removal function defined by a summary.  */
 635   cgraph_edge_hook m_symtab_removal;
 636   /* Duplication function defined by a summary.  */
 637   cgraph_2edge_hook m_symtab_duplication;
 638
 639   /* Internal summary removal hook pointer.  */
 640   cgraph_edge_hook_list *m_symtab_removal_hook;
 641   /* Internal summary duplication hook pointer.  */
 642   cgraph_2edge_hook_list *m_symtab_duplication_hook;
 643   /* Initialize summary for an edge that is cloned.  */
 644   bool m_initialize_when_cloning;
 645
 646 private:
 647   /* Return true when the summary uses GGC memory for allocation.  */
 648   virtual bool is_ggc () = 0;
 649
 650   /* Object allocator for heap allocation.  */
 651   object_allocator<T> m_allocator;
 652 };
 653
 654 template <typename T>
 655 void
 656 call_summary_base<T>::unregister_hooks ()
 657 {
 658   m_symtab->remove_edge_removal_hook (m_symtab_removal_hook);
 659   disable_duplication_hook ();
 660 }
 661
 662 /* An impossible class templated by non-pointers so, which makes sure that only
 663    summaries gathering pointers can be created.  */
 664
 665 template <class T>
 666 class call_summary
 667 {
 668 private:
 669   call_summary ();
 670 };
 671
 672 /* Class to store auxiliary information about call graph edges.  */
 673
 674 template <class T>
 675 class GTY((user)) call_summary <T *>: public call_summary_base<T>
 676 {
 677 public:
 678   /* Default construction takes SYMTAB as an argument.  */
 679   call_summary (symbol_table *symtab, bool ggc = false
 680                 CXX_MEM_STAT_INFO)
 681   : call_summary_base<T> (symtab, call_summary::symtab_removal,
 682                           call_summary::symtab_duplication PASS_MEM_STAT),
 683     m_ggc (ggc), m_map (13, ggc, true, GATHER_STATISTICS PASS_MEM_STAT) {}
 684
 685   /* Destructor.  */
 686   virtual ~call_summary ();
 687
 688   /* Traverses all summarys with an edge E called with
 689      ARG as argument.  */
 690   template<typename Arg, bool (*f)(const T &, Arg)>
 691   void traverse (Arg a) const
 692   {
 693     m_map.template traverse <f> (a);
 694   }
 695
 696   /* Getter for summary callgraph edge pointer.
 697      If a summary for an edge does not exist, it will be created.  */
 698   T* get_create (cgraph_edge *edge)
 699   {
 700     bool existed;
 701     T **v = &m_map.get_or_insert (edge->get_uid (), &existed);
 702     if (!existed)
 703       *v = this->allocate_new ();
 704
 705     return *v;
 706   }
 707
 708   /* Getter for summary callgraph edge pointer.  */
 709   T* get (cgraph_edge *edge) ATTRIBUTE_PURE
 710   {
 711     T **v = m_map.get (edge->get_uid ());
 712     return v == NULL ? NULL : *v;
 713   }
 714
 715   /* Remove edge from summary.  */
 716   using call_summary_base<T>::remove;
 717   void remove (cgraph_edge *edge)
 718   {
 719     int uid = edge->get_uid ();
 720     T **v = m_map.get (uid);
 721     if (v)
 722       {
 723         m_map.remove (uid);
 724         this->release (*v);
 725       }
 726   }
 727
 728   /* Return true if a summary for the given EDGE already exists.  */
 729   bool exists (cgraph_edge *edge)
 730   {
 731     return m_map.get (edge->get_uid ()) != NULL;
 732   }
 733
 734   /* Symbol removal hook that is registered to symbol table.  */
 735   static void symtab_removal (cgraph_edge *edge, void *data);
 736
 737   /* Symbol duplication hook that is registered to symbol table.  */
 738   static void symtab_duplication (cgraph_edge *edge1, cgraph_edge *edge2,
 739                                   void *data);
 740
 741 protected:
 742   /* Indication if we use ggc summary.  */
 743   bool m_ggc;
 744
 745 private:
 746   /* Indication if we use ggc summary.  */
 747   bool is_ggc () final override
 748   {
 749     return m_ggc;
 750   }
 751
 752   typedef int_hash <int, 0, -1> map_hash;
 753
 754   /* Main summary store, where summary ID is used as key.  */
 755   hash_map <map_hash, T *> m_map;
 756
 757   template <typename U> friend void gt_ggc_mx (call_summary <U *> * const &);
 758   template <typename U> friend void gt_pch_nx (call_summary <U *> * const &);
 759   template <typename U> friend void gt_pch_nx (call_summary <U *> * const &,
 760       gt_pointer_operator, void *);
 761 };
 762
 763 template <typename T>
 764 call_summary<T *>::~call_summary ()
 765 {
 766   this->unregister_hooks ();
 767
 768   /* Release all summaries.  */
 769   typedef typename hash_map <map_hash, T *>::iterator map_iterator;
 770   for (map_iterator it = m_map.begin (); it != m_map.end (); ++it)
 771     this->release ((*it).second);
 772 }
 773
 774 template <typename T>
 775 void
 776 call_summary<T *>::symtab_removal (cgraph_edge *edge, void *data)
 777 {
 778   call_summary *summary = (call_summary <T *> *) (data);
 779   summary->remove (edge);
 780 }
 781
 782 template <typename T>
 783 void
 784 call_summary<T *>::symtab_duplication (cgraph_edge *edge1,
 785                                        cgraph_edge *edge2, void *data)
 786 {
 787   call_summary *summary = (call_summary <T *> *) (data);
 788   T *edge1_summary = NULL;
 789
 790   if (summary->m_initialize_when_cloning)
 791     edge1_summary = summary->get_create (edge1);
 792   else
 793     edge1_summary = summary->get (edge1);
 794
 795   if (edge1_summary)
 796     summary->duplicate (edge1, edge2, edge1_summary,
 797                         summary->get_create (edge2));
 798 }
 799
 800 template <typename T>
 801 void
 802 gt_ggc_mx(call_summary<T *>* const &summary)
 803 {
 804   gcc_checking_assert (summary->m_ggc);
 805   gt_ggc_mx (&summary->m_map);
 806 }
 807
 808 template <typename T>
 809 void
 810 gt_pch_nx (call_summary<T *> *const &)
 811 {
 812   gcc_unreachable ();
 813 }
 814
 815 template <typename T>
 816 void
 817 gt_pch_nx (call_summary<T *> *const &, gt_pointer_operator, void *)
 818 {
 819   gcc_unreachable ();
 820 }
 821
 822 /* We want to pass just pointer types as argument for fast_call_summary
 823    template class.  */
 824
 825 template <class T, class V>
 826 class fast_call_summary
 827 {
 828 private:
 829   fast_call_summary ();
 830 };
 831
 832 /* Call vector summary is a fast implementation of call_summary that
 833    utilizes vector as primary storage of summaries.  */
 834
 835 template <class T, class V>
 836 class GTY((user)) fast_call_summary <T *, V>: public call_summary_base<T>
 837 {
 838 public:
 839   /* Default construction takes SYMTAB as an argument.  */
 840   fast_call_summary (symbol_table *symtab CXX_MEM_STAT_INFO)
 841   : call_summary_base<T> (symtab, fast_call_summary::symtab_removal,
 842                           fast_call_summary::symtab_duplication PASS_MEM_STAT),
 843     m_vector (NULL)
 844   {
 845     vec_alloc (m_vector, 13 PASS_MEM_STAT);
 846   }
 847
 848   /* Destructor.  */
 849   virtual ~fast_call_summary ();
 850
 851   /* Traverses all summarys with an edge F called with
 852      ARG as argument.  */
 853   template<typename Arg, bool (*f)(const T &, Arg)>
 854   void traverse (Arg a) const
 855   {
 856     for (unsigned i = 0; i < m_vector->length (); i++)
 857       if ((*m_vector[i]) != NULL)
 858         f ((*m_vector)[i], a);
 859   }
 860
 861   /* Getter for summary callgraph edge pointer.
 862      If a summary for an edge does not exist, it will be created.  */
 863   T* get_create (cgraph_edge *edge)
 864   {
 865     int id = edge->get_summary_id ();
 866     if (id == -1)
 867       id = this->m_symtab->assign_summary_id (edge);
 868
 869     if ((unsigned)id >= m_vector->length ())
 870       vec_safe_grow_cleared (m_vector, this->m_symtab->edges_max_summary_id);
 871
 872     if ((*m_vector)[id] == NULL)
 873       (*m_vector)[id] = this->allocate_new ();
 874
 875     return (*m_vector)[id];
 876   }
 877
 878   /* Getter for summary callgraph edge pointer.  */
 879   T* get (cgraph_edge *edge) ATTRIBUTE_PURE
 880   {
 881     return exists (edge) ? (*m_vector)[edge->get_summary_id ()] : NULL;
 882   }
 883
 884   /* Remove edge from summary.  */
 885   using call_summary_base<T>::remove;
 886   void remove (cgraph_edge *edge)
 887   {
 888     if (exists (edge))
 889       {
 890         int id = edge->get_summary_id ();
 891         this->release ((*m_vector)[id]);
 892         (*m_vector)[id] = NULL;
 893       }
 894   }
 895
 896   /* Return true if a summary for the given EDGE already exists.  */
 897   bool exists (cgraph_edge *edge)
 898   {
 899     int id = edge->get_summary_id ();
 900     return (id != -1
 901             && (unsigned)id < m_vector->length ()
 902             && (*m_vector)[id] != NULL);
 903   }
 904
 905   /* Symbol removal hook that is registered to symbol table.  */
 906   static void symtab_removal (cgraph_edge *edge, void *data);
 907
 908   /* Symbol duplication hook that is registered to symbol table.  */
 909   static void symtab_duplication (cgraph_edge *edge1, cgraph_edge *edge2,
 910                                   void *data);
 911
 912 private:
 913   bool is_ggc () final override;
 914
 915   /* Summary is stored in the vector.  */
 916   vec <T *, V> *m_vector;
 917
 918   template <typename U> friend void gt_ggc_mx (fast_call_summary <U *, va_gc> * const &);
 919   template <typename U> friend void gt_pch_nx (fast_call_summary <U *, va_gc> * const &);
 920   template <typename U> friend void gt_pch_nx (fast_call_summary <U *, va_gc> * const &,
 921       gt_pointer_operator, void *);
 922 };
 923
 924 template <typename T, typename V>
 925 fast_call_summary<T *, V>::~fast_call_summary ()
 926 {
 927   this->unregister_hooks ();
 928
 929   /* Release all summaries.  */
 930   for (unsigned i = 0; i < m_vector->length (); i++)
 931     if ((*m_vector)[i] != NULL)
 932       this->release ((*m_vector)[i]);
 933   vec_free (m_vector);
 934 }
 935
 936 template <typename T, typename V>
 937 void
 938 fast_call_summary<T *, V>::symtab_removal (cgraph_edge *edge, void *data)
 939 {
 940   fast_call_summary *summary = (fast_call_summary <T *, V> *) (data);
 941   summary->remove (edge);
 942 }
 943
 944 template <typename T, typename V>
 945 void
 946 fast_call_summary<T *, V>::symtab_duplication (cgraph_edge *edge1,
 947                                                  cgraph_edge *edge2, void *data)
 948 {
 949   fast_call_summary *summary = (fast_call_summary <T *, V> *) (data);
 950   T *edge1_summary = NULL;
 951
 952   if (summary->m_initialize_when_cloning)
 953     edge1_summary = summary->get_create (edge1);
 954   else
 955     edge1_summary = summary->get (edge1);
 956
 957   if (edge1_summary)
 958     {
 959       T *duplicate = summary->get_create (edge2);
 960       summary->duplicate (edge1, edge2, edge1_summary, duplicate);
 961     }
 962 }
 963
 964 template <typename T, typename V>
 965 inline bool
 966 fast_call_summary<T *, V>::is_ggc ()
 967 {
 968   return is_same<V, va_gc>::value;
 969 }
 970
 971 template <typename T>
 972 void
 973 gt_ggc_mx (fast_call_summary<T *, va_heap>* const &summary ATTRIBUTE_UNUSED)
 974 {
 975 }
 976
 977 template <typename T>
 978 void
 979 gt_pch_nx (fast_call_summary<T *, va_heap>* const &summary ATTRIBUTE_UNUSED)
 980 {
 981 }
 982
 983 template <typename T>
 984 void
 985 gt_pch_nx (fast_call_summary<T *, va_heap>* const& summary ATTRIBUTE_UNUSED,
 986            gt_pointer_operator op ATTRIBUTE_UNUSED,
 987            void *cookie ATTRIBUTE_UNUSED)
 988 {
 989 }
 990
 991 template <typename T>
 992 void
 993 gt_ggc_mx (fast_call_summary<T *, va_gc>* const &summary)
 994 {
 995   ggc_test_and_set_mark (summary->m_vector);
 996   gt_ggc_mx (&summary->m_vector);
 997 }
 998
 999 template <typename T>
1000 void
1001 gt_pch_nx (fast_call_summary<T *, va_gc> *const &)
1002 {
1003   gcc_unreachable ();
1004 }
1005
1006 template <typename T>
1007 void
1008 gt_pch_nx (fast_call_summary<T *, va_gc> *const &, gt_pointer_operator, void *)
1009 {
1010   gcc_unreachable ();
1011 }
1012
1013 #endif  /* GCC_SYMBOL_SUMMARY_H  */