xref: /netbsd/src/external/gpl3/gcc/dist/gcc/attribs.cc

/* Functions dealing with attribute handling, used by most front ends.
   Copyright (C) 1992-2022 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#define INCLUDE_STRING
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "target.h"
#include "tree.h"
#include "stringpool.h"
#include "diagnostic-core.h"
#include "attribs.h"
#include "fold-const.h"
#include "stor-layout.h"
#include "langhooks.h"
#include "plugin.h"
#include "selftest.h"
#include "hash-set.h"
#include "diagnostic.h"
#include "pretty-print.h"
#include "tree-pretty-print.h"
#include "intl.h"

/* Table of the tables of attributes (common, language, format, machine)
   searched.  */
static const struct attribute_spec *attribute_tables[4];

/* Substring representation.  */

struct substring
{
  const char *str;
  int length;
};

/* Simple hash function to avoid need to scan whole string.  */

static inline hashval_t
substring_hash (const char *str, int l)
{
  return str[0] + str[l - 1] * 256 + l * 65536;
}

/* Used for attribute_hash.  */

struct attribute_hasher : nofree_ptr_hash <attribute_spec>
{
  typedef substring *compare_type;
  static inline hashval_t hash (const attribute_spec *);
  static inline bool equal (const attribute_spec *, const substring *);
};

inline hashval_t
attribute_hasher::hash (const attribute_spec *spec)
{
  const int l = strlen (spec->name);
  return substring_hash (spec->name, l);
}

inline bool
attribute_hasher::equal (const attribute_spec *spec, const substring *str)
{
  return (strncmp (spec->name, str->str, str->length) == 0
            && !spec->name[str->length]);
}

/* Scoped attribute name representation.  */

struct scoped_attributes
{
  const char *ns;
  vec<attribute_spec> attributes;
  hash_table<attribute_hasher> *attribute_hash;
  /* True if we should not warn about unknown attributes in this NS.  */
  bool ignored_p;
};

/* The table of scope attributes.  */
static vec<scoped_attributes> attributes_table;

static scoped_attributes* find_attribute_namespace (const char*);
static void register_scoped_attribute (const struct attribute_spec *,
                                               scoped_attributes *);
static const struct attribute_spec *lookup_scoped_attribute_spec (const_tree,
                                                                                  const_tree);

static bool attributes_initialized = false;

/* Default empty table of attributes.  */

static const struct attribute_spec empty_attribute_table[] =
{
  { NULL, 0, 0, false, false, false, false, NULL, NULL }
};

/* Insert an array of attributes ATTRIBUTES into a namespace.  This
   array must be NULL terminated.  NS is the name of attribute
   namespace.  IGNORED_P is true iff all unknown attributes in this
   namespace should be ignored for the purposes of -Wattributes.  The
   function returns the namespace into which the attributes have been
   registered.  */

scoped_attributes *
register_scoped_attributes (const struct attribute_spec *attributes,
                                  const char *ns, bool ignored_p /*=false*/)
{
  scoped_attributes *result = NULL;

  /* See if we already have attributes in the namespace NS.  */
  result = find_attribute_namespace (ns);

  if (result == NULL)
    {
      /* We don't have any namespace NS yet.  Create one.  */
      scoped_attributes sa;

      if (attributes_table.is_empty ())
          attributes_table.create (64);

      memset (&sa, 0, sizeof (sa));
      sa.ns = ns;
      sa.attributes.create (64);
      sa.ignored_p = ignored_p;
      result = attributes_table.safe_push (sa);
      result->attribute_hash = new hash_table<attribute_hasher> (200);
    }
  else
    result->ignored_p |= ignored_p;

  /* Really add the attributes to their namespace now.  */
  for (unsigned i = 0; attributes[i].name != NULL; ++i)
    {
      result->attributes.safe_push (attributes[i]);
      register_scoped_attribute (&attributes[i], result);
    }

  gcc_assert (result != NULL);

  return result;
}

/* Return the namespace which name is NS, NULL if none exist.  */

static scoped_attributes*
find_attribute_namespace (const char* ns)
{
  for (scoped_attributes &iter : attributes_table)
    if (ns == iter.ns
          || (iter.ns != NULL
              && ns != NULL
              && !strcmp (iter.ns, ns)))
      return &iter;
  return NULL;
}

/* Make some sanity checks on the attribute tables.  */

static void
check_attribute_tables (void)
{
  for (size_t i = 0; i < ARRAY_SIZE (attribute_tables); i++)
    for (size_t j = 0; attribute_tables[i][j].name != NULL; j++)
      {
          /* The name must not begin and end with __.  */
          const char *name = attribute_tables[i][j].name;
          int len = strlen (name);

          gcc_assert (!(name[0] == '_' && name[1] == '_'
                          && name[len - 1] == '_' && name[len - 2] == '_'));

          /* The minimum and maximum lengths must be consistent.  */
          gcc_assert (attribute_tables[i][j].min_length >= 0);

          gcc_assert (attribute_tables[i][j].max_length == -1
                        || (attribute_tables[i][j].max_length
                              >= attribute_tables[i][j].min_length));

          /* An attribute cannot require both a DECL and a TYPE.  */
          gcc_assert (!attribute_tables[i][j].decl_required
                        || !attribute_tables[i][j].type_required);

            /* If an attribute requires a function type, in particular
               it requires a type.  */
          gcc_assert (!attribute_tables[i][j].function_type_required
                        || attribute_tables[i][j].type_required);
      }

  /* Check that each name occurs just once in each table.  */
  for (size_t i = 0; i < ARRAY_SIZE (attribute_tables); i++)
    for (size_t j = 0; attribute_tables[i][j].name != NULL; j++)
      for (size_t k = j + 1; attribute_tables[i][k].name != NULL; k++)
          gcc_assert (strcmp (attribute_tables[i][j].name,
                                  attribute_tables[i][k].name));

  /* Check that no name occurs in more than one table.  Names that
     begin with '*' are exempt, and may be overridden.  */
  for (size_t i = 0; i < ARRAY_SIZE (attribute_tables); i++)
    for (size_t j = i + 1; j < ARRAY_SIZE (attribute_tables); j++)
      for (size_t k = 0; attribute_tables[i][k].name != NULL; k++)
          for (size_t l = 0; attribute_tables[j][l].name != NULL; l++)
            gcc_assert (attribute_tables[i][k].name[0] == '*'
                          || strcmp (attribute_tables[i][k].name,
                                         attribute_tables[j][l].name));
}

/* Used to stash pointers to allocated memory so that we can free them at
   the end of parsing of all TUs. */
static vec<attribute_spec *> ignored_attributes_table;

/* Parse arguments V of -Wno-attributes=.
   Currently we accept:
     vendor::attr
     vendor::
   This functions also registers the parsed attributes so that we don't
   warn that we don't recognize them.  */

void
handle_ignored_attributes_option (vec<char *> *v)
{
  if (v == nullptr)
    return;

  for (auto opt : v)
    {
      char *cln = strstr (opt, "::");
      /* We don't accept '::attr'.  */
      if (cln == nullptr || cln == opt)
          {
            error ("wrong argument to ignored attributes");
            inform (input_location, "valid format is %<ns::attr%> or %<ns::%>");
            continue;
          }
      const char *vendor_start = opt;
      ptrdiff_t vendor_len = cln - opt;
      const char *attr_start = cln + 2;
      /* This could really use rawmemchr :(.  */
      ptrdiff_t attr_len = strchr (attr_start, '\0') - attr_start;
      /* Verify that they look valid.  */
      auto valid_p = [](const char *const s, ptrdiff_t len) {
          bool ok = false;

          for (int i = 0; i < len; ++i)
            if (ISALNUM (s[i]))
              ok = true;
            else if (s[i] != '_')
              return false;

          return ok;
      };
      if (!valid_p (vendor_start, vendor_len))
          {
            error ("wrong argument to ignored attributes");
            continue;
          }
      canonicalize_attr_name (vendor_start, vendor_len);
      /* We perform all this hijinks so that we don't have to copy OPT.  */
      tree vendor_id = get_identifier_with_length (vendor_start, vendor_len);
      const char *attr;
      /* In the "vendor::" case, we should ignore *any* attribute coming
           from this attribute namespace.  */
      if (attr_len > 0)
          {
            if (!valid_p (attr_start, attr_len))
              {
                error ("wrong argument to ignored attributes");
                continue;
              }
            canonicalize_attr_name (attr_start, attr_len);
            tree attr_id = get_identifier_with_length (attr_start, attr_len);
            attr = IDENTIFIER_POINTER (attr_id);
            /* If we've already seen this vendor::attr, ignore it.  Attempting to
               register it twice would lead to a crash.  */
            if (lookup_scoped_attribute_spec (vendor_id, attr_id))
              continue;
          }
      else
          attr = nullptr;
      /* Create a table with extra attributes which we will register.
           We can't free it here, so squirrel away the pointers.  */
      attribute_spec *table = new attribute_spec[2];
      ignored_attributes_table.safe_push (table);
      table[0] = { attr, 0, -2, false, false, false, false, nullptr, nullptr };
      table[1] = { nullptr, 0, 0, false, false, false, false, nullptr,
                       nullptr };
      register_scoped_attributes (table, IDENTIFIER_POINTER (vendor_id), !attr);
    }
}

/* Free data we might have allocated when adding extra attributes.  */

void
free_attr_data ()
{
  for (auto x : ignored_attributes_table)
    delete[] x;
  ignored_attributes_table.release ();
}

/* Initialize attribute tables, and make some sanity checks if checking is
   enabled.  */

void
init_attributes (void)
{
  size_t i;

  if (attributes_initialized)
    return;

  attribute_tables[0] = lang_hooks.common_attribute_table;
  attribute_tables[1] = lang_hooks.attribute_table;
  attribute_tables[2] = lang_hooks.format_attribute_table;
  attribute_tables[3] = targetm.attribute_table;

  /* Translate NULL pointers to pointers to the empty table.  */
  for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
    if (attribute_tables[i] == NULL)
      attribute_tables[i] = empty_attribute_table;

  if (flag_checking)
    check_attribute_tables ();

  for (i = 0; i < ARRAY_SIZE (attribute_tables); ++i)
    /* Put all the GNU attributes into the "gnu" namespace.  */
    register_scoped_attributes (attribute_tables[i], "gnu");

  vec<char *> *ignored = (vec<char *> *) flag_ignored_attributes;
  handle_ignored_attributes_option (ignored);

  invoke_plugin_callbacks (PLUGIN_ATTRIBUTES, NULL);
  attributes_initialized = true;
}

/* Insert a single ATTR into the attribute table.  */

void
register_attribute (const struct attribute_spec *attr)
{
  register_scoped_attribute (attr, find_attribute_namespace ("gnu"));
}

/* Insert a single attribute ATTR into a namespace of attributes.  */

static void
register_scoped_attribute (const struct attribute_spec *attr,
                                 scoped_attributes *name_space)
{
  struct substring str;
  attribute_spec **slot;

  gcc_assert (attr != NULL && name_space != NULL);

  gcc_assert (name_space->attribute_hash);

  str.str = attr->name;
  str.length = strlen (str.str);

  /* Attribute names in the table must be in the form 'text' and not
     in the form '__text__'.  */
  gcc_checking_assert (!canonicalize_attr_name (str.str, str.length));

  slot = name_space->attribute_hash
           ->find_slot_with_hash (&str, substring_hash (str.str, str.length),
                                        INSERT);
  gcc_assert (!*slot || attr->name[0] == '*');
  *slot = CONST_CAST (struct attribute_spec *, attr);
}

/* Return the spec for the scoped attribute with namespace NS and
   name NAME.   */

static const struct attribute_spec *
lookup_scoped_attribute_spec (const_tree ns, const_tree name)
{
  struct substring attr;
  scoped_attributes *attrs;

  const char *ns_str = (ns != NULL_TREE) ? IDENTIFIER_POINTER (ns): NULL;

  attrs = find_attribute_namespace (ns_str);

  if (attrs == NULL)
    return NULL;

  attr.str = IDENTIFIER_POINTER (name);
  attr.length = IDENTIFIER_LENGTH (name);
  return attrs->attribute_hash->find_with_hash (&attr,
                                                            substring_hash (attr.str,
                                                                                attr.length));
}

/* Return the spec for the attribute named NAME.  If NAME is a TREE_LIST,
   it also specifies the attribute namespace.  */

const struct attribute_spec *
lookup_attribute_spec (const_tree name)
{
  tree ns;
  if (TREE_CODE (name) == TREE_LIST)
    {
      ns = TREE_PURPOSE (name);
      name = TREE_VALUE (name);
    }
  else
    ns = get_identifier ("gnu");
  return lookup_scoped_attribute_spec (ns, name);
}


/* Return the namespace of the attribute ATTR.  This accessor works on
   GNU and C++11 (scoped) attributes.  On GNU attributes,
   it returns an identifier tree for the string "gnu".

   Please read the comments of cxx11_attribute_p to understand the
   format of attributes.  */

tree
get_attribute_namespace (const_tree attr)
{
  if (cxx11_attribute_p (attr))
    return TREE_PURPOSE (TREE_PURPOSE (attr));
  return get_identifier ("gnu");
}

/* Check LAST_DECL and NODE of the same symbol for attributes that are
   recorded in SPEC to be mutually exclusive with ATTRNAME, diagnose
   them, and return true if any have been found.  NODE can be a DECL
   or a TYPE.  */

static bool
diag_attr_exclusions (tree last_decl, tree node, tree attrname,
                          const attribute_spec *spec)
{
  const attribute_spec::exclusions *excl = spec->exclude;

  tree_code code = TREE_CODE (node);

  if ((code == FUNCTION_DECL && !excl->function
       && (!excl->type || !spec->affects_type_identity))
      || (code == VAR_DECL && !excl->variable
            && (!excl->type || !spec->affects_type_identity))
      || (((code == TYPE_DECL || RECORD_OR_UNION_TYPE_P (node)) && !excl->type)))
    return false;

  /* True if an attribute that's mutually exclusive with ATTRNAME
     has been found.  */
  bool found = false;

  if (last_decl && last_decl != node && TREE_TYPE (last_decl) != node)
    {
      /* Check both the last DECL and its type for conflicts with
           the attribute being added to the current decl or type.  */
      found |= diag_attr_exclusions (last_decl, last_decl, attrname, spec);
      tree decl_type = TREE_TYPE (last_decl);
      found |= diag_attr_exclusions (last_decl, decl_type, attrname, spec);
    }

  /* NODE is either the current DECL to which the attribute is being
     applied or its TYPE.  For the former, consider the attributes on
     both the DECL and its type.  */
  tree attrs[2];

  if (DECL_P (node))
    {
      attrs[0] = DECL_ATTRIBUTES (node);
      if (TREE_TYPE (node))
          attrs[1] = TYPE_ATTRIBUTES (TREE_TYPE (node));
      else
          /* TREE_TYPE can be NULL e.g. while processing attributes on
             enumerators.  */
          attrs[1] = NULL_TREE;
    }
  else
    {
      attrs[0] = TYPE_ATTRIBUTES (node);
      attrs[1] = NULL_TREE;
    }

  /* Iterate over the mutually exclusive attribute names and verify
     that the symbol doesn't contain it.  */
  for (unsigned i = 0; i != sizeof attrs / sizeof *attrs; ++i)
    {
      if (!attrs[i])
          continue;

      for ( ; excl->name; ++excl)
          {
            /* Avoid checking the attribute against itself.  */
            if (is_attribute_p (excl->name, attrname))
              continue;

            if (!lookup_attribute (excl->name, attrs[i]))
              continue;

            /* An exclusion may apply either to a function declaration,
               type declaration, or a field/variable declaration, or
               any subset of the three.  */
            if (TREE_CODE (node) == FUNCTION_DECL
                && !excl->function)
              continue;

            if (TREE_CODE (node) == TYPE_DECL
                && !excl->type)
              continue;

            if ((TREE_CODE (node) == FIELD_DECL
                 || TREE_CODE (node) == VAR_DECL)
                && !excl->variable)
              continue;

            found = true;

            /* Print a note?  */
            bool note = last_decl != NULL_TREE;
            auto_diagnostic_group d;
            if (TREE_CODE (node) == FUNCTION_DECL
                && fndecl_built_in_p (node))
              note &= warning (OPT_Wattributes,
                                   "ignoring attribute %qE in declaration of "
                                   "a built-in function %qD because it conflicts "
                                   "with attribute %qs",
                                   attrname, node, excl->name);
            else
              note &= warning (OPT_Wattributes,
                                   "ignoring attribute %qE because "
                                   "it conflicts with attribute %qs",
                                   attrname, excl->name);

            if (note)
              inform (DECL_SOURCE_LOCATION (last_decl),
                        "previous declaration here");
          }
    }

  return found;
}

/* Return true iff we should not complain about unknown attributes
   coming from the attribute namespace NS.  This is the case for
   the -Wno-attributes=ns:: command-line option.  */

static bool
attr_namespace_ignored_p (tree ns)
{
  if (ns == NULL_TREE)
    return false;
  scoped_attributes *r = find_attribute_namespace (IDENTIFIER_POINTER (ns));
  return r && r->ignored_p;
}

/* Return true if the attribute ATTR should not be warned about.  */

bool
attribute_ignored_p (tree attr)
{
  if (!cxx11_attribute_p (attr))
    return false;
  if (tree ns = get_attribute_namespace (attr))
    {
      const attribute_spec *as = lookup_attribute_spec (TREE_PURPOSE (attr));
      if (as == NULL && attr_namespace_ignored_p (ns))
          return true;
      if (as && as->max_length == -2)
          return true;
    }
  return false;
}

/* Like above, but takes an attribute_spec AS, which must be nonnull.  */

bool
attribute_ignored_p (const attribute_spec *const as)
{
  return as->max_length == -2;
}

/* Process the attributes listed in ATTRIBUTES and install them in *NODE,
   which is either a DECL (including a TYPE_DECL) or a TYPE.  If a DECL,
   it should be modified in place; if a TYPE, a copy should be created
   unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS.  FLAGS gives further
   information, in the form of a bitwise OR of flags in enum attribute_flags
   from tree.h.  Depending on these flags, some attributes may be
   returned to be applied at a later stage (for example, to apply
   a decl attribute to the declaration rather than to its type).  */

tree
decl_attributes (tree *node, tree attributes, int flags,
                     tree last_decl /* = NULL_TREE */)
{
  tree returned_attrs = NULL_TREE;

  if (TREE_TYPE (*node) == error_mark_node || attributes == error_mark_node)
    return NULL_TREE;

  if (!attributes_initialized)
    init_attributes ();

  /* If this is a function and the user used #pragma GCC optimize, add the
     options to the attribute((optimize(...))) list.  */
  if (TREE_CODE (*node) == FUNCTION_DECL && current_optimize_pragma)
    {
      tree cur_attr = lookup_attribute ("optimize", attributes);
      tree opts = copy_list (current_optimize_pragma);

      if (! cur_attr)
          attributes
            = tree_cons (get_identifier ("optimize"), opts, attributes);
      else
          TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
    }

  if (TREE_CODE (*node) == FUNCTION_DECL
      && (optimization_current_node != optimization_default_node
            || target_option_current_node != target_option_default_node)
      && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node))
    {
      DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node) = optimization_current_node;
      /* Don't set DECL_FUNCTION_SPECIFIC_TARGET for targets that don't
           support #pragma GCC target or target attribute.  */
      if (target_option_default_node)
          {
            tree cur_tree
              = build_target_option_node (&global_options, &global_options_set);
            tree old_tree = DECL_FUNCTION_SPECIFIC_TARGET (*node);
            if (!old_tree)
              old_tree = target_option_default_node;
            /* The changes on optimization options can cause the changes in
               target options, update it accordingly if it's changed.  */
            if (old_tree != cur_tree)
              DECL_FUNCTION_SPECIFIC_TARGET (*node) = cur_tree;
          }
    }

  /* If this is a function and the user used #pragma GCC target, add the
     options to the attribute((target(...))) list.  */
  if (TREE_CODE (*node) == FUNCTION_DECL
      && current_target_pragma
      && targetm.target_option.valid_attribute_p (*node, NULL_TREE,
                                                              current_target_pragma, 0))
    {
      tree cur_attr = lookup_attribute ("target", attributes);
      tree opts = copy_list (current_target_pragma);

      if (! cur_attr)
          attributes = tree_cons (get_identifier ("target"), opts, attributes);
      else
          TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
    }

  /* A "naked" function attribute implies "noinline" and "noclone" for
     those targets that support it.  */
  if (TREE_CODE (*node) == FUNCTION_DECL
      && attributes
      && lookup_attribute ("naked", attributes) != NULL
      && lookup_attribute_spec (get_identifier ("naked"))
      && lookup_attribute ("noipa", attributes) == NULL)
          attributes = tree_cons (get_identifier ("noipa"), NULL, attributes);

  /* A "noipa" function attribute implies "noinline", "noclone" and "no_icf"
     for those targets that support it.  */
  if (TREE_CODE (*node) == FUNCTION_DECL
      && attributes
      && lookup_attribute ("noipa", attributes) != NULL
      && lookup_attribute_spec (get_identifier ("noipa")))
    {
      if (lookup_attribute ("noinline", attributes) == NULL)
          attributes = tree_cons (get_identifier ("noinline"), NULL, attributes);

      if (lookup_attribute ("noclone", attributes) == NULL)
          attributes = tree_cons (get_identifier ("noclone"),  NULL, attributes);

      if (lookup_attribute ("no_icf", attributes) == NULL)
          attributes = tree_cons (get_identifier ("no_icf"),  NULL, attributes);
    }

  targetm.insert_attributes (*node, &attributes);

  /* Note that attributes on the same declaration are not necessarily
     in the same order as in the source.  */
  for (tree attr = attributes; attr; attr = TREE_CHAIN (attr))
    {
      tree ns = get_attribute_namespace (attr);
      tree name = get_attribute_name (attr);
      tree args = TREE_VALUE (attr);
      tree *anode = node;
      const struct attribute_spec *spec
          = lookup_scoped_attribute_spec (ns, name);
      int fn_ptr_quals = 0;
      tree fn_ptr_tmp = NULL_TREE;
      const bool cxx11_attr_p = cxx11_attribute_p (attr);

      if (spec == NULL)
          {
            if (!(flags & (int) ATTR_FLAG_BUILT_IN)
                && !attr_namespace_ignored_p (ns))
              {
                if (ns == NULL_TREE || !cxx11_attr_p)
                    warning (OPT_Wattributes, "%qE attribute directive ignored",
                               name);
                else
                    warning (OPT_Wattributes,
                               "%<%E::%E%> scoped attribute directive ignored",
                               ns, name);
              }
            continue;
          }
      else
          {
            int nargs = list_length (args);
            if (nargs < spec->min_length
                || (spec->max_length >= 0
                      && nargs > spec->max_length))
              {
                error ("wrong number of arguments specified for %qE attribute",
                         name);
                if (spec->max_length < 0)
                    inform (input_location, "expected %i or more, found %i",
                              spec->min_length, nargs);
                else
                    inform (input_location, "expected between %i and %i, found %i",
                              spec->min_length, spec->max_length, nargs);
                continue;
              }
          }
      gcc_assert (is_attribute_p (spec->name, name));

      if (spec->decl_required && !DECL_P (*anode))
          {
            if (flags & ((int) ATTR_FLAG_DECL_NEXT
                           | (int) ATTR_FLAG_FUNCTION_NEXT
                           | (int) ATTR_FLAG_ARRAY_NEXT))
              {
                /* Pass on this attribute to be tried again.  */
                tree attr = tree_cons (name, args, NULL_TREE);
                returned_attrs = chainon (returned_attrs, attr);
                continue;
              }
            else
              {
                warning (OPT_Wattributes, "%qE attribute does not apply to types",
                           name);
                continue;
              }
          }

      /* If we require a type, but were passed a decl, set up to make a
           new type and update the one in the decl.  ATTR_FLAG_TYPE_IN_PLACE
           would have applied if we'd been passed a type, but we cannot modify
           the decl's type in place here.  */
      if (spec->type_required && DECL_P (*anode))
          {
            anode = &TREE_TYPE (*anode);
            flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
          }

      if (spec->function_type_required && TREE_CODE (*anode) != FUNCTION_TYPE
            && TREE_CODE (*anode) != METHOD_TYPE)
          {
            if (TREE_CODE (*anode) == POINTER_TYPE
                && (TREE_CODE (TREE_TYPE (*anode)) == FUNCTION_TYPE
                      || TREE_CODE (TREE_TYPE (*anode)) == METHOD_TYPE))
              {
                /* OK, this is a bit convoluted.  We can't just make a copy
                     of the pointer type and modify its TREE_TYPE, because if
                     we change the attributes of the target type the pointer
                     type needs to have a different TYPE_MAIN_VARIANT.  So we
                     pull out the target type now, frob it as appropriate, and
                     rebuild the pointer type later.

                     This would all be simpler if attributes were part of the
                     declarator, grumble grumble.  */
                fn_ptr_tmp = TREE_TYPE (*anode);
                fn_ptr_quals = TYPE_QUALS (*anode);
                anode = &fn_ptr_tmp;
                flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
              }
            else if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
              {
                /* Pass on this attribute to be tried again.  */
                tree attr = tree_cons (name, args, NULL_TREE);
                returned_attrs = chainon (returned_attrs, attr);
                continue;
              }

            if (TREE_CODE (*anode) != FUNCTION_TYPE
                && TREE_CODE (*anode) != METHOD_TYPE)
              {
                warning (OPT_Wattributes,
                           "%qE attribute only applies to function types",
                           name);
                continue;
              }
          }

      if (TYPE_P (*anode)
            && (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
            && TYPE_SIZE (*anode) != NULL_TREE)
          {
            warning (OPT_Wattributes, "type attributes ignored after type is already defined");
            continue;
          }

      bool no_add_attrs = false;

      /* Check for exclusions with other attributes on the current
           declation as well as the last declaration of the same
           symbol already processed (if one exists).  Detect and
           reject incompatible attributes.  */
      bool built_in = flags & ATTR_FLAG_BUILT_IN;
      if (spec->exclude
            && (flag_checking || !built_in)
            && !error_operand_p (last_decl))
          {
            /* Always check attributes on user-defined functions.
               Check them on built-ins only when -fchecking is set.
               Ignore __builtin_unreachable -- it's both const and
               noreturn.  */

            if (!built_in
                || !DECL_P (*anode)
                || DECL_BUILT_IN_CLASS (*anode) != BUILT_IN_NORMAL
                || (DECL_FUNCTION_CODE (*anode) != BUILT_IN_UNREACHABLE
                      && (DECL_FUNCTION_CODE (*anode)
                          != BUILT_IN_UBSAN_HANDLE_BUILTIN_UNREACHABLE)))
              {
                bool no_add = diag_attr_exclusions (last_decl, *anode, name, spec);
                if (!no_add && anode != node)
                    no_add = diag_attr_exclusions (last_decl, *node, name, spec);
                no_add_attrs |= no_add;
              }
          }

      if (no_add_attrs
            /* Don't add attributes registered just for -Wno-attributes=foo::bar
               purposes.  */
            || attribute_ignored_p (attr))
          continue;

      if (spec->handler != NULL)
          {
            int cxx11_flag = (cxx11_attr_p ? ATTR_FLAG_CXX11 : 0);

            /* Pass in an array of the current declaration followed
               by the last pushed/merged declaration if one exists.
               For calls that modify the type attributes of a DECL
               and for which *ANODE is *NODE's type, also pass in
               the DECL as the third element to use in diagnostics.
               If the handler changes CUR_AND_LAST_DECL[0] replace
               *ANODE with its value.  */
            tree cur_and_last_decl[3] = { *anode, last_decl };
            if (anode != node && DECL_P (*node))
              cur_and_last_decl[2] = *node;

            tree ret = (spec->handler) (cur_and_last_decl, name, args,
                                              flags|cxx11_flag, &no_add_attrs);

            *anode = cur_and_last_decl[0];
            if (ret == error_mark_node)
              {
                warning (OPT_Wattributes, "%qE attribute ignored", name);
                no_add_attrs = true;
              }
            else
              returned_attrs = chainon (ret, returned_attrs);
          }

      /* Layout the decl in case anything changed.  */
      if (spec->type_required && DECL_P (*node)
            && (VAR_P (*node)
                || TREE_CODE (*node) == PARM_DECL
                || TREE_CODE (*node) == RESULT_DECL))
          relayout_decl (*node);

      if (!no_add_attrs)
          {
            tree old_attrs;
            tree a;

            if (DECL_P (*anode))
              old_attrs = DECL_ATTRIBUTES (*anode);
            else
              old_attrs = TYPE_ATTRIBUTES (*anode);

            for (a = lookup_attribute (spec->name, old_attrs);
                 a != NULL_TREE;
                 a = lookup_attribute (spec->name, TREE_CHAIN (a)))
              {
                if (simple_cst_equal (TREE_VALUE (a), args) == 1)
                    break;
              }

            if (a == NULL_TREE)
              {
                /* This attribute isn't already in the list.  */
                tree r;
                /* Preserve the C++11 form.  */
                if (cxx11_attr_p)
                    r = tree_cons (build_tree_list (ns, name), args, old_attrs);
                else
                    r = tree_cons (name, args, old_attrs);

                if (DECL_P (*anode))
                    DECL_ATTRIBUTES (*anode) = r;
                else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
                    {
                      TYPE_ATTRIBUTES (*anode) = r;
                      /* If this is the main variant, also push the attributes
                         out to the other variants.  */
                      if (*anode == TYPE_MAIN_VARIANT (*anode))
                        {
                          for (tree variant = *anode; variant;
                                 variant = TYPE_NEXT_VARIANT (variant))
                              {
                                if (TYPE_ATTRIBUTES (variant) == old_attrs)
                                  TYPE_ATTRIBUTES (variant)
                                    = TYPE_ATTRIBUTES (*anode);
                                else if (!lookup_attribute
                                           (spec->name, TYPE_ATTRIBUTES (variant)))
                                  TYPE_ATTRIBUTES (variant) = tree_cons
                                    (name, args, TYPE_ATTRIBUTES (variant));
                              }
                        }
                    }
                else
                    *anode = build_type_attribute_variant (*anode, r);
              }
          }

      if (fn_ptr_tmp)
          {
            /* Rebuild the function pointer type and put it in the
               appropriate place.  */
            fn_ptr_tmp = build_pointer_type (fn_ptr_tmp);
            if (fn_ptr_quals)
              fn_ptr_tmp = build_qualified_type (fn_ptr_tmp, fn_ptr_quals);
            if (DECL_P (*node))
              TREE_TYPE (*node) = fn_ptr_tmp;
            else
              {
                gcc_assert (TREE_CODE (*node) == POINTER_TYPE);
                *node = fn_ptr_tmp;
              }
          }
    }

  return returned_attrs;
}

/* Return TRUE iff ATTR has been parsed by the front-end as a C++-11
   attribute.

   When G++ parses a C++11 attribute, it is represented as
   a TREE_LIST which TREE_PURPOSE is itself a TREE_LIST.  TREE_PURPOSE
   (TREE_PURPOSE (ATTR)) is the namespace of the attribute, and the
   TREE_VALUE (TREE_PURPOSE (ATTR)) is its non-qualified name.  Please
   use get_attribute_namespace and get_attribute_name to retrieve the
   namespace and name of the attribute, as these accessors work with
   GNU attributes as well.  */

bool
cxx11_attribute_p (const_tree attr)
{
  if (attr == NULL_TREE
      || TREE_CODE (attr) != TREE_LIST)
    return false;

  return (TREE_CODE (TREE_PURPOSE (attr)) == TREE_LIST);
}

/* Return the name of the attribute ATTR.  This accessor works on GNU
   and C++11 (scoped) attributes.

   Please read the comments of cxx11_attribute_p to understand the
   format of attributes.  */

tree
get_attribute_name (const_tree attr)
{
  if (cxx11_attribute_p (attr))
    return TREE_VALUE (TREE_PURPOSE (attr));
  return TREE_PURPOSE (attr);
}

/* Subroutine of set_method_tm_attributes.  Apply TM attribute ATTR
   to the method FNDECL.  */

void
apply_tm_attr (tree fndecl, tree attr)
{
  decl_attributes (&TREE_TYPE (fndecl), tree_cons (attr, NULL, NULL), 0);
}

/* Makes a function attribute of the form NAME(ARG_NAME) and chains
   it to CHAIN.  */

tree
make_attribute (const char *name, const char *arg_name, tree chain)
{
  tree attr_name;
  tree attr_arg_name;
  tree attr_args;
  tree attr;

  attr_name = get_identifier (name);
  attr_arg_name = build_string (strlen (arg_name), arg_name);
  attr_args = tree_cons (NULL_TREE, attr_arg_name, NULL_TREE);
  attr = tree_cons (attr_name, attr_args, chain);
  return attr;
}


/* Common functions used for target clone support.  */

/* Comparator function to be used in qsort routine to sort attribute
   specification strings to "target".  */

static int
attr_strcmp (const void *v1, const void *v2)
{
  const char *c1 = *(char *const*)v1;
  const char *c2 = *(char *const*)v2;
  return strcmp (c1, c2);
}

/* ARGLIST is the argument to target attribute.  This function tokenizes
   the comma separated arguments, sorts them and returns a string which
   is a unique identifier for the comma separated arguments.   It also
   replaces non-identifier characters "=,-" with "_".  */

char *
sorted_attr_string (tree arglist)
{
  tree arg;
  size_t str_len_sum = 0;
  char **args = NULL;
  char *attr_str, *ret_str;
  char *attr = NULL;
  unsigned int argnum = 1;
  unsigned int i;

  for (arg = arglist; arg; arg = TREE_CHAIN (arg))
    {
      const char *str = TREE_STRING_POINTER (TREE_VALUE (arg));
      size_t len = strlen (str);
      str_len_sum += len + 1;
      if (arg != arglist)
          argnum++;
      for (i = 0; i < strlen (str); i++)
          if (str[i] == ',')
            argnum++;
    }

  attr_str = XNEWVEC (char, str_len_sum);
  str_len_sum = 0;
  for (arg = arglist; arg; arg = TREE_CHAIN (arg))
    {
      const char *str = TREE_STRING_POINTER (TREE_VALUE (arg));
      size_t len = strlen (str);
      memcpy (attr_str + str_len_sum, str, len);
      attr_str[str_len_sum + len] = TREE_CHAIN (arg) ? ',' : '\0';
      str_len_sum += len + 1;
    }

  /* Replace "=,-" with "_".  */
  for (i = 0; i < strlen (attr_str); i++)
    if (attr_str[i] == '=' || attr_str[i]== '-')
      attr_str[i] = '_';

  if (argnum == 1)
    return attr_str;

  args = XNEWVEC (char *, argnum);

  i = 0;
  attr = strtok (attr_str, ",");
  while (attr != NULL)
    {
      args[i] = attr;
      i++;
      attr = strtok (NULL, ",");
    }

  qsort (args, argnum, sizeof (char *), attr_strcmp);

  ret_str = XNEWVEC (char, str_len_sum);
  str_len_sum = 0;
  for (i = 0; i < argnum; i++)
    {
      size_t len = strlen (args[i]);
      memcpy (ret_str + str_len_sum, args[i], len);
      ret_str[str_len_sum + len] = i < argnum - 1 ? '_' : '\0';
      str_len_sum += len + 1;
    }

  XDELETEVEC (args);
  XDELETEVEC (attr_str);
  return ret_str;
}


/* This function returns true if FN1 and FN2 are versions of the same function,
   that is, the target strings of the function decls are different.  This assumes
   that FN1 and FN2 have the same signature.  */

bool
common_function_versions (tree fn1, tree fn2)
{
  tree attr1, attr2;
  char *target1, *target2;
  bool result;

  if (TREE_CODE (fn1) != FUNCTION_DECL
      || TREE_CODE (fn2) != FUNCTION_DECL)
    return false;

  attr1 = lookup_attribute ("target", DECL_ATTRIBUTES (fn1));
  attr2 = lookup_attribute ("target", DECL_ATTRIBUTES (fn2));

  /* At least one function decl should have the target attribute specified.  */
  if (attr1 == NULL_TREE && attr2 == NULL_TREE)
    return false;

  /* Diagnose missing target attribute if one of the decls is already
     multi-versioned.  */
  if (attr1 == NULL_TREE || attr2 == NULL_TREE)
    {
      if (DECL_FUNCTION_VERSIONED (fn1) || DECL_FUNCTION_VERSIONED (fn2))
          {
            if (attr2 != NULL_TREE)
              {
                std::swap (fn1, fn2);
                attr1 = attr2;
              }
            error_at (DECL_SOURCE_LOCATION (fn2),
                        "missing %<target%> attribute for multi-versioned %qD",
                        fn2);
            inform (DECL_SOURCE_LOCATION (fn1),
                      "previous declaration of %qD", fn1);
            /* Prevent diagnosing of the same error multiple times.  */
            DECL_ATTRIBUTES (fn2)
              = tree_cons (get_identifier ("target"),
                               copy_node (TREE_VALUE (attr1)),
                               DECL_ATTRIBUTES (fn2));
          }
      return false;
    }

  target1 = sorted_attr_string (TREE_VALUE (attr1));
  target2 = sorted_attr_string (TREE_VALUE (attr2));

  /* The sorted target strings must be different for fn1 and fn2
     to be versions.  */
  if (strcmp (target1, target2) == 0)
    result = false;
  else
    result = true;

  XDELETEVEC (target1);
  XDELETEVEC (target2);

  return result;
}

/* Make a dispatcher declaration for the multi-versioned function DECL.
   Calls to DECL function will be replaced with calls to the dispatcher
   by the front-end.  Return the decl created.  */

tree
make_dispatcher_decl (const tree decl)
{
  tree func_decl;
  char *func_name;
  tree fn_type, func_type;

  func_name = xstrdup (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));

  fn_type = TREE_TYPE (decl);
  func_type = build_function_type (TREE_TYPE (fn_type),
                                           TYPE_ARG_TYPES (fn_type));

  func_decl = build_fn_decl (func_name, func_type);
  XDELETEVEC (func_name);
  TREE_USED (func_decl) = 1;
  DECL_CONTEXT (func_decl) = NULL_TREE;
  DECL_INITIAL (func_decl) = error_mark_node;
  DECL_ARTIFICIAL (func_decl) = 1;
  /* Mark this func as external, the resolver will flip it again if
     it gets generated.  */
  DECL_EXTERNAL (func_decl) = 1;
  /* This will be of type IFUNCs have to be externally visible.  */
  TREE_PUBLIC (func_decl) = 1;

  return func_decl;
}

/* Returns true if decl is multi-versioned and DECL is the default function,
   that is it is not tagged with target specific optimization.  */

bool
is_function_default_version (const tree decl)
{
  if (TREE_CODE (decl) != FUNCTION_DECL
      || !DECL_FUNCTION_VERSIONED (decl))
    return false;
  tree attr = lookup_attribute ("target", DECL_ATTRIBUTES (decl));
  gcc_assert (attr);
  attr = TREE_VALUE (TREE_VALUE (attr));
  return (TREE_CODE (attr) == STRING_CST
            && strcmp (TREE_STRING_POINTER (attr), "default") == 0);
}

/* Return a declaration like DDECL except that its DECL_ATTRIBUTES
   is ATTRIBUTE.  */

tree
build_decl_attribute_variant (tree ddecl, tree attribute)
{
  DECL_ATTRIBUTES (ddecl) = attribute;
  return ddecl;
}

/* Return a type like TTYPE except that its TYPE_ATTRIBUTE
   is ATTRIBUTE and its qualifiers are QUALS.

   Record such modified types already made so we don't make duplicates.  */

tree
build_type_attribute_qual_variant (tree otype, tree attribute, int quals)
{
  tree ttype = otype;
  if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
    {
      tree ntype;

      /* Building a distinct copy of a tagged type is inappropriate; it
           causes breakage in code that expects there to be a one-to-one
           relationship between a struct and its fields.
           build_duplicate_type is another solution (as used in
           handle_transparent_union_attribute), but that doesn't play well
           with the stronger C++ type identity model.  */
      if (TREE_CODE (ttype) == RECORD_TYPE
            || TREE_CODE (ttype) == UNION_TYPE
            || TREE_CODE (ttype) == QUAL_UNION_TYPE
            || TREE_CODE (ttype) == ENUMERAL_TYPE)
          {
            warning (OPT_Wattributes,
                       "ignoring attributes applied to %qT after definition",
                       TYPE_MAIN_VARIANT (ttype));
            return build_qualified_type (ttype, quals);
          }

      ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
      if (lang_hooks.types.copy_lang_qualifiers
            && otype != TYPE_MAIN_VARIANT (otype))
          ttype = (lang_hooks.types.copy_lang_qualifiers
                     (ttype, TYPE_MAIN_VARIANT (otype)));

      tree dtype = ntype = build_distinct_type_copy (ttype);

      TYPE_ATTRIBUTES (ntype) = attribute;

      hashval_t hash = type_hash_canon_hash (ntype);
      ntype = type_hash_canon (hash, ntype);

      if (ntype != dtype)
          /* This variant was already in the hash table, don't mess with
             TYPE_CANONICAL.  */;
      else if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
                 || !comp_type_attributes (ntype, ttype))
          /* If the target-dependent attributes make NTYPE different from
             its canonical type, we will need to use structural equality
             checks for this type.

             We shouldn't get here for stripping attributes from a type;
             the no-attribute type might not need structural comparison.  But
             we can if was discarded from type_hash_table.  */
          SET_TYPE_STRUCTURAL_EQUALITY (ntype);
      else if (TYPE_CANONICAL (ntype) == ntype)
          TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);

      ttype = build_qualified_type (ntype, quals);
      if (lang_hooks.types.copy_lang_qualifiers
            && otype != TYPE_MAIN_VARIANT (otype))
          ttype = lang_hooks.types.copy_lang_qualifiers (ttype, otype);
    }
  else if (TYPE_QUALS (ttype) != quals)
    ttype = build_qualified_type (ttype, quals);

  return ttype;
}

/* Compare two identifier nodes representing attributes.
   Return true if they are the same, false otherwise.  */

static bool
cmp_attrib_identifiers (const_tree attr1, const_tree attr2)
{
  /* Make sure we're dealing with IDENTIFIER_NODEs.  */
  gcc_checking_assert (TREE_CODE (attr1) == IDENTIFIER_NODE
                           && TREE_CODE (attr2) == IDENTIFIER_NODE);

  /* Identifiers can be compared directly for equality.  */
  if (attr1 == attr2)
    return true;

  return cmp_attribs (IDENTIFIER_POINTER (attr1), IDENTIFIER_LENGTH (attr1),
                          IDENTIFIER_POINTER (attr2), IDENTIFIER_LENGTH (attr2));
}

/* Compare two constructor-element-type constants.  Return 1 if the lists
   are known to be equal; otherwise return 0.  */

bool
simple_cst_list_equal (const_tree l1, const_tree l2)
{
  while (l1 != NULL_TREE && l2 != NULL_TREE)
    {
      if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
          return false;

      l1 = TREE_CHAIN (l1);
      l2 = TREE_CHAIN (l2);
    }

  return l1 == l2;
}

/* Check if "omp declare simd" attribute arguments, CLAUSES1 and CLAUSES2, are
   the same.  */

static bool
omp_declare_simd_clauses_equal (tree clauses1, tree clauses2)
{
  tree cl1, cl2;
  for (cl1 = clauses1, cl2 = clauses2;
       cl1 && cl2;
       cl1 = OMP_CLAUSE_CHAIN (cl1), cl2 = OMP_CLAUSE_CHAIN (cl2))
    {
      if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_CODE (cl2))
          return false;
      if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_SIMDLEN)
          {
            if (simple_cst_equal (OMP_CLAUSE_DECL (cl1),
                                        OMP_CLAUSE_DECL (cl2)) != 1)
              return false;
          }
      switch (OMP_CLAUSE_CODE (cl1))
          {
          case OMP_CLAUSE_ALIGNED:
            if (simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (cl1),
                                        OMP_CLAUSE_ALIGNED_ALIGNMENT (cl2)) != 1)
              return false;
            break;
          case OMP_CLAUSE_LINEAR:
            if (simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (cl1),
                                        OMP_CLAUSE_LINEAR_STEP (cl2)) != 1)
              return false;
            break;
          case OMP_CLAUSE_SIMDLEN:
            if (simple_cst_equal (OMP_CLAUSE_SIMDLEN_EXPR (cl1),
                                        OMP_CLAUSE_SIMDLEN_EXPR (cl2)) != 1)
              return false;
          default:
            break;
          }
    }
  return true;
}


/* Compare two attributes for their value identity.  Return true if the
   attribute values are known to be equal; otherwise return false.  */

bool
attribute_value_equal (const_tree attr1, const_tree attr2)
{
  if (TREE_VALUE (attr1) == TREE_VALUE (attr2))
    return true;

  if (TREE_VALUE (attr1) != NULL_TREE
      && TREE_CODE (TREE_VALUE (attr1)) == TREE_LIST
      && TREE_VALUE (attr2) != NULL_TREE
      && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST)
    {
      /* Handle attribute format.  */
      if (is_attribute_p ("format", get_attribute_name (attr1)))
          {
            attr1 = TREE_VALUE (attr1);
            attr2 = TREE_VALUE (attr2);
            /* Compare the archetypes (printf/scanf/strftime/...).  */
            if (!cmp_attrib_identifiers (TREE_VALUE (attr1), TREE_VALUE (attr2)))
              return false;
            /* Archetypes are the same.  Compare the rest.  */
            return (simple_cst_list_equal (TREE_CHAIN (attr1),
                                                   TREE_CHAIN (attr2)) == 1);
          }
      return (simple_cst_list_equal (TREE_VALUE (attr1),
                                             TREE_VALUE (attr2)) == 1);
    }

  if (TREE_VALUE (attr1)
      && TREE_CODE (TREE_VALUE (attr1)) == OMP_CLAUSE
      && TREE_VALUE (attr2)
      && TREE_CODE (TREE_VALUE (attr2)) == OMP_CLAUSE)
    return omp_declare_simd_clauses_equal (TREE_VALUE (attr1),
                                                     TREE_VALUE (attr2));

  return (simple_cst_equal (TREE_VALUE (attr1), TREE_VALUE (attr2)) == 1);
}

/* Return 0 if the attributes for two types are incompatible, 1 if they
   are compatible, and 2 if they are nearly compatible (which causes a
   warning to be generated).  */
int
comp_type_attributes (const_tree type1, const_tree type2)
{
  const_tree a1 = TYPE_ATTRIBUTES (type1);
  const_tree a2 = TYPE_ATTRIBUTES (type2);
  const_tree a;

  if (a1 == a2)
    return 1;
  for (a = a1; a != NULL_TREE; a = TREE_CHAIN (a))
    {
      const struct attribute_spec *as;
      const_tree attr;

      as = lookup_attribute_spec (get_attribute_name (a));
      if (!as || as->affects_type_identity == false)
          continue;

      attr = lookup_attribute (as->name, CONST_CAST_TREE (a2));
      if (!attr || !attribute_value_equal (a, attr))
          break;
    }
  if (!a)
    {
      for (a = a2; a != NULL_TREE; a = TREE_CHAIN (a))
          {
            const struct attribute_spec *as;

            as = lookup_attribute_spec (get_attribute_name (a));
            if (!as || as->affects_type_identity == false)
              continue;

            if (!lookup_attribute (as->name, CONST_CAST_TREE (a1)))
              break;
            /* We don't need to compare trees again, as we did this
               already in first loop.  */
          }
      /* All types - affecting identity - are equal, so
           there is no need to call target hook for comparison.  */
      if (!a)
          return 1;
    }
  if (lookup_attribute ("transaction_safe", CONST_CAST_TREE (a)))
    return 0;
  if ((lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (type1)) != NULL)
      ^ (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (type2)) != NULL))
    return 0;
  /* As some type combinations - like default calling-convention - might
     be compatible, we have to call the target hook to get the final result.  */
  return targetm.comp_type_attributes (type1, type2);
}

/* PREDICATE acts as a function of type:

     (const_tree attr, const attribute_spec *as) -> bool

   where ATTR is an attribute and AS is its possibly-null specification.
   Return a list of every attribute in attribute list ATTRS for which
   PREDICATE is true.  Return ATTRS itself if PREDICATE returns true
   for every attribute.  */

template<typename Predicate>
tree
remove_attributes_matching (tree attrs, Predicate predicate)
{
  tree new_attrs = NULL_TREE;
  tree *ptr = &new_attrs;
  const_tree start = attrs;
  for (const_tree attr = attrs; attr; attr = TREE_CHAIN (attr))
    {
      tree name = get_attribute_name (attr);
      const attribute_spec *as = lookup_attribute_spec (name);
      const_tree end;
      if (!predicate (attr, as))
          end = attr;
      else if (start == attrs)
          continue;
      else
          end = TREE_CHAIN (attr);

      for (; start != end; start = TREE_CHAIN (start))
          {
            *ptr = tree_cons (TREE_PURPOSE (start),
                                  TREE_VALUE (start), NULL_TREE);
            TREE_CHAIN (*ptr) = NULL_TREE;
            ptr = &TREE_CHAIN (*ptr);
          }
      start = TREE_CHAIN (attr);
    }
  gcc_assert (!start || start == attrs);
  return start ? attrs : new_attrs;
}

/* If VALUE is true, return the subset of ATTRS that affect type identity,
   otherwise return the subset of ATTRS that don't affect type identity.  */

tree
affects_type_identity_attributes (tree attrs, bool value)
{
  auto predicate = [value](const_tree, const attribute_spec *as) -> bool
    {
      return bool (as && as->affects_type_identity) == value;
    };
  return remove_attributes_matching (attrs, predicate);
}

/* Remove attributes that affect type identity from ATTRS unless the
   same attributes occur in OK_ATTRS.  */

tree
restrict_type_identity_attributes_to (tree attrs, tree ok_attrs)
{
  auto predicate = [ok_attrs](const_tree attr,
                                    const attribute_spec *as) -> bool
    {
      if (!as || !as->affects_type_identity)
          return true;

      for (tree ok_attr = lookup_attribute (as->name, ok_attrs);
             ok_attr;
             ok_attr = lookup_attribute (as->name, TREE_CHAIN (ok_attr)))
          if (simple_cst_equal (TREE_VALUE (ok_attr), TREE_VALUE (attr)) == 1)
            return true;

      return false;
    };
  return remove_attributes_matching (attrs, predicate);
}

/* Return a type like TTYPE except that its TYPE_ATTRIBUTE
   is ATTRIBUTE.

   Record such modified types already made so we don't make duplicates.  */

tree
build_type_attribute_variant (tree ttype, tree attribute)
{
  return build_type_attribute_qual_variant (ttype, attribute,
                                                      TYPE_QUALS (ttype));
}

/* A variant of lookup_attribute() that can be used with an identifier
   as the first argument, and where the identifier can be either
   'text' or '__text__'.

   Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
   return a pointer to the attribute's list element if the attribute
   is part of the list, or NULL_TREE if not found.  If the attribute
   appears more than once, this only returns the first occurrence; the
   TREE_CHAIN of the return value should be passed back in if further
   occurrences are wanted.  ATTR_IDENTIFIER must be an identifier but
   can be in the form 'text' or '__text__'.  */
static tree
lookup_ident_attribute (tree attr_identifier, tree list)
{
  gcc_checking_assert (TREE_CODE (attr_identifier) == IDENTIFIER_NODE);

  while (list)
    {
      gcc_checking_assert (TREE_CODE (get_attribute_name (list))
                                 == IDENTIFIER_NODE);

      if (cmp_attrib_identifiers (attr_identifier,
                                          get_attribute_name (list)))
          /* Found it.  */
          break;
      list = TREE_CHAIN (list);
    }

  return list;
}

/* Remove any instances of attribute ATTR_NAME in LIST and return the
   modified list.  */

tree
remove_attribute (const char *attr_name, tree list)
{
  tree *p;
  gcc_checking_assert (attr_name[0] != '_');

  for (p = &list; *p;)
    {
      tree l = *p;

      tree attr = get_attribute_name (l);
      if (is_attribute_p (attr_name, attr))
          *p = TREE_CHAIN (l);
      else
          p = &TREE_CHAIN (l);
    }

  return list;
}

/* Return an attribute list that is the union of a1 and a2.  */

tree
merge_attributes (tree a1, tree a2)
{
  tree attributes;

  /* Either one unset?  Take the set one.  */

  if ((attributes = a1) == 0)
    attributes = a2;

  /* One that completely contains the other?  Take it.  */

  else if (a2 != 0 && ! attribute_list_contained (a1, a2))
    {
      if (attribute_list_contained (a2, a1))
          attributes = a2;
      else
          {
            /* Pick the longest list, and hang on the other list.  */

            if (list_length (a1) < list_length (a2))
              attributes = a2, a2 = a1;

            for (; a2 != 0; a2 = TREE_CHAIN (a2))
              {
                tree a;
                for (a = lookup_ident_attribute (get_attribute_name (a2),
                                                         attributes);
                       a != NULL_TREE && !attribute_value_equal (a, a2);
                       a = lookup_ident_attribute (get_attribute_name (a2),
                                                         TREE_CHAIN (a)))
                    ;
                if (a == NULL_TREE)
                    {
                      a1 = copy_node (a2);
                      TREE_CHAIN (a1) = attributes;
                      attributes = a1;
                    }
              }
          }
    }
  return attributes;
}

/* Given types T1 and T2, merge their attributes and return
  the result.  */

tree
merge_type_attributes (tree t1, tree t2)
{
  return merge_attributes (TYPE_ATTRIBUTES (t1),
                                 TYPE_ATTRIBUTES (t2));
}

/* Given decls OLDDECL and NEWDECL, merge their attributes and return
   the result.  */

tree
merge_decl_attributes (tree olddecl, tree newdecl)
{
  return merge_attributes (DECL_ATTRIBUTES (olddecl),
                                 DECL_ATTRIBUTES (newdecl));
}

/* Duplicate all attributes with name NAME in ATTR list to *ATTRS if
   they are missing there.  */

void
duplicate_one_attribute (tree *attrs, tree attr, const char *name)
{
  attr = lookup_attribute (name, attr);
  if (!attr)
    return;
  tree a = lookup_attribute (name, *attrs);
  while (attr)
    {
      tree a2;
      for (a2 = a; a2; a2 = lookup_attribute (name, TREE_CHAIN (a2)))
          if (attribute_value_equal (attr, a2))
            break;
      if (!a2)
          {
            a2 = copy_node (attr);
            TREE_CHAIN (a2) = *attrs;
            *attrs = a2;
          }
      attr = lookup_attribute (name, TREE_CHAIN (attr));
    }
}

/* Duplicate all attributes from user DECL to the corresponding
   builtin that should be propagated.  */

void
copy_attributes_to_builtin (tree decl)
{
  tree b = builtin_decl_explicit (DECL_FUNCTION_CODE (decl));
  if (b)
    duplicate_one_attribute (&DECL_ATTRIBUTES (b),
                                   DECL_ATTRIBUTES (decl), "omp declare simd");
}

#if TARGET_DLLIMPORT_DECL_ATTRIBUTES

/* Specialization of merge_decl_attributes for various Windows targets.

   This handles the following situation:

     __declspec (dllimport) int foo;
     int foo;

   The second instance of `foo' nullifies the dllimport.  */

tree
merge_dllimport_decl_attributes (tree old, tree new_tree)
{
  tree a;
  int delete_dllimport_p = 1;

  /* What we need to do here is remove from `old' dllimport if it doesn't
     appear in `new'.  dllimport behaves like extern: if a declaration is
     marked dllimport and a definition appears later, then the object
     is not dllimport'd.  We also remove a `new' dllimport if the old list
     contains dllexport:  dllexport always overrides dllimport, regardless
     of the order of declaration.  */
  if (!VAR_OR_FUNCTION_DECL_P (new_tree))
    delete_dllimport_p = 0;
  else if (DECL_DLLIMPORT_P (new_tree)
             && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
    {
      DECL_DLLIMPORT_P (new_tree) = 0;
      warning (OPT_Wattributes, "%q+D already declared with dllexport "
                 "attribute: dllimport ignored", new_tree);
    }
  else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
    {
      /* Warn about overriding a symbol that has already been used, e.g.:
             extern int __attribute__ ((dllimport)) foo;
             int* bar () {return &foo;}
             int foo;
      */
      if (TREE_USED (old))
          {
            warning (0, "%q+D redeclared without dllimport attribute "
                       "after being referenced with dll linkage", new_tree);
            /* If we have used a variable's address with dllimport linkage,
                keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
                decl may already have had TREE_CONSTANT computed.
                We still remove the attribute so that assembler code refers
                to '&foo rather than '_imp__foo'.  */
            if (VAR_P (old) && TREE_ADDRESSABLE (old))
              DECL_DLLIMPORT_P (new_tree) = 1;
          }

      /* Let an inline definition silently override the external reference,
           but otherwise warn about attribute inconsistency.  */
      else if (VAR_P (new_tree) || !DECL_DECLARED_INLINE_P (new_tree))
          warning (OPT_Wattributes, "%q+D redeclared without dllimport "
                     "attribute: previous dllimport ignored", new_tree);
    }
  else
    delete_dllimport_p = 0;

  a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));

  if (delete_dllimport_p)
    a = remove_attribute ("dllimport", a);

  return a;
}

/* Handle a "dllimport" or "dllexport" attribute; arguments as in
   struct attribute_spec.handler.  */

tree
handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
                          bool *no_add_attrs)
{
  tree node = *pnode;
  bool is_dllimport;

  /* These attributes may apply to structure and union types being created,
     but otherwise should pass to the declaration involved.  */
  if (!DECL_P (node))
    {
      if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
                       | (int) ATTR_FLAG_ARRAY_NEXT))
          {
            *no_add_attrs = true;
            return tree_cons (name, args, NULL_TREE);
          }
      if (TREE_CODE (node) == RECORD_TYPE
            || TREE_CODE (node) == UNION_TYPE)
          {
            node = TYPE_NAME (node);
            if (!node)
              return NULL_TREE;
          }
      else
          {
            warning (OPT_Wattributes, "%qE attribute ignored",
                       name);
            *no_add_attrs = true;
            return NULL_TREE;
          }
    }

  if (!VAR_OR_FUNCTION_DECL_P (node) && TREE_CODE (node) != TYPE_DECL)
    {
      *no_add_attrs = true;
      warning (OPT_Wattributes, "%qE attribute ignored",
                 name);
      return NULL_TREE;
    }

  if (TREE_CODE (node) == TYPE_DECL
      && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
      && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
    {
      *no_add_attrs = true;
      warning (OPT_Wattributes, "%qE attribute ignored",
                 name);
      return NULL_TREE;
    }

  is_dllimport = is_attribute_p ("dllimport", name);

  /* Report error on dllimport ambiguities seen now before they cause
     any damage.  */
  if (is_dllimport)
    {
      /* Honor any target-specific overrides.  */
      if (!targetm.valid_dllimport_attribute_p (node))
          *no_add_attrs = true;

     else if (TREE_CODE (node) == FUNCTION_DECL
                && DECL_DECLARED_INLINE_P (node))
          {
            warning (OPT_Wattributes, "inline function %q+D declared as "
                      "dllimport: attribute ignored", node);
            *no_add_attrs = true;
          }
      /* Like MS, treat definition of dllimported variables and
           non-inlined functions on declaration as syntax errors.  */
     else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
          {
            error ("function %q+D definition is marked dllimport", node);
            *no_add_attrs = true;
          }

     else if (VAR_P (node))
          {
            if (DECL_INITIAL (node))
              {
                error ("variable %q+D definition is marked dllimport",
                         node);
                *no_add_attrs = true;
              }

            /* `extern' needn't be specified with dllimport.
               Specify `extern' now and hope for the best.  Sigh.  */
            DECL_EXTERNAL (node) = 1;
            /* Also, implicitly give dllimport'd variables declared within
               a function global scope, unless declared static.  */
            if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
              TREE_PUBLIC (node) = 1;
            /* Clear TREE_STATIC because DECL_EXTERNAL is set, unless
               it is a C++ static data member.  */
            if (DECL_CONTEXT (node) == NULL_TREE
                || !RECORD_OR_UNION_TYPE_P (DECL_CONTEXT (node)))
              TREE_STATIC (node) = 0;
          }

      if (*no_add_attrs == false)
          DECL_DLLIMPORT_P (node) = 1;
    }
  else if (TREE_CODE (node) == FUNCTION_DECL
             && DECL_DECLARED_INLINE_P (node)
             && flag_keep_inline_dllexport)
    /* An exported function, even if inline, must be emitted.  */
    DECL_EXTERNAL (node) = 0;

  /*  Report error if symbol is not accessible at global scope.  */
  if (!TREE_PUBLIC (node) && VAR_OR_FUNCTION_DECL_P (node))
    {
      error ("external linkage required for symbol %q+D because of "
               "%qE attribute", node, name);
      *no_add_attrs = true;
    }

  /* A dllexport'd entity must have default visibility so that other
     program units (shared libraries or the main executable) can see
     it.  A dllimport'd entity must have default visibility so that
     the linker knows that undefined references within this program
     unit can be resolved by the dynamic linker.  */
  if (!*no_add_attrs)
    {
      if (DECL_VISIBILITY_SPECIFIED (node)
            && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
          error ("%qE implies default visibility, but %qD has already "
                 "been declared with a different visibility",
                 name, node);
      DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
      DECL_VISIBILITY_SPECIFIED (node) = 1;
    }

  return NULL_TREE;
}

#endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES  */

/* Given two lists of attributes, return true if list l2 is
   equivalent to l1.  */

int
attribute_list_equal (const_tree l1, const_tree l2)
{
  if (l1 == l2)
    return 1;

  return attribute_list_contained (l1, l2)
           && attribute_list_contained (l2, l1);
}

/* Given two lists of attributes, return true if list L2 is
   completely contained within L1.  */
/* ??? This would be faster if attribute names were stored in a canonicalized
   form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
   must be used to show these elements are equivalent (which they are).  */
/* ??? It's not clear that attributes with arguments will always be handled
   correctly.  */

int
attribute_list_contained (const_tree l1, const_tree l2)
{
  const_tree t1, t2;

  /* First check the obvious, maybe the lists are identical.  */
  if (l1 == l2)
    return 1;

  /* Maybe the lists are similar.  */
  for (t1 = l1, t2 = l2;
       t1 != 0 && t2 != 0
       && get_attribute_name (t1) == get_attribute_name (t2)
       && TREE_VALUE (t1) == TREE_VALUE (t2);
       t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
    ;

  /* Maybe the lists are equal.  */
  if (t1 == 0 && t2 == 0)
    return 1;

  for (; t2 != 0; t2 = TREE_CHAIN (t2))
    {
      const_tree attr;
      /* This CONST_CAST is okay because lookup_attribute does not
           modify its argument and the return value is assigned to a
           const_tree.  */
      for (attr = lookup_ident_attribute (get_attribute_name (t2),
                                                    CONST_CAST_TREE (l1));
             attr != NULL_TREE && !attribute_value_equal (t2, attr);
             attr = lookup_ident_attribute (get_attribute_name (t2),
                                                    TREE_CHAIN (attr)))
          ;

      if (attr == NULL_TREE)
          return 0;
    }

  return 1;
}

/* The backbone of lookup_attribute().  ATTR_LEN is the string length
   of ATTR_NAME, and LIST is not NULL_TREE.

   The function is called from lookup_attribute in order to optimize
   for size.  */

tree
private_lookup_attribute (const char *attr_name, size_t attr_len, tree list)
{
  while (list)
    {
      tree attr = get_attribute_name (list);
      size_t ident_len = IDENTIFIER_LENGTH (attr);
      if (cmp_attribs (attr_name, attr_len, IDENTIFIER_POINTER (attr),
                           ident_len))
          break;
      list = TREE_CHAIN (list);
    }

  return list;
}

/* Return true if the function decl or type NODE has been declared
   with attribute ANAME among attributes ATTRS.  */

static bool
has_attribute (tree node, tree attrs, const char *aname)
{
  if (!strcmp (aname, "const"))
    {
      if (DECL_P (node) && TREE_READONLY (node))
          return true;
    }
  else if (!strcmp (aname, "malloc"))
    {
      if (DECL_P (node) && DECL_IS_MALLOC (node))
          return true;
    }
  else if (!strcmp (aname, "noreturn"))
    {
      if (DECL_P (node) && TREE_THIS_VOLATILE (node))
          return true;
    }
  else if (!strcmp (aname, "nothrow"))
    {
      if (TREE_NOTHROW (node))
          return true;
    }
  else if (!strcmp (aname, "pure"))
    {
      if (DECL_P (node) && DECL_PURE_P (node))
          return true;
    }

  return lookup_attribute (aname, attrs);
}

/* Return the number of mismatched function or type attributes between
   the "template" function declaration TMPL and DECL.  The word "template"
   doesn't necessarily refer to a C++ template but rather a declaration
   whose attributes should be matched by those on DECL.  For a non-zero
   return value set *ATTRSTR to a string representation of the list of
   mismatched attributes with quoted names.
   ATTRLIST is a list of additional attributes that SPEC should be
   taken to ultimately be declared with.  */

unsigned
decls_mismatched_attributes (tree tmpl, tree decl, tree attrlist,
                                   const char* const blacklist[],
                                   pretty_printer *attrstr)
{
  if (TREE_CODE (tmpl) != FUNCTION_DECL)
    return 0;

  /* Avoid warning if either declaration or its type is deprecated.  */
  if (TREE_DEPRECATED (tmpl)
      || TREE_DEPRECATED (decl))
    return 0;

  const tree tmpls[] = { tmpl, TREE_TYPE (tmpl) };
  const tree decls[] = { decl, TREE_TYPE (decl) };

  if (TREE_DEPRECATED (tmpls[1])
      || TREE_DEPRECATED (decls[1])
      || TREE_DEPRECATED (TREE_TYPE (tmpls[1]))
      || TREE_DEPRECATED (TREE_TYPE (decls[1])))
    return 0;

  tree tmpl_attrs[] = { DECL_ATTRIBUTES (tmpl), TYPE_ATTRIBUTES (tmpls[1]) };
  tree decl_attrs[] = { DECL_ATTRIBUTES (decl), TYPE_ATTRIBUTES (decls[1]) };

  if (!decl_attrs[0])
    decl_attrs[0] = attrlist;
  else if (!decl_attrs[1])
    decl_attrs[1] = attrlist;

  /* Avoid warning if the template has no attributes.  */
  if (!tmpl_attrs[0] && !tmpl_attrs[1])
    return 0;

  /* Avoid warning if either declaration contains an attribute on
     the white list below.  */
  const char* const whitelist[] = {
    "error", "warning"
  };

  for (unsigned i = 0; i != 2; ++i)
    for (unsigned j = 0; j != sizeof whitelist / sizeof *whitelist; ++j)
      if (lookup_attribute (whitelist[j], tmpl_attrs[i])
            || lookup_attribute (whitelist[j], decl_attrs[i]))
          return 0;

  /* Put together a list of the black-listed attributes that the template
     is declared with and the declaration is not, in case it's not apparent
     from the most recent declaration of the template.  */
  unsigned nattrs = 0;

  for (unsigned i = 0; blacklist[i]; ++i)
    {
      /* Attribute leaf only applies to extern functions.  Avoid mentioning
           it when it's missing from a static declaration.  */
      if (!TREE_PUBLIC (decl)
            && !strcmp ("leaf", blacklist[i]))
          continue;

      for (unsigned j = 0; j != 2; ++j)
          {
            if (!has_attribute (tmpls[j], tmpl_attrs[j], blacklist[i]))
              continue;

            bool found = false;
            unsigned kmax = 1 + !!decl_attrs[1];
            for (unsigned k = 0; k != kmax; ++k)
              {
                if (has_attribute (decls[k], decl_attrs[k], blacklist[i]))
                    {
                      found = true;
                      break;
                    }
              }

            if (!found)
              {
                if (nattrs)
                    pp_string (attrstr, ", ");
                pp_begin_quote (attrstr, pp_show_color (global_dc->printer));
                pp_string (attrstr, blacklist[i]);
                pp_end_quote (attrstr, pp_show_color (global_dc->printer));
                ++nattrs;
              }

            break;
          }
    }

  return nattrs;
}

/* Issue a warning for the declaration ALIAS for TARGET where ALIAS
   specifies either attributes that are incompatible with those of
   TARGET, or attributes that are missing and that declaring ALIAS
   with would benefit.  */

void
maybe_diag_alias_attributes (tree alias, tree target)
{
  /* Do not expect attributes to match between aliases and ifunc
     resolvers.  There is no obvious correspondence between them.  */
  if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (alias)))
    return;

  const char* const blacklist[] = {
    "alloc_align", "alloc_size", "cold", "const", "hot", "leaf", "malloc",
    "nonnull", "noreturn", "nothrow", "pure", "returns_nonnull",
    "returns_twice", NULL
  };

  pretty_printer attrnames;
  if (warn_attribute_alias > 1)
    {
      /* With -Wattribute-alias=2 detect alias declarations that are more
           restrictive than their targets first.  Those indicate potential
           codegen bugs.  */
      if (unsigned n = decls_mismatched_attributes (alias, target, NULL_TREE,
                                                                blacklist, &attrnames))
          {
            auto_diagnostic_group d;
            if (warning_n (DECL_SOURCE_LOCATION (alias),
                               OPT_Wattribute_alias_, n,
                               "%qD specifies more restrictive attribute than "
                               "its target %qD: %s",
                               "%qD specifies more restrictive attributes than "
                               "its target %qD: %s",
                               alias, target, pp_formatted_text (&attrnames)))
              inform (DECL_SOURCE_LOCATION (target),
                        "%qD target declared here", alias);
            return;
          }
    }

  /* Detect alias declarations that are less restrictive than their
     targets.  Those suggest potential optimization opportunities
     (solved by adding the missing attribute(s) to the alias).  */
  if (unsigned n = decls_mismatched_attributes (target, alias, NULL_TREE,
                                                            blacklist, &attrnames))
    {
      auto_diagnostic_group d;
      if (warning_n (DECL_SOURCE_LOCATION (alias),
                         OPT_Wmissing_attributes, n,
                         "%qD specifies less restrictive attribute than "
                         "its target %qD: %s",
                         "%qD specifies less restrictive attributes than "
                         "its target %qD: %s",
                         alias, target, pp_formatted_text (&attrnames)))
          inform (DECL_SOURCE_LOCATION (target),
                    "%qD target declared here", alias);
    }
}

/* Initialize a mapping RWM for a call to a function declared with
   attribute access in ATTRS.  Each attribute positional operand
   inserts one entry into the mapping with the operand number as
   the key.  */

void
init_attr_rdwr_indices (rdwr_map *rwm, tree attrs)
{
  if (!attrs)
    return;

  for (tree access = attrs;
       (access = lookup_attribute ("access", access));
       access = TREE_CHAIN (access))
    {
      /* The TREE_VALUE of an attribute is a TREE_LIST whose TREE_VALUE
           is the attribute argument's value.  */
      tree mode = TREE_VALUE (access);
      if (!mode)
          return;

      /* The (optional) list of VLA bounds.  */
      tree vblist = TREE_CHAIN (mode);
      mode = TREE_VALUE (mode);
      if (TREE_CODE (mode) != STRING_CST)
          continue;
      gcc_assert (TREE_CODE (mode) == STRING_CST);

      if (vblist)
          vblist = nreverse (copy_list (TREE_VALUE (vblist)));

      for (const char *m = TREE_STRING_POINTER (mode); *m; )
          {
            attr_access acc = { };

            /* Skip the internal-only plus sign.  */
            if (*m == '+')
              ++m;

            acc.str = m;
            acc.mode = acc.from_mode_char (*m);
            acc.sizarg = UINT_MAX;

            const char *end;
            acc.ptrarg = strtoul (++m, const_cast<char**>(&end), 10);
            m = end;

            if (*m == '[')
              {
                /* Forms containing the square bracket are internal-only
                     (not specified by an attribute declaration), and used
                     for various forms of array and VLA parameters.  */
                acc.internal_p = true;

                /* Search to the closing bracket and look at the preceding
                     code: it determines the form of the most significant
                     bound of the array.  Others prior to it encode the form
                     of interior VLA bounds.  They're not of interest here.  */
                end = strchr (m, ']');
                const char *p = end;
                gcc_assert (p);

                while (ISDIGIT (p[-1]))
                    --p;

                if (ISDIGIT (*p))
                    {
                      /* A digit denotes a constant bound (as in T[3]).  */
                      acc.static_p = p[-1] == 's';
                      acc.minsize = strtoull (p, NULL, 10);
                    }
                else if (' ' == p[-1])
                    {
                      /* A space denotes an ordinary array of unspecified bound
                         (as in T[]).  */
                      acc.minsize = 0;
                    }
                else if ('*' == p[-1] || '$' == p[-1])
                    {
                      /* An asterisk denotes a VLA.  When the closing bracket
                         is followed by a comma and a dollar sign its bound is
                         on the list.  Otherwise it's a VLA with an unspecified
                         bound.  */
                      acc.static_p = p[-2] == 's';
                      acc.minsize = HOST_WIDE_INT_M1U;
                    }

                m = end + 1;
              }

            if (*m == ',')
              {
                ++m;
                do
                    {
                      if (*m == '$')
                        {
                          ++m;
                          if (!acc.size && vblist)
                              {
                                /* Extract the list of VLA bounds for the current
                                   parameter, store it in ACC.SIZE, and advance
                                   to the list of bounds for the next VLA parameter.
                                */
                                acc.size = TREE_VALUE (vblist);
                                vblist = TREE_CHAIN (vblist);
                              }
                        }

                      if (ISDIGIT (*m))
                        {
                          /* Extract the positional argument.  It's absent
                               for VLAs whose bound doesn't name a function
                               parameter.  */
                          unsigned pos = strtoul (m, const_cast<char**>(&end), 10);
                          if (acc.sizarg == UINT_MAX)
                              acc.sizarg = pos;
                          m = end;
                        }
                    }
                while (*m == '$');
              }

            acc.end = m;

            bool existing;
            auto &ref = rwm->get_or_insert (acc.ptrarg, &existing);
            if (existing)
              {
                /* Merge the new spec with the existing.  */
                if (acc.minsize == HOST_WIDE_INT_M1U)
                    ref.minsize = HOST_WIDE_INT_M1U;

                if (acc.sizarg != UINT_MAX)
                    ref.sizarg = acc.sizarg;

                if (acc.mode)
                    ref.mode = acc.mode;
              }
            else
              ref = acc;

            /* Unconditionally add an entry for the required pointer
               operand of the attribute, and one for the optional size
               operand when it's specified.  */
            if (acc.sizarg != UINT_MAX)
              rwm->put (acc.sizarg, acc);
          }
    }
}

/* Return the access specification for a function parameter PARM
   or null if the current function has no such specification.  */

attr_access *
get_parm_access (rdwr_map &rdwr_idx, tree parm,
                     tree fndecl /* = current_function_decl */)
{
  tree fntype = TREE_TYPE (fndecl);
  init_attr_rdwr_indices (&rdwr_idx, TYPE_ATTRIBUTES (fntype));

  if (rdwr_idx.is_empty ())
    return NULL;

  unsigned argpos = 0;
  tree fnargs = DECL_ARGUMENTS (fndecl);
  for (tree arg = fnargs; arg; arg = TREE_CHAIN (arg), ++argpos)
    if (arg == parm)
      return rdwr_idx.get (argpos);

  return NULL;
}

/* Return the internal representation as STRING_CST.  Internal positional
   arguments are zero-based.  */

tree
attr_access::to_internal_string () const
{
  return build_string (end - str, str);
}

/* Return the human-readable representation of the external attribute
   specification (as it might appear in the source code) as STRING_CST.
   External positional arguments are one-based.  */

tree
attr_access::to_external_string () const
{
  char buf[80];
  gcc_assert (mode != access_deferred);
  int len = snprintf (buf, sizeof buf, "access (%s, %u",
                          mode_names[mode], ptrarg + 1);
  if (sizarg != UINT_MAX)
    len += snprintf (buf + len, sizeof buf - len, ", %u", sizarg + 1);
  strcpy (buf + len, ")");
  return build_string (len + 2, buf);
}

/* Return the number of specified VLA bounds and set *nunspec to
   the number of unspecified ones (those designated by [*]).  */

unsigned
attr_access::vla_bounds (unsigned *nunspec) const
{
  unsigned nbounds = 0;
  *nunspec = 0;
  /* STR points to the beginning of the specified string for the current
     argument that may be followed by the string for the next argument.  */
  for (const char* p = strchr (str, ']'); p && *p != '['; --p)
    {
      if (*p == '*')
          ++*nunspec;
      else if (*p == '$')
          ++nbounds;
    }
  return nbounds;
}

/* Reset front end-specific attribute access data from ATTRS.
   Called from the free_lang_data pass.  */

/* static */ void
attr_access::free_lang_data (tree attrs)
{
  for (tree acs = attrs; (acs = lookup_attribute ("access", acs));
       acs = TREE_CHAIN (acs))
    {
      tree vblist = TREE_VALUE (acs);
      vblist = TREE_CHAIN (vblist);
      if (!vblist)
          continue;

      for (vblist = TREE_VALUE (vblist); vblist; vblist = TREE_CHAIN (vblist))
          {
            tree *pvbnd = &TREE_VALUE (vblist);
            if (!*pvbnd || DECL_P (*pvbnd))
              continue;

            /* VLA bounds that are expressions as opposed to DECLs are
               only used in the front end.  Reset them to keep front end
               trees leaking into the middle end (see pr97172) and to
               free up memory.  */
            *pvbnd = NULL_TREE;
          }
    }

  for (tree argspec = attrs; (argspec = lookup_attribute ("arg spec", argspec));
       argspec = TREE_CHAIN (argspec))
    {
      /* Same as above.  */
      tree *pvblist = &TREE_VALUE (argspec);
      *pvblist = NULL_TREE;
    }
}

/* Defined in attr_access.  */
constexpr char attr_access::mode_chars[];
constexpr char attr_access::mode_names[][11];

/* Format an array, including a VLA, pointed to by TYPE and used as
   a function parameter as a human-readable string.  ACC describes
   an access to the parameter and is used to determine the outermost
   form of the array including its bound which is otherwise obviated
   by its decay to pointer.  Return the formatted string.  */

std::string
attr_access::array_as_string (tree type) const
{
  std::string typstr;

  if (type == error_mark_node)
    return std::string ();

  if (this->str)
    {
      /* For array parameters (but not pointers) create a temporary array
           type that corresponds to the form of the parameter including its
           qualifiers even though they apply to the pointer, not the array
           type.  */
      const bool vla_p = minsize == HOST_WIDE_INT_M1U;
      tree eltype = TREE_TYPE (type);
      tree index_type = NULL_TREE;

      if (minsize == HOST_WIDE_INT_M1U)
          {
            /* Determine if this is a VLA (an array whose most significant
               bound is nonconstant and whose access string has "$]" in it)
               extract the bound expression from SIZE.  */
            const char *p = end;
            for ( ; p != str && *p-- != ']'; );
            if (*p == '$')
              /* SIZE may have been cleared.  Use it with care.  */
              index_type = build_index_type (size ? TREE_VALUE (size) : size);
          }
      else if (minsize)
          index_type = build_index_type (size_int (minsize - 1));

      tree arat = NULL_TREE;
      if (static_p || vla_p)
          {
            tree flag = static_p ? integer_one_node : NULL_TREE;
            /* Hack: there's no language-independent way to encode
               the "static" specifier or the "*" notation in an array type.
               Add a "fake" attribute to have the pretty-printer add "static"
               or "*".  The "[static N]" notation is only valid in the most
               significant bound but [*] can be used for any bound.  Because
               [*] is represented the same as [0] this hack only works for
               the most significant bound like static and the others are
               rendered as [0].  */
            arat = build_tree_list (get_identifier ("array"), flag);
          }

      const int quals = TYPE_QUALS (type);
      type = build_array_type (eltype, index_type);
      type = build_type_attribute_qual_variant (type, arat, quals);
    }

  /* Format the type using the current pretty printer.  The generic tree
     printer does a terrible job.  */
  pretty_printer *pp = global_dc->printer->clone ();
  pp_printf (pp, "%qT", type);
  typstr = pp_formatted_text (pp);
  delete pp;

  return typstr;
}

#if CHECKING_P

namespace selftest
{

/* Helper types to verify the consistency attribute exclusions.  */

typedef std::pair<const char *, const char *> excl_pair;

struct excl_hash_traits: typed_noop_remove<excl_pair>
{
  typedef excl_pair  value_type;
  typedef value_type compare_type;

  static hashval_t hash (const value_type &x)
  {
    hashval_t h1 = htab_hash_string (x.first);
    hashval_t h2 = htab_hash_string (x.second);
    return h1 ^ h2;
  }

  static bool equal (const value_type &x, const value_type &y)
  {
    return !strcmp (x.first, y.first) && !strcmp (x.second, y.second);
  }

  static void mark_deleted (value_type &x)
  {
    x = value_type (NULL, NULL);
  }

  static const bool empty_zero_p = false;

  static void mark_empty (value_type &x)
  {
    x = value_type ("", "");
  }

  static bool is_deleted (const value_type &x)
  {
    return !x.first && !x.second;
  }

  static bool is_empty (const value_type &x)
  {
    return !*x.first && !*x.second;
  }
};


/* Self-test to verify that each attribute exclusion is symmetric,
   meaning that if attribute A is encoded as incompatible with
   attribute B then the opposite relationship is also encoded.
   This test also detects most cases of misspelled attribute names
   in exclusions.  */

static void
test_attribute_exclusions ()
{
  /* Iterate over the array of attribute tables first (with TI0 as
     the index) and over the array of attribute_spec in each table
     (with SI0 as the index).  */
  const size_t ntables = ARRAY_SIZE (attribute_tables);

  /* Set of pairs of mutually exclusive attributes.  */
  typedef hash_set<excl_pair, false, excl_hash_traits> exclusion_set;
  exclusion_set excl_set;

  for (size_t ti0 = 0; ti0 != ntables; ++ti0)
    for (size_t s0 = 0; attribute_tables[ti0][s0].name; ++s0)
      {
          const attribute_spec::exclusions *excl
            = attribute_tables[ti0][s0].exclude;

          /* Skip each attribute that doesn't define exclusions.  */
          if (!excl)
            continue;

          const char *attr_name = attribute_tables[ti0][s0].name;

          /* Iterate over the set of exclusions for every attribute
             (with EI0 as the index) adding the exclusions defined
             for each to the set.  */
          for (size_t ei0 = 0; excl[ei0].name; ++ei0)
            {
              const char *excl_name = excl[ei0].name;

              if (!strcmp (attr_name, excl_name))
                continue;

              excl_set.add (excl_pair (attr_name, excl_name));
            }
      }

  /* Traverse the set of mutually exclusive pairs of attributes
     and verify that they are symmetric.  */
  for (exclusion_set::iterator it = excl_set.begin ();
       it != excl_set.end ();
       ++it)
    {
      if (!excl_set.contains (excl_pair ((*it).second, (*it).first)))
          {
            /* An exclusion for an attribute has been found that
               doesn't have a corresponding exclusion in the opposite
               direction.  */
            char desc[120];
            sprintf (desc, "'%s' attribute exclusion '%s' must be symmetric",
                       (*it).first, (*it).second);
            fail (SELFTEST_LOCATION, desc);
          }
    }
}

void
attribs_cc_tests ()
{
  test_attribute_exclusions ();
}

} /* namespace selftest */

#endif /* CHECKING_P */