From c4b30920c7427fc57181d91f17e9998502fe1866 Mon Sep 17 00:00:00 2001 From: Richard Sandiford Date: Tue, 7 Jan 2020 10:15:43 +0000 Subject: [PATCH] Don't mangle attributes that have a space in their name The SVE port needs to maintain a different type identity for GNU vectors and "SVE vectors" even during LTO, since the types use different ABIs. The easiest way of doing that seemed to be to use type attributes. However, these type attributes shouldn't be user-facing; they're just a convenient way of representing the types internally in GCC. There are already several internal-only attributes, such as "fn spec" and "omp declare simd". They're distinguished from normal user-facing attributes by having a space in their name, which means that it isn't possible to write them directly in C or C++. Taking the same approach mostly works well for SVE. The only snag I've hit so far is that the new attribute needs to (and only exists to) affect type identity. This means that it would normally get included in mangled names, to distinguish it from types without the attribute. However, the SVE ABI specifies a separate mangling for SVE vector types, rather than using an attribute mangling + a normal vector mangling. So we need some way of suppressing the attribute mangling for this case. There are currently no other target-independent or target-specific internal-only attributes that affect type identity, so this patch goes for the simplest fix of skipping mangling for attributes whose names contain a space (which usually wouldn't give a valid symbol anyway). Other options I thought about were: (1) Also make sure that targetm.mangled_type returns nonnull. (2) Check directly for the target-specific name. (3) Add a new target hook. (4) Add new information to attribute_spec. This would be very invasive at this stage, but maybe we should consider replacing all the boolean fields with flags? That should make the tables slightly easier to read and would make adding new flags much simpler in future. 2020-01-07 Richard Sandiford gcc/cp/ * mangle.c (mangle_type_attribute_p): New function, split out from... (write_CV_qualifiers_for_type): ...here. Don't mangle attributes that contain a space. From-SVN: r279952 --- gcc/cp/ChangeLog | 6 ++++++ gcc/cp/mangle.c | 38 ++++++++++++++++++++++++++++++-------- 2 files changed, 36 insertions(+), 8 deletions(-) diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 77c7b107c88..a82b6cf2f21 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,9 @@ +2020-01-07 Richard Sandiford + + * mangle.c (mangle_type_attribute_p): New function, split out from... + (write_CV_qualifiers_for_type): ...here. Don't mangle attributes + that contain a space. + 2020-01-07 Jakub Jelinek PR c++/91369 diff --git a/gcc/cp/mangle.c b/gcc/cp/mangle.c index 36fc315e613..23baa382ed9 100644 --- a/gcc/cp/mangle.c +++ b/gcc/cp/mangle.c @@ -2348,6 +2348,34 @@ attr_strcmp (const void *p1, const void *p2) return strcmp (as1->name, as2->name); } +/* Return true if we should mangle a type attribute with name NAME. */ + +static bool +mangle_type_attribute_p (tree name) +{ + const attribute_spec *as = lookup_attribute_spec (name); + if (!as || !as->affects_type_identity) + return false; + + /* Skip internal-only attributes, which are distinguished from others + by having a space. At present, all internal-only attributes that + affect type identity are target-specific and are handled by + targetm.mangle_type instead. + + Another reason to do this is that a space isn't a valid identifier + character for most file formats. */ + if (strchr (IDENTIFIER_POINTER (name), ' ')) + return false; + + /* The following attributes are mangled specially. */ + if (is_attribute_p ("transaction_safe", name)) + return false; + if (is_attribute_p ("abi_tag", name)) + return false; + + return true; +} + /* Non-terminal for type nodes. Returns the number of CV-qualifiers written for TYPE. @@ -2373,14 +2401,8 @@ write_CV_qualifiers_for_type (const tree type) { auto_vec vec; for (tree a = TYPE_ATTRIBUTES (type); a; a = TREE_CHAIN (a)) - { - tree name = get_attribute_name (a); - const attribute_spec *as = lookup_attribute_spec (name); - if (as && as->affects_type_identity - && !is_attribute_p ("transaction_safe", name) - && !is_attribute_p ("abi_tag", name)) - vec.safe_push (a); - } + if (mangle_type_attribute_p (get_attribute_name (a))) + vec.safe_push (a); if (abi_warn_or_compat_version_crosses (10) && !vec.is_empty ()) G.need_abi_warning = true; if (abi_version_at_least (10)) -- 2.30.2