[Bug exp/30271] Addresses of static thread_local fields are badly calculated sometimes

["michal.chojnowski at scylladb dot com" <sourceware-bugzilla@sourceware.org>]

https://sourceware.org/bugzilla/show_bug.cgi?id=30271

--- Comment #3 from Michal Chojnowski <michal.chojnowski at scylladb dot com> ---
I managed to boil it down to a minimal example. I've added the test case as an
attachment.

As it turns out, the problem happens because
`cooked_index_functions::expand_symtabs_matching` fails to expand the symtabs
which contain the definitions of the static fields, because cooked index
entries corresponding to static fields don't have parent_entry set. (For this
part of the bug, thread_local is not relevant — this happens for any static
field, but only thread_local messes up the fallback code path which happens
after the lookup fails).

This only happens when the test is compiled with clang, though. (I tested that
with clang++ 15.0.7). It doesn't seem to happen with gcc. (I tested that with
g++ 12.2.1).

If the relevant symtab is expanded beforehand, e.g. by another lookup, then the
lookup of the static field won't fail. This makes the bug quite hard to hit. In
many cases, the relevant symtab is expanded by the lookup of the class which
occurs immediately before the lookup of the field. That's why two files are
needed in the test — the class lookup expands one symtab, and so the lookup of
one field doesn't fail, but it doesn't expand the other symtab and the lookup
of the other field fails.

Note that this problem with symtabs is orthogonal to the problem with
`value_static_field` which I described in earlier comments. If this turns out
to be a clang bug, `value_static_field` may still deserve a fix.

-- 
You are receiving this mail because:
You are on the CC list for the bug.