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 Free Software Foundation, Inc.
5 This file is part of GCC.
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 3, or (at your option) any later
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
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
34 #include "langhooks.h"
37 static void init_attributes (void);
39 /* Table of the tables of attributes (common, language, format, machine)
41 static const struct attribute_spec
*attribute_tables
[4];
43 /* Hashtable mapping names (represented as substrings) to attribute specs. */
44 static htab_t attribute_hash
;
46 /* Substring representation. */
54 static bool attributes_initialized
= false;
56 /* Default empty table of attributes. */
58 static const struct attribute_spec empty_attribute_table
[] =
60 { NULL
, 0, 0, false, false, false, NULL
}
63 /* Return base name of the attribute. Ie '__attr__' is turned into 'attr'.
64 To avoid need for copying, we simply return length of the string. */
67 extract_attribute_substring (struct substring
*str
)
69 if (str
->length
> 4 && str
->str
[0] == '_' && str
->str
[1] == '_'
70 && str
->str
[str
->length
- 1] == '_' && str
->str
[str
->length
- 2] == '_')
77 /* Simple hash function to avoid need to scan whole string. */
79 static inline hashval_t
80 substring_hash (const char *str
, int l
)
82 return str
[0] + str
[l
- 1] * 256 + l
* 65536;
85 /* Used for attribute_hash. */
88 hash_attr (const void *p
)
90 const struct attribute_spec
*const spec
= (const struct attribute_spec
*) p
;
91 const int l
= strlen (spec
->name
);
93 return substring_hash (spec
->name
, l
);
96 /* Used for attribute_hash. */
99 eq_attr (const void *p
, const void *q
)
101 const struct attribute_spec
*const spec
= (const struct attribute_spec
*) p
;
102 const struct substring
*const str
= (const struct substring
*) q
;
104 return (!strncmp (spec
->name
, str
->str
, str
->length
) && !spec
->name
[str
->length
]);
107 /* Initialize attribute tables, and make some sanity checks
108 if --enable-checking. */
111 init_attributes (void)
116 attribute_tables
[0] = lang_hooks
.common_attribute_table
;
117 attribute_tables
[1] = lang_hooks
.attribute_table
;
118 attribute_tables
[2] = lang_hooks
.format_attribute_table
;
119 attribute_tables
[3] = targetm
.attribute_table
;
121 /* Translate NULL pointers to pointers to the empty table. */
122 for (i
= 0; i
< ARRAY_SIZE (attribute_tables
); i
++)
123 if (attribute_tables
[i
] == NULL
)
124 attribute_tables
[i
] = empty_attribute_table
;
126 #ifdef ENABLE_CHECKING
127 /* Make some sanity checks on the attribute tables. */
128 for (i
= 0; i
< ARRAY_SIZE (attribute_tables
); i
++)
132 for (j
= 0; attribute_tables
[i
][j
].name
!= NULL
; j
++)
134 /* The name must not begin and end with __. */
135 const char *name
= attribute_tables
[i
][j
].name
;
136 int len
= strlen (name
);
138 gcc_assert (!(name
[0] == '_' && name
[1] == '_'
139 && name
[len
- 1] == '_' && name
[len
- 2] == '_'));
141 /* The minimum and maximum lengths must be consistent. */
142 gcc_assert (attribute_tables
[i
][j
].min_length
>= 0);
144 gcc_assert (attribute_tables
[i
][j
].max_length
== -1
145 || (attribute_tables
[i
][j
].max_length
146 >= attribute_tables
[i
][j
].min_length
));
148 /* An attribute cannot require both a DECL and a TYPE. */
149 gcc_assert (!attribute_tables
[i
][j
].decl_required
150 || !attribute_tables
[i
][j
].type_required
);
152 /* If an attribute requires a function type, in particular
153 it requires a type. */
154 gcc_assert (!attribute_tables
[i
][j
].function_type_required
155 || attribute_tables
[i
][j
].type_required
);
159 /* Check that each name occurs just once in each table. */
160 for (i
= 0; i
< ARRAY_SIZE (attribute_tables
); i
++)
163 for (j
= 0; attribute_tables
[i
][j
].name
!= NULL
; j
++)
164 for (k
= j
+ 1; attribute_tables
[i
][k
].name
!= NULL
; k
++)
165 gcc_assert (strcmp (attribute_tables
[i
][j
].name
,
166 attribute_tables
[i
][k
].name
));
168 /* Check that no name occurs in more than one table. */
169 for (i
= 0; i
< ARRAY_SIZE (attribute_tables
); i
++)
173 for (j
= i
+ 1; j
< ARRAY_SIZE (attribute_tables
); j
++)
174 for (k
= 0; attribute_tables
[i
][k
].name
!= NULL
; k
++)
175 for (l
= 0; attribute_tables
[j
][l
].name
!= NULL
; l
++)
176 gcc_assert (strcmp (attribute_tables
[i
][k
].name
,
177 attribute_tables
[j
][l
].name
));
181 attribute_hash
= htab_create (200, hash_attr
, eq_attr
, NULL
);
182 for (i
= 0; i
< ARRAY_SIZE (attribute_tables
); i
++)
183 for (k
= 0; attribute_tables
[i
][k
].name
!= NULL
; k
++)
185 struct substring str
;
188 str
.str
= attribute_tables
[i
][k
].name
;
189 str
.length
= strlen (attribute_tables
[i
][k
].name
);
190 slot
= (const void **)htab_find_slot_with_hash (attribute_hash
, &str
,
191 substring_hash (str
.str
, str
.length
),
194 *slot
= &attribute_tables
[i
][k
];
196 attributes_initialized
= true;
199 /* Return the spec for the attribute named NAME. */
201 const struct attribute_spec
*
202 lookup_attribute_spec (tree name
)
204 struct substring attr
;
206 attr
.str
= IDENTIFIER_POINTER (name
);
207 attr
.length
= IDENTIFIER_LENGTH (name
);
208 extract_attribute_substring (&attr
);
209 return (const struct attribute_spec
*)
210 htab_find_with_hash (attribute_hash
, &attr
,
211 substring_hash (attr
.str
, attr
.length
));
214 /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
215 which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL,
216 it should be modified in place; if a TYPE, a copy should be created
217 unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further
218 information, in the form of a bitwise OR of flags in enum attribute_flags
219 from tree.h. Depending on these flags, some attributes may be
220 returned to be applied at a later stage (for example, to apply
221 a decl attribute to the declaration rather than to its type). */
224 decl_attributes (tree
*node
, tree attributes
, int flags
)
227 tree returned_attrs
= NULL_TREE
;
229 if (TREE_TYPE (*node
) == error_mark_node
)
232 if (!attributes_initialized
)
235 /* If this is a function and the user used #pragma GCC optimize, add the
236 options to the attribute((optimize(...))) list. */
237 if (TREE_CODE (*node
) == FUNCTION_DECL
&& current_optimize_pragma
)
239 tree cur_attr
= lookup_attribute ("optimize", attributes
);
240 tree opts
= copy_list (current_optimize_pragma
);
244 = tree_cons (get_identifier ("optimize"), opts
, attributes
);
246 TREE_VALUE (cur_attr
) = chainon (opts
, TREE_VALUE (cur_attr
));
249 if (TREE_CODE (*node
) == FUNCTION_DECL
250 && optimization_current_node
!= optimization_default_node
251 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
))
252 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
) = optimization_current_node
;
254 /* If this is a function and the user used #pragma GCC target, add the
255 options to the attribute((target(...))) list. */
256 if (TREE_CODE (*node
) == FUNCTION_DECL
257 && current_target_pragma
258 && targetm
.target_option
.valid_attribute_p (*node
, NULL_TREE
,
259 current_target_pragma
, 0))
261 tree cur_attr
= lookup_attribute ("target", attributes
);
262 tree opts
= copy_list (current_target_pragma
);
265 attributes
= tree_cons (get_identifier ("target"), opts
, attributes
);
267 TREE_VALUE (cur_attr
) = chainon (opts
, TREE_VALUE (cur_attr
));
270 targetm
.insert_attributes (*node
, &attributes
);
272 for (a
= attributes
; a
; a
= TREE_CHAIN (a
))
274 tree name
= TREE_PURPOSE (a
);
275 tree args
= TREE_VALUE (a
);
277 const struct attribute_spec
*spec
= lookup_attribute_spec (name
);
278 bool no_add_attrs
= 0;
279 tree fn_ptr_tmp
= NULL_TREE
;
283 warning (OPT_Wattributes
, "%qE attribute directive ignored",
287 else if (list_length (args
) < spec
->min_length
288 || (spec
->max_length
>= 0
289 && list_length (args
) > spec
->max_length
))
291 error ("wrong number of arguments specified for %qE attribute",
295 gcc_assert (is_attribute_p (spec
->name
, name
));
297 if (spec
->decl_required
&& !DECL_P (*anode
))
299 if (flags
& ((int) ATTR_FLAG_DECL_NEXT
300 | (int) ATTR_FLAG_FUNCTION_NEXT
301 | (int) ATTR_FLAG_ARRAY_NEXT
))
303 /* Pass on this attribute to be tried again. */
304 returned_attrs
= tree_cons (name
, args
, returned_attrs
);
309 warning (OPT_Wattributes
, "%qE attribute does not apply to types",
315 /* If we require a type, but were passed a decl, set up to make a
316 new type and update the one in the decl. ATTR_FLAG_TYPE_IN_PLACE
317 would have applied if we'd been passed a type, but we cannot modify
318 the decl's type in place here. */
319 if (spec
->type_required
&& DECL_P (*anode
))
321 anode
= &TREE_TYPE (*anode
);
322 /* Allow ATTR_FLAG_TYPE_IN_PLACE for the type's naming decl. */
323 if (!(TREE_CODE (*anode
) == TYPE_DECL
324 && *anode
== TYPE_NAME (TYPE_MAIN_VARIANT
325 (TREE_TYPE (*anode
)))))
326 flags
&= ~(int) ATTR_FLAG_TYPE_IN_PLACE
;
329 if (spec
->function_type_required
&& TREE_CODE (*anode
) != FUNCTION_TYPE
330 && TREE_CODE (*anode
) != METHOD_TYPE
)
332 if (TREE_CODE (*anode
) == POINTER_TYPE
333 && (TREE_CODE (TREE_TYPE (*anode
)) == FUNCTION_TYPE
334 || TREE_CODE (TREE_TYPE (*anode
)) == METHOD_TYPE
))
336 /* OK, this is a bit convoluted. We can't just make a copy
337 of the pointer type and modify its TREE_TYPE, because if
338 we change the attributes of the target type the pointer
339 type needs to have a different TYPE_MAIN_VARIANT. So we
340 pull out the target type now, frob it as appropriate, and
341 rebuild the pointer type later.
343 This would all be simpler if attributes were part of the
344 declarator, grumble grumble. */
345 fn_ptr_tmp
= TREE_TYPE (*anode
);
347 flags
&= ~(int) ATTR_FLAG_TYPE_IN_PLACE
;
349 else if (flags
& (int) ATTR_FLAG_FUNCTION_NEXT
)
351 /* Pass on this attribute to be tried again. */
352 returned_attrs
= tree_cons (name
, args
, returned_attrs
);
356 if (TREE_CODE (*anode
) != FUNCTION_TYPE
357 && TREE_CODE (*anode
) != METHOD_TYPE
)
359 warning (OPT_Wattributes
,
360 "%qE attribute only applies to function types",
367 && (flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
)
368 && TYPE_SIZE (*anode
) != NULL_TREE
)
370 warning (OPT_Wattributes
, "type attributes ignored after type is already defined");
374 if (spec
->handler
!= NULL
)
375 returned_attrs
= chainon ((*spec
->handler
) (anode
, name
, args
,
376 flags
, &no_add_attrs
),
379 /* Layout the decl in case anything changed. */
380 if (spec
->type_required
&& DECL_P (*node
)
381 && (TREE_CODE (*node
) == VAR_DECL
382 || TREE_CODE (*node
) == PARM_DECL
383 || TREE_CODE (*node
) == RESULT_DECL
))
384 relayout_decl (*node
);
392 old_attrs
= DECL_ATTRIBUTES (*anode
);
394 old_attrs
= TYPE_ATTRIBUTES (*anode
);
396 for (a
= lookup_attribute (spec
->name
, old_attrs
);
398 a
= lookup_attribute (spec
->name
, TREE_CHAIN (a
)))
400 if (simple_cst_equal (TREE_VALUE (a
), args
) == 1)
406 /* This attribute isn't already in the list. */
408 DECL_ATTRIBUTES (*anode
) = tree_cons (name
, args
, old_attrs
);
409 else if (flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
)
411 TYPE_ATTRIBUTES (*anode
) = tree_cons (name
, args
, old_attrs
);
412 /* If this is the main variant, also push the attributes
413 out to the other variants. */
414 if (*anode
== TYPE_MAIN_VARIANT (*anode
))
417 for (variant
= *anode
; variant
;
418 variant
= TYPE_NEXT_VARIANT (variant
))
420 if (TYPE_ATTRIBUTES (variant
) == old_attrs
)
421 TYPE_ATTRIBUTES (variant
)
422 = TYPE_ATTRIBUTES (*anode
);
423 else if (!lookup_attribute
424 (spec
->name
, TYPE_ATTRIBUTES (variant
)))
425 TYPE_ATTRIBUTES (variant
) = tree_cons
426 (name
, args
, TYPE_ATTRIBUTES (variant
));
431 *anode
= build_type_attribute_variant (*anode
,
432 tree_cons (name
, args
,
439 /* Rebuild the function pointer type and put it in the
440 appropriate place. */
441 fn_ptr_tmp
= build_pointer_type (fn_ptr_tmp
);
443 TREE_TYPE (*node
) = fn_ptr_tmp
;
446 gcc_assert (TREE_CODE (*node
) == POINTER_TYPE
);
452 return returned_attrs
;