Hi Patrick,
> On 13 Aug 2025, at 16:26, Patrick Palka <ppa...@redhat.com> wrote:
>
> On Sun, 10 Aug 2025, Jason Merrill wrote:
>
>> On 8/8/25 1:27 PM, Patrick Palka wrote:
>>> Bootstrapped and regtested on x86_64-pc-linux-gnu, does this look OK
>>> for trunk?
>>>
>>> -- >8 --
>>>
>>> At some point these flag start getting defined in terms of the previous
>>> flag, which is inconvenient when we want to test if the flag is set
>>> during a debugging session since we don't immediately know its actual
>>> numeric value.
>>
>> Can't you ask the debugger its value? You're using -g3, right?
>
> I've just been using a vanilla --disable-bootstrap build which uses -g by
> default. -g3 works nicely, I wonder why it isn't the default given our
> still pervasive use of macros?
>
> Looks like impact on build time/memory use is minimal compared to -g,
> but it does increase the size of each object file by about 2MB. Can't
> we just build one object file with -g3 to preserve the macro definitions
> (and perhaps with -fkeep-inline-functions so that small inline functions
> will be preserved as well), and the rest with -g?
g3 is problematical on Darwin where it is not supported by the ‘binutils' or
lldb and newer linker issues warnings about the lack of support
(yes, I wish it worked, but too many projects already).
So, please loop me in to test any proposed patch to catch build fails early.
thanks
Iain
>
>>
>> The current pattern was intended to allow adding/removing flags without
>> adjusting the whole list, but I guess we could also leave a hole if we remove
>> a flag.
>
> Makes sense, though removing flags doesn't seem to happen very often --
> around 12 times according to
>
> git log --oneline --grep "LOOKUP_.*[rR]emove" --grep "LOOKUP_.*[dD]elete"
>
>>
>> So, it's not clear to me that this is an improvement, but I also don't object
>> to it; if it's helpful to you then it's OK.
>>
>>> It also results in a rather large AST that looks like
>>> ((1 << (1 << ...)) << 1). This patch defines all LOOKUP_* flags directly.
>>>
>>> gcc/cp/ChangeLog:
>>>
>>> * cp-tree.h (LOOKUP_NO_NARROWING): Determine value directly, not
>>> in terms of the previous flag.
>>> (LOOKUP_LIST_INIT_CTOR): Likewise.
>>> (LOOKUP_COPY_PARM): Likewise.
>>> (LOOKUP_LIST_ONLY): Likewise.
>>> (LOOKUP_SPECULATIVE): Likewise.
>>> (LOOKUP_DEFAULTED): Likewise.
>>> (LOOKUP_ALREADY_DIGESTED): Likewise.
>>> (LOOKUP_NO_RVAL_BIND): Likewise.
>>> (LOOKUP_NO_NON_INTEGRAL): Likewise.
>>> (LOOKUP_DELEGATING_CONS): Likewise.
>>> (LOOKUP_ALLOW_FLEXARRAY_INIT): Likewise.
>>> (LOOKUP_REWRITTEN): Likewise.
>>> (LOOKUP_REVERSED): Likewise.
>>> (LOOKUP_AGGREGATE_PAREN_INIT): Likewise.
>>> (LOOKUP_SHORTCUT_BAD_CONVS): Likewise.
>>> ---
>>> gcc/cp/cp-tree.h | 30 +++++++++++++++---------------
>>> 1 file changed, 15 insertions(+), 15 deletions(-)
>>>
>>> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
>>> index fb8e0d8d98e3..bc0b8fd8b85b 100644
>>> --- a/gcc/cp/cp-tree.h
>>> +++ b/gcc/cp/cp-tree.h
>>> @@ -6224,52 +6224,52 @@ enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG,
>>> TYPENAME_FLAG };
>>> /* Do not permit references to bind to temporaries. */
>>> #define LOOKUP_NO_TEMP_BIND (1 << 6)
>>> /* We're inside an init-list, so narrowing conversions are ill-formed. */
>>> -#define LOOKUP_NO_NARROWING (LOOKUP_NO_TEMP_BIND << 1)
>>> +#define LOOKUP_NO_NARROWING (1 << 7)
>>> /* We're looking up a constructor for list-initialization. */
>>> -#define LOOKUP_LIST_INIT_CTOR (LOOKUP_NO_NARROWING << 1)
>>> +#define LOOKUP_LIST_INIT_CTOR (1 << 8)
>>> /* This is the first parameter of a copy constructor. */
>>> -#define LOOKUP_COPY_PARM (LOOKUP_LIST_INIT_CTOR << 1)
>>> +#define LOOKUP_COPY_PARM (1 << 9)
>>> /* We only want to consider list constructors. */
>>> -#define LOOKUP_LIST_ONLY (LOOKUP_COPY_PARM << 1)
>>> +#define LOOKUP_LIST_ONLY (1 << 10)
>>> /* Return after determining which function to call and checking access.
>>> Used by sythesized_method_walk to determine which functions will
>>> be called to initialize subobjects, in order to determine exception
>>> specification and possible implicit delete.
>>> This is kind of a hack, but exiting early avoids problems with trying
>>> to perform argument conversions when the class isn't complete yet. */
>>> -#define LOOKUP_SPECULATIVE (LOOKUP_LIST_ONLY << 1)
>>> +#define LOOKUP_SPECULATIVE (1 << 11)
>>> /* Used by calls from defaulted functions to limit the overload set to
>>> avoid
>>> cycles trying to declare them (core issue 1092). */
>>> -#define LOOKUP_DEFAULTED (LOOKUP_SPECULATIVE << 1)
>>> +#define LOOKUP_DEFAULTED (1 << 12)
>>> /* Used in calls to store_init_value to suppress its usual call to
>>> digest_init. */
>>> -#define LOOKUP_ALREADY_DIGESTED (LOOKUP_DEFAULTED << 1)
>>> +#define LOOKUP_ALREADY_DIGESTED (1 << 13)
>>> /* Like LOOKUP_NO_TEMP_BIND, but also prevent binding to xvalues. */
>>> -#define LOOKUP_NO_RVAL_BIND (LOOKUP_ALREADY_DIGESTED << 1)
>>> +#define LOOKUP_NO_RVAL_BIND (1 << 14)
>>> /* Used by case_conversion to disregard non-integral conversions. */
>>> -#define LOOKUP_NO_NON_INTEGRAL (LOOKUP_NO_RVAL_BIND << 1)
>>> +#define LOOKUP_NO_NON_INTEGRAL (1 << 15)
>>> /* Used for delegating constructors in order to diagnose self-delegation.
>>> */
>>> -#define LOOKUP_DELEGATING_CONS (LOOKUP_NO_NON_INTEGRAL << 1)
>>> +#define LOOKUP_DELEGATING_CONS (1 << 16)
>>> /* Allow initialization of a flexible array members. */
>>> -#define LOOKUP_ALLOW_FLEXARRAY_INIT (LOOKUP_DELEGATING_CONS << 1)
>>> +#define LOOKUP_ALLOW_FLEXARRAY_INIT (1 << 17)
>>> /* We're looking for either a rewritten comparison operator candidate or
>>> the
>>> operator to use on the former's result. We distinguish between the two
>>> by
>>> knowing that comparisons other than == and <=> must be the latter, as
>>> must
>>> a <=> expression trying to rewrite to <=> without reversing. */
>>> -#define LOOKUP_REWRITTEN (LOOKUP_ALLOW_FLEXARRAY_INIT << 1)
>>> +#define LOOKUP_REWRITTEN (1 << 18)
>>> /* Reverse the order of the two arguments for comparison rewriting. First
>>> we
>>> swap the arguments in add_operator_candidates, then we swap the
>>> conversions
>>> in add_candidate (so that they correspond to the original order of the
>>> args), then we swap the conversions back in build_new_op_1 (so they
>>> correspond to the order of the args in the candidate). */
>>> -#define LOOKUP_REVERSED (LOOKUP_REWRITTEN << 1)
>>> +#define LOOKUP_REVERSED (1 << 19)
>>> /* We're initializing an aggregate from a parenthesized list of values.
>>> */
>>> -#define LOOKUP_AGGREGATE_PAREN_INIT (LOOKUP_REVERSED << 1)
>>> +#define LOOKUP_AGGREGATE_PAREN_INIT (1 << 20)
>>> /* We're computing conversions as part of a first pass of overload
>>> resolution
>>> wherein we don't try to distinguish an unviable candidate from a
>>> non-strictly viable candidate and thus can avoid computing unnecessary
>>> bad conversions. */
>>> -#define LOOKUP_SHORTCUT_BAD_CONVS (LOOKUP_AGGREGATE_PAREN_INIT << 1)
>>> +#define LOOKUP_SHORTCUT_BAD_CONVS (1 << 21)
>>> /* These flags are used by the conversion code.
>>> CONV_IMPLICIT : Perform implicit conversions (standard and
>>> user-defined).
