gcc/attribs.c

   1 /* Functions dealing with attribute handling, used by most front ends.
   2    Copyright (C) 1992-2018 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 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "target.h"
  24 #include "tree.h"
  25 #include "stringpool.h"
  26 #include "diagnostic-core.h"
  27 #include "attribs.h"
  28 #include "stor-layout.h"
  29 #include "langhooks.h"
  30 #include "plugin.h"
  31 #include "selftest.h"
  32 #include "hash-set.h"
  33
  34 /* Table of the tables of attributes (common, language, format, machine)
  35    searched.  */
  36 static const struct attribute_spec *attribute_tables[4];
  37
  38 /* Substring representation.  */
  39
  40 struct substring
  41 {
  42   const char *str;
  43   int length;
  44 };
  45
  46 /* Simple hash function to avoid need to scan whole string.  */
  47
  48 static inline hashval_t
  49 substring_hash (const char *str, int l)
  50 {
  51   return str[0] + str[l - 1] * 256 + l * 65536;
  52 }
  53
  54 /* Used for attribute_hash.  */
  55
  56 struct attribute_hasher : nofree_ptr_hash <attribute_spec>
  57 {
  58   typedef substring *compare_type;
  59   static inline hashval_t hash (const attribute_spec *);
  60   static inline bool equal (const attribute_spec *, const substring *);
  61 };
  62
  63 inline hashval_t
  64 attribute_hasher::hash (const attribute_spec *spec)
  65 {
  66   const int l = strlen (spec->name);
  67   return substring_hash (spec->name, l);
  68 }
  69
  70 inline bool
  71 attribute_hasher::equal (const attribute_spec *spec, const substring *str)
  72 {
  73   return (strncmp (spec->name, str->str, str->length) == 0
  74           && !spec->name[str->length]);
  75 }
  76
  77 /* Scoped attribute name representation.  */
  78
  79 struct scoped_attributes
  80 {
  81   const char *ns;
  82   vec<attribute_spec> attributes;
  83   hash_table<attribute_hasher> *attribute_hash;
  84 };
  85
  86 /* The table of scope attributes.  */
  87 static vec<scoped_attributes> attributes_table;
  88
  89 static scoped_attributes* find_attribute_namespace (const char*);
  90 static void register_scoped_attribute (const struct attribute_spec *,
  91                                        scoped_attributes *);
  92
  93 static bool attributes_initialized = false;
  94
  95 /* Default empty table of attributes.  */
  96
  97 static const struct attribute_spec empty_attribute_table[] =
  98 {
  99   { NULL, 0, 0, false, false, false, false, NULL, NULL }
 100 };
 101
 102 /* Return base name of the attribute.  Ie '__attr__' is turned into 'attr'.
 103    To avoid need for copying, we simply return length of the string.  */
 104
 105 static void
 106 extract_attribute_substring (struct substring *str)
 107 {
 108   if (str->length > 4 && str->str[0] == '_' && str->str[1] == '_'
 109       && str->str[str->length - 1] == '_' && str->str[str->length - 2] == '_')
 110     {
 111       str->length -= 4;
 112       str->str += 2;
 113     }
 114 }
 115
 116 /* Insert an array of attributes ATTRIBUTES into a namespace.  This
 117    array must be NULL terminated.  NS is the name of attribute
 118    namespace.  The function returns the namespace into which the
 119    attributes have been registered.  */
 120
 121 scoped_attributes *
 122 register_scoped_attributes (const struct attribute_spec *attributes,
 123                             const char *ns)
 124 {
 125   scoped_attributes *result = NULL;
 126
 127   /* See if we already have attributes in the namespace NS.  */
 128   result = find_attribute_namespace (ns);
 129
 130   if (result == NULL)
 131     {
 132       /* We don't have any namespace NS yet.  Create one.  */
 133       scoped_attributes sa;
 134
 135       if (attributes_table.is_empty ())
 136         attributes_table.create (64);
 137
 138       memset (&sa, 0, sizeof (sa));
 139       sa.ns = ns;
 140       sa.attributes.create (64);
 141       result = attributes_table.safe_push (sa);
 142       result->attribute_hash = new hash_table<attribute_hasher> (200);
 143     }
 144
 145   /* Really add the attributes to their namespace now.  */
 146   for (unsigned i = 0; attributes[i].name != NULL; ++i)
 147     {
 148       result->attributes.safe_push (attributes[i]);
 149       register_scoped_attribute (&attributes[i], result);
 150     }
 151
 152   gcc_assert (result != NULL);
 153
 154   return result;
 155 }
 156
 157 /* Return the namespace which name is NS, NULL if none exist.  */
 158
 159 static scoped_attributes*
 160 find_attribute_namespace (const char* ns)
 161 {
 162   unsigned ix;
 163   scoped_attributes *iter;
 164
 165   FOR_EACH_VEC_ELT (attributes_table, ix, iter)
 166     if (ns == iter->ns
 167         || (iter->ns != NULL
 168             && ns != NULL
 169             && !strcmp (iter->ns, ns)))
 170       return iter;
 171   return NULL;
 172 }
 173
 174 /* Make some sanity checks on the attribute tables.  */
 175
 176 static void
 177 check_attribute_tables (void)
 178 {
 179   for (size_t i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 180     for (size_t j = 0; attribute_tables[i][j].name != NULL; j++)
 181       {
 182         /* The name must not begin and end with __.  */
 183         const char *name = attribute_tables[i][j].name;
 184         int len = strlen (name);
 185
 186         gcc_assert (!(name[0] == '_' && name[1] == '_'
 187                       && name[len - 1] == '_' && name[len - 2] == '_'));
 188
 189         /* The minimum and maximum lengths must be consistent.  */
 190         gcc_assert (attribute_tables[i][j].min_length >= 0);
 191
 192         gcc_assert (attribute_tables[i][j].max_length == -1
 193                     || (attribute_tables[i][j].max_length
 194                         >= attribute_tables[i][j].min_length));
 195
 196         /* An attribute cannot require both a DECL and a TYPE.  */
 197         gcc_assert (!attribute_tables[i][j].decl_required
 198                     || !attribute_tables[i][j].type_required);
 199
 200           /* If an attribute requires a function type, in particular
 201              it requires a type.  */
 202         gcc_assert (!attribute_tables[i][j].function_type_required
 203                     || attribute_tables[i][j].type_required);
 204       }
 205
 206   /* Check that each name occurs just once in each table.  */
 207   for (size_t i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 208     for (size_t j = 0; attribute_tables[i][j].name != NULL; j++)
 209       for (size_t k = j + 1; attribute_tables[i][k].name != NULL; k++)
 210         gcc_assert (strcmp (attribute_tables[i][j].name,
 211                             attribute_tables[i][k].name));
 212
 213   /* Check that no name occurs in more than one table.  Names that
 214      begin with '*' are exempt, and may be overridden.  */
 215   for (size_t i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 216     for (size_t j = i + 1; j < ARRAY_SIZE (attribute_tables); j++)
 217       for (size_t k = 0; attribute_tables[i][k].name != NULL; k++)
 218         for (size_t l = 0; attribute_tables[j][l].name != NULL; l++)
 219           gcc_assert (attribute_tables[i][k].name[0] == '*'
 220                       || strcmp (attribute_tables[i][k].name,
 221                                  attribute_tables[j][l].name));
 222 }
 223
 224 /* Initialize attribute tables, and make some sanity checks if checking is
 225    enabled.  */
 226
 227 void
 228 init_attributes (void)
 229 {
 230   size_t i;
 231
 232   if (attributes_initialized)
 233     return;
 234
 235   attribute_tables[0] = lang_hooks.common_attribute_table;
 236   attribute_tables[1] = lang_hooks.attribute_table;
 237   attribute_tables[2] = lang_hooks.format_attribute_table;
 238   attribute_tables[3] = targetm.attribute_table;
 239
 240   /* Translate NULL pointers to pointers to the empty table.  */
 241   for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 242     if (attribute_tables[i] == NULL)
 243       attribute_tables[i] = empty_attribute_table;
 244
 245   if (flag_checking)
 246     check_attribute_tables ();
 247
 248   for (i = 0; i < ARRAY_SIZE (attribute_tables); ++i)
 249     /* Put all the GNU attributes into the "gnu" namespace.  */
 250     register_scoped_attributes (attribute_tables[i], "gnu");
 251
 252   invoke_plugin_callbacks (PLUGIN_ATTRIBUTES, NULL);
 253   attributes_initialized = true;
 254 }
 255
 256 /* Insert a single ATTR into the attribute table.  */
 257
 258 void
 259 register_attribute (const struct attribute_spec *attr)
 260 {
 261   register_scoped_attribute (attr, find_attribute_namespace ("gnu"));
 262 }
 263
 264 /* Insert a single attribute ATTR into a namespace of attributes.  */
 265
 266 static void
 267 register_scoped_attribute (const struct attribute_spec *attr,
 268                            scoped_attributes *name_space)
 269 {
 270   struct substring str;
 271   attribute_spec **slot;
 272
 273   gcc_assert (attr != NULL && name_space != NULL);
 274
 275   gcc_assert (name_space->attribute_hash);
 276
 277   str.str = attr->name;
 278   str.length = strlen (str.str);
 279
 280   /* Attribute names in the table must be in the form 'text' and not
 281      in the form '__text__'.  */
 282   gcc_assert (str.length > 0 && str.str[0] != '_');
 283
 284   slot = name_space->attribute_hash
 285          ->find_slot_with_hash (&str, substring_hash (str.str, str.length),
 286                                 INSERT);
 287   gcc_assert (!*slot || attr->name[0] == '*');
 288   *slot = CONST_CAST (struct attribute_spec *, attr);
 289 }
 290
 291 /* Return the spec for the scoped attribute with namespace NS and
 292    name NAME.   */
 293
 294 static const struct attribute_spec *
 295 lookup_scoped_attribute_spec (const_tree ns, const_tree name)
 296 {
 297   struct substring attr;
 298   scoped_attributes *attrs;
 299
 300   const char *ns_str = (ns != NULL_TREE) ? IDENTIFIER_POINTER (ns): NULL;
 301
 302   attrs = find_attribute_namespace (ns_str);
 303
 304   if (attrs == NULL)
 305     return NULL;
 306
 307   attr.str = IDENTIFIER_POINTER (name);
 308   attr.length = IDENTIFIER_LENGTH (name);
 309   extract_attribute_substring (&attr);
 310   return attrs->attribute_hash->find_with_hash (&attr,
 311                                                 substring_hash (attr.str,
 312                                                                 attr.length));
 313 }
 314
 315 /* Return the spec for the attribute named NAME.  If NAME is a TREE_LIST,
 316    it also specifies the attribute namespace.  */
 317
 318 const struct attribute_spec *
 319 lookup_attribute_spec (const_tree name)
 320 {
 321   tree ns;
 322   if (TREE_CODE (name) == TREE_LIST)
 323     {
 324       ns = TREE_PURPOSE (name);
 325       name = TREE_VALUE (name);
 326     }
 327   else
 328     ns = get_identifier ("gnu");
 329   return lookup_scoped_attribute_spec (ns, name);
 330 }
 331
 332
 333 /* Return the namespace of the attribute ATTR.  This accessor works on
 334    GNU and C++11 (scoped) attributes.  On GNU attributes,
 335    it returns an identifier tree for the string "gnu".
 336
 337    Please read the comments of cxx11_attribute_p to understand the
 338    format of attributes.  */
 339
 340 static tree
 341 get_attribute_namespace (const_tree attr)
 342 {
 343   if (cxx11_attribute_p (attr))
 344     return TREE_PURPOSE (TREE_PURPOSE (attr));
 345   return get_identifier ("gnu");
 346 }
 347
 348 /* Check LAST_DECL and NODE of the same symbol for attributes that are
 349    recorded in SPEC to be mutually exclusive with ATTRNAME, diagnose
 350    them, and return true if any have been found.  NODE can be a DECL
 351    or a TYPE.  */
 352
 353 static bool
 354 diag_attr_exclusions (tree last_decl, tree node, tree attrname,
 355                       const attribute_spec *spec)
 356 {
 357   const attribute_spec::exclusions *excl = spec->exclude;
 358
 359   tree_code code = TREE_CODE (node);
 360
 361   if ((code == FUNCTION_DECL && !excl->function
 362        && (!excl->type || !spec->affects_type_identity))
 363       || (code == VAR_DECL && !excl->variable
 364           && (!excl->type || !spec->affects_type_identity))
 365       || (((code == TYPE_DECL || RECORD_OR_UNION_TYPE_P (node)) && !excl->type)))
 366     return false;
 367
 368   /* True if an attribute that's mutually exclusive with ATTRNAME
 369      has been found.  */
 370   bool found = false;
 371
 372   if (last_decl && last_decl != node && TREE_TYPE (last_decl) != node)
 373     {
 374       /* Check both the last DECL and its type for conflicts with
 375          the attribute being added to the current decl or type.  */
 376       found |= diag_attr_exclusions (last_decl, last_decl, attrname, spec);
 377       tree decl_type = TREE_TYPE (last_decl);
 378       found |= diag_attr_exclusions (last_decl, decl_type, attrname, spec);
 379     }
 380
 381   /* NODE is either the current DECL to which the attribute is being
 382      applied or its TYPE.  For the former, consider the attributes on
 383      both the DECL and its type.  */
 384   tree attrs[2];
 385
 386   if (DECL_P (node))
 387     {
 388       attrs[0] = DECL_ATTRIBUTES (node);
 389       attrs[1] = TYPE_ATTRIBUTES (TREE_TYPE (node));
 390     }
 391   else
 392     {
 393       attrs[0] = TYPE_ATTRIBUTES (node);
 394       attrs[1] = NULL_TREE;
 395     }
 396
 397   /* Iterate over the mutually exclusive attribute names and verify
 398      that the symbol doesn't contain it.  */
 399   for (unsigned i = 0; i != sizeof attrs / sizeof *attrs; ++i)
 400     {
 401       if (!attrs[i])
 402         continue;
 403
 404       for ( ; excl->name; ++excl)
 405         {
 406           /* Avoid checking the attribute against itself.  */
 407           if (is_attribute_p (excl->name, attrname))
 408             continue;
 409
 410           if (!lookup_attribute (excl->name, attrs[i]))
 411             continue;
 412
 413           /* An exclusion may apply either to a function declaration,
 414              type declaration, or a field/variable declaration, or
 415              any subset of the three.  */
 416           if (TREE_CODE (node) == FUNCTION_DECL
 417               && !excl->function)
 418             continue;
 419
 420           if (TREE_CODE (node) == TYPE_DECL
 421               && !excl->type)
 422             continue;
 423
 424           if ((TREE_CODE (node) == FIELD_DECL
 425                || TREE_CODE (node) == VAR_DECL)
 426               && !excl->variable)
 427             continue;
 428
 429           found = true;
 430
 431           /* Print a note?  */
 432           bool note = last_decl != NULL_TREE;
 433
 434           if (TREE_CODE (node) == FUNCTION_DECL
 435               && DECL_BUILT_IN (node))
 436             note &= warning (OPT_Wattributes,
 437                              "ignoring attribute %qE in declaration of "
 438                              "a built-in function %qD because it conflicts "
 439                              "with attribute %qs",
 440                              attrname, node, excl->name);
 441           else
 442             note &= warning (OPT_Wattributes,
 443                              "ignoring attribute %qE because "
 444                              "it conflicts with attribute %qs",
 445                              attrname, excl->name);
 446
 447           if (note)
 448             inform (DECL_SOURCE_LOCATION (last_decl),
 449                     "previous declaration here");
 450         }
 451     }
 452
 453   return found;
 454 }
 455
 456 /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
 457    which is either a DECL (including a TYPE_DECL) or a TYPE.  If a DECL,
 458    it should be modified in place; if a TYPE, a copy should be created
 459    unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS.  FLAGS gives further
 460    information, in the form of a bitwise OR of flags in enum attribute_flags
 461    from tree.h.  Depending on these flags, some attributes may be
 462    returned to be applied at a later stage (for example, to apply
 463    a decl attribute to the declaration rather than to its type).  */
 464
 465 tree
 466 decl_attributes (tree *node, tree attributes, int flags,
 467                  tree last_decl /* = NULL_TREE */)
 468 {
 469   tree a;
 470   tree returned_attrs = NULL_TREE;
 471
 472   if (TREE_TYPE (*node) == error_mark_node || attributes == error_mark_node)
 473     return NULL_TREE;
 474
 475   if (!attributes_initialized)
 476     init_attributes ();
 477
 478   /* If this is a function and the user used #pragma GCC optimize, add the
 479      options to the attribute((optimize(...))) list.  */
 480   if (TREE_CODE (*node) == FUNCTION_DECL && current_optimize_pragma)
 481     {
 482       tree cur_attr = lookup_attribute ("optimize", attributes);
 483       tree opts = copy_list (current_optimize_pragma);
 484
 485       if (! cur_attr)
 486         attributes
 487           = tree_cons (get_identifier ("optimize"), opts, attributes);
 488       else
 489         TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
 490     }
 491
 492   if (TREE_CODE (*node) == FUNCTION_DECL
 493       && optimization_current_node != optimization_default_node
 494       && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node))
 495     DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node) = optimization_current_node;
 496
 497   /* If this is a function and the user used #pragma GCC target, add the
 498      options to the attribute((target(...))) list.  */
 499   if (TREE_CODE (*node) == FUNCTION_DECL
 500       && current_target_pragma
 501       && targetm.target_option.valid_attribute_p (*node, NULL_TREE,
 502                                                   current_target_pragma, 0))
 503     {
 504       tree cur_attr = lookup_attribute ("target", attributes);
 505       tree opts = copy_list (current_target_pragma);
 506
 507       if (! cur_attr)
 508         attributes = tree_cons (get_identifier ("target"), opts, attributes);
 509       else
 510         TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
 511     }
 512
 513   /* A "naked" function attribute implies "noinline" and "noclone" for
 514      those targets that support it.  */
 515   if (TREE_CODE (*node) == FUNCTION_DECL
 516       && attributes
 517       && lookup_attribute ("naked", attributes) != NULL
 518       && lookup_attribute_spec (get_identifier ("naked")))
 519     {
 520       if (lookup_attribute ("noinline", attributes) == NULL)
 521         attributes = tree_cons (get_identifier ("noinline"), NULL, attributes);
 522
 523       if (lookup_attribute ("noclone", attributes) == NULL)
 524         attributes = tree_cons (get_identifier ("noclone"),  NULL, attributes);
 525     }
 526
 527   /* A "noipa" function attribute implies "noinline", "noclone" and "no_icf"
 528      for those targets that support it.  */
 529   if (TREE_CODE (*node) == FUNCTION_DECL
 530       && attributes
 531       && lookup_attribute ("noipa", attributes) != NULL
 532       && lookup_attribute_spec (get_identifier ("noipa")))
 533     {
 534       if (lookup_attribute ("noinline", attributes) == NULL)
 535         attributes = tree_cons (get_identifier ("noinline"), NULL, attributes);
 536
 537       if (lookup_attribute ("noclone", attributes) == NULL)
 538         attributes = tree_cons (get_identifier ("noclone"),  NULL, attributes);
 539
 540       if (lookup_attribute ("no_icf", attributes) == NULL)
 541         attributes = tree_cons (get_identifier ("no_icf"),  NULL, attributes);
 542     }
 543
 544   targetm.insert_attributes (*node, &attributes);
 545
 546   /* Note that attributes on the same declaration are not necessarily
 547      in the same order as in the source.  */
 548   for (a = attributes; a; a = TREE_CHAIN (a))
 549     {
 550       tree ns = get_attribute_namespace (a);
 551       tree name = get_attribute_name (a);
 552       tree args = TREE_VALUE (a);
 553       tree *anode = node;
 554       const struct attribute_spec *spec
 555         = lookup_scoped_attribute_spec (ns, name);
 556       int fn_ptr_quals = 0;
 557       tree fn_ptr_tmp = NULL_TREE;
 558
 559       if (spec == NULL)
 560         {
 561           if (!(flags & (int) ATTR_FLAG_BUILT_IN))
 562             {
 563               if (ns == NULL_TREE || !cxx11_attribute_p (a))
 564                 warning (OPT_Wattributes, "%qE attribute directive ignored",
 565                          name);
 566               else
 567                 warning (OPT_Wattributes,
 568                          "%<%E::%E%> scoped attribute directive ignored",
 569                          ns, name);
 570             }
 571           continue;
 572         }
 573       else if (list_length (args) < spec->min_length
 574                || (spec->max_length >= 0
 575                    && list_length (args) > spec->max_length))
 576         {
 577           error ("wrong number of arguments specified for %qE attribute",
 578                  name);
 579           continue;
 580         }
 581       gcc_assert (is_attribute_p (spec->name, name));
 582
 583       if (TYPE_P (*node)
 584           && cxx11_attribute_p (a)
 585           && !(flags & ATTR_FLAG_TYPE_IN_PLACE))
 586         {
 587           /* This is a c++11 attribute that appertains to a
 588              type-specifier, outside of the definition of, a class
 589              type.  Ignore it.  */
 590           if (warning (OPT_Wattributes, "attribute ignored"))
 591             inform (input_location,
 592                     "an attribute that appertains to a type-specifier "
 593                     "is ignored");
 594           continue;
 595         }
 596
 597       if (spec->decl_required && !DECL_P (*anode))
 598         {
 599           if (flags & ((int) ATTR_FLAG_DECL_NEXT
 600                        | (int) ATTR_FLAG_FUNCTION_NEXT
 601                        | (int) ATTR_FLAG_ARRAY_NEXT))
 602             {
 603               /* Pass on this attribute to be tried again.  */
 604               tree attr = tree_cons (name, args, NULL_TREE);
 605               returned_attrs = chainon (returned_attrs, attr);
 606               continue;
 607             }
 608           else
 609             {
 610               warning (OPT_Wattributes, "%qE attribute does not apply to types",
 611                        name);
 612               continue;
 613             }
 614         }
 615
 616       /* If we require a type, but were passed a decl, set up to make a
 617          new type and update the one in the decl.  ATTR_FLAG_TYPE_IN_PLACE
 618          would have applied if we'd been passed a type, but we cannot modify
 619          the decl's type in place here.  */
 620       if (spec->type_required && DECL_P (*anode))
 621         {
 622           anode = &TREE_TYPE (*anode);
 623           flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
 624         }
 625
 626       if (spec->function_type_required && TREE_CODE (*anode) != FUNCTION_TYPE
 627           && TREE_CODE (*anode) != METHOD_TYPE)
 628         {
 629           if (TREE_CODE (*anode) == POINTER_TYPE
 630               && (TREE_CODE (TREE_TYPE (*anode)) == FUNCTION_TYPE
 631                   || TREE_CODE (TREE_TYPE (*anode)) == METHOD_TYPE))
 632             {
 633               /* OK, this is a bit convoluted.  We can't just make a copy
 634                  of the pointer type and modify its TREE_TYPE, because if
 635                  we change the attributes of the target type the pointer
 636                  type needs to have a different TYPE_MAIN_VARIANT.  So we
 637                  pull out the target type now, frob it as appropriate, and
 638                  rebuild the pointer type later.
 639
 640                  This would all be simpler if attributes were part of the
 641                  declarator, grumble grumble.  */
 642               fn_ptr_tmp = TREE_TYPE (*anode);
 643               fn_ptr_quals = TYPE_QUALS (*anode);
 644               anode = &fn_ptr_tmp;
 645               flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
 646             }
 647           else if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
 648             {
 649               /* Pass on this attribute to be tried again.  */
 650               tree attr = tree_cons (name, args, NULL_TREE);
 651               returned_attrs = chainon (returned_attrs, attr);
 652               continue;
 653             }
 654
 655           if (TREE_CODE (*anode) != FUNCTION_TYPE
 656               && TREE_CODE (*anode) != METHOD_TYPE)
 657             {
 658               warning (OPT_Wattributes,
 659                        "%qE attribute only applies to function types",
 660                        name);
 661               continue;
 662             }
 663         }
 664
 665       if (TYPE_P (*anode)
 666           && (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
 667           && TYPE_SIZE (*anode) != NULL_TREE)
 668         {
 669           warning (OPT_Wattributes, "type attributes ignored after type is already defined");
 670           continue;
 671         }
 672
 673       bool no_add_attrs = false;
 674
 675       if (spec->handler != NULL)
 676         {
 677           int cxx11_flag =
 678             cxx11_attribute_p (a) ? ATTR_FLAG_CXX11 : 0;
 679
 680           /* Pass in an array of the current declaration followed
 681              by the last pushed/merged declaration if  one exists.
 682              If the handler changes CUR_AND_LAST_DECL[0] replace
 683              *ANODE with its value.  */
 684           tree cur_and_last_decl[] = { *anode, last_decl };
 685           tree ret = (spec->handler) (cur_and_last_decl, name, args,
 686                                       flags|cxx11_flag, &no_add_attrs);
 687
 688           *anode = cur_and_last_decl[0];
 689           if (ret == error_mark_node)
 690             {
 691               warning (OPT_Wattributes, "%qE attribute ignored", name);
 692               no_add_attrs = true;
 693             }
 694           else
 695             returned_attrs = chainon (ret, returned_attrs);
 696         }
 697
 698       /* If the attribute was successfully handled on its own and is
 699          about to be added check for exclusions with other attributes
 700          on the current declation as well as the last declaration of
 701          the same symbol already processed (if one exists).  */
 702       bool built_in = flags & ATTR_FLAG_BUILT_IN;
 703       if (spec->exclude
 704           && !no_add_attrs
 705           && (flag_checking || !built_in))
 706         {
 707           /* Always check attributes on user-defined functions.
 708              Check them on built-ins only when -fchecking is set.
 709              Ignore __builtin_unreachable -- it's both const and
 710              noreturn.  */
 711
 712           if (!built_in
 713               || !DECL_P (*anode)
 714               || (DECL_FUNCTION_CODE (*anode) != BUILT_IN_UNREACHABLE
 715                   && (DECL_FUNCTION_CODE (*anode)
 716                       != BUILT_IN_UBSAN_HANDLE_BUILTIN_UNREACHABLE)))
 717             {
 718               bool no_add = diag_attr_exclusions (last_decl, *anode, name, spec);
 719               if (!no_add && anode != node)
 720                 no_add = diag_attr_exclusions (last_decl, *node, name, spec);
 721               no_add_attrs |= no_add;
 722             }
 723         }
 724
 725       /* Layout the decl in case anything changed.  */
 726       if (spec->type_required && DECL_P (*node)
 727           && (VAR_P (*node)
 728               || TREE_CODE (*node) == PARM_DECL
 729               || TREE_CODE (*node) == RESULT_DECL))
 730         relayout_decl (*node);
 731
 732       if (!no_add_attrs)
 733         {
 734           tree old_attrs;
 735           tree a;
 736
 737           if (DECL_P (*anode))
 738             old_attrs = DECL_ATTRIBUTES (*anode);
 739           else
 740             old_attrs = TYPE_ATTRIBUTES (*anode);
 741
 742           for (a = lookup_attribute (spec->name, old_attrs);
 743                a != NULL_TREE;
 744                a = lookup_attribute (spec->name, TREE_CHAIN (a)))
 745             {
 746               if (simple_cst_equal (TREE_VALUE (a), args) == 1)
 747                 break;
 748             }
 749
 750           if (a == NULL_TREE)
 751             {
 752               /* This attribute isn't already in the list.  */
 753               if (DECL_P (*anode))
 754                 DECL_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
 755               else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
 756                 {
 757                   TYPE_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
 758                   /* If this is the main variant, also push the attributes
 759                      out to the other variants.  */
 760                   if (*anode == TYPE_MAIN_VARIANT (*anode))
 761                     {
 762                       tree variant;
 763                       for (variant = *anode; variant;
 764                            variant = TYPE_NEXT_VARIANT (variant))
 765                         {
 766                           if (TYPE_ATTRIBUTES (variant) == old_attrs)
 767                             TYPE_ATTRIBUTES (variant)
 768                               = TYPE_ATTRIBUTES (*anode);
 769                           else if (!lookup_attribute
 770                                    (spec->name, TYPE_ATTRIBUTES (variant)))
 771                             TYPE_ATTRIBUTES (variant) = tree_cons
 772                               (name, args, TYPE_ATTRIBUTES (variant));
 773                         }
 774                     }
 775                 }
 776               else
 777                 *anode = build_type_attribute_variant (*anode,
 778                                                        tree_cons (name, args,
 779                                                                   old_attrs));
 780             }
 781         }
 782
 783       if (fn_ptr_tmp)
 784         {
 785           /* Rebuild the function pointer type and put it in the
 786              appropriate place.  */
 787           fn_ptr_tmp = build_pointer_type (fn_ptr_tmp);
 788           if (fn_ptr_quals)
 789             fn_ptr_tmp = build_qualified_type (fn_ptr_tmp, fn_ptr_quals);
 790           if (DECL_P (*node))
 791             TREE_TYPE (*node) = fn_ptr_tmp;
 792           else
 793             {
 794               gcc_assert (TREE_CODE (*node) == POINTER_TYPE);
 795               *node = fn_ptr_tmp;
 796             }
 797         }
 798     }
 799
 800   return returned_attrs;
 801 }
 802
 803 /* Return TRUE iff ATTR has been parsed by the front-end as a C++-11
 804    attribute.
 805
 806    When G++ parses a C++11 attribute, it is represented as
 807    a TREE_LIST which TREE_PURPOSE is itself a TREE_LIST.  TREE_PURPOSE
 808    (TREE_PURPOSE (ATTR)) is the namespace of the attribute, and the
 809    TREE_VALUE (TREE_PURPOSE (ATTR)) is its non-qualified name.  Please
 810    use get_attribute_namespace and get_attribute_name to retrieve the
 811    namespace and name of the attribute, as these accessors work with
 812    GNU attributes as well.  */
 813
 814 bool
 815 cxx11_attribute_p (const_tree attr)
 816 {
 817   if (attr == NULL_TREE
 818       || TREE_CODE (attr) != TREE_LIST)
 819     return false;
 820
 821   return (TREE_CODE (TREE_PURPOSE (attr)) == TREE_LIST);
 822 }
 823
 824 /* Return the name of the attribute ATTR.  This accessor works on GNU
 825    and C++11 (scoped) attributes.
 826
 827    Please read the comments of cxx11_attribute_p to understand the
 828    format of attributes.  */
 829
 830 tree
 831 get_attribute_name (const_tree attr)
 832 {
 833   if (cxx11_attribute_p (attr))
 834     return TREE_VALUE (TREE_PURPOSE (attr));
 835   return TREE_PURPOSE (attr);
 836 }
 837
 838 /* Subroutine of set_method_tm_attributes.  Apply TM attribute ATTR
 839    to the method FNDECL.  */
 840
 841 void
 842 apply_tm_attr (tree fndecl, tree attr)
 843 {
 844   decl_attributes (&TREE_TYPE (fndecl), tree_cons (attr, NULL, NULL), 0);
 845 }
 846
 847 /* Makes a function attribute of the form NAME(ARG_NAME) and chains
 848    it to CHAIN.  */
 849
 850 tree
 851 make_attribute (const char *name, const char *arg_name, tree chain)
 852 {
 853   tree attr_name;
 854   tree attr_arg_name;
 855   tree attr_args;
 856   tree attr;
 857
 858   attr_name = get_identifier (name);
 859   attr_arg_name = build_string (strlen (arg_name), arg_name);
 860   attr_args = tree_cons (NULL_TREE, attr_arg_name, NULL_TREE);
 861   attr = tree_cons (attr_name, attr_args, chain);
 862   return attr;
 863 }
 864
 865 \f
 866 /* Common functions used for target clone support.  */
 867
 868 /* Comparator function to be used in qsort routine to sort attribute
 869    specification strings to "target".  */
 870
 871 static int
 872 attr_strcmp (const void *v1, const void *v2)
 873 {
 874   const char *c1 = *(char *const*)v1;
 875   const char *c2 = *(char *const*)v2;
 876   return strcmp (c1, c2);
 877 }
 878
 879 /* ARGLIST is the argument to target attribute.  This function tokenizes
 880    the comma separated arguments, sorts them and returns a string which
 881    is a unique identifier for the comma separated arguments.   It also
 882    replaces non-identifier characters "=,-" with "_".  */
 883
 884 char *
 885 sorted_attr_string (tree arglist)
 886 {
 887   tree arg;
 888   size_t str_len_sum = 0;
 889   char **args = NULL;
 890   char *attr_str, *ret_str;
 891   char *attr = NULL;
 892   unsigned int argnum = 1;
 893   unsigned int i;
 894
 895   for (arg = arglist; arg; arg = TREE_CHAIN (arg))
 896     {
 897       const char *str = TREE_STRING_POINTER (TREE_VALUE (arg));
 898       size_t len = strlen (str);
 899       str_len_sum += len + 1;
 900       if (arg != arglist)
 901         argnum++;
 902       for (i = 0; i < strlen (str); i++)
 903         if (str[i] == ',')
 904           argnum++;
 905     }
 906
 907   attr_str = XNEWVEC (char, str_len_sum);
 908   str_len_sum = 0;
 909   for (arg = arglist; arg; arg = TREE_CHAIN (arg))
 910     {
 911       const char *str = TREE_STRING_POINTER (TREE_VALUE (arg));
 912       size_t len = strlen (str);
 913       memcpy (attr_str + str_len_sum, str, len);
 914       attr_str[str_len_sum + len] = TREE_CHAIN (arg) ? ',' : '\0';
 915       str_len_sum += len + 1;
 916     }
 917
 918   /* Replace "=,-" with "_".  */
 919   for (i = 0; i < strlen (attr_str); i++)
 920     if (attr_str[i] == '=' || attr_str[i]== '-')
 921       attr_str[i] = '_';
 922
 923   if (argnum == 1)
 924     return attr_str;
 925
 926   args = XNEWVEC (char *, argnum);
 927
 928   i = 0;
 929   attr = strtok (attr_str, ",");
 930   while (attr != NULL)
 931     {
 932       args[i] = attr;
 933       i++;
 934       attr = strtok (NULL, ",");
 935     }
 936
 937   qsort (args, argnum, sizeof (char *), attr_strcmp);
 938
 939   ret_str = XNEWVEC (char, str_len_sum);
 940   str_len_sum = 0;
 941   for (i = 0; i < argnum; i++)
 942     {
 943       size_t len = strlen (args[i]);
 944       memcpy (ret_str + str_len_sum, args[i], len);
 945       ret_str[str_len_sum + len] = i < argnum - 1 ? '_' : '\0';
 946       str_len_sum += len + 1;
 947     }
 948
 949   XDELETEVEC (args);
 950   XDELETEVEC (attr_str);
 951   return ret_str;
 952 }
 953
 954
 955 /* This function returns true if FN1 and FN2 are versions of the same function,
 956    that is, the target strings of the function decls are different.  This assumes
 957    that FN1 and FN2 have the same signature.  */
 958
 959 bool
 960 common_function_versions (tree fn1, tree fn2)
 961 {
 962   tree attr1, attr2;
 963   char *target1, *target2;
 964   bool result;
 965
 966   if (TREE_CODE (fn1) != FUNCTION_DECL
 967       || TREE_CODE (fn2) != FUNCTION_DECL)
 968     return false;
 969
 970   attr1 = lookup_attribute ("target", DECL_ATTRIBUTES (fn1));
 971   attr2 = lookup_attribute ("target", DECL_ATTRIBUTES (fn2));
 972
 973   /* At least one function decl should have the target attribute specified.  */
 974   if (attr1 == NULL_TREE && attr2 == NULL_TREE)
 975     return false;
 976
 977   /* Diagnose missing target attribute if one of the decls is already
 978      multi-versioned.  */
 979   if (attr1 == NULL_TREE || attr2 == NULL_TREE)
 980     {
 981       if (DECL_FUNCTION_VERSIONED (fn1) || DECL_FUNCTION_VERSIONED (fn2))
 982         {
 983           if (attr2 != NULL_TREE)
 984             {
 985               std::swap (fn1, fn2);
 986               attr1 = attr2;
 987             }
 988           error_at (DECL_SOURCE_LOCATION (fn2),
 989                     "missing %<target%> attribute for multi-versioned %qD",
 990                     fn2);
 991           inform (DECL_SOURCE_LOCATION (fn1),
 992                   "previous declaration of %qD", fn1);
 993           /* Prevent diagnosing of the same error multiple times.  */
 994           DECL_ATTRIBUTES (fn2)
 995             = tree_cons (get_identifier ("target"),
 996                          copy_node (TREE_VALUE (attr1)),
 997                          DECL_ATTRIBUTES (fn2));
 998         }
 999       return false;
1000     }
1001
1002   target1 = sorted_attr_string (TREE_VALUE (attr1));
1003   target2 = sorted_attr_string (TREE_VALUE (attr2));
1004
1005   /* The sorted target strings must be different for fn1 and fn2
1006      to be versions.  */
1007   if (strcmp (target1, target2) == 0)
1008     result = false;
1009   else
1010     result = true;
1011
1012   XDELETEVEC (target1);
1013   XDELETEVEC (target2);
1014
1015   return result;
1016 }
1017
1018 /* Return a new name by appending SUFFIX to the DECL name.  If make_unique
1019    is true, append the full path name of the source file.  */
1020
1021 char *
1022 make_unique_name (tree decl, const char *suffix, bool make_unique)
1023 {
1024   char *global_var_name;
1025   int name_len;
1026   const char *name;
1027   const char *unique_name = NULL;
1028
1029   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1030
1031   /* Get a unique name that can be used globally without any chances
1032      of collision at link time.  */
1033   if (make_unique)
1034     unique_name = IDENTIFIER_POINTER (get_file_function_name ("\0"));
1035
1036   name_len = strlen (name) + strlen (suffix) + 2;
1037
1038   if (make_unique)
1039     name_len += strlen (unique_name) + 1;
1040   global_var_name = XNEWVEC (char, name_len);
1041
1042   /* Use '.' to concatenate names as it is demangler friendly.  */
1043   if (make_unique)
1044     snprintf (global_var_name, name_len, "%s.%s.%s", name, unique_name,
1045               suffix);
1046   else
1047     snprintf (global_var_name, name_len, "%s.%s", name, suffix);
1048
1049   return global_var_name;
1050 }
1051
1052 /* Make a dispatcher declaration for the multi-versioned function DECL.
1053    Calls to DECL function will be replaced with calls to the dispatcher
1054    by the front-end.  Return the decl created.  */
1055
1056 tree
1057 make_dispatcher_decl (const tree decl)
1058 {
1059   tree func_decl;
1060   char *func_name;
1061   tree fn_type, func_type;
1062
1063   func_name = xstrdup (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
1064
1065   fn_type = TREE_TYPE (decl);
1066   func_type = build_function_type (TREE_TYPE (fn_type),
1067                                    TYPE_ARG_TYPES (fn_type));
1068
1069   func_decl = build_fn_decl (func_name, func_type);
1070   XDELETEVEC (func_name);
1071   TREE_USED (func_decl) = 1;
1072   DECL_CONTEXT (func_decl) = NULL_TREE;
1073   DECL_INITIAL (func_decl) = error_mark_node;
1074   DECL_ARTIFICIAL (func_decl) = 1;
1075   /* Mark this func as external, the resolver will flip it again if
1076      it gets generated.  */
1077   DECL_EXTERNAL (func_decl) = 1;
1078   /* This will be of type IFUNCs have to be externally visible.  */
1079   TREE_PUBLIC (func_decl) = 1;
1080
1081   return func_decl;
1082 }
1083
1084 /* Returns true if decl is multi-versioned and DECL is the default function,
1085    that is it is not tagged with target specific optimization.  */
1086
1087 bool
1088 is_function_default_version (const tree decl)
1089 {
1090   if (TREE_CODE (decl) != FUNCTION_DECL
1091       || !DECL_FUNCTION_VERSIONED (decl))
1092     return false;
1093   tree attr = lookup_attribute ("target", DECL_ATTRIBUTES (decl));
1094   gcc_assert (attr);
1095   attr = TREE_VALUE (TREE_VALUE (attr));
1096   return (TREE_CODE (attr) == STRING_CST
1097           && strcmp (TREE_STRING_POINTER (attr), "default") == 0);
1098 }
1099
1100 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
1101    is ATTRIBUTE.  */
1102
1103 tree
1104 build_decl_attribute_variant (tree ddecl, tree attribute)
1105 {
1106   DECL_ATTRIBUTES (ddecl) = attribute;
1107   return ddecl;
1108 }
1109
1110 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
1111    is ATTRIBUTE and its qualifiers are QUALS.
1112
1113    Record such modified types already made so we don't make duplicates.  */
1114
1115 tree
1116 build_type_attribute_qual_variant (tree otype, tree attribute, int quals)
1117 {
1118   tree ttype = otype;
1119   if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
1120     {
1121       tree ntype;
1122
1123       /* Building a distinct copy of a tagged type is inappropriate; it
1124          causes breakage in code that expects there to be a one-to-one
1125          relationship between a struct and its fields.
1126          build_duplicate_type is another solution (as used in
1127          handle_transparent_union_attribute), but that doesn't play well
1128          with the stronger C++ type identity model.  */
1129       if (TREE_CODE (ttype) == RECORD_TYPE
1130           || TREE_CODE (ttype) == UNION_TYPE
1131           || TREE_CODE (ttype) == QUAL_UNION_TYPE
1132           || TREE_CODE (ttype) == ENUMERAL_TYPE)
1133         {
1134           warning (OPT_Wattributes,
1135                    "ignoring attributes applied to %qT after definition",
1136                    TYPE_MAIN_VARIANT (ttype));
1137           return build_qualified_type (ttype, quals);
1138         }
1139
1140       ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
1141       if (lang_hooks.types.copy_lang_qualifiers
1142           && otype != TYPE_MAIN_VARIANT (otype))
1143         ttype = (lang_hooks.types.copy_lang_qualifiers
1144                  (ttype, TYPE_MAIN_VARIANT (otype)));
1145
1146       tree dtype = ntype = build_distinct_type_copy (ttype);
1147
1148       TYPE_ATTRIBUTES (ntype) = attribute;
1149
1150       hashval_t hash = type_hash_canon_hash (ntype);
1151       ntype = type_hash_canon (hash, ntype);
1152
1153       if (ntype != dtype)
1154         /* This variant was already in the hash table, don't mess with
1155            TYPE_CANONICAL.  */;
1156       else if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
1157                || !comp_type_attributes (ntype, ttype))
1158         /* If the target-dependent attributes make NTYPE different from
1159            its canonical type, we will need to use structural equality
1160            checks for this type.
1161
1162            We shouldn't get here for stripping attributes from a type;
1163            the no-attribute type might not need structural comparison.  But
1164            we can if was discarded from type_hash_table.  */
1165         SET_TYPE_STRUCTURAL_EQUALITY (ntype);
1166       else if (TYPE_CANONICAL (ntype) == ntype)
1167         TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
1168
1169       ttype = build_qualified_type (ntype, quals);
1170       if (lang_hooks.types.copy_lang_qualifiers
1171           && otype != TYPE_MAIN_VARIANT (otype))
1172         ttype = lang_hooks.types.copy_lang_qualifiers (ttype, otype);
1173     }
1174   else if (TYPE_QUALS (ttype) != quals)
1175     ttype = build_qualified_type (ttype, quals);
1176
1177   return ttype;
1178 }
1179
1180 /* Compare two identifier nodes representing attributes.
1181    Return true if they are the same, false otherwise.  */
1182
1183 static bool
1184 cmp_attrib_identifiers (const_tree attr1, const_tree attr2)
1185 {
1186   /* Make sure we're dealing with IDENTIFIER_NODEs.  */
1187   gcc_checking_assert (TREE_CODE (attr1) == IDENTIFIER_NODE
1188                        && TREE_CODE (attr2) == IDENTIFIER_NODE);
1189
1190   /* Identifiers can be compared directly for equality.  */
1191   if (attr1 == attr2)
1192     return true;
1193
1194   return cmp_attribs (IDENTIFIER_POINTER (attr1), IDENTIFIER_LENGTH (attr1),
1195                       IDENTIFIER_POINTER (attr2), IDENTIFIER_LENGTH (attr2));
1196 }
1197
1198 /* Compare two constructor-element-type constants.  Return 1 if the lists
1199    are known to be equal; otherwise return 0.  */
1200
1201 static bool
1202 simple_cst_list_equal (const_tree l1, const_tree l2)
1203 {
1204   while (l1 != NULL_TREE && l2 != NULL_TREE)
1205     {
1206       if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
1207         return false;
1208
1209       l1 = TREE_CHAIN (l1);
1210       l2 = TREE_CHAIN (l2);
1211     }
1212
1213   return l1 == l2;
1214 }
1215
1216 /* Check if "omp declare simd" attribute arguments, CLAUSES1 and CLAUSES2, are
1217    the same.  */
1218
1219 static bool
1220 omp_declare_simd_clauses_equal (tree clauses1, tree clauses2)
1221 {
1222   tree cl1, cl2;
1223   for (cl1 = clauses1, cl2 = clauses2;
1224        cl1 && cl2;
1225        cl1 = OMP_CLAUSE_CHAIN (cl1), cl2 = OMP_CLAUSE_CHAIN (cl2))
1226     {
1227       if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_CODE (cl2))
1228         return false;
1229       if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_SIMDLEN)
1230         {
1231           if (simple_cst_equal (OMP_CLAUSE_DECL (cl1),
1232                                 OMP_CLAUSE_DECL (cl2)) != 1)
1233             return false;
1234         }
1235       switch (OMP_CLAUSE_CODE (cl1))
1236         {
1237         case OMP_CLAUSE_ALIGNED:
1238           if (simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (cl1),
1239                                 OMP_CLAUSE_ALIGNED_ALIGNMENT (cl2)) != 1)
1240             return false;
1241           break;
1242         case OMP_CLAUSE_LINEAR:
1243           if (simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (cl1),
1244                                 OMP_CLAUSE_LINEAR_STEP (cl2)) != 1)
1245             return false;
1246           break;
1247         case OMP_CLAUSE_SIMDLEN:
1248           if (simple_cst_equal (OMP_CLAUSE_SIMDLEN_EXPR (cl1),
1249                                 OMP_CLAUSE_SIMDLEN_EXPR (cl2)) != 1)
1250             return false;
1251         default:
1252           break;
1253         }
1254     }
1255   return true;
1256 }
1257
1258
1259 /* Compare two attributes for their value identity.  Return true if the
1260    attribute values are known to be equal; otherwise return false.  */
1261
1262 bool
1263 attribute_value_equal (const_tree attr1, const_tree attr2)
1264 {
1265   if (TREE_VALUE (attr1) == TREE_VALUE (attr2))
1266     return true;
1267
1268   if (TREE_VALUE (attr1) != NULL_TREE
1269       && TREE_CODE (TREE_VALUE (attr1)) == TREE_LIST
1270       && TREE_VALUE (attr2) != NULL_TREE
1271       && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST)
1272     {
1273       /* Handle attribute format.  */
1274       if (is_attribute_p ("format", get_attribute_name (attr1)))
1275         {
1276           attr1 = TREE_VALUE (attr1);
1277           attr2 = TREE_VALUE (attr2);
1278           /* Compare the archetypes (printf/scanf/strftime/...).  */
1279           if (!cmp_attrib_identifiers (TREE_VALUE (attr1), TREE_VALUE (attr2)))
1280             return false;
1281           /* Archetypes are the same.  Compare the rest.  */
1282           return (simple_cst_list_equal (TREE_CHAIN (attr1),
1283                                          TREE_CHAIN (attr2)) == 1);
1284         }
1285       return (simple_cst_list_equal (TREE_VALUE (attr1),
1286                                      TREE_VALUE (attr2)) == 1);
1287     }
1288
1289   if (TREE_VALUE (attr1)
1290       && TREE_CODE (TREE_VALUE (attr1)) == OMP_CLAUSE
1291       && TREE_VALUE (attr2)
1292       && TREE_CODE (TREE_VALUE (attr2)) == OMP_CLAUSE)
1293     return omp_declare_simd_clauses_equal (TREE_VALUE (attr1),
1294                                            TREE_VALUE (attr2));
1295
1296   return (simple_cst_equal (TREE_VALUE (attr1), TREE_VALUE (attr2)) == 1);
1297 }
1298
1299 /* Return 0 if the attributes for two types are incompatible, 1 if they
1300    are compatible, and 2 if they are nearly compatible (which causes a
1301    warning to be generated).  */
1302 int
1303 comp_type_attributes (const_tree type1, const_tree type2)
1304 {
1305   const_tree a1 = TYPE_ATTRIBUTES (type1);
1306   const_tree a2 = TYPE_ATTRIBUTES (type2);
1307   const_tree a;
1308
1309   if (a1 == a2)
1310     return 1;
1311   for (a = a1; a != NULL_TREE; a = TREE_CHAIN (a))
1312     {
1313       const struct attribute_spec *as;
1314       const_tree attr;
1315
1316       as = lookup_attribute_spec (get_attribute_name (a));
1317       if (!as || as->affects_type_identity == false)
1318         continue;
1319
1320       attr = lookup_attribute (as->name, CONST_CAST_TREE (a2));
1321       if (!attr || !attribute_value_equal (a, attr))
1322         break;
1323     }
1324   if (!a)
1325     {
1326       for (a = a2; a != NULL_TREE; a = TREE_CHAIN (a))
1327         {
1328           const struct attribute_spec *as;
1329
1330           as = lookup_attribute_spec (get_attribute_name (a));
1331           if (!as || as->affects_type_identity == false)
1332             continue;
1333
1334           if (!lookup_attribute (as->name, CONST_CAST_TREE (a1)))
1335             break;
1336           /* We don't need to compare trees again, as we did this
1337              already in first loop.  */
1338         }
1339       /* All types - affecting identity - are equal, so
1340          there is no need to call target hook for comparison.  */
1341       if (!a)
1342         return 1;
1343     }
1344   if (lookup_attribute ("transaction_safe", CONST_CAST_TREE (a)))
1345     return 0;
1346   if ((lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (type1)) != NULL)
1347       ^ (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (type2)) != NULL))
1348     return 0;
1349   /* As some type combinations - like default calling-convention - might
1350      be compatible, we have to call the target hook to get the final result.  */
1351   return targetm.comp_type_attributes (type1, type2);
1352 }
1353
1354 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
1355    is ATTRIBUTE.
1356
1357    Record such modified types already made so we don't make duplicates.  */
1358
1359 tree
1360 build_type_attribute_variant (tree ttype, tree attribute)
1361 {
1362   return build_type_attribute_qual_variant (ttype, attribute,
1363                                             TYPE_QUALS (ttype));
1364 }
1365 \f
1366 /* A variant of lookup_attribute() that can be used with an identifier
1367    as the first argument, and where the identifier can be either
1368    'text' or '__text__'.
1369
1370    Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
1371    return a pointer to the attribute's list element if the attribute
1372    is part of the list, or NULL_TREE if not found.  If the attribute
1373    appears more than once, this only returns the first occurrence; the
1374    TREE_CHAIN of the return value should be passed back in if further
1375    occurrences are wanted.  ATTR_IDENTIFIER must be an identifier but
1376    can be in the form 'text' or '__text__'.  */
1377 static tree
1378 lookup_ident_attribute (tree attr_identifier, tree list)
1379 {
1380   gcc_checking_assert (TREE_CODE (attr_identifier) == IDENTIFIER_NODE);
1381
1382   while (list)
1383     {
1384       gcc_checking_assert (TREE_CODE (get_attribute_name (list))
1385                            == IDENTIFIER_NODE);
1386
1387       if (cmp_attrib_identifiers (attr_identifier,
1388                                   get_attribute_name (list)))
1389         /* Found it.  */
1390         break;
1391       list = TREE_CHAIN (list);
1392     }
1393
1394   return list;
1395 }
1396
1397 /* Remove any instances of attribute ATTR_NAME in LIST and return the
1398    modified list.  */
1399
1400 tree
1401 remove_attribute (const char *attr_name, tree list)
1402 {
1403   tree *p;
1404   gcc_checking_assert (attr_name[0] != '_');
1405
1406   for (p = &list; *p;)
1407     {
1408       tree l = *p;
1409
1410       tree attr = get_attribute_name (l);
1411       if (is_attribute_p (attr_name, attr))
1412         *p = TREE_CHAIN (l);
1413       else
1414         p = &TREE_CHAIN (l);
1415     }
1416
1417   return list;
1418 }
1419
1420 /* Return an attribute list that is the union of a1 and a2.  */
1421
1422 tree
1423 merge_attributes (tree a1, tree a2)
1424 {
1425   tree attributes;
1426
1427   /* Either one unset?  Take the set one.  */
1428
1429   if ((attributes = a1) == 0)
1430     attributes = a2;
1431
1432   /* One that completely contains the other?  Take it.  */
1433
1434   else if (a2 != 0 && ! attribute_list_contained (a1, a2))
1435     {
1436       if (attribute_list_contained (a2, a1))
1437         attributes = a2;
1438       else
1439         {
1440           /* Pick the longest list, and hang on the other list.  */
1441
1442           if (list_length (a1) < list_length (a2))
1443             attributes = a2, a2 = a1;
1444
1445           for (; a2 != 0; a2 = TREE_CHAIN (a2))
1446             {
1447               tree a;
1448               for (a = lookup_ident_attribute (get_attribute_name (a2),
1449                                                attributes);
1450                    a != NULL_TREE && !attribute_value_equal (a, a2);
1451                    a = lookup_ident_attribute (get_attribute_name (a2),
1452                                                TREE_CHAIN (a)))
1453                 ;
1454               if (a == NULL_TREE)
1455                 {
1456                   a1 = copy_node (a2);
1457                   TREE_CHAIN (a1) = attributes;
1458                   attributes = a1;
1459                 }
1460             }
1461         }
1462     }
1463   return attributes;
1464 }
1465
1466 /* Given types T1 and T2, merge their attributes and return
1467   the result.  */
1468
1469 tree
1470 merge_type_attributes (tree t1, tree t2)
1471 {
1472   return merge_attributes (TYPE_ATTRIBUTES (t1),
1473                            TYPE_ATTRIBUTES (t2));
1474 }
1475
1476 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
1477    the result.  */
1478
1479 tree
1480 merge_decl_attributes (tree olddecl, tree newdecl)
1481 {
1482   return merge_attributes (DECL_ATTRIBUTES (olddecl),
1483                            DECL_ATTRIBUTES (newdecl));
1484 }
1485
1486 /* Duplicate all attributes with name NAME in ATTR list to *ATTRS if
1487    they are missing there.  */
1488
1489 void
1490 duplicate_one_attribute (tree *attrs, tree attr, const char *name)
1491 {
1492   attr = lookup_attribute (name, attr);
1493   if (!attr)
1494     return;
1495   tree a = lookup_attribute (name, *attrs);
1496   while (attr)
1497     {
1498       tree a2;
1499       for (a2 = a; a2; a2 = lookup_attribute (name, TREE_CHAIN (a2)))
1500         if (attribute_value_equal (attr, a2))
1501           break;
1502       if (!a2)
1503         {
1504           a2 = copy_node (attr);
1505           TREE_CHAIN (a2) = *attrs;
1506           *attrs = a2;
1507         }
1508       attr = lookup_attribute (name, TREE_CHAIN (attr));
1509     }
1510 }
1511
1512 /* Duplicate all attributes from user DECL to the corresponding
1513    builtin that should be propagated.  */
1514
1515 void
1516 copy_attributes_to_builtin (tree decl)
1517 {
1518   tree b = builtin_decl_explicit (DECL_FUNCTION_CODE (decl));
1519   if (b)
1520     duplicate_one_attribute (&DECL_ATTRIBUTES (b),
1521                              DECL_ATTRIBUTES (decl), "omp declare simd");
1522 }
1523
1524 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
1525
1526 /* Specialization of merge_decl_attributes for various Windows targets.
1527
1528    This handles the following situation:
1529
1530      __declspec (dllimport) int foo;
1531      int foo;
1532
1533    The second instance of `foo' nullifies the dllimport.  */
1534
1535 tree
1536 merge_dllimport_decl_attributes (tree old, tree new_tree)
1537 {
1538   tree a;
1539   int delete_dllimport_p = 1;
1540
1541   /* What we need to do here is remove from `old' dllimport if it doesn't
1542      appear in `new'.  dllimport behaves like extern: if a declaration is
1543      marked dllimport and a definition appears later, then the object
1544      is not dllimport'd.  We also remove a `new' dllimport if the old list
1545      contains dllexport:  dllexport always overrides dllimport, regardless
1546      of the order of declaration.  */
1547   if (!VAR_OR_FUNCTION_DECL_P (new_tree))
1548     delete_dllimport_p = 0;
1549   else if (DECL_DLLIMPORT_P (new_tree)
1550            && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
1551     {
1552       DECL_DLLIMPORT_P (new_tree) = 0;
1553       warning (OPT_Wattributes, "%q+D already declared with dllexport "
1554                "attribute: dllimport ignored", new_tree);
1555     }
1556   else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
1557     {
1558       /* Warn about overriding a symbol that has already been used, e.g.:
1559            extern int __attribute__ ((dllimport)) foo;
1560            int* bar () {return &foo;}
1561            int foo;
1562       */
1563       if (TREE_USED (old))
1564         {
1565           warning (0, "%q+D redeclared without dllimport attribute "
1566                    "after being referenced with dll linkage", new_tree);
1567           /* If we have used a variable's address with dllimport linkage,
1568               keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
1569               decl may already have had TREE_CONSTANT computed.
1570               We still remove the attribute so that assembler code refers
1571               to '&foo rather than '_imp__foo'.  */
1572           if (VAR_P (old) && TREE_ADDRESSABLE (old))
1573             DECL_DLLIMPORT_P (new_tree) = 1;
1574         }
1575
1576       /* Let an inline definition silently override the external reference,
1577          but otherwise warn about attribute inconsistency.  */
1578       else if (VAR_P (new_tree) || !DECL_DECLARED_INLINE_P (new_tree))
1579         warning (OPT_Wattributes, "%q+D redeclared without dllimport "
1580                  "attribute: previous dllimport ignored", new_tree);
1581     }
1582   else
1583     delete_dllimport_p = 0;
1584
1585   a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
1586
1587   if (delete_dllimport_p)
1588     a = remove_attribute ("dllimport", a);
1589
1590   return a;
1591 }
1592
1593 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
1594    struct attribute_spec.handler.  */
1595
1596 tree
1597 handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
1598                       bool *no_add_attrs)
1599 {
1600   tree node = *pnode;
1601   bool is_dllimport;
1602
1603   /* These attributes may apply to structure and union types being created,
1604      but otherwise should pass to the declaration involved.  */
1605   if (!DECL_P (node))
1606     {
1607       if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
1608                    | (int) ATTR_FLAG_ARRAY_NEXT))
1609         {
1610           *no_add_attrs = true;
1611           return tree_cons (name, args, NULL_TREE);
1612         }
1613       if (TREE_CODE (node) == RECORD_TYPE
1614           || TREE_CODE (node) == UNION_TYPE)
1615         {
1616           node = TYPE_NAME (node);
1617           if (!node)
1618             return NULL_TREE;
1619         }
1620       else
1621         {
1622           warning (OPT_Wattributes, "%qE attribute ignored",
1623                    name);
1624           *no_add_attrs = true;
1625           return NULL_TREE;
1626         }
1627     }
1628
1629   if (!VAR_OR_FUNCTION_DECL_P (node) && TREE_CODE (node) != TYPE_DECL)
1630     {
1631       *no_add_attrs = true;
1632       warning (OPT_Wattributes, "%qE attribute ignored",
1633                name);
1634       return NULL_TREE;
1635     }
1636
1637   if (TREE_CODE (node) == TYPE_DECL
1638       && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
1639       && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
1640     {
1641       *no_add_attrs = true;
1642       warning (OPT_Wattributes, "%qE attribute ignored",
1643                name);
1644       return NULL_TREE;
1645     }
1646
1647   is_dllimport = is_attribute_p ("dllimport", name);
1648
1649   /* Report error on dllimport ambiguities seen now before they cause
1650      any damage.  */
1651   if (is_dllimport)
1652     {
1653       /* Honor any target-specific overrides.  */
1654       if (!targetm.valid_dllimport_attribute_p (node))
1655         *no_add_attrs = true;
1656
1657      else if (TREE_CODE (node) == FUNCTION_DECL
1658               && DECL_DECLARED_INLINE_P (node))
1659         {
1660           warning (OPT_Wattributes, "inline function %q+D declared as "
1661                   " dllimport: attribute ignored", node);
1662           *no_add_attrs = true;
1663         }
1664       /* Like MS, treat definition of dllimported variables and
1665          non-inlined functions on declaration as syntax errors.  */
1666      else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
1667         {
1668           error ("function %q+D definition is marked dllimport", node);
1669           *no_add_attrs = true;
1670         }
1671
1672      else if (VAR_P (node))
1673         {
1674           if (DECL_INITIAL (node))
1675             {
1676               error ("variable %q+D definition is marked dllimport",
1677                      node);
1678               *no_add_attrs = true;
1679             }
1680
1681           /* `extern' needn't be specified with dllimport.
1682              Specify `extern' now and hope for the best.  Sigh.  */
1683           DECL_EXTERNAL (node) = 1;
1684           /* Also, implicitly give dllimport'd variables declared within
1685              a function global scope, unless declared static.  */
1686           if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
1687             TREE_PUBLIC (node) = 1;
1688         }
1689
1690       if (*no_add_attrs == false)
1691         DECL_DLLIMPORT_P (node) = 1;
1692     }
1693   else if (TREE_CODE (node) == FUNCTION_DECL
1694            && DECL_DECLARED_INLINE_P (node)
1695            && flag_keep_inline_dllexport)
1696     /* An exported function, even if inline, must be emitted.  */
1697     DECL_EXTERNAL (node) = 0;
1698
1699   /*  Report error if symbol is not accessible at global scope.  */
1700   if (!TREE_PUBLIC (node) && VAR_OR_FUNCTION_DECL_P (node))
1701     {
1702       error ("external linkage required for symbol %q+D because of "
1703              "%qE attribute", node, name);
1704       *no_add_attrs = true;
1705     }
1706
1707   /* A dllexport'd entity must have default visibility so that other
1708      program units (shared libraries or the main executable) can see
1709      it.  A dllimport'd entity must have default visibility so that
1710      the linker knows that undefined references within this program
1711      unit can be resolved by the dynamic linker.  */
1712   if (!*no_add_attrs)
1713     {
1714       if (DECL_VISIBILITY_SPECIFIED (node)
1715           && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
1716         error ("%qE implies default visibility, but %qD has already "
1717                "been declared with a different visibility",
1718                name, node);
1719       DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
1720       DECL_VISIBILITY_SPECIFIED (node) = 1;
1721     }
1722
1723   return NULL_TREE;
1724 }
1725
1726 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES  */
1727
1728 /* Given two lists of attributes, return true if list l2 is
1729    equivalent to l1.  */
1730
1731 int
1732 attribute_list_equal (const_tree l1, const_tree l2)
1733 {
1734   if (l1 == l2)
1735     return 1;
1736
1737   return attribute_list_contained (l1, l2)
1738          && attribute_list_contained (l2, l1);
1739 }
1740
1741 /* Given two lists of attributes, return true if list L2 is
1742    completely contained within L1.  */
1743 /* ??? This would be faster if attribute names were stored in a canonicalized
1744    form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
1745    must be used to show these elements are equivalent (which they are).  */
1746 /* ??? It's not clear that attributes with arguments will always be handled
1747    correctly.  */
1748
1749 int
1750 attribute_list_contained (const_tree l1, const_tree l2)
1751 {
1752   const_tree t1, t2;
1753
1754   /* First check the obvious, maybe the lists are identical.  */
1755   if (l1 == l2)
1756     return 1;
1757
1758   /* Maybe the lists are similar.  */
1759   for (t1 = l1, t2 = l2;
1760        t1 != 0 && t2 != 0
1761        && get_attribute_name (t1) == get_attribute_name (t2)
1762        && TREE_VALUE (t1) == TREE_VALUE (t2);
1763        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1764     ;
1765
1766   /* Maybe the lists are equal.  */
1767   if (t1 == 0 && t2 == 0)
1768     return 1;
1769
1770   for (; t2 != 0; t2 = TREE_CHAIN (t2))
1771     {
1772       const_tree attr;
1773       /* This CONST_CAST is okay because lookup_attribute does not
1774          modify its argument and the return value is assigned to a
1775          const_tree.  */
1776       for (attr = lookup_ident_attribute (get_attribute_name (t2),
1777                                           CONST_CAST_TREE (l1));
1778            attr != NULL_TREE && !attribute_value_equal (t2, attr);
1779            attr = lookup_ident_attribute (get_attribute_name (t2),
1780                                           TREE_CHAIN (attr)))
1781         ;
1782
1783       if (attr == NULL_TREE)
1784         return 0;
1785     }
1786
1787   return 1;
1788 }
1789
1790 /* The backbone of lookup_attribute().  ATTR_LEN is the string length
1791    of ATTR_NAME, and LIST is not NULL_TREE.
1792
1793    The function is called from lookup_attribute in order to optimize
1794    for size.  */
1795
1796 tree
1797 private_lookup_attribute (const char *attr_name, size_t attr_len, tree list)
1798 {
1799   while (list)
1800     {
1801       tree attr = get_attribute_name (list);
1802       size_t ident_len = IDENTIFIER_LENGTH (attr);
1803       if (cmp_attribs (attr_name, attr_len, IDENTIFIER_POINTER (attr),
1804                        ident_len))
1805         break;
1806       list = TREE_CHAIN (list);
1807     }
1808
1809   return list;
1810 }
1811
1812 #if CHECKING_P
1813
1814 namespace selftest
1815 {
1816
1817 /* Helper types to verify the consistency attribute exclusions.  */
1818
1819 typedef std::pair<const char *, const char *> excl_pair;
1820
1821 struct excl_hash_traits: typed_noop_remove<excl_pair>
1822 {
1823   typedef excl_pair  value_type;
1824   typedef value_type compare_type;
1825
1826   static hashval_t hash (const value_type &x)
1827   {
1828     hashval_t h1 = htab_hash_string (x.first);
1829     hashval_t h2 = htab_hash_string (x.second);
1830     return h1 ^ h2;
1831   }
1832
1833   static bool equal (const value_type &x, const value_type &y)
1834   {
1835     return !strcmp (x.first, y.first) && !strcmp (x.second, y.second);
1836   }
1837
1838   static void mark_deleted (value_type &x)
1839   {
1840     x = value_type (NULL, NULL);
1841   }
1842
1843   static void mark_empty (value_type &x)
1844   {
1845     x = value_type ("", "");
1846   }
1847
1848   static bool is_deleted (const value_type &x)
1849   {
1850     return !x.first && !x.second;
1851   }
1852
1853   static bool is_empty (const value_type &x)
1854   {
1855     return !*x.first && !*x.second;
1856   }
1857 };
1858
1859
1860 /* Self-test to verify that each attribute exclusion is symmetric,
1861    meaning that if attribute A is encoded as incompatible with
1862    attribute B then the opposite relationship is also encoded.
1863    This test also detects most cases of misspelled attribute names
1864    in exclusions.  */
1865
1866 static void
1867 test_attribute_exclusions ()
1868 {
1869   /* Iterate over the array of attribute tables first (with TI0 as
1870      the index) and over the array of attribute_spec in each table
1871      (with SI0 as the index).  */
1872   const size_t ntables = ARRAY_SIZE (attribute_tables);
1873
1874   /* Set of pairs of mutually exclusive attributes.  */
1875   typedef hash_set<excl_pair, excl_hash_traits> exclusion_set;
1876   exclusion_set excl_set;
1877
1878   for (size_t ti0 = 0; ti0 != ntables; ++ti0)
1879     for (size_t s0 = 0; attribute_tables[ti0][s0].name; ++s0)
1880       {
1881         const attribute_spec::exclusions *excl
1882           = attribute_tables[ti0][s0].exclude;
1883
1884         /* Skip each attribute that doesn't define exclusions.  */
1885         if (!excl)
1886           continue;
1887
1888         const char *attr_name = attribute_tables[ti0][s0].name;
1889
1890         /* Iterate over the set of exclusions for every attribute
1891            (with EI0 as the index) adding the exclusions defined
1892            for each to the set.  */
1893         for (size_t ei0 = 0; excl[ei0].name; ++ei0)
1894           {
1895             const char *excl_name = excl[ei0].name;
1896
1897             if (!strcmp (attr_name, excl_name))
1898               continue;
1899
1900             excl_set.add (excl_pair (attr_name, excl_name));
1901           }
1902       }
1903
1904   /* Traverse the set of mutually exclusive pairs of attributes
1905      and verify that they are symmetric.  */
1906   for (exclusion_set::iterator it = excl_set.begin ();
1907        it != excl_set.end ();
1908        ++it)
1909     {
1910       if (!excl_set.contains (excl_pair ((*it).second, (*it).first)))
1911         {
1912           /* An exclusion for an attribute has been found that
1913              doesn't have a corresponding exclusion in the opposite
1914              direction.  */
1915           char desc[120];
1916           sprintf (desc, "'%s' attribute exclusion '%s' must be symmetric",
1917                    (*it).first, (*it).second);
1918           fail (SELFTEST_LOCATION, desc);
1919         }
1920     }
1921 }
1922
1923 void
1924 attribute_c_tests ()
1925 {
1926   test_attribute_exclusions ();
1927 }
1928
1929 } /* namespace selftest */
1930
1931 #endif /* CHECKING_P */