[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: inlining change and abidiff noise

Hello Ben,

Ben Woodard <woodard@redhat.com> a écrit:

> One of the challenges doing inter-compiler comparison between object
> files created by different compilers is that the signal to noise ratio
> is very high apparently due to different inlining decisions.
> Would there be any negative consequences to having abidiff consider
> changes which appear to be due to just differences in how the
> compilers choose to inline functions.
> As a case in point:
> $ ./tools/abidiff ./tools/.libs/abidiff ../build-llvl/tools/.libs/abidiff
> Functions changes summary: 4 Removed, 0 Changed, 0 Added functions
> Variables changes summary: 0 Removed, 0 Changed, 0 Added variable
> Function symbols changes summary: 7 Removed, 223 Added function
> symbols not referenced by debug info
> Variable symbols changes summary: 0 Removed, 3 Added variable symbols
> not referenced by debug info
> when you look 3 out of 4 of the removed functions and all 233 of the
> added functions you can quickly see that they are all weak symbols.

A weak symbol is not necessarily a symbol that results from function

A user can very well write in her code:

    int __attribute__((weak)) power2(int x);

And the symbol of that function 'power2' is going to be weak.

In this case, however, abidiff is saying that: 

    > Function symbols changes summary: 7 Removed, 223 Added function symbols not referenced by debug info

In other words, it is saying that the symbols that got added/removed
match *no* debug info.  That is to say that no function explicitely
written by the user generated those ELF symbols.  It follows that those
symbols result from functions that were generated artificially by the

If this change was happening between two binaries generated with the
same compiler (and using the same compiler option), it would certainly
be a hint of a problem.

In this case of binaries generated by different compilers, I guess it's
different, especially after you've analyzed the changes as you did.

So in this case, you could have used the --no-unreferenced-symbols
option of abidiff to tell it to avoid showing you changes on symbols for
which there is no debug info.

> The assumption that I'm making is that adding logic like:
> if a symbol is added or removed and the only reference to it is with a
> weak symbol then it is a result of a change in inlining and it is
> therefore harmless.

I think that assumption is not correct, unfortunately.  A removed weak
symbol can result from a using removing the declaration below from the

    int __attribute__((weak)) power2(int x);

So doing this by default might lead us to miss some real problems.

Maybe we could add a --no-weak-symbols option to abidiff that would
implement the logic you are talking about?  That way, people who know
what they are doing, like yourself, would use it.

Then, we'd write a guide for people analysing ABI changes that are due
to using different compilers.  That guide would introduce the subtleties
we are talking about here and mention the abidiff options that need to
be used, when and why.

What do you think?