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). */
135
136 tree
decl_attributes(tree * node,tree attributes,int flags)137 decl_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