libabigail
abg-comparison-priv.h
Go to the documentation of this file.
1 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
2 // -*- Mode: C++ -*-
3 //
4 // Copyright (C) 2017-2023 Red Hat, Inc.
5 //
6 // Author: Dodji Seketeli
7 
8 /// @file
9 ///
10 /// The private data and functions of the @ref abigail::ir::comparison types.
11 ///
12 /// Interfaces declared/defined in this file are to be used by parts
13 /// of libabigail but *NOT* by clients of libabigail.
14 ///
15 
16 #ifndef __ABG_COMPARISON_PRIV_H__
17 #define __ABG_COMPARISON_PRIV_H__
18 
19 #include "abg-internal.h"
20 // <headers defining libabigail's API go under here>
21 #include <memory>
22 #include <unordered_set>
23 ABG_BEGIN_EXPORT_DECLARATIONS
24 
25 #include "abg-hash.h"
26 #include "abg-suppression.h"
27 #include "abg-comparison.h"
28 #include "abg-comp-filter.h"
29 #include "abg-sptr-utils.h"
30 #include "abg-tools-utils.h"
31 
33 // </headers defining libabigail's API>
34 
35 namespace abigail
36 {
37 
38 namespace comparison
39 {
40 
41 using std::unordered_set;
42 using namespace abigail::suppr;
43 
44 // Inject types from outside in here.
45 using std::vector;
46 using std::dynamic_pointer_cast;
47 using std::static_pointer_cast;
49 
50 /// Convenience typedef for a pair of decls or types.
51 typedef std::pair<const type_or_decl_base_sptr,
52  const type_or_decl_base_sptr> types_or_decls_type;
53 
54 /// A hashing functor for @ref types_or_decls_type.
56 {
57  size_t
58  operator()(const types_or_decls_type& d) const
59  {
60  size_t h1 = hash_type_or_decl(d.first);
61  size_t h2 = hash_type_or_decl(d.second);
62  return hashing::combine_hashes(h1, h2);
63  }
64 };
65 
66 /// An equality functor for @ref types_or_decls_type.
68 {
69  bool
70  operator()(const types_or_decls_type &d1, const types_or_decls_type &d2) const
71  {return d1.first == d2.first && d1.second == d2.second;}
72 };
73 
74 /// A convenience typedef for a map of @ref types_or_decls_type and
75 /// diff_sptr.
76 typedef unordered_map<types_or_decls_type, diff_sptr,
79 
80 /// A hashing functor for using @ref diff_sptr and @ref diff* in a
81 /// hash map or set.
82 struct diff_hash
83 {
84  /// The function-call operator to hash a @ref diff node.
85  ///
86  /// @param d the @ref diff node to hash.
87  ///
88  /// @return the hash value of @p d.
89  size_t
90  operator()(const diff_sptr& d) const
91  {return operator()(*d);}
92 
93  /// The function-call operator to hash a @ref diff node.
94  ///
95  /// @param d the @ref diff node to hash.
96  ///
97  /// @return the hash value of @p d.
98  size_t
99  operator()(const diff *d) const
100  {return operator()(*d);}
101 
102  /// The function-call operator to hash a @ref diff node.
103  ///
104  /// @param d the @ref diff node to hash.
105  ///
106  /// @return the hash value of @p d.
107  size_t
108  operator()(const diff& d) const
109  {
110  diff* canonical_diff = d.get_canonical_diff();
111  ABG_ASSERT(canonical_diff);
112  return reinterpret_cast<size_t>(canonical_diff);
113  }
114 }; // end struct diff_hash
115 
116 /// A comparison functor for using @ref diff_sptr and @ref diff* in a
117 /// hash map or set.
119 {
120  /// The function-call operator to compare two @ref diff nodes.
121  ///
122  /// @param d1 the first diff node involved in the comparison.
123  ///
124  /// @param d2 the second diff node involved in the comparison.
125  ///
126  /// @return true iff @p d1 equals @p d2.
127  bool
128  operator()(const diff* d1, const diff* d2) const
129  {return operator()(*d1, *d2);}
130 
131  /// The function-call operator to compare two @ref diff nodes.
132  ///
133  /// @param d1 the first diff node involved in the comparison.
134  ///
135  /// @param d2 the second diff node involved in the comparison.
136  ///
137  /// @return true iff @p d1 equals @p d2.
138  bool
139  operator()(const diff_sptr& d1, const diff_sptr& d2) const
140  {return operator()(*d1, *d2);}
141 
142  /// The function-call operator to compare two @ref diff nodes.
143  ///
144  /// @param d1 the first diff node involved in the comparison.
145  ///
146  /// @param d2 the second diff node involved in the comparison.
147  ///
148  /// @return true iff @p d1 equals @p d2.
149  bool
150  operator()(const diff& d1, const diff& d2) const
151  {
152  diff* canonical_diff1 = d1.get_canonical_diff();
153  ABG_ASSERT(canonical_diff1);
154 
155  diff *canonical_diff2 = d2.get_canonical_diff();
156  ABG_ASSERT(canonical_diff2);
157 
158  return canonical_diff1 == canonical_diff2;
159  }
160 }; // end struct diff_equal
161 
162 /// A convenience typedef for an unordered_map which key is a @ref
163 /// diff* and which value is a @ref artifact_sptr_set_type.
164 typedef unordered_map<const diff*, artifact_sptr_set_type,
167 
168 /// The private member (pimpl) for @ref diff_context.
170 {
171  diff_category allowed_category_;
172  reporter_base_sptr reporter_;
173  types_or_decls_diff_map_type types_or_decls_diff_map;
174  unordered_diff_sptr_set live_diffs_;
175  vector<diff_sptr> canonical_diffs;
176  vector<filtering::filter_base_sptr> filters_;
177  // All the suppressions specifications are stored in this data
178  // member.
179  suppressions_type suppressions_;
180  // The negated suppressions specifications that are in
181  // suppressions_ are stored here. Each time suppressions_ is
182  // modified, this data member should be cleared.
183  suppressions_type negated_suppressions_;
184  // The non-negated suppressions specifications that are in
185  // suppressions_ are stored here. Each time suppressions_ is
186  // modified, this data member should be cleared.
187  suppressions_type direct_suppressions_;
188  pointer_map visited_diff_nodes_;
189  corpus_diff_sptr corpus_diff_;
190  ostream* default_output_stream_;
191  ostream* error_output_stream_;
192  bool perform_change_categorization_;
193  bool leaf_changes_only_;
194  bool forbid_visiting_a_node_twice_;
195  bool reset_visited_diffs_for_each_interface_;
196  bool hex_values_;
197  bool show_offsets_sizes_in_bits_;
198  bool show_relative_offset_changes_;
199  bool show_stats_only_;
200  bool show_soname_change_;
201  bool show_architecture_change_;
202  bool show_deleted_fns_;
203  bool show_changed_fns_;
204  bool show_added_fns_;
205  bool show_deleted_vars_;
206  bool show_changed_vars_;
207  bool show_added_vars_;
208  bool show_linkage_names_;
209  bool show_locs_;
210  bool show_redundant_changes_;
211  bool show_syms_unreferenced_by_di_;
212  bool show_added_syms_unreferenced_by_di_;
213  bool show_unreachable_types_;
214  bool show_impacted_interfaces_;
215  bool dump_diff_tree_;
216  bool do_log_;
217 
218  priv()
219  : allowed_category_(EVERYTHING_CATEGORY),
220  reporter_(),
221  default_output_stream_(),
222  error_output_stream_(),
223  perform_change_categorization_(true),
224  leaf_changes_only_(),
225  forbid_visiting_a_node_twice_(true),
226  reset_visited_diffs_for_each_interface_(),
227  hex_values_(),
228  show_offsets_sizes_in_bits_(true),
229  show_relative_offset_changes_(true),
230  show_stats_only_(false),
231  show_soname_change_(true),
232  show_architecture_change_(true),
233  show_deleted_fns_(true),
234  show_changed_fns_(true),
235  show_added_fns_(true),
236  show_deleted_vars_(true),
237  show_changed_vars_(true),
238  show_added_vars_(true),
239  show_linkage_names_(false),
240  show_locs_(true),
241  show_redundant_changes_(true),
242  show_syms_unreferenced_by_di_(true),
243  show_added_syms_unreferenced_by_di_(true),
244  show_unreachable_types_(false),
245  show_impacted_interfaces_(true),
246  dump_diff_tree_(),
247  do_log_()
248  {}
249 };// end struct diff_context::priv
250 
252 {
253 public:
254  friend class type_diff_base;
255 }; // end class type_diff_base
256 
257 /// Private data for the @ref diff type. The details of generic view
258 /// of the diff node are expressed here.
260 {
261  bool finished_;
262  bool traversing_;
263  type_or_decl_base_sptr first_subject_;
264  type_or_decl_base_sptr second_subject_;
265  vector<diff*> children_;
266  diff* parent_;
267  diff* parent_interface_;
268  diff* canonical_diff_;
269  diff_context_wptr ctxt_;
270  diff_category local_category_;
271  diff_category category_;
272  mutable bool reported_once_;
273  mutable bool currently_reporting_;
274  mutable string pretty_representation_;
275 
276  priv();
277 
278 public:
279 
280  priv(type_or_decl_base_sptr first_subject,
281  type_or_decl_base_sptr second_subject,
282  diff_context_sptr ctxt,
283  diff_category category,
284  bool reported_once,
285  bool currently_reporting)
286  : finished_(),
287  traversing_(),
288  first_subject_(first_subject),
289  second_subject_(second_subject),
290  parent_(),
291  parent_interface_(),
292  canonical_diff_(),
293  ctxt_(ctxt),
294  local_category_(category),
295  category_(category),
296  reported_once_(reported_once),
297  currently_reporting_(currently_reporting)
298  {}
299 
300  /// Getter of the diff context associated with this diff.
301  ///
302  /// @returnt a smart pointer to the diff context.
304  get_context() const
305  {return ctxt_.lock();}
306 
307  /// Check if a given categorization of a diff node should make it be
308  /// filtered out.
309  ///
310  /// @param category the categorization to take into account.
311  bool
313  {
314  diff_context_sptr ctxt = get_context();
315  if (!ctxt)
316  return false;
317 
318  if (ctxt->get_allowed_category() == EVERYTHING_CATEGORY)
319  return false;
320 
321  // If this node is on the path of a node that *must* be reported,
322  // then do not filter it.
326  return false;
327 
328  /// We don't want to display nodes suppressed by a user-provided
329  /// suppression specification or by a "private type" suppression
330  /// specification.
331  if (category & (SUPPRESSED_CATEGORY | PRIVATE_TYPE_CATEGORY))
332  return true;
333 
334  // We don't want to display redundant diff nodes, when the user
335  // asked to avoid seeing redundant diff nodes.
336  if (!ctxt->show_redundant_changes()
337  && (category & REDUNDANT_CATEGORY))
338  return true;
339 
340  if (category == NO_CHANGE_CATEGORY)
341  return false;
342 
343  // Ignore the REDUNDANT_CATEGORY bit when comparing allowed
344  // categories and the current set of categories.
345  return !((category & ~REDUNDANT_CATEGORY)
346  & (ctxt->get_allowed_category()
347  & ~REDUNDANT_CATEGORY));
348  }
349 };// end class diff::priv
350 
351 /// A functor to compare two instances of @ref diff_sptr.
353 {
354  /// An operator that takes two instances of @ref diff_sptr returns
355  /// true if its first operand compares less than its second operand.
356  ///
357  /// @param l the first operand to consider.
358  ///
359  /// @param r the second operand to consider.
360  ///
361  /// @return true if @p l compares less than @p r.
362  bool
363  operator()(const diff* l, const diff* r) const
364  {
365  if (!l || !r || !l->first_subject() || !r->first_subject())
366  return false;
367 
368  string l_qn = get_name(l->first_subject());
369  string r_qn = get_name(r->first_subject());
370 
371  return l_qn < r_qn;
372  }
373 
374  /// An operator that takes two instances of @ref diff_sptr returns
375  /// true if its first operand compares less than its second operand.
376  ///
377  /// @param l the first operand to consider.
378  ///
379  /// @param r the second operand to consider.
380  ///
381  /// @return true if @p l compares less than @p r.
382  bool
383  operator()(const diff_sptr& l, const diff_sptr& r) const
384  {return operator()(l.get(), r.get());}
385 }; // end struct diff_less_than_functor
386 
388 {
389 public:
390  friend class decl_diff_base;
391 };//end class priv
392 
393 /// The private data structure for @ref distinct_diff.
395 {
396  diff_sptr compatible_child_diff;
397 };// end struct distinct_diff
398 
399 /// The internal type for the impl idiom implementation of @ref
400 /// var_diff.
402 {
403  diff_wptr type_diff_;
404 };//end struct var_diff
405 
406 /// The internal type for the impl idiom implementation of @ref
407 /// pointer_diff.
409 {
410  diff_sptr underlying_type_diff_;
411 
412  priv(diff_sptr ud)
413  : underlying_type_diff_(ud)
414  {}
415 };//end struct pointer_diff::priv
416 
417 /// The internal type for the impl idiom implementation of @ref
418 /// subrange_diff.
420 {
421  diff_sptr underlying_type_diff_;
422 
423  priv(diff_sptr u)
424  : underlying_type_diff_(u)
425  {}
426 }; // end struct subrange_diff::priv
427 
429 {
430  /// The diff between the two array element types.
432 
433  priv(diff_sptr element_type_diff)
434  : element_type_diff_(element_type_diff)
435  {}
436 };//end struct array_diff::priv
437 
439 {
440  diff_sptr underlying_type_diff_;
441  priv(diff_sptr underlying)
442  : underlying_type_diff_(underlying)
443  {}
444 };//end struct reference_diff::priv
445 
446 /// The private data of the @ref ptr_to_mbr_diff type.
448 {
449  diff_sptr member_type_diff_;
450  diff_sptr containing_type_diff_;
451 
452  priv(const diff_sptr& member_type_diff,
453  const diff_sptr& containing_type_diff)
454  : member_type_diff_(member_type_diff),
455  containing_type_diff_(containing_type_diff)
456  {}
457 };//end ptr_to_mbr_diff::priv
458 
460 {
461  diff_sptr underlying_type_diff;
462  mutable diff_sptr leaf_underlying_type_diff;
463 
464  priv(diff_sptr underlying)
465  : underlying_type_diff(underlying)
466  {}
467 };// end struct qualified_type_diff::priv
468 
470 {
471  diff_sptr underlying_type_diff_;
472  edit_script enumerators_changes_;
473  string_enumerator_map deleted_enumerators_;
474  string_enumerator_map inserted_enumerators_;
475  string_changed_enumerator_map changed_enumerators_;
476 
477  priv(diff_sptr underlying)
478  : underlying_type_diff_(underlying)
479  {}
480 };//end struct enum_diff::priv
481 
482 /// A functor to compare two enumerators based on their value. This
483 /// implements the "less than" operator.
485 {
486  bool
487  operator()(const enum_type_decl::enumerator& f,
488  const enum_type_decl::enumerator& s) const
489  {return f.get_value() < s.get_value();}
490 };//end struct enumerator_value_comp
491 
492 /// A functor to compare two changed enumerators, based on their
493 /// initial value.
495 {
496  bool
497  operator()(const changed_enumerator& f,
498  const changed_enumerator& s) const
499  {return f.first.get_value() < s.first.get_value();}
500 };// end struct changed_enumerator_comp.
501 
502 /// The type of private data of @ref class_or_union_diff.
504 {
505  edit_script member_types_changes_;
506  edit_script data_members_changes_;
507  edit_script member_fns_changes_;
508  edit_script member_fn_tmpls_changes_;
509  edit_script member_class_tmpls_changes_;
510 
511  string_decl_base_sptr_map deleted_member_types_;
512  string_decl_base_sptr_map inserted_member_types_;
513  string_diff_sptr_map changed_member_types_;
514  diff_sptrs_type sorted_changed_member_types_;
515  string_decl_base_sptr_map deleted_data_members_;
516  unsigned_decl_base_sptr_map deleted_dm_by_offset_;
517  string_decl_base_sptr_map inserted_data_members_;
518  unsigned_decl_base_sptr_map inserted_dm_by_offset_;
519  // This map contains the data member which sub-type changed.
520  string_var_diff_sptr_map subtype_changed_dm_;
521  var_diff_sptrs_type sorted_subtype_changed_dm_;
522  // This one contains the list of data members changes that can be
523  // represented as a data member foo that got removed from offset N,
524  // and a data member bar that got inserted at offset N; IOW, this
525  // can be translated as data member foo that got changed into data
526  // member bar at offset N.
527  unsigned_var_diff_sptr_map changed_dm_;
528  var_diff_sptrs_type sorted_changed_dm_;
529 
530  // This is a data structure to represent data members that have been
531  // replaced by anonymous data members. It's a map that associates
532  // the name of the data member to the anonymous data member that
533  // replaced it.
534  string_decl_base_sptr_map dms_replaced_by_adms_;
535  mutable changed_var_sptrs_type dms_replaced_by_adms_ordered_;
536  string_member_function_sptr_map deleted_member_functions_;
537  class_or_union::member_functions sorted_deleted_member_functions_;
538  string_member_function_sptr_map inserted_member_functions_;
539  class_or_union::member_functions sorted_inserted_member_functions_;
540  string_function_decl_diff_sptr_map changed_member_functions_;
541  function_decl_diff_sptrs_type sorted_changed_member_functions_;
542  string_decl_base_sptr_map deleted_member_class_tmpls_;
543  string_decl_base_sptr_map inserted_member_class_tmpls_;
544  string_diff_sptr_map changed_member_class_tmpls_;
545  diff_sptrs_type sorted_changed_member_class_tmpls_;
546 
547  type_or_decl_base_sptr
548  member_type_has_changed(decl_base_sptr) const;
549 
550  decl_base_sptr
551  subtype_changed_dm(decl_base_sptr) const;
552 
553  decl_base_sptr
554  member_class_tmpl_has_changed(decl_base_sptr) const;
555 
556  size_t
557  get_deleted_non_static_data_members_number() const;
558 
559  size_t
560  get_inserted_non_static_data_members_number() const;
561 
562  size_t
563  count_filtered_subtype_changed_dm(bool local_only = false);
564 
565  size_t
566  count_filtered_changed_dm(bool local_only = false);
567 
568  size_t
569  count_filtered_changed_mem_fns(const diff_context_sptr&);
570 
571  size_t
572  count_filtered_inserted_mem_fns(const diff_context_sptr&);
573 
574  size_t
575  count_filtered_deleted_mem_fns(const diff_context_sptr&);
576 
577  priv()
578  {}
579 }; // end struct class_or_union_diff::priv
580 
581 /// A comparison functor to compare two data members based on their
582 /// offset.
584 {
585 
586  /// Compare two data members.
587  ///
588  /// First look at their offset and then their name.
589  ///
590  /// @parm first_dm the first data member to consider.
591  ///
592  /// @param second_dm the second data member to consider.
593  bool
595  const var_decl_sptr& second_dm) const
596  {
597  ABG_ASSERT(first_dm);
598  ABG_ASSERT(second_dm);
599 
600  size_t first_offset = get_data_member_offset(first_dm);
601  size_t second_offset = get_data_member_offset(second_dm);
602 
603  // The data member at the smallest offset comes first.
604  if (first_offset != second_offset)
605  return first_offset < second_offset;
606 
607  string first_dm_name = first_dm->get_name();
608  string second_dm_name = second_dm->get_name();
609 
610  // But in case the two data members are at the same offset, then
611  // sort them lexicographically.
612  return first_dm_name < second_dm_name;
613  }
614 
615  /// Compare two data members.
616  ///
617  /// First look at their offset and then their name.
618  ///
619  /// @parm first_dm the first data member to consider.
620  ///
621  /// @param second_dm the second data member to consider.
622  bool
623  operator()(const decl_base_sptr& f,
624  const decl_base_sptr& s) const
625  {
626  var_decl_sptr first_dm = is_data_member(f);
627  var_decl_sptr second_dm = is_data_member(s);
628 
629  return compare_data_members(first_dm, second_dm);
630  }
631 
632  /// Compare two data members.
633  ///
634  /// First look at their offset and then their name.
635  ///
636  /// @parm first_dm the first data member to consider.
637  ///
638  /// @param second_dm the second data member to consider.
639  bool
641  const changed_var_sptr& s) const
642  {
643  var_decl_sptr first_dm = is_data_member(is_decl(f.first));
644  var_decl_sptr second_dm = is_data_member(is_decl(s.first));
645 
646  return compare_data_members(first_dm, second_dm);
647  }
648 };//end struct data_member_comp
649 
650 /// The type of the private data (pimpl sub-object) of the @ref
651 /// class_diff type.
653 {
654  edit_script base_changes_;
655  string_base_sptr_map deleted_bases_;
656  class_decl::base_specs sorted_deleted_bases_;
657  string_base_sptr_map inserted_bases_;
658  class_decl::base_specs sorted_inserted_bases_;
659  string_base_diff_sptr_map changed_bases_;
660  base_diff_sptrs_type sorted_changed_bases_;
661  vector<class_decl::base_spec_sptr> moved_bases_;
662 
664  base_has_changed(class_decl::base_spec_sptr) const;
665 
666  size_t
667  count_filtered_bases();
668 
669  priv()
670  {}
671 };//end struct class_diff::priv
672 
673 /// A functor to compare instances of @ref class_decl::base_spec.
675 {
676  bool
677  operator()(const class_decl::base_spec&l,
678  const class_decl::base_spec&r)
679  {
680  string str1 = l.get_pretty_representation();
681  string str2 = r.get_pretty_representation();
682  return str1 < str2;
683  }
684  bool
685  operator()(const class_decl::base_spec_sptr&l,
687  {return operator()(*l, *r);}
688 }; // end base_spec_comp
689 
690 /// A comparison function for instances of @ref base_diff.
692 {
693  bool
694  operator()(const base_diff& l, const base_diff& r) const
695  {
697  if (f->get_offset_in_bits() >= 0
698  && s->get_offset_in_bits() >= 0)
699  return f->get_offset_in_bits() < s->get_offset_in_bits();
700  else
701  return (f->get_base_class()->get_pretty_representation()
702  < s->get_base_class()->get_pretty_representation());
703  }
704 
705  bool
706  operator()(const base_diff* l, const base_diff* r) const
707  {return operator()(*l, *r);}
708 
709  bool
710  operator()(const base_diff_sptr l, const base_diff_sptr r) const
711  {return operator()(l.get(), r.get());}
712 }; // end struct base_diff_comp
713 
714 /// A comparison functor to compare two instances of @ref var_diff
715 /// that represent changed data members based on the offset of the
716 /// initial data members, or if equal, based on their qualified name.
717 /// If equal again, then the offset and qualified name of the new data
718 /// members are considered.
720 {
721  /// @param f the first change to data member to take into account
722  ///
723  /// @param s the second change to data member to take into account.
724  ///
725  /// @return true iff f is before s.
726  bool
728  const var_diff_sptr s) const
729  {
730  var_decl_sptr first_dm = f->first_var();
731  var_decl_sptr second_dm = s->first_var();
732 
733  ABG_ASSERT(is_data_member(first_dm));
734  ABG_ASSERT(is_data_member(second_dm));
735 
736  size_t off1 = get_data_member_offset(first_dm);
737  size_t off2 = get_data_member_offset(second_dm);
738 
739  if (off1 != off2)
740  return off1 < off2;
741 
742  // The two offsets of the initial data members are the same. So
743  // lets compare the qualified name of these initial data members.
744 
745  string name1 = first_dm->get_qualified_name();
746  string name2 = second_dm->get_qualified_name();
747 
748  if (name1 != name2)
749  return name1 < name2;
750 
751  // The offsets and the qualified names of the initial data members
752  // are the same. Let's now compare the offsets of the *new* data
753  // members.
754 
755  first_dm = f->second_var();
756  second_dm = s->second_var();
757 
758  ABG_ASSERT(is_data_member(first_dm));
759  ABG_ASSERT(is_data_member(second_dm));
760 
761  off1 = get_data_member_offset(first_dm);
762  off2 = get_data_member_offset(second_dm);
763 
764  if (off1 != off2)
765  return off1 < off2;
766 
767  // The offsets of the new data members are the same, dang! Let's
768  // compare the qualified names of these new data members then.
769 
770  name1 = first_dm->get_qualified_name();
771  name2 = second_dm->get_qualified_name();
772 
773  return name1 < name2;
774  }
775 }; // end struct var_diff_comp
776 
777 bool
778 is_less_than(const function_decl_diff& first, const function_decl_diff& second);
779 
780 /// A comparison functor for instances of @ref function_decl_diff that
781 /// represent changes between two virtual member functions.
783 {
784  bool
785  operator()(const function_decl_diff& l,
786  const function_decl_diff& r) const
787  {
790 
793  if (l_offset != r_offset)
794  return l_offset < r_offset;
795 
796  return is_less_than(l, r);
797  }
798 
799  bool
800  operator()(const function_decl_diff* l,
801  const function_decl_diff* r)
802  {return operator()(*l, *r);}
803 
804  bool
805  operator()(const function_decl_diff_sptr l,
806  const function_decl_diff_sptr r)
807  {return operator()(l.get(), r.get());}
808 }; // end struct virtual_member_function_diff_comp
809 
811 {
812  class_diff_sptr underlying_class_diff_;
813 
814  priv(class_diff_sptr underlying)
815  : underlying_class_diff_(underlying)
816  {}
817 }; // end struct base_diff::priv
818 
820 {
821  // The edit script built by the function compute_diff.
822  edit_script member_changes_;
823 
824  // Below are the useful lookup tables.
825  //
826  // If you add a new lookup table, please update member functions
827  // clear_lookup_tables, lookup_tables_empty and
828  // ensure_lookup_tables_built.
829 
830  // The deleted/inserted types/decls. These basically map what is
831  // inside the member_changes_ data member. Note that for instance,
832  // a given type T might be deleted from the first scope and added to
833  // the second scope again; this means that the type was *changed*.
834  string_decl_base_sptr_map deleted_types_;
835  string_decl_base_sptr_map deleted_decls_;
836  string_decl_base_sptr_map inserted_types_;
837  string_decl_base_sptr_map inserted_decls_;
838 
839  // The changed types/decls lookup tables.
840  //
841  // These lookup tables are populated from the lookup tables above.
842  //
843  // Note that the value stored in each of these tables is a pair
844  // containing the old decl/type and the new one. That way it is
845  // easy to run a diff between the old decl/type and the new one.
846  //
847  // A changed type/decl is one that has been deleted from the first
848  // scope and that has been inserted into the second scope.
849  string_diff_sptr_map changed_types_;
850  diff_sptrs_type sorted_changed_types_;
851  string_diff_sptr_map changed_decls_;
852  diff_sptrs_type sorted_changed_decls_;
853 
854  // The removed types/decls lookup tables.
855  //
856  // A removed type/decl is one that has been deleted from the first
857  // scope and that has *NOT* been inserted into it again.
858  string_decl_base_sptr_map removed_types_;
859  string_decl_base_sptr_map removed_decls_;
860 
861  // The added types/decls lookup tables.
862  //
863  // An added type/decl is one that has been inserted to the first
864  // scope but that has not been deleted from it.
865  string_decl_base_sptr_map added_types_;
866  string_decl_base_sptr_map added_decls_;
867 };//end struct scope_diff::priv
868 
869 /// A comparison functor for instances of @ref diff.
870 struct diff_comp
871 {
872  /// Lexicographically compare two diff nodes.
873  ///
874  /// Compare the pretty representation of the first subjects of two
875  /// diff nodes.
876  ///
877  /// @return true iff @p l is less than @p r.
878  bool
879  operator()(const diff& l, diff& r) const
880  {
881  return (get_pretty_representation(l.first_subject(), true)
882  <
884  }
885 
886  /// Lexicographically compare two diff nodes.
887  ///
888  /// Compare the pretty representation of the first subjects of two
889  /// diff nodes.
890  ///
891  /// @return true iff @p l is less than @p r.
892  bool
893  operator()(const diff* l, diff* r) const
894  {return operator()(*l, *r);}
895 
896  /// Lexicographically compare two diff nodes.
897  ///
898  /// Compare the pretty representation of the first subjects of two
899  /// diff nodes.
900  ///
901  /// @return true iff @p l is less than @p r.
902  bool
903  operator()(const diff_sptr l, diff_sptr r) const
904  {return operator()(l.get(), r.get());}
905 }; // end struct diff_comp;
906 
908 {
909  mutable diff_sptr type_diff;
910 }; // end struct fn_parm_diff::priv
911 
913 {
914  diff_sptr return_type_diff_;
915  edit_script parm_changes_;
916 
917  // useful lookup tables.
918  string_parm_map deleted_parms_;
919  vector<function_decl::parameter_sptr> sorted_deleted_parms_;
920  string_parm_map added_parms_;
921  vector<function_decl::parameter_sptr> sorted_added_parms_;
922  // This map contains parameters sub-type changes that don't change
923  // the name of the type of the parameter.
924  string_fn_parm_diff_sptr_map subtype_changed_parms_;
925  vector<fn_parm_diff_sptr> sorted_subtype_changed_parms_;
926  // This map contains parameter type changes that actually change the
927  // name of the type of the parameter, but in a compatible way;
928  // otherwise, the mangling of the function would have changed (in
929  // c++ at least).
930  unsigned_fn_parm_diff_sptr_map changed_parms_by_id_;
931  vector<fn_parm_diff_sptr> sorted_changed_parms_by_id_;
932  unsigned_parm_map deleted_parms_by_id_;
933  unsigned_parm_map added_parms_by_id_;
934 
935  priv()
936  {}
937 }; // end struct function_type_diff::priv
938 
940 {
941  function_type_diff_sptr type_diff_;
942 
943  priv()
944  {}
945 };// end struct function_decl_diff::priv
946 
947 /// A comparison functor to compare two instances of @ref fn_parm_diff
948 /// based on their indexes.
950 {
951  /// @param f the first diff
952  ///
953  /// @param s the second diff
954  ///
955  /// @return true if the index of @p f is less than the index of @p
956  /// s.
957  bool
959  {return f.first_parameter()->get_index() < s.first_parameter()->get_index();}
960 
961  bool
962  operator()(const fn_parm_diff_sptr& f, const fn_parm_diff_sptr& s)
963  {return operator()(*f, *s);}
964 }; // end struct fn_parm_diff_comp
965 
966 /// Functor that compares two function parameters for the purpose of
967 /// sorting them.
968 struct parm_comp
969 {
970  /// Returns true iff the index of the first parameter is smaller
971  /// than the of the second parameter.
972  ///
973  /// @param l the first parameter to compare.
974  ///
975  /// @param r the second parameter to compare.
976  ///
977  /// @return true iff the index of the first parameter is smaller
978  /// than the of the second parameter.
979  bool
981  const function_decl::parameter& r)
982  {return l.get_index() < r.get_index();}
983 
984  /// Returns true iff the index of the first parameter is smaller
985  /// than the of the second parameter.
986  ///
987  /// @param l the first parameter to compare.
988  ///
989  /// @param r the second parameter to compare.
990  ///
991  /// @return true iff the index of the first parameter is smaller
992  /// than the of the second parameter.
993  bool
996  {return operator()(*l, *r);}
997 }; // end struct parm_comp
998 
999 /// A functor to compare instances of @ref var_decl base on their
1000 /// qualified names.
1001 struct var_comp
1002 {
1003  bool
1004  operator() (const var_decl& l, const var_decl& r) const
1005  {
1006  string name1 = l.get_qualified_name(), name2 = r.get_qualified_name();
1007  return name1 < name2;
1008  }
1009 
1010  bool
1011  operator() (const var_decl* l, const var_decl* r) const
1012  {return operator()(*l, *r);}
1013 };// end struct var_comp
1014 
1015 /// A functor to compare instances of @ref elf_symbol base on their
1016 /// names.
1018 {
1019  bool
1020  operator()(const elf_symbol& l, const elf_symbol& r)
1021  {
1022  string name1 = l.get_id_string(), name2 = r.get_id_string();
1023  return name1 < name2;
1024  }
1025 
1026  bool
1027  operator()(const elf_symbol* l, const elf_symbol* r)
1028  {return operator()(*l, *r);}
1029 
1030  bool
1031  operator()(const elf_symbol_sptr& l, const elf_symbol_sptr& r)
1032  {return operator()(l.get(), r.get());}
1033 }; //end struct elf_symbol_comp
1034 
1036 {
1037  diff_sptr underlying_type_diff_;
1038 
1039  priv(const diff_sptr underlying_type_diff)
1040  : underlying_type_diff_(underlying_type_diff)
1041  {}
1042 };//end struct typedef_diff::priv
1043 
1045 {
1046  translation_unit_sptr first_;
1047  translation_unit_sptr second_;
1048 
1050  : first_(f), second_(s)
1051  {}
1052 };//end struct translation_unit_diff::priv
1053 
1055 {
1056  bool finished_;
1057  string pretty_representation_;
1058  vector<diff*> children_;
1059  corpus_sptr first_;
1060  corpus_sptr second_;
1061  diff_context_wptr ctxt_;
1062  corpus_diff::diff_stats_sptr diff_stats_;
1063  bool sonames_equal_;
1064  bool architectures_equal_;
1065  edit_script fns_edit_script_;
1066  edit_script vars_edit_script_;
1067  edit_script unrefed_fn_syms_edit_script_;
1068  edit_script unrefed_var_syms_edit_script_;
1069  string_function_ptr_map deleted_fns_;
1070  string_function_ptr_map suppressed_deleted_fns_;
1071  string_function_ptr_map added_fns_;
1072  string_function_ptr_map suppressed_added_fns_;
1073  string_function_decl_diff_sptr_map changed_fns_map_;
1074  function_decl_diff_sptrs_type changed_fns_;
1075  string_var_ptr_map deleted_vars_;
1076  string_var_ptr_map suppressed_deleted_vars_;
1077  string_var_ptr_map added_vars_;
1078  string_var_ptr_map suppressed_added_vars_;
1079  string_var_diff_sptr_map changed_vars_map_;
1080  var_diff_sptrs_type sorted_changed_vars_;
1081  string_elf_symbol_map added_unrefed_fn_syms_;
1082  string_elf_symbol_map suppressed_added_unrefed_fn_syms_;
1083  string_elf_symbol_map deleted_unrefed_fn_syms_;
1084  string_elf_symbol_map suppressed_deleted_unrefed_fn_syms_;
1085  string_elf_symbol_map added_unrefed_var_syms_;
1086  string_elf_symbol_map suppressed_added_unrefed_var_syms_;
1087  string_elf_symbol_map deleted_unrefed_var_syms_;
1088  string_elf_symbol_map suppressed_deleted_unrefed_var_syms_;
1089  edit_script unreachable_types_edit_script_;
1090  string_type_base_sptr_map deleted_unreachable_types_;
1091  vector<type_base_sptr> deleted_unreachable_types_sorted_;
1092  string_type_base_sptr_map suppressed_deleted_unreachable_types_;
1093  string_type_base_sptr_map added_unreachable_types_;
1094  vector<type_base_sptr> added_unreachable_types_sorted_;
1095  string_type_base_sptr_map suppressed_added_unreachable_types_;
1096  string_diff_sptr_map changed_unreachable_types_;
1097  mutable vector<diff_sptr> changed_unreachable_types_sorted_;
1098  diff_maps leaf_diffs_;
1099 
1100  /// Default constructor of corpus_diff::priv.
1102  : finished_(false),
1103  sonames_equal_(false),
1104  architectures_equal_(false)
1105  {}
1106 
1107  /// Constructor of corpus_diff::priv.
1108  ///
1109  /// @param first the first corpus of this diff.
1110  ///
1111  /// @param second the second corpus of this diff.
1112  ///
1113  /// @param ctxt the context of the diff.
1114  priv(corpus_sptr first,
1115  corpus_sptr second,
1116  diff_context_sptr ctxt)
1117  : finished_(false),
1118  first_(first),
1119  second_(second),
1120  ctxt_(ctxt),
1121  sonames_equal_(false),
1122  architectures_equal_(false)
1123  {}
1124 
1126  get_context();
1127 
1128  bool
1129  lookup_tables_empty() const;
1130 
1131  void
1132  clear_lookup_tables();
1133 
1134  void
1135  ensure_lookup_tables_populated();
1136 
1137  void
1138  apply_supprs_to_added_removed_fns_vars_unreachable_types();
1139 
1140  bool
1141  deleted_function_is_suppressed(const function_decl* fn) const;
1142 
1143  bool
1144  added_function_is_suppressed(const function_decl* fn) const;
1145 
1146  bool
1147  deleted_variable_is_suppressed(const var_decl* var) const;
1148 
1149  bool
1150  added_variable_is_suppressed(const var_decl* var) const;
1151 
1152  bool
1153  added_unreachable_type_is_suppressed(const type_base *t)const ;
1154 
1155  bool
1156  deleted_unreachable_type_is_suppressed(const type_base *t)const ;
1157 
1158  bool
1159  deleted_unrefed_fn_sym_is_suppressed(const elf_symbol*) const;
1160 
1161  bool
1162  added_unrefed_fn_sym_is_suppressed(const elf_symbol*) const;
1163 
1164  bool
1165  deleted_unrefed_var_sym_is_suppressed(const elf_symbol*) const;
1166 
1167  bool
1168  added_unrefed_var_sym_is_suppressed(const elf_symbol*) const;
1169 
1170  void count_leaf_changes(size_t &num_changes, size_t &num_filtered);
1171 
1172  void count_leaf_type_changes(size_t &num_type_changes,
1173  size_t &num_type_changes_filtered);
1174 
1175  void count_unreachable_types(size_t &num_added,
1176  size_t &num_removed,
1177  size_t &num_changed,
1178  size_t &num_filtered_added,
1179  size_t &num_filtered_removed,
1180  size_t &num_filtered_changed);
1181 
1182  const string_diff_sptr_map&
1183  changed_unreachable_types() const;
1184 
1185  const vector<diff_sptr>&
1186  changed_unreachable_types_sorted() const;
1187 
1188  void
1189  apply_filters_and_compute_diff_stats(corpus_diff::diff_stats&);
1190 
1191  void
1192  emit_diff_stats(const diff_stats& stats,
1193  ostream& out,
1194  const string& indent);
1195 
1196  void
1197  categorize_redundant_changed_sub_nodes();
1198 
1199  void
1201 
1202  void
1203  maybe_dump_diff_tree();
1204 }; // end corpus::priv
1205 
1206 /// "Less than" functor to compare instances of @ref function_decl.
1208 {
1209  /// The actual "less than" operator for instances of @ref
1210  /// function_decl. It returns true if the first @ref function_decl
1211  /// is lest than the second one.
1212  ///
1213  /// @param f the first @ref function_decl to take in account.
1214  ///
1215  /// @param s the second @ref function_decl to take in account.
1216  ///
1217  /// @return true iff @p f is less than @p s.
1218  bool
1221 
1222  /// The actual "less than" operator for instances of @ref
1223  /// function_decl. It returns true if the first @ref function_decl
1224  /// is lest than the second one.
1225  ///
1226  /// @param f the first @ref function_decl to take in account.
1227  ///
1228  /// @param s the second @ref function_decl to take in account.
1229  ///
1230  /// @return true iff @p f is less than @p s.
1231  bool
1233  {return operator()(*f, *s);}
1234 
1235  /// The actual "less than" operator for instances of @ref
1236  /// function_decl. It returns true if the first @ref function_decl
1237  /// is lest than the second one.
1238  ///
1239  /// @param f the first @ref function_decl to take in account.
1240  ///
1241  /// @param s the second @ref function_decl to take in account.
1242  ///
1243  /// @return true iff @p f is less than @p s.
1244  bool
1246  {return operator()(f.get(), s.get());}
1247 }; // end function_comp
1248 
1249 /// A "Less Than" functor to compare instance of @ref
1250 /// function_decl_diff.
1252 {
1253  /// The actual less than operator.
1254  ///
1255  /// It returns true if the first @ref function_decl_diff is less
1256  /// than the second one.
1257  ///
1258  /// param first the first @ref function_decl_diff to consider.
1259  ///
1260  /// @param second the second @ref function_decl_diff to consider.
1261  ///
1262  /// @return true iff @p first is less than @p second.
1263  bool
1265  const function_decl_diff& second)
1266  {
1267  return is_less_than(first, second);
1268  }
1269 
1270  /// The actual less than operator.
1271  ///
1272  /// It returns true if the first @ref function_decl_diff_sptr is
1273  /// less than the second one.
1274  ///
1275  /// param first the first @ref function_decl_diff_sptr to consider.
1276  ///
1277  /// @param second the second @ref function_decl_diff_sptr to
1278  /// consider.
1279  ///
1280  /// @return true iff @p first is less than @p second.
1281  bool
1283  const function_decl_diff_sptr second)
1284  {return operator()(*first, *second);}
1285 }; // end struct function_decl_diff_comp
1286 
1287 /// Functor to sort instances of @ref var_diff_sptr
1289 {
1290  /// Return true if the first argument is less than the second one.
1291  ///
1292  /// @param f the first argument to consider.
1293  ///
1294  /// @param s the second argument to consider.
1295  ///
1296  /// @return true if @p f is less than @p s.
1297  bool
1299  const var_diff_sptr s)
1300  {
1301  return (f->first_var()->get_qualified_name()
1302  < s->first_var()->get_qualified_name());
1303  }
1304 }; // end struct var_diff_sptr_comp
1305 
1306 /// The type of the private data of corpus_diff::diff_stats.
1308 {
1309  friend class corpus_diff::diff_stats;
1310 
1311  diff_context_wptr ctxt_;
1312  size_t num_func_removed;
1313  size_t num_removed_func_filtered_out;
1314  size_t num_func_added;
1315  size_t num_added_func_filtered_out;
1316  size_t num_func_changed;
1317  size_t num_changed_func_filtered_out;
1318  size_t num_func_with_virt_offset_changes;
1319  size_t num_vars_removed;
1320  size_t num_removed_vars_filtered_out;
1321  size_t num_vars_added;
1322  size_t num_added_vars_filtered_out;
1323  size_t num_vars_changed;
1324  size_t num_changed_vars_filtered_out;
1325  size_t num_func_syms_removed;
1326  size_t num_removed_func_syms_filtered_out;
1327  size_t num_func_syms_added;
1328  size_t num_added_func_syms_filtered_out;
1329  size_t num_var_syms_removed;
1330  size_t num_removed_var_syms_filtered_out;
1331  size_t num_var_syms_added;
1332  size_t num_added_var_syms_filtered_out;
1333  size_t num_leaf_changes;
1334  size_t num_leaf_changes_filtered_out;
1335  size_t num_leaf_type_changes;
1336  size_t num_leaf_type_changes_filtered_out;
1337  size_t num_leaf_func_changes;
1338  size_t num_leaf_func_changes_filtered_out;
1339  size_t num_leaf_var_changes;
1340  size_t num_leaf_var_changes_filtered_out;
1341  size_t num_added_unreachable_types;
1342  size_t num_added_unreachable_types_filtered_out;
1343  size_t num_removed_unreachable_types;
1344  size_t num_removed_unreachable_types_filtered_out;
1345  size_t num_changed_unreachable_types;
1346  size_t num_changed_unreachable_types_filtered_out;
1347 
1348  priv(diff_context_sptr ctxt)
1349  : ctxt_(ctxt),
1350  num_func_removed(),
1351  num_removed_func_filtered_out(),
1352  num_func_added(),
1353  num_added_func_filtered_out(),
1354  num_func_changed(),
1355  num_changed_func_filtered_out(),
1356  num_func_with_virt_offset_changes(),
1357  num_vars_removed(),
1358  num_removed_vars_filtered_out(),
1359  num_vars_added(),
1360  num_added_vars_filtered_out(),
1361  num_vars_changed(),
1362  num_changed_vars_filtered_out(),
1363  num_func_syms_removed(),
1364  num_removed_func_syms_filtered_out(),
1365  num_func_syms_added(),
1366  num_added_func_syms_filtered_out(),
1367  num_var_syms_removed(),
1368  num_removed_var_syms_filtered_out(),
1369  num_var_syms_added(),
1370  num_added_var_syms_filtered_out(),
1371  num_leaf_changes(),
1372  num_leaf_changes_filtered_out(),
1373  num_leaf_type_changes(),
1374  num_leaf_type_changes_filtered_out(),
1375  num_leaf_func_changes(),
1376  num_leaf_func_changes_filtered_out(),
1377  num_leaf_var_changes(),
1378  num_leaf_var_changes_filtered_out(),
1379  num_added_unreachable_types(),
1380  num_added_unreachable_types_filtered_out(),
1381  num_removed_unreachable_types(),
1382  num_removed_unreachable_types_filtered_out(),
1383  num_changed_unreachable_types(),
1384  num_changed_unreachable_types_filtered_out()
1385  {}
1386 
1388  ctxt()
1389  {return ctxt_.lock();}
1390 }; // end class corpus_diff::diff_stats::priv
1391 
1392 void
1393 sort_enumerators(const string_enumerator_map& enumerators_map,
1394  enum_type_decl::enumerators& sorted);
1395 
1396 void
1398  changed_enumerators_type& sorted);
1399 
1400 void
1401 sort_data_members(const string_decl_base_sptr_map &data_members,
1402  vector<decl_base_sptr>& sorted);
1403 
1404 void
1406 
1407 void
1409  vector<const function_decl*>& sorted);
1410 
1411 void
1414 
1415 void
1417  vector<type_base_sptr>& sorted);
1418 
1419 void
1423 
1424 void
1426  var_diff_sptrs_type& sorted);
1427 
1428 void
1430  vector<elf_symbol_sptr>& sorted);
1431 
1432 void
1434  vector<const var_decl*>& sorted);
1435 
1436 void
1438  var_diff_sptrs_type& sorted);
1439 
1440 void
1442  var_diff_sptrs_type& sorted);
1443 
1444 void
1448 
1449 void
1451  diff_sptrs_type& sorted);
1452 
1453 void
1455  diff_ptrs_type& sorted);
1456 
1457 void
1459  base_diff_sptrs_type& sorted);
1460 
1461 void
1463  class_decl::base_specs& sorted);
1464 
1465 void
1467  vector<fn_parm_diff_sptr>& sorted);
1468 void
1470  vector<fn_parm_diff_sptr>& sorted);
1471 void
1473  vector<function_decl::parameter_sptr>& sorted);
1474 
1475 void
1476 sort_artifacts_set(const artifact_sptr_set_type& set,
1477  vector<type_or_decl_base_sptr>& sorted);
1478 
1479 type_base_sptr
1480 get_leaf_type(qualified_type_def_sptr t);
1481 
1482 diff*
1483 get_fn_decl_or_var_decl_diff_ancestor(const diff *);
1484 
1485 bool
1486 is_diff_of_global_decls(const diff*);
1487 
1488 } // end namespace comparison
1489 
1490 } // namespace abigail
1491 
1492 #endif // __ABG_COMPARISON_PRIV_H__
vector< diff * > diff_ptrs_type
Convenience typedef for a vector of diff*.
std::pair< var_decl_sptr, var_decl_sptr > changed_var_sptr
Convenience typedef for a pair of var_decl_sptr representing a var_decl change. The first member of t...
A comparison function for instances of base_diff.
priv()
Default constructor of corpus_diff::priv.
bool operator()(const diff *l, const diff *r) const
An operator that takes two instances of diff_sptr returns true if its first operand compares less tha...
bool get_member_function_is_virtual(const function_decl &f)
Test if a given member function is virtual.
Definition: abg-ir.cc:6882
void sort_enumerators(const string_enumerator_map &enumerators_map, enum_type_decl::enumerators &sorted)
Sort a map of enumerators by their value.
shared_ptr< function_type_diff > function_type_diff_sptr
A convenience typedef for a shared pointer to function_type_type_diff.
A comparison functor for instances of diff.
vector< function_decl_diff_sptr > function_decl_diff_sptrs_type
Convenience typedef for a vector of function_decl_diff_sptr.
The private data of the ptr_to_mbr_diff type.
A "Less Than" functor to compare instance of function_decl_diff.
void sort_string_member_function_sptr_map(const string_member_function_sptr_map &map, class_or_union::member_functions &sorted)
Sort a map that's an instance of string_member_function_sptr_map and fill a vector of member function...
This header declares filters for the diff trees resulting from comparing ABI Corpora.
bool operator()(const diff_sptr l, diff_sptr r) const
Lexicographically compare two diff nodes.
The abstraction of a change between two ABI artifacts, a.k.a an artifact change.
shared_ptr< class_diff > class_diff_sptr
Convenience typedef for a shared pointer on a class_diff type.
vector< var_diff_sptr > var_diff_sptrs_type
Convenience typedef for a vector of var_diff_sptr.
const function_decl_sptr first_function_decl() const
The internal type for the impl idiom implementation of pointer_diff.
bool operator()(const diff *d1, const diff *d2) const
The function-call operator to compare two diff nodes.
bool is_data_member(const var_decl &v)
Test if a var_decl is a data member.
Definition: abg-ir.cc:5854
virtual string get_pretty_representation(bool internal=false, bool qualified_name=true) const
Get the pretty representatin of the current declaration.
Definition: abg-ir.cc:5086
Utilities to ease the wrapping of C types into std::shared_ptr.
An equality functor for types_or_decls_type.
bool operator()(const var_diff_sptr f, const var_diff_sptr s)
Return true if the first argument is less than the second one.
void sort_string_var_diff_sptr_map(const string_var_diff_sptr_map &map, var_diff_sptrs_type &sorted)
Sort of an instance of string_var_diff_sptr_map map.
bool operator()(const function_decl *f, const function_decl *s)
The actual "less than" operator for instances of function_decl. It returns true if the first function...
vector< changed_var_sptr > changed_var_sptrs_type
Convenience typedef for a vector of .gg381.
A special enumerator that is the logical 'or' all the enumerators above.
An abstraction helper for type declarations.
Definition: abg-ir.h:1972
A functor to compare instances of elf_symbol base on their names.
size_t operator()(const diff &d) const
The function-call operator to hash a diff node.
void clear_redundancy_categorization(diff *diff_tree)
Walk a given diff sub-tree to clear the REDUNDANT_CATEGORY out of the category of the nodes...
This means that a diff node was marked as suppressed by a user-provided suppression specification...
void sort_string_data_member_diff_sptr_map(const string_var_diff_sptr_map &map, var_diff_sptrs_type &sorted)
Sort the values of a string_var_diff_sptr_map and store the result in a vector of var_diff_sptr...
bool operator()(const var_diff_sptr f, const var_diff_sptr s) const
type_or_decl_base_sptr first_subject() const
Getter of the first subject of the diff.
This means the diff node does not carry any (meaningful) change, or that it carries changes that have...
Abstraction of a base specifier in a class declaration.
Definition: abg-ir.h:4426
unordered_map< string, const var_decl * > string_var_ptr_map
Convenience typedef for a map which key is a string and which value is a point to var_decl...
unordered_map< string, class_decl::base_spec_sptr > string_base_sptr_map
Convenience typedef for a map of string and class_decl::basse_spec_sptr.
shared_ptr< diff_context > diff_context_sptr
Convenience typedef for a shared pointer of diff_context.
Definition: abg-fwd.h:68
ssize_t get_member_function_vtable_offset(const function_decl &f)
Get the vtable offset of a member function.
Definition: abg-ir.cc:6819
void sort_data_members(const string_decl_base_sptr_map &data_members, vector< decl_base_sptr > &sorted)
Sort a map of data members by the offset of their initial value.
bool operator()(const function_decl &f, const function_decl &s)
The actual "less than" operator for instances of function_decl. It returns true if the first function...
bool compare_data_members(const var_decl_sptr &first_dm, const var_decl_sptr &second_dm) const
Compare two data members.
shared_ptr< var_decl > var_decl_sptr
Convenience typedef for a shared pointer on a var_decl.
Definition: abg-fwd.h:254
A diff node in this category has a parent node that is in the HAS_ALLOWED_CHANGE_CATEGORY category...
bool operator()(const fn_parm_diff &f, const fn_parm_diff &s)
class_decl::base_spec_sptr first_base() const
Getter for the first base spec of the diff object.
shared_ptr< translation_unit > translation_unit_sptr
Convenience typedef for a shared pointer on a translation_unit type.
Definition: abg-fwd.h:134
Abstraction of a diff between two function_decl.
void sort_string_diff_sptr_map(const string_diff_sptr_map &map, diff_sptrs_type &sorted)
Sort a map ofg string -> diff_sptr into a vector of diff_sptr. The diff_sptr are sorted lexicographic...
unordered_map< string, diff * > string_diff_ptr_map
Convenience typedef for a map which value is a diff*. The key of the map is the qualified name of the...
unordered_set< diff_sptr, diff_sptr_hasher > unordered_diff_sptr_set
Convenience typedef for an unoredered set of diff_sptr.
unordered_map< string, decl_base_sptr > string_decl_base_sptr_map
Convenience typedef for a map which key is a string and which value is a decl_base_sptr.
Definition: abg-fwd.h:158
Abstracts a variable declaration.
Definition: abg-ir.h:3007
void sort_string_elf_symbol_map(const string_elf_symbol_map &map, vector< elf_symbol_sptr > &sorted)
Sort a map of string -> pointer to elf_symbol.
The private data structure for distinct_diff.
void sort_string_parm_map(const string_parm_map &map, vector< function_decl::parameter_sptr > &sorted)
Sort a map of string -> function parameters.
A functor to compare instances of var_decl base on their qualified names.
diff_context_sptr get_context() const
Getter of the diff context associated with this diff.
bool is_diff_of_global_decls(const diff *)
Tests if a given diff node is to represent the changes between two gobal decls.
Abstraction of a function parameter.
Definition: abg-ir.h:3285
The base class of diff between decls.
The base class of diff between types.
bool operator()(const function_decl_diff &first, const function_decl_diff &second)
The actual less than operator.
unordered_map< string, var_diff_sptr > string_var_diff_sptr_map
Convenience typedef for a map whose key is a string and whose value is a changed variable of type var...
unordered_map< string, base_diff_sptr > string_base_diff_sptr_map
Convenience typedef for a map of string and base_diff_sptr.
unordered_map< string, elf_symbol_sptr > string_elf_symbol_map
Convenience typedef for a map whose key is a string and whose value is an elf_symbol_sptr.
The internal type for the impl idiom implementation of subrange_diff.
std::vector< enumerator > enumerators
Convenience typedef for a list of enumerator.
Definition: abg-ir.h:2763
unordered_map< unsigned, fn_parm_diff_sptr > unsigned_fn_parm_diff_sptr_map
Convenience typedef for a map which key is an integer and which value is a changed parameter...
void sort_string_base_diff_sptr_map(const string_base_diff_sptr_map &map, base_diff_sptrs_type &sorted)
Sort a map of string -> base_diff_sptr into a sorted vector of base_diff_sptr. The base_diff_sptr are...
A functor to compare instances of class_decl::base_spec.
A functor to compare two instances of diff_sptr.
void sort_unsigned_data_member_diff_sptr_map(const unsigned_var_diff_sptr_map map, var_diff_sptrs_type &sorted)
Sort the values of a unsigned_var_diff_sptr_map map and store the result into a vector of var_diff_sp...
vector< changed_enumerator > changed_enumerators_type
Convenience typedef for a vector of changed enumerators.
uint64_t get_data_member_offset(const var_decl &m)
Get the offset of a data member.
Definition: abg-ir.cc:6425
diff_category
An enum for the different categories that a diff tree node falls into, regarding the kind of changes ...
Toplevel namespace for libabigail.
bool operator()(const changed_var_sptr &f, const changed_var_sptr &s) const
Compare two data members.
unordered_set< type_or_decl_base_sptr, type_or_decl_hash, type_or_decl_equal > artifact_sptr_set_type
A convenience typedef for a hash set of type_or_decl_base_sptr.
Definition: abg-ir.h:550
unordered_map< string, changed_enumerator > string_changed_enumerator_map
Convenience typedef for a map which value is a changed enumerator. The key is the name of the changed...
An abstraction of a diff between two instances of class_decl::base_spec.
size_t operator()(const diff_sptr &d) const
The function-call operator to hash a diff node.
shared_ptr< function_decl > function_decl_sptr
Convenience typedef for a shared pointer on a function_decl.
Definition: abg-fwd.h:267
decl_base * is_decl(const type_or_decl_base *d)
Test if an ABI artifact is a declaration.
Definition: abg-ir.cc:10605
type_base_sptr get_leaf_type(qualified_type_def_sptr t)
Return the first underlying type that is not a qualified type.
virtual const interned_string & get_qualified_name(bool internal=false) const
Get the qualified name of a given variable or data member.
Definition: abg-ir.cc:21092
void sort_string_base_sptr_map(const string_base_sptr_map &m, class_decl::base_specs &sorted)
Lexicographically sort base specifications found in instances of string_base_sptr_map.
shared_ptr< parameter > parameter_sptr
Convenience typedef for a shared pointer on a function_decl::parameter.
Definition: abg-ir.h:3131
The type of the private data of corpus_diff::diff_stats.
shared_ptr< diff_stats > diff_stats_sptr
A convenience typedef for a shared pointer to diff_stats.
size_t hash_type_or_decl(const type_or_decl_base *tod)
Hash an ABI artifact that is either a type or a decl.
Definition: abg-ir.cc:27845
shared_ptr< base_spec > base_spec_sptr
Convenience typedef.
Definition: abg-ir.h:4245
diff_sptr element_type_diff_
The diff between the two array element types.
unordered_map< string, type_base_sptr > string_type_base_sptr_map
Convenience typedef for a map which key is a string and which value is a type_base_sptr.
This means that a diff node was warked as being for a private type. That is, the diff node is meant t...
Abstraction of a diff between two function parameters.
const function_decl::parameter_sptr first_parameter() const
Getter for the first subject of this diff node.
Abstraction for a function declaration.
Definition: abg-ir.h:3110
bool operator()(const diff &l, diff &r) const
Lexicographically compare two diff nodes.
unordered_map< string, diff_sptr > string_diff_sptr_map
Convenience typedef for a map which value is a diff_sptr. The key of the map is the qualified name of...
unordered_map< string, function_decl_diff_sptr > string_function_decl_diff_sptr_map
Convenience typedef for a map which key is a string and which value is a function_decl_diff_sptr.
bool is_less_than(const function_decl_diff &first, const function_decl_diff &second)
Compare two function_decl_diff for the purpose of sorting.
bool operator()(const diff *l, diff *r) const
Lexicographically compare two diff nodes.
A hashing functor for types_or_decls_type.
priv(corpus_sptr first, corpus_sptr second, diff_context_sptr ctxt)
Constructor of corpus_diff::priv.
A diff node in this category is redundant. That means it's present as a child of a other nodes in the...
shared_ptr< function_decl_diff > function_decl_diff_sptr
Convenience typedef for a shared pointer to a function_decl type.
Functor to sort instances of var_diff_sptr.
unordered_map< unsigned, function_decl::parameter_sptr > unsigned_parm_map
Convenience typedef for a map which key is an integer and which value is a parameter.
diff * get_canonical_diff() const
Getter for the canonical diff of the current instance of diff.
unordered_map< const diff *, artifact_sptr_set_type, diff_hash, diff_equal > diff_artifact_set_map_type
A convenience typedef for an unordered_map which key is a diff* and which value is a artifact_sptr_se...
shared_ptr< type_or_decl_base > type_or_decl_base_sptr
A convenience typedef for a shared_ptr to type_or_decl_base.
Definition: abg-fwd.h:119
A hashing functor for using diff_sptr and diff* in a hash map or set.
bool operator()(const function_decl::parameter_sptr &l, const function_decl::parameter_sptr &r)
Returns true iff the index of the first parameter is smaller than the of the second parameter...
Abstraction of an elf symbol.
Definition: abg-ir.h:922
unordered_map< string, const function_decl * > string_function_ptr_map
Convenience typedef for a map which key is a string and which value is a pointer to decl_base...
vector< method_decl_sptr > member_functions
Convenience typedef.
Definition: abg-ir.h:4060
shared_ptr< var_diff > var_diff_sptr
Convenience typedef for a shared pointer to a var_diff type.
shared_ptr< elf_symbol > elf_symbol_sptr
A convenience typedef for a shared pointer to elf_symbol.
Definition: abg-ir.h:886
#define ABG_ASSERT(cond)
This is a wrapper around the 'assert' glibc call. It allows for its argument to have side effects...
Definition: abg-fwd.h:1714
void sort_string_var_ptr_map(const string_var_ptr_map &map, vector< const var_decl * > &sorted)
Sort a map of string -> pointer to var_decl.
vector< suppression_sptr > suppressions_type
Convenience typedef for a vector of suppression_sptr.
Definition: abg-fwd.h:1658
A functor to compare two enumerators based on their value. This implements the "less than" operator...
A diff node in this category has a descendant node that is in the HAS_ALLOWED_CHANGE_CATEGORY categor...
bool operator()(const function_decl::parameter &l, const function_decl::parameter &r)
Returns true iff the index of the first parameter is smaller than the of the second parameter...
A comparison functor to compare two instances of fn_parm_diff based on their indexes.
unordered_map< unsigned, decl_base_sptr > unsigned_decl_base_sptr_map
Convenience typedef for a map which key is an unsigned integer and which value is a decl_base_sptr...
std::pair< enum_type_decl::enumerator, enum_type_decl::enumerator > changed_enumerator
Convenience typedef for a changed enumerator. The first element of the pair is the old enumerator and...
A comparison functor to compare two instances of var_diff that represent changed data members based o...
bool operator()(const diff_sptr &l, const diff_sptr &r) const
An operator that takes two instances of diff_sptr returns true if its first operand compares less tha...
This type contains maps. Each map associates a type name to a diff of that type. Not all kinds of dif...
unordered_map< unsigned, var_diff_sptr > unsigned_var_diff_sptr_map
Convenience typedef for a map whose key is an unsigned int and whose value is a changed variable of t...
The private member (pimpl) for diff_context.
bool operator()(const function_decl_diff_sptr first, const function_decl_diff_sptr second)
The actual less than operator.
unordered_map< types_or_decls_type, diff_sptr, types_or_decls_hash, types_or_decls_equal > types_or_decls_diff_map_type
A convenience typedef for a map of types_or_decls_type and diff_sptr.
void sort_changed_data_members(changed_var_sptrs_type &input)
Sort (in place) a vector of changed data members.
shared_ptr< base_diff > base_diff_sptr
Convenience typedef for a shared pointer to a base_diff type.
void sort_changed_enumerators(const string_changed_enumerator_map &enumerators_map, changed_enumerators_type &sorted)
Sort a map of changed enumerators.
bool is_filtered_out(diff_category category)
Check if a given categorization of a diff node should make it be filtered out.
A comparison functor to compare two data members based on their offset.
shared_ptr< fn_parm_diff > fn_parm_diff_sptr
Convenience typedef for a shared pointer to a fn_parm_diff type.
string get_name(const type_or_decl_base *tod, bool qualified)
Build and return a copy of the name of an ABI artifact that is either a type or a decl...
Definition: abg-ir.cc:8860
unordered_map< string, method_decl_sptr > string_member_function_sptr_map
Convenience typedef for a hash map of strings and member functions.
bool function_decl_is_less_than(const function_decl &f, const function_decl &s)
Test if the pretty representation of a given function_decl is lexicographically less then the pretty ...
Definition: abg-ir.cc:28110
The type of private data of class_or_union_diff.
A deleter for shared pointers that ... doesn't delete the object managed by the shared pointer...
std::pair< const type_or_decl_base_sptr, const type_or_decl_base_sptr > types_or_decls_type
Convenience typedef for a pair of decls or types.
unordered_map< size_t, size_t > pointer_map
Convenience typedef for a map of pointer values. The Key is a pointer value and the value is potentia...
unordered_map< string, fn_parm_diff_sptr > string_fn_parm_diff_sptr_map
Convenience typedef for a map which value is a changed function parameter and which key is the name o...
void sort_string_fn_parm_diff_sptr_map(const unsigned_fn_parm_diff_sptr_map &map, vector< fn_parm_diff_sptr > &sorted)
Sort a map of fn_parm_diff by the indexes of the function parameters.
void sort_string_virtual_member_function_diff_sptr_map(const string_function_decl_diff_sptr_map &map, function_decl_diff_sptrs_type &sorted)
Sort an map of string -> virtual member function into a vector of virtual member functions. The virtual member functions are sorted by increasing order of their virtual index.
an engine to suppress the parts of the result of comparing two sets of ABI artifacts.
void sort_string_function_decl_diff_sptr_map(const string_function_decl_diff_sptr_map &map, function_decl_diff_sptrs_type &sorted)
Sort the values of a string_function_decl_diff_sptr_map map and store the result in a vector of funct...
A diff node in this category carries a change that must be reported, even if the diff node is also in...
vector< diff_sptr > diff_sptrs_type
Convenience typedef for a vector of diff_sptr.
A functor to compare two changed enumerators, based on their initial value.
shared_ptr< corpus_diff > corpus_diff_sptr
A convenience typedef for a shared pointer to corpus_diff.
weak_ptr< diff_context > diff_context_wptr
Convenience typedef for a weak pointer of diff_context.
Definition: abg-fwd.h:74
A comparison functor for using diff_sptr and diff* in a hash map or set.
vector< base_diff_sptr > base_diff_sptrs_type
Convenience typedef for a vector of base_diff_sptr.
unordered_map< string, function_decl::parameter_sptr > string_parm_map
Convenience typedef for a map which value is a function parameter. The key is the name of the functio...
bool operator()(const diff &d1, const diff &d2) const
The function-call operator to compare two diff nodes.
"Less than" functor to compare instances of function_decl.
void sort_string_type_base_sptr_map(string_type_base_sptr_map &map, vector< type_base_sptr > &sorted)
Sort a map of string to type_base_sptr entities.
Functor that compares two function parameters for the purpose of sorting them.
void sort_string_diff_ptr_map(const string_diff_ptr_map &map, diff_ptrs_type &sorted)
Sort a map ofg string -> diff* into a vector of diff_ptr. The diff_ptr are sorted lexicographically w...
bool operator()(const diff_sptr &d1, const diff_sptr &d2) const
The function-call operator to compare two diff nodes.
unordered_map< string, enum_type_decl::enumerator > string_enumerator_map
Convenience typedef for a map which value is an enumerator. The key is the name of the enumerator...
size_t operator()(const diff *d) const
The function-call operator to hash a diff node.
const string & get_id_string() const
Get a string that is representative of a given elf_symbol.
Definition: abg-ir.cc:2528
vector< base_spec_sptr > base_specs
Convenience typedef.
Definition: abg-ir.h:4250
This is a document class that aims to capture statistics about the changes carried by a corpus_diff t...
void sort_string_function_ptr_map(const string_function_ptr_map &map, vector< const function_decl * > &sorted)
Sort an instance of string_function_ptr_map map and stuff a resulting sorted vector of pointers to fu...
The type of the private data (pimpl sub-object) of the class_diff type.
The internal type for the impl idiom implementation of var_diff.
shared_ptr< diff > diff_sptr
Convenience typedef for a shared_ptr for the diff class.
Definition: abg-fwd.h:76
shared_ptr< reporter_base > reporter_base_sptr
A convenience typedef for a shared pointer to a reporter_base.
Definition: abg-reporter.h:50
void sort_artifacts_set(const artifact_sptr_set_type &set, vector< type_or_decl_base_sptr > &sorted)
Sort the set of ABI artifacts contained in a artifact_sptr_set_type.
bool operator()(const function_decl_sptr f, const function_decl_sptr s)
The actual "less than" operator for instances of function_decl. It returns true if the first function...
string get_pretty_representation(diff *d)
Get a copy of the pretty representation of a diff node.
weak_ptr< diff > diff_wptr
Convenience typedef for a weak_ptr for the diff class.
Definition: abg-fwd.h:82
A comparison functor for instances of function_decl_diff that represent changes between two virtual m...
Private data for the diff type. The details of generic view of the diff node are expressed here...
bool operator()(const decl_base_sptr &f, const decl_base_sptr &s) const
Compare two data members.