Google Git
Sign in
gnu / gcc / refs/heads/releases/gcc-11 / . / gcc / attribs.c
blob: 47969bd7742680fb6993827fe5cab7db9b403507 [file] [log] [blame]
/* Functions dealing with attribute handling, used by most front ends.
Copyright (C) 1992-2021 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;
};
/* 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 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 }
};
/* Return base name of the attribute. Ie '__attr__' is turned into 'attr'.
To avoid need for copying, we simply return length of the string. */
static void
extract_attribute_substring (struct substring *str)
{
if (str->length > 4 && str->str[0] == '_' && str->str[1] == '_'
&& str->str[str->length - 1] == '_' && str->str[str->length - 2] == '_')
{
str->length -= 4;
str->str += 2;
}
}
/* Insert an array of attributes ATTRIBUTES into a namespace. This
array must be NULL terminated. NS is the name of attribute
namespace. 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)
{
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);
result = attributes_table.safe_push (sa);
result->attribute_hash = new hash_table<attribute_hasher> (200);
}
/* 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)
{
unsigned ix;
scoped_attributes *iter;
FOR_EACH_VEC_ELT (attributes_table, ix, iter)
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));
}
/* 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");
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_assert (str.length > 0 && str.str[0] != '_');
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);
extract_attribute_substring (&attr);
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);
attrs[1] = TYPE_ATTRIBUTES (TREE_TYPE (node));
}
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;
}
/* 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
&& !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node))
DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node) = optimization_current_node;
/* 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))
{
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)
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;
}
/* Return a new name by appending SUFFIX to the DECL name. If make_unique
is true, append the full path name of the source file. */
char *
make_unique_name (tree decl, const char *suffix, bool make_unique)
{
char *global_var_name;
int name_len;
const char *name;
const char *unique_name = NULL;
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
/* Get a unique name that can be used globally without any chances
of collision at link time. */
if (make_unique)
unique_name = IDENTIFIER_POINTER (get_file_function_name ("\0"));
name_len = strlen (name) + strlen (suffix) + 2;
if (make_unique)
name_len += strlen (unique_name) + 1;
global_var_name = XNEWVEC (char, name_len);
/* Use '.' to concatenate names as it is demangler friendly. */
if (make_unique)
snprintf (global_var_name, name_len, "%s.%s.%s", name, unique_name,
suffix);
else
snprintf (global_var_name, name_len, "%s.%s", name, suffix);
return global_var_name;
}
/* 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. */
static 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);
if (vblist)
vblist = TREE_VALUE (vblist);
mode = TREE_VALUE (mode);
if (TREE_CODE (mode) != STRING_CST)
continue;
gcc_assert (TREE_CODE (mode) == STRING_CST);
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
{
*nunspec = 0;
for (const char* p = strrchr (str, ']'); p && *p != '['; --p)
if (*p == '*')
++*nunspec;
return list_length (size);
}
/* 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
attribute_c_tests ()
{
test_attribute_exclusions ();
}
} /* namespace selftest */
#endif /* CHECKING_P */