1 /* Declarations and definitions dealing with attribute handling. 2 Copyright (C) 2013-2022 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #ifndef GCC_ATTRIBS_H 21 #define GCC_ATTRIBS_H 22 23 extern const struct attribute_spec *lookup_attribute_spec (const_tree); 24 extern void free_attr_data (); 25 extern void init_attributes (void); 26 27 /* Process the attributes listed in ATTRIBUTES and install them in *NODE, 28 which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL, 29 it should be modified in place; if a TYPE, a copy should be created 30 unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further 31 information, in the form of a bitwise OR of flags in enum attribute_flags 32 from tree.h. Depending on these flags, some attributes may be 33 returned to be applied at a later stage (for example, to apply 34 a decl attribute to the declaration rather than to its type). */ 35 extern tree decl_attributes (tree *, tree, int, tree = NULL_TREE); 36 37 extern bool cxx11_attribute_p (const_tree); 38 extern tree get_attribute_name (const_tree); 39 extern tree get_attribute_namespace (const_tree); 40 extern void apply_tm_attr (tree, tree); 41 extern tree make_attribute (const char *, const char *, tree); 42 extern bool attribute_ignored_p (tree); 43 extern bool attribute_ignored_p (const attribute_spec *const); 44 45 extern struct scoped_attributes* register_scoped_attributes (const struct attribute_spec *, 46 const char *, 47 bool = false); 48 49 extern char *sorted_attr_string (tree); 50 extern bool common_function_versions (tree, tree); 51 extern tree make_dispatcher_decl (const tree); 52 extern bool is_function_default_version (const tree); 53 extern void handle_ignored_attributes_option (vec<char *> *); 54 55 /* Return a type like TTYPE except that its TYPE_ATTRIBUTES 56 is ATTRIBUTE. 57 58 Such modified types already made are recorded so that duplicates 59 are not made. */ 60 61 extern tree build_type_attribute_variant (tree, tree); 62 extern tree build_decl_attribute_variant (tree, tree); 63 extern tree build_type_attribute_qual_variant (tree, tree, int); 64 65 extern bool simple_cst_list_equal (const_tree, const_tree); 66 extern bool attribute_value_equal (const_tree, const_tree); 67 68 /* Return 0 if the attributes for two types are incompatible, 1 if they 69 are compatible, and 2 if they are nearly compatible (which causes a 70 warning to be generated). */ 71 extern int comp_type_attributes (const_tree, const_tree); 72 73 extern tree affects_type_identity_attributes (tree, bool = true); 74 extern tree restrict_type_identity_attributes_to (tree, tree); 75 76 /* Default versions of target-overridable functions. */ 77 extern tree merge_decl_attributes (tree, tree); 78 extern tree merge_type_attributes (tree, tree); 79 80 /* Remove any instances of attribute ATTR_NAME in LIST and return the 81 modified list. */ 82 83 extern tree remove_attribute (const char *, tree); 84 85 /* Given two attributes lists, return a list of their union. */ 86 87 extern tree merge_attributes (tree, tree); 88 89 /* Duplicate all attributes with name NAME in ATTR list to *ATTRS if 90 they are missing there. */ 91 92 extern void duplicate_one_attribute (tree *, tree, const char *); 93 94 /* Duplicate all attributes from user DECL to the corresponding 95 builtin that should be propagated. */ 96 97 extern void copy_attributes_to_builtin (tree); 98 99 /* Given two Windows decl attributes lists, possibly including 100 dllimport, return a list of their union . */ 101 extern tree merge_dllimport_decl_attributes (tree, tree); 102 103 /* Handle a "dllimport" or "dllexport" attribute. */ 104 extern tree handle_dll_attribute (tree *, tree, tree, int, bool *); 105 106 extern int attribute_list_equal (const_tree, const_tree); 107 extern int attribute_list_contained (const_tree, const_tree); 108 109 /* The backbone of lookup_attribute(). ATTR_LEN is the string length 110 of ATTR_NAME, and LIST is not NULL_TREE. 111 112 The function is called from lookup_attribute in order to optimize 113 for size. */ 114 extern tree private_lookup_attribute (const char *attr_name, size_t attr_len, 115 tree list); 116 117 extern unsigned decls_mismatched_attributes (tree, tree, tree, 118 const char* const[], 119 pretty_printer*); 120 121 extern void maybe_diag_alias_attributes (tree, tree); 122 123 /* For a given string S of length L, strip leading and trailing '_' characters 124 so that we have a canonical form of attribute names. NB: This function may 125 change S and L. */ 126 127 template <typename T> 128 inline bool 129 canonicalize_attr_name (const char *&s, T &l) 130 { 131 if (l > 4 && s[0] == '_' && s[1] == '_' && s[l - 1] == '_' && s[l - 2] == '_') 132 { 133 s += 2; 134 l -= 4; 135 return true; 136 } 137 return false; 138 } 139 140 /* For a given IDENTIFIER_NODE, strip leading and trailing '_' characters 141 so that we have a canonical form of attribute names. */ 142 143 static inline tree 144 canonicalize_attr_name (tree attr_name) 145 { 146 size_t l = IDENTIFIER_LENGTH (attr_name); 147 const char *s = IDENTIFIER_POINTER (attr_name); 148 149 if (canonicalize_attr_name (s, l)) 150 return get_identifier_with_length (s, l); 151 152 return attr_name; 153 } 154 155 /* Compare attribute identifiers ATTR1 and ATTR2 with length ATTR1_LEN and 156 ATTR2_LEN. */ 157 158 static inline bool 159 cmp_attribs (const char *attr1, size_t attr1_len, 160 const char *attr2, size_t attr2_len) 161 { 162 return attr1_len == attr2_len && strncmp (attr1, attr2, attr1_len) == 0; 163 } 164 165 /* Compare attribute identifiers ATTR1 and ATTR2. */ 166 167 static inline bool 168 cmp_attribs (const char *attr1, const char *attr2) 169 { 170 return cmp_attribs (attr1, strlen (attr1), attr2, strlen (attr2)); 171 } 172 173 /* Given an identifier node IDENT and a string ATTR_NAME, return true 174 if the identifier node is a valid attribute name for the string. */ 175 176 static inline bool 177 is_attribute_p (const char *attr_name, const_tree ident) 178 { 179 return cmp_attribs (attr_name, strlen (attr_name), 180 IDENTIFIER_POINTER (ident), IDENTIFIER_LENGTH (ident)); 181 } 182 183 /* Given an attribute name ATTR_NAME and a list of attributes LIST, 184 return a pointer to the attribute's list element if the attribute 185 is part of the list, or NULL_TREE if not found. If the attribute 186 appears more than once, this only returns the first occurrence; the 187 TREE_CHAIN of the return value should be passed back in if further 188 occurrences are wanted. ATTR_NAME must be in the form 'text' (not 189 '__text__'). */ 190 191 static inline tree 192 lookup_attribute (const char *attr_name, tree list) 193 { 194 if (CHECKING_P && attr_name[0] != '_') 195 { 196 size_t attr_len = strlen (attr_name); 197 gcc_checking_assert (!canonicalize_attr_name (attr_name, attr_len)); 198 } 199 /* In most cases, list is NULL_TREE. */ 200 if (list == NULL_TREE) 201 return NULL_TREE; 202 else 203 { 204 size_t attr_len = strlen (attr_name); 205 /* Do the strlen() before calling the out-of-line implementation. 206 In most cases attr_name is a string constant, and the compiler 207 will optimize the strlen() away. */ 208 return private_lookup_attribute (attr_name, attr_len, list); 209 } 210 } 211 212 /* Given an attribute name ATTR_NAME and a list of attributes LIST, 213 return a pointer to the attribute's list first element if the attribute 214 starts with ATTR_NAME. ATTR_NAME must be in the form 'text' (not 215 '__text__'). */ 216 217 static inline tree 218 lookup_attribute_by_prefix (const char *attr_name, tree list) 219 { 220 gcc_checking_assert (attr_name[0] != '_'); 221 /* In most cases, list is NULL_TREE. */ 222 if (list == NULL_TREE) 223 return NULL_TREE; 224 else 225 { 226 size_t attr_len = strlen (attr_name); 227 while (list) 228 { 229 tree name = get_attribute_name (list); 230 size_t ident_len = IDENTIFIER_LENGTH (name); 231 232 if (attr_len > ident_len) 233 { 234 list = TREE_CHAIN (list); 235 continue; 236 } 237 238 const char *p = IDENTIFIER_POINTER (name); 239 gcc_checking_assert (attr_len == 0 || p[0] != '_'); 240 241 if (strncmp (attr_name, p, attr_len) == 0) 242 break; 243 244 list = TREE_CHAIN (list); 245 } 246 247 return list; 248 } 249 } 250 251 /* Description of a function argument declared with attribute access. 252 Used as an "iterator" over all such arguments in a function declaration 253 or call. */ 254 255 struct attr_access 256 { 257 /* The beginning and end of the internal string representation. */ 258 const char *str, *end; 259 /* The attribute pointer argument. */ 260 tree ptr; 261 /* For a declaration, a TREE_CHAIN of VLA bound expressions stored 262 in TREE_VALUE and their positions in the argument list (stored 263 in TREE_PURPOSE). Each expression may be a PARM_DECL or some 264 other DECL (for ordinary variables), or an EXPR for other 265 expressions (e.g., funcion calls). */ 266 tree size; 267 268 /* The zero-based position of each of the formal function arguments. 269 For the optional SIZARG, UINT_MAX when not specified. For VLAs 270 with multiple variable bounds, SIZARG is the position corresponding 271 to the most significant bound in the argument list. Positions of 272 subsequent bounds are in the TREE_PURPOSE field of the SIZE chain. */ 273 unsigned ptrarg; 274 unsigned sizarg; 275 /* For internal specifications only, the constant minimum size of 276 the array, zero if not specified, and HWI_M1U for the unspecified 277 VLA [*] notation. Meaningless for external (explicit) access 278 specifications. */ 279 unsigned HOST_WIDE_INT minsize; 280 281 /* The access mode. */ 282 access_mode mode; 283 284 /* Set for an attribute added internally rather than by an explicit 285 declaration. */ 286 bool internal_p; 287 /* Set for the T[static MINSIZE] array notation for nonzero MINSIZE 288 less than HWI_M1U. */ 289 bool static_p; 290 291 /* Return the number of specified VLA bounds. */ 292 unsigned vla_bounds (unsigned *) const; 293 294 /* Return internal representation as STRING_CST. */ 295 tree to_internal_string () const; 296 297 /* Return the human-readable representation of the external attribute 298 specification (as it might appear in the source code) as STRING_CST. */ 299 tree to_external_string () const; 300 301 /* Return argument of array type formatted as a readable string. */ 302 std::string array_as_string (tree) const; 303 304 /* Return the access mode corresponding to the character code. */ 305 static access_mode from_mode_char (char); 306 307 /* Reset front end-specific attribute access data from attributes. */ 308 static void free_lang_data (tree); 309 310 /* The character codes corresponding to all the access modes. */ 311 static constexpr char mode_chars[5] = { '-', 'r', 'w', 'x', '^' }; 312 313 /* The strings corresponding to just the external access modes. */ 314 static constexpr char mode_names[4][11] = 315 { 316 "none", "read_only", "write_only", "read_write" 317 }; 318 }; 319 320 inline access_mode 321 attr_access::from_mode_char (char c) 322 { 323 switch (c) 324 { 325 case mode_chars[access_none]: return access_none; 326 case mode_chars[access_read_only]: return access_read_only; 327 case mode_chars[access_write_only]: return access_write_only; 328 case mode_chars[access_read_write]: return access_read_write; 329 case mode_chars[access_deferred]: return access_deferred; 330 } 331 gcc_unreachable (); 332 } 333 334 /* Used to define rdwr_map below. */ 335 struct rdwr_access_hash: int_hash<int, -1> { }; 336 337 /* A mapping between argument number corresponding to attribute access 338 mode (read_only, write_only, or read_write) and operands. */ 339 struct attr_access; 340 typedef hash_map<rdwr_access_hash, attr_access> rdwr_map; 341 342 extern void init_attr_rdwr_indices (rdwr_map *, tree); 343 extern attr_access *get_parm_access (rdwr_map &, tree, 344 tree = current_function_decl); 345 346 #endif // GCC_ATTRIBS_H 347
Indexes created Tue Feb 24 01:34:59 UTC 2026