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