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