attribs.c revision 117395
1199482Srdivacky/* Functions dealing with attribute handling, used by most front ends. 2199482Srdivacky Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 3199482Srdivacky 2002 Free Software Foundation, Inc. 4199482Srdivacky 5199482SrdivackyThis file is part of GCC. 6199482Srdivacky 7199482SrdivackyGCC is free software; you can redistribute it and/or modify it under 8199482Srdivackythe terms of the GNU General Public License as published by the Free 9199482SrdivackySoftware Foundation; either version 2, or (at your option) any later 10199482Srdivackyversion. 11199482Srdivacky 12199482SrdivackyGCC is distributed in the hope that it will be useful, but WITHOUT ANY 13199482SrdivackyWARRANTY; without even the implied warranty of MERCHANTABILITY or 14199482SrdivackyFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15199482Srdivackyfor more details. 16199482Srdivacky 17199482SrdivackyYou should have received a copy of the GNU General Public License 18199482Srdivackyalong with GCC; see the file COPYING. If not, write to the Free 19212904SdimSoftware Foundation, 59 Temple Place - Suite 330, Boston, MA 20212904Sdim02111-1307, USA. */ 21239462Sdim 22212904Sdim#include "config.h" 23212904Sdim#include "system.h" 24239462Sdim#include "tree.h" 25199482Srdivacky#include "flags.h" 26199482Srdivacky#include "toplev.h" 27199482Srdivacky#include "output.h" 28249423Sdim#include "rtl.h" 29212904Sdim#include "ggc.h" 30199482Srdivacky#include "expr.h" 31199482Srdivacky#include "tm_p.h" 32212904Sdim#include "cpplib.h" 33239462Sdim#include "target.h" 34199482Srdivacky#include "langhooks.h" 35199482Srdivacky 36199482Srdivackystatic void init_attributes PARAMS ((void)); 37199482Srdivacky 38199482Srdivacky/* Table of the tables of attributes (common, language, format, machine) 39199482Srdivacky 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