mirror of
git://sourceware.org/git/libabigail.git
synced 2025-03-05 22:27:34 +00:00
ca08bae742
671 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
Dodji Seketeli
|
ee2b54ddd9 |
Make abidiff and abidw support several --headers-dir{1,2} options
When handling a binary with abidiff or abidw it can be useful to
provide several different header files directories, for the cases
where the header files of the binary are scathered in several
different directories.
It thus becomes possible to invoke abidiff like this:
abidiff --headers-dir1 first-header-dir1 \
--headers-dir1 second-header-dir1 \
--headers-dir2 first-header-dir2 \
--headers-dir2 second-header-dir2 \
binary1 binary2
This patch adds support for that. It also modifies the
tests/test-abidiff-exit.cc test harness to make it take header
directories. With that modification done, a new test is added in that
harness to exercise this new feature.
This should close the feature request over at
https://sourceware.org/bugzilla/show_bug.cgi?id=26565.
* doc/manuals/abidiff.rst: Update documentation for the
--headers-dir{1,2} options.
* doc/manuals/abidw.rst: Likewise for the --header-dir option.
* include/abg-tools-utils.h (gen_suppr_spec_from_headers): Add new
overload that takes a vector of headers root dirs.
* src/abg-tools-utils.cc (gen_suppr_spec_from_headers_root_dir):
Define new function.
(gen_suppr_spec_from_headers): Define a new overload that takes a
vector of head_root_dir strings; it uses the new
gen_suppr_spec_from_headers function. Use the new overload in the
previous one that takes just one head_root_dir string.
* tools/abidiff.cc (options::headers_dirs{1,2}): Rename
option::headers_dir{1,2} into this one and make it be a vector of
strings rather than just a string.
(parse_command_line): Support several --headers-dir{1,2} on the
command line.
(set_diff_context_from_opts, set_suppressions): Adjust.
* tools/abidw.cc (options::headers_dirs): Renamed
options::headers_dir into this and make it be a vector of strings
rather than just a string.
(parse_command_line): Support several --headers-dir on the command
line.
(set_suppressions): Adjust.
* tests/data/test-abidiff-exit/test-headers-dirs/headers-a/header-a-v{0,1}.h:
Header files of new binary test input.
* tests/data/test-abidiff-exit/test-headers-dirs/headers-b/header-b-v{0,1}.h:
Likewise.
* tests/data/test-abidiff-exit/test-headers-dirs/test-headers-dir-v{0,1}.c:
Source code of new binary test input.
* tests/data/test-abidiff-exit/test-headers-dirs/test-headers-dir-report-{1,2}.txt:
Reference output of new binary test input.
* tests/data/test-abidiff-exit/test-headers-dirs/test-headers-dir-v{0,1}.o:
New binary test input.
* tests/data/Makefile.am: Add the new files above to source
distribution.
* tests/test-abidiff-exit.cc (InOutSpec::in_elfv{0,1}_path): Add
new data members.
(in_out_specs): Adjust the content of this array as its type
changed. Also, add two new entries to run the test over the new
binary test inputs above.
(do_prefix_strings): Define new static function.
(main): Use it the new do_prefix_strings here. Make abidiff
use the --header-dir{1,2} option whenever header directories are
specified in an entry of the in_out_specs array.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
3d7916caa4 |
Bug 26309 - Wrong leaf reporting of changes to typedef underlying type
In leaf mode, libabigail fails to report changes to the underlying
type of a typedef.
At its core, this is due to the fact that changes to the underlying
type of a typedef are not considered local. As the leaf reporter only
reports local changes (as opposed to non-local changes which are
changes to sub-types) it doesn't detect those non-local typedef
changes.
To handle this, this patch makes changes to the underlying type of a
typedef be considered as local changes. This is like what we already
do for pointer and qualified types.
Now that we have another set of changes to report in the leaf
reporter, we need to handle how to propagate the category and
redundancy status of those changes. The patch does this too.
Also, just like we do pointer and qualified type changes, the patch
avoids marking the diff node carrying the typedef change as being a
leaf change. That way, only existing leaf changes carrying that
typedef diff node will be reported. For instance, a function whose
parameter has a typedef change will be reported because that change to
the function is considered a leaf change. Otherwise, reporting the
typedef (or the pointer or qualified) type change on its own is not
useful unless it impacts those leaf changes that we deem useful.
The patch adds the example given in problem report to the testsuite.
* src/abg-ir.cc (equals): In the overload for typedef_decls,
report changes to the underlying type as being local of kind
LOCAL_TYPE_CHANGE_KIND.
* src/abg-comparison.cc
(leaf_diff_node_marker_visitor::visit_begin): Do not mark typedef
diff node as leaf node.
(suppression_categorization_visitor::visit_end): Propagate the
'suppressed' category of the underlying type to the parent typedef
unless the later has a local non-type change.
(redundancy_marking_visitor::visit_end): Likewise for the
'redundant' category.
* include/abg-reporter.h (report_non_type_typedef_changes): Rename ...
* src/abg-default-reporter.cc (report_non_type_typedef_changes):
... report_local_typedef_changes into this.
* src/abg-leaf-reporter.cc (leaf_reporter::report): Make the leaf
reporter invoke the reporting method of the default reporter for
typedefs as all typedef changes are now local.
* tests/data/test-diff-filter/test-PR26309-report-0.txt: Add new
test reference output.
* tests/data/test-diff-filter/test-PR26309-v{0,1}.o: Add new test
binary input.
* tests/data/test-diff-filter/test-PR26309-v{0,1}.c: Add source
code for new test binary input.
* tests/data/Makefile.am: Add the new text material above to
source distribution.
* tests/test-diff-filter.cc (in_out_specs): Add the new test input
above to this test harness.
* tests/data/test-diff-pkg/spice-server-0.12.4-19.el7.x86_64-0.12.8-1.el7.x86_64-report-3.txt: Adjust.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
5cf2473d3c |
writer: Avoid using dynamic hashing in type maps
When using type maps the hash used for a given type T is usually the pointer value of the canonical type of T. In the rare cases where T doesn't have a canonical type, we were using a 'dynamic hash' computed by recursively walking the components of T and progressively building a hash that way. The dynamic hashing code hasn't been updated in a while and would need some overhaul to support hashing with schemes like MD5 or maybe sha even. It might be useful for various use cases that have been proposed by some users over the years but nobody was motivated enough to implement it. In the mean time, rather than trying to come up with a fully beefed up dynamic hashing code, we'd rather just return a constant number for non canonicalized types. In practise that amounts to forcing the code of the maps to always use structural comparison for those non canonicalized types. Note that the amount of non-canonicalized types should be fairly small. For now, the only non-canonicalized types should be declaration-only types and those are quite fast to compare anyway. This patch thus introduces a new hashing scheme for maps in the writer which just uses a numerical constant as the hash for non-canonicalized types. * include/abg-fwd.h (hash_as_canonical_type_or_constant): Declare ... * src/abg-ir.cc (hash_as_canonical_type_or_constant): ... new function. * src/abg-writer.cc (type_hasher::operator()): Use the new hash_as_canonical_type_or_constant. * tests/data/test-read-dwarf/test16-pr18904.so.abi: Adjust. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
Giuliano Procida
|
23f11d70de |
Fix inheritance of scope_decl::insert_member_decl
The classes class_decl, class_or_union and scope_decl derive from each other. The method insert_member_decl is declared virtual and defined in each of these. Unfortunately, it has different argument types in the base scope_decl class. Most calls to insert_member_decl are at a statically known class, but in insert_decl_into_scope the method is called via a scope_decl pointer. There is the possibility that this could be a type derived from scope_decl rather than scope_decl itself, in which case the base method would be called, not as intended. This commit adjusts the type of the member argument to scope_decl::insert_member_decl to match the other two classes and eliminates the last trigger of Clang's -Werror-overloaded-virtual. * include/abg-ir.h (scope_decl::insert_member_decl): Change type of member argument from const decl_base_sptr& to plain decl_base_sptr. * src/abg-ir.cc (scope_decl::insert_member_decl): Likewise. Signed-off-by: Giuliano Procida <gprocida@google.com> |
||
|
Dodji Seketeli
|
38b1476765 |
Pimpl-ify traversable_base and remove its unused traverse method
The traverse method is defined in the traversable_base class but is
never used as the synonymous methods in the derived classes have
different argument types and so hide it.
It's never used because it's mostly intended as documentation for what
the implementations of this interface should look like. Namely they
should define a traversable method and its parameter type should
derive from the parameter type of traversable_base::traverse.
But apparently, clang's -Werror-overloaded-virtual is not happy about
this. It flags it as an error. It's not. But hey, let's work-around
it then.
So this patch just comments that method out and document its intent.
To make the change somewhat useful, this patch pimpl-ifies this
abg-traverse.h header file to get us one step closer to some a{b,p}i
stability. The definitions are moved into abg-traverse.cc.
* include/abg-traverse.h (traversable_base::priv): Declare new type.
(traverse_base::priv_sptr): Add pointer to private data
member.
(traverse_base::visiting_): Move this data member definition into
traverse_base::priv.
(traverse_base::{visiting, traverse_base, ~traverse_base}): Move
definitions out-of-oline.
(traverse_base::traverse): Comment out.
* src/abg-traverse.cc (struct traversable_base::priv): Define new
type.
(traversable_base::{traversable_base, ~traversable_base, traverse,
visiting}): Move these previous inline definitions here.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Giuliano Procida
|
93fae877d8 |
Simplify peel_typedef_pointer_or_reference_type
The second argument to this function controls whether CV qualifiers should be stripped as well as the elements mentioned in the function name. While it defaults to true, it is now always passed in as false. The function contains incomplete code for peeling array types. This is not needed or indeed wanted by its current callers. This commits removes the peel_qual_type argument and removes the associated behaviour. It removes the array peeling code. There are no functional changes apart from no longer performing early canonicalisation of certain array types. I looked at the history of this function to see where the behaviours originated. |
||
|
Giuliano Procida
|
3b93574beb |
Remove unused is_reference_or_pointer_diff.
The function is_reference_or_pointer_diff was added in commit |
||
|
Giuliano Procida
|
12baf89751 |
abg-comparison.h: Remove stray declaration
The functon is_reference_or_pointer_diff_to_non_basic_distinct_types
was declared in
|
||
|
Giuliano Procida
|
697347e402 |
Fix corpus_diff::has_net_changes for --leaf-changes-only mode
This function was not aware of --leaf-changes-only mode.
- Stats counters for changed variables and types have
different names in the different modes.
- Net leaf type changes were not included in leaf mode.
For some inputs, this resulted in abidiff producing an empty report
but returning a non-zero exit status in --leaf-changes-only mode.
For other inputs the combination of both issues still resulted in the
correct return code. This included the following test-abidiff-exit
test cases:
- test-leaf-peeling
- test-leaf2
- test-no-stray-comma
This patch makes corpus_diff::has_net_changes mirror emit_diff_stats,
modulo flags like --non-reachable-types which if absent can still
result in discrepancies between output and return code.
To achieve this in a more maintainable way, the patch introduces a new interface
reporter_base::diff_has_net_changes. That interface is implemented by
all current reporters. Each reporter focuses on its own
particularities to provide the required behavious. Then
corpus_diff:has_net_changes just has to invoke
reporter_base::diff_has_net_changes on the reporter that is currently
in used.
The tests below verify that the exit code is zero when all the changes
between the test files are suppressed.
* include/abg-reporter.h ({reporter_base, default_reporter,
leaf_reporter}::diff_has_net_changes): Add new virtual function.
This breaks binary compatibility but should conserve source
compatibility.
* src/abg-default-reporter.cc
(default_reporter::diff_has_net_changes): Define new member
function.
* src/abg-leaf-reporter.cc (leaf_reporter::diff_has_net_changes):
Likewise.
* src/abg-comparison.cc (corpus_diff::has_net_changes): Invoke
reporter_base::diff_has_net_changes on the current reporter,
rather than trying to handle all the different kinds of reporters
here.
(corpus_diff::priv::apply_filters_and_compute_diff_stats): Add a
TODO to possibly delegate the implementation of this function to
the reporters.
* tests/data/Makefile.am: Add new test case files.
* tests/data/test-abidiff-exit/test-net-change-report0.txt:
Normal mode, nothing suppressed.
* tests/data/test-abidiff-exit/test-net-change-report1.txt:
Normal mode, everything suppressed.
* tests/data/test-abidiff-exit/test-net-change-report2.txt:
Leaf mode, nothing suppressed.
* tests/data/test-abidiff-exit/test-net-change-report3.txt:
Leaf mode, everything suppressions.
* tests/data/test-abidiff-exit/test-net-change-v0.c: Test file
* tests/data/test-abidiff-exit/test-net-change-v0.o: Test file
* tests/data/test-abidiff-exit/test-net-change-v1.c: Test file
* tests/data/test-abidiff-exit/test-net-change-v1.o: Test file
* tests/data/test-abidiff-exit/test-net-change.abignore: This
suppresses changes for all variables, functions and types in
the test files, except for the 'victim' function.
* tests/test-abidiff-exit.cc: Run new test cases.
Reviewed-by: Matthias Maennich <maennich@google.com>
Signed-off-by: Giuliano Procida <gprocida@google.com>
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Giuliano Procida
|
dbef379a96 |
Support incomplete enums in core and diff code.
This is an initial implementation of the support for incomplete, also
known as forward-declared, enum types. I've not made any attempt to
refactor or share logic with the struct/union code.
* include/abg-comp-filter.h (has_decl_only_def_change) : Declare
New function.
* src/abg-comp-filter.cc (there_is_a_decl_only_enum): Define new
static function and ...
(type_size_changed): ... use it here.
(has_decl_only_def_change): Define new function and ...
(categorize_harm{less, ful}_diff_node): ... use it here.
* include/abg-fwd.h (enums_type, decl_base_wptr): Declare new
typedefs.
(look_through_decl_only_class): Declare new overload for
class_or_union*.
(is_compatible_with_enum_type, is_compatible_with_enum_type)
(look_through_decl_only, lookup_enum_types, lookup_enum_types):
Declare new functions.
* include/abg-ir.h (decl_base::{get_is_declaration_only,
set_is_declaration_only, set_definition_of_declaration,
get_definition_of_declaration,
get_naked_definition_of_declaration}): Declare new member
functions. They were moved here from the class_or_union class.
(class_or_union::{get_earlier_declaration,
set_earlier_declaration, get_definition_of_declaration,
set_definition_of_declaration,
get_naked_definition_of_declaration, get_is_declaration_only,
set_is_declaration_only}): Remove these member functions.
* src/abg-ir.cc (decl_base::priv::{declaration_,
definition_of_declaration_, naked_definition_of_declaration_,
is_declaration_only_}): Define data members. Moved here from
class_or_union.
(decl_base::priv::priv): Adjust to initialize the new data
members.
(decl_base::{get_earlier_declaration, set_earlier_declaration,
get_definition_of_declaration,
get_naked_definition_of_declaration, get_is_declaration_only,
set_is_declaration_only, set_definition_of_declaration}): Define
member functions.
(operator|): In the overload for (change_kind, change_kind),
adjust the return type of the call to
decl_base::get_definition_of_declaration.
(look_through_decl_only): Define new function.
(look_through_decl_only_class): Adjust.
(look_through_decl_only_enum): Likewise.
(maybe_update_types_lookup_map<class_decl>): Adjust return type of
call to decl_base::get_definition_of_declaration.
(types_defined_same_linux_kernel_corpus_public): Use
look_through_decl_only_class rather than open coding it.
(class_or_union::priv::{declaration_, definition_of_declaration_,
naked_definition_of_declaration_, is_declaration_only_}): Remove
these data members. They are now carried by decl_base::priv.
(class_or_union::{g,s}et_alignment_in_bits): Adjust.
(class_or_union::{g,s}et_size_in_bits): Likewise.
(class_or_union::operator==): Likewise.
(equals): Adjust the overload for class_or_union.
(is_compatible_with_enum_type)
* src/abg-comparison.cc (try_to_diff<class_decl>): Adjust the
return type of decl_base::get_definition_of_declaration.
(leaf_diff_node_marker_visitor::visit_begin): Use
filtering::has_decl_only_def_change rather than
filtering::has_class_decl_only_def_change. Decl-only changes to
enums (or any other type really) will thus not be recorded as leaf
changes.
* src/abg-dwarf-reader.cc (get_scope_for_die): Adjust return type
of decl_base::get_definition_of_declaration.
* src/abg-default-reporter.cc (default_reporter::report): Report
enum decl-only <-> definition changes.
* src/abg-hash.cc (class_or_union:#️⃣:operator()): In the
overload for class_or_union& adjust the return type for
decl_base::get_definition_of_declaration.
Signed-off-by: Giuliano Procida <gprocida@google.com>
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Giuliano Procida
|
401e3cded9 |
abg-ir.cc: Remove unused re_canonicalize function.
The function re_canonicalize was added in commit: |
||
|
Dodji Seketeli
|
346e88dd76 |
Bug 26135 - Wrong linkage name causes anonymous classes miscomparison
When comparing decls, the overload of the 'equals' function for
instances of decl_base compares their linkage names. If they are
different, then the decls are generally considered different.
Class declarations (and definitions) also use the 'equals' function
referred to above. So when two classes have different linkage names,
they are always considered different.
Now let's consider the case of an anonymous class. It doesn't have
any user-provided name, by definition. Libabigail does, however,
assigns it an internal name for various (internal) purposes. That
internal name is generally ignored for the purpose of (anonymous) type
comparison. So by design, two anonymous classes can have different
internal anonymous names and yet still happen to be equal.
The root issue in this problem report is that by default, the linkage
name of a class is set to its name. And when that class is anonymous,
its internal name is used as its linkage name. Oops. That leads to
anonymous classes being wrongly considered different.
This patch fixes the issue by providing additional constructors for a
class type to avoid using the internal anonymous name as its linkage
name.
Note that the same issue is present for unions so the patch does the
a similar thing for union types.
Enums are properly handled so we don't need to do anything in that
regard.
For good measure, the patch also adds an assert to
type_base::get_canonical_types_for to ensure that anonymous class or
union types don't have linkage names for now.
* include/abg-ir.h (class_decl::class_decl): Add two overloads
that take the "is_anonymous" flag.
(union_decl::union_decl): Likewise.
* src/abg-ir.cc (class_decl::class_decl): Define two overloads
that take the "is_anonymous" flag and set the linkage name
accordingly.
(union_decl::union_decl): Likewise.
(type_base::get_canonical_type_for): Assert that an anonymous
class or union can't have a linkage name for now.
* src/abg-dwarf-reader.cc (add_or_update_class_type)
(add_or_update_union_type): Use a new overload for the constuctor
of {class, union}_decl and set the "is_anonymous" flag. Don't use
decl_base::set_is_anonymous anymore.
* src/abg-reader.cc (build_class_decl, build_union_decl):
Likewise.
* tests/data/test-read-dwarf/PR22122-libftdc.so.abi: Adjust.
* tests/data/test-read-dwarf/test12-pr18844.so.abi: Likewise.
* tests/data/test-read-dwarf/test9-pr18818-clang.so.abi: Likewise.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Giuliano Procida
|
dd1c608120 |
Rename declaration-definition change category.
This patch renames CLASS_DECL_ONLY_DEF_CHANGE_CATEGORY to TYPE_DECL_ONLY_DEF_CHANGE_CATEGORY. * include/abg-comparison.h (TYPE_DECL_ONLY_DEF_CHANGE_CATEGORY): Rename CLASS_DECL_ONLY_DEF_CHANGE_CATEGORY into this. (EVERYTHING_CATEGORY): In the value of this enumerator, rename CLASS_DECL_ONLY_DEF_CHANGE_CATEGORY into TYPE_DECL_ONLY_DEF_CHANGE_CATEGORY. * src/abg-comp-filter.cc (categorize_harmless_diff_node): Likewise. * src/abg-comparison.cc (get_default_harmless_categories_bitmap): Likewise. (operator<<(ostream& o, diff_category c)): Likewise. * src/abg-default-reporter.cc (default_reporter::report): Likewise in the overload for class_or_union_diff. * src/abg-leaf-reporter.cc (leaf_reporter::report): Likewise in the overload for class_or_union_diff. Signed-off-by: Giuliano Procida <gprocida@google.com> Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Giuliano Procida
|
df47240f7d |
Improve code comments and whitespace.
These are zero impact changes. * include/abg-fwd.h: Correct doc-comment reference to enum_type_decl. * src/abg-comp-filter.cc: Fix doc-comment syntax. * src/abg-comparison.cc (operator<<): In the diff_category overload, fix code indentation. * src/abg-default-reporter.cc (report): In the class_or_union_diff overload, adjust comment to reflect that the code is reporting changes between declaration-only and defined types, in either direction. Signed-off-by: Giuliano Procida <gprocida@google.com> |
||
|
Dodji Seketeli
|
a5d02b95a6 |
Bug 26127 - abidw --annotate emits incomplete function types
When we get the qualified name of a pointer type, the result is cached
so that subsequent invocations of the getter yields a faster result.
When the pointed-to type is not yet fully constructed at the time of
the first invocation of the getter of the qualified name, what is
cached is the name of the pointer to a non-yet fully qualified type.
Then after the pointed-to type is fully constructed (and
canonicalized), the pointer type also becomes canonicalized (in that
order) and thus, the cache needs to be invalidated so that the
qualified name of the pointer to the fully qualified type is cached
again by a subsequent invocation of the getter.
The problem in this problem report is that the cache doesn't get
invalidated when the pointer type is canonicalized.
This patch fixes that. A similar issue exists with reference and
qualified types so the patch addresses it for those types as well.
* include/abg-ir.h (decl_base::clear_qualified_name): Declare new
protected member function.
({pointer_type_def, reference_type_def, qualified_type_def,
function_type}::on_canonical_type_set): Declare virtual member
functions.
* src/abg-ir.cc (decl_base::clear_qualified_name): Define new
protected member function.
({pointer_type_def, reference_type_def, qualified_type_def,
function_type}::on_canonical_type_set): Define virtual member
functions.
* tests/data/test-annotate/test17-pr19027.so.abi: Adjust.
* tests/data/test-annotate/test18-pr19037-libvtkRenderingLIC-6.1.so.abi:
Likewise.
* tests/data/test-annotate/test20-pr19025-libvtkParallelCore-6.1.so.abi:
Likewise.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Giuliano Procida
|
29de666641 |
abg-writer: Add support for stable hash type ids.
The type ids currently emitted by the XML writer are simply type-id-1,
type-id-2 etc. Additions or removals of types early in this sequence
result in cascading changes to many other XML elements.
This commit adds support for stable type ids in the form of hashes of
libabigail's internal type names. On fairly rare occasions (typically
involving unnamed types), the names of two distinct types can be the
same. In any case, if there is a hash collision the XML writer will
find the next unused id and so preserve uniqueness.
Diffs between large XML files produced using --type-id-style hash will
be much smaller and easier to review.
This also commit adds some test cases to verify that the hashing is
actually stable across architectures.
* doc/manuals/abidw.rst: Replace stray documentation of
--named-type-ids with documention of new --type-id-style
option.
* include/abg-writer.h (type_id_style_kind): Add new enum.
(set_type_id_style): Add new write_context setter.
(set_common_options): Set type id style in write context.
* include/abg-hash.h (fnv_hash): Declare new 32-bit FNV-1a
hash function in abigail::hashing namespace.
* src/abg-hash.h (fnv_hash): Define new 32-bit FNV-1a hash
function in abigail::hashing namespace.
* src/abg-writer.cc (write_context): Add m_type_id_style
member to record type style to use, defaulting to
SEQUENCE_TYPE_ID_STYLE; add m_used_type_id_hashes to record
already-used hashes.
(write_context::get_type_id_style): Add new getter.
(write_context::set_type_id_style): Add new setter.
(get_id_for_type): Add support for HASH_TYPE_ID_STYLE style.
(set_type_id_style): Add new helper function.
* tools/abidw.cc (options): Add type_id_style member.
(display_usage): Add description of --type-id-style option.
(parse_command_line): Parse --type-id-style option.
* tests/data/Makefile.am: Add new hash type id ABI files.
* tests/test-read-dwarf.cc: (InOutSpec): Add type_id_style
member.
(in_out_specs): Set type_id_style to SEQUENCE_TYPE_ID_STYLE in
existing test specifications. Duplicate first 9 test cases
with type_id_style set to HASH_TYPE_ID_STYLE.
* tests/data/test-read-dwarf/test0.hash.abi: New ABI XML file
with hash type ids.
* tests/data/test-read-dwarf/test1.hash.abi: Ditto.
* tests/data/test-read-dwarf/test2.so.hash.abi: Ditto.
* tests/data/test-read-dwarf/test3.so.hash.abi: Ditto.
* tests/data/test-read-dwarf/test4.so.hash.abi: Ditto.
* tests/data/test-read-dwarf/test5.o.hash.abi: Ditto.
* tests/data/test-read-dwarf/test6.so.hash.abi: Ditto.
* tests/data/test-read-dwarf/test7.so.hash.abi: Ditto.
* tests/data/test-read-dwarf/test8-qualified-this-pointer.so.hash.abi:
Ditto.
Signed-off-by: Giuliano Procida <gprocida@google.com>
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Giuliano Procida
|
660605728f |
Eliminate non-ASCII characters.
There are few non-ASCII characters in various code comments. A few are typos and the rest have obvious ASCII equivalents. This commit replaces them all with ASCII characters. * include/abg-diff-utils.h: Replace "’’" with "'". * src/abg-elf-helpers.cc: Replace "⋅" with ".". * src/abg-ini.cc: Replace "@êef" with "@ref". * src/abg-ir.cc: Ditto. * src/abg-tools-utils.cc: Replace "–" with "-". Signed-off-by: Giuliano Procida <gprocida@google.com> |
||
Matthias Maennich
|
20b989fd3c |
abg-reporter: fully qualify std::string and std::ostream
In order to not unnecessarily pollute the abigail namespace and to avoid ambiguity at compile time, fully qualify std::string and std::string. This also resolves the issue that include/abg-reporter.h could not be compiled standalone and therefore was broken as a public header. It required a `using std::string` from a prior include. * include/abg-reporter.h (reporter_base::report) fully qualify std::string and std::ostream for all overloads. (default_reporter::report_local_typedef_changes): Likewise. (default_reporter::report_local_qualified_type_changes): Likewise. (default_reporter::report_local_reference_type_changes): Likewise. (default_reporter::report_local_function_type_changes): Likewise. (default_reporter::report): Likewise. (leaf_reporter::report_changes_from_diff_maps): Likewise. (leaf_reporter::report): Likewise. Suggested-by: Mark Barolak <mbar@google.com> Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Giuliano Procida
|
2b4ff3c6cf |
Fix HARMLESS_SYMBOL_ALIAS_CHANGE_CATEGORY spelling
The enumerator HARMLESS_SYMBOL_ALIAS_CHANGE_CATEORY has a spelling mistake in it. This changes fixes this and also corrects the spelling of both this and HARMLESS_UNION_CHANGE_CATEORY when output. * include/abg-comparison.h (enum diff_category): Rename HARMLESS_SYMBOL_ALIAS_CHANGE_CATEORY enumerator to HARMLESS_SYMBOL_ALIAS_CHANGE_CATEGORY. * src/abg-comp-filter.cc (categorize_harmless_diff_node): Replace use of HARMLESS_SYMBOL_ALIAS_CHANGE_CATEORY enumerator with HARMLESS_SYMBOL_ALIAS_CHANGE_CATEGORY. * src/abg-comparison.cc (get_default_harmless_categories_bitmap): Replace use of HARMLESS_SYMBOL_ALIAS_CHANGE_CATEORY enumerator with HARMLESS_SYMBOL_ALIAS_CHANGE_CATEGORY. (operator<<): In the diff_category overload, replace use of HARMLESS_SYMBOL_ALIAS_CHANGE_CATEORY enumerator with HARMLESS_SYMBOL_ALIAS_CHANGE_CATEGORY and output correct spelling for both this and HARMLESS_UNION_CHANGE_CATEGORY. * tools/abicompat.cc (create_diff_context): Replace use of HARMLESS_SYMBOL_ALIAS_CHANGE_CATEORY enumerator with HARMLESS_SYMBOL_ALIAS_CHANGE_CATEGORY. Signed-off-by: Giuliano Procida <gprocida@google.com> |
||
|
Dodji Seketeli
|
5eb4d7627a |
Bug 25661 - Support data member replacement by anonymous data member
We ought to detect when a data member is replaced by an anonymous data
member in a way that doesn't change the ABI in an incompatible way,
especially when that change is non equivocal.
For instance, consider this ABI-visible struct:
struct S
{
int a;
};
Now, consider that it's changed into:
struct S
{
union
{
int a;
char b;
};
};
Stricto sensu, the bit-layout of struct S doesn't change and so that
change isn't ABI-incompatible.
The current version of libabigail however flags that change as a
/potential/ issue and asks the user for further review. It appears
that this class of changes is frequent enough to be annoying,
especially in semi-automatic ABI compliance checking setups where we
want the least possible "false positives".
This patch detects that kind of change patterns where a data member is
replaced by an anonymous data member in a benign way, in terms of ABI.
So now let's look at a more complicated example where an ABI-visible
type looks like:
struct S
{
int a;
int b;
int c;
};
Now suppose that type was changed into:
struct S
{
union
{
int tag[3];
struct
{
int a;
int b;
int c;
};
};
};
The patch allows abidiff to recognise that kind of pattern, filter out
the detected change and report by default that the two binaries are
ABI compatible.
Here are the output that we'd get:
$ abidiff test-v0.o test-v1.o
Functions changes summary: 0 Removed, 0 Changed (1 filtered out), 0 Added function
Variables changes summary: 0 Removed, 0 Changed, 0 Added variable
When asked to show the detailed of the filtered out changes, we get:
$ abidiff --harmless test-v0.o test-v1.o
Functions changes summary: 0 Removed, 1 Changed, 0 Added function
Variables changes summary: 0 Removed, 0 Changed, 0 Added variable
1 function with some indirect sub-type change:
[C] 'function void foo(S*)' at test-v1.cc:18:1 has some indirect sub-type changes:
parameter 1 of type 'S*' has sub-type changes:
in pointed to type 'struct S' at test-v1.cc:1:1:
type size hasn't changed
data members 'S::a', 'S::b', 'S::c' were replaced by anonymous data member:
'union {int tag[3]; struct {int a; int b; int c;};}'
And using the leaf-node reporter, that would give:
$ abidiff --leaf-changes-only --harmless test-v0.o test-v1.o
Leaf changes summary: 1 artifact changed
Changed leaf types summary: 1 leaf type changed
Removed/Changed/Added functions summary: 0 Removed, 0 Changed, 0 Added function
Removed/Changed/Added variables summary: 0 Removed, 0 Changed, 0 Added variable
'struct S at test-v0.cc:1:1' changed:
type size hasn't changed
data members 'S::a', 'S::b', 'S::c' were replaced by anonymous data member:
'union {int tag[3]; struct {int a; int b; int c;};}'
* include/abg-comp-filter.h (has_data_member_replaced_by_anon_dm):
Declare new function.
* include/abg-comparison.h (changed_var_sptr)
(changed_var_sptrs_type): Declare new typedefs.
(HARMLESS_DATA_MEMBER_CHANGE_CATEGORY): Add a new enumerator to
the diff_category enum.
(EVERYTHING_CATEGORY): In the diff_category, adjust this
enumerator to OR the new HARMLESS_DATA_MEMBER_CHANGE_CATEGORY into
it.
(SUPPRESSED_CATEGORY, PRIVATE_TYPE_CATEGORY)
(SIZE_OR_OFFSET_CHANGE_CATEGORY, VIRTUAL_MEMBER_CHANGE_CATEGORY)
(CLASS_DECL_ONLY_DEF_CHANGE_CATEGORY)
(FN_PARM_TYPE_TOP_CV_CHANGE_CATEGORY)
(FN_RETURN_TYPE_CV_CHANGE_CATEGORY, VAR_TYPE_CV_CHANGE_CATEGORY)
(VOID_PTR_TO_PTR_CHANGE_CATEGORY)
(BENIGN_INFINITE_ARRAY_CHANGE_CATEGORY): Adjust the value of these
enumerators of the diff_category enum.
(class_or_union_diff::{data_members_replaced_by_adms,
ordered_data_members_replaced_by_adms}): Declare new member
functions.
* include/abg-fwd.h (var_decl_wptr): Declare new typedef.
(get_next_data_member, get_first_non_anonymous_data_member)
(find_data_member_from_anonymous_data_member)
(get_absolute_data_member_offset): Declare new functions.
* include/abg-ir.h (struct anonymous_dm_hash): Declare new type.
(anonymous_data_member_sptr_set_type): Declare new typedef.
(class decl_base): Befriend class class_or_union.
(class dm_context_rel): Pimpl-ify this class.
(dm_context_rel::{g,s}et_anonymous_data_member_types): Declare new
member functions.
(var_decl::get_anon_dm_reliable_name): Declare new member
function.
(class var_decl): Make get_absolute_data_member_offset,
get_absolute_data_member_offset be friends of this.
(class_or_union::maybe_fixup_members_of_anon_data_member): Declare
new protected member function.
* src/abg-comp-filter.cc (has_data_member_replaced_by_anon_dm):
Define new function.
(categorize_harmless_diff_node): Use the above.
* src/abg-comparison-priv.h
(class_or_union_diff::priv::{dms_replaced_by_adms_,
changed_var_sptrs_type dms_replaced_by_adms_ordered_}): Add new
data members.
(data_member_comp::compare_data_members): Factorize this out of ...
(data_member_comp::operator()(decl_base_sptr&, decl_base_sptr&)):
... this.
(data_member_comp::operator()(changed_var_sptr&,
changed_var_sptr&)): Add new member function.
(sort_changed_data_members): Declare ...
* src/abg-comparison.cc (sort_changed_data_members): ... new
function.
(get_default_harmless_categories_bitmap): Adjust to take the new
abigail::comparison::HARMLESS_DATA_MEMBER_CHANGE_CATEGORY into
account.
(operator<<(ostream& o, diff_category c)): Likewise.
(class_or_union_diff::ensure_lookup_tables_populated): Handle
Handle the insertion of anonymous data members to replace existing
data members.
(class_or_union_diff::{data_members_replaced_by_adms,
ordered_data_members_replaced_by_adms}): Define new accessors.
(suppression_categorization_visitor::visit_end): Propagate the
SUPPRESSION_CATEGORIZATION_VISITOR from changes to the type of the
data member if the data member doesn't have real local changes.
* src/abg-default-reporter.cc (default_reporter::report): Report
about anonymous data members that replace data members.
* src/abg-ir.cc (struct dm_context_rel::priv): Define new data
structure.
(dm_context_rel::{dm_context_rel, get_is_laid_out,
set_is_laid_out, get_offset_in_bits, set_offset_in_bits,
operator==, operator!=, get_anonymous_data_member,
set_anonymous_data_member}): Define the member functions here as
they are not inline anymore.
(class_or_union::maybe_fixup_members_of_anon_data_member): Define
new member function.
(class_or_union::add_data_member): Use it.
(get_first_non_anonymous_data_member, get_next_data_member)
(get_absolute_data_member_offset)
(find_data_member_from_anonymous_data_member): Define new
functions.
* src/abg-reporter-priv.h
(maybe_report_data_members_replaced_by_anon_dm): Declare ...
* src/abg-reporter-priv.cc
(maybe_report_data_members_replaced_by_anon_dm): ... new function.
* src/abg-leaf-reporter.cc (leaf_reporter::report): Report data
members replaced by anonymous data members.
* tests/data/test-diff-filter/test-PR25661-[1-6]-report-[1-4].txt: New
test reference outputs.
* tests/data/test-diff-filter/test-PR25661-[1-6]-v{0,1}.c: Test
source code files.
* tests/data/test-diff-filter/test-PR25661-[1-6]-v{0,1}.o: Test
binary input files.
* tests/data/Makefile.am: Add the new test files above to source
distribution.
* tests/test-diff-filter.cc (in_out_specs): Add the binary test
inputs above to this test harness.
* tests/data/test-diff-dwarf/test45-anon-dm-change-report-0.txt:
Adjust.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
88fcbfeced |
dwarf-reader: support several anonymous data members in a given class
At the moment, if a class has more than one anonymous data member, we are just keeping the first one and dropping the others. This patch fixes that. Now that there is the possibility of having several anonymous data members in a given class we need to be able to name them correctly, to tell them apart. That means we cannot use the name returned by var_decl::get_name() as that name is empty for an anonymous data member. This patch thus introduces a new method var_decl::get_anon_dm_reliable_name() which returns a name that is reliable (non-empty) even when the var_decl designates an anonymous data member. Note that there are many situations where we still need to have var_decl::get_name() behave like it used to, so we can't make it invariably return what var_decl::get_anon_dm_reliable_name() returns today. * include/abg-ir.h (class_or_union::find_anonymous_data_member): Declare a new member function. (class_or_union::find_data_member): Declare a new overload. (var_decl::get_anon_dm_reliable_name): Declare new member function. * src/abg-ir.cc (var_decl::get_pretty_representation): Make this work on a var_decl is going to be used to represent an anonymous data member even before the var_decl has been added to its finale scope. This is useful to make class_or_union::find_data_member work on a var_decl that is to be used as an anonymous data member. (var_decl::get_anon_dm_reliable_name): Define new member function. (class_or_union::find_data_member): In the existing overload that takes a string, look for the named data member inside the anonymous data members. Define a new overload that takes a var_decl_sptr, to look for anonymous data members. (class_or_union::find_anonymous_data_member): Define a new member function. (lookup_data_member): Use the existing class_or_union::find_data_member. * src/abg-reader.cc: (build_class_decl): Use the full anonymous variable for lookup, rather than its name which is empty and will thus give false positives. * src/abg-dwarf-reader.cc (add_or_update_class_type): Likewise. * src/abg-comparison.cc (class_or_union_diff::ensure_lookup_tables_populated): Name anonymous data members properly - as opposed to wrongly using their empty name. * src/abg-reporter-priv.cc (represent): In the overload for var_diff_sptr, make sure that changes to the /type/ of a variable declaration are always reported. * tests/data/test-abidiff-exit/test-member-size-report0.txt: Adjust as we now emit more detailed changes about anonymous data members. * tests/data/test-abidiff-exit/test-member-size-report1.txt: Likewise. * tests/data/test-annotate/test-anonymous-members-0.o.abi: Adjust to reflect the fact that a class can now have several anonymous data members. * tests/data/test-diff-dwarf-abixml/PR25409-librte_bus_dpaa.so.20.0.abi: Likewise. * tests/data/test-diff-filter/test30-pr18904-rvalueref-report0.txt: Likewise. * tests/data/test-diff-filter/test30-pr18904-rvalueref-report1.txt: Likewise. * tests/data/test-diff-filter/test35-pr18754-no-added-syms-report-0.txt: Likewise. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Dodji Seketeli
|
48f26ddc00 |
{default,leaf}-reporter: group data members changes reports together
There are two kinds of data member changes:
1/ changes to the type or offset of a given data member
basically, in this kind of change, the name of the data member
remained the same.
2/ changes where the data member (at a given offset) was replaced by
something else completely.
Today, the comparison engine recognizes these two kinds of changes and
records them in two different data structures. This is useful because
it allows for a finer grain analysis.
But when we report these changes, today, we report them separately and
sometimes that doesn't make sense. For instance, because there is no
change of the 1/ kind, the reporter would say "no data member
changes", and yet go ahead and emit data member changes of the 2/ kind.
This patch groups the reporting of the two kinds of changes so that
when it says "no data member changes", it means there was no data
member changes at all.
* include/abg-comparison.h
(class_or_union_diff::{sorted_changed_data_members,
count_filtered_changed_data_members,
sorted_subtype_changed_data_members,
count_filtered_subtype_changed_data_members}): Declare ...
* src/abg-comparison.cc
(class_or_union_diff::{sorted_changed_data_members,
count_filtered_changed_data_members,
sorted_subtype_changed_data_members,
count_filtered_subtype_changed_data_members}): ... accessors for
existing private data members.
* src/abg-default-reporter.cc (default_reporter::report): In the
class_or_union_diff& overload, group the reporting of the changes
to data member sub-types with the replacement of data members.
These are just data member changes after all. Use the newly
declared accessors for better measure.
* src/abg-leaf-reporter.cc (leaf_reporter::report): Likewise.
* tests/data/test-diff-dwarf/test45-anon-dm-change-report-0.txt: Adjust.
* src/abg-leaf-reporter.cc (leaf_reporter::report): Likewise.
* tests/data/test-diff-pkg/spice-server-0.12.4-19.el7.x86_64-0.12.8-1.el7.x86_64-report-2.txt:
Likewise.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Giuliano Procida
|
38504ab66c |
Tidy get_pretty_representation qualified_name.
The virtual function get_pretty_representation exists in many classes (derived from type_or_decl_base). It takes a qualified_name argumenta and this is defaulted to true in all but one case which seems to be an oversight. This commit changes this for no better reason than consistency. * include/abg-ir.h (type_decl::get_pretty_representation) Change default for qualified_name parameter to true. Signed-off-by: Giuliano Procida <gprocida@google.com> |
||
Mark Wielaard
|
66e5e36469 |
Don't iterate before the start of a RandomAccessOutputIterator.
Found with -D_GLIBCXX_DEBUG. You cannot go before the start of an RandomAccessOutputIterator. Iterator -1 + 1 might seem to work, but is actually undefined behaviour. * include/abg-diff-utils.h (compute_diff): Put brackets around p[ux].[xy]() + 1 calculation. Signed-off-by: Mark Wielaard <mark@klomp.org> |
||
|
Giuliano Procida
|
c72f52c381 |
Add POSIX regex wrapper functions.
libabigail code uses the POSIX regex library consistently:
- compile std::string to regex, with the flag REG_EXTENDED
- store regex using a shared pointer wrapper
- check match of regex against std::string
All the C string / std::string logic and so on is repeated at every
call site. This patch introduces wrapper functions to take care of
this logic.
There are no behavioural changes.
* include/abg-regex.h (compile): Declare new function.
(match): Declare new function.
* src/abg-regex.cc (compile): Add new function wrapping
regcomp. (match): Add new function wrapping regexec.
Reviewed-by: Matthias Maennich <maennich@google.com>
Signed-off-by: Giuliano Procida <gprocida@google.com>
|
||
|
Giuliano Procida
|
44ce7a5755 |
Escape names used in symbol whitelisting regex.
There is the theoretical possibility that symbols may contain special regex characters like '.' and '$'. This patch ensures all such characters in symbol names are escaped before they are added to the whitelisting regex. * include/regex.h (escape): New string reference holder class. (operator<<): Declaration of std::ostream, regex::escape overload. * include/regex.cc (operator<<): New std::ostream, regex::escape overload that outputs regex-escaped strings. * src/abg-tools-utils.cc (gen_suppr_spec_from_kernel_abi_whitelists): Make sure any special regex characters in symbol names are escaped. Reviewed-by: Matthias Maennich <maennich@google.com> Signed-off-by: Giuliano Procida <gprocida@google.com> |
||
|
Giuliano Procida
|
1a3c6ec12a |
Make set_drops_artifact_from_ir non-const.
Setters should be non-const but set_drops_artifact_from_ir isn't. This patch fixes this. This reason this didn't cause a compilation failure is that const shared_ptr<X> is equivalent to X *const, not const X*. Note that resolving the apparent const-safety issue will require std::experimental::propagate_const or similar. * include/abg-suppression.h (suppression_base::set_drops_artifact_from_ir): Drop const qualifier. * src/abg-suppression.cc (suppression_base::set_drops_artifact_from_ir): Drop const qualifier. Reviewed-by: Matthias Maennich <maennich@google.com> Signed-off-by: Giuliano Procida <gprocida@google.com> |
||
|
Giuliano Procida
|
8282d92304 |
Remove stray semicolons.
This patch removes various stray semicolons. * include/abg-diff-utils.h (display_edit_script): Remove redundant semicolon. * include/abg-fwd.h (lookup_basic_type): Ditto. * src/abg-comparison.cc (mark_diff_as_visited): Ditto. (array_diff::has_local_changes): Ditto. (class_diff::ensure_lookup_tables_populated): Ditto. * src/abg-corpus.cc (corpus::priv::build_unreferenced_symbols_tables): Ditto. * src/abg-default-reporter.cc (default_reporter::report): Ditto. * src/abg-dwarf-reader.cc (finish_member_function_reading): Ditto. * src/abg-ir.cc (is_compatible_with_class_type): Ditto. (enum_type_decl::enumerator::set_name): Ditto. * src/abg-reader.cc (read_corpus_from_input): Ditto. (build_function_type): Ditto. * src/abg-suppression.cc (type_suppression::suppresses_type): Ditto. Reviewed-by: Matthias Maennich <maennich@google.com> Signed-off-by: Giuliano Procida <gprocida@google.com> |
||
|
Matthias Maennich
|
246ca20049 |
corpus/writer: sort emitted translation units by path name
By sorting the corpora output, we achieve determinism for the emitted XML file across multiple runs of abidw. For that to happen, change the collection of translation units to a std::set (instead of std::vector), sorted by absolute path name. Test data needed adjustments, but changes are fully compatible. * include/abg-fwd.h: remove translation_units fwd declaration. * include/abg-ir.h (struct shared_translation_unit_comparator): Define new class. (translation_units): Define new typedef. * src/abg-corpus.cc (corpus::add): do checked insert into the translation_units set (rather than vector::push_back) * tests/data/test-annotate/test13-pr18894.so.abi: Adjust test data. * tests/data/test-annotate/test14-pr18893.so.abi: Likewise. * tests/data/test-annotate/test15-pr18892.so.abi: Likewise. * tests/data/test-annotate/test17-pr19027.so.abi: Likewise. * tests/data/test-annotate/test18-pr19037-libvtkRenderingLIC-6.1.so.abi: Likewise. * tests/data/test-annotate/test19-pr19023-libtcmalloc_and_profiler.so.abi: Likewise. * tests/data/test-annotate/test20-pr19025-libvtkParallelCore-6.1.so.abi: Likewise. * tests/data/test-annotate/test21-pr19092.so.abi: Likewise. Signed-off-by: Matthias Maennich <maennich@google.com> Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Dodji Seketeli
|
f014f8c1f0 |
Fix compilation with g++ 4.8.5 on el7
G++ 4.8.5 doesn't allow a function template specialization to appear in a namespace that is different from the namespace where the function template was declared. Also, in that namespace, the name of the specialized function template must be non-fully-qualified. Fixed thus. * include/abg-libxml-utils.h (build_sptr<xmlTextReader>): Wrap this specialization in the namespace sptr_utils and do away with the sptr_utils qualifier. * include/abg-regex.h (build_sptr<regex_t>): Likewise. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Giuliano Procida
|
186cc9ed3a |
Simplify generation of symbol whitelist regex.
The code to build the symbol whitelist regex uses things like seekp and tellp to generate regexes like "^foo$|^bar$". This patch simplifies the code, for further enhancement, resulting in generated regexes like "^(foo|bar)$". There should be no change in behaviour, unless whitelisted symbol names contain special regex characters. * include/abg-regex.h (generate_from_strings): Declare new function to build a regex from some strings, representing a membership test. * src/abg-regex.cc (generate_from_strings): Implement new function to build a regex from some strings, representing a membership test, in a straightfoward fashion. * src/abg-tools-utils.cc (gen_suppr_spec_from_kernel_abi_whitelists): Replace regex-building code with a call to generate_from_strings. * tests/test-kmi-whitelist.cc: Update regexes in test. Signed-off-by: Giuliano Procida <gprocida@google.com> |
||
|
Giuliano Procida
|
0082ee529f |
Move libxml bits out of abg-sptr-utils.h.
The header file abg-sptr-utils.h contains generic things relating to shared pointers. It also contains shared pointer typedefs (in the sptr_utils namespace) and template specialisations for XML types. The last of these more naturally belong in abg-libxml-utils.h (and in the xml namespace). This patch moves them. There are no behavioural changes. * include/abg-sptr-utils.h: Remove reader_sptr and xml_char_sptr typedefs, from namespace sptr_utils. (build_sptr): Remove corresponding template function specialisations for these types. * include/abg-libxml-utils.h: Add reader_sptr and xml_char_sptr typedefs, to namespace xml. (build_sptr): Add corresponding template function specialisations for these types. Signed-off-by: Giuliano Procida <gprocida@google.com> |
||
|
Giuliano Procida
|
ae30e5fa96 |
Move regex definitions to own files.
As a prelude to adding wrapper and helper functions for regex functionality, it makes sense to move the existing regex code (the shared pointer type and its specialised deleter) to their own files. This patch does this and also moves various entities into a new namespace, abigail::regex. It removes the file abg-sptr-utils.cc which only contained regex things. There are no behavioural changes. * include/Makefile.am: Add abg-regex.h. * src/Makefile.am: Remove abg-sptr-utils.h, add abg-regex.cc * include/abg-sptr-utils.h (regex_t_sptr): Remove this typedef, from namespace abigail::sptr_utils. (regex_t_deleter): Remove this struct, from namespace abigail::sptr_utils. (build_sptr): Remove these template specialisations, in duplicate, for regex_t_sptr. * include/abg-regex.h: New file, introduces namespace abigail::regex. (regex_t_sptr): Add this typedef, to namespace abigail::regex. (regex_t_deleter): Add this struct, to namespace abigail::regex. (build_sptr): Add these template specialisations for regex_t_sptr * src/abg-sptr-utils.cc: Remove this file. * src/abg-regex.cc: Add new file with contents effectively the same as abg-sptr-utils.cc. * src/abg-corpus-priv.h: Update regex_t_sptr namespace qualification. * src/abg-corpus.cc: Ditto. * src/abg-suppression-priv.h: Ditto. * src/abg-suppression.cc: Ditto. Signed-off-by: Giuliano Procida <gprocida@google.com> Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Mark Wielaard
|
a9f5fb4089 |
Add --no-write-default-sizes option.
abidw will write out the exact same size-in-bits address for every
pointer type, reference type, function declaration and function type
even though it is always the same as the translation unit address
size. When giving the --no-write-default-sizes option these aren't
written out anymore. The reader is updated to set the default size
when none is given in the XML description.
Even though size and alignment are handled together in the reader,
default alignment is still set to zero, following commit
|
||
|
Mark Wielaard
|
b8860e1db3 |
Add --no-elf-needed option to drop DT_NEEDED list from corpus.
The elf-needed list is not relevant for the exported ABI of a library
so provide an option to drop it.
* doc/manuals/abidw.rst: Document --no-elf-needed.
* include/abg-writer.h (set_write_elf_needed): New function.
(set_common_options): Call it.
* src/abg-writer.cc (write_context::m_write_elf_needed): New data
member.
(write_context::{g,s}et_write_elf_needed): Add new accessors.
(set_write_elf_needed): New function.
(write_context::write_corpus): Check write_elf_needed.
* tools/abidw.cc (options): Add write_elf_needed bool.
(display_usage): Describe --no-elf-needed.
(parse_command_line): Parse --no-elf-needed.
Signed-off-by: Mark Wielaard <mark@klomp.org>
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Mark Wielaard
|
8da509aaa2 |
Add no-parameter-names to drop function parameter names.
The function parameter names are not relevant for the (exported) ABI. So provide an option to simply drop them from the corpus. * doc/manuals/abidw.rst: Add documentation for --no-parameter-names. * include/abg-writer.h (set_write_parameter_names): New function. (set_write_parameter_names): Call it. * src/abg-writer.cc (write_context): Add m_write_parameter_names bool, get_write_parameter_names and set_write_parameter_names functions. (write_context::write_function_decl): Check write_parameter_names. * tools/abidw.cc (options): Add write_parameter_names. (display_usage): Describe --no-parameter-names. (parse_command_line): Parse --no-parameter-names. Signed-off-by: Mark Wielaard <mark@klomp.org> Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Mark Wielaard
|
254cafb7d7 |
Add --drop-undefined-syms to abidw.
Add a drop_undefined_syms properties to the read_context that indicates the reader wants to drop any undefined symbols (which don't have associated addresses in the corpus). Implement this for the dwarf_reader and abidw (when using the --drop-undefined-syms option). * include/abg-dwarf-reader.h (set_drop_undefined_syms): New declaration. * src/abg-dwarf-reader.cc (class read_context): Add private bool drop_undefined_syms_. (drop_undefined_syms): New getter and setter method. (set_drop_undefined_syms): New function. (function_is_suppressed): Check drop_undefined_syms on read_context. (variable_is_suppressed): Likewise. * src/abg-reader.cc (read_context): Add private bool m_drop_undefined_syms. (drop_undefined_syms): New getter and setter method. * tools/abidw.cc (struct options): Add drop_undefined_syms. (display_usage): Print --drop-undefined-syms. (parse_command_line): Parse --drop-undefined-syms. (main): Call set_drop_undefined_syms. Signed-off-by: Mark Wielaard <mark@klomp.org> Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Mark Wielaard
|
9fe85b370c |
Add --header-file option to add individual public header files.
Sometimes public header files are in the same directory as private header files. In such cases --headers-dir cannot be used. Add --header-file to add individual public header files. * include/abg-tools-utils.h (gen_suppr_spec_from_headers): Add hdr_files string vector argument. * src/abg-tools-utils.cc (handle_file_entry): New function that adds one specific file to the type_suppression. Implementation lifted from... (handle_fts_entry): ...here. Call handle_file_entry for each file. (gen_suppr_spec_from_headers): Also takes a header_files string vector as argument. Call handle_file_entry for each file entry. * tools/abidiff.cc (options): Add header_files1 and header_files2 string vectors. (display_usage): Print --header-file1 and --header-file2 usage. (parse_command_line): Handle --header-file1, --hf1 and --header-file2, --hf2. (set_diff_context_from_opts): Call gen_suppr_spec_from_headers with header_files1 and header_files2. (set_suppressions): Likewise. * tools/abidw.cc (options): Add header_files string vector. (display_usage): Print --header-file usage. (parse_command_line): Handle --header-file1, --hf1. (maybe_check_header_files): New function. (set_suppressions): Call gen_suppr_spec_from_headers with header_files. (main): Call maybe_check_header_files. * tools/abilint.cc (options): Add header_files string vector. (display_usage): Print --header-file usage. (parse_command_line): Handle --header-file1, --hf1. (set_suppressions): Call gen_suppr_spec_from_headers with header_files. * doc/manuals/abidiff.rst: Document --header-file1, --hf1 and --header-file2, --hf2. Add new options to documentation of --drop-private-types. * doc/manuals/abidw.rst: Document --header-file, --hf. * doc/manuals/abilint.rst: Likewise. Signed-off-by: Mark Wielaard <mark@klomp.org> Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Giuliano Procida
|
ef90972a4a |
abidiff: Remove blank line after typedef changes.
This patch removes perhaps the last remaining cause of double blank lines in output. The state variable emit_nl was being set to true just after emitting a new line which resulted in a blank line after every local typedef change report. * include/abg-reporter.h (default_reporter::report_local_typedef_changes): Change return type to void. * src/abg-default-reporter.cc: (default_reporter::report_local_typedef_changes): Change return type to void, remove emit_nl state variable and logic. * tests/data/test-abidiff/test-PR18791-report0.txt: Remove blank lines. * tests/data/test-diff-dwarf/test42-PR21296-clanggcc-report0.txt: Ditto. * tests/data/test-diff-suppr/test39-opaque-type-report-0.txt: Ditto. Signed-off-by: Giuliano Procida <gprocida@google.com> |
||
|
Giuliano Procida
|
2d5389f265 |
Fix size calculations for multidimensional arrays.
The code in abg-ir.cc that calculated the memory size of an array summed, rather than multiplied, the dimensions. It also did duplicate work for each dimension after the first. Existing code in abg-reader.cc asserted that array size information read from XML match freshly calculated values. This patch corrects the calculation, eliminates the duplicate work and updates the XML reader validation to just emit a warning if old bad array size information is found. * include/abg-ir.h (array_type_def::append_subrange): Remove this function. * src/abg-ir.cc (array_type_def::set_element_type): Add a note about safe usage. (array_type_def::append_subrange): Inline this function into its only caller append_subranges and remove it. (array_type_def::append_subranges): Do correct multiplicative calculation of multidimensional array sizes. * src/abg-reader.cc (build_array_type_def): When checking calculated against read array sizes, warn once if value matches old behaviour rather than raising an assertion. Otherwise, before raising an assertion, emit an informative error message. * tests/data/test-annotate/test14-pr18893.so.abi: Correct array sizes. * tests/data/test-annotate/test17-pr19027.so.abi: Ditto. * tests/data/test-annotate/test19-pr19023-libtcmalloc_and_profiler.so.abi: Ditto. * tests/data/test-annotate/test7.so.abi: Ditto. * tests/data/test-diff-dwarf/test10-report.txt: Ditto. * tests/data/test-diff-dwarf/test11-report.txt: Ditto. * tests/data/test-read-write/test25.xml: Ditto. Reviewed-by: Matthias Maennich <maennich@google.com> Signed-off-by: Giuliano Procida <gprocida@google.com> |
||
|
Giuliano Procida
|
9cf76b1175 |
abg-ir.cc: Improve types_have_similar_structure.
This function is used to determine whether or not type differences are
"local" and is primarily used in --leaf-changes-only mode. The logic
has some issues which are addressed by this patch:
- Any number of points-to (*) and refers-to (& and &&) components
are peeled off the types being compared, rather than checking
these match in number and kind.
- This peeling is done with peel_typedef_pointer_or_reference_type
which also peels any number of CV qualifiers (OK) and
array-of ([N]) type components (not OK).
- The function sets a state variable (was_indirect_type) to modify
the behaviour of downstream comparisons, but this cannot be
passed through recursive calls.
The effect of the indirect_type flag is to switch to comparisons by
name: identically named structs don't get introspected. Arguably, a
more useful behaviour for --leaf-changes-only mode would be to treat
any change to a named type as non-local, except in the context of the
definition of that type itself. This would be a more significant
change in behaviour.
* include/abg-fwd.h (types_have_similar_structure): In both
overloads, add an indirect_type argument, defaulting to
false.
* src/abg-ir.cc (reference_type_def constructor): Tabify.
(types_have_similar_structure): In both overloads, add an
indirect_type argument and update documentation text. In the
type_base_sptr overload, pass indirect_type in the tail
call. In the type_base* overload, replace was_indirect_type
with indirect_type; peel CV qualifiers and typedefs without
testing as the peel function does this; replace the
indiscriminate peeling of qualifier/pointer/reference/array
type components with code that checks the same
pointer/reference/array type component is used on each side
and makes recursive calls with indirect_type set to true; pass
the indirect_type argument recursively when comparing other
subtypes; move the typeid check earlier, document its purpose
and remove unneccessary checks after later dynamic casts;
remove an always-true conditional; add a TODO for comparing
array types more accurately.
* tests/data/Makefile.am: Add new test case files.
* tests/data/test-abidiff-exit/test-leaf-peeling-v0.cc: New
test case.
* tests/data/test-abidiff-exit/test-leaf-peeling-v1.cc: Ditto.
* tests/data/test-abidiff-exit/test-leaf-peeling-report.txt:
Ditto.
* tests/test-abidiff-exit.cc: Run new test case.
Signed-off-by: Giuliano Procida <gprocida@google.com>
|
||
|
Giuliano Procida
|
b0ce702088 |
Eliminate redundancy in representation of local change kinds.
* include/abg-ir.h (change_kind): Remove redundant
LOCAL_CHANGE_KIND member, renumber members and update
comments.
* src/abg-comparison.cc (distinct_diff::has_local_changes):
Remove redundant LOCAL_CHANGE_KIND.
(var_diff::has_local_changes
* src/abg-ir.cc (equals): In the type_base,
qualified_type_def, pointer_type_def, reference_type_def,
array_type_def::subrange_type, array_type_def, enum_type_decl,
typedef_decl, var_decl, function_type, function_decl,
function_decl::parameter, class_or_union,
class_decl::base_spec, class_decl, decl_base and scope_decl
overloads, remove redundant LOCAL_CHANGE_KIND.
(enum_has_non_name_change): Remove redundant
LOCAL_CHANGE_KIND.
Signed-off-by: Giuliano Procida <gprocida@google.com>
|
||
|
Dodji Seketeli
|
1d6731c438 |
Update copyright year to 2020
We are in February 2020 so this is long overdue. * include/abg-comp-filter.h: Update copyright year to 2020. * include/abg-comparison.h: Likewise. * include/abg-config.h: Likewise. * include/abg-corpus.h: Likewise. * include/abg-cxx-compat.h: Likewise. * include/abg-diff-utils.h: Likewise. * include/abg-dwarf-reader.h: Likewise. * include/abg-fwd.h: Likewise. * include/abg-hash.h: Likewise. * include/abg-ini.h: Likewise. * include/abg-interned-str.h: Likewise. * include/abg-ir.h: Likewise. * include/abg-libxml-utils.h: Likewise. * include/abg-libzip-utils.h: Likewise. * include/abg-reader.h: Likewise. * include/abg-reporter.h: Likewise. * include/abg-sptr-utils.h: Likewise. * include/abg-suppression.h: Likewise. * include/abg-tools-utils.h: Likewise. * include/abg-traverse.h: Likewise. * include/abg-viz-common.h: Likewise. * include/abg-viz-dot.h: Likewise. * include/abg-viz-svg.h: Likewise. * include/abg-workers.h: Likewise. * include/abg-writer.h: Likewise. * src/abg-comp-filter.cc: Likewise. * src/abg-comparison-priv.h: Likewise. * src/abg-comparison.cc: Likewise. * src/abg-config.cc: Likewise. * src/abg-corpus-priv.h: Likewise. * src/abg-corpus.cc: Likewise. * src/abg-default-reporter.cc: Likewise. * src/abg-diff-utils.cc: Likewise. * src/abg-dwarf-reader.cc: Likewise. * src/abg-hash.cc: Likewise. * src/abg-ini.cc: Likewise. * src/abg-internal.h: Likewise. * src/abg-ir-priv.h: Likewise. * src/abg-ir.cc: Likewise. * src/abg-leaf-reporter.cc: Likewise. * src/abg-libxml-utils.cc: Likewise. * src/abg-libzip-utils.cc: Likewise. * src/abg-reader.cc: Likewise. * src/abg-reporter-priv.cc: Likewise. * src/abg-reporter-priv.h: Likewise. * src/abg-sptr-utils.cc: Likewise. * src/abg-suppression-priv.h: Likewise. * src/abg-suppression.cc: Likewise. * src/abg-tools-utils.cc: Likewise. * src/abg-traverse.cc: Likewise. * src/abg-viz-common.cc: Likewise. * src/abg-viz-dot.cc: Likewise. * src/abg-viz-svg.cc: Likewise. * src/abg-workers.cc: Likewise. * src/abg-writer.cc: Likewise. * tests/print-diff-tree.cc: Likewise. * tests/test-abicompat.cc: Likewise. * tests/test-abidiff-exit.cc: Likewise. * tests/test-abidiff.cc: Likewise. * tests/test-alt-dwarf-file.cc: Likewise. * tests/test-core-diff.cc: Likewise. * tests/test-diff-dwarf-abixml.cc: Likewise. * tests/test-diff-dwarf.cc: Likewise. * tests/test-diff-filter.cc: Likewise. * tests/test-diff-pkg.cc: Likewise. * tests/test-diff-suppr.cc: Likewise. * tests/test-diff2.cc: Likewise. * tests/test-dot.cc: Likewise. * tests/test-ini.cc: Likewise. * tests/test-ir-walker.cc: Likewise. * tests/test-lookup-syms.cc: Likewise. * tests/test-read-dwarf.cc: Likewise. * tests/test-read-write.cc: Likewise. * tests/test-svg.cc: Likewise. * tests/test-tools-utils.cc: Likewise. * tests/test-types-stability.cc: Likewise. * tests/test-utils.cc: Likewise. * tests/test-utils.h: Likewise. * tests/test-write-read-archive.cc: Likewise. * tools/abiar.cc: Likewise. * tools/abicompat.cc: Likewise. * tools/abidiff.cc: Likewise. * tools/abidw.cc: Likewise. * tools/abilint.cc: Likewise. * tools/abipkgdiff.cc: Likewise. * tools/abisym.cc: Likewise. * tools/binilint.cc: Likewise. * tools/kmidiff.cc: Likewise. * update-copyright.sh: Fix the updating script to handle not just "Red Hat, Inc." Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Dodji Seketeli
|
6a0e7e120b |
abixml-reader: Support SONAME related properties on file suppression
When comparing binary files (using abidiff for instance) libabigail
can interpret the [suppress_file] section of a suppression
specification. If the suppression specification matches either of the
compared files, no comparison is performed.
At the moment, that doesn't work when comparing abixml files.
Thus, this patch implements that feature for abixml files.
With this patch, one can now write a suppression specification like
this:
[suppress_file]
soname_regexp = <some-regexp>
or
[suppress_file]
file_name_regexp = <some-regexp>
If either abixml file has a soname matched by such a regexp, then no
comparison is performed.
* doc/manuals/libabigail-concepts.rst: Update the documentation to
mention soname_regexp and soname_not_regexp is supported in the
[suppress_file] section.
* include/abg-suppression.h (suppression_matches_soname)
(suppression_matches_soname_or_filename): Declare new functions.
Make them be friends of class suppression_base.
* src/abg-reader.cc
(read_context::corpus_is_suppressed_by_soname_or_filename): Define
new member function.
(read_corpus_from_input): Apply file suppression.
* src/abg-suppression.cc (read_file_suppression): Support
"soname_regexp" and "soname_not_regexp" in the [suppress_file]
section.
(suppression_matches_soname)
(suppression_matches_soname_or_filename): Define new functions.
* tests/data/test-diff-suppr/libtest48-soname-abixml-report-{1,2}.txt:
New test reference output files.
Likewise.
* tests/data/test-diff-suppr/libtest48-soname-abixml-suppr.txt:
New test suppression file.
* tests/data/test-diff-suppr/libtest48-soname-abixml-suppr-{2,3,4}.txt::
Likewise.
* tests/data/test-diff-suppr/libtest48-soname-abixml-v{0,1}.so: New
test binary input files.
* tests/data/test-diff-suppr/libtest48-soname-abixml-v{0,1}.so.abi:
New abixml for the binary input files above.
* tests/data/test-diff-suppr/test48-soname-abixml-v{0,1}.c: Source
code of the binary input files above.
* tests/data/Makefile.am: Add the above test material to source
distribution.
* tests/test-diff-suppr.cc (in_out_specs): Add the test input
above to this test harness.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
f5fd6931f6 |
suppression: Better handle soname/filename properties evaluation
At the moment, we don't make any difference between these two cases:
1/ A suppression specification has no soname or file name related
property.
2/ A suppression specification has a soname or file name related
property that doesn't match the soname or file name of a given
corpus.
In both cases 1/ and 2/ libabigail currently assumes that the
suppression specification does not match the given corpus we are
looking at. This can be wrong, especially if we are in the case 1/
and if the suppression does have other properties that should make it
match the corpus.
This patch fixes this issue.
* include/abg-suppression.h
(suppression_base::has_{soname,file_name}_related_property): Add
new member functions.
* src/abg-dwarf-reader.cc (read_context::suppression_can_match):
Fix the logic to make a difference between the case where the
suppression doesn't have any soname/filename property and the case
where the suppression does have a soname/filename property that
does not match the current binary.
* src/abg-reader.cc (read_context::suppression_can_match):
Likewise.
* src/abg-suppression-priv.h
(suppression_base::priv::matches_soname): If the suppression does
not have any soname related property then it doesn't match the
soname we are looking at.
(suppression_base::priv::matches_binary_name): If the suppression
does not have any filename related property then it doesn't match
the filename we are looking at.
* src/abg-suppression.cc
(suppression_base::has_{soname,file_name}_related_property):
Define new member functions.
(sonames_of_binaries_match): If the suppression does not have any
soname related property then it doesn't match the corpora of the
diff we are looking at.
(names_of_binaries_match): If the suppression does not have any
filename related property then it doesn't match the corpora of the
diff we are looking at.
(type_suppression::suppresses_type): Fix the logic to make a
difference between the case where the suppression doesn't have any
soname/filename property and the case where the suppression does
have a soname/filename property that does not match the current
binary.
(function_suppression::suppresses_{function, function_symbol}):
Likewise.
(variable_suppression::suppresses_{variable, variable_symbol}):
Likewise.
(file_suppression::suppresses_file): Likewise.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Matthias Maennich
|
91a4274c9c |
abg-workers: Rework the worker queue to improve concurrent behaviour
This patch refactors the abigail::workers::queue and abigail::workers::worker implementations to avoid holding locking primitives longer than necessary. In particular, the queue_cond_mutex was held during the entiry worker runtime, effectively serializing the workers. Hence, use a mutex+cond pair for each, the input and output queue and only synchronize around the interaction with their corresponding queues. The tasks_todo_(mutex|cond) are meant to synchronize scheduling and distribution of work among workers, while tasks_done_(mutex|cond) are used for synchronizing threads when putting back the tasks to the output queue and to hold back threads waiting for the queue and workers to drain. Along that way, I did some cleanup that was now possible. - Move entire implementation of abigail::workers::task into header. - Make default_notify a static member. - Replace the multiple constructors with one with default arguments. * include/abg-workers.h (workers::task): move entire implementation to header and drop superfluous forward declaration. * src/abg-workers.cc (workers::task):: Likewise. (workers::queue::priv): Drop queue_cond_mutex, rename queue_cond to tasks_todo_cond, add task_done_cond, make default_notify static. (workers::queue::priv::priv): Add default arguments to fully qualified constructor, drop the remaining ones. (workers::queue:prive::more_tasks_to_execute): Drop method. (workers::queue:prive::schedule_task): Do not synchronize access to the queue condition variable, but only on the mutex. (do_bring_workers_down): Likewise. Also await tasks_done to be empty. (workers::queue:prive::worker::wait_to_execute_a_task): Await tasks on the tasks_todo with tasks_todo_(cond|mutex) and signal task completion to tasks_done_cond. Signed-off-by: Matthias Maennich <maennich@google.com> Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Matthias Maennich
|
48c8da31c0 |
abg-fwd: drop duplicate forward declaration for corpus_sptr
This declaration has already been done some lines above. Drop the duplicate. * include/abg-fwd.h: drop superfluous forward declaration. Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Matthias Maennich
|
fe214f0f70 |
Fix / add include guards
Fix the include guards of abg-dwarf-reader.h and abg-reporter-priv.h by moving them before any other includes where they actually belongs. Add missing include guards for abg-libxml-utils.h and abg-libzip-utils.h. * include/abg-dwarf-reader.h: Move include guard to the beginning. * include/abg-reporter-priv.h: Likewise. * include/abg-libxml-utils.h: Add include guard. * include/abg-libzip-utils.h: Likewise. Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Matthias Maennich
|
9ab71105eb |
KMI Whitelists: Drop old whitelist extraction methods
The previous commit introduces a new (tested) way of creating function and variable suppressions from multiple whitelist definitions. Migrate to this new way of processing KMI whitelists. * include/abg-tools-utils.h (gen_suppr_spec_from_kernel_abi_whitelist): Delete declaration. * src/abg-tools-utils.cc (gen_suppr_spec_from_kernel_abi_whitelist): Delete definition and migrate users to gen_suppr_spec_from_kernel_abi_whitelists. * tools/abidiff.cc (set_suppressions): Migrate from using gen_suppr_spec_from_kernel_abi_whitelist to gen_suppr_spec_from_kernel_abi_whitelists. * tools/abidw.cc (set_suppressions): Likewise. * tools/abipkgdiff.cc: Drop unused using definition. * tools/kmidiff.cc: Likewise. Reviewed-by: Dodji Seketeli <dodji@seketeli.org> Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Matthias Maennich
|
4ecde9a800 |
KMI Whitelists: Add functionality to make whitelists additive
If multiple KMI whitelists are specified, either by passing --kmi-whitelist several times or by having multiple whitelist sections in the whitelist files, the generated suppressions are created as an intersection of symbols. That is rather unusual, as whitelisting should rather work additive. That means that the symbols (or expressions thereof) defined across several sections or files shall be considered a union of symbols. This patch combines the whitelist parsing to create exactly one function_suppression and one variable suppression. A test case has been added to ensure the functionality is working. Please note, migrating the existing code to this new functionality is done in a separate commit. * include/abg-tools-utils.h (gen_suppr_spec_from_kernel_abi_whitelists): New function. * src/abg-tools-utils.cc (gen_suppr_spec_from_kernel_abi_whitelists): Likewise. * tests/.gitignore: Ignore new test executable. * tests/Makefile.am: Add new test executable. * tests/data/test-kmi-whitelist/whitelist-with-another-single-entry: New test input file. * tests/data/test-kmi-whitelist/whitelist-with-duplicate-entry: Likewise. * tests/data/test-kmi-whitelist/whitelist-with-single-entry: Likewise. * tests/data/test-kmi-whitelist/whitelist-with-two-sections: Likewise. * tests/data/Makefile.am: Add above test material. * tests/test-kmi-whitelist.cc: Add new test executable. Reviewed-by: Dodji Seketeli <dodji@seketeli.org> Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Matthias Maennich
|
ade58f9c49 |
Add (undocumented) support for version suffixes
Allow appending arbitrary text to the libabigail version string representation. That is useful to identify custom versions of the library (e.g. development versions or versions of a particular origin). The feature can be enabled by passing VERSION_SUFFIX to `configure`, e.g. $ configure VERSION_SUFFIX="-dev" That will extend the version string to (currently) 1.7.0-dev. The behaviour before this patch remains the default behaviour of not appending any additional text. The feature stays intentionally undocumented as the main release of libabigail will usually not carry a version suffix. * configure.ac: add substitution for VERSION_SUFFIX * include/abg-version.h.in: add define for ABIGAIL_VERSION_SUFFIX * include/abg-config.h(abigail_get_library_version): add support for a version suffix * src/abg-config.cc(abigail_get_library_version): Likewise. * src/abg-tools-utils.cc(get_library_version_string): Likewise. Reviewed-by: Dodji Seketeli <dodji@seketeli.org> Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Dodji Seketeli
|
c32b8ec9f3 |
Bug 24690 - Support comparing non-reachable types of a binary
This patch adds the ability to compare all types of a binary,
including those types that are not reachable from global functions and
variables.
This implies that for types that are not reachable from public
interfaces, we want compare them against each others directly, without
first comparing global functions/variables and walking the graph of
reachable types from there.
The patch adds the --non-reachable-types option to abidiff and
abipkgdiff, instructing them to also compare types that are
non-reachable from global variables and functions.
Using that option, for instance, here is what the summary of
abipkgdiff now looks like, in the test case attached added by this
patch:
================ changes of 'libflatpak.so.0.10204.0'===============
Functions changes summary: 0 Removed, 0 Changed (16 filtered out), 16 Added functions
Variables changes summary: 0 Removed, 0 Changed, 0 Added variable
Unreachable types summary: 3 removed (2 filtered out), 1 changed (15 filtered out), 3 added (1 filtered out) types
You can see that there is a new summary line which starts with the
string: "Unreachable types summary:"
Then in the body of the report, those unreachable types are reported
separately.
In practise, we want to limit the unreachable types to compare
somehow, otherwise we'll end up comparing all the types of the types
of the binary and that can be huge. So we want to limit the
unreachable type analysis to types that are defined in public headers.
So, for abipkgdiff, one can limit the analysis of non-reachable types
to those defined in public headers by supplying the --devel{1,2}
options that specifies the development packages that contain said
public headers. For abidiff however, you'll want to use the
--headers-dir{1,2} options for that.
The patch comes with appropriate regression tests.
* include/abg-comparison.h (string_type_base_sptr_map): Define new
typedef.
(diff_context::show_unreachable_types): Declare new member
functions.
(corpus_diff::{deleted_unreachable_types,
deleted_unreachable_types_sorted, added_unreachable_types,
added_unreachable_types_sorted, changed_unreachable_types,
changed_unreachable_types_sorted}): Likewise.
(maybe_report_unreachable_type_changes): Declare this function a
friend of class corpus_diff.
(corpus_diff::diff_stats::{num_added_unreachable_types,
num_added_unreachable_types_filtered_out,
net_num_added_unreachable_types, num_removed_unreachable_types,
num_removed_unreachable_types_filtered_out,
net_num_removed_unreachable_types, num_changed_unreachable_types,
num_changed_unreachable_types_filtered_out,
net_num_changed_unreachable_types}): Likewise.
* src/abg-comparison-priv.h
(diff_context::priv::show_unreachable_types_): Define new data
member.
(diff_context::priv::priv): Initialize the new data member.
(diff_comp::operator()): Use pretty representation of diff
subjects to sort them, rather than just their name. Also, add
comment to the other member functions of diff_comp.
(corpus_diff::{unreachable_types_edit_script_,
deleted_unreachable_types_, deleted_unreachable_types_sorted_,
suppressed_deleted_unreachable_types_, added_unreachable_types_,
added_unreachable_types_sorted_,
suppressed_added_unreachable_types_, changed_unreachable_types_,
changed_unreachable_types_sorted_}): Define new data members.
(corpus_diff::priv::apply_supprs_to_added_removed_fns_vars_unreachable_types):
Changed the name of
corpus_diff::priv::apply_suppressions_to_added_removed_fns_vars into
this.
(corpus_diff::priv::{added_unreachable_type_is_suppressed,
deleted_unreachable_type_is_suppressed,
changed_unreachable_types_sorted, count_unreachable_types}):
Declare new member functions.
(corpus_diff::diff_stats::priv::{num_added_unreachable_types,
num_added_unreachable_types_filtered_out,
num_removed_unreachable_types,
num_removed_unreachable_types_filtered_out,
num_changed_unreachable_types,
num_changed_unreachable_types_filtered_out}): Define new data
members.
(sort_string_type_base_sptr_map): Declare new function.
* src/abg-comparison.cc (sort_string_type_base_sptr_map)
(diff_context::show_unreachable_types): Define new functions.
(corpus_diff::diff_stats::{num_added_unreachable_types,
num_added_unreachable_types_filtered_out,
net_num_added_unreachable_types,
net_num_removed_unreachable_types,
num_removed_unreachable_types_filtered_out,
num_removed_unreachable_types}): Define new member functions.
(diff_maps::insert_diff_node): Do not update the map "diff ->
impacted interfaces" if the current impacted interface is nil.
This happens if we are looking at a diff node for a change on a
type that is not reachable from any interfaces.
(corpus_diff::priv::ensure_lookup_tables_populated): Handle the
edit script for unreachable types.
(corpus_diff::priv::apply_supprs_to_added_removed_fns_vars_unreachable_types):
Rename
corpus_diff::priv::apply_suppressions_to_added_removed_fns_vars
into this. Apply suppression specifications to added and removed
unreachable types as well.
(corpus_diff::priv::{added,deleted}_unreachable_type_is_suppressed):
Define new member functions.
(corpus_diff::priv::{count_unreachable_types,
changed_unreachable_types_sorted}): Likewise.
(corpus_diff::priv::apply_filters_and_compute_diff_stats): Update
statistics (including walking changed unreachable types to apply
categorization and redundancy filters to them) related to
unreachable types.
(corpus_diff::priv::emit_diff_stats): Emit diff stats related to
unreachable types.
(corpus_diff::priv::maybe_dump_diff_tree): Dump diff tree nodes
related to unreachable types.
(corpus_diff::{deleted_unreachable_types,
deleted_unreachable_types_sorted, added_unreachable_types,
added_unreachable_types_sorted, changed_unreachable_types,
changed_unreachable_types_sorted): Define new member functions.
(corpus_diff::has_changes): Take deleted/added/changed unreachable
types into account.
(corpus_diff::has_incompatible_changes): Take net removed/changed
unreachable types into account.
(corpus_diff::has_net_subtype_changes): Take net removed and
changed unreachable types into account.
(corpus_diff::has_net_changes): Take net removed/added/changed
unreachable types into account.
(corpus_diff::traverse): When traversing the components of a
corpus_diff node, make sure to traverse the changed unreachable
types of the corpus.
(leaf_diff_node_marker_visitor::visit_begin): Arrange for the fact
that the current topmost interface can be nil if we are looking at
types not reachable from global functions/variables. Also, make
sure that only leaf nodes that are reachable from a global
function/variable are recorded as leaf nodes.
(compute_diff): In the overload for corpus_sptr, compute the
changes between types not reachable from global functions and
variables, if the user wishes that we do so. Also, add more
comments.
(apply_suppressions): Update for the name change of the function
apply_suppressions_to_added_removed_fns_vars to
apply_supprs_to_added_removed_fns_vars_unreachable_types.
* include/abg-corpus.h
(corpus::{record_type_as_reachable_from_public_interfaces,
type_is_reachable_from_public_interfaces,
get_types_not_reachable_from_public_interfaces}): Declare new
member functions.
(corpus::recording_types_reachable_from_public_interface_supported):
Declare new virtual member function.
(corpus_group::get_public_types_pretty_representations): Declare
new member functons.
(corpus_group::recording_types_reachable_from_public_interface_supported):
Declare new virtual member function.
* src/abg-corpus-priv.h
(corpus::priv::{types_not_reachable_from_pub_ifaces_,
pub_type_pretty_reprs_}): Define new data members.
(corpus::priv::priv): Initialize the pub_type_pretty_reprs_ data
member because it's a pointer.
(corpus::priv::get_public_types_pretty_representations): Declare
new member function.
(corpus::priv::~priv): Declare a destructor.
* src/abg-corpus.cc
(corpus::priv::get_public_types_pretty_representations): Define
new member function.
(corpus::priv::~priv): Define new destructor to delete the new
pub_type_pretty_reprs_ member pointer.
(corpus::{record_type_as_reachable_from_public_interfaces,
type_is_reachable_from_public_interfaces,
get_types_not_reachable_from_public_interfaces,
recording_types_reachable_from_public_interface_supported}):
Define new member functions
(corpus_group::get_public_types_pretty_representations): Likewise.
* include/abg-diff-utils.h (struct deep_ptr_eq_functor): Document
the equality operator. Also, add an overload to the equality
operator, for weak_ptr<T>. The existing equality operator
overload was just for shared_ptr<T>.
* include/abg-fwd.h (is_user_defined_type): Declare function.
* include/abg-ir.h (operator!=(const decl_base_sptr&, const
decl_base_sptr&)): Declare new operator.
(type_maps::get_types_sorted_by_name): Declare
new member function.
(decl_base::{g,s}et_is_artificial): Declare new member function.
(function_decl::parameter::{g,s}et_artificial): Remove these
member functions.
* src/abg-ir.cc (operator!=(const decl_base_sptr&, const
decl_base_sptr&)): Define new operator.
(decl_base::priv::is_artificial_): Define new data
member.
(type_maps::priv::sorted_types_): Define new data member.
(struct type_name_comp): Define new comparison functor to sort
types based on their pretty representations.
(decl_base::priv::priv): Initialize it.
(decl_base::{g,s}et_is_artificial): Define new member functions.
(type_maps::get_types_sorted_by_name): Define new member function.
(is_user_defined_type): Define new function overloads.
(strip_typedef, function_type::{function_type, set_parameters}):
Adjust using decl_base::get_is_artificial rather than
function_decl::parameter::get_artificial.
(function_decl::parameter::priv::artificial_): Remove this data
member.
(function_decl::parameter::priv::priv): Adjust to the removal of
function_decl::parameter::priv::artificial_. This constructor
does not take an "is_artificial" flag anymore.
(function_decl::parameter::parameter): Adjust to the removal of
the is_artificial flag from the arguments of the constructor of
function_decl::parameter::parameter::priv.
(function_decl::parameter::get_artificial): Remove this member
function.
* src/abg-reporter-priv.h (maybe_report_unreachable_type_changes):
Declare new function.
* src/abg-reporter-priv.cc
(maybe_report_unreachable_type_changes): Define new function.
* src/abg-default-reporter.cc (default_reporter::report): In the
overload for corpus_diff&, report added/removed/changed types that
are not reachable from global functions and variables using the
new function maybe_report_unreachable_type_changes.
* src/abg-leaf-reporter.cc (leaf_reporter::report): In the
overload for corpus_diff, report changes to types unreachable from
global functions or variables, using the new function
maybe_report_unreachable_type_changes.
* src/abg-dwarf-reader.cc (build_ir_node_from_die): When the user
requests that all types be loaded, record relevant types as
reachable from global functions and variables.
(build_enum_type, add_or_update_class_type)
(add_or_update_union_type): Read the 'is-artificial' DWARF
attribute and set the corresponding decl_base property
accordingly.
(finish_member_function_reading, strip_typedef)
(function_type::function_type): Adjust using
decl_base::get_is_artificial, rather than
function_decl::parameter::get_artificial.
* include/abg-reader.h
(consider_types_not_reachable_from_public_interfaces): Declare new
function.
* src/abg-reader.cc
(read_context::m_tracking_non_reachable_types): Add new data
member.
(read_context::read_context): Initialize it.
(read_context::tracking_non_reachable_types): Define accessors for
the new data member above.
(read_is_declaration_only): Re-indent.
(read_is_artificial): Define new helper function.
(build_function_parameter): Use the new read_is_artificial
function here, rather than open-coding it.
(build_enum_type_decl, build_class_decl, build_union_decl):
Support reading the 'is-artificial' property by using the new
read_is_artificial function.
(read_corpus_from_input): If the user wants us to take
non-reachable types into account, then make sure we do so.
(read_tracking_non_reachable_types, read_is_non_reachable_type):
Define new static functions.
(handle_element_node, build_type): Read the "is-non-reachable"
attribute on type element nodes if the user wants us to track
non-reachable types.
(consider_types_not_reachable_from_public_interfaces): Define new
function.
* src/abg-writer.cc (write_is_artificial): Define new static
helper function.
(annotate): Adjust using decl_base::get_is_artificial rather than
function_decl::parameter::get_artificial.
(write_enum_type_decl, write_class_decl_opening_tag)
(write_union_decl_opening_tag): Support writing the
"is-artificial" property, using the new write_is_artificial
function.
(write_function_type): Adjust this to use the new
write_is_artificial rather than open-coding writing the
'is-artificial' attribute.
(write_is_non_reachable)
(write_tracking_non_reachable_types): Define new static functions.
(write_enum_type_decl, write_class_decl_opening_tag)
(write_union_decl_opening_tag): Write the 'is-no-reachable'
attribute when applicable.
(write_corpus, write_corpus_group): Write the
'tracking-non-reachable-types' attribute when applicable.
* tools/abidiff.cc (options::options): Initialize ...
(options::show_all_types): ... new data member.
(display_usage): Add help string from the new
--non-reachable-types option.
(parse_command_line): Parse the new --non-reachable-types option.
(set_diff_context_from_opts): Set the
dwarf_reader::read_context::show_unreachable_types property.
(set_native_xml_reader_options): Define new
static function.
(main): Load all types when analyzing the DWARF or the ABIXML
files, if the user wants us to do so.
* tools/abipkgdiff.cc (options::show_all_types): Define new data
member.
(options::options): Initialize it.
(parse_command_line): Parse the --non-reachable-types option to
set the options::show_all_types data member.
(display_usage): Add a help string for the new
--non-reachable-types option.
(set_diff_context_from_opts): Set the
dwarf_reader::read_context::show_unreachable_types property based
on the options::show_all_type data member.
(compare): Configure the read context to load all types while
analyzing the DWARF info, depending on the options::show_all_type
data member.
* doc/manuals/abidiff.rst: Document the new --non-reachable-types
option added to abidiff above.
* doc/manuals/abipkgdiff.rst: Add documentation for the
--non-reachable-types option.
* tests/data/test-diff-suppr/test47-non-reachable-types-v{0,1}.c:
Source code files of test binary input.
* tests/data/test-diff-suppr/test47-non-reachable-types-suppr-{1,2,3,4,5}.txt:
New test input files.
* tests/data/test-diff-suppr/test47-non-reachable-types-report-{1,2,3,4,5,6,7,8,9,10}.txt:
New test reference output files.
* tests/data/test-diff-suppr/test47-non-reachable-types-v{0,1}.o.alltypes.abixml:
New test input abixml.
* tests/data/Makefile.am: Add the new test material to source
distribution.
* tests/test-diff-suppr.cc (in_out_specs): Add the new tests above
to this test harness.
* tests/data/test-abidiff/test-struct1-report.txt: Adjust.
* tests/data/test-diff-pkg/PR24690/flatpak-debuginfo-1.2.4-3.fc30.x86_64.rpm:
New input binary RPM.
* tests/data/test-diff-pkg/PR24690/flatpak-debuginfo-1.4.0-1.fc30.x86_64.rpm:
Likewise.
* tests/data/test-diff-pkg/PR24690/flatpak-devel-1.2.4-3.fc30.x86_64.rpm:
Likewise.
* tests/data/test-diff-pkg/PR24690/flatpak-devel-1.4.0-1.fc30.x86_64.rpm:
Likewise.
* tests/data/test-diff-pkg/PR24690/flatpak-libs-1.2.4-3.fc30.x86_64.rpm:
Likewise.
* tests/data/test-diff-pkg/PR24690/flatpak-libs-1.4.0-1.fc30.x86_64.rpm:
Likewise.
* tests/data/test-diff-pkg/PR24690/flatpak-libs-debuginfo-1.2.4-3.fc30.x86_64.rpm:
Likewise.
* tests/data/test-diff-pkg/PR24690/flatpak-libs-debuginfo-1.4.0-1.fc30.x86_64.rpm:
Likewise.
* tests/data/test-diff-pkg/PR24690/PR24690-report-0.txt: New test
reference output.
* tests/data/Makefile.am: Add the new test material above to
source distribution.
* tests/test-diff-pkg.cc (in_out_specs): Add the new test material
above to this test harness.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
847800d497 |
Bug 25128 - Handle decl-only classes that differ only in size
Because DWARF sometimes emit decl-only classes (real one, with no members) with a size property, and the rest of the time, would emit the same decl-only class without a size property, comparing the two might yield some false positives. This patch handles those beasts when comparing classes. * include/abg-comp-filter.h (is_decl_only_class_with_size_change): Declare an overload. * include/abg-fwd.h (look_through_decl_only_class): Declare an overload. * src/abg-comp-filter.cc (is_decl_only_class_with_size_change): Define an overload that takes class_or_union& type. Re-write the previous overload in terms of this new one. * src/abg-ir.cc (look_through_decl_only_class): Define a new overload that takes a class_or_union&. Rewrite the previous overload in terms of this one. (equals): In the overload for class_or_union&, use is_decl_only_class_with_size_change to detect cases of decl-only classes that differ only by their size attribute and avoid comparing them. * tests/data/test-annotate/test21-pr19092.so.abi: Adjust. * tests/data/test-read-dwarf/test21-pr19092.so.abi: Likewise. * tests/data/test-diff-filter/test41-report-0.txt: Likewise. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Dodji Seketeli
|
1f4dbe3515 |
Bug 25128 - Leaf diff reporter shouldn't compare decl-only classes
The leaf_diff_node_marker_visitor pass which collects leaf diff nodes for the leaf diff reporter considers bogus decl-only classes (that have the is-declaration-only flag set, are empty, and yet have a non-nil size property) originated from bogus DWARF. The leaf reporter thus potentially reports size changes among decl-only classes, which does not make sense. Two decl-only classes of the same name should always be considered equal, in this context. This patch thus teaches the leaf_diff_node_marker_visitor to avoid collecting a leaf diff node that is about a size change on a true decl-only class. * include/abg-comp-filter.h (is_decl_only_class_with_size_change): Declare new function. * src/abg-comp-filter.cc (is_decl_only_class_with_size_change): Define new function. * src/abg-comparison.cc (leaf_diff_node_marker_visitor::visit_begin): Use the newly defined is_decl_only_class_with_size_change above to ignore bogus decl-only classes with a size change. * tests/data/test-diff-suppr/test45-abi-report-1.txt: New test input. * tests/data/test-diff-suppr/test45-abi-wl.xml: Likewise. * tests/data/test-diff-suppr/test45-abi.xml: Likewise. * tests/data/test-diff-suppr/test45-abi.suppr.txt: New reference output for the test input above. * tests/data/test-diff-suppr/test46-PR25128-base.xml: New test input. * tests/data/test-diff-suppr/test46-PR25128-new.xml: Likewise. * tests/data/test-diff-suppr/test46-PR25128-report-1.txt: New reference input for the test input above. * tests/data/Makefile.am: Add the new test material to source distribution. * tests/test-diff-suppr.cc (in_out_spec): Add the new test input above to this test harness. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Dodji Seketeli
|
b00976517f |
Support symbol_name_not_regexp in [suppress_{function, variable}]
In the suppress_function and suppress_variable directives of the suppression specification language, we lack the 'symbol_name_not_regexp' properties, that would allow users to specify which (function/variable) symbols to *keep* as opposed to specifying which symbols to suppress. This patch adds that feature. That will later allow us to make the linux kernel symbol white lists[1] functionality use this feature; that is, upon analysing the content of a kernel symbol whitelist which lists a symbol named "foo", Libabigail would automatically generate a suppression specification which contains, e.g a 'suppress_function" directive that has this new 'symbol_name_not_regexp' property which value is set to "foo". Note that the patch makes sure that feature is supported when analyzing both abixml and DWARF formats. [1]: You can learn about what a Linux Kernel symbols white list is by reading about it at https://sourceware.org/libabigail/manual/kmidiff.html#environment. * doc/manuals/libabigail-concepts.rst: Document the new symbol_name_not_regexp properties for the suppress_{function,variable} directives. * include/abg-suppression.h ({function,variable}_suppression::{g,s}et_symbol_name_not_regex_str): Declare new member functions. * src/abg-dwarf-reader.cc (read_context::is_elf_symbol_suppressed): Define new member functions. (read_context::{load_symbol_maps_from_symtab_section, populate_symbol_map_from_ksymtab, populate_symbol_map_from_ksymtab_reloc}): Drop suppressed symbols when reading symbol tables. ({function,variable}_is_suppressed): Consider that in C, the linkage name is _by default_ the same as the function/variable name. Remove local variable. * include/abg-ir.h (elf_symbol_is_{function,variable}): Add ... * src/abg-ir.cc (elf_symbol_is_{function,variable}): ... new functions. * src/abg-reader.cc (build_elf_symbol): Take an additional boolean to detect and drop suppressed symbols. (build_elf_symbol_db): Adjust the call to build_elf_symbol to make it detect and drop suppressed symbols. (read_corpus_from_input): Be mindful that the set of symbols for a given corpus can be empty because of suppression specifications. * src/abg-suppression-priv.h ({function,variable}_suppression::priv::symbol_name_not_regex[_str_]): Add new data members. (function,variable}_suppression::priv::get_symbol_name_not_regex): Add new member functions. ({function,variable}_is_suppressed): Guard against empty name. (is_elf_symbol_suppressed): Define new function template. * src/abg-suppression.cc ({function,variable}_suppression::{g,s}et_symbol_name_not_regex_str): Define new member functions. ({function,variable}_suppression::suppresses_function) (suppression_matches_{function,variable}_sym_name) (read_{function,variable}_suppression): Support the new "symbol_name_not_regex" property. * tests/data/test-diff-suppr/test44-suppr-sym-name-not-regexp-report-1.txt: New test reference report. * tests/data/test-diff-suppr/test44-suppr-sym-name-not-regexp-report-2.txt: Likewise. * tests/data/test-diff-suppr/test44-suppr-sym-name-not-regexp-v{0,1}.c: Sources of the new test input. * tests/data/test-diff-suppr/test44-suppr-sym-name-not-regexp-v{0,1}.o: New test input binaries. * tests/data/test-diff-suppr/test44-suppr-sym-name-not-regexp-v{0,1}.o.abi: New test input abixml files. * tests/data/test-diff-suppr/test44-suppr-sym-name-not-regexp.suppr.txt: Next test suppression specification. * tests/data/Makefile.am: Add the new test material above to source distribution. * tests/test-diff-suppr.cc (in_out_specs): Add the input tests above to the test harness. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Dodji Seketeli
|
d2c88645e8 |
Support the "name_not_regexp" property in the [suppress_type] section
When writting a suppression specification in which the user wants to
keep a family of types (whose names set is specified by a regular
expression) and suppress/drop all other types, one needs to write
something like:
[suppress_type]
name_regexp = (?!the-regexp-of-the-types-to-keep)
It would be nicer (like what is done for other properties that take
regular expressions as value in suppression specifications) to be able
to write:
[suppress_type]
name_not_regexp = the-regexp-of-types-to-keep
This patch does just that.
It augments the abigail::suppr::type_suppression type to make it carry
the new 'name_not_regex' property. It updates the suppression engine
to take the 'name_not_regex' property into account when interpreting
instances of abigail::suppr::type_suppression. The parser for type
suppression directives is updated to recognize the new name_not_regexp
property. The manual has been updated accordingly to describe the new
property. New regression tests have been added.
* doc/manuals/libabigail-concepts.rst: Update this to document the
new name_not_regexp property of the suppress_type directive.
* include/abg-suppression.h
(type_suppression::{g,s}et_type_name_not_regex_str): Declare new accessors.
* src/abg-suppression-priv.h
(type_suppression::priv::{type_name_not_regex_str_,
type_name_not_regex_}): Define new data members.
(type_suppression::priv::{get_type_name_not_regex,
set_type_name_not_regex, get_type_name_not_regex_str,
set_type_name_not_regex_str}): Define new member functions.
* src/abg-suppression.cc
(type_suppression::get_type_name_regex_str): Fix comments.
(type_suppression::{set_type_name_not_regex_str,
get_type_name_not_regex_str}): Define new data members.
(suppression_matches_type_name): Adapt to support the new
type_name_not_regex property.
(read_type_suppression): Support parsing the type_name_not_regexp
property.
* tests/data/test-diff-suppr/test42-negative-suppr-type-report-0.txt:
New test reference output.
* tests/data/test-diff-suppr/test42-negative-suppr-type-report-1.txt: Likewise.
* tests/data/test-diff-suppr/test42-negative-suppr-type-suppr-1.txt:
New test input.
* tests/data/test-diff-suppr/test42-negative-suppr-type-suppr-2.txt: Likewise.
* tests/data/test-diff-suppr/test42-negative-suppr-type-v0.{cc, o}: Likewise.
* tests/data/test-diff-suppr/test42-negative-suppr-type-v1.{cc,
o}: Likewise.
* tests/data/Makefile.am: Add the test files above to source
distribution.
* tests/test-diff-suppr.cc (int_out_specs): Add the new tests to
the harness.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
ed9492065e |
Remove the elf_symbol::get_value property
Now that there are proper facilities to lookup ELF symbols inside the
ELF/DWARF reader and get a native GElf_Sym type instance (from
libelf), we don't need to carry the value of the symbol (that is
relevant only that low level anyway) in the abigail::ir::elf_symbol
type.
This patch removes that property.
* include/abg-ir.h (elf_symbol::{elf_symbol, create}): Remove the
'val' parameter.
* src/abg-dwarf-reader.cc (elf_symbol::get_value): Remove this
member function declaration.
(lookup_symbol_from_sysv_hash_tab)
(lookup_symbol_from_gnu_hash_tab, lookup_symbol_from_symtab)
(create_default_var_sym, create_default_fn_sym)
(read_context::lookup_elf_symbol_from_index): Adjust calls to
creating elf_symbol instances.
* src/abg-ir.cc (elf_symbol::priv::value_): Remove this data
member.
(elf_symbol::{priv::priv, elf_symbol, create): Adjust.
* src/abg-reader.cc (build_elf_symbol): Likewise.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
Jessica Yu
|
e6870326e0 |
Support pre and post v4.19 ksymtabs for Linux kernel modules
As described in commit
|
||
|
Dodji Seketeli
|
bc2d2ce660 |
Serialize canonical types to avoid testing if types have been emitted
When emitting abixml, profiling shows that we spend a great deal of
time testing if a given type has been emitted already, to avoid
emitting a given type more than once. This makes the serialization
phase take more time than the binary analysis phase!
This patch leverages the fact that we already have the set of
canonical types in the system. While emitting that set entirely, we
don't need to test if a type has been emitted already because we know
by definition that every type is present just once in that set, more
or less. OK, because there are also types that don't have canonical
types (for instance, declaration-only class/structs), we'll still have
to check of those types have already been emitted, but this is a very
small set to handle.
The patch thus organizes the canonical types per scope, so that when
emitting a scope and the canonical types within it, the type is
emitted in its correct namespace.
Then, when emitting a translation unit and each namespaces in it, the
patch emits the canonical types of those namespaces.
The patch arranges for some ancillary things that are needed to make
the whole picture be coherent enough for things to keep working.
Testing shows that we gained ~ 30% of performance by doing this, while
analysing the whole linux kernel 5.1 version. We went from ~ 3m30s
minutes to less than 2m30s.
With this patch, the serialization phase now takes less time than the
analysis time.
* include/abg-fwd.h (is_decl_slow)
(peel_pointer_or_reference_type): Declare new functions.
* include/abg-ir.h (struct canonical_type_hash): Define new type.
(type_base_ptr_set_type, type_base_ptrs_type)
(type_base_sptrs_type, canonical_type_sptr_set_type): Define new
typedefs.
(environment::get_canonical_types_map): Declare new member
function.
(scope_decl::{get_canonical_types, get_sorted_canonical_types}):
Declare new member functions.
* src/abg-ir.cc (is_ptr_ref_or_qual_type)
(peel_pointer_or_reference_type, is_decl_slow): Define new
functions.
(environment::{get_canonical_types_map}): Define new member
functions.
(canonical_type_hash::operator()): Likewise.
(scope_decl::{get_canonical_types, get_sorted_canonical_types}):
Likewise.
(struct type_topo_comp): Define new comparison functor type.
(environment::{sorted_canonical_types_}): Define new data member.
(scope_decl::priv::{canonical_types_, sorted_canonical_types_}):
Likewise.
(scope_decl::is_empty): Take the presence of canonical types into
account when determining if a scope is empty or not.
(is_decl): Make this work for cases where the artifact at hand is
a type which has a declaration, as opposed to being a pure
declaration like a variable or a function.
(canonicalize): Add the canonical type the list of canonical types
of its scope.
* src/abg-dwarf-reader.cc (read_context::die_is_in_cplus_plus):
Define new member function.
* src/abg-writer.cc (write_type, write_canonical_types_of_scope):
Define new static functions.
(fn_type_ptr_set_type): Define new typedef.
(write_context::{m_referenced_fn_types_set,
m_referenced_non_canonical_types_set}): Add new data members.
(write_context::m_referenced_types_set): Renamed
m_referenced_types_map into this.
(write_context::get_referenced_types): Adjust.
(write_context::get_referenced_{function_types,
non_canonical_types}):
(write_context::record_type_as_referenced): Adjust to add the
referenced type in the proper set which would be one of the three
following: write_context::{get_referenced_types,
get_referenced_function_types,
get_referenced_non_canonical_types}.
(write_context::{type_is_referenced, clear_referenced}): Adjust.
(write_translation_unit): Use the new
write_canonical_types_of_scope. Also emit declaration-only
classes that have member types. Do not test if a given type of a
given scope has been emitted, in general, as this was super slow
given the number of types. Emit referenced function types (as
these don't belong to any scope). Rather than using the expensive
"is_function_type" on *all* the referenced types, just walk the
set write_context::get_referenced_function_types. Likewise,
rather than using type_base::get_naked_canonical_type on
*all* the referenced types, just walk the set
write_context::get_referenced_non_canonical_types
(write_class): Use write_canonical_types_of_scope here.
* tools/abilint.cc (main): Support linting corpus group abixml
files.
* tests/data/test-annotate/libtest23.so.abi: Adjust.
* tests/data/test-annotate/libtest24-drop-fns-2.so.abi: Likewise.
* tests/data/test-annotate/libtest24-drop-fns.so.abi: Likewise.
* tests/data/test-annotate/test-anonymous-members-0.o.abi: Likewise.
* tests/data/test-annotate/test0.abi: Likewise.
* tests/data/test-annotate/test1.abi: Likewise.
* tests/data/test-annotate/test13-pr18894.so.abi: Likewise.
* tests/data/test-annotate/test14-pr18893.so.abi: Likewise.
* tests/data/test-annotate/test15-pr18892.so.abi: Likewise.
* tests/data/test-annotate/test17-pr19027.so.abi: Likewise.
* tests/data/test-annotate/test18-pr19037-libvtkRenderingLIC-6.1.so.abi: Likewise.
* tests/data/test-annotate/test19-pr19023-libtcmalloc_and_profiler.so.abi: Likewise.
* tests/data/test-annotate/test2.so.abi: Likewise.
* tests/data/test-annotate/test20-pr19025-libvtkParallelCore-6.1.so.abi: Likewise.
* tests/data/test-annotate/test21-pr19092.so.abi: Likewise.
* tests/data/test-annotate/test4.so.abi: Likewise.
* tests/data/test-annotate/test6.so.abi: Likewise.
* tests/data/test-annotate/test7.so.abi: Likewise.
* tests/data/test-annotate/test8-qualified-this-pointer.so.abi: Likewise.
* tests/data/test-read-dwarf/PR22015-libboost_iostreams.so.abi: Likewise.
* tests/data/test-read-dwarf/PR22122-libftdc.so.abi: Likewise.
* tests/data/test-read-dwarf/PR24378-fn-is-not-scope.abi: Likewise.
* tests/data/test-read-dwarf/libtest23.so.abi: Likewise.
* tests/data/test-read-dwarf/libtest24-drop-fns-2.so.abi: Likewise.
* tests/data/test-read-dwarf/libtest24-drop-fns.so.abi: Likewise.
* tests/data/test-read-dwarf/test0.abi: Likewise.
* tests/data/test-read-dwarf/test1.abi: Likewise.
* tests/data/test-read-dwarf/test10-pr18818-gcc.so.abi: Likewise.
* tests/data/test-read-dwarf/test11-pr18828.so.abi: Likewise.
* tests/data/test-read-dwarf/test12-pr18844.so.abi: Likewise.
* tests/data/test-read-dwarf/test13-pr18894.so.abi: Likewise.
* tests/data/test-read-dwarf/test14-pr18893.so.abi: Likewise.
* tests/data/test-read-dwarf/test15-pr18892.so.abi: Likewise.
* tests/data/test-read-dwarf/test16-pr18904.so.abi: Likewise.
* tests/data/test-read-dwarf/test17-pr19027.so.abi: Likewise.
* tests/data/test-read-dwarf/test18-pr19037-libvtkRenderingLIC-6.1.so.abi: Likewise.
* tests/data/test-read-dwarf/test19-pr19023-libtcmalloc_and_profiler.so.abi: Likewise.
* tests/data/test-read-dwarf/test2.so.abi: Likewise.
* tests/data/test-read-dwarf/test20-pr19025-libvtkParallelCore-6.1.so.abi: Likewise.
* tests/data/test-read-dwarf/test21-pr19092.so.abi: Likewise.
* tests/data/test-read-dwarf/test22-pr19097-libstdc++.so.6.0.17.so.abi: Likewise.
* tests/data/test-read-dwarf/test4.so.abi: Likewise.
* tests/data/test-read-dwarf/test6.so.abi: Likewise.
* tests/data/test-read-dwarf/test7.so.abi: Likewise.
* tests/data/test-read-dwarf/test8-qualified-this-pointer.so.abi: Likewise.
* tests/data/test-read-dwarf/test9-pr18818-clang.so.abi: Likewise.
* tests/data/test-read-write/test10.xml: Likewise.
* tests/data/test-read-write/test14.xml: Likewise.
* tests/data/test-read-write/test15.xml: Likewise.
* tests/data/test-read-write/test17.xml: Likewise.
* tests/data/test-read-write/test18.xml: Likewise.
* tests/data/test-read-write/test19.xml: Likewise.
* tests/data/test-read-write/test2.xml: Likewise.
* tests/data/test-read-write/test20.xml: Likewise.
* tests/data/test-read-write/test21.xml: Likewise.
* tests/data/test-read-write/test22.xml: Likewise.
* tests/data/test-read-write/test23.xml: Likewise.
* tests/data/test-read-write/test24.xml: Likewise.
* tests/data/test-read-write/test25.xml: Likewise.
* tests/data/test-read-write/test26.xml: Likewise.
* tests/data/test-read-write/test27.xml: Likewise.
* tests/data/test-read-write/test28-without-std-fns-ref.xml: Likewise.
* tests/data/test-read-write/test28-without-std-vars-ref.xml: Likewise.
* tests/data/test-read-write/test3.xml: Likewise.
* tests/data/test-read-write/test6.xml: Likewise.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
f2437aabad |
Bug 24787 - Filter out enum changes into compatible integer types
Libabigail's filtering engine fails to recognize an enum changing into
a compatible integer (or vice versa) as a harmless change.
This patch fixes that.
* include/abg-comparison.h (peel_typedef_or_qualified_type_diff):
Declare new function.
(peel_pointer_or_qualified_type_diff): Rename
peel_pointer_or_qualified_type into this.
* include/abg-fwd.h (is_enum_type): Declare a new overload for
type_or_decl_base*.
* src/abg-comp-filter.cc (has_harmless_enum_to_int_change): Define
new static function.
* src/abg-comparison.cc (categorize_harmless_diff_node): Use the
new has_harmless_enum_to_int_change here.
(peel_pointer_or_qualified_type_diff): Renamed
peel_pointer_or_qualified_type into this.
(is_diff_of_basic_type): Adjust.
(peel_typedef_or_qualified_type_diff): Define new function.
* test-diff-filter/PR24787-lib{one, two}.so: New test input
binaries.
* test-diff-filter/PR24787-{one, two}.c: Source files of the test
input binaries above.
* test-diff-filter/PR24787-report-0.txt: Test output reference.
* tests/data/Makefile.am: Add the new testing material to source
distribution.
* tests/test-diff-filter.cc (in_out_specs): Add the new test to
the test harness.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
3df54522b8 |
Add timing to the verbose logs of abidw
While doing my recent optimization work, it became useful to have an
idea of the time different parts of the processing pipeline are
taking.
This patch introduces an abigail::tools_utils::timer type that is easy
to use to time a given part of the code and emit the elapsed time to
an output stream.
This abigail::tools_utils::timer type is thus used to time various
parts of the processing pipeline involved in abidw. Just using the
existing --verbose option now yields timing information.
* include/abg-tools-utils.h (class timer): Declare new type.
(operator<<(ostream&, const timer&)): Declare new streaming
operator for the new timer type.
* src/abg-tools-utils.cc (struct timer::priv): Define new type.
(timer::{timer, start, stop, value_in_seconds, value,
value_as_string, ~timer}): Define member functions.
(operator<<(ostream& o, const timer& t)): Define streaming
operator.
(build_corpus_group_from_kernel_dist_under): Add timing logs to
the linux kernel reading process.
* src/abg-dwarf-reader.cc
(read_context::canonicalize_types_scheduled): Add timing logs to
type canonicalization.
(read_debug_info_into_corpus): Add timing logs for the whole debug
info loading and internal representation building process.
* tools/abidw.cc (load_corpus_and_write_abixml): Add timing logs
for the binary loading and serizalization process.
(load_kernel_corpus_group_and_write_abixml): Add timing logs the
Linux Kernel binary loading and writing process.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
400ac7a412 |
Implement fast comparison of Linux Kernel types when applicable
During type canonicalization there are observations that can speed-up
type comparison significantly without impacting correctness too much.
Typically, when two types are of the same name and kind, are found in
the same corpus and are defined in the same translation unit, they
ought to be the same type, even in C. So there is no need in this
case to actually perform the structural comparison of the two types
which does have a quadratic performance at best.
Using this optimization made the loading of the
drivers/gpu/drm/i915/i915.ko module go from a quasi inifite time (many
hours on my system) to less than two minutes. I am confining this
optimization to the Linux kernel case only for now, but I believe it
could benefit all C programs. I am waiting for more testing before
applying it more broadly.
Also, while looking at this, I noticed that when loading several
corpora into a given corpus group (i.e, loading several linux kernel
binaries to represent a single conceptual kernel), we sometimes fail
to recognize that a type defined in a header file that is included in
several corpora is actually the same type, and should be re-used,
rather than being re-defined in each corpus. This later adds stress
(time and space) on the system as we need to canonicalize and
de-duplicate these type later on.
This is because the "per-corpus" type maps that we use to lookup a
type by name and location when we see it (so that we know it's defined
in a different corpus of our current group) should really be
per-corpus-group type maps! That is a type can be defined in the
corpus representing a .ko binary, and that type would be seen again in
another .ko binary later. Until now, we were wrongly considering that
types were to be first defined in the corpus of the vmlinux binary,
and then could be re-used later.
I have thus fixed the code so that whenever we add a type to its
scope, the relevant per-corpus type maps are updated, as well as the
per-corpus-group ones, so that we can later lookup types in those
per-corpus-group type maps to know if a type is already defined in any
corpus of the group.
* include/abg-corpus.h (corpus::origin): Add a new
LINUX_KERNEL_BINARY_ORIGIN enumerator.
(corpus::{s,g}et_group): Declare new member
functions.
(class corpus): Make the corpus_group class friend of this one.
(corpus_group::get_main_corpus): Declare new member function.
* src/abg-corpus-priv.h (corpus::priv::group): Define new data
member.
(corpus::priv::priv): Initialize the new corpus::priv::group data
member.
* src/abg-corpus.cc (corpus::{g,s}et_group): Define new member
functions.
(corpus_group::get_main_corpus): Likewise.
(corpus_group::add_corpus): Use the new corpus::set_group() here
to to make the corpus be aware of the group it belongs to.
* src/abg-dwarf-reader.cc (read_debug_info_into_corpus): Set the
current corpus origin to the corpus::LINUX_KERNEL_BINARY_ORIGIN if
we are looking at a Linux Kernel binary.
(read_context::main_corpus_from_current_group): Use the
corpus_group::get_main_corpus method.
(should_reuse_type_from_corpus_group): Return the corpus group,
rather than the main corpus.
(read_debug_info_into_corpus): Add the current corpus to the
current corpus group before the debug info reading is done. That
way, the corpus group will be accessible from the current corpus
during the construction of the internal representation.
(read_and_add_corpus_to_group_from_elf): Add the corpus to the
group only if it wasn't added to it before.
* include/abg-ir.h (operator{==,!=}): Declare new deep equality
and inequality operators for class_or_union_sptr and
union_decl_sptr.
* src/abg-ir.cc (types_defined_same_linux_kernel_corpus_public):
Define a new static function.
(type_base::get_canonical_type_for): Use the new
types_defined_same_linux_kernel_corpus_public here to speed up
type comparison.
(equals): In the overload of class_or_union, use the new
types_defined_same_linux_kernel_corpus_public as well, to speed up
type comparison.
(operator{==,!=}): Define new deep equality and inequality
operators for class_or_union_sptr and union_decl_sptr.
(maybe_update_types_lookup_map): In the overload function for
type_decl_sptr, class_decl_sptr, union_decl_sptr,
enum_type_decl_sptr, typedef_decl_sptr, qualified_type_def_sptr,
reference_type_def_sptr, array_type_def_sptr,
array_type_def::subrange_sptr, and function_type_sptr, update the
type lookup maps of the containing corpus group as well, not just
the ones of the current corpus.
* src/abg-reader.cc (build_enum_type_decl): Forgot to set the
"is-anonymous" flag. Oops, fix this.
* tests/data/test-read-dwarf/PR22122-libftdc.so.abi: Adjust.
* tests/data/test-read-dwarf/test10-pr18818-gcc.so.abi: Adjust.
* tests/data/test-read-dwarf/test12-pr18844.so.abi: Adjust.
* tests/data/test-read-dwarf/test22-pr19097-libstdc++.so.6.0.17.so.abi: Adjust.
* tests/data/test-read-dwarf/test9-pr18818-clang.so.abi: Adjust.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Matthias Maennich
|
85f185a684 |
abg-tools-utils: add missing header include guards
* include/abg-tools-utils.h: add header include guards Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Matthias Maennich
|
beededda29 |
Add compatibility layer for C++11 mode
Introduce a compatibility layer for C++11 code by adding include/abg-cxx-compat.h. abg-cxx-compat defines a new namespace abg_compat and defines abg_compat::hash abg_compat::shared_ptr abg_compat::weak_ptr abg_compat::dynamic_pointer_cast abg_compat::static_pointer_cast abg_compat::unordered_map abg_compat::unordered_set based on definitions from std::tr1 (std=gnu++98) or std:: (std=gnu++11). I decided for introducing abg_compat:: rather than polluting abigail:: to allow an easier transition to C++11 at a later time and to not subtly break existing code. As the shared_ptr in C++11 defines shared_ptr::operator bool() explicit, some locations where a shared_ptr is assigned to boolean, needed to be adjusted to explicitly cast to bool. * include/abg-cxx-compat.h: new file introducing the abg_compat namespace to provide C++11 functionality from either std::tr1 or std:: * include/Makefile.am: Add the new abg-cxx-compat.h to source distribution. * include/abg-comparison.h: replace std::tr1 usage by abg_compat and adjust includes accordingly: likewise * include/abg-diff-utils.h: likewise * include/abg-fwd.h: likewise * include/abg-ini.h: likewise * include/abg-interned-str.h: likewise * include/abg-ir.h: likewise * include/abg-libxml-utils.h: likewise * include/abg-libzip-utils.h: likewise * include/abg-reporter.h: likewise * include/abg-sptr-utils.h: likewise * include/abg-suppression.h: likewise * include/abg-tools-utils.h: likewise * include/abg-workers.h: likewise * src/abg-comp-filter.cc: likewise * src/abg-comparison-priv.h: likewise * src/abg-corpus.cc: likewise * src/abg-dwarf-reader.cc: likewise * src/abg-hash.cc: likewise * src/abg-ir.cc: likewise * src/abg-reader.cc: likewise * src/abg-suppression.cc: likewise * src/abg-tools-utils.cc: likewise * src/abg-writer.cc: likewise * tests/test-diff-filter.cc: likewise * tests/test-diff-pkg.cc: likewise * tests/test-read-dwarf.cc: likewise * tests/test-read-write.cc: likewise * tests/test-types-stability.cc: likewise * tests/test-write-read-archive.cc: likewise * tools/abicompat.cc: likewise * tools/abidiff.cc: likewise * tools/abidw.cc: likewise * tools/abilint.cc: likewise * tools/abipkgdiff.cc: likewise Signed-off-by: Matthias Maennich <maennich@google.com> Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Matthias Maennich
|
42cd02a9be |
Drop requirement to compile with GNU extensions
__gnu_cxx::stdio_filebuf is a GNU extension only available in certain std libraries. It is not e.g. in libc++. In order to be able to compile with using libc++, replace the usage of __gnu_cxx::stdio_filebuf with standard C++ methods. In this case, reopen the temporary file with a std::fstream and expose that stream rather than the previously exposed std::iostream. * include/abg-tools-utils.h (get_stream): Change return type to std::fstream * src/abg-corpus.cc: remove unused #include of ext/stdio_filebuf.h * src/abg-tools-utils (temp_file::priv): remove filebuf_ member, and replace iostream_ by fstream_ with changing the shared_ptr type accordingly (temp_file::priv::priv): initialize fstream_ based on temporary file name (temp_file::priv::~priv): adjust destruction accordingly (temp_file::is_good): test the fstream rather than the fd (temp_file::get_stream): adjust return type to std::fstream and adjust implementation based on the changes in temp_file::priv * src/Makefile.am: remove gnu extension from c++ standard flag * tests/Makefile.am: likewise Signed-off-by: Matthias Maennich <maennich@google.com> Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Dodji Seketeli
|
65318dacfb |
[xml-writter] Avoid using RTTI when dynamically hashing types
When we dynamically hash types in the abixml writter, we use hash_type_or_decl. This function uses runtime type identification to determine if the (type) artifact is a decl or a type, and based on that, choose how to compute its hash value. Profiling shows that using the RTTI in hash_type_or_decl at this point is a hotspot. Because we know that the type ABI is a *type*, we obviously can avoid using RTTI there. The patch thus implements a hash_type function, and uses that in the xml writter. Emitting the abixml output is faster with this patch. * include/abg-fwd.h (hash_type): Declare new function. * src/abg-ir.cc (hash_type): Define new function. * src/abg-writer.cc (type_hasher::operator()): Use the new hash_type rather than the old hash_type_or_decl. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Dodji Seketeli
|
c940a229c9 |
Implement a poor-man's RTTI for performance
Profiling showed that a number of use of dynamic_cast are a speed
bottleneck.
This patch implements a poor-man's RTTI that allows us to implement a
form of dynamic_cast that is specific to the types of the internal
reprenstation that are in the namespace abigail::ir. It speeds up
things greatly.
Basically, the base type of all ABI artifacts
(abigail::ir::type_or_decl_base) now contains three new data members.
The first one contains a bitmap that identifies the type of artifact.
The second one contains a pointer to the dynamic type sub-object of
the current instance of the artifact. The last one contains either a
pointer to the type_base sub-object of the current instance of ABI
artifact if it's a type, or a pointer to the type_decl sub-object of
the current instance.
Together these three data members allow the patch to implement the
abigail::ir::{is_type(), is_decl(), is_<type_kind>_type} functions
that we need to make the code base noticeably faster when using abidw
on a big vmlinux binary.
* include/abg-fwd.h (is_type_decl): Replace the overloads
that takes a type_base* and/or a decl_base* by one that takes a
type_or_decl_base*.
* include/abg-ir.h (type_or_decl_base::type_or_decl_kind): Define
new enum.
(type_or_decl_base::{kind, runtime_type_instance,
type_or_decl_base_pointer}): Declare new accessors.
(operator{|,|=,&,&=): Declare new operators for the new
type_or_decl_base::type_or_decl_kind enum.
(global_scope::global_scope): Move the definition of this
constructor to ...
* src/abg-ir.cc (global_scope::global_scope): ... here.
(type_or_decl_base::priv::{kind_, rtti_, type_or_decl_ptr_}):
Add new data members.
(type_or_decl_base::priv::priv): Take a
type_or_decl_base::type_or_decl_kind enum.
(type_or_decl_base::priv::kind): Define new accessors.
(operator{|,|=,&,&=): Define new operators for the new
type_or_decl_base::type_or_decl_kind enum.
(type_or_decl_base::type_or_decl_base): Take a
type_or_decl_base::type_or_decl_kind enum.
(type_or_decl_base::{kind, runtime_type_instance,
type_or_decl_base_pointer}): Define new accessors.
(decl_base::decl_base, scope_decl::scope_decl)
(type_base::type_base, scope_type_decl::scope_type_decl)
(class_or_union::class_or_union) : Adjust to set the runtime type
identifier of the instances of these types.
(global_scope::global_scope, type_decl::type_decl)
(qualified_type_def::qualified_type_def)
(pointer_type_def::pointer_type_def)
(reference_type_def::reference_type_def
array_type_def::subrange_type::subrange_type)
(array_type_def::array_type_def, enum_type_decl::enum_type_decl)
(typedef_decl::typedef_decl, var_decl::var_decl)
(function_type::function_type, method_type::method_type)
(function_decl::function_decl)
(function_decl::parameter::parameter, method_decl::method_decl)
(class_decl::class_decl, class_decl::base_spec::base_spec)
(union_decl::union_decl, template_decl::template_decl)
(type_tparameter::type_tparameter)
(non_type_tparameter::non_type_tparameter)
(template_tparameter::template_tparameter)
(type_composition::type_composition)
(function_tdecl::function_tdecl, function_tdecl::function_tdecl)
(class_tdecl::class_tdecl):
Likewise and call runtime_type_instance() here to set the runtime
type instance pointers of the current instance.
(is_decl, is_type, is_class_type, is_pointer_type): Adjust to use
the new poor-man's rtti machinery.
(is_type_decl): Replace the overloads that takes a type_base*
and/or a decl_base* by one that takes a type_or_decl_base*.
(pointer_type_def::operator==, class_decl::operator==): Use the
poor-man's rtti machinery to replace dynamic_cast.
hash_type_or_decl: Replace dynamic_cast<const type_base> by
is_type() and dynamic_cast<const decl_base*> by is_decl().
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
2209df1b90 |
Make abidiff --harmless show harmless changes in unions
Since the previous commit filters out harmless changes inside unions,
this one allows those changes to be reported whenever the user runs
abidiff with the --harmless option.
The patch just displays the "before" and "after" of the union because
some of the harmless changes are not tracked anymore.
Because we want to display the before and after of the union we use
the function get_class_or_union_flat_representation. The patch adds a
"qualified_name" boolean parameter to that function so that we can
choose to display union members names in a non-qualified fashion,
which is the natural way of displaying those names in the context of a
union (or class) representation. Because
get_class_or_union_flat_representation uses
type_or_decl_base::get_pretty_representation, the patch has also added a
"qualified_name" boolean parameter to that function so that we can
choose to display names in a non-qualified manner.
* include/abg-fwd.h (get_class_or_union_flat_representation): Add
a "qualified_name" boolean parameter.
* include/abg-ir.h ({type_or_decl_base, decl_base, type_decl,
namespace_decl, array_type_def::subrange_type, array_type_def,
enum_type_decl, typedef_decl, var_decl, function_decl,
function_decl::parameter, function_type, method_type, class_decl,
union_decl}::get_pretty_representation): Likewise.
* src/abg-ir.cc ({type_or_decl_base, decl_base, type_decl,
namespace_decl, array_type_def::subrange_type, array_type_def, enum_type_decl,
typedef_decl, var_decl, function_decl, function_decl::parameter,
function_type, method_type, class_decl, union_decl,
}::get_pretty_representation): Adjust the code to emit qualified
or non-qualified names depending on the new "qualified_name"
boolean parameter.
(get_class_or_union_flat_representation): Likewise.
* src/abg-default-reporter.cc (default_reporter::report): Use
get_class_or_union_flat_representation with the new
"qualified_name" boolean set to false.
* tests/data/test-diff-dwarf/test38-union-report-0.txt: Adjust.
* tests/test-diff-filter.cc (in_out_specs): Run the test harness
on test-PR24731-v{0,1}.o make abidiff use the --harmless option.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
a11a0068ea |
Bug 24731 - Wrongly reporting union members order change
When union data members are re-ordered, abidiff reports the re-ordering as if it was a meaningful ABI change. This patch teaches Libabigail to categorize that benign type layout change as a HARMLESS_UNION_CHANGE_CATEGORY kind of change and ignore it. * include/abg-comp-filter.h (union_diff_has_harmless_changes): Declare new function and ... * src/abg-comp-filter.cc (union_diff_has_harmless_changes): ... define it here. (categorize_harmless_diff_node): Use the new union_diff_has_harmless_changes here. * include/abg-comparison.h (HARMLESS_UNION_CHANGE_CATEGORY): Add a new enumerator to diff_category enum. Adjust the value of the other enumerators. * src/abg-comparison.cc (get_default_harmless_categories_bitmap): Add the new HARMLESS_UNION_CHANGE_CATEGORY in here. (operator<<(ostream& o, diff_category c)): Support the new HARMLESS_UNION_CHANGE_CATEGORY. * tests/data/test-diff-filter/test-PR24731-report-0.txt: Likewise. * tests/data/test-diff-filter/test-PR24731-report-1.txt: Likewise. * tests/data/test-diff-filter/test-PR24731-v0.c: Likewise. * tests/data/test-diff-filter/test-PR24731-v0.o: Likewise. * tests/data/test-diff-filter/test-PR24731-v1.c: Likewise. * tests/data/test-diff-filter/test-PR24731-v1.o: Likewise. * tests/data/Makefile.am: Add the new test material above to source distribution. * tests/test-diff-filter.cc (in_out_spec): Add the new test input to this test harness. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Dodji Seketeli
|
bf100fcb41 |
Fully account for anonymous-ness of scopes when comparing decl names
When comparing internal decl names (as part of decl comparison), we
need to take into account the fact that a given decl might be
anonymous and that it might have anonymous scopes in its tree of
containing scopes.
For instance, "__anonymous_struct__1::foo" and
"__anonymous_struct__2::foo" are considered equivalent.
So are "__anonymous_struct__1::foo::__anonymous_struct__2::bar" and
"__anonymous_struct__10::foo::__anonymous_struct__11::bar".
But "__anonymous_struct__1::bar::__anonymous_struct__2::baz" and
"__anonymous_struct__10::foo::__anonymous_struct__11::bar" are not.
This patch introduces the function tools_utils::decl_names_equal that
compares fully qualified names by taking into account anonymous
component names.
That function is thus used in the equals() function overload for
decl_base types. Because tools_utils::decl_names_equal compares strings the
usual way (character by character) it's slower than comparing
instances of interned_string in a O(1) time. So the patch carefully
tries to use tools_utils::decl_names_equal sparringly; that is, it
uses it only when we are looking at decls that have some anonymous
scope. That way, we use the fast interned_string comparison most of
the time. By doing this, we barely see any performance degradation
while running abidw --noout on a full blown vmlinux binary.
* include/abg-ir.h (decl_base::{get_has_anonymous_parent,
set_has_anonymous_parent,
get_is_anonymous_or_has_anonymous_parent}): Declare new member
functions.
* src/abg-ir.cc (decl_base::priv::has_anonymous_parent_): Define
new data member.
(decl_base::priv): Initialize the new data member.
(decl_base::{get_has_anonymous_parent, set_has_anonymous_parent,
get_is_anonymous_or_has_anonymous_parent}): Define new member
functions.
(equals): In the overload for decl_base, use the new
decl_names_equal for decls that have anonymous scopes.
(scope_decl::add_member_decl): Propagate the
decl_base::has_anonymous_parent_ property.
* include/abg-tools-utils.h
(get_anonymous_struct_internal_name_prefix)
(get_anonymous_union_internal_name_prefix)
(get_anonymous_enum_internal_name_prefix, decl_names_equal):
Declare new functions.
* src/abg-comp-filter.cc (has_harmless_name_change): Handle the
case where the name change is actually from an anonymous name to
another one, using the new decl_names_equal function.
* src/abg-dwarf-reader.cc
(get_internal_anonymous_die_prefix_name): Renamed
get_internal_anonynous_die_base_name into this. Use the new
get_anonymous_{struct, union, enum}_internal_name_prefix functions
here.
(get_internal_anonymous_die_name, die_qualified_type_name)
(build_enum_type, add_or_update_class_type)
(add_or_update_union_type): Adjust.
* src/abg-tools-utils.cc (get_anonymous_struct_internal_name_prefix)
(get_anonymous_union_internal_name_prefix)
(get_anonymous_enum_internal_name_prefix, decl_names_equal):
Define new functions.
* tests/test-tools-utils.cc: New test file.
* tests/Makefile.am: Add new runtesttoolsutils test, built from
test-tools-utils.cc.
* tests/data/test-diff-dwarf/test46-rust-report-0.txt: Adjust.
* tests/data/test-diff-pkg/spice-server-0.12.4-19.el7.x86_64-0.12.8-1.el7.x86_64-report-3.txt:
Likewise.
* tests/data/test-read-dwarf/PR22122-libftdc.so.abi: Likewise.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Matthias Maennich
|
2651a3623a |
abg-reporter.h: add missing includes / using declarations
In order to build this (external!) header file stand-alone, it required some minor fixes. I.e. adding some includes and using declarations. * include/abg-reporter.h: fix includes and using declarations Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Dodji Seketeli
|
073608f47d |
Take anonymous scopes into account when comparing decls
This is another attempt at handling anonymous decls comparison. It's not the full blown method that I'd like, but this one seems to be fast enough. In this method, we take the immediate scope (and whether it's anonymous or not) of the anonymous decl into account. * include/abg-interned-str.h (interned_string::clear): Add new member function. * src/abg-ir.cc (equals): In the overload for decl_base, consider the scope of the current (anonymous) decl. If that scope is anonymous then take that into account as well. * tests/data/test-diff-pkg/spice-server-0.12.4-19.el7.x86_64-0.12.8-1.el7.x86_64-report-3.txt: Adjust. * tests/data/test-read-dwarf/PR22122-libftdc.so.abi: Likewise. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Matthias Maennich
|
1e67db0797 |
abg-writer: drop deprecated API
Drop the deprecated overloads for write_translation_unit, write_corpus, write_corpus_group. Also remove the deprecation facilities as they are not used anymore. * include/abg-fwd.h (ABG_DEPRECATED): Remove this macro. * include/abg-writer.h (write_translation_unit, write_corpus) (write_corpus_group): Drop the deprecated overloads of these declarations. * src/abg-writer.cc (write_translation_unit, write_corpus) (write_corpus_group): Drop the deprecated overloads of these definitions. Signed-off-by: Matthias Maennich <maennich@google.com> Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Matthias Maennich
|
f3f7537b6e |
abidw: add option to only emit file names (--short-locs)
Various emitted directories contain machine specific information and
therefore break reproducibility of abidw's output across different
build paths.
Hence introduce --short-locs to only emit file names.
Thanks to earlier changes, adding an option boils down to adding it to
set_opts and to the write_context along with some auxiliary functions
for setting and getting.
* include/abg-writer.h (set_short_locs): Declare new function.
(set_common_options): Use it.
set_opts
* src/abg-writer.cc (write_context::m_short_locs): New data
member.
(write_context::write_context): Initialize it.
(write_context::{g,s}et_short_locs): Define new accessors.
(write_location, write_translation_unit, write_corpus): Honour the
new write_context::get_short_locs property.
(set_short_locs): Define new function.
* tools/abidw.cc (options::short_locs): New data member.
(display_usage): Help string for the new --no-show-locs option.
(parse_command_line): Parse the new --no-show-locs option.
Signed-off-by: Matthias Maennich <maennich@google.com>
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Matthias Maennich
|
bf9e8b9448 |
abidw: add option to omit the compilation directory
The compilation directory contains machine specific information
therefore breaks reproducibility of abidw's output across different
build paths. Hence introduce --no-comp-dir-path (as in the xml
attribute). Internally I decided to not carry on the duplication of
'dir' and 'path' and used 'comp_dir'.
Thanks to earlier changes, adding an option boils down to adding it to
set_common_options and to the write_context along with some auxiliary
functions for setting and getting.
write_translation_unit uses the flag in the write_context and omits the
comp-dir-path if asked for.
* include/abg-writer.h (set_write_comp_dir): Declare new function.
(set_common_options): Use it.
* src/abg-writer.cc (write_context::m_write_comp_dir): Define new
data member.
(write_context::write_context): Initialize it.
(write_context::{g,s}et_write_comp_dir): Define new member
accessors.
(set_write_comp_dir): Define new free-form getter.
(write_translation_unit): Teach to respect write_comp_dir flag of
write_context.
* tools/abidw.cc (options::write_corpus_path): Define new data
member.
(options::options): Initialize it.
(display_usage): Add doc string for a new command line option: --no-comp-dir-path.
(parse_command_line): Parse the new command line option --no-comp-dir-path.
Signed-off-by: Matthias Maennich <maennich@google.com>
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Matthias Maennich
|
fca2661581 |
Make write_architecture and write_corpus_path flags in the write_context
Having write_context carry corresponding flags for output sensitive
command line options, is useful to ensure these options are not lost in
chains for write_* calls. In particular, these options can have various
meanings depending on the context (corpus, corpus_group, etc.)
Hence add them to the write_context along with getters and setters and
make the writers aware of their existence. We do not need to modify the
corpus or corpus group's path or architecture any longer as they get
ignored for a different reason now.
Finally, drop the flag handling in abidw as it is already done via
set_opts, which learned about these new flags.
* include/abg-writer.h (set_write_architecture)
(set_write_corpus_path): Declare new getter functions.
(write_corpus): Take a new "member_of_group" argument.
(set_common_options): Use set_write_{architecture, corpus_path}
here.
* src/abg-writer.cc (write_context::m_write_{architecture,
corpus_path}}): Add new data members.
(write_context::write_context): Initialize the new data members.
(write_context::{s,g}et_write_{architecture, corpus}): Define new
accessors.
(set_write_{architecture, corpus}): Define new free-form getter
functions.
(write_corpus): Add flag to make aware if written as part of a
group.
* tools/abidw.cc (load_corpus_and_write_abixml)
(load_kernel_corpus_group_and_write_abixml): Drop obsolete option
handling as xml_writer::set_common_options now takes care of it.
Signed-off-by: Matthias Maennich <maennich@google.com>
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
ldiff --git a/include/abg-writer.h b/include/abg-writer.h
index 200b5f7..729b455 100644
--- a/include/abg-writer.h
+++ b/include/abg-writer.h
@@ -53,6 +53,11 @@ set_show_locs(write_context& ctxt, bool flag);
void
set_annotate(write_context& ctxt, bool flag);
+void
+set_write_architecture(write_context& ctxt, bool flag);
+
+void
+set_write_corpus_path(write_context& ctxt, bool flag);
/// A convenience generic function to set common options (usually used
/// by Libabigail tools) from a generic options carrying-object, into
@@ -69,6 +74,8 @@ set_common_options(write_context& ctxt, const OPTS& opts)
{
set_annotate(ctxt, opts.annotate);
set_show_locs(ctxt, opts.show_locs);
+ set_write_architecture(ctxt, opts.write_architecture);
+ set_write_corpus_path(ctxt, opts.write_corpus_path);
}
void
@@ -105,7 +112,10 @@ write_corpus_to_archive(const corpus_sptr corp,
const bool annotate = false);
bool
-write_corpus(write_context& ctxt, const corpus_sptr& corpus, unsigned indent);
+write_corpus(write_context& ctxt,
+ const corpus_sptr& corpus,
+ unsigned indent,
+ bool member_of_group = false);
bool ABG_DEPRECATED
write_corpus(const corpus_sptr& corpus, unsigned indent, write_context& ctxt);
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Matthias Maennich
|
344138e6b4 |
abidw: Consolidate setting options
When setting options meant to be used for the write_context, it is easy to forget to change all relavant locations. In order to consolidate that, introduce a set_opts function that sets various known options. We benefit from earlier refactoring as now the write_context is passed around to carry options for writers. Hence we can be sure, that if we set up the context correctly (and do not use deprecated functionality), the respective write_* function will see the options set in the context. * include/abg-writer.h (set_common_option): Declare new function. * tools/abidw.cc (load_corpus_and_write_abixml) (load_kernel_corpus_group_and_write_abixml): Use the newly introduced set_common_option. Signed-off-by: Matthias Maennich <maennich@google.com> Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Matthias Maennich
|
6c07e82933 |
write_context: allow mutating the ostream used
Allowing the mutation of the ostream, allows heavy reuse of the
write_context as this is the distinction in most places where
write_context is used.
Hence, fixup various users of write_context and use common objects where
applicable.
* include/abg-writer.h (set_ostream): Declare new function.
* src/abg-writer.cc (write_context::m_ostream): Make this data
member be a pointer rather than a reference.
(write_context::{write_context, get_ostream): Adjust. member.
(write_context::set_ostream): Define new member function.
(set_ostream): Define new free-form function.
* tools/abidw.cc (load_corpus_and_write_abixml)
(load_kernel_corpus_group_and_write_abixml): Use the feature of
mutating the ostream and reuse the write_context in most cases.
Signed-off-by: Matthias Maennich <maennich@google.com>
|
||
|
Matthias Maennich
|
6aeed171c1 |
abg-writer: Refactor write_corpus_group API
Introduce a new call overload for write_corpus_group that follows the parameter order context, object (i.e. corpus_group), indent. Deprecate all other overloads that were part of the API and mostly forward them to the new overload. That effort is made to ensure write_context is always provided. write_context allows access to all options that influence the output format. * include/abg-writer.h (write_corpus_group): Introduce new overload write_corpus_group(ctxt, corpus_group, indent) and deprecate all others. * src/abg-writer.cc (write_corpus_group): Likewise for the definitions and adjust. * tools/abidw.cc (load_kernel_corpus_group_and_write_abixml): Migrate to new API of write_corpus_group() Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Matthias Maennich
|
948f27480f |
abg-writer: Refactor write_corpus API
Introduce a new overload for write_corpus that follows the parameter order context, object (i.e. corpus), indent. Deprecate all other overloads that were part of the API and mostly forward them to the new overload. That effort is made to ensure write_context is always provided. write_context allows access to all options that influence the output format. * include/abg-writer.h (write_corpus): Introduce new overload write_corpus(ctxt, corpus, indent) and deprecate all others. * src/abg-writer.cc (write_corpus): Likewise for the definitions and adjust. * tests/test-read-dwarf.cc (test_task::perform): Use the new write_corpus which requires a write_context. * tools/abidw.cc (load_corpus_and_write_abixml, ): Likewise. * tools/abilint.cc (main): Likewise. Also simplify logic around the locations as they now can be expressed with less code. Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Matthias Maennich
|
f5907c7e74 |
abg-writer: Refactor write_translation_unit API
Introduce a new overload for write_translation_unit that follows the parameter order context, object (i.e. translation unit), indent. Deprecate all other overloads that were part of the API and mostly forward them to the new one. That effort is made to ensure write_context is always provided. write_context allows access to all options that influence the output format. * include/abg-writer.h (write_translation_unit): Declare a new overload write_translation_unit(ctxt, tu, indent) and deprecate all others. * src/abg-writer.cc (write_translation_unit): Likewise in the definitions. (write_corpus, dump, write_translation_unit): Adjust. * tools/abilint.cc (main): use new write_translation_unit() API Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Matthias Maennich
|
b0f123c18e |
Add deprecation facilities
Add the macro 'ABG_DEPRECATED' to mark APIs as to be removed in a next major release. APIs marked with that flag are supposed to work as before, but might come with downsides. E.g. they could perform worse or provide only limited functionality. All deprecated functions shall come with a hint to equivalent functionality within the non-deprecated part of the API. * include/abg-fwd.h: Introduce deprecation macro ABG_DEPRECATED Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Dodji Seketeli
|
f754d81116 |
Bug 24552 - abidiff fails comparing a corpus against a corpus group
In this problem report, the issue is that when comparing two corpus
groups, especially when looking up function/variable symbols, the
get_fun_symbol_map() and get_var_symbol_map() member functions used
are corpus::get_{fun,var}_symbol_map, rather than
corpus_group::get_{fun, var}_symbol_map. Note that the type
corpus_group inherits from the type corpus. That leads to unexpected
comparison results, especially for symbols.
This patch fixes this by making the corpus::get_{fun, var}_symbol_map
member function be virtual and by using it during the lookup of
function/variable symbols. That way, the right symbol map gets used.
* include/abg-corpus.h (corpus{_group}::get_{fun,
var}_symbol_map): Make these member functions virtual.
* src/abg-corpus.cc (corpus::lookup_{function, variable}_symbol):
Use the virtual corpus::get_{fun, var}_symbol_map() member
function to get the symbols of the current corpus or corpus_group.
* tests/data/Makefile.am: Add the new test input material below to
source distribution.
* tests/data/test-abidiff/test-PR24552-report0.txt: New test input.
* tests/data/test-abidiff/test-PR24552-v0.abi: Likewise.
* tests/data/test-abidiff/test-PR24552-v1.abi: Likewise.
* tests/test-abidiff.cc (main): Support comparing corpus groups.
(specs): Add the new test inputs to the harness.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
2cf9a18e8c |
Better handle several anonymous types of the same kind
This is a follow-up patch for the commit:
|
||
|
Dodji Seketeli
|
43d56de89b |
Handle several member anonymous types of the same kind
When there are several anonymous types (e.g, anonymous classes, unions
or enums) in a given class or union, libabigail's internals do
struggle.
An anonymous class, for instance, is named __anonymous_struct__. When
there are more than one of these inside a given class, then we can't
name and look them up, because they all have the same name.
Incidentally, when add_or_update_class_type completes a class type
that was initially constructed before, it fails to determine that an
anonymous member type of that class was already present in that
context. It thus wrongly duplicates anonymous structs/unions/enums in
there and that leads to spurious textual (abixml) representation
differences later, where duplicated anonymous member types would
appear intermittently, depending on the order in which the class was
built.
This patch addresses this general issue by naming anonymous member
types in a way that allows several of them to exist. That is, if there
are two anonymous structs in a class, they are going to be named
__anonymous_struct__ and __anonymous_struct__1. We do follow a
similar scheme for anonymous unions and enums. This is handled by the
DWARF reader that builds the internal representation.
While looking at this issue, I also fixed a tangent bug; some DWARF
emitters wrongly *define* types in the scope of a
DW_TAG_subroutine_type or DW_TAG_array_type. We handle that by
actually defining those types in the scope of that subroutine or
array. But then it appears that if that scope itself a class and if
the type defined is an anonymous type, then putting that anonymous
type in the class scope might interfere with the *naming* of the
existing legit anonymous types of that scope. I decided to put those
anonymous types in the containing namespace instead. We'll see how
that goes in real time use.
The patch also updates lots of existing tests and adds a new one.
* include/abg-ir.h
(class_or_union::get_num_anonymous_member_{classes, unions,
enums}): Declare new member functions.
* src/abg-dwarf-reader.cc (get_internal_anonynous_die_base_name)
(build_internal_anonymous_die_name)
(get_internal_anonymous_die_name, is_anonymous_type_die): Define
new static functions.
(die_qualified_type_name): Use the new
get_internal_anonymous_die_name.
(get_scope_for_die): Fix this to put anonymous types that were
wrongly emitted into the scope of DW_TAG_subroutine_type or
DW_TAG_array_type by buggy DWARF emitters into the enclosing
namespace, rather than into the enclosing class/union.
(build_enum_type): Take the scope of the enum to have a chance to
properly name potential anonymous enums.
(lookup_class_typedef_or_enum_type_from_corpus): Take an anonymous
member type index for when the DIE we are lookup up represents an
anonymous type. Support proper building of the internal anonymous
name of the anonymous type we are lookup up.
(add_or_update_class_type): Use the new
get_internal_anonynous_die_base_name and
build_internal_anonymous_die_name functions. Support making sure
that the anonymous member type we are adding to the class wasn't
already there, especially for cases where we are updating a class
type.
(add_or_update_union_type): Use the new
get_internal_anonynous_die_base_name and
build_internal_anonymous_die_name functions.
(build_ir_node_from_die): Adjust the use of build_enum_type to
pass it the scope of the enum type we are building.
* src/abg-ir.cc (lookup_union_type): Add a new overload.
(lookup_class_or_typedef_type): Use the new overload of
lookup_union_type above to support looking up union types too.
(class_or_union::get_num_anonymous_member_{classes, unions,
enums}): Define new member functions.
* src/abg-reporter-priv.cc (represent): Detect when anonymous
types of anonymous data members have their internal names change,
probably because anonymous member types were inserted in the scope.
* tests/data/Makefile.am: Add the new test-anonymous-members-0.*
test input files to the source distribution.
* tests/data/test-annotate/test-anonymous-members-0.cc: New test
input file.
* tests/data/test-annotate/test-anonymous-members-0.o: Likewise.
* tests/data/test-annotate/test-anonymous-members-0.o.abi: Likewise.
* tests/data/test-annotate/test17-pr19027.so.abi: Adjust.
* tests/data/test-annotate/test18-pr19037-libvtkRenderingLIC-6.1.so.abi:
Likewise.
* tests/data/test-annotate/test19-pr19023-libtcmalloc_and_profiler.so.abi:
Likewise.
* tests/data/test-annotate/test21-pr19092.so.abi: Likewise.
* tests/data/test-diff-filter/test30-pr18904-rvalueref-report0.txt:
Likewise.
* tests/data/test-diff-filter/test30-pr18904-rvalueref-report1.txt
* tests/data/test-diff-filter/test30-pr18904-rvalueref-report2.txt:
Likewise.
* tests/data/test-diff-filter/test35-pr18754-no-added-syms-report-0.txt:
Likewise.
* tests/data/test-read-dwarf/PR22122-libftdc.so.abi: Likewise.
* tests/data/test-read-dwarf/test12-pr18844.so.abi: Likewise.
* tests/data/test-read-dwarf/test16-pr18904.so.abi: Likewise.
* tests/data/test-read-dwarf/test17-pr19027.so.abi: Likewise.
* tests/data/test-read-dwarf/test18-pr19037-libvtkRenderingLIC-6.1.so.abi:
Likewise.
* tests/data/test-read-dwarf/test19-pr19023-libtcmalloc_and_profiler.so.abi:
Likewise.
* tests/data/test-read-dwarf/test21-pr19092.so.abi: Likewise.
* tests/data/test-read-dwarf/test22-pr19097-libstdc++.so.6.0.17.so.abi:
Likewise.
* tests/test-annotate.cc (int_out_specs): Add the new test inputs
to this test harness.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
04d61a726d |
Don't try to de-duplicate all anonymous struct DIEs
Trying to de-duplicate anonymous struct DIEs can lead to subtle issues, because there can be two different naming typedefs designating two anonymous structs that are equivalent, in the same translation unit. In that case, de-duplicating the two leaf anonymous structs DIEs leads to non-resolvable conflict. This patch avoids de-duplicating anonymous structs DIEs and rather de-duplicates (naming) typedefs. * include/abg-fwd.h (is_typedef): Remove the overloads for type_base_sptr and decl_base_sptr. Replace those with an overload for type_or_decl_base_sptr. * src/abg-ir.cc (is_typedef): Do the same for the definitions. * src/abg-dwarf-reader.cc (add_or_update_class_type) (add_or_update_union_type): Do not de-duplicate anonymous struct/union DIEs. (build_typedef_type): Try to de-duplicate typedefs DIEs. * tests/data/test-annotate/test17-pr19027.so.abi: Adjust. * tests/data/test-annotate/test19-pr19023-libtcmalloc_and_profiler.so.abi: Likewise * tests/data/test-annotate/test21-pr19092.so.abi: Likewise. * tests/data/test-read-dwarf/PR22015-libboost_iostreams.so.abi: Likewise. * tests/data/test-read-dwarf/PR22122-libftdc.so.abi: Likewise. * tests/data/test-read-dwarf/test16-pr18904.so.abi: Likewise. * tests/data/test-read-dwarf/test17-pr19027.so.abi: Likewise. * tests/data/test-read-dwarf/test19-pr19023-libtcmalloc_and_profiler.so.abi: Likewise. * tests/data/test-read-dwarf/test21-pr19092.so.abi: Likewise. * tests/data/test-read-dwarf/test9-pr18818-clang.so.abi: Likewise. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
Matthias Maennich via libabigail
|
15b4f9bb66 |
viz-dot: remove unused members from dot
_M_canvas and _M_typo are unused within "dot". Remove them and all references. * include/abg-viz-dot.h: remove unused data members from 'dot' Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Matthias Maennich via libabigail
|
704932b75a |
add missing virtual destructors
Several virtual desctructors were missing. Even though there might not have been actual leaks or similar bugs, it is worth fixing these locations as they might lead to bugs in the future. Clang also warns at these locations: warning: delete called on non-final 'abigail::ir::corpus' that has virtual functions but non-virtual destructor [-Wdelete-non-virtual-dtor] * include/abg-comparison.h: add virtual destructor for corpus_diff and diff_node_visitor * include/abg-corpus.h: add virtual destructor for corpus * include/abg-reporter.h: add virtual destructor for reporter_base * include/abg-traverse.h: add virtual destructor for traversable_base Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Matthias Maennich via libabigail
|
8cfd264224 |
diff-utils: point: fix postfix decrement/increment operator
The postfix increment / decrement operators were implemented by calling themselves recursively. Fix that by implementing these in terms of their prefix counter parts. * include/abg-diff-utils.h: fix postfix dec/inc operator Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Matthias Maennich via libabigail
|
87bbc09b9e |
abg-fwd.h: fix mismatched tags for ir_node_visitor
ir_node_visitor is defined as `class` in include/abg-ir.h:4429 and should therefore also be forward-declared as such. * include/abg-fwd.h: forward-declare ir_node_visitor as class Signed-off-by: Matthias Maennich <maennich@google.com> |
||
|
Dodji Seketeli
|
286cadf841 |
Bug 24430 - Fold away const for array types
In C and C++ the qualifiers of a qualified array type apply to the
element type of said array.
In this particular problem report, GCC and Clang emit DWARF that
represent the qualifiers either on the array type, or on the element
type. Quoting the test of the bug:
Given the following example:
struct test {
const char asdf[4];
};
void func(struct test arg) {}
abidiff says:
1 function with some indirect sub-type change:
[C]'function void func(test)' at test.c:5:1 has some indirect sub-type
changes:
parameter 1 of type 'struct test' has sub-type changes:
type size hasn't changed
1 data member change:
type of 'const char test::asdf[4]' changed:
entity changed from 'const char[4]' to 'const char[4] const'
This is because GCC represents the array as const array of const
signed char, whereas clang represents it as an array of const signed
char.
In this patch, libabigail's DWARF reader detects qualified array types
and appropriately qualifies the array element type, instead of
qualifying the array type. The patch accordingly adjusts the various
regression tests and adds a new test which comes from the problem
report.
* include/abg-fwd.h (is_array_of_qualified_element): Declare 2
overloads of this function.
(re_canonicalize): Declare a new function.
* include/abg-ir.h (class {decl_base, type_base}): Declare
re_canonicalize as a friend of these classes.
* src/abg-dwarf-reader.cc (maybe_strip_qualification): Detect
qualified array types and appropriately qualifies the array
element type, instead of qualifying the array type itself.
Re-canonicalize the resulting type if necessary.
* src/abg-ir.cc (is_array_of_qualified_element): Define 2
overloads of this function.
(re_canonicalize): Define new function.
* tests/data/Makefile.am: The two new test binary input files
PR24430-fold-qualified-array-clang and
PR24430-fold-qualified-array-gcc to source distribution, as well
as the expected reference output.
* tests/data/test-annotate/test15-pr18892.so.abi: Adjust.
* tests/data/test-annotate/test17-pr19027.so.abi: Likewise.
* tests/data/test-annotate/test19-pr19023-libtcmalloc_and_profiler.so.abi:
Likewise.
* tests/data/test-annotate/test21-pr19092.so.abi: Likewise.
* tests/data/test-diff-filter/PR24430-fold-qualified-array-clang:
New binary test input coming from the bug report.
* tests/data/test-diff-filter/PR24430-fold-qualified-array-gcc:
Likewise.
* tests/data/test-diff-filter/PR24430-fold-qualified-array-report-0.txt:
Expected reference abi difference.
* tests/data/test-diff-filter/test33-report-0.txt: Adjust.
* tests/data/test-diff-pkg/nss-3.23.0-1.0.fc23.x86_64-report-0.txt:
Likewise.
* tests/data/test-read-dwarf/PR22122-libftdc.so.abi: Likewise.
* tests/data/test-read-dwarf/test12-pr18844.so.abi: Likewise.
* tests/data/test-read-dwarf/test15-pr18892.so.abi: Likewise.
* tests/data/test-read-dwarf/test17-pr19027.so.abi: Likewise.
* tests/data/test-read-dwarf/test19-pr19023-libtcmalloc_and_profiler.so.abi:
Likewise.
* tests/data/test-read-dwarf/test21-pr19092.so.abi: Likewise.
* tests/data/test-read-dwarf/test22-pr19097-libstdc++.so.6.0.17.so.abi:
Likewise.
* tests/test-diff-filter.cc: Add the new binary test input to this
test harness.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
f85dd789c2 |
Add missing assignment operators
This was detected by compiling with GCC 9.0.1
* include/abg-interned-str.h (interned_string::operator=): Define
assignment operator.
* include/abg-ir.h
({location, enum_type_decl::enumerator}::operator=): Declare
assignment operator.
* src/abg-ir.cc (enum_type_decl::enumerator::operator=): Define
assignment operator.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
782c3d8c42 |
Add ir::{lookup_data_member, get_function_parameter}
While looking at something else, I figured it's useful, for debugging purposes, to be able to lookup a given data member of a union/class by name, as well as a function parameter by index. This patch adds both. * include/abg-ir.h (lookup_data_member, get_function_parameter): Declare new functions. * src/abg-ir.cc (lookup_data_member, get_function_parameter): Define them. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Dodji Seketeli
|
0036d0448e |
Better detection of void* to something* change
Whenever a void* pointer changes to a T* pointer, we already consider that change to be ABI-compatible. The issue though is that we don't detect the case of foo* changing into T* where foo is typedef void foo. This patch fixes that. * include/abg-ir.h (is_void_type): Add a new overload that takes type_base*. * src/abg-ir.cc (is_void_type): Define the new overload that takes type_base*. (is_void_pointer_type): Look through typedefs in the pointed-to type. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Dodji Seketeli
|
e9c66d2d75 |
Avoid over-suppressing fns & vars when analysing the Kernel
When analyzing the Linux Kernel (with e.g abidw) and providing a symbol whitelist the DWARF reader performs a speed optimization which is that it does not read the symbol table of the kernel binary. To know if a function is to be suppressed (because it doesn't belong to the whitelist, for instance) dwarf_reader::function_is_suppressed actually tries to see if the address of the function corresponds to the address of an ELF symbol that is publicly exported, before looking at if the function was suppressed by a suppression specification. But then, when a whitelist is provided and the speed optimization of not reading the symbol table is at play, there is no information about ELF symbol addressed around. So dwarf_reader::function_is_suppressed almost always supposes that the function is suppressed. This patch fixes that by not trying to look at the address of the function/variable when the symbol table optimization is on. * include/abg-dwarf-reader.h (get_ignore_symbol_table): Take a const read_context&. * src/abg-dwarf-reader.cc (get_ignore_symbol_table): Likewise. (function_is_suppressed): When the symbol table optimization is in flight -- that is, when no symbol table has been loaded -- do not try to see if a given function symbol was exported at the ELF level or not. Just look at if the function was suppressed or not. (variable_is_suppressed): Likewise for variables. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Dodji Seketeli
|
84ec784743 |
Bug 24157 - Wrong support of Ada ranges
In this problem report, the DWARF reader comes across an ADA subrange
which lower bound is a negative signed integer. The problem is that
the internal representation of libabigail expects the bounds of the
subrange to be unsigned integer. This incompatibility leads to an
assertion failure.
Further down the road I realized that the function
types_have_similar_structure doesn't support subrange types.
This patch thus introduces a new
array_type_def::subrange_type::bound_value class that captures the
signedness of the bound value. This allows the internal
representation to keep the sign information of the bound value, and
yet be able to treat the bound value as either a signed or unsigned
value depending on the contexts.
The patch also extends the function types_have_similar_structure to
make it support subrange types.
* include/abg-ir.h (array_type_def::subrange_type::bound_value):
Define new class.
(array_type_def::subrange_type::subrange_type): Adjust to use the
new bound_value type for bound values.
(array_type_def::subrange_type::{get_upper_bound, get_lower_bound,
set_upper_bound, set_lower_bound}): Return or take int64_t rather
than size_t.
(array_type_def::subrange_type::get_length): Return uint64_t
rather than size_t.
* src/abg-dwarf-reader.cc (die_signed_constant_attribute)
(die_constant_attribute, die_attribute_has_form)
(die_attribute_is_signed, die_attribute_is_unsigned)
(die_attribute_has_no_signedness): Define new static functions.
(get_default_array_lower_bound): Return uint64_t rather than int.
(build_subrange_type): Use the new
array_type_def::subrange_type::bound_value type for bound values.
Use the new die_constant_attribute function, rather than
die_unsigned_constant_attribute to fecth the bound values.
* src/abg-ir.cc
(array_type_def::subrange_type::bound_value::{bound_value,
get_signedness, set_signedness, get_signed_value,
get_unsigned_value, set_unsigned, set_signed}): Define new member
functions.
(array_type_def::subrange_type::priv::{lower_bound_,
upper_bound}): Use the new class bound_value.
(array_type_def::subrange_type::priv::priv): Adjust to use the new
bound_value class to hold bound values.
(array_type_def::subrange_type::subrange_type): Likewise.
(array_type_def::subrange_type::{get_upper_bound, get_lower_bound,
set_upper_bound, set_lower_bound}): Return or take int64_t rather
than size_t.
(array_type_def::subrange_type::get_length): Return uint64_t
rather than size_t.
(types_have_similar_structure): Handle array_type_def::subrange_type
* src/abg-reader.cc (build_subrange_type): Use the new
array_type_def::subrange_type::bound_value to hold bound values.
* tests/data/test-diff-pkg/GtkAda-debuginfo-2.24.2-29.fc29.x86_64.rpm:
New binary RPM as test input.
* tests/data/test-diff-pkg/GtkAda-debuginfo-2.24.2-30.fc30.x86_64.rpm:
Likewise.
* tests/data/test-diff-pkg/GtkAda-devel-2.24.2-29.fc29.x86_64.rpm:
Likewise.
* tests/data/test-diff-pkg/GtkAda-devel-2.24.2-30.fc30.x86_64.rpm:
Likewise.
* tests/data/test-diff-pkg/GtkAda-gl-2.24.2-29.fc29.x86_64--2.24.2-30.fc30.x86_64-report-0.txt:
New expected test output.
* tests/data/test-diff-pkg/GtkAda-gl-2.24.2-29.fc29.x86_64.rpm:
New binary RPM as test input.
* tests/data/test-diff-pkg/GtkAda-gl-2.24.2-30.fc30.x86_64.rpm:
Likewise.
* tests/data/test-diff-pkg/GtkAda-gl-debuginfo-2.24.2-29.fc29.x86_64.rpm:
Likewise.
* tests/data/test-diff-pkg/GtkAda-gl-debuginfo-2.24.2-30.fc30.x86_64.rpm:
Likewise.
* tests/data/Makefile.am: Add the new test material above to source
distribution.
* tests/test-diff-pkg.cc (in_out_specs): Add the new input testing
RPMs in here.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
3826ab5308 |
Bug 24139 - Support suppressing some enumerator changes
This patch teaches the suppression specification subsystem how to
ignore changes of some enumerators in particular.
The patch adds a new property to the [suppress_type] section which is:
changed_enumerators = enumerator1, enumerator2, etc
This property is taken into accound iff the current suppress_type does
have the 'type_kind = enum' property.
Changes to enum types that match the new 'changed_enumerators'
property are suppressed.
* doc/manuals/libabigail-concepts.rst: Document the new
'changed_enumerators' property.
* include/abg-suppression.h
(type_suppression::{g, s}et_changed_enumerator_names): Declare two
new member functions.
* src/abg-suppression-priv.h
(type_suppression::priv::changed_enumerator_names_): Add a new
data member.
* src/abg-suppression.cc
(type_suppression::{g,s}et_changed_enumerator_names): Define two
new member functions.
(type_suppression::suppresses_diff): Support evaluating the new
'changed_enumerators = <vector of changed enumerators>'.
(read_type_suppression): Read the new list
property'changed_enumerators" and store it into the
type_suppression using the new
type_suppression::set_changed_enumerator_names ().
* tests/data/test-diff-suppr/libtest4{0,1}-enumerator-changes-v{0,1}.so:
Add new test inpujts.
* tests/data/test-diff-suppr/test4{0,1}-enumerator-changes-0.suppr:
Add a new suppr spec for this new test.
* tests/data/test-diff-suppr/test4{0,1}-enumerator-changes-report-0.txt:
The default report.
* tests/data/test-diff-suppr/test4{0,1}-enumerator-changes-v{0,1}.cc:
Add Source code of libtest4{0,1}-enumerator-changes-v{0,1}.so.
* tests/data/Makefile.am: Add the test files above to source
distribution.
* tests/test-diff-suppr.cc: Add the test input files above to the
harness.
Signed-off-by: Dodji Seketeli <dodji@redhat.com>
|
||
|
Dodji Seketeli
|
52369923ac |
Better comments in the comparison engine
* include/abg-comparison.h (enum diff_category): Add comments to describe what to update when a new enumerator is added to this enum. * src/abg-comp-filter.cc (has_fn_return_type_cv_qual_change): Fix comment thinko here. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Dodji Seketeli
|
7d639aef70 |
Bug 20175 - Classify CV qual changes in variable type as harmless
When the type of a variable changes and that change is only a CV qual change, we want libabigail to automatically classify that change as being harmless. This patch thus introduces a new VAR_TYPE_CV_CHANGE_CATEGORY change category (enumerator of the abigail::comparison::diff_category enum) for this kind of changes and classifies that category as being harmless. The patch then detects diff nodes that carry CV qualifiers change on variable types and flags them as belonging to the new VAR_TYPE_CV_CHANGE_CATEGORY. * include/abg-comparison.h (VAR_TYPE_CV_CHANGE_CATEGORY): Add new enumerator to diff_category enum. (EVERYTHING_CATEGORY): Update this enumerator. * src/abg-comp-filter.cc (type_diff_has_cv_qual_change_only): Support array diff nodes carrying a cv qual change on the element type. (has_var_type_cv_qual_change): Define new static function. (categorize_harmless_diff_node): Use the new has_var_type_cv_qual_change to categorize variable diff node with cv qual change on its type as harmless. * src/abg-comparison.cc (get_default_harmless_categories_bitmap): Update this. (operator<<(ostream& o, diff_category c)): Likewise. * include/abg-ir.h (equals_modulo_cv_qualifier): Declare new ... * src/abg-ir.cc (equals_modulo_cv_qualifier): ... function. * tests/data/test-diff-pkg/libICE-1.0.6-1.el6.x86_64.rpm--libICE-1.0.9-2.el7.x86_64.rpm-report-0.txt: Update expected test output. * tests/data/test-diff-pkg/spice-server-0.12.4-19.el7.x86_64-0.12.8-1.el7.x86_64-report-2.txt: Likewise. * tests/data/Makefile.am: Add the new test material below to source distribution. * tests/data/test-diff-pkg/nss-3.23.0-1.0.fc23.x86_64-report-0.txt: New expecte test output. * tests/data/test-diff-pkg/nss-3.23.0-1.0.fc23.x86_64.rpm: New test input. * tests/data/test-diff-pkg/nss-3.24.0-1.0.fc23.x86_64.rpm: Likewise. * tests/data/test-diff-pkg/nss-debuginfo-3.23.0-1.0.fc23.x86_64.rpm: Likewise. * tests/data/test-diff-pkg/nss-debuginfo-3.24.0-1.0.fc23.x86_64.rpm: Likewise. * tests/data/test-diff-pkg/nss-devel-3.23.0-1.0.fc23.x86_64.rpm: Likewise. * tests/data/test-diff-pkg/nss-devel-3.24.0-1.0.fc23.x86_64.rpm: Likewise. * tests/test-diff-pkg.cc (in_out_specs): Add the test input above to the test harness. Signed-off-by: Dodji Seketeli <dodji@redhat.com> |
||
|
Mark Wielaard
|
2366dca947 |
Conditionalize the use of DW_LANG_C_plus_plus_03 and DW_LANG_Rust
Older elfutils (pre-0.170) don't define these constants in dwarf.h so don't use them in that case. * include/abg-ir.h (LANG_C_plus_plus_03): Add this new language enum to "enum translation_unit::language". * src/abg-dwarf-reader.cc (dwarf_language_to_tu_language): Do not use DW_LANG_Rust or DW_LANG_C_plus_plus_03 if these are not defined. (get_default_array_lower_bound): Handle the new translation_unit::LANG_C_plus_plus_03 enumerator. Signed-off-by: Mark Wielaard <mark@klomp.org> Signed-off-by: Dodji Seketeli <dodji@redhat.com> |