Studying note of GCC-3.4.6 source (60)

4.3.1.7.5.6.5. Processing attributes of builtin
4.3.1.7.5.6.5.1. Install attribute handlers
Though we create nodes for attributes of builtin functions, we still don’t install them into the builtin function. And even there is no attribute, we should express this fact in the function node explicitly.

builtin_function_1 (continue)

3253 /* Possibly apply some default attributes to this built-in function. */
3254 if (attrs)
3255 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
3256 else
3257 decl_attributes (&decl, NULL_TREE, 0);
3258
3259 return decl;
3260 }

Obviously, the language determines the set of available attributes, further some attributes’ processing methods depend on target. So first, we need to select out the correct methods according to the language and the target.

139 tree
140 decl_attributes (tree *node, tree attributes, int flags) in attribs.c
141 {
142 tree a;
143 tree returned_attrs = NULL_TREE;
144
145 if (!attributes_initialized)
146 init_attributes ();

Attribute handling methods are collected by attribute_spec with other running information. In GCC v3.4.6, the methods are grouped into 4 sets.

42 static const struct attribute_spec *attribute_tables[4]; in attribs.c

2181 struct attribute_spec in tree.h
2182 {
2183 /* The name of the attribute (without any leading or trailing __),
2184 or NULL to mark the end of a table of attributes. */
2185 const char *const name;
2186 /* The minimum length of the list of arguments of the attribute. */
2187 const int min_length;
2188 /* The maximum length of the list of arguments of the attribute
2189 (-1 for no maximum). */
2190 const int max_length;
2191 /* Whether this attribute requires a DECL. If it does, it will be passed
2192 from types of DECLs, function return types and array element types to
2193 the DECLs, function types and array types respectively; but when
2194 applied to a type in any other circumstances, it will be ignored with
2195 a warning. (If greater control is desired for a given attribute,
2196 this should be false, and the flags argument to the handler may be
2197 used to gain greater control in that case.) */
2198 const bool decl_required;
2199 /* Whether this attribute requires a type. If it does, it will be passed
2200 from a DECL to the type of that DECL. */
2201 const bool type_required;
2202 /* Whether this attribute requires a function (or method) type. If it does,
2203 it will be passed from a function pointer type to the target type,
2204 and from a function return type (which is not itself a function
2205 pointer type) to the function type. */
2206 const bool function_type_required;
2207 /* Function to handle this attribute. NODE points to the node to which
2208 the attribute is to be applied. If a DECL, it should be modified in
2209 place; if a TYPE, a copy should be created. NAME is the name of the
2210 attribute (possibly with leading or trailing __). ARGS is the TREE_LIST
2211 of the arguments (which may be NULL). FLAGS gives further information
2212 about the context of the attribute. Afterwards, the attributes will
2213 be added to the DECL_ATTRIBUTES or TYPE_ATTRIBUTES, as appropriate,
2214 unless *NO_ADD_ATTRS is set to true (which should be done on error,
2215 as well as in any other cases when the attributes should not be added
2216 to the DECL or TYPE). Depending on FLAGS, any attributes to be
2217 applied to another type or DECL later may be returned;
2218 otherwise the return value should be NULL_TREE. This pointer may be
2219 NULL if no special handling is required beyond the checks implied
2220 by the rest of this structure. */
2221 tree (*const handler) (tree *node, tree name, tree args,
2222 int flags, bool *no_add_attrs);
2223 };

The detail information about these 4 sets are given in following 4 tables.

name	min args	max args	del_req	type_req	func_req	handler
packed	0	0	false	false	false	handle_packed_attribute
nocommon	0	0	true	false	false	handle_nocommon_attribute
common	0	0	true	false	false	handle_common_attribute
noreturn	0	0	true	false	false	handle_noreturn_attribute
volatile	0	0	true	false	false	handle_noreturn_attribute
noinline	0	0	true	false	false	handle_noinline_attribute
always_inline	0	0	true	false	false	handle_always_inline_attribute
used	0	0	true	false	false	handle_used_attribute
unused	0	0	false	false	false	handle_unused_attribute
const	0	0	true	false	false	handle_const_attribute
transparent_union	0	0	false	false	false	handle_transparent_union_attribute
constructor	0	0	true	false	false	handle_constructor_attribute
destructor	0	0	true	false	false	handle_destructor_attribute
mode	1	1	false	true	false	handle_mode_attribute
section	1	1	true	false	false	handle_section_attribute
aligned	0	1	false	false	false	handle_aligned_attribute
weak	0	0	true	false	false	handle_weak_attribute
alias	1	1	true	false	false	handle_alias_attribute
no_instrument_function	0	0	true	false	false	handle_no_instrument_function_attribute
malloc	0	0	true	false	false	handle_malloc_attribute
no_stack_limit	0	0	true	false	false	handle_no_limit_stack_attribute
pure	0	0	true	false	false	handle_pure_attribute
deprecated	0	0	false	false	false	handle_deprecated_attribute
vector_size	1	1	false	true	false	handle_vector_size_attribute
visibility	1	1	true	false	false	handle_visibility_attribute
tls_model	1	1	true	false	false	handle_tls_model_attribute
nonnull	0	-1	false	true	true	handle_nonnull_attribute
nothrow	0	0	true	false	false	handle_nothrow_attribute
may_alias	0	0	false	true	false	NULL
cleanup	1	1	true	false	false	handle_cleanup_attribute
warn_unused_result	0	0	false	true	true	handle_warn_unused_result_attribute

Table 12: builtin functions of common_attribute_table for C++

name	min args	max args	del_req	type_req	func_req	handler
java_interface	0	0	false	false	false	handle_java_interface_attribute
com_interface	0	0	false	false	false	handle_com_interface_attribute
init_priority	1	1	true	false	false	handle_init_priority_attribute

Table 13: builtin function of attribute_table for C++

name	min args	max args	del_req	type_req	func_req	handler
format	3	3	false	true	true	handle_format_attribute
format_arg	1	1	false	true	true	handle_format_arg_attribute

Table 14: builtin function of format_attribute_table for C++

name	min args	max args	del_req	type_req	func_req	handler
stdcall	0	0	false	true	true	ix86_handle_cdecl_attribute
fastcall	0	0	false	true	true	ix86_handle_cdecl_attribute
cdecl	0	0	false	true	true	ix86_handle_cdecl_attribute
regparm	1	1	false	true	true	ix86_handle_regparm_attribute
ms_struct	0	0	false	false	false	ix86_handle_struct_attribute
gcc_struct	0	0	false	false	false	ix86_handle_struct_attribute

Table 15: builtin function of ix86_attribute_table for x86 machine
In below code, it can see that the first 3 tables are set by language hook, which have their content filled by the language; and in the last table are attributes unrelated to language but depend on target.

55 static void
56 init_attributes (void) in attribs.c
57 {
58 size_t i;
59
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;
64
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;
69
70 #ifdef ENABLE_CHECKING
...
125 #endif
126
127 attributes_initialized = true;
128 }

Remember that in the builtin function “__builtin_vprintf”, its attributes are given in built_in_attributes [ATTR_FORMAT_PRINTF_1_0], and its structure is shown is below figure.



In this image, it is clearly that attributes are linked tegother by field chain, with field purpose tells out what it is for and field value gives out its content. Notice that purpose field in fact is a node of identifier.

decl_attributes (continue)

148 (*targetm.insert_attributes) (*node, &attributes);
149
150 for (a = attributes; a; a = TREE_CHAIN (a))
151 {
152 tree name = TREE_PURPOSE (a);
153 tree args = TREE_VALUE (a);
154 tree *anode = node;
155 const struct attribute_spec *spec = NULL;
156 bool no_add_attrs = 0;
157 tree fn_ptr_tmp = NULL_TREE;
158 size_t i;
159
160 for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
161 {
162 int j;
163
164 for (j = 0; attribute_tables[i][j].name != NULL; j++)
165 {
166 if (is_attribute_p (attribute_tables[i][j].name, name))
167 {
168 spec = &attribute_tables[i][j];
169 break;
170 }
171 }
172 if (spec != NULL)
173 break;
174 }
175
176 if (spec == NULL)
177 {
178 warning ("`%s' attribute directive ignored",
179 IDENTIFIER_POINTER (name));
180 continue;
181 }
182 else if (list_length (args) < spec->min_length
183 || (spec->max_length >= 0
184 && list_length (args) > spec->max_length))
185 {
186 error ("wrong number of arguments specified for `%s' attribute",
187 IDENTIFIER_POINTER (name));
188 continue;
189 }

At line 148, for x86 machine, insert_attributes is not redefined. It does nothing by default. Andnote that anode and node are both pointer of pointer, node always keeps the address of the tree node, and anode transfer within the node for searching the real object the attributes being applied. To clarify the real kind of the node, argument flags is used give out the detail. Currently, below enumerators are in used:
ATTR_FLAG_DECL_NEXT: node is the type of a declaration, and any attributes that should be passed in again to be applied to the declaration rather than the type should be returned.
ATTR_FLAG_FUNCTION_NEXT: node is a function-return-type, and any attributes that should be passed in again to be applied to the function type rather than the return type should be returned.
ATTR_FLAG_ARRAY_NEXT: node is an array-element-type, and any attributes that should be passed in again to be applied to the array type rather than the element type should be returned.
ATTR_FLAG_TYPE_IN_PLACE: node is a struct, union or enum type being created, and should be modified in place.
ATTR_FLAG_BUILT_IN: The attributes are being applied by default to a library function whose name indicates known behavior, and should be silently ignored if they are not in fact compatible with the function type.
Here for builtin “__builtin_vprintf”, argument flags is ATTR_FLAG_BUILT_IN.

decl_attributes (continue)

191 if (spec->decl_required && !DECL_P (*anode))
192 {
193 if (flags & ((int) ATTR_FLAG_DECL_NEXT
194 | (int) ATTR_FLAG_FUNCTION_NEXT
195 | (int) ATTR_FLAG_ARRAY_NEXT))
196 {
197 /* Pass on this attribute to be tried again. */
198 returned_attrs = tree_cons (name, args, returned_attrs);
199 continue;
200 }
201 else
202 {
203 warning ("`%s' attribute does not apply to types",
204 IDENTIFIER_POINTER (name));
205 continue;
206 }
207 }
208
209 /* If we require a type, but were passed a decl, set up to make a
210 new type and update the one in the decl. ATTR_FLAG_TYPE_IN_PLACE
211 would have applied if we'd been passed a type, but we cannot modify
212 the decl's type in place here. */
213 if (spec->type_required && DECL_P (*anode))
214 {
215 anode = &TREE_TYPE (*anode);
216 flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
217 }
218
219 if (spec->function_type_required && TREE_CODE (*anode) != FUNCTION_TYPE
220 && TREE_CODE (*anode) != METHOD_TYPE)
221 {
222 if (TREE_CODE (*anode) == POINTER_TYPE
223 && (TREE_CODE (TREE_TYPE (*anode)) == FUNCTION_TYPE
224 || TREE_CODE (TREE_TYPE (*anode)) == METHOD_TYPE))
225 {
226 /* OK, this is a bit convoluted. We can't just make a copy
227 of the pointer type and modify its TREE_TYPE, because if
228 we change the attributes of the target type the pointer
229 type needs to have a different TYPE_MAIN_VARIANT. So we
230 pull out the target type now, frob it as appropriate, and
231 rebuild the pointer type later.
232
233 This would all be simpler if attributes were part of the
234 declarator, grumble grumble. */
235 fn_ptr_tmp = TREE_TYPE (*anode);
236 anode = &fn_ptr_tmp;
237 flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
238 }
239 else if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
240 {
241 /* Pass on this attribute to be tried again. */
242 returned_attrs = tree_cons (name, args, returned_attrs);
243 continue;
244 }
245
246 if (TREE_CODE (*anode) != FUNCTION_TYPE
247 && TREE_CODE (*anode) != METHOD_TYPE)
248 {
249 warning ("`%s' attribute only applies to function types",
250 IDENTIFIER_POINTER (name));
251 continue;
252 }
253 }
254
255 if (spec->handler != NULL)
256 returned_attrs = chainon ((*spec->handler) (anode, name, args,
257 flags, &no_add_attrs),
258 returned_attrs);

Refer to builtin function for format_attribute_table for C++, for attribute of format, it requires type and function type, but node is a FUNCTION_DECL. However, at line 215, anode is updated to the type of declaration - builtin_types [BT_FN_INT_CONST_STRING_VALIST_ARG].