|
111
|
1 /* Declarations and definitions dealing with attribute handling.
|
|
145
|
2 Copyright (C) 2013-2020 Free Software Foundation, Inc.
|
|
111
|
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 init_attributes (void);
|
|
|
25
|
|
|
26 /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
|
|
|
27 which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL,
|
|
|
28 it should be modified in place; if a TYPE, a copy should be created
|
|
|
29 unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further
|
|
|
30 information, in the form of a bitwise OR of flags in enum attribute_flags
|
|
|
31 from tree.h. Depending on these flags, some attributes may be
|
|
|
32 returned to be applied at a later stage (for example, to apply
|
|
|
33 a decl attribute to the declaration rather than to its type). */
|
|
131
|
34 extern tree decl_attributes (tree *, tree, int, tree = NULL_TREE);
|
|
111
|
35
|
|
|
36 extern bool cxx11_attribute_p (const_tree);
|
|
|
37 extern tree get_attribute_name (const_tree);
|
|
145
|
38 extern tree get_attribute_namespace (const_tree);
|
|
111
|
39 extern void apply_tm_attr (tree, tree);
|
|
|
40 extern tree make_attribute (const char *, const char *, tree);
|
|
|
41
|
|
|
42 extern struct scoped_attributes* register_scoped_attributes (const struct attribute_spec *,
|
|
|
43 const char *);
|
|
|
44
|
|
|
45 extern char *sorted_attr_string (tree);
|
|
|
46 extern bool common_function_versions (tree, tree);
|
|
|
47 extern char *make_unique_name (tree, const char *, bool);
|
|
|
48 extern tree make_dispatcher_decl (const tree);
|
|
|
49 extern bool is_function_default_version (const tree);
|
|
|
50
|
|
|
51 /* Return a type like TTYPE except that its TYPE_ATTRIBUTES
|
|
|
52 is ATTRIBUTE.
|
|
|
53
|
|
|
54 Such modified types already made are recorded so that duplicates
|
|
|
55 are not made. */
|
|
|
56
|
|
|
57 extern tree build_type_attribute_variant (tree, tree);
|
|
|
58 extern tree build_decl_attribute_variant (tree, tree);
|
|
|
59 extern tree build_type_attribute_qual_variant (tree, tree, int);
|
|
|
60
|
|
|
61 extern bool attribute_value_equal (const_tree, const_tree);
|
|
|
62
|
|
|
63 /* Return 0 if the attributes for two types are incompatible, 1 if they
|
|
|
64 are compatible, and 2 if they are nearly compatible (which causes a
|
|
|
65 warning to be generated). */
|
|
|
66 extern int comp_type_attributes (const_tree, const_tree);
|
|
|
67
|
|
|
68 /* Default versions of target-overridable functions. */
|
|
|
69 extern tree merge_decl_attributes (tree, tree);
|
|
|
70 extern tree merge_type_attributes (tree, tree);
|
|
|
71
|
|
|
72 /* Remove any instances of attribute ATTR_NAME in LIST and return the
|
|
|
73 modified list. */
|
|
|
74
|
|
|
75 extern tree remove_attribute (const char *, tree);
|
|
|
76
|
|
|
77 /* Given two attributes lists, return a list of their union. */
|
|
|
78
|
|
|
79 extern tree merge_attributes (tree, tree);
|
|
|
80
|
|
|
81 /* Duplicate all attributes with name NAME in ATTR list to *ATTRS if
|
|
|
82 they are missing there. */
|
|
|
83
|
|
|
84 extern void duplicate_one_attribute (tree *, tree, const char *);
|
|
|
85
|
|
|
86 /* Duplicate all attributes from user DECL to the corresponding
|
|
|
87 builtin that should be propagated. */
|
|
|
88
|
|
|
89 extern void copy_attributes_to_builtin (tree);
|
|
|
90
|
|
|
91 /* Given two Windows decl attributes lists, possibly including
|
|
|
92 dllimport, return a list of their union . */
|
|
|
93 extern tree merge_dllimport_decl_attributes (tree, tree);
|
|
|
94
|
|
|
95 /* Handle a "dllimport" or "dllexport" attribute. */
|
|
|
96 extern tree handle_dll_attribute (tree *, tree, tree, int, bool *);
|
|
|
97
|
|
|
98 extern int attribute_list_equal (const_tree, const_tree);
|
|
|
99 extern int attribute_list_contained (const_tree, const_tree);
|
|
|
100
|
|
|
101 /* The backbone of lookup_attribute(). ATTR_LEN is the string length
|
|
|
102 of ATTR_NAME, and LIST is not NULL_TREE.
|
|
|
103
|
|
|
104 The function is called from lookup_attribute in order to optimize
|
|
|
105 for size. */
|
|
|
106 extern tree private_lookup_attribute (const char *attr_name, size_t attr_len,
|
|
|
107 tree list);
|
|
|
108
|
|
145
|
109 extern unsigned decls_mismatched_attributes (tree, tree, tree,
|
|
|
110 const char* const[],
|
|
|
111 pretty_printer*);
|
|
|
112
|
|
|
113 extern void maybe_diag_alias_attributes (tree, tree);
|
|
|
114
|
|
111
|
115 /* For a given IDENTIFIER_NODE, strip leading and trailing '_' characters
|
|
|
116 so that we have a canonical form of attribute names. */
|
|
|
117
|
|
|
118 static inline tree
|
|
|
119 canonicalize_attr_name (tree attr_name)
|
|
|
120 {
|
|
|
121 const size_t l = IDENTIFIER_LENGTH (attr_name);
|
|
|
122 const char *s = IDENTIFIER_POINTER (attr_name);
|
|
|
123
|
|
|
124 if (l > 4 && s[0] == '_' && s[1] == '_' && s[l - 1] == '_' && s[l - 2] == '_')
|
|
|
125 return get_identifier_with_length (s + 2, l - 4);
|
|
|
126
|
|
|
127 return attr_name;
|
|
|
128 }
|
|
|
129
|
|
|
130 /* Compare attribute identifiers ATTR1 and ATTR2 with length ATTR1_LEN and
|
|
|
131 ATTR2_LEN. */
|
|
|
132
|
|
|
133 static inline bool
|
|
|
134 cmp_attribs (const char *attr1, size_t attr1_len,
|
|
|
135 const char *attr2, size_t attr2_len)
|
|
|
136 {
|
|
|
137 return attr1_len == attr2_len && strncmp (attr1, attr2, attr1_len) == 0;
|
|
|
138 }
|
|
|
139
|
|
|
140 /* Compare attribute identifiers ATTR1 and ATTR2. */
|
|
|
141
|
|
|
142 static inline bool
|
|
|
143 cmp_attribs (const char *attr1, const char *attr2)
|
|
|
144 {
|
|
|
145 return cmp_attribs (attr1, strlen (attr1), attr2, strlen (attr2));
|
|
|
146 }
|
|
|
147
|
|
|
148 /* Given an identifier node IDENT and a string ATTR_NAME, return true
|
|
|
149 if the identifier node is a valid attribute name for the string. */
|
|
|
150
|
|
|
151 static inline bool
|
|
|
152 is_attribute_p (const char *attr_name, const_tree ident)
|
|
|
153 {
|
|
|
154 return cmp_attribs (attr_name, strlen (attr_name),
|
|
|
155 IDENTIFIER_POINTER (ident), IDENTIFIER_LENGTH (ident));
|
|
|
156 }
|
|
|
157
|
|
|
158 /* Given an attribute name ATTR_NAME and a list of attributes LIST,
|
|
|
159 return a pointer to the attribute's list element if the attribute
|
|
|
160 is part of the list, or NULL_TREE if not found. If the attribute
|
|
|
161 appears more than once, this only returns the first occurrence; the
|
|
|
162 TREE_CHAIN of the return value should be passed back in if further
|
|
|
163 occurrences are wanted. ATTR_NAME must be in the form 'text' (not
|
|
|
164 '__text__'). */
|
|
|
165
|
|
|
166 static inline tree
|
|
|
167 lookup_attribute (const char *attr_name, tree list)
|
|
|
168 {
|
|
|
169 gcc_checking_assert (attr_name[0] != '_');
|
|
|
170 /* In most cases, list is NULL_TREE. */
|
|
|
171 if (list == NULL_TREE)
|
|
|
172 return NULL_TREE;
|
|
|
173 else
|
|
|
174 {
|
|
|
175 size_t attr_len = strlen (attr_name);
|
|
|
176 /* Do the strlen() before calling the out-of-line implementation.
|
|
|
177 In most cases attr_name is a string constant, and the compiler
|
|
|
178 will optimize the strlen() away. */
|
|
|
179 return private_lookup_attribute (attr_name, attr_len, list);
|
|
|
180 }
|
|
|
181 }
|
|
|
182
|
|
|
183 /* Given an attribute name ATTR_NAME and a list of attributes LIST,
|
|
|
184 return a pointer to the attribute's list first element if the attribute
|
|
|
185 starts with ATTR_NAME. ATTR_NAME must be in the form 'text' (not
|
|
|
186 '__text__'). */
|
|
|
187
|
|
|
188 static inline tree
|
|
|
189 lookup_attribute_by_prefix (const char *attr_name, tree list)
|
|
|
190 {
|
|
|
191 gcc_checking_assert (attr_name[0] != '_');
|
|
|
192 /* In most cases, list is NULL_TREE. */
|
|
|
193 if (list == NULL_TREE)
|
|
|
194 return NULL_TREE;
|
|
|
195 else
|
|
|
196 {
|
|
|
197 size_t attr_len = strlen (attr_name);
|
|
|
198 while (list)
|
|
|
199 {
|
|
|
200 size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
|
|
|
201
|
|
|
202 if (attr_len > ident_len)
|
|
|
203 {
|
|
|
204 list = TREE_CHAIN (list);
|
|
|
205 continue;
|
|
|
206 }
|
|
|
207
|
|
|
208 const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
|
|
|
209 gcc_checking_assert (attr_len == 0 || p[0] != '_');
|
|
|
210
|
|
|
211 if (strncmp (attr_name, p, attr_len) == 0)
|
|
|
212 break;
|
|
|
213
|
|
|
214 list = TREE_CHAIN (list);
|
|
|
215 }
|
|
|
216
|
|
|
217 return list;
|
|
|
218 }
|
|
|
219 }
|
|
|
220
|
|
145
|
221 /* Description of a function argument declared with attribute access.
|
|
|
222 Used as an "iterator" over all such arguments in a function declaration
|
|
|
223 or call. */
|
|
|
224
|
|
|
225 struct attr_access
|
|
|
226 {
|
|
|
227 /* The attribute pointer argument. */
|
|
|
228 tree ptr;
|
|
|
229 /* The size of the pointed-to object or NULL when not specified. */
|
|
|
230 tree size;
|
|
|
231
|
|
|
232 /* The zero-based number of each of the formal function arguments. */
|
|
|
233 unsigned ptrarg;
|
|
|
234 unsigned sizarg;
|
|
|
235
|
|
|
236 /* The access mode. */
|
|
|
237 enum access_mode { read_only, write_only, read_write };
|
|
|
238 access_mode mode;
|
|
|
239 };
|
|
|
240
|
|
111
|
241 #endif // GCC_ATTRIBS_H
|
