LCOV - code coverage report
Current view: top level - gcc - attribs.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 94.3 % 1078 1017
Test Date: 2026-11-14 16:39:50 Functions: 98.5 % 68 67
Legend: Lines:     hit not hit

            Line data    Source code
       1              : /* Functions dealing with attribute handling, used by most front ends.
       2              :    Copyright (C) 1992-2026 Free Software Foundation, Inc.
       3              : 
       4              : This file is part of GCC.
       5              : 
       6              : GCC is free software; you can redistribute it and/or modify it under
       7              : the terms of the GNU General Public License as published by the Free
       8              : Software Foundation; either version 3, or (at your option) any later
       9              : version.
      10              : 
      11              : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12              : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13              : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14              : for more details.
      15              : 
      16              : You should have received a copy of the GNU General Public License
      17              : along with GCC; see the file COPYING3.  If not see
      18              : <http://www.gnu.org/licenses/>.  */
      19              : 
      20              : #define INCLUDE_STRING
      21              : #include "config.h"
      22              : #include "system.h"
      23              : #include "coretypes.h"
      24              : #include "target.h"
      25              : #include "tree.h"
      26              : #include "stringpool.h"
      27              : #include "diagnostic-core.h"
      28              : #include "attribs.h"
      29              : #include "fold-const.h"
      30              : #include "ipa-strub.h"
      31              : #include "stor-layout.h"
      32              : #include "langhooks.h"
      33              : #include "plugin.h"
      34              : #include "selftest.h"
      35              : #include "hash-set.h"
      36              : #include "diagnostic.h"
      37              : #include "pretty-print.h"
      38              : #include "pretty-print-markup.h"
      39              : #include "tree-pretty-print.h"
      40              : #include "intl.h"
      41              : #include "gcc-urlifier.h"
      42              : #include "cgraph.h"
      43              : 
      44              : /* Table of the tables of attributes (common, language, format, machine)
      45              :    searched.  */
      46              : static array_slice<const scoped_attribute_specs *const> attribute_tables[2];
      47              : 
      48              : /* Substring representation.  */
      49              : 
      50              : struct substring
      51              : {
      52              :   const char *str;
      53              :   int length;
      54              : };
      55              : 
      56              : /* Simple hash function to avoid need to scan whole string.  */
      57              : 
      58              : static inline hashval_t
      59  13506397297 : substring_hash (const char *str, int l)
      60              : {
      61  13506397297 :   return str[0] + str[l - 1] * 256 + l * 65536;
      62              : }
      63              : 
      64              : /* Used for attribute_hash.  */
      65              : 
      66              : struct attribute_hasher : nofree_ptr_hash <attribute_spec>
      67              : {
      68              :   typedef substring *compare_type;
      69              :   static inline hashval_t hash (const attribute_spec *);
      70              :   static inline bool equal (const attribute_spec *, const substring *);
      71              : };
      72              : 
      73              : inline hashval_t
      74  11428705581 : attribute_hasher::hash (const attribute_spec *spec)
      75              : {
      76  11428705581 :   const int l = strlen (spec->name);
      77  11428705581 :   return substring_hash (spec->name, l);
      78              : }
      79              : 
      80              : inline bool
      81  13989769624 : attribute_hasher::equal (const attribute_spec *spec, const substring *str)
      82              : {
      83  13989769624 :   return (strncmp (spec->name, str->str, str->length) == 0
      84  13989769624 :           && !spec->name[str->length]);
      85              : }
      86              : 
      87              : /* Scoped attribute name representation.  */
      88              : 
      89              : struct scoped_attributes
      90              : {
      91              :   const char *ns;
      92              :   vec<attribute_spec> attributes;
      93              :   hash_table<attribute_hasher> *attribute_hash;
      94              :   /* True if we should not warn about unknown attributes in this NS.  */
      95              :   bool ignored_p;
      96              : };
      97              : 
      98              : /* The table of scope attributes.  */
      99              : static vec<scoped_attributes> attributes_table;
     100              : 
     101              : static scoped_attributes* find_attribute_namespace (const char*);
     102              : static void register_scoped_attribute (const struct attribute_spec *,
     103              :                                        scoped_attributes *);
     104              : static const struct attribute_spec *lookup_scoped_attribute_spec (const_tree,
     105              :                                                                   const_tree);
     106              : 
     107              : static bool attributes_initialized = false;
     108              : 
     109              : /* Do not use directly; go through get_gnu_namespace instead.  */
     110              : static GTY(()) tree gnu_namespace_cache;
     111              : 
     112              : /* Return the IDENTIFIER_NODE for the gnu namespace.  */
     113              : 
     114              : static tree
     115   2867242709 : get_gnu_namespace ()
     116              : {
     117   2867242709 :   if (!gnu_namespace_cache)
     118       295498 :     gnu_namespace_cache = get_identifier ("gnu");
     119   2867242709 :   return gnu_namespace_cache;
     120              : }
     121              : 
     122              : /* Insert SPECS into its namespace.  IGNORED_P is true iff all unknown
     123              :    attributes in this namespace should be ignored for the purposes of
     124              :    -Wattributes.  The function returns the namespace into which the
     125              :    attributes have been registered.  */
     126              : 
     127              : scoped_attributes *
     128      1546681 : register_scoped_attributes (const scoped_attribute_specs &specs,
     129              :                             bool ignored_p /*=false*/)
     130              : {
     131      1546681 :   scoped_attributes *result = NULL;
     132              : 
     133              :   /* See if we already have attributes in the namespace NS.  */
     134      1546681 :   result = find_attribute_namespace (specs.ns);
     135              : 
     136      1546681 :   if (result == NULL)
     137              :     {
     138              :       /* We don't have any namespace NS yet.  Create one.  */
     139       827522 :       scoped_attributes sa;
     140              : 
     141       827522 :       if (attributes_table.is_empty ())
     142       295627 :         attributes_table.create (64);
     143              : 
     144       827522 :       memset (&sa, 0, sizeof (sa));
     145       827522 :       sa.ns = specs.ns;
     146       827522 :       sa.attributes.create (64);
     147       827522 :       sa.ignored_p = ignored_p;
     148       827522 :       result = attributes_table.safe_push (sa);
     149       827522 :       result->attribute_hash = new hash_table<attribute_hasher> (200);
     150              :     }
     151              :   else
     152       719159 :     result->ignored_p |= ignored_p;
     153              : 
     154              :   /* Really add the attributes to their namespace now.  */
     155     43775736 :   for (const attribute_spec &attribute : specs.attributes)
     156              :     {
     157     42229055 :       result->attributes.safe_push (attribute);
     158     42229055 :       register_scoped_attribute (&attribute, result);
     159              :     }
     160              : 
     161      1546681 :   gcc_assert (result != NULL);
     162              : 
     163      1546681 :   return result;
     164              : }
     165              : 
     166              : /* Return the namespace which name is NS, NULL if none exist.  */
     167              : 
     168              : static scoped_attributes*
     169   2037281402 : find_attribute_namespace (const char* ns)
     170              : {
     171   7968431617 :   for (scoped_attributes &iter : attributes_table)
     172   3893895248 :     if (ns == iter.ns
     173   3866535461 :         || (iter.ns != NULL
     174   2014815985 :             && ns != NULL
     175   2014815985 :             && !strcmp (iter.ns, ns)))
     176              :       return &iter;
     177              :   return NULL;
     178              : }
     179              : 
     180              : /* Make some sanity checks on the attribute tables.  */
     181              : 
     182              : static void
     183       295608 : check_attribute_tables (void)
     184              : {
     185       295608 :   hash_set<pair_hash<nofree_string_hash, nofree_string_hash>> names;
     186              : 
     187      1182432 :   for (auto scoped_array : attribute_tables)
     188      2137627 :     for (auto scoped_attributes : scoped_array)
     189     43771885 :       for (const attribute_spec &attribute : scoped_attributes->attributes)
     190              :         {
     191              :           /* The name must not begin and end with __.  */
     192     42225474 :           const char *name = attribute.name;
     193     42225474 :           int len = strlen (name);
     194              : 
     195     42225474 :           gcc_assert (!(name[0] == '_' && name[1] == '_'
     196              :                         && name[len - 1] == '_' && name[len - 2] == '_'));
     197              : 
     198              :           /* The minimum and maximum lengths must be consistent.  */
     199     42225474 :           gcc_assert (attribute.min_length >= 0);
     200              : 
     201     42225474 :           gcc_assert (attribute.max_length == -1
     202              :                       || attribute.max_length >= attribute.min_length);
     203              : 
     204              :           /* An attribute cannot require both a DECL and a TYPE.  */
     205     42225474 :           gcc_assert (!attribute.decl_required
     206              :                       || !attribute.type_required);
     207              : 
     208              :           /* If an attribute requires a function type, in particular
     209              :              it requires a type.  */
     210     42225474 :           gcc_assert (!attribute.function_type_required
     211              :                       || attribute.type_required);
     212              : 
     213              :           /* Check that no name occurs more than once.  Names that
     214              :              begin with '*' are exempt, and may be overridden.  */
     215     42225474 :           const char *ns = scoped_attributes->ns;
     216     44049490 :           if (name[0] != '*' && names.add ({ ns ? ns : "", name }))
     217            0 :             gcc_unreachable ();
     218              :         }
     219       295608 : }
     220              : 
     221              : /* Used to stash pointers to allocated memory so that we can free them at
     222              :    the end of parsing of all TUs. */
     223              : static vec<attribute_spec *> ignored_attributes_table;
     224              : 
     225              : /* Parse arguments V of -Wno-attributes=.
     226              :    Currently we accept:
     227              :      vendor::attr
     228              :      vendor::
     229              :    This functions also registers the parsed attributes so that we don't
     230              :    warn that we don't recognize them.  */
     231              : 
     232              : void
     233       295671 : handle_ignored_attributes_option (vec<char *> *v)
     234              : {
     235       295671 :   if (v == nullptr)
     236              :     return;
     237              : 
     238          330 :   for (auto opt : v)
     239              :     {
     240          184 :       char *cln = strstr (opt, "::");
     241              :       /* We don't accept '::attr'.  */
     242          184 :       if (cln == nullptr || cln == opt)
     243              :         {
     244            0 :           auto_diagnostic_group d;
     245            0 :           error ("wrong argument to ignored attributes");
     246            0 :           inform (input_location, "valid format is %<ns::attr%> or %<ns::%>");
     247            0 :           continue;
     248            0 :         }
     249          184 :       const char *vendor_start = opt;
     250          184 :       ptrdiff_t vendor_len = cln - opt;
     251          184 :       const char *attr_start = cln + 2;
     252              :       /* This could really use rawmemchr :(.  */
     253          184 :       ptrdiff_t attr_len = strchr (attr_start, '\0') - attr_start;
     254              :       /* Verify that they look valid.  */
     255          501 :       auto valid_p = [](const char *const s, ptrdiff_t len) {
     256          317 :         bool ok = false;
     257              : 
     258         1596 :         for (int i = 0; i < len; ++i)
     259         1287 :           if (ISALNUM (s[i]))
     260              :             ok = true;
     261          182 :           else if (s[i] != '_')
     262              :             return false;
     263              : 
     264              :         return ok;
     265              :       };
     266          184 :       if (!valid_p (vendor_start, vendor_len))
     267              :         {
     268           12 :           error ("wrong argument to ignored attributes");
     269           12 :           continue;
     270              :         }
     271          172 :       canonicalize_attr_name (vendor_start, vendor_len);
     272              :       /* We perform all this hijinks so that we don't have to copy OPT.  */
     273          172 :       tree vendor_id = get_identifier_with_length (vendor_start, vendor_len);
     274          172 :       array_slice<const attribute_spec> attrs;
     275              :       /* In the "vendor::" case, we should ignore *any* attribute coming
     276              :          from this attribute namespace.  */
     277          172 :       if (attr_len > 0)
     278              :         {
     279          133 :           if (!valid_p (attr_start, attr_len))
     280              :             {
     281            8 :               error ("wrong argument to ignored attributes");
     282           24 :               continue;
     283              :             }
     284          125 :           canonicalize_attr_name (attr_start, attr_len);
     285          125 :           tree attr_id = get_identifier_with_length (attr_start, attr_len);
     286          125 :           const char *attr = IDENTIFIER_POINTER (attr_id);
     287              :           /* If we've already seen this vendor::attr, ignore it.  Attempting to
     288              :              register it twice would lead to a crash.  */
     289          125 :           if (lookup_scoped_attribute_spec (vendor_id, attr_id))
     290           16 :             continue;
     291              :           /* Create a table with extra attributes which we will register.
     292              :              We can't free it here, so squirrel away the pointers.  */
     293          109 :           attribute_spec *table = new attribute_spec {
     294              :             attr, 0, -2, false, false, false, false, nullptr, nullptr
     295          109 :           };
     296          109 :           ignored_attributes_table.safe_push (table);
     297          109 :           attrs = { table, 1 };
     298              :         }
     299          148 :       const scoped_attribute_specs scoped_specs = {
     300          148 :         IDENTIFIER_POINTER (vendor_id), { attrs }
     301          148 :       };
     302          148 :       register_scoped_attributes (scoped_specs, attrs.empty ());
     303              :     }
     304              : }
     305              : 
     306              : /* Free data we might have allocated when adding extra attributes.  */
     307              : 
     308              : void
     309       287747 : free_attr_data ()
     310              : {
     311       287922 :   for (auto x : ignored_attributes_table)
     312          109 :     delete x;
     313       287747 :   ignored_attributes_table.release ();
     314       287747 : }
     315              : 
     316              : /* Initialize attribute tables, and make some sanity checks if checking is
     317              :    enabled.  */
     318              : 
     319              : void
     320      1149061 : init_attributes (void)
     321              : {
     322      1149061 :   if (attributes_initialized)
     323              :     return;
     324              : 
     325       295627 :   attribute_tables[0] = lang_hooks.attribute_table;
     326       295627 :   attribute_tables[1] = targetm.attribute_table;
     327              : 
     328       295627 :   if (flag_checking)
     329       295608 :     check_attribute_tables ();
     330              : 
     331       886881 :   for (auto scoped_array : attribute_tables)
     332      2137787 :     for (auto scoped_attributes : scoped_array)
     333      1546533 :       register_scoped_attributes (*scoped_attributes);
     334              : 
     335       295627 :   vec<char *> *ignored = (vec<char *> *) flag_ignored_attributes;
     336       295627 :   handle_ignored_attributes_option (ignored);
     337              : 
     338       295627 :   invoke_plugin_callbacks (PLUGIN_ATTRIBUTES, NULL);
     339       295627 :   attributes_initialized = true;
     340              : }
     341              : 
     342              : /* Insert a single ATTR into the attribute table.  */
     343              : 
     344              : void
     345            1 : register_attribute (const struct attribute_spec *attr)
     346              : {
     347            1 :   register_scoped_attribute (attr, find_attribute_namespace ("gnu"));
     348            1 : }
     349              : 
     350              : /* Insert a single attribute ATTR into a namespace of attributes.  */
     351              : 
     352              : static void
     353     42229056 : register_scoped_attribute (const struct attribute_spec *attr,
     354              :                            scoped_attributes *name_space)
     355              : {
     356     42229056 :   struct substring str;
     357     42229056 :   attribute_spec **slot;
     358              : 
     359     42229056 :   gcc_assert (attr != NULL && name_space != NULL);
     360              : 
     361     42229056 :   gcc_assert (name_space->attribute_hash);
     362              : 
     363     42229056 :   str.str = attr->name;
     364     42229056 :   str.length = strlen (str.str);
     365              : 
     366              :   /* Attribute names in the table must be in the form 'text' and not
     367              :      in the form '__text__'.  */
     368     42229056 :   gcc_checking_assert (!canonicalize_attr_name (str.str, str.length));
     369              : 
     370     42229056 :   slot = name_space->attribute_hash
     371     42229056 :          ->find_slot_with_hash (&str, substring_hash (str.str, str.length),
     372              :                                 INSERT);
     373     42229056 :   gcc_assert (!*slot || attr->name[0] == '*');
     374     42229056 :   *slot = const_cast<struct attribute_spec *> (attr);
     375     42229056 : }
     376              : 
     377              : /* Return the spec for the scoped attribute with namespace NS and
     378              :    name NAME.   */
     379              : 
     380              : static const struct attribute_spec *
     381   2035733965 : lookup_scoped_attribute_spec (const_tree ns, const_tree name)
     382              : {
     383   2035733965 :   struct substring attr;
     384   2035733965 :   scoped_attributes *attrs;
     385              : 
     386   4044828232 :   const char *ns_str = (ns != NULL_TREE) ? IDENTIFIER_POINTER (ns) : NULL;
     387              : 
     388   2035733965 :   attrs = find_attribute_namespace (ns_str);
     389              : 
     390   2035733965 :   if (attrs == NULL)
     391              :     return NULL;
     392              : 
     393   2035462660 :   attr.str = IDENTIFIER_POINTER (name);
     394   2035462660 :   attr.length = IDENTIFIER_LENGTH (name);
     395   2035462660 :   return attrs->attribute_hash->find_with_hash (&attr,
     396              :                                                 substring_hash (attr.str,
     397   2035462660 :                                                                 attr.length));
     398              : }
     399              : 
     400              : /* Return the spec for the attribute named NAME.  If NAME is a TREE_LIST,
     401              :    it also specifies the attribute namespace.  */
     402              : 
     403              : const struct attribute_spec *
     404    384812502 : lookup_attribute_spec (const_tree name)
     405              : {
     406    384812502 :   tree ns;
     407    384812502 :   if (TREE_CODE (name) == TREE_LIST)
     408              :     {
     409     22003021 :       ns = TREE_PURPOSE (name);
     410     22003021 :       name = TREE_VALUE (name);
     411              :     }
     412              :   else
     413    362809481 :     ns = get_gnu_namespace ();
     414    384812502 :   return lookup_scoped_attribute_spec (ns, name);
     415              : }
     416              : 
     417              : 
     418              : /* Return the namespace of the attribute ATTR.  This accessor works on
     419              :    GNU and C++11 (scoped) attributes.  On GNU attributes,
     420              :    it returns an identifier tree for the string "gnu".
     421              : 
     422              :    Please read the comments of cxx11_attribute_p to understand the
     423              :    format of attributes.  */
     424              : 
     425              : tree
     426   2549690304 : get_attribute_namespace (const_tree attr)
     427              : {
     428   2549690304 :   if (cxx11_attribute_p (attr))
     429     45257076 :     return TREE_PURPOSE (TREE_PURPOSE (attr));
     430   2504433228 :   return get_gnu_namespace ();
     431              : }
     432              : 
     433              : /* Check LAST_DECL and NODE of the same symbol for attributes that are
     434              :    recorded in SPEC to be mutually exclusive with ATTRNAME, diagnose
     435              :    them, and return true if any have been found.  NODE can be a DECL
     436              :    or a TYPE.  */
     437              : 
     438              : static bool
     439    363494188 : diag_attr_exclusions (tree last_decl, tree node, tree attrname,
     440              :                       const attribute_spec *spec)
     441              : {
     442    363494188 :   const attribute_spec::exclusions *excl = spec->exclude;
     443              : 
     444    363494188 :   tree_code code = TREE_CODE (node);
     445              : 
     446    363494188 :   if ((code == FUNCTION_DECL && !excl->function
     447            0 :        && (!excl->type || !spec->affects_type_identity))
     448    363494188 :       || (code == VAR_DECL && !excl->variable
     449              :           && (!excl->type || !spec->affects_type_identity))
     450    363457136 :       || (((code == TYPE_DECL || RECORD_OR_UNION_TYPE_P (node)) && !excl->type)))
     451              :     return false;
     452              : 
     453              :   /* True if an attribute that's mutually exclusive with ATTRNAME
     454              :      has been found.  */
     455    363179274 :   bool found = false;
     456              : 
     457    363179274 :   if (last_decl && last_decl != node && TREE_TYPE (last_decl) != node)
     458              :     {
     459              :       /* Check both the last DECL and its type for conflicts with
     460              :          the attribute being added to the current decl or type.  */
     461      1930902 :       found |= diag_attr_exclusions (last_decl, last_decl, attrname, spec);
     462      1930902 :       tree decl_type = TREE_TYPE (last_decl);
     463      1930902 :       found |= diag_attr_exclusions (last_decl, decl_type, attrname, spec);
     464              :     }
     465              : 
     466              :   /* NODE is either the current DECL to which the attribute is being
     467              :      applied or its TYPE.  For the former, consider the attributes on
     468              :      both the DECL and its type.  */
     469    363179274 :   tree attrs[2];
     470              : 
     471    363179274 :   if (DECL_P (node))
     472              :     {
     473    355840365 :       attrs[0] = DECL_ATTRIBUTES (node);
     474    355840365 :       if (TREE_TYPE (node))
     475    355840362 :         attrs[1] = TYPE_ATTRIBUTES (TREE_TYPE (node));
     476              :       else
     477              :         /* TREE_TYPE can be NULL e.g. while processing attributes on
     478              :            enumerators.  */
     479            3 :         attrs[1] = NULL_TREE;
     480              :     }
     481              :   else
     482              :     {
     483      7338909 :       attrs[0] = TYPE_ATTRIBUTES (node);
     484      7338909 :       attrs[1] = NULL_TREE;
     485              :     }
     486              : 
     487              :   /* Iterate over the mutually exclusive attribute names and verify
     488              :      that the symbol doesn't contain it.  */
     489   1089537822 :   for (unsigned i = 0; i != ARRAY_SIZE (attrs); ++i)
     490              :     {
     491    726358548 :       if (!attrs[i])
     492    637276144 :         continue;
     493              : 
     494    277821261 :       for ( ; excl->name; ++excl)
     495              :         {
     496              :           /* Avoid checking the attribute against itself.  */
     497    188738857 :           if (is_attribute_p (excl->name, attrname))
     498    188738442 :             continue;
     499              : 
     500    174601270 :           if (!lookup_attribute (excl->name, attrs[i]))
     501    174599673 :             continue;
     502              : 
     503              :           /* An exclusion may apply either to a function declaration,
     504              :              type declaration, or a field/variable declaration, or
     505              :              any subset of the three.  */
     506         1597 :           if (TREE_CODE (node) == FUNCTION_DECL
     507          353 :               && !excl->function)
     508            0 :             continue;
     509              : 
     510         1597 :           if (TREE_CODE (node) == TYPE_DECL
     511            0 :               && !excl->type)
     512            0 :             continue;
     513              : 
     514         1597 :           if ((TREE_CODE (node) == FIELD_DECL
     515         1597 :                || VAR_P (node))
     516         1203 :               && !excl->variable)
     517         1182 :             continue;
     518              : 
     519          415 :           found = true;
     520              : 
     521              :           /* Print a note?  */
     522          415 :           bool note = last_decl != NULL_TREE;
     523          415 :           auto_diagnostic_group d;
     524          415 :           if (TREE_CODE (node) == FUNCTION_DECL
     525          415 :               && fndecl_built_in_p (node))
     526            0 :             note &= warning (OPT_Wattributes,
     527              :                              "ignoring attribute %qE in declaration of "
     528              :                              "a built-in function %qD because it conflicts "
     529              :                              "with attribute %qs",
     530            0 :                              attrname, node, excl->name);
     531              :           else
     532          415 :             note &= warning (OPT_Wattributes,
     533              :                              "ignoring attribute %qE because "
     534              :                              "it conflicts with attribute %qs",
     535          415 :                              attrname, excl->name);
     536              : 
     537          415 :           if (note)
     538          180 :             inform (DECL_SOURCE_LOCATION (last_decl),
     539              :                     "previous declaration here");
     540          415 :         }
     541              :     }
     542              : 
     543              :   return found;
     544              : }
     545              : 
     546              : /* Return true iff we should not complain about unknown attributes
     547              :    coming from the attribute namespace NS.  This is the case for
     548              :    the -Wno-attributes=ns:: command-line option.  */
     549              : 
     550              : static bool
     551          806 : attr_namespace_ignored_p (tree ns)
     552              : {
     553          806 :   if (ns == NULL_TREE)
     554              :     return false;
     555          755 :   scoped_attributes *r = find_attribute_namespace (IDENTIFIER_POINTER (ns));
     556          755 :   return r && r->ignored_p;
     557              : }
     558              : 
     559              : /* Return true if the attribute ATTR should not be warned about.  */
     560              : 
     561              : bool
     562   1647695004 : attribute_ignored_p (tree attr)
     563              : {
     564   1647695004 :   if (!cxx11_attribute_p (attr))
     565              :     return false;
     566     19333688 :   if (tree ns = get_attribute_namespace (attr))
     567              :     {
     568      4359168 :       const attribute_spec *as = lookup_attribute_spec (TREE_PURPOSE (attr));
     569      4359168 :       if (as == NULL && attr_namespace_ignored_p (ns))
     570              :         return true;
     571      4359101 :       if (as && as->max_length == -2)
     572          221 :         return true;
     573              :     }
     574              :   return false;
     575              : }
     576              : 
     577              : /* Like above, but takes an attribute_spec AS, which must be nonnull.  */
     578              : 
     579              : bool
     580        93076 : attribute_ignored_p (const attribute_spec *const as)
     581              : {
     582        93076 :   return as->max_length == -2;
     583              : }
     584              : 
     585              : /* Return true if the ATTRS chain contains at least one attribute which
     586              :    is not ignored.  */
     587              : 
     588              : bool
     589         1509 : any_nonignored_attribute_p (tree attrs)
     590              : {
     591         1581 :   for (tree attr = attrs; attr; attr = TREE_CHAIN (attr))
     592         1554 :     if (!attribute_ignored_p (attr))
     593              :       return true;
     594              : 
     595              :   return false;
     596              : }
     597              : 
     598              : /* See whether LIST contains at least one instance of attribute ATTR
     599              :    (possibly with different arguments).  Return the first such attribute
     600              :    if so, otherwise return null.  */
     601              : 
     602              : static tree
     603   1652781449 : find_same_attribute (const_tree attr, tree list)
     604              : {
     605   1652781449 :   if (list == NULL_TREE)
     606              :     return NULL_TREE;
     607    853914337 :   tree ns = get_attribute_namespace (attr);
     608    853914337 :   tree name = get_attribute_name (attr);
     609   1707828674 :   return private_lookup_attribute (ns ? IDENTIFIER_POINTER (ns) : nullptr,
     610    853914337 :                                    IDENTIFIER_POINTER (name),
     611    853740629 :                                    ns ? IDENTIFIER_LENGTH (ns) : 0,
     612   1707828674 :                                    IDENTIFIER_LENGTH (name), list);
     613              : }
     614              : 
     615              : /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
     616              :    which is either a DECL (including a TYPE_DECL) or a TYPE.  If a DECL,
     617              :    it should be modified in place; if a TYPE, a copy should be created
     618              :    unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS.  FLAGS gives further
     619              :    information, in the form of a bitwise OR of flags in enum attribute_flags
     620              :    from tree.h.  Depending on these flags, some attributes may be
     621              :    returned to be applied at a later stage (for example, to apply
     622              :    a decl attribute to the declaration rather than to its type).  */
     623              : 
     624              : tree
     625   1942650924 : decl_attributes (tree *node, tree attributes, int flags,
     626              :                  tree last_decl /* = NULL_TREE */)
     627              : {
     628   1942650924 :   tree returned_attrs = NULL_TREE;
     629              : 
     630   1942650924 :   if (TREE_TYPE (*node) == error_mark_node || attributes == error_mark_node)
     631              :     return NULL_TREE;
     632              : 
     633   1942650584 :   if (!attributes_initialized)
     634       295627 :     init_attributes ();
     635              : 
     636   1942650584 :   auto_urlify_attributes sentinel;
     637              : 
     638              :   /* If this is a function and the user used #pragma GCC optimize, add the
     639              :      options to the attribute((optimize(...))) list.  */
     640   1942650584 :   if (TREE_CODE (*node) == FUNCTION_DECL && current_optimize_pragma)
     641              :     {
     642       342862 :       tree cur_attr = lookup_attribute ("optimize", attributes);
     643       342862 :       tree opts = copy_list (current_optimize_pragma);
     644              : 
     645       342862 :       if (! cur_attr)
     646       342859 :         attributes
     647       342859 :           = tree_cons (get_identifier ("optimize"), opts, attributes);
     648              :       else
     649            3 :         TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
     650              :     }
     651              : 
     652   1942650584 :   if (TREE_CODE (*node) == FUNCTION_DECL
     653   1177474140 :       && (optimization_current_node != optimization_default_node
     654   1177417159 :           || target_option_current_node != target_option_default_node)
     655   1968314989 :       && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node))
     656              :     {
     657     25616398 :       DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node) = optimization_current_node;
     658              :       /* Don't set DECL_FUNCTION_SPECIFIC_TARGET for targets that don't
     659              :          support #pragma GCC target or target attribute.  */
     660     25616398 :       if (target_option_default_node)
     661              :         {
     662     25616398 :           tree cur_tree
     663     25616398 :             = build_target_option_node (&global_options, &global_options_set);
     664     25616398 :           tree old_tree = DECL_FUNCTION_SPECIFIC_TARGET (*node);
     665     25616398 :           if (!old_tree)
     666     25616398 :             old_tree = target_option_default_node;
     667              :           /* The changes on optimization options can cause the changes in
     668              :              target options, update it accordingly if it's changed.  */
     669     25616398 :           if (old_tree != cur_tree)
     670     25587019 :             DECL_FUNCTION_SPECIFIC_TARGET (*node) = cur_tree;
     671              :         }
     672              :     }
     673              : 
     674              :   /* If this is a function and the user used #pragma GCC target, add the
     675              :      options to the attribute((target(...))) list.  */
     676   1942650584 :   if (TREE_CODE (*node) == FUNCTION_DECL
     677   1177474140 :       && current_target_pragma
     678   1967711093 :       && targetm.target_option.valid_attribute_p (*node,
     679              :                                                   get_identifier ("target"),
     680              :                                                   current_target_pragma, 0))
     681              :     {
     682     25060509 :       tree cur_attr = lookup_attribute ("target", attributes);
     683     25060509 :       tree opts = copy_list (current_target_pragma);
     684              : 
     685     25060509 :       if (! cur_attr)
     686     25060508 :         attributes = tree_cons (get_identifier ("target"), opts, attributes);
     687              :       else
     688            1 :         TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
     689              :     }
     690              : 
     691              :   /* A "naked" function attribute implies "noinline" and "noclone" for
     692              :      those targets that support it.  */
     693   1942650584 :   if (TREE_CODE (*node) == FUNCTION_DECL
     694   1177474140 :       && attributes
     695    585687334 :       && lookup_attribute ("naked", attributes) != NULL
     696           79 :       && lookup_attribute_spec (get_identifier ("naked"))
     697   1942650663 :       && lookup_attribute ("noipa", attributes) == NULL)
     698           79 :         attributes = tree_cons (get_identifier ("noipa"), NULL, attributes);
     699              : 
     700              :   /* A "noipa" function attribute implies "noinline", "noclone" and "no_icf"
     701              :      for those targets that support it.  */
     702   1942650584 :   if (TREE_CODE (*node) == FUNCTION_DECL
     703   1177474140 :       && attributes
     704    585687334 :       && lookup_attribute ("noipa", attributes) != NULL
     705   1942673375 :       && lookup_attribute_spec (get_identifier ("noipa")))
     706              :     {
     707        22791 :       if (lookup_attribute ("noinline", attributes) == NULL)
     708        21882 :         attributes = tree_cons (get_identifier ("noinline"), NULL, attributes);
     709              : 
     710        22791 :       if (lookup_attribute ("noclone", attributes) == NULL)
     711        22451 :         attributes = tree_cons (get_identifier ("noclone"),  NULL, attributes);
     712              : 
     713        22791 :       if (lookup_attribute ("no_icf", attributes) == NULL)
     714        22781 :         attributes = tree_cons (get_identifier ("no_icf"),  NULL, attributes);
     715              :     }
     716              : 
     717   1942650584 :   targetm.insert_attributes (*node, &attributes);
     718              : 
     719              :   /* Note that attributes on the same declaration are not necessarily
     720              :      in the same order as in the source.  */
     721   3593571921 :   for (tree attr = attributes; attr; attr = TREE_CHAIN (attr))
     722              :     {
     723   1650921338 :       tree ns = get_attribute_namespace (attr);
     724   1650921338 :       tree name = get_attribute_name (attr);
     725   1650921338 :       tree args = TREE_VALUE (attr);
     726   1650921338 :       tree *anode = node;
     727   1650921338 :       const struct attribute_spec *spec
     728   1650921338 :         = lookup_scoped_attribute_spec (ns, name);
     729   1650921338 :       qualifier_set fn_ptr_quals {};
     730   1650921338 :       tree fn_ptr_tmp = NULL_TREE;
     731   1650921338 :       const bool cxx11_attr_p = cxx11_attribute_p (attr);
     732              : 
     733   1650921338 :       if (spec == NULL)
     734              :         {
     735      3208005 :           if (!(flags & (int) ATTR_FLAG_BUILT_IN)
     736      3208005 :               && !attr_namespace_ignored_p (ns))
     737              :             {
     738          583 :               if (ns == NULL_TREE || !cxx11_attr_p)
     739          206 :                 warning (OPT_Wattributes, "%qE attribute directive ignored",
     740              :                          name);
     741          186 :               else if ((flag_openmp || flag_openmp_simd)
     742          191 :                        && is_attribute_p ("omp", ns)
     743          191 :                        && is_attribute_p ("directive", name)
     744          568 :                        && (VAR_P (*node)
     745           20 :                            || TREE_CODE (*node) == FUNCTION_DECL))
     746      3228300 :                 continue;
     747              :               else
     748          194 :                 warning (OPT_Wattributes,
     749              :                          "%<%E::%E%> scoped attribute directive ignored",
     750              :                          ns, name);
     751              :             }
     752      3207821 :           continue;
     753              :         }
     754              :       else
     755              :         {
     756   1647713333 :           int nargs = list_length (args);
     757   1647713333 :           if (nargs < spec->min_length
     758   1647713299 :               || (spec->max_length >= 0
     759   1570052836 :                   && nargs > spec->max_length))
     760              :             {
     761           88 :               auto_diagnostic_group d;
     762           88 :               error ("wrong number of arguments specified for %qE attribute",
     763              :                      name);
     764           88 :               if (spec->max_length < 0)
     765            0 :                 inform (input_location, "expected %i or more, found %i",
     766            0 :                         spec->min_length, nargs);
     767           88 :               else if (spec->min_length == spec->max_length)
     768           45 :                 inform (input_location, "expected %i, found %i",
     769              :                         spec->min_length, nargs);
     770              :               else
     771           43 :                 inform (input_location, "expected between %i and %i, found %i",
     772              :                         spec->min_length, spec->max_length, nargs);
     773           88 :               continue;
     774           88 :             }
     775              :         }
     776   1647713245 :       gcc_assert (is_attribute_p (spec->name, name));
     777              : 
     778   1647713245 :       if (spec->decl_required && !DECL_P (*anode))
     779              :         {
     780        19047 :           if (flags & ((int) ATTR_FLAG_DECL_NEXT
     781              :                        | (int) ATTR_FLAG_FUNCTION_NEXT
     782              :                        | (int) ATTR_FLAG_ARRAY_NEXT))
     783              :             {
     784              :               /* Pass on this attribute to be tried again.  */
     785        18809 :               tree attr = tree_cons (name, args, NULL_TREE);
     786        18809 :               returned_attrs = chainon (returned_attrs, attr);
     787        18809 :               continue;
     788        18809 :             }
     789              :           else
     790              :             {
     791          238 :               warning (OPT_Wattributes, "%qE attribute does not apply to types",
     792              :                        name);
     793          238 :               continue;
     794              :             }
     795              :         }
     796              : 
     797              :       /* If we require a type, but were passed a decl, set up to make a
     798              :          new type and update the one in the decl.  ATTR_FLAG_TYPE_IN_PLACE
     799              :          would have applied if we'd been passed a type, but we cannot modify
     800              :          the decl's type in place here.  */
     801   1647694198 :       if (spec->type_required && DECL_P (*anode))
     802              :         {
     803    248556695 :           anode = &TREE_TYPE (*anode);
     804    248556695 :           flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
     805              :         }
     806              : 
     807   1647694198 :       if (spec->function_type_required
     808    247519031 :           && !FUNC_OR_METHOD_TYPE_P (*anode))
     809              :         {
     810          833 :           if (TREE_CODE (*anode) == POINTER_TYPE
     811          833 :               && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (*anode)))
     812              :             {
     813              :               /* OK, this is a bit convoluted.  We can't just make a copy
     814              :                  of the pointer type and modify its TREE_TYPE, because if
     815              :                  we change the attributes of the target type the pointer
     816              :                  type needs to have a different TYPE_MAIN_VARIANT.  So we
     817              :                  pull out the target type now, frob it as appropriate, and
     818              :                  rebuild the pointer type later.
     819              : 
     820              :                  This would all be simpler if attributes were part of the
     821              :                  declarator, grumble grumble.  */
     822          298 :               fn_ptr_tmp = TREE_TYPE (*anode);
     823          298 :               fn_ptr_quals = TYPE_QUALS (*anode);
     824          298 :               anode = &fn_ptr_tmp;
     825          298 :               flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
     826              :             }
     827          535 :           else if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
     828              :             {
     829              :               /* Pass on this attribute to be tried again.  */
     830          461 :               tree attr = tree_cons (name, args, NULL_TREE);
     831          461 :               returned_attrs = chainon (returned_attrs, attr);
     832          461 :               continue;
     833          461 :             }
     834              : 
     835          446 :           if (TREE_CODE (*anode) != FUNCTION_TYPE
     836          372 :               && TREE_CODE (*anode) != METHOD_TYPE)
     837              :             {
     838           74 :               warning (OPT_Wattributes,
     839              :                        "%qE attribute only applies to function types",
     840              :                        name);
     841           74 :               continue;
     842              :             }
     843              :         }
     844              : 
     845   1647693702 :       if (TYPE_P (*anode)
     846    250279830 :           && (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
     847   1648233141 :           && COMPLETE_TYPE_P (*anode))
     848              :         {
     849           39 :           warning (OPT_Wattributes, "type attributes ignored after type is already defined");
     850           39 :           continue;
     851              :         }
     852              : 
     853   1647693624 :       bool no_add_attrs = false;
     854              : 
     855              :       /* Check for exclusions with other attributes on the current
     856              :          declaration as well as the last declaration of the same
     857              :          symbol already processed (if one exists).  Detect and
     858              :          reject incompatible attributes.  */
     859   1647693624 :       bool built_in = flags & ATTR_FLAG_BUILT_IN;
     860   1647693624 :       if (spec->exclude
     861    355696801 :           && (flag_checking || !built_in)
     862   2003370834 :           && !error_operand_p (last_decl))
     863              :         {
     864              :           /* Always check attributes on user-defined functions.
     865              :              Check them on built-ins only when -fchecking is set.
     866              :              Ignore __builtin_unreachable -- it's both const and
     867              :              noreturn.  */
     868              : 
     869    355677209 :           if (!built_in
     870    239053829 :               || !DECL_P (*anode)
     871    234109983 :               || DECL_BUILT_IN_CLASS (*anode) != BUILT_IN_NORMAL
     872    589787192 :               || (DECL_FUNCTION_CODE (*anode) != BUILT_IN_UNREACHABLE
     873    233404952 :                   && DECL_FUNCTION_CODE (*anode) != BUILT_IN_UNREACHABLE_TRAP
     874    232699936 :                   && (DECL_FUNCTION_CODE (*anode)
     875              :                       != BUILT_IN_UBSAN_HANDLE_BUILTIN_UNREACHABLE)))
     876              :             {
     877    354225123 :               bool no_add = diag_attr_exclusions (last_decl, *anode, name, spec);
     878    354225123 :               if (!no_add && anode != node)
     879      5407261 :                 no_add = diag_attr_exclusions (last_decl, *node, name, spec);
     880    354225123 :               no_add_attrs |= no_add;
     881              :             }
     882              :         }
     883              : 
     884   1647694211 :       if (no_add_attrs
     885              :           /* Don't add attributes registered just for -Wno-attributes=foo::bar
     886              :              purposes.  */
     887   1647693624 :           || attribute_ignored_p (attr))
     888          587 :         continue;
     889              : 
     890   1647693037 :       if (spec->handler != NULL)
     891              :         {
     892   1647430787 :           int cxx11_flag = (cxx11_attr_p ? ATTR_FLAG_CXX11 : 0);
     893              : 
     894              :           /* Pass in an array of the current declaration followed
     895              :              by the last pushed/merged declaration if one exists.
     896              :              For calls that modify the type attributes of a DECL
     897              :              and for which *ANODE is *NODE's type, also pass in
     898              :              the DECL as the third element to use in diagnostics.
     899              :              If the handler changes CUR_AND_LAST_DECL[0] replace
     900              :              *ANODE with its value.  */
     901   1647430787 :           tree cur_and_last_decl[3] = { *anode, last_decl };
     902   1647430787 :           if (anode != node && DECL_P (*node))
     903    248304460 :             cur_and_last_decl[2] = *node;
     904              : 
     905   1647430787 :           tree ret = (spec->handler) (cur_and_last_decl, name, args,
     906              :                                       flags|cxx11_flag, &no_add_attrs);
     907              : 
     908              :           /* Fix up typedefs clobbered by attribute handlers.  */
     909   1647430787 :           if (TREE_CODE (*node) == TYPE_DECL
     910       854203 :               && anode == &TREE_TYPE (*node)
     911       577271 :               && DECL_ORIGINAL_TYPE (*node)
     912         2277 :               && TYPE_NAME (*anode) == *node
     913   1647430791 :               && TYPE_NAME (cur_and_last_decl[0]) != *node)
     914              :             {
     915            4 :               tree t = cur_and_last_decl[0];
     916            4 :               DECL_ORIGINAL_TYPE (*node) = t;
     917            4 :               tree tt = build_variant_type_copy (t);
     918            4 :               cur_and_last_decl[0] = tt;
     919            4 :               TREE_TYPE (*node) = tt;
     920            4 :               TYPE_NAME (tt) = *node;
     921              :             }
     922              : 
     923   1647430787 :           if (*anode != cur_and_last_decl[0])
     924              :             {
     925              :               /* Even if !spec->function_type_required, allow the attribute
     926              :                  handler to request the attribute to be applied to the function
     927              :                  type, rather than to the function pointer type, by setting
     928              :                  cur_and_last_decl[0] to the function type.  */
     929      1745982 :               if (!fn_ptr_tmp
     930      1745964 :                   && POINTER_TYPE_P (*anode)
     931        10800 :                   && TREE_TYPE (*anode) == cur_and_last_decl[0]
     932      1746116 :                   && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (*anode)))
     933              :                 {
     934          134 :                   fn_ptr_tmp = TREE_TYPE (*anode);
     935          134 :                   fn_ptr_quals = TYPE_QUALS (*anode);
     936          134 :                   anode = &fn_ptr_tmp;
     937              :                 }
     938      1745982 :               *anode = cur_and_last_decl[0];
     939              :             }
     940              : 
     941   1647430787 :           if (ret == error_mark_node)
     942              :             {
     943          302 :               warning (OPT_Wattributes, "%qE attribute ignored", name);
     944          302 :               no_add_attrs = true;
     945              :             }
     946              :           else
     947   1647430485 :             returned_attrs = chainon (ret, returned_attrs);
     948              :         }
     949              : 
     950              :       /* Layout the decl in case anything changed.  */
     951   1647693037 :       if (spec->type_required && DECL_P (*node)
     952              :           && (VAR_P (*node)
     953              :               || TREE_CODE (*node) == PARM_DECL
     954              :               || TREE_CODE (*node) == RESULT_DECL))
     955         3457 :         relayout_decl (*node);
     956              : 
     957   1647693037 :       if (!no_add_attrs)
     958              :         {
     959   1643897568 :           tree old_attrs;
     960   1643897568 :           tree a;
     961              : 
     962   1643897568 :           if (DECL_P (*anode))
     963   1396930174 :             old_attrs = DECL_ATTRIBUTES (*anode);
     964              :           else
     965    246967394 :             old_attrs = TYPE_ATTRIBUTES (*anode);
     966              : 
     967   1643897568 :           for (a = find_same_attribute (attr, old_attrs);
     968   1650958708 :                a != NULL_TREE;
     969      7061140 :                a = find_same_attribute (attr, TREE_CHAIN (a)))
     970     13133974 :             if (attribute_value_equal (a, attr))
     971              :               break;
     972              : 
     973   1643897568 :           if (a == NULL_TREE)
     974              :             {
     975              :               /* This attribute isn't already in the list.  */
     976   1637824734 :               tree r;
     977              :               /* Preserve the C++11 form.  */
     978   1637824734 :               if (cxx11_attr_p)
     979     19005157 :                 r = tree_cons (build_tree_list (ns, name), args, old_attrs);
     980              :               else
     981   1618819577 :                 r = tree_cons (name, args, old_attrs);
     982              : 
     983   1637824734 :               if (DECL_P (*anode))
     984   1390857660 :                 DECL_ATTRIBUTES (*anode) = r;
     985    246967074 :               else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
     986              :                 {
     987       256263 :                   TYPE_ATTRIBUTES (*anode) = r;
     988              :                   /* If this is the main variant, also push the attributes
     989              :                      out to the other variants.  */
     990       256263 :                   if (*anode == TYPE_MAIN_VARIANT (*anode))
     991              :                     {
     992       630007 :                       for (tree variant = *anode; variant;
     993       373744 :                            variant = TYPE_NEXT_VARIANT (variant))
     994              :                         {
     995       373744 :                           if (TYPE_ATTRIBUTES (variant) == old_attrs)
     996       234962 :                             TYPE_ATTRIBUTES (variant)
     997       117481 :                               = TYPE_ATTRIBUTES (*anode);
     998       256263 :                           else if (!find_same_attribute
     999       256263 :                                    (attr, TYPE_ATTRIBUTES (variant)))
    1000            0 :                             TYPE_ATTRIBUTES (variant) = tree_cons
    1001            0 :                               (name, args, TYPE_ATTRIBUTES (variant));
    1002              :                         }
    1003              :                     }
    1004              :                 }
    1005              :               else
    1006    246710811 :                 *anode = build_type_attribute_variant (*anode, r);
    1007              :             }
    1008              :         }
    1009              : 
    1010   1647693037 :       if (fn_ptr_tmp)
    1011              :         {
    1012              :           /* Rebuild the function pointer type and put it in the
    1013              :              appropriate place.  */
    1014          432 :           fn_ptr_tmp = build_pointer_type (fn_ptr_tmp);
    1015          432 :           if (fn_ptr_quals)
    1016           22 :             fn_ptr_tmp = build_qualified_type (fn_ptr_tmp, fn_ptr_quals);
    1017          432 :           if (DECL_P (*node))
    1018          413 :             TREE_TYPE (*node) = fn_ptr_tmp;
    1019              :           else
    1020              :             {
    1021           19 :               gcc_assert (TREE_CODE (*node) == POINTER_TYPE);
    1022           19 :               *node = fn_ptr_tmp;
    1023              :             }
    1024              :         }
    1025              :     }
    1026              : 
    1027   1942650583 :   return returned_attrs;
    1028   1942650583 : }
    1029              : 
    1030              : /* Return TRUE iff ATTR has been parsed by the front-end as a C++-11
    1031              :    attribute.
    1032              : 
    1033              :    When G++ parses a C++11 attribute, it is represented as
    1034              :    a TREE_LIST which TREE_PURPOSE is itself a TREE_LIST.  TREE_PURPOSE
    1035              :    (TREE_PURPOSE (ATTR)) is the namespace of the attribute, and the
    1036              :    TREE_VALUE (TREE_PURPOSE (ATTR)) is its non-qualified name.  Please
    1037              :    use get_attribute_namespace and get_attribute_name to retrieve the
    1038              :    namespace and name of the attribute, as these accessors work with
    1039              :    GNU attributes as well.  */
    1040              : 
    1041              : bool
    1042  35526071399 : cxx11_attribute_p (const_tree attr)
    1043              : {
    1044  35526071399 :   if (attr == NULL_TREE
    1045  35522645141 :       || TREE_CODE (attr) != TREE_LIST)
    1046              :     return false;
    1047              : 
    1048  35522645091 :   return (TREE_CODE (TREE_PURPOSE (attr)) == TREE_LIST);
    1049              : }
    1050              : 
    1051              : /* Return the name of the attribute ATTR.  This accessor works on GNU
    1052              :    and C++11 (scoped) attributes.
    1053              : 
    1054              :    Please read the comments of cxx11_attribute_p to understand the
    1055              :    format of attributes.  */
    1056              : 
    1057              : tree
    1058  29650729312 : get_attribute_name (const_tree attr)
    1059              : {
    1060  29650729312 :   if (cxx11_attribute_p (attr))
    1061   1431659649 :     return TREE_VALUE (TREE_PURPOSE (attr));
    1062  28219069663 :   return TREE_PURPOSE (attr);
    1063              : }
    1064              : 
    1065              : /* Subroutine of set_method_tm_attributes.  Apply TM attribute ATTR
    1066              :    to the method FNDECL.  */
    1067              : 
    1068              : void
    1069         3576 : apply_tm_attr (tree fndecl, tree attr)
    1070              : {
    1071         3576 :   decl_attributes (&TREE_TYPE (fndecl), tree_cons (attr, NULL, NULL), 0);
    1072         3576 : }
    1073              : 
    1074              : /* Makes a function attribute of the form NAME(ARG_NAME) and chains
    1075              :    it to CHAIN.  */
    1076              : 
    1077              : tree
    1078          459 : make_attribute (string_slice name, string_slice arg_name, tree chain)
    1079              : {
    1080          459 :   tree attr_name = get_identifier_with_length (name.begin (), name.size ());
    1081          459 :   tree attr_arg_name = build_string (arg_name.size (), arg_name.begin ());
    1082          459 :   tree attr_args = tree_cons (NULL_TREE, attr_arg_name, NULL_TREE);
    1083          459 :   tree attr = tree_cons (attr_name, attr_args, chain);
    1084          459 :   return attr;
    1085              : }
    1086              : 
    1087              : /* Default implementation of TARGET_OPTION_FUNCTIONS_B_RESOLVABLE_FROM_A.
    1088              :    Used to check very basically if DECL_B is callable from DECL_A.
    1089              :    For now this checks if the version strings are the same.  */
    1090              : 
    1091              : bool
    1092          397 : functions_b_resolvable_from_a (tree decl_a, tree decl_b,
    1093              :                                tree base ATTRIBUTE_UNUSED)
    1094              : {
    1095          397 :   const char *attr_name = TARGET_HAS_FMV_TARGET_ATTRIBUTE
    1096              :                           ? "target"
    1097              :                           : "target_version";
    1098              : 
    1099          397 :   tree attr_a = lookup_attribute (attr_name, DECL_ATTRIBUTES (decl_a));
    1100          397 :   tree attr_b = lookup_attribute (attr_name, DECL_ATTRIBUTES (decl_b));
    1101              : 
    1102          397 :   gcc_assert (attr_b);
    1103          397 :   if (!attr_a)
    1104              :     return false;
    1105              : 
    1106           19 :   return attribute_value_equal (attr_a, attr_b);
    1107              : }
    1108              : 
    1109              : /* Comparator function to be used in qsort routine to sort attribute
    1110              :    specification strings to "target".  */
    1111              : 
    1112              : static int
    1113         7788 : attr_strcmp (const void *v1, const void *v2)
    1114              : {
    1115         7788 :   const char *c1 = *(char *const*)v1;
    1116         7788 :   const char *c2 = *(char *const*)v2;
    1117         7788 :   return strcmp (c1, c2);
    1118              : }
    1119              : 
    1120              : /* ARGLIST is the argument to target attribute.  This function tokenizes
    1121              :    the TARGET_CLONES_ATTR_SEPARATOR separated arguments, sorts them and
    1122              :    returns a string which is a unique identifier for the
    1123              :    TARGET_CLONES_ATTR_SEPARATOR separated arguments.  It also replaces
    1124              :    non-identifier characters "=,-" with "_".  */
    1125              : 
    1126              : char *
    1127        38135 : sorted_attr_string (tree arglist)
    1128              : {
    1129        38135 :   tree arg;
    1130        38135 :   size_t str_len_sum = 0;
    1131        38135 :   char **args = NULL;
    1132        38135 :   char *attr_str, *ret_str;
    1133        38135 :   char *attr = NULL;
    1134        38135 :   unsigned int argnum = 1;
    1135        38135 :   unsigned int i;
    1136        38135 :   static const char separator_str[] = { TARGET_CLONES_ATTR_SEPARATOR, 0 };
    1137              : 
    1138        76288 :   for (arg = arglist; arg; arg = TREE_CHAIN (arg))
    1139              :     {
    1140        38153 :       const char *str = TREE_STRING_POINTER (TREE_VALUE (arg));
    1141        38153 :       size_t len = strlen (str);
    1142        38153 :       str_len_sum += len + 1;
    1143        38153 :       if (arg != arglist)
    1144           18 :         argnum++;
    1145       371589 :       for (i = 0; i < strlen (str); i++)
    1146       333436 :         if (str[i] == TARGET_CLONES_ATTR_SEPARATOR)
    1147         1929 :           argnum++;
    1148              :     }
    1149              : 
    1150        38135 :   attr_str = XNEWVEC (char, str_len_sum);
    1151        38135 :   str_len_sum = 0;
    1152       114423 :   for (arg = arglist; arg; arg = TREE_CHAIN (arg))
    1153              :     {
    1154        38153 :       const char *str = TREE_STRING_POINTER (TREE_VALUE (arg));
    1155        38153 :       size_t len = strlen (str);
    1156        38153 :       memcpy (attr_str + str_len_sum, str, len);
    1157        76306 :       attr_str[str_len_sum + len]
    1158        38153 :         = TREE_CHAIN (arg) ? TARGET_CLONES_ATTR_SEPARATOR : '\0';
    1159        38153 :       str_len_sum += len + 1;
    1160              :     }
    1161              : 
    1162              :   /* Replace "=,-" with "_".  */
    1163       371589 :   for (i = 0; i < strlen (attr_str); i++)
    1164       333454 :     if (attr_str[i] == '=' || attr_str[i]== '-')
    1165        19436 :       attr_str[i] = '_';
    1166              : 
    1167        38135 :   if (argnum == 1)
    1168              :     return attr_str;
    1169              : 
    1170         1947 :   args = XNEWVEC (char *, argnum);
    1171              : 
    1172         1947 :   i = 0;
    1173         1947 :   attr = strtok (attr_str, separator_str);
    1174         7788 :   while (attr != NULL)
    1175              :     {
    1176         3894 :       args[i] = attr;
    1177         3894 :       i++;
    1178         3894 :       attr = strtok (NULL, separator_str);
    1179              :     }
    1180              : 
    1181         1947 :   qsort (args, argnum, sizeof (char *), attr_strcmp);
    1182              : 
    1183         1947 :   ret_str = XNEWVEC (char, str_len_sum);
    1184         1947 :   str_len_sum = 0;
    1185         7788 :   for (i = 0; i < argnum; i++)
    1186              :     {
    1187         3894 :       size_t len = strlen (args[i]);
    1188         3894 :       memcpy (ret_str + str_len_sum, args[i], len);
    1189         3894 :       ret_str[str_len_sum + len] = i < argnum - 1 ? '_' : '\0';
    1190         3894 :       str_len_sum += len + 1;
    1191              :     }
    1192              : 
    1193         1947 :   XDELETEVEC (args);
    1194         1947 :   XDELETEVEC (attr_str);
    1195         1947 :   return ret_str;
    1196              : }
    1197              : 
    1198              : /* Make a dispatcher declaration for the multi-versioned function DECL.
    1199              :    Calls to DECL function will be replaced with calls to the dispatcher
    1200              :    by the front-end.  Return the decl created.  */
    1201              : 
    1202              : tree
    1203          207 : make_dispatcher_decl (const tree decl)
    1204              : {
    1205          207 :   tree fn_type = TREE_TYPE (decl);
    1206          207 :   tree func_type = build_function_type (TREE_TYPE (fn_type),
    1207          207 :                                         TYPE_ARG_TYPES (fn_type));
    1208          207 :   tree func_decl = build_fn_decl (IDENTIFIER_POINTER (DECL_NAME (decl)),
    1209              :                                   func_type);
    1210              : 
    1211          207 :   TREE_USED (func_decl) = 1;
    1212          207 :   DECL_CONTEXT (func_decl) = NULL_TREE;
    1213          207 :   DECL_INITIAL (func_decl) = error_mark_node;
    1214          207 :   DECL_ARTIFICIAL (func_decl) = 1;
    1215              :   /* Mark this func as external, the resolver will flip it again if
    1216              :      it gets generated.  */
    1217          207 :   DECL_EXTERNAL (func_decl) = 1;
    1218              :   /* This will be of type IFUNCs have to be externally visible.  */
    1219          207 :   TREE_PUBLIC (func_decl) = 1;
    1220          207 :   TREE_NOTHROW (func_decl) = TREE_NOTHROW (decl);
    1221              : 
    1222              :   /* Set the decl name to avoid graph_node re-mangling it.  */
    1223          207 :   SET_DECL_ASSEMBLER_NAME (func_decl, DECL_ASSEMBLER_NAME (decl));
    1224              : 
    1225          207 :   cgraph_node *node = cgraph_node::get (decl);
    1226          207 :   gcc_assert (node);
    1227          207 :   cgraph_function_version_info *node_v = node->function_version ();
    1228          207 :   gcc_assert (node_v);
    1229              : 
    1230              :   /* Set flags on the cgraph_node for the new decl.  */
    1231          207 :   cgraph_node *func_node = cgraph_node::get_create (func_decl);
    1232          207 :   func_node->dispatcher_function = true;
    1233              :   /* For targets with TARGET_HAS_FMV_TARGET_ATTRIBUTE, the resolver is created
    1234              :      unconditionally if any versioned nodes are present.
    1235              :      For !TARGET_HAS_FMV_TARGET_ATTRIBUTE, the dispatcher is only defined when
    1236              :      the default node is defined.  */
    1237          207 :   func_node->definition = node->definition || TARGET_HAS_FMV_TARGET_ATTRIBUTE;
    1238              : 
    1239          207 :   cgraph_function_version_info *func_v
    1240          207 :     = func_node->insert_new_function_version ();
    1241          207 :   func_v->next = node_v;
    1242          207 :   func_v->assembler_name = node_v->assembler_name;
    1243              : 
    1244              :   /* If the default node is from a target_clone, mark the dispatcher as from
    1245              :      target_clone.  */
    1246          207 :   func_node->is_target_clone = node->is_target_clone;
    1247              : 
    1248              :   /* Get the assembler name by mangling with the base assembler name.  */
    1249          207 :   tree id = targetm.mangle_decl_assembler_name
    1250          207 :     (func_decl, func_v->assembler_name);
    1251          207 :   symtab->change_decl_assembler_name (func_decl, id);
    1252              : 
    1253          207 :   return func_decl;
    1254              : }
    1255              : 
    1256              : /* Returns true if DECL a multiversioned default.
    1257              :    With the target attribute semantics, returns true if the function is marked
    1258              :    as default with the target version.
    1259              :    With the target_version attribute semantics, returns true if the function
    1260              :    is either not annotated, annotated as default, or is a target_clone
    1261              :    containing the default declaration.  */
    1262              : 
    1263              : bool
    1264         9820 : is_function_default_version (const tree decl)
    1265              : {
    1266         9820 :   tree attr;
    1267         9820 :   if (TREE_CODE (decl) != FUNCTION_DECL)
    1268              :     return false;
    1269         9820 :   if (TARGET_HAS_FMV_TARGET_ATTRIBUTE)
    1270              :     {
    1271         9820 :       if (!DECL_FUNCTION_VERSIONED (decl))
    1272              :         return false;
    1273         8738 :       attr = lookup_attribute ("target", DECL_ATTRIBUTES (decl));
    1274         8738 :       gcc_assert (attr);
    1275              :     }
    1276              :   else
    1277              :     {
    1278              :       if (lookup_attribute ("target_clones", DECL_ATTRIBUTES (decl)))
    1279              :         {
    1280              :           int num_defaults = 0;
    1281              :           get_clone_versions (decl, &num_defaults);
    1282              :           return num_defaults > 0;
    1283              :         }
    1284              : 
    1285              :       attr = lookup_attribute ("target_version", DECL_ATTRIBUTES (decl));
    1286              :       if (!attr)
    1287              :         return true;
    1288              :     }
    1289         8738 :   attr = TREE_VALUE (TREE_VALUE (attr));
    1290         8738 :   return (TREE_CODE (attr) == STRING_CST
    1291         8738 :           && strcmp (TREE_STRING_POINTER (attr), "default") == 0);
    1292              : }
    1293              : 
    1294              : /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
    1295              :    is ATTRIBUTE.  */
    1296              : 
    1297              : tree
    1298     53005290 : build_decl_attribute_variant (tree ddecl, tree attribute)
    1299              : {
    1300     53005290 :   DECL_ATTRIBUTES (ddecl) = attribute;
    1301     53005290 :   return ddecl;
    1302              : }
    1303              : 
    1304              : /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
    1305              :    is ATTRIBUTE and its qualifiers are QUALS.
    1306              : 
    1307              :    Record such modified types already made so we don't make duplicates.  */
    1308              : 
    1309              : tree
    1310    400414040 : build_type_attribute_qual_variant (tree otype, tree attribute,
    1311              :                                    qualifier_set quals)
    1312              : {
    1313    400414040 :   tree ttype = otype;
    1314    400414040 :   if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
    1315              :     {
    1316    258655108 :       tree ntype;
    1317              : 
    1318              :       /* Building a distinct copy of a tagged type is inappropriate; it
    1319              :          causes breakage in code that expects there to be a one-to-one
    1320              :          relationship between a struct and its fields.
    1321              :          build_duplicate_type is another solution (as used in
    1322              :          handle_transparent_union_attribute), but that doesn't play well
    1323              :          with the stronger C++ type identity model.  */
    1324    258655108 :       if (RECORD_OR_UNION_TYPE_P (ttype)
    1325    258655105 :           || TREE_CODE (ttype) == ENUMERAL_TYPE)
    1326              :         {
    1327            3 :           warning (OPT_Wattributes,
    1328              :                    "ignoring attributes applied to %qT after definition",
    1329            3 :                    TYPE_MAIN_VARIANT (ttype));
    1330            3 :           return build_qualified_type (ttype, quals);
    1331              :         }
    1332              : 
    1333    258655105 :       ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
    1334    258655105 :       if (lang_hooks.types.copy_lang_qualifiers
    1335    258655105 :           && otype != TYPE_MAIN_VARIANT (otype))
    1336      8905859 :         ttype = (lang_hooks.types.copy_lang_qualifiers
    1337      8905859 :                  (ttype, TYPE_MAIN_VARIANT (otype)));
    1338              : 
    1339    258655105 :       tree dtype = ntype = build_distinct_type_copy (ttype);
    1340              : 
    1341    258655105 :       TYPE_ATTRIBUTES (ntype) = attribute;
    1342              :       /* If the target-dependent attributes make NTYPE different from
    1343              :          its canonical type, we will need to use structural equality
    1344              :          checks for this type.
    1345              : 
    1346              :          We shouldn't get here for stripping attributes from a type;
    1347              :          the no-attribute type might not need structural comparison.  But
    1348              :          we can if was discarded from type_hash_table.  */
    1349    258655105 :       if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
    1350    258655105 :           || !comp_type_attributes (ntype, ttype))
    1351      5104658 :         SET_TYPE_STRUCTURAL_EQUALITY (ntype);
    1352              : 
    1353    258655105 :       hashval_t hash = type_hash_canon_hash (ntype);
    1354    258655105 :       ntype = type_hash_canon (hash, ntype);
    1355              : 
    1356    258655105 :       if (ntype != dtype)
    1357              :         /* This variant was already in the hash table, don't mess with
    1358              :            TYPE_CANONICAL.  */;
    1359     62196060 :       else if (TYPE_CANONICAL (ntype) == ntype)
    1360     59856517 :         TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
    1361              : 
    1362    258655105 :       ttype = build_qualified_type (ntype, quals);
    1363    258655105 :       if (lang_hooks.types.copy_lang_qualifiers
    1364    258655105 :           && otype != TYPE_MAIN_VARIANT (otype))
    1365      8905859 :         ttype = lang_hooks.types.copy_lang_qualifiers (ttype, otype);
    1366              :     }
    1367    141758932 :   else if (TYPE_QUALS (ttype) != quals)
    1368       897766 :     ttype = build_qualified_type (ttype, quals);
    1369              : 
    1370              :   return ttype;
    1371              : }
    1372              : 
    1373              : /* Compare two identifier nodes representing attributes.
    1374              :    Return true if they are the same, false otherwise.  */
    1375              : 
    1376              : static bool
    1377     76113950 : cmp_attrib_identifiers (const_tree attr1, const_tree attr2)
    1378              : {
    1379              :   /* Make sure we're dealing with IDENTIFIER_NODEs.  */
    1380     76113950 :   gcc_checking_assert (TREE_CODE (attr1) == IDENTIFIER_NODE
    1381              :                        && TREE_CODE (attr2) == IDENTIFIER_NODE);
    1382              : 
    1383              :   /* Identifiers can be compared directly for equality.  */
    1384     76113950 :   if (attr1 == attr2)
    1385              :     return true;
    1386              : 
    1387    115526809 :   return cmp_attribs (IDENTIFIER_POINTER (attr1), IDENTIFIER_LENGTH (attr1),
    1388     39412859 :                       IDENTIFIER_POINTER (attr2), IDENTIFIER_LENGTH (attr2));
    1389              : }
    1390              : 
    1391              : /* Compare two constructor-element-type constants.  Return 1 if the lists
    1392              :    are known to be equal; otherwise return 0.  */
    1393              : 
    1394              : bool
    1395     26981105 : simple_cst_list_equal (const_tree l1, const_tree l2)
    1396              : {
    1397     41078242 :   while (l1 != NULL_TREE && l2 != NULL_TREE)
    1398              :     {
    1399     29929312 :       if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
    1400              :         return false;
    1401              : 
    1402     14097137 :       l1 = TREE_CHAIN (l1);
    1403     14097137 :       l2 = TREE_CHAIN (l2);
    1404              :     }
    1405              : 
    1406     11148930 :   return l1 == l2;
    1407              : }
    1408              : 
    1409              : /* Check if "omp declare simd" attribute arguments, CLAUSES1 and CLAUSES2, are
    1410              :    the same.  */
    1411              : 
    1412              : static bool
    1413            0 : omp_declare_simd_clauses_equal (tree clauses1, tree clauses2)
    1414              : {
    1415            0 :   tree cl1, cl2;
    1416            0 :   for (cl1 = clauses1, cl2 = clauses2;
    1417            0 :        cl1 && cl2;
    1418            0 :        cl1 = OMP_CLAUSE_CHAIN (cl1), cl2 = OMP_CLAUSE_CHAIN (cl2))
    1419              :     {
    1420            0 :       if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_CODE (cl2))
    1421              :         return false;
    1422            0 :       if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_SIMDLEN)
    1423              :         {
    1424            0 :           if (simple_cst_equal (OMP_CLAUSE_DECL (cl1),
    1425            0 :                                 OMP_CLAUSE_DECL (cl2)) != 1)
    1426              :             return false;
    1427              :         }
    1428            0 :       switch (OMP_CLAUSE_CODE (cl1))
    1429              :         {
    1430            0 :         case OMP_CLAUSE_ALIGNED:
    1431            0 :           if (simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (cl1),
    1432            0 :                                 OMP_CLAUSE_ALIGNED_ALIGNMENT (cl2)) != 1)
    1433              :             return false;
    1434              :           break;
    1435            0 :         case OMP_CLAUSE_LINEAR:
    1436            0 :           if (simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (cl1),
    1437            0 :                                 OMP_CLAUSE_LINEAR_STEP (cl2)) != 1)
    1438              :             return false;
    1439              :           break;
    1440            0 :         case OMP_CLAUSE_SIMDLEN:
    1441            0 :           if (simple_cst_equal (OMP_CLAUSE_SIMDLEN_EXPR (cl1),
    1442            0 :                                 OMP_CLAUSE_SIMDLEN_EXPR (cl2)) != 1)
    1443              :             return false;
    1444            0 :           if (OMP_CLAUSE_SIMDLEN_TYPE (cl1) != OMP_CLAUSE_SIMDLEN_TYPE (cl2))
    1445              :             return false;
    1446            0 :           if ((OMP_CLAUSE_SIMDLEN_DIVISOR (cl1) == NULL_TREE)
    1447            0 :               != (OMP_CLAUSE_SIMDLEN_DIVISOR (cl2) == NULL_TREE)
    1448            0 :               || (OMP_CLAUSE_SIMDLEN_DIVISOR (cl1)
    1449            0 :                   && simple_cst_equal (OMP_CLAUSE_SIMDLEN_DIVISOR (cl1),
    1450            0 :                                        OMP_CLAUSE_SIMDLEN_DIVISOR (cl2)) != 1))
    1451              :             return false;
    1452              :         default:
    1453              :           break;
    1454              :         }
    1455              :     }
    1456              :   return true;
    1457              : }
    1458              : 
    1459              : 
    1460              : /* Compare two attributes for their value identity.  Return true if the
    1461              :    attribute values are known to be equal; otherwise return false.  */
    1462              : 
    1463              : bool
    1464     49397445 : attribute_value_equal (const_tree attr1, const_tree attr2)
    1465              : {
    1466     49397445 :   if (TREE_VALUE (attr1) == TREE_VALUE (attr2))
    1467              :     return true;
    1468              : 
    1469     33568552 :   if (TREE_VALUE (attr1) != NULL_TREE
    1470     31300917 :       && TREE_CODE (TREE_VALUE (attr1)) == TREE_LIST
    1471     31300902 :       && TREE_VALUE (attr2) != NULL_TREE
    1472     63281195 :       && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST)
    1473              :     {
    1474     29712643 :       if (ATTR_UNIQUE_VALUE_P (TREE_VALUE (attr1))
    1475     29712643 :           || ATTR_UNIQUE_VALUE_P (TREE_VALUE (attr2)))
    1476              :         return false;
    1477              : 
    1478              :       /* Handle attribute format.  */
    1479     29711681 :       if (is_attribute_p ("format", get_attribute_name (attr1)))
    1480              :         {
    1481      3180290 :           attr1 = TREE_VALUE (attr1);
    1482      3180290 :           attr2 = TREE_VALUE (attr2);
    1483              :           /* Compare the archetypes (printf/scanf/strftime/...).  */
    1484      3180290 :           if (!cmp_attrib_identifiers (TREE_VALUE (attr1), TREE_VALUE (attr2)))
    1485              :             return false;
    1486              :           /* Archetypes are the same.  Compare the rest.  */
    1487       443158 :           return (simple_cst_list_equal (TREE_CHAIN (attr1),
    1488       886316 :                                          TREE_CHAIN (attr2)) == 1);
    1489              :         }
    1490     53062782 :       return (simple_cst_list_equal (TREE_VALUE (attr1),
    1491     53062782 :                                      TREE_VALUE (attr2)) == 1);
    1492              :     }
    1493              : 
    1494      3855909 :   if (TREE_VALUE (attr1)
    1495      1588274 :       && TREE_CODE (TREE_VALUE (attr1)) == OMP_CLAUSE
    1496            0 :       && TREE_VALUE (attr2)
    1497      3855909 :       && TREE_CODE (TREE_VALUE (attr2)) == OMP_CLAUSE)
    1498            0 :     return omp_declare_simd_clauses_equal (TREE_VALUE (attr1),
    1499            0 :                                            TREE_VALUE (attr2));
    1500              : 
    1501      3855909 :   return (simple_cst_equal (TREE_VALUE (attr1), TREE_VALUE (attr2)) == 1);
    1502              : }
    1503              : 
    1504              : /* Return 0 if the attributes for two types are incompatible, 1 if they
    1505              :    are compatible, and 2 if they are nearly compatible (which causes a
    1506              :    warning to be generated).  */
    1507              : int
    1508   1166349306 : comp_type_attributes (const_tree type1, const_tree type2)
    1509              : {
    1510   1166349306 :   const_tree a1 = TYPE_ATTRIBUTES (type1);
    1511   1166349306 :   const_tree a2 = TYPE_ATTRIBUTES (type2);
    1512   1166349306 :   const_tree a;
    1513              : 
    1514   1166349306 :   if (a1 == a2)
    1515              :     return 1;
    1516    578145499 :   for (a = a1; a != NULL_TREE; a = TREE_CHAIN (a))
    1517              :     {
    1518    303409355 :       const struct attribute_spec *as;
    1519    303409355 :       const_tree attr;
    1520              : 
    1521    303409355 :       as = lookup_attribute_spec (TREE_PURPOSE (a));
    1522    303409355 :       if (!as || as->affects_type_identity == false)
    1523    301850866 :         continue;
    1524              : 
    1525      1558489 :       attr = find_same_attribute (a, const_cast<tree> (a2));
    1526      1558489 :       if (!attr || !attribute_value_equal (a, attr))
    1527              :         break;
    1528              :     }
    1529    276292303 :   if (!a)
    1530              :     {
    1531    312949267 :       for (a = a2; a != NULL_TREE; a = TREE_CHAIN (a))
    1532              :         {
    1533     38218782 :           const struct attribute_spec *as;
    1534              : 
    1535     38218782 :           as = lookup_attribute_spec (TREE_PURPOSE (a));
    1536     38218782 :           if (!as || as->affects_type_identity == false)
    1537     38210793 :             continue;
    1538              : 
    1539         7989 :           if (!find_same_attribute (a, const_cast<tree> (a1)))
    1540              :             break;
    1541              :           /* We don't need to compare trees again, as we did this
    1542              :              already in first loop.  */
    1543              :         }
    1544              :       /* All types - affecting identity - are equal, so
    1545              :          there is no need to call target hook for comparison.  */
    1546    274736144 :       if (!a)
    1547              :         return 1;
    1548              :     }
    1549      1561818 :   if (lookup_attribute ("transaction_safe", const_cast<tree> (a)))
    1550              :     return 0;
    1551      1557896 :   if ((lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (type1)) != NULL)
    1552      1557896 :       ^ (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (type2)) != NULL))
    1553              :     return 0;
    1554      1557725 :   int strub_ret = strub_comptypes (const_cast<tree> (type1),
    1555              :                                    const_cast<tree> (type2));
    1556      1557725 :   if (strub_ret == 0)
    1557              :     return strub_ret;
    1558              :   /* As some type combinations - like default calling-convention - might
    1559              :      be compatible, we have to call the target hook to get the final result.  */
    1560      1555279 :   int target_ret = targetm.comp_type_attributes (type1, type2);
    1561      1555279 :   if (target_ret == 0)
    1562              :     return target_ret;
    1563       756301 :   if (strub_ret == 2 || target_ret == 2)
    1564              :     return 2;
    1565       754390 :   if (strub_ret == 1 && target_ret == 1)
    1566              :     return 1;
    1567            0 :   gcc_unreachable ();
    1568              : }
    1569              : 
    1570              : /* PREDICATE acts as a function of type:
    1571              : 
    1572              :      (const_tree attr, const attribute_spec *as) -> bool
    1573              : 
    1574              :    where ATTR is an attribute and AS is its possibly-null specification.
    1575              :    Return a list of every attribute in attribute list ATTRS for which
    1576              :    PREDICATE is true.  Return ATTRS itself if PREDICATE returns true
    1577              :    for every attribute.  */
    1578              : 
    1579              : template<typename Predicate>
    1580              : tree
    1581       439679 : remove_attributes_matching (tree attrs, Predicate predicate)
    1582              : {
    1583       439679 :   tree new_attrs = NULL_TREE;
    1584       439679 :   tree *ptr = &new_attrs;
    1585       439679 :   const_tree start = attrs;
    1586       834213 :   for (const_tree attr = attrs; attr; attr = TREE_CHAIN (attr))
    1587              :     {
    1588       394534 :       const attribute_spec *as = lookup_attribute_spec (TREE_PURPOSE (attr));
    1589              :       const_tree end;
    1590       394534 :       if (!predicate (attr, as))
    1591       379820 :         end = attr;
    1592        14714 :       else if (start == attrs)
    1593        14714 :         continue;
    1594              :       else
    1595            0 :         end = TREE_CHAIN (attr);
    1596              : 
    1597       379820 :       for (; start != end; start = TREE_CHAIN (start))
    1598              :         {
    1599            0 :           *ptr = tree_cons (TREE_PURPOSE (start),
    1600            0 :                             TREE_VALUE (start), NULL_TREE);
    1601            0 :           TREE_CHAIN (*ptr) = NULL_TREE;
    1602            0 :           ptr = &TREE_CHAIN (*ptr);
    1603              :         }
    1604       379820 :       start = TREE_CHAIN (attr);
    1605              :     }
    1606       439679 :   gcc_assert (!start || start == attrs);
    1607       439679 :   return start ? attrs : new_attrs;
    1608              : }
    1609              : 
    1610              : /* If VALUE is true, return the subset of ATTRS that affect type identity,
    1611              :    otherwise return the subset of ATTRS that don't affect type identity.  */
    1612              : 
    1613              : tree
    1614       379818 : affects_type_identity_attributes (tree attrs, bool value)
    1615              : {
    1616       759638 :   auto predicate = [value](const_tree, const attribute_spec *as) -> bool
    1617              :     {
    1618       379820 :       return bool (as && as->affects_type_identity) == value;
    1619       379818 :     };
    1620       379818 :   return remove_attributes_matching (attrs, predicate);
    1621              : }
    1622              : 
    1623              : /* Remove attributes that affect type identity from ATTRS unless the
    1624              :    same attributes occur in OK_ATTRS.  */
    1625              : 
    1626              : tree
    1627        59861 : restrict_type_identity_attributes_to (tree attrs, tree ok_attrs)
    1628              : {
    1629        74575 :   auto predicate = [ok_attrs](const_tree attr,
    1630              :                               const attribute_spec *as) -> bool
    1631              :     {
    1632        14714 :       if (!as || !as->affects_type_identity)
    1633              :         return true;
    1634              : 
    1635            0 :       for (tree ok_attr = lookup_attribute (as->name, ok_attrs);
    1636            0 :            ok_attr;
    1637            0 :            ok_attr = lookup_attribute (as->name, TREE_CHAIN (ok_attr)))
    1638            0 :         if (simple_cst_equal (TREE_VALUE (ok_attr), TREE_VALUE (attr)) == 1)
    1639              :           return true;
    1640              : 
    1641              :       return false;
    1642        59861 :     };
    1643        59861 :   return remove_attributes_matching (attrs, predicate);
    1644              : }
    1645              : 
    1646              : /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
    1647              :    is ATTRIBUTE.
    1648              : 
    1649              :    Record such modified types already made so we don't make duplicates.  */
    1650              : 
    1651              : tree
    1652    391866416 : build_type_attribute_variant (tree ttype, tree attribute)
    1653              : {
    1654    391866416 :   return build_type_attribute_qual_variant (ttype, attribute,
    1655    391866416 :                                             TYPE_QUALS (ttype));
    1656              : }
    1657              : 
    1658              : /* A variant of lookup_attribute() that can be used with an identifier
    1659              :    as the first argument, and where the identifier can be either
    1660              :    'text' or '__text__'.
    1661              : 
    1662              :    Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
    1663              :    return a pointer to the attribute's list element if the attribute
    1664              :    is part of the list, or NULL_TREE if not found.  If the attribute
    1665              :    appears more than once, this only returns the first occurrence; the
    1666              :    TREE_CHAIN of the return value should be passed back in if further
    1667              :    occurrences are wanted.  ATTR_IDENTIFIER must be an identifier but
    1668              :    can be in the form 'text' or '__text__'.  */
    1669              : static tree
    1670    306302996 : lookup_ident_attribute (tree attr_identifier, tree list)
    1671              : {
    1672    306302996 :   gcc_checking_assert (TREE_CODE (attr_identifier) == IDENTIFIER_NODE);
    1673              : 
    1674    342978723 :   while (list)
    1675              :     {
    1676     72933660 :       gcc_checking_assert (TREE_CODE (get_attribute_name (list))
    1677              :                            == IDENTIFIER_NODE);
    1678              : 
    1679     72933660 :       if (cmp_attrib_identifiers (attr_identifier,
    1680     72933660 :                                   get_attribute_name (list)))
    1681              :         /* Found it.  */
    1682              :         break;
    1683     36675727 :       list = TREE_CHAIN (list);
    1684              :     }
    1685              : 
    1686    306302996 :   return list;
    1687              : }
    1688              : 
    1689              : /* Remove any instances of attribute ATTR_NAME in LIST and return the
    1690              :    modified list.  */
    1691              : 
    1692              : tree
    1693    121381828 : remove_attribute (const char *attr_name, tree list)
    1694              : {
    1695    121381828 :   tree *p;
    1696    121381828 :   gcc_checking_assert (attr_name[0] != '_');
    1697              : 
    1698    158057815 :   for (p = &list; *p;)
    1699              :     {
    1700     36675987 :       tree l = *p;
    1701              : 
    1702     36675987 :       tree attr = get_attribute_name (l);
    1703     36675987 :       if (is_attribute_p (attr_name, attr))
    1704         4225 :         *p = TREE_CHAIN (l);
    1705              :       else
    1706     36671762 :         p = &TREE_CHAIN (l);
    1707              :     }
    1708              : 
    1709    121381828 :   return list;
    1710              : }
    1711              : 
    1712              : /* Similarly but also match namespace on the removed attributes.
    1713              :    ATTR_NS "" stands for NULL or "gnu" namespace.  */
    1714              : 
    1715              : tree
    1716       484657 : remove_attribute (const char *attr_ns, const char *attr_name, tree list)
    1717              : {
    1718       484657 :   tree *p;
    1719       484657 :   gcc_checking_assert (attr_name[0] != '_');
    1720       484657 :   gcc_checking_assert (attr_ns == NULL || attr_ns[0] != '_');
    1721              : 
    1722       498025 :   for (p = &list; *p;)
    1723              :     {
    1724        13368 :       tree l = *p;
    1725              : 
    1726        13368 :       tree attr = get_attribute_name (l);
    1727        13368 :       if (is_attribute_p (attr_name, attr)
    1728        13368 :           && is_attribute_namespace_p (attr_ns, l))
    1729              :         {
    1730        12649 :           *p = TREE_CHAIN (l);
    1731        12649 :           continue;
    1732              :         }
    1733          719 :       p = &TREE_CHAIN (l);
    1734              :     }
    1735              : 
    1736       484657 :   return list;
    1737              : }
    1738              : 
    1739              : /* Return an attribute list that is the union of a1 and a2.  */
    1740              : 
    1741              : tree
    1742    203556184 : merge_attributes (tree a1, tree a2)
    1743              : {
    1744    203556184 :   tree attributes;
    1745              : 
    1746              :   /* Either one unset?  Take the set one.  */
    1747              : 
    1748    203556184 :   if ((attributes = a1) == 0)
    1749              :     attributes = a2;
    1750              : 
    1751              :   /* One that completely contains the other?  Take it.  */
    1752              : 
    1753     12233297 :   else if (a2 != 0 && ! attribute_list_contained (a1, a2))
    1754              :     {
    1755      1635385 :       if (attribute_list_contained (a2, a1))
    1756              :         attributes = a2;
    1757              :       else
    1758              :         {
    1759              :           /* Pick the longest list, and hang on the other list,
    1760              :              unless both lists contain ATTR_UNIQUE_VALUE_P values.
    1761              :              In that case a1 list needs to go after the a2 list
    1762              :              because attributes from a single declaration are stored
    1763              :              in reverse order of their declarations.  */
    1764              :           bool a1_unique_value_p = false, a2_unique_value_p = false;
    1765              :           tree aa1 = a1, aa2 = a2;
    1766      2823522 :           for (; aa1 && aa2; aa1 = TREE_CHAIN (aa1), aa2 = TREE_CHAIN (aa2))
    1767              :             {
    1768      1583317 :               if (!a1_unique_value_p
    1769      1583295 :                   && TREE_VALUE (aa1)
    1770       772992 :                   && TREE_CODE (TREE_VALUE (aa1)) == TREE_LIST
    1771      2356309 :                   && ATTR_UNIQUE_VALUE_P (TREE_VALUE (aa1)))
    1772              :                 a1_unique_value_p = true;
    1773      1583317 :               if (!a2_unique_value_p
    1774      1583295 :                   && TREE_VALUE (aa2)
    1775       817287 :                   && TREE_CODE (TREE_VALUE (aa2)) == TREE_LIST
    1776      2400588 :                   && ATTR_UNIQUE_VALUE_P (TREE_VALUE (aa2)))
    1777              :                 a2_unique_value_p = true;
    1778              :             }
    1779              : 
    1780      1240205 :           if (aa2 && (!a1_unique_value_p || !a2_unique_value_p))
    1781              :             {
    1782      1240205 :               attributes = a2;
    1783      1240205 :               a2 = a1;
    1784              :             }
    1785              : 
    1786      1240205 :           tree a3 = NULL_TREE, *pa = &a3;
    1787      2823532 :           for (; a2 != 0; a2 = TREE_CHAIN (a2))
    1788              :             {
    1789      1583327 :               tree a;
    1790      1583327 :               for (a = lookup_ident_attribute (get_attribute_name (a2),
    1791              :                                                attributes);
    1792      2137152 :                    a != NULL_TREE && !attribute_value_equal (a, a2);
    1793       553825 :                    a = lookup_ident_attribute (get_attribute_name (a2),
    1794       553825 :                                                TREE_CHAIN (a)))
    1795              :                 ;
    1796      1583327 :               if (a == NULL_TREE)
    1797              :                 {
    1798      1240827 :                   a1 = copy_node (a2);
    1799      1240827 :                   *pa = a1;
    1800      1240827 :                   pa = &TREE_CHAIN (a1);
    1801              :                 }
    1802              :             }
    1803      1240205 :           if (a3)
    1804              :             {
    1805      1240205 :               *pa = attributes;
    1806      1240205 :               attributes = a3;
    1807              :             }
    1808              :         }
    1809              :     }
    1810    203556184 :   return attributes;
    1811              : }
    1812              : 
    1813              : /* Given types T1 and T2, merge their attributes and return
    1814              :   the result.  */
    1815              : 
    1816              : tree
    1817    146181850 : merge_type_attributes (tree t1, tree t2)
    1818              : {
    1819    146181850 :   return merge_attributes (TYPE_ATTRIBUTES (t1),
    1820    146181850 :                            TYPE_ATTRIBUTES (t2));
    1821              : }
    1822              : 
    1823              : /* Given decls OLDDECL and NEWDECL, merge their attributes and return
    1824              :    the result.  */
    1825              : 
    1826              : tree
    1827     57297478 : merge_decl_attributes (tree olddecl, tree newdecl)
    1828              : {
    1829     57297478 :   return merge_attributes (DECL_ATTRIBUTES (olddecl),
    1830     57297478 :                            DECL_ATTRIBUTES (newdecl));
    1831              : }
    1832              : 
    1833              : /* Duplicate all attributes with name NAME in ATTR list to *ATTRS if
    1834              :    they are missing there.  */
    1835              : 
    1836              : void
    1837      8113517 : duplicate_one_attribute (tree *attrs, tree attr, const char *name)
    1838              : {
    1839      8113517 :   attr = lookup_attribute (name, attr);
    1840      8113517 :   if (!attr)
    1841              :     return;
    1842         9074 :   tree a = lookup_attribute (name, *attrs);
    1843        27222 :   while (attr)
    1844              :     {
    1845              :       tree a2;
    1846         9074 :       for (a2 = a; a2; a2 = lookup_attribute (name, TREE_CHAIN (a2)))
    1847            0 :         if (attribute_value_equal (attr, a2))
    1848              :           break;
    1849         9074 :       if (!a2)
    1850              :         {
    1851         9074 :           a2 = copy_node (attr);
    1852         9074 :           TREE_CHAIN (a2) = *attrs;
    1853         9074 :           *attrs = a2;
    1854              :         }
    1855         9074 :       attr = lookup_attribute (name, TREE_CHAIN (attr));
    1856              :     }
    1857              : }
    1858              : 
    1859              : /* Duplicate all attributes from user DECL to the corresponding
    1860              :    builtin that should be propagated.  */
    1861              : 
    1862              : void
    1863      8113476 : copy_attributes_to_builtin (tree decl)
    1864              : {
    1865      8113476 :   tree b = builtin_decl_explicit (DECL_FUNCTION_CODE (decl));
    1866      8113476 :   if (b)
    1867      8113476 :     duplicate_one_attribute (&DECL_ATTRIBUTES (b),
    1868      8113476 :                              DECL_ATTRIBUTES (decl), "omp declare simd");
    1869      8113476 : }
    1870              : 
    1871              : #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
    1872              : 
    1873              : /* Specialization of merge_decl_attributes for various Windows targets.
    1874              : 
    1875              :    This handles the following situation:
    1876              : 
    1877              :      __declspec (dllimport) int foo;
    1878              :      int foo;
    1879              : 
    1880              :    The second instance of `foo' nullifies the dllimport.  */
    1881              : 
    1882              : tree
    1883              : merge_dllimport_decl_attributes (tree old, tree new_tree)
    1884              : {
    1885              :   tree a;
    1886              :   int delete_dllimport_p = 1;
    1887              : 
    1888              :   /* What we need to do here is remove from `old' dllimport if it doesn't
    1889              :      appear in `new'.  dllimport behaves like extern: if a declaration is
    1890              :      marked dllimport and a definition appears later, then the object
    1891              :      is not dllimport'd.  We also remove a `new' dllimport if the old list
    1892              :      contains dllexport:  dllexport always overrides dllimport, regardless
    1893              :      of the order of declaration.  */
    1894              :   if (!VAR_OR_FUNCTION_DECL_P (new_tree))
    1895              :     delete_dllimport_p = 0;
    1896              :   else if (DECL_DLLIMPORT_P (new_tree)
    1897              :            && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
    1898              :     {
    1899              :       DECL_DLLIMPORT_P (new_tree) = 0;
    1900              :       warning (OPT_Wattributes, "%q+D already declared with dllexport "
    1901              :                "attribute: dllimport ignored", new_tree);
    1902              :     }
    1903              :   else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
    1904              :     {
    1905              :       /* Warn about overriding a symbol that has already been used, e.g.:
    1906              :            extern int __attribute__ ((dllimport)) foo;
    1907              :            int* bar () {return &foo;}
    1908              :            int foo;
    1909              :       */
    1910              :       if (TREE_USED (old))
    1911              :         {
    1912              :           warning (0, "%q+D redeclared without dllimport attribute "
    1913              :                    "after being referenced with dll linkage", new_tree);
    1914              :           /* If we have used a variable's address with dllimport linkage,
    1915              :               keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
    1916              :               decl may already have had TREE_CONSTANT computed.
    1917              :               We still remove the attribute so that assembler code refers
    1918              :               to '&foo rather than '_imp__foo'.  */
    1919              :           if (VAR_P (old) && TREE_ADDRESSABLE (old))
    1920              :             DECL_DLLIMPORT_P (new_tree) = 1;
    1921              :         }
    1922              : 
    1923              :       /* Let an inline definition silently override the external reference,
    1924              :          but otherwise warn about attribute inconsistency.  */
    1925              :       else if (VAR_P (new_tree) || !DECL_DECLARED_INLINE_P (new_tree))
    1926              :         warning (OPT_Wattributes, "%q+D redeclared without dllimport "
    1927              :                  "attribute: previous dllimport ignored", new_tree);
    1928              :     }
    1929              :   else
    1930              :     delete_dllimport_p = 0;
    1931              : 
    1932              :   a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
    1933              : 
    1934              :   if (delete_dllimport_p)
    1935              :     a = remove_attribute ("dllimport", a);
    1936              : 
    1937              :   return a;
    1938              : }
    1939              : 
    1940              : /* Handle a "dllimport" or "dllexport" attribute; arguments as in
    1941              :    struct attribute_spec.handler.  */
    1942              : 
    1943              : tree
    1944              : handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
    1945              :                       bool *no_add_attrs)
    1946              : {
    1947              :   tree node = *pnode;
    1948              :   bool is_dllimport;
    1949              : 
    1950              :   /* These attributes may apply to structure and union types being created,
    1951              :      but otherwise should pass to the declaration involved.  */
    1952              :   if (!DECL_P (node))
    1953              :     {
    1954              :       if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
    1955              :                    | (int) ATTR_FLAG_ARRAY_NEXT))
    1956              :         {
    1957              :           *no_add_attrs = true;
    1958              :           return tree_cons (name, args, NULL_TREE);
    1959              :         }
    1960              :       if (TREE_CODE (node) == RECORD_TYPE
    1961              :           || TREE_CODE (node) == UNION_TYPE)
    1962              :         {
    1963              :           node = TYPE_NAME (node);
    1964              :           if (!node)
    1965              :             return NULL_TREE;
    1966              :         }
    1967              :       else
    1968              :         {
    1969              :           warning (OPT_Wattributes, "%qE attribute ignored",
    1970              :                    name);
    1971              :           *no_add_attrs = true;
    1972              :           return NULL_TREE;
    1973              :         }
    1974              :     }
    1975              : 
    1976              :   if (!VAR_OR_FUNCTION_DECL_P (node) && TREE_CODE (node) != TYPE_DECL)
    1977              :     {
    1978              :       *no_add_attrs = true;
    1979              :       warning (OPT_Wattributes, "%qE attribute ignored",
    1980              :                name);
    1981              :       return NULL_TREE;
    1982              :     }
    1983              : 
    1984              :   if (TREE_CODE (node) == TYPE_DECL
    1985              :       && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
    1986              :       && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
    1987              :     {
    1988              :       *no_add_attrs = true;
    1989              :       warning (OPT_Wattributes, "%qE attribute ignored",
    1990              :                name);
    1991              :       return NULL_TREE;
    1992              :     }
    1993              : 
    1994              :   is_dllimport = is_attribute_p ("dllimport", name);
    1995              : 
    1996              :   /* Report error on dllimport ambiguities seen now before they cause
    1997              :      any damage.  */
    1998              :   if (is_dllimport)
    1999              :     {
    2000              :       /* Honor any target-specific overrides.  */
    2001              :       if (!targetm.valid_dllimport_attribute_p (node))
    2002              :         *no_add_attrs = true;
    2003              : 
    2004              :      else if (TREE_CODE (node) == FUNCTION_DECL
    2005              :               && DECL_DECLARED_INLINE_P (node))
    2006              :         {
    2007              :           warning (OPT_Wattributes, "inline function %q+D declared as "
    2008              :                   "dllimport: attribute ignored", node);
    2009              :           *no_add_attrs = true;
    2010              :         }
    2011              :       /* Like MS, treat definition of dllimported variables and
    2012              :          non-inlined functions on declaration as syntax errors.  */
    2013              :      else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
    2014              :         {
    2015              :           error ("function %q+D definition is marked dllimport", node);
    2016              :           *no_add_attrs = true;
    2017              :         }
    2018              : 
    2019              :      else if (VAR_P (node))
    2020              :         {
    2021              :           if (DECL_INITIAL (node))
    2022              :             {
    2023              :               error ("variable %q+D definition is marked dllimport", node);
    2024              :               *no_add_attrs = true;
    2025              :             }
    2026              : #if TARGET_WIN32_TLS
    2027              :           else if (DECL_THREAD_LOCAL_P (node))
    2028              :             {
    2029              :               error ("thread-local variable %q+D declared as dllimport", node);
    2030              :               *no_add_attrs = true;
    2031              :             }
    2032              : #endif
    2033              : 
    2034              :           /* `extern' needn't be specified with dllimport.
    2035              :              Specify `extern' now and hope for the best.  Sigh.  */
    2036              :           DECL_EXTERNAL (node) = 1;
    2037              :           /* Also, implicitly give dllimport'd variables declared within
    2038              :              a function global scope, unless declared static.  */
    2039              :           if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
    2040              :             TREE_PUBLIC (node) = 1;
    2041              :           /* Clear TREE_STATIC because DECL_EXTERNAL is set, unless
    2042              :              it is a C++ static data member.  */
    2043              :           if (DECL_CONTEXT (node) == NULL_TREE
    2044              :               || !RECORD_OR_UNION_TYPE_P (DECL_CONTEXT (node)))
    2045              :             TREE_STATIC (node) = 0;
    2046              :         }
    2047              : 
    2048              :       if (*no_add_attrs == false)
    2049              :         DECL_DLLIMPORT_P (node) = 1;
    2050              :     }
    2051              :   else if (TREE_CODE (node) == FUNCTION_DECL
    2052              :            && DECL_DECLARED_INLINE_P (node)
    2053              :            && flag_keep_inline_dllexport)
    2054              :     /* An exported function, even if inline, must be emitted.  */
    2055              :     DECL_EXTERNAL (node) = 0;
    2056              : #if TARGET_WIN32_TLS
    2057              :   else if (VAR_P (node) && DECL_THREAD_LOCAL_P (node))
    2058              :     {
    2059              :       error ("thread-local variable %q+D declared as dllexport", node);
    2060              :       *no_add_attrs = true;
    2061              :     }
    2062              : #endif
    2063              : 
    2064              :   /*  Report error if symbol is not accessible at global scope.  */
    2065              :   if (!TREE_PUBLIC (node) && VAR_OR_FUNCTION_DECL_P (node))
    2066              :     {
    2067              :       error ("external linkage required for symbol %q+D because of "
    2068              :              "%qE attribute", node, name);
    2069              :       *no_add_attrs = true;
    2070              :     }
    2071              : 
    2072              :   /* A dllexport'd entity must have default visibility so that other
    2073              :      program units (shared libraries or the main executable) can see
    2074              :      it.  A dllimport'd entity must have default visibility so that
    2075              :      the linker knows that undefined references within this program
    2076              :      unit can be resolved by the dynamic linker.  */
    2077              :   if (!*no_add_attrs)
    2078              :     {
    2079              :       if (DECL_VISIBILITY_SPECIFIED (node)
    2080              :           && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
    2081              :         error ("%qE implies default visibility, but %qD has already "
    2082              :                "been declared with a different visibility",
    2083              :                name, node);
    2084              :       DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
    2085              :       DECL_VISIBILITY_SPECIFIED (node) = 1;
    2086              :     }
    2087              : 
    2088              :   return NULL_TREE;
    2089              : }
    2090              : 
    2091              : #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES  */
    2092              : 
    2093              : /* Given two lists of attributes, return true if list l2 is
    2094              :    equivalent to l1.  */
    2095              : 
    2096              : int
    2097   5698265165 : attribute_list_equal (const_tree l1, const_tree l2)
    2098              : {
    2099   5698265165 :   if (l1 == l2)
    2100              :     return 1;
    2101              : 
    2102    457077160 :   return attribute_list_contained (l1, l2)
    2103    723005806 :          && attribute_list_contained (l2, l1);
    2104              : }
    2105              : 
    2106              : /* Given two lists of attributes, return true if list L2 is
    2107              :    completely contained within L1.  */
    2108              : /* ??? This would be faster if attribute names were stored in a canonicalized
    2109              :    form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
    2110              :    must be used to show these elements are equivalent (which they are).  */
    2111              : /* ??? It's not clear that attributes with arguments will always be handled
    2112              :    correctly.  */
    2113              : 
    2114              : int
    2115    656775291 : attribute_list_contained (const_tree l1, const_tree l2)
    2116              : {
    2117    656775291 :   const_tree t1, t2;
    2118              : 
    2119              :   /* First check the obvious, maybe the lists are identical.  */
    2120    656775291 :   if (l1 == l2)
    2121              :     return 1;
    2122              : 
    2123              :   /* Maybe the lists are similar.  */
    2124              :   for (t1 = l1, t2 = l2;
    2125   1060036366 :        t1 != 0 && t2 != 0
    2126    453893531 :        && get_attribute_name (t1) == get_attribute_name (t2)
    2127   1487951454 :        && TREE_VALUE (t1) == TREE_VALUE (t2);
    2128    403292180 :        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
    2129              :     ;
    2130              : 
    2131              :   /* Maybe the lists are equal.  */
    2132    656744186 :   if (t1 == 0 && t2 == 0)
    2133              :     return 1;
    2134              : 
    2135    304386763 :   for (; t2 != 0; t2 = TREE_CHAIN (t2))
    2136              :     {
    2137    289090015 :       const_tree attr;
    2138              :       /* This CONST_CAST is okay because lookup_attribute does not
    2139              :          modify its argument and the return value is assigned to a
    2140              :          const_tree.  */
    2141    289090015 :       for (attr = lookup_ident_attribute (get_attribute_name (t2),
    2142              :                                           const_cast<tree> (l1));
    2143    304165844 :            attr != NULL_TREE && !attribute_value_equal (t2, attr);
    2144     15075829 :            attr = lookup_ident_attribute (get_attribute_name (t2),
    2145     15075829 :                                           TREE_CHAIN (attr)))
    2146              :         ;
    2147              : 
    2148    289090015 :       if (attr == NULL_TREE)
    2149              :         return 0;
    2150              :     }
    2151              : 
    2152              :   return 1;
    2153              : }
    2154              : 
    2155              : /* The backbone of lookup_attribute().  ATTR_LEN is the string length
    2156              :    of ATTR_NAME, and LIST is not NULL_TREE.
    2157              : 
    2158              :    The function is called from lookup_attribute in order to optimize
    2159              :    for size.  */
    2160              : 
    2161              : tree
    2162  12986720505 : private_lookup_attribute (const char *attr_name, size_t attr_len, tree list)
    2163              : {
    2164  35244798554 :   while (list)
    2165              :     {
    2166  23889332083 :       tree attr = get_attribute_name (list);
    2167  23889332083 :       size_t ident_len = IDENTIFIER_LENGTH (attr);
    2168  23889332083 :       if (cmp_attribs (attr_name, attr_len, IDENTIFIER_POINTER (attr),
    2169              :                        ident_len))
    2170              :         break;
    2171  22258078049 :       list = TREE_CHAIN (list);
    2172              :     }
    2173              : 
    2174  12986720505 :   return list;
    2175              : }
    2176              : 
    2177              : /* Similarly but with also attribute namespace.  */
    2178              : 
    2179              : tree
    2180    928840830 : private_lookup_attribute (const char *attr_ns, const char *attr_name,
    2181              :                           size_t attr_ns_len, size_t attr_len, tree list)
    2182              : {
    2183   2312302386 :   while (list)
    2184              :     {
    2185   1396968346 :       tree attr = get_attribute_name (list);
    2186   1396968346 :       size_t ident_len = IDENTIFIER_LENGTH (attr);
    2187   1396968346 :       if (cmp_attribs (attr_name, attr_len, IDENTIFIER_POINTER (attr),
    2188              :                        ident_len))
    2189              :         {
    2190     13506884 :           tree ns = get_attribute_namespace (list);
    2191     13506884 :           if (ns == NULL_TREE)
    2192              :             {
    2193        13716 :               if (attr_ns_len == 0)
    2194              :                 break;
    2195              :             }
    2196     13493168 :           else if (attr_ns)
    2197              :             {
    2198     13493160 :               ident_len = IDENTIFIER_LENGTH (ns);
    2199     13493160 :               if (attr_ns_len == 0)
    2200              :                 {
    2201   2312397636 :                   if (cmp_attribs ("gnu", strlen ("gnu"),
    2202        95250 :                                    IDENTIFIER_POINTER (ns), ident_len))
    2203              :                     break;
    2204              :                 }
    2205   2325700296 :               else if (cmp_attribs (attr_ns, attr_ns_len,
    2206     13397910 :                                     IDENTIFIER_POINTER (ns), ident_len))
    2207              :                 break;
    2208              :             }
    2209              :         }
    2210   1383461556 :       list = TREE_CHAIN (list);
    2211              :     }
    2212              : 
    2213    928840830 :   return list;
    2214              : }
    2215              : 
    2216              : /* Return true if the function decl or type NODE has been declared
    2217              :    with attribute ANAME among attributes ATTRS.  */
    2218              : 
    2219              : static bool
    2220      1273735 : has_attribute (tree node, tree attrs, const char *aname)
    2221              : {
    2222      1273735 :   if (!strcmp (aname, "const"))
    2223              :     {
    2224         8906 :       if (DECL_P (node) && TREE_READONLY (node))
    2225              :         return true;
    2226              :     }
    2227      1264829 :   else if (!strcmp (aname, "malloc"))
    2228              :     {
    2229       261541 :       if (DECL_P (node) && DECL_IS_MALLOC (node))
    2230              :         return true;
    2231              :     }
    2232      1090496 :   else if (!strcmp (aname, "noreturn"))
    2233              :     {
    2234         8906 :       if (DECL_P (node) && TREE_THIS_VOLATILE (node))
    2235              :         return true;
    2236              :     }
    2237      1081590 :   else if (!strcmp (aname, "nothrow"))
    2238              :     {
    2239         8906 :       if (TREE_NOTHROW (node))
    2240              :         return true;
    2241              :     }
    2242      1072684 :   else if (!strcmp (aname, "pure"))
    2243              :     {
    2244        13360 :       if (DECL_P (node) && DECL_PURE_P (node))
    2245              :         return true;
    2246              :     }
    2247              : 
    2248      1272800 :   return lookup_attribute (aname, attrs);
    2249              : }
    2250              : 
    2251              : /* Return the number of mismatched function or type attributes between
    2252              :    the "template" function declaration TMPL and DECL.  The word "template"
    2253              :    doesn't necessarily refer to a C++ template but rather a declaration
    2254              :    whose attributes should be matched by those on DECL.  For a non-zero
    2255              :    return value append the names of the mismatcheed attributes to OUTATTRS.
    2256              :    ATTRLIST is a list of additional attributes that SPEC should be
    2257              :    taken to ultimately be declared with.  */
    2258              : 
    2259              : unsigned
    2260      1591407 : decls_mismatched_attributes (tree tmpl, tree decl, tree attrlist,
    2261              :                              const char* const blacklist[],
    2262              :                              auto_vec<const char *> &outattrs)
    2263              : {
    2264      1591407 :   if (TREE_CODE (tmpl) != FUNCTION_DECL)
    2265              :     return 0;
    2266              : 
    2267              :   /* Avoid warning if either declaration or its type is deprecated.  */
    2268       654609 :   if (TREE_DEPRECATED (tmpl)
    2269       654609 :       || TREE_DEPRECATED (decl))
    2270              :     return 0;
    2271              : 
    2272       654609 :   const tree tmpls[] = { tmpl, TREE_TYPE (tmpl) };
    2273       654609 :   const tree decls[] = { decl, TREE_TYPE (decl) };
    2274              : 
    2275       654609 :   if (TREE_DEPRECATED (tmpls[1])
    2276       654609 :       || TREE_DEPRECATED (decls[1])
    2277       654609 :       || TREE_DEPRECATED (TREE_TYPE (tmpls[1]))
    2278      1309218 :       || TREE_DEPRECATED (TREE_TYPE (decls[1])))
    2279              :     return 0;
    2280              : 
    2281       654600 :   tree tmpl_attrs[] = { DECL_ATTRIBUTES (tmpl), TYPE_ATTRIBUTES (tmpls[1]) };
    2282       654600 :   tree decl_attrs[] = { DECL_ATTRIBUTES (decl), TYPE_ATTRIBUTES (decls[1]) };
    2283              : 
    2284       654600 :   if (!decl_attrs[0])
    2285       649561 :     decl_attrs[0] = attrlist;
    2286         5039 :   else if (!decl_attrs[1])
    2287         5004 :     decl_attrs[1] = attrlist;
    2288              : 
    2289              :   /* Avoid warning if the template has no attributes.  */
    2290       654600 :   if (!tmpl_attrs[0] && !tmpl_attrs[1])
    2291              :     return 0;
    2292              : 
    2293              :   /* Avoid warning if either declaration contains an attribute on
    2294              :      the white list below.  */
    2295        87186 :   const char* const whitelist[] = {
    2296              :     "error", "warning"
    2297              :   };
    2298              : 
    2299       261516 :   for (unsigned i = 0; i != 2; ++i)
    2300       523023 :     for (unsigned j = 0; j != ARRAY_SIZE (whitelist); ++j)
    2301       348693 :       if (lookup_attribute (whitelist[j], tmpl_attrs[i])
    2302       348693 :           || lookup_attribute (whitelist[j], decl_attrs[i]))
    2303              :         return 0;
    2304              : 
    2305              :   /* Put together a list of the black-listed attributes that the template
    2306              :      is declared with and the declaration is not, in case it's not apparent
    2307              :      from the most recent declaration of the template.  */
    2308              :   unsigned nattrs = 0;
    2309              : 
    2310       724038 :   for (unsigned i = 0; blacklist[i]; ++i)
    2311              :     {
    2312              :       /* Attribute leaf only applies to extern functions.  Avoid mentioning
    2313              :          it when it's missing from a static declaration.  */
    2314       636873 :       if (!TREE_PUBLIC (decl)
    2315          667 :           && !strcmp ("leaf", blacklist[i]))
    2316           47 :         continue;
    2317              : 
    2318      1909395 :       for (unsigned j = 0; j != 2; ++j)
    2319              :         {
    2320      1273139 :           if (!has_attribute (tmpls[j], tmpl_attrs[j], blacklist[i]))
    2321      1272569 :             continue;
    2322              : 
    2323          570 :           bool found = false;
    2324          570 :           unsigned kmax = 1 + !!decl_attrs[1];
    2325          653 :           for (unsigned k = 0; k != kmax; ++k)
    2326              :             {
    2327          596 :               if (has_attribute (decls[k], decl_attrs[k], blacklist[i]))
    2328              :                 {
    2329              :                   found = true;
    2330              :                   break;
    2331              :                 }
    2332              :             }
    2333              : 
    2334          570 :           if (!found)
    2335              :             {
    2336           57 :               outattrs.safe_push (blacklist[i]);
    2337           57 :               ++nattrs;
    2338              :             }
    2339              : 
    2340              :           break;
    2341              :         }
    2342              :     }
    2343              : 
    2344              :   return nattrs;
    2345              : }
    2346              : 
    2347              : /* Issue a warning for the declaration ALIAS for TARGET where ALIAS
    2348              :    specifies either attributes that are incompatible with those of
    2349              :    TARGET, or attributes that are missing and that declaring ALIAS
    2350              :    with would benefit.  */
    2351              : 
    2352              : void
    2353         5160 : maybe_diag_alias_attributes (tree alias, tree target)
    2354              : {
    2355              :   /* Do not expect attributes to match between aliases and ifunc
    2356              :      resolvers.  There is no obvious correspondence between them.  */
    2357         5160 :   if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (alias)))
    2358          117 :     return;
    2359              : 
    2360         5047 :   const char* const blacklist[] = {
    2361              :     "alloc_align", "alloc_size", "cold", "const", "hot", "leaf", "malloc",
    2362              :     "nonnull", "noreturn", "nothrow", "pure", "returns_nonnull",
    2363              :     "returns_twice", NULL
    2364              :   };
    2365              : 
    2366         5047 :   if (warn_attribute_alias > 1)
    2367              :     {
    2368              :       /* With -Wattribute-alias=2 detect alias declarations that are more
    2369              :          restrictive than their targets first.  Those indicate potential
    2370              :          codegen bugs.  */
    2371            4 :       auto_vec<const char *> mismatches;
    2372            4 :       if (unsigned n = decls_mismatched_attributes (alias, target, NULL_TREE,
    2373              :                                                     blacklist, mismatches))
    2374              :         {
    2375            4 :           auto_diagnostic_group d;
    2376            4 :           pp_markup::comma_separated_quoted_strings e (mismatches);
    2377            4 :           if (warning_n (DECL_SOURCE_LOCATION (alias),
    2378            4 :                          OPT_Wattribute_alias_, n,
    2379              :                          "%qD specifies more restrictive attribute than "
    2380              :                          "its target %qD: %e",
    2381              :                          "%qD specifies more restrictive attributes than "
    2382              :                          "its target %qD: %e",
    2383              :                          alias, target, &e))
    2384            3 :             inform (DECL_SOURCE_LOCATION (target),
    2385              :                     "%qD target declared here", alias);
    2386            4 :           return;
    2387            4 :         }
    2388            4 :     }
    2389              : 
    2390              :   /* Detect alias declarations that are less restrictive than their
    2391              :      targets.  Those suggest potential optimization opportunities
    2392              :      (solved by adding the missing attribute(s) to the alias).  */
    2393         5043 :   auto_vec<const char *> mismatches;
    2394         5043 :   if (unsigned n = decls_mismatched_attributes (target, alias, NULL_TREE,
    2395              :                                                 blacklist, mismatches))
    2396              :     {
    2397           19 :       auto_diagnostic_group d;
    2398           19 :       pp_markup::comma_separated_quoted_strings e (mismatches);
    2399           19 :       if (warning_n (DECL_SOURCE_LOCATION (alias),
    2400           19 :                      OPT_Wmissing_attributes, n,
    2401              :                      "%qD specifies less restrictive attribute than "
    2402              :                      "its target %qD: %e",
    2403              :                      "%qD specifies less restrictive attributes than "
    2404              :                      "its target %qD: %e",
    2405              :                      alias, target, &e))
    2406           10 :         inform (DECL_SOURCE_LOCATION (target),
    2407              :                 "%qD target declared here", alias);
    2408           19 :     }
    2409         5043 : }
    2410              : 
    2411              : /* Initialize a mapping RWM for a call to a function declared with
    2412              :    attribute access in ATTRS.  Each attribute positional operand
    2413              :    inserts one entry into the mapping with the operand number as
    2414              :    the key.  */
    2415              : 
    2416              : void
    2417      8301412 : init_attr_rdwr_indices (rdwr_map *rwm, tree attrs)
    2418              : {
    2419      8301412 :   if (!attrs)
    2420              :     return;
    2421              : 
    2422      1341187 :   for (tree access = attrs;
    2423      7008219 :        (access = lookup_attribute ("access", access));
    2424      1341187 :        access = TREE_CHAIN (access))
    2425              :     {
    2426              :       /* The TREE_VALUE of an attribute is a TREE_LIST whose TREE_VALUE
    2427              :          is the attribute argument's value.  */
    2428      1341187 :       tree mode = TREE_VALUE (access);
    2429      1341187 :       if (!mode)
    2430              :         return;
    2431              : 
    2432              :       /* The (optional) list of VLA bounds.  */
    2433      1341187 :       tree vblist = TREE_CHAIN (mode);
    2434      1341187 :       mode = TREE_VALUE (mode);
    2435      1341187 :       if (TREE_CODE (mode) != STRING_CST)
    2436            0 :         continue;
    2437      1341187 :       gcc_assert (TREE_CODE (mode) == STRING_CST);
    2438              : 
    2439      1341187 :       if (vblist)
    2440       518104 :         vblist = nreverse (copy_list (TREE_VALUE (vblist)));
    2441              : 
    2442      2734631 :       for (const char *m = TREE_STRING_POINTER (mode); *m; )
    2443              :         {
    2444      1393444 :           attr_access acc = { };
    2445              : 
    2446              :           /* Skip the internal-only plus sign.  */
    2447      1393444 :           if (*m == '+')
    2448        39230 :             ++m;
    2449              : 
    2450      1393444 :           acc.str = m;
    2451      1393444 :           acc.mode = acc.from_mode_char (*m);
    2452      1393444 :           acc.sizarg = UINT_MAX;
    2453              : 
    2454      1393444 :           const char *end;
    2455      1393444 :           acc.ptrarg = strtoul (++m, const_cast<char**>(&end), 10);
    2456      1393444 :           m = end;
    2457              : 
    2458      1393444 :           if (*m == '[')
    2459              :             {
    2460              :               /* Forms containing the square bracket are internal-only
    2461              :                  (not specified by an attribute declaration), and used
    2462              :                  for various forms of array and VLA parameters.  */
    2463       570361 :               acc.internal_p = true;
    2464              : 
    2465              :               /* Search to the closing bracket and look at the preceding
    2466              :                  code: it determines the form of the most significant
    2467              :                  bound of the array.  Others prior to it encode the form
    2468              :                  of interior VLA bounds.  They're not of interest here.  */
    2469       570361 :               end = strchr (m, ']');
    2470       570361 :               const char *p = end;
    2471       570361 :               gcc_assert (p);
    2472              : 
    2473      1228426 :               while (ISDIGIT (p[-1]))
    2474       658065 :                 --p;
    2475              : 
    2476       570361 :               if (ISDIGIT (*p))
    2477              :                 {
    2478              :                   /* A digit denotes a constant bound (as in T[3]).  */
    2479       490179 :                   acc.static_p = p[-1] == 's';
    2480       490179 :                   acc.minsize = strtoull (p, NULL, 10);
    2481              :                 }
    2482        80182 :               else if (' ' == p[-1])
    2483              :                 {
    2484              :                   /* A space denotes an ordinary array of unspecified bound
    2485              :                      (as in T[]).  */
    2486              :                   acc.minsize = 0;
    2487              :                 }
    2488         2725 :               else if ('*' == p[-1] || '$' == p[-1])
    2489              :                 {
    2490              :                   /* An asterisk denotes a VLA.  When the closing bracket
    2491              :                      is followed by a comma and a dollar sign its bound is
    2492              :                      on the list.  Otherwise it's a VLA with an unspecified
    2493              :                      bound.  */
    2494         2725 :                   acc.static_p = p[-2] == 's';
    2495         2725 :                   acc.minsize = HOST_WIDE_INT_M1U;
    2496              :                 }
    2497              : 
    2498       570361 :               m = end + 1;
    2499              :             }
    2500              : 
    2501      1393444 :           if (*m == ',')
    2502              :             {
    2503       679578 :               ++m;
    2504       700618 :               do
    2505              :                 {
    2506       700618 :                   if (*m == '$')
    2507              :                     {
    2508        24176 :                       ++m;
    2509        24176 :                       if (!acc.size && vblist)
    2510              :                         {
    2511              :                           /* Extract the list of VLA bounds for the current
    2512              :                              parameter, store it in ACC.SIZE, and advance
    2513              :                              to the list of bounds for the next VLA parameter.
    2514              :                           */
    2515         3136 :                           acc.size = TREE_VALUE (vblist);
    2516         3136 :                           vblist = TREE_CHAIN (vblist);
    2517              :                         }
    2518              :                     }
    2519              : 
    2520       700618 :                   if (ISDIGIT (*m))
    2521              :                     {
    2522              :                       /* Extract the positional argument.  It's absent
    2523              :                          for VLAs whose bound doesn't name a function
    2524              :                          parameter.  */
    2525       677459 :                       unsigned pos = strtoul (m, const_cast<char**>(&end), 10);
    2526       677459 :                       if (acc.sizarg == UINT_MAX)
    2527       677346 :                         acc.sizarg = pos;
    2528       677459 :                       m = end;
    2529              :                     }
    2530              :                 }
    2531       700618 :               while (*m == '$');
    2532              :             }
    2533              : 
    2534      1393444 :           acc.end = m;
    2535              : 
    2536      1393444 :           bool existing;
    2537      1393444 :           auto &ref = rwm->get_or_insert (acc.ptrarg, &existing);
    2538      1393444 :           if (existing)
    2539              :             {
    2540              :               /* Merge the new spec with the existing.  */
    2541          222 :               if (acc.minsize == HOST_WIDE_INT_M1U)
    2542           12 :                 ref.minsize = HOST_WIDE_INT_M1U;
    2543              : 
    2544          222 :               if (acc.sizarg != UINT_MAX)
    2545           60 :                 ref.sizarg = acc.sizarg;
    2546              : 
    2547          222 :               if (acc.mode)
    2548          186 :                 ref.mode = acc.mode;
    2549              :             }
    2550              :           else
    2551      1393222 :             ref = acc;
    2552              : 
    2553              :           /* Unconditionally add an entry for the required pointer
    2554              :              operand of the attribute, and one for the optional size
    2555              :              operand when it's specified.  */
    2556      1393444 :           if (acc.sizarg != UINT_MAX)
    2557       677346 :             rwm->put (acc.sizarg, acc);
    2558              :         }
    2559              :     }
    2560              : }
    2561              : 
    2562              : /* Return the access specification for a function parameter PARM
    2563              :    or null if the current function has no such specification.  */
    2564              : 
    2565              : attr_access *
    2566       785265 : get_parm_access (rdwr_map &rdwr_idx, tree parm,
    2567              :                  tree fndecl /* = current_function_decl */)
    2568              : {
    2569       785265 :   tree fntype = TREE_TYPE (fndecl);
    2570       785265 :   init_attr_rdwr_indices (&rdwr_idx, TYPE_ATTRIBUTES (fntype));
    2571              : 
    2572       785265 :   if (rdwr_idx.is_empty ())
    2573              :     return NULL;
    2574              : 
    2575         3601 :   unsigned argpos = 0;
    2576         3601 :   tree fnargs = DECL_ARGUMENTS (fndecl);
    2577         8447 :   for (tree arg = fnargs; arg; arg = TREE_CHAIN (arg), ++argpos)
    2578         8433 :     if (arg == parm)
    2579         3587 :       return rdwr_idx.get (argpos);
    2580              : 
    2581              :   return NULL;
    2582              : }
    2583              : 
    2584              : /* Return the internal representation as STRING_CST.  Internal positional
    2585              :    arguments are zero-based.  */
    2586              : 
    2587              : tree
    2588      1188707 : attr_access::to_internal_string () const
    2589              : {
    2590      1188707 :   return build_string (end - str, str);
    2591              : }
    2592              : 
    2593              : /* Return the human-readable representation of the external attribute
    2594              :    specification (as it might appear in the source code) as STRING_CST.
    2595              :    External positional arguments are one-based.  */
    2596              : 
    2597              : tree
    2598         2512 : attr_access::to_external_string () const
    2599              : {
    2600         2512 :   char buf[80];
    2601         2512 :   gcc_assert (mode != access_deferred);
    2602         2512 :   int len = snprintf (buf, sizeof buf, "access (%s, %u",
    2603         2512 :                       mode_names[mode], ptrarg + 1);
    2604         2512 :   if (sizarg != UINT_MAX)
    2605         2202 :     len += snprintf (buf + len, sizeof buf - len, ", %u", sizarg + 1);
    2606         2512 :   strcpy (buf + len, ")");
    2607         2512 :   return build_string (len + 2, buf);
    2608              : }
    2609              : 
    2610              : /* Return the number of specified VLA bounds and set *nunspec to
    2611              :    the number of unspecified ones (those designated by [*]).  */
    2612              : 
    2613              : unsigned
    2614         8468 : attr_access::vla_bounds (unsigned *nunspec) const
    2615              : {
    2616         8468 :   unsigned nbounds = 0;
    2617         8468 :   *nunspec = 0;
    2618              :   /* STR points to the beginning of the specified string for the current
    2619              :      argument that may be followed by the string for the next argument.  */
    2620        54456 :   for (const char* p = strchr (str, ']'); p && *p != '['; --p)
    2621              :     {
    2622        45988 :       if (*p == '*')
    2623           91 :         ++*nunspec;
    2624        45897 :       else if (*p == '$')
    2625         9054 :         ++nbounds;
    2626              :     }
    2627         8468 :   return nbounds;
    2628              : }
    2629              : 
    2630              : /* Reset front end-specific attribute access data from ATTRS.
    2631              :    Called from the free_lang_data pass.  */
    2632              : 
    2633              : /* static */ void
    2634       335839 : attr_access::free_lang_data (tree attrs)
    2635              : {
    2636       385931 :   for (tree acs = attrs; (acs = lookup_attribute ("access", acs));
    2637        50092 :        acs = TREE_CHAIN (acs))
    2638              :     {
    2639        50092 :       tree vblist = TREE_VALUE (acs);
    2640        50092 :       vblist = TREE_CHAIN (vblist);
    2641        50092 :       if (!vblist)
    2642           26 :         continue;
    2643              : 
    2644        50341 :       for (vblist = TREE_VALUE (vblist); vblist; vblist = TREE_CHAIN (vblist))
    2645              :         {
    2646          275 :           tree *pvbnd = &TREE_VALUE (vblist);
    2647          275 :           if (!*pvbnd || DECL_P (*pvbnd))
    2648            0 :             continue;
    2649              : 
    2650              :           /* VLA bounds that are expressions as opposed to DECLs are
    2651              :              only used in the front end.  Reset them to keep front end
    2652              :              trees leaking into the middle end (see pr97172) and to
    2653              :              free up memory.  */
    2654          275 :           *pvbnd = NULL_TREE;
    2655              :         }
    2656              :     }
    2657              : 
    2658       417078 :   for (tree argspec = attrs; (argspec = lookup_attribute ("arg spec", argspec));
    2659        81239 :        argspec = TREE_CHAIN (argspec))
    2660              :     {
    2661              :       /* Same as above.  */
    2662        81239 :       tree *pvblist = &TREE_VALUE (argspec);
    2663        81239 :       *pvblist = NULL_TREE;
    2664              :     }
    2665       335839 : }
    2666              : 
    2667              : /* Defined in attr_access.  */
    2668              : constexpr char attr_access::mode_chars[];
    2669              : constexpr char attr_access::mode_names[][11];
    2670              : 
    2671              : /* Format an array, including a VLA, pointed to by TYPE and used as
    2672              :    a function parameter as a human-readable string.  ACC describes
    2673              :    an access to the parameter and is used to determine the outermost
    2674              :    form of the array including its bound which is otherwise obviated
    2675              :    by its decay to pointer.  Return the formatted string.  */
    2676              : 
    2677              : std::string
    2678         8994 : attr_access::array_as_string (tree type) const
    2679              : {
    2680         8994 :   std::string typstr;
    2681              : 
    2682         8994 :   if (type == error_mark_node)
    2683            0 :     return std::string ();
    2684              : 
    2685         8994 :   if (this->str)
    2686              :     {
    2687              :       /* For array parameters (but not pointers) create a temporary array
    2688              :          type that corresponds to the form of the parameter including its
    2689              :          qualifiers even though they apply to the pointer, not the array
    2690              :          type.  */
    2691         8610 :       const bool vla_p = minsize == HOST_WIDE_INT_M1U;
    2692         8610 :       tree eltype = TREE_TYPE (type);
    2693         8610 :       tree index_type = NULL_TREE;
    2694              : 
    2695         8610 :       if (minsize == HOST_WIDE_INT_M1U)
    2696              :         {
    2697              :           /* Determine if this is a VLA (an array whose most significant
    2698              :              bound is nonconstant and whose access string has "$]" in it)
    2699              :              extract the bound expression from SIZE.  */
    2700          741 :           const char *p = end;
    2701         9610 :           for ( ; p != str && *p-- != ']'; );
    2702          741 :           if (*p == '$')
    2703              :             /* SIZE may have been cleared.  Use it with care.  */
    2704          670 :             index_type = build_index_type (size ? TREE_VALUE (size) : size);
    2705              :         }
    2706         7869 :       else if (minsize)
    2707         7234 :         index_type = build_index_type (size_int (minsize - 1));
    2708              : 
    2709         8610 :       tree arat = NULL_TREE;
    2710         8610 :       if (static_p || vla_p)
    2711              :         {
    2712          780 :           tree flag = static_p ? integer_one_node : NULL_TREE;
    2713              :           /* Hack: there's no language-independent way to encode
    2714              :              the "static" specifier or the "*" notation in an array type.
    2715              :              Add a "fake" attribute to have the pretty-printer add "static"
    2716              :              or "*".  The "[static N]" notation is only valid in the most
    2717              :              significant bound but [*] can be used for any bound.  Because
    2718              :              [*] is represented the same as [0] this hack only works for
    2719              :              the most significant bound like static and the others are
    2720              :              rendered as [0].  */
    2721          780 :           arat = build_tree_list (get_identifier ("array "), flag);
    2722              :         }
    2723              : 
    2724         8610 :       const auto quals = TYPE_QUALS (type);
    2725         8610 :       type = build_array_type (eltype, index_type);
    2726         8610 :       type = build_type_attribute_qual_variant (type, arat, quals);
    2727              :     }
    2728              : 
    2729              :   /* Format the type using the current pretty printer.  The generic tree
    2730              :      printer does a terrible job.  */
    2731         8994 :   std::unique_ptr<pretty_printer> pp (global_dc->clone_printer ());
    2732         8994 :   pp_printf (pp.get (), "%qT", type);
    2733         8994 :   typstr = pp_formatted_text (pp.get ());
    2734              : 
    2735         8994 :   return typstr;
    2736         8994 : }
    2737              : 
    2738              : #if CHECKING_P
    2739              : 
    2740              : namespace selftest
    2741              : {
    2742              : 
    2743              : /* Self-test to verify that each attribute exclusion is symmetric,
    2744              :    meaning that if attribute A is encoded as incompatible with
    2745              :    attribute B then the opposite relationship is also encoded.
    2746              :    This test also detects most cases of misspelled attribute names
    2747              :    in exclusions.  */
    2748              : 
    2749              : static void
    2750            4 : test_attribute_exclusions ()
    2751              : {
    2752            4 :   using excl_hash_traits = pair_hash<nofree_string_hash, nofree_string_hash>;
    2753              : 
    2754              :   /* Iterate over the array of attribute tables first (with TI0 as
    2755              :      the index) and over the array of attribute_spec in each table
    2756              :      (with SI0 as the index).  */
    2757            4 :   hash_set<excl_hash_traits> excl_set;
    2758              : 
    2759           16 :   for (auto scoped_array : attribute_tables)
    2760           29 :     for (auto scoped_attributes : scoped_array)
    2761          608 :       for (const attribute_spec &attribute : scoped_attributes->attributes)
    2762              :         {
    2763          587 :           const attribute_spec::exclusions *excl = attribute.exclude;
    2764              : 
    2765              :           /* Skip each attribute that doesn't define exclusions.  */
    2766          587 :           if (!excl)
    2767          496 :             continue;
    2768              : 
    2769              :           /* Skip standard (non-GNU) attributes, since currently the
    2770              :              exclusions are implicitly for GNU attributes only.
    2771              :              Also, C++ likely and unlikely get rewritten to gnu::hot
    2772              :              and gnu::cold, so symmetry isn't necessary there.  */
    2773           91 :           if (!scoped_attributes->ns)
    2774            3 :             continue;
    2775              : 
    2776           88 :           const char *attr_name = attribute.name;
    2777              : 
    2778              :           /* Iterate over the set of exclusions for every attribute
    2779              :              (with EI0 as the index) adding the exclusions defined
    2780              :              for each to the set.  */
    2781          320 :           for (size_t ei0 = 0; excl[ei0].name; ++ei0)
    2782              :             {
    2783          232 :               const char *excl_name = excl[ei0].name;
    2784              : 
    2785          232 :               if (!strcmp (attr_name, excl_name))
    2786           47 :                 continue;
    2787              : 
    2788          185 :               excl_set.add ({ attr_name, excl_name });
    2789              :             }
    2790              :         }
    2791              : 
    2792              :   /* Traverse the set of mutually exclusive pairs of attributes
    2793              :      and verify that they are symmetric.  */
    2794          192 :   for (auto excl_pair : excl_set)
    2795          184 :     if (!excl_set.contains ({ excl_pair.second, excl_pair.first }))
    2796              :       {
    2797              :         /* An exclusion for an attribute has been found that
    2798              :            doesn't have a corresponding exclusion in the opposite
    2799              :            direction.  */
    2800            0 :         char desc[120];
    2801            0 :         sprintf (desc, "'%s' attribute exclusion '%s' must be symmetric",
    2802              :                  excl_pair.first, excl_pair.second);
    2803            0 :         fail (SELFTEST_LOCATION, desc);
    2804              :       }
    2805            4 : }
    2806              : 
    2807              : void
    2808            4 : attribs_cc_tests ()
    2809              : {
    2810            4 :   test_attribute_exclusions ();
    2811            4 : }
    2812              : 
    2813              : } /* namespace selftest */
    2814              : 
    2815              : #endif /* CHECKING_P */
    2816              : 
    2817              : #include "gt-attribs.h"
        

Generated by: LCOV version 2.5.0-beta

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.