[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, 2008, 2009 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"
#include "plugin.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++)
      {
        register_attribute (&attribute_tables[i][k]);
      }
  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)
{
  struct substring str;
  void **slot;

  str.str = attr->name;
  str.length = strlen (str.str);
  slot = htab_find_slot_with_hash (attribute_hash, &str,
				   substring_hash (str.str, str.length),
				   INSERT);
  gcc_assert (!*slot);
  *slot = (void *) CONST_CAST (struct attribute_spec *, attr);
}

/* 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 (const struct attribute_spec *)
    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 ();

  /* 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));
    }

  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, "%qE attribute directive ignored",
		   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 %qE attribute",
		 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, "%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);
	  /* 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,
		       "%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;
	}

      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,
402ba866	3	2002, 2003, 2004, 2005, 2007, 2008, 2009 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"
e3fced1a	36	#include "plugin.h"
e3f6ce11	37
aecda0d6	38	static void init_attributes (void);
e3f6ce11	39
f8e93a2e	40	/* Table of the tables of attributes (common, language, format, machine)
e3f6ce11	41	searched. */
	42	static const struct attribute_spec *attribute_tables[4];
	43
5b634bfa	44	/* Hashtable mapping names (represented as substrings) to attribute specs. */
	45	static htab_t attribute_hash;
	46
	47	/* Substring representation. */
	48
	49	struct substring
	50	{
	51	const char *str;
	52	int length;
	53	};
	54
e3f6ce11	55	static bool attributes_initialized = false;
e3f6ce11	56
e3f6ce11	57	/* Default empty table of attributes. */
5b634bfa	58
e3f6ce11	59	static const struct attribute_spec empty_attribute_table[] =
	60	{
	61	{ NULL, 0, 0, false, false, false, NULL }
	62	};
	63
5b634bfa	64	/* Return base name of the attribute. Ie '__attr__' is turned into 'attr'.
	65	To avoid need for copying, we simply return length of the string. */
	66
	67	static void
	68	extract_attribute_substring (struct substring *str)
	69	{
	70	if (str->length > 4 && str->str[0] == '_' && str->str[1] == '_'
	71	&& str->str[str->length - 1] == '_' && str->str[str->length - 2] == '_')
	72	{
	73	str->length -= 4;
	74	str->str += 2;
	75	}
	76	}
	77
	78	/* Simple hash function to avoid need to scan whole string. */
	79
	80	static inline hashval_t
	81	substring_hash (const char *str, int l)
	82	{
	83	return str[0] + str[l - 1] * 256 + l * 65536;
	84	}
	85
	86	/* Used for attribute_hash. */
	87
	88	static hashval_t
	89	hash_attr (const void *p)
	90	{
b7bf20db	91	const struct attribute_spec const spec = (const struct attribute_spec ) p;
b7bf20db	92	const int l = strlen (spec->name);
5b634bfa	93
	94	return substring_hash (spec->name, l);
	95	}
	96
	97	/* Used for attribute_hash. */
	98
	99	static int
	100	eq_attr (const void p, const void q)
	101	{
b7bf20db	102	const struct attribute_spec const spec = (const struct attribute_spec ) p;
b7bf20db	103	const struct substring const str = (const struct substring ) q;
5b634bfa	104
	105	return (!strncmp (spec->name, str->str, str->length) && !spec->name[str->length]);
	106	}
	107
e3f6ce11	108	/* Initialize attribute tables, and make some sanity checks
	109	if --enable-checking. */
	110
	111	static void
aecda0d6	112	init_attributes (void)
e3f6ce11	113	{
3585dac7	114	size_t i;
5b634bfa	115	int k;
e3f6ce11	116
f8e93a2e	117	attribute_tables[0] = lang_hooks.common_attribute_table;
	118	attribute_tables[1] = lang_hooks.attribute_table;
	119	attribute_tables[2] = lang_hooks.format_attribute_table;
e3f6ce11	120	attribute_tables[3] = targetm.attribute_table;
e3f6ce11	121
f8e93a2e	122	/* Translate NULL pointers to pointers to the empty table. */
	123	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
	124	if (attribute_tables[i] == NULL)
	125	attribute_tables[i] = empty_attribute_table;
	126
e3f6ce11	127	#ifdef ENABLE_CHECKING
e3f6ce11	128	/* Make some sanity checks on the attribute tables. */
3585dac7	129	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
e3f6ce11	130	{
	131	int j;
	132
	133	for (j = 0; attribute_tables[i][j].name != NULL; j++)
	134	{
	135	/* The name must not begin and end with __. */
	136	const char *name = attribute_tables[i][j].name;
	137	int len = strlen (name);
a0c938f0	138
64db345d	139	gcc_assert (!(name[0] == '_' && name[1] == '_'
64db345d	140	&& name[len - 1] == '_' && name[len - 2] == '_'));
a0c938f0	141
e3f6ce11	142	/* The minimum and maximum lengths must be consistent. */
64db345d	143	gcc_assert (attribute_tables[i][j].min_length >= 0);
a0c938f0	144
64db345d	145	gcc_assert (attribute_tables[i][j].max_length == -1
	146	\|\| (attribute_tables[i][j].max_length
	147	>= attribute_tables[i][j].min_length));
a0c938f0	148
e3f6ce11	149	/* An attribute cannot require both a DECL and a TYPE. */
64db345d	150	gcc_assert (!attribute_tables[i][j].decl_required
64db345d	151	\|\| !attribute_tables[i][j].type_required);
a0c938f0	152
e3f6ce11	153	/* If an attribute requires a function type, in particular
e3f6ce11	154	it requires a type. */
64db345d	155	gcc_assert (!attribute_tables[i][j].function_type_required
64db345d	156	\|\| attribute_tables[i][j].type_required);
e3f6ce11	157	}
	158	}
	159
	160	/* Check that each name occurs just once in each table. */
3585dac7	161	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
e3f6ce11	162	{
	163	int j, k;
	164	for (j = 0; attribute_tables[i][j].name != NULL; j++)
	165	for (k = j + 1; attribute_tables[i][k].name != NULL; k++)
64db345d	166	gcc_assert (strcmp (attribute_tables[i][j].name,
64db345d	167	attribute_tables[i][k].name));
e3f6ce11	168	}
e3f6ce11	169	/* Check that no name occurs in more than one table. */
3585dac7	170	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
e3f6ce11	171	{
3585dac7	172	size_t j, k, l;
e3f6ce11	173
3585dac7	174	for (j = i + 1; j < ARRAY_SIZE (attribute_tables); j++)
e3f6ce11	175	for (k = 0; attribute_tables[i][k].name != NULL; k++)
e3f6ce11	176	for (l = 0; attribute_tables[j][l].name != NULL; l++)
64db345d	177	gcc_assert (strcmp (attribute_tables[i][k].name,
64db345d	178	attribute_tables[j][l].name));
e3f6ce11	179	}
	180	#endif
	181
5b634bfa	182	attribute_hash = htab_create (200, hash_attr, eq_attr, NULL);
	183	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
	184	for (k = 0; attribute_tables[i][k].name != NULL; k++)
	185	{
e3fced1a	186	register_attribute (&attribute_tables[i][k]);
	187	}
	188	invoke_plugin_callbacks (PLUGIN_ATTRIBUTES, NULL);
	189	attributes_initialized = true;
	190	}
	191
	192	/* Insert a single ATTR into the attribute table. */
	193
	194	void
48e1416a	195	register_attribute (const struct attribute_spec *attr)
e3fced1a	196	{
4fb84273	197	struct substring str;
402ba866	198	void **slot;
4fb84273	199
	200	str.str = attr->name;
	201	str.length = strlen (str.str);
402ba866	202	slot = htab_find_slot_with_hash (attribute_hash, &str,
	203	substring_hash (str.str, str.length),
	204	INSERT);
4fb84273	205	gcc_assert (!*slot);
402ba866	206	slot = (void ) CONST_CAST (struct attribute_spec *, attr);
e3f6ce11	207	}
2fdd6488	208
	209	/* Return the spec for the attribute named NAME. */
	210
	211	const struct attribute_spec *
	212	lookup_attribute_spec (tree name)
	213	{
	214	struct substring attr;
	215
	216	attr.str = IDENTIFIER_POINTER (name);
	217	attr.length = IDENTIFIER_LENGTH (name);
	218	extract_attribute_substring (&attr);
364c0c59	219	return (const struct attribute_spec *)
	220	htab_find_with_hash (attribute_hash, &attr,
	221	substring_hash (attr.str, attr.length));
2fdd6488	222	}
e3f6ce11	223	\f
	224	/* Process the attributes listed in ATTRIBUTES and install them in *NODE,
	225	which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL,
	226	it should be modified in place; if a TYPE, a copy should be created
	227	unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further
	228	information, in the form of a bitwise OR of flags in enum attribute_flags
	229	from tree.h. Depending on these flags, some attributes may be
	230	returned to be applied at a later stage (for example, to apply
101cc430	231	a decl attribute to the declaration rather than to its type). */
e3f6ce11	232
e3f6ce11	233	tree
aecda0d6	234	decl_attributes (tree *node, tree attributes, int flags)
e3f6ce11	235	{
	236	tree a;
	237	tree returned_attrs = NULL_TREE;
	238
1ccba7b7	239	if (TREE_TYPE (*node) == error_mark_node)
	240	return NULL_TREE;
	241
e3f6ce11	242	if (!attributes_initialized)
	243	init_attributes ();
	244
46f8e3b0	245	/* If this is a function and the user used #pragma GCC optimize, add the
	246	options to the attribute((optimize(...))) list. */
	247	if (TREE_CODE (*node) == FUNCTION_DECL && current_optimize_pragma)
	248	{
	249	tree cur_attr = lookup_attribute ("optimize", attributes);
	250	tree opts = copy_list (current_optimize_pragma);
	251
	252	if (! cur_attr)
	253	attributes
	254	= tree_cons (get_identifier ("optimize"), opts, attributes);
	255	else
	256	TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
	257	}
	258
	259	if (TREE_CODE (*node) == FUNCTION_DECL
	260	&& optimization_current_node != optimization_default_node
	261	&& !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node))
	262	DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node) = optimization_current_node;
	263
24470055	264	/* If this is a function and the user used #pragma GCC target, add the
24470055	265	options to the attribute((target(...))) list. */
46f8e3b0	266	if (TREE_CODE (*node) == FUNCTION_DECL
24470055	267	&& current_target_pragma
46f8e3b0	268	&& targetm.target_option.valid_attribute_p (*node, NULL_TREE,
24470055	269	current_target_pragma, 0))
46f8e3b0	270	{
24470055	271	tree cur_attr = lookup_attribute ("target", attributes);
24470055	272	tree opts = copy_list (current_target_pragma);
46f8e3b0	273
46f8e3b0	274	if (! cur_attr)
24470055	275	attributes = tree_cons (get_identifier ("target"), opts, attributes);
46f8e3b0	276	else
	277	TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
	278	}
	279
883b2e73	280	targetm.insert_attributes (*node, &attributes);
e3f6ce11	281
	282	for (a = attributes; a; a = TREE_CHAIN (a))
	283	{
	284	tree name = TREE_PURPOSE (a);
	285	tree args = TREE_VALUE (a);
	286	tree *anode = node;
2fdd6488	287	const struct attribute_spec *spec = lookup_attribute_spec (name);
e3f6ce11	288	bool no_add_attrs = 0;
79bdd5ff	289	tree fn_ptr_tmp = NULL_TREE;
e3f6ce11	290
	291	if (spec == NULL)
	292	{
abd3e6b5	293	warning (OPT_Wattributes, "%qE attribute directive ignored",
abd3e6b5	294	name);
e3f6ce11	295	continue;
	296	}
	297	else if (list_length (args) < spec->min_length
	298	\|\| (spec->max_length >= 0
	299	&& list_length (args) > spec->max_length))
	300	{
abd3e6b5	301	error ("wrong number of arguments specified for %qE attribute",
abd3e6b5	302	name);
e3f6ce11	303	continue;
e3f6ce11	304	}
5b634bfa	305	gcc_assert (is_attribute_p (spec->name, name));
e3f6ce11	306
	307	if (spec->decl_required && !DECL_P (*anode))
	308	{
	309	if (flags & ((int) ATTR_FLAG_DECL_NEXT
	310	\| (int) ATTR_FLAG_FUNCTION_NEXT
	311	\| (int) ATTR_FLAG_ARRAY_NEXT))
	312	{
	313	/* Pass on this attribute to be tried again. */
	314	returned_attrs = tree_cons (name, args, returned_attrs);
	315	continue;
	316	}
	317	else
	318	{
abd3e6b5	319	warning (OPT_Wattributes, "%qE attribute does not apply to types",
abd3e6b5	320	name);
e3f6ce11	321	continue;
	322	}
	323	}
	324
aa9c60c1	325	/* If we require a type, but were passed a decl, set up to make a
	326	new type and update the one in the decl. ATTR_FLAG_TYPE_IN_PLACE
	327	would have applied if we'd been passed a type, but we cannot modify
	328	the decl's type in place here. */
e3f6ce11	329	if (spec->type_required && DECL_P (*anode))
aa9c60c1	330	{
aa9c60c1	331	anode = &TREE_TYPE (*anode);
3ef0a05e	332	/* Allow ATTR_FLAG_TYPE_IN_PLACE for the type's naming decl. */
	333	if (!(TREE_CODE (*anode) == TYPE_DECL
	334	&& *anode == TYPE_NAME (TYPE_MAIN_VARIANT
	335	(TREE_TYPE (*anode)))))
	336	flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
aa9c60c1	337	}
e3f6ce11	338
	339	if (spec->function_type_required && TREE_CODE (*anode) != FUNCTION_TYPE
	340	&& TREE_CODE (*anode) != METHOD_TYPE)
	341	{
	342	if (TREE_CODE (*anode) == POINTER_TYPE
	343	&& (TREE_CODE (TREE_TYPE (*anode)) == FUNCTION_TYPE
	344	\|\| TREE_CODE (TREE_TYPE (*anode)) == METHOD_TYPE))
	345	{
79bdd5ff	346	/* OK, this is a bit convoluted. We can't just make a copy
	347	of the pointer type and modify its TREE_TYPE, because if
	348	we change the attributes of the target type the pointer
	349	type needs to have a different TYPE_MAIN_VARIANT. So we
	350	pull out the target type now, frob it as appropriate, and
	351	rebuild the pointer type later.
	352
a0c938f0	353	This would all be simpler if attributes were part of the
a0c938f0	354	declarator, grumble grumble. */
79bdd5ff	355	fn_ptr_tmp = TREE_TYPE (*anode);
	356	anode = &fn_ptr_tmp;
	357	flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
e3f6ce11	358	}
	359	else if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
	360	{
	361	/* Pass on this attribute to be tried again. */
	362	returned_attrs = tree_cons (name, args, returned_attrs);
	363	continue;
	364	}
	365
	366	if (TREE_CODE (*anode) != FUNCTION_TYPE
	367	&& TREE_CODE (*anode) != METHOD_TYPE)
	368	{
9b2d6d13	369	warning (OPT_Wattributes,
abd3e6b5	370	"%qE attribute only applies to function types",
abd3e6b5	371	name);
e3f6ce11	372	continue;
	373	}
	374	}
	375
4a2849cb	376	if (TYPE_P (*anode)
	377	&& (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
	378	&& TYPE_SIZE (*anode) != NULL_TREE)
	379	{
	380	warning (OPT_Wattributes, "type attributes ignored after type is already defined");
	381	continue;
	382	}
	383
e3f6ce11	384	if (spec->handler != NULL)
	385	returned_attrs = chainon ((*spec->handler) (anode, name, args,
	386	flags, &no_add_attrs),
	387	returned_attrs);
ae4718db	388
	389	/* Layout the decl in case anything changed. */
	390	if (spec->type_required && DECL_P (*node)
e56de52f	391	&& (TREE_CODE (*node) == VAR_DECL
	392	\|\| TREE_CODE (*node) == PARM_DECL
	393	\|\| TREE_CODE (*node) == RESULT_DECL))
1c0a6d1e	394	relayout_decl (*node);
ae4718db	395
e3f6ce11	396	if (!no_add_attrs)
	397	{
	398	tree old_attrs;
	399	tree a;
	400
	401	if (DECL_P (*anode))
	402	old_attrs = DECL_ATTRIBUTES (*anode);
	403	else
	404	old_attrs = TYPE_ATTRIBUTES (*anode);
	405
	406	for (a = lookup_attribute (spec->name, old_attrs);
	407	a != NULL_TREE;
	408	a = lookup_attribute (spec->name, TREE_CHAIN (a)))
	409	{
	410	if (simple_cst_equal (TREE_VALUE (a), args) == 1)
	411	break;
	412	}
	413
	414	if (a == NULL_TREE)
	415	{
	416	/* This attribute isn't already in the list. */
	417	if (DECL_P (*anode))
	418	DECL_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
	419	else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
316e17ae	420	{
	421	TYPE_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
	422	/* If this is the main variant, also push the attributes
	423	out to the other variants. */
	424	if (anode == TYPE_MAIN_VARIANT (anode))
	425	{
	426	tree variant;
	427	for (variant = *anode; variant;
	428	variant = TYPE_NEXT_VARIANT (variant))
	429	{
	430	if (TYPE_ATTRIBUTES (variant) == old_attrs)
	431	TYPE_ATTRIBUTES (variant)
	432	= TYPE_ATTRIBUTES (*anode);
	433	else if (!lookup_attribute
	434	(spec->name, TYPE_ATTRIBUTES (variant)))
	435	TYPE_ATTRIBUTES (variant) = tree_cons
	436	(name, args, TYPE_ATTRIBUTES (variant));
	437	}
	438	}
	439	}
e3f6ce11	440	else
	441	anode = build_type_attribute_variant (anode,
	442	tree_cons (name, args,
	443	old_attrs));
	444	}
	445	}
79bdd5ff	446
	447	if (fn_ptr_tmp)
	448	{
	449	/* Rebuild the function pointer type and put it in the
	450	appropriate place. */
	451	fn_ptr_tmp = build_pointer_type (fn_ptr_tmp);
	452	if (DECL_P (*node))
	453	TREE_TYPE (*node) = fn_ptr_tmp;
79bdd5ff	454	else
64db345d	455	{
	456	gcc_assert (TREE_CODE (*node) == POINTER_TYPE);
	457	*node = fn_ptr_tmp;
	458	}
79bdd5ff	459	}
e3f6ce11	460	}
	461
	462	return returned_attrs;
	463	}