gcc/d/d-attribs.cc

   1 /* d-attribs.c -- D attributes handling.
   2    Copyright (C) 2015-2019 Free Software Foundation, Inc.
   3
   4 GCC is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation; either version 3, or (at your option)
   7 any later version.
   8
   9 GCC is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with GCC; see the file COPYING3.  If not see
  16 <http://www.gnu.org/licenses/>.  */
  17
  18 /* Implementation of attribute handlers for user defined attributes and
  19    internal built-in functions.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24
  25 #include "dmd/declaration.h"
  26 #include "dmd/mtype.h"
  27
  28 #include "tree.h"
  29 #include "diagnostic.h"
  30 #include "tm.h"
  31 #include "cgraph.h"
  32 #include "toplev.h"
  33 #include "target.h"
  34 #include "common/common-target.h"
  35 #include "stringpool.h"
  36 #include "attribs.h"
  37 #include "varasm.h"
  38
  39 #include "d-tree.h"
  40
  41
  42 /* Internal attribute handlers for built-in functions.  */
  43 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
  44 static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
  45 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
  46 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
  47 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
  48 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
  49 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
  50 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
  51 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
  52 static tree handle_transaction_pure_attribute (tree *, tree, tree, int, bool *);
  53 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
  54 static tree handle_fnspec_attribute (tree *, tree, tree, int, bool *);
  55
  56 /* D attribute handlers for user defined attributes.  */
  57 static tree d_handle_noinline_attribute (tree *, tree, tree, int, bool *);
  58 static tree d_handle_forceinline_attribute (tree *, tree, tree, int, bool *);
  59 static tree d_handle_flatten_attribute (tree *, tree, tree, int, bool *);
  60 static tree d_handle_target_attribute (tree *, tree, tree, int, bool *);
  61 static tree d_handle_noclone_attribute (tree *, tree, tree, int, bool *);
  62 static tree d_handle_section_attribute (tree *, tree, tree, int, bool *);
  63 static tree d_handle_alias_attribute (tree *, tree, tree, int, bool *);
  64 static tree d_handle_weak_attribute (tree *, tree, tree, int, bool *) ;
  65
  66 /* Helper to define attribute exclusions.  */
  67 #define ATTR_EXCL(name, function, type, variable)       \
  68   { name, function, type, variable }
  69
  70 /* Define attributes that are mutually exclusive with one another.  */
  71 static const struct attribute_spec::exclusions attr_noreturn_exclusions[] =
  72 {
  73   ATTR_EXCL ("const", true, true, true),
  74   ATTR_EXCL ("malloc", true, true, true),
  75   ATTR_EXCL ("pure", true, true, true),
  76   ATTR_EXCL ("returns_twice", true, true, true),
  77   ATTR_EXCL (NULL, false, false, false),
  78 };
  79
  80 static const struct attribute_spec::exclusions attr_returns_twice_exclusions[] =
  81 {
  82   ATTR_EXCL ("noreturn", true, true, true),
  83   ATTR_EXCL (NULL, false, false, false),
  84 };
  85
  86 static const struct attribute_spec::exclusions attr_const_pure_exclusions[] =
  87 {
  88   ATTR_EXCL ("const", true, true, true),
  89   ATTR_EXCL ("noreturn", true, true, true),
  90   ATTR_EXCL ("pure", true, true, true),
  91   ATTR_EXCL (NULL, false, false, false)
  92 };
  93
  94 static const struct attribute_spec::exclusions attr_inline_exclusions[] =
  95 {
  96   ATTR_EXCL ("noinline", true, true, true),
  97   ATTR_EXCL (NULL, false, false, false),
  98 };
  99
 100 static const struct attribute_spec::exclusions attr_noinline_exclusions[] =
 101 {
 102   ATTR_EXCL ("forceinline", true, true, true),
 103   ATTR_EXCL (NULL, false, false, false),
 104 };
 105
 106 /* Helper to define an attribute.  */
 107 #define ATTR_SPEC(name, min_len, max_len, decl_req, type_req, fn_type_req, \
 108                   affects_type_identity, handler, exclude)                 \
 109   { name, min_len, max_len, decl_req, type_req, fn_type_req,               \
 110     affects_type_identity, handler, exclude }
 111
 112 /* Table of machine-independent attributes.
 113    For internal use (marking of built-ins) only.  */
 114 const attribute_spec d_langhook_common_attribute_table[] =
 115 {
 116   ATTR_SPEC ("noreturn", 0, 0, true, false, false, false,
 117              handle_noreturn_attribute, attr_noreturn_exclusions),
 118   ATTR_SPEC ("leaf", 0, 0, true, false, false, false,
 119              handle_leaf_attribute, NULL),
 120   ATTR_SPEC ("const", 0, 0, true, false, false, false,
 121              handle_const_attribute, attr_const_pure_exclusions),
 122   ATTR_SPEC ("malloc", 0, 0, true, false, false, false,
 123              handle_malloc_attribute, NULL),
 124   ATTR_SPEC ("returns_twice", 0, 0, true, false, false, false,
 125              handle_returns_twice_attribute, attr_returns_twice_exclusions),
 126   ATTR_SPEC ("pure", 0, 0, true, false, false, false,
 127              handle_pure_attribute, attr_const_pure_exclusions),
 128   ATTR_SPEC ("nonnull", 0, -1, false, true, true, false,
 129              handle_nonnull_attribute, NULL),
 130   ATTR_SPEC ("nothrow", 0, 0, true, false, false, false,
 131              handle_nothrow_attribute, NULL),
 132   ATTR_SPEC ("transaction_pure", 0, 0, false, true, true, false,
 133              handle_transaction_pure_attribute, NULL),
 134   ATTR_SPEC ("no vops", 0, 0, true, false, false, false,
 135              handle_novops_attribute, NULL),
 136   ATTR_SPEC ("type generic", 0, 0, false, true, true, false,
 137              handle_type_generic_attribute, NULL),
 138   ATTR_SPEC ("fn spec", 1, 1, false, true, true, false,
 139              handle_fnspec_attribute, NULL),
 140   ATTR_SPEC (NULL, 0, 0, false, false, false, false, NULL, NULL),
 141 };
 142
 143 /* Table of D language attributes exposed by `gcc.attribute' UDAs.  */
 144 const attribute_spec d_langhook_attribute_table[] =
 145 {
 146   ATTR_SPEC ("noinline", 0, 0, true, false, false, false,
 147              d_handle_noinline_attribute, attr_noinline_exclusions),
 148   ATTR_SPEC ("forceinline", 0, 0, true, false, false, false,
 149              d_handle_forceinline_attribute, attr_inline_exclusions),
 150   ATTR_SPEC ("flatten", 0, 0, true, false, false, false,
 151              d_handle_flatten_attribute, NULL),
 152   ATTR_SPEC ("target", 1, -1, true, false, false, false,
 153              d_handle_target_attribute, NULL),
 154   ATTR_SPEC ("noclone", 0, 0, true, false, false, false,
 155              d_handle_noclone_attribute, NULL),
 156   ATTR_SPEC ("section", 1, 1, true, false, false, false,
 157              d_handle_section_attribute, NULL),
 158   ATTR_SPEC ("alias", 1, 1, true, false, false, false,
 159              d_handle_alias_attribute, NULL),
 160   ATTR_SPEC ("weak", 0, 0, true, false, false, false,
 161              d_handle_weak_attribute, NULL),
 162   ATTR_SPEC (NULL, 0, 0, false, false, false, false, NULL, NULL),
 163 };
 164
 165
 166 /* Insert the type attribute ATTRNAME with value VALUE into TYPE.
 167    Returns a new variant of the original type declaration.  */
 168
 169 tree
 170 insert_type_attribute (tree type, const char *attrname, tree value)
 171 {
 172   tree ident = get_identifier (attrname);
 173
 174   if (value)
 175     value = tree_cons (NULL_TREE, value, NULL_TREE);
 176
 177   tree attribs = merge_attributes (TYPE_ATTRIBUTES (type),
 178                                    tree_cons (ident, value, NULL_TREE));
 179
 180   return build_type_attribute_variant (type, attribs);
 181 }
 182
 183 /* Insert the decl attribute ATTRNAME with value VALUE into DECL.  */
 184
 185 tree
 186 insert_decl_attribute (tree decl, const char *attrname, tree value)
 187 {
 188   tree ident = get_identifier (attrname);
 189
 190   if (value)
 191     value = tree_cons (NULL_TREE, value, NULL_TREE);
 192
 193   tree attribs = merge_attributes (DECL_ATTRIBUTES (decl),
 194                                    tree_cons (ident, value, NULL_TREE));
 195
 196   return build_decl_attribute_variant (decl, attribs);
 197 }
 198
 199 /* Returns TRUE if NAME is an attribute recognized as being handled by
 200    the `gcc.attribute' module.  */
 201
 202 static bool
 203 uda_attribute_p (const char *name)
 204 {
 205   tree ident = get_identifier (name);
 206
 207   /* Search both our language, and target attribute tables.
 208      Common and format attributes are kept internal.  */
 209   for (const attribute_spec *p = d_langhook_attribute_table; p->name; p++)
 210     {
 211       if (get_identifier (p->name) == ident)
 212         return true;
 213     }
 214
 215   for (const attribute_spec *p = targetm.attribute_table; p->name; p++)
 216     {
 217       if (get_identifier (p->name) == ident)
 218         return true;
 219     }
 220
 221   return false;
 222 }
 223
 224 /* [attribute/uda]
 225
 226    User Defined Attributes (UDA) are compile time expressions that can be
 227    attached to a declaration.  These attributes can then be queried, extracted,
 228    and manipulated at compile-time.  There is no run-time component to them.
 229
 230    Expand and merge all UDAs found in the EATTRS list that are of type
 231    `gcc.attribute.Attribute'.  This symbol is internally recognized by the
 232    compiler and maps them to their equivalent GCC attribute.  */
 233
 234 tree
 235 build_attributes (Expressions *eattrs)
 236 {
 237   if (!eattrs)
 238     return NULL_TREE;
 239
 240   expandTuples (eattrs);
 241
 242   tree attribs = NULL_TREE;
 243
 244   for (size_t i = 0; i < eattrs->dim; i++)
 245     {
 246       Expression *attr = (*eattrs)[i];
 247       Dsymbol *sym = attr->type->toDsymbol (0);
 248
 249       if (!sym)
 250         continue;
 251
 252       /* Attribute symbol must come from the `gcc.attribute' module.  */
 253       Dsymbol *mod = (Dsymbol*) sym->getModule ();
 254       if (!(strcmp (mod->toChars (), "attribute") == 0
 255             && mod->parent != NULL
 256             && strcmp (mod->parent->toChars (), "gcc") == 0
 257             && !mod->parent->parent))
 258         continue;
 259
 260       /* Get the result of the attribute if it hasn't already been folded.  */
 261       if (attr->op == TOKcall)
 262         attr = attr->ctfeInterpret ();
 263
 264       /* Should now have a struct `Attribute("attrib", "value", ...)'
 265          initializer list.  */
 266       gcc_assert (attr->op == TOKstructliteral);
 267       Expressions *elems = ((StructLiteralExp*) attr)->elements;
 268       Expression *e0 = (*elems)[0];
 269
 270       if (e0->op != TOKstring)
 271         {
 272           error ("expected string attribute, not %qs", e0->toChars ());
 273           return error_mark_node;
 274         }
 275
 276       StringExp *se = (StringExp*) e0;
 277       gcc_assert (se->sz == 1);
 278
 279       /* Empty string attribute, just ignore it.  */
 280       if (se->len == 0)
 281         continue;
 282
 283       /* Check if the attribute is recognized and handled.
 284          Done here to report the diagnostic at the right location.  */
 285       const char *name = (const char *)(se->len ? se->string : "");
 286       if (!uda_attribute_p (name))
 287         {
 288           warning_at (make_location_t (e0->loc), OPT_Wattributes,
 289                       "unknown attribute %qs", name);
 290           return error_mark_node;
 291         }
 292
 293       /* Chain all attribute arguments together.  */
 294       tree args = NULL_TREE;
 295
 296       for (size_t j = 1; j < elems->dim; j++)
 297         {
 298           Expression *e = (*elems)[j];
 299           tree t;
 300           if (e->op == TOKstring && ((StringExp *) e)->sz == 1)
 301             {
 302               StringExp *s = (StringExp *) e;
 303               const char *string = (const char *)(s->len ? s->string : "");
 304               t = build_string (s->len, string);
 305             }
 306           else
 307             t = build_expr (e);
 308
 309           args = chainon (args, build_tree_list (0, t));
 310         }
 311
 312       tree list = build_tree_list (get_identifier (name), args);
 313       attribs = chainon (attribs, list);
 314     }
 315
 316   return attribs;
 317 }
 318
 319 /* Built-in attribute handlers.  */
 320
 321 /* Handle a "noreturn" attribute; arguments as in
 322    struct attribute_spec.handler.  */
 323
 324 static tree
 325 handle_noreturn_attribute (tree *node, tree ARG_UNUSED (name),
 326                            tree ARG_UNUSED (args), int ARG_UNUSED (flags),
 327                            bool * ARG_UNUSED (no_add_attrs))
 328 {
 329   tree type = TREE_TYPE (*node);
 330
 331   if (TREE_CODE (*node) == FUNCTION_DECL)
 332     TREE_THIS_VOLATILE (*node) = 1;
 333   else if (TREE_CODE (type) == POINTER_TYPE
 334            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 335     TREE_TYPE (*node)
 336       = build_pointer_type
 337         (build_type_variant (TREE_TYPE (type),
 338                              TYPE_READONLY (TREE_TYPE (type)), 1));
 339   else
 340     gcc_unreachable ();
 341
 342   return NULL_TREE;
 343 }
 344
 345 /* Handle a "leaf" attribute; arguments as in
 346    struct attribute_spec.handler.  */
 347
 348 static tree
 349 handle_leaf_attribute (tree *node, tree name,
 350                        tree ARG_UNUSED (args),
 351                        int ARG_UNUSED (flags), bool *no_add_attrs)
 352 {
 353   if (TREE_CODE (*node) != FUNCTION_DECL)
 354     {
 355       warning (OPT_Wattributes, "%qE attribute ignored", name);
 356       *no_add_attrs = true;
 357     }
 358   if (!TREE_PUBLIC (*node))
 359     {
 360       warning (OPT_Wattributes, "%qE attribute has no effect", name);
 361       *no_add_attrs = true;
 362     }
 363
 364   return NULL_TREE;
 365 }
 366
 367 /* Handle a "const" attribute; arguments as in
 368    struct attribute_spec.handler.  */
 369
 370 static tree
 371 handle_const_attribute (tree *node, tree ARG_UNUSED (name),
 372                         tree ARG_UNUSED (args), int ARG_UNUSED (flags),
 373                         bool * ARG_UNUSED (no_add_attrs))
 374 {
 375   tree type = TREE_TYPE (*node);
 376
 377   if (TREE_CODE (*node) == FUNCTION_DECL)
 378     TREE_READONLY (*node) = 1;
 379   else if (TREE_CODE (type) == POINTER_TYPE
 380            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 381     TREE_TYPE (*node)
 382       = build_pointer_type
 383         (build_type_variant (TREE_TYPE (type), 1,
 384                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
 385   else
 386     gcc_unreachable ();
 387
 388   return NULL_TREE;
 389 }
 390
 391 /* Handle a "malloc" attribute; arguments as in
 392    struct attribute_spec.handler.  */
 393
 394 tree
 395 handle_malloc_attribute (tree *node, tree ARG_UNUSED (name),
 396                          tree ARG_UNUSED (args), int ARG_UNUSED (flags),
 397                          bool * ARG_UNUSED (no_add_attrs))
 398 {
 399   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL
 400               && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))));
 401   DECL_IS_MALLOC (*node) = 1;
 402   return NULL_TREE;
 403 }
 404
 405 /* Handle a "pure" attribute; arguments as in
 406    struct attribute_spec.handler.  */
 407
 408 static tree
 409 handle_pure_attribute (tree *node, tree ARG_UNUSED (name),
 410                        tree ARG_UNUSED (args), int ARG_UNUSED (flags),
 411                        bool * ARG_UNUSED (no_add_attrs))
 412 {
 413   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
 414   DECL_PURE_P (*node) = 1;
 415   return NULL_TREE;
 416 }
 417
 418 /* Handle a "no vops" attribute; arguments as in
 419    struct attribute_spec.handler.  */
 420
 421 static tree
 422 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
 423                          tree ARG_UNUSED (args), int ARG_UNUSED (flags),
 424                          bool * ARG_UNUSED (no_add_attrs))
 425 {
 426   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
 427   DECL_IS_NOVOPS (*node) = 1;
 428   return NULL_TREE;
 429 }
 430
 431 /* Helper for nonnull attribute handling; fetch the operand number
 432    from the attribute argument list.  */
 433
 434 static bool
 435 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
 436 {
 437   /* Verify the arg number is a constant.  */
 438   if (!tree_fits_uhwi_p (arg_num_expr))
 439     return false;
 440
 441   *valp = TREE_INT_CST_LOW (arg_num_expr);
 442   return true;
 443 }
 444
 445 /* Handle the "nonnull" attribute.  */
 446
 447 static tree
 448 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
 449                           tree args, int ARG_UNUSED (flags),
 450                           bool * ARG_UNUSED (no_add_attrs))
 451 {
 452   tree type = *node;
 453
 454   /* If no arguments are specified, all pointer arguments should be
 455      non-null.  Verify a full prototype is given so that the arguments
 456      will have the correct types when we actually check them later.
 457      Avoid diagnosing type-generic built-ins since those have no
 458      prototype.  */
 459   if (!args)
 460     {
 461       gcc_assert (prototype_p (type)
 462                   || !TYPE_ATTRIBUTES (type)
 463                   || lookup_attribute ("type generic", TYPE_ATTRIBUTES (type)));
 464
 465       return NULL_TREE;
 466     }
 467
 468   /* Argument list specified.  Verify that each argument number references
 469      a pointer argument.  */
 470   for (; args; args = TREE_CHAIN (args))
 471     {
 472       tree argument;
 473       unsigned HOST_WIDE_INT arg_num = 0, ck_num;
 474
 475       if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
 476         gcc_unreachable ();
 477
 478       argument = TYPE_ARG_TYPES (type);
 479       if (argument)
 480         {
 481           for (ck_num = 1; ; ck_num++)
 482             {
 483               if (!argument || ck_num == arg_num)
 484                 break;
 485               argument = TREE_CHAIN (argument);
 486             }
 487
 488           gcc_assert (argument
 489                       && TREE_CODE (TREE_VALUE (argument)) == POINTER_TYPE);
 490         }
 491     }
 492
 493   return NULL_TREE;
 494 }
 495
 496 /* Handle a "nothrow" attribute; arguments as in
 497    struct attribute_spec.handler.  */
 498
 499 static tree
 500 handle_nothrow_attribute (tree *node, tree ARG_UNUSED (name),
 501                           tree ARG_UNUSED (args), int ARG_UNUSED (flags),
 502                           bool * ARG_UNUSED (no_add_attrs))
 503 {
 504   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
 505   TREE_NOTHROW (*node) = 1;
 506   return NULL_TREE;
 507 }
 508
 509 /* Handle a "type_generic" attribute.  */
 510
 511 static tree
 512 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
 513                                tree ARG_UNUSED (args), int ARG_UNUSED (flags),
 514                                bool * ARG_UNUSED (no_add_attrs))
 515 {
 516   /* Ensure we have a function type.  */
 517   gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
 518
 519   /* Ensure we have a variadic function.  */
 520   gcc_assert (!prototype_p (*node) || stdarg_p (*node));
 521
 522   return NULL_TREE;
 523 }
 524
 525 /* Handle a "transaction_pure" attribute.  */
 526
 527 static tree
 528 handle_transaction_pure_attribute (tree *node, tree ARG_UNUSED (name),
 529                                    tree ARG_UNUSED (args),
 530                                    int ARG_UNUSED (flags),
 531                                    bool * ARG_UNUSED (no_add_attrs))
 532 {
 533   /* Ensure we have a function type.  */
 534   gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
 535
 536   return NULL_TREE;
 537 }
 538
 539 /* Handle a "returns_twice" attribute.  */
 540
 541 static tree
 542 handle_returns_twice_attribute (tree *node, tree ARG_UNUSED (name),
 543                                 tree ARG_UNUSED (args),
 544                                 int ARG_UNUSED (flags),
 545                                 bool * ARG_UNUSED (no_add_attrs))
 546 {
 547   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
 548
 549   DECL_IS_RETURNS_TWICE (*node) = 1;
 550
 551   return NULL_TREE;
 552 }
 553
 554 /* Handle a "fn spec" attribute; arguments as in
 555    struct attribute_spec.handler.  */
 556
 557 tree
 558 handle_fnspec_attribute (tree *node ATTRIBUTE_UNUSED, tree ARG_UNUSED (name),
 559                          tree args, int ARG_UNUSED (flags),
 560                          bool *no_add_attrs ATTRIBUTE_UNUSED)
 561 {
 562   gcc_assert (args
 563               && TREE_CODE (TREE_VALUE (args)) == STRING_CST
 564               && !TREE_CHAIN (args));
 565   return NULL_TREE;
 566 }
 567
 568 /* Language specific attribute handlers.  */
 569
 570 /* Handle a "noinline" attribute.  */
 571
 572 static tree
 573 d_handle_noinline_attribute (tree *node, tree name,
 574                              tree ARG_UNUSED (args),
 575                              int ARG_UNUSED (flags), bool *no_add_attrs)
 576 {
 577   Type *t = TYPE_LANG_FRONTEND (TREE_TYPE (*node));
 578
 579   if (t->ty == Tfunction)
 580     DECL_UNINLINABLE (*node) = 1;
 581   else
 582     {
 583       warning (OPT_Wattributes, "%qE attribute ignored", name);
 584       *no_add_attrs = true;
 585     }
 586
 587   return NULL_TREE;
 588 }
 589
 590 /* Handle a "forceinline" attribute.  */
 591
 592 static tree
 593 d_handle_forceinline_attribute (tree *node, tree name,
 594                                 tree ARG_UNUSED (args),
 595                                 int ARG_UNUSED (flags),
 596                                 bool *no_add_attrs)
 597 {
 598   Type *t = TYPE_LANG_FRONTEND (TREE_TYPE (*node));
 599
 600   if (t->ty == Tfunction)
 601     {
 602       tree attributes = DECL_ATTRIBUTES (*node);
 603
 604       /* Push attribute always_inline.  */
 605       if (! lookup_attribute ("always_inline", attributes))
 606         DECL_ATTRIBUTES (*node) = tree_cons (get_identifier ("always_inline"),
 607                                              NULL_TREE, attributes);
 608
 609       DECL_DECLARED_INLINE_P (*node) = 1;
 610       DECL_NO_INLINE_WARNING_P (*node) = 1;
 611       DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
 612     }
 613   else
 614     {
 615       warning (OPT_Wattributes, "%qE attribute ignored", name);
 616       *no_add_attrs = true;
 617     }
 618
 619   return NULL_TREE;
 620 }
 621
 622 /* Handle a "flatten" attribute.  */
 623
 624 static tree
 625 d_handle_flatten_attribute (tree *node, tree name,
 626                             tree args ATTRIBUTE_UNUSED,
 627                             int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
 628 {
 629   Type *t = TYPE_LANG_FRONTEND (TREE_TYPE (*node));
 630
 631   if (t->ty != Tfunction)
 632     {
 633       warning (OPT_Wattributes, "%qE attribute ignored", name);
 634       *no_add_attrs = true;
 635     }
 636
 637   return NULL_TREE;
 638 }
 639
 640 /* Handle a "target" attribute.  */
 641
 642 static tree
 643 d_handle_target_attribute (tree *node, tree name, tree args, int flags,
 644                            bool *no_add_attrs)
 645 {
 646   Type *t = TYPE_LANG_FRONTEND (TREE_TYPE (*node));
 647
 648   /* Ensure we have a function type.  */
 649   if (t->ty != Tfunction)
 650     {
 651       warning (OPT_Wattributes, "%qE attribute ignored", name);
 652       *no_add_attrs = true;
 653     }
 654   else if (! targetm.target_option.valid_attribute_p (*node, name, args, flags))
 655     *no_add_attrs = true;
 656
 657   return NULL_TREE;
 658 }
 659
 660 /* Handle a "noclone" attribute.  */
 661
 662 static tree
 663 d_handle_noclone_attribute (tree *node, tree name,
 664                                 tree ARG_UNUSED (args),
 665                                 int ARG_UNUSED (flags),
 666                                 bool *no_add_attrs)
 667 {
 668   Type *t = TYPE_LANG_FRONTEND (TREE_TYPE (*node));
 669
 670   if (t->ty == Tfunction)
 671     {
 672       tree attributes = DECL_ATTRIBUTES (*node);
 673
 674       /* Push attribute noclone.  */
 675       if (! lookup_attribute ("noclone", attributes))
 676         DECL_ATTRIBUTES (*node) = tree_cons (get_identifier ("noclone"),
 677                                              NULL_TREE, attributes);
 678     }
 679   else
 680     {
 681       warning (OPT_Wattributes, "%qE attribute ignored", name);
 682       *no_add_attrs = true;
 683     }
 684
 685   return NULL_TREE;
 686 }
 687
 688 /* Handle a "section" attribute; arguments as in
 689    struct attribute_spec.handler.  */
 690
 691 static tree
 692 d_handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
 693                             int ARG_UNUSED (flags), bool *no_add_attrs)
 694 {
 695   tree decl = *node;
 696
 697   if (targetm_common.have_named_sections)
 698     {
 699       if (VAR_OR_FUNCTION_DECL_P (decl)
 700           && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
 701         {
 702           if (VAR_P (decl)
 703               && current_function_decl != NULL_TREE
 704               && !TREE_STATIC (decl))
 705             {
 706               error_at (DECL_SOURCE_LOCATION (decl),
 707                         "section attribute cannot be specified for "
 708                         "local variables");
 709               *no_add_attrs = true;
 710             }
 711
 712           /* The decl may have already been given a section attribute
 713              from a previous declaration.  Ensure they match.  */
 714           else if (DECL_SECTION_NAME (decl) != NULL
 715                    && strcmp (DECL_SECTION_NAME (decl),
 716                               TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
 717             {
 718               error ("section of %q+D conflicts with previous declaration",
 719                      *node);
 720               *no_add_attrs = true;
 721             }
 722           else if (VAR_P (decl)
 723                    && !targetm.have_tls && targetm.emutls.tmpl_section
 724                    && DECL_THREAD_LOCAL_P (decl))
 725             {
 726               error ("section of %q+D cannot be overridden", *node);
 727               *no_add_attrs = true;
 728             }
 729           else
 730             set_decl_section_name (decl,
 731                                    TREE_STRING_POINTER (TREE_VALUE (args)));
 732         }
 733       else
 734         {
 735           error ("section attribute not allowed for %q+D", *node);
 736           *no_add_attrs = true;
 737         }
 738     }
 739   else
 740     {
 741       error_at (DECL_SOURCE_LOCATION (*node),
 742                 "section attributes are not supported for this target");
 743       *no_add_attrs = true;
 744     }
 745
 746   return NULL_TREE;
 747 }
 748
 749 /* Handle an "alias" attribute; arguments as in
 750    struct attribute_spec.handler.  */
 751
 752 static tree
 753 d_handle_alias_attribute (tree *node, tree ARG_UNUSED (name),
 754                           tree args, int ARG_UNUSED (flags),
 755                           bool *no_add_attrs ATTRIBUTE_UNUSED)
 756 {
 757   tree decl = *node;
 758
 759   if (TREE_CODE (decl) != FUNCTION_DECL
 760       && TREE_CODE (decl) != VAR_DECL)
 761     {
 762       warning (OPT_Wattributes, "%qE attribute ignored", name);
 763       *no_add_attrs = true;
 764       return NULL_TREE;
 765     }
 766   else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
 767       || (TREE_CODE (decl) != FUNCTION_DECL
 768           && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
 769       /* A static variable declaration is always a tentative definition,
 770          but the alias is a non-tentative definition which overrides.  */
 771       || (TREE_CODE (decl) != FUNCTION_DECL
 772           && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
 773     {
 774       error ("%q+D defined both normally and as %qE attribute", decl, name);
 775       *no_add_attrs = true;
 776       return NULL_TREE;
 777     }
 778   else if (decl_function_context (decl))
 779     {
 780       error ("%q+D alias functions must be global", name);
 781       *no_add_attrs = true;
 782       return NULL_TREE;
 783     }
 784   else
 785     {
 786       tree id;
 787
 788       id = TREE_VALUE (args);
 789       if (TREE_CODE (id) != STRING_CST)
 790         {
 791           error ("attribute %qE argument not a string", name);
 792           *no_add_attrs = true;
 793           return NULL_TREE;
 794         }
 795       id = get_identifier (TREE_STRING_POINTER (id));
 796       /* This counts as a use of the object pointed to.  */
 797       TREE_USED (id) = 1;
 798
 799       if (TREE_CODE (decl) == FUNCTION_DECL)
 800         DECL_INITIAL (decl) = error_mark_node;
 801       else
 802         TREE_STATIC (decl) = 1;
 803
 804       return NULL_TREE;
 805     }
 806 }
 807
 808 /* Handle a "weak" attribute; arguments as in
 809    struct attribute_spec.handler.  */
 810
 811 static tree
 812 d_handle_weak_attribute (tree *node, tree name,
 813                          tree ARG_UNUSED (args),
 814                          int ARG_UNUSED (flags),
 815                          bool * ARG_UNUSED (no_add_attrs))
 816 {
 817   if (TREE_CODE (*node) == FUNCTION_DECL
 818       && DECL_DECLARED_INLINE_P (*node))
 819     {
 820       warning (OPT_Wattributes, "inline function %q+D declared weak", *node);
 821       *no_add_attrs = true;
 822     }
 823   else if (VAR_OR_FUNCTION_DECL_P (*node))
 824     {
 825       struct symtab_node *n = symtab_node::get (*node);
 826       if (n && n->refuse_visibility_changes)
 827         error ("%q+D declared weak after being used", *node);
 828       declare_weak (*node);
 829     }
 830   else
 831     warning (OPT_Wattributes, "%qE attribute ignored", name);
 832
 833   return NULL_TREE;
 834 }
 835