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 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 /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
200 which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL,
201 it should be modified in place; if a TYPE, a copy should be created
202 unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further
203 information, in the form of a bitwise OR of flags in enum attribute_flags
204 from tree.h. Depending on these flags, some attributes may be
205 returned to be applied at a later stage (for example, to apply
206 a decl attribute to the declaration rather than to its type). */
209 decl_attributes (tree
*node
, tree attributes
, int flags
)
212 tree returned_attrs
= NULL_TREE
;
214 if (!attributes_initialized
)
217 targetm
.insert_attributes (*node
, &attributes
);
219 for (a
= attributes
; a
; a
= TREE_CHAIN (a
))
221 tree name
= TREE_PURPOSE (a
);
222 tree args
= TREE_VALUE (a
);
224 const struct attribute_spec
*spec
= NULL
;
225 bool no_add_attrs
= 0;
226 tree fn_ptr_tmp
= NULL_TREE
;
227 struct substring attr
;
229 attr
.str
= IDENTIFIER_POINTER (name
);
230 attr
.length
= IDENTIFIER_LENGTH (name
);
231 extract_attribute_substring (&attr
);
232 spec
= htab_find_with_hash (attribute_hash
, &attr
,
233 substring_hash (attr
.str
, attr
.length
));
237 warning (OPT_Wattributes
, "%qs attribute directive ignored",
238 IDENTIFIER_POINTER (name
));
241 else if (list_length (args
) < spec
->min_length
242 || (spec
->max_length
>= 0
243 && list_length (args
) > spec
->max_length
))
245 error ("wrong number of arguments specified for %qs attribute",
246 IDENTIFIER_POINTER (name
));
249 gcc_assert (is_attribute_p (spec
->name
, name
));
251 if (spec
->decl_required
&& !DECL_P (*anode
))
253 if (flags
& ((int) ATTR_FLAG_DECL_NEXT
254 | (int) ATTR_FLAG_FUNCTION_NEXT
255 | (int) ATTR_FLAG_ARRAY_NEXT
))
257 /* Pass on this attribute to be tried again. */
258 returned_attrs
= tree_cons (name
, args
, returned_attrs
);
263 warning (OPT_Wattributes
, "%qs attribute does not apply to types",
264 IDENTIFIER_POINTER (name
));
269 /* If we require a type, but were passed a decl, set up to make a
270 new type and update the one in the decl. ATTR_FLAG_TYPE_IN_PLACE
271 would have applied if we'd been passed a type, but we cannot modify
272 the decl's type in place here. */
273 if (spec
->type_required
&& DECL_P (*anode
))
275 anode
= &TREE_TYPE (*anode
);
276 flags
&= ~(int) ATTR_FLAG_TYPE_IN_PLACE
;
279 if (spec
->function_type_required
&& TREE_CODE (*anode
) != FUNCTION_TYPE
280 && TREE_CODE (*anode
) != METHOD_TYPE
)
282 if (TREE_CODE (*anode
) == POINTER_TYPE
283 && (TREE_CODE (TREE_TYPE (*anode
)) == FUNCTION_TYPE
284 || TREE_CODE (TREE_TYPE (*anode
)) == METHOD_TYPE
))
286 /* OK, this is a bit convoluted. We can't just make a copy
287 of the pointer type and modify its TREE_TYPE, because if
288 we change the attributes of the target type the pointer
289 type needs to have a different TYPE_MAIN_VARIANT. So we
290 pull out the target type now, frob it as appropriate, and
291 rebuild the pointer type later.
293 This would all be simpler if attributes were part of the
294 declarator, grumble grumble. */
295 fn_ptr_tmp
= TREE_TYPE (*anode
);
297 flags
&= ~(int) ATTR_FLAG_TYPE_IN_PLACE
;
299 else if (flags
& (int) ATTR_FLAG_FUNCTION_NEXT
)
301 /* Pass on this attribute to be tried again. */
302 returned_attrs
= tree_cons (name
, args
, returned_attrs
);
306 if (TREE_CODE (*anode
) != FUNCTION_TYPE
307 && TREE_CODE (*anode
) != METHOD_TYPE
)
309 warning (OPT_Wattributes
,
310 "%qs attribute only applies to function types",
311 IDENTIFIER_POINTER (name
));
317 && (flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
)
318 && TYPE_SIZE (*anode
) != NULL_TREE
)
320 warning (OPT_Wattributes
, "type attributes ignored after type is already defined");
324 if (spec
->handler
!= NULL
)
325 returned_attrs
= chainon ((*spec
->handler
) (anode
, name
, args
,
326 flags
, &no_add_attrs
),
329 /* Layout the decl in case anything changed. */
330 if (spec
->type_required
&& DECL_P (*node
)
331 && (TREE_CODE (*node
) == VAR_DECL
332 || TREE_CODE (*node
) == PARM_DECL
333 || TREE_CODE (*node
) == RESULT_DECL
))
334 relayout_decl (*node
);
342 old_attrs
= DECL_ATTRIBUTES (*anode
);
344 old_attrs
= TYPE_ATTRIBUTES (*anode
);
346 for (a
= lookup_attribute (spec
->name
, old_attrs
);
348 a
= lookup_attribute (spec
->name
, TREE_CHAIN (a
)))
350 if (simple_cst_equal (TREE_VALUE (a
), args
) == 1)
356 /* This attribute isn't already in the list. */
358 DECL_ATTRIBUTES (*anode
) = tree_cons (name
, args
, old_attrs
);
359 else if (flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
)
361 TYPE_ATTRIBUTES (*anode
) = tree_cons (name
, args
, old_attrs
);
362 /* If this is the main variant, also push the attributes
363 out to the other variants. */
364 if (*anode
== TYPE_MAIN_VARIANT (*anode
))
367 for (variant
= *anode
; variant
;
368 variant
= TYPE_NEXT_VARIANT (variant
))
370 if (TYPE_ATTRIBUTES (variant
) == old_attrs
)
371 TYPE_ATTRIBUTES (variant
)
372 = TYPE_ATTRIBUTES (*anode
);
373 else if (!lookup_attribute
374 (spec
->name
, TYPE_ATTRIBUTES (variant
)))
375 TYPE_ATTRIBUTES (variant
) = tree_cons
376 (name
, args
, TYPE_ATTRIBUTES (variant
));
381 *anode
= build_type_attribute_variant (*anode
,
382 tree_cons (name
, args
,
389 /* Rebuild the function pointer type and put it in the
390 appropriate place. */
391 fn_ptr_tmp
= build_pointer_type (fn_ptr_tmp
);
393 TREE_TYPE (*node
) = fn_ptr_tmp
;
396 gcc_assert (TREE_CODE (*node
) == POINTER_TYPE
);
402 return returned_attrs
;