LCOV - code coverage report
Current view: top level - gcc/c-family - c-attribs.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1513 1790 84.5 %
Date: 2020-03-28 11:57:23 Functions: 95 101 94.1 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* C-family attributes handling.
       2                 :            :    Copyright (C) 1992-2020 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 "function.h"
      25                 :            : #include "tree.h"
      26                 :            : #include "memmodel.h"
      27                 :            : #include "c-common.h"
      28                 :            : #include "gimple-expr.h"
      29                 :            : #include "tm_p.h"
      30                 :            : #include "stringpool.h"
      31                 :            : #include "cgraph.h"
      32                 :            : #include "diagnostic.h"
      33                 :            : #include "intl.h"
      34                 :            : #include "stor-layout.h"
      35                 :            : #include "calls.h"
      36                 :            : #include "attribs.h"
      37                 :            : #include "varasm.h"
      38                 :            : #include "trans-mem.h"
      39                 :            : #include "c-objc.h"
      40                 :            : #include "common/common-target.h"
      41                 :            : #include "langhooks.h"
      42                 :            : #include "tree-inline.h"
      43                 :            : #include "toplev.h"
      44                 :            : #include "tree-iterator.h"
      45                 :            : #include "opts.h"
      46                 :            : #include "gimplify.h"
      47                 :            : #include "tree-pretty-print.h"
      48                 :            : 
      49                 :            : static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
      50                 :            : static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
      51                 :            : static tree handle_common_attribute (tree *, tree, tree, int, bool *);
      52                 :            : static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
      53                 :            : static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
      54                 :            : static tree handle_no_sanitize_attribute (tree *, tree, tree, int, bool *);
      55                 :            : static tree handle_no_sanitize_address_attribute (tree *, tree, tree,
      56                 :            :                                                   int, bool *);
      57                 :            : static tree handle_no_sanitize_thread_attribute (tree *, tree, tree,
      58                 :            :                                                  int, bool *);
      59                 :            : static tree handle_no_address_safety_analysis_attribute (tree *, tree, tree,
      60                 :            :                                                          int, bool *);
      61                 :            : static tree handle_no_sanitize_undefined_attribute (tree *, tree, tree, int,
      62                 :            :                                                     bool *);
      63                 :            : static tree handle_asan_odr_indicator_attribute (tree *, tree, tree, int,
      64                 :            :                                                  bool *);
      65                 :            : static tree handle_stack_protect_attribute (tree *, tree, tree, int, bool *);
      66                 :            : static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
      67                 :            : static tree handle_noclone_attribute (tree *, tree, tree, int, bool *);
      68                 :            : static tree handle_nocf_check_attribute (tree *, tree, tree, int, bool *);
      69                 :            : static tree handle_symver_attribute (tree *, tree, tree, int, bool *);
      70                 :            : static tree handle_noicf_attribute (tree *, tree, tree, int, bool *);
      71                 :            : static tree handle_noipa_attribute (tree *, tree, tree, int, bool *);
      72                 :            : static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
      73                 :            : static tree handle_always_inline_attribute (tree *, tree, tree, int,
      74                 :            :                                             bool *);
      75                 :            : static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
      76                 :            : static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
      77                 :            : static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
      78                 :            : static tree handle_error_attribute (tree *, tree, tree, int, bool *);
      79                 :            : static tree handle_used_attribute (tree *, tree, tree, int, bool *);
      80                 :            : static tree handle_externally_visible_attribute (tree *, tree, tree, int,
      81                 :            :                                                  bool *);
      82                 :            : static tree handle_no_reorder_attribute (tree *, tree, tree, int,
      83                 :            :                                                  bool *);
      84                 :            : static tree handle_const_attribute (tree *, tree, tree, int, bool *);
      85                 :            : static tree handle_transparent_union_attribute (tree *, tree, tree,
      86                 :            :                                                 int, bool *);
      87                 :            : static tree handle_scalar_storage_order_attribute (tree *, tree, tree,
      88                 :            :                                                    int, bool *);
      89                 :            : static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
      90                 :            : static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
      91                 :            : static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
      92                 :            : static tree handle_section_attribute (tree *, tree, tree, int, bool *);
      93                 :            : static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
      94                 :            : static tree handle_warn_if_not_aligned_attribute (tree *, tree, tree,
      95                 :            :                                                   int, bool *);
      96                 :            : static tree handle_noinit_attribute (tree *, tree, tree, int, bool *);
      97                 :            : static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
      98                 :            : static tree handle_noplt_attribute (tree *, tree, tree, int, bool *) ;
      99                 :            : static tree handle_alias_ifunc_attribute (bool, tree *, tree, tree, bool *);
     100                 :            : static tree handle_ifunc_attribute (tree *, tree, tree, int, bool *);
     101                 :            : static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
     102                 :            : static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
     103                 :            : static tree handle_visibility_attribute (tree *, tree, tree, int,
     104                 :            :                                          bool *);
     105                 :            : static tree handle_tls_model_attribute (tree *, tree, tree, int,
     106                 :            :                                         bool *);
     107                 :            : static tree handle_no_instrument_function_attribute (tree *, tree,
     108                 :            :                                                      tree, int, bool *);
     109                 :            : static tree handle_no_profile_instrument_function_attribute (tree *, tree,
     110                 :            :                                                              tree, int, bool *);
     111                 :            : static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
     112                 :            : static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
     113                 :            : static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
     114                 :            :                                              bool *);
     115                 :            : static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
     116                 :            : static tree handle_tm_attribute (tree *, tree, tree, int, bool *);
     117                 :            : static tree handle_tm_wrap_attribute (tree *, tree, tree, int, bool *);
     118                 :            : static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
     119                 :            : static tree handle_vector_size_attribute (tree *, tree, tree, int,
     120                 :            :                                           bool *);
     121                 :            : static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
     122                 :            : static tree handle_nonstring_attribute (tree *, tree, tree, int, bool *);
     123                 :            : static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
     124                 :            : static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
     125                 :            : static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
     126                 :            :                                                  bool *);
     127                 :            : static tree handle_access_attribute (tree *, tree, tree, int, bool *);
     128                 :            : 
     129                 :            : static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
     130                 :            : static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
     131                 :            : static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
     132                 :            : static tree handle_alloc_align_attribute (tree *, tree, tree, int, bool *);
     133                 :            : static tree handle_assume_aligned_attribute (tree *, tree, tree, int, bool *);
     134                 :            : static tree handle_target_attribute (tree *, tree, tree, int, bool *);
     135                 :            : static tree handle_target_clones_attribute (tree *, tree, tree, int, bool *);
     136                 :            : static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
     137                 :            : static tree ignore_attribute (tree *, tree, tree, int, bool *);
     138                 :            : static tree handle_no_split_stack_attribute (tree *, tree, tree, int, bool *);
     139                 :            : static tree handle_fnspec_attribute (tree *, tree, tree, int, bool *);
     140                 :            : static tree handle_warn_unused_attribute (tree *, tree, tree, int, bool *);
     141                 :            : static tree handle_returns_nonnull_attribute (tree *, tree, tree, int, bool *);
     142                 :            : static tree handle_omp_declare_simd_attribute (tree *, tree, tree, int,
     143                 :            :                                                bool *);
     144                 :            : static tree handle_omp_declare_variant_attribute (tree *, tree, tree, int,
     145                 :            :                                                   bool *);
     146                 :            : static tree handle_simd_attribute (tree *, tree, tree, int, bool *);
     147                 :            : static tree handle_omp_declare_target_attribute (tree *, tree, tree, int,
     148                 :            :                                                  bool *);
     149                 :            : static tree handle_designated_init_attribute (tree *, tree, tree, int, bool *);
     150                 :            : static tree handle_patchable_function_entry_attribute (tree *, tree, tree,
     151                 :            :                                                        int, bool *);
     152                 :            : static tree handle_copy_attribute (tree *, tree, tree, int, bool *);
     153                 :            : 
     154                 :            : /* Helper to define attribute exclusions.  */
     155                 :            : #define ATTR_EXCL(name, function, type, variable)       \
     156                 :            :   { name, function, type, variable }
     157                 :            : 
     158                 :            : /* Define attributes that are mutually exclusive with one another.  */
     159                 :            : static const struct attribute_spec::exclusions attr_aligned_exclusions[] =
     160                 :            : {
     161                 :            :   /* Attribute name     exclusion applies to:
     162                 :            :                         function, type, variable */
     163                 :            :   ATTR_EXCL ("aligned", true, false, false),
     164                 :            :   ATTR_EXCL ("packed", true, false, false),
     165                 :            :   ATTR_EXCL (NULL, false, false, false)
     166                 :            : };
     167                 :            : 
     168                 :            : extern const struct attribute_spec::exclusions attr_cold_hot_exclusions[] =
     169                 :            : {
     170                 :            :   ATTR_EXCL ("cold", true, true, true),
     171                 :            :   ATTR_EXCL ("hot", true, true, true),
     172                 :            :   ATTR_EXCL (NULL, false, false, false)
     173                 :            : };
     174                 :            : 
     175                 :            : static const struct attribute_spec::exclusions attr_common_exclusions[] =
     176                 :            : {
     177                 :            :   ATTR_EXCL ("common", true, true, true),
     178                 :            :   ATTR_EXCL ("nocommon", true, true, true),
     179                 :            :   ATTR_EXCL (NULL, false, false, false),
     180                 :            : };
     181                 :            : 
     182                 :            : static const struct attribute_spec::exclusions attr_inline_exclusions[] =
     183                 :            : {
     184                 :            :   ATTR_EXCL ("noinline", true, true, true),
     185                 :            :   ATTR_EXCL (NULL, false, false, false),
     186                 :            : };
     187                 :            : 
     188                 :            : static const struct attribute_spec::exclusions attr_noinline_exclusions[] =
     189                 :            : {
     190                 :            :   ATTR_EXCL ("always_inline", true, true, true),
     191                 :            :   ATTR_EXCL ("gnu_inline", true, true, true),
     192                 :            :   ATTR_EXCL (NULL, false, false, false),
     193                 :            : };
     194                 :            : 
     195                 :            : extern const struct attribute_spec::exclusions attr_noreturn_exclusions[] =
     196                 :            : {
     197                 :            :   ATTR_EXCL ("alloc_align", true, true, true),
     198                 :            :   ATTR_EXCL ("alloc_size", true, true, true),
     199                 :            :   ATTR_EXCL ("const", true, true, true),
     200                 :            :   ATTR_EXCL ("malloc", true, true, true),
     201                 :            :   ATTR_EXCL ("pure", true, true, true),
     202                 :            :   ATTR_EXCL ("returns_twice", true, true, true),
     203                 :            :   ATTR_EXCL ("warn_unused_result", true, true, true),
     204                 :            :   ATTR_EXCL (NULL, false, false, false),
     205                 :            : };
     206                 :            : 
     207                 :            : static const struct attribute_spec::exclusions
     208                 :            : attr_warn_unused_result_exclusions[] =
     209                 :            : {
     210                 :            :   ATTR_EXCL ("noreturn", true, true, true),
     211                 :            :   ATTR_EXCL ("warn_unused_result", true, true, true),
     212                 :            :   ATTR_EXCL (NULL, false, false, false),
     213                 :            : };
     214                 :            : 
     215                 :            : static const struct attribute_spec::exclusions attr_returns_twice_exclusions[] =
     216                 :            : {
     217                 :            :   ATTR_EXCL ("noreturn", true, true, true),
     218                 :            :   ATTR_EXCL (NULL, false, false, false),
     219                 :            : };
     220                 :            : 
     221                 :            : /* Exclusions that apply to attribute alloc_align, alloc_size, and malloc.  */
     222                 :            : static const struct attribute_spec::exclusions attr_alloc_exclusions[] =
     223                 :            : {
     224                 :            :   ATTR_EXCL ("const", true, true, true),
     225                 :            :   ATTR_EXCL ("noreturn", true, true, true),
     226                 :            :   ATTR_EXCL ("pure", true, true, true),
     227                 :            :   ATTR_EXCL (NULL, false, false, false),
     228                 :            : };
     229                 :            : 
     230                 :            : static const struct attribute_spec::exclusions attr_const_pure_exclusions[] =
     231                 :            : {
     232                 :            :   ATTR_EXCL ("const", true, true, true),
     233                 :            :   ATTR_EXCL ("alloc_align", true, true, true),
     234                 :            :   ATTR_EXCL ("alloc_size", true, true, true),
     235                 :            :   ATTR_EXCL ("malloc", true, true, true),
     236                 :            :   ATTR_EXCL ("noreturn", true, true, true),
     237                 :            :   ATTR_EXCL ("pure", true, true, true),
     238                 :            :   ATTR_EXCL (NULL, false, false, false)
     239                 :            : };
     240                 :            : 
     241                 :            : static const struct attribute_spec::exclusions attr_noinit_exclusions[] =
     242                 :            : {
     243                 :            :   ATTR_EXCL ("noinit", true, true, true),
     244                 :            :   ATTR_EXCL ("section", true, true, true),
     245                 :            :   ATTR_EXCL (NULL, false, false, false),
     246                 :            : };
     247                 :            : 
     248                 :            : /* Table of machine-independent attributes common to all C-like languages.
     249                 :            : 
     250                 :            :    Current list of processed common attributes: nonnull.  */
     251                 :            : const struct attribute_spec c_common_attribute_table[] =
     252                 :            : {
     253                 :            :   /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
     254                 :            :        affects_type_identity, handler, exclude } */
     255                 :            :   { "packed",                 0, 0, false, false, false, false,
     256                 :            :                               handle_packed_attribute,
     257                 :            :                               attr_aligned_exclusions },
     258                 :            :   { "nocommon",               0, 0, true,  false, false, false,
     259                 :            :                               handle_nocommon_attribute,
     260                 :            :                               attr_common_exclusions },
     261                 :            :   { "common",                 0, 0, true,  false, false, false,
     262                 :            :                               handle_common_attribute,
     263                 :            :                               attr_common_exclusions },
     264                 :            :   /* FIXME: logically, noreturn attributes should be listed as
     265                 :            :      "false, true, true" and apply to function types.  But implementing this
     266                 :            :      would require all the places in the compiler that use TREE_THIS_VOLATILE
     267                 :            :      on a decl to identify non-returning functions to be located and fixed
     268                 :            :      to check the function type instead.  */
     269                 :            :   { "noreturn",               0, 0, true,  false, false, false,
     270                 :            :                               handle_noreturn_attribute,
     271                 :            :                               attr_noreturn_exclusions },
     272                 :            :   { "volatile",               0, 0, true,  false, false, false,
     273                 :            :                               handle_noreturn_attribute, NULL },
     274                 :            :   { "stack_protect",          0, 0, true,  false, false, false,
     275                 :            :                               handle_stack_protect_attribute, NULL },
     276                 :            :   { "noinline",               0, 0, true,  false, false, false,
     277                 :            :                               handle_noinline_attribute,
     278                 :            :                               attr_noinline_exclusions },
     279                 :            :   { "noclone",                0, 0, true,  false, false, false,
     280                 :            :                               handle_noclone_attribute, NULL },
     281                 :            :   { "no_icf",                 0, 0, true,  false, false, false,
     282                 :            :                               handle_noicf_attribute, NULL },
     283                 :            :   { "noipa",                0, 0, true,  false, false, false,
     284                 :            :                               handle_noipa_attribute, NULL },
     285                 :            :   { "leaf",                   0, 0, true,  false, false, false,
     286                 :            :                               handle_leaf_attribute, NULL },
     287                 :            :   { "always_inline",          0, 0, true,  false, false, false,
     288                 :            :                               handle_always_inline_attribute,
     289                 :            :                               attr_inline_exclusions },
     290                 :            :   { "gnu_inline",             0, 0, true,  false, false, false,
     291                 :            :                               handle_gnu_inline_attribute,
     292                 :            :                               attr_inline_exclusions },
     293                 :            :   { "artificial",             0, 0, true,  false, false, false,
     294                 :            :                               handle_artificial_attribute, NULL },
     295                 :            :   { "flatten",                0, 0, true,  false, false, false,
     296                 :            :                               handle_flatten_attribute, NULL },
     297                 :            :   { "used",                   0, 0, true,  false, false, false,
     298                 :            :                               handle_used_attribute, NULL },
     299                 :            :   { "unused",                 0, 0, false, false, false, false,
     300                 :            :                               handle_unused_attribute, NULL },
     301                 :            :   { "externally_visible",     0, 0, true,  false, false, false,
     302                 :            :                               handle_externally_visible_attribute, NULL },
     303                 :            :   { "no_reorder",           0, 0, true, false, false, false,
     304                 :            :                               handle_no_reorder_attribute, NULL },
     305                 :            :   /* The same comments as for noreturn attributes apply to const ones.  */
     306                 :            :   { "const",                  0, 0, true,  false, false, false,
     307                 :            :                               handle_const_attribute,
     308                 :            :                               attr_const_pure_exclusions },
     309                 :            :   { "scalar_storage_order",   1, 1, false, false, false, false,
     310                 :            :                               handle_scalar_storage_order_attribute, NULL },
     311                 :            :   { "transparent_union",      0, 0, false, false, false, false,
     312                 :            :                               handle_transparent_union_attribute, NULL },
     313                 :            :   { "constructor",            0, 1, true,  false, false, false,
     314                 :            :                               handle_constructor_attribute, NULL },
     315                 :            :   { "destructor",             0, 1, true,  false, false, false,
     316                 :            :                               handle_destructor_attribute, NULL },
     317                 :            :   { "mode",                   1, 1, false,  true, false, false,
     318                 :            :                               handle_mode_attribute, NULL },
     319                 :            :   { "section",                1, 1, true,  false, false, false,
     320                 :            :                               handle_section_attribute, attr_noinit_exclusions },
     321                 :            :   { "aligned",                0, 1, false, false, false, false,
     322                 :            :                               handle_aligned_attribute,
     323                 :            :                               attr_aligned_exclusions },
     324                 :            :   { "warn_if_not_aligned",    0, 1, false, false, false, false,
     325                 :            :                               handle_warn_if_not_aligned_attribute, NULL },
     326                 :            :   { "weak",                   0, 0, true,  false, false, false,
     327                 :            :                               handle_weak_attribute, NULL },
     328                 :            :   { "noplt",                   0, 0, true,  false, false, false,
     329                 :            :                               handle_noplt_attribute, NULL },
     330                 :            :   { "ifunc",                  1, 1, true,  false, false, false,
     331                 :            :                               handle_ifunc_attribute, NULL },
     332                 :            :   { "alias",                  1, 1, true,  false, false, false,
     333                 :            :                               handle_alias_attribute, NULL },
     334                 :            :   { "weakref",                0, 1, true,  false, false, false,
     335                 :            :                               handle_weakref_attribute, NULL },
     336                 :            :   { "no_instrument_function", 0, 0, true,  false, false, false,
     337                 :            :                               handle_no_instrument_function_attribute,
     338                 :            :                               NULL },
     339                 :            :   { "no_profile_instrument_function",  0, 0, true, false, false, false,
     340                 :            :                               handle_no_profile_instrument_function_attribute,
     341                 :            :                               NULL },
     342                 :            :   { "malloc",                 0, 0, true,  false, false, false,
     343                 :            :                               handle_malloc_attribute, attr_alloc_exclusions },
     344                 :            :   { "returns_twice",          0, 0, true,  false, false, false,
     345                 :            :                               handle_returns_twice_attribute,
     346                 :            :                               attr_returns_twice_exclusions },
     347                 :            :   { "no_stack_limit",         0, 0, true,  false, false, false,
     348                 :            :                               handle_no_limit_stack_attribute, NULL },
     349                 :            :   { "pure",                   0, 0, true,  false, false, false,
     350                 :            :                               handle_pure_attribute,
     351                 :            :                               attr_const_pure_exclusions },
     352                 :            :   { "transaction_callable",   0, 0, false, true,  false, false,
     353                 :            :                               handle_tm_attribute, NULL },
     354                 :            :   { "transaction_unsafe",     0, 0, false, true,  false, true,
     355                 :            :                               handle_tm_attribute, NULL },
     356                 :            :   { "transaction_safe",       0, 0, false, true,  false, true,
     357                 :            :                               handle_tm_attribute, NULL },
     358                 :            :   { "transaction_safe_dynamic", 0, 0, true, false,  false, false,
     359                 :            :                               handle_tm_attribute, NULL },
     360                 :            :   { "transaction_may_cancel_outer", 0, 0, false, true, false, false,
     361                 :            :                               handle_tm_attribute, NULL },
     362                 :            :   /* ??? These two attributes didn't make the transition from the
     363                 :            :      Intel language document to the multi-vendor language document.  */
     364                 :            :   { "transaction_pure",       0, 0, false, true,  false, false,
     365                 :            :                               handle_tm_attribute, NULL },
     366                 :            :   { "transaction_wrap",       1, 1, true,  false,  false, false,
     367                 :            :                              handle_tm_wrap_attribute, NULL },
     368                 :            :   /* For internal use (marking of builtins) only.  The name contains space
     369                 :            :      to prevent its usage in source code.  */
     370                 :            :   { "no vops",                0, 0, true,  false, false, false,
     371                 :            :                               handle_novops_attribute, NULL },
     372                 :            :   { "deprecated",             0, 1, false, false, false, false,
     373                 :            :                               handle_deprecated_attribute, NULL },
     374                 :            :   { "vector_size",          1, 1, false, true, false, true,
     375                 :            :                               handle_vector_size_attribute, NULL },
     376                 :            :   { "visibility",           1, 1, false, false, false, false,
     377                 :            :                               handle_visibility_attribute, NULL },
     378                 :            :   { "tls_model",            1, 1, true,  false, false, false,
     379                 :            :                               handle_tls_model_attribute, NULL },
     380                 :            :   { "nonnull",                0, -1, false, true, true, false,
     381                 :            :                               handle_nonnull_attribute, NULL },
     382                 :            :   { "nonstring",              0, 0, true, false, false, false,
     383                 :            :                               handle_nonstring_attribute, NULL },
     384                 :            :   { "nothrow",                0, 0, true,  false, false, false,
     385                 :            :                               handle_nothrow_attribute, NULL },
     386                 :            :   { "may_alias",            0, 0, false, true, false, false, NULL, NULL },
     387                 :            :   { "cleanup",                      1, 1, true, false, false, false,
     388                 :            :                               handle_cleanup_attribute, NULL },
     389                 :            :   { "warn_unused_result",     0, 0, false, true, true, false,
     390                 :            :                               handle_warn_unused_result_attribute,
     391                 :            :                               attr_warn_unused_result_exclusions },
     392                 :            :   { "sentinel",               0, 1, false, true, true, false,
     393                 :            :                               handle_sentinel_attribute, NULL },
     394                 :            :   /* For internal use (marking of builtins) only.  The name contains space
     395                 :            :      to prevent its usage in source code.  */
     396                 :            :   { "type generic",           0, 0, false, true, true, false,
     397                 :            :                               handle_type_generic_attribute, NULL },
     398                 :            :   { "alloc_size",           1, 2, false, true, true, false,
     399                 :            :                               handle_alloc_size_attribute,
     400                 :            :                               attr_alloc_exclusions },
     401                 :            :   { "cold",                   0, 0, true,  false, false, false,
     402                 :            :                               handle_cold_attribute,
     403                 :            :                               attr_cold_hot_exclusions },
     404                 :            :   { "hot",                    0, 0, true,  false, false, false,
     405                 :            :                               handle_hot_attribute,
     406                 :            :                               attr_cold_hot_exclusions },
     407                 :            :   { "no_address_safety_analysis",
     408                 :            :                               0, 0, true, false, false, false,
     409                 :            :                               handle_no_address_safety_analysis_attribute,
     410                 :            :                               NULL },
     411                 :            :   { "no_sanitize",          1, -1, true, false, false, false,
     412                 :            :                               handle_no_sanitize_attribute, NULL },
     413                 :            :   { "no_sanitize_address",    0, 0, true, false, false, false,
     414                 :            :                               handle_no_sanitize_address_attribute, NULL },
     415                 :            :   { "no_sanitize_thread",     0, 0, true, false, false, false,
     416                 :            :                               handle_no_sanitize_thread_attribute, NULL },
     417                 :            :   { "no_sanitize_undefined",  0, 0, true, false, false, false,
     418                 :            :                               handle_no_sanitize_undefined_attribute, NULL },
     419                 :            :   { "asan odr indicator",     0, 0, true, false, false, false,
     420                 :            :                               handle_asan_odr_indicator_attribute, NULL },
     421                 :            :   { "warning",                      1, 1, true,  false, false, false,
     422                 :            :                               handle_error_attribute, NULL },
     423                 :            :   { "error",                1, 1, true,  false, false, false,
     424                 :            :                               handle_error_attribute, NULL },
     425                 :            :   { "target",                 1, -1, true, false, false, false,
     426                 :            :                               handle_target_attribute, NULL },
     427                 :            :   { "target_clones",          1, -1, true, false, false, false,
     428                 :            :                               handle_target_clones_attribute, NULL },
     429                 :            :   { "optimize",               1, -1, true, false, false, false,
     430                 :            :                               handle_optimize_attribute, NULL },
     431                 :            :   /* For internal use only.  The leading '*' both prevents its usage in
     432                 :            :      source code and signals that it may be overridden by machine tables.  */
     433                 :            :   { "*tm regparm",            0, 0, false, true, true, false,
     434                 :            :                               ignore_attribute, NULL },
     435                 :            :   { "no_split_stack",       0, 0, true,  false, false, false,
     436                 :            :                               handle_no_split_stack_attribute, NULL },
     437                 :            :   /* For internal use (marking of builtins and runtime functions) only.
     438                 :            :      The name contains space to prevent its usage in source code.  */
     439                 :            :   { "fn spec",                      1, 1, false, true, true, false,
     440                 :            :                               handle_fnspec_attribute, NULL },
     441                 :            :   { "warn_unused",            0, 0, false, false, false, false,
     442                 :            :                               handle_warn_unused_attribute, NULL },
     443                 :            :   { "returns_nonnull",        0, 0, false, true, true, false,
     444                 :            :                               handle_returns_nonnull_attribute, NULL },
     445                 :            :   { "omp declare simd",       0, -1, true,  false, false, false,
     446                 :            :                               handle_omp_declare_simd_attribute, NULL },
     447                 :            :   { "omp declare variant base", 0, -1, true,  false, false, false,
     448                 :            :                               handle_omp_declare_variant_attribute, NULL },
     449                 :            :   { "omp declare variant variant", 0, -1, true,  false, false, false,
     450                 :            :                               handle_omp_declare_variant_attribute, NULL },
     451                 :            :   { "simd",                 0, 1, true,  false, false, false,
     452                 :            :                               handle_simd_attribute, NULL },
     453                 :            :   { "omp declare target",     0, -1, true, false, false, false,
     454                 :            :                               handle_omp_declare_target_attribute, NULL },
     455                 :            :   { "omp declare target link", 0, 0, true, false, false, false,
     456                 :            :                               handle_omp_declare_target_attribute, NULL },
     457                 :            :   { "omp declare target implicit", 0, 0, true, false, false, false,
     458                 :            :                               handle_omp_declare_target_attribute, NULL },
     459                 :            :   { "omp declare target host", 0, 0, true, false, false, false,
     460                 :            :                               handle_omp_declare_target_attribute, NULL },
     461                 :            :   { "omp declare target nohost", 0, 0, true, false, false, false,
     462                 :            :                               handle_omp_declare_target_attribute, NULL },
     463                 :            :   { "omp declare target block", 0, 0, true, false, false, false,
     464                 :            :                               handle_omp_declare_target_attribute, NULL },
     465                 :            :   { "alloc_align",          1, 1, false, true, true, false,
     466                 :            :                               handle_alloc_align_attribute,
     467                 :            :                               attr_alloc_exclusions },
     468                 :            :   { "assume_aligned",       1, 2, false, true, true, false,
     469                 :            :                               handle_assume_aligned_attribute, NULL },
     470                 :            :   { "designated_init",        0, 0, false, true, false, false,
     471                 :            :                               handle_designated_init_attribute, NULL },
     472                 :            :   { "fallthrough",          0, 0, false, false, false, false,
     473                 :            :                               handle_fallthrough_attribute, NULL },
     474                 :            :   { "patchable_function_entry",       1, 2, true, false, false, false,
     475                 :            :                               handle_patchable_function_entry_attribute,
     476                 :            :                               NULL },
     477                 :            :   { "nocf_check",           0, 0, false, true, true, true,
     478                 :            :                               handle_nocf_check_attribute, NULL },
     479                 :            :   { "symver",               1, -1, true, false, false, false,
     480                 :            :                               handle_symver_attribute, NULL},
     481                 :            :   { "copy",                   1, 1, false, false, false, false,
     482                 :            :                               handle_copy_attribute, NULL },
     483                 :            :   { "noinit",               0, 0, true,  false, false, false,
     484                 :            :                               handle_noinit_attribute, attr_noinit_exclusions },
     485                 :            :   { "access",               1, 3, false, true, true, false,
     486                 :            :                               handle_access_attribute, NULL },
     487                 :            :   { NULL,                     0, 0, false, false, false, false, NULL, NULL }
     488                 :            : };
     489                 :            : 
     490                 :            : /* Give the specifications for the format attributes, used by C and all
     491                 :            :    descendants.
     492                 :            : 
     493                 :            :    Current list of processed format attributes: format, format_arg.  */
     494                 :            : const struct attribute_spec c_common_format_attribute_table[] =
     495                 :            : {
     496                 :            :   /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
     497                 :            :        affects_type_identity, handler, exclude } */
     498                 :            :   { "format",                 3, 3, false, true,  true, false,
     499                 :            :                               handle_format_attribute, NULL },
     500                 :            :   { "format_arg",             1, 1, false, true,  true, false,
     501                 :            :                               handle_format_arg_attribute, NULL },
     502                 :            :   { NULL,                     0, 0, false, false, false, false, NULL, NULL }
     503                 :            : };
     504                 :            : 
     505                 :            : /* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
     506                 :            :    identifier as an argument, so the front end shouldn't look it up.  */
     507                 :            : 
     508                 :            : bool
     509                 :    4324640 : attribute_takes_identifier_p (const_tree attr_id)
     510                 :            : {
     511                 :    4324640 :   const struct attribute_spec *spec = lookup_attribute_spec (attr_id);
     512                 :    4324640 :   if (spec == NULL)
     513                 :            :     /* Unknown attribute that we'll end up ignoring, return true so we
     514                 :            :        don't complain about an identifier argument.  */
     515                 :            :     return true;
     516                 :    4324600 :   else if (!strcmp ("mode", spec->name)
     517                 :    4280760 :            || !strcmp ("format", spec->name)
     518                 :    4114490 :            || !strcmp ("cleanup", spec->name)
     519                 :    4114270 :            || !strcmp ("access", spec->name))
     520                 :            :     return true;
     521                 :            :   else
     522                 :    4113860 :     return targetm.attribute_takes_identifier_p (attr_id);
     523                 :            : }
     524                 :            : 
     525                 :            : /* Verify that argument value POS at position ARGNO to attribute NAME
     526                 :            :    applied to function TYPE refers to a function parameter at position
     527                 :            :    POS and the expected type CODE.  Treat CODE == INTEGER_TYPE as
     528                 :            :    matching all C integral types except bool.  If successful, return
     529                 :            :    POS after default conversions, if any.  Otherwise, issue appropriate
     530                 :            :    warnings and return null.  A non-zero 1-based ARGNO should be passed
     531                 :            :    in by callers only for attributes with more than one argument.  */
     532                 :            : 
     533                 :            : tree
     534                 :   32945500 : positional_argument (const_tree fntype, const_tree atname, tree pos,
     535                 :            :                      tree_code code, int argno /* = 0 */,
     536                 :            :                      int flags /* = posargflags () */)
     537                 :            : {
     538                 :   32945500 :   if (pos && TREE_CODE (pos) != IDENTIFIER_NODE
     539                 :   32945500 :       && TREE_CODE (pos) != FUNCTION_DECL)
     540                 :   32945500 :     pos = default_conversion (pos);
     541                 :            : 
     542                 :   32945500 :   tree postype = TREE_TYPE (pos);
     543                 :   32945500 :   if (pos == error_mark_node || !postype)
     544                 :            :     {
     545                 :            :       /* Only mention the positional argument number when it's non-zero.  */
     546                 :         21 :       if (argno < 1)
     547                 :         11 :         warning (OPT_Wattributes,
     548                 :            :                  "%qE attribute argument is invalid", atname);
     549                 :            :       else
     550                 :         10 :         warning (OPT_Wattributes,
     551                 :            :                  "%qE attribute argument %i is invalid", atname, argno);
     552                 :            : 
     553                 :         21 :       return NULL_TREE;
     554                 :            :     }
     555                 :            : 
     556                 :   32945500 :   if (!INTEGRAL_TYPE_P (postype))
     557                 :            :     {
     558                 :            :       /* Handle this case specially to avoid mentioning the value
     559                 :            :          of pointer constants in diagnostics.  Only mention
     560                 :            :          the positional argument number when it's non-zero.  */
     561                 :         39 :       if (argno < 1)
     562                 :         27 :         warning (OPT_Wattributes,
     563                 :            :                  "%qE attribute argument has type %qT",
     564                 :            :                  atname, postype);
     565                 :            :       else
     566                 :         12 :         warning (OPT_Wattributes,
     567                 :            :                  "%qE attribute argument %i has type %qT",
     568                 :            :                  atname, argno, postype);
     569                 :            : 
     570                 :         39 :       return NULL_TREE;
     571                 :            :     }
     572                 :            : 
     573                 :   32945500 :   if (TREE_CODE (pos) != INTEGER_CST)
     574                 :            :     {
     575                 :            :       /* Only mention the argument number when it's non-zero.  */
     576                 :          7 :       if (argno < 1)
     577                 :          3 :         warning (OPT_Wattributes,
     578                 :            :                  "%qE attribute argument value %qE is not an integer "
     579                 :            :                  "constant",
     580                 :            :                  atname, pos);
     581                 :            :       else
     582                 :          4 :         warning (OPT_Wattributes,
     583                 :            :                  "%qE attribute argument %i value %qE is not an integer "
     584                 :            :                  "constant",
     585                 :            :                  atname, argno, pos);
     586                 :            : 
     587                 :          7 :       return NULL_TREE;
     588                 :            :     }
     589                 :            : 
     590                 :            :   /* Argument positions are 1-based.  */
     591                 :   32945500 :   if (integer_zerop (pos))
     592                 :            :     {
     593                 :    3668800 :       if (flags & POSARG_ZERO)
     594                 :            :         /* Zero is explicitly allowed.  */
     595                 :            :         return pos;
     596                 :            : 
     597                 :          5 :       if (argno < 1)
     598                 :          4 :         warning (OPT_Wattributes,
     599                 :            :                  "%qE attribute argument value %qE does not refer to "
     600                 :            :                  "a function parameter",
     601                 :            :                  atname, pos);
     602                 :            :       else
     603                 :          1 :         warning (OPT_Wattributes,
     604                 :            :                  "%qE attribute argument %i value %qE does not refer to "
     605                 :            :                  "a function parameter",
     606                 :            :                  atname, argno, pos);
     607                 :            : 
     608                 :          5 :       return NULL_TREE;
     609                 :            :     }
     610                 :            : 
     611                 :   29276600 :   if (!prototype_p (fntype))
     612                 :            :     return pos;
     613                 :            : 
     614                 :            :   /* Verify that the argument position does not exceed the number
     615                 :            :      of formal arguments to the function.  When POSARG_ELLIPSIS
     616                 :            :      is set, ARGNO may be beyond the last argument of a vararg
     617                 :            :      function.  */
     618                 :   29276500 :   unsigned nargs = type_num_arguments (fntype);
     619                 :   29276500 :   if (!nargs
     620                 :   29276500 :       || !tree_fits_uhwi_p (pos)
     621                 :   29276500 :       || ((flags & POSARG_ELLIPSIS) == 0
     622                 :   25112100 :           && !IN_RANGE (tree_to_uhwi (pos), 1, nargs)))
     623                 :            :     {
     624                 :            : 
     625                 :         18 :       if (argno < 1)
     626                 :         13 :         warning (OPT_Wattributes,
     627                 :            :                  "%qE attribute argument value %qE exceeds the number "
     628                 :            :                  "of function parameters %u",
     629                 :            :                  atname, pos, nargs);
     630                 :            :       else
     631                 :          5 :         warning (OPT_Wattributes,
     632                 :            :                  "%qE attribute argument %i value %qE exceeds the number "
     633                 :            :                  "of function parameters %u",
     634                 :            :                  atname, argno, pos, nargs);
     635                 :         18 :       return NULL_TREE;
     636                 :            :     }
     637                 :            : 
     638                 :            :   /* Verify that the type of the referenced formal argument matches
     639                 :            :      the expected type.  */
     640                 :   29276500 :   unsigned HOST_WIDE_INT ipos = tree_to_uhwi (pos);
     641                 :            : 
     642                 :            :   /* Zero was handled above.  */
     643                 :   29276500 :   gcc_assert (ipos != 0);
     644                 :            : 
     645                 :   29276500 :   if (tree argtype = type_argument_type (fntype, ipos))
     646                 :            :     {
     647                 :   25112100 :       if (flags & POSARG_ELLIPSIS)
     648                 :            :         {
     649                 :          2 :           if (argno < 1)
     650                 :          0 :             error ("%qE attribute argument value %qE does not refer to "
     651                 :            :                    "a variable argument list",
     652                 :            :                    atname, pos);
     653                 :            :           else
     654                 :          2 :             error ("%qE attribute argument %i value %qE does not refer to "
     655                 :            :                    "a variable argument list",
     656                 :            :                    atname, argno, pos);
     657                 :          2 :           return NULL_TREE;
     658                 :            :         }
     659                 :            : 
     660                 :            :       /* Where the expected code is STRING_CST accept any pointer
     661                 :            :          expected by attribute format (this includes possibly qualified
     662                 :            :          char pointers and, for targets like Darwin, also pointers to
     663                 :            :          struct CFString).  */
     664                 :   25112100 :       bool type_match;
     665                 :   25112100 :       if (code == STRING_CST)
     666                 :    8651950 :         type_match = valid_format_string_type_p (argtype);
     667                 :   16460100 :       else if (code == INTEGER_TYPE)
     668                 :            :         /* For integers, accept enums, wide characters and other types
     669                 :            :            that match INTEGRAL_TYPE_P except for bool.  */
     670                 :    1942830 :         type_match = (INTEGRAL_TYPE_P (argtype)
     671                 :    1942830 :                       && TREE_CODE (argtype) != BOOLEAN_TYPE);
     672                 :            :       else
     673                 :   14517300 :         type_match = TREE_CODE (argtype) == code;
     674                 :            : 
     675                 :   25112100 :       if (!type_match)
     676                 :            :         {
     677                 :         44 :           if (code == STRING_CST)
     678                 :            :             {
     679                 :            :               /* Reject invalid format strings with an error.  */
     680                 :         18 :               if (argno < 1)
     681                 :          6 :                 error ("%qE attribute argument value %qE refers to "
     682                 :            :                        "parameter type %qT",
     683                 :            :                        atname, pos, argtype);
     684                 :            :               else
     685                 :         12 :                 error ("%qE attribute argument %i value %qE refers to "
     686                 :            :                        "parameter type %qT",
     687                 :            :                        atname, argno, pos, argtype);
     688                 :            : 
     689                 :         18 :               return NULL_TREE;
     690                 :            :             }
     691                 :            : 
     692                 :         26 :           if (argno < 1)
     693                 :         26 :             warning (OPT_Wattributes,
     694                 :            :                      "%qE attribute argument value %qE refers to "
     695                 :            :                      "parameter type %qT",
     696                 :            :                      atname, pos, argtype);
     697                 :            :           else
     698                 :          0 :             warning (OPT_Wattributes,
     699                 :            :                    "%qE attribute argument %i value %qE refers to "
     700                 :            :                      "parameter type %qT",
     701                 :            :                      atname, argno, pos, argtype);
     702                 :         26 :           return NULL_TREE;
     703                 :            :         }
     704                 :            :     }
     705                 :    4164420 :   else if (!(flags & POSARG_ELLIPSIS))
     706                 :            :     {
     707                 :          0 :       if (argno < 1)
     708                 :          0 :         warning (OPT_Wattributes,
     709                 :            :                  "%qE attribute argument value %qE refers to "
     710                 :            :                  "a variadic function parameter of unknown type",
     711                 :            :                  atname, pos);
     712                 :            :       else
     713                 :          0 :         warning (OPT_Wattributes,
     714                 :            :                  "%qE attribute argument %i value %qE refers to "
     715                 :            :                  "a variadic function parameter of unknown type",
     716                 :            :                  atname, argno, pos);
     717                 :          0 :       return NULL_TREE;
     718                 :            :     }
     719                 :            : 
     720                 :            :   return pos;
     721                 :            : }
     722                 :            : 
     723                 :            : 
     724                 :            : /* Attribute handlers common to C front ends.  */
     725                 :            : 
     726                 :            : /* Handle a "packed" attribute; arguments as in
     727                 :            :    struct attribute_spec.handler.  */
     728                 :            : 
     729                 :            : static tree
     730                 :       4103 : handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
     731                 :            :                          int flags, bool *no_add_attrs)
     732                 :            : {
     733                 :       4103 :   if (TYPE_P (*node))
     734                 :            :     {
     735                 :       2105 :       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
     736                 :            :         {
     737                 :         40 :           warning (OPT_Wattributes,
     738                 :            :                    "%qE attribute ignored for type %qT", name, *node);
     739                 :         40 :           *no_add_attrs = true;
     740                 :            :         }
     741                 :            :       else
     742                 :       2065 :         TYPE_PACKED (*node) = 1;
     743                 :            :     }
     744                 :       1998 :   else if (TREE_CODE (*node) == FIELD_DECL)
     745                 :            :     {
     746                 :       1984 :       if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
     747                 :            :           /* Still pack bitfields.  */
     748                 :       1984 :           && ! DECL_C_BIT_FIELD (*node))
     749                 :        302 :         warning (OPT_Wattributes,
     750                 :            :                  "%qE attribute ignored for field of type %qT",
     751                 :        302 :                  name, TREE_TYPE (*node));
     752                 :            :       else
     753                 :       1682 :         DECL_PACKED (*node) = 1;
     754                 :            :     }
     755                 :            :   /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
     756                 :            :      used for DECL_REGISTER.  It wouldn't mean anything anyway.
     757                 :            :      We can't set DECL_PACKED on the type of a TYPE_DECL, because
     758                 :            :      that changes what the typedef is typing.  */
     759                 :            :   else
     760                 :            :     {
     761                 :         14 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
     762                 :         14 :       *no_add_attrs = true;
     763                 :            :     }
     764                 :            : 
     765                 :       4103 :   return NULL_TREE;
     766                 :            : }
     767                 :            : 
     768                 :            : /* Handle a "nocommon" attribute; arguments as in
     769                 :            :    struct attribute_spec.handler.  */
     770                 :            : 
     771                 :            : static tree
     772                 :         13 : handle_nocommon_attribute (tree *node, tree name,
     773                 :            :                            tree ARG_UNUSED (args),
     774                 :            :                            int ARG_UNUSED (flags), bool *no_add_attrs)
     775                 :            : {
     776                 :         13 :   if (VAR_P (*node))
     777                 :         13 :     DECL_COMMON (*node) = 0;
     778                 :            :   else
     779                 :            :     {
     780                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
     781                 :          0 :       *no_add_attrs = true;
     782                 :            :     }
     783                 :            : 
     784                 :         13 :   return NULL_TREE;
     785                 :            : }
     786                 :            : 
     787                 :            : /* Handle a "common" attribute; arguments as in
     788                 :            :    struct attribute_spec.handler.  */
     789                 :            : 
     790                 :            : static tree
     791                 :         39 : handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
     792                 :            :                          int ARG_UNUSED (flags), bool *no_add_attrs)
     793                 :            : {
     794                 :         39 :   if (VAR_P (*node))
     795                 :         34 :     DECL_COMMON (*node) = 1;
     796                 :            :   else
     797                 :            :     {
     798                 :          5 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
     799                 :          5 :       *no_add_attrs = true;
     800                 :            :     }
     801                 :            : 
     802                 :         39 :   return NULL_TREE;
     803                 :            : }
     804                 :            : 
     805                 :            : /* Handle a "noreturn" attribute; arguments as in
     806                 :            :    struct attribute_spec.handler.  */
     807                 :            : 
     808                 :            : tree
     809                 :    2475860 : handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
     810                 :            :                            int ARG_UNUSED (flags), bool *no_add_attrs)
     811                 :            : {
     812                 :    2475860 :   tree type = TREE_TYPE (*node);
     813                 :            : 
     814                 :            :   /* See FIXME comment in c_common_attribute_table.  */
     815                 :    2475860 :   if (TREE_CODE (*node) == FUNCTION_DECL
     816                 :    2475860 :       || objc_method_decl (TREE_CODE (*node)))
     817                 :    2475800 :     TREE_THIS_VOLATILE (*node) = 1;
     818                 :         56 :   else if (TREE_CODE (type) == POINTER_TYPE
     819                 :        107 :            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
     820                 :        102 :     TREE_TYPE (*node)
     821                 :         51 :       = (build_qualified_type
     822                 :        153 :          (build_pointer_type
     823                 :        102 :           (build_type_variant (TREE_TYPE (type),
     824                 :            :                                TYPE_READONLY (TREE_TYPE (type)), 1)),
     825                 :         51 :           TYPE_QUALS (type)));
     826                 :            :   else
     827                 :            :     {
     828                 :          5 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
     829                 :          5 :       *no_add_attrs = true;
     830                 :            :     }
     831                 :            : 
     832                 :    2475860 :   return NULL_TREE;
     833                 :            : }
     834                 :            : 
     835                 :            : /* Handle a "hot" and attribute; arguments as in
     836                 :            :    struct attribute_spec.handler.  */
     837                 :            : 
     838                 :            : static tree
     839                 :         49 : handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
     840                 :            :                       int ARG_UNUSED (flags), bool *no_add_attrs)
     841                 :            : {
     842                 :         49 :   if (TREE_CODE (*node) == FUNCTION_DECL
     843                 :         49 :       || TREE_CODE (*node) == LABEL_DECL)
     844                 :            :     {
     845                 :            :       /* Attribute hot processing is done later with lookup_attribute.  */
     846                 :            :     }
     847                 :            :   else
     848                 :            :     {
     849                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
     850                 :          0 :       *no_add_attrs = true;
     851                 :            :     }
     852                 :            : 
     853                 :         49 :   return NULL_TREE;
     854                 :            : }
     855                 :            : 
     856                 :            : /* Handle a "cold" and attribute; arguments as in
     857                 :            :    struct attribute_spec.handler.  */
     858                 :            : 
     859                 :            : static tree
     860                 :     987804 : handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
     861                 :            :                        int ARG_UNUSED (flags), bool *no_add_attrs)
     862                 :            : {
     863                 :     987804 :   if (TREE_CODE (*node) == FUNCTION_DECL
     864                 :     987804 :       || TREE_CODE (*node) == LABEL_DECL)
     865                 :            :     {
     866                 :            :       /* Attribute cold processing is done later with lookup_attribute.  */
     867                 :            :     }
     868                 :            :   else
     869                 :            :     {
     870                 :          5 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
     871                 :          5 :       *no_add_attrs = true;
     872                 :            :     }
     873                 :            : 
     874                 :     987804 :   return NULL_TREE;
     875                 :            : }
     876                 :            : 
     877                 :            : /* Add FLAGS for a function NODE to no_sanitize_flags in DECL_ATTRIBUTES.  */
     878                 :            : 
     879                 :            : void
     880                 :        524 : add_no_sanitize_value (tree node, unsigned int flags)
     881                 :            : {
     882                 :        524 :   tree attr = lookup_attribute ("no_sanitize", DECL_ATTRIBUTES (node));
     883                 :        524 :   if (attr)
     884                 :            :     {
     885                 :         21 :       unsigned int old_value = tree_to_uhwi (TREE_VALUE (attr));
     886                 :         21 :       flags |= old_value;
     887                 :            : 
     888                 :         21 :       if (flags == old_value)
     889                 :            :         return;
     890                 :            : 
     891                 :          7 :       TREE_VALUE (attr) = build_int_cst (unsigned_type_node, flags);
     892                 :            :     }
     893                 :            :   else
     894                 :        503 :     DECL_ATTRIBUTES (node)
     895                 :        503 :       = tree_cons (get_identifier ("no_sanitize"),
     896                 :            :                    build_int_cst (unsigned_type_node, flags),
     897                 :        503 :                    DECL_ATTRIBUTES (node));
     898                 :            : }
     899                 :            : 
     900                 :            : /* Handle a "no_sanitize" attribute; arguments as in
     901                 :            :    struct attribute_spec.handler.  */
     902                 :            : 
     903                 :            : static tree
     904                 :        147 : handle_no_sanitize_attribute (tree *node, tree name, tree args, int,
     905                 :            :                               bool *no_add_attrs)
     906                 :            : {
     907                 :        147 :   unsigned int flags = 0;
     908                 :        147 :   *no_add_attrs = true;
     909                 :        147 :   if (TREE_CODE (*node) != FUNCTION_DECL)
     910                 :            :     {
     911                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
     912                 :          0 :       return NULL_TREE;
     913                 :            :     }
     914                 :            : 
     915                 :        378 :   for (; args; args = TREE_CHAIN (args))
     916                 :            :     {
     917                 :        231 :       tree id = TREE_VALUE (args);
     918                 :        231 :       if (TREE_CODE (id) != STRING_CST)
     919                 :            :         {
     920                 :          0 :           error ("%qE argument not a string", name);
     921                 :          0 :           return NULL_TREE;
     922                 :            :         }
     923                 :            : 
     924                 :        231 :       char *string = ASTRDUP (TREE_STRING_POINTER (id));
     925                 :        231 :       flags |= parse_no_sanitize_attribute (string);
     926                 :            :     }
     927                 :            : 
     928                 :        147 :   add_no_sanitize_value (*node, flags);
     929                 :            : 
     930                 :        147 :   return NULL_TREE;
     931                 :            : }
     932                 :            : 
     933                 :            : /* Handle a "no_sanitize_address" attribute; arguments as in
     934                 :            :    struct attribute_spec.handler.  */
     935                 :            : 
     936                 :            : static tree
     937                 :        149 : handle_no_sanitize_address_attribute (tree *node, tree name, tree, int,
     938                 :            :                                       bool *no_add_attrs)
     939                 :            : {
     940                 :        149 :   *no_add_attrs = true;
     941                 :        149 :   if (TREE_CODE (*node) != FUNCTION_DECL)
     942                 :         14 :     warning (OPT_Wattributes, "%qE attribute ignored", name);
     943                 :            :   else
     944                 :        135 :     add_no_sanitize_value (*node, SANITIZE_ADDRESS);
     945                 :            : 
     946                 :        149 :   return NULL_TREE;
     947                 :            : }
     948                 :            : 
     949                 :            : /* Handle a "no_sanitize_thread" attribute; arguments as in
     950                 :            :    struct attribute_spec.handler.  */
     951                 :            : 
     952                 :            : static tree
     953                 :          4 : handle_no_sanitize_thread_attribute (tree *node, tree name, tree, int,
     954                 :            :                                       bool *no_add_attrs)
     955                 :            : {
     956                 :          4 :   *no_add_attrs = true;
     957                 :          4 :   if (TREE_CODE (*node) != FUNCTION_DECL)
     958                 :          0 :     warning (OPT_Wattributes, "%qE attribute ignored", name);
     959                 :            :   else
     960                 :          4 :     add_no_sanitize_value (*node, SANITIZE_THREAD);
     961                 :            : 
     962                 :          4 :   return NULL_TREE;
     963                 :            : }
     964                 :            : 
     965                 :            : 
     966                 :            : /* Handle a "no_address_safety_analysis" attribute; arguments as in
     967                 :            :    struct attribute_spec.handler.  */
     968                 :            : 
     969                 :            : static tree
     970                 :         28 : handle_no_address_safety_analysis_attribute (tree *node, tree name, tree, int,
     971                 :            :                                              bool *no_add_attrs)
     972                 :            : {
     973                 :         28 :   *no_add_attrs = true;
     974                 :         28 :   if (TREE_CODE (*node) != FUNCTION_DECL)
     975                 :         14 :     warning (OPT_Wattributes, "%qE attribute ignored", name);
     976                 :            :   else
     977                 :         14 :     add_no_sanitize_value (*node, SANITIZE_ADDRESS);
     978                 :            : 
     979                 :         28 :   return NULL_TREE;
     980                 :            : }
     981                 :            : 
     982                 :            : /* Handle a "no_sanitize_undefined" attribute; arguments as in
     983                 :            :    struct attribute_spec.handler.  */
     984                 :            : 
     985                 :            : static tree
     986                 :        217 : handle_no_sanitize_undefined_attribute (tree *node, tree name, tree, int,
     987                 :            :                                       bool *no_add_attrs)
     988                 :            : {
     989                 :        217 :   *no_add_attrs = true;
     990                 :        217 :   if (TREE_CODE (*node) != FUNCTION_DECL)
     991                 :          0 :     warning (OPT_Wattributes, "%qE attribute ignored", name);
     992                 :            :   else
     993                 :        217 :     add_no_sanitize_value (*node,
     994                 :            :                            SANITIZE_UNDEFINED | SANITIZE_UNDEFINED_NONDEFAULT);
     995                 :            : 
     996                 :        217 :   return NULL_TREE;
     997                 :            : }
     998                 :            : 
     999                 :            : /* Handle an "asan odr indicator" attribute; arguments as in
    1000                 :            :    struct attribute_spec.handler.  */
    1001                 :            : 
    1002                 :            : static tree
    1003                 :          0 : handle_asan_odr_indicator_attribute (tree *, tree, tree, int, bool *)
    1004                 :            : {
    1005                 :          0 :   return NULL_TREE;
    1006                 :            : }
    1007                 :            : 
    1008                 :            : /* Handle a "stack_protect" attribute; arguments as in
    1009                 :            :    struct attribute_spec.handler.  */
    1010                 :            : 
    1011                 :            : static tree
    1012                 :          9 : handle_stack_protect_attribute (tree *node, tree name, tree, int,
    1013                 :            :                                 bool *no_add_attrs)
    1014                 :            : {
    1015                 :          9 :   if (TREE_CODE (*node) != FUNCTION_DECL)
    1016                 :            :     {
    1017                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1018                 :          0 :       *no_add_attrs = true;
    1019                 :            :     }
    1020                 :            : 
    1021                 :          9 :   return NULL_TREE;
    1022                 :            : }
    1023                 :            : 
    1024                 :            : /* Handle a "noipa" attribute; arguments as in
    1025                 :            :    struct attribute_spec.handler.  */
    1026                 :            : 
    1027                 :            : static tree
    1028                 :       4456 : handle_noipa_attribute (tree *node, tree name, tree, int, bool *no_add_attrs)
    1029                 :            : {
    1030                 :       4456 :   if (TREE_CODE (*node) != FUNCTION_DECL)
    1031                 :            :     {
    1032                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1033                 :          0 :       *no_add_attrs = true;
    1034                 :            :     }
    1035                 :            : 
    1036                 :       4456 :   return NULL_TREE;
    1037                 :            : }
    1038                 :            : 
    1039                 :            : /* Handle a "noinline" attribute; arguments as in
    1040                 :            :    struct attribute_spec.handler.  */
    1041                 :            : 
    1042                 :            : static tree
    1043                 :     257701 : handle_noinline_attribute (tree *node, tree name,
    1044                 :            :                            tree ARG_UNUSED (args),
    1045                 :            :                            int ARG_UNUSED (flags), bool *no_add_attrs)
    1046                 :            : {
    1047                 :     257701 :   if (TREE_CODE (*node) == FUNCTION_DECL)
    1048                 :            :     {
    1049                 :     257693 :       if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (*node)))
    1050                 :            :         {
    1051                 :          0 :           warning (OPT_Wattributes, "%qE attribute ignored due to conflict "
    1052                 :            :                    "with attribute %qs", name, "always_inline");
    1053                 :          0 :           *no_add_attrs = true;
    1054                 :            :         }
    1055                 :            :       else
    1056                 :     257693 :         DECL_UNINLINABLE (*node) = 1;
    1057                 :            :     }
    1058                 :            :   else
    1059                 :            :     {
    1060                 :          8 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1061                 :          8 :       *no_add_attrs = true;
    1062                 :            :     }
    1063                 :            : 
    1064                 :     257701 :   return NULL_TREE;
    1065                 :            : }
    1066                 :            : 
    1067                 :            : /* Handle a "noclone" attribute; arguments as in
    1068                 :            :    struct attribute_spec.handler.  */
    1069                 :            : 
    1070                 :            : static tree
    1071                 :     100272 : handle_noclone_attribute (tree *node, tree name,
    1072                 :            :                           tree ARG_UNUSED (args),
    1073                 :            :                           int ARG_UNUSED (flags), bool *no_add_attrs)
    1074                 :            : {
    1075                 :     100272 :   if (TREE_CODE (*node) != FUNCTION_DECL)
    1076                 :            :     {
    1077                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1078                 :          0 :       *no_add_attrs = true;
    1079                 :            :     }
    1080                 :            : 
    1081                 :     100272 :   return NULL_TREE;
    1082                 :            : }
    1083                 :            : 
    1084                 :            : /* Handle a "nocf_check" attribute; arguments as in
    1085                 :            :    struct attribute_spec.handler.  */
    1086                 :            : 
    1087                 :            : static tree
    1088                 :         77 : handle_nocf_check_attribute (tree *node, tree name,
    1089                 :            :                           tree ARG_UNUSED (args),
    1090                 :            :                           int ARG_UNUSED (flags), bool *no_add_attrs)
    1091                 :            : {
    1092                 :         77 :   if (TREE_CODE (*node) != FUNCTION_TYPE
    1093                 :         77 :       && TREE_CODE (*node) != METHOD_TYPE)
    1094                 :            :     {
    1095                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1096                 :          0 :       *no_add_attrs = true;
    1097                 :            :     }
    1098                 :         77 :   else if (!(flag_cf_protection & CF_BRANCH))
    1099                 :            :     {
    1100                 :         41 :       warning (OPT_Wattributes, "%qE attribute ignored. Use "
    1101                 :            :                                 "%<-fcf-protection%> option to enable it",
    1102                 :            :                                 name);
    1103                 :         41 :       *no_add_attrs = true;
    1104                 :            :     }
    1105                 :            : 
    1106                 :         77 :   return NULL_TREE;
    1107                 :            : }
    1108                 :            : 
    1109                 :            : /* Handle a "no_icf" attribute; arguments as in
    1110                 :            :    struct attribute_spec.handler.  */
    1111                 :            : 
    1112                 :            : static tree
    1113                 :       4471 : handle_noicf_attribute (tree *node, tree name,
    1114                 :            :                         tree ARG_UNUSED (args),
    1115                 :            :                         int ARG_UNUSED (flags), bool *no_add_attrs)
    1116                 :            : {
    1117                 :       4471 :   if (TREE_CODE (*node) != FUNCTION_DECL)
    1118                 :            :     {
    1119                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1120                 :          0 :       *no_add_attrs = true;
    1121                 :            :     }
    1122                 :            : 
    1123                 :       4471 :   return NULL_TREE;
    1124                 :            : }
    1125                 :            : 
    1126                 :            : 
    1127                 :            : /* Handle a "always_inline" attribute; arguments as in
    1128                 :            :    struct attribute_spec.handler.  */
    1129                 :            : 
    1130                 :            : static tree
    1131                 :   20558400 : handle_always_inline_attribute (tree *node, tree name,
    1132                 :            :                                 tree ARG_UNUSED (args),
    1133                 :            :                                 int ARG_UNUSED (flags),
    1134                 :            :                                 bool *no_add_attrs)
    1135                 :            : {
    1136                 :   20558400 :   if (TREE_CODE (*node) == FUNCTION_DECL)
    1137                 :            :     {
    1138                 :   20558400 :       if (lookup_attribute ("noinline", DECL_ATTRIBUTES (*node)))
    1139                 :            :         {
    1140                 :          0 :           warning (OPT_Wattributes, "%qE attribute ignored due to conflict "
    1141                 :            :                    "with %qs attribute", name, "noinline");
    1142                 :          0 :           *no_add_attrs = true;
    1143                 :            :         }
    1144                 :   20558400 :       else if (lookup_attribute ("target_clones", DECL_ATTRIBUTES (*node)))
    1145                 :            :         {
    1146                 :          4 :           warning (OPT_Wattributes, "%qE attribute ignored due to conflict "
    1147                 :            :                    "with %qs attribute", name, "target_clones");
    1148                 :          4 :           *no_add_attrs = true;
    1149                 :            :         }
    1150                 :            :       else
    1151                 :            :         /* Set the attribute and mark it for disregarding inline
    1152                 :            :            limits.  */
    1153                 :   20558400 :         DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
    1154                 :            :     }
    1155                 :            :   else
    1156                 :            :     {
    1157                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1158                 :          0 :       *no_add_attrs = true;
    1159                 :            :     }
    1160                 :            : 
    1161                 :   20558400 :   return NULL_TREE;
    1162                 :            : }
    1163                 :            : 
    1164                 :            : /* Handle a "gnu_inline" attribute; arguments as in
    1165                 :            :    struct attribute_spec.handler.  */
    1166                 :            : 
    1167                 :            : static tree
    1168                 :   20755600 : handle_gnu_inline_attribute (tree *node, tree name,
    1169                 :            :                              tree ARG_UNUSED (args),
    1170                 :            :                              int ARG_UNUSED (flags),
    1171                 :            :                              bool *no_add_attrs)
    1172                 :            : {
    1173                 :   20755600 :   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
    1174                 :            :     {
    1175                 :            :       /* Do nothing else, just set the attribute.  We'll get at
    1176                 :            :          it later with lookup_attribute.  */
    1177                 :            :     }
    1178                 :            :   else
    1179                 :            :     {
    1180                 :      51050 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1181                 :      51050 :       *no_add_attrs = true;
    1182                 :            :     }
    1183                 :            : 
    1184                 :   20755600 :   return NULL_TREE;
    1185                 :            : }
    1186                 :            : 
    1187                 :            : /* Handle a "leaf" attribute; arguments as in
    1188                 :            :    struct attribute_spec.handler.  */
    1189                 :            : 
    1190                 :            : static tree
    1191                 :  202667000 : handle_leaf_attribute (tree *node, tree name,
    1192                 :            :                        tree ARG_UNUSED (args),
    1193                 :            :                        int ARG_UNUSED (flags), bool *no_add_attrs)
    1194                 :            : {
    1195                 :  202667000 :   if (TREE_CODE (*node) != FUNCTION_DECL)
    1196                 :            :     {
    1197                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1198                 :          0 :       *no_add_attrs = true;
    1199                 :            :     }
    1200                 :  202667000 :   if (!TREE_PUBLIC (*node))
    1201                 :            :     {
    1202                 :          7 :       warning (OPT_Wattributes, "%qE attribute has no effect on unit local "
    1203                 :            :                "functions", name);
    1204                 :          7 :       *no_add_attrs = true;
    1205                 :            :     }
    1206                 :            : 
    1207                 :  202667000 :   return NULL_TREE;
    1208                 :            : }
    1209                 :            : 
    1210                 :            : /* Handle an "artificial" attribute; arguments as in
    1211                 :            :    struct attribute_spec.handler.  */
    1212                 :            : 
    1213                 :            : static tree
    1214                 :   20496700 : handle_artificial_attribute (tree *node, tree name,
    1215                 :            :                              tree ARG_UNUSED (args),
    1216                 :            :                              int ARG_UNUSED (flags),
    1217                 :            :                              bool *no_add_attrs)
    1218                 :            : {
    1219                 :   20496700 :   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
    1220                 :            :     {
    1221                 :            :       /* Do nothing else, just set the attribute.  We'll get at
    1222                 :            :          it later with lookup_attribute.  */
    1223                 :            :     }
    1224                 :            :   else
    1225                 :            :     {
    1226                 :      51050 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1227                 :      51050 :       *no_add_attrs = true;
    1228                 :            :     }
    1229                 :            : 
    1230                 :   20496700 :   return NULL_TREE;
    1231                 :            : }
    1232                 :            : 
    1233                 :            : /* Handle a "flatten" attribute; arguments as in
    1234                 :            :    struct attribute_spec.handler.  */
    1235                 :            : 
    1236                 :            : static tree
    1237                 :         87 : handle_flatten_attribute (tree *node, tree name,
    1238                 :            :                           tree args ATTRIBUTE_UNUSED,
    1239                 :            :                           int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
    1240                 :            : {
    1241                 :         87 :   if (TREE_CODE (*node) == FUNCTION_DECL)
    1242                 :            :     /* Do nothing else, just set the attribute.  We'll get at
    1243                 :            :        it later with lookup_attribute.  */
    1244                 :            :     ;
    1245                 :            :   else
    1246                 :            :     {
    1247                 :          5 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1248                 :          5 :       *no_add_attrs = true;
    1249                 :            :     }
    1250                 :            : 
    1251                 :         87 :   return NULL_TREE;
    1252                 :            : }
    1253                 :            : 
    1254                 :            : /* Handle a "warning" or "error" attribute; arguments as in
    1255                 :            :    struct attribute_spec.handler.  */
    1256                 :            : 
    1257                 :            : static tree
    1258                 :         68 : handle_error_attribute (tree *node, tree name, tree args,
    1259                 :            :                         int ARG_UNUSED (flags), bool *no_add_attrs)
    1260                 :            : {
    1261                 :         68 :   if (TREE_CODE (*node) == FUNCTION_DECL
    1262                 :        135 :       && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
    1263                 :            :     /* Do nothing else, just set the attribute.  We'll get at
    1264                 :            :        it later with lookup_attribute.  */
    1265                 :            :     ;
    1266                 :            :   else
    1267                 :            :     {
    1268                 :          3 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1269                 :          3 :       *no_add_attrs = true;
    1270                 :            :     }
    1271                 :            : 
    1272                 :         68 :   return NULL_TREE;
    1273                 :            : }
    1274                 :            : 
    1275                 :            : /* Handle a "used" attribute; arguments as in
    1276                 :            :    struct attribute_spec.handler.  */
    1277                 :            : 
    1278                 :            : static tree
    1279                 :       1098 : handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
    1280                 :            :                        int ARG_UNUSED (flags), bool *no_add_attrs)
    1281                 :            : {
    1282                 :       1098 :   tree node = *pnode;
    1283                 :            : 
    1284                 :       1098 :   if (TREE_CODE (node) == FUNCTION_DECL
    1285                 :        584 :       || (VAR_P (node) && TREE_STATIC (node))
    1286                 :         38 :       || (TREE_CODE (node) == TYPE_DECL))
    1287                 :            :     {
    1288                 :       1075 :       TREE_USED (node) = 1;
    1289                 :       1075 :       DECL_PRESERVE_P (node) = 1;
    1290                 :       1075 :       if (VAR_P (node))
    1291                 :        546 :         DECL_READ_P (node) = 1;
    1292                 :            :     }
    1293                 :            :   else
    1294                 :            :     {
    1295                 :         23 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1296                 :         23 :       *no_add_attrs = true;
    1297                 :            :     }
    1298                 :            : 
    1299                 :       1098 :   return NULL_TREE;
    1300                 :            : }
    1301                 :            : 
    1302                 :            : /* Handle a "unused" attribute; arguments as in
    1303                 :            :    struct attribute_spec.handler.  */
    1304                 :            : 
    1305                 :            : tree
    1306                 :     175387 : handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
    1307                 :            :                          int flags, bool *no_add_attrs)
    1308                 :            : {
    1309                 :     175387 :   if (DECL_P (*node))
    1310                 :            :     {
    1311                 :     175260 :       tree decl = *node;
    1312                 :            : 
    1313                 :     175260 :       if (TREE_CODE (decl) == PARM_DECL
    1314                 :     146220 :           || VAR_OR_FUNCTION_DECL_P (decl)
    1315                 :         94 :           || TREE_CODE (decl) == LABEL_DECL
    1316                 :         47 :           || TREE_CODE (decl) == CONST_DECL
    1317                 :         38 :           || TREE_CODE (decl) == TYPE_DECL)
    1318                 :            :         {
    1319                 :     175256 :           TREE_USED (decl) = 1;
    1320                 :     175256 :           if (VAR_P (decl) || TREE_CODE (decl) == PARM_DECL)
    1321                 :      82007 :             DECL_READ_P (decl) = 1;
    1322                 :            :         }
    1323                 :            :       else
    1324                 :            :         {
    1325                 :          4 :           warning (OPT_Wattributes, "%qE attribute ignored", name);
    1326                 :          4 :           *no_add_attrs = true;
    1327                 :            :         }
    1328                 :            :     }
    1329                 :            :   else
    1330                 :            :     {
    1331                 :        127 :       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
    1332                 :         80 :         *node = build_variant_type_copy (*node);
    1333                 :        127 :       TREE_USED (*node) = 1;
    1334                 :            :     }
    1335                 :            : 
    1336                 :     175387 :   return NULL_TREE;
    1337                 :            : }
    1338                 :            : 
    1339                 :            : /* Handle a "externally_visible" attribute; arguments as in
    1340                 :            :    struct attribute_spec.handler.  */
    1341                 :            : 
    1342                 :            : static tree
    1343                 :      48684 : handle_externally_visible_attribute (tree *pnode, tree name,
    1344                 :            :                                      tree ARG_UNUSED (args),
    1345                 :            :                                      int ARG_UNUSED (flags),
    1346                 :            :                                      bool *no_add_attrs)
    1347                 :            : {
    1348                 :      48684 :   tree node = *pnode;
    1349                 :            : 
    1350                 :      48684 :   if (VAR_OR_FUNCTION_DECL_P (node))
    1351                 :            :     {
    1352                 :      48635 :       if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
    1353                 :      97314 :            && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
    1354                 :            :         {
    1355                 :         21 :           warning (OPT_Wattributes,
    1356                 :            :                    "%qE attribute have effect only on public objects", name);
    1357                 :         21 :           *no_add_attrs = true;
    1358                 :            :         }
    1359                 :            :     }
    1360                 :            :   else
    1361                 :            :     {
    1362                 :          5 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1363                 :          5 :       *no_add_attrs = true;
    1364                 :            :     }
    1365                 :            : 
    1366                 :      48684 :   return NULL_TREE;
    1367                 :            : }
    1368                 :            : 
    1369                 :            : /* Handle the "no_reorder" attribute.  Arguments as in
    1370                 :            :    struct attribute_spec.handler.  */
    1371                 :            : 
    1372                 :            : static tree
    1373                 :          5 : handle_no_reorder_attribute (tree *pnode,
    1374                 :            :                              tree name,
    1375                 :            :                              tree,
    1376                 :            :                              int,
    1377                 :            :                              bool *no_add_attrs)
    1378                 :            : {
    1379                 :          5 :   tree node = *pnode;
    1380                 :            : 
    1381                 :          5 :   if (!VAR_OR_FUNCTION_DECL_P (node)
    1382                 :          5 :         && !(TREE_STATIC (node) || DECL_EXTERNAL (node)))
    1383                 :            :     {
    1384                 :          0 :       warning (OPT_Wattributes,
    1385                 :            :                 "%qE attribute only affects top level objects",
    1386                 :            :                 name);
    1387                 :          0 :       *no_add_attrs = true;
    1388                 :            :     }
    1389                 :            : 
    1390                 :          5 :   return NULL_TREE;
    1391                 :            : }
    1392                 :            : 
    1393                 :            : /* Handle a "const" attribute; arguments as in
    1394                 :            :    struct attribute_spec.handler.  */
    1395                 :            : 
    1396                 :            : static tree
    1397                 :   83490600 : handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
    1398                 :            :                         int flags, bool *no_add_attrs)
    1399                 :            : {
    1400                 :   83490600 :   tree type = TREE_TYPE (*node);
    1401                 :            : 
    1402                 :            :   /* See FIXME comment on noreturn in c_common_attribute_table.  */
    1403                 :   83490600 :   if (TREE_CODE (*node) == FUNCTION_DECL)
    1404                 :   83490600 :     TREE_READONLY (*node) = 1;
    1405                 :         36 :   else if (TREE_CODE (type) == POINTER_TYPE
    1406                 :         67 :            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
    1407                 :         62 :     TREE_TYPE (*node)
    1408                 :         31 :       = (build_qualified_type
    1409                 :         93 :          (build_pointer_type
    1410                 :         62 :           (build_type_variant (TREE_TYPE (type), 1,
    1411                 :            :                                TREE_THIS_VOLATILE (TREE_TYPE (type)))),
    1412                 :         31 :           TYPE_QUALS (type)));
    1413                 :            :   else
    1414                 :            :     {
    1415                 :          5 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1416                 :          5 :       *no_add_attrs = true;
    1417                 :            :     }
    1418                 :            : 
    1419                 :            :   /* void __builtin_unreachable(void) is const.  Accept other such
    1420                 :            :      built-ins but warn on user-defined functions that return void.  */
    1421                 :   83490600 :   if (!(flags & ATTR_FLAG_BUILT_IN)
    1422                 :     842144 :       && TREE_CODE (*node) == FUNCTION_DECL
    1423                 :   84332700 :       && VOID_TYPE_P (TREE_TYPE (type)))
    1424                 :         16 :     warning (OPT_Wattributes, "%qE attribute on function "
    1425                 :            :              "returning %<void%>", name);
    1426                 :            : 
    1427                 :   83490600 :   return NULL_TREE;
    1428                 :            : }
    1429                 :            : 
    1430                 :            : /* Handle a "scalar_storage_order" attribute; arguments as in
    1431                 :            :    struct attribute_spec.handler.  */
    1432                 :            : 
    1433                 :            : static tree
    1434                 :        847 : handle_scalar_storage_order_attribute (tree *node, tree name, tree args,
    1435                 :            :                                        int flags, bool *no_add_attrs)
    1436                 :            : {
    1437                 :        847 :   tree id = TREE_VALUE (args);
    1438                 :        847 :   tree type;
    1439                 :            : 
    1440                 :        847 :   if (TREE_CODE (*node) == TYPE_DECL
    1441                 :          3 :       && ! (flags & ATTR_FLAG_CXX11))
    1442                 :          3 :     node = &TREE_TYPE (*node);
    1443                 :        847 :   type = *node;
    1444                 :            : 
    1445                 :        847 :   if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN)
    1446                 :            :     {
    1447                 :            :       error ("%qE attribute is not supported because endianness is not uniform",
    1448                 :            :              name);
    1449                 :            :       return NULL_TREE;
    1450                 :            :     }
    1451                 :            : 
    1452                 :        847 :   if (RECORD_OR_UNION_TYPE_P (type) && !c_dialect_cxx ())
    1453                 :            :     {
    1454                 :        843 :       bool reverse = false;
    1455                 :            : 
    1456                 :        843 :       if (TREE_CODE (id) == STRING_CST
    1457                 :        843 :           && strcmp (TREE_STRING_POINTER (id), "big-endian") == 0)
    1458                 :            :         reverse = !BYTES_BIG_ENDIAN;
    1459                 :        416 :       else if (TREE_CODE (id) == STRING_CST
    1460                 :        416 :                && strcmp (TREE_STRING_POINTER (id), "little-endian") == 0)
    1461                 :            :         reverse = BYTES_BIG_ENDIAN;
    1462                 :            :       else
    1463                 :            :         {
    1464                 :          3 :           error ("attribute %qE argument must be one of %qs or %qs",
    1465                 :            :                  name, "big-endian", "little-endian");
    1466                 :          3 :           return NULL_TREE;
    1467                 :            :         }
    1468                 :            : 
    1469                 :        840 :       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
    1470                 :            :         {
    1471                 :          2 :           if (reverse)
    1472                 :            :             /* A type variant isn't good enough, since we don't want a cast
    1473                 :            :                to such a type to be removed as a no-op.  */
    1474                 :          1 :             *node = type = build_duplicate_type (type);
    1475                 :            :         }
    1476                 :            : 
    1477                 :        840 :       TYPE_REVERSE_STORAGE_ORDER (type) = reverse;
    1478                 :        840 :       return NULL_TREE;
    1479                 :            :     }
    1480                 :            : 
    1481                 :          4 :   warning (OPT_Wattributes, "%qE attribute ignored", name);
    1482                 :          4 :   *no_add_attrs = true;
    1483                 :          4 :   return NULL_TREE;
    1484                 :            : }
    1485                 :            : 
    1486                 :            : /* Handle a "transparent_union" attribute; arguments as in
    1487                 :            :    struct attribute_spec.handler.  */
    1488                 :            : 
    1489                 :            : static tree
    1490                 :        118 : handle_transparent_union_attribute (tree *node, tree name,
    1491                 :            :                                     tree ARG_UNUSED (args), int flags,
    1492                 :            :                                     bool *no_add_attrs)
    1493                 :            : {
    1494                 :        118 :   tree type;
    1495                 :            : 
    1496                 :        118 :   *no_add_attrs = true;
    1497                 :            : 
    1498                 :        118 :   if (TREE_CODE (*node) == TYPE_DECL
    1499                 :         57 :       && ! (flags & ATTR_FLAG_CXX11))
    1500                 :         51 :     node = &TREE_TYPE (*node);
    1501                 :        118 :   type = *node;
    1502                 :            : 
    1503                 :        118 :   if (TREE_CODE (type) == UNION_TYPE)
    1504                 :            :     {
    1505                 :            :       /* Make sure that the first field will work for a transparent union.
    1506                 :            :          If the type isn't complete yet, leave the check to the code in
    1507                 :            :          finish_struct.  */
    1508                 :        112 :       if (TYPE_SIZE (type))
    1509                 :            :         {
    1510                 :         51 :           tree first = first_field (type);
    1511                 :         51 :           if (first == NULL_TREE
    1512                 :         38 :               || DECL_ARTIFICIAL (first)
    1513                 :        127 :               || TYPE_MODE (type) != DECL_MODE (first))
    1514                 :         13 :             goto ignored;
    1515                 :            :         }
    1516                 :            : 
    1517                 :         99 :       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
    1518                 :            :         {
    1519                 :            :           /* If the type isn't complete yet, setting the flag
    1520                 :            :              on a variant wouldn't ever be checked.  */
    1521                 :         30 :           if (!TYPE_SIZE (type))
    1522                 :          0 :             goto ignored;
    1523                 :            : 
    1524                 :            :           /* build_duplicate_type doesn't work for C++.  */
    1525                 :         30 :           if (c_dialect_cxx ())
    1526                 :          4 :             goto ignored;
    1527                 :            : 
    1528                 :            :           /* A type variant isn't good enough, since we don't want a cast
    1529                 :            :              to such a type to be removed as a no-op.  */
    1530                 :         26 :           *node = type = build_duplicate_type (type);
    1531                 :            :         }
    1532                 :            : 
    1533                 :        210 :       for (tree t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
    1534                 :        230 :         TYPE_TRANSPARENT_AGGR (t) = 1;
    1535                 :            :       return NULL_TREE;
    1536                 :            :     }
    1537                 :            : 
    1538                 :          6 :  ignored:
    1539                 :         23 :   warning (OPT_Wattributes, "%qE attribute ignored", name);
    1540                 :         23 :   return NULL_TREE;
    1541                 :            : }
    1542                 :            : 
    1543                 :            : /* Subroutine of handle_{con,de}structor_attribute.  Evaluate ARGS to
    1544                 :            :    get the requested priority for a constructor or destructor,
    1545                 :            :    possibly issuing diagnostics for invalid or reserved
    1546                 :            :    priorities.  */
    1547                 :            : 
    1548                 :            : static priority_type
    1549                 :        543 : get_priority (tree args, bool is_destructor)
    1550                 :            : {
    1551                 :        543 :   HOST_WIDE_INT pri;
    1552                 :        543 :   tree arg;
    1553                 :            : 
    1554                 :        543 :   if (!args)
    1555                 :            :     return DEFAULT_INIT_PRIORITY;
    1556                 :            : 
    1557                 :        199 :   if (!SUPPORTS_INIT_PRIORITY)
    1558                 :            :     {
    1559                 :            :       if (is_destructor)
    1560                 :            :         error ("destructor priorities are not supported");
    1561                 :            :       else
    1562                 :            :         error ("constructor priorities are not supported");
    1563                 :            :       return DEFAULT_INIT_PRIORITY;
    1564                 :            :     }
    1565                 :            : 
    1566                 :        199 :   arg = TREE_VALUE (args);
    1567                 :        199 :   if (TREE_CODE (arg) == IDENTIFIER_NODE)
    1568                 :          0 :     goto invalid;
    1569                 :        199 :   if (arg == error_mark_node)
    1570                 :            :     return DEFAULT_INIT_PRIORITY;
    1571                 :        194 :   arg = default_conversion (arg);
    1572                 :        194 :   if (!tree_fits_shwi_p (arg)
    1573                 :        379 :       || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
    1574                 :         11 :     goto invalid;
    1575                 :            : 
    1576                 :        183 :   pri = tree_to_shwi (arg);
    1577                 :        183 :   if (pri < 0 || pri > MAX_INIT_PRIORITY)
    1578                 :          8 :     goto invalid;
    1579                 :            : 
    1580                 :        175 :   if (pri <= MAX_RESERVED_INIT_PRIORITY)
    1581                 :            :     {
    1582                 :         26 :       if (is_destructor)
    1583                 :         10 :         warning (OPT_Wprio_ctor_dtor,
    1584                 :            :                  "destructor priorities from 0 to %d are reserved "
    1585                 :            :                  "for the implementation",
    1586                 :            :                  MAX_RESERVED_INIT_PRIORITY);
    1587                 :            :       else
    1588                 :         16 :         warning (OPT_Wprio_ctor_dtor,
    1589                 :            :                  "constructor priorities from 0 to %d are reserved "
    1590                 :            :                  "for the implementation",
    1591                 :            :                  MAX_RESERVED_INIT_PRIORITY);
    1592                 :            :     }
    1593                 :        175 :   return pri;
    1594                 :            : 
    1595                 :         19 :  invalid:
    1596                 :         19 :   if (is_destructor)
    1597                 :          8 :     error ("destructor priorities must be integers from 0 to %d inclusive",
    1598                 :            :            MAX_INIT_PRIORITY);
    1599                 :            :   else
    1600                 :         11 :     error ("constructor priorities must be integers from 0 to %d inclusive",
    1601                 :            :            MAX_INIT_PRIORITY);
    1602                 :            :   return DEFAULT_INIT_PRIORITY;
    1603                 :            : }
    1604                 :            : 
    1605                 :            : /* Handle a "constructor" attribute; arguments as in
    1606                 :            :    struct attribute_spec.handler.  */
    1607                 :            : 
    1608                 :            : static tree
    1609                 :        394 : handle_constructor_attribute (tree *node, tree name, tree args,
    1610                 :            :                               int ARG_UNUSED (flags),
    1611                 :            :                               bool *no_add_attrs)
    1612                 :            : {
    1613                 :        394 :   tree decl = *node;
    1614                 :        394 :   tree type = TREE_TYPE (decl);
    1615                 :            : 
    1616                 :        394 :   if (TREE_CODE (decl) == FUNCTION_DECL
    1617                 :        394 :       && TREE_CODE (type) == FUNCTION_TYPE
    1618                 :        788 :       && decl_function_context (decl) == 0)
    1619                 :            :     {
    1620                 :        394 :       priority_type priority;
    1621                 :        394 :       DECL_STATIC_CONSTRUCTOR (decl) = 1;
    1622                 :        394 :       priority = get_priority (args, /*is_destructor=*/false);
    1623                 :        394 :       SET_DECL_INIT_PRIORITY (decl, priority);
    1624                 :        394 :       TREE_USED (decl) = 1;
    1625                 :            :     }
    1626                 :            :   else
    1627                 :            :     {
    1628                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1629                 :          0 :       *no_add_attrs = true;
    1630                 :            :     }
    1631                 :            : 
    1632                 :        394 :   return NULL_TREE;
    1633                 :            : }
    1634                 :            : 
    1635                 :            : /* Handle a "destructor" attribute; arguments as in
    1636                 :            :    struct attribute_spec.handler.  */
    1637                 :            : 
    1638                 :            : static tree
    1639                 :        149 : handle_destructor_attribute (tree *node, tree name, tree args,
    1640                 :            :                              int ARG_UNUSED (flags),
    1641                 :            :                              bool *no_add_attrs)
    1642                 :            : {
    1643                 :        149 :   tree decl = *node;
    1644                 :        149 :   tree type = TREE_TYPE (decl);
    1645                 :            : 
    1646                 :        149 :   if (TREE_CODE (decl) == FUNCTION_DECL
    1647                 :        149 :       && TREE_CODE (type) == FUNCTION_TYPE
    1648                 :        298 :       && decl_function_context (decl) == 0)
    1649                 :            :     {
    1650                 :        149 :       priority_type priority;
    1651                 :        149 :       DECL_STATIC_DESTRUCTOR (decl) = 1;
    1652                 :        149 :       priority = get_priority (args, /*is_destructor=*/true);
    1653                 :        149 :       SET_DECL_FINI_PRIORITY (decl, priority);
    1654                 :        149 :       TREE_USED (decl) = 1;
    1655                 :            :     }
    1656                 :            :   else
    1657                 :            :     {
    1658                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    1659                 :          0 :       *no_add_attrs = true;
    1660                 :            :     }
    1661                 :            : 
    1662                 :        149 :   return NULL_TREE;
    1663                 :            : }
    1664                 :            : 
    1665                 :            : /* Nonzero if the mode is a valid vector mode for this architecture.
    1666                 :            :    This returns nonzero even if there is no hardware support for the
    1667                 :            :    vector mode, but we can emulate with narrower modes.  */
    1668                 :            : 
    1669                 :            : static bool
    1670                 :          0 : vector_mode_valid_p (machine_mode mode)
    1671                 :            : {
    1672                 :          0 :   enum mode_class mclass = GET_MODE_CLASS (mode);
    1673                 :            : 
    1674                 :            :   /* Doh!  What's going on?  */
    1675                 :          0 :   if (mclass != MODE_VECTOR_INT
    1676                 :          0 :       && mclass != MODE_VECTOR_FLOAT
    1677                 :            :       && mclass != MODE_VECTOR_FRACT
    1678                 :          0 :       && mclass != MODE_VECTOR_UFRACT
    1679                 :            :       && mclass != MODE_VECTOR_ACCUM
    1680                 :          0 :       && mclass != MODE_VECTOR_UACCUM)
    1681                 :            :     return false;
    1682                 :            : 
    1683                 :            :   /* Hardware support.  Woo hoo!  */
    1684                 :          0 :   if (targetm.vector_mode_supported_p (mode))
    1685                 :            :     return true;
    1686                 :            : 
    1687                 :            :   /* We should probably return 1 if requesting V4DI and we have no DI,
    1688                 :            :      but we have V2DI, but this is probably very unlikely.  */
    1689                 :            : 
    1690                 :            :   /* If we have support for the inner mode, we can safely emulate it.
    1691                 :            :      We may not have V2DI, but me can emulate with a pair of DIs.  */
    1692                 :          0 :   return targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
    1693                 :            : }
    1694                 :            : 
    1695                 :            : 
    1696                 :            : /* Handle a "mode" attribute; arguments as in
    1697                 :            :    struct attribute_spec.handler.  */
    1698                 :            : 
    1699                 :            : static tree
    1700                 :      43812 : handle_mode_attribute (tree *node, tree name, tree args,
    1701                 :            :                        int ARG_UNUSED (flags), bool *no_add_attrs)
    1702                 :            : {
    1703                 :      43812 :   tree type = *node;
    1704                 :      43812 :   tree ident = TREE_VALUE (args);
    1705                 :            : 
    1706                 :      43812 :   *no_add_attrs = true;
    1707                 :            : 
    1708                 :      43812 :   if (TREE_CODE (ident) != IDENTIFIER_NODE)
    1709                 :          2 :     warning (OPT_Wattributes, "%qE attribute ignored", name);
    1710                 :            :   else
    1711                 :            :     {
    1712                 :      43810 :       int j;
    1713                 :      43810 :       const char *p = IDENTIFIER_POINTER (ident);
    1714                 :      43810 :       int len = strlen (p);
    1715                 :      43810 :       machine_mode mode = VOIDmode;
    1716                 :      43810 :       tree typefm;
    1717                 :      43810 :       bool valid_mode;
    1718                 :            : 
    1719                 :      43810 :       if (len > 4 && p[0] == '_' && p[1] == '_'
    1720                 :      23289 :           && p[len - 1] == '_' && p[len - 2] == '_')
    1721                 :            :         {
    1722                 :      23289 :           char *newp = (char *) alloca (len - 1);
    1723                 :            : 
    1724                 :      23289 :           strcpy (newp, &p[2]);
    1725                 :      23289 :           newp[len - 4] = '\0';
    1726                 :      23289 :           p = newp;
    1727                 :            :         }
    1728                 :            : 
    1729                 :            :       /* Change this type to have a type with the specified mode.
    1730                 :            :          First check for the special modes.  */
    1731                 :      43810 :       if (!strcmp (p, "byte"))
    1732                 :         82 :         mode = byte_mode;
    1733                 :      43728 :       else if (!strcmp (p, "word"))
    1734                 :      16875 :         mode = word_mode;
    1735                 :      26853 :       else if (!strcmp (p, "pointer"))
    1736                 :        736 :         mode = ptr_mode;
    1737                 :      26117 :       else if (!strcmp (p, "libgcc_cmp_return"))
    1738                 :        400 :         mode = targetm.libgcc_cmp_return_mode ();
    1739                 :      25717 :       else if (!strcmp (p, "libgcc_shift_count"))
    1740                 :        296 :         mode = targetm.libgcc_shift_count_mode ();
    1741                 :      25421 :       else if (!strcmp (p, "unwind_word"))
    1742                 :        402 :         mode = targetm.unwind_word_mode ();
    1743                 :            :       else
    1744                 :    1067220 :         for (j = 0; j < NUM_MACHINE_MODES; j++)
    1745                 :    1067220 :           if (!strcmp (p, GET_MODE_NAME (j)))
    1746                 :            :             {
    1747                 :      25017 :               mode = (machine_mode) j;
    1748                 :      25017 :               break;
    1749                 :            :             }
    1750                 :            : 
    1751                 :      43810 :       if (mode == VOIDmode)
    1752                 :            :         {
    1753                 :          2 :           error ("unknown machine mode %qE", ident);
    1754                 :          2 :           return NULL_TREE;
    1755                 :            :         }
    1756                 :            : 
    1757                 :            :       /* Allow the target a chance to translate MODE into something supported.
    1758                 :            :          See PR86324.  */
    1759                 :      43808 :       mode = targetm.translate_mode_attribute (mode);
    1760                 :            : 
    1761                 :      43808 :       valid_mode = false;
    1762                 :      43808 :       switch (GET_MODE_CLASS (mode))
    1763                 :            :         {
    1764                 :      32858 :         case MODE_INT:
    1765                 :      32858 :         case MODE_PARTIAL_INT:
    1766                 :      32858 :         case MODE_FLOAT:
    1767                 :      32858 :         case MODE_DECIMAL_FLOAT:
    1768                 :      32858 :         case MODE_FRACT:
    1769                 :      32858 :         case MODE_UFRACT:
    1770                 :      32858 :         case MODE_ACCUM:
    1771                 :      32858 :         case MODE_UACCUM:
    1772                 :      32858 :           valid_mode
    1773                 :      32858 :             = targetm.scalar_mode_supported_p (as_a <scalar_mode> (mode));
    1774                 :      32858 :           break;
    1775                 :            : 
    1776                 :      10950 :         case MODE_COMPLEX_INT:
    1777                 :      10950 :         case MODE_COMPLEX_FLOAT:
    1778                 :      10950 :           valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
    1779                 :      10950 :           break;
    1780                 :            : 
    1781                 :          0 :         case MODE_VECTOR_INT:
    1782                 :          0 :         case MODE_VECTOR_FLOAT:
    1783                 :          0 :         case MODE_VECTOR_FRACT:
    1784                 :          0 :         case MODE_VECTOR_UFRACT:
    1785                 :          0 :         case MODE_VECTOR_ACCUM:
    1786                 :          0 :         case MODE_VECTOR_UACCUM:
    1787                 :          0 :           warning (OPT_Wattributes, "specifying vector types with "
    1788                 :            :                    "%<__attribute__ ((mode))%> is deprecated");
    1789                 :          0 :           inform (input_location,
    1790                 :            :                   "use %<__attribute__ ((vector_size))%> instead");
    1791                 :          0 :           valid_mode = vector_mode_valid_p (mode);
    1792                 :          0 :           break;
    1793                 :            : 
    1794                 :            :         default:
    1795                 :            :           break;
    1796                 :            :         }
    1797                 :      43808 :       if (!valid_mode)
    1798                 :            :         {
    1799                 :          7 :           error ("unable to emulate %qs", p);
    1800                 :          7 :           return NULL_TREE;
    1801                 :            :         }
    1802                 :            : 
    1803                 :      43801 :       if (POINTER_TYPE_P (type))
    1804                 :            :         {
    1805                 :          0 :           scalar_int_mode addr_mode;
    1806                 :          0 :           addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (type));
    1807                 :          0 :           tree (*fn)(tree, machine_mode, bool);
    1808                 :            : 
    1809                 :          0 :           if (!is_a <scalar_int_mode> (mode, &addr_mode)
    1810                 :          0 :               || !targetm.addr_space.valid_pointer_mode (addr_mode, as))
    1811                 :            :             {
    1812                 :          0 :               error ("invalid pointer mode %qs", p);
    1813                 :          0 :               return NULL_TREE;
    1814                 :            :             }
    1815                 :            : 
    1816                 :          0 :           if (TREE_CODE (type) == POINTER_TYPE)
    1817                 :            :             fn = build_pointer_type_for_mode;
    1818                 :            :           else
    1819                 :          0 :             fn = build_reference_type_for_mode;
    1820                 :          0 :           typefm = fn (TREE_TYPE (type), addr_mode, false);
    1821                 :            :         }
    1822                 :            :       else
    1823                 :            :         {
    1824                 :            :           /* For fixed-point modes, we need to test if the signness of type
    1825                 :            :              and the machine mode are consistent.  */
    1826                 :      43801 :           if (ALL_FIXED_POINT_MODE_P (mode)
    1827                 :      43801 :               && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
    1828                 :            :             {
    1829                 :          0 :               error ("signedness of type and machine mode %qs don%'t match", p);
    1830                 :          0 :               return NULL_TREE;
    1831                 :            :             }
    1832                 :            :           /* For fixed-point modes, we need to pass saturating info.  */
    1833                 :      87602 :           typefm = lang_hooks.types.type_for_mode (mode,
    1834                 :      43801 :                         ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
    1835                 :      43801 :                                                       : TYPE_UNSIGNED (type));
    1836                 :            :         }
    1837                 :            : 
    1838                 :      43801 :       if (typefm == NULL_TREE)
    1839                 :            :         {
    1840                 :          0 :           error ("no data type for mode %qs", p);
    1841                 :          0 :           return NULL_TREE;
    1842                 :            :         }
    1843                 :      43801 :       else if (TREE_CODE (type) == ENUMERAL_TYPE)
    1844                 :            :         {
    1845                 :            :           /* For enumeral types, copy the precision from the integer
    1846                 :            :              type returned above.  If not an INTEGER_TYPE, we can't use
    1847                 :            :              this mode for this type.  */
    1848                 :        107 :           if (TREE_CODE (typefm) != INTEGER_TYPE)
    1849                 :            :             {
    1850                 :          0 :               error ("cannot use mode %qs for enumerated types", p);
    1851                 :          0 :               return NULL_TREE;
    1852                 :            :             }
    1853                 :            : 
    1854                 :        107 :           if (flags & ATTR_FLAG_TYPE_IN_PLACE)
    1855                 :            :             {
    1856                 :         34 :               TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
    1857                 :         34 :               typefm = type;
    1858                 :            :             }
    1859                 :            :           else
    1860                 :            :             {
    1861                 :            :               /* We cannot build a type variant, as there's code that assumes
    1862                 :            :                  that TYPE_MAIN_VARIANT has the same mode.  This includes the
    1863                 :            :                  debug generators.  Instead, create a subrange type.  This
    1864                 :            :                  results in all of the enumeral values being emitted only once
    1865                 :            :                  in the original, and the subtype gets them by reference.  */
    1866                 :         73 :               if (TYPE_UNSIGNED (type))
    1867                 :         73 :                 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
    1868                 :            :               else
    1869                 :          0 :                 typefm = make_signed_type (TYPE_PRECISION (typefm));
    1870                 :         73 :               TREE_TYPE (typefm) = type;
    1871                 :            :             }
    1872                 :        107 :           *no_add_attrs = false;
    1873                 :            :         }
    1874                 :      87388 :       else if (VECTOR_MODE_P (mode)
    1875                 :      43694 :                ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
    1876                 :      43694 :                : TREE_CODE (type) != TREE_CODE (typefm))
    1877                 :            :         {
    1878                 :          1 :           error ("mode %qs applied to inappropriate type", p);
    1879                 :          1 :           return NULL_TREE;
    1880                 :            :         }
    1881                 :            : 
    1882                 :      43800 :       *node = build_qualified_type (typefm, TYPE_QUALS (type));
    1883                 :            :     }
    1884                 :            : 
    1885                 :            :   return NULL_TREE;
    1886                 :            : }
    1887                 :            : 
    1888                 :            : /* Handle a "section" attribute; arguments as in
    1889                 :            :    struct attribute_spec.handler.  */
    1890                 :            : 
    1891                 :            : static tree
    1892                 :        283 : handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
    1893                 :            :                           int ARG_UNUSED (flags), bool *no_add_attrs)
    1894                 :            : {
    1895                 :        283 :   tree decl = *node;
    1896                 :        283 :   tree res = NULL_TREE;
    1897                 :            : 
    1898                 :        283 :   if (!targetm_common.have_named_sections)
    1899                 :            :     {
    1900                 :          0 :       error_at (DECL_SOURCE_LOCATION (*node),
    1901                 :            :                 "section attributes are not supported for this target");
    1902                 :          0 :       goto fail;
    1903                 :            :     }
    1904                 :            : 
    1905                 :        283 :   if (!VAR_OR_FUNCTION_DECL_P (decl))
    1906                 :            :     {
    1907                 :          0 :       error ("section attribute not allowed for %q+D", *node);
    1908                 :          0 :       goto fail;
    1909                 :            :     }
    1910                 :            : 
    1911                 :        283 :   if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
    1912                 :            :     {
    1913                 :          0 :       error ("section attribute argument not a string constant");
    1914                 :          0 :       goto fail;
    1915                 :            :     }
    1916                 :            : 
    1917                 :        283 :   if (VAR_P (decl)
    1918                 :        238 :       && current_function_decl != NULL_TREE
    1919                 :         10 :       && !TREE_STATIC (decl))
    1920                 :            :     {
    1921                 :          0 :       error_at (DECL_SOURCE_LOCATION (decl),
    1922                 :            :                 "section attribute cannot be specified for local variables");
    1923                 :          0 :       goto fail;
    1924                 :            :     }
    1925                 :            : 
    1926                 :            :   /* The decl may have already been given a section attribute
    1927                 :            :      from a previous declaration.  Ensure they match.  */
    1928                 :        283 :   if (DECL_SECTION_NAME (decl) != NULL
    1929                 :        283 :       && strcmp (DECL_SECTION_NAME (decl),
    1930                 :          0 :                  TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
    1931                 :            :     {
    1932                 :          0 :       error ("section of %q+D conflicts with previous declaration", *node);
    1933                 :          0 :       goto fail;
    1934                 :            :     }
    1935                 :            : 
    1936                 :        283 :   if (VAR_P (decl)
    1937                 :        238 :       && !targetm.have_tls && targetm.emutls.tmpl_section
    1938                 :        283 :       && DECL_THREAD_LOCAL_P (decl))
    1939                 :            :     {
    1940                 :          0 :       error ("section of %q+D cannot be overridden", *node);
    1941                 :          0 :       goto fail;
    1942                 :            :     }
    1943                 :            : 
    1944                 :        283 :   res = targetm.handle_generic_attribute (node, name, args, flags,
    1945                 :            :                                           no_add_attrs);
    1946                 :            : 
    1947                 :            :   /* If the back end confirms the attribute can be added then continue onto
    1948                 :            :      final processing.  */
    1949                 :        283 :   if (!(*no_add_attrs))
    1950                 :            :     {
    1951                 :        283 :       set_decl_section_name (decl, TREE_STRING_POINTER (TREE_VALUE (args)));
    1952                 :        283 :       return res;
    1953                 :            :     }
    1954                 :            : 
    1955                 :          0 : fail:
    1956                 :          0 :   *no_add_attrs = true;
    1957                 :          0 :   return res;
    1958                 :            : }
    1959                 :            : 
    1960                 :            : /* Common codes shared by handle_warn_if_not_aligned_attribute and
    1961                 :            :    handle_aligned_attribute.  */
    1962                 :            : 
    1963                 :            : static tree
    1964                 :     147033 : common_handle_aligned_attribute (tree *node, tree name, tree args, int flags,
    1965                 :            :                                  bool *no_add_attrs,
    1966                 :            :                                  bool warn_if_not_aligned_p)
    1967                 :            : {
    1968                 :     147033 :   tree decl = NULL_TREE;
    1969                 :     147033 :   tree *type = NULL;
    1970                 :     147033 :   bool is_type = false;
    1971                 :     147033 :   tree align_expr;
    1972                 :            : 
    1973                 :            :   /* The last (already pushed) declaration with all validated attributes
    1974                 :            :      merged in or the current about-to-be-pushed one if one hasn't been
    1975                 :            :      yet.  */
    1976                 :     147033 :   tree last_decl = node[1] ? node[1] : *node;
    1977                 :            : 
    1978                 :     147033 :   if (args)
    1979                 :            :     {
    1980                 :     135254 :       align_expr = TREE_VALUE (args);
    1981                 :     135254 :       if (align_expr && TREE_CODE (align_expr) != IDENTIFIER_NODE
    1982                 :     135254 :           && TREE_CODE (align_expr) != FUNCTION_DECL)
    1983                 :     135244 :         align_expr = default_conversion (align_expr);
    1984                 :            :     }
    1985                 :            :   else
    1986                 :      23558 :     align_expr = size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT);
    1987                 :            : 
    1988                 :     147033 :   if (DECL_P (*node))
    1989                 :            :     {
    1990                 :     130114 :       decl = *node;
    1991                 :     130114 :       type = &TREE_TYPE (decl);
    1992                 :     130114 :       is_type = TREE_CODE (*node) == TYPE_DECL;
    1993                 :            :     }
    1994                 :      16919 :   else if (TYPE_P (*node))
    1995                 :      16919 :     type = node, is_type = true;
    1996                 :            : 
    1997                 :            :   /* True to consider invalid alignments greater than MAX_OFILE_ALIGNMENT.  */
    1998                 :     294066 :   bool objfile = (TREE_CODE (*node) == FUNCTION_DECL
    1999                 :     147033 :                   || (VAR_P (*node) && TREE_STATIC (*node)));
    2000                 :            :   /* Log2 of specified alignment.  */
    2001                 :     147033 :   int pow2align = check_user_alignment (align_expr, objfile,
    2002                 :            :                                         /* warn_zero = */ true);
    2003                 :     147033 :   if (pow2align == -1)
    2004                 :            :     {
    2005                 :        163 :       *no_add_attrs = true;
    2006                 :        163 :       return NULL_TREE;
    2007                 :            :     }
    2008                 :            : 
    2009                 :            :   /* The alignment in bits corresponding to the specified alignment.  */
    2010                 :     146870 :   unsigned bitalign = (1U << pow2align) * BITS_PER_UNIT;
    2011                 :            : 
    2012                 :            :   /* The alignment of the current declaration and that of the last
    2013                 :            :      pushed declaration, determined on demand below.  */
    2014                 :     146870 :   unsigned curalign = 0;
    2015                 :     146870 :   unsigned lastalign = 0;
    2016                 :            : 
    2017                 :            :   /* True when SET_DECL_ALIGN() should be called for the decl when
    2018                 :            :      *NO_ADD_ATTRS is false.  */
    2019                 :     146870 :   bool set_align = true;
    2020                 :     146870 :   if (is_type)
    2021                 :            :     {
    2022                 :     108681 :       if ((flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
    2023                 :            :         /* OK, modify the type in place.  */;
    2024                 :            :       /* If we have a TYPE_DECL, then copy the type, so that we
    2025                 :            :          don't accidentally modify a builtin type.  See pushdecl.  */
    2026                 :      89243 :       else if (decl && TREE_TYPE (decl) != error_mark_node
    2027                 :     178794 :                && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
    2028                 :            :         {
    2029                 :      89130 :           tree tt = TREE_TYPE (decl);
    2030                 :      89130 :           *type = build_variant_type_copy (*type);
    2031                 :      89130 :           DECL_ORIGINAL_TYPE (decl) = tt;
    2032                 :      89130 :           TYPE_NAME (*type) = decl;
    2033                 :      89130 :           TREE_USED (*type) = TREE_USED (decl);
    2034                 :      89130 :           TREE_TYPE (decl) = *type;
    2035                 :            :         }
    2036                 :            :       else
    2037                 :        421 :         *type = build_variant_type_copy (*type);
    2038                 :            : 
    2039                 :     108681 :       if (warn_if_not_aligned_p)
    2040                 :            :         {
    2041                 :         90 :           SET_TYPE_WARN_IF_NOT_ALIGN (*type, bitalign);
    2042                 :         90 :           warn_if_not_aligned_p = false;
    2043                 :            :         }
    2044                 :            :       else
    2045                 :            :         {
    2046                 :     108591 :           SET_TYPE_ALIGN (*type, bitalign);
    2047                 :     108591 :           TYPE_USER_ALIGN (*type) = 1;
    2048                 :            :         }
    2049                 :            :     }
    2050                 :      38189 :   else if (! VAR_OR_FUNCTION_DECL_P (decl)
    2051                 :      34662 :            && TREE_CODE (decl) != FIELD_DECL)
    2052                 :            :     {
    2053                 :          0 :       error ("alignment may not be specified for %q+D", decl);
    2054                 :          0 :       *no_add_attrs = true;
    2055                 :            :     }
    2056                 :      38189 :   else if (TREE_CODE (decl) == FUNCTION_DECL
    2057                 :      38520 :            && ((curalign = DECL_ALIGN (decl)) > bitalign
    2058                 :        319 :                || ((lastalign = DECL_ALIGN (last_decl)) > bitalign)))
    2059                 :            :     {
    2060                 :            :       /* Either a prior attribute on the same declaration or one
    2061                 :            :          on a prior declaration of the same function specifies
    2062                 :            :          stricter alignment than this attribute.  */
    2063                 :         48 :       bool note = lastalign != 0;
    2064                 :         48 :       if (lastalign)
    2065                 :         36 :         curalign = lastalign;
    2066                 :            : 
    2067                 :         48 :       curalign /= BITS_PER_UNIT;
    2068                 :         48 :       unsigned newalign = bitalign / BITS_PER_UNIT;
    2069                 :            : 
    2070                 :         96 :       auto_diagnostic_group d;
    2071                 :         48 :       if ((DECL_USER_ALIGN (decl)
    2072                 :         84 :            || DECL_USER_ALIGN (last_decl)))
    2073                 :            :         {
    2074                 :         48 :           if (warning (OPT_Wattributes,
    2075                 :            :                        "ignoring attribute %<%E (%u)%> because it conflicts "
    2076                 :            :                        "with attribute %<%E (%u)%>",
    2077                 :            :                        name, newalign, name, curalign)
    2078                 :         48 :               && note)
    2079                 :         36 :             inform (DECL_SOURCE_LOCATION (last_decl),
    2080                 :            :                     "previous declaration here");
    2081                 :            :           /* Only reject attempts to relax/override an alignment
    2082                 :            :              explicitly specified previously and accept declarations
    2083                 :            :              that appear to relax the implicit function alignment for
    2084                 :            :              the target.  Both increasing and increasing the alignment
    2085                 :            :              set by -falign-functions setting is permitted.  */
    2086                 :         48 :           *no_add_attrs = true;
    2087                 :            :         }
    2088                 :          0 :       else if (!warn_if_not_aligned_p)
    2089                 :            :         {
    2090                 :            :           /* Do not fail for attribute warn_if_not_aligned.  Otherwise,
    2091                 :            :              silently avoid applying the alignment to the declaration
    2092                 :            :              because it's implicitly satisfied by the target.  Apply
    2093                 :            :              the attribute nevertheless so it can be retrieved by
    2094                 :            :              __builtin_has_attribute.  */
    2095                 :          0 :           set_align = false;
    2096                 :            :         }
    2097                 :            :     }
    2098                 :      38141 :   else if (DECL_USER_ALIGN (decl)
    2099                 :      38141 :            && DECL_ALIGN (decl) > bitalign)
    2100                 :            :     /* C++-11 [dcl.align/4]:
    2101                 :            : 
    2102                 :            :            When multiple alignment-specifiers are specified for an
    2103                 :            :            entity, the alignment requirement shall be set to the
    2104                 :            :            strictest specified alignment.
    2105                 :            : 
    2106                 :            :       This formally comes from the c++11 specification but we are
    2107                 :            :       doing it for the GNU attribute syntax as well.  */
    2108                 :          3 :     *no_add_attrs = true;
    2109                 :      38138 :   else if (!warn_if_not_aligned_p
    2110                 :      38073 :            && TREE_CODE (decl) == FUNCTION_DECL
    2111                 :      38416 :            && DECL_ALIGN (decl) > bitalign)
    2112                 :            :     {
    2113                 :            :       /* Don't warn for function alignment here if warn_if_not_aligned_p
    2114                 :            :          is true.  It will be warned about later.  */
    2115                 :          0 :       if (DECL_USER_ALIGN (decl))
    2116                 :            :         {
    2117                 :            :           /* Only reject attempts to relax/override an alignment
    2118                 :            :              explicitly specified previously and accept declarations
    2119                 :            :              that appear to relax the implicit function alignment for
    2120                 :            :              the target.  Both increasing and increasing the alignment
    2121                 :            :              set by -falign-functions setting is permitted.  */
    2122                 :          0 :           error ("alignment for %q+D was previously specified as %d "
    2123                 :            :                  "and may not be decreased", decl,
    2124                 :          0 :                  DECL_ALIGN (decl) / BITS_PER_UNIT);
    2125                 :          0 :           *no_add_attrs = true;
    2126                 :            :         }
    2127                 :            :     }
    2128                 :      38138 :   else if (warn_if_not_aligned_p
    2129                 :         65 :            && TREE_CODE (decl) == FIELD_DECL
    2130                 :      38193 :            && !DECL_C_BIT_FIELD (decl))
    2131                 :            :     {
    2132                 :         50 :       SET_DECL_WARN_IF_NOT_ALIGN (decl, bitalign);
    2133                 :         50 :       warn_if_not_aligned_p = false;
    2134                 :         50 :       set_align = false;
    2135                 :            :     }
    2136                 :            : 
    2137                 :     146870 :   if (warn_if_not_aligned_p)
    2138                 :            :     {
    2139                 :         15 :       error ("%<warn_if_not_aligned%> may not be specified for %q+D",
    2140                 :            :              decl);
    2141                 :         15 :       *no_add_attrs = true;
    2142                 :            :     }
    2143                 :     146855 :   else if (!is_type && !*no_add_attrs && set_align)
    2144                 :            :     {
    2145                 :      38073 :       SET_DECL_ALIGN (decl, bitalign);
    2146                 :      38073 :       DECL_USER_ALIGN (decl) = 1;
    2147                 :            :     }
    2148                 :            : 
    2149                 :            :   return NULL_TREE;
    2150                 :            : }
    2151                 :            : 
    2152                 :            : /* Handle a "aligned" attribute; arguments as in
    2153                 :            :    struct attribute_spec.handler.  */
    2154                 :            : 
    2155                 :            : static tree
    2156                 :     146878 : handle_aligned_attribute (tree *node, tree name, tree args,
    2157                 :            :                           int flags, bool *no_add_attrs)
    2158                 :            : {
    2159                 :     146878 :   return common_handle_aligned_attribute (node, name, args, flags,
    2160                 :     146878 :                                          no_add_attrs, false);
    2161                 :            : }
    2162                 :            : 
    2163                 :            : /* Handle a "warn_if_not_aligned" attribute; arguments as in
    2164                 :            :    struct attribute_spec.handler.  */
    2165                 :            : 
    2166                 :            : static tree
    2167                 :        155 : handle_warn_if_not_aligned_attribute (tree *node, tree name,
    2168                 :            :                                       tree args, int flags,
    2169                 :            :                                       bool *no_add_attrs)
    2170                 :            : {
    2171                 :        155 :   return common_handle_aligned_attribute (node, name, args, flags,
    2172                 :        155 :                                           no_add_attrs, true);
    2173                 :            : }
    2174                 :            : 
    2175                 :            : /* Handle a "weak" attribute; arguments as in
    2176                 :            :    struct attribute_spec.handler.  */
    2177                 :            : 
    2178                 :            : static tree
    2179                 :      15315 : handle_weak_attribute (tree *node, tree name,
    2180                 :            :                        tree ARG_UNUSED (args),
    2181                 :            :                        int ARG_UNUSED (flags),
    2182                 :            :                        bool * ARG_UNUSED (no_add_attrs))
    2183                 :            : {
    2184                 :      15315 :   if (TREE_CODE (*node) == FUNCTION_DECL
    2185                 :      15315 :       && DECL_DECLARED_INLINE_P (*node))
    2186                 :            :     {
    2187                 :          1 :       warning (OPT_Wattributes, "inline function %q+D declared weak", *node);
    2188                 :          1 :       *no_add_attrs = true;
    2189                 :            :     }
    2190                 :      15314 :   else if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node)))
    2191                 :            :     {
    2192                 :          1 :       error ("indirect function %q+D cannot be declared weak", *node);
    2193                 :          1 :       *no_add_attrs = true;
    2194                 :          1 :       return NULL_TREE;
    2195                 :            :     }
    2196                 :      15313 :   else if (VAR_OR_FUNCTION_DECL_P (*node))
    2197                 :      15308 :     declare_weak (*node);
    2198                 :            :   else
    2199                 :          5 :     warning (OPT_Wattributes, "%qE attribute ignored", name);
    2200                 :            : 
    2201                 :            :   return NULL_TREE;
    2202                 :            : }
    2203                 :            : 
    2204                 :            : /* Handle a "noinit" attribute; arguments as in struct
    2205                 :            :    attribute_spec.handler.  Check whether the attribute is allowed
    2206                 :            :    here and add the attribute to the variable decl tree or otherwise
    2207                 :            :    issue a diagnostic.  This function checks NODE is of the expected
    2208                 :            :    type and issues diagnostics otherwise using NAME.  If it is not of
    2209                 :            :    the expected type *NO_ADD_ATTRS will be set to true.  */
    2210                 :            : 
    2211                 :            : static tree
    2212                 :          0 : handle_noinit_attribute (tree * node,
    2213                 :            :                   tree   name,
    2214                 :            :                   tree   args,
    2215                 :            :                   int    flags ATTRIBUTE_UNUSED,
    2216                 :            :                   bool *no_add_attrs)
    2217                 :            : {
    2218                 :          0 :   const char *message = NULL;
    2219                 :          0 :   tree res = NULL_TREE;
    2220                 :            : 
    2221                 :          0 :   gcc_assert (DECL_P (*node));
    2222                 :          0 :   gcc_assert (args == NULL);
    2223                 :            : 
    2224                 :          0 :   if (TREE_CODE (*node) != VAR_DECL)
    2225                 :            :     message = G_("%qE attribute only applies to variables");
    2226                 :            : 
    2227                 :            :   /* Check that it's possible for the variable to have a section.  */
    2228                 :          0 :   else if ((TREE_STATIC (*node) || DECL_EXTERNAL (*node) || in_lto_p)
    2229                 :          0 :            && DECL_SECTION_NAME (*node))
    2230                 :            :     message = G_("%qE attribute cannot be applied to variables "
    2231                 :            :                  "with specific sections");
    2232                 :            : 
    2233                 :          0 :   else if (!targetm.have_switchable_bss_sections)
    2234                 :            :     message = G_("%qE attribute is specific to ELF targets");
    2235                 :            : 
    2236                 :          0 :   if (message)
    2237                 :            :     {
    2238                 :          0 :       warning (OPT_Wattributes, message, name);
    2239                 :          0 :       *no_add_attrs = true;
    2240                 :            :     }
    2241                 :            :   else
    2242                 :            :     {
    2243                 :          0 :       res = targetm.handle_generic_attribute (node, name, args, flags,
    2244                 :            :                                               no_add_attrs);
    2245                 :            :       /* If the back end confirms the attribute can be added then continue onto
    2246                 :            :          final processing.  */
    2247                 :          0 :       if (!(*no_add_attrs))
    2248                 :            :         {
    2249                 :            :           /* If this var is thought to be common, then change this.  Common
    2250                 :            :              variables are assigned to sections before the backend has a
    2251                 :            :              chance to process them.  Do this only if the attribute is
    2252                 :            :              valid.  */
    2253                 :          0 :           if (DECL_COMMON (*node))
    2254                 :          0 :             DECL_COMMON (*node) = 0;
    2255                 :            :         }
    2256                 :            :     }
    2257                 :            : 
    2258                 :          0 :   return res;
    2259                 :            : }
    2260                 :            : 
    2261                 :            : 
    2262                 :            : /* Handle a "noplt" attribute; arguments as in
    2263                 :            :    struct attribute_spec.handler.  */
    2264                 :            : 
    2265                 :            : static tree
    2266                 :          5 : handle_noplt_attribute (tree *node, tree name,
    2267                 :            :                        tree ARG_UNUSED (args),
    2268                 :            :                        int ARG_UNUSED (flags),
    2269                 :            :                        bool * ARG_UNUSED (no_add_attrs))
    2270                 :            : {
    2271                 :          5 :   if (TREE_CODE (*node) != FUNCTION_DECL)
    2272                 :            :     {
    2273                 :          0 :       warning (OPT_Wattributes,
    2274                 :            :                "%qE attribute is only applicable on functions", name);
    2275                 :          0 :       *no_add_attrs = true;
    2276                 :          0 :       return NULL_TREE;
    2277                 :            :     }
    2278                 :            :   return NULL_TREE;
    2279                 :            : }
    2280                 :            : 
    2281                 :            : /* Handle a "symver" attribute.  */
    2282                 :            : 
    2283                 :            : static tree
    2284                 :          0 : handle_symver_attribute (tree *node, tree ARG_UNUSED (name), tree args,
    2285                 :            :                          int ARG_UNUSED (flags), bool *no_add_attrs)
    2286                 :            : {
    2287                 :          0 :   tree symver;
    2288                 :          0 :   const char *symver_str;
    2289                 :            : 
    2290                 :          0 :   if (TREE_CODE (*node) != FUNCTION_DECL && TREE_CODE (*node) != VAR_DECL)
    2291                 :            :     {
    2292                 :          0 :       warning (OPT_Wattributes,
    2293                 :            :                "%<symver%> attribute only applies to functions and variables");
    2294                 :          0 :       *no_add_attrs = true;
    2295                 :          0 :       return NULL_TREE;
    2296                 :            :     }
    2297                 :            : 
    2298                 :          0 :   if (!decl_in_symtab_p (*node))
    2299                 :            :     {
    2300                 :          0 :       warning (OPT_Wattributes,
    2301                 :            :                "%<symver%> attribute is only applicable to symbols");
    2302                 :          0 :       *no_add_attrs = true;
    2303                 :          0 :       return NULL_TREE;
    2304                 :            :     }
    2305                 :            : 
    2306                 :          0 :   for (; args; args = TREE_CHAIN (args))
    2307                 :            :     {
    2308                 :          0 :       symver = TREE_VALUE (args);
    2309                 :          0 :       if (TREE_CODE (symver) != STRING_CST)
    2310                 :            :         {
    2311                 :          0 :           error ("%<symver%> attribute argument not a string constant");
    2312                 :          0 :           *no_add_attrs = true;
    2313                 :          0 :           return NULL_TREE;
    2314                 :            :         }
    2315                 :            : 
    2316                 :          0 :       symver_str = TREE_STRING_POINTER (symver);
    2317                 :            : 
    2318                 :          0 :       int ats = 0;
    2319                 :          0 :       for (int n = 0; (int)n < TREE_STRING_LENGTH (symver); n++)
    2320                 :          0 :         if (symver_str[n] == '@')
    2321                 :          0 :           ats++;
    2322                 :            : 
    2323                 :          0 :       if (ats != 1 && ats != 2)
    2324                 :            :         {
    2325                 :          0 :           error ("symver attribute argument must have format %<name@nodename%>");
    2326                 :          0 :           error ("%<symver%> attribute argument %qs must contain one or two "
    2327                 :            :                  "%<@%>", symver_str);
    2328                 :          0 :           *no_add_attrs = true;
    2329                 :          0 :           return NULL_TREE;
    2330                 :            :         }
    2331                 :            :     }
    2332                 :            : 
    2333                 :            :   return NULL_TREE;
    2334                 :            : }
    2335                 :            : 
    2336                 :            : 
    2337                 :            : /* Handle an "alias" or "ifunc" attribute; arguments as in
    2338                 :            :    struct attribute_spec.handler, except that IS_ALIAS tells us
    2339                 :            :    whether this is an alias as opposed to ifunc attribute.  */
    2340                 :            : 
    2341                 :            : static tree
    2342                 :     282480 : handle_alias_ifunc_attribute (bool is_alias, tree *node, tree name, tree args,
    2343                 :            :                               bool *no_add_attrs)
    2344                 :            : {
    2345                 :     282480 :   tree decl = *node;
    2346                 :            : 
    2347                 :     282480 :   if (TREE_CODE (decl) != FUNCTION_DECL
    2348                 :        187 :       && (!is_alias || !VAR_P (decl)))
    2349                 :            :     {
    2350                 :          1 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    2351                 :          1 :       *no_add_attrs = true;
    2352                 :            :     }
    2353                 :     282293 :   else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
    2354                 :     282479 :       || (TREE_CODE (decl) != FUNCTION_DECL
    2355                 :        313 :           && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
    2356                 :            :       /* A static variable declaration is always a tentative definition,
    2357                 :            :          but the alias is a non-tentative definition which overrides.  */
    2358                 :     564958 :       || (TREE_CODE (decl) != FUNCTION_DECL
    2359                 :        245 :           && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
    2360                 :            :     {
    2361                 :          0 :       error ("%q+D defined both normally and as %qE attribute", decl, name);
    2362                 :          0 :       *no_add_attrs = true;
    2363                 :          0 :       return NULL_TREE;
    2364                 :            :     }
    2365                 :     282479 :   else if (!is_alias
    2366                 :     282621 :            && (lookup_attribute ("weak", DECL_ATTRIBUTES (decl))
    2367                 :        141 :                || lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))))
    2368                 :            :     {
    2369                 :          1 :       error ("weak %q+D cannot be defined %qE", decl, name);
    2370                 :          1 :       *no_add_attrs = true;
    2371                 :          1 :       return NULL_TREE;
    2372                 :            :     }
    2373                 :            : 
    2374                 :            :   /* Note that the very first time we process a nested declaration,
    2375                 :            :      decl_function_context will not be set.  Indeed, *would* never
    2376                 :            :      be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
    2377                 :            :      we do below.  After such frobbery, pushdecl would set the context.
    2378                 :            :      In any case, this is never what we want.  */
    2379                 :     282478 :   else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
    2380                 :            :     {
    2381                 :     282470 :       tree id;
    2382                 :            : 
    2383                 :     282470 :       id = TREE_VALUE (args);
    2384                 :     282470 :       if (TREE_CODE (id) != STRING_CST)
    2385                 :            :         {
    2386                 :          0 :           error ("attribute %qE argument not a string", name);
    2387                 :          0 :           *no_add_attrs = true;
    2388                 :          0 :           return NULL_TREE;
    2389                 :            :         }
    2390                 :     282470 :       id = get_identifier (TREE_STRING_POINTER (id));
    2391                 :            :       /* This counts as a use of the object pointed to.  */
    2392                 :     282470 :       TREE_USED (id) = 1;
    2393                 :            : 
    2394                 :     282470 :       if (TREE_CODE (decl) == FUNCTION_DECL)
    2395                 :     282284 :         DECL_INITIAL (decl) = error_mark_node;
    2396                 :            :       else
    2397                 :        186 :         TREE_STATIC (decl) = 1;
    2398                 :            : 
    2399                 :     282470 :       if (!is_alias)
    2400                 :            :         {
    2401                 :            :           /* ifuncs are also aliases, so set that attribute too.  */
    2402                 :        141 :           DECL_ATTRIBUTES (decl)
    2403                 :        141 :             = tree_cons (get_identifier ("alias"), args,
    2404                 :        141 :                          DECL_ATTRIBUTES (decl));
    2405                 :        282 :           DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("ifunc"),
    2406                 :        141 :                                               NULL, DECL_ATTRIBUTES (decl));
    2407                 :            :         }
    2408                 :            :     }
    2409                 :            :   else
    2410                 :            :     {
    2411                 :          8 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    2412                 :          8 :       *no_add_attrs = true;
    2413                 :            :     }
    2414                 :            : 
    2415                 :     282479 :   if (decl_in_symtab_p (*node))
    2416                 :            :     {
    2417                 :     282478 :       struct symtab_node *n = symtab_node::get (decl);
    2418                 :     282478 :       if (n && n->refuse_visibility_changes)
    2419                 :          0 :         error ("%+qD declared %qs after being used",
    2420                 :            :                decl, is_alias ? "alias" : "ifunc");
    2421                 :            :     }
    2422                 :            : 
    2423                 :            : 
    2424                 :            :   return NULL_TREE;
    2425                 :            : }
    2426                 :            : 
    2427                 :            : /* Handle an "alias" or "ifunc" attribute; arguments as in
    2428                 :            :    struct attribute_spec.handler.  */
    2429                 :            : 
    2430                 :            : static tree
    2431                 :        142 : handle_ifunc_attribute (tree *node, tree name, tree args,
    2432                 :            :                         int ARG_UNUSED (flags), bool *no_add_attrs)
    2433                 :            : {
    2434                 :        142 :   return handle_alias_ifunc_attribute (false, node, name, args, no_add_attrs);
    2435                 :            : }
    2436                 :            : 
    2437                 :            : /* Handle an "alias" or "ifunc" attribute; arguments as in
    2438                 :            :    struct attribute_spec.handler.  */
    2439                 :            : 
    2440                 :            : static tree
    2441                 :     282338 : handle_alias_attribute (tree *node, tree name, tree args,
    2442                 :            :                         int ARG_UNUSED (flags), bool *no_add_attrs)
    2443                 :            : {
    2444                 :     282338 :   return handle_alias_ifunc_attribute (true, node, name, args, no_add_attrs);
    2445                 :            : }
    2446                 :            : 
    2447                 :            : /* Handle the "copy" attribute NAME by copying the set of attributes
    2448                 :            :    from the symbol referenced by ARGS to the declaration of *NODE.  */
    2449                 :            : 
    2450                 :            : static tree
    2451                 :      67990 : handle_copy_attribute (tree *node, tree name, tree args,
    2452                 :            :                        int flags, bool *no_add_attrs)
    2453                 :            : {
    2454                 :            :   /* Do not apply the copy attribute itself.  It serves no purpose
    2455                 :            :      other than to copy other attributes.  */
    2456                 :      67990 :   *no_add_attrs = true;
    2457                 :            : 
    2458                 :      67990 :   tree decl = *node;
    2459                 :            : 
    2460                 :      67990 :   tree ref = TREE_VALUE (args);
    2461                 :      67990 :   if (ref == error_mark_node)
    2462                 :            :     return NULL_TREE;
    2463                 :            : 
    2464                 :      67989 :   if (TREE_CODE (ref) == STRING_CST)
    2465                 :            :     {
    2466                 :            :       /* Explicitly handle this case since using a string literal
    2467                 :            :          as an argument is a likely mistake.  */
    2468                 :          1 :       error_at (DECL_SOURCE_LOCATION (decl),
    2469                 :            :                 "%qE attribute argument cannot be a string",
    2470                 :            :                 name);
    2471                 :          1 :       return NULL_TREE;
    2472                 :            :     }
    2473                 :            : 
    2474                 :      67988 :   if (CONSTANT_CLASS_P (ref)
    2475                 :      68007 :       && (INTEGRAL_TYPE_P (TREE_TYPE (ref))
    2476                 :         18 :           || FLOAT_TYPE_P (TREE_TYPE (ref))))
    2477                 :            :     {
    2478                 :            :       /* Similar to the string case, since some function attributes
    2479                 :            :          accept literal numbers as arguments (e.g., alloc_size or
    2480                 :            :          nonnull) using one here is a likely mistake.  */
    2481                 :          1 :       error_at (DECL_SOURCE_LOCATION (decl),
    2482                 :            :                 "%qE attribute argument cannot be a constant arithmetic "
    2483                 :            :                 "expression",
    2484                 :            :                 name);
    2485                 :          1 :       return NULL_TREE;
    2486                 :            :     }
    2487                 :            : 
    2488                 :      67987 :   if (ref == node[1])
    2489                 :            :     {
    2490                 :            :       /* Another possible mistake (but indirect self-references aren't
    2491                 :            :          and diagnosed and shouldn't be).  */
    2492                 :          9 :       if (warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wattributes,
    2493                 :            :                       "%qE attribute ignored on a redeclaration "
    2494                 :            :                       "of the referenced symbol",
    2495                 :            :                       name))
    2496                 :          9 :         inform (DECL_SOURCE_LOCATION (node[1]),
    2497                 :            :                 "previous declaration here");
    2498                 :          9 :       return NULL_TREE;
    2499                 :            :     }
    2500                 :            : 
    2501                 :            :   /* Consider address-of expressions in the attribute argument
    2502                 :            :      as requests to copy from the referenced entity.  */
    2503                 :      67978 :   if (TREE_CODE (ref) == ADDR_EXPR)
    2504                 :         20 :     ref = TREE_OPERAND (ref, 0);
    2505                 :            : 
    2506                 :      68032 :   do
    2507                 :            :     {
    2508                 :            :       /* Drill down into references to find the referenced decl.  */
    2509                 :      68032 :       tree_code refcode = TREE_CODE (ref);
    2510                 :      68032 :       if (refcode == ARRAY_REF
    2511                 :      68032 :           || refcode == INDIRECT_REF)
    2512                 :         64 :         ref = TREE_OPERAND (ref, 0);
    2513                 :      67968 :       else if (refcode == COMPONENT_REF)
    2514                 :         89 :         ref = TREE_OPERAND (ref, 1);
    2515                 :            :       else
    2516                 :            :         break;
    2517                 :        153 :     } while (!DECL_P (ref));
    2518                 :            : 
    2519                 :            :   /* For object pointer expressions, consider those to be requests
    2520                 :            :      to copy from their type, such as in:
    2521                 :            :        struct __attribute__ (copy ((struct T *)0)) U { ... };
    2522                 :            :      which copies type attributes from struct T to the declaration
    2523                 :            :      of struct U.  */
    2524                 :      67950 :   if ((CONSTANT_CLASS_P (ref) || EXPR_P (ref))
    2525                 :         89 :       && POINTER_TYPE_P (TREE_TYPE (ref))
    2526                 :      68045 :       && !FUNCTION_POINTER_TYPE_P (TREE_TYPE (ref)))
    2527                 :      67978 :     ref = TREE_TYPE (ref);
    2528                 :            : 
    2529                 :     135902 :   tree reftype = TYPE_P (ref) ? ref : TREE_TYPE (ref);
    2530                 :            : 
    2531                 :      67978 :   if (DECL_P (decl))
    2532                 :            :     {
    2533                 :      67976 :       if ((VAR_P (decl)
    2534                 :         21 :            && (TREE_CODE (ref) == FUNCTION_DECL
    2535                 :         20 :                || (EXPR_P (ref)
    2536                 :          1 :                    && POINTER_TYPE_P (reftype)
    2537                 :          1 :                    && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (reftype)))))
    2538                 :      67995 :           || (TREE_CODE (decl) == FUNCTION_DECL
    2539                 :      67782 :               && (VAR_P (ref)
    2540                 :      67781 :                   || (EXPR_P (ref)
    2541                 :         21 :                       && !FUNC_OR_METHOD_TYPE_P (reftype)
    2542                 :         13 :                       && (!POINTER_TYPE_P (reftype)
    2543                 :         12 :                           || !FUNC_OR_METHOD_TYPE_P (TREE_TYPE (reftype)))))))
    2544                 :            :         {
    2545                 :            :           /* It makes no sense to try to copy function attributes
    2546                 :            :              to a variable, or variable attributes to a function.  */
    2547                 :          4 :           if (warning (OPT_Wattributes,
    2548                 :            :                        "%qE attribute ignored on a declaration of "
    2549                 :            :                        "a different kind than referenced symbol",
    2550                 :            :                        name)
    2551                 :          4 :               && DECL_P (ref))
    2552                 :          2 :             inform (DECL_SOURCE_LOCATION (ref),
    2553                 :            :                     "symbol %qD referenced by %qD declared here", ref, decl);
    2554                 :          4 :           return NULL_TREE;
    2555                 :            :         }
    2556                 :            : 
    2557                 :      67972 :       tree attrs = NULL_TREE;
    2558                 :      67972 :       if (DECL_P (ref))
    2559                 :      67887 :         attrs = DECL_ATTRIBUTES (ref);
    2560                 :         85 :       else if (TYPE_P (ref))
    2561                 :         52 :         attrs = TYPE_ATTRIBUTES (ref);
    2562                 :            : 
    2563                 :            :       /* Copy decl attributes from REF to DECL.  */
    2564                 :      81556 :       for (tree at = attrs; at; at = TREE_CHAIN (at))
    2565                 :            :         {
    2566                 :            :           /* Avoid copying attributes that affect a symbol linkage,
    2567                 :            :              inlining, or visibility since those in all likelihood
    2568                 :            :              only apply to the target.
    2569                 :            :              FIXME: make it possible to specify which attributes to
    2570                 :            :              copy or not to copy in the copy attribute itself.  */
    2571                 :      13584 :           tree atname = get_attribute_name (at);
    2572                 :      13584 :           if (is_attribute_p ("alias", atname)
    2573                 :      13583 :               || is_attribute_p ("always_inline", atname)
    2574                 :      13581 :               || is_attribute_p ("gnu_inline", atname)
    2575                 :      11809 :               || is_attribute_p ("ifunc", atname)
    2576                 :      11809 :               || is_attribute_p ("noinline", atname)
    2577                 :      11809 :               || is_attribute_p ("visibility", atname)
    2578                 :      11576 :               || is_attribute_p ("weak", atname)
    2579                 :      11576 :               || is_attribute_p ("weakref", atname)
    2580                 :      25160 :               || is_attribute_p ("target_clones", atname))
    2581                 :       2009 :             continue;
    2582                 :            : 
    2583                 :            :           /* Attribute leaf only applies to extern functions.
    2584                 :            :              Avoid copying it to static ones.  */
    2585                 :      15223 :           if (!TREE_PUBLIC (decl)
    2586                 :      11575 :               && is_attribute_p ("leaf", atname))
    2587                 :       3648 :             continue;
    2588                 :            : 
    2589                 :       7927 :           tree atargs = TREE_VALUE (at);
    2590                 :            :           /* Create a copy of just the one attribute ar AT, including
    2591                 :            :              its argumentsm and add it to DECL.  */
    2592                 :       7927 :           tree attr = tree_cons (atname, copy_list (atargs), NULL_TREE);
    2593                 :       7927 :           decl_attributes (node, attr, flags,  EXPR_P (ref) ? NULL_TREE : ref);
    2594                 :            :         }
    2595                 :            : 
    2596                 :            :       /* Proceed to copy type attributes below.  */
    2597                 :            :     }
    2598                 :          2 :   else if (!TYPE_P (decl))
    2599                 :            :     {
    2600                 :          0 :       error_at (DECL_SOURCE_LOCATION (decl),
    2601                 :            :                 "%qE attribute must apply to a declaration",
    2602                 :            :                 name);
    2603                 :          0 :       return NULL_TREE;
    2604                 :            :     }
    2605                 :            : 
    2606                 :            :   /* A function declared with attribute nothrow has the attribute
    2607                 :            :      attached to it, but a C++ throw() function does not.  */
    2608                 :      67974 :   if (TREE_NOTHROW (ref))
    2609                 :      55611 :     TREE_NOTHROW (decl) = true;
    2610                 :            : 
    2611                 :            :   /* Similarly, a function declared with attribute noreturn has it
    2612                 :            :      attached on to it, but a C11 _Noreturn function does not.  */
    2613                 :      67974 :   if (DECL_P (ref)
    2614                 :      67887 :       && TREE_THIS_VOLATILE (ref)
    2615                 :         33 :       && FUNC_OR_METHOD_TYPE_P (reftype))
    2616                 :         32 :     TREE_THIS_VOLATILE (decl) = true;
    2617                 :            : 
    2618                 :      67974 :   if (POINTER_TYPE_P (reftype))
    2619                 :        119 :     reftype = TREE_TYPE (reftype);
    2620                 :            : 
    2621                 :      67974 :   if (!TYPE_P (reftype))
    2622                 :            :     return NULL_TREE;
    2623                 :            : 
    2624                 :      67974 :   tree attrs = TYPE_ATTRIBUTES (reftype);
    2625                 :            : 
    2626                 :            :   /* Copy type attributes from REF to DECL.  Pass in REF if it's a DECL
    2627                 :            :      or a type but not if it's an expression.  */
    2628                 :     114027 :   for (tree at = attrs; at; at = TREE_CHAIN (at))
    2629                 :      46086 :     decl_attributes (node, at, flags, EXPR_P (ref) ? NULL_TREE : ref);
    2630                 :            : 
    2631                 :            :   return NULL_TREE;
    2632                 :            : }
    2633                 :            : 
    2634                 :            : /* Handle a "weakref" attribute; arguments as in struct
    2635                 :            :    attribute_spec.handler.  */
    2636                 :            : 
    2637                 :            : static tree
    2638                 :     555857 : handle_weakref_attribute (tree *node, tree name, tree args,
    2639                 :            :                           int flags, bool *no_add_attrs)
    2640                 :            : {
    2641                 :     555857 :   tree attr = NULL_TREE;
    2642                 :            : 
    2643                 :            :   /* We must ignore the attribute when it is associated with
    2644                 :            :      local-scoped decls, since attribute alias is ignored and many
    2645                 :            :      such symbols do not even have a DECL_WEAK field.  */
    2646                 :     555857 :   if (decl_function_context (*node)
    2647                 :     555857 :       || current_function_decl
    2648                 :    1111710 :       || !VAR_OR_FUNCTION_DECL_P (*node))
    2649                 :            :     {
    2650                 :          2 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    2651                 :          2 :       *no_add_attrs = true;
    2652                 :          2 :       return NULL_TREE;
    2653                 :            :     }
    2654                 :            : 
    2655                 :     555855 :   if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node)))
    2656                 :            :     {
    2657                 :          0 :       error ("indirect function %q+D cannot be declared %qE",
    2658                 :            :              *node, name);
    2659                 :          0 :       *no_add_attrs = true;
    2660                 :          0 :       return NULL_TREE;
    2661                 :            :     }
    2662                 :            : 
    2663                 :            :   /* The idea here is that `weakref("name")' mutates into `weakref,
    2664                 :            :      alias("name")', and weakref without arguments, in turn,
    2665                 :            :      implicitly adds weak.  */
    2666                 :            : 
    2667                 :     555855 :   if (args)
    2668                 :            :     {
    2669                 :     277925 :       attr = tree_cons (get_identifier ("alias"), args, attr);
    2670                 :     277925 :       attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
    2671                 :            : 
    2672                 :     277925 :       *no_add_attrs = true;
    2673                 :            : 
    2674                 :     277925 :       decl_attributes (node, attr, flags);
    2675                 :            :     }
    2676                 :            :   else
    2677                 :            :     {
    2678                 :     277930 :       if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
    2679                 :          0 :         error_at (DECL_SOURCE_LOCATION (*node),
    2680                 :            :                   "%qE attribute must appear before %qs attribute",
    2681                 :            :                   name, "alias");
    2682                 :            : 
    2683                 :            :       /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
    2684                 :            :          and that isn't supported; and because it wants to add it to
    2685                 :            :          the list of weak decls, which isn't helpful.  */
    2686                 :     277930 :       DECL_WEAK (*node) = 1;
    2687                 :            :     }
    2688                 :            : 
    2689                 :     555855 :   if (decl_in_symtab_p (*node))
    2690                 :            :     {
    2691                 :     555855 :       struct symtab_node *n = symtab_node::get (*node);
    2692                 :     555855 :       if (n && n->refuse_visibility_changes)
    2693                 :          0 :         error ("%+qD declared %qE after being used", *node, name);
    2694                 :            :     }
    2695                 :            : 
    2696                 :            :   return NULL_TREE;
    2697                 :            : }
    2698                 :            : 
    2699                 :            : /* Handle an "visibility" attribute; arguments as in
    2700                 :            :    struct attribute_spec.handler.  */
    2701                 :            : 
    2702                 :            : static tree
    2703                 :     534806 : handle_visibility_attribute (tree *node, tree name, tree args,
    2704                 :            :                              int ARG_UNUSED (flags),
    2705                 :            :                              bool *ARG_UNUSED (no_add_attrs))
    2706                 :            : {
    2707                 :     534806 :   tree decl = *node;
    2708                 :     534806 :   tree id = TREE_VALUE (args);
    2709                 :     534806 :   enum symbol_visibility vis;
    2710                 :            : 
    2711                 :     534806 :   if (TYPE_P (*node))
    2712                 :            :     {
    2713                 :        151 :       if (TREE_CODE (*node) == ENUMERAL_TYPE)
    2714                 :            :         /* OK */;
    2715                 :        148 :       else if (!RECORD_OR_UNION_TYPE_P (*node))
    2716                 :            :         {
    2717                 :          0 :           warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
    2718                 :            :                    name);
    2719                 :          0 :           return NULL_TREE;
    2720                 :            :         }
    2721                 :        148 :       else if (TYPE_FIELDS (*node))
    2722                 :            :         {
    2723                 :          0 :           error ("%qE attribute ignored because %qT is already defined",
    2724                 :            :                  name, *node);
    2725                 :          0 :           return NULL_TREE;
    2726                 :            :         }
    2727                 :            :     }
    2728                 :     534655 :   else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
    2729                 :            :     {
    2730                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    2731                 :          0 :       return NULL_TREE;
    2732                 :            :     }
    2733                 :            : 
    2734                 :     534806 :   if (TREE_CODE (id) != STRING_CST)
    2735                 :            :     {
    2736                 :          0 :       error ("visibility argument not a string");
    2737                 :          0 :       return NULL_TREE;
    2738                 :            :     }
    2739                 :            : 
    2740                 :            :   /*  If this is a type, set the visibility on the type decl.  */
    2741                 :     534806 :   if (TYPE_P (decl))
    2742                 :            :     {
    2743                 :        151 :       decl = TYPE_NAME (decl);
    2744                 :        151 :       if (!decl)
    2745                 :            :         return NULL_TREE;
    2746                 :        151 :       if (TREE_CODE (decl) == IDENTIFIER_NODE)
    2747                 :            :         {
    2748                 :          1 :            warning (OPT_Wattributes, "%qE attribute ignored on types",
    2749                 :            :                     name);
    2750                 :          1 :            return NULL_TREE;
    2751                 :            :         }
    2752                 :            :     }
    2753                 :            : 
    2754                 :     534805 :   if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
    2755                 :            :     vis = VISIBILITY_DEFAULT;
    2756                 :     500468 :   else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
    2757                 :            :     vis = VISIBILITY_INTERNAL;
    2758                 :     500394 :   else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
    2759                 :            :     vis = VISIBILITY_HIDDEN;
    2760                 :         71 :   else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
    2761                 :            :     vis = VISIBILITY_PROTECTED;
    2762                 :            :   else
    2763                 :            :     {
    2764                 :          0 :       error ("attribute %qE argument must be one of %qs, %qs, %qs, or %qs",
    2765                 :            :              name, "default", "hidden", "protected", "internal");
    2766                 :          0 :       vis = VISIBILITY_DEFAULT;
    2767                 :            :     }
    2768                 :            : 
    2769                 :     534805 :   if (DECL_VISIBILITY_SPECIFIED (decl)
    2770                 :     534805 :       && vis != DECL_VISIBILITY (decl))
    2771                 :            :     {
    2772                 :         28 :       tree attributes = (TYPE_P (*node)
    2773                 :         28 :                          ? TYPE_ATTRIBUTES (*node)
    2774                 :         16 :                          : DECL_ATTRIBUTES (decl));
    2775                 :         28 :       if (lookup_attribute ("visibility", attributes))
    2776                 :          4 :         error ("%qD redeclared with different visibility", decl);
    2777                 :            :       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
    2778                 :            :                && lookup_attribute ("dllimport", attributes))
    2779                 :            :         error ("%qD was declared %qs which implies default visibility",
    2780                 :            :                decl, "dllimport");
    2781                 :            :       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
    2782                 :            :                && lookup_attribute ("dllexport", attributes))
    2783                 :            :         error ("%qD was declared %qs which implies default visibility",
    2784                 :            :                decl, "dllexport");
    2785                 :            :     }
    2786                 :            : 
    2787                 :     534805 :   DECL_VISIBILITY (decl) = vis;
    2788                 :     534805 :   DECL_VISIBILITY_SPECIFIED (decl) = 1;
    2789                 :            : 
    2790                 :            :   /* Go ahead and attach the attribute to the node as well.  This is needed
    2791                 :            :      so we can determine whether we have VISIBILITY_DEFAULT because the
    2792                 :            :      visibility was not specified, or because it was explicitly overridden
    2793                 :            :      from the containing scope.  */
    2794                 :            : 
    2795                 :     534805 :   return NULL_TREE;
    2796                 :            : }
    2797                 :            : 
    2798                 :            : /* Handle an "tls_model" attribute; arguments as in
    2799                 :            :    struct attribute_spec.handler.  */
    2800                 :            : 
    2801                 :            : static tree
    2802                 :        257 : handle_tls_model_attribute (tree *node, tree name, tree args,
    2803                 :            :                             int ARG_UNUSED (flags),
    2804                 :            :                             bool *ARG_UNUSED (no_add_attrs))
    2805                 :            : {
    2806                 :        257 :   tree id;
    2807                 :        257 :   tree decl = *node;
    2808                 :        257 :   enum tls_model kind;
    2809                 :            : 
    2810                 :        257 :   if (!VAR_P (decl))
    2811                 :            :     {
    2812                 :          2 :       warning (OPT_Wattributes, "%qE attribute ignored because %qD "
    2813                 :            :                "is not a variable",
    2814                 :            :                name, decl);
    2815                 :          2 :       return NULL_TREE;
    2816                 :            :     }
    2817                 :            : 
    2818                 :        313 :   if (!DECL_THREAD_LOCAL_P (decl))
    2819                 :            :     {
    2820                 :          2 :       warning (OPT_Wattributes, "%qE attribute ignored because %qD does "
    2821                 :            :                "not have thread storage duration", name, decl);
    2822                 :          2 :       return NULL_TREE;
    2823                 :            :     }
    2824                 :            : 
    2825                 :        253 :   kind = DECL_TLS_MODEL (decl);
    2826                 :        253 :   id = TREE_VALUE (args);
    2827                 :        253 :   if (TREE_CODE (id) != STRING_CST)
    2828                 :            :     {
    2829                 :          1 :       error ("%qE argument not a string", name);
    2830                 :          1 :       return NULL_TREE;
    2831                 :            :     }
    2832                 :            : 
    2833                 :        252 :   if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
    2834                 :            :     kind = TLS_MODEL_LOCAL_EXEC;
    2835                 :        225 :   else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
    2836                 :            :     kind = TLS_MODEL_INITIAL_EXEC;
    2837                 :        124 :   else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
    2838                 :         54 :     kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
    2839                 :         70 :   else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
    2840                 :            :     kind = TLS_MODEL_GLOBAL_DYNAMIC;
    2841                 :            :   else
    2842                 :          1 :     error ("%qE argument must be one of %qs, %qs, %qs, or %qs",
    2843                 :            :            name,
    2844                 :            :            "local-exec", "initial-exec", "local-dynamic", "global-dynamic");
    2845                 :            : 
    2846                 :        252 :   set_decl_tls_model (decl, kind);
    2847                 :        252 :   return NULL_TREE;
    2848                 :            : }
    2849                 :            : 
    2850                 :            : /* Handle a "no_instrument_function" attribute; arguments as in
    2851                 :            :    struct attribute_spec.handler.  */
    2852                 :            : 
    2853                 :            : static tree
    2854                 :         71 : handle_no_instrument_function_attribute (tree *node, tree name,
    2855                 :            :                                          tree ARG_UNUSED (args),
    2856                 :            :                                          int ARG_UNUSED (flags),
    2857                 :            :                                          bool *no_add_attrs)
    2858                 :            : {
    2859                 :         71 :   tree decl = *node;
    2860                 :            : 
    2861                 :         71 :   if (TREE_CODE (decl) != FUNCTION_DECL)
    2862                 :            :     {
    2863                 :          0 :       error_at (DECL_SOURCE_LOCATION (decl),
    2864                 :            :                 "%qE attribute applies only to functions", name);
    2865                 :          0 :       *no_add_attrs = true;
    2866                 :            :     }
    2867                 :            :   else
    2868                 :         71 :     DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
    2869                 :            : 
    2870                 :         71 :   return NULL_TREE;
    2871                 :            : }
    2872                 :            : 
    2873                 :            : /* Handle a "no_profile_instrument_function" attribute; arguments as in
    2874                 :            :    struct attribute_spec.handler.  */
    2875                 :            : 
    2876                 :            : static tree
    2877                 :          2 : handle_no_profile_instrument_function_attribute (tree *node, tree name, tree,
    2878                 :            :                                                  int, bool *no_add_attrs)
    2879                 :            : {
    2880                 :          2 :   if (TREE_CODE (*node) != FUNCTION_DECL)
    2881                 :            :     {
    2882                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    2883                 :          0 :       *no_add_attrs = true;
    2884                 :            :     }
    2885                 :            : 
    2886                 :          2 :   return NULL_TREE;
    2887                 :            : }
    2888                 :            : 
    2889                 :            : /* Handle a "malloc" attribute; arguments as in
    2890                 :            :    struct attribute_spec.handler.  */
    2891                 :            : 
    2892                 :            : static tree
    2893                 :    1839860 : handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
    2894                 :            :                          int ARG_UNUSED (flags), bool *no_add_attrs)
    2895                 :            : {
    2896                 :    1839860 :   if (TREE_CODE (*node) == FUNCTION_DECL
    2897                 :    1839860 :       && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
    2898                 :    1839860 :     DECL_IS_MALLOC (*node) = 1;
    2899                 :            :   else
    2900                 :            :     {
    2901                 :          4 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    2902                 :          4 :       *no_add_attrs = true;
    2903                 :            :     }
    2904                 :            : 
    2905                 :    1839860 :   return NULL_TREE;
    2906                 :            : }
    2907                 :            : 
    2908                 :            : /* Handle a "alloc_size" attribute; arguments as in
    2909                 :            :    struct attribute_spec.handler.  */
    2910                 :            : 
    2911                 :            : static tree
    2912                 :    1598280 : handle_alloc_size_attribute (tree *node, tree name, tree args,
    2913                 :            :                              int ARG_UNUSED (flags), bool *no_add_attrs)
    2914                 :            : {
    2915                 :    1598280 :   tree decl = *node;
    2916                 :    1598280 :   tree rettype = TREE_TYPE (decl);
    2917                 :    1598280 :   if (!POINTER_TYPE_P (rettype))
    2918                 :            :     {
    2919                 :         46 :       warning (OPT_Wattributes,
    2920                 :            :                "%qE attribute ignored on a function returning %qT",
    2921                 :            :                name, rettype);
    2922                 :         46 :       *no_add_attrs = true;
    2923                 :         46 :       return NULL_TREE;
    2924                 :            :     }
    2925                 :            : 
    2926                 :    3540850 :   for (int i = 1; args; ++i)
    2927                 :            :     {
    2928                 :    1942660 :       tree pos = TREE_VALUE (args);
    2929                 :            :       /* NEXT is null when the attribute includes just one argument.
    2930                 :            :          That's used to tell positional_argument to avoid mentioning
    2931                 :            :          the argument number in diagnostics (since there's just one
    2932                 :            :          mentioning it is unnecessary and coule be confusing).  */
    2933                 :    1942660 :       tree next = TREE_CHAIN (args);
    2934                 :    1942660 :       if (tree val = positional_argument (decl, name, pos, INTEGER_TYPE,
    2935                 :    1942660 :                                           next || i > 1 ? i : 0))
    2936                 :    1942620 :         TREE_VALUE (args) = val;
    2937                 :            :       else
    2938                 :            :         {
    2939                 :         41 :           *no_add_attrs = true;
    2940                 :         41 :           break;
    2941                 :            :         }
    2942                 :            : 
    2943                 :    1942620 :       args = next;
    2944                 :            :     }
    2945                 :            : 
    2946                 :            :   return NULL_TREE;
    2947                 :            : }
    2948                 :            : 
    2949                 :            : /* Handle a "alloc_align" attribute; arguments as in
    2950                 :            :    struct attribute_spec.handler.  */
    2951                 :            : 
    2952                 :            : static tree
    2953                 :        239 : handle_alloc_align_attribute (tree *node, tree name, tree args, int,
    2954                 :            :                               bool *no_add_attrs)
    2955                 :            : {
    2956                 :        239 :   tree decl = *node;
    2957                 :        239 :   tree rettype = TREE_TYPE (decl);
    2958                 :        239 :   if (!POINTER_TYPE_P (rettype))
    2959                 :            :     {
    2960                 :         13 :       warning (OPT_Wattributes,
    2961                 :            :                "%qE attribute ignored on a function returning %qT",
    2962                 :            :                name, rettype);
    2963                 :         13 :       *no_add_attrs = true;
    2964                 :         13 :       return NULL_TREE;
    2965                 :            :     }
    2966                 :            : 
    2967                 :        226 :   if (!positional_argument (*node, name, TREE_VALUE (args), INTEGER_TYPE))
    2968                 :         37 :     *no_add_attrs = true;
    2969                 :            : 
    2970                 :            :   return NULL_TREE;
    2971                 :            : }
    2972                 :            : 
    2973                 :            : /* Handle a "assume_aligned" attribute; arguments as in
    2974                 :            :    struct attribute_spec.handler.  */
    2975                 :            : 
    2976                 :            : static tree
    2977                 :         45 : handle_assume_aligned_attribute (tree *node, tree name, tree args, int,
    2978                 :            :                                  bool *no_add_attrs)
    2979                 :            : {
    2980                 :         45 :   tree decl = *node;
    2981                 :         45 :   tree rettype = TREE_TYPE (decl);
    2982                 :         45 :   if (TREE_CODE (rettype) != POINTER_TYPE)
    2983                 :            :     {
    2984                 :          7 :       warning (OPT_Wattributes,
    2985                 :            :                "%qE attribute ignored on a function returning %qT",
    2986                 :            :                name, rettype);
    2987                 :          7 :       *no_add_attrs = true;
    2988                 :          7 :       return NULL_TREE;
    2989                 :            :     }
    2990                 :            : 
    2991                 :            :   /* The alignment specified by the first argument.  */
    2992                 :            :   tree align = NULL_TREE;
    2993                 :            : 
    2994                 :         76 :   for (; args; args = TREE_CHAIN (args))
    2995                 :            :     {
    2996                 :         52 :       tree val = TREE_VALUE (args);
    2997                 :         52 :       if (val && TREE_CODE (val) != IDENTIFIER_NODE
    2998                 :         52 :           && TREE_CODE (val) != FUNCTION_DECL)
    2999                 :         47 :         val = default_conversion (val);
    3000                 :            : 
    3001                 :         52 :       if (!tree_fits_shwi_p (val))
    3002                 :            :         {
    3003                 :          6 :           warning (OPT_Wattributes,
    3004                 :            :                    "%qE attribute %E is not an integer constant",
    3005                 :            :                    name, val);
    3006                 :          6 :           *no_add_attrs = true;
    3007                 :          6 :           return NULL_TREE;
    3008                 :            :         }
    3009                 :            : 
    3010                 :         46 :       if (!align)
    3011                 :            :         {
    3012                 :            :           /* Validate and save the alignment.  */
    3013                 :         32 :           if (!integer_pow2p (val))
    3014                 :            :             {
    3015                 :          6 :               warning (OPT_Wattributes,
    3016                 :            :                        "%qE attribute argument %E is not a power of 2",
    3017                 :            :                        name, val);
    3018                 :          6 :               *no_add_attrs = true;
    3019                 :          6 :               return NULL_TREE;
    3020                 :            :             }
    3021                 :            : 
    3022                 :            :           align = val;
    3023                 :            :         }
    3024                 :         14 :       else if (tree_int_cst_sgn (val) < 0 || tree_int_cst_le (align, val))
    3025                 :            :         {
    3026                 :            :           /* The misalignment specified by the second argument
    3027                 :            :              must be non-negative and less than the alignment.  */
    3028                 :          2 :           warning (OPT_Wattributes,
    3029                 :            :                    "%qE attribute argument %E is not in the range [0, %wu]",
    3030                 :          2 :                    name, val, tree_to_uhwi (align) - 1);
    3031                 :          2 :           *no_add_attrs = true;
    3032                 :          2 :           return NULL_TREE;
    3033                 :            :         }
    3034                 :            :     }
    3035                 :            :   return NULL_TREE;
    3036                 :            : }
    3037                 :            : 
    3038                 :            : /* Handle a "fn spec" attribute; arguments as in
    3039                 :            :    struct attribute_spec.handler.  */
    3040                 :            : 
    3041                 :            : static tree
    3042                 :    4088200 : handle_fnspec_attribute (tree *node ATTRIBUTE_UNUSED, tree ARG_UNUSED (name),
    3043                 :            :                          tree args, int ARG_UNUSED (flags),
    3044                 :            :                          bool *no_add_attrs ATTRIBUTE_UNUSED)
    3045                 :            : {
    3046                 :   12264600 :   gcc_assert (args
    3047                 :            :               && TREE_CODE (TREE_VALUE (args)) == STRING_CST
    3048                 :            :               && !TREE_CHAIN (args));
    3049                 :    4088200 :   return NULL_TREE;
    3050                 :            : }
    3051                 :            : 
    3052                 :            : /* Handle a "warn_unused" attribute; arguments as in
    3053                 :            :    struct attribute_spec.handler.  */
    3054                 :            : 
    3055                 :            : static tree
    3056                 :          4 : handle_warn_unused_attribute (tree *node, tree name,
    3057                 :            :                               tree args ATTRIBUTE_UNUSED,
    3058                 :            :                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
    3059                 :            : {
    3060                 :          4 :   if (TYPE_P (*node))
    3061                 :            :     /* Do nothing else, just set the attribute.  We'll get at
    3062                 :            :        it later with lookup_attribute.  */
    3063                 :            :     ;
    3064                 :            :   else
    3065                 :            :     {
    3066                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    3067                 :          0 :       *no_add_attrs = true;
    3068                 :            :     }
    3069                 :            : 
    3070                 :          4 :   return NULL_TREE;
    3071                 :            : }
    3072                 :            : 
    3073                 :            : /* Handle an "omp declare simd" attribute; arguments as in
    3074                 :            :    struct attribute_spec.handler.  */
    3075                 :            : 
    3076                 :            : static tree
    3077                 :        770 : handle_omp_declare_simd_attribute (tree *, tree, tree, int, bool *)
    3078                 :            : {
    3079                 :        770 :   return NULL_TREE;
    3080                 :            : }
    3081                 :            : 
    3082                 :            : /* Handle an "omp declare variant {base,variant}" attribute; arguments as in
    3083                 :            :    struct attribute_spec.handler.  */
    3084                 :            : 
    3085                 :            : static tree
    3086                 :       1057 : handle_omp_declare_variant_attribute (tree *, tree, tree, int, bool *)
    3087                 :            : {
    3088                 :       1057 :   return NULL_TREE;
    3089                 :            : }
    3090                 :            : 
    3091                 :            : /* Handle a "simd" attribute.  */
    3092                 :            : 
    3093                 :            : static tree
    3094                 :       1684 : handle_simd_attribute (tree *node, tree name, tree args, int, bool *no_add_attrs)
    3095                 :            : {
    3096                 :       1684 :   if (TREE_CODE (*node) == FUNCTION_DECL)
    3097                 :            :     {
    3098                 :       1684 :       tree t = get_identifier ("omp declare simd");
    3099                 :       1684 :       tree attr = NULL_TREE;
    3100                 :       1684 :       if (args)
    3101                 :            :         {
    3102                 :       1637 :           tree id = TREE_VALUE (args);
    3103                 :            : 
    3104                 :       1637 :           if (TREE_CODE (id) != STRING_CST)
    3105                 :            :             {
    3106                 :          0 :               error ("attribute %qE argument not a string", name);
    3107                 :          0 :               *no_add_attrs = true;
    3108                 :          0 :               return NULL_TREE;
    3109                 :            :             }
    3110                 :            : 
    3111                 :       1637 :           if (strcmp (TREE_STRING_POINTER (id), "notinbranch") == 0)
    3112                 :       1627 :             attr = build_omp_clause (DECL_SOURCE_LOCATION (*node),
    3113                 :            :                                      OMP_CLAUSE_NOTINBRANCH);
    3114                 :         10 :           else if (strcmp (TREE_STRING_POINTER (id), "inbranch") == 0)
    3115                 :          5 :             attr = build_omp_clause (DECL_SOURCE_LOCATION (*node),
    3116                 :            :                                      OMP_CLAUSE_INBRANCH);
    3117                 :            :           else
    3118                 :            :             {
    3119                 :          5 :               error ("only %<inbranch%> and %<notinbranch%> flags are "
    3120                 :            :                      "allowed for %<__simd__%> attribute");
    3121                 :          5 :               *no_add_attrs = true;
    3122                 :          5 :               return NULL_TREE;
    3123                 :            :             }
    3124                 :            :         }
    3125                 :            : 
    3126                 :       1679 :       DECL_ATTRIBUTES (*node)
    3127                 :       1679 :         = tree_cons (t, build_tree_list (NULL_TREE, attr),
    3128                 :       1679 :                      DECL_ATTRIBUTES (*node));
    3129                 :            :     }
    3130                 :            :   else
    3131                 :            :     {
    3132                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    3133                 :          0 :       *no_add_attrs = true;
    3134                 :            :     }
    3135                 :            : 
    3136                 :            :   return NULL_TREE;
    3137                 :            : }
    3138                 :            : 
    3139                 :            : /* Handle an "omp declare target" attribute; arguments as in
    3140                 :            :    struct attribute_spec.handler.  */
    3141                 :            : 
    3142                 :            : static tree
    3143                 :       4400 : handle_omp_declare_target_attribute (tree *, tree, tree, int, bool *)
    3144                 :            : {
    3145                 :       4400 :   return NULL_TREE;
    3146                 :            : }
    3147                 :            : 
    3148                 :            : /* Handle a "returns_twice" attribute; arguments as in
    3149                 :            :    struct attribute_spec.handler.  */
    3150                 :            : 
    3151                 :            : static tree
    3152                 :     157462 : handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
    3153                 :            :                          int ARG_UNUSED (flags), bool *no_add_attrs)
    3154                 :            : {
    3155                 :     157462 :   if (TREE_CODE (*node) == FUNCTION_DECL)
    3156                 :     157462 :     DECL_IS_RETURNS_TWICE (*node) = 1;
    3157                 :            :   else
    3158                 :            :     {
    3159                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    3160                 :          0 :       *no_add_attrs = true;
    3161                 :            :     }
    3162                 :            : 
    3163                 :     157462 :   return NULL_TREE;
    3164                 :            : }
    3165                 :            : 
    3166                 :            : /* Handle a "no_limit_stack" attribute; arguments as in
    3167                 :            :    struct attribute_spec.handler.  */
    3168                 :            : 
    3169                 :            : static tree
    3170                 :          0 : handle_no_limit_stack_attribute (tree *node, tree name,
    3171                 :            :                                  tree ARG_UNUSED (args),
    3172                 :            :                                  int ARG_UNUSED (flags),
    3173                 :            :                                  bool *no_add_attrs)
    3174                 :            : {
    3175                 :          0 :   tree decl = *node;
    3176                 :            : 
    3177                 :          0 :   if (TREE_CODE (decl) != FUNCTION_DECL)
    3178                 :            :     {
    3179                 :          0 :       error_at (DECL_SOURCE_LOCATION (decl),
    3180                 :            :              "%qE attribute applies only to functions", name);
    3181                 :          0 :       *no_add_attrs = true;
    3182                 :            :     }
    3183                 :          0 :   else if (DECL_INITIAL (decl))
    3184                 :            :     {
    3185                 :          0 :       error_at (DECL_SOURCE_LOCATION (decl),
    3186                 :            :                 "cannot set %qE attribute after definition", name);
    3187                 :          0 :       *no_add_attrs = true;
    3188                 :            :     }
    3189                 :            :   else
    3190                 :          0 :     DECL_NO_LIMIT_STACK (decl) = 1;
    3191                 :            : 
    3192                 :          0 :   return NULL_TREE;
    3193                 :            : }
    3194                 :            : 
    3195                 :            : /* Handle a "pure" attribute; arguments as in
    3196                 :            :    struct attribute_spec.handler.  */
    3197                 :            : 
    3198                 :            : static tree
    3199                 :   14078500 : handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
    3200                 :            :                        int ARG_UNUSED (flags), bool *no_add_attrs)
    3201                 :            : {
    3202                 :   14078500 :   if (TREE_CODE (*node) == FUNCTION_DECL)
    3203                 :            :     {
    3204                 :   14078500 :       tree type = TREE_TYPE (*node);
    3205                 :   14078500 :       if (VOID_TYPE_P (TREE_TYPE (type)))
    3206                 :          0 :         warning (OPT_Wattributes, "%qE attribute on function "
    3207                 :            :                  "returning %<void%>", name);
    3208                 :            : 
    3209                 :   14078500 :       DECL_PURE_P (*node) = 1;
    3210                 :            :       /* ??? TODO: Support types.  */
    3211                 :            :     }
    3212                 :            :   else
    3213                 :            :     {
    3214                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    3215                 :          0 :       *no_add_attrs = true;
    3216                 :            :     }
    3217                 :            : 
    3218                 :   14078500 :   return NULL_TREE;
    3219                 :            : }
    3220                 :            : 
    3221                 :            : /* Digest an attribute list destined for a transactional memory statement.
    3222                 :            :    ALLOWED is the set of attributes that are allowed for this statement;
    3223                 :            :    return the attribute we parsed.  Multiple attributes are never allowed.  */
    3224                 :            : 
    3225                 :            : int
    3226                 :         51 : parse_tm_stmt_attr (tree attrs, int allowed)
    3227                 :            : {
    3228                 :         51 :   tree a_seen = NULL;
    3229                 :         51 :   int m_seen = 0;
    3230                 :            : 
    3231                 :        103 :   for ( ; attrs ; attrs = TREE_CHAIN (attrs))
    3232                 :            :     {
    3233                 :         52 :       tree a = get_attribute_name (attrs);
    3234                 :         52 :       tree ns = get_attribute_namespace (attrs);
    3235                 :         52 :       int m = 0;
    3236                 :            : 
    3237                 :         52 :       if (is_attribute_p ("outer", a)
    3238                 :         86 :           && (ns == NULL_TREE || strcmp (IDENTIFIER_POINTER (ns), "gnu") == 0))
    3239                 :            :         m = TM_STMT_ATTR_OUTER;
    3240                 :            : 
    3241                 :         52 :       if ((m & allowed) == 0)
    3242                 :            :         {
    3243                 :          4 :           warning (OPT_Wattributes, "%qE attribute directive ignored", a);
    3244                 :          4 :           continue;
    3245                 :            :         }
    3246                 :            : 
    3247                 :         48 :       if (m_seen == 0)
    3248                 :            :         {
    3249                 :            :           a_seen = a;
    3250                 :            :           m_seen = m;
    3251                 :            :         }
    3252                 :          1 :       else if (m_seen == m)
    3253                 :          1 :         warning (OPT_Wattributes, "%qE attribute duplicated", a);
    3254                 :            :       else
    3255                 :          0 :         warning (OPT_Wattributes, "%qE attribute follows %qE", a, a_seen);
    3256                 :            :     }
    3257                 :            : 
    3258                 :         51 :   return m_seen;
    3259                 :            : }
    3260                 :            : 
    3261                 :            : /* Transform a TM attribute name into a maskable integer and back.
    3262                 :            :    Note that NULL (i.e. no attribute) is mapped to UNKNOWN, corresponding
    3263                 :            :    to how the lack of an attribute is treated.  */
    3264                 :            : 
    3265                 :            : int
    3266                 :      72412 : tm_attr_to_mask (tree attr)
    3267                 :            : {
    3268                 :      72412 :   if (attr == NULL)
    3269                 :            :     return 0;
    3270                 :      72132 :   if (is_attribute_p ("transaction_safe", attr))
    3271                 :            :     return TM_ATTR_SAFE;
    3272                 :      71967 :   if (is_attribute_p ("transaction_callable", attr))
    3273                 :            :     return TM_ATTR_CALLABLE;
    3274                 :      71833 :   if (is_attribute_p ("transaction_pure", attr))
    3275                 :            :     return TM_ATTR_PURE;
    3276                 :      71809 :   if (is_attribute_p ("transaction_unsafe", attr))
    3277                 :            :     return TM_ATTR_IRREVOCABLE;
    3278                 :      71797 :   if (is_attribute_p ("transaction_may_cancel_outer", attr))
    3279                 :          0 :     return TM_ATTR_MAY_CANCEL_OUTER;
    3280                 :            :   return 0;
    3281                 :            : }
    3282                 :            : 
    3283                 :            : tree
    3284                 :         54 : tm_mask_to_attr (int mask)
    3285                 :            : {
    3286                 :         54 :   const char *str;
    3287                 :         54 :   switch (mask)
    3288                 :            :     {
    3289                 :            :     case TM_ATTR_SAFE:
    3290                 :            :       str = "transaction_safe";
    3291                 :            :       break;
    3292                 :         12 :     case TM_ATTR_CALLABLE:
    3293                 :         12 :       str = "transaction_callable";
    3294                 :         12 :       break;
    3295                 :         12 :     case TM_ATTR_PURE:
    3296                 :         12 :       str = "transaction_pure";
    3297                 :         12 :       break;
    3298                 :          0 :     case TM_ATTR_IRREVOCABLE:
    3299                 :          0 :       str = "transaction_unsafe";
    3300                 :          0 :       break;
    3301                 :          0 :     case TM_ATTR_MAY_CANCEL_OUTER:
    3302                 :          0 :       str = "transaction_may_cancel_outer";
    3303                 :          0 :       break;
    3304                 :          0 :     default:
    3305                 :          0 :       gcc_unreachable ();
    3306                 :            :     }
    3307                 :         54 :   return get_identifier (str);
    3308                 :            : }
    3309                 :            : 
    3310                 :            : /* Return the first TM attribute seen in LIST.  */
    3311                 :            : 
    3312                 :            : tree
    3313                 :     887218 : find_tm_attribute (tree list)
    3314                 :            : {
    3315                 :     891584 :   for (; list ; list = TREE_CHAIN (list))
    3316                 :            :     {
    3317                 :       4561 :       tree name = TREE_PURPOSE (list);
    3318                 :       4561 :       if (tm_attr_to_mask (name) != 0)
    3319                 :        195 :         return name;
    3320                 :            :     }
    3321                 :            :   return NULL_TREE;
    3322                 :            : }
    3323                 :            : 
    3324                 :            : /* Handle the TM attributes; arguments as in struct attribute_spec.handler.
    3325                 :            :    Here we accept only function types, and verify that none of the other
    3326                 :            :    function TM attributes are also applied.  */
    3327                 :            : /* ??? We need to accept class types for C++, but not C.  This greatly
    3328                 :            :    complicates this function, since we can no longer rely on the extra
    3329                 :            :    processing given by function_type_required.  */
    3330                 :            : 
    3331                 :            : static tree
    3332                 :     881648 : handle_tm_attribute (tree *node, tree name, tree args,
    3333                 :            :                      int flags, bool *no_add_attrs)
    3334                 :            : {
    3335                 :            :   /* Only one path adds the attribute; others don't.  */
    3336                 :     881648 :   *no_add_attrs = true;
    3337                 :            : 
    3338                 :     881648 :   switch (TREE_CODE (*node))
    3339                 :            :     {
    3340                 :         20 :     case RECORD_TYPE:
    3341                 :         20 :     case UNION_TYPE:
    3342                 :            :       /* Only tm_callable and tm_safe apply to classes.  */
    3343                 :         20 :       if (tm_attr_to_mask (name) & ~(TM_ATTR_SAFE | TM_ATTR_CALLABLE))
    3344                 :          0 :         goto ignored;
    3345                 :            :       /* FALLTHRU */
    3346                 :            : 
    3347                 :     881526 :     case FUNCTION_TYPE:
    3348                 :     881526 :     case METHOD_TYPE:
    3349                 :     881526 :       {
    3350                 :     881526 :         tree old_name = find_tm_attribute (TYPE_ATTRIBUTES (*node));
    3351                 :     881526 :         if (old_name == name)
    3352                 :            :           ;
    3353                 :     881526 :         else if (old_name != NULL_TREE)
    3354                 :         15 :           error ("type was previously declared %qE", old_name);
    3355                 :            :         else
    3356                 :     881511 :           *no_add_attrs = false;
    3357                 :            :       }
    3358                 :            :       break;
    3359                 :            : 
    3360                 :         35 :     case FUNCTION_DECL:
    3361                 :         35 :       {
    3362                 :            :         /* transaction_safe_dynamic goes on the FUNCTION_DECL, but we also
    3363                 :            :            want to set transaction_safe on the type.  */
    3364                 :         35 :         gcc_assert (is_attribute_p ("transaction_safe_dynamic", name));
    3365                 :         35 :         if (!TYPE_P (DECL_CONTEXT (*node)))
    3366                 :          1 :           error_at (DECL_SOURCE_LOCATION (*node),
    3367                 :            :                     "%<transaction_safe_dynamic%> may only be specified for "
    3368                 :            :                     "a virtual function");
    3369                 :         35 :         *no_add_attrs = false;
    3370                 :         35 :         decl_attributes (&TREE_TYPE (*node),
    3371                 :            :                          build_tree_list (get_identifier ("transaction_safe"),
    3372                 :            :                                           NULL_TREE),
    3373                 :            :                          0);
    3374                 :         35 :         break;
    3375                 :            :       }
    3376                 :            : 
    3377                 :         77 :     case POINTER_TYPE:
    3378                 :         77 :       {
    3379                 :         77 :         enum tree_code subcode = TREE_CODE (TREE_TYPE (*node));
    3380                 :         77 :         if (subcode == FUNCTION_TYPE || subcode == METHOD_TYPE)
    3381                 :            :           {
    3382                 :         77 :             tree fn_tmp = TREE_TYPE (*node);
    3383                 :         77 :             decl_attributes (&fn_tmp, tree_cons (name, args, NULL), 0);
    3384                 :         77 :             *node = build_pointer_type (fn_tmp);
    3385                 :         77 :             break;
    3386                 :            :           }
    3387                 :            :       }
    3388                 :            :       /* FALLTHRU */
    3389                 :            : 
    3390                 :         10 :     default:
    3391                 :            :       /* If a function is next, pass it on to be tried next.  */
    3392                 :         10 :       if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
    3393                 :          0 :         return tree_cons (name, args, NULL);
    3394                 :            : 
    3395                 :         10 :     ignored:
    3396                 :         10 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    3397                 :         10 :       break;
    3398                 :            :     }
    3399                 :            : 
    3400                 :            :   return NULL_TREE;
    3401                 :            : }
    3402                 :            : 
    3403                 :            : /* Handle the TM_WRAP attribute; arguments as in
    3404                 :            :    struct attribute_spec.handler.  */
    3405                 :            : 
    3406                 :            : static tree
    3407                 :         44 : handle_tm_wrap_attribute (tree *node, tree name, tree args,
    3408                 :            :                           int ARG_UNUSED (flags), bool *no_add_attrs)
    3409                 :            : {
    3410                 :         44 :   tree decl = *node;
    3411                 :            : 
    3412                 :            :   /* We don't need the attribute even on success, since we
    3413                 :            :      record the entry in an external table.  */
    3414                 :         44 :   *no_add_attrs = true;
    3415                 :            : 
    3416                 :         44 :   if (TREE_CODE (decl) != FUNCTION_DECL)
    3417                 :          0 :     warning (OPT_Wattributes, "%qE attribute ignored", name);
    3418                 :            :   else
    3419                 :            :     {
    3420                 :         44 :       tree wrap_decl = TREE_VALUE (args);
    3421                 :         83 :       if (error_operand_p (wrap_decl))
    3422                 :            :         ;
    3423                 :         39 :       else if (TREE_CODE (wrap_decl) != IDENTIFIER_NODE
    3424                 :         39 :                && !VAR_OR_FUNCTION_DECL_P (wrap_decl))
    3425                 :         10 :         error ("%qE argument not an identifier", name);
    3426                 :            :       else
    3427                 :            :         {
    3428                 :         29 :           if (TREE_CODE (wrap_decl) == IDENTIFIER_NODE)
    3429                 :          0 :             wrap_decl = lookup_name (wrap_decl);
    3430                 :         29 :           if (wrap_decl && TREE_CODE (wrap_decl) == FUNCTION_DECL)
    3431                 :            :             {
    3432                 :         48 :               if (lang_hooks.types_compatible_p (TREE_TYPE (decl),
    3433                 :         24 :                                                  TREE_TYPE (wrap_decl)))
    3434                 :         14 :                 record_tm_replacement (wrap_decl, decl);
    3435                 :            :               else
    3436                 :         10 :                 error ("%qD is not compatible with %qD", wrap_decl, decl);
    3437                 :            :             }
    3438                 :            :           else
    3439                 :          5 :             error ("%qE argument is not a function", name);
    3440                 :            :         }
    3441                 :            :     }
    3442                 :            : 
    3443                 :         44 :   return NULL_TREE;
    3444                 :            : }
    3445                 :            : 
    3446                 :            : /* Ignore the given attribute.  Used when this attribute may be usefully
    3447                 :            :    overridden by the target, but is not used generically.  */
    3448                 :            : 
    3449                 :            : static tree
    3450                 :          0 : ignore_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
    3451                 :            :                   tree ARG_UNUSED (args), int ARG_UNUSED (flags),
    3452                 :            :                   bool *no_add_attrs)
    3453                 :            : {
    3454                 :          0 :   *no_add_attrs = true;
    3455                 :          0 :   return NULL_TREE;
    3456                 :            : }
    3457                 :            : 
    3458                 :            : /* Handle a "no vops" attribute; arguments as in
    3459                 :            :    struct attribute_spec.handler.  */
    3460                 :            : 
    3461                 :            : static tree
    3462                 :    1250280 : handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
    3463                 :            :                          tree ARG_UNUSED (args), int ARG_UNUSED (flags),
    3464                 :            :                          bool *ARG_UNUSED (no_add_attrs))
    3465                 :            : {
    3466                 :    1250280 :   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
    3467                 :    1250280 :   DECL_IS_NOVOPS (*node) = 1;
    3468                 :    1250280 :   return NULL_TREE;
    3469                 :            : }
    3470                 :            : 
    3471                 :            : /* Handle a "deprecated" attribute; arguments as in
    3472                 :            :    struct attribute_spec.handler.  */
    3473                 :            : 
    3474                 :            : tree
    3475                 :     128785 : handle_deprecated_attribute (tree *node, tree name,
    3476                 :            :                              tree args, int flags,
    3477                 :            :                              bool *no_add_attrs)
    3478                 :            : {
    3479                 :     128785 :   tree type = NULL_TREE;
    3480                 :     128785 :   int warn = 0;
    3481                 :     128785 :   tree what = NULL_TREE;
    3482                 :            : 
    3483                 :     128785 :   if (!args)
    3484                 :     123919 :     *no_add_attrs = true;
    3485                 :       4866 :   else if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
    3486                 :            :     {
    3487                 :          0 :       error ("deprecated message is not a string");
    3488                 :          0 :       *no_add_attrs = true;
    3489                 :            :     }
    3490                 :            : 
    3491                 :     128785 :   if (DECL_P (*node))
    3492                 :            :     {
    3493                 :     116601 :       tree decl = *node;
    3494                 :     116601 :       type = TREE_TYPE (decl);
    3495                 :            : 
    3496                 :     116601 :       if (TREE_CODE (decl) == TYPE_DECL
    3497                 :     116601 :           || TREE_CODE (decl) == PARM_DECL
    3498                 :      30207 :           || VAR_OR_FUNCTION_DECL_P (decl)
    3499                 :         96 :           || TREE_CODE (decl) == FIELD_DECL
    3500                 :         40 :           || TREE_CODE (decl) == CONST_DECL
    3501                 :     116601 :           || objc_method_decl (TREE_CODE (decl)))
    3502                 :     116601 :         TREE_DEPRECATED (decl) = 1;
    3503                 :            :       else
    3504                 :            :         warn = 1;
    3505                 :            :     }
    3506                 :      12184 :   else if (TYPE_P (*node))
    3507                 :            :     {
    3508                 :      12184 :       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
    3509                 :         15 :         *node = build_variant_type_copy (*node);
    3510                 :      12184 :       TREE_DEPRECATED (*node) = 1;
    3511                 :      12184 :       type = *node;
    3512                 :            :     }
    3513                 :            :   else
    3514                 :            :     warn = 1;
    3515                 :            : 
    3516                 :     128785 :   if (warn)
    3517                 :            :     {
    3518                 :          0 :       *no_add_attrs = true;
    3519                 :          0 :       if (type && TYPE_NAME (type))
    3520                 :            :         {
    3521                 :          0 :           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
    3522                 :          0 :             what = TYPE_NAME (*node);
    3523                 :          0 :           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
    3524                 :          0 :                    && DECL_NAME (TYPE_NAME (type)))
    3525                 :          0 :             what = DECL_NAME (TYPE_NAME (type));
    3526                 :            :         }
    3527                 :          0 :       if (what)
    3528                 :          0 :         warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
    3529                 :            :       else
    3530                 :          0 :         warning (OPT_Wattributes, "%qE attribute ignored", name);
    3531                 :            :     }
    3532                 :            : 
    3533                 :     128785 :   return NULL_TREE;
    3534                 :            : }
    3535                 :            : 
    3536                 :            : /* Return the "base" type from TYPE that is suitable to apply attribute
    3537                 :            :    vector_size to by stripping arrays, function types, etc.  */
    3538                 :            : static tree
    3539                 :     334524 : type_for_vector_size (tree type)
    3540                 :            : {
    3541                 :            :   /* We need to provide for vector pointers, vector arrays, and
    3542                 :            :      functions returning vectors.  For example:
    3543                 :            : 
    3544                 :            :        __attribute__((vector_size(16))) short *foo;
    3545                 :            : 
    3546                 :            :      In this case, the mode is SI, but the type being modified is
    3547                 :            :      HI, so we need to look further.  */
    3548                 :            : 
    3549                 :     334845 :   while (POINTER_TYPE_P (type)
    3550                 :     334845 :          || TREE_CODE (type) == FUNCTION_TYPE
    3551                 :     334650 :          || TREE_CODE (type) == METHOD_TYPE
    3552                 :     334634 :          || TREE_CODE (type) == ARRAY_TYPE
    3553                 :     669373 :          || TREE_CODE (type) == OFFSET_TYPE)
    3554                 :        321 :     type = TREE_TYPE (type);
    3555                 :            : 
    3556                 :     334524 :   return type;
    3557                 :            : }
    3558                 :            : 
    3559                 :            : /* Given TYPE, return the base type to which the vector_size attribute
    3560                 :            :    ATNAME with ARGS, when non-null, can be applied, if one exists.
    3561                 :            :    On success and when both ARGS and PTRNUNITS are non-null, set
    3562                 :            :    *PTRNUNINTS to the number of vector units.  When PTRNUNITS is not
    3563                 :            :    null, issue a warning when the attribute argument is not constant
    3564                 :            :    and an error if there is no such type.  Otherwise issue a warning
    3565                 :            :    in the latter case and return null.  */
    3566                 :            : 
    3567                 :            : static tree
    3568                 :     334524 : type_valid_for_vector_size (tree type, tree atname, tree args,
    3569                 :            :                             unsigned HOST_WIDE_INT *ptrnunits)
    3570                 :            : {
    3571                 :     334524 :   bool error_p = ptrnunits != NULL;
    3572                 :            : 
    3573                 :            :   /* Get the mode of the type being modified.  */
    3574                 :     334524 :   machine_mode orig_mode = TYPE_MODE (type);
    3575                 :            : 
    3576                 :     334524 :   if ((!INTEGRAL_TYPE_P (type)
    3577                 :     334524 :        && !SCALAR_FLOAT_TYPE_P (type)
    3578                 :          1 :        && !FIXED_POINT_TYPE_P (type))
    3579                 :     334523 :       || (!SCALAR_FLOAT_MODE_P (orig_mode)
    3580                 :     233792 :           && GET_MODE_CLASS (orig_mode) != MODE_INT
    3581                 :          0 :           && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
    3582                 :     334523 :       || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type))
    3583                 :     669047 :       || TREE_CODE (type) == BOOLEAN_TYPE)
    3584                 :            :     {
    3585                 :         10 :       if (error_p)
    3586                 :         10 :         error ("invalid vector type for attribute %qE", atname);
    3587                 :            :       else
    3588                 :          0 :         warning (OPT_Wattributes, "invalid vector type for attribute %qE",
    3589                 :            :                  atname);
    3590                 :         10 :       return NULL_TREE;
    3591                 :            :     }
    3592                 :            : 
    3593                 :            :   /* When no argument has been provided this is just a request to validate
    3594                 :            :      the type above.  Return TYPE to indicate success.  */
    3595                 :     334514 :   if (!args)
    3596                 :            :     return type;
    3597                 :            : 
    3598                 :     334514 :   tree size = TREE_VALUE (args);
    3599                 :            :   /* Erroneous arguments have already been diagnosed.  */
    3600                 :     334514 :   if (size == error_mark_node)
    3601                 :            :     return NULL_TREE;
    3602                 :            : 
    3603                 :     334509 :   if (size && TREE_CODE (size) != IDENTIFIER_NODE
    3604                 :     334509 :       && TREE_CODE (size) != FUNCTION_DECL)
    3605                 :     334499 :     size = default_conversion (size);
    3606                 :            : 
    3607                 :     334509 :   if (TREE_CODE (size) != INTEGER_CST)
    3608                 :            :     {
    3609                 :         10 :       if (error_p)
    3610                 :         10 :         error ("%qE attribute argument value %qE is not an integer constant",
    3611                 :            :                atname, size);
    3612                 :            :       else
    3613                 :          0 :         warning (OPT_Wattributes,
    3614                 :            :                  "%qE attribute argument value %qE is not an integer constant",
    3615                 :            :                  atname, size);
    3616                 :         10 :       return NULL_TREE;
    3617                 :            :     }
    3618                 :            : 
    3619                 :     334499 :   if (!TYPE_UNSIGNED (TREE_TYPE (size))
    3620                 :     334499 :       && tree_int_cst_sgn (size) < 0)
    3621                 :            :     {
    3622                 :          1 :       if (error_p)
    3623                 :          1 :         error ("%qE attribute argument value %qE is negative",
    3624                 :            :                atname, size);
    3625                 :            :       else
    3626                 :          0 :         warning (OPT_Wattributes,
    3627                 :            :                  "%qE attribute argument value %qE is negative",
    3628                 :            :                  atname, size);
    3629                 :          1 :       return NULL_TREE;
    3630                 :            :     }
    3631                 :            : 
    3632                 :            :   /* The attribute argument value is constrained by the maximum bit
    3633                 :            :      alignment representable in unsigned int on the host.  */
    3634                 :     334498 :   unsigned HOST_WIDE_INT vecsize;
    3635                 :     334498 :   unsigned HOST_WIDE_INT maxsize = tree_to_uhwi (max_object_size ());
    3636                 :     334498 :   if (!tree_fits_uhwi_p (size)
    3637                 :     334498 :       || (vecsize = tree_to_uhwi (size)) > maxsize)
    3638                 :            :     {
    3639                 :          2 :       if (error_p)
    3640                 :          2 :         error ("%qE attribute argument value %qE exceeds %wu",
    3641                 :            :                atname, size, maxsize);
    3642                 :            :       else
    3643                 :          0 :         warning (OPT_Wattributes,
    3644                 :            :                  "%qE attribute argument value %qE exceeds %wu",
    3645                 :            :                  atname, size, maxsize);
    3646                 :          2 :       return NULL_TREE;
    3647                 :            :     }
    3648                 :            : 
    3649                 :     334496 :   if (vecsize % tree_to_uhwi (TYPE_SIZE_UNIT (type)))
    3650                 :            :     {
    3651                 :         67 :       if (error_p)
    3652                 :          2 :         error ("vector size not an integral multiple of component size");
    3653                 :         67 :       return NULL_TREE;
    3654                 :            :     }
    3655                 :            : 
    3656                 :     334429 :   if (vecsize == 0)
    3657                 :            :     {
    3658                 :          1 :       error ("zero vector size");
    3659                 :          1 :       return NULL;
    3660                 :            :     }
    3661                 :            : 
    3662                 :            :   /* Calculate how many units fit in the vector.  */
    3663                 :     334428 :   unsigned HOST_WIDE_INT nunits = vecsize / tree_to_uhwi (TYPE_SIZE_UNIT (type));
    3664                 :     334428 :   if (nunits & (nunits - 1))
    3665                 :            :     {
    3666                 :          0 :       if (error_p)
    3667                 :          0 :         error ("number of components of the vector not a power of two");
    3668                 :            :       else
    3669                 :          0 :         warning (OPT_Wattributes,
    3670                 :            :                  "number of components of the vector not a power of two");
    3671                 :          0 :       return NULL_TREE;
    3672                 :            :     }
    3673                 :            : 
    3674                 :     334428 :   if (ptrnunits)
    3675                 :     334273 :     *ptrnunits = nunits;
    3676                 :            : 
    3677                 :            :   return type;
    3678                 :            : }
    3679                 :            : 
    3680                 :            : /* Handle a "vector_size" attribute; arguments as in
    3681                 :            :    struct attribute_spec.handler.  */
    3682                 :            : 
    3683                 :            : static tree
    3684                 :     334304 : handle_vector_size_attribute (tree *node, tree name, tree args,
    3685                 :            :                               int ARG_UNUSED (flags),
    3686                 :            :                               bool *no_add_attrs)
    3687                 :            : {
    3688                 :     334304 :   *no_add_attrs = true;
    3689                 :            : 
    3690                 :            :   /* Determine the "base" type to apply the attribute to.  */
    3691                 :     334304 :   tree type = type_for_vector_size (*node);
    3692                 :            : 
    3693                 :            :   /* Get the vector size (in bytes) and let the function compute
    3694                 :            :      the number of vector units.  */
    3695                 :     334304 :   unsigned HOST_WIDE_INT nunits;
    3696                 :     334304 :   type = type_valid_for_vector_size (type, name, args, &nunits);
    3697                 :     334304 :   if (!type)
    3698                 :            :     return NULL_TREE;
    3699                 :            : 
    3700                 :     334273 :   tree new_type = build_vector_type (type, nunits);
    3701                 :            : 
    3702                 :            :   /* Build back pointers if needed.  */
    3703                 :     334273 :   *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
    3704                 :            : 
    3705                 :     334273 :   return NULL_TREE;
    3706                 :            : }
    3707                 :            : 
    3708                 :            : /* Handle the "nonnull" attribute.  */
    3709                 :            : 
    3710                 :            : static tree
    3711                 :   33380000 : handle_nonnull_attribute (tree *node, tree name,
    3712                 :            :                           tree args, int ARG_UNUSED (flags),
    3713                 :            :                           bool *no_add_attrs)
    3714                 :            : {
    3715                 :   33380000 :   tree type = *node;
    3716                 :            : 
    3717                 :            :   /* If no arguments are specified, all pointer arguments should be
    3718                 :            :      non-null.  Verify a full prototype is given so that the arguments
    3719                 :            :      will have the correct types when we actually check them later.
    3720                 :            :      Avoid diagnosing type-generic built-ins since those have no
    3721                 :            :      prototype.  */
    3722                 :   33380000 :   if (!args)
    3723                 :            :     {
    3724                 :   22544400 :       if (!prototype_p (type)
    3725                 :   23014900 :           && (!TYPE_ATTRIBUTES (type)
    3726                 :     470508 :               || !lookup_attribute ("type generic", TYPE_ATTRIBUTES (type))))
    3727                 :            :         {
    3728                 :          1 :           error ("%qE attribute without arguments on a non-prototype",
    3729                 :            :                  name);
    3730                 :          1 :           *no_add_attrs = true;
    3731                 :            :         }
    3732                 :   22544400 :       return NULL_TREE;
    3733                 :            :     }
    3734                 :            : 
    3735                 :   25352900 :   for (int i = 1; args; ++i)
    3736                 :            :     {
    3737                 :   14517300 :       tree pos = TREE_VALUE (args);
    3738                 :            :       /* NEXT is null when the attribute includes just one argument.
    3739                 :            :          That's used to tell positional_argument to avoid mentioning
    3740                 :            :          the argument number in diagnostics (since there's just one
    3741                 :            :          mentioning it is unnecessary and coule be confusing).  */
    3742                 :   14517300 :       tree next = TREE_CHAIN (args);
    3743                 :   14517300 :       if (tree val = positional_argument (type, name, pos, POINTER_TYPE,
    3744                 :   14517300 :                                           next || i > 1 ? i : 0))
    3745                 :   14517300 :         TREE_VALUE (args) = val;
    3746                 :            :       else
    3747                 :            :         {
    3748                 :         28 :           *no_add_attrs = true;
    3749                 :         28 :           break;
    3750                 :            :         }
    3751                 :   14517300 :       args = next;
    3752                 :            :     }
    3753                 :            : 
    3754                 :            :   return NULL_TREE;
    3755                 :            : }
    3756                 :            : 
    3757                 :            : /* Handle the "nonstring" variable attribute.  */
    3758                 :            : 
    3759                 :            : static tree
    3760                 :        626 : handle_nonstring_attribute (tree *node, tree name, tree ARG_UNUSED (args),
    3761                 :            :                             int ARG_UNUSED (flags), bool *no_add_attrs)
    3762                 :            : {
    3763                 :        626 :   gcc_assert (!args);
    3764                 :        626 :   tree_code code = TREE_CODE (*node);
    3765                 :            : 
    3766                 :        626 :   if (VAR_P (*node)
    3767                 :        276 :       || code == FIELD_DECL
    3768                 :        276 :       || code == PARM_DECL)
    3769                 :            :     {
    3770                 :        616 :       tree type = TREE_TYPE (*node);
    3771                 :            : 
    3772                 :        616 :       if (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
    3773                 :            :         {
    3774                 :            :           /* Accept the attribute on arrays and pointers to all three
    3775                 :            :              narrow character types.  */
    3776                 :        606 :           tree eltype = TREE_TYPE (type);
    3777                 :        606 :           eltype = TYPE_MAIN_VARIANT (eltype);
    3778                 :        606 :           if (eltype == char_type_node
    3779                 :         90 :               || eltype == signed_char_type_node
    3780                 :         50 :               || eltype == unsigned_char_type_node)
    3781                 :            :             return NULL_TREE;
    3782                 :            :         }
    3783                 :            : 
    3784                 :         20 :       warning (OPT_Wattributes,
    3785                 :            :                "%qE attribute ignored on objects of type %qT",
    3786                 :            :                name, type);
    3787                 :         20 :       *no_add_attrs = true;
    3788                 :         20 :       return NULL_TREE;
    3789                 :            :     }
    3790                 :            : 
    3791                 :         10 :   if (code == FUNCTION_DECL)
    3792                 :          5 :     warning (OPT_Wattributes,
    3793                 :            :              "%qE attribute does not apply to functions", name);
    3794                 :          5 :   else if (code == TYPE_DECL)
    3795                 :          5 :     warning (OPT_Wattributes,
    3796                 :            :              "%qE attribute does not apply to types", name);
    3797                 :            :   else
    3798                 :          0 :     warning (OPT_Wattributes, "%qE attribute ignored", name);
    3799                 :            : 
    3800                 :         10 :   *no_add_attrs = true;
    3801                 :         10 :   return NULL_TREE;
    3802                 :            : }
    3803                 :            : 
    3804                 :            : /* Given a function type FUNCTYPE, returns the type of the parameter
    3805                 :            :    ARGNO or null if ARGNO exceeds the number of parameters.  On failure
    3806                 :            :    set *NARGS to the number of function parameters.  */
    3807                 :            : 
    3808                 :            : static tree
    3809                 :        426 : get_argument_type (tree functype, unsigned argno, unsigned *nargs)
    3810                 :            : {
    3811                 :        426 :   function_args_iterator iter;
    3812                 :        426 :   function_args_iter_init (&iter, functype);
    3813                 :            : 
    3814                 :        426 :   unsigned count = 0;
    3815                 :            : 
    3816                 :       1311 :   for ( ; iter.next; ++count, function_args_iter_next (&iter))
    3817                 :            :     {
    3818                 :       1305 :       if (count + 1 == argno)
    3819                 :            :         {
    3820                 :        420 :           tree argtype = function_args_iter_cond (&iter);
    3821                 :        420 :           if (VOID_TYPE_P (argtype))
    3822                 :            :             break;
    3823                 :            :           return argtype;
    3824                 :            :         }
    3825                 :            :     }
    3826                 :            : 
    3827                 :          9 :   *nargs = count;
    3828                 :          9 :   return NULL_TREE;
    3829                 :            : }
    3830                 :            : 
    3831                 :            : /* Appends ATTRSTR to the access string in ATTRS if one is there
    3832                 :            :    or creates a new one and returns the concatenated access string.  */
    3833                 :            : 
    3834                 :            : static tree
    3835                 :        574 : append_access_attrs (tree t, tree attrs, const char *attrstr,
    3836                 :            :                      char code, HOST_WIDE_INT idxs[2])
    3837                 :            : {
    3838                 :        574 :   char attrspec[80];
    3839                 :        574 :   int n1 = sprintf (attrspec, "%c%u", code, (unsigned) idxs[0] - 1);
    3840                 :        574 :   int n2 = 0;
    3841                 :        574 :   if (idxs[1])
    3842                 :         38 :     n2 = sprintf (attrspec + n1 + 1, "%u", (unsigned) idxs[1] - 1);
    3843                 :            : 
    3844                 :        574 :   size_t newlen = n1 + n2 + !!n2;
    3845                 :        574 :   char *newspec = attrspec;
    3846                 :            : 
    3847                 :        574 :   if (tree acs = lookup_attribute ("access", attrs))
    3848                 :            :     {
    3849                 :            :       /* The TREE_VALUE of an attribute is a TREE_LIST whose TREE_VALUE
    3850                 :            :          is the attribute argument's value.  */
    3851                 :        268 :       acs = TREE_VALUE (acs);
    3852                 :        268 :       gcc_assert (TREE_CODE (acs) == TREE_LIST);
    3853                 :        268 :       acs = TREE_VALUE (acs);
    3854                 :        268 :       gcc_assert (TREE_CODE (acs) == STRING_CST);
    3855                 :            : 
    3856                 :            :       /* Check to make sure ATTRSPEC doesn't conflict with another
    3857                 :            :          access attribute specified in ATTRS by searching the access
    3858                 :            :          string in ATTRS for the position string formatted above into
    3859                 :            :          ATTRSPEC, and if it's found, that the two match.  */
    3860                 :            : 
    3861                 :        268 :       const char *posstr = attrspec + 1;
    3862                 :        268 :       const char *str = TREE_STRING_POINTER (acs);
    3863                 :        268 :       const char *pos = str;
    3864                 :        268 :       for ( ; ; pos += n1)
    3865                 :            :         {
    3866                 :        268 :           pos = strstr (pos, posstr);
    3867                 :        268 :           if (!pos)
    3868                 :            :             break;
    3869                 :            : 
    3870                 :        135 :           if (ISDIGIT (pos[-1]) || ISDIGIT (pos[n1 -1]))
    3871                 :          0 :             continue;
    3872                 :            : 
    3873                 :            :           /* Found a matching positional argument.  */
    3874                 :        135 :           if (*attrspec != pos[-1])
    3875                 :            :             {
    3876                 :            :               /* Mismatch in access mode.  */
    3877                 :         10 :               auto_diagnostic_group d;
    3878                 :         16 :               if (warning (OPT_Wattributes,
    3879                 :            :                            "attribute %qs mismatch with mode %qs",
    3880                 :            :                            attrstr,
    3881                 :         10 :                            (pos[-1] == 'r'
    3882                 :            :                             ? "read_only"
    3883                 :            :                             : (pos[-1] == 'w' ? "write_only" : "read_write")))
    3884                 :         10 :                   && DECL_P (t))
    3885                 :          9 :                 inform (DECL_SOURCE_LOCATION (t),
    3886                 :            :                         "previous declaration here");
    3887                 :         10 :               return NULL_TREE;
    3888                 :            :             }
    3889                 :            : 
    3890                 :        125 :           if ((n2 && pos[n1 - 1] != ','))
    3891                 :            :             {
    3892                 :            :               /* Mismatch in the presence of the size argument.  */
    3893                 :          2 :               auto_diagnostic_group d;
    3894                 :          2 :               if (warning (OPT_Wattributes,
    3895                 :            :                            "attribute %qs positional argument 2 conflicts "
    3896                 :            :                            "with previous designation",
    3897                 :            :                            attrstr)
    3898                 :          2 :                   && DECL_P (t))
    3899                 :          1 :                 inform (DECL_SOURCE_LOCATION (t),
    3900                 :            :                         "previous declaration here");
    3901                 :          2 :               return NULL_TREE;
    3902                 :            :             }
    3903                 :            : 
    3904                 :        123 :           if (!n2 && pos[n1 - 1] == ',')
    3905                 :            :             {
    3906                 :            :               /* Mismatch in the presence of the size argument.  */
    3907                 :          1 :               auto_diagnostic_group d;
    3908                 :          1 :               if (warning (OPT_Wattributes,
    3909                 :            :                            "attribute %qs missing positional argument 2 "
    3910                 :            :                            "provided in previous designation",
    3911                 :            :                            attrstr)
    3912                 :          1 :                   && DECL_P (t))
    3913                 :          0 :                 inform (DECL_SOURCE_LOCATION (t),
    3914                 :            :                         "previous declaration here");
    3915                 :          1 :               return NULL_TREE;
    3916                 :            :             }
    3917                 :            : 
    3918                 :        122 :           if (n2 && strncmp (attrspec + n1 + 1, pos + n1, n2))
    3919                 :            :             {
    3920                 :            :               /* Mismatch in the value of the size argument.  */
    3921                 :          2 :               auto_diagnostic_group d;
    3922                 :          6 :               if (warning (OPT_Wattributes,
    3923                 :            :                            "attribute %qs mismatched positional argument "
    3924                 :            :                            "values %i and %i",
    3925                 :          2 :                            attrstr, atoi (attrspec + n1 + 1) + 1,
    3926                 :          2 :                            atoi (pos + n1) + 1)
    3927                 :          2 :                   && DECL_P (t))
    3928                 :          2 :                 inform (DECL_SOURCE_LOCATION (t),
    3929                 :            :                         "previous declaration here");
    3930                 :          2 :               return NULL_TREE;
    3931                 :            :             }
    3932                 :            : 
    3933                 :            :           /* Avoid adding the same attribute specification.  */
    3934                 :            :           return NULL_TREE;
    3935                 :          0 :         }
    3936                 :            : 
    3937                 :            :       /* Connect the two substrings formatted above into a single one.  */
    3938                 :        133 :       if (idxs[1])
    3939                 :          9 :         attrspec[n1] = ',';
    3940                 :            : 
    3941                 :        133 :       size_t len = strlen (str);
    3942                 :        133 :       newspec = XNEWVEC (char, newlen + len + 1);
    3943                 :        133 :       strcpy (newspec, str);
    3944                 :        133 :       strcpy (newspec + len, attrspec);
    3945                 :        133 :       newlen += len;
    3946                 :            :     }
    3947                 :        306 :   else if (idxs[1])
    3948                 :            :     /* Connect the two substrings formatted above into a single one.  */
    3949                 :         24 :     attrspec[n1] = ',';
    3950                 :            : 
    3951                 :        439 :   tree ret = build_string (newlen + 1, newspec);
    3952                 :        439 :   if (newspec != attrspec)
    3953                 :        133 :     XDELETEVEC (newspec);
    3954                 :            :   return ret;
    3955                 :            : }
    3956                 :            : 
    3957                 :            : /* Handle the access attribute (read_only, write_only, and read_write).  */
    3958                 :            : 
    3959                 :            : static tree
    3960                 :        833 : handle_access_attribute (tree *node, tree name, tree args,
    3961                 :            :                          int ARG_UNUSED (flags), bool *no_add_attrs)
    3962                 :            : {
    3963                 :        833 :   tree type = *node;
    3964                 :        833 :   tree attrs = TYPE_ATTRIBUTES (type);
    3965                 :            : 
    3966                 :        833 :   *no_add_attrs = true;
    3967                 :            : 
    3968                 :            :   /* Verify a full prototype is provided so that the argument types
    3969                 :            :      can be validated.  Avoid diagnosing type-generic built-ins since
    3970                 :            :      those have no prototype.  */
    3971                 :        833 :   if (!args
    3972                 :          0 :       && !prototype_p (type)
    3973                 :        833 :       && (!attrs || !lookup_attribute ("type generic", attrs)))
    3974                 :            :     {
    3975                 :          0 :       error ("attribute %qE without arguments on a non-prototype", name);
    3976                 :          0 :       return NULL_TREE;
    3977                 :            :     }
    3978                 :            : 
    3979                 :        833 :   tree access_mode = TREE_VALUE (args);
    3980                 :        833 :   if (TREE_CODE (access_mode) == STRING_CST)
    3981                 :            :     {
    3982                 :            :       /* This must be a recursive call to handle the condensed internal
    3983                 :            :          form of the attribute (see below).  Since all validation has
    3984                 :            :          been done simply return here, accepting the attribute as is.  */
    3985                 :        429 :       *no_add_attrs = false;
    3986                 :        429 :       return NULL_TREE;
    3987                 :            :     }
    3988                 :            : 
    3989                 :            :   /* Set to true when the access mode has the form of a function call
    3990                 :            :      as in 'attribute (read_only (1, 2))'.  That's an easy mistake to
    3991                 :            :      make and so worth a special diagnostic.  */
    3992                 :        404 :   bool funcall = false;
    3993                 :        404 :   if (TREE_CODE (access_mode) == CALL_EXPR)
    3994                 :            :     {
    3995                 :          6 :       access_mode = CALL_EXPR_FN (access_mode);
    3996                 :          6 :       if (TREE_CODE (access_mode) != ADDR_EXPR)
    3997                 :            :         {
    3998                 :          0 :           error ("attribute %qE invalid mode", name);
    3999                 :          0 :           return NULL_TREE;
    4000                 :            :         }
    4001                 :          6 :       access_mode = TREE_OPERAND (access_mode, 0);
    4002                 :          6 :       access_mode = DECL_NAME (access_mode);
    4003                 :          6 :       funcall = true;
    4004                 :            :     }
    4005                 :            : 
    4006                 :        404 :   const char* const access_str = IDENTIFIER_POINTER (access_mode);
    4007                 :        404 :   const char *ps = access_str;
    4008                 :        404 :   if (ps[0] == '_' && ps[1] == '_')
    4009                 :            :     {
    4010                 :          0 :       size_t len = strlen (ps);
    4011                 :          0 :       if (ps[len - 1] == '_' && ps[len - 2] == '_')
    4012                 :          0 :         ps += 2;
    4013                 :            :     }
    4014                 :            : 
    4015                 :        404 :   const bool read_only = strncmp (ps, "read_only", 9) == 0;
    4016                 :        404 :   const bool write_only = strncmp (ps, "write_only", 10) == 0;
    4017                 :        404 :   if (!read_only && !write_only && strncmp (ps, "read_write", 10))
    4018                 :            :     {
    4019                 :         18 :       error ("attribute %qE invalid mode %qs; expected one of "
    4020                 :            :              "%qs, %qs, or %qs", name, access_str,
    4021                 :            :              "read_only", "read_write", "write_only");
    4022                 :         18 :       return NULL_TREE;
    4023                 :            :     }
    4024                 :            : 
    4025                 :        386 :   if (funcall)
    4026                 :            :     {
    4027                 :          3 :       error ("attribute %qE unexpected %<(%> after mode %qs; expected "
    4028                 :            :              "a positional argument or %<)%>",
    4029                 :            :              name, access_str);
    4030                 :          3 :       return NULL_TREE;
    4031                 :            :     }
    4032                 :            : 
    4033                 :        383 :   args = TREE_CHAIN (args);
    4034                 :        383 :   if (!args)
    4035                 :            :     {
    4036                 :            :       /* The first positional argument is required.  It may be worth
    4037                 :            :          dropping the requirement at some point and having read_only
    4038                 :            :          apply to all const-qualified pointers and read_write or
    4039                 :            :          write_only to the rest.  */
    4040                 :          4 :       error ("attribute %<%E(%s)%> missing an argument",
    4041                 :            :              name, access_str);
    4042                 :          4 :       return NULL_TREE;
    4043                 :            :     }
    4044                 :            : 
    4045                 :            :   /* One or more positional arguments have been specified.  Validate
    4046                 :            :      them.  */
    4047                 :        379 :   tree idxnodes[2] = { NULL_TREE, NULL_TREE };
    4048                 :        379 :   tree argtypes[2] = { NULL_TREE, NULL_TREE };
    4049                 :            :   /* 1-based attribute positional arguments or zero if not specified.
    4050                 :            :      Invalid negative or excessive values are also stored but used
    4051                 :            :      only in diagnostics.  */
    4052                 :        379 :   HOST_WIDE_INT idxs[2] = { 0, 0 };
    4053                 :            : 
    4054                 :            :   /* Number of function formal arguments (used in diagnostics).  */
    4055                 :        379 :   unsigned nfuncargs = 0;
    4056                 :            :   /* Number of (optional) attribute positional arguments.  */
    4057                 :        379 :   unsigned nattrargs = 0;
    4058                 :            : 
    4059                 :        811 :   for (unsigned i = 0; i != 2; ++i, args = TREE_CHAIN (args), ++nattrargs)
    4060                 :            :     {
    4061                 :        758 :       if (!args)
    4062                 :            :         break;
    4063                 :            : 
    4064                 :        432 :       idxnodes[i] = TREE_VALUE (args);
    4065                 :            : 
    4066                 :        432 :       if (TREE_CODE (idxnodes[i]) != IDENTIFIER_NODE
    4067                 :        432 :           && TREE_CODE (idxnodes[i]) != FUNCTION_DECL)
    4068                 :        432 :         idxnodes[i] = default_conversion (idxnodes[i]);
    4069                 :            : 
    4070                 :        432 :       if (tree_fits_shwi_p (idxnodes[i]))
    4071                 :            :         {
    4072                 :        426 :           idxs[i] = tree_to_shwi (idxnodes[i]);
    4073                 :        426 :           argtypes[i] = get_argument_type (type, idxs[i], &nfuncargs);
    4074                 :            :         }
    4075                 :            :     }
    4076                 :            : 
    4077                 :        379 :   if ((nattrargs == 1 && !idxs[0])
    4078                 :        376 :       || (nattrargs == 2 && (!idxs[0] || !idxs[1])))
    4079                 :            :     {
    4080                 :          6 :       if (idxnodes[1])
    4081                 :          3 :         error ("attribute %<%E(%s, %E, %E)%> invalid positional argument %i",
    4082                 :          3 :                name, access_str, idxnodes[0], idxnodes[1], idxs[0] ? 2 : 1);
    4083                 :            :       else
    4084                 :          3 :         error ("attribute %<%E(%s, %E)%> invalid positional argument %i",
    4085                 :          3 :                name, access_str, idxnodes[0], idxs[0] ? 2 : 1);
    4086                 :          6 :       return NULL_TREE;
    4087                 :            :     }
    4088                 :            : 
    4089                 :            :   /* Format the attribute specification to include in diagnostics.  */
    4090                 :        373 :   char attrstr[80];
    4091                 :        373 :   if (idxnodes[1])
    4092                 :        100 :     snprintf (attrstr, sizeof attrstr, "%s(%s, %lli, %lli)",
    4093                 :         50 :               IDENTIFIER_POINTER (name), access_str,
    4094                 :         50 :               (long long) idxs[0], (long long) idxs[1]);
    4095                 :        323 :   else if (idxnodes[0])
    4096                 :        646 :     snprintf (attrstr, sizeof attrstr, "%s(%s, %lli)",
    4097                 :        323 :               IDENTIFIER_POINTER (name), access_str,
    4098                 :        323 :               (long long) idxs[0]);
    4099                 :            :   else
    4100                 :          0 :     snprintf (attrstr, sizeof attrstr, "%s(%s)",
    4101                 :          0 :               IDENTIFIER_POINTER (name), access_str);
    4102                 :            : 
    4103                 :            :   /* Verify the positional argument values are in range.  */
    4104                 :        373 :   if (!argtypes[0] || (idxnodes[1] && !argtypes[1]))
    4105                 :            :     {
    4106                 :          9 :       if (idxnodes[0])
    4107                 :            :         {
    4108                 :          9 :           if (idxs[0] < 0 || idxs[1] < 0)
    4109                 :          9 :             error ("attribute %qs positional argument %i invalid value %wi",
    4110                 :            :                    attrstr, idxs[0] < 0 ? 1 : 2,
    4111                 :            :                    idxs[0] < 0 ? idxs[0] : idxs[1]);
    4112                 :            :           else
    4113                 :          3 :             error ("attribute %qs positional argument %i value %wi exceeds "
    4114                 :            :                    "number of function arguments %u",
    4115                 :            :                    attrstr, idxs[0] ? 1 : 2,
    4116                 :            :                    idxs[0] ? idxs[0] : idxs[1],
    4117                 :            :                    nfuncargs);
    4118                 :            :         }
    4119                 :            :       else
    4120                 :          0 :         error ("attribute %qs invalid positional argument", attrstr);
    4121                 :            : 
    4122                 :          9 :       return NULL_TREE;
    4123                 :            :     }
    4124                 :            : 
    4125                 :        364 :   if (!POINTER_TYPE_P (argtypes[0]))
    4126                 :            :     {
    4127                 :            :       /* The first argument must have a pointer or reference type.  */
    4128                 :          4 :       error ("attribute %qs positional argument 1 references "
    4129                 :            :              "non-pointer argument type %qT",
    4130                 :            :              attrstr, argtypes[0]);
    4131                 :          4 :       return NULL_TREE;
    4132                 :            :     }
    4133                 :            : 
    4134                 :        360 :   {
    4135                 :            :     /* Pointers to functions are not allowed.  */
    4136                 :        360 :     tree ptrtype = TREE_TYPE (argtypes[0]);
    4137                 :        360 :     if (FUNC_OR_METHOD_TYPE_P (ptrtype))
    4138                 :            :       {
    4139                 :          3 :         error ("attribute %qs positional argument 1 references "
    4140                 :            :                "argument of function type %qT",
    4141                 :            :                attrstr, ptrtype);
    4142                 :          3 :         return NULL_TREE;
    4143                 :            :       }
    4144                 :            :   }
    4145                 :            : 
    4146                 :        357 :   if (!read_only)
    4147                 :            :     {
    4148                 :            :       /* A read_write and write_only modes must reference non-const
    4149                 :            :          arguments.  */
    4150                 :        291 :       if (TYPE_READONLY (TREE_TYPE (argtypes[0])))
    4151                 :            :         {
    4152                 :          3 :           error ("attribute %qs positional argument 1 references "
    4153                 :            :                  "%qs-qualified argument type %qT",
    4154                 :            :                  attrstr, "const", argtypes[0]);
    4155                 :          3 :           return NULL_TREE;
    4156                 :            :         }
    4157                 :            :     }
    4158                 :         66 :   else if (!TYPE_READONLY (TREE_TYPE (argtypes[0])))
    4159                 :            :     {
    4160                 :            :       /* A read_only mode should ideally reference const-qualified
    4161                 :            :          arguments but it's not diagnosed error if one doesn't.
    4162                 :            :          This makes it possible to annotate legacy, const-incorrect
    4163                 :            :          APIs.  It might be worth a diagnostic along the lines of
    4164                 :            :          -Wsuggest-const.  */
    4165                 :            :       ;
    4166                 :            :     }
    4167                 :            : 
    4168                 :        354 :   if (argtypes[1] && !INTEGRAL_TYPE_P (argtypes[1]))
    4169                 :            :     {
    4170                 :         12 :       error ("attribute %qs positional argument 2 references "
    4171                 :            :              "non-integer argument type %qT",
    4172                 :            :              attrstr, argtypes[1]);
    4173                 :         12 :       return NULL_TREE;
    4174                 :            :     }
    4175                 :            : 
    4176                 :            :   /* Verify that the new attribute doesn't conflict with any existing
    4177                 :            :      attributes specified on previous declarations of the same type
    4178                 :            :      and if not, concatenate the two.  */
    4179                 :        342 :   const char code = read_only ? 'r' : write_only ? 'w' : 'x';
    4180                 :        342 :   tree new_attrs = append_access_attrs (node[0], attrs, attrstr, code, idxs);
    4181                 :        342 :   if (!new_attrs)
    4182                 :            :     return NULL_TREE;
    4183                 :            : 
    4184                 :            :   /* Replace any existing access attribute specification with
    4185                 :            :      the concatenation above.  */
    4186                 :        313 :   new_attrs = tree_cons (NULL_TREE, new_attrs, NULL_TREE);
    4187                 :        313 :   new_attrs = tree_cons (name, new_attrs, attrs);
    4188                 :            : 
    4189                 :        313 :   if (node[1])
    4190                 :            :     {
    4191                 :            :       /* Repeat for the previously declared type.  */
    4192                 :        232 :       attrs = TYPE_ATTRIBUTES (TREE_TYPE (node[1]));
    4193                 :        232 :       tree attrs1 = append_access_attrs (node[1], attrs, attrstr, code, idxs);
    4194                 :        232 :       if (!attrs1)
    4195                 :            :         return NULL_TREE;
    4196                 :            : 
    4197                 :        126 :       attrs1 = tree_cons (NULL_TREE, attrs1, NULL_TREE);
    4198                 :        126 :       new_attrs = tree_cons (name, attrs1, attrs);
    4199                 :            :     }
    4200                 :            : 
    4201                 :            :   /* Recursively call self to "replace" the documented/external form
    4202                 :            :      of the attribute with the condensend internal form.  */
    4203                 :        207 :   decl_attributes (node, new_attrs, flags);
    4204                 :        207 :   return NULL_TREE;
    4205                 :            : }
    4206                 :            : 
    4207                 :            : /* Handle a "nothrow" attribute; arguments as in
    4208                 :            :    struct attribute_spec.handler.  */
    4209                 :            : 
    4210                 :            : static tree
    4211                 :  210719000 : handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
    4212                 :            :                           int ARG_UNUSED (flags), bool *no_add_attrs)
    4213                 :            : {
    4214                 :  210719000 :   if (TREE_CODE (*node) == FUNCTION_DECL)
    4215                 :  210719000 :     TREE_NOTHROW (*node) = 1;
    4216                 :            :   /* ??? TODO: Support types.  */
    4217                 :            :   else
    4218                 :            :     {
    4219                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    4220                 :          0 :       *no_add_attrs = true;
    4221                 :            :     }
    4222                 :            : 
    4223                 :  210719000 :   return NULL_TREE;
    4224                 :            : }
    4225                 :            : 
    4226                 :            : /* Handle a "cleanup" attribute; arguments as in
    4227                 :            :    struct attribute_spec.handler.  */
    4228                 :            : 
    4229                 :            : static tree
    4230                 :        219 : handle_cleanup_attribute (tree *node, tree name, tree args,
    4231                 :            :                           int ARG_UNUSED (flags), bool *no_add_attrs)
    4232                 :            : {
    4233                 :        219 :   tree decl = *node;
    4234                 :        219 :   tree cleanup_id, cleanup_decl;
    4235                 :            : 
    4236                 :            :   /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
    4237                 :            :      for global destructors in C++.  This requires infrastructure that
    4238                 :            :      we don't have generically at the moment.  It's also not a feature
    4239                 :            :      we'd be missing too much, since we do have attribute constructor.  */
    4240                 :        219 :   if (!VAR_P (decl) || TREE_STATIC (decl))
    4241                 :            :     {
    4242                 :         15 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    4243                 :         15 :       *no_add_attrs = true;
    4244                 :         15 :       return NULL_TREE;
    4245                 :            :     }
    4246                 :            : 
    4247                 :            :   /* Verify that the argument is a function in scope.  */
    4248                 :            :   /* ??? We could support pointers to functions here as well, if
    4249                 :            :      that was considered desirable.  */
    4250                 :        204 :   cleanup_id = TREE_VALUE (args);
    4251                 :        204 :   if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
    4252                 :            :     {
    4253                 :          5 :       error ("cleanup argument not an identifier");
    4254                 :          5 :       *no_add_attrs = true;
    4255                 :          5 :       return NULL_TREE;
    4256                 :            :     }
    4257                 :        199 :   cleanup_decl = lookup_name (cleanup_id);
    4258                 :        199 :   if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
    4259                 :            :     {
    4260                 :         10 :       error ("cleanup argument not a function");
    4261                 :         10 :       *no_add_attrs = true;
    4262                 :         10 :       return NULL_TREE;
    4263                 :            :     }
    4264                 :            : 
    4265                 :            :   /* That the function has proper type is checked with the
    4266                 :            :      eventual call to build_function_call.  */
    4267                 :            : 
    4268                 :            :   return NULL_TREE;
    4269                 :            : }
    4270                 :            : 
    4271                 :            : /* Handle a "warn_unused_result" attribute.  No special handling.  */
    4272                 :            : 
    4273                 :            : static tree
    4274                 :    2077900 : handle_warn_unused_result_attribute (tree *node, tree name,
    4275                 :            :                                tree ARG_UNUSED (args),
    4276                 :            :                                int ARG_UNUSED (flags), bool *no_add_attrs)
    4277                 :            : {
    4278                 :            :   /* Ignore the attribute for functions not returning any value.  */
    4279                 :    2077900 :   if (VOID_TYPE_P (TREE_TYPE (*node)))
    4280                 :            :     {
    4281                 :         11 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    4282                 :         11 :       *no_add_attrs = true;
    4283                 :            :     }
    4284                 :            : 
    4285                 :    2077900 :   return NULL_TREE;
    4286                 :            : }
    4287                 :            : 
    4288                 :            : /* Handle a "sentinel" attribute.  */
    4289                 :            : 
    4290                 :            : static tree
    4291                 :     813196 : handle_sentinel_attribute (tree *node, tree name, tree args,
    4292                 :            :                            int ARG_UNUSED (flags), bool *no_add_attrs)
    4293                 :            : {
    4294                 :     813196 :   if (!prototype_p (*node))
    4295                 :            :     {
    4296                 :          4 :       warning (OPT_Wattributes,
    4297                 :            :                "%qE attribute requires prototypes with named arguments", name);
    4298                 :          4 :       *no_add_attrs = true;
    4299                 :            :     }
    4300                 :            :   else
    4301                 :            :     {
    4302                 :     813192 :       if (!stdarg_p (*node))
    4303                 :            :         {
    4304                 :          2 :           warning (OPT_Wattributes,
    4305                 :            :                    "%qE attribute only applies to variadic functions", name);
    4306                 :          2 :           *no_add_attrs = true;
    4307                 :            :         }
    4308                 :            :     }
    4309                 :            : 
    4310                 :     813196 :   if (args)
    4311                 :            :     {
    4312                 :     271061 :       tree position = TREE_VALUE (args);
    4313                 :     271061 :       if (position && TREE_CODE (position) != IDENTIFIER_NODE
    4314                 :     271061 :           && TREE_CODE (position) != FUNCTION_DECL)
    4315                 :     271056 :         position = default_conversion (position);
    4316                 :            : 
    4317                 :     271061 :       if (TREE_CODE (position) != INTEGER_CST
    4318                 :     542115 :           || !INTEGRAL_TYPE_P (TREE_TYPE (position)))
    4319                 :            :         {
    4320                 :          7 :           warning (OPT_Wattributes,
    4321                 :            :                    "requested position is not an integer constant");
    4322                 :          7 :           *no_add_attrs = true;
    4323                 :            :         }
    4324                 :            :       else
    4325                 :            :         {
    4326                 :     271054 :           if (tree_int_cst_lt (position, integer_zero_node))
    4327                 :            :             {
    4328                 :          2 :               warning (OPT_Wattributes,
    4329                 :            :                        "requested position is less than zero");
    4330                 :          2 :               *no_add_attrs = true;
    4331                 :            :             }
    4332                 :            :         }
    4333                 :            :     }
    4334                 :            : 
    4335                 :     813196 :   return NULL_TREE;
    4336                 :            : }
    4337                 :            : 
    4338                 :            : /* Handle a "type_generic" attribute.  */
    4339                 :            : 
    4340                 :            : static tree
    4341                 :    3389990 : handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
    4342                 :            :                                tree ARG_UNUSED (args), int ARG_UNUSED (flags),
    4343                 :            :                                bool * ARG_UNUSED (no_add_attrs))
    4344                 :            : {
    4345                 :            :   /* Ensure we have a function type.  */
    4346                 :    3389990 :   gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
    4347                 :            : 
    4348                 :            :   /* Ensure we have a variadic function.  */
    4349                 :    3389990 :   gcc_assert (!prototype_p (*node) || stdarg_p (*node));
    4350                 :            : 
    4351                 :    3389990 :   return NULL_TREE;
    4352                 :            : }
    4353                 :            : 
    4354                 :            : /* Handle a "target" attribute.  */
    4355                 :            : 
    4356                 :            : static tree
    4357                 :   11721400 : handle_target_attribute (tree *node, tree name, tree args, int flags,
    4358                 :            :                          bool *no_add_attrs)
    4359                 :            : {
    4360                 :            :   /* Ensure we have a function type.  */
    4361                 :   11721400 :   if (TREE_CODE (*node) != FUNCTION_DECL)
    4362                 :            :     {
    4363                 :          1 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    4364                 :          1 :       *no_add_attrs = true;
    4365                 :            :     }
    4366                 :   11721400 :   else if (lookup_attribute ("target_clones", DECL_ATTRIBUTES (*node)))
    4367                 :            :     {
    4368                 :          4 :       warning (OPT_Wattributes, "%qE attribute ignored due to conflict "
    4369                 :            :                    "with %qs attribute", name, "target_clones");
    4370                 :          4 :       *no_add_attrs = true;
    4371                 :            :     }
    4372                 :   11721400 :   else if (! targetm.target_option.valid_attribute_p (*node, name, args,
    4373                 :            :                                                       flags))
    4374                 :        166 :     *no_add_attrs = true;
    4375                 :            : 
    4376                 :            :   /* Check that there's no empty string in values of the attribute.  */
    4377                 :   23552200 :   for (tree t = args; t != NULL_TREE; t = TREE_CHAIN (t))
    4378                 :            :     {
    4379                 :   11830800 :       tree value = TREE_VALUE (t);
    4380                 :   11830800 :       if (TREE_CODE (value) == STRING_CST
    4381                 :   11830800 :           && TREE_STRING_LENGTH (value) == 1
    4382                 :   11830800 :           && TREE_STRING_POINTER (value)[0] == '\0')
    4383                 :            :         {
    4384                 :         12 :           warning (OPT_Wattributes, "empty string in attribute %<target%>");
    4385                 :         12 :           *no_add_attrs = true;
    4386                 :            :         }
    4387                 :            :     }
    4388                 :            : 
    4389                 :   11721400 :   return NULL_TREE;
    4390                 :            : }
    4391                 :            : 
    4392                 :            : /* Handle a "target_clones" attribute.  */
    4393                 :            : 
    4394                 :            : static tree
    4395                 :         81 : handle_target_clones_attribute (tree *node, tree name, tree ARG_UNUSED (args),
    4396                 :            :                           int ARG_UNUSED (flags), bool *no_add_attrs)
    4397                 :            : {
    4398                 :            :   /* Ensure we have a function type.  */
    4399                 :         81 :   if (TREE_CODE (*node) == FUNCTION_DECL)
    4400                 :            :     {
    4401                 :         81 :       if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (*node)))
    4402                 :            :         {
    4403                 :          4 :           warning (OPT_Wattributes, "%qE attribute ignored due to conflict "
    4404                 :            :                    "with %qs attribute", name, "always_inline");
    4405                 :          4 :           *no_add_attrs = true;
    4406                 :            :         }
    4407                 :         77 :       else if (lookup_attribute ("target", DECL_ATTRIBUTES (*node)))
    4408                 :            :         {
    4409                 :          4 :           warning (OPT_Wattributes, "%qE attribute ignored due to conflict "
    4410                 :            :                    "with %qs attribute", name, "target");
    4411                 :          4 :           *no_add_attrs = true;
    4412                 :            :         }
    4413                 :            :       else
    4414                 :            :       /* Do not inline functions with multiple clone targets.  */
    4415                 :         73 :         DECL_UNINLINABLE (*node) = 1;
    4416                 :            :     }
    4417                 :            :   else
    4418                 :            :     {
    4419                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    4420                 :          0 :       *no_add_attrs = true;
    4421                 :            :     }
    4422                 :         81 :   return NULL_TREE;
    4423                 :            : }
    4424                 :            : 
    4425                 :            : /* For handling "optimize" attribute. arguments as in
    4426                 :            :    struct attribute_spec.handler.  */
    4427                 :            : 
    4428                 :            : static tree
    4429                 :       4281 : handle_optimize_attribute (tree *node, tree name, tree args,
    4430                 :            :                            int ARG_UNUSED (flags), bool *no_add_attrs)
    4431                 :            : {
    4432                 :            :   /* Ensure we have a function type.  */
    4433                 :       4281 :   if (TREE_CODE (*node) != FUNCTION_DECL)
    4434                 :            :     {
    4435                 :          0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    4436                 :          0 :       *no_add_attrs = true;
    4437                 :            :     }
    4438                 :            :   else
    4439                 :            :     {
    4440                 :       4281 :       struct cl_optimization cur_opts;
    4441                 :       4281 :       tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
    4442                 :            : 
    4443                 :            :       /* Save current options.  */
    4444                 :       4281 :       cl_optimization_save (&cur_opts, &global_options);
    4445                 :            : 
    4446                 :            :       /* If we previously had some optimization options, use them as the
    4447                 :            :          default.  */
    4448                 :       4281 :       if (old_opts)
    4449                 :        278 :         cl_optimization_restore (&global_options,
    4450                 :        278 :                                  TREE_OPTIMIZATION (old_opts));
    4451                 :            : 
    4452                 :            :       /* Parse options, and update the vector.  */
    4453                 :       4281 :       parse_optimize_options (args, true);
    4454                 :       4281 :       DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
    4455                 :       4281 :         = build_optimization_node (&global_options);
    4456                 :            : 
    4457                 :            :       /* Restore current options.  */
    4458                 :       4281 :       cl_optimization_restore (&global_options, &cur_opts);
    4459                 :            :     }
    4460                 :            : 
    4461                 :       4281 :   return NULL_TREE;
    4462                 :            : }
    4463                 :            : 
    4464                 :            : /* Handle a "no_split_stack" attribute.  */
    4465                 :            : 
    4466                 :            : static tree
    4467                 :        421 : handle_no_split_stack_attribute (tree *node, tree name,
    4468                 :            :                                  tree ARG_UNUSED (args),
    4469                 :            :                                  int ARG_UNUSED (flags),
    4470                 :            :                                  bool *no_add_attrs)
    4471                 :            : {
    4472                 :        421 :   tree decl = *node;
    4473                 :            : 
    4474                 :        421 :   if (TREE_CODE (decl) != FUNCTION_DECL)
    4475                 :            :     {
    4476                 :          0 :       error_at (DECL_SOURCE_LOCATION (decl),
    4477                 :            :                 "%qE attribute applies only to functions", name);
    4478                 :          0 :       *no_add_attrs = true;
    4479                 :            :     }
    4480                 :        421 :   else if (DECL_INITIAL (decl))
    4481                 :            :     {
    4482                 :          0 :       error_at (DECL_SOURCE_LOCATION (decl),
    4483                 :            :                 "cannot set %qE attribute after definition", name);
    4484                 :          0 :       *no_add_attrs = true;
    4485                 :            :     }
    4486                 :            : 
    4487                 :        421 :   return NULL_TREE;
    4488                 :            : }
    4489                 :            : 
    4490                 :            : /* Handle a "returns_nonnull" attribute; arguments as in
    4491                 :            :    struct attribute_spec.handler.  */
    4492                 :            : 
    4493                 :            : static tree
    4494                 :    1898210 : handle_returns_nonnull_attribute (tree *node, tree name, tree, int,
    4495                 :            :                                   bool *no_add_attrs)
    4496                 :            : {
    4497                 :            :   // Even without a prototype we still have a return type we can check.
    4498                 :    1898210 :   if (TREE_CODE (TREE_TYPE (*node)) != POINTER_TYPE)
    4499                 :            :     {
    4500                 :          5 :       error ("%qE attribute on a function not returning a pointer", name);
    4501                 :          5 :       *no_add_attrs = true;
    4502                 :            :     }
    4503                 :    1898210 :   return NULL_TREE;
    4504                 :            : }
    4505                 :            : 
    4506                 :            : /* Handle a "designated_init" attribute; arguments as in
    4507                 :            :    struct attribute_spec.handler.  */
    4508                 :            : 
    4509                 :            : static tree
    4510                 :          7 : handle_designated_init_attribute (tree *node, tree name, tree, int,
    4511                 :            :                                   bool *no_add_attrs)
    4512                 :            : {
    4513                 :          7 :   if (TREE_CODE (*node) != RECORD_TYPE)
    4514                 :            :     {
    4515                 :          3 :       error ("%qE attribute is only valid on %<struct%> type", name);
    4516                 :          3 :       *no_add_attrs = true;
    4517                 :            :     }
    4518                 :          7 :   return NULL_TREE;
    4519                 :            : }
    4520                 :            : 
    4521                 :            : 
    4522                 :            : /* Handle a "fallthrough" attribute; arguments as in struct
    4523                 :            :    attribute_spec.handler.  */
    4524                 :            : 
    4525                 :            : tree
    4526                 :         14 : handle_fallthrough_attribute (tree *, tree name, tree, int,
    4527                 :            :                               bool *no_add_attrs)
    4528                 :            : {
    4529                 :         14 :   pedwarn (input_location, OPT_Wattributes, "%qE attribute ignored", name);
    4530                 :         14 :   *no_add_attrs = true;
    4531                 :         14 :   return NULL_TREE;
    4532                 :            : }
    4533                 :            : 
    4534                 :            : /* Handle a "patchable_function_entry" attributes; arguments as in
    4535                 :            :    struct attribute_spec.handler.  */
    4536                 :            : 
    4537                 :            : static tree
    4538                 :         30 : handle_patchable_function_entry_attribute (tree *, tree name, tree args,
    4539                 :            :                                            int, bool *no_add_attrs)
    4540                 :            : {
    4541                 :         50 :   for (; args; args = TREE_CHAIN (args))
    4542                 :            :     {
    4543                 :         40 :       tree val = TREE_VALUE (args);
    4544                 :         40 :       if (val && TREE_CODE (val) != IDENTIFIER_NODE
    4545                 :         40 :           && TREE_CODE (val) != FUNCTION_DECL)
    4546                 :         40 :         val = default_conversion (val);
    4547                 :            : 
    4548                 :         40 :       if (!tree_fits_uhwi_p (val))
    4549                 :            :         {
    4550                 :         20 :           warning (OPT_Wattributes,
    4551                 :            :                    "%qE attribute argument %qE is not an integer constant",
    4552                 :            :                    name, val);
    4553                 :         20 :           *no_add_attrs = true;
    4554                 :         20 :           return NULL_TREE;
    4555                 :            :         }
    4556                 :            :     }
    4557                 :            :   return NULL_TREE;
    4558                 :            : }
    4559                 :            : 
    4560                 :            : /* Attempt to partially validate a single attribute ATTR as if
    4561                 :            :    it were to be applied to an entity OPER.  */
    4562                 :            : 
    4563                 :            : static bool
    4564                 :       3513 : validate_attribute (location_t atloc, tree oper, tree attr)
    4565                 :            : {
    4566                 :            :   /* Determine whether the name of the attribute is valid
    4567                 :            :      and fail with an error if not.  */
    4568                 :       3513 :   tree atname = get_attribute_name (attr);
    4569                 :       3513 :   if (!lookup_attribute_spec (atname))
    4570                 :            :     {
    4571                 :         10 :       if (atloc != UNKNOWN_LOCATION)
    4572                 :         10 :         error_at (atloc, "unknown attribute %qE", atname);
    4573                 :         10 :       return false;
    4574                 :            :     }
    4575                 :            : 
    4576                 :       3503 :   tree args = TREE_VALUE (attr);
    4577                 :       3503 :   if (!args)
    4578                 :            :     return true;
    4579                 :            : 
    4580                 :            :   /* FIXME: Do some validation.  */
    4581                 :       2040 :   const char *atstr = IDENTIFIER_POINTER (atname);
    4582                 :       2040 :   if (!strcmp (atstr, "format"))
    4583                 :            :     return true;
    4584                 :            : 
    4585                 :            :   /* Only when attribute arguments have been provided try to validate
    4586                 :            :      the whole thing.  decl_attributes doesn't return an indication of
    4587                 :            :      success or failure so proceed regardless.  */
    4588                 :       2030 :   const char tmpname[] = "__builtin_has_attribute_tmp.";
    4589                 :       2030 :   tree tmpid = get_identifier (tmpname);
    4590                 :       2030 :   tree tmpdecl;
    4591                 :       2030 :   if (!strcmp (atstr, "vector_size"))
    4592                 :            :     {
    4593                 :        365 :       tree type = TYPE_P (oper) ? oper : TREE_TYPE (oper);
    4594                 :            :       /* Check for function type here since type_for_vector_size
    4595                 :            :          strips it while looking for a function's return type.  */
    4596                 :        220 :       if (FUNC_OR_METHOD_TYPE_P (type))
    4597                 :            :         {
    4598                 :          0 :           warning_at (atloc, OPT_Wattributes,
    4599                 :            :                       "invalid operand type %qT for %qs", type, atstr);
    4600                 :          0 :           return false;
    4601                 :            :         }
    4602                 :            : 
    4603                 :        220 :       type = type_for_vector_size (type);
    4604                 :        220 :       if (VECTOR_TYPE_P (type))
    4605                 :        205 :         type = TREE_TYPE (type);
    4606                 :            :       /* Avoid trying to apply attribute vector_size to OPER since
    4607                 :            :          it's overly restrictive.  Simply make sure it has the right
    4608                 :            :          type.  */
    4609                 :        220 :       return type_valid_for_vector_size (type, atname, args, NULL);
    4610                 :            :     }
    4611                 :            : 
    4612                 :       1810 :   if (TYPE_P (oper))
    4613                 :        385 :     tmpdecl = build_decl (atloc, TYPE_DECL, tmpid, oper);
    4614                 :       1425 :   else if (DECL_P (oper))
    4615                 :        697 :     tmpdecl = build_decl (atloc, TREE_CODE (oper), tmpid, TREE_TYPE (oper));
    4616                 :        728 :   else if (EXPR_P (oper))
    4617                 :        728 :     tmpdecl = build_decl (atloc, TYPE_DECL, tmpid, TREE_TYPE (oper));
    4618                 :            :   else
    4619                 :            :     return false;
    4620                 :            : 
    4621                 :            :   /* Temporarily clear CURRENT_FUNCTION_DECL to make decl_attributes
    4622                 :            :      believe the DECL declared above is at file scope.  (See bug 87526.)  */
    4623                 :       1810 :   tree save_curfunc = current_function_decl;
    4624                 :       1810 :   current_function_decl = NULL_TREE;
    4625                 :       1810 :   if (DECL_P (tmpdecl))
    4626                 :            :     {
    4627                 :       1810 :       if (DECL_P (oper))
    4628                 :            :         /* An alias cannot be a definition so declare the symbol extern.  */
    4629                 :        697 :         DECL_EXTERNAL (tmpdecl) = true;
    4630                 :            :       /* Attribute visibility only applies to symbols visible from other
    4631                 :            :          translation units so make it "public."   */
    4632                 :       1810 :       TREE_PUBLIC (tmpdecl) = TREE_PUBLIC (oper);
    4633                 :            :     }
    4634                 :       1810 :   decl_attributes (&tmpdecl, attr, 0);
    4635                 :       1810 :   current_function_decl = save_curfunc;
    4636                 :            : 
    4637                 :            :   /* FIXME: Change decl_attributes to indicate success or failure (and
    4638                 :            :      parameterize it to avoid failing with errors).  */
    4639                 :       1810 :   return true;
    4640                 :            : }
    4641                 :            : 
    4642                 :            : /* Return true if the DECL, EXPR, or TYPE t has been declared with
    4643                 :            :    attribute ATTR.  For DECL, consider also its type.  For EXPR,
    4644                 :            :    consider just its type.  */
    4645                 :            : 
    4646                 :            : bool
    4647                 :       3514 : has_attribute (location_t atloc, tree t, tree attr, tree (*convert)(tree))
    4648                 :            : {
    4649                 :       3514 :   if (!attr || !t || t == error_mark_node)
    4650                 :            :     return false;
    4651                 :            : 
    4652                 :       3513 :   if (!validate_attribute (atloc, t, attr))
    4653                 :            :     return false;
    4654                 :            : 
    4655                 :       3438 :   tree type = NULL_TREE;
    4656                 :       3438 :   tree expr = NULL_TREE;
    4657                 :       3438 :   if (TYPE_P (t))
    4658                 :            :     type = t;
    4659                 :            :   else
    4660                 :            :     {
    4661                 :       2984 :       do
    4662                 :            :         {
    4663                 :            :           /* Determine the array element/member declaration from
    4664                 :            :              a COMPONENT_REF and an INDIRECT_REF involving a refeence.  */
    4665                 :       2984 :           STRIP_NOPS (t);
    4666                 :       2984 :           tree_code code = TREE_CODE (t);
    4667                 :       2984 :           if (code == INDIRECT_REF)
    4668                 :            :             {
    4669                 :        539 :               tree op0 = TREE_OPERAND (t, 0);
    4670                 :        539 :               if (TREE_CODE (TREE_TYPE (op0)) == REFERENCE_TYPE)
    4671                 :            :                 t = op0;
    4672                 :            :               else
    4673                 :            :                 break;
    4674                 :            :             }
    4675                 :       2445 :           else if (code == COMPONENT_REF)
    4676                 :        202 :             t = TREE_OPERAND (t, 1);
    4677                 :            :           else
    4678                 :            :             break;
    4679                 :            :         } while (true);
    4680                 :            :       expr = t;
    4681                 :            :     }
    4682                 :            : 
    4683                 :            :   /* Set to true when an attribute is found in the referenced entity
    4684                 :            :      that matches the specified attribute.  */
    4685                 :       3438 :   bool found_match = false;
    4686                 :            : 
    4687                 :       3438 :   tree atname = get_attribute_name (attr);
    4688                 :       3438 :   const char *namestr = IDENTIFIER_POINTER (atname);
    4689                 :            : 
    4690                 :            :    /* Iterate once for a type and twice for a function or variable
    4691                 :            :      declaration: once for the DECL and the second time for its
    4692                 :            :      TYPE.  */
    4693                 :       6795 :   for (bool done = false; !found_match && !done; )
    4694                 :            :     {
    4695                 :       4392 :       tree atlist;
    4696                 :       4392 :       if (type)
    4697                 :            :         {
    4698                 :       1634 :           if (type == error_mark_node)
    4699                 :            :             {
    4700                 :            :               /* This could be a label.  FIXME: add support for labels.  */
    4701                 :          0 :               warning_at (atloc, OPT_Wattributes,
    4702                 :          0 :                           (TYPE_P (t)
    4703                 :            :                            ? G_("%qs attribute not supported for %qT "
    4704                 :            :                                 "in %<__builtin_has_attribute%>")
    4705                 :            :                            : G_("%qs attribute not supported for %qE "
    4706                 :            :                                 "in %<__builtin_has_attribute%>")),
    4707                 :            :                           namestr, t);
    4708                 :          0 :               return false;
    4709                 :            :             }
    4710                 :            : 
    4711                 :            :           /* Clear EXPR to prevent considering it again below.  */
    4712                 :       1634 :           atlist = TYPE_ATTRIBUTES (type);
    4713                 :       1634 :           expr = NULL_TREE;
    4714                 :       1634 :           done = true;
    4715                 :            :         }
    4716                 :       2758 :       else if (DECL_P (expr))
    4717                 :            :         {
    4718                 :            :           /* Set TYPE to the DECL's type to process it on the next
    4719                 :            :              iteration.  */
    4720                 :       1622 :           atlist = DECL_ATTRIBUTES (expr);
    4721                 :       1622 :           type = TREE_TYPE (expr);
    4722                 :            :         }
    4723                 :            :       else
    4724                 :            :         {
    4725                 :       1136 :           type = TREE_TYPE (expr);
    4726                 :       1136 :           atlist = TYPE_ATTRIBUTES (type);
    4727                 :       1136 :           done = true;
    4728                 :            :         }
    4729                 :            : 
    4730                 :            :      /* True when an attribute with the sought name (though not necessarily
    4731                 :            :          with the sought attributes) has been found on the attribute chain.  */
    4732                 :       4392 :       bool found_attr = false;
    4733                 :            : 
    4734                 :            :       /* When clear, the first mismatched attribute argument results
    4735                 :            :          in failure.  Otherwise, the first matched attribute argument
    4736                 :            :          results in success.  */
    4737                 :       4392 :       bool attr_nonnull = !strcmp ("nonnull", namestr);
    4738                 :       4392 :       bool ignore_mismatches = attr_nonnull;
    4739                 :            : 
    4740                 :            :       /* Iterate over the instances of the sought attribute on the DECL or
    4741                 :            :          TYPE (there may be multiple instances with different arguments).  */
    4742                 :       4829 :       for (; (atlist = lookup_attribute (namestr, atlist));
    4743                 :        437 :            found_attr = true, atlist = TREE_CHAIN (atlist))
    4744                 :            :         {
    4745                 :            :           /* If there are no arguments to match the result is true except
    4746                 :            :              for nonnull where the attribute with no arguments must match.  */
    4747                 :       1217 :           if (!TREE_VALUE (attr))
    4748                 :        545 :             return attr_nonnull ? !TREE_VALUE (atlist) : true;
    4749                 :            : 
    4750                 :            :           /* Attribute nonnull with no arguments subsumes all values of
    4751                 :            :              the attribute.  FIXME: This is overly broad since it only
    4752                 :            :              applies to pointer arguments, but querying non-pointer
    4753                 :            :              arguments is diagnosed.  */
    4754                 :        682 :           if (!TREE_VALUE (atlist) && attr_nonnull)
    4755                 :            :             return true;
    4756                 :            : 
    4757                 :            :           /* Iterate over the DECL or TYPE attribute argument's values.  */
    4758                 :       1078 :           for (tree val = TREE_VALUE (atlist); val; val = TREE_CHAIN (val))
    4759                 :            :             {
    4760                 :            :               /* Iterate over the arguments in the sought attribute comparing
    4761                 :            :                  their values to those specified for the DECL or TYPE.  */
    4762                 :        666 :               for (tree arg = TREE_VALUE (attr); arg; arg = TREE_CHAIN (arg))
    4763                 :            :                 {
    4764                 :        641 :                   tree v1 = TREE_VALUE (val);
    4765                 :        641 :                   tree v2 = TREE_VALUE (arg);
    4766                 :        641 :                   if (v1 == v2)
    4767                 :            :                     return true;
    4768                 :            : 
    4769                 :        488 :                   if (!v1 || !v2)
    4770                 :            :                     break;
    4771                 :            : 
    4772                 :        488 :                   if (TREE_CODE (v1) == IDENTIFIER_NODE
    4773                 :        483 :                       || TREE_CODE (v2) == IDENTIFIER_NODE)
    4774                 :            :                     /* Two identifiers are the same if their values are
    4775                 :            :                        equal (that's handled above).  Otherwise ther are
    4776                 :            :                        either not the same or oneis not an identifier.  */
    4777                 :            :                     return false;
    4778                 :            : 
    4779                 :            :                   /* Convert to make them equality-comparable.  */
    4780                 :        483 :                   v1 = convert (v1);
    4781                 :        483 :                   v2 = convert (v2);
    4782                 :            : 
    4783                 :            :                   /* A positive value indicates equality, negative means
    4784                 :            :                      "don't know."  */
    4785                 :        483 :                   if (simple_cst_equal (v1, v2) == 1)
    4786                 :            :                     return true;
    4787                 :            : 
    4788                 :        411 :                   if (!ignore_mismatches)
    4789                 :            :                     break;
    4790                 :            :                 }
    4791                 :            :             }
    4792                 :            :         }
    4793                 :            : 
    4794                 :       3612 :       if (!found_attr)
    4795                 :            :         {
    4796                 :            :           /* Some attributes are encoded directly in the tree node.  */
    4797                 :       3202 :           if (!strcmp ("aligned", namestr))
    4798                 :            :             {
    4799                 :       1673 :               if (tree arg = TREE_VALUE (attr))
    4800                 :            :                 {
    4801                 :       1240 :                   arg = convert (TREE_VALUE (arg));
    4802                 :       1240 :                   if (!tree_fits_uhwi_p (arg))
    4803                 :            :                     /* Invalid argument.  */;
    4804                 :        778 :                   else if (expr && DECL_P (expr)
    4805                 :       1305 :                            && DECL_USER_ALIGN (expr))
    4806                 :          0 :                     found_match = DECL_ALIGN_UNIT (expr) == tree_to_uhwi (arg);
    4807                 :       2470 :                   else if (type && TYPE_USER_ALIGN (type))
    4808                 :        760 :                     found_match = TYPE_ALIGN_UNIT (type) == tree_to_uhwi (arg);
    4809                 :            :                 }
    4810                 :        433 :               else if (expr && DECL_P (expr))
    4811                 :         17 :                 found_match = DECL_USER_ALIGN (expr);
    4812                 :        416 :               else if (type)
    4813                 :        416 :                 found_match = TYPE_USER_ALIGN (type);
    4814                 :            :             }
    4815                 :       1529 :           else if (!strcmp ("const", namestr))
    4816                 :            :             {
    4817                 :         30 :               if (expr && DECL_P (expr))
    4818                 :         15 :                 found_match = TREE_READONLY (expr);
    4819                 :            :             }
    4820                 :       1499 :           else if (!strcmp ("noreturn", namestr))
    4821                 :            :             {
    4822                 :            :               /* C11 _Noreturn sets the volatile bit without attaching
    4823                 :            :                  an attribute to the decl.  */
    4824                 :         11 :               if (expr
    4825                 :          1 :                   && DECL_P (expr)
    4826                 :         12 :                   && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (expr)))
    4827                 :          1 :                 found_match = TREE_THIS_VOLATILE (expr);
    4828                 :            :             }
    4829                 :       1488 :           else if (!strcmp ("pure", namestr))
    4830                 :            :             {
    4831                 :         30 :               if (expr && DECL_P (expr))
    4832                 :         15 :                 found_match = DECL_PURE_P (expr);
    4833                 :            :             }
    4834                 :       1458 :           else if (!strcmp ("deprecated", namestr))
    4835                 :            :             {
    4836                 :          0 :               found_match = TREE_DEPRECATED (expr ? expr : type);
    4837                 :          0 :               if (found_match)
    4838                 :            :                 return true;
    4839                 :            :             }
    4840                 :       1458 :           else if (!strcmp ("vector_size", namestr))
    4841                 :            :             {
    4842                 :        250 :               if (!type || !VECTOR_TYPE_P (type))
    4843                 :            :                 return false;
    4844                 :            : 
    4845                 :        150 :               if (tree arg = TREE_VALUE (attr))
    4846                 :            :                 {
    4847                 :            :                   /* Compare the vector size argument for equality.  */
    4848                 :        110 :                   arg = convert (TREE_VALUE (arg));
    4849                 :        110 :                   return tree_int_cst_equal (arg, TYPE_SIZE_UNIT (type)) == 1;
    4850                 :            :                 }
    4851                 :            :               else
    4852                 :            :                 return true;
    4853                 :            :             }
    4854                 :       1208 :           else if (!strcmp ("warn_if_not_aligned", namestr))
    4855                 :            :             {
    4856                 :         30 :               if (tree arg = TREE_VALUE (attr))
    4857                 :            :                 {
    4858                 :         30 :                   arg = convert (TREE_VALUE (arg));
    4859                 :         30 :                   if (expr && DECL_P (expr))
    4860                 :          0 :                     found_match = (DECL_WARN_IF_NOT_ALIGN (expr)
    4861                 :          0 :                                    == tree_to_uhwi (arg) * BITS_PER_UNIT);
    4862                 :         30 :                   else if (type)
    4863                 :         30 :                     found_match = (TYPE_WARN_IF_NOT_ALIGN (type)
    4864                 :         30 :                                    == tree_to_uhwi (arg) * BITS_PER_UNIT);
    4865                 :            :                 }
    4866                 :          0 :               else if (expr && DECL_P (expr))
    4867                 :          0 :                 found_match = DECL_WARN_IF_NOT_ALIGN (expr);
    4868                 :          0 :               else if (type)
    4869                 :          0 :                 found_match = TYPE_WARN_IF_NOT_ALIGN (type);
    4870                 :            :             }
    4871                 :       1178 :           else if (!strcmp ("transparent_union", namestr))
    4872                 :            :             {
    4873                 :         25 :               if (type)
    4874                 :         50 :                 found_match = TYPE_TRANSPARENT_AGGR (type) != 0;
    4875                 :            :             }
    4876                 :       1153 :           else if (!strcmp ("mode", namestr))
    4877                 :            :             {
    4878                 :            :               /* Finally issue a warning for attributes that cannot
    4879                 :            :                  be supported in this context.  Attribute mode is not
    4880                 :            :                  added to a symbol and cannot be determined from it.  */
    4881                 :          5 :               warning_at (atloc, OPT_Wattributes,
    4882                 :            :                           "%qs attribute not supported in "
    4883                 :            :                           "%<__builtin_has_attribute%>", namestr);
    4884                 :          5 :               break;
    4885                 :            :             }
    4886                 :            :         }
    4887                 :            :     }
    4888                 :            :   return found_match;
    4889                 :            : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.