name-lookup.c (lookup_arg_dependent): Use conditional timevars.
[official-gcc.git] / gcc / attribs.c
blob9448c0c6beb5bb0cee623fcaec4b452b789a2ab9
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, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
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 "diagnostic-core.h"
29 #include "ggc.h"
30 #include "tm_p.h"
31 #include "cpplib.h"
32 #include "target.h"
33 #include "langhooks.h"
34 #include "hashtab.h"
35 #include "plugin.h"
37 /* Table of the tables of attributes (common, language, format, machine)
38 searched. */
39 static const struct attribute_spec *attribute_tables[4];
41 /* Hashtable mapping names (represented as substrings) to attribute specs. */
42 static htab_t attribute_hash;
44 /* Substring representation. */
46 struct substring
48 const char *str;
49 int length;
52 static bool attributes_initialized = false;
54 /* Default empty table of attributes. */
56 static const struct attribute_spec empty_attribute_table[] =
58 { NULL, 0, 0, false, false, false, NULL, false }
61 /* Return base name of the attribute. Ie '__attr__' is turned into 'attr'.
62 To avoid need for copying, we simply return length of the string. */
64 static void
65 extract_attribute_substring (struct substring *str)
67 if (str->length > 4 && str->str[0] == '_' && str->str[1] == '_'
68 && str->str[str->length - 1] == '_' && str->str[str->length - 2] == '_')
70 str->length -= 4;
71 str->str += 2;
75 /* Simple hash function to avoid need to scan whole string. */
77 static inline hashval_t
78 substring_hash (const char *str, int l)
80 return str[0] + str[l - 1] * 256 + l * 65536;
83 /* Used for attribute_hash. */
85 static hashval_t
86 hash_attr (const void *p)
88 const struct attribute_spec *const spec = (const struct attribute_spec *) p;
89 const int l = strlen (spec->name);
91 return substring_hash (spec->name, l);
94 /* Used for attribute_hash. */
96 static int
97 eq_attr (const void *p, const void *q)
99 const struct attribute_spec *const spec = (const struct attribute_spec *) p;
100 const struct substring *const str = (const struct substring *) q;
102 return (!strncmp (spec->name, str->str, str->length) && !spec->name[str->length]);
105 /* Initialize attribute tables, and make some sanity checks
106 if --enable-checking. */
108 void
109 init_attributes (void)
111 size_t i;
112 int k;
114 if (attributes_initialized)
115 return;
117 attribute_tables[0] = lang_hooks.common_attribute_table;
118 attribute_tables[1] = lang_hooks.attribute_table;
119 attribute_tables[2] = lang_hooks.format_attribute_table;
120 attribute_tables[3] = targetm.attribute_table;
122 /* Translate NULL pointers to pointers to the empty table. */
123 for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
124 if (attribute_tables[i] == NULL)
125 attribute_tables[i] = empty_attribute_table;
127 #ifdef ENABLE_CHECKING
128 /* Make some sanity checks on the attribute tables. */
129 for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
131 int j;
133 for (j = 0; attribute_tables[i][j].name != NULL; j++)
135 /* The name must not begin and end with __. */
136 const char *name = attribute_tables[i][j].name;
137 int len = strlen (name);
139 gcc_assert (!(name[0] == '_' && name[1] == '_'
140 && name[len - 1] == '_' && name[len - 2] == '_'));
142 /* The minimum and maximum lengths must be consistent. */
143 gcc_assert (attribute_tables[i][j].min_length >= 0);
145 gcc_assert (attribute_tables[i][j].max_length == -1
146 || (attribute_tables[i][j].max_length
147 >= attribute_tables[i][j].min_length));
149 /* An attribute cannot require both a DECL and a TYPE. */
150 gcc_assert (!attribute_tables[i][j].decl_required
151 || !attribute_tables[i][j].type_required);
153 /* If an attribute requires a function type, in particular
154 it requires a type. */
155 gcc_assert (!attribute_tables[i][j].function_type_required
156 || attribute_tables[i][j].type_required);
160 /* Check that each name occurs just once in each table. */
161 for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
163 int j, k;
164 for (j = 0; attribute_tables[i][j].name != NULL; j++)
165 for (k = j + 1; attribute_tables[i][k].name != NULL; k++)
166 gcc_assert (strcmp (attribute_tables[i][j].name,
167 attribute_tables[i][k].name));
169 /* Check that no name occurs in more than one table. */
170 for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
172 size_t j, k, l;
174 for (j = i + 1; j < ARRAY_SIZE (attribute_tables); j++)
175 for (k = 0; attribute_tables[i][k].name != NULL; k++)
176 for (l = 0; attribute_tables[j][l].name != NULL; l++)
177 gcc_assert (strcmp (attribute_tables[i][k].name,
178 attribute_tables[j][l].name));
180 #endif
182 attribute_hash = htab_create (200, hash_attr, eq_attr, NULL);
183 for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
184 for (k = 0; attribute_tables[i][k].name != NULL; k++)
186 register_attribute (&attribute_tables[i][k]);
188 invoke_plugin_callbacks (PLUGIN_ATTRIBUTES, NULL);
189 attributes_initialized = true;
192 /* Insert a single ATTR into the attribute table. */
194 void
195 register_attribute (const struct attribute_spec *attr)
197 struct substring str;
198 void **slot;
200 str.str = attr->name;
201 str.length = strlen (str.str);
203 /* Attribute names in the table must be in the form 'text' and not
204 in the form '__text__'. */
205 gcc_assert (str.length > 0 && str.str[0] != '_');
207 slot = htab_find_slot_with_hash (attribute_hash, &str,
208 substring_hash (str.str, str.length),
209 INSERT);
210 gcc_assert (!*slot);
211 *slot = (void *) CONST_CAST (struct attribute_spec *, attr);
214 /* Return the spec for the attribute named NAME. */
216 const struct attribute_spec *
217 lookup_attribute_spec (const_tree name)
219 struct substring attr;
221 attr.str = IDENTIFIER_POINTER (name);
222 attr.length = IDENTIFIER_LENGTH (name);
223 extract_attribute_substring (&attr);
224 return (const struct attribute_spec *)
225 htab_find_with_hash (attribute_hash, &attr,
226 substring_hash (attr.str, attr.length));
229 /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
230 which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL,
231 it should be modified in place; if a TYPE, a copy should be created
232 unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further
233 information, in the form of a bitwise OR of flags in enum attribute_flags
234 from tree.h. Depending on these flags, some attributes may be
235 returned to be applied at a later stage (for example, to apply
236 a decl attribute to the declaration rather than to its type). */
238 tree
239 decl_attributes (tree *node, tree attributes, int flags)
241 tree a;
242 tree returned_attrs = NULL_TREE;
244 if (TREE_TYPE (*node) == error_mark_node)
245 return NULL_TREE;
247 if (!attributes_initialized)
248 init_attributes ();
250 /* If this is a function and the user used #pragma GCC optimize, add the
251 options to the attribute((optimize(...))) list. */
252 if (TREE_CODE (*node) == FUNCTION_DECL && current_optimize_pragma)
254 tree cur_attr = lookup_attribute ("optimize", attributes);
255 tree opts = copy_list (current_optimize_pragma);
257 if (! cur_attr)
258 attributes
259 = tree_cons (get_identifier ("optimize"), opts, attributes);
260 else
261 TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
264 if (TREE_CODE (*node) == FUNCTION_DECL
265 && optimization_current_node != optimization_default_node
266 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node))
267 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node) = optimization_current_node;
269 /* If this is a function and the user used #pragma GCC target, add the
270 options to the attribute((target(...))) list. */
271 if (TREE_CODE (*node) == FUNCTION_DECL
272 && current_target_pragma
273 && targetm.target_option.valid_attribute_p (*node, NULL_TREE,
274 current_target_pragma, 0))
276 tree cur_attr = lookup_attribute ("target", attributes);
277 tree opts = copy_list (current_target_pragma);
279 if (! cur_attr)
280 attributes = tree_cons (get_identifier ("target"), opts, attributes);
281 else
282 TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
285 /* A "naked" function attribute implies "noinline" and "noclone" for
286 those targets that support it. */
287 if (TREE_CODE (*node) == FUNCTION_DECL
288 && attributes
289 && lookup_attribute_spec (get_identifier ("naked"))
290 && lookup_attribute ("naked", attributes) != NULL)
292 if (lookup_attribute ("noinline", attributes) == NULL)
293 attributes = tree_cons (get_identifier ("noinline"), NULL, attributes);
295 if (lookup_attribute ("noclone", attributes) == NULL)
296 attributes = tree_cons (get_identifier ("noclone"), NULL, attributes);
299 targetm.insert_attributes (*node, &attributes);
301 for (a = attributes; a; a = TREE_CHAIN (a))
303 tree name = TREE_PURPOSE (a);
304 tree args = TREE_VALUE (a);
305 tree *anode = node;
306 const struct attribute_spec *spec = lookup_attribute_spec (name);
307 bool no_add_attrs = 0;
308 int fn_ptr_quals = 0;
309 tree fn_ptr_tmp = NULL_TREE;
311 if (spec == NULL)
313 warning (OPT_Wattributes, "%qE attribute directive ignored",
314 name);
315 continue;
317 else if (list_length (args) < spec->min_length
318 || (spec->max_length >= 0
319 && list_length (args) > spec->max_length))
321 error ("wrong number of arguments specified for %qE attribute",
322 name);
323 continue;
325 gcc_assert (is_attribute_p (spec->name, name));
327 if (spec->decl_required && !DECL_P (*anode))
329 if (flags & ((int) ATTR_FLAG_DECL_NEXT
330 | (int) ATTR_FLAG_FUNCTION_NEXT
331 | (int) ATTR_FLAG_ARRAY_NEXT))
333 /* Pass on this attribute to be tried again. */
334 returned_attrs = tree_cons (name, args, returned_attrs);
335 continue;
337 else
339 warning (OPT_Wattributes, "%qE attribute does not apply to types",
340 name);
341 continue;
345 /* If we require a type, but were passed a decl, set up to make a
346 new type and update the one in the decl. ATTR_FLAG_TYPE_IN_PLACE
347 would have applied if we'd been passed a type, but we cannot modify
348 the decl's type in place here. */
349 if (spec->type_required && DECL_P (*anode))
351 anode = &TREE_TYPE (*anode);
352 /* Allow ATTR_FLAG_TYPE_IN_PLACE for the type's naming decl. */
353 if (!(TREE_CODE (*anode) == TYPE_DECL
354 && *anode == TYPE_NAME (TYPE_MAIN_VARIANT
355 (TREE_TYPE (*anode)))))
356 flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
359 if (spec->function_type_required && TREE_CODE (*anode) != FUNCTION_TYPE
360 && TREE_CODE (*anode) != METHOD_TYPE)
362 if (TREE_CODE (*anode) == POINTER_TYPE
363 && (TREE_CODE (TREE_TYPE (*anode)) == FUNCTION_TYPE
364 || TREE_CODE (TREE_TYPE (*anode)) == METHOD_TYPE))
366 /* OK, this is a bit convoluted. We can't just make a copy
367 of the pointer type and modify its TREE_TYPE, because if
368 we change the attributes of the target type the pointer
369 type needs to have a different TYPE_MAIN_VARIANT. So we
370 pull out the target type now, frob it as appropriate, and
371 rebuild the pointer type later.
373 This would all be simpler if attributes were part of the
374 declarator, grumble grumble. */
375 fn_ptr_tmp = TREE_TYPE (*anode);
376 fn_ptr_quals = TYPE_QUALS (*anode);
377 anode = &fn_ptr_tmp;
378 flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
380 else if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
382 /* Pass on this attribute to be tried again. */
383 returned_attrs = tree_cons (name, args, returned_attrs);
384 continue;
387 if (TREE_CODE (*anode) != FUNCTION_TYPE
388 && TREE_CODE (*anode) != METHOD_TYPE)
390 warning (OPT_Wattributes,
391 "%qE attribute only applies to function types",
392 name);
393 continue;
397 if (TYPE_P (*anode)
398 && (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
399 && TYPE_SIZE (*anode) != NULL_TREE)
401 warning (OPT_Wattributes, "type attributes ignored after type is already defined");
402 continue;
405 if (spec->handler != NULL)
406 returned_attrs = chainon ((*spec->handler) (anode, name, args,
407 flags, &no_add_attrs),
408 returned_attrs);
410 /* Layout the decl in case anything changed. */
411 if (spec->type_required && DECL_P (*node)
412 && (TREE_CODE (*node) == VAR_DECL
413 || TREE_CODE (*node) == PARM_DECL
414 || TREE_CODE (*node) == RESULT_DECL))
415 relayout_decl (*node);
417 if (!no_add_attrs)
419 tree old_attrs;
420 tree a;
422 if (DECL_P (*anode))
423 old_attrs = DECL_ATTRIBUTES (*anode);
424 else
425 old_attrs = TYPE_ATTRIBUTES (*anode);
427 for (a = lookup_attribute (spec->name, old_attrs);
428 a != NULL_TREE;
429 a = lookup_attribute (spec->name, TREE_CHAIN (a)))
431 if (simple_cst_equal (TREE_VALUE (a), args) == 1)
432 break;
435 if (a == NULL_TREE)
437 /* This attribute isn't already in the list. */
438 if (DECL_P (*anode))
439 DECL_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
440 else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
442 TYPE_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
443 /* If this is the main variant, also push the attributes
444 out to the other variants. */
445 if (*anode == TYPE_MAIN_VARIANT (*anode))
447 tree variant;
448 for (variant = *anode; variant;
449 variant = TYPE_NEXT_VARIANT (variant))
451 if (TYPE_ATTRIBUTES (variant) == old_attrs)
452 TYPE_ATTRIBUTES (variant)
453 = TYPE_ATTRIBUTES (*anode);
454 else if (!lookup_attribute
455 (spec->name, TYPE_ATTRIBUTES (variant)))
456 TYPE_ATTRIBUTES (variant) = tree_cons
457 (name, args, TYPE_ATTRIBUTES (variant));
461 else
462 *anode = build_type_attribute_variant (*anode,
463 tree_cons (name, args,
464 old_attrs));
468 if (fn_ptr_tmp)
470 /* Rebuild the function pointer type and put it in the
471 appropriate place. */
472 fn_ptr_tmp = build_pointer_type (fn_ptr_tmp);
473 if (fn_ptr_quals)
474 fn_ptr_tmp = build_qualified_type (fn_ptr_tmp, fn_ptr_quals);
475 if (DECL_P (*node))
476 TREE_TYPE (*node) = fn_ptr_tmp;
477 else
479 gcc_assert (TREE_CODE (*node) == POINTER_TYPE);
480 *node = fn_ptr_tmp;
485 return returned_attrs;