abigail::comparison::filtering Namespace Reference

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.
typedef std::vector< filter_base_sptr >	filters
	Convenience typedef for a vector of filter_base_sptr.
typedef shared_ptr< harmless_harmful_filter >	harmful_harmless_filter_sptr
	A convenience typedef for a shared pointer to harmful_filter.
typedef shared_ptr< harmless_filter >	harmless_filter_sptr
	Convenience typedef for a shared pointer to a harmless_filter.

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.
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.
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.
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.
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.
bool	has_basic_or_class_type_name_change (const diff *d)
	Test if a diff node carries a basic or class type name change.
bool	has_basic_type_name_change (const diff *d)
	Test if a diff node carries a basic type name change.
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_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.
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.
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_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.
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.
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.
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.
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.
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.
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_fn_with_virtual_offset_change (const diff_sptr &d)
	Test if a diff node carries a change to the offset of a virtual function.
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_harmful_name_change (const diff *dif)
	Test if a diff node represents a harmful 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_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_incompatible_fn_or_var_change (const diff *d)
	Test if a diff node carries an incompatible ABI change.
bool	has_incompatible_fn_or_var_change (const diff_sptr &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, or vice versa.
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.
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.
diff_category	has_var_harmful_local_change (const diff *d)
	Test if a diff node carries a harmful local change to a variable.
diff_category	has_var_harmful_local_change (const diff_sptr &d)
	Test if diff node carries a harmful local change to a variable.
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.
bool	has_void_ptr_to_ptr_change (const diff *dif)
	Test if a diff node carries a void* to pointer type change.
bool	has_void_to_non_void_change (const diff *d)
	Test if a diff node carries a "void-to-non-void" type change.
bool	has_void_to_non_void_change (const diff_sptr &d)
	Test if a diff node carries a "void-to-non-void" type change.
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.
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.
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.
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.
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.
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.
bool	union_diff_has_harmless_changes (const diff *d)
	Test if a union diff node does have changes that don't impact its size.

Detailed Description

Facilities to walk, categorize and possibly filter nodes of the diff tree.

Typedef Documentation

filter_base_sptr

typedef shared_ptr< filter_base > filter_base_sptr

Convenience typedef for a shared pointer to filter_base.

Definition at line 153 of file abg-comp-filter.h.

filters

typedef std::vector< filter_base_sptr > filters

Convenience typedef for a vector of filter_base_sptr.

Definition at line 155 of file abg-comp-filter.h.

harmful_harmless_filter_sptr

typedef shared_ptr<harmless_harmful_filter> harmful_harmless_filter_sptr

A convenience typedef for a shared pointer to harmful_filter.

Definition at line 194 of file abg-comp-filter.h.

harmless_filter_sptr

typedef shared_ptr<harmless_filter> harmless_filter_sptr

Convenience typedef for a shared pointer to a harmless_filter.

Definition at line 179 of file abg-comp-filter.h.

Function Documentation

apply_filter() [1/3]

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.

Parameters

filter	the filter to apply to the diff nodes
d	the corpus diff to apply the filter to.

Definition at line 63 of file abg-comp-filter.cc.

apply_filter() [2/3]

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.

Parameters

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 84 of file abg-comp-filter.cc.

apply_filter() [3/3]

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.

Parameters

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 106 of file abg-comp-filter.cc.

has_anonymous_data_member_change() [1/2]

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.

Parameters

d	the diff node to consider.

Returns

true iff d carries a non-anonymous to anonymous data member change, or vice-versa.

Definition at line 1616 of file abg-comp-filter.cc.

has_anonymous_data_member_change() [2/2]

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.

Parameters

d	the diff node to consider.

Returns

true iff d carries a non-anonymous to anonymous data member change, or vice-versa.

Definition at line 1632 of file abg-comp-filter.cc.

has_basic_or_class_type_name_change()

bool has_basic_or_class_type_name_change

(

const diff *

d

)

Test if a diff node carries a basic or class type name change.

Parameters

d	the diff node to consider.

Returns

true iff the diff node carries a basic or class type name change.

Definition at line 1552 of file abg-comp-filter.cc.

has_basic_type_name_change()

bool has_basic_type_name_change

(

const diff *

d

)

Test if a diff node carries a basic type name change.

Parameters

d	the diff node to consider.

Returns

true iff the diff node carries a basic type name change.

Definition at line 1520 of file abg-comp-filter.cc.

has_benign_array_of_unknown_size_change()

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.

Parameters

dif	the diff node to consider.

Returns

true iff dif contains the benign array type size change.

Definition at line 2340 of file abg-comp-filter.cc.

has_class_decl_only_def_change() [1/2]

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.

Parameters

first	the first class or union to consider.
second	the second class or union to consider.

Returns

true iff the two arguments are different just by the fact that one is decl-only and the other one is defined.

Definition at line 1426 of file abg-comp-filter.cc.

has_class_decl_only_def_change() [2/2]

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.

Parameters

diff	the diff node to consider.

Returns

true if the 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.

Definition at line 1478 of file abg-comp-filter.cc.

has_class_or_union_type_name_change()

bool has_class_or_union_type_name_change

(

const diff *

d

)

Test if a diff node carries a class or union type name change.

Parameters

d	the diff node to consider.

Returns

true iff the diff node carries a class or union type name change.

Definition at line 1536 of file abg-comp-filter.cc.

has_data_member_replaced_by_anon_dm()

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.

Parameters

diff	the diff node to consider.

Returns

true iff the class_or_union_diff has a data member harmlessly replaced by an anonymous data member.

Definition at line 837 of file abg-comp-filter.cc.

has_decl_only_def_change() [1/2]

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.

Parameters

first	the first decl to consider.
second	the second decl to consider.

Returns

true iff the two arguments are different just by the fact that one is decl-only and the other one is defined.

Definition at line 1375 of file abg-comp-filter.cc.

has_decl_only_def_change() [2/2]

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.

Parameters

diff	the diff node to consider.

Returns

true if the 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.

Definition at line 1402 of file abg-comp-filter.cc.

has_enum_decl_only_def_change() [1/2]

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.

Parameters

diff	the diff node to consider.

Returns

true if the 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.

Definition at line 1502 of file abg-comp-filter.cc.

has_enum_decl_only_def_change() [2/2]

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.

Parameters

first	the first enum to consider.
second	the second enum to consider.

Returns

true iff the two arguments are different just by the fact that one is decl-only and the other one is defined.

Definition at line 1453 of file abg-comp-filter.cc.

has_fn_return_or_parm_harmful_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 that is deemed harmful.

Parameters

d	the diff node to consider.

Returns

the category of the change carried by or zero if doesn't carry any change.

Definition at line 2021 of file abg-comp-filter.cc.

has_fn_with_virtual_offset_change() [1/2]

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.

Parameters

d	the diff node to consider.

Returns

true iff carries a change to the offset of a virtual function.

Definition at line 2070 of file abg-comp-filter.cc.

has_fn_with_virtual_offset_change() [2/2]

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.

Parameters

d	the diff node to consider.

Returns

true iff carries a change to the offset of a virtual function.

Definition at line 2090 of file abg-comp-filter.cc.

has_harmful_name_change() [1/2]

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.

Parameters

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.

Returns

true iff decl s represents a harmful name change over f.

Definition at line 760 of file abg-comp-filter.cc.

has_harmful_name_change() [2/2]

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.

Parameters

f	the first decl to consider in the comparison.
s	the second decl to consider in the comparison.

Returns

true iff decl s represents a harmful name change over f.

Definition at line 777 of file abg-comp-filter.cc.

has_harmless_enum_to_int_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).

The test takes into account the fact change we care about might be wrapped into a typedef or qualified type diff.

Parameters

diff	the diff node to consider.

Returns

true if diff is a harmless enum to integer change.

Definition at line 1717 of file abg-comp-filter.cc.

has_harmless_name_change()

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.

Parameters

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.

Returns

true iff decl s represents a harmless change over f.

Definition at line 716 of file abg-comp-filter.cc.

has_incompatible_fn_or_var_change() [1/2]

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.

Parameters

d	the diff node to consider.

Returns

true iff d carries an incompatible ABI change.

Definition at line 2142 of file abg-comp-filter.cc.

has_incompatible_fn_or_var_change() [2/2]

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.

Parameters

d	the diff node to consider.

Returns

true iff d carries an incompatible ABI change.

Definition at line 2159 of file abg-comp-filter.cc.

has_lvalue_reference_ness_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, or vice versa.

Parameters

dif	the diff node to consider.

Returns

true iff dif carries a change where an lvalue reference changed into a rvalue reference, or vice versa.

Definition at line 982 of file abg-comp-filter.cc.

has_strict_fam_conversion() [1/2]

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.

Parameters

first	the first version of the class to consider.
second	the second version of the class to consider.

Returns

true iff first has a fake flexible array data member that got changed into second with a real flexible array data member.

Definition at line 940 of file abg-comp-filter.cc.

has_strict_fam_conversion() [2/2]

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.

Parameters

the	diff node to consider.

Returns

true iff 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 964 of file abg-comp-filter.cc.

has_var_harmful_local_change() [1/2]

diff_category has_var_harmful_local_change

(

const diff *

d

)

Test if a diff node carries a harmful local change to a variable.

Parameters

d	the diff node to consider.

Returns

the diff_category of the harmful local change or zero if the diff node carries no harmful local change.

Definition at line 2101 of file abg-comp-filter.cc.

has_var_harmful_local_change() [2/2]

diff_category has_var_harmful_local_change

(

const diff_sptr &

d

)

Test if diff node carries a harmful local change to a variable.

Parameters

d	the diff node to consider.

Returns

the diff_category of the harmful local change or zero if the diff node carries no harmful local change.

Definition at line 2129 of file abg-comp-filter.cc.

has_virtual_mem_fn_change()

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.

Parameters

diff	the function_decl_diff node to consider.

Returns

true iff the function_decl_diff node contains changes involving virtual member functions.

Definition at line 1165 of file abg-comp-filter.cc.

has_void_ptr_to_ptr_change()

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.

Parameters

dif	the diff node to consider.

Returns

true iff dif carries a void* to pointer type change.

Definition at line 2286 of file abg-comp-filter.cc.

has_void_to_non_void_change() [1/2]

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.

Parameters

f	the first type to consider.
s	the second type to consider.

Returns

true iff the pair of types represents a void-to-non-void type change.

Definition at line 2255 of file abg-comp-filter.cc.

has_void_to_non_void_change() [2/2]

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.

Parameters

f	the first type to consider.
s	the second type to consider.

Returns

true iff the pair of types represents a void-to-non-void type change.

Definition at line 2274 of file abg-comp-filter.cc.

is_decl_only_class_with_size_change() [1/3]

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.

Parameters

first	the first class or union to consider.
seconf	the second class or union to consider.

Returns

true if the two classes are decl-only and differ in their size.

Definition at line 1295 of file abg-comp-filter.cc.

is_decl_only_class_with_size_change() [2/3]

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.

Parameters

first	the first class or union to consider.
seconf	the second class or union to consider.

Returns

true if the two classes are decl-only and differ in their size.

Definition at line 1325 of file abg-comp-filter.cc.

is_decl_only_class_with_size_change() [3/3]

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.

Parameters

diff	the diff node to consider.

Returns

true if the two classes are decl-only and differ in their size.

Definition at line 1351 of file abg-comp-filter.cc.

is_mostly_distinct_diff()

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.

Parameters

d	the diff node to consider.

Returns

true iff d is mostly a distinct diff.

Definition at line 1569 of file abg-comp-filter.cc.

is_var_1_dim_unknown_size_array_change() [1/2]

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 913 of file abg-comp-filter.cc.

is_var_1_dim_unknown_size_array_change() [2/2]

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 861 of file abg-comp-filter.cc.

union_diff_has_harmless_changes()

bool union_diff_has_harmless_changes

(

const diff *

d

)

Test if a union diff node does have changes that don't impact its size.

Parameters

d	the union diff node to consider.

Returns

true iff d is a diff node which has changes that don't impact its size.

Definition at line 2353 of file abg-comp-filter.cc.