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