attribs.c revision 117395
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 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to the Free 19Software Foundation, 59 Temple Place - Suite 330, Boston, MA 2002111-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 36static void init_attributes PARAMS ((void)); 37 38/* Table of the tables of attributes (common, language, format, machine) 39 searched. */ 40static const struct attribute_spec *attribute_tables[4]; 41 42static bool attributes_initialized = false; 43 44/* Default empty table of attributes. */ 45static 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 53static void 54init_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 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 141tree 142decl_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 317void 318split_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 394tree 395strip_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 412