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
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, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-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
37 static void init_attributes (void);
38
39 /* Table of the tables of attributes (common, language, format, machine)
40 searched. */
41 static const struct attribute_spec *attribute_tables[4];
42
43 static bool attributes_initialized = false;
44
45 /* Default empty table of attributes. */
46 static 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
54 static void
init_attributes(void)55 init_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). If
135 ATTR_FLAG_BUILT_IN is not set and *NODE is a DECL, then also consider
136 whether there might be some default attributes to apply to this DECL;
137 if so, decl_attributes will be called recursively with those attributes
138 and ATTR_FLAG_BUILT_IN set. */
139
140 tree
decl_attributes(tree * node,tree attributes,int flags)141 decl_attributes (tree *node, tree attributes, int flags)
142 {
143 tree a;
144 tree returned_attrs = NULL_TREE;
145
146 if (!attributes_initialized)
147 init_attributes ();
148
149 targetm.insert_attributes (*node, &attributes);
150
151 if (DECL_P (*node) && TREE_CODE (*node) == FUNCTION_DECL
152 && !(flags & (int) ATTR_FLAG_BUILT_IN))
153 (*lang_hooks.insert_default_attributes) (*node);
154
155 for (a = attributes; a; a = TREE_CHAIN (a))
156 {
157 tree name = TREE_PURPOSE (a);
158 tree args = TREE_VALUE (a);
159 tree *anode = node;
160 const struct attribute_spec *spec = NULL;
161 bool no_add_attrs = 0;
162 tree fn_ptr_tmp = NULL_TREE;
163 size_t i;
164
165 for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
166 {
167 int j;
168
169 for (j = 0; attribute_tables[i][j].name != NULL; j++)
170 {
171 if (is_attribute_p (attribute_tables[i][j].name, name))
172 {
173 spec = &attribute_tables[i][j];
174 break;
175 }
176 }
177 if (spec != NULL)
178 break;
179 }
180
181 if (spec == NULL)
182 {
183 warning (OPT_Wattributes, "%qs attribute directive ignored",
184 IDENTIFIER_POINTER (name));
185 continue;
186 }
187 else if (list_length (args) < spec->min_length
188 || (spec->max_length >= 0
189 && list_length (args) > spec->max_length))
190 {
191 error ("wrong number of arguments specified for %qs attribute",
192 IDENTIFIER_POINTER (name));
193 continue;
194 }
195
196 if (spec->decl_required && !DECL_P (*anode))
197 {
198 if (flags & ((int) ATTR_FLAG_DECL_NEXT
199 | (int) ATTR_FLAG_FUNCTION_NEXT
200 | (int) ATTR_FLAG_ARRAY_NEXT))
201 {
202 /* Pass on this attribute to be tried again. */
203 returned_attrs = tree_cons (name, args, returned_attrs);
204 continue;
205 }
206 else
207 {
208 warning (OPT_Wattributes, "%qs attribute does not apply to types",
209 IDENTIFIER_POINTER (name));
210 continue;
211 }
212 }
213
214 /* If we require a type, but were passed a decl, set up to make a
215 new type and update the one in the decl. ATTR_FLAG_TYPE_IN_PLACE
216 would have applied if we'd been passed a type, but we cannot modify
217 the decl's type in place here. */
218 if (spec->type_required && DECL_P (*anode))
219 {
220 anode = &TREE_TYPE (*anode);
221 flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
222 }
223
224 if (spec->function_type_required && TREE_CODE (*anode) != FUNCTION_TYPE
225 && TREE_CODE (*anode) != METHOD_TYPE)
226 {
227 if (TREE_CODE (*anode) == POINTER_TYPE
228 && (TREE_CODE (TREE_TYPE (*anode)) == FUNCTION_TYPE
229 || TREE_CODE (TREE_TYPE (*anode)) == METHOD_TYPE))
230 {
231 /* OK, this is a bit convoluted. We can't just make a copy
232 of the pointer type and modify its TREE_TYPE, because if
233 we change the attributes of the target type the pointer
234 type needs to have a different TYPE_MAIN_VARIANT. So we
235 pull out the target type now, frob it as appropriate, and
236 rebuild the pointer type later.
237
238 This would all be simpler if attributes were part of the
239 declarator, grumble grumble. */
240 fn_ptr_tmp = TREE_TYPE (*anode);
241 anode = &fn_ptr_tmp;
242 flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
243 }
244 else if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
245 {
246 /* Pass on this attribute to be tried again. */
247 returned_attrs = tree_cons (name, args, returned_attrs);
248 continue;
249 }
250
251 if (TREE_CODE (*anode) != FUNCTION_TYPE
252 && TREE_CODE (*anode) != METHOD_TYPE)
253 {
254 warning (OPT_Wattributes,
255 "%qs attribute only applies to function types",
256 IDENTIFIER_POINTER (name));
257 continue;
258 }
259 }
260
261 if (spec->handler != NULL)
262 returned_attrs = chainon ((*spec->handler) (anode, name, args,
263 flags, &no_add_attrs),
264 returned_attrs);
265
266 /* Layout the decl in case anything changed. */
267 if (spec->type_required && DECL_P (*node)
268 && (TREE_CODE (*node) == VAR_DECL
269 || TREE_CODE (*node) == PARM_DECL
270 || TREE_CODE (*node) == RESULT_DECL))
271 relayout_decl (*node);
272
273 if (!no_add_attrs)
274 {
275 tree old_attrs;
276 tree a;
277
278 if (DECL_P (*anode))
279 old_attrs = DECL_ATTRIBUTES (*anode);
280 else
281 old_attrs = TYPE_ATTRIBUTES (*anode);
282
283 for (a = lookup_attribute (spec->name, old_attrs);
284 a != NULL_TREE;
285 a = lookup_attribute (spec->name, TREE_CHAIN (a)))
286 {
287 if (simple_cst_equal (TREE_VALUE (a), args) == 1)
288 break;
289 }
290
291 if (a == NULL_TREE)
292 {
293 /* This attribute isn't already in the list. */
294 if (DECL_P (*anode))
295 DECL_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
296 else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
297 {
298 TYPE_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
299 /* If this is the main variant, also push the attributes
300 out to the other variants. */
301 if (*anode == TYPE_MAIN_VARIANT (*anode))
302 {
303 tree variant;
304 for (variant = *anode; variant;
305 variant = TYPE_NEXT_VARIANT (variant))
306 {
307 if (TYPE_ATTRIBUTES (variant) == old_attrs)
308 TYPE_ATTRIBUTES (variant)
309 = TYPE_ATTRIBUTES (*anode);
310 else if (!lookup_attribute
311 (spec->name, TYPE_ATTRIBUTES (variant)))
312 TYPE_ATTRIBUTES (variant) = tree_cons
313 (name, args, TYPE_ATTRIBUTES (variant));
314 }
315 }
316 }
317 else
318 *anode = build_type_attribute_variant (*anode,
319 tree_cons (name, args,
320 old_attrs));
321 }
322 }
323
324 if (fn_ptr_tmp)
325 {
326 /* Rebuild the function pointer type and put it in the
327 appropriate place. */
328 fn_ptr_tmp = build_pointer_type (fn_ptr_tmp);
329 if (DECL_P (*node))
330 TREE_TYPE (*node) = fn_ptr_tmp;
331 else
332 {
333 gcc_assert (TREE_CODE (*node) == POINTER_TYPE);
334 *node = fn_ptr_tmp;
335 }
336 }
337 }
338
339 return returned_attrs;
340 }
341