d-bi-attrs-34.h

   1 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
   2 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
   3 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
   4 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
   5 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
   6 static tree handle_always_inline_attribute (tree *, tree, tree, int,
   7                                             bool *);
   8 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
   9 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
  10 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
  11 static tree handle_transparent_union_attribute (tree *, tree, tree,
  12                                                 int, bool *);
  13 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
  14 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
  15 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
  16 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
  17 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
  18 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
  19 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
  20 static tree handle_visibility_attribute (tree *, tree, tree, int,
  21                                          bool *);
  22 static tree handle_tls_model_attribute (tree *, tree, tree, int,
  23                                         bool *);
  24 static tree handle_no_instrument_function_attribute (tree *, tree,
  25                                                      tree, int, bool *);
  26 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
  27 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
  28                                              bool *);
  29 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
  30 static tree handle_deprecated_attribute (tree *, tree, tree, int,
  31                                          bool *);
  32 static tree handle_vector_size_attribute (tree *, tree, tree, int,
  33                                           bool *);
  34 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
  35 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
  36 /*not in gdc//static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);*/
  37 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
  38                                                  bool *);
  39
  40 /*not in gdc//static void check_function_nonnull (tree, tree);*/
  41 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
  42 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
  43 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
  44
  45 /* extra for gdc copy: */
  46 static void check_function_arguments_recurse (void (*)
  47                                               (void *, tree,
  48                                                unsigned HOST_WIDE_INT),
  49                                               void *, tree,
  50                                               unsigned HOST_WIDE_INT);
  51 static tree
  52 handle_format_arg_attribute (tree *node ATTRIBUTE_UNUSED, tree name ATTRIBUTE_UNUSED,
  53                              tree args ATTRIBUTE_UNUSED, int flags ATTRIBUTE_UNUSED, bool *no_add_attrs ATTRIBUTE_UNUSED)
  54 {
  55     return NULL_TREE;
  56 }
  57 static tree
  58 handle_format_attribute (tree *node ATTRIBUTE_UNUSED, tree name ATTRIBUTE_UNUSED, tree args ATTRIBUTE_UNUSED,
  59                          int flags ATTRIBUTE_UNUSED, bool *no_add_attrs ATTRIBUTE_UNUSED)
  60 {
  61     return NULL_TREE;
  62 }
  63
  64 /* -- end extra */
  65
  66 /* Table of machine-independent attributes common to all C-like languages.  */
  67 const struct attribute_spec d_common_attribute_table[] =
  68 {
  69   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
  70   { "packed",                 0, 0, false, false, false,
  71                               handle_packed_attribute },
  72   { "nocommon",               0, 0, true,  false, false,
  73                               handle_nocommon_attribute },
  74   { "common",                 0, 0, true,  false, false,
  75                               handle_common_attribute },
  76   /* FIXME: logically, noreturn attributes should be listed as
  77      "false, true, true" and apply to function types.  But implementing this
  78      would require all the places in the compiler that use TREE_THIS_VOLATILE
  79      on a decl to identify non-returning functions to be located and fixed
  80      to check the function type instead.  */
  81   { "noreturn",               0, 0, true,  false, false,
  82                               handle_noreturn_attribute },
  83   { "volatile",               0, 0, true,  false, false,
  84                               handle_noreturn_attribute },
  85   { "noinline",               0, 0, true,  false, false,
  86                               handle_noinline_attribute },
  87   { "always_inline",          0, 0, true,  false, false,
  88                               handle_always_inline_attribute },
  89   { "used",                   0, 0, true,  false, false,
  90                               handle_used_attribute },
  91   { "unused",                 0, 0, false, false, false,
  92                               handle_unused_attribute },
  93   /* The same comments as for noreturn attributes apply to const ones.  */
  94   { "const",                  0, 0, true,  false, false,
  95                               handle_const_attribute },
  96   { "transparent_union",      0, 0, false, false, false,
  97                               handle_transparent_union_attribute },
  98   { "constructor",            0, 0, true,  false, false,
  99                               handle_constructor_attribute },
 100   { "destructor",             0, 0, true,  false, false,
 101                               handle_destructor_attribute },
 102   { "mode",                   1, 1, false,  true, false,
 103                               handle_mode_attribute },
 104   { "section",                1, 1, true,  false, false,
 105                               handle_section_attribute },
 106   { "aligned",                0, 1, false, false, false,
 107                               handle_aligned_attribute },
 108   { "weak",                   0, 0, true,  false, false,
 109                               handle_weak_attribute },
 110   { "alias",                  1, 1, true,  false, false,
 111                               handle_alias_attribute },
 112   { "no_instrument_function", 0, 0, true,  false, false,
 113                               handle_no_instrument_function_attribute },
 114   { "malloc",                 0, 0, true,  false, false,
 115                               handle_malloc_attribute },
 116   { "no_stack_limit",         0, 0, true,  false, false,
 117                               handle_no_limit_stack_attribute },
 118   { "pure",                   0, 0, true,  false, false,
 119                               handle_pure_attribute },
 120   { "deprecated",             0, 0, false, false, false,
 121                               handle_deprecated_attribute },
 122   { "vector_size",            1, 1, false, true, false,
 123                               handle_vector_size_attribute },
 124   { "visibility",             1, 1, true,  false, false,
 125                               handle_visibility_attribute },
 126   { "tls_model",              1, 1, true,  false, false,
 127                               handle_tls_model_attribute },
 128   { "nonnull",                0, -1, false, true, true,
 129                               handle_nonnull_attribute },
 130   { "nothrow",                0, 0, true,  false, false,
 131                               handle_nothrow_attribute },
 132   { "may_alias",              0, 0, false, true, false, NULL },
 133   /* not in gdc//  { "cleanup",               1, 1, true, false, false,
 134      handle_cleanup_attribute },*/
 135   { "warn_unused_result",     0, 0, false, true, true,
 136                               handle_warn_unused_result_attribute },
 137   { NULL,                     0, 0, false, false, false, NULL }
 138 };
 139
 140 /* Give the specifications for the format attributes, used by C and all
 141    descendants.  */
 142
 143 const struct attribute_spec d_common_format_attribute_table[] =
 144 {
 145   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
 146   { "format",                 3, 3, false, true,  true,
 147                               handle_format_attribute },
 148   { "format_arg",             1, 1, false, true,  true,
 149                               handle_format_arg_attribute },
 150   { NULL,                     0, 0, false, false, false, NULL }
 151 };
 152
 153 /* Attribute handlers common to C front ends.  */
 154
 155 /* Handle a "packed" attribute; arguments as in
 156    struct attribute_spec.handler.  */
 157
 158 static tree
 159 handle_packed_attribute (tree *node, tree name, tree args  ATTRIBUTE_UNUSED,
 160                          int flags, bool *no_add_attrs)
 161 {
 162   if (TYPE_P (*node))
 163     {
 164       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
 165         *node = build_type_copy (*node);
 166       TYPE_PACKED (*node) = 1;
 167       if (TYPE_MAIN_VARIANT (*node) == *node)
 168         {
 169           /* If it is the main variant, then pack the other variants
 170              too. This happens in,
 171
 172              struct Foo {
 173                struct Foo const *ptr; // creates a variant w/o packed flag
 174                } __ attribute__((packed)); // packs it now.
 175           */
 176           tree probe;
 177
 178           for (probe = *node; probe; probe = TYPE_NEXT_VARIANT (probe))
 179             TYPE_PACKED (probe) = 1;
 180         }
 181
 182     }
 183   else if (TREE_CODE (*node) == FIELD_DECL)
 184     DECL_PACKED (*node) = 1;
 185   /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
 186      used for DECL_REGISTER.  It wouldn't mean anything anyway.
 187      We can't set DECL_PACKED on the type of a TYPE_DECL, because
 188      that changes what the typedef is typing.  */
 189   else
 190     {
 191       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 192       *no_add_attrs = true;
 193     }
 194
 195   return NULL_TREE;
 196 }
 197
 198 /* Handle a "nocommon" attribute; arguments as in
 199    struct attribute_spec.handler.  */
 200
 201 static tree
 202 handle_nocommon_attribute (tree *node, tree name,
 203                            tree args ATTRIBUTE_UNUSED,
 204                            int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
 205 {
 206   if (TREE_CODE (*node) == VAR_DECL)
 207     DECL_COMMON (*node) = 0;
 208   else
 209     {
 210       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 211       *no_add_attrs = true;
 212     }
 213
 214   return NULL_TREE;
 215 }
 216
 217 /* Handle a "common" attribute; arguments as in
 218    struct attribute_spec.handler.  */
 219
 220 static tree
 221 handle_common_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
 222                          int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
 223 {
 224   if (TREE_CODE (*node) == VAR_DECL)
 225     DECL_COMMON (*node) = 1;
 226   else
 227     {
 228       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 229       *no_add_attrs = true;
 230     }
 231
 232   return NULL_TREE;
 233 }
 234
 235 /* Handle a "noreturn" attribute; arguments as in
 236    struct attribute_spec.handler.  */
 237
 238 static tree
 239 handle_noreturn_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
 240                            int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
 241 {
 242   tree type = TREE_TYPE (*node);
 243
 244   /* See FIXME comment in c_common_attribute_table.  */
 245   if (TREE_CODE (*node) == FUNCTION_DECL)
 246     TREE_THIS_VOLATILE (*node) = 1;
 247   else if (TREE_CODE (type) == POINTER_TYPE
 248            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 249     TREE_TYPE (*node)
 250       = build_pointer_type
 251         (build_type_variant (TREE_TYPE (type),
 252                              TREE_READONLY (TREE_TYPE (type)), 1));
 253   else
 254     {
 255       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 256       *no_add_attrs = true;
 257     }
 258
 259   return NULL_TREE;
 260 }
 261
 262 /* Handle a "noinline" attribute; arguments as in
 263    struct attribute_spec.handler.  */
 264
 265 static tree
 266 handle_noinline_attribute (tree *node, tree name,
 267                            tree args ATTRIBUTE_UNUSED,
 268                            int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
 269 {
 270   if (TREE_CODE (*node) == FUNCTION_DECL)
 271     DECL_UNINLINABLE (*node) = 1;
 272   else
 273     {
 274       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 275       *no_add_attrs = true;
 276     }
 277
 278   return NULL_TREE;
 279 }
 280
 281 /* Handle a "always_inline" attribute; arguments as in
 282    struct attribute_spec.handler.  */
 283
 284 static tree
 285 handle_always_inline_attribute (tree *node, tree name,
 286                                 tree args ATTRIBUTE_UNUSED,
 287                                 int flags ATTRIBUTE_UNUSED,
 288                                 bool *no_add_attrs)
 289 {
 290   if (TREE_CODE (*node) == FUNCTION_DECL)
 291     {
 292       /* Do nothing else, just set the attribute.  We'll get at
 293          it later with lookup_attribute.  */
 294     }
 295   else
 296     {
 297       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 298       *no_add_attrs = true;
 299     }
 300
 301   return NULL_TREE;
 302 }
 303
 304 /* Handle a "used" attribute; arguments as in
 305    struct attribute_spec.handler.  */
 306
 307 static tree
 308 handle_used_attribute (tree *pnode, tree name, tree args ATTRIBUTE_UNUSED,
 309                        int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
 310 {
 311   tree node = *pnode;
 312
 313   if (TREE_CODE (node) == FUNCTION_DECL
 314       || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
 315     {
 316       TREE_USED (node) = 1;
 317     }
 318   else
 319     {
 320       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 321       *no_add_attrs = true;
 322     }
 323
 324   return NULL_TREE;
 325 }
 326
 327 /* Handle a "unused" attribute; arguments as in
 328    struct attribute_spec.handler.  */
 329
 330 static tree
 331 handle_unused_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
 332                          int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
 333 {
 334   if (DECL_P (*node))
 335     {
 336       tree decl = *node;
 337
 338       if (TREE_CODE (decl) == PARM_DECL
 339           || TREE_CODE (decl) == VAR_DECL
 340           || TREE_CODE (decl) == FUNCTION_DECL
 341           || TREE_CODE (decl) == LABEL_DECL
 342           || TREE_CODE (decl) == TYPE_DECL)
 343         TREE_USED (decl) = 1;
 344       else
 345         {
 346           warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 347           *no_add_attrs = true;
 348         }
 349     }
 350   else
 351     {
 352       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
 353         *node = build_type_copy (*node);
 354       TREE_USED (*node) = 1;
 355     }
 356
 357   return NULL_TREE;
 358 }
 359
 360 /* Handle a "const" attribute; arguments as in
 361    struct attribute_spec.handler.  */
 362
 363 static tree
 364 handle_const_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
 365                         int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
 366 {
 367   tree type = TREE_TYPE (*node);
 368
 369   /* See FIXME comment on noreturn in c_common_attribute_table.  */
 370   if (TREE_CODE (*node) == FUNCTION_DECL)
 371     TREE_READONLY (*node) = 1;
 372   else if (TREE_CODE (type) == POINTER_TYPE
 373            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 374     TREE_TYPE (*node)
 375       = build_pointer_type
 376         (build_type_variant (TREE_TYPE (type), 1,
 377                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
 378   else
 379     {
 380       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 381       *no_add_attrs = true;
 382     }
 383
 384   return NULL_TREE;
 385 }
 386
 387 /* Handle a "transparent_union" attribute; arguments as in
 388    struct attribute_spec.handler.  */
 389
 390 static tree
 391 handle_transparent_union_attribute (tree *node, tree name,
 392                                     tree args ATTRIBUTE_UNUSED, int flags,
 393                                     bool *no_add_attrs)
 394 {
 395   tree decl = NULL_TREE;
 396   tree *type = NULL;
 397   int is_type = 0;
 398
 399   if (DECL_P (*node))
 400     {
 401       decl = *node;
 402       type = &TREE_TYPE (decl);
 403       is_type = TREE_CODE (*node) == TYPE_DECL;
 404     }
 405   else if (TYPE_P (*node))
 406     type = node, is_type = 1;
 407
 408   if (is_type
 409       && TREE_CODE (*type) == UNION_TYPE
 410       && (decl == 0
 411           || (TYPE_FIELDS (*type) != 0
 412               && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
 413     {
 414       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
 415         *type = build_type_copy (*type);
 416       TYPE_TRANSPARENT_UNION (*type) = 1;
 417     }
 418   else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
 419            && TREE_CODE (*type) == UNION_TYPE
 420            && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
 421     DECL_TRANSPARENT_UNION (decl) = 1;
 422   else
 423     {
 424       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 425       *no_add_attrs = true;
 426     }
 427
 428   return NULL_TREE;
 429 }
 430
 431 /* Handle a "constructor" attribute; arguments as in
 432    struct attribute_spec.handler.  */
 433
 434 static tree
 435 handle_constructor_attribute (tree *node, tree name,
 436                               tree args ATTRIBUTE_UNUSED,
 437                               int flags ATTRIBUTE_UNUSED,
 438                               bool *no_add_attrs)
 439 {
 440   tree decl = *node;
 441   tree type = TREE_TYPE (decl);
 442
 443   if (TREE_CODE (decl) == FUNCTION_DECL
 444       && TREE_CODE (type) == FUNCTION_TYPE
 445       && decl_function_context (decl) == 0)
 446     {
 447       DECL_STATIC_CONSTRUCTOR (decl) = 1;
 448       TREE_USED (decl) = 1;
 449     }
 450   else
 451     {
 452       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 453       *no_add_attrs = true;
 454     }
 455
 456   return NULL_TREE;
 457 }
 458
 459 /* Handle a "destructor" attribute; arguments as in
 460    struct attribute_spec.handler.  */
 461
 462 static tree
 463 handle_destructor_attribute (tree *node, tree name,
 464                              tree args ATTRIBUTE_UNUSED,
 465                              int flags ATTRIBUTE_UNUSED,
 466                              bool *no_add_attrs)
 467 {
 468   tree decl = *node;
 469   tree type = TREE_TYPE (decl);
 470
 471   if (TREE_CODE (decl) == FUNCTION_DECL
 472       && TREE_CODE (type) == FUNCTION_TYPE
 473       && decl_function_context (decl) == 0)
 474     {
 475       DECL_STATIC_DESTRUCTOR (decl) = 1;
 476       TREE_USED (decl) = 1;
 477     }
 478   else
 479     {
 480       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 481       *no_add_attrs = true;
 482     }
 483
 484   return NULL_TREE;
 485 }
 486
 487 /* Handle a "mode" attribute; arguments as in
 488    struct attribute_spec.handler.  */
 489
 490 static tree
 491 handle_mode_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
 492                        int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
 493 {
 494   tree type = *node;
 495
 496   *no_add_attrs = true;
 497
 498   if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
 499     warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 500   else
 501     {
 502       int j;
 503       const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
 504       int len = strlen (p);
 505       enum machine_mode mode = VOIDmode;
 506       tree typefm;
 507       tree ptr_type;
 508
 509       if (len > 4 && p[0] == '_' && p[1] == '_'
 510           && p[len - 1] == '_' && p[len - 2] == '_')
 511         {
 512           char *newp = alloca (len - 1);
 513
 514           strcpy (newp, &p[2]);
 515           newp[len - 4] = '\0';
 516           p = newp;
 517         }
 518
 519       /* Change this type to have a type with the specified mode.
 520          First check for the special modes.  */
 521       if (! strcmp (p, "byte"))
 522         mode = byte_mode;
 523       else if (!strcmp (p, "word"))
 524         mode = word_mode;
 525       else if (! strcmp (p, "pointer"))
 526         mode = ptr_mode;
 527       else
 528         for (j = 0; j < NUM_MACHINE_MODES; j++)
 529           if (!strcmp (p, GET_MODE_NAME (j)))
 530             {
 531               mode = (enum machine_mode) j;
 532               break;
 533             }
 534
 535       if (mode == VOIDmode)
 536         error ("unknown machine mode `%s'", p);
 537       else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
 538                      (mode, TREE_UNSIGNED (type))))
 539         error ("no data type for mode `%s'", p);
 540       else if ((TREE_CODE (type) == POINTER_TYPE
 541                 || TREE_CODE (type) == REFERENCE_TYPE)
 542                && !(*targetm.valid_pointer_mode) (mode))
 543         error ("invalid pointer mode `%s'", p);
 544       else
 545         {
 546           /* If this is a vector, make sure we either have hardware
 547              support, or we can emulate it.  */
 548           if (VECTOR_MODE_P (mode) && !vector_mode_valid_p (mode))
 549             {
 550               error ("unable to emulate '%s'", GET_MODE_NAME (mode));
 551               return NULL_TREE;
 552             }
 553
 554           if (TREE_CODE (type) == POINTER_TYPE)
 555             {
 556               ptr_type = build_pointer_type_for_mode (TREE_TYPE (type),
 557                                                       mode);
 558               *node = ptr_type;
 559             }
 560           else if (TREE_CODE (type) == REFERENCE_TYPE)
 561             {
 562               ptr_type = build_reference_type_for_mode (TREE_TYPE (type),
 563                                                         mode);
 564               *node = ptr_type;
 565             }
 566           else if (VECTOR_MODE_P (mode)
 567                    ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
 568                    : TREE_CODE (type) != TREE_CODE (typefm))
 569
 570             {
 571               error ("mode `%s' applied to inappropriate type", p);
 572               return NULL_TREE;
 573             }
 574           else
 575             *node = typefm;
 576
 577           /* No need to layout the type here.  The caller should do this.  */
 578         }
 579     }
 580
 581   return NULL_TREE;
 582 }
 583
 584 /* Handle a "section" attribute; arguments as in
 585    struct attribute_spec.handler.  */
 586
 587 static tree
 588 handle_section_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
 589                           int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
 590 {
 591   tree decl = *node;
 592
 593   if (targetm.have_named_sections)
 594     {
 595       if ((TREE_CODE (decl) == FUNCTION_DECL
 596            || TREE_CODE (decl) == VAR_DECL)
 597           && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
 598         {
 599           if (TREE_CODE (decl) == VAR_DECL
 600               && current_function_decl != NULL_TREE
 601               && ! (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
 602             {
 603               error ("%Jsection attribute cannot be specified for "
 604                      "local variables", decl);
 605               *no_add_attrs = true;
 606             }
 607
 608           /* The decl may have already been given a section attribute
 609              from a previous declaration.  Ensure they match.  */
 610           else if (DECL_SECTION_NAME (decl) != NULL_TREE
 611                    && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
 612                               TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
 613             {
 614               error ("%Jsection of '%D' conflicts with previous declaration",
 615                      *node, *node);
 616               *no_add_attrs = true;
 617             }
 618           else
 619             DECL_SECTION_NAME (decl) = TREE_VALUE (args);
 620         }
 621       else
 622         {
 623           error ("%Jsection attribute not allowed for '%D'", *node, *node);
 624           *no_add_attrs = true;
 625         }
 626     }
 627   else
 628     {
 629       error ("%Jsection attributes are not supported for this target", *node);
 630       *no_add_attrs = true;
 631     }
 632
 633   return NULL_TREE;
 634 }
 635
 636 /* Handle a "aligned" attribute; arguments as in
 637    struct attribute_spec.handler.  */
 638
 639 static tree
 640 handle_aligned_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
 641                           int flags, bool *no_add_attrs)
 642 {
 643   tree decl = NULL_TREE;
 644   tree *type = NULL;
 645   int is_type = 0;
 646   tree align_expr = (args ? TREE_VALUE (args)
 647                      : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
 648   int i;
 649
 650   if (DECL_P (*node))
 651     {
 652       decl = *node;
 653       type = &TREE_TYPE (decl);
 654       is_type = TREE_CODE (*node) == TYPE_DECL;
 655     }
 656   else if (TYPE_P (*node))
 657     type = node, is_type = 1;
 658
 659   /* Strip any NOPs of any kind.  */
 660   while (TREE_CODE (align_expr) == NOP_EXPR
 661          || TREE_CODE (align_expr) == CONVERT_EXPR
 662          || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
 663     align_expr = TREE_OPERAND (align_expr, 0);
 664
 665   if (TREE_CODE (align_expr) != INTEGER_CST)
 666     {
 667       error ("requested alignment is not a constant");
 668       *no_add_attrs = true;
 669     }
 670   else if ((i = tree_log2 (align_expr)) == -1)
 671     {
 672       error ("requested alignment is not a power of 2");
 673       *no_add_attrs = true;
 674     }
 675   else if (i > HOST_BITS_PER_INT - 2)
 676     {
 677       error ("requested alignment is too large");
 678       *no_add_attrs = true;
 679     }
 680   else if (is_type)
 681     {
 682       /* If we have a TYPE_DECL, then copy the type, so that we
 683          don't accidentally modify a builtin type.  See pushdecl.  */
 684       if (decl && TREE_TYPE (decl) != error_mark_node
 685           && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
 686         {
 687           tree tt = TREE_TYPE (decl);
 688           *type = build_type_copy (*type);
 689           DECL_ORIGINAL_TYPE (decl) = tt;
 690           TYPE_NAME (*type) = decl;
 691           TREE_USED (*type) = TREE_USED (decl);
 692           TREE_TYPE (decl) = *type;
 693         }
 694       else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
 695         *type = build_type_copy (*type);
 696
 697       TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
 698       TYPE_USER_ALIGN (*type) = 1;
 699     }
 700   else if (TREE_CODE (decl) != VAR_DECL
 701            && TREE_CODE (decl) != FIELD_DECL)
 702     {
 703       error ("%Jalignment may not be specified for '%D'", decl, decl);
 704       *no_add_attrs = true;
 705     }
 706   else
 707     {
 708       DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
 709       DECL_USER_ALIGN (decl) = 1;
 710     }
 711
 712   return NULL_TREE;
 713 }
 714
 715 /* Handle a "weak" attribute; arguments as in
 716    struct attribute_spec.handler.  */
 717
 718 static tree
 719 handle_weak_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
 720                        tree args ATTRIBUTE_UNUSED,
 721                        int flags ATTRIBUTE_UNUSED,
 722                        bool *no_add_attrs ATTRIBUTE_UNUSED)
 723 {
 724   declare_weak (*node);
 725
 726   return NULL_TREE;
 727 }
 728
 729 /* Handle an "alias" attribute; arguments as in
 730    struct attribute_spec.handler.  */
 731
 732 static tree
 733 handle_alias_attribute (tree *node, tree name, tree args,
 734                         int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
 735 {
 736   tree decl = *node;
 737
 738   if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
 739       || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
 740     {
 741       error ("%J'%D' defined both normally and as an alias", decl, decl);
 742       *no_add_attrs = true;
 743     }
 744   else if (decl_function_context (decl) == 0)
 745     {
 746       tree id;
 747
 748       id = TREE_VALUE (args);
 749       if (TREE_CODE (id) != STRING_CST)
 750         {
 751           error ("alias arg not a string");
 752           *no_add_attrs = true;
 753           return NULL_TREE;
 754         }
 755       id = get_identifier (TREE_STRING_POINTER (id));
 756       /* This counts as a use of the object pointed to.  */
 757       TREE_USED (id) = 1;
 758
 759       if (TREE_CODE (decl) == FUNCTION_DECL)
 760         DECL_INITIAL (decl) = error_mark_node;
 761       else
 762         DECL_EXTERNAL (decl) = 0;
 763     }
 764   else
 765     {
 766       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 767       *no_add_attrs = true;
 768     }
 769
 770   return NULL_TREE;
 771 }
 772
 773 /* Handle an "visibility" attribute; arguments as in
 774    struct attribute_spec.handler.  */
 775
 776 static tree
 777 handle_visibility_attribute (tree *node, tree name, tree args,
 778                              int flags ATTRIBUTE_UNUSED,
 779                              bool *no_add_attrs)
 780 {
 781   tree decl = *node;
 782   tree id = TREE_VALUE (args);
 783
 784   *no_add_attrs = true;
 785
 786   if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
 787     {
 788       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 789       return NULL_TREE;
 790     }
 791
 792   if (TREE_CODE (id) != STRING_CST)
 793     {
 794       error ("visibility arg not a string");
 795       return NULL_TREE;
 796     }
 797
 798   if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
 799     DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
 800   else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
 801     DECL_VISIBILITY (decl) = VISIBILITY_INTERNAL;
 802   else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
 803     DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
 804   else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
 805     DECL_VISIBILITY (decl) = VISIBILITY_PROTECTED;
 806   else
 807     error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
 808
 809   return NULL_TREE;
 810 }
 811
 812 /* Handle an "tls_model" attribute; arguments as in
 813    struct attribute_spec.handler.  */
 814
 815 static tree
 816 handle_tls_model_attribute (tree *node, tree name, tree args,
 817                             int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
 818 {
 819   tree decl = *node;
 820
 821   if (! DECL_THREAD_LOCAL (decl))
 822     {
 823       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 824       *no_add_attrs = true;
 825     }
 826   else
 827     {
 828       tree id;
 829
 830       id = TREE_VALUE (args);
 831       if (TREE_CODE (id) != STRING_CST)
 832         {
 833           error ("tls_model arg not a string");
 834           *no_add_attrs = true;
 835           return NULL_TREE;
 836         }
 837       if (strcmp (TREE_STRING_POINTER (id), "local-exec")
 838           && strcmp (TREE_STRING_POINTER (id), "initial-exec")
 839           && strcmp (TREE_STRING_POINTER (id), "local-dynamic")
 840           && strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
 841         {
 842           error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
 843           *no_add_attrs = true;
 844           return NULL_TREE;
 845         }
 846     }
 847
 848   return NULL_TREE;
 849 }
 850
 851 /* Handle a "no_instrument_function" attribute; arguments as in
 852    struct attribute_spec.handler.  */
 853
 854 static tree
 855 handle_no_instrument_function_attribute (tree *node, tree name,
 856                                          tree args ATTRIBUTE_UNUSED,
 857                                          int flags ATTRIBUTE_UNUSED,
 858                                          bool *no_add_attrs)
 859 {
 860   tree decl = *node;
 861
 862   if (TREE_CODE (decl) != FUNCTION_DECL)
 863     {
 864       error ("%J'%E' attribute applies only to functions", decl, name);
 865       *no_add_attrs = true;
 866     }
 867   else if (DECL_INITIAL (decl))
 868     {
 869       error ("%Jcan't set '%E' attribute after definition", decl, name);
 870       *no_add_attrs = true;
 871     }
 872   else
 873     DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
 874
 875   return NULL_TREE;
 876 }
 877
 878 /* Handle a "malloc" attribute; arguments as in
 879    struct attribute_spec.handler.  */
 880
 881 static tree
 882 handle_malloc_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
 883                          int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
 884 {
 885   if (TREE_CODE (*node) == FUNCTION_DECL)
 886     DECL_IS_MALLOC (*node) = 1;
 887   /* ??? TODO: Support types.  */
 888   else
 889     {
 890       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 891       *no_add_attrs = true;
 892     }
 893
 894   return NULL_TREE;
 895 }
 896
 897 /* Handle a "no_limit_stack" attribute; arguments as in
 898    struct attribute_spec.handler.  */
 899
 900 static tree
 901 handle_no_limit_stack_attribute (tree *node, tree name,
 902                                  tree args ATTRIBUTE_UNUSED,
 903                                  int flags ATTRIBUTE_UNUSED,
 904                                  bool *no_add_attrs)
 905 {
 906   tree decl = *node;
 907
 908   if (TREE_CODE (decl) != FUNCTION_DECL)
 909     {
 910       error ("%J'%E' attribute applies only to functions", decl, name);
 911       *no_add_attrs = true;
 912     }
 913   else if (DECL_INITIAL (decl))
 914     {
 915       error ("%Jcan't set '%E' attribute after definition", decl, name);
 916       *no_add_attrs = true;
 917     }
 918   else
 919     DECL_NO_LIMIT_STACK (decl) = 1;
 920
 921   return NULL_TREE;
 922 }
 923
 924 /* Handle a "pure" attribute; arguments as in
 925    struct attribute_spec.handler.  */
 926
 927 static tree
 928 handle_pure_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
 929                        int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
 930 {
 931   if (TREE_CODE (*node) == FUNCTION_DECL)
 932     DECL_IS_PURE (*node) = 1;
 933   /* ??? TODO: Support types.  */
 934   else
 935     {
 936       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 937       *no_add_attrs = true;
 938     }
 939
 940   return NULL_TREE;
 941 }
 942
 943 /* Handle a "deprecated" attribute; arguments as in
 944    struct attribute_spec.handler.  */
 945
 946 static tree
 947 handle_deprecated_attribute (tree *node, tree name,
 948                              tree args ATTRIBUTE_UNUSED, int flags,
 949                              bool *no_add_attrs)
 950 {
 951   tree type = NULL_TREE;
 952   int warn = 0;
 953   const char *what = NULL;
 954
 955   if (DECL_P (*node))
 956     {
 957       tree decl = *node;
 958       type = TREE_TYPE (decl);
 959
 960       if (TREE_CODE (decl) == TYPE_DECL
 961           || TREE_CODE (decl) == PARM_DECL
 962           || TREE_CODE (decl) == VAR_DECL
 963           || TREE_CODE (decl) == FUNCTION_DECL
 964           || TREE_CODE (decl) == FIELD_DECL)
 965         TREE_DEPRECATED (decl) = 1;
 966       else
 967         warn = 1;
 968     }
 969   else if (TYPE_P (*node))
 970     {
 971       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
 972         *node = build_type_copy (*node);
 973       TREE_DEPRECATED (*node) = 1;
 974       type = *node;
 975     }
 976   else
 977     warn = 1;
 978
 979   if (warn)
 980     {
 981       *no_add_attrs = true;
 982       if (type && TYPE_NAME (type))
 983         {
 984           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
 985             what = IDENTIFIER_POINTER (TYPE_NAME (*node));
 986           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
 987                    && DECL_NAME (TYPE_NAME (type)))
 988             what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
 989         }
 990       if (what)
 991         warning ("`%s' attribute ignored for `%s'",
 992                   IDENTIFIER_POINTER (name), what);
 993       else
 994         warning ("`%s' attribute ignored",
 995                       IDENTIFIER_POINTER (name));
 996     }
 997
 998   return NULL_TREE;
 999 }
1000
1001 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
1002    to prevent us from duplicating type nodes unnecessarily.
1003    The normal mechanism to prevent duplicates is to use type_hash_canon, but
1004    since we want to distinguish types that are essentially identical (except
1005    for their debug representation), we use a local list here.  */
1006 static GTY(()) tree vector_type_node_list = 0;
1007
1008 /* Handle a "vector_size" attribute; arguments as in
1009    struct attribute_spec.handler.  */
1010
1011 static tree
1012 handle_vector_size_attribute (tree *node, tree name, tree args,
1013                               int flags ATTRIBUTE_UNUSED,
1014                               bool *no_add_attrs)
1015 {
1016   unsigned HOST_WIDE_INT vecsize, nunits;
1017   enum machine_mode mode, orig_mode, new_mode;
1018   tree type = *node, new_type = NULL_TREE;
1019   tree type_list_node;
1020
1021   *no_add_attrs = true;
1022
1023   if (! host_integerp (TREE_VALUE (args), 1))
1024     {
1025       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
1026       return NULL_TREE;
1027     }
1028
1029   /* Get the vector size (in bytes).  */
1030   vecsize = tree_low_cst (TREE_VALUE (args), 1);
1031
1032   /* We need to provide for vector pointers, vector arrays, and
1033      functions returning vectors.  For example:
1034
1035        __attribute__((vector_size(16))) short *foo;
1036
1037      In this case, the mode is SI, but the type being modified is
1038      HI, so we need to look further.  */
1039
1040   while (POINTER_TYPE_P (type)
1041          || TREE_CODE (type) == FUNCTION_TYPE
1042          || TREE_CODE (type) == METHOD_TYPE
1043          || TREE_CODE (type) == ARRAY_TYPE)
1044     type = TREE_TYPE (type);
1045
1046   /* Get the mode of the type being modified.  */
1047   orig_mode = TYPE_MODE (type);
1048
1049   if (TREE_CODE (type) == RECORD_TYPE
1050       || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
1051           && GET_MODE_CLASS (orig_mode) != MODE_INT)
1052       || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
1053     {
1054       error ("invalid vector type for attribute `%s'",
1055              IDENTIFIER_POINTER (name));
1056       return NULL_TREE;
1057     }
1058
1059   /* Calculate how many units fit in the vector.  */
1060   nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
1061
1062   /* Find a suitably sized vector.  */
1063   new_mode = VOIDmode;
1064   for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
1065                                         ? MODE_VECTOR_INT
1066                                         : MODE_VECTOR_FLOAT);
1067        mode != VOIDmode;
1068        mode = GET_MODE_WIDER_MODE (mode))
1069     if (vecsize == GET_MODE_SIZE (mode)
1070         && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
1071       {
1072         new_mode = mode;
1073         break;
1074       }
1075
1076     if (new_mode == VOIDmode)
1077     {
1078       error ("no vector mode with the size and type specified could be found");
1079       return NULL_TREE;
1080     }
1081
1082   for (type_list_node = vector_type_node_list; type_list_node;
1083        type_list_node = TREE_CHAIN (type_list_node))
1084     {
1085       tree other_type = TREE_VALUE (type_list_node);
1086       tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
1087       tree fields = TYPE_FIELDS (record);
1088       tree field_type = TREE_TYPE (fields);
1089       tree array_type = TREE_TYPE (field_type);
1090       if (TREE_CODE (fields) != FIELD_DECL
1091           || TREE_CODE (field_type) != ARRAY_TYPE)
1092         abort ();
1093
1094       if (TYPE_MODE (other_type) == mode && type == array_type)
1095         {
1096           new_type = other_type;
1097           break;
1098         }
1099     }
1100
1101   if (new_type == NULL_TREE)
1102     {
1103       tree index, array, rt, list_node;
1104
1105       new_type = (*lang_hooks.types.type_for_mode) (new_mode,
1106                                                     TREE_UNSIGNED (type));
1107
1108       if (!new_type)
1109         {
1110           error ("no vector mode with the size and type specified could be found");
1111           return NULL_TREE;
1112         }
1113
1114       new_type = build_type_copy (new_type);
1115
1116       /* If this is a vector, make sure we either have hardware
1117          support, or we can emulate it.  */
1118       if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
1119            || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
1120           && !vector_mode_valid_p (mode))
1121         {
1122           error ("unable to emulate '%s'", GET_MODE_NAME (mode));
1123           return NULL_TREE;
1124         }
1125
1126       /* Set the debug information here, because this is the only
1127          place where we know the underlying type for a vector made
1128          with vector_size.  For debugging purposes we pretend a vector
1129          is an array within a structure.  */
1130       index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
1131       array = build_array_type (type, build_index_type (index));
1132       rt = make_node (RECORD_TYPE);
1133
1134       TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
1135       DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
1136       layout_type (rt);
1137       TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
1138
1139       list_node = build_tree_list (NULL, new_type);
1140       TREE_CHAIN (list_node) = vector_type_node_list;
1141       vector_type_node_list = list_node;
1142     }
1143
1144   /* Build back pointers if needed.  */
1145   *node = reconstruct_complex_type (*node, new_type);
1146
1147   return NULL_TREE;
1148 }
1149
1150 /* Handle the "nonnull" attribute.  */
1151 static tree
1152 handle_nonnull_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
1153                           tree args, int flags ATTRIBUTE_UNUSED,
1154                           bool *no_add_attrs)
1155 {
1156   tree type = *node;
1157   unsigned HOST_WIDE_INT attr_arg_num;
1158
1159   /* If no arguments are specified, all pointer arguments should be
1160      non-null.  Verify a full prototype is given so that the arguments
1161      will have the correct types when we actually check them later.  */
1162   if (! args)
1163     {
1164       if (! TYPE_ARG_TYPES (type))
1165         {
1166           error ("nonnull attribute without arguments on a non-prototype");
1167           *no_add_attrs = true;
1168         }
1169       return NULL_TREE;
1170     }
1171
1172   /* Argument list specified.  Verify that each argument number references
1173      a pointer argument.  */
1174   for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
1175     {
1176       tree argument;
1177       unsigned HOST_WIDE_INT arg_num, ck_num;
1178
1179       if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
1180         {
1181           error ("nonnull argument has invalid operand number (arg %lu)",
1182                  (unsigned long) attr_arg_num);
1183           *no_add_attrs = true;
1184           return NULL_TREE;
1185         }
1186
1187       argument = TYPE_ARG_TYPES (type);
1188       if (argument)
1189         {
1190           for (ck_num = 1; ; ck_num++)
1191             {
1192               if (! argument || ck_num == arg_num)
1193                 break;
1194               argument = TREE_CHAIN (argument);
1195             }
1196
1197           if (! argument
1198               || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
1199             {
1200               error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
1201                      (unsigned long) attr_arg_num, (unsigned long) arg_num);
1202               *no_add_attrs = true;
1203               return NULL_TREE;
1204             }
1205
1206           if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
1207             {
1208               error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
1209                    (unsigned long) attr_arg_num, (unsigned long) arg_num);
1210               *no_add_attrs = true;
1211               return NULL_TREE;
1212             }
1213         }
1214     }
1215
1216   return NULL_TREE;
1217 }
1218
1219 #if 0
1220 /* not in gdc */
1221 /* Check the argument list of a function call for null in argument slots
1222    that are marked as requiring a non-null pointer argument.  */
1223
1224 static void
1225 check_function_nonnull (tree attrs, tree params)
1226 {
1227   tree a, args, param;
1228   int param_num;
1229
1230   for (a = attrs; a; a = TREE_CHAIN (a))
1231     {
1232       if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
1233         {
1234           args = TREE_VALUE (a);
1235
1236           /* Walk the argument list.  If we encounter an argument number we
1237              should check for non-null, do it.  If the attribute has no args,
1238              then every pointer argument is checked (in which case the check
1239              for pointer type is done in check_nonnull_arg).  */
1240           for (param = params, param_num = 1; ;
1241                param_num++, param = TREE_CHAIN (param))
1242             {
1243               if (! param)
1244         break;
1245               if (! args || nonnull_check_p (args, param_num))
1246         check_function_arguments_recurse (check_nonnull_arg, NULL,
1247                                           TREE_VALUE (param),
1248                                           param_num);
1249             }
1250         }
1251     }
1252 }
1253 #endif
1254
1255 /* Helper for check_function_nonnull; given a list of operands which
1256    must be non-null in ARGS, determine if operand PARAM_NUM should be
1257    checked.  */
1258
1259 static bool
1260 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
1261 {
1262   unsigned HOST_WIDE_INT arg_num;
1263
1264   for (; args; args = TREE_CHAIN (args))
1265     {
1266       if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
1267         abort ();
1268
1269       if (arg_num == param_num)
1270         return true;
1271     }
1272   return false;
1273 }
1274
1275 /* Check that the function argument PARAM (which is operand number
1276    PARAM_NUM) is non-null.  This is called by check_function_nonnull
1277    via check_function_arguments_recurse.  */
1278
1279 static void
1280 check_nonnull_arg (void *ctx ATTRIBUTE_UNUSED, tree param,
1281                    unsigned HOST_WIDE_INT param_num)
1282 {
1283   /* Just skip checking the argument if it's not a pointer.  This can
1284      happen if the "nonnull" attribute was given without an operand
1285      list (which means to check every pointer argument).  */
1286
1287   if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
1288     return;
1289
1290   if (integer_zerop (param))
1291     warning ("null argument where non-null required (arg %lu)",
1292              (unsigned long) param_num);
1293 }
1294
1295 /* Helper for nonnull attribute handling; fetch the operand number
1296    from the attribute argument list.  */
1297
1298 static bool
1299 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
1300 {
1301   /* Strip any conversions from the arg number and verify they
1302      are constants.  */
1303   while (TREE_CODE (arg_num_expr) == NOP_EXPR
1304          || TREE_CODE (arg_num_expr) == CONVERT_EXPR
1305          || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
1306     arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
1307
1308   if (TREE_CODE (arg_num_expr) != INTEGER_CST
1309       || TREE_INT_CST_HIGH (arg_num_expr) != 0)
1310     return false;
1311
1312   *valp = TREE_INT_CST_LOW (arg_num_expr);
1313   return true;
1314 }
1315
1316 /* Handle a "nothrow" attribute; arguments as in
1317    struct attribute_spec.handler.  */
1318
1319 static tree
1320 handle_nothrow_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
1321                           int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
1322 {
1323   if (TREE_CODE (*node) == FUNCTION_DECL)
1324     TREE_NOTHROW (*node) = 1;
1325   /* ??? TODO: Support types.  */
1326   else
1327     {
1328       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
1329       *no_add_attrs = true;
1330     }
1331
1332   return NULL_TREE;
1333 }
1334
1335 #if 0
1336 /* not in gdc */
1337 /* Handle a "cleanup" attribute; arguments as in
1338    struct attribute_spec.handler.  */
1339
1340 static tree
1341 handle_cleanup_attribute (tree *node, tree name, tree args,
1342                           int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
1343 {
1344   tree decl = *node;
1345   tree cleanup_id, cleanup_decl;
1346
1347   /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
1348      for global destructors in C++.  This requires infrastructure that
1349      we don't have generically at the moment.  It's also not a feature
1350      we'd be missing too much, since we do have attribute constructor.  */
1351   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
1352     {
1353       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
1354       *no_add_attrs = true;
1355       return NULL_TREE;
1356     }
1357
1358   /* Verify that the argument is a function in scope.  */
1359   /* ??? We could support pointers to functions here as well, if
1360      that was considered desirable.  */
1361   cleanup_id = TREE_VALUE (args);
1362   if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
1363     {
1364       error ("cleanup arg not an identifier");
1365       *no_add_attrs = true;
1366       return NULL_TREE;
1367     }
1368   cleanup_decl = lookup_name (cleanup_id);
1369   if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
1370     {
1371       error ("cleanup arg not a function");
1372       *no_add_attrs = true;
1373       return NULL_TREE;
1374     }
1375
1376   /* That the function has proper type is checked with the
1377      eventual call to build_function_call.  */
1378
1379   return NULL_TREE;
1380 }
1381 #endif
1382
1383 /* Handle a "warn_unused_result" attribute.  No special handling.  */
1384
1385 static tree
1386 handle_warn_unused_result_attribute (tree *node, tree name,
1387                                tree args ATTRIBUTE_UNUSED,
1388                                int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
1389 {
1390   /* Ignore the attribute for functions not returning any value.  */
1391   if (VOID_TYPE_P (TREE_TYPE (*node)))
1392     {
1393       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
1394       *no_add_attrs = true;
1395     }
1396
1397   return NULL_TREE;
1398 }
1399
1400 #if 0
1401 /* not in gdc */
1402 /* Check for valid arguments being passed to a function.  */
1403 static void
1404 check_function_arguments (tree attrs, tree params)
1405 {
1406   /* Check for null being passed in a pointer argument that must be
1407      non-null.  We also need to do this if format checking is enabled.  */
1408
1409   if (warn_nonnull)
1410     check_function_nonnull (attrs, params);
1411
1412   /* Check for errors in format strings.  */
1413
1414   if (warn_format)
1415     check_function_format (NULL, attrs, params);
1416 }
1417 #endif
1418
1419 /* Generic argument checking recursion routine.  PARAM is the argument to
1420    be checked.  PARAM_NUM is the number of the argument.  CALLBACK is invoked
1421    once the argument is resolved.  CTX is context for the callback.  */
1422 void
1423 check_function_arguments_recurse (void (*callback)
1424                                   (void *, tree, unsigned HOST_WIDE_INT),
1425                                   void *ctx, tree param,
1426                                   unsigned HOST_WIDE_INT param_num)
1427 {
1428   if (TREE_CODE (param) == NOP_EXPR)
1429     {
1430       /* Strip coercion.  */
1431       check_function_arguments_recurse (callback, ctx,
1432                                         TREE_OPERAND (param, 0), param_num);
1433       return;
1434     }
1435
1436   if (TREE_CODE (param) == CALL_EXPR)
1437     {
1438       tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
1439       tree attrs;
1440       bool found_format_arg = false;
1441
1442       /* See if this is a call to a known internationalization function
1443          that modifies a format arg.  Such a function may have multiple
1444          format_arg attributes (for example, ngettext).  */
1445
1446       for (attrs = TYPE_ATTRIBUTES (type);
1447            attrs;
1448            attrs = TREE_CHAIN (attrs))
1449         if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
1450           {
1451             tree inner_args;
1452             tree format_num_expr;
1453             int format_num;
1454             int i;
1455
1456             /* Extract the argument number, which was previously checked
1457                to be valid.  */
1458             format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
1459             while (TREE_CODE (format_num_expr) == NOP_EXPR
1460                    || TREE_CODE (format_num_expr) == CONVERT_EXPR
1461                    || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
1462               format_num_expr = TREE_OPERAND (format_num_expr, 0);
1463
1464             if (TREE_CODE (format_num_expr) != INTEGER_CST
1465                 || TREE_INT_CST_HIGH (format_num_expr) != 0)
1466               abort ();
1467
1468             format_num = TREE_INT_CST_LOW (format_num_expr);
1469
1470             for (inner_args = TREE_OPERAND (param, 1), i = 1;
1471                  inner_args != 0;
1472                  inner_args = TREE_CHAIN (inner_args), i++)
1473               if (i == format_num)
1474                 {
1475                   check_function_arguments_recurse (callback, ctx,
1476                                                     TREE_VALUE (inner_args),
1477                                                     param_num);
1478                   found_format_arg = true;
1479                   break;
1480                 }
1481           }
1482
1483       /* If we found a format_arg attribute and did a recursive check,
1484          we are done with checking this argument.  Otherwise, we continue
1485          and this will be considered a non-literal.  */
1486       if (found_format_arg)
1487         return;
1488     }
1489
1490   if (TREE_CODE (param) == COND_EXPR)
1491     {
1492       /* Check both halves of the conditional expression.  */
1493       check_function_arguments_recurse (callback, ctx,
1494                                         TREE_OPERAND (param, 1), param_num);
1495       check_function_arguments_recurse (callback, ctx,
1496                                         TREE_OPERAND (param, 2), param_num);
1497       return;
1498     }
1499
1500   (*callback) (ctx, param, param_num);
1501 }