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 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 2, 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 COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
36 #include "langhooks.h"
38 static void init_attributes (void);
40 /* Table of the tables of attributes (common, language, format, machine)
42 static const struct attribute_spec
*attribute_tables
[4];
44 static bool attributes_initialized
= false;
46 /* Default empty table of attributes. */
47 static const struct attribute_spec empty_attribute_table
[] =
49 { NULL
, 0, 0, false, false, false, NULL
}
52 /* Initialize attribute tables, and make some sanity checks
53 if --enable-checking. */
56 init_attributes (void)
60 attribute_tables
[0] = lang_hooks
.common_attribute_table
;
61 attribute_tables
[1] = lang_hooks
.attribute_table
;
62 attribute_tables
[2] = lang_hooks
.format_attribute_table
;
63 attribute_tables
[3] = targetm
.attribute_table
;
65 /* Translate NULL pointers to pointers to the empty table. */
66 for (i
= 0; i
< ARRAY_SIZE (attribute_tables
); i
++)
67 if (attribute_tables
[i
] == NULL
)
68 attribute_tables
[i
] = empty_attribute_table
;
70 #ifdef ENABLE_CHECKING
71 /* Make some sanity checks on the attribute tables. */
72 for (i
= 0; i
< ARRAY_SIZE (attribute_tables
); i
++)
76 for (j
= 0; attribute_tables
[i
][j
].name
!= NULL
; j
++)
78 /* The name must not begin and end with __. */
79 const char *name
= attribute_tables
[i
][j
].name
;
80 int len
= strlen (name
);
81 if (name
[0] == '_' && name
[1] == '_'
82 && name
[len
- 1] == '_' && name
[len
- 2] == '_')
84 /* The minimum and maximum lengths must be consistent. */
85 if (attribute_tables
[i
][j
].min_length
< 0)
87 if (attribute_tables
[i
][j
].max_length
!= -1
88 && (attribute_tables
[i
][j
].max_length
89 < attribute_tables
[i
][j
].min_length
))
91 /* An attribute cannot require both a DECL and a TYPE. */
92 if (attribute_tables
[i
][j
].decl_required
93 && attribute_tables
[i
][j
].type_required
)
95 /* If an attribute requires a function type, in particular
96 it requires a type. */
97 if (attribute_tables
[i
][j
].function_type_required
98 && !attribute_tables
[i
][j
].type_required
)
103 /* Check that each name occurs just once in each table. */
104 for (i
= 0; i
< ARRAY_SIZE (attribute_tables
); i
++)
107 for (j
= 0; attribute_tables
[i
][j
].name
!= NULL
; j
++)
108 for (k
= j
+ 1; attribute_tables
[i
][k
].name
!= NULL
; k
++)
109 if (!strcmp (attribute_tables
[i
][j
].name
,
110 attribute_tables
[i
][k
].name
))
113 /* Check that no name occurs in more than one table. */
114 for (i
= 0; i
< ARRAY_SIZE (attribute_tables
); i
++)
118 for (j
= i
+ 1; j
< ARRAY_SIZE (attribute_tables
); j
++)
119 for (k
= 0; attribute_tables
[i
][k
].name
!= NULL
; k
++)
120 for (l
= 0; attribute_tables
[j
][l
].name
!= NULL
; l
++)
121 if (!strcmp (attribute_tables
[i
][k
].name
,
122 attribute_tables
[j
][l
].name
))
127 attributes_initialized
= true;
130 /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
131 which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL,
132 it should be modified in place; if a TYPE, a copy should be created
133 unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further
134 information, in the form of a bitwise OR of flags in enum attribute_flags
135 from tree.h. Depending on these flags, some attributes may be
136 returned to be applied at a later stage (for example, to apply
137 a decl attribute to the declaration rather than to its type). */
140 decl_attributes (tree
*node
, tree attributes
, int flags
)
143 tree returned_attrs
= NULL_TREE
;
145 if (!attributes_initialized
)
148 (*targetm
.insert_attributes
) (*node
, &attributes
);
150 for (a
= attributes
; a
; a
= TREE_CHAIN (a
))
152 tree name
= TREE_PURPOSE (a
);
153 tree args
= TREE_VALUE (a
);
155 const struct attribute_spec
*spec
= NULL
;
156 bool no_add_attrs
= 0;
159 for (i
= 0; i
< ARRAY_SIZE (attribute_tables
); i
++)
163 for (j
= 0; attribute_tables
[i
][j
].name
!= NULL
; j
++)
165 if (is_attribute_p (attribute_tables
[i
][j
].name
, name
))
167 spec
= &attribute_tables
[i
][j
];
177 warning ("`%s' attribute directive ignored",
178 IDENTIFIER_POINTER (name
));
181 else if (list_length (args
) < spec
->min_length
182 || (spec
->max_length
>= 0
183 && list_length (args
) > spec
->max_length
))
185 error ("wrong number of arguments specified for `%s' attribute",
186 IDENTIFIER_POINTER (name
));
190 if (spec
->decl_required
&& !DECL_P (*anode
))
192 if (flags
& ((int) ATTR_FLAG_DECL_NEXT
193 | (int) ATTR_FLAG_FUNCTION_NEXT
194 | (int) ATTR_FLAG_ARRAY_NEXT
))
196 /* Pass on this attribute to be tried again. */
197 returned_attrs
= tree_cons (name
, args
, returned_attrs
);
202 warning ("`%s' attribute does not apply to types",
203 IDENTIFIER_POINTER (name
));
208 /* If we require a type, but were passed a decl, set up to make a
209 new type and update the one in the decl. ATTR_FLAG_TYPE_IN_PLACE
210 would have applied if we'd been passed a type, but we cannot modify
211 the decl's type in place here. */
212 if (spec
->type_required
&& DECL_P (*anode
))
214 anode
= &TREE_TYPE (*anode
);
215 flags
&= ~(int) ATTR_FLAG_TYPE_IN_PLACE
;
218 if (spec
->function_type_required
&& TREE_CODE (*anode
) != FUNCTION_TYPE
219 && TREE_CODE (*anode
) != METHOD_TYPE
)
221 if (TREE_CODE (*anode
) == POINTER_TYPE
222 && (TREE_CODE (TREE_TYPE (*anode
)) == FUNCTION_TYPE
223 || TREE_CODE (TREE_TYPE (*anode
)) == METHOD_TYPE
))
225 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
226 *anode
= build_type_copy (*anode
);
227 anode
= &TREE_TYPE (*anode
);
229 else if (flags
& (int) ATTR_FLAG_FUNCTION_NEXT
)
231 /* Pass on this attribute to be tried again. */
232 returned_attrs
= tree_cons (name
, args
, returned_attrs
);
236 if (TREE_CODE (*anode
) != FUNCTION_TYPE
237 && TREE_CODE (*anode
) != METHOD_TYPE
)
239 warning ("`%s' attribute only applies to function types",
240 IDENTIFIER_POINTER (name
));
245 if (spec
->handler
!= NULL
)
246 returned_attrs
= chainon ((*spec
->handler
) (anode
, name
, args
,
247 flags
, &no_add_attrs
),
250 /* Layout the decl in case anything changed. */
251 if (spec
->type_required
&& DECL_P (*node
)
252 && (TREE_CODE (*node
) == VAR_DECL
253 || TREE_CODE (*node
) == PARM_DECL
254 || TREE_CODE (*node
) == RESULT_DECL
))
256 /* Force a recalculation of mode and size. */
257 DECL_MODE (*node
) = VOIDmode
;
258 DECL_SIZE (*node
) = 0;
260 layout_decl (*node
, 0);
269 old_attrs
= DECL_ATTRIBUTES (*anode
);
271 old_attrs
= TYPE_ATTRIBUTES (*anode
);
273 for (a
= lookup_attribute (spec
->name
, old_attrs
);
275 a
= lookup_attribute (spec
->name
, TREE_CHAIN (a
)))
277 if (simple_cst_equal (TREE_VALUE (a
), args
) == 1)
283 /* This attribute isn't already in the list. */
285 DECL_ATTRIBUTES (*anode
) = tree_cons (name
, args
, old_attrs
);
286 else if (flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
)
287 TYPE_ATTRIBUTES (*anode
) = tree_cons (name
, args
, old_attrs
);
289 *anode
= build_type_attribute_variant (*anode
,
290 tree_cons (name
, args
,
296 return returned_attrs
;
299 /* Split SPECS_ATTRS, a list of declspecs and prefix attributes, into two
300 lists. SPECS_ATTRS may also be just a typespec (eg: RECORD_TYPE).
302 The head of the declspec list is stored in DECLSPECS.
303 The head of the attribute list is stored in PREFIX_ATTRIBUTES.
305 Note that attributes in SPECS_ATTRS are stored in the TREE_PURPOSE of
306 the list elements. We drop the containing TREE_LIST nodes and link the
307 resulting attributes together the way decl_attributes expects them. */
310 split_specs_attrs (tree specs_attrs
, tree
*declspecs
, tree
*prefix_attributes
)
312 tree t
, s
, a
, next
, specs
, attrs
;
314 /* This can happen after an __extension__ in pedantic mode. */
315 if (specs_attrs
!= NULL_TREE
316 && TREE_CODE (specs_attrs
) == INTEGER_CST
)
318 *declspecs
= NULL_TREE
;
319 *prefix_attributes
= NULL_TREE
;
323 /* This can happen in c++ (eg: decl: typespec initdecls ';'). */
324 if (specs_attrs
!= NULL_TREE
325 && TREE_CODE (specs_attrs
) != TREE_LIST
)
327 *declspecs
= specs_attrs
;
328 *prefix_attributes
= NULL_TREE
;
332 /* Remember to keep the lists in the same order, element-wise. */
334 specs
= s
= NULL_TREE
;
335 attrs
= a
= NULL_TREE
;
336 for (t
= specs_attrs
; t
; t
= next
)
338 next
= TREE_CHAIN (t
);
339 /* Declspecs have a non-NULL TREE_VALUE. */
340 if (TREE_VALUE (t
) != NULL_TREE
)
342 if (specs
== NULL_TREE
)
350 /* The TREE_PURPOSE may also be empty in the case of
351 __attribute__(()). */
352 else if (TREE_PURPOSE (t
) != NULL_TREE
)
354 if (attrs
== NULL_TREE
)
355 attrs
= a
= TREE_PURPOSE (t
);
358 TREE_CHAIN (a
) = TREE_PURPOSE (t
);
359 a
= TREE_PURPOSE (t
);
361 /* More attrs can be linked here, move A to the end. */
362 while (TREE_CHAIN (a
) != NULL_TREE
)
367 /* Terminate the lists. */
369 TREE_CHAIN (s
) = NULL_TREE
;
371 TREE_CHAIN (a
) = NULL_TREE
;
375 *prefix_attributes
= attrs
;
378 /* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
379 This function is used by the parser when a rule will accept attributes
380 in a particular position, but we don't want to support that just yet.
382 A warning is issued for every ignored attribute. */
385 strip_attrs (tree specs_attrs
)
389 split_specs_attrs (specs_attrs
, &specs
, &attrs
);
393 warning ("`%s' attribute ignored",
394 IDENTIFIER_POINTER (TREE_PURPOSE (attrs
)));
395 attrs
= TREE_CHAIN (attrs
);