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, 2003, 2004, 2005, 2007, 2008, 2009 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 3, 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 COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "tree.h"
  26 #include "flags.h"
  27 #include "toplev.h"
  28 #include "output.h"
  29 #include "rtl.h"
  30 #include "ggc.h"
  31 #include "tm_p.h"
  32 #include "cpplib.h"
  33 #include "target.h"
  34 #include "langhooks.h"
  35 #include "hashtab.h"
  36 #include "plugin.h"
  37
  38 static void init_attributes (void);
  39
  40 /* Table of the tables of attributes (common, language, format, machine)
  41    searched.  */
  42 static const struct attribute_spec *attribute_tables[4];
  43
  44 /* Hashtable mapping names (represented as substrings) to attribute specs. */
  45 static htab_t attribute_hash;
  46
  47 /* Substring representation.  */
  48
  49 struct substring
  50 {
  51   const char *str;
  52   int length;
  53 };
  54
  55 static bool attributes_initialized = false;
  56
  57 /* Default empty table of attributes.  */
  58
  59 static const struct attribute_spec empty_attribute_table[] =
  60 {
  61   { NULL, 0, 0, false, false, false, NULL }
  62 };
  63
  64 /* Return base name of the attribute.  Ie '__attr__' is turned into 'attr'.
  65    To avoid need for copying, we simply return length of the string.  */
  66
  67 static void
  68 extract_attribute_substring (struct substring *str)
  69 {
  70   if (str->length > 4 && str->str[0] == '_' && str->str[1] == '_'
  71       && str->str[str->length - 1] == '_' && str->str[str->length - 2] == '_')
  72     {
  73       str->length -= 4;
  74       str->str += 2;
  75     }
  76 }
  77
  78 /* Simple hash function to avoid need to scan whole string.  */
  79
  80 static inline hashval_t
  81 substring_hash (const char *str, int l)
  82 {
  83   return str[0] + str[l - 1] * 256 + l * 65536;
  84 }
  85
  86 /* Used for attribute_hash.  */
  87
  88 static hashval_t
  89 hash_attr (const void *p)
  90 {
  91   const struct attribute_spec *const spec = (const struct attribute_spec *) p;
  92   const int l = strlen (spec->name);
  93
  94   return substring_hash (spec->name, l);
  95 }
  96
  97 /* Used for attribute_hash.  */
  98
  99 static int
 100 eq_attr (const void *p, const void *q)
 101 {
 102   const struct attribute_spec *const spec = (const struct attribute_spec *) p;
 103   const struct substring *const str = (const struct substring *) q;
 104
 105   return (!strncmp (spec->name, str->str, str->length) && !spec->name[str->length]);
 106 }
 107
 108 /* Initialize attribute tables, and make some sanity checks
 109    if --enable-checking.  */
 110
 111 static void
 112 init_attributes (void)
 113 {
 114   size_t i;
 115   int k;
 116
 117   attribute_tables[0] = lang_hooks.common_attribute_table;
 118   attribute_tables[1] = lang_hooks.attribute_table;
 119   attribute_tables[2] = lang_hooks.format_attribute_table;
 120   attribute_tables[3] = targetm.attribute_table;
 121
 122   /* Translate NULL pointers to pointers to the empty table.  */
 123   for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 124     if (attribute_tables[i] == NULL)
 125       attribute_tables[i] = empty_attribute_table;
 126
 127 #ifdef ENABLE_CHECKING
 128   /* Make some sanity checks on the attribute tables.  */
 129   for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 130     {
 131       int j;
 132
 133       for (j = 0; attribute_tables[i][j].name != NULL; j++)
 134         {
 135           /* The name must not begin and end with __.  */
 136           const char *name = attribute_tables[i][j].name;
 137           int len = strlen (name);
 138
 139           gcc_assert (!(name[0] == '_' && name[1] == '_'
 140                         && name[len - 1] == '_' && name[len - 2] == '_'));
 141
 142           /* The minimum and maximum lengths must be consistent.  */
 143           gcc_assert (attribute_tables[i][j].min_length >= 0);
 144
 145           gcc_assert (attribute_tables[i][j].max_length == -1
 146                       || (attribute_tables[i][j].max_length
 147                           >= attribute_tables[i][j].min_length));
 148
 149           /* An attribute cannot require both a DECL and a TYPE.  */
 150           gcc_assert (!attribute_tables[i][j].decl_required
 151                       || !attribute_tables[i][j].type_required);
 152
 153           /* If an attribute requires a function type, in particular
 154              it requires a type.  */
 155           gcc_assert (!attribute_tables[i][j].function_type_required
 156                       || attribute_tables[i][j].type_required);
 157         }
 158     }
 159
 160   /* Check that each name occurs just once in each table.  */
 161   for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 162     {
 163       int j, k;
 164       for (j = 0; attribute_tables[i][j].name != NULL; j++)
 165         for (k = j + 1; attribute_tables[i][k].name != NULL; k++)
 166           gcc_assert (strcmp (attribute_tables[i][j].name,
 167                               attribute_tables[i][k].name));
 168     }
 169   /* Check that no name occurs in more than one table.  */
 170   for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 171     {
 172       size_t j, k, l;
 173
 174       for (j = i + 1; j < ARRAY_SIZE (attribute_tables); j++)
 175         for (k = 0; attribute_tables[i][k].name != NULL; k++)
 176           for (l = 0; attribute_tables[j][l].name != NULL; l++)
 177             gcc_assert (strcmp (attribute_tables[i][k].name,
 178                                 attribute_tables[j][l].name));
 179     }
 180 #endif
 181
 182   attribute_hash = htab_create (200, hash_attr, eq_attr, NULL);
 183   for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 184     for (k = 0; attribute_tables[i][k].name != NULL; k++)
 185       {
 186         register_attribute (&attribute_tables[i][k]);
 187       }
 188   invoke_plugin_callbacks (PLUGIN_ATTRIBUTES, NULL);
 189   attributes_initialized = true;
 190 }
 191
 192 /* Insert a single ATTR into the attribute table.  */
 193
 194 void
 195 register_attribute (const struct attribute_spec *attr)
 196 {
 197   struct substring str;
 198   void **slot;
 199
 200   str.str = attr->name;
 201   str.length = strlen (str.str);
 202   slot = htab_find_slot_with_hash (attribute_hash, &str,
 203                                    substring_hash (str.str, str.length),
 204                                    INSERT);
 205   gcc_assert (!*slot);
 206   *slot = (void *) CONST_CAST (struct attribute_spec *, attr);
 207 }
 208
 209 /* Return the spec for the attribute named NAME.  */
 210
 211 const struct attribute_spec *
 212 lookup_attribute_spec (tree name)
 213 {
 214   struct substring attr;
 215
 216   attr.str = IDENTIFIER_POINTER (name);
 217   attr.length = IDENTIFIER_LENGTH (name);
 218   extract_attribute_substring (&attr);
 219   return (const struct attribute_spec *)
 220     htab_find_with_hash (attribute_hash, &attr,
 221                          substring_hash (attr.str, attr.length));
 222 }
 223 \f
 224 /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
 225    which is either a DECL (including a TYPE_DECL) or a TYPE.  If a DECL,
 226    it should be modified in place; if a TYPE, a copy should be created
 227    unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS.  FLAGS gives further
 228    information, in the form of a bitwise OR of flags in enum attribute_flags
 229    from tree.h.  Depending on these flags, some attributes may be
 230    returned to be applied at a later stage (for example, to apply
 231    a decl attribute to the declaration rather than to its type).  */
 232
 233 tree
 234 decl_attributes (tree *node, tree attributes, int flags)
 235 {
 236   tree a;
 237   tree returned_attrs = NULL_TREE;
 238
 239   if (TREE_TYPE (*node) == error_mark_node)
 240     return NULL_TREE;
 241
 242   if (!attributes_initialized)
 243     init_attributes ();
 244
 245   /* If this is a function and the user used #pragma GCC optimize, add the
 246      options to the attribute((optimize(...))) list.  */
 247   if (TREE_CODE (*node) == FUNCTION_DECL && current_optimize_pragma)
 248     {
 249       tree cur_attr = lookup_attribute ("optimize", attributes);
 250       tree opts = copy_list (current_optimize_pragma);
 251
 252       if (! cur_attr)
 253         attributes
 254           = tree_cons (get_identifier ("optimize"), opts, attributes);
 255       else
 256         TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
 257     }
 258
 259   if (TREE_CODE (*node) == FUNCTION_DECL
 260       && optimization_current_node != optimization_default_node
 261       && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node))
 262     DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node) = optimization_current_node;
 263
 264   /* If this is a function and the user used #pragma GCC target, add the
 265      options to the attribute((target(...))) list.  */
 266   if (TREE_CODE (*node) == FUNCTION_DECL
 267       && current_target_pragma
 268       && targetm.target_option.valid_attribute_p (*node, NULL_TREE,
 269                                                   current_target_pragma, 0))
 270     {
 271       tree cur_attr = lookup_attribute ("target", attributes);
 272       tree opts = copy_list (current_target_pragma);
 273
 274       if (! cur_attr)
 275         attributes = tree_cons (get_identifier ("target"), opts, attributes);
 276       else
 277         TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
 278     }
 279
 280   targetm.insert_attributes (*node, &attributes);
 281
 282   for (a = attributes; a; a = TREE_CHAIN (a))
 283     {
 284       tree name = TREE_PURPOSE (a);
 285       tree args = TREE_VALUE (a);
 286       tree *anode = node;
 287       const struct attribute_spec *spec = lookup_attribute_spec (name);
 288       bool no_add_attrs = 0;
 289       int fn_ptr_quals = 0;
 290       tree fn_ptr_tmp = NULL_TREE;
 291
 292       if (spec == NULL)
 293         {
 294           warning (OPT_Wattributes, "%qE attribute directive ignored",
 295                    name);
 296           continue;
 297         }
 298       else if (list_length (args) < spec->min_length
 299                || (spec->max_length >= 0
 300                    && list_length (args) > spec->max_length))
 301         {
 302           error ("wrong number of arguments specified for %qE attribute",
 303                  name);
 304           continue;
 305         }
 306       gcc_assert (is_attribute_p (spec->name, name));
 307
 308       if (spec->decl_required && !DECL_P (*anode))
 309         {
 310           if (flags & ((int) ATTR_FLAG_DECL_NEXT
 311                        | (int) ATTR_FLAG_FUNCTION_NEXT
 312                        | (int) ATTR_FLAG_ARRAY_NEXT))
 313             {
 314               /* Pass on this attribute to be tried again.  */
 315               returned_attrs = tree_cons (name, args, returned_attrs);
 316               continue;
 317             }
 318           else
 319             {
 320               warning (OPT_Wattributes, "%qE attribute does not apply to types",
 321                        name);
 322               continue;
 323             }
 324         }
 325
 326       /* If we require a type, but were passed a decl, set up to make a
 327          new type and update the one in the decl.  ATTR_FLAG_TYPE_IN_PLACE
 328          would have applied if we'd been passed a type, but we cannot modify
 329          the decl's type in place here.  */
 330       if (spec->type_required && DECL_P (*anode))
 331         {
 332           anode = &TREE_TYPE (*anode);
 333           /* Allow ATTR_FLAG_TYPE_IN_PLACE for the type's naming decl.  */
 334           if (!(TREE_CODE (*anode) == TYPE_DECL
 335                 && *anode == TYPE_NAME (TYPE_MAIN_VARIANT
 336                                         (TREE_TYPE (*anode)))))
 337             flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
 338         }
 339
 340       if (spec->function_type_required && TREE_CODE (*anode) != FUNCTION_TYPE
 341           && TREE_CODE (*anode) != METHOD_TYPE)
 342         {
 343           if (TREE_CODE (*anode) == POINTER_TYPE
 344               && (TREE_CODE (TREE_TYPE (*anode)) == FUNCTION_TYPE
 345                   || TREE_CODE (TREE_TYPE (*anode)) == METHOD_TYPE))
 346             {
 347               /* OK, this is a bit convoluted.  We can't just make a copy
 348                  of the pointer type and modify its TREE_TYPE, because if
 349                  we change the attributes of the target type the pointer
 350                  type needs to have a different TYPE_MAIN_VARIANT.  So we
 351                  pull out the target type now, frob it as appropriate, and
 352                  rebuild the pointer type later.
 353
 354                  This would all be simpler if attributes were part of the
 355                  declarator, grumble grumble.  */
 356               fn_ptr_tmp = TREE_TYPE (*anode);
 357               fn_ptr_quals = TYPE_QUALS (*anode);
 358               anode = &fn_ptr_tmp;
 359               flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
 360             }
 361           else if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
 362             {
 363               /* Pass on this attribute to be tried again.  */
 364               returned_attrs = tree_cons (name, args, returned_attrs);
 365               continue;
 366             }
 367
 368           if (TREE_CODE (*anode) != FUNCTION_TYPE
 369               && TREE_CODE (*anode) != METHOD_TYPE)
 370             {
 371               warning (OPT_Wattributes,
 372                        "%qE attribute only applies to function types",
 373                        name);
 374               continue;
 375             }
 376         }
 377
 378       if (TYPE_P (*anode)
 379           && (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
 380           && TYPE_SIZE (*anode) != NULL_TREE)
 381         {
 382           warning (OPT_Wattributes, "type attributes ignored after type is already defined");
 383           continue;
 384         }
 385
 386       if (spec->handler != NULL)
 387         returned_attrs = chainon ((*spec->handler) (anode, name, args,
 388                                                     flags, &no_add_attrs),
 389                                   returned_attrs);
 390
 391       /* Layout the decl in case anything changed.  */
 392       if (spec->type_required && DECL_P (*node)
 393           && (TREE_CODE (*node) == VAR_DECL
 394               || TREE_CODE (*node) == PARM_DECL
 395               || TREE_CODE (*node) == RESULT_DECL))
 396         relayout_decl (*node);
 397
 398       if (!no_add_attrs)
 399         {
 400           tree old_attrs;
 401           tree a;
 402
 403           if (DECL_P (*anode))
 404             old_attrs = DECL_ATTRIBUTES (*anode);
 405           else
 406             old_attrs = TYPE_ATTRIBUTES (*anode);
 407
 408           for (a = lookup_attribute (spec->name, old_attrs);
 409                a != NULL_TREE;
 410                a = lookup_attribute (spec->name, TREE_CHAIN (a)))
 411             {
 412               if (simple_cst_equal (TREE_VALUE (a), args) == 1)
 413                 break;
 414             }
 415
 416           if (a == NULL_TREE)
 417             {
 418               /* This attribute isn't already in the list.  */
 419               if (DECL_P (*anode))
 420                 DECL_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
 421               else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
 422                 {
 423                   TYPE_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
 424                   /* If this is the main variant, also push the attributes
 425                      out to the other variants.  */
 426                   if (*anode == TYPE_MAIN_VARIANT (*anode))
 427                     {
 428                       tree variant;
 429                       for (variant = *anode; variant;
 430                            variant = TYPE_NEXT_VARIANT (variant))
 431                         {
 432                           if (TYPE_ATTRIBUTES (variant) == old_attrs)
 433                             TYPE_ATTRIBUTES (variant)
 434                               = TYPE_ATTRIBUTES (*anode);
 435                           else if (!lookup_attribute
 436                                    (spec->name, TYPE_ATTRIBUTES (variant)))
 437                             TYPE_ATTRIBUTES (variant) = tree_cons
 438                               (name, args, TYPE_ATTRIBUTES (variant));
 439                         }
 440                     }
 441                 }
 442               else
 443                 *anode = build_type_attribute_variant (*anode,
 444                                                        tree_cons (name, args,
 445                                                                   old_attrs));
 446             }
 447         }
 448
 449       if (fn_ptr_tmp)
 450         {
 451           /* Rebuild the function pointer type and put it in the
 452              appropriate place.  */
 453           fn_ptr_tmp = build_pointer_type (fn_ptr_tmp);
 454           if (fn_ptr_quals)
 455             fn_ptr_tmp = build_qualified_type (fn_ptr_tmp, fn_ptr_quals);
 456           if (DECL_P (*node))
 457             TREE_TYPE (*node) = fn_ptr_tmp;
 458           else
 459             {
 460               gcc_assert (TREE_CODE (*node) == POINTER_TYPE);
 461               *node = fn_ptr_tmp;
 462             }
 463         }
 464     }
 465
 466   return returned_attrs;
 467 }