Line data Source code
1 : /* Functions dealing with attribute handling, used by most front ends.
2 : Copyright (C) 1992-2026 Free Software Foundation, Inc.
3 :
4 : This file is part of GCC.
5 :
6 : GCC is free software; you can redistribute it and/or modify it under
7 : the terms of the GNU General Public License as published by the Free
8 : Software Foundation; either version 3, or (at your option) any later
9 : version.
10 :
11 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 : WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 : for more details.
15 :
16 : You should have received a copy of the GNU General Public License
17 : along with GCC; see the file COPYING3. If not see
18 : <http://www.gnu.org/licenses/>. */
19 :
20 : #define INCLUDE_STRING
21 : #include "config.h"
22 : #include "system.h"
23 : #include "coretypes.h"
24 : #include "target.h"
25 : #include "tree.h"
26 : #include "stringpool.h"
27 : #include "diagnostic-core.h"
28 : #include "attribs.h"
29 : #include "fold-const.h"
30 : #include "ipa-strub.h"
31 : #include "stor-layout.h"
32 : #include "langhooks.h"
33 : #include "plugin.h"
34 : #include "selftest.h"
35 : #include "hash-set.h"
36 : #include "diagnostic.h"
37 : #include "pretty-print.h"
38 : #include "pretty-print-markup.h"
39 : #include "tree-pretty-print.h"
40 : #include "intl.h"
41 : #include "gcc-urlifier.h"
42 : #include "cgraph.h"
43 :
44 : /* Table of the tables of attributes (common, language, format, machine)
45 : searched. */
46 : static array_slice<const scoped_attribute_specs *const> attribute_tables[2];
47 :
48 : /* Substring representation. */
49 :
50 : struct substring
51 : {
52 : const char *str;
53 : int length;
54 : };
55 :
56 : /* Simple hash function to avoid need to scan whole string. */
57 :
58 : static inline hashval_t
59 13506397297 : substring_hash (const char *str, int l)
60 : {
61 13506397297 : return str[0] + str[l - 1] * 256 + l * 65536;
62 : }
63 :
64 : /* Used for attribute_hash. */
65 :
66 : struct attribute_hasher : nofree_ptr_hash <attribute_spec>
67 : {
68 : typedef substring *compare_type;
69 : static inline hashval_t hash (const attribute_spec *);
70 : static inline bool equal (const attribute_spec *, const substring *);
71 : };
72 :
73 : inline hashval_t
74 11428705581 : attribute_hasher::hash (const attribute_spec *spec)
75 : {
76 11428705581 : const int l = strlen (spec->name);
77 11428705581 : return substring_hash (spec->name, l);
78 : }
79 :
80 : inline bool
81 13989769624 : attribute_hasher::equal (const attribute_spec *spec, const substring *str)
82 : {
83 13989769624 : return (strncmp (spec->name, str->str, str->length) == 0
84 13989769624 : && !spec->name[str->length]);
85 : }
86 :
87 : /* Scoped attribute name representation. */
88 :
89 : struct scoped_attributes
90 : {
91 : const char *ns;
92 : vec<attribute_spec> attributes;
93 : hash_table<attribute_hasher> *attribute_hash;
94 : /* True if we should not warn about unknown attributes in this NS. */
95 : bool ignored_p;
96 : };
97 :
98 : /* The table of scope attributes. */
99 : static vec<scoped_attributes> attributes_table;
100 :
101 : static scoped_attributes* find_attribute_namespace (const char*);
102 : static void register_scoped_attribute (const struct attribute_spec *,
103 : scoped_attributes *);
104 : static const struct attribute_spec *lookup_scoped_attribute_spec (const_tree,
105 : const_tree);
106 :
107 : static bool attributes_initialized = false;
108 :
109 : /* Do not use directly; go through get_gnu_namespace instead. */
110 : static GTY(()) tree gnu_namespace_cache;
111 :
112 : /* Return the IDENTIFIER_NODE for the gnu namespace. */
113 :
114 : static tree
115 2867242709 : get_gnu_namespace ()
116 : {
117 2867242709 : if (!gnu_namespace_cache)
118 295498 : gnu_namespace_cache = get_identifier ("gnu");
119 2867242709 : return gnu_namespace_cache;
120 : }
121 :
122 : /* Insert SPECS into its namespace. IGNORED_P is true iff all unknown
123 : attributes in this namespace should be ignored for the purposes of
124 : -Wattributes. The function returns the namespace into which the
125 : attributes have been registered. */
126 :
127 : scoped_attributes *
128 1546681 : register_scoped_attributes (const scoped_attribute_specs &specs,
129 : bool ignored_p /*=false*/)
130 : {
131 1546681 : scoped_attributes *result = NULL;
132 :
133 : /* See if we already have attributes in the namespace NS. */
134 1546681 : result = find_attribute_namespace (specs.ns);
135 :
136 1546681 : if (result == NULL)
137 : {
138 : /* We don't have any namespace NS yet. Create one. */
139 827522 : scoped_attributes sa;
140 :
141 827522 : if (attributes_table.is_empty ())
142 295627 : attributes_table.create (64);
143 :
144 827522 : memset (&sa, 0, sizeof (sa));
145 827522 : sa.ns = specs.ns;
146 827522 : sa.attributes.create (64);
147 827522 : sa.ignored_p = ignored_p;
148 827522 : result = attributes_table.safe_push (sa);
149 827522 : result->attribute_hash = new hash_table<attribute_hasher> (200);
150 : }
151 : else
152 719159 : result->ignored_p |= ignored_p;
153 :
154 : /* Really add the attributes to their namespace now. */
155 43775736 : for (const attribute_spec &attribute : specs.attributes)
156 : {
157 42229055 : result->attributes.safe_push (attribute);
158 42229055 : register_scoped_attribute (&attribute, result);
159 : }
160 :
161 1546681 : gcc_assert (result != NULL);
162 :
163 1546681 : return result;
164 : }
165 :
166 : /* Return the namespace which name is NS, NULL if none exist. */
167 :
168 : static scoped_attributes*
169 2037281402 : find_attribute_namespace (const char* ns)
170 : {
171 7968431617 : for (scoped_attributes &iter : attributes_table)
172 3893895248 : if (ns == iter.ns
173 3866535461 : || (iter.ns != NULL
174 2014815985 : && ns != NULL
175 2014815985 : && !strcmp (iter.ns, ns)))
176 : return &iter;
177 : return NULL;
178 : }
179 :
180 : /* Make some sanity checks on the attribute tables. */
181 :
182 : static void
183 295608 : check_attribute_tables (void)
184 : {
185 295608 : hash_set<pair_hash<nofree_string_hash, nofree_string_hash>> names;
186 :
187 1182432 : for (auto scoped_array : attribute_tables)
188 2137627 : for (auto scoped_attributes : scoped_array)
189 43771885 : for (const attribute_spec &attribute : scoped_attributes->attributes)
190 : {
191 : /* The name must not begin and end with __. */
192 42225474 : const char *name = attribute.name;
193 42225474 : int len = strlen (name);
194 :
195 42225474 : gcc_assert (!(name[0] == '_' && name[1] == '_'
196 : && name[len - 1] == '_' && name[len - 2] == '_'));
197 :
198 : /* The minimum and maximum lengths must be consistent. */
199 42225474 : gcc_assert (attribute.min_length >= 0);
200 :
201 42225474 : gcc_assert (attribute.max_length == -1
202 : || attribute.max_length >= attribute.min_length);
203 :
204 : /* An attribute cannot require both a DECL and a TYPE. */
205 42225474 : gcc_assert (!attribute.decl_required
206 : || !attribute.type_required);
207 :
208 : /* If an attribute requires a function type, in particular
209 : it requires a type. */
210 42225474 : gcc_assert (!attribute.function_type_required
211 : || attribute.type_required);
212 :
213 : /* Check that no name occurs more than once. Names that
214 : begin with '*' are exempt, and may be overridden. */
215 42225474 : const char *ns = scoped_attributes->ns;
216 44049490 : if (name[0] != '*' && names.add ({ ns ? ns : "", name }))
217 0 : gcc_unreachable ();
218 : }
219 295608 : }
220 :
221 : /* Used to stash pointers to allocated memory so that we can free them at
222 : the end of parsing of all TUs. */
223 : static vec<attribute_spec *> ignored_attributes_table;
224 :
225 : /* Parse arguments V of -Wno-attributes=.
226 : Currently we accept:
227 : vendor::attr
228 : vendor::
229 : This functions also registers the parsed attributes so that we don't
230 : warn that we don't recognize them. */
231 :
232 : void
233 295671 : handle_ignored_attributes_option (vec<char *> *v)
234 : {
235 295671 : if (v == nullptr)
236 : return;
237 :
238 330 : for (auto opt : v)
239 : {
240 184 : char *cln = strstr (opt, "::");
241 : /* We don't accept '::attr'. */
242 184 : if (cln == nullptr || cln == opt)
243 : {
244 0 : auto_diagnostic_group d;
245 0 : error ("wrong argument to ignored attributes");
246 0 : inform (input_location, "valid format is %<ns::attr%> or %<ns::%>");
247 0 : continue;
248 0 : }
249 184 : const char *vendor_start = opt;
250 184 : ptrdiff_t vendor_len = cln - opt;
251 184 : const char *attr_start = cln + 2;
252 : /* This could really use rawmemchr :(. */
253 184 : ptrdiff_t attr_len = strchr (attr_start, '\0') - attr_start;
254 : /* Verify that they look valid. */
255 501 : auto valid_p = [](const char *const s, ptrdiff_t len) {
256 317 : bool ok = false;
257 :
258 1596 : for (int i = 0; i < len; ++i)
259 1287 : if (ISALNUM (s[i]))
260 : ok = true;
261 182 : else if (s[i] != '_')
262 : return false;
263 :
264 : return ok;
265 : };
266 184 : if (!valid_p (vendor_start, vendor_len))
267 : {
268 12 : error ("wrong argument to ignored attributes");
269 12 : continue;
270 : }
271 172 : canonicalize_attr_name (vendor_start, vendor_len);
272 : /* We perform all this hijinks so that we don't have to copy OPT. */
273 172 : tree vendor_id = get_identifier_with_length (vendor_start, vendor_len);
274 172 : array_slice<const attribute_spec> attrs;
275 : /* In the "vendor::" case, we should ignore *any* attribute coming
276 : from this attribute namespace. */
277 172 : if (attr_len > 0)
278 : {
279 133 : if (!valid_p (attr_start, attr_len))
280 : {
281 8 : error ("wrong argument to ignored attributes");
282 24 : continue;
283 : }
284 125 : canonicalize_attr_name (attr_start, attr_len);
285 125 : tree attr_id = get_identifier_with_length (attr_start, attr_len);
286 125 : const char *attr = IDENTIFIER_POINTER (attr_id);
287 : /* If we've already seen this vendor::attr, ignore it. Attempting to
288 : register it twice would lead to a crash. */
289 125 : if (lookup_scoped_attribute_spec (vendor_id, attr_id))
290 16 : continue;
291 : /* Create a table with extra attributes which we will register.
292 : We can't free it here, so squirrel away the pointers. */
293 109 : attribute_spec *table = new attribute_spec {
294 : attr, 0, -2, false, false, false, false, nullptr, nullptr
295 109 : };
296 109 : ignored_attributes_table.safe_push (table);
297 109 : attrs = { table, 1 };
298 : }
299 148 : const scoped_attribute_specs scoped_specs = {
300 148 : IDENTIFIER_POINTER (vendor_id), { attrs }
301 148 : };
302 148 : register_scoped_attributes (scoped_specs, attrs.empty ());
303 : }
304 : }
305 :
306 : /* Free data we might have allocated when adding extra attributes. */
307 :
308 : void
309 287747 : free_attr_data ()
310 : {
311 287922 : for (auto x : ignored_attributes_table)
312 109 : delete x;
313 287747 : ignored_attributes_table.release ();
314 287747 : }
315 :
316 : /* Initialize attribute tables, and make some sanity checks if checking is
317 : enabled. */
318 :
319 : void
320 1149061 : init_attributes (void)
321 : {
322 1149061 : if (attributes_initialized)
323 : return;
324 :
325 295627 : attribute_tables[0] = lang_hooks.attribute_table;
326 295627 : attribute_tables[1] = targetm.attribute_table;
327 :
328 295627 : if (flag_checking)
329 295608 : check_attribute_tables ();
330 :
331 886881 : for (auto scoped_array : attribute_tables)
332 2137787 : for (auto scoped_attributes : scoped_array)
333 1546533 : register_scoped_attributes (*scoped_attributes);
334 :
335 295627 : vec<char *> *ignored = (vec<char *> *) flag_ignored_attributes;
336 295627 : handle_ignored_attributes_option (ignored);
337 :
338 295627 : invoke_plugin_callbacks (PLUGIN_ATTRIBUTES, NULL);
339 295627 : attributes_initialized = true;
340 : }
341 :
342 : /* Insert a single ATTR into the attribute table. */
343 :
344 : void
345 1 : register_attribute (const struct attribute_spec *attr)
346 : {
347 1 : register_scoped_attribute (attr, find_attribute_namespace ("gnu"));
348 1 : }
349 :
350 : /* Insert a single attribute ATTR into a namespace of attributes. */
351 :
352 : static void
353 42229056 : register_scoped_attribute (const struct attribute_spec *attr,
354 : scoped_attributes *name_space)
355 : {
356 42229056 : struct substring str;
357 42229056 : attribute_spec **slot;
358 :
359 42229056 : gcc_assert (attr != NULL && name_space != NULL);
360 :
361 42229056 : gcc_assert (name_space->attribute_hash);
362 :
363 42229056 : str.str = attr->name;
364 42229056 : str.length = strlen (str.str);
365 :
366 : /* Attribute names in the table must be in the form 'text' and not
367 : in the form '__text__'. */
368 42229056 : gcc_checking_assert (!canonicalize_attr_name (str.str, str.length));
369 :
370 42229056 : slot = name_space->attribute_hash
371 42229056 : ->find_slot_with_hash (&str, substring_hash (str.str, str.length),
372 : INSERT);
373 42229056 : gcc_assert (!*slot || attr->name[0] == '*');
374 42229056 : *slot = const_cast<struct attribute_spec *> (attr);
375 42229056 : }
376 :
377 : /* Return the spec for the scoped attribute with namespace NS and
378 : name NAME. */
379 :
380 : static const struct attribute_spec *
381 2035733965 : lookup_scoped_attribute_spec (const_tree ns, const_tree name)
382 : {
383 2035733965 : struct substring attr;
384 2035733965 : scoped_attributes *attrs;
385 :
386 4044828232 : const char *ns_str = (ns != NULL_TREE) ? IDENTIFIER_POINTER (ns) : NULL;
387 :
388 2035733965 : attrs = find_attribute_namespace (ns_str);
389 :
390 2035733965 : if (attrs == NULL)
391 : return NULL;
392 :
393 2035462660 : attr.str = IDENTIFIER_POINTER (name);
394 2035462660 : attr.length = IDENTIFIER_LENGTH (name);
395 2035462660 : return attrs->attribute_hash->find_with_hash (&attr,
396 : substring_hash (attr.str,
397 2035462660 : attr.length));
398 : }
399 :
400 : /* Return the spec for the attribute named NAME. If NAME is a TREE_LIST,
401 : it also specifies the attribute namespace. */
402 :
403 : const struct attribute_spec *
404 384812502 : lookup_attribute_spec (const_tree name)
405 : {
406 384812502 : tree ns;
407 384812502 : if (TREE_CODE (name) == TREE_LIST)
408 : {
409 22003021 : ns = TREE_PURPOSE (name);
410 22003021 : name = TREE_VALUE (name);
411 : }
412 : else
413 362809481 : ns = get_gnu_namespace ();
414 384812502 : return lookup_scoped_attribute_spec (ns, name);
415 : }
416 :
417 :
418 : /* Return the namespace of the attribute ATTR. This accessor works on
419 : GNU and C++11 (scoped) attributes. On GNU attributes,
420 : it returns an identifier tree for the string "gnu".
421 :
422 : Please read the comments of cxx11_attribute_p to understand the
423 : format of attributes. */
424 :
425 : tree
426 2549690304 : get_attribute_namespace (const_tree attr)
427 : {
428 2549690304 : if (cxx11_attribute_p (attr))
429 45257076 : return TREE_PURPOSE (TREE_PURPOSE (attr));
430 2504433228 : return get_gnu_namespace ();
431 : }
432 :
433 : /* Check LAST_DECL and NODE of the same symbol for attributes that are
434 : recorded in SPEC to be mutually exclusive with ATTRNAME, diagnose
435 : them, and return true if any have been found. NODE can be a DECL
436 : or a TYPE. */
437 :
438 : static bool
439 363494188 : diag_attr_exclusions (tree last_decl, tree node, tree attrname,
440 : const attribute_spec *spec)
441 : {
442 363494188 : const attribute_spec::exclusions *excl = spec->exclude;
443 :
444 363494188 : tree_code code = TREE_CODE (node);
445 :
446 363494188 : if ((code == FUNCTION_DECL && !excl->function
447 0 : && (!excl->type || !spec->affects_type_identity))
448 363494188 : || (code == VAR_DECL && !excl->variable
449 : && (!excl->type || !spec->affects_type_identity))
450 363457136 : || (((code == TYPE_DECL || RECORD_OR_UNION_TYPE_P (node)) && !excl->type)))
451 : return false;
452 :
453 : /* True if an attribute that's mutually exclusive with ATTRNAME
454 : has been found. */
455 363179274 : bool found = false;
456 :
457 363179274 : if (last_decl && last_decl != node && TREE_TYPE (last_decl) != node)
458 : {
459 : /* Check both the last DECL and its type for conflicts with
460 : the attribute being added to the current decl or type. */
461 1930902 : found |= diag_attr_exclusions (last_decl, last_decl, attrname, spec);
462 1930902 : tree decl_type = TREE_TYPE (last_decl);
463 1930902 : found |= diag_attr_exclusions (last_decl, decl_type, attrname, spec);
464 : }
465 :
466 : /* NODE is either the current DECL to which the attribute is being
467 : applied or its TYPE. For the former, consider the attributes on
468 : both the DECL and its type. */
469 363179274 : tree attrs[2];
470 :
471 363179274 : if (DECL_P (node))
472 : {
473 355840365 : attrs[0] = DECL_ATTRIBUTES (node);
474 355840365 : if (TREE_TYPE (node))
475 355840362 : attrs[1] = TYPE_ATTRIBUTES (TREE_TYPE (node));
476 : else
477 : /* TREE_TYPE can be NULL e.g. while processing attributes on
478 : enumerators. */
479 3 : attrs[1] = NULL_TREE;
480 : }
481 : else
482 : {
483 7338909 : attrs[0] = TYPE_ATTRIBUTES (node);
484 7338909 : attrs[1] = NULL_TREE;
485 : }
486 :
487 : /* Iterate over the mutually exclusive attribute names and verify
488 : that the symbol doesn't contain it. */
489 1089537822 : for (unsigned i = 0; i != ARRAY_SIZE (attrs); ++i)
490 : {
491 726358548 : if (!attrs[i])
492 637276144 : continue;
493 :
494 277821261 : for ( ; excl->name; ++excl)
495 : {
496 : /* Avoid checking the attribute against itself. */
497 188738857 : if (is_attribute_p (excl->name, attrname))
498 188738442 : continue;
499 :
500 174601270 : if (!lookup_attribute (excl->name, attrs[i]))
501 174599673 : continue;
502 :
503 : /* An exclusion may apply either to a function declaration,
504 : type declaration, or a field/variable declaration, or
505 : any subset of the three. */
506 1597 : if (TREE_CODE (node) == FUNCTION_DECL
507 353 : && !excl->function)
508 0 : continue;
509 :
510 1597 : if (TREE_CODE (node) == TYPE_DECL
511 0 : && !excl->type)
512 0 : continue;
513 :
514 1597 : if ((TREE_CODE (node) == FIELD_DECL
515 1597 : || VAR_P (node))
516 1203 : && !excl->variable)
517 1182 : continue;
518 :
519 415 : found = true;
520 :
521 : /* Print a note? */
522 415 : bool note = last_decl != NULL_TREE;
523 415 : auto_diagnostic_group d;
524 415 : if (TREE_CODE (node) == FUNCTION_DECL
525 415 : && fndecl_built_in_p (node))
526 0 : note &= warning (OPT_Wattributes,
527 : "ignoring attribute %qE in declaration of "
528 : "a built-in function %qD because it conflicts "
529 : "with attribute %qs",
530 0 : attrname, node, excl->name);
531 : else
532 415 : note &= warning (OPT_Wattributes,
533 : "ignoring attribute %qE because "
534 : "it conflicts with attribute %qs",
535 415 : attrname, excl->name);
536 :
537 415 : if (note)
538 180 : inform (DECL_SOURCE_LOCATION (last_decl),
539 : "previous declaration here");
540 415 : }
541 : }
542 :
543 : return found;
544 : }
545 :
546 : /* Return true iff we should not complain about unknown attributes
547 : coming from the attribute namespace NS. This is the case for
548 : the -Wno-attributes=ns:: command-line option. */
549 :
550 : static bool
551 806 : attr_namespace_ignored_p (tree ns)
552 : {
553 806 : if (ns == NULL_TREE)
554 : return false;
555 755 : scoped_attributes *r = find_attribute_namespace (IDENTIFIER_POINTER (ns));
556 755 : return r && r->ignored_p;
557 : }
558 :
559 : /* Return true if the attribute ATTR should not be warned about. */
560 :
561 : bool
562 1647695004 : attribute_ignored_p (tree attr)
563 : {
564 1647695004 : if (!cxx11_attribute_p (attr))
565 : return false;
566 19333688 : if (tree ns = get_attribute_namespace (attr))
567 : {
568 4359168 : const attribute_spec *as = lookup_attribute_spec (TREE_PURPOSE (attr));
569 4359168 : if (as == NULL && attr_namespace_ignored_p (ns))
570 : return true;
571 4359101 : if (as && as->max_length == -2)
572 221 : return true;
573 : }
574 : return false;
575 : }
576 :
577 : /* Like above, but takes an attribute_spec AS, which must be nonnull. */
578 :
579 : bool
580 93076 : attribute_ignored_p (const attribute_spec *const as)
581 : {
582 93076 : return as->max_length == -2;
583 : }
584 :
585 : /* Return true if the ATTRS chain contains at least one attribute which
586 : is not ignored. */
587 :
588 : bool
589 1509 : any_nonignored_attribute_p (tree attrs)
590 : {
591 1581 : for (tree attr = attrs; attr; attr = TREE_CHAIN (attr))
592 1554 : if (!attribute_ignored_p (attr))
593 : return true;
594 :
595 : return false;
596 : }
597 :
598 : /* See whether LIST contains at least one instance of attribute ATTR
599 : (possibly with different arguments). Return the first such attribute
600 : if so, otherwise return null. */
601 :
602 : static tree
603 1652781449 : find_same_attribute (const_tree attr, tree list)
604 : {
605 1652781449 : if (list == NULL_TREE)
606 : return NULL_TREE;
607 853914337 : tree ns = get_attribute_namespace (attr);
608 853914337 : tree name = get_attribute_name (attr);
609 1707828674 : return private_lookup_attribute (ns ? IDENTIFIER_POINTER (ns) : nullptr,
610 853914337 : IDENTIFIER_POINTER (name),
611 853740629 : ns ? IDENTIFIER_LENGTH (ns) : 0,
612 1707828674 : IDENTIFIER_LENGTH (name), list);
613 : }
614 :
615 : /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
616 : which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL,
617 : it should be modified in place; if a TYPE, a copy should be created
618 : unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further
619 : information, in the form of a bitwise OR of flags in enum attribute_flags
620 : from tree.h. Depending on these flags, some attributes may be
621 : returned to be applied at a later stage (for example, to apply
622 : a decl attribute to the declaration rather than to its type). */
623 :
624 : tree
625 1942650924 : decl_attributes (tree *node, tree attributes, int flags,
626 : tree last_decl /* = NULL_TREE */)
627 : {
628 1942650924 : tree returned_attrs = NULL_TREE;
629 :
630 1942650924 : if (TREE_TYPE (*node) == error_mark_node || attributes == error_mark_node)
631 : return NULL_TREE;
632 :
633 1942650584 : if (!attributes_initialized)
634 295627 : init_attributes ();
635 :
636 1942650584 : auto_urlify_attributes sentinel;
637 :
638 : /* If this is a function and the user used #pragma GCC optimize, add the
639 : options to the attribute((optimize(...))) list. */
640 1942650584 : if (TREE_CODE (*node) == FUNCTION_DECL && current_optimize_pragma)
641 : {
642 342862 : tree cur_attr = lookup_attribute ("optimize", attributes);
643 342862 : tree opts = copy_list (current_optimize_pragma);
644 :
645 342862 : if (! cur_attr)
646 342859 : attributes
647 342859 : = tree_cons (get_identifier ("optimize"), opts, attributes);
648 : else
649 3 : TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
650 : }
651 :
652 1942650584 : if (TREE_CODE (*node) == FUNCTION_DECL
653 1177474140 : && (optimization_current_node != optimization_default_node
654 1177417159 : || target_option_current_node != target_option_default_node)
655 1968314989 : && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node))
656 : {
657 25616398 : DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node) = optimization_current_node;
658 : /* Don't set DECL_FUNCTION_SPECIFIC_TARGET for targets that don't
659 : support #pragma GCC target or target attribute. */
660 25616398 : if (target_option_default_node)
661 : {
662 25616398 : tree cur_tree
663 25616398 : = build_target_option_node (&global_options, &global_options_set);
664 25616398 : tree old_tree = DECL_FUNCTION_SPECIFIC_TARGET (*node);
665 25616398 : if (!old_tree)
666 25616398 : old_tree = target_option_default_node;
667 : /* The changes on optimization options can cause the changes in
668 : target options, update it accordingly if it's changed. */
669 25616398 : if (old_tree != cur_tree)
670 25587019 : DECL_FUNCTION_SPECIFIC_TARGET (*node) = cur_tree;
671 : }
672 : }
673 :
674 : /* If this is a function and the user used #pragma GCC target, add the
675 : options to the attribute((target(...))) list. */
676 1942650584 : if (TREE_CODE (*node) == FUNCTION_DECL
677 1177474140 : && current_target_pragma
678 1967711093 : && targetm.target_option.valid_attribute_p (*node,
679 : get_identifier ("target"),
680 : current_target_pragma, 0))
681 : {
682 25060509 : tree cur_attr = lookup_attribute ("target", attributes);
683 25060509 : tree opts = copy_list (current_target_pragma);
684 :
685 25060509 : if (! cur_attr)
686 25060508 : attributes = tree_cons (get_identifier ("target"), opts, attributes);
687 : else
688 1 : TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
689 : }
690 :
691 : /* A "naked" function attribute implies "noinline" and "noclone" for
692 : those targets that support it. */
693 1942650584 : if (TREE_CODE (*node) == FUNCTION_DECL
694 1177474140 : && attributes
695 585687334 : && lookup_attribute ("naked", attributes) != NULL
696 79 : && lookup_attribute_spec (get_identifier ("naked"))
697 1942650663 : && lookup_attribute ("noipa", attributes) == NULL)
698 79 : attributes = tree_cons (get_identifier ("noipa"), NULL, attributes);
699 :
700 : /* A "noipa" function attribute implies "noinline", "noclone" and "no_icf"
701 : for those targets that support it. */
702 1942650584 : if (TREE_CODE (*node) == FUNCTION_DECL
703 1177474140 : && attributes
704 585687334 : && lookup_attribute ("noipa", attributes) != NULL
705 1942673375 : && lookup_attribute_spec (get_identifier ("noipa")))
706 : {
707 22791 : if (lookup_attribute ("noinline", attributes) == NULL)
708 21882 : attributes = tree_cons (get_identifier ("noinline"), NULL, attributes);
709 :
710 22791 : if (lookup_attribute ("noclone", attributes) == NULL)
711 22451 : attributes = tree_cons (get_identifier ("noclone"), NULL, attributes);
712 :
713 22791 : if (lookup_attribute ("no_icf", attributes) == NULL)
714 22781 : attributes = tree_cons (get_identifier ("no_icf"), NULL, attributes);
715 : }
716 :
717 1942650584 : targetm.insert_attributes (*node, &attributes);
718 :
719 : /* Note that attributes on the same declaration are not necessarily
720 : in the same order as in the source. */
721 3593571921 : for (tree attr = attributes; attr; attr = TREE_CHAIN (attr))
722 : {
723 1650921338 : tree ns = get_attribute_namespace (attr);
724 1650921338 : tree name = get_attribute_name (attr);
725 1650921338 : tree args = TREE_VALUE (attr);
726 1650921338 : tree *anode = node;
727 1650921338 : const struct attribute_spec *spec
728 1650921338 : = lookup_scoped_attribute_spec (ns, name);
729 1650921338 : qualifier_set fn_ptr_quals {};
730 1650921338 : tree fn_ptr_tmp = NULL_TREE;
731 1650921338 : const bool cxx11_attr_p = cxx11_attribute_p (attr);
732 :
733 1650921338 : if (spec == NULL)
734 : {
735 3208005 : if (!(flags & (int) ATTR_FLAG_BUILT_IN)
736 3208005 : && !attr_namespace_ignored_p (ns))
737 : {
738 583 : if (ns == NULL_TREE || !cxx11_attr_p)
739 206 : warning (OPT_Wattributes, "%qE attribute directive ignored",
740 : name);
741 186 : else if ((flag_openmp || flag_openmp_simd)
742 191 : && is_attribute_p ("omp", ns)
743 191 : && is_attribute_p ("directive", name)
744 568 : && (VAR_P (*node)
745 20 : || TREE_CODE (*node) == FUNCTION_DECL))
746 3228300 : continue;
747 : else
748 194 : warning (OPT_Wattributes,
749 : "%<%E::%E%> scoped attribute directive ignored",
750 : ns, name);
751 : }
752 3207821 : continue;
753 : }
754 : else
755 : {
756 1647713333 : int nargs = list_length (args);
757 1647713333 : if (nargs < spec->min_length
758 1647713299 : || (spec->max_length >= 0
759 1570052836 : && nargs > spec->max_length))
760 : {
761 88 : auto_diagnostic_group d;
762 88 : error ("wrong number of arguments specified for %qE attribute",
763 : name);
764 88 : if (spec->max_length < 0)
765 0 : inform (input_location, "expected %i or more, found %i",
766 0 : spec->min_length, nargs);
767 88 : else if (spec->min_length == spec->max_length)
768 45 : inform (input_location, "expected %i, found %i",
769 : spec->min_length, nargs);
770 : else
771 43 : inform (input_location, "expected between %i and %i, found %i",
772 : spec->min_length, spec->max_length, nargs);
773 88 : continue;
774 88 : }
775 : }
776 1647713245 : gcc_assert (is_attribute_p (spec->name, name));
777 :
778 1647713245 : if (spec->decl_required && !DECL_P (*anode))
779 : {
780 19047 : if (flags & ((int) ATTR_FLAG_DECL_NEXT
781 : | (int) ATTR_FLAG_FUNCTION_NEXT
782 : | (int) ATTR_FLAG_ARRAY_NEXT))
783 : {
784 : /* Pass on this attribute to be tried again. */
785 18809 : tree attr = tree_cons (name, args, NULL_TREE);
786 18809 : returned_attrs = chainon (returned_attrs, attr);
787 18809 : continue;
788 18809 : }
789 : else
790 : {
791 238 : warning (OPT_Wattributes, "%qE attribute does not apply to types",
792 : name);
793 238 : continue;
794 : }
795 : }
796 :
797 : /* If we require a type, but were passed a decl, set up to make a
798 : new type and update the one in the decl. ATTR_FLAG_TYPE_IN_PLACE
799 : would have applied if we'd been passed a type, but we cannot modify
800 : the decl's type in place here. */
801 1647694198 : if (spec->type_required && DECL_P (*anode))
802 : {
803 248556695 : anode = &TREE_TYPE (*anode);
804 248556695 : flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
805 : }
806 :
807 1647694198 : if (spec->function_type_required
808 247519031 : && !FUNC_OR_METHOD_TYPE_P (*anode))
809 : {
810 833 : if (TREE_CODE (*anode) == POINTER_TYPE
811 833 : && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (*anode)))
812 : {
813 : /* OK, this is a bit convoluted. We can't just make a copy
814 : of the pointer type and modify its TREE_TYPE, because if
815 : we change the attributes of the target type the pointer
816 : type needs to have a different TYPE_MAIN_VARIANT. So we
817 : pull out the target type now, frob it as appropriate, and
818 : rebuild the pointer type later.
819 :
820 : This would all be simpler if attributes were part of the
821 : declarator, grumble grumble. */
822 298 : fn_ptr_tmp = TREE_TYPE (*anode);
823 298 : fn_ptr_quals = TYPE_QUALS (*anode);
824 298 : anode = &fn_ptr_tmp;
825 298 : flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
826 : }
827 535 : else if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
828 : {
829 : /* Pass on this attribute to be tried again. */
830 461 : tree attr = tree_cons (name, args, NULL_TREE);
831 461 : returned_attrs = chainon (returned_attrs, attr);
832 461 : continue;
833 461 : }
834 :
835 446 : if (TREE_CODE (*anode) != FUNCTION_TYPE
836 372 : && TREE_CODE (*anode) != METHOD_TYPE)
837 : {
838 74 : warning (OPT_Wattributes,
839 : "%qE attribute only applies to function types",
840 : name);
841 74 : continue;
842 : }
843 : }
844 :
845 1647693702 : if (TYPE_P (*anode)
846 250279830 : && (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
847 1648233141 : && COMPLETE_TYPE_P (*anode))
848 : {
849 39 : warning (OPT_Wattributes, "type attributes ignored after type is already defined");
850 39 : continue;
851 : }
852 :
853 1647693624 : bool no_add_attrs = false;
854 :
855 : /* Check for exclusions with other attributes on the current
856 : declaration as well as the last declaration of the same
857 : symbol already processed (if one exists). Detect and
858 : reject incompatible attributes. */
859 1647693624 : bool built_in = flags & ATTR_FLAG_BUILT_IN;
860 1647693624 : if (spec->exclude
861 355696801 : && (flag_checking || !built_in)
862 2003370834 : && !error_operand_p (last_decl))
863 : {
864 : /* Always check attributes on user-defined functions.
865 : Check them on built-ins only when -fchecking is set.
866 : Ignore __builtin_unreachable -- it's both const and
867 : noreturn. */
868 :
869 355677209 : if (!built_in
870 239053829 : || !DECL_P (*anode)
871 234109983 : || DECL_BUILT_IN_CLASS (*anode) != BUILT_IN_NORMAL
872 589787192 : || (DECL_FUNCTION_CODE (*anode) != BUILT_IN_UNREACHABLE
873 233404952 : && DECL_FUNCTION_CODE (*anode) != BUILT_IN_UNREACHABLE_TRAP
874 232699936 : && (DECL_FUNCTION_CODE (*anode)
875 : != BUILT_IN_UBSAN_HANDLE_BUILTIN_UNREACHABLE)))
876 : {
877 354225123 : bool no_add = diag_attr_exclusions (last_decl, *anode, name, spec);
878 354225123 : if (!no_add && anode != node)
879 5407261 : no_add = diag_attr_exclusions (last_decl, *node, name, spec);
880 354225123 : no_add_attrs |= no_add;
881 : }
882 : }
883 :
884 1647694211 : if (no_add_attrs
885 : /* Don't add attributes registered just for -Wno-attributes=foo::bar
886 : purposes. */
887 1647693624 : || attribute_ignored_p (attr))
888 587 : continue;
889 :
890 1647693037 : if (spec->handler != NULL)
891 : {
892 1647430787 : int cxx11_flag = (cxx11_attr_p ? ATTR_FLAG_CXX11 : 0);
893 :
894 : /* Pass in an array of the current declaration followed
895 : by the last pushed/merged declaration if one exists.
896 : For calls that modify the type attributes of a DECL
897 : and for which *ANODE is *NODE's type, also pass in
898 : the DECL as the third element to use in diagnostics.
899 : If the handler changes CUR_AND_LAST_DECL[0] replace
900 : *ANODE with its value. */
901 1647430787 : tree cur_and_last_decl[3] = { *anode, last_decl };
902 1647430787 : if (anode != node && DECL_P (*node))
903 248304460 : cur_and_last_decl[2] = *node;
904 :
905 1647430787 : tree ret = (spec->handler) (cur_and_last_decl, name, args,
906 : flags|cxx11_flag, &no_add_attrs);
907 :
908 : /* Fix up typedefs clobbered by attribute handlers. */
909 1647430787 : if (TREE_CODE (*node) == TYPE_DECL
910 854203 : && anode == &TREE_TYPE (*node)
911 577271 : && DECL_ORIGINAL_TYPE (*node)
912 2277 : && TYPE_NAME (*anode) == *node
913 1647430791 : && TYPE_NAME (cur_and_last_decl[0]) != *node)
914 : {
915 4 : tree t = cur_and_last_decl[0];
916 4 : DECL_ORIGINAL_TYPE (*node) = t;
917 4 : tree tt = build_variant_type_copy (t);
918 4 : cur_and_last_decl[0] = tt;
919 4 : TREE_TYPE (*node) = tt;
920 4 : TYPE_NAME (tt) = *node;
921 : }
922 :
923 1647430787 : if (*anode != cur_and_last_decl[0])
924 : {
925 : /* Even if !spec->function_type_required, allow the attribute
926 : handler to request the attribute to be applied to the function
927 : type, rather than to the function pointer type, by setting
928 : cur_and_last_decl[0] to the function type. */
929 1745982 : if (!fn_ptr_tmp
930 1745964 : && POINTER_TYPE_P (*anode)
931 10800 : && TREE_TYPE (*anode) == cur_and_last_decl[0]
932 1746116 : && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (*anode)))
933 : {
934 134 : fn_ptr_tmp = TREE_TYPE (*anode);
935 134 : fn_ptr_quals = TYPE_QUALS (*anode);
936 134 : anode = &fn_ptr_tmp;
937 : }
938 1745982 : *anode = cur_and_last_decl[0];
939 : }
940 :
941 1647430787 : if (ret == error_mark_node)
942 : {
943 302 : warning (OPT_Wattributes, "%qE attribute ignored", name);
944 302 : no_add_attrs = true;
945 : }
946 : else
947 1647430485 : returned_attrs = chainon (ret, returned_attrs);
948 : }
949 :
950 : /* Layout the decl in case anything changed. */
951 1647693037 : if (spec->type_required && DECL_P (*node)
952 : && (VAR_P (*node)
953 : || TREE_CODE (*node) == PARM_DECL
954 : || TREE_CODE (*node) == RESULT_DECL))
955 3457 : relayout_decl (*node);
956 :
957 1647693037 : if (!no_add_attrs)
958 : {
959 1643897568 : tree old_attrs;
960 1643897568 : tree a;
961 :
962 1643897568 : if (DECL_P (*anode))
963 1396930174 : old_attrs = DECL_ATTRIBUTES (*anode);
964 : else
965 246967394 : old_attrs = TYPE_ATTRIBUTES (*anode);
966 :
967 1643897568 : for (a = find_same_attribute (attr, old_attrs);
968 1650958708 : a != NULL_TREE;
969 7061140 : a = find_same_attribute (attr, TREE_CHAIN (a)))
970 13133974 : if (attribute_value_equal (a, attr))
971 : break;
972 :
973 1643897568 : if (a == NULL_TREE)
974 : {
975 : /* This attribute isn't already in the list. */
976 1637824734 : tree r;
977 : /* Preserve the C++11 form. */
978 1637824734 : if (cxx11_attr_p)
979 19005157 : r = tree_cons (build_tree_list (ns, name), args, old_attrs);
980 : else
981 1618819577 : r = tree_cons (name, args, old_attrs);
982 :
983 1637824734 : if (DECL_P (*anode))
984 1390857660 : DECL_ATTRIBUTES (*anode) = r;
985 246967074 : else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
986 : {
987 256263 : TYPE_ATTRIBUTES (*anode) = r;
988 : /* If this is the main variant, also push the attributes
989 : out to the other variants. */
990 256263 : if (*anode == TYPE_MAIN_VARIANT (*anode))
991 : {
992 630007 : for (tree variant = *anode; variant;
993 373744 : variant = TYPE_NEXT_VARIANT (variant))
994 : {
995 373744 : if (TYPE_ATTRIBUTES (variant) == old_attrs)
996 234962 : TYPE_ATTRIBUTES (variant)
997 117481 : = TYPE_ATTRIBUTES (*anode);
998 256263 : else if (!find_same_attribute
999 256263 : (attr, TYPE_ATTRIBUTES (variant)))
1000 0 : TYPE_ATTRIBUTES (variant) = tree_cons
1001 0 : (name, args, TYPE_ATTRIBUTES (variant));
1002 : }
1003 : }
1004 : }
1005 : else
1006 246710811 : *anode = build_type_attribute_variant (*anode, r);
1007 : }
1008 : }
1009 :
1010 1647693037 : if (fn_ptr_tmp)
1011 : {
1012 : /* Rebuild the function pointer type and put it in the
1013 : appropriate place. */
1014 432 : fn_ptr_tmp = build_pointer_type (fn_ptr_tmp);
1015 432 : if (fn_ptr_quals)
1016 22 : fn_ptr_tmp = build_qualified_type (fn_ptr_tmp, fn_ptr_quals);
1017 432 : if (DECL_P (*node))
1018 413 : TREE_TYPE (*node) = fn_ptr_tmp;
1019 : else
1020 : {
1021 19 : gcc_assert (TREE_CODE (*node) == POINTER_TYPE);
1022 19 : *node = fn_ptr_tmp;
1023 : }
1024 : }
1025 : }
1026 :
1027 1942650583 : return returned_attrs;
1028 1942650583 : }
1029 :
1030 : /* Return TRUE iff ATTR has been parsed by the front-end as a C++-11
1031 : attribute.
1032 :
1033 : When G++ parses a C++11 attribute, it is represented as
1034 : a TREE_LIST which TREE_PURPOSE is itself a TREE_LIST. TREE_PURPOSE
1035 : (TREE_PURPOSE (ATTR)) is the namespace of the attribute, and the
1036 : TREE_VALUE (TREE_PURPOSE (ATTR)) is its non-qualified name. Please
1037 : use get_attribute_namespace and get_attribute_name to retrieve the
1038 : namespace and name of the attribute, as these accessors work with
1039 : GNU attributes as well. */
1040 :
1041 : bool
1042 35526071399 : cxx11_attribute_p (const_tree attr)
1043 : {
1044 35526071399 : if (attr == NULL_TREE
1045 35522645141 : || TREE_CODE (attr) != TREE_LIST)
1046 : return false;
1047 :
1048 35522645091 : return (TREE_CODE (TREE_PURPOSE (attr)) == TREE_LIST);
1049 : }
1050 :
1051 : /* Return the name of the attribute ATTR. This accessor works on GNU
1052 : and C++11 (scoped) attributes.
1053 :
1054 : Please read the comments of cxx11_attribute_p to understand the
1055 : format of attributes. */
1056 :
1057 : tree
1058 29650729312 : get_attribute_name (const_tree attr)
1059 : {
1060 29650729312 : if (cxx11_attribute_p (attr))
1061 1431659649 : return TREE_VALUE (TREE_PURPOSE (attr));
1062 28219069663 : return TREE_PURPOSE (attr);
1063 : }
1064 :
1065 : /* Subroutine of set_method_tm_attributes. Apply TM attribute ATTR
1066 : to the method FNDECL. */
1067 :
1068 : void
1069 3576 : apply_tm_attr (tree fndecl, tree attr)
1070 : {
1071 3576 : decl_attributes (&TREE_TYPE (fndecl), tree_cons (attr, NULL, NULL), 0);
1072 3576 : }
1073 :
1074 : /* Makes a function attribute of the form NAME(ARG_NAME) and chains
1075 : it to CHAIN. */
1076 :
1077 : tree
1078 459 : make_attribute (string_slice name, string_slice arg_name, tree chain)
1079 : {
1080 459 : tree attr_name = get_identifier_with_length (name.begin (), name.size ());
1081 459 : tree attr_arg_name = build_string (arg_name.size (), arg_name.begin ());
1082 459 : tree attr_args = tree_cons (NULL_TREE, attr_arg_name, NULL_TREE);
1083 459 : tree attr = tree_cons (attr_name, attr_args, chain);
1084 459 : return attr;
1085 : }
1086 :
1087 : /* Default implementation of TARGET_OPTION_FUNCTIONS_B_RESOLVABLE_FROM_A.
1088 : Used to check very basically if DECL_B is callable from DECL_A.
1089 : For now this checks if the version strings are the same. */
1090 :
1091 : bool
1092 397 : functions_b_resolvable_from_a (tree decl_a, tree decl_b,
1093 : tree base ATTRIBUTE_UNUSED)
1094 : {
1095 397 : const char *attr_name = TARGET_HAS_FMV_TARGET_ATTRIBUTE
1096 : ? "target"
1097 : : "target_version";
1098 :
1099 397 : tree attr_a = lookup_attribute (attr_name, DECL_ATTRIBUTES (decl_a));
1100 397 : tree attr_b = lookup_attribute (attr_name, DECL_ATTRIBUTES (decl_b));
1101 :
1102 397 : gcc_assert (attr_b);
1103 397 : if (!attr_a)
1104 : return false;
1105 :
1106 19 : return attribute_value_equal (attr_a, attr_b);
1107 : }
1108 :
1109 : /* Comparator function to be used in qsort routine to sort attribute
1110 : specification strings to "target". */
1111 :
1112 : static int
1113 7788 : attr_strcmp (const void *v1, const void *v2)
1114 : {
1115 7788 : const char *c1 = *(char *const*)v1;
1116 7788 : const char *c2 = *(char *const*)v2;
1117 7788 : return strcmp (c1, c2);
1118 : }
1119 :
1120 : /* ARGLIST is the argument to target attribute. This function tokenizes
1121 : the TARGET_CLONES_ATTR_SEPARATOR separated arguments, sorts them and
1122 : returns a string which is a unique identifier for the
1123 : TARGET_CLONES_ATTR_SEPARATOR separated arguments. It also replaces
1124 : non-identifier characters "=,-" with "_". */
1125 :
1126 : char *
1127 38135 : sorted_attr_string (tree arglist)
1128 : {
1129 38135 : tree arg;
1130 38135 : size_t str_len_sum = 0;
1131 38135 : char **args = NULL;
1132 38135 : char *attr_str, *ret_str;
1133 38135 : char *attr = NULL;
1134 38135 : unsigned int argnum = 1;
1135 38135 : unsigned int i;
1136 38135 : static const char separator_str[] = { TARGET_CLONES_ATTR_SEPARATOR, 0 };
1137 :
1138 76288 : for (arg = arglist; arg; arg = TREE_CHAIN (arg))
1139 : {
1140 38153 : const char *str = TREE_STRING_POINTER (TREE_VALUE (arg));
1141 38153 : size_t len = strlen (str);
1142 38153 : str_len_sum += len + 1;
1143 38153 : if (arg != arglist)
1144 18 : argnum++;
1145 371589 : for (i = 0; i < strlen (str); i++)
1146 333436 : if (str[i] == TARGET_CLONES_ATTR_SEPARATOR)
1147 1929 : argnum++;
1148 : }
1149 :
1150 38135 : attr_str = XNEWVEC (char, str_len_sum);
1151 38135 : str_len_sum = 0;
1152 114423 : for (arg = arglist; arg; arg = TREE_CHAIN (arg))
1153 : {
1154 38153 : const char *str = TREE_STRING_POINTER (TREE_VALUE (arg));
1155 38153 : size_t len = strlen (str);
1156 38153 : memcpy (attr_str + str_len_sum, str, len);
1157 76306 : attr_str[str_len_sum + len]
1158 38153 : = TREE_CHAIN (arg) ? TARGET_CLONES_ATTR_SEPARATOR : '\0';
1159 38153 : str_len_sum += len + 1;
1160 : }
1161 :
1162 : /* Replace "=,-" with "_". */
1163 371589 : for (i = 0; i < strlen (attr_str); i++)
1164 333454 : if (attr_str[i] == '=' || attr_str[i]== '-')
1165 19436 : attr_str[i] = '_';
1166 :
1167 38135 : if (argnum == 1)
1168 : return attr_str;
1169 :
1170 1947 : args = XNEWVEC (char *, argnum);
1171 :
1172 1947 : i = 0;
1173 1947 : attr = strtok (attr_str, separator_str);
1174 7788 : while (attr != NULL)
1175 : {
1176 3894 : args[i] = attr;
1177 3894 : i++;
1178 3894 : attr = strtok (NULL, separator_str);
1179 : }
1180 :
1181 1947 : qsort (args, argnum, sizeof (char *), attr_strcmp);
1182 :
1183 1947 : ret_str = XNEWVEC (char, str_len_sum);
1184 1947 : str_len_sum = 0;
1185 7788 : for (i = 0; i < argnum; i++)
1186 : {
1187 3894 : size_t len = strlen (args[i]);
1188 3894 : memcpy (ret_str + str_len_sum, args[i], len);
1189 3894 : ret_str[str_len_sum + len] = i < argnum - 1 ? '_' : '\0';
1190 3894 : str_len_sum += len + 1;
1191 : }
1192 :
1193 1947 : XDELETEVEC (args);
1194 1947 : XDELETEVEC (attr_str);
1195 1947 : return ret_str;
1196 : }
1197 :
1198 : /* Make a dispatcher declaration for the multi-versioned function DECL.
1199 : Calls to DECL function will be replaced with calls to the dispatcher
1200 : by the front-end. Return the decl created. */
1201 :
1202 : tree
1203 207 : make_dispatcher_decl (const tree decl)
1204 : {
1205 207 : tree fn_type = TREE_TYPE (decl);
1206 207 : tree func_type = build_function_type (TREE_TYPE (fn_type),
1207 207 : TYPE_ARG_TYPES (fn_type));
1208 207 : tree func_decl = build_fn_decl (IDENTIFIER_POINTER (DECL_NAME (decl)),
1209 : func_type);
1210 :
1211 207 : TREE_USED (func_decl) = 1;
1212 207 : DECL_CONTEXT (func_decl) = NULL_TREE;
1213 207 : DECL_INITIAL (func_decl) = error_mark_node;
1214 207 : DECL_ARTIFICIAL (func_decl) = 1;
1215 : /* Mark this func as external, the resolver will flip it again if
1216 : it gets generated. */
1217 207 : DECL_EXTERNAL (func_decl) = 1;
1218 : /* This will be of type IFUNCs have to be externally visible. */
1219 207 : TREE_PUBLIC (func_decl) = 1;
1220 207 : TREE_NOTHROW (func_decl) = TREE_NOTHROW (decl);
1221 :
1222 : /* Set the decl name to avoid graph_node re-mangling it. */
1223 207 : SET_DECL_ASSEMBLER_NAME (func_decl, DECL_ASSEMBLER_NAME (decl));
1224 :
1225 207 : cgraph_node *node = cgraph_node::get (decl);
1226 207 : gcc_assert (node);
1227 207 : cgraph_function_version_info *node_v = node->function_version ();
1228 207 : gcc_assert (node_v);
1229 :
1230 : /* Set flags on the cgraph_node for the new decl. */
1231 207 : cgraph_node *func_node = cgraph_node::get_create (func_decl);
1232 207 : func_node->dispatcher_function = true;
1233 : /* For targets with TARGET_HAS_FMV_TARGET_ATTRIBUTE, the resolver is created
1234 : unconditionally if any versioned nodes are present.
1235 : For !TARGET_HAS_FMV_TARGET_ATTRIBUTE, the dispatcher is only defined when
1236 : the default node is defined. */
1237 207 : func_node->definition = node->definition || TARGET_HAS_FMV_TARGET_ATTRIBUTE;
1238 :
1239 207 : cgraph_function_version_info *func_v
1240 207 : = func_node->insert_new_function_version ();
1241 207 : func_v->next = node_v;
1242 207 : func_v->assembler_name = node_v->assembler_name;
1243 :
1244 : /* If the default node is from a target_clone, mark the dispatcher as from
1245 : target_clone. */
1246 207 : func_node->is_target_clone = node->is_target_clone;
1247 :
1248 : /* Get the assembler name by mangling with the base assembler name. */
1249 207 : tree id = targetm.mangle_decl_assembler_name
1250 207 : (func_decl, func_v->assembler_name);
1251 207 : symtab->change_decl_assembler_name (func_decl, id);
1252 :
1253 207 : return func_decl;
1254 : }
1255 :
1256 : /* Returns true if DECL a multiversioned default.
1257 : With the target attribute semantics, returns true if the function is marked
1258 : as default with the target version.
1259 : With the target_version attribute semantics, returns true if the function
1260 : is either not annotated, annotated as default, or is a target_clone
1261 : containing the default declaration. */
1262 :
1263 : bool
1264 9820 : is_function_default_version (const tree decl)
1265 : {
1266 9820 : tree attr;
1267 9820 : if (TREE_CODE (decl) != FUNCTION_DECL)
1268 : return false;
1269 9820 : if (TARGET_HAS_FMV_TARGET_ATTRIBUTE)
1270 : {
1271 9820 : if (!DECL_FUNCTION_VERSIONED (decl))
1272 : return false;
1273 8738 : attr = lookup_attribute ("target", DECL_ATTRIBUTES (decl));
1274 8738 : gcc_assert (attr);
1275 : }
1276 : else
1277 : {
1278 : if (lookup_attribute ("target_clones", DECL_ATTRIBUTES (decl)))
1279 : {
1280 : int num_defaults = 0;
1281 : get_clone_versions (decl, &num_defaults);
1282 : return num_defaults > 0;
1283 : }
1284 :
1285 : attr = lookup_attribute ("target_version", DECL_ATTRIBUTES (decl));
1286 : if (!attr)
1287 : return true;
1288 : }
1289 8738 : attr = TREE_VALUE (TREE_VALUE (attr));
1290 8738 : return (TREE_CODE (attr) == STRING_CST
1291 8738 : && strcmp (TREE_STRING_POINTER (attr), "default") == 0);
1292 : }
1293 :
1294 : /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
1295 : is ATTRIBUTE. */
1296 :
1297 : tree
1298 53005290 : build_decl_attribute_variant (tree ddecl, tree attribute)
1299 : {
1300 53005290 : DECL_ATTRIBUTES (ddecl) = attribute;
1301 53005290 : return ddecl;
1302 : }
1303 :
1304 : /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
1305 : is ATTRIBUTE and its qualifiers are QUALS.
1306 :
1307 : Record such modified types already made so we don't make duplicates. */
1308 :
1309 : tree
1310 400414040 : build_type_attribute_qual_variant (tree otype, tree attribute,
1311 : qualifier_set quals)
1312 : {
1313 400414040 : tree ttype = otype;
1314 400414040 : if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
1315 : {
1316 258655108 : tree ntype;
1317 :
1318 : /* Building a distinct copy of a tagged type is inappropriate; it
1319 : causes breakage in code that expects there to be a one-to-one
1320 : relationship between a struct and its fields.
1321 : build_duplicate_type is another solution (as used in
1322 : handle_transparent_union_attribute), but that doesn't play well
1323 : with the stronger C++ type identity model. */
1324 258655108 : if (RECORD_OR_UNION_TYPE_P (ttype)
1325 258655105 : || TREE_CODE (ttype) == ENUMERAL_TYPE)
1326 : {
1327 3 : warning (OPT_Wattributes,
1328 : "ignoring attributes applied to %qT after definition",
1329 3 : TYPE_MAIN_VARIANT (ttype));
1330 3 : return build_qualified_type (ttype, quals);
1331 : }
1332 :
1333 258655105 : ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
1334 258655105 : if (lang_hooks.types.copy_lang_qualifiers
1335 258655105 : && otype != TYPE_MAIN_VARIANT (otype))
1336 8905859 : ttype = (lang_hooks.types.copy_lang_qualifiers
1337 8905859 : (ttype, TYPE_MAIN_VARIANT (otype)));
1338 :
1339 258655105 : tree dtype = ntype = build_distinct_type_copy (ttype);
1340 :
1341 258655105 : TYPE_ATTRIBUTES (ntype) = attribute;
1342 : /* If the target-dependent attributes make NTYPE different from
1343 : its canonical type, we will need to use structural equality
1344 : checks for this type.
1345 :
1346 : We shouldn't get here for stripping attributes from a type;
1347 : the no-attribute type might not need structural comparison. But
1348 : we can if was discarded from type_hash_table. */
1349 258655105 : if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
1350 258655105 : || !comp_type_attributes (ntype, ttype))
1351 5104658 : SET_TYPE_STRUCTURAL_EQUALITY (ntype);
1352 :
1353 258655105 : hashval_t hash = type_hash_canon_hash (ntype);
1354 258655105 : ntype = type_hash_canon (hash, ntype);
1355 :
1356 258655105 : if (ntype != dtype)
1357 : /* This variant was already in the hash table, don't mess with
1358 : TYPE_CANONICAL. */;
1359 62196060 : else if (TYPE_CANONICAL (ntype) == ntype)
1360 59856517 : TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
1361 :
1362 258655105 : ttype = build_qualified_type (ntype, quals);
1363 258655105 : if (lang_hooks.types.copy_lang_qualifiers
1364 258655105 : && otype != TYPE_MAIN_VARIANT (otype))
1365 8905859 : ttype = lang_hooks.types.copy_lang_qualifiers (ttype, otype);
1366 : }
1367 141758932 : else if (TYPE_QUALS (ttype) != quals)
1368 897766 : ttype = build_qualified_type (ttype, quals);
1369 :
1370 : return ttype;
1371 : }
1372 :
1373 : /* Compare two identifier nodes representing attributes.
1374 : Return true if they are the same, false otherwise. */
1375 :
1376 : static bool
1377 76113950 : cmp_attrib_identifiers (const_tree attr1, const_tree attr2)
1378 : {
1379 : /* Make sure we're dealing with IDENTIFIER_NODEs. */
1380 76113950 : gcc_checking_assert (TREE_CODE (attr1) == IDENTIFIER_NODE
1381 : && TREE_CODE (attr2) == IDENTIFIER_NODE);
1382 :
1383 : /* Identifiers can be compared directly for equality. */
1384 76113950 : if (attr1 == attr2)
1385 : return true;
1386 :
1387 115526809 : return cmp_attribs (IDENTIFIER_POINTER (attr1), IDENTIFIER_LENGTH (attr1),
1388 39412859 : IDENTIFIER_POINTER (attr2), IDENTIFIER_LENGTH (attr2));
1389 : }
1390 :
1391 : /* Compare two constructor-element-type constants. Return 1 if the lists
1392 : are known to be equal; otherwise return 0. */
1393 :
1394 : bool
1395 26981105 : simple_cst_list_equal (const_tree l1, const_tree l2)
1396 : {
1397 41078242 : while (l1 != NULL_TREE && l2 != NULL_TREE)
1398 : {
1399 29929312 : if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
1400 : return false;
1401 :
1402 14097137 : l1 = TREE_CHAIN (l1);
1403 14097137 : l2 = TREE_CHAIN (l2);
1404 : }
1405 :
1406 11148930 : return l1 == l2;
1407 : }
1408 :
1409 : /* Check if "omp declare simd" attribute arguments, CLAUSES1 and CLAUSES2, are
1410 : the same. */
1411 :
1412 : static bool
1413 0 : omp_declare_simd_clauses_equal (tree clauses1, tree clauses2)
1414 : {
1415 0 : tree cl1, cl2;
1416 0 : for (cl1 = clauses1, cl2 = clauses2;
1417 0 : cl1 && cl2;
1418 0 : cl1 = OMP_CLAUSE_CHAIN (cl1), cl2 = OMP_CLAUSE_CHAIN (cl2))
1419 : {
1420 0 : if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_CODE (cl2))
1421 : return false;
1422 0 : if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_SIMDLEN)
1423 : {
1424 0 : if (simple_cst_equal (OMP_CLAUSE_DECL (cl1),
1425 0 : OMP_CLAUSE_DECL (cl2)) != 1)
1426 : return false;
1427 : }
1428 0 : switch (OMP_CLAUSE_CODE (cl1))
1429 : {
1430 0 : case OMP_CLAUSE_ALIGNED:
1431 0 : if (simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (cl1),
1432 0 : OMP_CLAUSE_ALIGNED_ALIGNMENT (cl2)) != 1)
1433 : return false;
1434 : break;
1435 0 : case OMP_CLAUSE_LINEAR:
1436 0 : if (simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (cl1),
1437 0 : OMP_CLAUSE_LINEAR_STEP (cl2)) != 1)
1438 : return false;
1439 : break;
1440 0 : case OMP_CLAUSE_SIMDLEN:
1441 0 : if (simple_cst_equal (OMP_CLAUSE_SIMDLEN_EXPR (cl1),
1442 0 : OMP_CLAUSE_SIMDLEN_EXPR (cl2)) != 1)
1443 : return false;
1444 0 : if (OMP_CLAUSE_SIMDLEN_TYPE (cl1) != OMP_CLAUSE_SIMDLEN_TYPE (cl2))
1445 : return false;
1446 0 : if ((OMP_CLAUSE_SIMDLEN_DIVISOR (cl1) == NULL_TREE)
1447 0 : != (OMP_CLAUSE_SIMDLEN_DIVISOR (cl2) == NULL_TREE)
1448 0 : || (OMP_CLAUSE_SIMDLEN_DIVISOR (cl1)
1449 0 : && simple_cst_equal (OMP_CLAUSE_SIMDLEN_DIVISOR (cl1),
1450 0 : OMP_CLAUSE_SIMDLEN_DIVISOR (cl2)) != 1))
1451 : return false;
1452 : default:
1453 : break;
1454 : }
1455 : }
1456 : return true;
1457 : }
1458 :
1459 :
1460 : /* Compare two attributes for their value identity. Return true if the
1461 : attribute values are known to be equal; otherwise return false. */
1462 :
1463 : bool
1464 49397445 : attribute_value_equal (const_tree attr1, const_tree attr2)
1465 : {
1466 49397445 : if (TREE_VALUE (attr1) == TREE_VALUE (attr2))
1467 : return true;
1468 :
1469 33568552 : if (TREE_VALUE (attr1) != NULL_TREE
1470 31300917 : && TREE_CODE (TREE_VALUE (attr1)) == TREE_LIST
1471 31300902 : && TREE_VALUE (attr2) != NULL_TREE
1472 63281195 : && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST)
1473 : {
1474 29712643 : if (ATTR_UNIQUE_VALUE_P (TREE_VALUE (attr1))
1475 29712643 : || ATTR_UNIQUE_VALUE_P (TREE_VALUE (attr2)))
1476 : return false;
1477 :
1478 : /* Handle attribute format. */
1479 29711681 : if (is_attribute_p ("format", get_attribute_name (attr1)))
1480 : {
1481 3180290 : attr1 = TREE_VALUE (attr1);
1482 3180290 : attr2 = TREE_VALUE (attr2);
1483 : /* Compare the archetypes (printf/scanf/strftime/...). */
1484 3180290 : if (!cmp_attrib_identifiers (TREE_VALUE (attr1), TREE_VALUE (attr2)))
1485 : return false;
1486 : /* Archetypes are the same. Compare the rest. */
1487 443158 : return (simple_cst_list_equal (TREE_CHAIN (attr1),
1488 886316 : TREE_CHAIN (attr2)) == 1);
1489 : }
1490 53062782 : return (simple_cst_list_equal (TREE_VALUE (attr1),
1491 53062782 : TREE_VALUE (attr2)) == 1);
1492 : }
1493 :
1494 3855909 : if (TREE_VALUE (attr1)
1495 1588274 : && TREE_CODE (TREE_VALUE (attr1)) == OMP_CLAUSE
1496 0 : && TREE_VALUE (attr2)
1497 3855909 : && TREE_CODE (TREE_VALUE (attr2)) == OMP_CLAUSE)
1498 0 : return omp_declare_simd_clauses_equal (TREE_VALUE (attr1),
1499 0 : TREE_VALUE (attr2));
1500 :
1501 3855909 : return (simple_cst_equal (TREE_VALUE (attr1), TREE_VALUE (attr2)) == 1);
1502 : }
1503 :
1504 : /* Return 0 if the attributes for two types are incompatible, 1 if they
1505 : are compatible, and 2 if they are nearly compatible (which causes a
1506 : warning to be generated). */
1507 : int
1508 1166349306 : comp_type_attributes (const_tree type1, const_tree type2)
1509 : {
1510 1166349306 : const_tree a1 = TYPE_ATTRIBUTES (type1);
1511 1166349306 : const_tree a2 = TYPE_ATTRIBUTES (type2);
1512 1166349306 : const_tree a;
1513 :
1514 1166349306 : if (a1 == a2)
1515 : return 1;
1516 578145499 : for (a = a1; a != NULL_TREE; a = TREE_CHAIN (a))
1517 : {
1518 303409355 : const struct attribute_spec *as;
1519 303409355 : const_tree attr;
1520 :
1521 303409355 : as = lookup_attribute_spec (TREE_PURPOSE (a));
1522 303409355 : if (!as || as->affects_type_identity == false)
1523 301850866 : continue;
1524 :
1525 1558489 : attr = find_same_attribute (a, const_cast<tree> (a2));
1526 1558489 : if (!attr || !attribute_value_equal (a, attr))
1527 : break;
1528 : }
1529 276292303 : if (!a)
1530 : {
1531 312949267 : for (a = a2; a != NULL_TREE; a = TREE_CHAIN (a))
1532 : {
1533 38218782 : const struct attribute_spec *as;
1534 :
1535 38218782 : as = lookup_attribute_spec (TREE_PURPOSE (a));
1536 38218782 : if (!as || as->affects_type_identity == false)
1537 38210793 : continue;
1538 :
1539 7989 : if (!find_same_attribute (a, const_cast<tree> (a1)))
1540 : break;
1541 : /* We don't need to compare trees again, as we did this
1542 : already in first loop. */
1543 : }
1544 : /* All types - affecting identity - are equal, so
1545 : there is no need to call target hook for comparison. */
1546 274736144 : if (!a)
1547 : return 1;
1548 : }
1549 1561818 : if (lookup_attribute ("transaction_safe", const_cast<tree> (a)))
1550 : return 0;
1551 1557896 : if ((lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (type1)) != NULL)
1552 1557896 : ^ (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (type2)) != NULL))
1553 : return 0;
1554 1557725 : int strub_ret = strub_comptypes (const_cast<tree> (type1),
1555 : const_cast<tree> (type2));
1556 1557725 : if (strub_ret == 0)
1557 : return strub_ret;
1558 : /* As some type combinations - like default calling-convention - might
1559 : be compatible, we have to call the target hook to get the final result. */
1560 1555279 : int target_ret = targetm.comp_type_attributes (type1, type2);
1561 1555279 : if (target_ret == 0)
1562 : return target_ret;
1563 756301 : if (strub_ret == 2 || target_ret == 2)
1564 : return 2;
1565 754390 : if (strub_ret == 1 && target_ret == 1)
1566 : return 1;
1567 0 : gcc_unreachable ();
1568 : }
1569 :
1570 : /* PREDICATE acts as a function of type:
1571 :
1572 : (const_tree attr, const attribute_spec *as) -> bool
1573 :
1574 : where ATTR is an attribute and AS is its possibly-null specification.
1575 : Return a list of every attribute in attribute list ATTRS for which
1576 : PREDICATE is true. Return ATTRS itself if PREDICATE returns true
1577 : for every attribute. */
1578 :
1579 : template<typename Predicate>
1580 : tree
1581 439679 : remove_attributes_matching (tree attrs, Predicate predicate)
1582 : {
1583 439679 : tree new_attrs = NULL_TREE;
1584 439679 : tree *ptr = &new_attrs;
1585 439679 : const_tree start = attrs;
1586 834213 : for (const_tree attr = attrs; attr; attr = TREE_CHAIN (attr))
1587 : {
1588 394534 : const attribute_spec *as = lookup_attribute_spec (TREE_PURPOSE (attr));
1589 : const_tree end;
1590 394534 : if (!predicate (attr, as))
1591 379820 : end = attr;
1592 14714 : else if (start == attrs)
1593 14714 : continue;
1594 : else
1595 0 : end = TREE_CHAIN (attr);
1596 :
1597 379820 : for (; start != end; start = TREE_CHAIN (start))
1598 : {
1599 0 : *ptr = tree_cons (TREE_PURPOSE (start),
1600 0 : TREE_VALUE (start), NULL_TREE);
1601 0 : TREE_CHAIN (*ptr) = NULL_TREE;
1602 0 : ptr = &TREE_CHAIN (*ptr);
1603 : }
1604 379820 : start = TREE_CHAIN (attr);
1605 : }
1606 439679 : gcc_assert (!start || start == attrs);
1607 439679 : return start ? attrs : new_attrs;
1608 : }
1609 :
1610 : /* If VALUE is true, return the subset of ATTRS that affect type identity,
1611 : otherwise return the subset of ATTRS that don't affect type identity. */
1612 :
1613 : tree
1614 379818 : affects_type_identity_attributes (tree attrs, bool value)
1615 : {
1616 759638 : auto predicate = [value](const_tree, const attribute_spec *as) -> bool
1617 : {
1618 379820 : return bool (as && as->affects_type_identity) == value;
1619 379818 : };
1620 379818 : return remove_attributes_matching (attrs, predicate);
1621 : }
1622 :
1623 : /* Remove attributes that affect type identity from ATTRS unless the
1624 : same attributes occur in OK_ATTRS. */
1625 :
1626 : tree
1627 59861 : restrict_type_identity_attributes_to (tree attrs, tree ok_attrs)
1628 : {
1629 74575 : auto predicate = [ok_attrs](const_tree attr,
1630 : const attribute_spec *as) -> bool
1631 : {
1632 14714 : if (!as || !as->affects_type_identity)
1633 : return true;
1634 :
1635 0 : for (tree ok_attr = lookup_attribute (as->name, ok_attrs);
1636 0 : ok_attr;
1637 0 : ok_attr = lookup_attribute (as->name, TREE_CHAIN (ok_attr)))
1638 0 : if (simple_cst_equal (TREE_VALUE (ok_attr), TREE_VALUE (attr)) == 1)
1639 : return true;
1640 :
1641 : return false;
1642 59861 : };
1643 59861 : return remove_attributes_matching (attrs, predicate);
1644 : }
1645 :
1646 : /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
1647 : is ATTRIBUTE.
1648 :
1649 : Record such modified types already made so we don't make duplicates. */
1650 :
1651 : tree
1652 391866416 : build_type_attribute_variant (tree ttype, tree attribute)
1653 : {
1654 391866416 : return build_type_attribute_qual_variant (ttype, attribute,
1655 391866416 : TYPE_QUALS (ttype));
1656 : }
1657 :
1658 : /* A variant of lookup_attribute() that can be used with an identifier
1659 : as the first argument, and where the identifier can be either
1660 : 'text' or '__text__'.
1661 :
1662 : Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
1663 : return a pointer to the attribute's list element if the attribute
1664 : is part of the list, or NULL_TREE if not found. If the attribute
1665 : appears more than once, this only returns the first occurrence; the
1666 : TREE_CHAIN of the return value should be passed back in if further
1667 : occurrences are wanted. ATTR_IDENTIFIER must be an identifier but
1668 : can be in the form 'text' or '__text__'. */
1669 : static tree
1670 306302996 : lookup_ident_attribute (tree attr_identifier, tree list)
1671 : {
1672 306302996 : gcc_checking_assert (TREE_CODE (attr_identifier) == IDENTIFIER_NODE);
1673 :
1674 342978723 : while (list)
1675 : {
1676 72933660 : gcc_checking_assert (TREE_CODE (get_attribute_name (list))
1677 : == IDENTIFIER_NODE);
1678 :
1679 72933660 : if (cmp_attrib_identifiers (attr_identifier,
1680 72933660 : get_attribute_name (list)))
1681 : /* Found it. */
1682 : break;
1683 36675727 : list = TREE_CHAIN (list);
1684 : }
1685 :
1686 306302996 : return list;
1687 : }
1688 :
1689 : /* Remove any instances of attribute ATTR_NAME in LIST and return the
1690 : modified list. */
1691 :
1692 : tree
1693 121381828 : remove_attribute (const char *attr_name, tree list)
1694 : {
1695 121381828 : tree *p;
1696 121381828 : gcc_checking_assert (attr_name[0] != '_');
1697 :
1698 158057815 : for (p = &list; *p;)
1699 : {
1700 36675987 : tree l = *p;
1701 :
1702 36675987 : tree attr = get_attribute_name (l);
1703 36675987 : if (is_attribute_p (attr_name, attr))
1704 4225 : *p = TREE_CHAIN (l);
1705 : else
1706 36671762 : p = &TREE_CHAIN (l);
1707 : }
1708 :
1709 121381828 : return list;
1710 : }
1711 :
1712 : /* Similarly but also match namespace on the removed attributes.
1713 : ATTR_NS "" stands for NULL or "gnu" namespace. */
1714 :
1715 : tree
1716 484657 : remove_attribute (const char *attr_ns, const char *attr_name, tree list)
1717 : {
1718 484657 : tree *p;
1719 484657 : gcc_checking_assert (attr_name[0] != '_');
1720 484657 : gcc_checking_assert (attr_ns == NULL || attr_ns[0] != '_');
1721 :
1722 498025 : for (p = &list; *p;)
1723 : {
1724 13368 : tree l = *p;
1725 :
1726 13368 : tree attr = get_attribute_name (l);
1727 13368 : if (is_attribute_p (attr_name, attr)
1728 13368 : && is_attribute_namespace_p (attr_ns, l))
1729 : {
1730 12649 : *p = TREE_CHAIN (l);
1731 12649 : continue;
1732 : }
1733 719 : p = &TREE_CHAIN (l);
1734 : }
1735 :
1736 484657 : return list;
1737 : }
1738 :
1739 : /* Return an attribute list that is the union of a1 and a2. */
1740 :
1741 : tree
1742 203556184 : merge_attributes (tree a1, tree a2)
1743 : {
1744 203556184 : tree attributes;
1745 :
1746 : /* Either one unset? Take the set one. */
1747 :
1748 203556184 : if ((attributes = a1) == 0)
1749 : attributes = a2;
1750 :
1751 : /* One that completely contains the other? Take it. */
1752 :
1753 12233297 : else if (a2 != 0 && ! attribute_list_contained (a1, a2))
1754 : {
1755 1635385 : if (attribute_list_contained (a2, a1))
1756 : attributes = a2;
1757 : else
1758 : {
1759 : /* Pick the longest list, and hang on the other list,
1760 : unless both lists contain ATTR_UNIQUE_VALUE_P values.
1761 : In that case a1 list needs to go after the a2 list
1762 : because attributes from a single declaration are stored
1763 : in reverse order of their declarations. */
1764 : bool a1_unique_value_p = false, a2_unique_value_p = false;
1765 : tree aa1 = a1, aa2 = a2;
1766 2823522 : for (; aa1 && aa2; aa1 = TREE_CHAIN (aa1), aa2 = TREE_CHAIN (aa2))
1767 : {
1768 1583317 : if (!a1_unique_value_p
1769 1583295 : && TREE_VALUE (aa1)
1770 772992 : && TREE_CODE (TREE_VALUE (aa1)) == TREE_LIST
1771 2356309 : && ATTR_UNIQUE_VALUE_P (TREE_VALUE (aa1)))
1772 : a1_unique_value_p = true;
1773 1583317 : if (!a2_unique_value_p
1774 1583295 : && TREE_VALUE (aa2)
1775 817287 : && TREE_CODE (TREE_VALUE (aa2)) == TREE_LIST
1776 2400588 : && ATTR_UNIQUE_VALUE_P (TREE_VALUE (aa2)))
1777 : a2_unique_value_p = true;
1778 : }
1779 :
1780 1240205 : if (aa2 && (!a1_unique_value_p || !a2_unique_value_p))
1781 : {
1782 1240205 : attributes = a2;
1783 1240205 : a2 = a1;
1784 : }
1785 :
1786 1240205 : tree a3 = NULL_TREE, *pa = &a3;
1787 2823532 : for (; a2 != 0; a2 = TREE_CHAIN (a2))
1788 : {
1789 1583327 : tree a;
1790 1583327 : for (a = lookup_ident_attribute (get_attribute_name (a2),
1791 : attributes);
1792 2137152 : a != NULL_TREE && !attribute_value_equal (a, a2);
1793 553825 : a = lookup_ident_attribute (get_attribute_name (a2),
1794 553825 : TREE_CHAIN (a)))
1795 : ;
1796 1583327 : if (a == NULL_TREE)
1797 : {
1798 1240827 : a1 = copy_node (a2);
1799 1240827 : *pa = a1;
1800 1240827 : pa = &TREE_CHAIN (a1);
1801 : }
1802 : }
1803 1240205 : if (a3)
1804 : {
1805 1240205 : *pa = attributes;
1806 1240205 : attributes = a3;
1807 : }
1808 : }
1809 : }
1810 203556184 : return attributes;
1811 : }
1812 :
1813 : /* Given types T1 and T2, merge their attributes and return
1814 : the result. */
1815 :
1816 : tree
1817 146181850 : merge_type_attributes (tree t1, tree t2)
1818 : {
1819 146181850 : return merge_attributes (TYPE_ATTRIBUTES (t1),
1820 146181850 : TYPE_ATTRIBUTES (t2));
1821 : }
1822 :
1823 : /* Given decls OLDDECL and NEWDECL, merge their attributes and return
1824 : the result. */
1825 :
1826 : tree
1827 57297478 : merge_decl_attributes (tree olddecl, tree newdecl)
1828 : {
1829 57297478 : return merge_attributes (DECL_ATTRIBUTES (olddecl),
1830 57297478 : DECL_ATTRIBUTES (newdecl));
1831 : }
1832 :
1833 : /* Duplicate all attributes with name NAME in ATTR list to *ATTRS if
1834 : they are missing there. */
1835 :
1836 : void
1837 8113517 : duplicate_one_attribute (tree *attrs, tree attr, const char *name)
1838 : {
1839 8113517 : attr = lookup_attribute (name, attr);
1840 8113517 : if (!attr)
1841 : return;
1842 9074 : tree a = lookup_attribute (name, *attrs);
1843 27222 : while (attr)
1844 : {
1845 : tree a2;
1846 9074 : for (a2 = a; a2; a2 = lookup_attribute (name, TREE_CHAIN (a2)))
1847 0 : if (attribute_value_equal (attr, a2))
1848 : break;
1849 9074 : if (!a2)
1850 : {
1851 9074 : a2 = copy_node (attr);
1852 9074 : TREE_CHAIN (a2) = *attrs;
1853 9074 : *attrs = a2;
1854 : }
1855 9074 : attr = lookup_attribute (name, TREE_CHAIN (attr));
1856 : }
1857 : }
1858 :
1859 : /* Duplicate all attributes from user DECL to the corresponding
1860 : builtin that should be propagated. */
1861 :
1862 : void
1863 8113476 : copy_attributes_to_builtin (tree decl)
1864 : {
1865 8113476 : tree b = builtin_decl_explicit (DECL_FUNCTION_CODE (decl));
1866 8113476 : if (b)
1867 8113476 : duplicate_one_attribute (&DECL_ATTRIBUTES (b),
1868 8113476 : DECL_ATTRIBUTES (decl), "omp declare simd");
1869 8113476 : }
1870 :
1871 : #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
1872 :
1873 : /* Specialization of merge_decl_attributes for various Windows targets.
1874 :
1875 : This handles the following situation:
1876 :
1877 : __declspec (dllimport) int foo;
1878 : int foo;
1879 :
1880 : The second instance of `foo' nullifies the dllimport. */
1881 :
1882 : tree
1883 : merge_dllimport_decl_attributes (tree old, tree new_tree)
1884 : {
1885 : tree a;
1886 : int delete_dllimport_p = 1;
1887 :
1888 : /* What we need to do here is remove from `old' dllimport if it doesn't
1889 : appear in `new'. dllimport behaves like extern: if a declaration is
1890 : marked dllimport and a definition appears later, then the object
1891 : is not dllimport'd. We also remove a `new' dllimport if the old list
1892 : contains dllexport: dllexport always overrides dllimport, regardless
1893 : of the order of declaration. */
1894 : if (!VAR_OR_FUNCTION_DECL_P (new_tree))
1895 : delete_dllimport_p = 0;
1896 : else if (DECL_DLLIMPORT_P (new_tree)
1897 : && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
1898 : {
1899 : DECL_DLLIMPORT_P (new_tree) = 0;
1900 : warning (OPT_Wattributes, "%q+D already declared with dllexport "
1901 : "attribute: dllimport ignored", new_tree);
1902 : }
1903 : else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
1904 : {
1905 : /* Warn about overriding a symbol that has already been used, e.g.:
1906 : extern int __attribute__ ((dllimport)) foo;
1907 : int* bar () {return &foo;}
1908 : int foo;
1909 : */
1910 : if (TREE_USED (old))
1911 : {
1912 : warning (0, "%q+D redeclared without dllimport attribute "
1913 : "after being referenced with dll linkage", new_tree);
1914 : /* If we have used a variable's address with dllimport linkage,
1915 : keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
1916 : decl may already have had TREE_CONSTANT computed.
1917 : We still remove the attribute so that assembler code refers
1918 : to '&foo rather than '_imp__foo'. */
1919 : if (VAR_P (old) && TREE_ADDRESSABLE (old))
1920 : DECL_DLLIMPORT_P (new_tree) = 1;
1921 : }
1922 :
1923 : /* Let an inline definition silently override the external reference,
1924 : but otherwise warn about attribute inconsistency. */
1925 : else if (VAR_P (new_tree) || !DECL_DECLARED_INLINE_P (new_tree))
1926 : warning (OPT_Wattributes, "%q+D redeclared without dllimport "
1927 : "attribute: previous dllimport ignored", new_tree);
1928 : }
1929 : else
1930 : delete_dllimport_p = 0;
1931 :
1932 : a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
1933 :
1934 : if (delete_dllimport_p)
1935 : a = remove_attribute ("dllimport", a);
1936 :
1937 : return a;
1938 : }
1939 :
1940 : /* Handle a "dllimport" or "dllexport" attribute; arguments as in
1941 : struct attribute_spec.handler. */
1942 :
1943 : tree
1944 : handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
1945 : bool *no_add_attrs)
1946 : {
1947 : tree node = *pnode;
1948 : bool is_dllimport;
1949 :
1950 : /* These attributes may apply to structure and union types being created,
1951 : but otherwise should pass to the declaration involved. */
1952 : if (!DECL_P (node))
1953 : {
1954 : if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
1955 : | (int) ATTR_FLAG_ARRAY_NEXT))
1956 : {
1957 : *no_add_attrs = true;
1958 : return tree_cons (name, args, NULL_TREE);
1959 : }
1960 : if (TREE_CODE (node) == RECORD_TYPE
1961 : || TREE_CODE (node) == UNION_TYPE)
1962 : {
1963 : node = TYPE_NAME (node);
1964 : if (!node)
1965 : return NULL_TREE;
1966 : }
1967 : else
1968 : {
1969 : warning (OPT_Wattributes, "%qE attribute ignored",
1970 : name);
1971 : *no_add_attrs = true;
1972 : return NULL_TREE;
1973 : }
1974 : }
1975 :
1976 : if (!VAR_OR_FUNCTION_DECL_P (node) && TREE_CODE (node) != TYPE_DECL)
1977 : {
1978 : *no_add_attrs = true;
1979 : warning (OPT_Wattributes, "%qE attribute ignored",
1980 : name);
1981 : return NULL_TREE;
1982 : }
1983 :
1984 : if (TREE_CODE (node) == TYPE_DECL
1985 : && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
1986 : && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
1987 : {
1988 : *no_add_attrs = true;
1989 : warning (OPT_Wattributes, "%qE attribute ignored",
1990 : name);
1991 : return NULL_TREE;
1992 : }
1993 :
1994 : is_dllimport = is_attribute_p ("dllimport", name);
1995 :
1996 : /* Report error on dllimport ambiguities seen now before they cause
1997 : any damage. */
1998 : if (is_dllimport)
1999 : {
2000 : /* Honor any target-specific overrides. */
2001 : if (!targetm.valid_dllimport_attribute_p (node))
2002 : *no_add_attrs = true;
2003 :
2004 : else if (TREE_CODE (node) == FUNCTION_DECL
2005 : && DECL_DECLARED_INLINE_P (node))
2006 : {
2007 : warning (OPT_Wattributes, "inline function %q+D declared as "
2008 : "dllimport: attribute ignored", node);
2009 : *no_add_attrs = true;
2010 : }
2011 : /* Like MS, treat definition of dllimported variables and
2012 : non-inlined functions on declaration as syntax errors. */
2013 : else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
2014 : {
2015 : error ("function %q+D definition is marked dllimport", node);
2016 : *no_add_attrs = true;
2017 : }
2018 :
2019 : else if (VAR_P (node))
2020 : {
2021 : if (DECL_INITIAL (node))
2022 : {
2023 : error ("variable %q+D definition is marked dllimport", node);
2024 : *no_add_attrs = true;
2025 : }
2026 : #if TARGET_WIN32_TLS
2027 : else if (DECL_THREAD_LOCAL_P (node))
2028 : {
2029 : error ("thread-local variable %q+D declared as dllimport", node);
2030 : *no_add_attrs = true;
2031 : }
2032 : #endif
2033 :
2034 : /* `extern' needn't be specified with dllimport.
2035 : Specify `extern' now and hope for the best. Sigh. */
2036 : DECL_EXTERNAL (node) = 1;
2037 : /* Also, implicitly give dllimport'd variables declared within
2038 : a function global scope, unless declared static. */
2039 : if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
2040 : TREE_PUBLIC (node) = 1;
2041 : /* Clear TREE_STATIC because DECL_EXTERNAL is set, unless
2042 : it is a C++ static data member. */
2043 : if (DECL_CONTEXT (node) == NULL_TREE
2044 : || !RECORD_OR_UNION_TYPE_P (DECL_CONTEXT (node)))
2045 : TREE_STATIC (node) = 0;
2046 : }
2047 :
2048 : if (*no_add_attrs == false)
2049 : DECL_DLLIMPORT_P (node) = 1;
2050 : }
2051 : else if (TREE_CODE (node) == FUNCTION_DECL
2052 : && DECL_DECLARED_INLINE_P (node)
2053 : && flag_keep_inline_dllexport)
2054 : /* An exported function, even if inline, must be emitted. */
2055 : DECL_EXTERNAL (node) = 0;
2056 : #if TARGET_WIN32_TLS
2057 : else if (VAR_P (node) && DECL_THREAD_LOCAL_P (node))
2058 : {
2059 : error ("thread-local variable %q+D declared as dllexport", node);
2060 : *no_add_attrs = true;
2061 : }
2062 : #endif
2063 :
2064 : /* Report error if symbol is not accessible at global scope. */
2065 : if (!TREE_PUBLIC (node) && VAR_OR_FUNCTION_DECL_P (node))
2066 : {
2067 : error ("external linkage required for symbol %q+D because of "
2068 : "%qE attribute", node, name);
2069 : *no_add_attrs = true;
2070 : }
2071 :
2072 : /* A dllexport'd entity must have default visibility so that other
2073 : program units (shared libraries or the main executable) can see
2074 : it. A dllimport'd entity must have default visibility so that
2075 : the linker knows that undefined references within this program
2076 : unit can be resolved by the dynamic linker. */
2077 : if (!*no_add_attrs)
2078 : {
2079 : if (DECL_VISIBILITY_SPECIFIED (node)
2080 : && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
2081 : error ("%qE implies default visibility, but %qD has already "
2082 : "been declared with a different visibility",
2083 : name, node);
2084 : DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
2085 : DECL_VISIBILITY_SPECIFIED (node) = 1;
2086 : }
2087 :
2088 : return NULL_TREE;
2089 : }
2090 :
2091 : #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
2092 :
2093 : /* Given two lists of attributes, return true if list l2 is
2094 : equivalent to l1. */
2095 :
2096 : int
2097 5698265165 : attribute_list_equal (const_tree l1, const_tree l2)
2098 : {
2099 5698265165 : if (l1 == l2)
2100 : return 1;
2101 :
2102 457077160 : return attribute_list_contained (l1, l2)
2103 723005806 : && attribute_list_contained (l2, l1);
2104 : }
2105 :
2106 : /* Given two lists of attributes, return true if list L2 is
2107 : completely contained within L1. */
2108 : /* ??? This would be faster if attribute names were stored in a canonicalized
2109 : form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
2110 : must be used to show these elements are equivalent (which they are). */
2111 : /* ??? It's not clear that attributes with arguments will always be handled
2112 : correctly. */
2113 :
2114 : int
2115 656775291 : attribute_list_contained (const_tree l1, const_tree l2)
2116 : {
2117 656775291 : const_tree t1, t2;
2118 :
2119 : /* First check the obvious, maybe the lists are identical. */
2120 656775291 : if (l1 == l2)
2121 : return 1;
2122 :
2123 : /* Maybe the lists are similar. */
2124 : for (t1 = l1, t2 = l2;
2125 1060036366 : t1 != 0 && t2 != 0
2126 453893531 : && get_attribute_name (t1) == get_attribute_name (t2)
2127 1487951454 : && TREE_VALUE (t1) == TREE_VALUE (t2);
2128 403292180 : t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
2129 : ;
2130 :
2131 : /* Maybe the lists are equal. */
2132 656744186 : if (t1 == 0 && t2 == 0)
2133 : return 1;
2134 :
2135 304386763 : for (; t2 != 0; t2 = TREE_CHAIN (t2))
2136 : {
2137 289090015 : const_tree attr;
2138 : /* This CONST_CAST is okay because lookup_attribute does not
2139 : modify its argument and the return value is assigned to a
2140 : const_tree. */
2141 289090015 : for (attr = lookup_ident_attribute (get_attribute_name (t2),
2142 : const_cast<tree> (l1));
2143 304165844 : attr != NULL_TREE && !attribute_value_equal (t2, attr);
2144 15075829 : attr = lookup_ident_attribute (get_attribute_name (t2),
2145 15075829 : TREE_CHAIN (attr)))
2146 : ;
2147 :
2148 289090015 : if (attr == NULL_TREE)
2149 : return 0;
2150 : }
2151 :
2152 : return 1;
2153 : }
2154 :
2155 : /* The backbone of lookup_attribute(). ATTR_LEN is the string length
2156 : of ATTR_NAME, and LIST is not NULL_TREE.
2157 :
2158 : The function is called from lookup_attribute in order to optimize
2159 : for size. */
2160 :
2161 : tree
2162 12986720505 : private_lookup_attribute (const char *attr_name, size_t attr_len, tree list)
2163 : {
2164 35244798554 : while (list)
2165 : {
2166 23889332083 : tree attr = get_attribute_name (list);
2167 23889332083 : size_t ident_len = IDENTIFIER_LENGTH (attr);
2168 23889332083 : if (cmp_attribs (attr_name, attr_len, IDENTIFIER_POINTER (attr),
2169 : ident_len))
2170 : break;
2171 22258078049 : list = TREE_CHAIN (list);
2172 : }
2173 :
2174 12986720505 : return list;
2175 : }
2176 :
2177 : /* Similarly but with also attribute namespace. */
2178 :
2179 : tree
2180 928840830 : private_lookup_attribute (const char *attr_ns, const char *attr_name,
2181 : size_t attr_ns_len, size_t attr_len, tree list)
2182 : {
2183 2312302386 : while (list)
2184 : {
2185 1396968346 : tree attr = get_attribute_name (list);
2186 1396968346 : size_t ident_len = IDENTIFIER_LENGTH (attr);
2187 1396968346 : if (cmp_attribs (attr_name, attr_len, IDENTIFIER_POINTER (attr),
2188 : ident_len))
2189 : {
2190 13506884 : tree ns = get_attribute_namespace (list);
2191 13506884 : if (ns == NULL_TREE)
2192 : {
2193 13716 : if (attr_ns_len == 0)
2194 : break;
2195 : }
2196 13493168 : else if (attr_ns)
2197 : {
2198 13493160 : ident_len = IDENTIFIER_LENGTH (ns);
2199 13493160 : if (attr_ns_len == 0)
2200 : {
2201 2312397636 : if (cmp_attribs ("gnu", strlen ("gnu"),
2202 95250 : IDENTIFIER_POINTER (ns), ident_len))
2203 : break;
2204 : }
2205 2325700296 : else if (cmp_attribs (attr_ns, attr_ns_len,
2206 13397910 : IDENTIFIER_POINTER (ns), ident_len))
2207 : break;
2208 : }
2209 : }
2210 1383461556 : list = TREE_CHAIN (list);
2211 : }
2212 :
2213 928840830 : return list;
2214 : }
2215 :
2216 : /* Return true if the function decl or type NODE has been declared
2217 : with attribute ANAME among attributes ATTRS. */
2218 :
2219 : static bool
2220 1273735 : has_attribute (tree node, tree attrs, const char *aname)
2221 : {
2222 1273735 : if (!strcmp (aname, "const"))
2223 : {
2224 8906 : if (DECL_P (node) && TREE_READONLY (node))
2225 : return true;
2226 : }
2227 1264829 : else if (!strcmp (aname, "malloc"))
2228 : {
2229 261541 : if (DECL_P (node) && DECL_IS_MALLOC (node))
2230 : return true;
2231 : }
2232 1090496 : else if (!strcmp (aname, "noreturn"))
2233 : {
2234 8906 : if (DECL_P (node) && TREE_THIS_VOLATILE (node))
2235 : return true;
2236 : }
2237 1081590 : else if (!strcmp (aname, "nothrow"))
2238 : {
2239 8906 : if (TREE_NOTHROW (node))
2240 : return true;
2241 : }
2242 1072684 : else if (!strcmp (aname, "pure"))
2243 : {
2244 13360 : if (DECL_P (node) && DECL_PURE_P (node))
2245 : return true;
2246 : }
2247 :
2248 1272800 : return lookup_attribute (aname, attrs);
2249 : }
2250 :
2251 : /* Return the number of mismatched function or type attributes between
2252 : the "template" function declaration TMPL and DECL. The word "template"
2253 : doesn't necessarily refer to a C++ template but rather a declaration
2254 : whose attributes should be matched by those on DECL. For a non-zero
2255 : return value append the names of the mismatcheed attributes to OUTATTRS.
2256 : ATTRLIST is a list of additional attributes that SPEC should be
2257 : taken to ultimately be declared with. */
2258 :
2259 : unsigned
2260 1591407 : decls_mismatched_attributes (tree tmpl, tree decl, tree attrlist,
2261 : const char* const blacklist[],
2262 : auto_vec<const char *> &outattrs)
2263 : {
2264 1591407 : if (TREE_CODE (tmpl) != FUNCTION_DECL)
2265 : return 0;
2266 :
2267 : /* Avoid warning if either declaration or its type is deprecated. */
2268 654609 : if (TREE_DEPRECATED (tmpl)
2269 654609 : || TREE_DEPRECATED (decl))
2270 : return 0;
2271 :
2272 654609 : const tree tmpls[] = { tmpl, TREE_TYPE (tmpl) };
2273 654609 : const tree decls[] = { decl, TREE_TYPE (decl) };
2274 :
2275 654609 : if (TREE_DEPRECATED (tmpls[1])
2276 654609 : || TREE_DEPRECATED (decls[1])
2277 654609 : || TREE_DEPRECATED (TREE_TYPE (tmpls[1]))
2278 1309218 : || TREE_DEPRECATED (TREE_TYPE (decls[1])))
2279 : return 0;
2280 :
2281 654600 : tree tmpl_attrs[] = { DECL_ATTRIBUTES (tmpl), TYPE_ATTRIBUTES (tmpls[1]) };
2282 654600 : tree decl_attrs[] = { DECL_ATTRIBUTES (decl), TYPE_ATTRIBUTES (decls[1]) };
2283 :
2284 654600 : if (!decl_attrs[0])
2285 649561 : decl_attrs[0] = attrlist;
2286 5039 : else if (!decl_attrs[1])
2287 5004 : decl_attrs[1] = attrlist;
2288 :
2289 : /* Avoid warning if the template has no attributes. */
2290 654600 : if (!tmpl_attrs[0] && !tmpl_attrs[1])
2291 : return 0;
2292 :
2293 : /* Avoid warning if either declaration contains an attribute on
2294 : the white list below. */
2295 87186 : const char* const whitelist[] = {
2296 : "error", "warning"
2297 : };
2298 :
2299 261516 : for (unsigned i = 0; i != 2; ++i)
2300 523023 : for (unsigned j = 0; j != ARRAY_SIZE (whitelist); ++j)
2301 348693 : if (lookup_attribute (whitelist[j], tmpl_attrs[i])
2302 348693 : || lookup_attribute (whitelist[j], decl_attrs[i]))
2303 : return 0;
2304 :
2305 : /* Put together a list of the black-listed attributes that the template
2306 : is declared with and the declaration is not, in case it's not apparent
2307 : from the most recent declaration of the template. */
2308 : unsigned nattrs = 0;
2309 :
2310 724038 : for (unsigned i = 0; blacklist[i]; ++i)
2311 : {
2312 : /* Attribute leaf only applies to extern functions. Avoid mentioning
2313 : it when it's missing from a static declaration. */
2314 636873 : if (!TREE_PUBLIC (decl)
2315 667 : && !strcmp ("leaf", blacklist[i]))
2316 47 : continue;
2317 :
2318 1909395 : for (unsigned j = 0; j != 2; ++j)
2319 : {
2320 1273139 : if (!has_attribute (tmpls[j], tmpl_attrs[j], blacklist[i]))
2321 1272569 : continue;
2322 :
2323 570 : bool found = false;
2324 570 : unsigned kmax = 1 + !!decl_attrs[1];
2325 653 : for (unsigned k = 0; k != kmax; ++k)
2326 : {
2327 596 : if (has_attribute (decls[k], decl_attrs[k], blacklist[i]))
2328 : {
2329 : found = true;
2330 : break;
2331 : }
2332 : }
2333 :
2334 570 : if (!found)
2335 : {
2336 57 : outattrs.safe_push (blacklist[i]);
2337 57 : ++nattrs;
2338 : }
2339 :
2340 : break;
2341 : }
2342 : }
2343 :
2344 : return nattrs;
2345 : }
2346 :
2347 : /* Issue a warning for the declaration ALIAS for TARGET where ALIAS
2348 : specifies either attributes that are incompatible with those of
2349 : TARGET, or attributes that are missing and that declaring ALIAS
2350 : with would benefit. */
2351 :
2352 : void
2353 5160 : maybe_diag_alias_attributes (tree alias, tree target)
2354 : {
2355 : /* Do not expect attributes to match between aliases and ifunc
2356 : resolvers. There is no obvious correspondence between them. */
2357 5160 : if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (alias)))
2358 117 : return;
2359 :
2360 5047 : const char* const blacklist[] = {
2361 : "alloc_align", "alloc_size", "cold", "const", "hot", "leaf", "malloc",
2362 : "nonnull", "noreturn", "nothrow", "pure", "returns_nonnull",
2363 : "returns_twice", NULL
2364 : };
2365 :
2366 5047 : if (warn_attribute_alias > 1)
2367 : {
2368 : /* With -Wattribute-alias=2 detect alias declarations that are more
2369 : restrictive than their targets first. Those indicate potential
2370 : codegen bugs. */
2371 4 : auto_vec<const char *> mismatches;
2372 4 : if (unsigned n = decls_mismatched_attributes (alias, target, NULL_TREE,
2373 : blacklist, mismatches))
2374 : {
2375 4 : auto_diagnostic_group d;
2376 4 : pp_markup::comma_separated_quoted_strings e (mismatches);
2377 4 : if (warning_n (DECL_SOURCE_LOCATION (alias),
2378 4 : OPT_Wattribute_alias_, n,
2379 : "%qD specifies more restrictive attribute than "
2380 : "its target %qD: %e",
2381 : "%qD specifies more restrictive attributes than "
2382 : "its target %qD: %e",
2383 : alias, target, &e))
2384 3 : inform (DECL_SOURCE_LOCATION (target),
2385 : "%qD target declared here", alias);
2386 4 : return;
2387 4 : }
2388 4 : }
2389 :
2390 : /* Detect alias declarations that are less restrictive than their
2391 : targets. Those suggest potential optimization opportunities
2392 : (solved by adding the missing attribute(s) to the alias). */
2393 5043 : auto_vec<const char *> mismatches;
2394 5043 : if (unsigned n = decls_mismatched_attributes (target, alias, NULL_TREE,
2395 : blacklist, mismatches))
2396 : {
2397 19 : auto_diagnostic_group d;
2398 19 : pp_markup::comma_separated_quoted_strings e (mismatches);
2399 19 : if (warning_n (DECL_SOURCE_LOCATION (alias),
2400 19 : OPT_Wmissing_attributes, n,
2401 : "%qD specifies less restrictive attribute than "
2402 : "its target %qD: %e",
2403 : "%qD specifies less restrictive attributes than "
2404 : "its target %qD: %e",
2405 : alias, target, &e))
2406 10 : inform (DECL_SOURCE_LOCATION (target),
2407 : "%qD target declared here", alias);
2408 19 : }
2409 5043 : }
2410 :
2411 : /* Initialize a mapping RWM for a call to a function declared with
2412 : attribute access in ATTRS. Each attribute positional operand
2413 : inserts one entry into the mapping with the operand number as
2414 : the key. */
2415 :
2416 : void
2417 8301412 : init_attr_rdwr_indices (rdwr_map *rwm, tree attrs)
2418 : {
2419 8301412 : if (!attrs)
2420 : return;
2421 :
2422 1341187 : for (tree access = attrs;
2423 7008219 : (access = lookup_attribute ("access", access));
2424 1341187 : access = TREE_CHAIN (access))
2425 : {
2426 : /* The TREE_VALUE of an attribute is a TREE_LIST whose TREE_VALUE
2427 : is the attribute argument's value. */
2428 1341187 : tree mode = TREE_VALUE (access);
2429 1341187 : if (!mode)
2430 : return;
2431 :
2432 : /* The (optional) list of VLA bounds. */
2433 1341187 : tree vblist = TREE_CHAIN (mode);
2434 1341187 : mode = TREE_VALUE (mode);
2435 1341187 : if (TREE_CODE (mode) != STRING_CST)
2436 0 : continue;
2437 1341187 : gcc_assert (TREE_CODE (mode) == STRING_CST);
2438 :
2439 1341187 : if (vblist)
2440 518104 : vblist = nreverse (copy_list (TREE_VALUE (vblist)));
2441 :
2442 2734631 : for (const char *m = TREE_STRING_POINTER (mode); *m; )
2443 : {
2444 1393444 : attr_access acc = { };
2445 :
2446 : /* Skip the internal-only plus sign. */
2447 1393444 : if (*m == '+')
2448 39230 : ++m;
2449 :
2450 1393444 : acc.str = m;
2451 1393444 : acc.mode = acc.from_mode_char (*m);
2452 1393444 : acc.sizarg = UINT_MAX;
2453 :
2454 1393444 : const char *end;
2455 1393444 : acc.ptrarg = strtoul (++m, const_cast<char**>(&end), 10);
2456 1393444 : m = end;
2457 :
2458 1393444 : if (*m == '[')
2459 : {
2460 : /* Forms containing the square bracket are internal-only
2461 : (not specified by an attribute declaration), and used
2462 : for various forms of array and VLA parameters. */
2463 570361 : acc.internal_p = true;
2464 :
2465 : /* Search to the closing bracket and look at the preceding
2466 : code: it determines the form of the most significant
2467 : bound of the array. Others prior to it encode the form
2468 : of interior VLA bounds. They're not of interest here. */
2469 570361 : end = strchr (m, ']');
2470 570361 : const char *p = end;
2471 570361 : gcc_assert (p);
2472 :
2473 1228426 : while (ISDIGIT (p[-1]))
2474 658065 : --p;
2475 :
2476 570361 : if (ISDIGIT (*p))
2477 : {
2478 : /* A digit denotes a constant bound (as in T[3]). */
2479 490179 : acc.static_p = p[-1] == 's';
2480 490179 : acc.minsize = strtoull (p, NULL, 10);
2481 : }
2482 80182 : else if (' ' == p[-1])
2483 : {
2484 : /* A space denotes an ordinary array of unspecified bound
2485 : (as in T[]). */
2486 : acc.minsize = 0;
2487 : }
2488 2725 : else if ('*' == p[-1] || '$' == p[-1])
2489 : {
2490 : /* An asterisk denotes a VLA. When the closing bracket
2491 : is followed by a comma and a dollar sign its bound is
2492 : on the list. Otherwise it's a VLA with an unspecified
2493 : bound. */
2494 2725 : acc.static_p = p[-2] == 's';
2495 2725 : acc.minsize = HOST_WIDE_INT_M1U;
2496 : }
2497 :
2498 570361 : m = end + 1;
2499 : }
2500 :
2501 1393444 : if (*m == ',')
2502 : {
2503 679578 : ++m;
2504 700618 : do
2505 : {
2506 700618 : if (*m == '$')
2507 : {
2508 24176 : ++m;
2509 24176 : if (!acc.size && vblist)
2510 : {
2511 : /* Extract the list of VLA bounds for the current
2512 : parameter, store it in ACC.SIZE, and advance
2513 : to the list of bounds for the next VLA parameter.
2514 : */
2515 3136 : acc.size = TREE_VALUE (vblist);
2516 3136 : vblist = TREE_CHAIN (vblist);
2517 : }
2518 : }
2519 :
2520 700618 : if (ISDIGIT (*m))
2521 : {
2522 : /* Extract the positional argument. It's absent
2523 : for VLAs whose bound doesn't name a function
2524 : parameter. */
2525 677459 : unsigned pos = strtoul (m, const_cast<char**>(&end), 10);
2526 677459 : if (acc.sizarg == UINT_MAX)
2527 677346 : acc.sizarg = pos;
2528 677459 : m = end;
2529 : }
2530 : }
2531 700618 : while (*m == '$');
2532 : }
2533 :
2534 1393444 : acc.end = m;
2535 :
2536 1393444 : bool existing;
2537 1393444 : auto &ref = rwm->get_or_insert (acc.ptrarg, &existing);
2538 1393444 : if (existing)
2539 : {
2540 : /* Merge the new spec with the existing. */
2541 222 : if (acc.minsize == HOST_WIDE_INT_M1U)
2542 12 : ref.minsize = HOST_WIDE_INT_M1U;
2543 :
2544 222 : if (acc.sizarg != UINT_MAX)
2545 60 : ref.sizarg = acc.sizarg;
2546 :
2547 222 : if (acc.mode)
2548 186 : ref.mode = acc.mode;
2549 : }
2550 : else
2551 1393222 : ref = acc;
2552 :
2553 : /* Unconditionally add an entry for the required pointer
2554 : operand of the attribute, and one for the optional size
2555 : operand when it's specified. */
2556 1393444 : if (acc.sizarg != UINT_MAX)
2557 677346 : rwm->put (acc.sizarg, acc);
2558 : }
2559 : }
2560 : }
2561 :
2562 : /* Return the access specification for a function parameter PARM
2563 : or null if the current function has no such specification. */
2564 :
2565 : attr_access *
2566 785265 : get_parm_access (rdwr_map &rdwr_idx, tree parm,
2567 : tree fndecl /* = current_function_decl */)
2568 : {
2569 785265 : tree fntype = TREE_TYPE (fndecl);
2570 785265 : init_attr_rdwr_indices (&rdwr_idx, TYPE_ATTRIBUTES (fntype));
2571 :
2572 785265 : if (rdwr_idx.is_empty ())
2573 : return NULL;
2574 :
2575 3601 : unsigned argpos = 0;
2576 3601 : tree fnargs = DECL_ARGUMENTS (fndecl);
2577 8447 : for (tree arg = fnargs; arg; arg = TREE_CHAIN (arg), ++argpos)
2578 8433 : if (arg == parm)
2579 3587 : return rdwr_idx.get (argpos);
2580 :
2581 : return NULL;
2582 : }
2583 :
2584 : /* Return the internal representation as STRING_CST. Internal positional
2585 : arguments are zero-based. */
2586 :
2587 : tree
2588 1188707 : attr_access::to_internal_string () const
2589 : {
2590 1188707 : return build_string (end - str, str);
2591 : }
2592 :
2593 : /* Return the human-readable representation of the external attribute
2594 : specification (as it might appear in the source code) as STRING_CST.
2595 : External positional arguments are one-based. */
2596 :
2597 : tree
2598 2512 : attr_access::to_external_string () const
2599 : {
2600 2512 : char buf[80];
2601 2512 : gcc_assert (mode != access_deferred);
2602 2512 : int len = snprintf (buf, sizeof buf, "access (%s, %u",
2603 2512 : mode_names[mode], ptrarg + 1);
2604 2512 : if (sizarg != UINT_MAX)
2605 2202 : len += snprintf (buf + len, sizeof buf - len, ", %u", sizarg + 1);
2606 2512 : strcpy (buf + len, ")");
2607 2512 : return build_string (len + 2, buf);
2608 : }
2609 :
2610 : /* Return the number of specified VLA bounds and set *nunspec to
2611 : the number of unspecified ones (those designated by [*]). */
2612 :
2613 : unsigned
2614 8468 : attr_access::vla_bounds (unsigned *nunspec) const
2615 : {
2616 8468 : unsigned nbounds = 0;
2617 8468 : *nunspec = 0;
2618 : /* STR points to the beginning of the specified string for the current
2619 : argument that may be followed by the string for the next argument. */
2620 54456 : for (const char* p = strchr (str, ']'); p && *p != '['; --p)
2621 : {
2622 45988 : if (*p == '*')
2623 91 : ++*nunspec;
2624 45897 : else if (*p == '$')
2625 9054 : ++nbounds;
2626 : }
2627 8468 : return nbounds;
2628 : }
2629 :
2630 : /* Reset front end-specific attribute access data from ATTRS.
2631 : Called from the free_lang_data pass. */
2632 :
2633 : /* static */ void
2634 335839 : attr_access::free_lang_data (tree attrs)
2635 : {
2636 385931 : for (tree acs = attrs; (acs = lookup_attribute ("access", acs));
2637 50092 : acs = TREE_CHAIN (acs))
2638 : {
2639 50092 : tree vblist = TREE_VALUE (acs);
2640 50092 : vblist = TREE_CHAIN (vblist);
2641 50092 : if (!vblist)
2642 26 : continue;
2643 :
2644 50341 : for (vblist = TREE_VALUE (vblist); vblist; vblist = TREE_CHAIN (vblist))
2645 : {
2646 275 : tree *pvbnd = &TREE_VALUE (vblist);
2647 275 : if (!*pvbnd || DECL_P (*pvbnd))
2648 0 : continue;
2649 :
2650 : /* VLA bounds that are expressions as opposed to DECLs are
2651 : only used in the front end. Reset them to keep front end
2652 : trees leaking into the middle end (see pr97172) and to
2653 : free up memory. */
2654 275 : *pvbnd = NULL_TREE;
2655 : }
2656 : }
2657 :
2658 417078 : for (tree argspec = attrs; (argspec = lookup_attribute ("arg spec", argspec));
2659 81239 : argspec = TREE_CHAIN (argspec))
2660 : {
2661 : /* Same as above. */
2662 81239 : tree *pvblist = &TREE_VALUE (argspec);
2663 81239 : *pvblist = NULL_TREE;
2664 : }
2665 335839 : }
2666 :
2667 : /* Defined in attr_access. */
2668 : constexpr char attr_access::mode_chars[];
2669 : constexpr char attr_access::mode_names[][11];
2670 :
2671 : /* Format an array, including a VLA, pointed to by TYPE and used as
2672 : a function parameter as a human-readable string. ACC describes
2673 : an access to the parameter and is used to determine the outermost
2674 : form of the array including its bound which is otherwise obviated
2675 : by its decay to pointer. Return the formatted string. */
2676 :
2677 : std::string
2678 8994 : attr_access::array_as_string (tree type) const
2679 : {
2680 8994 : std::string typstr;
2681 :
2682 8994 : if (type == error_mark_node)
2683 0 : return std::string ();
2684 :
2685 8994 : if (this->str)
2686 : {
2687 : /* For array parameters (but not pointers) create a temporary array
2688 : type that corresponds to the form of the parameter including its
2689 : qualifiers even though they apply to the pointer, not the array
2690 : type. */
2691 8610 : const bool vla_p = minsize == HOST_WIDE_INT_M1U;
2692 8610 : tree eltype = TREE_TYPE (type);
2693 8610 : tree index_type = NULL_TREE;
2694 :
2695 8610 : if (minsize == HOST_WIDE_INT_M1U)
2696 : {
2697 : /* Determine if this is a VLA (an array whose most significant
2698 : bound is nonconstant and whose access string has "$]" in it)
2699 : extract the bound expression from SIZE. */
2700 741 : const char *p = end;
2701 9610 : for ( ; p != str && *p-- != ']'; );
2702 741 : if (*p == '$')
2703 : /* SIZE may have been cleared. Use it with care. */
2704 670 : index_type = build_index_type (size ? TREE_VALUE (size) : size);
2705 : }
2706 7869 : else if (minsize)
2707 7234 : index_type = build_index_type (size_int (minsize - 1));
2708 :
2709 8610 : tree arat = NULL_TREE;
2710 8610 : if (static_p || vla_p)
2711 : {
2712 780 : tree flag = static_p ? integer_one_node : NULL_TREE;
2713 : /* Hack: there's no language-independent way to encode
2714 : the "static" specifier or the "*" notation in an array type.
2715 : Add a "fake" attribute to have the pretty-printer add "static"
2716 : or "*". The "[static N]" notation is only valid in the most
2717 : significant bound but [*] can be used for any bound. Because
2718 : [*] is represented the same as [0] this hack only works for
2719 : the most significant bound like static and the others are
2720 : rendered as [0]. */
2721 780 : arat = build_tree_list (get_identifier ("array "), flag);
2722 : }
2723 :
2724 8610 : const auto quals = TYPE_QUALS (type);
2725 8610 : type = build_array_type (eltype, index_type);
2726 8610 : type = build_type_attribute_qual_variant (type, arat, quals);
2727 : }
2728 :
2729 : /* Format the type using the current pretty printer. The generic tree
2730 : printer does a terrible job. */
2731 8994 : std::unique_ptr<pretty_printer> pp (global_dc->clone_printer ());
2732 8994 : pp_printf (pp.get (), "%qT", type);
2733 8994 : typstr = pp_formatted_text (pp.get ());
2734 :
2735 8994 : return typstr;
2736 8994 : }
2737 :
2738 : #if CHECKING_P
2739 :
2740 : namespace selftest
2741 : {
2742 :
2743 : /* Self-test to verify that each attribute exclusion is symmetric,
2744 : meaning that if attribute A is encoded as incompatible with
2745 : attribute B then the opposite relationship is also encoded.
2746 : This test also detects most cases of misspelled attribute names
2747 : in exclusions. */
2748 :
2749 : static void
2750 4 : test_attribute_exclusions ()
2751 : {
2752 4 : using excl_hash_traits = pair_hash<nofree_string_hash, nofree_string_hash>;
2753 :
2754 : /* Iterate over the array of attribute tables first (with TI0 as
2755 : the index) and over the array of attribute_spec in each table
2756 : (with SI0 as the index). */
2757 4 : hash_set<excl_hash_traits> excl_set;
2758 :
2759 16 : for (auto scoped_array : attribute_tables)
2760 29 : for (auto scoped_attributes : scoped_array)
2761 608 : for (const attribute_spec &attribute : scoped_attributes->attributes)
2762 : {
2763 587 : const attribute_spec::exclusions *excl = attribute.exclude;
2764 :
2765 : /* Skip each attribute that doesn't define exclusions. */
2766 587 : if (!excl)
2767 496 : continue;
2768 :
2769 : /* Skip standard (non-GNU) attributes, since currently the
2770 : exclusions are implicitly for GNU attributes only.
2771 : Also, C++ likely and unlikely get rewritten to gnu::hot
2772 : and gnu::cold, so symmetry isn't necessary there. */
2773 91 : if (!scoped_attributes->ns)
2774 3 : continue;
2775 :
2776 88 : const char *attr_name = attribute.name;
2777 :
2778 : /* Iterate over the set of exclusions for every attribute
2779 : (with EI0 as the index) adding the exclusions defined
2780 : for each to the set. */
2781 320 : for (size_t ei0 = 0; excl[ei0].name; ++ei0)
2782 : {
2783 232 : const char *excl_name = excl[ei0].name;
2784 :
2785 232 : if (!strcmp (attr_name, excl_name))
2786 47 : continue;
2787 :
2788 185 : excl_set.add ({ attr_name, excl_name });
2789 : }
2790 : }
2791 :
2792 : /* Traverse the set of mutually exclusive pairs of attributes
2793 : and verify that they are symmetric. */
2794 192 : for (auto excl_pair : excl_set)
2795 184 : if (!excl_set.contains ({ excl_pair.second, excl_pair.first }))
2796 : {
2797 : /* An exclusion for an attribute has been found that
2798 : doesn't have a corresponding exclusion in the opposite
2799 : direction. */
2800 0 : char desc[120];
2801 0 : sprintf (desc, "'%s' attribute exclusion '%s' must be symmetric",
2802 : excl_pair.first, excl_pair.second);
2803 0 : fail (SELFTEST_LOCATION, desc);
2804 : }
2805 4 : }
2806 :
2807 : void
2808 4 : attribs_cc_tests ()
2809 : {
2810 4 : test_attribute_exclusions ();
2811 4 : }
2812 :
2813 : } /* namespace selftest */
2814 :
2815 : #endif /* CHECKING_P */
2816 :
2817 : #include "gt-attribs.h"
|