[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 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 2, 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 COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.  */

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

static void init_attributes		PARAMS ((void));

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

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 }
};

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

static void
init_attributes ()
{
  size_t i;

  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);
	  if (name[0] == '_' && name[1] == '_'
	      && name[len - 1] == '_' && name[len - 2] == '_')
	    abort ();
	  /* The minimum and maximum lengths must be consistent.  */
	  if (attribute_tables[i][j].min_length < 0)
	    abort ();
	  if (attribute_tables[i][j].max_length != -1
	      && (attribute_tables[i][j].max_length
		  < attribute_tables[i][j].min_length))
	    abort ();
	  /* An attribute cannot require both a DECL and a TYPE.  */
	  if (attribute_tables[i][j].decl_required
	      && attribute_tables[i][j].type_required)
	    abort ();
	  /* If an attribute requires a function type, in particular
	     it requires a type.  */
	  if (attribute_tables[i][j].function_type_required
	      && !attribute_tables[i][j].type_required)
	    abort ();
	}
    }

  /* 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++)
	  if (!strcmp (attribute_tables[i][j].name,
		       attribute_tables[i][k].name))
	    abort ();
    }
  /* 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++)
	    if (!strcmp (attribute_tables[i][k].name,
			 attribute_tables[j][l].name))
	      abort ();
    }
#endif

  attributes_initialized = true;
}
\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).  If
   ATTR_FLAG_BUILT_IN is not set and *NODE is a DECL, then also consider
   whether there might be some default attributes to apply to this DECL;
   if so, decl_attributes will be called recursively with those attributes
   and ATTR_FLAG_BUILT_IN set.  */

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

  if (!attributes_initialized)
    init_attributes ();

  (*targetm.insert_attributes) (*node, &attributes);

  if (DECL_P (*node) && TREE_CODE (*node) == FUNCTION_DECL
      && !(flags & (int) ATTR_FLAG_BUILT_IN))
    (*lang_hooks.insert_default_attributes) (*node);

  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 = NULL;
      bool no_add_attrs = 0;
      size_t i;

      for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
	{
	  int j;

	  for (j = 0; attribute_tables[i][j].name != NULL; j++)
	    {
	      if (is_attribute_p (attribute_tables[i][j].name, name))
		{
		  spec = &attribute_tables[i][j];
		  break;
		}
	    }
	  if (spec != NULL)
	    break;
	}

      if (spec == NULL)
	{
	  warning ("`%s' 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 `%s' attribute",
		 IDENTIFIER_POINTER (name));
	  continue;
	}

      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 ("`%s' 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);
	  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))
	    {
	      if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
		*anode = build_type_copy (*anode);
	      anode = &TREE_TYPE (*anode);
	    }
	  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 ("`%s' attribute only applies to function types",
		       IDENTIFIER_POINTER (name));
	      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))
	{
	  /* Force a recalculation of mode and size.  */
	  DECL_MODE (*node) = VOIDmode;
	  DECL_SIZE (*node) = 0;

	  layout_decl (*node, 0);
	}

      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);
	      else
		*anode = build_type_attribute_variant (*anode,
						       tree_cons (name, args,
								  old_attrs));
	    }
	}
    }

  return returned_attrs;
}

/* Split SPECS_ATTRS, a list of declspecs and prefix attributes, into two
   lists.  SPECS_ATTRS may also be just a typespec (eg: RECORD_TYPE).

   The head of the declspec list is stored in DECLSPECS.
   The head of the attribute list is stored in PREFIX_ATTRIBUTES.

   Note that attributes in SPECS_ATTRS are stored in the TREE_PURPOSE of
   the list elements.  We drop the containing TREE_LIST nodes and link the
   resulting attributes together the way decl_attributes expects them.  */

void
split_specs_attrs (specs_attrs, declspecs, prefix_attributes)
     tree specs_attrs;
     tree *declspecs, *prefix_attributes;
{
  tree t, s, a, next, specs, attrs;

  /* This can happen after an __extension__ in pedantic mode.  */
  if (specs_attrs != NULL_TREE
      && TREE_CODE (specs_attrs) == INTEGER_CST)
    {
      *declspecs = NULL_TREE;
      *prefix_attributes = NULL_TREE;
      return;
    }

  /* This can happen in c++ (eg: decl: typespec initdecls ';').  */
  if (specs_attrs != NULL_TREE
      && TREE_CODE (specs_attrs) != TREE_LIST)
    {
      *declspecs = specs_attrs;
      *prefix_attributes = NULL_TREE;
      return;
    }

  /* Remember to keep the lists in the same order, element-wise.  */

  specs = s = NULL_TREE;
  attrs = a = NULL_TREE;
  for (t = specs_attrs; t; t = next)
    {
      next = TREE_CHAIN (t);
      /* Declspecs have a non-NULL TREE_VALUE.  */
      if (TREE_VALUE (t) != NULL_TREE)
	{
	  if (specs == NULL_TREE)
	    specs = s = t;
	  else
	    {
	      TREE_CHAIN (s) = t;
	      s = t;
	    }
	}
      /* The TREE_PURPOSE may also be empty in the case of
	 __attribute__(()).  */
      else if (TREE_PURPOSE (t) != NULL_TREE)
	{
	  if (attrs == NULL_TREE)
	    attrs = a = TREE_PURPOSE (t);
	  else
	    {
	      TREE_CHAIN (a) = TREE_PURPOSE (t);
	      a = TREE_PURPOSE (t);
	    }
	  /* More attrs can be linked here, move A to the end.  */
	  while (TREE_CHAIN (a) != NULL_TREE)
	    a = TREE_CHAIN (a);
	}
    }

  /* Terminate the lists.  */
  if (s != NULL_TREE)
    TREE_CHAIN (s) = NULL_TREE;
  if (a != NULL_TREE)
    TREE_CHAIN (a) = NULL_TREE;

  /* All done.  */
  *declspecs = specs;
  *prefix_attributes = attrs;
}

/* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
   This function is used by the parser when a rule will accept attributes
   in a particular position, but we don't want to support that just yet.

   A warning is issued for every ignored attribute.  */

tree
strip_attrs (specs_attrs)
     tree specs_attrs;
{
  tree specs, attrs;

  split_specs_attrs (specs_attrs, &specs, &attrs);

  while (attrs)
    {
      warning ("`%s' attribute ignored",
	       IDENTIFIER_POINTER (TREE_PURPOSE (attrs)));
      attrs = TREE_CHAIN (attrs);
    }

  return specs;
}
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,
80fabb90	3	2002 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
	9	Software Foundation; either version 2, or (at your option) any later
	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
	18	along with GCC; see the file COPYING. If not, write to the Free
	19	Software Foundation, 59 Temple Place - Suite 330, Boston, MA
	20	02111-1307, USA. */
	21
	22	#include "config.h"
	23	#include "system.h"
	24	#include "tree.h"
	25	#include "flags.h"
	26	#include "toplev.h"
	27	#include "output.h"
	28	#include "rtl.h"
	29	#include "ggc.h"
	30	#include "expr.h"
	31	#include "tm_p.h"
e3f6ce11	32	#include "cpplib.h"
e3f6ce11	33	#include "target.h"
26ca6c20	34	#include "langhooks.h"
e3f6ce11	35
	36	static void init_attributes PARAMS ((void));
	37
f8e93a2e	38	/* Table of the tables of attributes (common, language, format, machine)
e3f6ce11	39	searched. */
	40	static const struct attribute_spec *attribute_tables[4];
	41
	42	static bool attributes_initialized = false;
	43
e3f6ce11	44	/* Default empty table of attributes. */
	45	static const struct attribute_spec empty_attribute_table[] =
	46	{
	47	{ NULL, 0, 0, false, false, false, NULL }
	48	};
	49
e3f6ce11	50	/* Initialize attribute tables, and make some sanity checks
	51	if --enable-checking. */
	52
	53	static void
	54	init_attributes ()
	55	{
3585dac7	56	size_t i;
e3f6ce11	57
f8e93a2e	58	attribute_tables[0] = lang_hooks.common_attribute_table;
	59	attribute_tables[1] = lang_hooks.attribute_table;
	60	attribute_tables[2] = lang_hooks.format_attribute_table;
e3f6ce11	61	attribute_tables[3] = targetm.attribute_table;
e3f6ce11	62
f8e93a2e	63	/* Translate NULL pointers to pointers to the empty table. */
	64	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
	65	if (attribute_tables[i] == NULL)
	66	attribute_tables[i] = empty_attribute_table;
	67
e3f6ce11	68	#ifdef ENABLE_CHECKING
e3f6ce11	69	/* Make some sanity checks on the attribute tables. */
3585dac7	70	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
e3f6ce11	71	{
	72	int j;
	73
	74	for (j = 0; attribute_tables[i][j].name != NULL; j++)
	75	{
	76	/* The name must not begin and end with __. */
	77	const char *name = attribute_tables[i][j].name;
	78	int len = strlen (name);
	79	if (name[0] == '_' && name[1] == '_'
	80	&& name[len - 1] == '_' && name[len - 2] == '_')
	81	abort ();
	82	/* The minimum and maximum lengths must be consistent. */
	83	if (attribute_tables[i][j].min_length < 0)
	84	abort ();
	85	if (attribute_tables[i][j].max_length != -1
	86	&& (attribute_tables[i][j].max_length
	87	< attribute_tables[i][j].min_length))
	88	abort ();
	89	/* An attribute cannot require both a DECL and a TYPE. */
	90	if (attribute_tables[i][j].decl_required
	91	&& attribute_tables[i][j].type_required)
	92	abort ();
	93	/* If an attribute requires a function type, in particular
	94	it requires a type. */
	95	if (attribute_tables[i][j].function_type_required
	96	&& !attribute_tables[i][j].type_required)
	97	abort ();
	98	}
	99	}
	100
	101	/* Check that each name occurs just once in each table. */
3585dac7	102	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
e3f6ce11	103	{
	104	int j, k;
	105	for (j = 0; attribute_tables[i][j].name != NULL; j++)
	106	for (k = j + 1; attribute_tables[i][k].name != NULL; k++)
	107	if (!strcmp (attribute_tables[i][j].name,
	108	attribute_tables[i][k].name))
	109	abort ();
	110	}
	111	/* Check that no name occurs in more than one table. */
3585dac7	112	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
e3f6ce11	113	{
3585dac7	114	size_t j, k, l;
e3f6ce11	115
3585dac7	116	for (j = i + 1; j < ARRAY_SIZE (attribute_tables); j++)
e3f6ce11	117	for (k = 0; attribute_tables[i][k].name != NULL; k++)
	118	for (l = 0; attribute_tables[j][l].name != NULL; l++)
	119	if (!strcmp (attribute_tables[i][k].name,
	120	attribute_tables[j][l].name))
	121	abort ();
	122	}
	123	#endif
	124
	125	attributes_initialized = true;
	126	}
	127	\f
	128	/* Process the attributes listed in ATTRIBUTES and install them in *NODE,
	129	which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL,
	130	it should be modified in place; if a TYPE, a copy should be created
	131	unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further
	132	information, in the form of a bitwise OR of flags in enum attribute_flags
	133	from tree.h. Depending on these flags, some attributes may be
	134	returned to be applied at a later stage (for example, to apply
7d3b509a	135	a decl attribute to the declaration rather than to its type). If
	136	ATTR_FLAG_BUILT_IN is not set and *NODE is a DECL, then also consider
	137	whether there might be some default attributes to apply to this DECL;
35a3065a	138	if so, decl_attributes will be called recursively with those attributes
7d3b509a	139	and ATTR_FLAG_BUILT_IN set. */
e3f6ce11	140
	141	tree
	142	decl_attributes (node, attributes, flags)
	143	tree *node, attributes;
	144	int flags;
	145	{
	146	tree a;
	147	tree returned_attrs = NULL_TREE;
	148
	149	if (!attributes_initialized)
	150	init_attributes ();
	151
	152	(targetm.insert_attributes) (node, &attributes);
	153
7d3b509a	154	if (DECL_P (node) && TREE_CODE (node) == FUNCTION_DECL
7d3b509a	155	&& !(flags & (int) ATTR_FLAG_BUILT_IN))
26ca6c20	156	(lang_hooks.insert_default_attributes) (node);
7d3b509a	157
e3f6ce11	158	for (a = attributes; a; a = TREE_CHAIN (a))
	159	{
	160	tree name = TREE_PURPOSE (a);
	161	tree args = TREE_VALUE (a);
	162	tree *anode = node;
	163	const struct attribute_spec *spec = NULL;
	164	bool no_add_attrs = 0;
40265b77	165	size_t i;
e3f6ce11	166
3585dac7	167	for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
e3f6ce11	168	{
	169	int j;
	170
	171	for (j = 0; attribute_tables[i][j].name != NULL; j++)
	172	{
	173	if (is_attribute_p (attribute_tables[i][j].name, name))
	174	{
	175	spec = &attribute_tables[i][j];
	176	break;
	177	}
	178	}
	179	if (spec != NULL)
	180	break;
	181	}
	182
	183	if (spec == NULL)
	184	{
	185	warning ("`%s' attribute directive ignored",
	186	IDENTIFIER_POINTER (name));
	187	continue;
	188	}
	189	else if (list_length (args) < spec->min_length
	190	\|\| (spec->max_length >= 0
	191	&& list_length (args) > spec->max_length))
	192	{
	193	error ("wrong number of arguments specified for `%s' attribute",
	194	IDENTIFIER_POINTER (name));
	195	continue;
	196	}
	197
	198	if (spec->decl_required && !DECL_P (*anode))
	199	{
	200	if (flags & ((int) ATTR_FLAG_DECL_NEXT
	201	\| (int) ATTR_FLAG_FUNCTION_NEXT
	202	\| (int) ATTR_FLAG_ARRAY_NEXT))
	203	{
	204	/* Pass on this attribute to be tried again. */
	205	returned_attrs = tree_cons (name, args, returned_attrs);
	206	continue;
	207	}
	208	else
	209	{
	210	warning ("`%s' attribute does not apply to types",
	211	IDENTIFIER_POINTER (name));
	212	continue;
	213	}
	214	}
	215
aa9c60c1	216	/* If we require a type, but were passed a decl, set up to make a
	217	new type and update the one in the decl. ATTR_FLAG_TYPE_IN_PLACE
	218	would have applied if we'd been passed a type, but we cannot modify
	219	the decl's type in place here. */
e3f6ce11	220	if (spec->type_required && DECL_P (*anode))
aa9c60c1	221	{
	222	anode = &TREE_TYPE (*anode);
	223	flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
	224	}
e3f6ce11	225
	226	if (spec->function_type_required && TREE_CODE (*anode) != FUNCTION_TYPE
	227	&& TREE_CODE (*anode) != METHOD_TYPE)
	228	{
	229	if (TREE_CODE (*anode) == POINTER_TYPE
	230	&& (TREE_CODE (TREE_TYPE (*anode)) == FUNCTION_TYPE
	231	\|\| TREE_CODE (TREE_TYPE (*anode)) == METHOD_TYPE))
	232	{
	233	if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
	234	anode = build_type_copy (anode);
	235	anode = &TREE_TYPE (*anode);
	236	}
	237	else if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
	238	{
	239	/* Pass on this attribute to be tried again. */
	240	returned_attrs = tree_cons (name, args, returned_attrs);
	241	continue;
	242	}
	243
	244	if (TREE_CODE (*anode) != FUNCTION_TYPE
	245	&& TREE_CODE (*anode) != METHOD_TYPE)
	246	{
	247	warning ("`%s' attribute only applies to function types",
	248	IDENTIFIER_POINTER (name));
	249	continue;
	250	}
	251	}
	252
	253	if (spec->handler != NULL)
	254	returned_attrs = chainon ((*spec->handler) (anode, name, args,
	255	flags, &no_add_attrs),
	256	returned_attrs);
ae4718db	257
	258	/* Layout the decl in case anything changed. */
	259	if (spec->type_required && DECL_P (*node)
e56de52f	260	&& (TREE_CODE (*node) == VAR_DECL
	261	\|\| TREE_CODE (*node) == PARM_DECL
	262	\|\| TREE_CODE (*node) == RESULT_DECL))
ae4718db	263	{
	264	/* Force a recalculation of mode and size. */
	265	DECL_MODE (*node) = VOIDmode;
	266	DECL_SIZE (*node) = 0;
	267
	268	layout_decl (*node, 0);
	269	}
	270
e3f6ce11	271	if (!no_add_attrs)
	272	{
	273	tree old_attrs;
	274	tree a;
	275
	276	if (DECL_P (*anode))
	277	old_attrs = DECL_ATTRIBUTES (*anode);
	278	else
	279	old_attrs = TYPE_ATTRIBUTES (*anode);
	280
	281	for (a = lookup_attribute (spec->name, old_attrs);
	282	a != NULL_TREE;
	283	a = lookup_attribute (spec->name, TREE_CHAIN (a)))
	284	{
	285	if (simple_cst_equal (TREE_VALUE (a), args) == 1)
	286	break;
	287	}
	288
	289	if (a == NULL_TREE)
	290	{
	291	/* This attribute isn't already in the list. */
	292	if (DECL_P (*anode))
	293	DECL_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
	294	else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
	295	TYPE_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
	296	else
	297	anode = build_type_attribute_variant (anode,
	298	tree_cons (name, args,
	299	old_attrs));
	300	}
	301	}
	302	}
	303
	304	return returned_attrs;
	305	}
	306
e3f6ce11	307	/* Split SPECS_ATTRS, a list of declspecs and prefix attributes, into two
	308	lists. SPECS_ATTRS may also be just a typespec (eg: RECORD_TYPE).
	309
	310	The head of the declspec list is stored in DECLSPECS.
	311	The head of the attribute list is stored in PREFIX_ATTRIBUTES.
	312
	313	Note that attributes in SPECS_ATTRS are stored in the TREE_PURPOSE of
	314	the list elements. We drop the containing TREE_LIST nodes and link the
	315	resulting attributes together the way decl_attributes expects them. */
	316
	317	void
	318	split_specs_attrs (specs_attrs, declspecs, prefix_attributes)
	319	tree specs_attrs;
	320	tree declspecs, prefix_attributes;
	321	{
	322	tree t, s, a, next, specs, attrs;
	323
	324	/* This can happen after an __extension__ in pedantic mode. */
9342ee68	325	if (specs_attrs != NULL_TREE
e3f6ce11	326	&& TREE_CODE (specs_attrs) == INTEGER_CST)
	327	{
	328	*declspecs = NULL_TREE;
	329	*prefix_attributes = NULL_TREE;
	330	return;
	331	}
	332
	333	/* This can happen in c++ (eg: decl: typespec initdecls ';'). */
	334	if (specs_attrs != NULL_TREE
	335	&& TREE_CODE (specs_attrs) != TREE_LIST)
	336	{
	337	*declspecs = specs_attrs;
	338	*prefix_attributes = NULL_TREE;
	339	return;
	340	}
	341
	342	/* Remember to keep the lists in the same order, element-wise. */
	343
	344	specs = s = NULL_TREE;
	345	attrs = a = NULL_TREE;
	346	for (t = specs_attrs; t; t = next)
	347	{
	348	next = TREE_CHAIN (t);
	349	/* Declspecs have a non-NULL TREE_VALUE. */
	350	if (TREE_VALUE (t) != NULL_TREE)
	351	{
	352	if (specs == NULL_TREE)
	353	specs = s = t;
	354	else
	355	{
	356	TREE_CHAIN (s) = t;
	357	s = t;
	358	}
	359	}
	360	/* The TREE_PURPOSE may also be empty in the case of
	361	__attribute__(()). */
	362	else if (TREE_PURPOSE (t) != NULL_TREE)
	363	{
	364	if (attrs == NULL_TREE)
	365	attrs = a = TREE_PURPOSE (t);
	366	else
	367	{
	368	TREE_CHAIN (a) = TREE_PURPOSE (t);
	369	a = TREE_PURPOSE (t);
	370	}
	371	/* More attrs can be linked here, move A to the end. */
	372	while (TREE_CHAIN (a) != NULL_TREE)
	373	a = TREE_CHAIN (a);
	374	}
	375	}
	376
	377	/* Terminate the lists. */
	378	if (s != NULL_TREE)
	379	TREE_CHAIN (s) = NULL_TREE;
	380	if (a != NULL_TREE)
	381	TREE_CHAIN (a) = NULL_TREE;
	382
	383	/* All done. */
	384	*declspecs = specs;
	385	*prefix_attributes = attrs;
	386	}
	387
	388	/* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
	389	This function is used by the parser when a rule will accept attributes
390	in a particular position, but we don't want to support that just yet.
391
392	A warning is issued for every ignored attribute. */
393
394	tree
395	strip_attrs (specs_attrs)
396	tree specs_attrs;
397	{
398	tree specs, attrs;
399
400	split_specs_attrs (specs_attrs, &specs, &attrs);
401
402	while (attrs)
403	{
404	warning ("`%s' attribute ignored",
405	IDENTIFIER_POINTER (TREE_PURPOSE (attrs)));
406	attrs = TREE_CHAIN (attrs);
407	}
408
409	return specs;
410	}
af87ad83	411