1 /* Some code common to C and ObjC front ends.
2 Copyright (C) 2001-2021 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 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "c-tree.h"
24 #include "intl.h"
25 #include "c-family/c-pretty-print.h"
26 #include "tree-pretty-print.h"
27 #include "gimple-pretty-print.h"
28 #include "langhooks.h"
29 #include "c-objc-common.h"
30 #include "gcc-rich-location.h"
31 #include "stringpool.h"
32 #include "attribs.h"
33
34 static bool c_tree_printer (pretty_printer *, text_info *, const char *,
35 int, bool, bool, bool, bool *, const char **);
36
37 bool
c_missing_noreturn_ok_p(tree decl)38 c_missing_noreturn_ok_p (tree decl)
39 {
40 /* A missing noreturn is not ok for freestanding implementations and
41 ok for the `main' function in hosted implementations. */
42 return flag_hosted && MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
43 }
44
45 /* Called from check_global_declaration. */
46
47 bool
c_warn_unused_global_decl(const_tree decl)48 c_warn_unused_global_decl (const_tree decl)
49 {
50 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
51 return false;
52 if (DECL_IN_SYSTEM_HEADER (decl))
53 return false;
54
55 return true;
56 }
57
58 /* Initialization common to C and Objective-C front ends. */
59 bool
c_objc_common_init(void)60 c_objc_common_init (void)
61 {
62 c_init_decl_processing ();
63
64 return c_common_init ();
65 }
66
67 /* Decide whether it's worth saying that TYPE is also known as some other
68 type. Return the other type if so, otherwise return TYPE. */
69
70 static tree
get_aka_type(tree type)71 get_aka_type (tree type)
72 {
73 if (type == error_mark_node)
74 return type;
75
76 tree result;
77 if (typedef_variant_p (type))
78 {
79 /* Saying that "foo" is also known as "struct foo" or
80 "struct <anonymous>" is unlikely to be useful, since users of
81 structure-like types would already know that they're structures.
82 The same applies to unions and enums; in general, printing the
83 tag is only useful if it has a different name. */
84 tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
85 tree_code code = TREE_CODE (orig_type);
86 tree orig_id = TYPE_IDENTIFIER (orig_type);
87 if ((code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
88 && (!orig_id || TYPE_IDENTIFIER (type) == orig_id))
89 return type;
90
91 if (!user_facing_original_type_p (type))
92 return type;
93
94 result = get_aka_type (orig_type);
95 }
96 else
97 {
98 tree canonical = TYPE_CANONICAL (type);
99 if (canonical && TREE_CODE (type) != TREE_CODE (canonical))
100 return canonical;
101
102 /* Recursive calls might choose a middle ground between TYPE
103 (which has no typedefs stripped) and CANONICAL (which has
104 all typedefs stripped). So try to reuse TYPE or CANONICAL if
105 convenient, but be prepared to create a new type if necessary. */
106 switch (TREE_CODE (type))
107 {
108 case POINTER_TYPE:
109 case REFERENCE_TYPE:
110 {
111 tree target_type = get_aka_type (TREE_TYPE (type));
112
113 if (target_type == TREE_TYPE (type))
114 return type;
115
116 if (canonical && target_type == TREE_TYPE (canonical))
117 return canonical;
118
119 result = (TREE_CODE (type) == POINTER_TYPE
120 ? build_pointer_type (target_type)
121 : build_reference_type (target_type));
122 break;
123 }
124
125 case ARRAY_TYPE:
126 {
127 tree element_type = get_aka_type (TREE_TYPE (type));
128 tree index_type = (TYPE_DOMAIN (type)
129 ? get_aka_type (TYPE_DOMAIN (type))
130 : NULL_TREE);
131
132 if (element_type == TREE_TYPE (type)
133 && index_type == TYPE_DOMAIN (type))
134 return type;
135
136 if (canonical
137 && element_type == TREE_TYPE (canonical)
138 && index_type == TYPE_DOMAIN (canonical))
139 return canonical;
140
141 result = build_array_type (element_type, index_type,
142 TYPE_TYPELESS_STORAGE (type));
143 break;
144 }
145
146 case FUNCTION_TYPE:
147 {
148 tree return_type = get_aka_type (TREE_TYPE (type));
149
150 tree args = TYPE_ARG_TYPES (type);
151 if (args == error_mark_node)
152 return type;
153
154 auto_vec<tree, 32> arg_types;
155 bool type_ok_p = true;
156 while (args && args != void_list_node)
157 {
158 tree arg_type = get_aka_type (TREE_VALUE (args));
159 arg_types.safe_push (arg_type);
160 type_ok_p &= (arg_type == TREE_VALUE (args));
161 args = TREE_CHAIN (args);
162 }
163
164 if (type_ok_p && return_type == TREE_TYPE (type))
165 return type;
166
167 unsigned int i;
168 tree arg_type;
169 FOR_EACH_VEC_ELT_REVERSE (arg_types, i, arg_type)
170 args = tree_cons (NULL_TREE, arg_type, args);
171 result = build_function_type (return_type, args);
172 break;
173 }
174
175 default:
176 return canonical ? canonical : type;
177 }
178 }
179 return build_type_attribute_qual_variant (result, TYPE_ATTRIBUTES (type),
180 TYPE_QUALS (type));
181 }
182
183 /* Print T to CPP. */
184
185 static void
print_type(c_pretty_printer * cpp,tree t,bool * quoted)186 print_type (c_pretty_printer *cpp, tree t, bool *quoted)
187 {
188 if (t == error_mark_node)
189 {
190 pp_string (cpp, _("{erroneous}"));
191 return;
192 }
193
194 gcc_assert (TYPE_P (t));
195 struct obstack *ob = pp_buffer (cpp)->obstack;
196 char *p = (char *) obstack_base (ob);
197 /* Remember the end of the initial dump. */
198 int len = obstack_object_size (ob);
199
200 tree name = TYPE_NAME (t);
201 if (name && TREE_CODE (name) == TYPE_DECL && DECL_NAME (name))
202 pp_identifier (cpp, lang_hooks.decl_printable_name (name, 2));
203 else
204 cpp->type_id (t);
205
206 /* If we're printing a type that involves typedefs, also print the
207 stripped version. But sometimes the stripped version looks
208 exactly the same, so we don't want it after all. To avoid
209 printing it in that case, we play ugly obstack games. */
210 tree aka_type = get_aka_type (t);
211 if (aka_type != t)
212 {
213 c_pretty_printer cpp2;
214 /* Print the stripped version into a temporary printer. */
215 cpp2.type_id (aka_type);
216 struct obstack *ob2 = cpp2.buffer->obstack;
217 /* Get the stripped version from the temporary printer. */
218 const char *aka = (char *) obstack_base (ob2);
219 int aka_len = obstack_object_size (ob2);
220 int type1_len = obstack_object_size (ob) - len;
221
222 /* If they are identical, bail out. */
223 if (aka_len == type1_len && memcmp (p + len, aka, aka_len) == 0)
224 return;
225
226 /* They're not, print the stripped version now. */
227 if (*quoted)
228 pp_end_quote (cpp, pp_show_color (cpp));
229 pp_c_whitespace (cpp);
230 pp_left_brace (cpp);
231 pp_c_ws_string (cpp, _("aka"));
232 pp_c_whitespace (cpp);
233 if (*quoted)
234 pp_begin_quote (cpp, pp_show_color (cpp));
235 cpp->type_id (aka_type);
236 if (*quoted)
237 pp_end_quote (cpp, pp_show_color (cpp));
238 pp_right_brace (cpp);
239 /* No further closing quotes are needed. */
240 *quoted = false;
241 }
242 }
243
244 /* Called during diagnostic message formatting process to print a
245 source-level entity onto BUFFER. The meaning of the format specifiers
246 is as follows:
247 %D: a general decl,
248 %E: an identifier or expression,
249 %F: a function declaration,
250 %G: a Gimple statement,
251 %K: a CALL_EXPR,
252 %T: a type.
253 %V: a list of type qualifiers from a tree.
254 %v: an explicit list of type qualifiers
255 %#v: an explicit list of type qualifiers of a function type.
256
257 Please notice when called, the `%' part was already skipped by the
258 diagnostic machinery. */
259 static bool
c_tree_printer(pretty_printer * pp,text_info * text,const char * spec,int precision,bool wide,bool set_locus,bool hash,bool * quoted,const char **)260 c_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
261 int precision, bool wide, bool set_locus, bool hash,
262 bool *quoted, const char **)
263 {
264 tree t = NULL_TREE;
265 // FIXME: the next cast should be a dynamic_cast, when it is permitted.
266 c_pretty_printer *cpp = (c_pretty_printer *) pp;
267 pp->padding = pp_none;
268
269 if (precision != 0 || wide)
270 return false;
271
272 if (*spec == 'G')
273 {
274 percent_G_format (text);
275 return true;
276 }
277
278 if (*spec == 'K')
279 {
280 t = va_arg (*text->args_ptr, tree);
281 percent_K_format (text, EXPR_LOCATION (t), TREE_BLOCK (t));
282 return true;
283 }
284
285 if (*spec != 'v')
286 {
287 t = va_arg (*text->args_ptr, tree);
288 if (set_locus)
289 text->set_location (0, DECL_SOURCE_LOCATION (t),
290 SHOW_RANGE_WITH_CARET);
291 }
292
293 switch (*spec)
294 {
295 case 'D':
296 if (VAR_P (t) && DECL_HAS_DEBUG_EXPR_P (t))
297 {
298 t = DECL_DEBUG_EXPR (t);
299 if (!DECL_P (t))
300 {
301 cpp->expression (t);
302 return true;
303 }
304 }
305 /* FALLTHRU */
306
307 case 'F':
308 if (DECL_NAME (t))
309 {
310 pp_identifier (cpp, lang_hooks.decl_printable_name (t, 2));
311 return true;
312 }
313 break;
314
315 case 'T':
316 print_type (cpp, t, quoted);
317 return true;
318
319 case 'E':
320 if (TREE_CODE (t) == IDENTIFIER_NODE)
321 pp_identifier (cpp, IDENTIFIER_POINTER (t));
322 else
323 cpp->expression (t);
324 return true;
325
326 case 'V':
327 pp_c_type_qualifier_list (cpp, t);
328 return true;
329
330 case 'v':
331 pp_c_cv_qualifiers (cpp, va_arg (*text->args_ptr, int), hash);
332 return true;
333
334 default:
335 return false;
336 }
337
338 pp_string (cpp, _("({anonymous})"));
339 return true;
340 }
341
342 /* C-specific implementation of range_label::get_text () vfunc for
343 range_label_for_type_mismatch. */
344
345 label_text
get_text(unsigned)346 range_label_for_type_mismatch::get_text (unsigned /*range_idx*/) const
347 {
348 if (m_labelled_type == NULL_TREE)
349 return label_text::borrow (NULL);
350
351 c_pretty_printer cpp;
352 bool quoted = false;
353 print_type (&cpp, m_labelled_type, "ed);
354 return label_text::take (xstrdup (pp_formatted_text (&cpp)));
355 }
356
357
358 /* In C and ObjC, all decls have "C" linkage. */
359 bool
has_c_linkage(const_tree decl ATTRIBUTE_UNUSED)360 has_c_linkage (const_tree decl ATTRIBUTE_UNUSED)
361 {
362 return true;
363 }
364
365 void
c_initialize_diagnostics(diagnostic_context * context)366 c_initialize_diagnostics (diagnostic_context *context)
367 {
368 pretty_printer *base = context->printer;
369 c_pretty_printer *pp = XNEW (c_pretty_printer);
370 context->printer = new (pp) c_pretty_printer ();
371
372 /* It is safe to free this object because it was previously XNEW()'d. */
373 base->~pretty_printer ();
374 XDELETE (base);
375
376 c_common_diagnostics_set_defaults (context);
377 diagnostic_format_decoder (context) = &c_tree_printer;
378 }
379
380 int
c_types_compatible_p(tree x,tree y)381 c_types_compatible_p (tree x, tree y)
382 {
383 return comptypes (TYPE_MAIN_VARIANT (x), TYPE_MAIN_VARIANT (y));
384 }
385
386 /* Determine if the type is a vla type for the backend. */
387
388 bool
c_vla_unspec_p(tree x,tree fn ATTRIBUTE_UNUSED)389 c_vla_unspec_p (tree x, tree fn ATTRIBUTE_UNUSED)
390 {
391 return c_vla_type_p (x);
392 }
393
394 /* Special routine to get the alias set of T for C. */
395
396 alias_set_type
c_get_alias_set(tree t)397 c_get_alias_set (tree t)
398 {
399 /* Allow aliasing between enumeral types and the underlying
400 integer type. This is required since those are compatible types. */
401 if (TREE_CODE (t) == ENUMERAL_TYPE)
402 {
403 tree t1 = c_common_type_for_size (tree_to_uhwi (TYPE_SIZE (t)),
404 /* short-cut commoning to signed
405 type. */
406 false);
407 return get_alias_set (t1);
408 }
409
410 return c_common_get_alias_set (t);
411 }
412