[Bug lto/113208] [14 Regression] lto1: error: Alias and target's comdat groups differs since r14-5979-g99d114c15523e0

["cvs-commit at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113208

--- Comment #34 from GCC Commits <cvs-commit at gcc dot gnu.org> ---
The master branch has been updated by Jakub Jelinek <jakub@gcc.gnu.org>:

https://gcc.gnu.org/g:c39654e7a431992773b48d61f804494b0d70855f

commit r14-10132-gc39654e7a431992773b48d61f804494b0d70855f
Author: Jakub Jelinek <jakub@redhat.com>
Date:   Thu Apr 25 20:37:10 2024 +0200

    c++: Retry the aliasing of base/complete cdtor optimization at
import_export_decl time [PR113208]

    When expand_or_defer_fn is called at_eof time, it calls import_export_decl
    and then maybe_clone_body, which uses DECL_ONE_ONLY and comdat name in a
    couple of places to try to optimize cdtors which are known to have the
    same body by making the complete cdtor an alias to base cdtor (and in
    that case also uses *[CD]5* as comdat group name instead of the normal
    comdat group names specific to each mangled name).
    Now, this optimization depends on DECL_ONE_ONLY and DECL_INTERFACE_KNOWN,
    maybe_clone_body and can_alias_cdtor use:
          if (DECL_ONE_ONLY (fn))
            cgraph_node::get_create (clone)->set_comdat_group (cxx_comdat_group
(clone));
    ...
      bool can_alias = can_alias_cdtor (fn);
    ...
          /* Tell cgraph if both ctors or both dtors are known to have
             the same body.  */
          if (can_alias
              && fns[0]
              && idx == 1
              && cgraph_node::get_create (fns[0])->create_same_body_alias
                   (clone, fns[0]))
            {
              alias = true;
              if (DECL_ONE_ONLY (fns[0]))
                {
                  /* For comdat base and complete cdtors put them
                     into the same, *[CD]5* comdat group instead of
                     *[CD][12]*.  */
                  comdat_group = cdtor_comdat_group (fns[1], fns[0]);
                  cgraph_node::get_create (fns[0])->set_comdat_group
(comdat_group);
                  if (symtab_node::get (clone)->same_comdat_group)
                    symtab_node::get (clone)->remove_from_same_comdat_group ();
                  symtab_node::get (clone)->add_to_same_comdat_group
                    (symtab_node::get (fns[0]));
                }
            }
    and
      /* Don't use aliases for weak/linkonce definitions unless we can put both
         symbols in the same COMDAT group.  */
      return (DECL_INTERFACE_KNOWN (fn)
              && (SUPPORTS_ONE_ONLY || !DECL_WEAK (fn))
              && (!DECL_ONE_ONLY (fn)
                  || (HAVE_COMDAT_GROUP && DECL_WEAK (fn))));
    The following testcase regressed with Marek's r14-5979 change,
    when pr113208_0.C is compiled where the ctor is marked constexpr,
    we no longer perform this optimization, where
    _ZN6vectorI12QualityValueEC2ERKS1_ was emitted in the
    _ZN6vectorI12QualityValueEC5ERKS1_ comdat group and
    _ZN6vectorI12QualityValueEC1ERKS1_ was made an alias to it,
    instead we emit _ZN6vectorI12QualityValueEC2ERKS1_ in
    _ZN6vectorI12QualityValueEC2ERKS1_ comdat group and the same
    content _ZN6vectorI12QualityValueEC1ERKS1_ as separate symbol in
    _ZN6vectorI12QualityValueEC1ERKS1_ comdat group.
    Now, the linker seems to somehow cope with that, eventhough it
    probably keeps both copies of the ctor, but seems LTO can't cope
    with that and Honza doesn't know what it should do in that case
    (linker decides that the prevailing symbol is
    _ZN6vectorI12QualityValueEC2ERKS1_ (from the
    _ZN6vectorI12QualityValueEC2ERKS1_ comdat group) and
    _ZN6vectorI12QualityValueEC1ERKS1_ alias (from the other TU,
    from _ZN6vectorI12QualityValueEC5ERKS1_ comdat group)).

    Note, the case where some constructor is marked constexpr in one
    TU and not in another one happens pretty often in libstdc++ when
    one mixes -std= flags used to compile different compilation units.

    The reason the optimization doesn't trigger when the constructor is
    constexpr is that expand_or_defer_fn is called in that case much earlier
    than when it is not constexpr; in the former case it is called when we
    try to constant evaluate that constructor.  But DECL_INTERFACE_KNOWN
    is false in that case and comdat_linkage hasn't been called either
    (I think it is desirable, because comdat group is stored in the cgraph
    node and am not sure it is a good idea to create cgraph nodes for
    something that might not be needed later on at all), so maybe_clone_body
    clones the bodies, but doesn't make them as aliases.

    The following patch is an attempt to redo this optimization when
    import_export_decl is called at_eof time on the base/complete cdtor
    (or deleting dtor).  It will not do anything if maybe_clone_body
    hasn't been called uyet (the TREE_ASM_WRITTEN check on the
    DECL_MAYBE_IN_CHARGE_CDTOR_P), or when one or both of the base/complete
    cdtors have been lowered already, or when maybe_clone_body called
    maybe_thunk_body and it was successful.  Otherwise retries the
    can_alias_cdtor check and makes the complete cdtor alias to the
    base cdtor with adjustments to the comdat group.

    2024-04-25  Jakub Jelinek  <jakub@redhat.com>

            PR lto/113208
            * cp-tree.h (maybe_optimize_cdtor): Declare.
            * decl2.cc (import_export_decl): Call it for cloned cdtors.
            * optimize.cc (maybe_optimize_cdtor): New function.

            * g++.dg/abi/comdat2.C: New test.
            * g++.dg/abi/comdat5.C: New test.
            * g++.dg/lto/pr113208_0.C: New test.
            * g++.dg/lto/pr113208_1.C: New file.
            * g++.dg/lto/pr113208.h: New file.