1/* Functions dealing with attribute handling, used by most front ends.
2   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3   2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 2, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING.  If not, write to the Free
19Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
2002110-1301, USA.  */
21
22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "tm.h"
26#include "tree.h"
27#include "flags.h"
28#include "toplev.h"
29#include "output.h"
30#include "rtl.h"
31#include "ggc.h"
32#include "tm_p.h"
33#include "cpplib.h"
34#include "target.h"
35#include "langhooks.h"
36
37static void init_attributes (void);
38
39/* Table of the tables of attributes (common, language, format, machine)
40   searched.  */
41static const struct attribute_spec *attribute_tables[4];
42
43static bool attributes_initialized = false;
44
45/* Default empty table of attributes.  */
46static const struct attribute_spec empty_attribute_table[] =
47{
48  { NULL, 0, 0, false, false, false, NULL }
49};
50
51/* Initialize attribute tables, and make some sanity checks
52   if --enable-checking.  */
53
54static void
55init_attributes (void)
56{
57  size_t i;
58
59  attribute_tables[0] = lang_hooks.common_attribute_table;
60  attribute_tables[1] = lang_hooks.attribute_table;
61  attribute_tables[2] = lang_hooks.format_attribute_table;
62  attribute_tables[3] = targetm.attribute_table;
63
64  /* Translate NULL pointers to pointers to the empty table.  */
65  for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
66    if (attribute_tables[i] == NULL)
67      attribute_tables[i] = empty_attribute_table;
68
69#ifdef ENABLE_CHECKING
70  /* Make some sanity checks on the attribute tables.  */
71  for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
72    {
73      int j;
74
75      for (j = 0; attribute_tables[i][j].name != NULL; j++)
76	{
77	  /* The name must not begin and end with __.  */
78	  const char *name = attribute_tables[i][j].name;
79	  int len = strlen (name);
80
81	  gcc_assert (!(name[0] == '_' && name[1] == '_'
82			&& name[len - 1] == '_' && name[len - 2] == '_'));
83
84	  /* The minimum and maximum lengths must be consistent.  */
85	  gcc_assert (attribute_tables[i][j].min_length >= 0);
86
87	  gcc_assert (attribute_tables[i][j].max_length == -1
88		      || (attribute_tables[i][j].max_length
89			  >= attribute_tables[i][j].min_length));
90
91	  /* An attribute cannot require both a DECL and a TYPE.  */
92	  gcc_assert (!attribute_tables[i][j].decl_required
93		      || !attribute_tables[i][j].type_required);
94
95	  /* If an attribute requires a function type, in particular
96	     it requires a type.  */
97	  gcc_assert (!attribute_tables[i][j].function_type_required
98		      || attribute_tables[i][j].type_required);
99	}
100    }
101
102  /* Check that each name occurs just once in each table.  */
103  for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
104    {
105      int j, k;
106      for (j = 0; attribute_tables[i][j].name != NULL; j++)
107	for (k = j + 1; attribute_tables[i][k].name != NULL; k++)
108	  gcc_assert (strcmp (attribute_tables[i][j].name,
109			      attribute_tables[i][k].name));
110    }
111  /* Check that no name occurs in more than one table.  */
112  for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
113    {
114      size_t j, k, l;
115
116      for (j = i + 1; j < ARRAY_SIZE (attribute_tables); j++)
117	for (k = 0; attribute_tables[i][k].name != NULL; k++)
118	  for (l = 0; attribute_tables[j][l].name != NULL; l++)
119	    gcc_assert (strcmp (attribute_tables[i][k].name,
120				attribute_tables[j][l].name));
121    }
122#endif
123
124  attributes_initialized = true;
125}
126
127/* Process the attributes listed in ATTRIBUTES and install them in *NODE,
128   which is either a DECL (including a TYPE_DECL) or a TYPE.  If a DECL,
129   it should be modified in place; if a TYPE, a copy should be created
130   unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS.  FLAGS gives further
131   information, in the form of a bitwise OR of flags in enum attribute_flags
132   from tree.h.  Depending on these flags, some attributes may be
133   returned to be applied at a later stage (for example, to apply
134   a decl attribute to the declaration rather than to its type).  */
135
136tree
137decl_attributes (tree *node, tree attributes, int flags)
138{
139  tree a;
140  tree returned_attrs = NULL_TREE;
141
142  if (!attributes_initialized)
143    init_attributes ();
144
145  targetm.insert_attributes (*node, &attributes);
146
147  for (a = attributes; a; a = TREE_CHAIN (a))
148    {
149      tree name = TREE_PURPOSE (a);
150      tree args = TREE_VALUE (a);
151      tree *anode = node;
152      const struct attribute_spec *spec = NULL;
153      bool no_add_attrs = 0;
154      tree fn_ptr_tmp = NULL_TREE;
155      size_t i;
156
157      for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
158	{
159	  int j;
160
161	  for (j = 0; attribute_tables[i][j].name != NULL; j++)
162	    {
163	      if (is_attribute_p (attribute_tables[i][j].name, name))
164		{
165		  spec = &attribute_tables[i][j];
166		  break;
167		}
168	    }
169	  if (spec != NULL)
170	    break;
171	}
172
173      if (spec == NULL)
174	{
175	  warning (OPT_Wattributes, "%qs attribute directive ignored",
176		   IDENTIFIER_POINTER (name));
177	  continue;
178	}
179      else if (list_length (args) < spec->min_length
180	       || (spec->max_length >= 0
181		   && list_length (args) > spec->max_length))
182	{
183	  error ("wrong number of arguments specified for %qs attribute",
184		 IDENTIFIER_POINTER (name));
185	  continue;
186	}
187
188      if (spec->decl_required && !DECL_P (*anode))
189	{
190	  if (flags & ((int) ATTR_FLAG_DECL_NEXT
191		       | (int) ATTR_FLAG_FUNCTION_NEXT
192		       | (int) ATTR_FLAG_ARRAY_NEXT))
193	    {
194	      /* Pass on this attribute to be tried again.  */
195	      returned_attrs = tree_cons (name, args, returned_attrs);
196	      continue;
197	    }
198	  else
199	    {
200	      warning (OPT_Wattributes, "%qs attribute does not apply to types",
201		       IDENTIFIER_POINTER (name));
202	      continue;
203	    }
204	}
205
206      /* If we require a type, but were passed a decl, set up to make a
207	 new type and update the one in the decl.  ATTR_FLAG_TYPE_IN_PLACE
208	 would have applied if we'd been passed a type, but we cannot modify
209	 the decl's type in place here.  */
210      if (spec->type_required && DECL_P (*anode))
211	{
212	  anode = &TREE_TYPE (*anode);
213	  flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
214	}
215
216      if (spec->function_type_required && TREE_CODE (*anode) != FUNCTION_TYPE
217	  && TREE_CODE (*anode) != METHOD_TYPE)
218	{
219	  /* APPLE LOCAL radar 6246527 */
220	  if ((TREE_CODE (*anode) == POINTER_TYPE || TREE_CODE (*anode) == BLOCK_POINTER_TYPE)
221	      && (TREE_CODE (TREE_TYPE (*anode)) == FUNCTION_TYPE
222		  || TREE_CODE (TREE_TYPE (*anode)) == METHOD_TYPE))
223	    {
224	      /* OK, this is a bit convoluted.  We can't just make a copy
225		 of the pointer type and modify its TREE_TYPE, because if
226		 we change the attributes of the target type the pointer
227		 type needs to have a different TYPE_MAIN_VARIANT.  So we
228		 pull out the target type now, frob it as appropriate, and
229		 rebuild the pointer type later.
230
231		 This would all be simpler if attributes were part of the
232		 declarator, grumble grumble.  */
233	      fn_ptr_tmp = TREE_TYPE (*anode);
234	      anode = &fn_ptr_tmp;
235	      flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
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 (OPT_Wattributes,
248		       "%qs attribute only applies to function types",
249		       IDENTIFIER_POINTER (name));
250	      continue;
251	    }
252	}
253
254      if (TYPE_P (*anode)
255	  && (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
256	  && TYPE_SIZE (*anode) != NULL_TREE)
257	{
258	  warning (OPT_Wattributes, "type attributes ignored after type is already defined");
259	  continue;
260	}
261
262      if (spec->handler != NULL)
263	returned_attrs = chainon ((*spec->handler) (anode, name, args,
264						    flags, &no_add_attrs),
265				  returned_attrs);
266
267      /* Layout the decl in case anything changed.  */
268      if (spec->type_required && DECL_P (*node)
269	  && (TREE_CODE (*node) == VAR_DECL
270	      || TREE_CODE (*node) == PARM_DECL
271	      || TREE_CODE (*node) == RESULT_DECL))
272	relayout_decl (*node);
273
274      if (!no_add_attrs)
275	{
276	  tree old_attrs;
277	  tree a;
278
279	  if (DECL_P (*anode))
280	    old_attrs = DECL_ATTRIBUTES (*anode);
281	  else
282	    old_attrs = TYPE_ATTRIBUTES (*anode);
283
284	  for (a = lookup_attribute (spec->name, old_attrs);
285	       a != NULL_TREE;
286	       a = lookup_attribute (spec->name, TREE_CHAIN (a)))
287	    {
288	      if (simple_cst_equal (TREE_VALUE (a), args) == 1)
289		break;
290	    }
291
292	  if (a == NULL_TREE)
293	    {
294	      /* This attribute isn't already in the list.  */
295	      if (DECL_P (*anode))
296		DECL_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
297	      else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
298		{
299		  TYPE_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
300		  /* If this is the main variant, also push the attributes
301		     out to the other variants.  */
302		  if (*anode == TYPE_MAIN_VARIANT (*anode))
303		    {
304		      tree variant;
305		      for (variant = *anode; variant;
306			   variant = TYPE_NEXT_VARIANT (variant))
307			{
308			  if (TYPE_ATTRIBUTES (variant) == old_attrs)
309			    TYPE_ATTRIBUTES (variant)
310			      = TYPE_ATTRIBUTES (*anode);
311			  else if (!lookup_attribute
312				   (spec->name, TYPE_ATTRIBUTES (variant)))
313			    TYPE_ATTRIBUTES (variant) = tree_cons
314			      (name, args, TYPE_ATTRIBUTES (variant));
315			}
316		    }
317		}
318	      else
319		*anode = build_type_attribute_variant (*anode,
320						       tree_cons (name, args,
321								  old_attrs));
322	    }
323	}
324
325      if (fn_ptr_tmp)
326	{
327	   /* APPLE LOCAL begin radar 6246527 */
328	   if (DECL_P (*node) && TREE_TYPE (*node) &&
329	       TREE_CODE (TREE_TYPE (*node)) == BLOCK_POINTER_TYPE)
330	     /* Rebuild the block pointer type and put it in the
331	        appropriate place.  */
332	     fn_ptr_tmp = build_block_pointer_type (fn_ptr_tmp);
333	   else
334	   /* APPLE LOCAL end radar 6246527 */
335	  /* Rebuild the function pointer type and put it in the
336	     appropriate place.  */
337	  fn_ptr_tmp = build_pointer_type (fn_ptr_tmp);
338	  if (DECL_P (*node))
339	    TREE_TYPE (*node) = fn_ptr_tmp;
340	  else
341	    {
342	      gcc_assert (TREE_CODE (*node) == POINTER_TYPE);
343	      *node = fn_ptr_tmp;
344	    }
345	}
346    }
347
348  return returned_attrs;
349}
350