[v7] Introduce attribute sym_alias

  On Nov 30, 2023, Jan Hubicka <hubicka@ucw.cz> wrote:

>> +      if (VAR_P (replaced))
>> +	varpool_node::create_alias (sym_node->decl, replacement);
>> +      else
>> +	cgraph_node::create_alias (sym_node->decl, replacement);

Unfortunately, this change didn't work.  Several of the C++ tests
regressed with it.  Going back to same-body aliases, they work.

I suspect this may have to do with the infrastructure put in to deal
with cdtors clones.

I've also found some discrepancies between C and C++ WRT sym_alias in
static local variables, and failure to detect and report symbol name
clashes between sym_aliases and unrelated declarations.  Thanks, Joseph,
for pushing me to consider other cases I hadn't thought of before :-)
I'm going to look into these, but for now, the patch below gets a full
pass, with these issues XFAILed.


> The IPA bits are fine.  I will take a look on your second patch.

Thanks!


Introduce attribute sym_alias

This patch introduces an attribute to add extra asm names (aliases)
for a decl when its definition is output.  The main goal is to ease
interfacing C++ with Ada, as C++ mangled names have to be named, and
in some cases (e.g. when using stdint.h typedefs in function
arguments) the symbol names may vary across platforms.

The attribute is usable in C and C++, presumably in all C-family
languages.  It can be attached to global variables and functions.  In
C++, it can also be attached to class types, namespace-scoped
variables and functions, static data members, member functions,
explicit instantiations and specializations of template functions,
members and classes.

When applied to constructors or destructor, additional sym aliases
with _Base and _Del suffixes are defined for variants other than
complete-object ones.  This changes the assumption that clones always
carry the same attributes as their abstract declarations, so there is
now a function to adjust them.

C++ also had a bug in which attributes from local extern declarations
failed to be propagated to a preexisting corresponding
namespace-scoped decl.  I've fixed that, and adjusted acc tests that
distinguished between C and C++ in this regard.

Applying the attribute to class types is only valid in C++, and the
effect is to attach the alias to the RTTI object associated with the
class type.

for  gcc/ChangeLog

	* attribs.cc: Include cgraph.h.
	(decl_attributes): Allow late introduction of sym_alias in
	types.
	(create_sym_alias_decl, create_sym_alias_decls): New.
	* attribs.h: Declare them.
	(FOR_EACH_SYM_ALIAS): New macro.
	* cgraph.cc (cgraph_node::create): Create sym_alias decls.
	* varpool.cc (varpool_node::get_create): Create sym_alias
	decls.
	* cgraph.h (symtab_node::remap_sym_alias_target): New.
	* symtab.cc (symtab_node::remap_sym_alias_target): Define.
	* cgraphunit.cc (cgraph_node::analyze): Create alias_target
	node if needed.
	(analyze_functions): Fixup visibility of implicit alias only
	after its node is analyzed.
	* doc/extend.texi (sym_alias): Document for variables,
	functions and types.

for  gcc/ada/ChangeLog

	* doc/gnat_rm/interfacing_to_other_languages.rst: Mention
	attribute sym_alias to give RTTI symbols mnemonic names.
	* doc/gnat_ugn/the_gnat_compilation_model.rst: Mention
	aliases.  Fix incorrect ref to C1 ctor variant.

for  gcc/c-family/ChangeLog

	* c-ada-spec.cc (pp_asm_name): Use first sym_alias if
	available.
	* c-attribs.cc (handle_sym_alias_attribute): New.
	(c_common_attribute_table): Add sym_alias.
	(handle_copy_attribute): Do not copy sym_alias attribute.

for  gcc/c/ChangeLog

	* c-decl.cc (duplicate_decls): Remap sym_alias target.

for  gcc/cp/ChangeLog

	* class.cc (adjust_clone_attributes): New.
	(copy_fndecl_with_name, build_clone): Call it.
	* cp-tree.h (adjust_clone_attributes): Declare.
	(update_sym_alias_interface): Declare.
	(update_tinfo_sym_alias): Declare.
	* decl.cc (duplicate_decls): Remap sym_alias target.
	Adjust clone attributes.
	(grokfndecl): Tentatively create sym_alias decls after
	adding attributes in e.g. a template member function explicit
	instantiation.
	* decl2.cc (cplus_decl_attributes): Update tinfo sym_alias.
	(copy_interface, update_sym_alias_interface): New.
	(determine_visibility): Update sym_alias interface.
	(tentative_decl_linkage, import_export_decl): Likewise.
	* name-lookup.cc: Include target.h and cgraph.h.
	(push_local_extern_decl_alias): Merge attributes with
	namespace-scoped decl, and drop duplicate sym_alias.
	* optimize.cc (maybe_clone_body): Re-adjust attributes after
	cloning them.  Update sym_alias interface.
	* rtti.cc: Include attribs.h and cgraph.h.
	(get_tinfo_decl): Copy sym_alias attributes from type to tinfo
	decl.  Create sym_alias decls.
	(update_tinfo_sym_alias): New.

for  gcc/testsuite/ChangeLog

	* c-c++-common/goacc/declare-1.c: Adjust.
	* c-c++-common/goacc/declare-2.c: Adjust.
	* c-c++-common/torture/attr-sym-alias-1.c: New.
	* c-c++-common/torture/attr-sym-alias-2.c: New.
	* c-c++-common/torture/attr-sym-alias-3.c: New.
	* c-c++-common/torture/attr-sym-alias-4.c: New.
	* c-c++-common/torture/attr-sym-alias-5.c: New.
	* c-c++-common/attr-sym-alias-neg.c: New.
	* g++.dg/torture/attr-sym-alias-1.C: New.
	* g++.dg/torture/attr-sym-alias-2.C: New.
	* g++.dg/torture/attr-sym-alias-3.C: New.
	* g++.dg/torture/attr-sym-alias-4.C: New.
	* g++.dg/torture/attr-sym-alias-5.C: New.
---
 .../doc/gnat_rm/interfacing_to_other_languages.rst |    6 +
 .../doc/gnat_ugn/the_gnat_compilation_model.rst    |   10 ++
 gcc/attribs.cc                                     |   66 ++++++++++++++++
 gcc/attribs.h                                      |    7 ++
 gcc/c-family/c-ada-spec.cc                         |    7 ++
 gcc/c-family/c-attribs.cc                          |   33 +++++++-
 gcc/c/c-decl.cc                                    |    2 
 gcc/cgraph.cc                                      |    2 
 gcc/cgraph.h                                       |    4 +
 gcc/cgraphunit.cc                                  |    2 
 gcc/cp/class.cc                                    |   64 +++++++++++++++
 gcc/cp/cp-tree.h                                   |    4 +
 gcc/cp/decl.cc                                     |    4 +
 gcc/cp/decl2.cc                                    |   50 ++++++++++++
 gcc/cp/name-lookup.cc                              |   11 +++
 gcc/cp/optimize.cc                                 |    3 +
 gcc/cp/rtti.cc                                     |   71 +++++++++++++++++
 gcc/doc/extend.texi                                |   56 +++++++++++++
 gcc/symtab.cc                                      |   38 +++++++++
 gcc/testsuite/c-c++-common/attr-sym-alias-neg.c    |   80 +++++++++++++++++++
 gcc/testsuite/c-c++-common/goacc/declare-1.c       |    6 +
 gcc/testsuite/c-c++-common/goacc/declare-2.c       |   14 ++-
 .../c-c++-common/torture/attr-sym-alias-1.c        |   39 +++++++++
 .../c-c++-common/torture/attr-sym-alias-2.c        |   13 +++
 .../c-c++-common/torture/attr-sym-alias-3.c        |   41 ++++++++++
 .../c-c++-common/torture/attr-sym-alias-4.c        |   28 +++++++
 .../c-c++-common/torture/attr-sym-alias-5.c        |   54 +++++++++++++
 gcc/testsuite/g++.dg/torture/attr-sym-alias-1.C    |   72 +++++++++++++++++
 gcc/testsuite/g++.dg/torture/attr-sym-alias-2.C    |   26 ++++++
 gcc/testsuite/g++.dg/torture/attr-sym-alias-3.C    |   83 ++++++++++++++++++++
 gcc/testsuite/g++.dg/torture/attr-sym-alias-4.C    |   28 +++++++
 gcc/testsuite/g++.dg/torture/attr-sym-alias-5.C    |   14 +++
 gcc/varpool.cc                                     |    3 +
 33 files changed, 922 insertions(+), 19 deletions(-)
 create mode 100644 gcc/testsuite/c-c++-common/attr-sym-alias-neg.c
 create mode 100644 gcc/testsuite/c-c++-common/torture/attr-sym-alias-1.c
 create mode 100644 gcc/testsuite/c-c++-common/torture/attr-sym-alias-2.c
 create mode 100644 gcc/testsuite/c-c++-common/torture/attr-sym-alias-3.c
 create mode 100644 gcc/testsuite/c-c++-common/torture/attr-sym-alias-4.c
 create mode 100644 gcc/testsuite/c-c++-common/torture/attr-sym-alias-5.c
 create mode 100644 gcc/testsuite/g++.dg/torture/attr-sym-alias-1.C
 create mode 100644 gcc/testsuite/g++.dg/torture/attr-sym-alias-2.C
 create mode 100644 gcc/testsuite/g++.dg/torture/attr-sym-alias-3.C
 create mode 100644 gcc/testsuite/g++.dg/torture/attr-sym-alias-4.C
 create mode 100644 gcc/testsuite/g++.dg/torture/attr-sym-alias-5.C
  

> On Nov 30, 2023, Jan Hubicka <hubicka@ucw.cz> wrote:
> 
> >> +      if (VAR_P (replaced))
> >> +	varpool_node::create_alias (sym_node->decl, replacement);
> >> +      else
> >> +	cgraph_node::create_alias (sym_node->decl, replacement);
> 
> Unfortunately, this change didn't work.  Several of the C++ tests
> regressed with it.  Going back to same-body aliases, they work.
> 
> I suspect this may have to do with the infrastructure put in to deal
> with cdtors clones.

Do you have short testcase for this?  THe main oddities with same body
aliases comes from the fact that C++ FE creates them early during
parsing before all declaration flags are finished.

Later we do:

  /* Ugly, but the fixup cannot happen at a time same body alias is created;
     C++ FE is confused about the COMDAT groups being right.  */
  if (symtab->cpp_implicit_aliases_done)
    FOR_EACH_SYMBOL (node)
      if (node->cpp_implicit_alias)
          node->fixup_same_cpp_alias_visibility (node->get_alias_target ());

Fixup copies some flags such as inline flags, visibility and comdat
groups which can change during parsing process.

Since you produce aliases late at finalization time, I do not see how
this could be relevant.  Pehraps unless you manage to copy wrong flags
from implicit aliases before the fixup happens which would be simple
ordering problem....

Honza
> 
> I've also found some discrepancies between C and C++ WRT sym_alias in
> static local variables, and failure to detect and report symbol name
> clashes between sym_aliases and unrelated declarations.  Thanks, Joseph,
> for pushing me to consider other cases I hadn't thought of before :-)
> I'm going to look into these, but for now, the patch below gets a full
> pass, with these issues XFAILed.
> 
> 
> > The IPA bits are fine.  I will take a look on your second patch.
> 
> Thanks!
> 
> 
> Introduce attribute sym_alias
> 
> This patch introduces an attribute to add extra asm names (aliases)
> for a decl when its definition is output.  The main goal is to ease
> interfacing C++ with Ada, as C++ mangled names have to be named, and
> in some cases (e.g. when using stdint.h typedefs in function
> arguments) the symbol names may vary across platforms.
> 
> The attribute is usable in C and C++, presumably in all C-family
> languages.  It can be attached to global variables and functions.  In
> C++, it can also be attached to class types, namespace-scoped
> variables and functions, static data members, member functions,
> explicit instantiations and specializations of template functions,
> members and classes.
> 
> When applied to constructors or destructor, additional sym aliases
> with _Base and _Del suffixes are defined for variants other than
> complete-object ones.  This changes the assumption that clones always
> carry the same attributes as their abstract declarations, so there is
> now a function to adjust them.
> 
> C++ also had a bug in which attributes from local extern declarations
> failed to be propagated to a preexisting corresponding
> namespace-scoped decl.  I've fixed that, and adjusted acc tests that
> distinguished between C and C++ in this regard.
> 
> Applying the attribute to class types is only valid in C++, and the
> effect is to attach the alias to the RTTI object associated with the
> class type.
> 
> for  gcc/ChangeLog
> 
> 	* attribs.cc: Include cgraph.h.
> 	(decl_attributes): Allow late introduction of sym_alias in
> 	types.
> 	(create_sym_alias_decl, create_sym_alias_decls): New.
> 	* attribs.h: Declare them.
> 	(FOR_EACH_SYM_ALIAS): New macro.
> 	* cgraph.cc (cgraph_node::create): Create sym_alias decls.
> 	* varpool.cc (varpool_node::get_create): Create sym_alias
> 	decls.
> 	* cgraph.h (symtab_node::remap_sym_alias_target): New.
> 	* symtab.cc (symtab_node::remap_sym_alias_target): Define.
> 	* cgraphunit.cc (cgraph_node::analyze): Create alias_target
> 	node if needed.
> 	(analyze_functions): Fixup visibility of implicit alias only
> 	after its node is analyzed.
> 	* doc/extend.texi (sym_alias): Document for variables,
> 	functions and types.
> 
> for  gcc/ada/ChangeLog
> 
> 	* doc/gnat_rm/interfacing_to_other_languages.rst: Mention
> 	attribute sym_alias to give RTTI symbols mnemonic names.
> 	* doc/gnat_ugn/the_gnat_compilation_model.rst: Mention
> 	aliases.  Fix incorrect ref to C1 ctor variant.
> 
> for  gcc/c-family/ChangeLog
> 
> 	* c-ada-spec.cc (pp_asm_name): Use first sym_alias if
> 	available.
> 	* c-attribs.cc (handle_sym_alias_attribute): New.
> 	(c_common_attribute_table): Add sym_alias.
> 	(handle_copy_attribute): Do not copy sym_alias attribute.
> 
> for  gcc/c/ChangeLog
> 
> 	* c-decl.cc (duplicate_decls): Remap sym_alias target.
> 
> for  gcc/cp/ChangeLog
> 
> 	* class.cc (adjust_clone_attributes): New.
> 	(copy_fndecl_with_name, build_clone): Call it.
> 	* cp-tree.h (adjust_clone_attributes): Declare.
> 	(update_sym_alias_interface): Declare.
> 	(update_tinfo_sym_alias): Declare.
> 	* decl.cc (duplicate_decls): Remap sym_alias target.
> 	Adjust clone attributes.
> 	(grokfndecl): Tentatively create sym_alias decls after
> 	adding attributes in e.g. a template member function explicit
> 	instantiation.
> 	* decl2.cc (cplus_decl_attributes): Update tinfo sym_alias.
> 	(copy_interface, update_sym_alias_interface): New.
> 	(determine_visibility): Update sym_alias interface.
> 	(tentative_decl_linkage, import_export_decl): Likewise.
> 	* name-lookup.cc: Include target.h and cgraph.h.
> 	(push_local_extern_decl_alias): Merge attributes with
> 	namespace-scoped decl, and drop duplicate sym_alias.
> 	* optimize.cc (maybe_clone_body): Re-adjust attributes after
> 	cloning them.  Update sym_alias interface.
> 	* rtti.cc: Include attribs.h and cgraph.h.
> 	(get_tinfo_decl): Copy sym_alias attributes from type to tinfo
> 	decl.  Create sym_alias decls.
> 	(update_tinfo_sym_alias): New.
> 
> for  gcc/testsuite/ChangeLog
> 
> 	* c-c++-common/goacc/declare-1.c: Adjust.
> 	* c-c++-common/goacc/declare-2.c: Adjust.
> 	* c-c++-common/torture/attr-sym-alias-1.c: New.
> 	* c-c++-common/torture/attr-sym-alias-2.c: New.
> 	* c-c++-common/torture/attr-sym-alias-3.c: New.
> 	* c-c++-common/torture/attr-sym-alias-4.c: New.
> 	* c-c++-common/torture/attr-sym-alias-5.c: New.
> 	* c-c++-common/attr-sym-alias-neg.c: New.
> 	* g++.dg/torture/attr-sym-alias-1.C: New.
> 	* g++.dg/torture/attr-sym-alias-2.C: New.
> 	* g++.dg/torture/attr-sym-alias-3.C: New.
> 	* g++.dg/torture/attr-sym-alias-4.C: New.
> 	* g++.dg/torture/attr-sym-alias-5.C: New.
> ---
>  .../doc/gnat_rm/interfacing_to_other_languages.rst |    6 +
>  .../doc/gnat_ugn/the_gnat_compilation_model.rst    |   10 ++
>  gcc/attribs.cc                                     |   66 ++++++++++++++++
>  gcc/attribs.h                                      |    7 ++
>  gcc/c-family/c-ada-spec.cc                         |    7 ++
>  gcc/c-family/c-attribs.cc                          |   33 +++++++-
>  gcc/c/c-decl.cc                                    |    2 
>  gcc/cgraph.cc                                      |    2 
>  gcc/cgraph.h                                       |    4 +
>  gcc/cgraphunit.cc                                  |    2 
>  gcc/cp/class.cc                                    |   64 +++++++++++++++
>  gcc/cp/cp-tree.h                                   |    4 +
>  gcc/cp/decl.cc                                     |    4 +
>  gcc/cp/decl2.cc                                    |   50 ++++++++++++
>  gcc/cp/name-lookup.cc                              |   11 +++
>  gcc/cp/optimize.cc                                 |    3 +
>  gcc/cp/rtti.cc                                     |   71 +++++++++++++++++
>  gcc/doc/extend.texi                                |   56 +++++++++++++
>  gcc/symtab.cc                                      |   38 +++++++++
>  gcc/testsuite/c-c++-common/attr-sym-alias-neg.c    |   80 +++++++++++++++++++
>  gcc/testsuite/c-c++-common/goacc/declare-1.c       |    6 +
>  gcc/testsuite/c-c++-common/goacc/declare-2.c       |   14 ++-
>  .../c-c++-common/torture/attr-sym-alias-1.c        |   39 +++++++++
>  .../c-c++-common/torture/attr-sym-alias-2.c        |   13 +++
>  .../c-c++-common/torture/attr-sym-alias-3.c        |   41 ++++++++++
>  .../c-c++-common/torture/attr-sym-alias-4.c        |   28 +++++++
>  .../c-c++-common/torture/attr-sym-alias-5.c        |   54 +++++++++++++
>  gcc/testsuite/g++.dg/torture/attr-sym-alias-1.C    |   72 +++++++++++++++++
>  gcc/testsuite/g++.dg/torture/attr-sym-alias-2.C    |   26 ++++++
>  gcc/testsuite/g++.dg/torture/attr-sym-alias-3.C    |   83 ++++++++++++++++++++
>  gcc/testsuite/g++.dg/torture/attr-sym-alias-4.C    |   28 +++++++
>  gcc/testsuite/g++.dg/torture/attr-sym-alias-5.C    |   14 +++
>  gcc/varpool.cc                                     |    3 +
>  33 files changed, 922 insertions(+), 19 deletions(-)
>  create mode 100644 gcc/testsuite/c-c++-common/attr-sym-alias-neg.c
>  create mode 100644 gcc/testsuite/c-c++-common/torture/attr-sym-alias-1.c
>  create mode 100644 gcc/testsuite/c-c++-common/torture/attr-sym-alias-2.c
>  create mode 100644 gcc/testsuite/c-c++-common/torture/attr-sym-alias-3.c
>  create mode 100644 gcc/testsuite/c-c++-common/torture/attr-sym-alias-4.c
>  create mode 100644 gcc/testsuite/c-c++-common/torture/attr-sym-alias-5.c
>  create mode 100644 gcc/testsuite/g++.dg/torture/attr-sym-alias-1.C
>  create mode 100644 gcc/testsuite/g++.dg/torture/attr-sym-alias-2.C
>  create mode 100644 gcc/testsuite/g++.dg/torture/attr-sym-alias-3.C
>  create mode 100644 gcc/testsuite/g++.dg/torture/attr-sym-alias-4.C
>  create mode 100644 gcc/testsuite/g++.dg/torture/attr-sym-alias-5.C
> 
> diff --git a/gcc/ada/doc/gnat_rm/interfacing_to_other_languages.rst b/gcc/ada/doc/gnat_rm/interfacing_to_other_languages.rst
> index ad0be511d4800..b8de16ebf7c0c 100644
> --- a/gcc/ada/doc/gnat_rm/interfacing_to_other_languages.rst
> +++ b/gcc/ada/doc/gnat_rm/interfacing_to_other_languages.rst
> @@ -123,6 +123,12 @@ It is also possible to import a C++ exception using the following syntax:
>  The ``External_Name`` is the name of the C++ RTTI symbol. You can then
>  cover a specific C++ exception in an exception handler.
>  
> +RTTI symbols undergo C++ name mangling, which can make for identifiers
> +that are inconvenient to use. An alias with a mnemonic name can be
> +introduced by adding attribute ``sym_alias`` to the class that the
> +RTTI symbol refers to.
> +
> +
>  .. _Interfacing_to_COBOL:
>  
>  Interfacing to COBOL
> diff --git a/gcc/ada/doc/gnat_ugn/the_gnat_compilation_model.rst b/gcc/ada/doc/gnat_ugn/the_gnat_compilation_model.rst
> index fd15459203a5c..2004569896268 100644
> --- a/gcc/ada/doc/gnat_ugn/the_gnat_compilation_model.rst
> +++ b/gcc/ada/doc/gnat_ugn/the_gnat_compilation_model.rst
> @@ -4274,6 +4274,7 @@ and two public primitives to set and get the value of this attribute.
>        public:
>          virtual void Set_Age (int New_Age);
>          virtual int Age ();
> +        __attribute__ ((__sym_alias__ ("Ctor_For_Animal")))
>          Animal() {Age_Count = 0;};
>        private:
>          int Age_Count;
> @@ -4306,6 +4307,7 @@ both Carnivore and Domestic, that is:
>          virtual int  Number_Of_Teeth ();
>          virtual void Set_Owner (char* Name);
>  
> +        __attribute__ ((__sym_alias__ ("Ctor_For_Dog"))) // mnemonic alias
>          Dog(); // Constructor
>        private:
>          int  Tooth_Count;
> @@ -4344,7 +4346,8 @@ how to import these C++ declarations from the Ada side:
>  
>         function New_Animal return Animal;
>         pragma CPP_Constructor (New_Animal);
> -       pragma Import (CPP, New_Animal, "_ZN6AnimalC1Ev");
> +       pragma Import (CPP, New_Animal,
> +                      "_ZN6AnimalC1Ev"); -- or "Ctor_For_Animal"
>  
>         type Dog is new Animal and Carnivore and Domestic with record
>           Tooth_Count : Natural;
> @@ -4360,7 +4363,7 @@ how to import these C++ declarations from the Ada side:
>  
>         function New_Dog return Dog;
>         pragma CPP_Constructor (New_Dog);
> -       pragma Import (CPP, New_Dog, "_ZN3DogC2Ev");
> +       pragma Import (CPP, New_Dog, "Ctor_For_Dog"); -- or "_ZN3DogC1Ev"
>       end Animals;
>  
>  Thanks to the compatibility between GNAT run-time structures and the C++ ABI,
> @@ -4382,7 +4385,8 @@ associated with each subprogram because it is assumed that all the calls to
>  these primitives will be dispatching calls. The only exception is the
>  constructor, which must be registered with the compiler by means of
>  ``pragma CPP_Constructor`` and needs to provide its associated C++
> -mangled name because the Ada compiler generates direct calls to it.
> +mangled name (or an alias) because the Ada compiler generates direct
> +calls to it.
>  
>  With the above packages we can now declare objects of type Dog on the Ada side
>  and dispatch calls to the corresponding subprograms on the C++ side. We can
> diff --git a/gcc/attribs.cc b/gcc/attribs.cc
> index c7209c26acc9f..c75ca6974cb71 100644
> --- a/gcc/attribs.cc
> +++ b/gcc/attribs.cc
> @@ -23,6 +23,7 @@ along with GCC; see the file COPYING3.  If not see
>  #include "coretypes.h"
>  #include "target.h"
>  #include "tree.h"
> +#include "cgraph.h"
>  #include "stringpool.h"
>  #include "diagnostic-core.h"
>  #include "attribs.h"
> @@ -825,7 +826,8 @@ decl_attributes (tree *node, tree attributes, int flags,
>  
>        if (TYPE_P (*anode)
>  	  && (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
> -	  && COMPLETE_TYPE_P (*anode))
> +	  && COMPLETE_TYPE_P (*anode)
> +	  && !is_attribute_p ("sym_alias", name))
>  	{
>  	  warning (OPT_Wattributes, "type attributes ignored after type is already defined");
>  	  continue;
> @@ -2640,6 +2642,68 @@ attr_access::array_as_string (tree type) const
>    return typstr;
>  }
>  
> +/* Create a sym attribute for DECL to be visible with linkage name ID.  */
> +
> +tree
> +create_sym_alias_decl (tree decl, tree id)
> +{
> +  const char *attr_str = "sym_alias";
> +
> +  if (symtab_node *sym_node = symtab_node::get_for_asmname (id))
> +    {
> +      if ((sym_node->analyzed
> +	   ? sym_node->get_alias_target ()->decl
> +	   : sym_node->alias_target) == decl)
> +	return sym_node->decl;
> +
> +      tree attr_name = get_identifier (attr_str);
> +      error_at (DECL_SOURCE_LOCATION (decl),
> +		"duplicate symbol name %qE in %qE attribute of %qD",
> +		id, attr_name, decl);
> +      inform (DECL_SOURCE_LOCATION (sym_node->decl),
> +	      "already used by %qD", sym_node->decl);
> +    }
> +
> +  tree clone = copy_node (decl);
> +  DECL_ATTRIBUTES (clone) = remove_attribute (attr_str,
> +					      DECL_ATTRIBUTES (decl));
> +  SET_DECL_ASSEMBLER_NAME (clone, id);
> +  TREE_USED (id) = 1;
> +  TREE_USED (clone) = 1;
> +  DECL_PRESERVE_P (clone) = 1;
> +  DECL_EXTERNAL (clone) = 0;
> +  TREE_STATIC (clone) = 1;
> +
> +  if (VAR_P (clone))
> +    // DECL_READ_P (clone) = 1;
> +    // varpool_node::create_extra_name_alias (clone, decl);
> +    varpool_node::create_alias (clone, decl);
> +  else
> +    cgraph_node::create_same_body_alias (clone, decl);
> +    // cgraph_node::create_alias (clone, decl);
> +
> +  return clone;
> +}
> +
> +/* Create decls for all sym aliases requested in DECL's attributes.  */
> +
> +void
> +create_sym_alias_decls (tree decl)
> +{
> +  if (!decl_in_symtab_p (decl)
> +      || !symtab_node::get (decl)
> +      || DECL_ABSTRACT_P (decl))
> +    return;
> +
> +  FOR_EACH_SYM_ALIAS (sym, DECL_ATTRIBUTES (decl))
> +    {
> +      tree id = TREE_VALUE (TREE_VALUE (sym));
> +      id = get_identifier (TREE_STRING_POINTER (id));
> +
> +      create_sym_alias_decl (decl, id);
> +    }
> +}
> +
>  #if CHECKING_P
>  
>  namespace selftest
> diff --git a/gcc/attribs.h b/gcc/attribs.h
> index 84a43658a70da..156f2c2058800 100644
> --- a/gcc/attribs.h
> +++ b/gcc/attribs.h
> @@ -398,4 +398,11 @@ extern void init_attr_rdwr_indices (rdwr_map *, tree);
>  extern attr_access *get_parm_access (rdwr_map &, tree,
>  				     tree = current_function_decl);
>  
> +extern tree create_sym_alias_decl (tree, tree);
> +extern void create_sym_alias_decls (tree);
> +
> +#define FOR_EACH_SYM_ALIAS(sym, attrs)					\
> +  for (tree sym = lookup_attribute ("sym_alias", (attrs));		\
> +       sym; sym = lookup_attribute ("sym_alias", TREE_CHAIN (sym)))
> +
>  #endif // GCC_ATTRIBS_H
> diff --git a/gcc/c-family/c-ada-spec.cc b/gcc/c-family/c-ada-spec.cc
> index 050994d841665..5042b9cfecd80 100644
> --- a/gcc/c-family/c-ada-spec.cc
> +++ b/gcc/c-family/c-ada-spec.cc
> @@ -1431,6 +1431,13 @@ pp_ada_tree_identifier (pretty_printer *buffer, tree node, tree type,
>  static void
>  pp_asm_name (pretty_printer *buffer, tree t)
>  {
> +  FOR_EACH_SYM_ALIAS (sym, DECL_ATTRIBUTES (t))
> +    {
> +      tree id = TREE_VALUE (TREE_VALUE (sym));
> +      pp_string (buffer, TREE_STRING_POINTER (id));
> +      return;
> +    }
> +
>    tree name = DECL_ASSEMBLER_NAME (t);
>    char *ada_name = XALLOCAVEC (char, IDENTIFIER_LENGTH (name) + 1), *s;
>    const char *ident = IDENTIFIER_POINTER (name);
> diff --git a/gcc/c-family/c-attribs.cc b/gcc/c-family/c-attribs.cc
> index 2b20e58c922c8..392437eab3b7d 100644
> --- a/gcc/c-family/c-attribs.cc
> +++ b/gcc/c-family/c-attribs.cc
> @@ -108,7 +108,8 @@ static tree handle_noplt_attribute (tree *, tree, tree, int, bool *) ;
>  static tree handle_alias_ifunc_attribute (bool, tree *, tree, tree, bool *);
>  static tree handle_ifunc_attribute (tree *, tree, tree, int, bool *);
>  static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
> -static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
> +static tree handle_weakref_attribute (tree *, tree, tree, int, bool *);
> +static tree handle_sym_alias_attribute (tree *, tree, tree, int, bool *);
>  static tree handle_visibility_attribute (tree *, tree, tree, int,
>  					 bool *);
>  static tree handle_tls_model_attribute (tree *, tree, tree, int,
> @@ -388,6 +389,8 @@ const struct attribute_spec c_common_attribute_table[] =
>  			      handle_alias_attribute, NULL },
>    { "weakref",                0, 1, true,  false, false, false,
>  			      handle_weakref_attribute, NULL },
> +  { "sym_alias",              1, 1, false,  false, false, false,
> +			      handle_sym_alias_attribute, NULL },
>    { "no_instrument_function", 0, 0, true,  false, false, false,
>  			      handle_no_instrument_function_attribute,
>  			      NULL },
> @@ -3002,7 +3005,7 @@ handle_alias_ifunc_attribute (bool is_alias, tree *node, tree name, tree args,
>    return NULL_TREE;
>  }
>  
> -/* Handle an "alias" or "ifunc" attribute; arguments as in
> +/* Handle an "ifunc" attribute; arguments as in
>     struct attribute_spec.handler.  */
>  
>  static tree
> @@ -3012,7 +3015,7 @@ handle_ifunc_attribute (tree *node, tree name, tree args,
>    return handle_alias_ifunc_attribute (false, node, name, args, no_add_attrs);
>  }
>  
> -/* Handle an "alias" or "ifunc" attribute; arguments as in
> +/* Handle an "alias" attribute; arguments as in
>     struct attribute_spec.handler.  */
>  
>  static tree
> @@ -3022,6 +3025,29 @@ handle_alias_attribute (tree *node, tree name, tree args,
>    return handle_alias_ifunc_attribute (true, node, name, args, no_add_attrs);
>  }
>  
> +/* Handle a "sym_alias" attribute; arguments as in struct
> +   attribute_spec.handler.  */
> +
> +static tree
> +handle_sym_alias_attribute (tree *pnode, tree name, tree args,
> +			    int ARG_UNUSED (flags), bool *no_add_attrs)
> +{
> +  tree node = *pnode;
> +
> +  *no_add_attrs = true;
> +
> +  if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
> +    error ("%qE attribute argument not a string", name);
> +  else if (decl_in_symtab_p (node))
> +    *no_add_attrs = false;
> +  else if (TYPE_P (node) && c_dialect_cxx ())
> +    *no_add_attrs = false;
> +  else
> +    return error_mark_node;
> +
> +  return NULL_TREE;
> +}
> +
>  /* Handle the "copy" attribute NAME by copying the set of attributes
>     from the symbol referenced by ARGS to the declaration of *NODE.  */
>  
> @@ -3155,6 +3181,7 @@ handle_copy_attribute (tree *node, tree name, tree args,
>  	      || is_attribute_p ("visibility", atname)
>  	      || is_attribute_p ("weak", atname)
>  	      || is_attribute_p ("weakref", atname)
> +	      || is_attribute_p ("sym_alias", atname)
>  	      || is_attribute_p ("target_clones", atname))
>  	    continue;
>  
> diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
> index cf1df82c0f405..e5a1ee54cb3ee 100644
> --- a/gcc/c/c-decl.cc
> +++ b/gcc/c/c-decl.cc
> @@ -3119,6 +3119,8 @@ duplicate_decls (tree newdecl, tree olddecl)
>  
>    merge_decls (newdecl, olddecl, newtype, oldtype);
>  
> +  symtab_node::remap_sym_alias_target (newdecl, olddecl);
> +
>    /* The NEWDECL will no longer be needed.
>  
>       Before releasing the node, be sure to remove function from symbol
> diff --git a/gcc/cgraph.cc b/gcc/cgraph.cc
> index f93259a8c70c4..0bef2179e89c4 100644
> --- a/gcc/cgraph.cc
> +++ b/gcc/cgraph.cc
> @@ -523,6 +523,8 @@ cgraph_node::create (tree decl)
>    node->register_symbol ();
>    maybe_record_nested_function (node);
>  
> +  create_sym_alias_decls (decl);
> +
>    return node;
>  }
>  
> diff --git a/gcc/cgraph.h b/gcc/cgraph.h
> index cfdd9f693a889..cb5ac01f7e290 100644
> --- a/gcc/cgraph.h
> +++ b/gcc/cgraph.h
> @@ -327,6 +327,10 @@ public:
>    /* Return DECL that alias is aliasing.  */
>    inline tree get_alias_target_tree ();
>  
> +  /* Remap sym alias nodes recorded as aliasing REPLACED to alias REPLACEMENT
> +     instead.  */
> +  static void remap_sym_alias_target (tree replaced, tree replacement);
> +
>    /* Set section for symbol and its aliases.  */
>    void set_section (const char *section);
>  
> diff --git a/gcc/cgraphunit.cc b/gcc/cgraphunit.cc
> index bccd2f2abb5a3..eb2d05094e989 100644
> --- a/gcc/cgraphunit.cc
> +++ b/gcc/cgraphunit.cc
> @@ -1175,7 +1175,7 @@ analyze_functions (bool first_time)
>       C++ FE is confused about the COMDAT groups being right.  */
>    if (symtab->cpp_implicit_aliases_done)
>      FOR_EACH_SYMBOL (node)
> -      if (node->cpp_implicit_alias)
> +      if (node->cpp_implicit_alias && node->analyzed)
>  	  node->fixup_same_cpp_alias_visibility (node->get_alias_target ());
>    build_type_inheritance_graph ();
>  
> diff --git a/gcc/cp/class.cc b/gcc/cp/class.cc
> index 6fdb56abfb9f8..fa8fc63db82a5 100644
> --- a/gcc/cp/class.cc
> +++ b/gcc/cp/class.cc
> @@ -4896,6 +4896,68 @@ check_methods (tree t)
>      }
>  }
>  
> +/* Adjust sym alias name for CLONE, cloned from FN and named NAME,
> +   if it is a cdtor, and drop the sym alias from other clones.  */
> +
> +void
> +adjust_clone_attributes (tree fn, tree clone, tree name, bool skip_copy_p)
> +{
> +  if (IDENTIFIER_CDTOR_P (name))
> +    {
> +      bool found = false;
> +      FOR_EACH_SYM_ALIAS (sym, DECL_ATTRIBUTES (clone))
> +	{
> +	  found = true;
> +	  break;
> +	}
> +
> +      if (found
> +	  && (name == complete_ctor_identifier
> +	      || name == complete_dtor_identifier))
> +	{
> +	  /* Reuse the sym alias decls created for the primary cdtor
> +	     decl.  */
> +	  symtab_node::remap_sym_alias_target (fn, clone);
> +	}
> +      else if (found)
> +	{
> +	  const char *suf;
> +
> +	  if (name == base_ctor_identifier
> +	      || name == base_dtor_identifier)
> +	    suf = "_Base";
> +	  else if (name == deleting_dtor_identifier)
> +	    suf = "_Del";
> +	  else
> +	    gcc_unreachable ();
> +
> +	  size_t xlen = strlen (suf);
> +
> +	  if (!skip_copy_p)
> +	    DECL_ATTRIBUTES (clone) = copy_list (DECL_ATTRIBUTES (clone));
> +
> +	  FOR_EACH_SYM_ALIAS (sym, DECL_ATTRIBUTES (clone))
> +	    {
> +	      /* We need to copy this even with skip_copy_p, because
> +		 even then copying was shallow.  */
> +	      TREE_VALUE (sym) = copy_list (TREE_VALUE (sym));
> +	      /* Append suf to the sym alias name.  */
> +	      tree str = TREE_VALUE (TREE_VALUE (sym));
> +	      char *symname = concat (TREE_STRING_POINTER (str), suf, NULL);
> +	      str = build_string (TREE_STRING_LENGTH (str) + xlen, symname);
> +	      TREE_VALUE (TREE_VALUE (sym)) = str;
> +	      free (symname);
> +	    }
> +
> +	  if (symtab_node::get (clone))
> +	    create_sym_alias_decls (clone);
> +	}
> +    }
> +  else
> +    DECL_ATTRIBUTES (clone)
> +      = remove_attribute ("sym_alias", DECL_ATTRIBUTES (clone));
> +}
> +
>  /* FN is constructor, destructor or operator function.  Clone the
>     declaration to create a NAME'd variant.  NEED_VTT_PARM_P and
>     OMIT_INHERITED_PARMS_P are relevant if it's a cdtor.  */
> @@ -5065,6 +5127,8 @@ build_clone (tree fn, tree name, bool need_vtt_parm_p,
>    DECL_CHAIN (clone) = DECL_CHAIN (fn);
>    DECL_CHAIN (fn) = clone;
>  
> +  adjust_clone_attributes (fn, clone, name);
> +
>    return clone;
>  }
>  
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index 964af1ddd85c5..2bafed4e9939b 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -5787,6 +5787,8 @@ struct GTY((for_user)) spec_entry
>  
>  extern int current_class_depth;
>  
> +void adjust_clone_attributes (tree fn, tree clone, tree name, bool = false);
> +
>  /* in decl.cc */
>  
>  /* An array of static vars & fns.  */
> @@ -7022,6 +7024,7 @@ extern void do_push_parm_decls			(tree, tree, tree *);
>  extern tree do_aggregate_paren_init		(tree, tree);
>  
>  /* in decl2.cc */
> +extern void update_sym_alias_interface		(tree);
>  extern void record_mangling			(tree, bool);
>  extern void overwrite_mangling			(tree, tree);
>  extern void note_mangling_alias			(tree, tree);
> @@ -7596,6 +7599,7 @@ extern bool emit_tinfo_decl			(tree);
>  extern unsigned get_pseudo_tinfo_index		(tree);
>  extern tree get_pseudo_tinfo_type		(unsigned);
>  extern tree build_if_nonnull			(tree, tree, tsubst_flags_t);
> +extern void update_tinfo_sym_alias		(tree);
>  
>  /* in search.cc */
>  extern tree get_parent_with_private_access 	(tree decl, tree binfo);
> diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
> index 2f2dbb8d10723..5636d694b6894 100644
> --- a/gcc/cp/decl.cc
> +++ b/gcc/cp/decl.cc
> @@ -3237,6 +3237,8 @@ duplicate_decls (tree newdecl, tree olddecl, bool hiding, bool was_hidden)
>  	      && TREE_STATIC (olddecl))))
>      make_decl_rtl (olddecl);
>  
> +  symtab_node::remap_sym_alias_target (newdecl, olddecl);
> +
>    /* The NEWDECL will no longer be needed.  Because every out-of-class
>       declaration of a member results in a call to duplicate_decls,
>       freeing these nodes represents in a significant savings.
> @@ -3260,6 +3262,7 @@ duplicate_decls (tree newdecl, tree olddecl, bool hiding, bool was_hidden)
>        FOR_EACH_CLONE (clone, olddecl)
>  	{
>  	  DECL_ATTRIBUTES (clone) = DECL_ATTRIBUTES (olddecl);
> +	  adjust_clone_attributes (olddecl, clone, DECL_NAME (clone));
>  	  DECL_PRESERVE_P (clone) |= DECL_PRESERVE_P (olddecl);
>  	}
>      }
> @@ -10789,6 +10792,7 @@ grokfndecl (tree ctype,
>      {
>        cplus_decl_attributes (&decl, *attrlist, 0);
>        *attrlist = NULL_TREE;
> +      create_sym_alias_decls (decl);
>      }
>  
>    if (DECL_HAS_CONTRACTS_P (decl))
> diff --git a/gcc/cp/decl2.cc b/gcc/cp/decl2.cc
> index 9e666e5eecee0..c7f009beaf08e 100644
> --- a/gcc/cp/decl2.cc
> +++ b/gcc/cp/decl2.cc
> @@ -1844,6 +1844,9 @@ cplus_decl_attributes (tree *decl, tree attributes, int flags)
>    if (late_attrs)
>      save_template_attributes (late_attrs, decl, flags);
>  
> +  if (TYPE_P (*decl) && attributes)
> +    update_tinfo_sym_alias (*decl);
> +
>    /* Propagate deprecation out to the template.  */
>    if (TREE_DEPRECATED (*decl))
>      if (tree ti = get_template_info (*decl))
> @@ -2200,6 +2203,47 @@ adjust_var_decl_tls_model (tree decl)
>      set_decl_tls_model (decl, decl_default_tls_model (decl));
>  }
>  
> +/* Copy externalness and linkage from DECL to DEST.  */
> +
> +static void
> +copy_interface (tree dest, tree decl)
> +{
> +  TREE_PUBLIC (dest) = TREE_PUBLIC (decl);
> +  TREE_STATIC (dest) = TREE_STATIC (decl);
> +  DECL_COMMON (dest) = DECL_COMMON (decl);
> +  DECL_COMDAT (dest) = DECL_COMDAT (decl);
> +  DECL_WEAK (dest) = DECL_WEAK (decl);
> +  DECL_EXTERNAL (dest) = DECL_EXTERNAL (decl);
> +  if (DECL_LANG_SPECIFIC (dest) && DECL_LANG_SPECIFIC (decl))
> +    DECL_NOT_REALLY_EXTERN (dest) = DECL_NOT_REALLY_EXTERN (decl);
> +  DECL_INTERFACE_KNOWN (dest) = DECL_INTERFACE_KNOWN (decl);
> +  DECL_VISIBILITY (dest) = DECL_VISIBILITY (decl);
> +  DECL_VISIBILITY_SPECIFIED (dest) = DECL_VISIBILITY_SPECIFIED (decl);
> +}
> +
> +/* Propagate linkage changes to sym aliases.  */
> +
> +void
> +update_sym_alias_interface (tree decl)
> +{
> +  if (!decl_in_symtab_p (decl)
> +      || !symtab_node::get (decl))
> +    return;
> +
> +  FOR_EACH_SYM_ALIAS (sym, DECL_ATTRIBUTES (decl))
> +    {
> +      tree id = TREE_VALUE (TREE_VALUE (sym));
> +      id = get_identifier (TREE_STRING_POINTER (id));
> +      symtab_node *sym_node = symtab_node::get_for_asmname (id);
> +
> +      if (sym_node
> +	  && (sym_node->analyzed
> +	      ? sym_node->get_alias_target ()->decl
> +	      : sym_node->alias_target) == decl)
> +	copy_interface (sym_node->decl, decl);
> +    }
> +}
> +
>  /* Set DECL up to have the closest approximation of "initialized common"
>     linkage available.  */
>  
> @@ -3007,6 +3051,8 @@ determine_visibility (tree decl)
>         translation unit, we can make the type internal.  */
>      constrain_visibility (decl, VISIBILITY_ANON, false);
>  
> +  update_sym_alias_interface (decl);
> +
>    /* If visibility changed and DECL already has DECL_RTL, ensure
>       symbol flags are updated.  */
>    if ((DECL_VISIBILITY (decl) != orig_visibility
> @@ -3269,6 +3315,8 @@ tentative_decl_linkage (tree decl)
>        else if (VAR_P (decl))
>  	maybe_commonize_var (decl);
>      }
> +
> +  update_sym_alias_interface (decl);
>  }
>  
>  /* DECL is a FUNCTION_DECL or VAR_DECL.  If the object file linkage
> @@ -3503,6 +3551,8 @@ import_export_decl (tree decl)
>      }
>  
>    DECL_INTERFACE_KNOWN (decl) = 1;
> +
> +  update_sym_alias_interface (decl);
>  }
>  
>  /* Return an expression that performs the destruction of DECL, which
> diff --git a/gcc/cp/name-lookup.cc b/gcc/cp/name-lookup.cc
> index d19ea5d121c8d..f877780b2acae 100644
> --- a/gcc/cp/name-lookup.cc
> +++ b/gcc/cp/name-lookup.cc
> @@ -22,9 +22,11 @@ along with GCC; see the file COPYING3.  If not see
>  #define INCLUDE_MEMORY
>  #include "system.h"
>  #include "coretypes.h"
> +#include "target.h"
>  #include "cp-tree.h"
>  #include "timevar.h"
>  #include "stringpool.h"
> +#include "cgraph.h"
>  #include "print-tree.h"
>  #include "attribs.h"
>  #include "debug.h"
> @@ -3479,6 +3481,15 @@ push_local_extern_decl_alias (tree decl)
>  	  /* Adjust visibility.  */
>  	  determine_visibility (alias);
>  	}
> +      else if (DECL_P (alias))
> +	DECL_ATTRIBUTES (alias)
> +	  = targetm.merge_decl_attributes (alias, decl);
> +      if (DECL_P (alias))
> +	{
> +	  symtab_node::remap_sym_alias_target (decl, alias);
> +	  DECL_ATTRIBUTES (decl)
> +	    = remove_attribute ("sym_alias", DECL_ATTRIBUTES (alias));
> +	}
>      }
>  
>    retrofit_lang_decl (decl);
> diff --git a/gcc/cp/optimize.cc b/gcc/cp/optimize.cc
> index 9e8926e4cc603..4a2e8cb435404 100644
> --- a/gcc/cp/optimize.cc
> +++ b/gcc/cp/optimize.cc
> @@ -528,9 +528,12 @@ maybe_clone_body (tree fn)
>        DECL_VISIBILITY_SPECIFIED (clone) = DECL_VISIBILITY_SPECIFIED (fn);
>        DECL_DLLIMPORT_P (clone) = DECL_DLLIMPORT_P (fn);
>        DECL_ATTRIBUTES (clone) = clone_attrs (DECL_ATTRIBUTES (fn));
> +      adjust_clone_attributes (fn, clone, DECL_NAME (clone), true);
>        DECL_DISREGARD_INLINE_LIMITS (clone) = DECL_DISREGARD_INLINE_LIMITS (fn);
>        set_decl_section_name (clone, fn);
>  
> +      update_sym_alias_interface (clone);
> +
>        /* Adjust the parameter names and locations.  */
>        parm = DECL_ARGUMENTS (fn);
>        clone_parm = DECL_ARGUMENTS (clone);
> diff --git a/gcc/cp/rtti.cc b/gcc/cp/rtti.cc
> index 7878929c24679..4bb7b8c8c6e78 100644
> --- a/gcc/cp/rtti.cc
> +++ b/gcc/cp/rtti.cc
> @@ -28,8 +28,10 @@ along with GCC; see the file COPYING3.  If not see
>  #include "stringpool.h"
>  #include "intl.h"
>  #include "stor-layout.h"
> +#include "attribs.h"
>  #include "c-family/c-pragma.h"
>  #include "gcc-rich-location.h"
> +#include "cgraph.h"
>  
>  /* C++ returns type information to the user in struct type_info
>     objects. We also use type information to implement dynamic_cast and
> @@ -479,8 +481,13 @@ get_tinfo_decl_direct (tree type, tree name, int pseudo_ix)
>  	  = build_tree_list (get_identifier ("non overlapping"),
>  			     NULL_TREE);
>        else
> +	/* Share the non overlapping attribute, without assuming it's
> +	   the only attribute, but assuming it's the last if it's
> +	   present.  There may be sym aliases too, and those are not
> +	   to be shared.  */
>  	DECL_ATTRIBUTES (d)
> -	  = DECL_ATTRIBUTES ((*unemitted_tinfo_decls)[0]);
> +	  = lookup_attribute ("non overlapping",
> +			      DECL_ATTRIBUTES ((*unemitted_tinfo_decls)[0]));
>  
>        /* Mark the variable as undefined -- but remember that we can
>  	 define it later if we need to do so.  */
> @@ -492,6 +499,16 @@ get_tinfo_decl_direct (tree type, tree name, int pseudo_ix)
>        if (CLASS_TYPE_P (type))
>  	CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)) = d;
>  
> +      /* Copy sym alias attributes from the type to the rtti obj decl.  */
> +      tree *attrs = &DECL_ATTRIBUTES (d);
> +      FOR_EACH_SYM_ALIAS (sym, TYPE_ATTRIBUTES (type))
> +	{
> +	  tree attr = tree_cons (TREE_PURPOSE (sym), TREE_VALUE (sym), *attrs);
> +	  *attrs = attr;
> +	  attrs = &TREE_CHAIN (attr);
> +	}
> +      create_sym_alias_decls (d);
> +
>        /* Add decl to the global array of tinfo decls.  */
>        vec_safe_push (unemitted_tinfo_decls, d);
>      }
> @@ -499,6 +516,58 @@ get_tinfo_decl_direct (tree type, tree name, int pseudo_ix)
>    return d;
>  }
>  
> +/* After modifying the attributes of TYPE, check whether tinfo was
> +   already created and, if so, add to it any sym alias attributes
> +   that were not already present.  */
> +
> +void
> +update_tinfo_sym_alias (tree type)
> +{
> +  if (!TYPE_SIZE (type) || !CLASS_TYPE_P (type))
> +    return;
> +
> +  tree d = CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type));
> +  if (!d)
> +    return;
> +
> +  bool first = true;
> +  symtab_node *node = NULL;
> +
> +  tree *attrs = &DECL_ATTRIBUTES (d);
> +  FOR_EACH_SYM_ALIAS (sym, TYPE_ATTRIBUTES (type))
> +    {
> +      bool found = false;
> +      FOR_EACH_SYM_ALIAS (d_sym, *attrs)
> +	if (TREE_VALUE (sym) == TREE_VALUE (d_sym))
> +	  {
> +	    found = true;
> +	    break;
> +	  }
> +
> +      if (found)
> +	continue;
> +
> +      tree attr = tree_cons (TREE_PURPOSE (sym),
> +			     TREE_VALUE (sym),
> +			     *attrs);
> +      *attrs = attr;
> +      attrs = &TREE_CHAIN (attr);
> +
> +      if (first)
> +	{
> +	  first = false;
> +	  node = symtab_node::get (d);
> +	}
> +
> +      if (!node)
> +	continue;
> +
> +      tree id = TREE_VALUE (TREE_VALUE (sym));
> +      id = get_identifier (TREE_STRING_POINTER (id));
> +      create_sym_alias_decl (d, id);
> +    }
> +}
> +
>  /* Return the type_info object for TYPE.  */
>  
>  tree
> diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
> index e6de0815846a6..5dcdec76c1ebc 100644
> --- a/gcc/doc/extend.texi
> +++ b/gcc/doc/extend.texi
> @@ -4141,6 +4141,43 @@ Function Attributes}, @ref{PowerPC Function Attributes},
>  @ref{Nios II Function Attributes}, and @ref{S/390 Function Attributes}
>  for details.
>  
> +@cindex @code{sym_alias} function attribute
> +@item sym_alias ("@var{name}")
> +The @code{sym_alias} attribute causes @var{name} to be output as an
> +alias to the function, with the same linkage and visibility as the
> +function, when the function definition is output, provided that the
> +function could be an alias target.  For instance,
> +
> +@smallexample
> +void f (uint64_t) __attribute__ ((__sym_alias__ ("f_u64")));
> +void f (uint64_t) @{ /* @r{Do something.} */; @}
> +@end smallexample
> +
> +@noindent
> +defines @samp{f}, and outputs @samp{f_u64} as an alias for @samp{f},
> +with the same linkage and visibility.  This is particularly useful when
> +exporting C++ names for use in other languages, or as an alias target,
> +when machine-dependent types would make mangled names harder to deal
> +with.
> +
> +In the case of C++ constructors and destructors, in which a single
> +definition may output multiple symbols, the specified name is associated
> +with the variant that constructs or destructs a complete object.  The
> +variant that applies to a base subobject gets a @code{_Base} suffix, and
> +the deleting destructor gets a @code{_Del} suffix.
> +
> +This attribute is silently ignored if @samp{f} is not defined in the
> +same translation unit, so that the attribute can be attached to forward
> +declarations.
> +
> +Aliases introduced with this attribute, such as @samp{f_u64} in the
> +example above, are assembly symbol names: they do not undergo C++ name
> +mangling, and are not made visible in any scope in the source language.
> +They can, however, can be named as alias targets.
> +
> +This attribute requires assembler and object file support for aliases,
> +and may not be available on all targets.
> +
>  @cindex @code{symver} function attribute
>  @item symver ("@var{name2}@@@var{nodename}")
>  On ELF targets this attribute creates a symbol version.  The @var{name2} part
> @@ -8069,6 +8106,10 @@ will be placed in new, unique sections.
>  
>  This additional functionality requires Binutils version 2.36 or later.
>  
> +@cindex @code{sym_alias} variable attribute
> +@item sym_alias ("@var{name}")
> +See @pxref{Common Function Attributes}.
> +
>  @cindex @code{uninitialized} variable attribute
>  @item uninitialized
>  This attribute, attached to a variable with automatic storage, means that
> @@ -9164,6 +9205,21 @@ is not supported; that is to say, if a given scalar object can be accessed
>  through distinct types that assign a different storage order to it, then the
>  behavior is undefined.
>  
> +@cindex @code{sym_alias} type attribute
> +@item sym_alias ("@var{name}")
> +The @code{sym_alias} type attribute causes @var{name} to be emitted as an
> +alias to the definition of the C++ Run-Time Type Information (RTTI)
> +@code{std::type_info} object associated with the type.  For instance,
> +
> +@smallexample
> +class foo __attribute__ ((__sym_alias__ ("TI_foo")));
> +@end smallexample
> +
> +@noindent
> +arranges for @samp{TI_foo} to be defined as an alias to the RTTI object
> +for class @samp{foo}, once the class is defined and used in ways that
> +cause its RTTI object to be synthesized and output.
> +
>  @cindex @code{transparent_union} type attribute
>  @item transparent_union
>  
> diff --git a/gcc/symtab.cc b/gcc/symtab.cc
> index 0470509a98d2a..43ba88d793925 100644
> --- a/gcc/symtab.cc
> +++ b/gcc/symtab.cc
> @@ -1943,6 +1943,44 @@ symtab_node::noninterposable_alias (symtab_node *node, void *data)
>    return false;
>  }
>  
> +/* Remap sym alias nodes recorded as aliasing REPLACED to alias
> +   REPLACEMENT instead.  */
> +
> +void
> +symtab_node::remap_sym_alias_target (tree replaced, tree replacement)
> +{
> +  if (!decl_in_symtab_p (replacement)
> +      || !symtab_node::get (replacement))
> +    return;
> +
> +  FOR_EACH_SYM_ALIAS (sym, DECL_ATTRIBUTES (replaced))
> +    {
> +      tree id = TREE_VALUE (TREE_VALUE (sym));
> +      id = get_identifier (TREE_STRING_POINTER (id));
> +
> +      symtab_node *sym_node = symtab_node::get_for_asmname (id);
> +
> +      if (!sym_node)
> +	{
> +	  create_sym_alias_decl (replacement, id);
> +	  continue;
> +	}
> +
> +      gcc_assert (!sym_node->analyzed);
> +      if (sym_node->alias_target != replaced)
> +	continue;
> +
> +      // sym_node->definition = 0;
> +
> +      if (VAR_P (replaced))
> +	// varpool_node::create_extra_name_alias (sym_node->decl, replacement);
> +	varpool_node::create_alias (sym_node->decl, replacement);
> +      else
> +	cgraph_node::create_same_body_alias (sym_node->decl, replacement);
> +	// cgraph_node::create_alias (sym_node->decl, replacement);
> +    }
> +}
> +
>  /* If node cannot be overwriten by static or dynamic linker to point to
>     different definition, return NODE. Otherwise look for alias with such
>     property and if none exists, introduce new one.  */
> diff --git a/gcc/testsuite/c-c++-common/attr-sym-alias-neg.c b/gcc/testsuite/c-c++-common/attr-sym-alias-neg.c
> new file mode 100644
> index 0000000000000..f64e5bb1ac44b
> --- /dev/null
> +++ b/gcc/testsuite/c-c++-common/attr-sym-alias-neg.c
> @@ -0,0 +1,80 @@
> +/* { dg-do compile } */
> +/* { dg-require-alias "" } */
> +
> +int f () {
> +  int i __attribute__ ((sym_alias ("f_i"))); /* { dg-warning "ignored" } */
> +  /* ??? X cannot be an alias target; should this be flagged? ... */
> +  static int x __attribute__ ((sym_alias ("f_x")));
> +  static int sx __attribute__ ((alias ("f_x"))); /* { dg-warning "ignored" } */
> +  extern int xx __attribute__ ((alias ("f_x"))); /* { dg-warning "ignored" } */
> +  return i;
> +}
> +
> +/* ??? ... or should XR be accepted?  */
> +extern int xr __attribute__ ((alias ("f_x"))); /* { dg-error "undefined" "" { xfail c++ } } */
> +int dr __attribute__ ((alias ("f_x"))); /* { dg-error "defined both" } */
> +
> +
> +struct s {
> +  int j __attribute__ ((sym_alias ("s_j"))); /* { dg-warning "ignored" } */
> +};
> +
> +
> +int j __attribute__ ((sym_alias ("J_var")));
> +void __attribute__ ((alias ("J_var")))
> +j_fn (); /* { dg-error "between function and variable" } */
> +
> +
> +void __attribute__ ((sym_alias ("K_fn")))
> +k () {
> +}
> +extern int __attribute__ ((alias ("K_fn")))
> +k_var; /* { dg-error "between function and variable" } */
> +
> +
> +int l __attribute__ ((sym_alias ("L_fn")));
> +
> +/* These should be detected and reported, not because the names clash at the
> +   source level, but because the asm symbols do.  */
> +#ifdef __cplusplus
> +extern "C"
> +#endif
> +void
> +L_fn () /* { dg-error "duplicate" "" { xfail *-*-* } } */
> +{
> +}
> +
> +
> +#ifdef __cplusplus
> +extern "C"
> +#endif
> +void __attribute__ ((sym_alias ("M_var")))
> +m ()
> +{
> +}
> +
> +int M_var; /* { dg-error "duplicate" "" { xfail *-*-* } } */
> +
> +
> +#ifdef __cplusplus
> +extern "C"
> +#endif
> +void __attribute__ ((sym_alias ("N_sym")))
> +n_fn ()
> +{
> +}
> +
> +int __attribute__ ((sym_alias ("N_sym")))
> +n_var; /* { dg-error "duplicate" } */
> +
> +
> +int __attribute__ ((sym_alias ("O_sym")))
> +o_var;
> +
> +#ifdef __cplusplus
> +extern "C"
> +#endif
> +void __attribute__ ((sym_alias ("O_sym")))
> +o_fn () /* { dg-error "duplicate" } */
> +{
> +}
> diff --git a/gcc/testsuite/c-c++-common/goacc/declare-1.c b/gcc/testsuite/c-c++-common/goacc/declare-1.c
> index 46ee01b675950..f284289331807 100644
> --- a/gcc/testsuite/c-c++-common/goacc/declare-1.c
> +++ b/gcc/testsuite/c-c++-common/goacc/declare-1.c
> @@ -113,11 +113,11 @@ f_2 (void)
>    int va3;
>  #pragma acc declare device_resident(va3)
>  
> -#ifndef __cplusplus
> +#if 0
>    /* TODO PR90868
>  
> -     C: "error: variable '[...]' used more than once with '#pragma acc declare'".  */
> -#else
> +     "error: variable '[...]' used more than once with '#pragma acc declare'".  */
> +
>    extern int ve0;
>  #pragma acc declare create(ve0)
>  
> diff --git a/gcc/testsuite/c-c++-common/goacc/declare-2.c b/gcc/testsuite/c-c++-common/goacc/declare-2.c
> index e2e22be57e9e4..aec59b69754c5 100644
> --- a/gcc/testsuite/c-c++-common/goacc/declare-2.c
> +++ b/gcc/testsuite/c-c++-common/goacc/declare-2.c
> @@ -137,25 +137,25 @@ void
>  f_pr90868_2 (void)
>  {
>    extern int we0;
> -#pragma acc declare create(we0) /* { dg-error "variable 'we0' used more than once with '#pragma acc declare'" "" { target c } } */
> +#pragma acc declare create(we0) /* { dg-error "variable 'we0' used more than once with '#pragma acc declare'" "" } */
>  
>    extern int we1;
> -#pragma acc declare copyin(we1) /* { dg-error "variable 'we1' used more than once with '#pragma acc declare'" "" { target c } } */
> +#pragma acc declare copyin(we1) /* { dg-error "variable 'we1' used more than once with '#pragma acc declare'" "" } */
>  
>    extern int *we2;
> -#pragma acc declare deviceptr(we2) /* { dg-error "variable 'we2' used more than once with '#pragma acc declare'" "" { target c } } */
> +#pragma acc declare deviceptr(we2) /* { dg-error "variable 'we2' used more than once with '#pragma acc declare'" "" } */
>  
>    extern int we3;
> -#pragma acc declare device_resident(we3) /* { dg-error "variable 'we3' used more than once with '#pragma acc declare'" "" { target c } } */
> +#pragma acc declare device_resident(we3) /* { dg-error "variable 'we3' used more than once with '#pragma acc declare'" "" } */
>  
>    extern int we4;
> -#pragma acc declare link(we4) /* { dg-error "variable 'we4' used more than once with '#pragma acc declare'" "" { target c } } */
> +#pragma acc declare link(we4) /* { dg-error "variable 'we4' used more than once with '#pragma acc declare'" "" } */
>  
>    extern int we5;
> -#pragma acc declare present_or_copyin(we5) /* { dg-error "variable 'we5' used more than once with '#pragma acc declare'" "" { target c } } */
> +#pragma acc declare present_or_copyin(we5) /* { dg-error "variable 'we5' used more than once with '#pragma acc declare'" "" } */
>   
>    extern int we6;
> -#pragma acc declare present_or_create(we6) /* { dg-error "variable 'we6' used more than once with '#pragma acc declare'" "" { target c } } */
> +#pragma acc declare present_or_create(we6) /* { dg-error "variable 'we6' used more than once with '#pragma acc declare'" "" } */
>  }
>  
>  
> diff --git a/gcc/testsuite/c-c++-common/torture/attr-sym-alias-1.c b/gcc/testsuite/c-c++-common/torture/attr-sym-alias-1.c
> new file mode 100644
> index 0000000000000..61af50cb5527f
> --- /dev/null
> +++ b/gcc/testsuite/c-c++-common/torture/attr-sym-alias-1.c
> @@ -0,0 +1,39 @@
> +/* { dg-do compile } */
> +/* { dg-require-alias "" } */
> +
> +extern int var_a __attribute__ ((__sym_alias__ ("FOOVAR_A")));
> +int var_a = 1;
> +
> +void foo_a () __attribute__ ((__sym_alias__ ("FOOBAR_A")));
> +
> +void
> +foo_a ()
> +{
> +}
> +
> +
> +int var_b;
> +extern int var_b __attribute__ ((__sym_alias__ ("FOOVAR_B")));
> +
> +void
> +foo_b ()
> +{
> +}
> +
> +void foo_b () __attribute__ ((__sym_alias__ ("FOOBAR_B")));
> +
> +
> +int var_c __attribute__ ((__sym_alias__ ("FOOVAR_C")));
> +
> +void __attribute__ ((__sym_alias__ ("FOOBAR_C")))
> +foo_c ()
> +{
> +}
> +
> +
> +/* { dg-final { scan-assembler "FOOBAR_A" } } */
> +/* { dg-final { scan-assembler "FOOVAR_A" } } */
> +/* { dg-final { scan-assembler "FOOBAR_B" } } */
> +/* { dg-final { scan-assembler "FOOVAR_B" } } */
> +/* { dg-final { scan-assembler "FOOBAR_C" } } */
> +/* { dg-final { scan-assembler "FOOVAR_C" } } */
> diff --git a/gcc/testsuite/c-c++-common/torture/attr-sym-alias-2.c b/gcc/testsuite/c-c++-common/torture/attr-sym-alias-2.c
> new file mode 100644
> index 0000000000000..6f0d55ca42cc8
> --- /dev/null
> +++ b/gcc/testsuite/c-c++-common/torture/attr-sym-alias-2.c
> @@ -0,0 +1,13 @@
> +/* { dg-do compile } */
> +/* { dg-require-alias "" } */
> +
> +struct s
> +{
> +  int mem __attribute__ ((__sym_alias__ ("MEMFOO"))); /* { dg-warning "attribute ignored" } */
> +};
> +
> +void foo()
> +{
> +  extern void bar () __attribute__ ((__sym_alias__ ("FOOBAR")));
> +  int var __attribute__ ((__sym_alias__ ("FOOVAR"))); /* { dg-warning "attribute ignored" } */
> +}
> diff --git a/gcc/testsuite/c-c++-common/torture/attr-sym-alias-3.c b/gcc/testsuite/c-c++-common/torture/attr-sym-alias-3.c
> new file mode 100644
> index 0000000000000..0052485a30afb
> --- /dev/null
> +++ b/gcc/testsuite/c-c++-common/torture/attr-sym-alias-3.c
> @@ -0,0 +1,41 @@
> +/* { dg-do compile } */
> +/* { dg-require-alias "" } */
> +
> +int var_a = 1;
> +
> +void
> +foo_a ()
> +{
> +  extern int var_a __attribute__ ((__sym_alias__ ("FOOVAR_A")));
> +  void foo_a () __attribute__ ((__sym_alias__ ("FOOBAR_A")));
> +}
> +
> +#if 0 // __cplusplus
> +/* Without this declaration before the local declaration below, the
> +   attributes of the local declaration do not get propagated to the
> +   (global) namespace scope.  */
> +extern int var_b;
> +#endif
> +
> +void
> +foo_b ()
> +{
> +  extern int var_b __attribute__ ((__sym_alias__ ("FOOVAR_B")));
> +}
> +
> +int var_b;
> +
> +void __attribute__ ((__sym_alias__ ("FOOBAR_C")))
> +foo_c ()
> +{
> +  void foo_b () __attribute__ ((__sym_alias__ ("FOOBAR_B")));
> +  /* Another sym for var_b.  */
> +  extern int var_b __attribute__ ((__sym_alias__ ("FOOVAR_C")));
> +}
> +
> +/* { dg-final { scan-assembler "FOOBAR_A" } } */
> +/* { dg-final { scan-assembler "FOOVAR_A" } } */
> +/* { dg-final { scan-assembler "FOOBAR_B" } } */
> +/* { dg-final { scan-assembler "FOOVAR_B" } } */
> +/* { dg-final { scan-assembler "FOOBAR_C" } } */
> +/* { dg-final { scan-assembler "FOOVAR_C" } } */
> diff --git a/gcc/testsuite/c-c++-common/torture/attr-sym-alias-4.c b/gcc/testsuite/c-c++-common/torture/attr-sym-alias-4.c
> new file mode 100644
> index 0000000000000..2beafa4637923
> --- /dev/null
> +++ b/gcc/testsuite/c-c++-common/torture/attr-sym-alias-4.c
> @@ -0,0 +1,28 @@
> +/* { dg-do run } */
> +/* { dg-require-alias "" } */
> +
> +int var_a __attribute__ ((__sym_alias__ ("FOOVAR_A"))) = 42;
> +
> +int __attribute__ ((__sym_alias__ ("FOOBAR_A")))
> +foo_a (int p)
> +{
> +  return p;
> +}
> +
> +extern int __attribute__ ((__alias__ (("FOOVAR_A")))) var_b;
> +extern int __attribute__ ((__alias__ (("FOOBAR_A")))) foo_b (int p);
> +
> +int
> +foo_c ()
> +{
> +  return foo_b (var_b);
> +}
> +
> +int
> +main ()
> +{
> +  if (foo_c () != 42)
> +    __builtin_abort ();
> +
> +  return 0;
> +}
> diff --git a/gcc/testsuite/c-c++-common/torture/attr-sym-alias-5.c b/gcc/testsuite/c-c++-common/torture/attr-sym-alias-5.c
> new file mode 100644
> index 0000000000000..bee90136dafd5
> --- /dev/null
> +++ b/gcc/testsuite/c-c++-common/torture/attr-sym-alias-5.c
> @@ -0,0 +1,54 @@
> +/* { dg-do compile } */
> +/* { dg-require-alias "" } */
> +/* { dg-require-visibility "" } */
> +
> +int __attribute__ ((sym_alias ("A_hid"), visibility ("hidden"))) a;
> +
> +extern int __attribute__ ((sym_alias ("B_prt"))) b;
> +
> +int b __attribute__ ((visibility ("protected")));
> +
> +extern int __attribute__ ((sym_alias ("C_ntr"))) c;
> +
> +extern int c __attribute__ ((visibility ("internal")));
> +
> +int c;
> +
> +static int d __attribute__ ((sym_alias ("D_stt")));
> +
> +
> +extern void __attribute__ ((sym_alias ("F_hid"), visibility ("hidden")))
> +f ();
> +
> +void
> +f () {
> +}
> +
> +extern void __attribute__ ((sym_alias ("G_prt")))
> +g ();
> +
> +void __attribute__ ((visibility ("protected")))
> +g () {
> +}
> +
> +extern void __attribute__ ((sym_alias ("H_ntr")))
> +h ();
> +
> +void __attribute__ ((visibility ("internal")))
> +h ();
> +
> +void h () {
> +}
> +
> +static void __attribute__ ((sym_alias ("I_stt")))
> +i () {
> +}
> +
> +/* { dg-final { scan-assembler {hidden[^\n]*A_hid} } } */
> +/* { dg-final { scan-assembler {protected[^\n]*B_prt} } } */
> +/* { dg-final { scan-assembler {internal[^\n]*C_ntr} } } */
> +/* { dg-final { scan-assembler-not {glob[^\n]*D_stt} } } */
> +/* { dg-final { scan-assembler {hidden[^\n]*F_hid} } } */
> +/* { dg-final { scan-assembler {protected[^\n]*G_prt} } } */
> +/* { dg-final { scan-assembler {internal[^\n]*H_ntr} } } */
> +/* { dg-final { scan-assembler-not {glob[^\n]*I_stt} } } */
> diff --git a/gcc/testsuite/g++.dg/torture/attr-sym-alias-1.C b/gcc/testsuite/g++.dg/torture/attr-sym-alias-1.C
> new file mode 100644
> index 0000000000000..579eda1a473f6
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/torture/attr-sym-alias-1.C
> @@ -0,0 +1,72 @@
> +/* { dg-do compile } */
> +/* { dg-require-alias "" } */
> +
> +class __attribute__ ((__sym_alias__ ("FOOCLS_A"),
> +		      __sym_alias__ ("FOOCLS_A_Dupe"))) foo {
> +  static int var __attribute__ ((__sym_alias__ ("FOOVAR_A")));
> +  __attribute__ ((__sym_alias__ ("FOOCTR_A"))) foo ();
> +  void __attribute__ ((__sym_alias__ ("FOOBAR_A"))) bar ();
> +  virtual __attribute__ ((__sym_alias__ ("FOODTR_A"))) ~foo() {}
> +};
> +
> +int foo::var = 1;
> +
> +foo::foo () {}
> +
> +void foo::bar () {}
> +
> +namespace b {
> +  class __attribute__ ((__sym_alias__ ("FOOCLS_B"))) foo {
> +    static int var __attribute__ ((__sym_alias__ ("FOOVAR_B")));
> +    __attribute__ ((__sym_alias__ ("FOOCTR_B"))) foo ();
> +    void __attribute__ ((__sym_alias__ ("FOOBAR_B"))) bar () {}
> +    virtual __attribute__ ((__sym_alias__ ("FOODTR_B"))) ~foo() {}
> +  };
> +
> +  int foo::var = 2;
> +
> +  foo::foo () {
> +    void (foo::*pbar)() = &foo::bar;
> +  }
> +}
> +
> +namespace c {
> +  namespace cd {
> +    class __attribute__ ((__sym_alias__ ("FOOCLS_C"))) foo {
> +      static int var __attribute__ ((__sym_alias__ ("FOOVAR_C")));
> +      __attribute__ ((__sym_alias__ ("FOOCTR_C"))) foo () {
> +	void (foo::*pbar)() = &foo::bar;
> +      }
> +      void __attribute__ ((__sym_alias__ ("FOOBAR_C"))) bar () {}
> +      virtual __attribute__ ((__sym_alias__ ("FOODTR_C"))) ~foo() {}
> +    };
> +
> +    int foo::var = 3;
> +  }
> +}
> +
> +/* { dg-final { scan-assembler "FOOCLS_A" } } */
> +/* { dg-final { scan-assembler "FOOCLS_A_Dupe" } } */
> +/* { dg-final { scan-assembler "FOOBAR_A" } } */
> +/* { dg-final { scan-assembler "FOOCTR_A" } } */
> +/* { dg-final { scan-assembler "FOOCTR_A_Base" } } */
> +/* { dg-final { scan-assembler "FOODTR_A" } } */
> +/* { dg-final { scan-assembler "FOODTR_A_Base" } } */
> +/* { dg-final { scan-assembler "FOODTR_A_Del" } } */
> +/* { dg-final { scan-assembler "FOOVAR_A" } } */
> +/* { dg-final { scan-assembler "FOOCLS_B" } } */
> +/* { dg-final { scan-assembler "FOOBAR_B" } } */
> +/* { dg-final { scan-assembler "FOOCTR_B" } } */
> +/* { dg-final { scan-assembler "FOOCTR_A_Base" } } */
> +/* { dg-final { scan-assembler "FOODTR_B" } } */
> +/* { dg-final { scan-assembler "FOODTR_B_Base" } } */
> +/* { dg-final { scan-assembler "FOODTR_B_Del" } } */
> +/* { dg-final { scan-assembler "FOOVAR_B" } } */
> +/* { dg-final { scan-assembler "FOOCLS_C" } } */
> +/* { dg-final { scan-assembler "FOOBAR_C" } } */
> +/* { dg-final { scan-assembler "FOOCTR_C" } } */
> +/* { dg-final { scan-assembler "FOOCTR_C_Base" } } */
> +/* { dg-final { scan-assembler "FOODTR_C" } } */
> +/* { dg-final { scan-assembler "FOODTR_C_Base" } } */
> +/* { dg-final { scan-assembler "FOODTR_C_Del" } } */
> +/* { dg-final { scan-assembler "FOOVAR_C" } } */
> diff --git a/gcc/testsuite/g++.dg/torture/attr-sym-alias-2.C b/gcc/testsuite/g++.dg/torture/attr-sym-alias-2.C
> new file mode 100644
> index 0000000000000..6facfcc2cd9a9
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/torture/attr-sym-alias-2.C
> @@ -0,0 +1,26 @@
> +/* { dg-do compile } */
> +/* { dg-require-alias "" } */
> +
> +namespace {
> +  class __attribute__ ((__sym_alias__ ("FOOCLS_A"))) foo {
> +    static int var __attribute__ ((__sym_alias__ ("FOOVAR_A")));
> +    __attribute__ ((__sym_alias__ ("FOOCTR_A"))) foo ();
> +    virtual __attribute__ ((__sym_alias__ ("FOODTR_A"))) ~foo ();
> +    void __attribute__ ((__sym_alias__ ("FOOBAR_A"))) bar ();
> +  };
> +
> +  int foo::var = 3;
> +  foo::foo () {}
> +  foo::~foo () {}
> +  void foo::bar () {}
> +}
> +
> +/* { dg-final { scan-assembler-not "\.globl" } } */
> +/* { dg-final { scan-assembler "FOOCLS_A" } } */
> +/* { dg-final { scan-assembler "FOOBAR_A" } } */
> +/* { dg-final { scan-assembler "FOOCTR_A" } } */
> +/* { dg-final { scan-assembler "FOOCTR_A_Base" } } */
> +/* { dg-final { scan-assembler "FOODTR_A" } } */
> +/* { dg-final { scan-assembler "FOODTR_A_Base" } } */
> +/* { dg-final { scan-assembler "FOODTR_A_Del" } } */
> +/* { dg-final { scan-assembler "FOOVAR_A" } } */
> diff --git a/gcc/testsuite/g++.dg/torture/attr-sym-alias-3.C b/gcc/testsuite/g++.dg/torture/attr-sym-alias-3.C
> new file mode 100644
> index 0000000000000..42c7288ad4ad2
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/torture/attr-sym-alias-3.C
> @@ -0,0 +1,83 @@
> +/* { dg-do compile } */
> +/* { dg-require-alias "" } */
> +
> +// sym can be applied to template function explicit instantiations.
> +
> +template <typename T>
> +void
> +fn(T) {
> +};
> +
> +template void __attribute__ ((__sym_alias__ ("FOOFUN_UINT"))) fn<>(unsigned int);
> +template void __attribute__ ((__sym_alias__ ("FOOFUN_LONG"))) fn<>(long);
> +
> +template<> void __attribute__ ((__sym_alias__ ("FOOFUN_CHAR"))) fn<>(char) {}
> +
> +
> +template <typename T = void>
> +struct
> +foo {
> +  virtual ~foo() {}
> +
> +  virtual void virtfun() {}
> +
> +  static void stfun() {}
> +  void inlfun() {}
> +};
> +
> +// Explicitly instantiate members before the enclosing class.
> +
> +template void
> +__attribute__ ((__sym_alias__ ("FOOCLS_CHAR_VIRT"))) foo<char>::virtfun();
> +
> +template class __attribute__ ((__sym_alias__ ("FOOCLS_CHAR_TI"))) foo<char>;
> +
> +// Though they're only output if the enclosing class is.
> +template void
> +__attribute__ ((__sym_alias__ ("FOOCLS_LONG_VIRT"))) foo<long>::virtfun();
> +extern
> +template class __attribute__ ((__sym_alias__ ("FOOCLS_LONG_TI_X"))) foo<long>;
> +
> +
> +template void
> +__attribute__ ((__sym_alias__ ("FOOCLS_VOID_ST"))) foo<void>::stfun();
> +
> +template class __attribute__ ((__sym_alias__ ("FOOCLS_VOID_TI"))) foo<>;
> +
> +
> +extern
> +template class __attribute__ ((__sym_alias__ ("FOOCLS_SHORT_TI_X"))) foo<short>;
> +
> +template void
> +__attribute__ ((__sym_alias__ ("FOOCLS_SHORT_ST"))) foo<short>::stfun();
> +template void
> +__attribute__ ((__sym_alias__ ("FOOCLS_SHORT_INL"))) foo<short>::inlfun();
> +
> +template class __attribute__ ((__sym_alias__ ("FOOCLS_SHORT_TI_D"))) foo<short>;
> +
> +// Explicit specializations work too.
> +
> +template <>
> +struct  __attribute__ ((__sym_alias__ ("FOOCLS_INT_TI")))
> +foo<int>
> +{
> +  virtual ~foo() {}
> +  virtual void __attribute__ ((__sym_alias__ ("FOOCLS_INT_VIRT"))) virtfun() {}
> +};
> +
> +/* { dg-final { scan-assembler "FOOFUN_UINT" } } */
> +/* { dg-final { scan-assembler "FOOFUN_LONG" } } */
> +/* { dg-final { scan-assembler "FOOFUN_CHAR" } } */
> +
> +/* { dg-final { scan-assembler "FOOCLS_VOID_TI" } } */
> +/* { dg-final { scan-assembler "FOOCLS_VOID_ST" } } */
> +/* { dg-final { scan-assembler "FOOCLS_CHAR_TI" } } */
> +/* { dg-final { scan-assembler "FOOCLS_CHAR_VIRT" } } */
> +/* { dg-final { scan-assembler "FOOCLS_SHORT_TI_X" } } */
> +/* { dg-final { scan-assembler "FOOCLS_SHORT_ST" } } */
> +/* { dg-final { scan-assembler "FOOCLS_SHORT_INL" } } */
> +/* { dg-final { scan-assembler "FOOCLS_SHORT_TI_D" } } */
> +/* { dg-final { scan-assembler-not "FOOCLS_LONG_TI_X" } } */
> +/* { dg-final { scan-assembler-not "FOOCLS_LONG_VIRT" } } */
> +/* { dg-final { scan-assembler "FOOCLS_INT_TI" } } */
> +/* { dg-final { scan-assembler "FOOCLS_INT_VIRT" } } */
> diff --git a/gcc/testsuite/g++.dg/torture/attr-sym-alias-4.C b/gcc/testsuite/g++.dg/torture/attr-sym-alias-4.C
> new file mode 100644
> index 0000000000000..59b779de35d80
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/torture/attr-sym-alias-4.C
> @@ -0,0 +1,28 @@
> +/* { dg-do compile } */
> +/* { dg-require-alias "" } */
> +
> +template <typename T = void>
> +class
> +__attribute__ ((__sym_alias__ ("FOOCLS")))
> +foo // { dg-error "duplicate|already" }
> +{
> +  virtual ~foo() {}
> +
> +  template <typename U>
> +  void
> +    __attribute__ ((__sym_alias__ ("FOOTMF")))
> +    tmemfun () {} // { dg-error "duplicate|already" }
> +};
> +
> +template <typename T>
> +void
> +__attribute__ ((__sym_alias__ ("FOOTFN")))
> +fn(T) { // { dg-error "duplicate|already" }
> +};
> +
> +template class foo<>;
> +template class foo<int>;
> +template void foo<>::tmemfun<void>();
> +template void foo<int>::tmemfun<void>();
> +template void fn<>(int);
> +template void fn<>(long);
> diff --git a/gcc/testsuite/g++.dg/torture/attr-sym-alias-5.C b/gcc/testsuite/g++.dg/torture/attr-sym-alias-5.C
> new file mode 100644
> index 0000000000000..45d59b953c325
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/torture/attr-sym-alias-5.C
> @@ -0,0 +1,14 @@
> +/* { dg-do compile { target c++11 } } */
> +/* { dg-require-alias "" } */
> +
> +struct foo {
> +  __attribute__ ((__sym_alias__ ("FOOCTR_A"))) foo ();
> +  virtual __attribute__ ((__sym_alias__ ("FOODTR_A"))) ~foo() {}
> +};
> +
> +foo::foo () {}
> +
> +// Make sure the inherited cdtors don't duplicate the syms.
> +struct bar : foo {
> +  using foo::foo;
> +};
> diff --git a/gcc/varpool.cc b/gcc/varpool.cc
> index e7b51b15e4a84..33649906d1d11 100644
> --- a/gcc/varpool.cc
> +++ b/gcc/varpool.cc
> @@ -163,6 +163,9 @@ varpool_node::get_create (tree decl)
>      }
>  
>    node->register_symbol ();
> +
> +  create_sym_alias_decls (decl);
> +
>    return node;
>  }
>  
> 
> 
> -- 
> Alexandre Oliva, happy hacker            https://FSFLA.org/blogs/lxo/
>    Free Software Activist                   GNU Toolchain Engineer
> More tolerance and less prejudice are key for inclusion and diversity
> Excluding neuro-others for not behaving ""normal"" is *not* inclusive
  

On Dec  6, 2023, Jan Hubicka <hubicka@ucw.cz> wrote:

>> On Nov 30, 2023, Jan Hubicka <hubicka@ucw.cz> wrote:
>> 
>> >> +      if (VAR_P (replaced))
>> >> +	varpool_node::create_alias (sym_node->decl, replacement);
>> >> +      else
>> >> +	cgraph_node::create_alias (sym_node->decl, replacement);
>> 
>> Unfortunately, this change didn't work.  Several of the C++ tests
>> regressed with it.  Going back to same-body aliases, they work.
>> 
>> I suspect this may have to do with the infrastructure put in to deal
>> with cdtors clones.

> Do you have short testcase for this?

attr-sym-alias-[13].C are not too big, and show various regressions with
the incremental patchlet below (to be applied on top of v7], but here's
a minimal testcase that triggers the problem:

struct foo {
  __attribute__ ((__sym_alias__ ("FOODTR_A"))) ~foo() {}
};
foo bar;

> THe main oddities with same body
> aliases comes from the fact that C++ FE creates them early during
> parsing before all declaration flags are finished.

*nod*, this is probably why some of the cdtor and even sym_aliases for
inline member functions (FOOBAR_B and FOOBAR_C in attr-sym-alias-1.C,
and FOOCLS_INT_VIRT in attr-sym-alias-3.C) fail to be output when not
using create_same_body_alias.

diff --git a/gcc/attribs.cc b/gcc/attribs.cc
index abfbbbf6294..65ce610f2d4 100644
--- a/gcc/attribs.cc
+++ b/gcc/attribs.cc
@@ -2717,8 +2717,8 @@ create_sym_alias_decl (tree decl, tree id)
     // node = varpool_node::create_extra_name_alias (clone, decl);
     node = varpool_node::create_alias (clone, decl);
   else
-    node = cgraph_node::create_same_body_alias (clone, decl);
-    // node = cgraph_node::create_alias (clone, decl);
+    // node = cgraph_node::create_same_body_alias (clone, decl);
+    node = cgraph_node::create_alias (clone, decl);
   if (symtab_node *dnode = symtab_node::get_create (decl))
     node->copy_visibility_from (dnode);
 
diff --git a/gcc/symtab.cc b/gcc/symtab.cc
index 44df52095c1..e40240077f2 100644
--- a/gcc/symtab.cc
+++ b/gcc/symtab.cc
@@ -1993,8 +1993,8 @@ symtab_node::remap_sym_alias_target (tree replaced, tree replacement)
 	// varpool_node::create_extra_name_alias (sym_node->decl, replacement);
 	varpool_node::create_alias (sym_node->decl, replacement);
       else
-	cgraph_node::create_same_body_alias (sym_node->decl, replacement);
-	// cgraph_node::create_alias (sym_node->decl, replacement);
+	// cgraph_node::create_same_body_alias (sym_node->decl, replacement);
+	cgraph_node::create_alias (sym_node->decl, replacement);
       sym_node->copy_visibility_from (repl_node);
     }
 }

> Fixup copies some flags such as inline flags, visibility and comdat
> groups which can change during parsing process.

*nod*, I've run into some of that, and had to add visibility propagation
to the sym_aliases to make up for it.

But I'm not sure that that's the issue you're getting at.  Some
sym_aliases don't even get output with this patchlet.  FOODTR_A* aliases
get created during parsing, when maybe_clone_body creates the dtor
clones and their cgraph nodes to set their comdat group.  ISTM that it's
the later visibility copying because of same body alias that enables the
alias declaration to get the same (final) visibility as the declarations
they alias.  Which suggests that there could be another way to ensure
the update takes place, but the best spot for it has so far eluded me.