|
libabigail
|
Facilities to walk, categorize and possibly filter nodes of the diff tree. More...
Classes | |
| struct | filter_base |
| The base class for the diff tree node filter. More... | |
| class | harmless_filter |
| A filter that walks the diff nodes tree and tags relevant diff nodes into categories considered to represent harmless changes. More... | |
| class | harmless_harmful_filter |
| A filter that walks the diff nodes tree and tags relevant diff nodes into categories considered to represent potentially harmless or harmful changes. More... | |
Typedefs | |
| typedef shared_ptr< filter_base > | filter_base_sptr |
| Convenience typedef for a shared pointer to filter_base. More... | |
| typedef std::vector< filter_base_sptr > | filters |
| Convenience typedef for a vector of filter_base_sptr. More... | |
| typedef shared_ptr< harmless_harmful_filter > | harmful_harmless_filter_sptr |
| A convenience typedef for a shared pointer to harmful_filter. More... | |
| typedef shared_ptr< harmless_filter > | harmless_filter_sptr |
| Convenience typedef for a shared pointer to a harmless_filter. More... | |
Functions | |
| 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. The filter categorizes each node, assigning it into one or several categories. More... | |
| void | apply_filter (filter_base &filter, diff_sptr d) |
| Walk a diff sub-tree and apply a filter to the nodes visted. The filter categorizes each node, assigning it into one or several categories. More... | |
| void | apply_filter (filter_base_sptr filter, diff_sptr d) |
| Walk a diff sub-tree and apply a filter to the nodes visted. The filter categorizes each node, assigning it into one or several categories. More... | |
| 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, or vice-versa. More... | |
| bool | has_anonymous_data_member_change (const diff_sptr &d) |
| Test if a diff node carries a non-anonymous data member to anonymous data member change, or vice-versa. More... | |
| bool | has_basic_or_class_type_name_change (const diff *d) |
| Test if a diff node carries a basic or class type name change. More... | |
| bool | has_basic_type_name_change (const diff *d) |
| Test if a diff node carries a basic type name change. More... | |
| 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. More... | |
| 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 one is defined. More... | |
| bool | has_class_decl_only_def_change (const diff *diff) |
| Test if a class_or_union_diff carries a change in which the two classes are different by the fact that one is a decl-only and the other one is defined. More... | |
| bool | has_class_or_union_type_name_change (const diff *d) |
| Test if a diff node carries a class or union type name change. More... | |
| 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 way. That means, the new anonymous data member somehow contains the replaced data member and it doesn't break the layout of the containing class. More... | |
| 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 defined. More... | |
| bool | has_decl_only_def_change (const diff *d) |
| Test if a diff carries a change in which the two decls are different by the fact that one is a decl-only and the other one is defined. More... | |
| 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 defined. More... | |
| bool | has_enum_decl_only_def_change (const diff *diff) |
| Test if a enum_diff carries a change in which the two enums are different by the fact that one is a decl-only and the other one is defined. More... | |
| 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 that is deemed harmful. More... | |
| 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. More... | |
| bool | has_fn_with_virtual_offset_change (const diff_sptr &d) |
| Test if a diff node carries a change to the offset of a virtual function. More... | |
| 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. More... | |
| bool | has_harmful_name_change (const diff *dif) |
| Test if a diff node represents a harmful name change. More... | |
| 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). More... | |
| 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. More... | |
| bool | has_incompatible_fn_or_var_change (const diff *d) |
| Test if a diff node carries an incompatible ABI change. More... | |
| bool | has_incompatible_fn_or_var_change (const diff_sptr &d) |
| Test if a diff node carries an incompatible ABI change. More... | |
| 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, or vice versa. More... | |
| 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 member. More... | |
| bool | has_strict_fam_conversion (const diff *dif) |
| Test if a diff node carries a change from class with a fake flexible data member into a class with a real fexible data member. More... | |
| diff_category | has_var_harmful_local_change (const diff *d) |
| Test if a diff node carries a harmful local change to a variable. More... | |
| diff_category | has_var_harmful_local_change (const diff_sptr &d) |
| Test if diff node carries a harmful local change to a variable. More... | |
| bool | has_virtual_mem_fn_change (const function_decl_diff *diff) |
| Test if the function_decl_diff node has a change involving virtual member functions. More... | |
| bool | has_void_ptr_to_ptr_change (const diff *dif) |
| Test if a diff node carries a void* to pointer type change. More... | |
| bool | has_void_to_non_void_change (const diff *d) |
| Test if a diff node carries a "void-to-non-void" type change. More... | |
| bool | has_void_to_non_void_change (const diff_sptr &d) |
| Test if a diff node carries a "void-to-non-void" type change. More... | |
| bool | is_data_member_to_compatible_anonymous_dm_change (const diff *d) |
| Test if a diff node carries a change where a data member F is modified into an anonymous data member S that contains F at the same offset. More... | |
| bool | is_data_member_to_compatible_anonymous_dm_change (const diff_sptr &d) |
| Test if a diff node carries a change where a data member F is modified into an anonymous data member S that contains F at the same offset. More... | |
| bool | is_data_member_to_compatible_anonymous_dm_change (const decl_base_sptr &f, const decl_base_sptr &s) |
| Test if a data member F is modified into an anonymous data member S that contains F at the same offset. More... | |
| 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 different just by their size. More... | |
| bool | is_decl_only_class_with_size_change (const class_or_union_sptr &first, const class_or_union_sptr &second) |
| Test if two classes that are decl-only (have the decl-only flag and carry no data members) but are different just by their size. More... | |
| bool | is_decl_only_class_with_size_change (const diff *diff) |
| Test if a diff node is for two classes that are decl-only (have the decl-only flag and carry no data members) but are different just by their size. More... | |
| 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 change. More... | |
| bool | is_type_to_compatible_anonymous_type_change (const diff_sptr &d) |
| Test if a diff node carries a change where a type T is modified into an anonymous type T' of the same size which contains a data member of the same type as T. More... | |
| bool | is_type_to_compatible_anonymous_type_change (const diff *d) |
| Test if a diff node carries a change where a type T is modified into an anonymous type T' of the same size which contains a data member of the same type as T. More... | |
| bool | is_type_to_compatible_anonymous_type_change (const type_base_sptr &f, const type_base_sptr &s) |
| Test if a type 'F' is modified into an anonymous type 'S' of the same size which contains a data member of the same type as 'F'. More... | |
| 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 being of unknow size and the two variables having the same symbol size. More... | |
| bool | is_var_1_dim_unknown_size_array_change (const diff *diff) |
| Test if we are looking at a diff that carries a change of variables which types are both one dimension array, with one of them being of unknow size and the two variables having the same symbol size. More... | |
| bool | union_diff_has_harmless_changes (const diff *d) |
| Test if a union diff node does have changes that don't impact its size. More... | |
Facilities to walk, categorize and possibly filter nodes of the diff tree.
| typedef shared_ptr< filter_base > filter_base_sptr |
Convenience typedef for a shared pointer to filter_base.
Definition at line 171 of file abg-comp-filter.h.
| typedef std::vector< filter_base_sptr > filters |
Convenience typedef for a vector of filter_base_sptr.
Definition at line 175 of file abg-comp-filter.h.
| typedef shared_ptr<harmless_harmful_filter> harmful_harmless_filter_sptr |
A convenience typedef for a shared pointer to harmful_filter.
Definition at line 212 of file abg-comp-filter.h.
| typedef shared_ptr<harmless_filter> harmless_filter_sptr |
Convenience typedef for a shared pointer to a harmless_filter.
Definition at line 197 of file abg-comp-filter.h.
| 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. The filter categorizes each node, assigning it into one or several categories.
| filter | the filter to apply to the diff nodes |
| d | the corpus diff to apply the filter to. |
Definition at line 73 of file abg-comp-filter.cc.
| void apply_filter | ( | filter_base & | filter, |
| diff_sptr | d | ||
| ) |
Walk a diff sub-tree and apply a filter to the nodes visted. The filter categorizes each node, assigning it into one or several categories.
Note that this function makes sure to avoid visiting a node (or any other node equivalent to it) more than once. This helps avoid infinite loops for diff trees that involve type changes that reference themselves.
| filter | the filter to apply to the nodes of the sub-tree. |
| d | the diff sub-tree to walk and apply the filter to. |
Definition at line 94 of file abg-comp-filter.cc.
| void apply_filter | ( | filter_base_sptr | filter, |
| diff_sptr | d | ||
| ) |
Walk a diff sub-tree and apply a filter to the nodes visted. The filter categorizes each node, assigning it into one or several categories.
Note that this function makes sure to avoid visiting a node (or any other node equivalent to it) more than once. This helps avoid infinite loops for diff trees that involve type changes that reference themselves.
| filter | the filter to apply to the nodes of the sub-tree. |
| d | the diff sub-tree to walk and apply the filter to. |
Definition at line 116 of file abg-comp-filter.cc.
| 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, or vice-versa.
| d | the diff node to consider. |
d carries a non-anonymous to anonymous data member change, or vice-versa. Definition at line 1866 of file abg-comp-filter.cc.
| bool has_anonymous_data_member_change | ( | const diff_sptr & | d | ) |
Test if a diff node carries a non-anonymous data member to anonymous data member change, or vice-versa.
| d | the diff node to consider. |
d carries a non-anonymous to anonymous data member change, or vice-versa. Definition at line 1884 of file abg-comp-filter.cc.
| bool has_basic_or_class_type_name_change | ( | const diff * | d | ) |
Test if a diff node carries a basic or class type name change.
| d | the diff node to consider. |
Definition at line 1802 of file abg-comp-filter.cc.
| bool has_basic_type_name_change | ( | const diff * | d | ) |
Test if a diff node carries a basic type name change.
| d | the diff node to consider. |
Definition at line 1770 of file abg-comp-filter.cc.
| 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.
A benign size change is a change in size (from or to infinite) of the array as expressed by the debug info, but when the *ELF* size (what really matters) of the variable object hasn't changed. This happens when the debug info emitter did have trouble figuring out the actual size of the array.
| dif | the diff node to consider. |
dif contains the benign array type size change. Definition at line 2743 of file abg-comp-filter.cc.
| 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 one is defined.
| first | the first class or union to consider. |
| second | the second class or union to consider. |
Definition at line 1676 of file abg-comp-filter.cc.
| bool has_class_decl_only_def_change | ( | const diff * | diff | ) |
Test if a class_or_union_diff carries a change in which the two classes are different by the fact that one is a decl-only and the other one is defined.
| diff | the diff node to consider. |
Definition at line 1728 of file abg-comp-filter.cc.
| bool has_class_or_union_type_name_change | ( | const diff * | d | ) |
Test if a diff node carries a class or union type name change.
| d | the diff node to consider. |
Definition at line 1786 of file abg-comp-filter.cc.
| 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 way. That means, the new anonymous data member somehow contains the replaced data member and it doesn't break the layout of the containing class.
| diff | the diff node to consider. |
Definition at line 1087 of file abg-comp-filter.cc.
| 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 defined.
| first | the first decl to consider. |
| second | the second decl to consider. |
Definition at line 1625 of file abg-comp-filter.cc.
| bool has_decl_only_def_change | ( | const diff * | d | ) |
Test if a diff carries a change in which the two decls are different by the fact that one is a decl-only and the other one is defined.
| diff | the diff node to consider. |
Definition at line 1652 of file abg-comp-filter.cc.
| 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 defined.
| first | the first enum to consider. |
| second | the second enum to consider. |
Definition at line 1703 of file abg-comp-filter.cc.
| bool has_enum_decl_only_def_change | ( | const diff * | diff | ) |
Test if a enum_diff carries a change in which the two enums are different by the fact that one is a decl-only and the other one is defined.
| diff | the diff node to consider. |
Definition at line 1752 of file abg-comp-filter.cc.
| 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 that is deemed harmful.
| d | the diff node to consider. |
or zero if doesn't carry any change. Definition at line 2273 of file abg-comp-filter.cc.
| 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.
| d | the diff node to consider. |
carries a change to the offset of a virtual function. Definition at line 2322 of file abg-comp-filter.cc.
| bool has_fn_with_virtual_offset_change | ( | const diff_sptr & | d | ) |
Test if a diff node carries a change to the offset of a virtual function.
| d | the diff node to consider. |
carries a change to the offset of a virtual function. Definition at line 2342 of file abg-comp-filter.cc.
| 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.
A harmful name change is a name change that is not harmless, so this function uses the function has_harmless_name_change.
| f | the first decl to consider in the comparison. |
| s | the second decl to consider in the comparison. |
| ctxt | the diff context to use for comparison. |
s represents a harmful name change over f. Definition at line 999 of file abg-comp-filter.cc.
| bool has_harmful_name_change | ( | const diff * | dif | ) |
Test if a diff node represents a harmful name change.
A harmful name change is a name change that is not harmless, so this function uses the function has_harmless_name_change.
| f | the first decl to consider in the comparison. |
| s | the second decl to consider in the comparison. |
s represents a harmful name change over f. Definition at line 1016 of file abg-comp-filter.cc.
| 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).
The test takes into account the fact change we care about might be wrapped into a typedef or qualified type diff.
| diff | the diff node to consider. |
diff is a harmless enum to integer change. Definition at line 1969 of file abg-comp-filter.cc.
| 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.
For now, a harmless name change is considered only for a typedef, enum or a data member.
| f | the first decl to consider in the comparison. |
| s | the second decl to consider in the comparison. |
| ctxt | the diff context to use for fine grained comparison of f and s. |
s represents a harmless change over f. Definition at line 944 of file abg-comp-filter.cc.
| bool has_incompatible_fn_or_var_change | ( | const diff * | d | ) |
Test if a diff node carries an incompatible ABI change.
An incompatible ABI change is a harmful ABI change (i.e, one that cannot be filtered out) that definitely makes the new ABI incompatible with the previous one.
| d | the diff node to consider. |
d carries an incompatible ABI change. Definition at line 2394 of file abg-comp-filter.cc.
| bool has_incompatible_fn_or_var_change | ( | const diff_sptr & | d | ) |
Test if a diff node carries an incompatible ABI change.
An incompatible ABI change is a harmful ABI change (i.e, one that cannot be filtered out) that definitely makes the new ABI incompatible with the previous one.
| d | the diff node to consider. |
d carries an incompatible ABI change. Definition at line 2411 of file abg-comp-filter.cc.
| 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, or vice versa.
| dif | the diff node to consider. |
dif carries a change where an lvalue reference changed into a rvalue reference, or vice versa. Definition at line 1232 of file abg-comp-filter.cc.
| 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 member.
A fake flexible array data member is a data member that is the last of the class/struct which type is an array of one element. This was used before C99 standardized flexible array data members.
| first | the first version of the class to consider. |
| second | the second version of the class to consider. |
first has a fake flexible array data member that got changed into second with a real flexible array data member. Definition at line 1190 of file abg-comp-filter.cc.
| bool has_strict_fam_conversion | ( | const diff * | dif | ) |
Test if a diff node carries a change from class with a fake flexible data member into a class with a real fexible data member.
A fake flexible array data member is a data member that is the last of the class/struct which type is an array of one element. This was used before C99 standardized flexible array data members.
| the | diff node to consider. |
dif carries a change from class with a fake flexible data member into a class with a real fexible data member. member. Definition at line 1214 of file abg-comp-filter.cc.
| diff_category has_var_harmful_local_change | ( | const diff * | d | ) |
Test if a diff node carries a harmful local change to a variable.
| d | the diff node to consider. |
Definition at line 2353 of file abg-comp-filter.cc.
| diff_category has_var_harmful_local_change | ( | const diff_sptr & | d | ) |
Test if diff node carries a harmful local change to a variable.
| d | the diff node to consider. |
Definition at line 2381 of file abg-comp-filter.cc.
| bool has_virtual_mem_fn_change | ( | const function_decl_diff * | diff | ) |
Test if the function_decl_diff node has a change involving virtual member functions.
That means whether there is an added, removed or changed virtual member function.
| diff | the function_decl_diff node to consider. |
Definition at line 1415 of file abg-comp-filter.cc.
| bool has_void_ptr_to_ptr_change | ( | const diff * | dif | ) |
Test if a diff node carries a void* to pointer type change.
Note that this function looks through typedef and qualifier types to find the void pointer.
| dif | the diff node to consider. |
dif carries a void* to pointer type change. Definition at line 2689 of file abg-comp-filter.cc.
| bool has_void_to_non_void_change | ( | const diff * | d | ) |
Test if a diff node carries a "void-to-non-void" type change.
The test looks through potential typedefs.
| f | the first type to consider. |
| s | the second type to consider. |
Definition at line 2658 of file abg-comp-filter.cc.
| bool has_void_to_non_void_change | ( | const diff_sptr & | d | ) |
Test if a diff node carries a "void-to-non-void" type change.
The test looks through potential typedefs.
| f | the first type to consider. |
| s | the second type to consider. |
Definition at line 2677 of file abg-comp-filter.cc.
| bool is_data_member_to_compatible_anonymous_dm_change | ( | const diff * | d | ) |
Test if a diff node carries a change where a data member F is modified into an anonymous data member S that contains F at the same offset.
F and S are thus said to be compatible.
| d | the diff node to consider. |
d carries a change where a data member F is modified into an anonymous data member S that contains F at the same offset. Definition at line 2504 of file abg-comp-filter.cc.
| bool is_data_member_to_compatible_anonymous_dm_change | ( | const diff_sptr & | d | ) |
Test if a diff node carries a change where a data member F is modified into an anonymous data member S that contains F at the same offset.
F and S are thus said to be compatible.
| d | the diff node to consider. |
d carries a change where a data member F is modified into an anonymous data member S that contains F at the same offset. Definition at line 2523 of file abg-comp-filter.cc.
| bool is_data_member_to_compatible_anonymous_dm_change | ( | const decl_base_sptr & | f, |
| const decl_base_sptr & | s | ||
| ) |
Test if a data member F is modified into an anonymous data member S that contains F at the same offset.
F and S are thus said to be compatible.
| f | the first data member to consider. |
| s | the second data member to consider. |
f is modified into s that contains F at the same offset. Definition at line 2538 of file abg-comp-filter.cc.
| 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 different just by their size.
In some weird DWARF representation, it happens that a decl-only class (with no data member) actually carries a non-zero size. That shouldn't happen, but hey, we need to deal with real life. So we need to detect that case first.
| first | the first class or union to consider. |
| seconf | the second class or union to consider. |
Definition at line 1545 of file abg-comp-filter.cc.
| bool is_decl_only_class_with_size_change | ( | const class_or_union_sptr & | first, |
| const class_or_union_sptr & | second | ||
| ) |
Test if two classes that are decl-only (have the decl-only flag and carry no data members) but are different just by their size.
In some weird DWARF representation, it happens that a decl-only class (with no data member) actually carries a non-zero size. That shouldn't happen, but hey, we need to deal with real life. So we need to detect that case first.
| first | the first class or union to consider. |
| seconf | the second class or union to consider. |
Definition at line 1575 of file abg-comp-filter.cc.
| bool is_decl_only_class_with_size_change | ( | const diff * | diff | ) |
Test if a diff node is for two classes that are decl-only (have the decl-only flag and carry no data members) but are different just by their size.
In some weird DWARF representation, it happens that a decl-only class (with no data member) actually carries a non-zero size. That shouldn't happen, but hey, we need to deal with real life. So we need to detect that case first.
| diff | the diff node to consider. |
Definition at line 1601 of file abg-comp-filter.cc.
| 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 change.
Note that a distinct type change is a change where the two subjects of the change are not of the same kind, e.g, a basic type that got changed into a qualified type.
| d | the diff node to consider. |
d is mostly a distinct diff. Definition at line 1819 of file abg-comp-filter.cc.
| bool is_type_to_compatible_anonymous_type_change | ( | const diff_sptr & | d | ) |
Test if a diff node carries a change where a type T is modified into an anonymous type T' of the same size which contains a data member of the same type as T.
T and T' are thus said to be compatible.
| d | the diff node to consider. |
d carriesa change where a type T is modified into an anonymous type T' of the same size which contains a data member of the same type as T. Definition at line 2426 of file abg-comp-filter.cc.
| bool is_type_to_compatible_anonymous_type_change | ( | const diff * | d | ) |
Test if a diff node carries a change where a type T is modified into an anonymous type T' of the same size which contains a data member of the same type as T.
T and T' are thus said to be compatible.
| d | the diff node to consider. |
d carriesa change where a type T is modified into an anonymous type T' of the same size which contains a data member of the same type as T. Definition at line 2441 of file abg-comp-filter.cc.
| bool is_type_to_compatible_anonymous_type_change | ( | const type_base_sptr & | f, |
| const type_base_sptr & | s | ||
| ) |
Test if a type 'F' is modified into an anonymous type 'S' of the same size which contains a data member of the same type as 'F'.
F and S are thus said to be compatible.
| F | the first type to consider. |
| S | the second version of type S to consider. |
'F' is modified into an anonymous type 'S' of the same size which contains a data member of the same type as 'F'. Definition at line 2462 of file abg-comp-filter.cc.
| 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 being of unknow size and the two variables having the same symbol size.
This can happen in the case of these two declarations, for instance:
unsigned int array[];
and:
unsigned int array[] ={0};
In both cases, the size of the ELF symbol of the variable 'array' is 32 bits, but, at least in the first case
Definition at line 1111 of file abg-comp-filter.cc.
| bool is_var_1_dim_unknown_size_array_change | ( | const diff * | diff | ) |
Test if we are looking at a diff that carries a change of variables which types are both one dimension array, with one of them being of unknow size and the two variables having the same symbol size.
This can happen in the case of these two declarations, for instance:
unsigned int array[];
and:
unsigned int array[] ={0};
In both cases, the size of the ELF symbol of the variable 'array' is 32 bits, but, at least in the first case
Definition at line 1163 of file abg-comp-filter.cc.
| bool union_diff_has_harmless_changes | ( | const diff * | d | ) |
Test if a union diff node does have changes that don't impact its size.
| d | the union diff node to consider. |
d is a diff node which has changes that don't impact its size. Definition at line 2756 of file abg-comp-filter.cc.
1.8.10