On Wed, 13 Aug 2025, Iain Sandoe wrote:
> 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.
I see, thanks for the heads up. I started using the following patch
locally to see how the approach fares in practice. No plans to
submit/polish it any time soon. I guess a proper patch should make
this behavior opt-in.
gcc/Makefile.in | 2 +-
gcc/cp/Make-lang.in | 4 ++++
2 files changed, 5 insertions(+), 1 deletion(-)
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index 340651793473..e3f7809f72fa 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -1110,7 +1110,7 @@ ALL_CFLAGS = $(T_CFLAGS) $(CFLAGS-$@) \
# The C++ version.
ALL_CXXFLAGS = $(T_CFLAGS) $(CFLAGS-$@) $(CXXFLAGS) $(INTERNAL_CFLAGS) \
$(COVERAGE_FLAGS) $(ALIASING_FLAGS) $(NOEXCEPTION_FLAGS) \
- $(WARN_CXXFLAGS) @DEFS@
+ $(WARN_CXXFLAGS) $(POST_CFLAGS-$@) @DEFS@
# Likewise. Put INCLUDES at the beginning: this way, if some autoconf macro
# puts -I options in CPPFLAGS, our include files in the srcdir will always
diff --git a/gcc/cp/Make-lang.in b/gcc/cp/Make-lang.in
index dae3c6846e04..d0f4b367d3d4 100644
--- a/gcc/cp/Make-lang.in
+++ b/gcc/cp/Make-lang.in
@@ -76,6 +76,10 @@ cp/module.o: s-cp-module-version
CFLAGS-cp/module.o += -DMODULE_VERSION='$(shell cat s-cp-module-version)'
endif
+ifneq ($(DEVPHASE_c),)
+POST_CFLAGS-cp/tree.o += -g3
+endif
+
# Create the compiler driver for g++.
GXX_OBJS = $(GCC_OBJS) cp/g++spec.o
xg++$(exeext): $(GXX_OBJS) $(EXTRA_GCC_OBJS) libcommon-target.a $(LIBDEPS)
>
> 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).
>
>
