libabigail
Loading...
Searching...
No Matches
abg-comp-filter.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) 2013-2025 Red Hat, Inc.
5//
6// Author: Dodji Seketeli
7
8/// @file
9///
10/// This header declares filters for the diff trees resulting from
11/// comparing ABI Corpora.
12
13#ifndef __ABG_COMP_FILTER_H__
14#define __ABG_COMP_FILTER_H__
15
16#include "abg-comparison.h"
17
18namespace abigail
19{
20namespace comparison
21{
22/// Facilities to walk, categorize and possibly filter nodes of the
23/// diff tree.
24namespace filtering
25{
26
27bool
28has_harmless_name_change(const decl_base_sptr& f,
29 const decl_base_sptr& s,
30 const diff_context_sptr& ctxt);
31
32bool union_diff_has_harmless_changes(const diff *d);
33
34bool
35has_harmful_name_change(const decl_base_sptr& f,
36 const decl_base_sptr& s,
37 const diff_context_sptr& ctxt);
38
39bool
40has_harmful_name_change(const diff* dif);
41
42bool
43has_virtual_mem_fn_change(const function_decl_diff* diff);
44
45bool
46is_decl_only_class_with_size_change(const class_or_union& first,
47 const class_or_union& second);
48
49bool
50is_decl_only_class_with_size_change(const class_or_union_sptr& first,
51 const class_or_union_sptr& second);
52
53bool
55
56bool
57has_decl_only_def_change(const decl_base_sptr& first,
58 const decl_base_sptr& second);
59
60bool
61has_decl_only_def_change(const diff *d);
62
63bool
64has_class_decl_only_def_change(const class_or_union_sptr& first,
65 const class_or_union_sptr& second);
66
67bool
69 const enum_type_decl_sptr& second);
70
71bool
72has_class_decl_only_def_change(const diff *diff);
73
74bool
75has_enum_decl_only_def_change(const diff *diff);
76
77bool
78has_basic_type_name_change(const diff *);
79
80bool
82
83bool
85
86bool
87is_mostly_distinct_diff(const diff *d);
88
89bool
91
92bool
94
95bool
97
98bool
100
101bool
103 const var_decl_sptr& var2);
104
105bool
107 const class_decl_sptr& second);
108
109bool
110has_strict_fam_conversion(const diff *d);
111
112bool
114
115bool
116has_void_ptr_to_ptr_change(const diff* d);
117
118bool
119has_void_to_non_void_change(const diff* d);
120
121bool
123
124bool
126
127bool
129
132
134has_var_harmful_local_change(const diff* d);
135
138
139bool
141
142bool
144
145bool
147
148bool
150
151struct filter_base;
152/// Convenience typedef for a shared pointer to filter_base
153typedef shared_ptr<filter_base> filter_base_sptr;
154/// Convenience typedef for a vector of filter_base_sptr
155typedef std::vector<filter_base_sptr> filters;
156
157/// The base class for the diff tree node filter.
158///
159/// It's intended to walk a tree of diff nodes and tag each relevant
160/// name into one or several categories depending on well choosen
161/// properties of the diff nodes.
163{
164 friend void
166}; //end class filter_base
167
168void
170
171void
173
174void
176
177class harmless_filter;
178/// Convenience typedef for a shared pointer to a harmless_filter.
179typedef shared_ptr<harmless_filter> harmless_filter_sptr;
180
181/// A filter that walks the diff nodes tree and tags relevant diff
182/// nodes into categories considered to represent harmless changes.
184{
185 virtual bool
186 visit(diff*, bool);
187
188 virtual void
189 visit_end(diff*);
190}; // end class harmless_filter
191
193/// A convenience typedef for a shared pointer to harmful_filter.
194typedef shared_ptr<harmless_harmful_filter> harmful_harmless_filter_sptr;
195
196/// A filter that walks the diff nodes tree and tags relevant diff
197/// nodes into categories considered to represent potentially harmless
198/// or harmful changes.
200{
201 virtual bool
202 visit(diff*, bool);
203
204 virtual void
205 visit_end(diff*);
206}; // end class harmless_harmful_filter
207
208} // end namespace filtering
209} // end namespace comparison
210} // end namespace abigail
211
212#endif // __ABG_COMP_FILTER_H__
diff_node_visitor()
Default constructor of the diff_node_visitor type.
The abstraction of a change between two ABI artifacts, a.k.a an artifact change.
A filter that walks the diff nodes tree and tags relevant diff nodes into categories considered to re...
A filter that walks the diff nodes tree and tags relevant diff nodes into categories considered to re...
Facilities to walk, categorize and possibly filter nodes of the diff tree.
bool has_void_ptr_to_ptr_change(const diff *dif)
Test if a diff node carries a void* to pointer type change.
bool has_basic_type_name_change(const diff *d)
Test if a diff node carries a basic type name change.
diff_category has_fn_return_or_parm_harmful_change(const diff *d)
Test if a diff node is a function diff node that carries either a return or a parameter type change t...
bool has_enum_decl_only_def_change(const enum_type_decl_sptr &first, const enum_type_decl_sptr &second)
Test if two enum_sptr are different just by the fact that one is decl-only and the other one is defin...
diff_category has_var_harmful_local_change(const diff *d)
Test if a diff node carries a harmful local change to a variable.
std::vector< filter_base_sptr > filters
Convenience typedef for a vector of filter_base_sptr.
bool has_fn_with_virtual_offset_change(const diff *d)
Test if a diff node carries a change to the offset of a virtual function.
bool has_harmless_name_change(const decl_base_sptr &f, const decl_base_sptr &s, const diff_context_sptr &ctxt)
Test if two decls represents a harmless name change.
bool has_harmless_enum_to_int_change(const diff *diff)
Test if a diff node carries a harmless change of an enum into an integer (or vice-versa).
bool has_class_decl_only_def_change(const class_or_union_sptr &first, const class_or_union_sptr &second)
Test if two class_or_union_sptr are different just by the fact that one is decl-only and the other on...
bool has_data_member_replaced_by_anon_dm(const diff *diff)
Test if a class_or_union_diff has a data member replaced by an anonymous data member in a harmless wa...
shared_ptr< harmless_harmful_filter > harmful_harmless_filter_sptr
A convenience typedef for a shared pointer to harmful_filter.
bool is_var_1_dim_unknown_size_array_change(const var_decl_sptr &var1, const var_decl_sptr &var2)
Test if we are looking at two variables which types are both one dimension array, with one of them be...
bool is_decl_only_class_with_size_change(const class_or_union &first, const class_or_union &second)
Test if two classes that are decl-only (have the decl-only flag and carry no data members) but are di...
shared_ptr< filter_base > filter_base_sptr
Convenience typedef for a shared pointer to filter_base.
bool has_benign_array_of_unknown_size_change(const diff *dif)
Test if a diff node carries a benign change to the size of a variable of type array.
bool has_class_or_union_type_name_change(const diff *d)
Test if a diff node carries a class or union type name change.
bool has_harmful_name_change(const decl_base_sptr &f, const decl_base_sptr &s, const diff_context_sptr &ctxt)
Test if two decls represent a harmful name change.
bool has_decl_only_def_change(const decl_base_sptr &first, const decl_base_sptr &second)
Test if two decl_base_sptr are different just by the fact that one is decl-only and the other one is ...
bool has_basic_or_class_type_name_change(const diff *d)
Test if a diff node carries a basic or class type name change.
shared_ptr< harmless_filter > harmless_filter_sptr
Convenience typedef for a shared pointer to a harmless_filter.
bool has_incompatible_fn_or_var_change(const diff *d)
Test if a diff node carries an incompatible ABI change.
bool has_lvalue_reference_ness_change(const diff *dif)
Test if a diff node carries a change where an lvalue reference changed into a rvalue reference,...
bool has_anonymous_data_member_change(const diff *d)
Test if a diff node carries a non-anonymous data member to anonymous data member change,...
bool has_void_to_non_void_change(const diff *d)
Test if a diff node carries a "void-to-non-void" type change.
void apply_filter(filter_base &filter, corpus_diff_sptr d)
Walk the diff sub-trees of a a corpus_diff and apply a filter to the nodes visted....
bool is_mostly_distinct_diff(const diff *d)
Test if a diff node carries a distinct type change or a pointer/reference/typedef to distinct type ch...
bool union_diff_has_harmless_changes(const diff *d)
Test if a union diff node does have changes that don't impact its size.
bool has_strict_fam_conversion(const class_decl_sptr &first, const class_decl_sptr &second)
Test if a class with a fake flexible data member got changed into a class with a real fexible data me...
utilities to compare abi artifacts
shared_ptr< diff > diff_sptr
Convenience typedef for a shared_ptr for the diff class.
Definition abg-fwd.h:78
diff_category
An enum for the different categories that a diff tree node falls into, regarding the kind of changes ...
shared_ptr< diff_context > diff_context_sptr
Convenience typedef for a shared pointer of diff_context.
Definition abg-fwd.h:70
shared_ptr< corpus_diff > corpus_diff_sptr
A convenience typedef for a shared pointer to corpus_diff.
shared_ptr< class_decl > class_decl_sptr
Convenience typedef for a shared pointer on a class_decl.
Definition abg-fwd.h:193
shared_ptr< var_decl > var_decl_sptr
Convenience typedef for a shared pointer on a var_decl.
Definition abg-fwd.h:256
shared_ptr< enum_type_decl > enum_type_decl_sptr
Convenience typedef for shared pointer to a enum_type_decl.
Definition abg-fwd.h:175
Toplevel namespace for libabigail.
The base class for the diff tree node filter.
friend void apply_filter(filter_base_sptr f, diff_sptr deef)
Walk a diff sub-tree and apply a filter to the nodes visted. The filter categorizes each node,...