[thirdparty/gcc.git] / gcc / attribs.c

/* Functions dealing with attribute handling, used by most front ends.
   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   2002, 2003, 2004, 2005, 2007 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/>.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "flags.h"
#include "toplev.h"
#include "output.h"
#include "rtl.h"
#include "ggc.h"
#include "tm_p.h"
#include "cpplib.h"
#include "target.h"
#include "langhooks.h"
#include "hashtab.h"

static void init_attributes (void);

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

/* Hashtable mapping names (represented as substrings) to attribute specs. */
static htab_t attribute_hash;

/* Substring representation.  */

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

static bool attributes_initialized = false;

/* Default empty table of attributes.  */

static const struct attribute_spec empty_attribute_table[] =
{
  { NULL, 0, 0, false, false, false, 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;
    }
}

/* 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.  */

static hashval_t
hash_attr (const void *p)
{
  const struct attribute_spec *const spec = (const struct attribute_spec *) p;
  const int l = strlen (spec->name);

  return substring_hash (spec->name, l);
}

/* Used for attribute_hash.  */

static int
eq_attr (const void *p, const void *q)
{
  const struct attribute_spec *const spec = (const struct attribute_spec *) p;
  const struct substring *const str = (const struct substring *) q;

  return (!strncmp (spec->name, str->str, str->length) && !spec->name[str->length]);
}

/* Initialize attribute tables, and make some sanity checks
   if --enable-checking.  */

static void
init_attributes (void)
{
  size_t i;
  int k;

  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;

#ifdef ENABLE_CHECKING
  /* Make some sanity checks on the attribute tables.  */
  for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
    {
      int j;

      for (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 (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
    {
      int j, k;
      for (j = 0; attribute_tables[i][j].name != NULL; j++)
	for (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.  */
  for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
    {
      size_t j, k, l;

      for (j = i + 1; j < ARRAY_SIZE (attribute_tables); j++)
	for (k = 0; attribute_tables[i][k].name != NULL; k++)
	  for (l = 0; attribute_tables[j][l].name != NULL; l++)
	    gcc_assert (strcmp (attribute_tables[i][k].name,
				attribute_tables[j][l].name));
    }
#endif

  attribute_hash = htab_create (200, hash_attr, eq_attr, NULL);
  for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
    for (k = 0; attribute_tables[i][k].name != NULL; k++)
      {
	struct substring str;
	const void **slot;

	str.str = attribute_tables[i][k].name;
	str.length = strlen (attribute_tables[i][k].name);
	slot = (const void **)htab_find_slot_with_hash (attribute_hash, &str,
					 substring_hash (str.str, str.length),
					 INSERT);
	gcc_assert (!*slot);
	*slot = &attribute_tables[i][k];
      }
  attributes_initialized = true;
}

/* Return the spec for the attribute named NAME.  */

const struct attribute_spec *
lookup_attribute_spec (tree name)
{
  struct substring attr;

  attr.str = IDENTIFIER_POINTER (name);
  attr.length = IDENTIFIER_LENGTH (name);
  extract_attribute_substring (&attr);
  return htab_find_with_hash (attribute_hash, &attr,
			      substring_hash (attr.str, attr.length));
}
\f
/* 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 a;
  tree returned_attrs = NULL_TREE;

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

  if (!attributes_initialized)
    init_attributes ();

  targetm.insert_attributes (*node, &attributes);

  for (a = attributes; a; a = TREE_CHAIN (a))
    {
      tree name = TREE_PURPOSE (a);
      tree args = TREE_VALUE (a);
      tree *anode = node;
      const struct attribute_spec *spec = lookup_attribute_spec (name);
      bool no_add_attrs = 0;
      tree fn_ptr_tmp = NULL_TREE;

      if (spec == NULL)
	{
	  warning (OPT_Wattributes, "%qs attribute directive ignored",
		   IDENTIFIER_POINTER (name));
	  continue;
	}
      else if (list_length (args) < spec->min_length
	       || (spec->max_length >= 0
		   && list_length (args) > spec->max_length))
	{
	  error ("wrong number of arguments specified for %qs attribute",
		 IDENTIFIER_POINTER (name));
	  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.  */
	      returned_attrs = tree_cons (name, args, returned_attrs);
	      continue;
	    }
	  else
	    {
	      warning (OPT_Wattributes, "%qs attribute does not apply to types",
		       IDENTIFIER_POINTER (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);
	  /* Allow ATTR_FLAG_TYPE_IN_PLACE for the type's naming decl.  */
	  if (!(TREE_CODE (*anode) == TYPE_DECL
		&& *anode == TYPE_NAME (TYPE_MAIN_VARIANT
					(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);
	      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.  */
	      returned_attrs = tree_cons (name, args, returned_attrs);
	      continue;
	    }

	  if (TREE_CODE (*anode) != FUNCTION_TYPE
	      && TREE_CODE (*anode) != METHOD_TYPE)
	    {
	      warning (OPT_Wattributes,
		       "%qs attribute only applies to function types",
		       IDENTIFIER_POINTER (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;
	}

      if (spec->handler != NULL)
	returned_attrs = chainon ((*spec->handler) (anode, name, args,
						    flags, &no_add_attrs),
				  returned_attrs);

      /* Layout the decl in case anything changed.  */
      if (spec->type_required && DECL_P (*node)
	  && (TREE_CODE (*node) == VAR_DECL
	      || 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.  */
	      if (DECL_P (*anode))
		DECL_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
	      else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
		{
		  TYPE_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
		  /* If this is the main variant, also push the attributes
		     out to the other variants.  */
		  if (*anode == TYPE_MAIN_VARIANT (*anode))
		    {
		      tree variant;
		      for (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,
						       tree_cons (name, args,
								  old_attrs));
	    }
	}

      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 (DECL_P (*node))
	    TREE_TYPE (*node) = fn_ptr_tmp;
	  else
	    {
	      gcc_assert (TREE_CODE (*node) == POINTER_TYPE);
	      *node = fn_ptr_tmp;
	    }
	}
    }

  return returned_attrs;
}
Commit	Line	Data
e3f6ce11	1	/* Functions dealing with attribute handling, used by most front ends.
80fabb90	2	Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
8c4c00c1	3	2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
e3f6ce11	4
	5	This file is part of GCC.
	6
	7	GCC is free software; you can redistribute it and/or modify it under
	8	the terms of the GNU General Public License as published by the Free
8c4c00c1	9	Software Foundation; either version 3, or (at your option) any later
e3f6ce11	10	version.
	11
	12	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	13	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	14	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	15	for more details.
	16
	17	You should have received a copy of the GNU General Public License
8c4c00c1	18	along with GCC; see the file COPYING3. If not see
8c4c00c1	19	<http://www.gnu.org/licenses/>. */
e3f6ce11	20
	21	#include "config.h"
	22	#include "system.h"
805e22b2	23	#include "coretypes.h"
805e22b2	24	#include "tm.h"
e3f6ce11	25	#include "tree.h"
	26	#include "flags.h"
	27	#include "toplev.h"
	28	#include "output.h"
	29	#include "rtl.h"
	30	#include "ggc.h"
e3f6ce11	31	#include "tm_p.h"
e3f6ce11	32	#include "cpplib.h"
e3f6ce11	33	#include "target.h"
26ca6c20	34	#include "langhooks.h"
5b634bfa	35	#include "hashtab.h"
e3f6ce11	36
aecda0d6	37	static void init_attributes (void);
e3f6ce11	38
f8e93a2e	39	/* Table of the tables of attributes (common, language, format, machine)
e3f6ce11	40	searched. */
	41	static const struct attribute_spec *attribute_tables[4];
	42
5b634bfa	43	/* Hashtable mapping names (represented as substrings) to attribute specs. */
	44	static htab_t attribute_hash;
	45
	46	/* Substring representation. */
	47
	48	struct substring
	49	{
	50	const char *str;
	51	int length;
	52	};
	53
e3f6ce11	54	static bool attributes_initialized = false;
e3f6ce11	55
e3f6ce11	56	/* Default empty table of attributes. */
5b634bfa	57
e3f6ce11	58	static const struct attribute_spec empty_attribute_table[] =
	59	{
	60	{ NULL, 0, 0, false, false, false, NULL }
	61	};
	62
5b634bfa	63	/* Return base name of the attribute. Ie '__attr__' is turned into 'attr'.
	64	To avoid need for copying, we simply return length of the string. */
	65
	66	static void
	67	extract_attribute_substring (struct substring *str)
	68	{
	69	if (str->length > 4 && str->str[0] == '_' && str->str[1] == '_'
	70	&& str->str[str->length - 1] == '_' && str->str[str->length - 2] == '_')
	71	{
	72	str->length -= 4;
	73	str->str += 2;
	74	}
	75	}
	76
	77	/* Simple hash function to avoid need to scan whole string. */
	78
	79	static inline hashval_t
	80	substring_hash (const char *str, int l)
	81	{
	82	return str[0] + str[l - 1] * 256 + l * 65536;
	83	}
	84
	85	/* Used for attribute_hash. */
	86
	87	static hashval_t
	88	hash_attr (const void *p)
	89	{
b7bf20db	90	const struct attribute_spec const spec = (const struct attribute_spec ) p;
b7bf20db	91	const int l = strlen (spec->name);
5b634bfa	92
	93	return substring_hash (spec->name, l);
	94	}
	95
	96	/* Used for attribute_hash. */
	97
	98	static int
	99	eq_attr (const void p, const void q)
	100	{
b7bf20db	101	const struct attribute_spec const spec = (const struct attribute_spec ) p;
b7bf20db	102	const struct substring const str = (const struct substring ) q;
5b634bfa	103
	104	return (!strncmp (spec->name, str->str, str->length) && !spec->name[str->length]);
	105	}
	106
e3f6ce11	107	/* Initialize attribute tables, and make some sanity checks
	108	if --enable-checking. */
	109
	110	static void
aecda0d6	111	init_attributes (void)
e3f6ce11	112	{
3585dac7	113	size_t i;
5b634bfa	114	int k;
e3f6ce11	115
f8e93a2e	116	attribute_tables[0] = lang_hooks.common_attribute_table;
	117	attribute_tables[1] = lang_hooks.attribute_table;
	118	attribute_tables[2] = lang_hooks.format_attribute_table;
e3f6ce11	119	attribute_tables[3] = targetm.attribute_table;
e3f6ce11	120
f8e93a2e	121	/* Translate NULL pointers to pointers to the empty table. */
	122	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
	123	if (attribute_tables[i] == NULL)
	124	attribute_tables[i] = empty_attribute_table;
	125
e3f6ce11	126	#ifdef ENABLE_CHECKING
e3f6ce11	127	/* Make some sanity checks on the attribute tables. */
3585dac7	128	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
e3f6ce11	129	{
	130	int j;
	131
	132	for (j = 0; attribute_tables[i][j].name != NULL; j++)
	133	{
	134	/* The name must not begin and end with __. */
	135	const char *name = attribute_tables[i][j].name;
	136	int len = strlen (name);
a0c938f0	137
64db345d	138	gcc_assert (!(name[0] == '_' && name[1] == '_'
64db345d	139	&& name[len - 1] == '_' && name[len - 2] == '_'));
a0c938f0	140
e3f6ce11	141	/* The minimum and maximum lengths must be consistent. */
64db345d	142	gcc_assert (attribute_tables[i][j].min_length >= 0);
a0c938f0	143
64db345d	144	gcc_assert (attribute_tables[i][j].max_length == -1
	145	\|\| (attribute_tables[i][j].max_length
	146	>= attribute_tables[i][j].min_length));
a0c938f0	147
e3f6ce11	148	/* An attribute cannot require both a DECL and a TYPE. */
64db345d	149	gcc_assert (!attribute_tables[i][j].decl_required
64db345d	150	\|\| !attribute_tables[i][j].type_required);
a0c938f0	151
e3f6ce11	152	/* If an attribute requires a function type, in particular
e3f6ce11	153	it requires a type. */
64db345d	154	gcc_assert (!attribute_tables[i][j].function_type_required
64db345d	155	\|\| attribute_tables[i][j].type_required);
e3f6ce11	156	}
	157	}
	158
	159	/* Check that each name occurs just once in each table. */
3585dac7	160	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
e3f6ce11	161	{
	162	int j, k;
	163	for (j = 0; attribute_tables[i][j].name != NULL; j++)
	164	for (k = j + 1; attribute_tables[i][k].name != NULL; k++)
64db345d	165	gcc_assert (strcmp (attribute_tables[i][j].name,
64db345d	166	attribute_tables[i][k].name));
e3f6ce11	167	}
e3f6ce11	168	/* Check that no name occurs in more than one table. */
3585dac7	169	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
e3f6ce11	170	{
3585dac7	171	size_t j, k, l;
e3f6ce11	172
3585dac7	173	for (j = i + 1; j < ARRAY_SIZE (attribute_tables); j++)
e3f6ce11	174	for (k = 0; attribute_tables[i][k].name != NULL; k++)
e3f6ce11	175	for (l = 0; attribute_tables[j][l].name != NULL; l++)
64db345d	176	gcc_assert (strcmp (attribute_tables[i][k].name,
64db345d	177	attribute_tables[j][l].name));
e3f6ce11	178	}
	179	#endif
	180
5b634bfa	181	attribute_hash = htab_create (200, hash_attr, eq_attr, NULL);
	182	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
	183	for (k = 0; attribute_tables[i][k].name != NULL; k++)
	184	{
	185	struct substring str;
b7bf20db	186	const void **slot;
5b634bfa	187
	188	str.str = attribute_tables[i][k].name;
	189	str.length = strlen (attribute_tables[i][k].name);
b7bf20db	190	slot = (const void **)htab_find_slot_with_hash (attribute_hash, &str,
5b634bfa	191	substring_hash (str.str, str.length),
	192	INSERT);
	193	gcc_assert (!*slot);
b7bf20db	194	*slot = &attribute_tables[i][k];
5b634bfa	195	}
e3f6ce11	196	attributes_initialized = true;
e3f6ce11	197	}
2fdd6488	198
	199	/* Return the spec for the attribute named NAME. */
	200
	201	const struct attribute_spec *
	202	lookup_attribute_spec (tree name)
	203	{
	204	struct substring attr;
	205
	206	attr.str = IDENTIFIER_POINTER (name);
	207	attr.length = IDENTIFIER_LENGTH (name);
	208	extract_attribute_substring (&attr);
	209	return htab_find_with_hash (attribute_hash, &attr,
	210	substring_hash (attr.str, attr.length));
	211	}
e3f6ce11	212	\f
	213	/* Process the attributes listed in ATTRIBUTES and install them in *NODE,
	214	which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL,
	215	it should be modified in place; if a TYPE, a copy should be created
	216	unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further
	217	information, in the form of a bitwise OR of flags in enum attribute_flags
	218	from tree.h. Depending on these flags, some attributes may be
	219	returned to be applied at a later stage (for example, to apply
101cc430	220	a decl attribute to the declaration rather than to its type). */
e3f6ce11	221
e3f6ce11	222	tree
aecda0d6	223	decl_attributes (tree *node, tree attributes, int flags)
e3f6ce11	224	{
	225	tree a;
	226	tree returned_attrs = NULL_TREE;
	227
1ccba7b7	228	if (TREE_TYPE (*node) == error_mark_node)
	229	return NULL_TREE;
	230
e3f6ce11	231	if (!attributes_initialized)
	232	init_attributes ();
	233
883b2e73	234	targetm.insert_attributes (*node, &attributes);
e3f6ce11	235
	236	for (a = attributes; a; a = TREE_CHAIN (a))
	237	{
	238	tree name = TREE_PURPOSE (a);
	239	tree args = TREE_VALUE (a);
	240	tree *anode = node;
2fdd6488	241	const struct attribute_spec *spec = lookup_attribute_spec (name);
e3f6ce11	242	bool no_add_attrs = 0;
79bdd5ff	243	tree fn_ptr_tmp = NULL_TREE;
e3f6ce11	244
	245	if (spec == NULL)
	246	{
9b2d6d13	247	warning (OPT_Wattributes, "%qs attribute directive ignored",
e3f6ce11	248	IDENTIFIER_POINTER (name));
	249	continue;
	250	}
	251	else if (list_length (args) < spec->min_length
	252	\|\| (spec->max_length >= 0
	253	&& list_length (args) > spec->max_length))
	254	{
eb586f2c	255	error ("wrong number of arguments specified for %qs attribute",
e3f6ce11	256	IDENTIFIER_POINTER (name));
	257	continue;
	258	}
5b634bfa	259	gcc_assert (is_attribute_p (spec->name, name));
e3f6ce11	260
	261	if (spec->decl_required && !DECL_P (*anode))
	262	{
	263	if (flags & ((int) ATTR_FLAG_DECL_NEXT
	264	\| (int) ATTR_FLAG_FUNCTION_NEXT
	265	\| (int) ATTR_FLAG_ARRAY_NEXT))
	266	{
	267	/* Pass on this attribute to be tried again. */
	268	returned_attrs = tree_cons (name, args, returned_attrs);
	269	continue;
	270	}
	271	else
	272	{
9b2d6d13	273	warning (OPT_Wattributes, "%qs attribute does not apply to types",
e3f6ce11	274	IDENTIFIER_POINTER (name));
	275	continue;
	276	}
	277	}
	278
aa9c60c1	279	/* If we require a type, but were passed a decl, set up to make a
	280	new type and update the one in the decl. ATTR_FLAG_TYPE_IN_PLACE
	281	would have applied if we'd been passed a type, but we cannot modify
	282	the decl's type in place here. */
e3f6ce11	283	if (spec->type_required && DECL_P (*anode))
aa9c60c1	284	{
aa9c60c1	285	anode = &TREE_TYPE (*anode);
3ef0a05e	286	/* Allow ATTR_FLAG_TYPE_IN_PLACE for the type's naming decl. */
	287	if (!(TREE_CODE (*anode) == TYPE_DECL
	288	&& *anode == TYPE_NAME (TYPE_MAIN_VARIANT
	289	(TREE_TYPE (*anode)))))
	290	flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
aa9c60c1	291	}
e3f6ce11	292
	293	if (spec->function_type_required && TREE_CODE (*anode) != FUNCTION_TYPE
	294	&& TREE_CODE (*anode) != METHOD_TYPE)
	295	{
	296	if (TREE_CODE (*anode) == POINTER_TYPE
	297	&& (TREE_CODE (TREE_TYPE (*anode)) == FUNCTION_TYPE
	298	\|\| TREE_CODE (TREE_TYPE (*anode)) == METHOD_TYPE))
	299	{
79bdd5ff	300	/* OK, this is a bit convoluted. We can't just make a copy
	301	of the pointer type and modify its TREE_TYPE, because if
	302	we change the attributes of the target type the pointer
	303	type needs to have a different TYPE_MAIN_VARIANT. So we
	304	pull out the target type now, frob it as appropriate, and
	305	rebuild the pointer type later.
	306
a0c938f0	307	This would all be simpler if attributes were part of the
a0c938f0	308	declarator, grumble grumble. */
79bdd5ff	309	fn_ptr_tmp = TREE_TYPE (*anode);
	310	anode = &fn_ptr_tmp;
	311	flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
e3f6ce11	312	}
	313	else if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
	314	{
	315	/* Pass on this attribute to be tried again. */
	316	returned_attrs = tree_cons (name, args, returned_attrs);
	317	continue;
	318	}
	319
	320	if (TREE_CODE (*anode) != FUNCTION_TYPE
	321	&& TREE_CODE (*anode) != METHOD_TYPE)
	322	{
9b2d6d13	323	warning (OPT_Wattributes,
9b2d6d13	324	"%qs attribute only applies to function types",
e3f6ce11	325	IDENTIFIER_POINTER (name));
	326	continue;
	327	}
	328	}
	329
4a2849cb	330	if (TYPE_P (*anode)
	331	&& (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
	332	&& TYPE_SIZE (*anode) != NULL_TREE)
	333	{
	334	warning (OPT_Wattributes, "type attributes ignored after type is already defined");
	335	continue;
	336	}
	337
e3f6ce11	338	if (spec->handler != NULL)
	339	returned_attrs = chainon ((*spec->handler) (anode, name, args,
	340	flags, &no_add_attrs),
	341	returned_attrs);
ae4718db	342
	343	/* Layout the decl in case anything changed. */
	344	if (spec->type_required && DECL_P (*node)
e56de52f	345	&& (TREE_CODE (*node) == VAR_DECL
	346	\|\| TREE_CODE (*node) == PARM_DECL
	347	\|\| TREE_CODE (*node) == RESULT_DECL))
1c0a6d1e	348	relayout_decl (*node);
ae4718db	349
e3f6ce11	350	if (!no_add_attrs)
	351	{
	352	tree old_attrs;
	353	tree a;
	354
	355	if (DECL_P (*anode))
	356	old_attrs = DECL_ATTRIBUTES (*anode);
	357	else
	358	old_attrs = TYPE_ATTRIBUTES (*anode);
	359
	360	for (a = lookup_attribute (spec->name, old_attrs);
	361	a != NULL_TREE;
	362	a = lookup_attribute (spec->name, TREE_CHAIN (a)))
	363	{
	364	if (simple_cst_equal (TREE_VALUE (a), args) == 1)
	365	break;
	366	}
	367
	368	if (a == NULL_TREE)
	369	{
	370	/* This attribute isn't already in the list. */
	371	if (DECL_P (*anode))
	372	DECL_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
	373	else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
316e17ae	374	{
	375	TYPE_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
	376	/* If this is the main variant, also push the attributes
	377	out to the other variants. */
	378	if (anode == TYPE_MAIN_VARIANT (anode))
	379	{
	380	tree variant;
	381	for (variant = *anode; variant;
	382	variant = TYPE_NEXT_VARIANT (variant))
	383	{
	384	if (TYPE_ATTRIBUTES (variant) == old_attrs)
	385	TYPE_ATTRIBUTES (variant)
	386	= TYPE_ATTRIBUTES (*anode);
	387	else if (!lookup_attribute
	388	(spec->name, TYPE_ATTRIBUTES (variant)))
	389	TYPE_ATTRIBUTES (variant) = tree_cons
	390	(name, args, TYPE_ATTRIBUTES (variant));
	391	}
	392	}
	393	}
e3f6ce11	394	else
	395	anode = build_type_attribute_variant (anode,
	396	tree_cons (name, args,
	397	old_attrs));
	398	}
	399	}
79bdd5ff	400
	401	if (fn_ptr_tmp)
	402	{
	403	/* Rebuild the function pointer type and put it in the
	404	appropriate place. */
	405	fn_ptr_tmp = build_pointer_type (fn_ptr_tmp);
	406	if (DECL_P (*node))
	407	TREE_TYPE (*node) = fn_ptr_tmp;
79bdd5ff	408	else
64db345d	409	{
	410	gcc_assert (TREE_CODE (*node) == POINTER_TYPE);
	411	*node = fn_ptr_tmp;
	412	}
79bdd5ff	413	}
e3f6ce11	414	}
	415
	416	return returned_attrs;
	417	}