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 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, 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"
32 #include "cpplib.h"
33 #include "target.h"
34 #include "langhooks.h"
35
36 static void init_attributes PARAMS ((void));
37
38 /* Table of the tables of attributes (common, language, format, machine)
39 searched. */
40 static const struct attribute_spec *attribute_tables[4];
41
42 static bool attributes_initialized = false;
43
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
50 /* Initialize attribute tables, and make some sanity checks
51 if --enable-checking. */
52
53 static void
init_attributes()54 init_attributes ()
55 {
56 size_t i;
57
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;
61 attribute_tables[3] = targetm.attribute_table;
62
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
68 #ifdef ENABLE_CHECKING
69 /* Make some sanity checks on the attribute tables. */
70 for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
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. */
102 for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
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. */
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 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
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
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;
138 if so, decl_attributes will be called recursively with those attributes
139 and ATTR_FLAG_BUILT_IN set. */
140
141 tree
decl_attributes(node,attributes,flags)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
154 if (DECL_P (*node) && TREE_CODE (*node) == FUNCTION_DECL
155 && !(flags & (int) ATTR_FLAG_BUILT_IN))
156 (*lang_hooks.insert_default_attributes) (*node);
157
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;
165 size_t i;
166
167 for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
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
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. */
220 if (spec->type_required && DECL_P (*anode))
221 {
222 anode = &TREE_TYPE (*anode);
223 flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
224 }
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);
257
258 /* Layout the decl in case anything changed. */
259 if (spec->type_required && DECL_P (*node)
260 && (TREE_CODE (*node) == VAR_DECL
261 || TREE_CODE (*node) == PARM_DECL
262 || TREE_CODE (*node) == RESULT_DECL))
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
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
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
split_specs_attrs(specs_attrs,declspecs,prefix_attributes)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. */
325 if (specs_attrs != NULL_TREE
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
strip_attrs(specs_attrs)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 }
411
412