gcc/attribs.c

   1 /* Functions dealing with attribute handling, used by most front ends.
   2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   3    2002 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "tree.h"
  25 #include "flags.h"
  26 #include "toplev.h"
  27 #include "output.h"
  28 #include "rtl.h"
  29 #include "ggc.h"
  30 #include "expr.h"
  31 #include "tm_p.h"
  32 #include "cpplib.h"
  33 #include "target.h"
  34 #include "langhooks.h"
  35
  36 static void init_attributes             PARAMS ((void));
  37
  38 /* Table of the tables of attributes (common, language, format, machine)
  39    searched.  */
  40 static const struct attribute_spec *attribute_tables[4];
  41
  42 static bool attributes_initialized = false;
  43
  44 /* Default empty table of attributes.  */
  45 static const struct attribute_spec empty_attribute_table[] =
  46 {
  47   { NULL, 0, 0, false, false, false, NULL }
  48 };
  49
  50 /* Initialize attribute tables, and make some sanity checks
  51    if --enable-checking.  */
  52
  53 static void
  54 init_attributes ()
  55 {
  56   size_t i;
  57
  58   attribute_tables[0] = lang_hooks.common_attribute_table;
  59   attribute_tables[1] = lang_hooks.attribute_table;
  60   attribute_tables[2] = lang_hooks.format_attribute_table;
  61   attribute_tables[3] = targetm.attribute_table;
  62
  63   /* Translate NULL pointers to pointers to the empty table.  */
  64   for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
  65     if (attribute_tables[i] == NULL)
  66       attribute_tables[i] = empty_attribute_table;
  67
  68 #ifdef ENABLE_CHECKING
  69   /* Make some sanity checks on the attribute tables.  */
  70   for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
  71     {
  72       int j;
  73
  74       for (j = 0; attribute_tables[i][j].name != NULL; j++)
  75         {
  76           /* The name must not begin and end with __.  */
  77           const char *name = attribute_tables[i][j].name;
  78           int len = strlen (name);
  79           if (name[0] == '_' && name[1] == '_'
  80               && name[len - 1] == '_' && name[len - 2] == '_')
  81             abort ();
  82           /* The minimum and maximum lengths must be consistent.  */
  83           if (attribute_tables[i][j].min_length < 0)
  84             abort ();
  85           if (attribute_tables[i][j].max_length != -1
  86               && (attribute_tables[i][j].max_length
  87                   < attribute_tables[i][j].min_length))
  88             abort ();
  89           /* An attribute cannot require both a DECL and a TYPE.  */
  90           if (attribute_tables[i][j].decl_required
  91               && attribute_tables[i][j].type_required)
  92             abort ();
  93           /* If an attribute requires a function type, in particular
  94              it requires a type.  */
  95           if (attribute_tables[i][j].function_type_required
  96               && !attribute_tables[i][j].type_required)
  97             abort ();
  98         }
  99     }
 100
 101   /* Check that each name occurs just once in each table.  */
 102   for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 103     {
 104       int j, k;
 105       for (j = 0; attribute_tables[i][j].name != NULL; j++)
 106         for (k = j + 1; attribute_tables[i][k].name != NULL; k++)
 107           if (!strcmp (attribute_tables[i][j].name,
 108                        attribute_tables[i][k].name))
 109             abort ();
 110     }
 111   /* Check that no name occurs in more than one table.  */
 112   for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 113     {
 114       size_t j, k, l;
 115
 116       for (j = i + 1; j < ARRAY_SIZE (attribute_tables); j++)
 117         for (k = 0; attribute_tables[i][k].name != NULL; k++)
 118           for (l = 0; attribute_tables[j][l].name != NULL; l++)
 119             if (!strcmp (attribute_tables[i][k].name,
 120                          attribute_tables[j][l].name))
 121               abort ();
 122     }
 123 #endif
 124
 125   attributes_initialized = true;
 126 }
 127 \f
 128 /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
 129    which is either a DECL (including a TYPE_DECL) or a TYPE.  If a DECL,
 130    it should be modified in place; if a TYPE, a copy should be created
 131    unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS.  FLAGS gives further
 132    information, in the form of a bitwise OR of flags in enum attribute_flags
 133    from tree.h.  Depending on these flags, some attributes may be
 134    returned to be applied at a later stage (for example, to apply
 135    a decl attribute to the declaration rather than to its type).  If
 136    ATTR_FLAG_BUILT_IN is not set and *NODE is a DECL, then also consider
 137    whether there might be some default attributes to apply to this DECL;
 138    if so, decl_attributes will be called recursively with those attributes
 139    and ATTR_FLAG_BUILT_IN set.  */
 140
 141 tree
 142 decl_attributes (node, attributes, flags)
 143      tree *node, attributes;
 144      int flags;
 145 {
 146   tree a;
 147   tree returned_attrs = NULL_TREE;
 148
 149   if (!attributes_initialized)
 150     init_attributes ();
 151
 152   (*targetm.insert_attributes) (*node, &attributes);
 153
 154   if (DECL_P (*node) && TREE_CODE (*node) == FUNCTION_DECL
 155       && !(flags & (int) ATTR_FLAG_BUILT_IN))
 156     (*lang_hooks.insert_default_attributes) (*node);
 157
 158   for (a = attributes; a; a = TREE_CHAIN (a))
 159     {
 160       tree name = TREE_PURPOSE (a);
 161       tree args = TREE_VALUE (a);
 162       tree *anode = node;
 163       const struct attribute_spec *spec = NULL;
 164       bool no_add_attrs = 0;
 165       size_t i;
 166
 167       for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 168         {
 169           int j;
 170
 171           for (j = 0; attribute_tables[i][j].name != NULL; j++)
 172             {
 173               if (is_attribute_p (attribute_tables[i][j].name, name))
 174                 {
 175                   spec = &attribute_tables[i][j];
 176                   break;
 177                 }
 178             }
 179           if (spec != NULL)
 180             break;
 181         }
 182
 183       if (spec == NULL)
 184         {
 185           warning ("`%s' attribute directive ignored",
 186                    IDENTIFIER_POINTER (name));
 187           continue;
 188         }
 189       else if (list_length (args) < spec->min_length
 190                || (spec->max_length >= 0
 191                    && list_length (args) > spec->max_length))
 192         {
 193           error ("wrong number of arguments specified for `%s' attribute",
 194                  IDENTIFIER_POINTER (name));
 195           continue;
 196         }
 197
 198       if (spec->decl_required && !DECL_P (*anode))
 199         {
 200           if (flags & ((int) ATTR_FLAG_DECL_NEXT
 201                        | (int) ATTR_FLAG_FUNCTION_NEXT
 202                        | (int) ATTR_FLAG_ARRAY_NEXT))
 203             {
 204               /* Pass on this attribute to be tried again.  */
 205               returned_attrs = tree_cons (name, args, returned_attrs);
 206               continue;
 207             }
 208           else
 209             {
 210               warning ("`%s' attribute does not apply to types",
 211                        IDENTIFIER_POINTER (name));
 212               continue;
 213             }
 214         }
 215
 216       /* If we require a type, but were passed a decl, set up to make a
 217          new type and update the one in the decl.  ATTR_FLAG_TYPE_IN_PLACE
 218          would have applied if we'd been passed a type, but we cannot modify
 219          the decl's type in place here.  */
 220       if (spec->type_required && DECL_P (*anode))
 221         {
 222           anode = &TREE_TYPE (*anode);
 223           flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
 224         }
 225
 226       if (spec->function_type_required && TREE_CODE (*anode) != FUNCTION_TYPE
 227           && TREE_CODE (*anode) != METHOD_TYPE)
 228         {
 229           if (TREE_CODE (*anode) == POINTER_TYPE
 230               && (TREE_CODE (TREE_TYPE (*anode)) == FUNCTION_TYPE
 231                   || TREE_CODE (TREE_TYPE (*anode)) == METHOD_TYPE))
 232             {
 233               if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
 234                 *anode = build_type_copy (*anode);
 235               anode = &TREE_TYPE (*anode);
 236             }
 237           else if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
 238             {
 239               /* Pass on this attribute to be tried again.  */
 240               returned_attrs = tree_cons (name, args, returned_attrs);
 241               continue;
 242             }
 243
 244           if (TREE_CODE (*anode) != FUNCTION_TYPE
 245               && TREE_CODE (*anode) != METHOD_TYPE)
 246             {
 247               warning ("`%s' attribute only applies to function types",
 248                        IDENTIFIER_POINTER (name));
 249               continue;
 250             }
 251         }
 252
 253       if (spec->handler != NULL)
 254         returned_attrs = chainon ((*spec->handler) (anode, name, args,
 255                                                     flags, &no_add_attrs),
 256                                   returned_attrs);
 257
 258       /* Layout the decl in case anything changed.  */
 259       if (spec->type_required && DECL_P (*node)
 260           && (TREE_CODE (*node) == VAR_DECL
 261               || TREE_CODE (*node) == PARM_DECL
 262               || TREE_CODE (*node) == RESULT_DECL))
 263         {
 264           /* Force a recalculation of mode and size.  */
 265           DECL_MODE (*node) = VOIDmode;
 266           DECL_SIZE (*node) = 0;
 267
 268           layout_decl (*node, 0);
 269         }
 270
 271       if (!no_add_attrs)
 272         {
 273           tree old_attrs;
 274           tree a;
 275
 276           if (DECL_P (*anode))
 277             old_attrs = DECL_ATTRIBUTES (*anode);
 278           else
 279             old_attrs = TYPE_ATTRIBUTES (*anode);
 280
 281           for (a = lookup_attribute (spec->name, old_attrs);
 282                a != NULL_TREE;
 283                a = lookup_attribute (spec->name, TREE_CHAIN (a)))
 284             {
 285               if (simple_cst_equal (TREE_VALUE (a), args) == 1)
 286                 break;
 287             }
 288
 289           if (a == NULL_TREE)
 290             {
 291               /* This attribute isn't already in the list.  */
 292               if (DECL_P (*anode))
 293                 DECL_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
 294               else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
 295                 TYPE_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
 296               else
 297                 *anode = build_type_attribute_variant (*anode,
 298                                                        tree_cons (name, args,
 299                                                                   old_attrs));
 300             }
 301         }
 302     }
 303
 304   return returned_attrs;
 305 }
 306
 307 /* Split SPECS_ATTRS, a list of declspecs and prefix attributes, into two
 308    lists.  SPECS_ATTRS may also be just a typespec (eg: RECORD_TYPE).
 309
 310    The head of the declspec list is stored in DECLSPECS.
 311    The head of the attribute list is stored in PREFIX_ATTRIBUTES.
 312
 313    Note that attributes in SPECS_ATTRS are stored in the TREE_PURPOSE of
 314    the list elements.  We drop the containing TREE_LIST nodes and link the
 315    resulting attributes together the way decl_attributes expects them.  */
 316
 317 void
 318 split_specs_attrs (specs_attrs, declspecs, prefix_attributes)
 319      tree specs_attrs;
 320      tree *declspecs, *prefix_attributes;
 321 {
 322   tree t, s, a, next, specs, attrs;
 323
 324   /* This can happen after an __extension__ in pedantic mode.  */
 325   if (specs_attrs != NULL_TREE
 326       && TREE_CODE (specs_attrs) == INTEGER_CST)
 327     {
 328       *declspecs = NULL_TREE;
 329       *prefix_attributes = NULL_TREE;
 330       return;
 331     }
 332
 333   /* This can happen in c++ (eg: decl: typespec initdecls ';').  */
 334   if (specs_attrs != NULL_TREE
 335       && TREE_CODE (specs_attrs) != TREE_LIST)
 336     {
 337       *declspecs = specs_attrs;
 338       *prefix_attributes = NULL_TREE;
 339       return;
 340     }
 341
 342   /* Remember to keep the lists in the same order, element-wise.  */
 343
 344   specs = s = NULL_TREE;
 345   attrs = a = NULL_TREE;
 346   for (t = specs_attrs; t; t = next)
 347     {
 348       next = TREE_CHAIN (t);
 349       /* Declspecs have a non-NULL TREE_VALUE.  */
 350       if (TREE_VALUE (t) != NULL_TREE)
 351         {
 352           if (specs == NULL_TREE)
 353             specs = s = t;
 354           else
 355             {
 356               TREE_CHAIN (s) = t;
 357               s = t;
 358             }
 359         }
 360       /* The TREE_PURPOSE may also be empty in the case of
 361          __attribute__(()).  */
 362       else if (TREE_PURPOSE (t) != NULL_TREE)
 363         {
 364           if (attrs == NULL_TREE)
 365             attrs = a = TREE_PURPOSE (t);
 366           else
 367             {
 368               TREE_CHAIN (a) = TREE_PURPOSE (t);
 369               a = TREE_PURPOSE (t);
 370             }
 371           /* More attrs can be linked here, move A to the end.  */
 372           while (TREE_CHAIN (a) != NULL_TREE)
 373             a = TREE_CHAIN (a);
 374         }
 375     }
 376
 377   /* Terminate the lists.  */
 378   if (s != NULL_TREE)
 379     TREE_CHAIN (s) = NULL_TREE;
 380   if (a != NULL_TREE)
 381     TREE_CHAIN (a) = NULL_TREE;
 382
 383   /* All done.  */
 384   *declspecs = specs;
 385   *prefix_attributes = attrs;
 386 }
 387
 388 /* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
 389    This function is used by the parser when a rule will accept attributes
 390    in a particular position, but we don't want to support that just yet.
 391
 392    A warning is issued for every ignored attribute.  */
 393
 394 tree
 395 strip_attrs (specs_attrs)
 396      tree specs_attrs;
 397 {
 398   tree specs, attrs;
 399
 400   split_specs_attrs (specs_attrs, &specs, &attrs);
 401
 402   while (attrs)
 403     {
 404       warning ("`%s' attribute ignored",
 405                IDENTIFIER_POINTER (TREE_PURPOSE (attrs)));
 406       attrs = TREE_CHAIN (attrs);
 407     }
 408
 409   return specs;
 410 }
 411