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