?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2015-06-23 Paolo Carlini <paolo.carlini@oracle.com>
[official-gcc.git] / gcc / cp / error.c
blob96fa94d50e0c3fe99719911a5ae9ec7a6f6f7aca
1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License 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 "tm.h"
24 #include "alias.h"
25 #include "symtab.h"
26 #include "tree.h"
27 #include "stringpool.h"
28 #include "cp-tree.h"
29 #include "flags.h"
30 #include "diagnostic.h"
31 #include "tree-diagnostic.h"
32 #include "langhooks-def.h"
33 #include "intl.h"
34 #include "cxx-pretty-print.h"
35 #include "tree-pretty-print.h"
36 #include "c-family/c-objc.h"
37 #include "ubsan.h"
38 #include "internal-fn.h"
39
40 #include <new> // For placement-new.
41
42 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
43 #define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
44
45 /* cxx_pp is a C++ front-end-specific pretty printer: this is where we
46 dump C++ ASTs as strings. It is mostly used only by the various
47 tree -> string functions that are occasionally called from the
48 debugger or by the front-end for things like
49 __PRETTY_FUNCTION__. */
50 static cxx_pretty_printer actual_pretty_printer;
51 static cxx_pretty_printer * const cxx_pp = &actual_pretty_printer;
52
53 /* Translate if being used for diagnostics, but not for dump files or
54 __PRETTY_FUNCTION. */
55 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
56
57 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
58
59 static const char *args_to_string (tree, int);
60 static const char *assop_to_string (enum tree_code);
61 static const char *code_to_string (enum tree_code);
62 static const char *cv_to_string (tree, int);
63 static const char *decl_to_string (tree, int);
64 static const char *expr_to_string (tree);
65 static const char *fndecl_to_string (tree, int);
66 static const char *op_to_string (enum tree_code);
67 static const char *parm_to_string (int);
68 static const char *type_to_string (tree, int);
69
70 static void dump_alias_template_specialization (cxx_pretty_printer *, tree, int);
71 static void dump_type (cxx_pretty_printer *, tree, int);
72 static void dump_typename (cxx_pretty_printer *, tree, int);
73 static void dump_simple_decl (cxx_pretty_printer *, tree, tree, int);
74 static void dump_decl (cxx_pretty_printer *, tree, int);
75 static void dump_template_decl (cxx_pretty_printer *, tree, int);
76 static void dump_function_decl (cxx_pretty_printer *, tree, int);
77 static void dump_expr (cxx_pretty_printer *, tree, int);
78 static void dump_unary_op (cxx_pretty_printer *, const char *, tree, int);
79 static void dump_binary_op (cxx_pretty_printer *, const char *, tree, int);
80 static void dump_aggr_type (cxx_pretty_printer *, tree, int);
81 static void dump_type_prefix (cxx_pretty_printer *, tree, int);
82 static void dump_type_suffix (cxx_pretty_printer *, tree, int);
83 static void dump_function_name (cxx_pretty_printer *, tree, int);
84 static void dump_call_expr_args (cxx_pretty_printer *, tree, int, bool);
85 static void dump_aggr_init_expr_args (cxx_pretty_printer *, tree, int, bool);
86 static void dump_expr_list (cxx_pretty_printer *, tree, int);
87 static void dump_global_iord (cxx_pretty_printer *, tree);
88 static void dump_parameters (cxx_pretty_printer *, tree, int);
89 static void dump_ref_qualifier (cxx_pretty_printer *, tree, int);
90 static void dump_exception_spec (cxx_pretty_printer *, tree, int);
91 static void dump_template_argument (cxx_pretty_printer *, tree, int);
92 static void dump_template_argument_list (cxx_pretty_printer *, tree, int);
93 static void dump_template_parameter (cxx_pretty_printer *, tree, int);
94 static void dump_template_bindings (cxx_pretty_printer *, tree, tree,
95 vec<tree, va_gc> *);
96 static void dump_scope (cxx_pretty_printer *, tree, int);
97 static void dump_template_parms (cxx_pretty_printer *, tree, int, int);
98 static int get_non_default_template_args_count (tree, int);
99 static const char *function_category (tree);
100 static void maybe_print_constexpr_context (diagnostic_context *);
101 static void maybe_print_instantiation_context (diagnostic_context *);
102 static void print_instantiation_full_context (diagnostic_context *);
103 static void print_instantiation_partial_context (diagnostic_context *,
104 struct tinst_level *,
105 location_t);
106 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
107 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
108
109 static bool cp_printer (pretty_printer *, text_info *, const char *,
110 int, bool, bool, bool);
111
112 /* CONTEXT->printer is a basic pretty printer that was constructed
113 presumably by diagnostic_initialize(), called early in the
114 compiler's initialization process (in general_init) Before the FE
115 is initialized. This (C++) FE-specific diagnostic initializer is
116 thus replacing the basic pretty printer with one that has C++-aware
117 capacities. */
118
119 void
120 cxx_initialize_diagnostics (diagnostic_context *context)
121 {
122 pretty_printer *base = context->printer;
123 cxx_pretty_printer *pp = XNEW (cxx_pretty_printer);
124 context->printer = new (pp) cxx_pretty_printer ();
125
126 /* It is safe to free this object because it was previously XNEW()'d. */
127 base->~pretty_printer ();
128 XDELETE (base);
129
130 c_common_diagnostics_set_defaults (context);
131 diagnostic_starter (context) = cp_diagnostic_starter;
132 /* diagnostic_finalizer is already c_diagnostic_finalizer. */
133 diagnostic_format_decoder (context) = cp_printer;
134 }
135
136 /* Dump a scope, if deemed necessary. */
137
138 static void
139 dump_scope (cxx_pretty_printer *pp, tree scope, int flags)
140 {
141 int f = flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF);
142
143 if (scope == NULL_TREE)
144 return;
145
146 if (TREE_CODE (scope) == NAMESPACE_DECL)
147 {
148 if (scope != global_namespace)
149 {
150 dump_decl (pp, scope, f);
151 pp_cxx_colon_colon (pp);
152 }
153 }
154 else if (AGGREGATE_TYPE_P (scope))
155 {
156 dump_type (pp, scope, f);
157 pp_cxx_colon_colon (pp);
158 }
159 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
160 {
161 dump_function_decl (pp, scope, f);
162 pp_cxx_colon_colon (pp);
163 }
164 }
165
166 /* Dump the template ARGument under control of FLAGS. */
167
168 static void
169 dump_template_argument (cxx_pretty_printer *pp, tree arg, int flags)
170 {
171 if (ARGUMENT_PACK_P (arg))
172 dump_template_argument_list (pp, ARGUMENT_PACK_ARGS (arg),
173 /* No default args in argument packs. */
174 flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS);
175 else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
176 dump_type (pp, arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
177 else
178 {
179 if (TREE_CODE (arg) == TREE_LIST)
180 arg = TREE_VALUE (arg);
181
182 dump_expr (pp, arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
183 }
184 }
185
186 /* Count the number of template arguments ARGS whose value does not
187 match the (optional) default template parameter in PARAMS */
188
189 static int
190 get_non_default_template_args_count (tree args, int flags)
191 {
192 int n = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args));
193
194 if (/* We use this flag when generating debug information. We don't
195 want to expand templates at this point, for this may generate
196 new decls, which gets decl counts out of sync, which may in
197 turn cause codegen differences between compilations with and
198 without -g. */
199 (flags & TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS) != 0
200 || !flag_pretty_templates)
201 return n;
202
203 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args));
204 }
205
206 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
207 of FLAGS. */
208
209 static void
210 dump_template_argument_list (cxx_pretty_printer *pp, tree args, int flags)
211 {
212 int n = get_non_default_template_args_count (args, flags);
213 int need_comma = 0;
214 int i;
215
216 for (i = 0; i < n; ++i)
217 {
218 tree arg = TREE_VEC_ELT (args, i);
219
220 /* Only print a comma if we know there is an argument coming. In
221 the case of an empty template argument pack, no actual
222 argument will be printed. */
223 if (need_comma
224 && (!ARGUMENT_PACK_P (arg)
225 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
226 pp_separate_with_comma (pp);
227
228 dump_template_argument (pp, arg, flags);
229 need_comma = 1;
230 }
231 }
232
233 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
234
235 static void
236 dump_template_parameter (cxx_pretty_printer *pp, tree parm, int flags)
237 {
238 tree p;
239 tree a;
240
241 if (parm == error_mark_node)
242 return;
243
244 p = TREE_VALUE (parm);
245 a = TREE_PURPOSE (parm);
246
247 if (TREE_CODE (p) == TYPE_DECL)
248 {
249 if (flags & TFF_DECL_SPECIFIERS)
250 {
251 pp_cxx_ws_string (pp, "class");
252 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
253 pp_cxx_ws_string (pp, "...");
254 if (DECL_NAME (p))
255 pp_cxx_tree_identifier (pp, DECL_NAME (p));
256 }
257 else if (DECL_NAME (p))
258 pp_cxx_tree_identifier (pp, DECL_NAME (p));
259 else
260 pp_cxx_canonical_template_parameter (pp, TREE_TYPE (p));
261 }
262 else
263 dump_decl (pp, p, flags | TFF_DECL_SPECIFIERS);
264
265 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
266 {
267 pp_cxx_whitespace (pp);
268 pp_equal (pp);
269 pp_cxx_whitespace (pp);
270 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
271 dump_type (pp, a, flags & ~TFF_CHASE_TYPEDEF);
272 else
273 dump_expr (pp, a, flags | TFF_EXPR_IN_PARENS);
274 }
275 }
276
277 /* Dump, under control of FLAGS, a template-parameter-list binding.
278 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
279 TREE_VEC. */
280
281 static void
282 dump_template_bindings (cxx_pretty_printer *pp, tree parms, tree args,
283 vec<tree, va_gc> *typenames)
284 {
285 bool need_semicolon = false;
286 int i;
287 tree t;
288
289 while (parms)
290 {
291 tree p = TREE_VALUE (parms);
292 int lvl = TMPL_PARMS_DEPTH (parms);
293 int arg_idx = 0;
294 int i;
295 tree lvl_args = NULL_TREE;
296
297 /* Don't crash if we had an invalid argument list. */
298 if (TMPL_ARGS_DEPTH (args) >= lvl)
299 lvl_args = TMPL_ARGS_LEVEL (args, lvl);
300
301 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
302 {
303 tree arg = NULL_TREE;
304
305 /* Don't crash if we had an invalid argument list. */
306 if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx)
307 arg = TREE_VEC_ELT (lvl_args, arg_idx);
308
309 if (need_semicolon)
310 pp_separate_with_semicolon (pp);
311 dump_template_parameter (pp, TREE_VEC_ELT (p, i),
312 TFF_PLAIN_IDENTIFIER);
313 pp_cxx_whitespace (pp);
314 pp_equal (pp);
315 pp_cxx_whitespace (pp);
316 if (arg)
317 {
318 if (ARGUMENT_PACK_P (arg))
319 pp_cxx_left_brace (pp);
320 dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER);
321 if (ARGUMENT_PACK_P (arg))
322 pp_cxx_right_brace (pp);
323 }
324 else
325 pp_string (pp, M_("<missing>"));
326
327 ++arg_idx;
328 need_semicolon = true;
329 }
330
331 parms = TREE_CHAIN (parms);
332 }
333
334 /* Don't bother with typenames for a partial instantiation. */
335 if (vec_safe_is_empty (typenames) || uses_template_parms (args))
336 return;
337
338 /* Don't try to print typenames when we're processing a clone. */
339 if (current_function_decl
340 && !DECL_LANG_SPECIFIC (current_function_decl))
341 return;
342
343 FOR_EACH_VEC_SAFE_ELT (typenames, i, t)
344 {
345 if (need_semicolon)
346 pp_separate_with_semicolon (pp);
347 dump_type (pp, t, TFF_PLAIN_IDENTIFIER);
348 pp_cxx_whitespace (pp);
349 pp_equal (pp);
350 pp_cxx_whitespace (pp);
351 push_deferring_access_checks (dk_no_check);
352 t = tsubst (t, args, tf_none, NULL_TREE);
353 pop_deferring_access_checks ();
354 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
355 pp_simple_type_specifier doesn't know about it. */
356 t = strip_typedefs (t);
357 dump_type (pp, t, TFF_PLAIN_IDENTIFIER);
358 }
359 }
360
361 /* Dump a human-readable equivalent of the alias template
362 specialization of T. */
363
364 static void
365 dump_alias_template_specialization (cxx_pretty_printer *pp, tree t, int flags)
366 {
367 tree name;
368
369 gcc_assert (alias_template_specialization_p (t));
370
371 if (!(flags & TFF_UNQUALIFIED_NAME))
372 dump_scope (pp, CP_DECL_CONTEXT (TYPE_NAME (t)), flags);
373 name = TYPE_IDENTIFIER (t);
374 pp_cxx_tree_identifier (pp, name);
375 dump_template_parms (pp, TYPE_TEMPLATE_INFO (t),
376 /*primary=*/false,
377 flags & ~TFF_TEMPLATE_HEADER);
378 }
379
380 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
381 format. */
382
383 static void
384 dump_type (cxx_pretty_printer *pp, tree t, int flags)
385 {
386 if (t == NULL_TREE)
387 return;
388
389 /* Don't print e.g. "struct mytypedef". */
390 if (TYPE_P (t) && typedef_variant_p (t))
391 {
392 tree decl = TYPE_NAME (t);
393 if ((flags & TFF_CHASE_TYPEDEF)
394 || DECL_SELF_REFERENCE_P (decl)
395 || (!flag_pretty_templates
396 && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)))
397 t = strip_typedefs (t);
398 else if (alias_template_specialization_p (t))
399 {
400 dump_alias_template_specialization (pp, t, flags);
401 return;
402 }
403 else if (same_type_p (t, TREE_TYPE (decl)))
404 t = decl;
405 else
406 {
407 pp_cxx_cv_qualifier_seq (pp, t);
408 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
409 return;
410 }
411 }
412
413 if (TYPE_PTRMEMFUNC_P (t))
414 goto offset_type;
415
416 switch (TREE_CODE (t))
417 {
418 case LANG_TYPE:
419 if (t == init_list_type_node)
420 pp_string (pp, M_("<brace-enclosed initializer list>"));
421 else if (t == unknown_type_node)
422 pp_string (pp, M_("<unresolved overloaded function type>"));
423 else
424 {
425 pp_cxx_cv_qualifier_seq (pp, t);
426 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
427 }
428 break;
429
430 case TREE_LIST:
431 /* A list of function parms. */
432 dump_parameters (pp, t, flags);
433 break;
434
435 case IDENTIFIER_NODE:
436 pp_cxx_tree_identifier (pp, t);
437 break;
438
439 case TREE_BINFO:
440 dump_type (pp, BINFO_TYPE (t), flags);
441 break;
442
443 case RECORD_TYPE:
444 case UNION_TYPE:
445 case ENUMERAL_TYPE:
446 dump_aggr_type (pp, t, flags);
447 break;
448
449 case TYPE_DECL:
450 if (flags & TFF_CHASE_TYPEDEF)
451 {
452 dump_type (pp, DECL_ORIGINAL_TYPE (t)
453 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
454 break;
455 }
456 /* Else fall through. */
457
458 case TEMPLATE_DECL:
459 case NAMESPACE_DECL:
460 dump_decl (pp, t, flags & ~TFF_DECL_SPECIFIERS);
461 break;
462
463 case INTEGER_TYPE:
464 case REAL_TYPE:
465 case VOID_TYPE:
466 case BOOLEAN_TYPE:
467 case COMPLEX_TYPE:
468 case VECTOR_TYPE:
469 case FIXED_POINT_TYPE:
470 pp_type_specifier_seq (pp, t);
471 break;
472
473 case TEMPLATE_TEMPLATE_PARM:
474 /* For parameters inside template signature. */
475 if (TYPE_IDENTIFIER (t))
476 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
477 else
478 pp_cxx_canonical_template_parameter (pp, t);
479 break;
480
481 case BOUND_TEMPLATE_TEMPLATE_PARM:
482 {
483 tree args = TYPE_TI_ARGS (t);
484 pp_cxx_cv_qualifier_seq (pp, t);
485 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
486 pp_cxx_begin_template_argument_list (pp);
487 dump_template_argument_list (pp, args, flags);
488 pp_cxx_end_template_argument_list (pp);
489 }
490 break;
491
492 case TEMPLATE_TYPE_PARM:
493 pp_cxx_cv_qualifier_seq (pp, t);
494 if (TYPE_IDENTIFIER (t))
495 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
496 else
497 pp_cxx_canonical_template_parameter
498 (pp, TEMPLATE_TYPE_PARM_INDEX (t));
499 break;
500
501 /* This is not always necessary for pointers and such, but doing this
502 reduces code size. */
503 case ARRAY_TYPE:
504 case POINTER_TYPE:
505 case REFERENCE_TYPE:
506 case OFFSET_TYPE:
507 offset_type:
508 case FUNCTION_TYPE:
509 case METHOD_TYPE:
510 {
511 dump_type_prefix (pp, t, flags);
512 dump_type_suffix (pp, t, flags);
513 break;
514 }
515 case TYPENAME_TYPE:
516 if (! (flags & TFF_CHASE_TYPEDEF)
517 && DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
518 {
519 dump_decl (pp, TYPE_NAME (t), TFF_PLAIN_IDENTIFIER);
520 break;
521 }
522 pp_cxx_cv_qualifier_seq (pp, t);
523 pp_cxx_ws_string (pp,
524 TYPENAME_IS_ENUM_P (t) ? "enum"
525 : TYPENAME_IS_CLASS_P (t) ? "class"
526 : "typename");
527 dump_typename (pp, t, flags);
528 break;
529
530 case UNBOUND_CLASS_TEMPLATE:
531 if (! (flags & TFF_UNQUALIFIED_NAME))
532 {
533 dump_type (pp, TYPE_CONTEXT (t), flags);
534 pp_cxx_colon_colon (pp);
535 }
536 pp_cxx_ws_string (pp, "template");
537 dump_type (pp, TYPE_IDENTIFIER (t), flags);
538 break;
539
540 case TYPEOF_TYPE:
541 pp_cxx_ws_string (pp, "__typeof__");
542 pp_cxx_whitespace (pp);
543 pp_cxx_left_paren (pp);
544 dump_expr (pp, TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
545 pp_cxx_right_paren (pp);
546 break;
547
548 case UNDERLYING_TYPE:
549 pp_cxx_ws_string (pp, "__underlying_type");
550 pp_cxx_whitespace (pp);
551 pp_cxx_left_paren (pp);
552 dump_expr (pp, UNDERLYING_TYPE_TYPE (t), flags & ~TFF_EXPR_IN_PARENS);
553 pp_cxx_right_paren (pp);
554 break;
555
556 case TYPE_PACK_EXPANSION:
557 dump_type (pp, PACK_EXPANSION_PATTERN (t), flags);
558 pp_cxx_ws_string (pp, "...");
559 break;
560
561 case TYPE_ARGUMENT_PACK:
562 dump_template_argument (pp, t, flags);
563 break;
564
565 case DECLTYPE_TYPE:
566 pp_cxx_ws_string (pp, "decltype");
567 pp_cxx_whitespace (pp);
568 pp_cxx_left_paren (pp);
569 dump_expr (pp, DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
570 pp_cxx_right_paren (pp);
571 break;
572
573 case NULLPTR_TYPE:
574 pp_string (pp, "std::nullptr_t");
575 break;
576
577 default:
578 pp_unsupported_tree (pp, t);
579 /* Fall through to error. */
580
581 case ERROR_MARK:
582 pp_string (pp, M_("<type error>"));
583 break;
584 }
585 }
586
587 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
588 a TYPENAME_TYPE. */
589
590 static void
591 dump_typename (cxx_pretty_printer *pp, tree t, int flags)
592 {
593 tree ctx = TYPE_CONTEXT (t);
594
595 if (TREE_CODE (ctx) == TYPENAME_TYPE)
596 dump_typename (pp, ctx, flags);
597 else
598 dump_type (pp, ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
599 pp_cxx_colon_colon (pp);
600 dump_decl (pp, TYPENAME_TYPE_FULLNAME (t), flags);
601 }
602
603 /* Return the name of the supplied aggregate, or enumeral type. */
604
605 const char *
606 class_key_or_enum_as_string (tree t)
607 {
608 if (TREE_CODE (t) == ENUMERAL_TYPE)
609 {
610 if (SCOPED_ENUM_P (t))
611 return "enum class";
612 else
613 return "enum";
614 }
615 else if (TREE_CODE (t) == UNION_TYPE)
616 return "union";
617 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
618 return "class";
619 else
620 return "struct";
621 }
622
623 /* Print out a class declaration T under the control of FLAGS,
624 in the form `class foo'. */
625
626 static void
627 dump_aggr_type (cxx_pretty_printer *pp, tree t, int flags)
628 {
629 tree name;
630 const char *variety = class_key_or_enum_as_string (t);
631 int typdef = 0;
632 int tmplate = 0;
633
634 pp_cxx_cv_qualifier_seq (pp, t);
635
636 if (flags & TFF_CLASS_KEY_OR_ENUM)
637 pp_cxx_ws_string (pp, variety);
638
639 name = TYPE_NAME (t);
640
641 if (name)
642 {
643 typdef = (!DECL_ARTIFICIAL (name)
644 /* An alias specialization is not considered to be a
645 typedef. */
646 && !alias_template_specialization_p (t));
647
648 if ((typdef
649 && ((flags & TFF_CHASE_TYPEDEF)
650 || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name)
651 && DECL_TEMPLATE_INFO (name))))
652 || DECL_SELF_REFERENCE_P (name))
653 {
654 t = TYPE_MAIN_VARIANT (t);
655 name = TYPE_NAME (t);
656 typdef = 0;
657 }
658
659 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
660 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
661 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
662 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
663
664 if (! (flags & TFF_UNQUALIFIED_NAME))
665 dump_scope (pp, CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
666 flags &= ~TFF_UNQUALIFIED_NAME;
667 if (tmplate)
668 {
669 /* Because the template names are mangled, we have to locate
670 the most general template, and use that name. */
671 tree tpl = TYPE_TI_TEMPLATE (t);
672
673 while (DECL_TEMPLATE_INFO (tpl))
674 tpl = DECL_TI_TEMPLATE (tpl);
675 name = tpl;
676 }
677 name = DECL_NAME (name);
678 }
679
680 if (name == 0 || anon_aggrname_p (name))
681 {
682 if (flags & TFF_CLASS_KEY_OR_ENUM)
683 pp_string (pp, M_("<anonymous>"));
684 else
685 pp_printf (pp, M_("<anonymous %s>"), variety);
686 }
687 else if (LAMBDA_TYPE_P (t))
688 {
689 /* A lambda's "type" is essentially its signature. */
690 pp_string (pp, M_("<lambda"));
691 if (lambda_function (t))
692 dump_parameters (pp,
693 FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)),
694 flags);
695 pp_greater (pp);
696 }
697 else
698 pp_cxx_tree_identifier (pp, name);
699 if (tmplate)
700 dump_template_parms (pp, TYPE_TEMPLATE_INFO (t),
701 !CLASSTYPE_USE_TEMPLATE (t),
702 flags & ~TFF_TEMPLATE_HEADER);
703 }
704
705 /* Dump into the obstack the initial part of the output for a given type.
706 This is necessary when dealing with things like functions returning
707 functions. Examples:
708
709 return type of `int (* fee ())()': pointer -> function -> int. Both
710 pointer (and reference and offset) and function (and member) types must
711 deal with prefix and suffix.
712
713 Arrays must also do this for DECL nodes, like int a[], and for things like
714 int *[]&. */
715
716 static void
717 dump_type_prefix (cxx_pretty_printer *pp, tree t, int flags)
718 {
719 if (TYPE_PTRMEMFUNC_P (t))
720 {
721 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
722 goto offset_type;
723 }
724
725 switch (TREE_CODE (t))
726 {
727 case POINTER_TYPE:
728 case REFERENCE_TYPE:
729 {
730 tree sub = TREE_TYPE (t);
731
732 dump_type_prefix (pp, sub, flags);
733 if (TREE_CODE (sub) == ARRAY_TYPE
734 || TREE_CODE (sub) == FUNCTION_TYPE)
735 {
736 pp_cxx_whitespace (pp);
737 pp_cxx_left_paren (pp);
738 pp_c_attributes_display (pp, TYPE_ATTRIBUTES (sub));
739 }
740 if (TYPE_PTR_P (t))
741 pp_star (pp);
742 else if (TREE_CODE (t) == REFERENCE_TYPE)
743 {
744 if (TYPE_REF_IS_RVALUE (t))
745 pp_ampersand_ampersand (pp);
746 else
747 pp_ampersand (pp);
748 }
749 pp->padding = pp_before;
750 pp_cxx_cv_qualifier_seq (pp, t);
751 }
752 break;
753
754 case OFFSET_TYPE:
755 offset_type:
756 dump_type_prefix (pp, TREE_TYPE (t), flags);
757 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
758 {
759 pp_maybe_space (pp);
760 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
761 pp_cxx_left_paren (pp);
762 dump_type (pp, TYPE_OFFSET_BASETYPE (t), flags);
763 pp_cxx_colon_colon (pp);
764 }
765 pp_cxx_star (pp);
766 pp_cxx_cv_qualifier_seq (pp, t);
767 pp->padding = pp_before;
768 break;
769
770 /* This can be reached without a pointer when dealing with
771 templates, e.g. std::is_function. */
772 case FUNCTION_TYPE:
773 dump_type_prefix (pp, TREE_TYPE (t), flags);
774 break;
775
776 case METHOD_TYPE:
777 dump_type_prefix (pp, TREE_TYPE (t), flags);
778 pp_maybe_space (pp);
779 pp_cxx_left_paren (pp);
780 dump_aggr_type (pp, TYPE_METHOD_BASETYPE (t), flags);
781 pp_cxx_colon_colon (pp);
782 break;
783
784 case ARRAY_TYPE:
785 dump_type_prefix (pp, TREE_TYPE (t), flags);
786 break;
787
788 case ENUMERAL_TYPE:
789 case IDENTIFIER_NODE:
790 case INTEGER_TYPE:
791 case BOOLEAN_TYPE:
792 case REAL_TYPE:
793 case RECORD_TYPE:
794 case TEMPLATE_TYPE_PARM:
795 case TEMPLATE_TEMPLATE_PARM:
796 case BOUND_TEMPLATE_TEMPLATE_PARM:
797 case TREE_LIST:
798 case TYPE_DECL:
799 case TREE_VEC:
800 case UNION_TYPE:
801 case LANG_TYPE:
802 case VOID_TYPE:
803 case TYPENAME_TYPE:
804 case COMPLEX_TYPE:
805 case VECTOR_TYPE:
806 case TYPEOF_TYPE:
807 case UNDERLYING_TYPE:
808 case DECLTYPE_TYPE:
809 case TYPE_PACK_EXPANSION:
810 case FIXED_POINT_TYPE:
811 case NULLPTR_TYPE:
812 dump_type (pp, t, flags);
813 pp->padding = pp_before;
814 break;
815
816 default:
817 pp_unsupported_tree (pp, t);
818 /* fall through. */
819 case ERROR_MARK:
820 pp_string (pp, M_("<typeprefixerror>"));
821 break;
822 }
823 }
824
825 /* Dump the suffix of type T, under control of FLAGS. This is the part
826 which appears after the identifier (or function parms). */
827
828 static void
829 dump_type_suffix (cxx_pretty_printer *pp, tree t, int flags)
830 {
831 if (TYPE_PTRMEMFUNC_P (t))
832 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
833
834 switch (TREE_CODE (t))
835 {
836 case POINTER_TYPE:
837 case REFERENCE_TYPE:
838 case OFFSET_TYPE:
839 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
840 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
841 pp_cxx_right_paren (pp);
842 if (TREE_CODE (t) == POINTER_TYPE)
843 flags |= TFF_POINTER;
844 dump_type_suffix (pp, TREE_TYPE (t), flags);
845 break;
846
847 case FUNCTION_TYPE:
848 case METHOD_TYPE:
849 {
850 tree arg;
851 if (TREE_CODE (t) == METHOD_TYPE)
852 /* Can only be reached through a pointer. */
853 pp_cxx_right_paren (pp);
854 arg = TYPE_ARG_TYPES (t);
855 if (TREE_CODE (t) == METHOD_TYPE)
856 arg = TREE_CHAIN (arg);
857
858 /* Function pointers don't have default args. Not in standard C++,
859 anyway; they may in g++, but we'll just pretend otherwise. */
860 dump_parameters (pp, arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
861
862 pp->padding = pp_before;
863 pp_cxx_cv_qualifiers (pp, type_memfn_quals (t),
864 TREE_CODE (t) == FUNCTION_TYPE
865 && (flags & TFF_POINTER));
866 dump_ref_qualifier (pp, t, flags);
867 dump_exception_spec (pp, TYPE_RAISES_EXCEPTIONS (t), flags);
868 dump_type_suffix (pp, TREE_TYPE (t), flags);
869 break;
870 }
871
872 case ARRAY_TYPE:
873 pp_maybe_space (pp);
874 pp_cxx_left_bracket (pp);
875 if (TYPE_DOMAIN (t))
876 {
877 tree dtype = TYPE_DOMAIN (t);
878 tree max = TYPE_MAX_VALUE (dtype);
879 if (integer_all_onesp (max))
880 pp_character (pp, '0');
881 else if (tree_fits_shwi_p (max))
882 pp_wide_integer (pp, tree_to_shwi (max) + 1);
883 else
884 {
885 STRIP_NOPS (max);
886 if (TREE_CODE (max) == SAVE_EXPR)
887 max = TREE_OPERAND (max, 0);
888 if (TREE_CODE (max) == MINUS_EXPR
889 || TREE_CODE (max) == PLUS_EXPR)
890 {
891 max = TREE_OPERAND (max, 0);
892 while (CONVERT_EXPR_P (max))
893 max = TREE_OPERAND (max, 0);
894 }
895 else
896 max = fold_build2_loc (input_location,
897 PLUS_EXPR, dtype, max,
898 build_int_cst (dtype, 1));
899 dump_expr (pp, max, flags & ~TFF_EXPR_IN_PARENS);
900 }
901 }
902 pp_cxx_right_bracket (pp);
903 dump_type_suffix (pp, TREE_TYPE (t), flags);
904 break;
905
906 case ENUMERAL_TYPE:
907 case IDENTIFIER_NODE:
908 case INTEGER_TYPE:
909 case BOOLEAN_TYPE:
910 case REAL_TYPE:
911 case RECORD_TYPE:
912 case TEMPLATE_TYPE_PARM:
913 case TEMPLATE_TEMPLATE_PARM:
914 case BOUND_TEMPLATE_TEMPLATE_PARM:
915 case TREE_LIST:
916 case TYPE_DECL:
917 case TREE_VEC:
918 case UNION_TYPE:
919 case LANG_TYPE:
920 case VOID_TYPE:
921 case TYPENAME_TYPE:
922 case COMPLEX_TYPE:
923 case VECTOR_TYPE:
924 case TYPEOF_TYPE:
925 case UNDERLYING_TYPE:
926 case DECLTYPE_TYPE:
927 case TYPE_PACK_EXPANSION:
928 case FIXED_POINT_TYPE:
929 case NULLPTR_TYPE:
930 break;
931
932 default:
933 pp_unsupported_tree (pp, t);
934 case ERROR_MARK:
935 /* Don't mark it here, we should have already done in
936 dump_type_prefix. */
937 break;
938 }
939 }
940
941 static void
942 dump_global_iord (cxx_pretty_printer *pp, tree t)
943 {
944 const char *p = NULL;
945
946 if (DECL_GLOBAL_CTOR_P (t))
947 p = M_("(static initializers for %s)");
948 else if (DECL_GLOBAL_DTOR_P (t))
949 p = M_("(static destructors for %s)");
950 else
951 gcc_unreachable ();
952
953 pp_printf (pp, p, LOCATION_FILE (input_location));
954 }
955
956 static void
957 dump_simple_decl (cxx_pretty_printer *pp, tree t, tree type, int flags)
958 {
959 if (flags & TFF_DECL_SPECIFIERS)
960 {
961 if (VAR_P (t)
962 && DECL_DECLARED_CONSTEXPR_P (t))
963 pp_cxx_ws_string (pp, "constexpr");
964 dump_type_prefix (pp, type, flags & ~TFF_UNQUALIFIED_NAME);
965 pp_maybe_space (pp);
966 }
967 if (! (flags & TFF_UNQUALIFIED_NAME)
968 && TREE_CODE (t) != PARM_DECL
969 && (!DECL_INITIAL (t)
970 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
971 dump_scope (pp, CP_DECL_CONTEXT (t), flags);
972 flags &= ~TFF_UNQUALIFIED_NAME;
973 if ((flags & TFF_DECL_SPECIFIERS)
974 && DECL_TEMPLATE_PARM_P (t)
975 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
976 pp_string (pp, "...");
977 if (DECL_NAME (t))
978 {
979 if (TREE_CODE (t) == FIELD_DECL && DECL_NORMAL_CAPTURE_P (t))
980 {
981 pp_less (pp);
982 pp_string (pp, IDENTIFIER_POINTER (DECL_NAME (t)) + 2);
983 pp_string (pp, " capture>");
984 }
985 else
986 dump_decl (pp, DECL_NAME (t), flags);
987 }
988 else
989 pp_string (pp, M_("<anonymous>"));
990 if (flags & TFF_DECL_SPECIFIERS)
991 dump_type_suffix (pp, type, flags);
992 }
993
994 /* Dump a human readable string for the decl T under control of FLAGS. */
995
996 static void
997 dump_decl (cxx_pretty_printer *pp, tree t, int flags)
998 {
999 if (t == NULL_TREE)
1000 return;
1001
1002 /* If doing Objective-C++, give Objective-C a chance to demangle
1003 Objective-C method names. */
1004 if (c_dialect_objc ())
1005 {
1006 const char *demangled = objc_maybe_printable_name (t, flags);
1007 if (demangled)
1008 {
1009 pp_string (pp, demangled);
1010 return;
1011 }
1012 }
1013
1014 switch (TREE_CODE (t))
1015 {
1016 case TYPE_DECL:
1017 /* Don't say 'typedef class A' */
1018 if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
1019 {
1020 if ((flags & TFF_DECL_SPECIFIERS)
1021 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
1022 {
1023 /* Say `class T' not just `T'. */
1024 pp_cxx_ws_string (pp, "class");
1025
1026 /* Emit the `...' for a parameter pack. */
1027 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1028 pp_cxx_ws_string (pp, "...");
1029 }
1030
1031 dump_type (pp, TREE_TYPE (t), flags);
1032 break;
1033 }
1034 if (TYPE_DECL_ALIAS_P (t)
1035 && (flags & TFF_DECL_SPECIFIERS
1036 || flags & TFF_CLASS_KEY_OR_ENUM))
1037 {
1038 pp_cxx_ws_string (pp, "using");
1039 dump_decl (pp, DECL_NAME (t), flags);
1040 pp_cxx_whitespace (pp);
1041 pp_cxx_ws_string (pp, "=");
1042 pp_cxx_whitespace (pp);
1043 dump_type (pp, DECL_ORIGINAL_TYPE (t), flags);
1044 break;
1045 }
1046 if ((flags & TFF_DECL_SPECIFIERS)
1047 && !DECL_SELF_REFERENCE_P (t))
1048 pp_cxx_ws_string (pp, "typedef");
1049 dump_simple_decl (pp, t, DECL_ORIGINAL_TYPE (t)
1050 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
1051 flags);
1052 break;
1053
1054 case VAR_DECL:
1055 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
1056 {
1057 pp_string (pp, M_("vtable for "));
1058 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
1059 dump_type (pp, DECL_CONTEXT (t), flags);
1060 break;
1061 }
1062 /* Else fall through. */
1063 case FIELD_DECL:
1064 case PARM_DECL:
1065 dump_simple_decl (pp, t, TREE_TYPE (t), flags);
1066
1067 /* Handle variable template specializations. */
1068 if (TREE_CODE (t) == VAR_DECL
1069 && DECL_LANG_SPECIFIC (t)
1070 && DECL_TEMPLATE_INFO (t)
1071 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)))
1072 {
1073 pp_cxx_begin_template_argument_list (pp);
1074 tree args = INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t));
1075 dump_template_argument_list (pp, args, flags);
1076 pp_cxx_end_template_argument_list (pp);
1077 }
1078 break;
1079
1080 case RESULT_DECL:
1081 pp_string (pp, M_("<return value> "));
1082 dump_simple_decl (pp, t, TREE_TYPE (t), flags);
1083 break;
1084
1085 case NAMESPACE_DECL:
1086 if (flags & TFF_DECL_SPECIFIERS)
1087 pp->declaration (t);
1088 else
1089 {
1090 if (! (flags & TFF_UNQUALIFIED_NAME))
1091 dump_scope (pp, CP_DECL_CONTEXT (t), flags);
1092 flags &= ~TFF_UNQUALIFIED_NAME;
1093 if (DECL_NAME (t) == NULL_TREE)
1094 {
1095 if (!(pp->flags & pp_c_flag_gnu_v3))
1096 pp_cxx_ws_string (pp, M_("{anonymous}"));
1097 else
1098 pp_cxx_ws_string (pp, M_("(anonymous namespace)"));
1099 }
1100 else
1101 pp_cxx_tree_identifier (pp, DECL_NAME (t));
1102 }
1103 break;
1104
1105 case SCOPE_REF:
1106 dump_type (pp, TREE_OPERAND (t, 0), flags);
1107 pp_colon_colon (pp);
1108 dump_decl (pp, TREE_OPERAND (t, 1), TFF_UNQUALIFIED_NAME);
1109 break;
1110
1111 case ARRAY_REF:
1112 dump_decl (pp, TREE_OPERAND (t, 0), flags);
1113 pp_cxx_left_bracket (pp);
1114 dump_decl (pp, TREE_OPERAND (t, 1), flags);
1115 pp_cxx_right_bracket (pp);
1116 break;
1117
1118 case ARRAY_NOTATION_REF:
1119 dump_decl (pp, ARRAY_NOTATION_ARRAY (t), flags | TFF_EXPR_IN_PARENS);
1120 pp_cxx_left_bracket (pp);
1121 dump_decl (pp, ARRAY_NOTATION_START (t), flags | TFF_EXPR_IN_PARENS);
1122 pp_colon (pp);
1123 dump_decl (pp, ARRAY_NOTATION_LENGTH (t), flags | TFF_EXPR_IN_PARENS);
1124 pp_colon (pp);
1125 dump_decl (pp, ARRAY_NOTATION_STRIDE (t), flags | TFF_EXPR_IN_PARENS);
1126 pp_cxx_right_bracket (pp);
1127 break;
1128
1129 /* So that we can do dump_decl on an aggr type. */
1130 case RECORD_TYPE:
1131 case UNION_TYPE:
1132 case ENUMERAL_TYPE:
1133 dump_type (pp, t, flags);
1134 break;
1135
1136 case BIT_NOT_EXPR:
1137 /* This is a pseudo destructor call which has not been folded into
1138 a PSEUDO_DTOR_EXPR yet. */
1139 pp_cxx_complement (pp);
1140 dump_type (pp, TREE_OPERAND (t, 0), flags);
1141 break;
1142
1143 case TYPE_EXPR:
1144 gcc_unreachable ();
1145 break;
1146
1147 /* These special cases are duplicated here so that other functions
1148 can feed identifiers to error and get them demangled properly. */
1149 case IDENTIFIER_NODE:
1150 if (IDENTIFIER_TYPENAME_P (t))
1151 {
1152 pp_cxx_ws_string (pp, "operator");
1153 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1154 dump_type (pp, TREE_TYPE (t), flags);
1155 break;
1156 }
1157 else
1158 pp_cxx_tree_identifier (pp, t);
1159 break;
1160
1161 case OVERLOAD:
1162 if (OVL_CHAIN (t))
1163 {
1164 t = OVL_CURRENT (t);
1165 if (DECL_CLASS_SCOPE_P (t))
1166 {
1167 dump_type (pp, DECL_CONTEXT (t), flags);
1168 pp_cxx_colon_colon (pp);
1169 }
1170 else if (!DECL_FILE_SCOPE_P (t))
1171 {
1172 dump_decl (pp, DECL_CONTEXT (t), flags);
1173 pp_cxx_colon_colon (pp);
1174 }
1175 dump_decl (pp, DECL_NAME (t), flags);
1176 break;
1177 }
1178
1179 /* If there's only one function, just treat it like an ordinary
1180 FUNCTION_DECL. */
1181 t = OVL_CURRENT (t);
1182 /* Fall through. */
1183
1184 case FUNCTION_DECL:
1185 if (! DECL_LANG_SPECIFIC (t))
1186 {
1187 if (DECL_ABSTRACT_ORIGIN (t))
1188 dump_decl (pp, DECL_ABSTRACT_ORIGIN (t), flags);
1189 else
1190 pp_string (pp, M_("<built-in>"));
1191 }
1192 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
1193 dump_global_iord (pp, t);
1194 else
1195 dump_function_decl (pp, t, flags);
1196 break;
1197
1198 case TEMPLATE_DECL:
1199 dump_template_decl (pp, t, flags);
1200 break;
1201
1202 case TEMPLATE_ID_EXPR:
1203 {
1204 tree name = TREE_OPERAND (t, 0);
1205 tree args = TREE_OPERAND (t, 1);
1206
1207 if (is_overloaded_fn (name))
1208 name = get_first_fn (name);
1209 if (DECL_P (name))
1210 name = DECL_NAME (name);
1211 dump_decl (pp, name, flags);
1212 pp_cxx_begin_template_argument_list (pp);
1213 if (args == error_mark_node)
1214 pp_string (pp, M_("<template arguments error>"));
1215 else if (args)
1216 dump_template_argument_list (pp, args, flags);
1217 pp_cxx_end_template_argument_list (pp);
1218 }
1219 break;
1220
1221 case LABEL_DECL:
1222 pp_cxx_tree_identifier (pp, DECL_NAME (t));
1223 break;
1224
1225 case CONST_DECL:
1226 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1227 || (DECL_INITIAL (t) &&
1228 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1229 dump_simple_decl (pp, t, TREE_TYPE (t), flags);
1230 else if (DECL_NAME (t))
1231 dump_decl (pp, DECL_NAME (t), flags);
1232 else if (DECL_INITIAL (t))
1233 dump_expr (pp, DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1234 else
1235 pp_string (pp, M_("<enumerator>"));
1236 break;
1237
1238 case USING_DECL:
1239 pp_cxx_ws_string (pp, "using");
1240 dump_type (pp, USING_DECL_SCOPE (t), flags);
1241 pp_cxx_colon_colon (pp);
1242 dump_decl (pp, DECL_NAME (t), flags);
1243 break;
1244
1245 case STATIC_ASSERT:
1246 pp->declaration (t);
1247 break;
1248
1249 case BASELINK:
1250 dump_decl (pp, BASELINK_FUNCTIONS (t), flags);
1251 break;
1252
1253 case NON_DEPENDENT_EXPR:
1254 dump_expr (pp, t, flags);
1255 break;
1256
1257 case TEMPLATE_TYPE_PARM:
1258 if (flags & TFF_DECL_SPECIFIERS)
1259 pp->declaration (t);
1260 else
1261 pp->type_id (t);
1262 break;
1263
1264 case UNBOUND_CLASS_TEMPLATE:
1265 case TYPE_PACK_EXPANSION:
1266 case TREE_BINFO:
1267 dump_type (pp, t, flags);
1268 break;
1269
1270 default:
1271 pp_unsupported_tree (pp, t);
1272 /* Fall through to error. */
1273
1274 case ERROR_MARK:
1275 pp_string (pp, M_("<declaration error>"));
1276 break;
1277 }
1278 }
1279
1280 /* Dump a template declaration T under control of FLAGS. This means the
1281 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1282
1283 static void
1284 dump_template_decl (cxx_pretty_printer *pp, tree t, int flags)
1285 {
1286 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1287 tree parms;
1288 int i;
1289
1290 if (flags & TFF_TEMPLATE_HEADER)
1291 {
1292 for (parms = orig_parms = nreverse (orig_parms);
1293 parms;
1294 parms = TREE_CHAIN (parms))
1295 {
1296 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1297 int len = TREE_VEC_LENGTH (inner_parms);
1298
1299 pp_cxx_ws_string (pp, "template");
1300 pp_cxx_begin_template_argument_list (pp);
1301
1302 /* If we've shown the template prefix, we'd better show the
1303 parameters' and decl's type too. */
1304 flags |= TFF_DECL_SPECIFIERS;
1305
1306 for (i = 0; i < len; i++)
1307 {
1308 if (i)
1309 pp_separate_with_comma (pp);
1310 dump_template_parameter (pp, TREE_VEC_ELT (inner_parms, i),
1311 flags);
1312 }
1313 pp_cxx_end_template_argument_list (pp);
1314 pp_cxx_whitespace (pp);
1315 }
1316 nreverse(orig_parms);
1317
1318 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1319 {
1320 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1321 pp_cxx_ws_string (pp, "class");
1322
1323 /* If this is a parameter pack, print the ellipsis. */
1324 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1325 pp_cxx_ws_string (pp, "...");
1326 }
1327 }
1328
1329 if (DECL_CLASS_TEMPLATE_P (t))
1330 dump_type (pp, TREE_TYPE (t),
1331 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1332 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1333 else if (DECL_TEMPLATE_RESULT (t)
1334 && (VAR_P (DECL_TEMPLATE_RESULT (t))
1335 /* Alias template. */
1336 || DECL_TYPE_TEMPLATE_P (t)))
1337 dump_decl (pp, DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1338 else
1339 {
1340 gcc_assert (TREE_TYPE (t));
1341 switch (NEXT_CODE (t))
1342 {
1343 case METHOD_TYPE:
1344 case FUNCTION_TYPE:
1345 dump_function_decl (pp, t, flags | TFF_TEMPLATE_NAME);
1346 break;
1347 default:
1348 /* This case can occur with some invalid code. */
1349 dump_type (pp, TREE_TYPE (t),
1350 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1351 | (flags & TFF_DECL_SPECIFIERS
1352 ? TFF_CLASS_KEY_OR_ENUM : 0));
1353 }
1354 }
1355 }
1356
1357 /* find_typenames looks through the type of the function template T
1358 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1359 it finds. */
1360
1361 struct find_typenames_t
1362 {
1363 hash_set<tree> *p_set;
1364 vec<tree, va_gc> *typenames;
1365 };
1366
1367 static tree
1368 find_typenames_r (tree *tp, int *walk_subtrees, void *data)
1369 {
1370 struct find_typenames_t *d = (struct find_typenames_t *)data;
1371 tree mv = NULL_TREE;
1372
1373 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1374 /* Add the type of the typedef without any additional cv-quals. */
1375 mv = TREE_TYPE (TYPE_NAME (*tp));
1376 else if (TREE_CODE (*tp) == TYPENAME_TYPE
1377 || TREE_CODE (*tp) == DECLTYPE_TYPE)
1378 /* Add the typename without any cv-qualifiers. */
1379 mv = TYPE_MAIN_VARIANT (*tp);
1380
1381 if (TREE_CODE (*tp) == TYPE_PACK_EXPANSION)
1382 {
1383 /* Don't mess with parameter packs since we don't remember
1384 the pack expansion context for a particular typename. */
1385 *walk_subtrees = false;
1386 return NULL_TREE;
1387 }
1388
1389 if (mv && (mv == *tp || !d->p_set->add (mv)))
1390 vec_safe_push (d->typenames, mv);
1391
1392 /* Search into class template arguments, which cp_walk_subtrees
1393 doesn't do. */
1394 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1395 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1396 data, d->p_set);
1397
1398 return NULL_TREE;
1399 }
1400
1401 static vec<tree, va_gc> *
1402 find_typenames (tree t)
1403 {
1404 struct find_typenames_t ft;
1405 ft.p_set = new hash_set<tree>;
1406 ft.typenames = NULL;
1407 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1408 find_typenames_r, &ft, ft.p_set);
1409 delete ft.p_set;
1410 return ft.typenames;
1411 }
1412
1413 /* Output the "[with ...]" clause for a template instantiation T iff
1414 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1415 formatting a deduction/substitution diagnostic rather than an
1416 instantiation. */
1417
1418 static void
1419 dump_substitution (cxx_pretty_printer *pp,
1420 tree t, tree template_parms, tree template_args,
1421 int flags)
1422 {
1423 if (template_parms != NULL_TREE && template_args != NULL_TREE
1424 && !(flags & TFF_NO_TEMPLATE_BINDINGS))
1425 {
1426 vec<tree, va_gc> *typenames = t ? find_typenames (t) : NULL;
1427 pp_cxx_whitespace (pp);
1428 pp_cxx_left_bracket (pp);
1429 pp->translate_string ("with");
1430 pp_cxx_whitespace (pp);
1431 dump_template_bindings (pp, template_parms, template_args, typenames);
1432 pp_cxx_right_bracket (pp);
1433 }
1434 }
1435
1436 /* Dump the lambda function FN including its 'mutable' qualifier and any
1437 template bindings. */
1438
1439 static void
1440 dump_lambda_function (cxx_pretty_printer *pp,
1441 tree fn, tree template_parms, tree template_args,
1442 int flags)
1443 {
1444 /* A lambda's signature is essentially its "type". */
1445 dump_type (pp, DECL_CONTEXT (fn), flags);
1446 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn))) & TYPE_QUAL_CONST))
1447 {
1448 pp->padding = pp_before;
1449 pp_c_ws_string (pp, "mutable");
1450 }
1451 dump_substitution (pp, fn, template_parms, template_args, flags);
1452 }
1453
1454 /* Pretty print a function decl. There are several ways we want to print a
1455 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1456 As error can only apply the '#' flag once to give 0 and 1 for V, there
1457 is %D which doesn't print the throw specs, and %F which does. */
1458
1459 static void
1460 dump_function_decl (cxx_pretty_printer *pp, tree t, int flags)
1461 {
1462 tree fntype;
1463 tree parmtypes;
1464 tree cname = NULL_TREE;
1465 tree template_args = NULL_TREE;
1466 tree template_parms = NULL_TREE;
1467 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1468 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1469 tree exceptions;
1470
1471 flags &= ~(TFF_UNQUALIFIED_NAME | TFF_TEMPLATE_NAME);
1472 if (TREE_CODE (t) == TEMPLATE_DECL)
1473 t = DECL_TEMPLATE_RESULT (t);
1474
1475 /* Save the exceptions, in case t is a specialization and we are
1476 emitting an error about incompatible specifications. */
1477 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1478
1479 /* Pretty print template instantiations only. */
1480 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1481 && flag_pretty_templates)
1482 {
1483 tree tmpl;
1484
1485 template_args = DECL_TI_ARGS (t);
1486 tmpl = most_general_template (t);
1487 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1488 {
1489 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1490 t = tmpl;
1491 }
1492 }
1493
1494 if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t))
1495 return dump_lambda_function (pp, t, template_parms, template_args, flags);
1496
1497 fntype = TREE_TYPE (t);
1498 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1499
1500 if (DECL_CLASS_SCOPE_P (t))
1501 cname = DECL_CONTEXT (t);
1502 /* This is for partially instantiated template methods. */
1503 else if (TREE_CODE (fntype) == METHOD_TYPE)
1504 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1505
1506 if (flags & TFF_DECL_SPECIFIERS)
1507 {
1508 if (DECL_STATIC_FUNCTION_P (t))
1509 pp_cxx_ws_string (pp, "static");
1510 else if (DECL_VIRTUAL_P (t))
1511 pp_cxx_ws_string (pp, "virtual");
1512
1513 if (DECL_DECLARED_CONSTEXPR_P (t))
1514 pp_cxx_ws_string (pp, "constexpr");
1515 }
1516
1517 /* Print the return type? */
1518 if (show_return)
1519 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1520 && !DECL_DESTRUCTOR_P (t);
1521 if (show_return)
1522 {
1523 tree ret = fndecl_declared_return_type (t);
1524 dump_type_prefix (pp, ret, flags);
1525 }
1526
1527 /* Print the function name. */
1528 if (!do_outer_scope)
1529 /* Nothing. */;
1530 else if (cname)
1531 {
1532 dump_type (pp, cname, flags);
1533 pp_cxx_colon_colon (pp);
1534 }
1535 else
1536 dump_scope (pp, CP_DECL_CONTEXT (t), flags);
1537
1538 dump_function_name (pp, t, flags);
1539
1540 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1541 {
1542 dump_parameters (pp, parmtypes, flags);
1543
1544 if (TREE_CODE (fntype) == METHOD_TYPE)
1545 {
1546 pp->padding = pp_before;
1547 pp_cxx_cv_qualifier_seq (pp, class_of_this_parm (fntype));
1548 dump_ref_qualifier (pp, fntype, flags);
1549 }
1550
1551 if (flags & TFF_EXCEPTION_SPECIFICATION)
1552 {
1553 pp->padding = pp_before;
1554 dump_exception_spec (pp, exceptions, flags);
1555 }
1556
1557 if (show_return)
1558 dump_type_suffix (pp, TREE_TYPE (fntype), flags);
1559
1560 dump_substitution (pp, t, template_parms, template_args, flags);
1561 }
1562 else if (template_args)
1563 {
1564 bool need_comma = false;
1565 int i;
1566 pp_cxx_begin_template_argument_list (pp);
1567 template_args = INNERMOST_TEMPLATE_ARGS (template_args);
1568 for (i = 0; i < TREE_VEC_LENGTH (template_args); ++i)
1569 {
1570 tree arg = TREE_VEC_ELT (template_args, i);
1571 if (need_comma)
1572 pp_separate_with_comma (pp);
1573 if (ARGUMENT_PACK_P (arg))
1574 pp_cxx_left_brace (pp);
1575 dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER);
1576 if (ARGUMENT_PACK_P (arg))
1577 pp_cxx_right_brace (pp);
1578 need_comma = true;
1579 }
1580 pp_cxx_end_template_argument_list (pp);
1581 }
1582 }
1583
1584 /* Print a parameter list. If this is for a member function, the
1585 member object ptr (and any other hidden args) should have
1586 already been removed. */
1587
1588 static void
1589 dump_parameters (cxx_pretty_printer *pp, tree parmtypes, int flags)
1590 {
1591 int first = 1;
1592 flags &= ~TFF_SCOPE;
1593 pp_cxx_left_paren (pp);
1594
1595 for (first = 1; parmtypes != void_list_node;
1596 parmtypes = TREE_CHAIN (parmtypes))
1597 {
1598 if (!first)
1599 pp_separate_with_comma (pp);
1600 first = 0;
1601 if (!parmtypes)
1602 {
1603 pp_cxx_ws_string (pp, "...");
1604 break;
1605 }
1606
1607 dump_type (pp, TREE_VALUE (parmtypes), flags);
1608
1609 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1610 {
1611 pp_cxx_whitespace (pp);
1612 pp_equal (pp);
1613 pp_cxx_whitespace (pp);
1614 dump_expr (pp, TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1615 }
1616 }
1617
1618 pp_cxx_right_paren (pp);
1619 }
1620
1621 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1622
1623 static void
1624 dump_ref_qualifier (cxx_pretty_printer *pp, tree t, int flags ATTRIBUTE_UNUSED)
1625 {
1626 if (FUNCTION_REF_QUALIFIED (t))
1627 {
1628 pp->padding = pp_before;
1629 if (FUNCTION_RVALUE_QUALIFIED (t))
1630 pp_cxx_ws_string (pp, "&&");
1631 else
1632 pp_cxx_ws_string (pp, "&");
1633 }
1634 }
1635
1636 /* Print an exception specification. T is the exception specification. */
1637
1638 static void
1639 dump_exception_spec (cxx_pretty_printer *pp, tree t, int flags)
1640 {
1641 if (t && TREE_PURPOSE (t))
1642 {
1643 pp_cxx_ws_string (pp, "noexcept");
1644 if (!integer_onep (TREE_PURPOSE (t)))
1645 {
1646 pp_cxx_whitespace (pp);
1647 pp_cxx_left_paren (pp);
1648 if (DEFERRED_NOEXCEPT_SPEC_P (t))
1649 pp_cxx_ws_string (pp, "<uninstantiated>");
1650 else
1651 dump_expr (pp, TREE_PURPOSE (t), flags);
1652 pp_cxx_right_paren (pp);
1653 }
1654 }
1655 else if (t)
1656 {
1657 pp_cxx_ws_string (pp, "throw");
1658 pp_cxx_whitespace (pp);
1659 pp_cxx_left_paren (pp);
1660 if (TREE_VALUE (t) != NULL_TREE)
1661 while (1)
1662 {
1663 dump_type (pp, TREE_VALUE (t), flags);
1664 t = TREE_CHAIN (t);
1665 if (!t)
1666 break;
1667 pp_separate_with_comma (pp);
1668 }
1669 pp_cxx_right_paren (pp);
1670 }
1671 }
1672
1673 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1674 and destructors properly. */
1675
1676 static void
1677 dump_function_name (cxx_pretty_printer *pp, tree t, int flags)
1678 {
1679 tree name = DECL_NAME (t);
1680
1681 /* We can get here with a decl that was synthesized by language-
1682 independent machinery (e.g. coverage.c) in which case it won't
1683 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1684 will crash. In this case it is safe just to print out the
1685 literal name. */
1686 if (!DECL_LANG_SPECIFIC (t))
1687 {
1688 pp_cxx_tree_identifier (pp, name);
1689 return;
1690 }
1691
1692 if (TREE_CODE (t) == TEMPLATE_DECL)
1693 t = DECL_TEMPLATE_RESULT (t);
1694
1695 /* Don't let the user see __comp_ctor et al. */
1696 if (DECL_CONSTRUCTOR_P (t)
1697 || DECL_DESTRUCTOR_P (t))
1698 {
1699 if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
1700 name = get_identifier ("<lambda>");
1701 else if (TYPE_ANONYMOUS_P (DECL_CONTEXT (t)))
1702 name = get_identifier ("<constructor>");
1703 else
1704 name = constructor_name (DECL_CONTEXT (t));
1705 }
1706
1707 if (DECL_DESTRUCTOR_P (t))
1708 {
1709 pp_cxx_complement (pp);
1710 dump_decl (pp, name, TFF_PLAIN_IDENTIFIER);
1711 }
1712 else if (DECL_CONV_FN_P (t))
1713 {
1714 /* This cannot use the hack that the operator's return
1715 type is stashed off of its name because it may be
1716 used for error reporting. In the case of conflicting
1717 declarations, both will have the same name, yet
1718 the types will be different, hence the TREE_TYPE field
1719 of the first name will be clobbered by the second. */
1720 pp_cxx_ws_string (pp, "operator");
1721 dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
1722 }
1723 else if (name && IDENTIFIER_OPNAME_P (name))
1724 pp_cxx_tree_identifier (pp, name);
1725 else if (name && UDLIT_OPER_P (name))
1726 pp_cxx_tree_identifier (pp, name);
1727 else
1728 dump_decl (pp, name, flags);
1729
1730 if (DECL_TEMPLATE_INFO (t)
1731 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1732 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1733 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1734 dump_template_parms (pp, DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t),
1735 flags);
1736 }
1737
1738 /* Dump the template parameters from the template info INFO under control of
1739 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1740 specialization (partial or complete). For partial specializations we show
1741 the specialized parameter values. For a primary template we show no
1742 decoration. */
1743
1744 static void
1745 dump_template_parms (cxx_pretty_printer *pp, tree info,
1746 int primary, int flags)
1747 {
1748 tree args = info ? TI_ARGS (info) : NULL_TREE;
1749
1750 if (primary && flags & TFF_TEMPLATE_NAME)
1751 return;
1752 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1753 pp_cxx_begin_template_argument_list (pp);
1754
1755 /* Be careful only to print things when we have them, so as not
1756 to crash producing error messages. */
1757 if (args && !primary)
1758 {
1759 int len, ix;
1760 len = get_non_default_template_args_count (args, flags);
1761
1762 args = INNERMOST_TEMPLATE_ARGS (args);
1763 for (ix = 0; ix != len; ix++)
1764 {
1765 tree arg = TREE_VEC_ELT (args, ix);
1766
1767 /* Only print a comma if we know there is an argument coming. In
1768 the case of an empty template argument pack, no actual
1769 argument will be printed. */
1770 if (ix
1771 && (!ARGUMENT_PACK_P (arg)
1772 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1773 pp_separate_with_comma (pp);
1774
1775 if (!arg)
1776 pp_string (pp, M_("<template parameter error>"));
1777 else
1778 dump_template_argument (pp, arg, flags);
1779 }
1780 }
1781 else if (primary)
1782 {
1783 tree tpl = TI_TEMPLATE (info);
1784 tree parms = DECL_TEMPLATE_PARMS (tpl);
1785 int len, ix;
1786
1787 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1788 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1789
1790 for (ix = 0; ix != len; ix++)
1791 {
1792 tree parm;
1793
1794 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1795 {
1796 pp_string (pp, M_("<template parameter error>"));
1797 continue;
1798 }
1799
1800 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1801
1802 if (ix)
1803 pp_separate_with_comma (pp);
1804
1805 dump_decl (pp, parm, flags & ~TFF_DECL_SPECIFIERS);
1806 }
1807 }
1808 pp_cxx_end_template_argument_list (pp);
1809 }
1810
1811 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1812 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1813
1814 static void
1815 dump_call_expr_args (cxx_pretty_printer *pp, tree t, int flags, bool skipfirst)
1816 {
1817 tree arg;
1818 call_expr_arg_iterator iter;
1819
1820 pp_cxx_left_paren (pp);
1821 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1822 {
1823 if (skipfirst)
1824 skipfirst = false;
1825 else
1826 {
1827 dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
1828 if (more_call_expr_args_p (&iter))
1829 pp_separate_with_comma (pp);
1830 }
1831 }
1832 pp_cxx_right_paren (pp);
1833 }
1834
1835 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1836 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1837 true. */
1838
1839 static void
1840 dump_aggr_init_expr_args (cxx_pretty_printer *pp, tree t, int flags,
1841 bool skipfirst)
1842 {
1843 tree arg;
1844 aggr_init_expr_arg_iterator iter;
1845
1846 pp_cxx_left_paren (pp);
1847 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1848 {
1849 if (skipfirst)
1850 skipfirst = false;
1851 else
1852 {
1853 dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
1854 if (more_aggr_init_expr_args_p (&iter))
1855 pp_separate_with_comma (pp);
1856 }
1857 }
1858 pp_cxx_right_paren (pp);
1859 }
1860
1861 /* Print out a list of initializers (subr of dump_expr). */
1862
1863 static void
1864 dump_expr_list (cxx_pretty_printer *pp, tree l, int flags)
1865 {
1866 while (l)
1867 {
1868 dump_expr (pp, TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1869 l = TREE_CHAIN (l);
1870 if (l)
1871 pp_separate_with_comma (pp);
1872 }
1873 }
1874
1875 /* Print out a vector of initializers (subr of dump_expr). */
1876
1877 static void
1878 dump_expr_init_vec (cxx_pretty_printer *pp, vec<constructor_elt, va_gc> *v,
1879 int flags)
1880 {
1881 unsigned HOST_WIDE_INT idx;
1882 tree value;
1883
1884 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1885 {
1886 dump_expr (pp, value, flags | TFF_EXPR_IN_PARENS);
1887 if (idx != v->length () - 1)
1888 pp_separate_with_comma (pp);
1889 }
1890 }
1891
1892
1893 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1894 function. Resolve it to a close relative -- in the sense of static
1895 type -- variant being overridden. That is close to what was written in
1896 the source code. Subroutine of dump_expr. */
1897
1898 static tree
1899 resolve_virtual_fun_from_obj_type_ref (tree ref)
1900 {
1901 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1902 HOST_WIDE_INT index = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref));
1903 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1904 while (index)
1905 {
1906 fun = TREE_CHAIN (fun);
1907 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1908 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1909 }
1910
1911 return BV_FN (fun);
1912 }
1913
1914 /* Print out an expression E under control of FLAGS. */
1915
1916 static void
1917 dump_expr (cxx_pretty_printer *pp, tree t, int flags)
1918 {
1919 tree op;
1920
1921 if (t == 0)
1922 return;
1923
1924 if (STATEMENT_CLASS_P (t))
1925 {
1926 pp_cxx_ws_string (pp, M_("<statement>"));
1927 return;
1928 }
1929
1930 switch (TREE_CODE (t))
1931 {
1932 case VAR_DECL:
1933 case PARM_DECL:
1934 case FIELD_DECL:
1935 case CONST_DECL:
1936 case FUNCTION_DECL:
1937 case TEMPLATE_DECL:
1938 case NAMESPACE_DECL:
1939 case LABEL_DECL:
1940 case OVERLOAD:
1941 case TYPE_DECL:
1942 case IDENTIFIER_NODE:
1943 dump_decl (pp, t, ((flags & ~(TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE
1944 |TFF_TEMPLATE_HEADER))
1945 | TFF_NO_FUNCTION_ARGUMENTS));
1946 break;
1947
1948 case SSA_NAME:
1949 if (SSA_NAME_VAR (t)
1950 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t)))
1951 dump_expr (pp, SSA_NAME_VAR (t), flags);
1952 else
1953 pp_cxx_ws_string (pp, M_("<unknown>"));
1954 break;
1955
1956 case VOID_CST:
1957 case INTEGER_CST:
1958 case REAL_CST:
1959 case STRING_CST:
1960 case COMPLEX_CST:
1961 pp->constant (t);
1962 break;
1963
1964 case USERDEF_LITERAL:
1965 pp_cxx_userdef_literal (pp, t);
1966 break;
1967
1968 case THROW_EXPR:
1969 /* While waiting for caret diagnostics, avoid printing
1970 __cxa_allocate_exception, __cxa_throw, and the like. */
1971 pp_cxx_ws_string (pp, M_("<throw-expression>"));
1972 break;
1973
1974 case PTRMEM_CST:
1975 pp_ampersand (pp);
1976 dump_type (pp, PTRMEM_CST_CLASS (t), flags);
1977 pp_cxx_colon_colon (pp);
1978 pp_cxx_tree_identifier (pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1979 break;
1980
1981 case COMPOUND_EXPR:
1982 pp_cxx_left_paren (pp);
1983 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1984 pp_separate_with_comma (pp);
1985 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1986 pp_cxx_right_paren (pp);
1987 break;
1988
1989 case COND_EXPR:
1990 pp_cxx_left_paren (pp);
1991 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1992 pp_string (pp, " ? ");
1993 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1994 pp_string (pp, " : ");
1995 dump_expr (pp, TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1996 pp_cxx_right_paren (pp);
1997 break;
1998
1999 case SAVE_EXPR:
2000 if (TREE_HAS_CONSTRUCTOR (t))
2001 {
2002 pp_cxx_ws_string (pp, "new");
2003 pp_cxx_whitespace (pp);
2004 dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
2005 }
2006 else
2007 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2008 break;
2009
2010 case AGGR_INIT_EXPR:
2011 {
2012 tree fn = NULL_TREE;
2013
2014 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
2015 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
2016
2017 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
2018 {
2019 if (DECL_CONSTRUCTOR_P (fn))
2020 dump_type (pp, DECL_CONTEXT (fn), flags);
2021 else
2022 dump_decl (pp, fn, 0);
2023 }
2024 else
2025 dump_expr (pp, AGGR_INIT_EXPR_FN (t), 0);
2026 }
2027 dump_aggr_init_expr_args (pp, t, flags, true);
2028 break;
2029
2030 case CALL_EXPR:
2031 {
2032 tree fn = CALL_EXPR_FN (t);
2033 bool skipfirst = false;
2034
2035 /* Deal with internal functions. */
2036 if (fn == NULL_TREE)
2037 {
2038 pp_string (pp, internal_fn_name (CALL_EXPR_IFN (t)));
2039 dump_call_expr_args (pp, t, flags, skipfirst);
2040 break;
2041 }
2042
2043 if (TREE_CODE (fn) == ADDR_EXPR)
2044 fn = TREE_OPERAND (fn, 0);
2045
2046 /* Nobody is interested in seeing the guts of vcalls. */
2047 if (TREE_CODE (fn) == OBJ_TYPE_REF)
2048 fn = resolve_virtual_fun_from_obj_type_ref (fn);
2049
2050 if (TREE_TYPE (fn) != NULL_TREE
2051 && NEXT_CODE (fn) == METHOD_TYPE
2052 && call_expr_nargs (t))
2053 {
2054 tree ob = CALL_EXPR_ARG (t, 0);
2055 if (TREE_CODE (ob) == ADDR_EXPR)
2056 {
2057 dump_expr (pp, TREE_OPERAND (ob, 0),
2058 flags | TFF_EXPR_IN_PARENS);
2059 pp_cxx_dot (pp);
2060 }
2061 else if (TREE_CODE (ob) != PARM_DECL
2062 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
2063 {
2064 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2065 pp_cxx_arrow (pp);
2066 }
2067 skipfirst = true;
2068 }
2069 if (flag_sanitize & SANITIZE_UNDEFINED
2070 && is_ubsan_builtin_p (fn))
2071 {
2072 pp_string (cxx_pp, M_("<ubsan routine call>"));
2073 break;
2074 }
2075 dump_expr (pp, fn, flags | TFF_EXPR_IN_PARENS);
2076 dump_call_expr_args (pp, t, flags, skipfirst);
2077 }
2078 break;
2079
2080 case TARGET_EXPR:
2081 /* Note that this only works for G++ target exprs. If somebody
2082 builds a general TARGET_EXPR, there's no way to represent that
2083 it initializes anything other that the parameter slot for the
2084 default argument. Note we may have cleared out the first
2085 operand in expand_expr, so don't go killing ourselves. */
2086 if (TREE_OPERAND (t, 1))
2087 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2088 break;
2089
2090 case POINTER_PLUS_EXPR:
2091 dump_binary_op (pp, "+", t, flags);
2092 break;
2093
2094 case INIT_EXPR:
2095 case MODIFY_EXPR:
2096 dump_binary_op (pp, assignment_operator_name_info[NOP_EXPR].name,
2097 t, flags);
2098 break;
2099
2100 case PLUS_EXPR:
2101 case MINUS_EXPR:
2102 case MULT_EXPR:
2103 case TRUNC_DIV_EXPR:
2104 case TRUNC_MOD_EXPR:
2105 case MIN_EXPR:
2106 case MAX_EXPR:
2107 case LSHIFT_EXPR:
2108 case RSHIFT_EXPR:
2109 case BIT_IOR_EXPR:
2110 case BIT_XOR_EXPR:
2111 case BIT_AND_EXPR:
2112 case TRUTH_ANDIF_EXPR:
2113 case TRUTH_ORIF_EXPR:
2114 case LT_EXPR:
2115 case LE_EXPR:
2116 case GT_EXPR:
2117 case GE_EXPR:
2118 case EQ_EXPR:
2119 case NE_EXPR:
2120 case EXACT_DIV_EXPR:
2121 dump_binary_op (pp, operator_name_info[TREE_CODE (t)].name, t, flags);
2122 break;
2123
2124 case CEIL_DIV_EXPR:
2125 case FLOOR_DIV_EXPR:
2126 case ROUND_DIV_EXPR:
2127 case RDIV_EXPR:
2128 dump_binary_op (pp, "/", t, flags);
2129 break;
2130
2131 case CEIL_MOD_EXPR:
2132 case FLOOR_MOD_EXPR:
2133 case ROUND_MOD_EXPR:
2134 dump_binary_op (pp, "%", t, flags);
2135 break;
2136
2137 case COMPONENT_REF:
2138 {
2139 tree ob = TREE_OPERAND (t, 0);
2140 if (INDIRECT_REF_P (ob))
2141 {
2142 ob = TREE_OPERAND (ob, 0);
2143 if (TREE_CODE (ob) != PARM_DECL
2144 || (DECL_NAME (ob)
2145 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
2146 {
2147 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2148 if (TREE_CODE (TREE_TYPE (ob)) == REFERENCE_TYPE)
2149 pp_cxx_dot (pp);
2150 else
2151 pp_cxx_arrow (pp);
2152 }
2153 }
2154 else
2155 {
2156 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2157 pp_cxx_dot (pp);
2158 }
2159 dump_expr (pp, TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
2160 }
2161 break;
2162
2163 case ARRAY_REF:
2164 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2165 pp_cxx_left_bracket (pp);
2166 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2167 pp_cxx_right_bracket (pp);
2168 break;
2169
2170 case ARRAY_NOTATION_REF:
2171 dump_expr (pp, ARRAY_NOTATION_ARRAY (t), flags | TFF_EXPR_IN_PARENS);
2172 pp_cxx_left_bracket (pp);
2173 dump_expr (pp, ARRAY_NOTATION_START (t), flags | TFF_EXPR_IN_PARENS);
2174 pp_colon (pp);
2175 dump_expr (pp, ARRAY_NOTATION_LENGTH (t), flags | TFF_EXPR_IN_PARENS);
2176 pp_colon (pp);
2177 dump_expr (pp, ARRAY_NOTATION_STRIDE (t), flags | TFF_EXPR_IN_PARENS);
2178 pp_cxx_right_bracket (pp);
2179 break;
2180
2181 case UNARY_PLUS_EXPR:
2182 dump_unary_op (pp, "+", t, flags);
2183 break;
2184
2185 case ADDR_EXPR:
2186 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
2187 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
2188 /* An ADDR_EXPR can have reference type. In that case, we
2189 shouldn't print the `&' doing so indicates to the user
2190 that the expression has pointer type. */
2191 || (TREE_TYPE (t)
2192 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
2193 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2194 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
2195 dump_unary_op (pp, "&&", t, flags);
2196 else
2197 dump_unary_op (pp, "&", t, flags);
2198 break;
2199
2200 case INDIRECT_REF:
2201 if (TREE_HAS_CONSTRUCTOR (t))
2202 {
2203 t = TREE_OPERAND (t, 0);
2204 gcc_assert (TREE_CODE (t) == CALL_EXPR);
2205 dump_expr (pp, CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
2206 dump_call_expr_args (pp, t, flags, true);
2207 }
2208 else
2209 {
2210 if (TREE_OPERAND (t,0) != NULL_TREE
2211 && TREE_TYPE (TREE_OPERAND (t, 0))
2212 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
2213 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2214 else
2215 dump_unary_op (pp, "*", t, flags);
2216 }
2217 break;
2218
2219 case MEM_REF:
2220 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
2221 && integer_zerop (TREE_OPERAND (t, 1)))
2222 dump_expr (pp, TREE_OPERAND (TREE_OPERAND (t, 0), 0), flags);
2223 else
2224 {
2225 pp_cxx_star (pp);
2226 if (!integer_zerop (TREE_OPERAND (t, 1)))
2227 {
2228 pp_cxx_left_paren (pp);
2229 if (!integer_onep (TYPE_SIZE_UNIT
2230 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))))))
2231 {
2232 pp_cxx_left_paren (pp);
2233 dump_type (pp, ptr_type_node, flags);
2234 pp_cxx_right_paren (pp);
2235 }
2236 }
2237 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2238 if (!integer_zerop (TREE_OPERAND (t, 1)))
2239 {
2240 pp_cxx_ws_string (pp, "+");
2241 dump_expr (pp, fold_convert (ssizetype, TREE_OPERAND (t, 1)),
2242 flags);
2243 pp_cxx_right_paren (pp);
2244 }
2245 }
2246 break;
2247
2248 case NEGATE_EXPR:
2249 case BIT_NOT_EXPR:
2250 case TRUTH_NOT_EXPR:
2251 case PREDECREMENT_EXPR:
2252 case PREINCREMENT_EXPR:
2253 dump_unary_op (pp, operator_name_info [TREE_CODE (t)].name, t, flags);
2254 break;
2255
2256 case POSTDECREMENT_EXPR:
2257 case POSTINCREMENT_EXPR:
2258 pp_cxx_left_paren (pp);
2259 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2260 pp_cxx_ws_string (pp, operator_name_info[TREE_CODE (t)].name);
2261 pp_cxx_right_paren (pp);
2262 break;
2263
2264 case NON_LVALUE_EXPR:
2265 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2266 should be another level of INDIRECT_REF so that I don't have to do
2267 this. */
2268 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
2269 {
2270 tree next = TREE_TYPE (TREE_TYPE (t));
2271
2272 while (TYPE_PTR_P (next))
2273 next = TREE_TYPE (next);
2274
2275 if (TREE_CODE (next) == FUNCTION_TYPE)
2276 {
2277 if (flags & TFF_EXPR_IN_PARENS)
2278 pp_cxx_left_paren (pp);
2279 pp_cxx_star (pp);
2280 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2281 if (flags & TFF_EXPR_IN_PARENS)
2282 pp_cxx_right_paren (pp);
2283 break;
2284 }
2285 /* Else fall through. */
2286 }
2287 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2288 break;
2289
2290 CASE_CONVERT:
2291 case IMPLICIT_CONV_EXPR:
2292 case VIEW_CONVERT_EXPR:
2293 {
2294 tree op = TREE_OPERAND (t, 0);
2295 tree ttype = TREE_TYPE (t);
2296 tree optype = TREE_TYPE (op);
2297
2298 if (TREE_CODE (ttype) != TREE_CODE (optype)
2299 && POINTER_TYPE_P (ttype)
2300 && POINTER_TYPE_P (optype)
2301 && same_type_p (TREE_TYPE (optype),
2302 TREE_TYPE (ttype)))
2303 {
2304 if (TREE_CODE (ttype) == REFERENCE_TYPE)
2305 {
2306 STRIP_NOPS (op);
2307 if (TREE_CODE (op) == ADDR_EXPR)
2308 dump_expr (pp, TREE_OPERAND (op, 0), flags);
2309 else
2310 dump_unary_op (pp, "*", t, flags);
2311 }
2312 else
2313 dump_unary_op (pp, "&", t, flags);
2314 }
2315 else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
2316 {
2317 /* It is a cast, but we cannot tell whether it is a
2318 reinterpret or static cast. Use the C style notation. */
2319 if (flags & TFF_EXPR_IN_PARENS)
2320 pp_cxx_left_paren (pp);
2321 pp_cxx_left_paren (pp);
2322 dump_type (pp, TREE_TYPE (t), flags);
2323 pp_cxx_right_paren (pp);
2324 dump_expr (pp, op, flags | TFF_EXPR_IN_PARENS);
2325 if (flags & TFF_EXPR_IN_PARENS)
2326 pp_cxx_right_paren (pp);
2327 }
2328 else
2329 dump_expr (pp, op, flags);
2330 break;
2331 }
2332
2333 case CONSTRUCTOR:
2334 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2335 {
2336 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
2337
2338 if (integer_zerop (idx))
2339 {
2340 /* A NULL pointer-to-member constant. */
2341 pp_cxx_left_paren (pp);
2342 pp_cxx_left_paren (pp);
2343 dump_type (pp, TREE_TYPE (t), flags);
2344 pp_cxx_right_paren (pp);
2345 pp_character (pp, '0');
2346 pp_cxx_right_paren (pp);
2347 break;
2348 }
2349 else if (tree_fits_shwi_p (idx))
2350 {
2351 tree virtuals;
2352 unsigned HOST_WIDE_INT n;
2353
2354 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
2355 t = TYPE_METHOD_BASETYPE (t);
2356 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
2357
2358 n = tree_to_shwi (idx);
2359
2360 /* Map vtable index back one, to allow for the null pointer to
2361 member. */
2362 --n;
2363
2364 while (n > 0 && virtuals)
2365 {
2366 --n;
2367 virtuals = TREE_CHAIN (virtuals);
2368 }
2369 if (virtuals)
2370 {
2371 dump_expr (pp, BV_FN (virtuals),
2372 flags | TFF_EXPR_IN_PARENS);
2373 break;
2374 }
2375 }
2376 }
2377 if (TREE_TYPE (t) && LAMBDA_TYPE_P (TREE_TYPE (t)))
2378 pp_string (pp, "<lambda closure object>");
2379 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
2380 {
2381 dump_type (pp, TREE_TYPE (t), 0);
2382 pp_cxx_left_paren (pp);
2383 pp_cxx_right_paren (pp);
2384 }
2385 else
2386 {
2387 if (!BRACE_ENCLOSED_INITIALIZER_P (t))
2388 dump_type (pp, TREE_TYPE (t), 0);
2389 pp_cxx_left_brace (pp);
2390 dump_expr_init_vec (pp, CONSTRUCTOR_ELTS (t), flags);
2391 pp_cxx_right_brace (pp);
2392 }
2393
2394 break;
2395
2396 case OFFSET_REF:
2397 {
2398 tree ob = TREE_OPERAND (t, 0);
2399 if (is_dummy_object (ob))
2400 {
2401 t = TREE_OPERAND (t, 1);
2402 if (TREE_CODE (t) == FUNCTION_DECL)
2403 /* A::f */
2404 dump_expr (pp, t, flags | TFF_EXPR_IN_PARENS);
2405 else if (BASELINK_P (t))
2406 dump_expr (pp, OVL_CURRENT (BASELINK_FUNCTIONS (t)),
2407 flags | TFF_EXPR_IN_PARENS);
2408 else
2409 dump_decl (pp, t, flags);
2410 }
2411 else
2412 {
2413 if (INDIRECT_REF_P (ob))
2414 {
2415 dump_expr (pp, TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2416 pp_cxx_arrow (pp);
2417 pp_cxx_star (pp);
2418 }
2419 else
2420 {
2421 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2422 pp_cxx_dot (pp);
2423 pp_cxx_star (pp);
2424 }
2425 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2426 }
2427 break;
2428 }
2429
2430 case TEMPLATE_PARM_INDEX:
2431 dump_decl (pp, TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2432 break;
2433
2434 case CAST_EXPR:
2435 if (TREE_OPERAND (t, 0) == NULL_TREE
2436 || TREE_CHAIN (TREE_OPERAND (t, 0)))
2437 {
2438 dump_type (pp, TREE_TYPE (t), flags);
2439 pp_cxx_left_paren (pp);
2440 dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
2441 pp_cxx_right_paren (pp);
2442 }
2443 else
2444 {
2445 pp_cxx_left_paren (pp);
2446 dump_type (pp, TREE_TYPE (t), flags);
2447 pp_cxx_right_paren (pp);
2448 pp_cxx_left_paren (pp);
2449 dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
2450 pp_cxx_right_paren (pp);
2451 }
2452 break;
2453
2454 case STATIC_CAST_EXPR:
2455 pp_cxx_ws_string (pp, "static_cast");
2456 goto cast;
2457 case REINTERPRET_CAST_EXPR:
2458 pp_cxx_ws_string (pp, "reinterpret_cast");
2459 goto cast;
2460 case CONST_CAST_EXPR:
2461 pp_cxx_ws_string (pp, "const_cast");
2462 goto cast;
2463 case DYNAMIC_CAST_EXPR:
2464 pp_cxx_ws_string (pp, "dynamic_cast");
2465 cast:
2466 pp_cxx_begin_template_argument_list (pp);
2467 dump_type (pp, TREE_TYPE (t), flags);
2468 pp_cxx_end_template_argument_list (pp);
2469 pp_cxx_left_paren (pp);
2470 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2471 pp_cxx_right_paren (pp);
2472 break;
2473
2474 case ARROW_EXPR:
2475 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2476 pp_cxx_arrow (pp);
2477 break;
2478
2479 case SIZEOF_EXPR:
2480 case ALIGNOF_EXPR:
2481 if (TREE_CODE (t) == SIZEOF_EXPR)
2482 pp_cxx_ws_string (pp, "sizeof");
2483 else
2484 {
2485 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2486 pp_cxx_ws_string (pp, "__alignof__");
2487 }
2488 op = TREE_OPERAND (t, 0);
2489 if (PACK_EXPANSION_P (op))
2490 {
2491 pp_string (pp, "...");
2492 op = PACK_EXPANSION_PATTERN (op);
2493 }
2494 pp_cxx_whitespace (pp);
2495 pp_cxx_left_paren (pp);
2496 if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t))
2497 dump_type (pp, TREE_TYPE (op), flags);
2498 else if (TYPE_P (TREE_OPERAND (t, 0)))
2499 dump_type (pp, op, flags);
2500 else
2501 dump_expr (pp, op, flags);
2502 pp_cxx_right_paren (pp);
2503 break;
2504
2505 case AT_ENCODE_EXPR:
2506 pp_cxx_ws_string (pp, "@encode");
2507 pp_cxx_whitespace (pp);
2508 pp_cxx_left_paren (pp);
2509 dump_type (pp, TREE_OPERAND (t, 0), flags);
2510 pp_cxx_right_paren (pp);
2511 break;
2512
2513 case NOEXCEPT_EXPR:
2514 pp_cxx_ws_string (pp, "noexcept");
2515 pp_cxx_whitespace (pp);
2516 pp_cxx_left_paren (pp);
2517 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2518 pp_cxx_right_paren (pp);
2519 break;
2520
2521 case REALPART_EXPR:
2522 case IMAGPART_EXPR:
2523 pp_cxx_ws_string (pp, operator_name_info[TREE_CODE (t)].name);
2524 pp_cxx_whitespace (pp);
2525 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2526 break;
2527
2528 case DEFAULT_ARG:
2529 pp_string (pp, M_("<unparsed>"));
2530 break;
2531
2532 case TRY_CATCH_EXPR:
2533 case WITH_CLEANUP_EXPR:
2534 case CLEANUP_POINT_EXPR:
2535 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2536 break;
2537
2538 case PSEUDO_DTOR_EXPR:
2539 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2540 pp_cxx_dot (pp);
2541 if (TREE_OPERAND (t, 1))
2542 {
2543 dump_type (pp, TREE_OPERAND (t, 1), flags);
2544 pp_cxx_colon_colon (pp);
2545 }
2546 pp_cxx_complement (pp);
2547 dump_type (pp, TREE_OPERAND (t, 2), flags);
2548 break;
2549
2550 case TEMPLATE_ID_EXPR:
2551 dump_decl (pp, t, flags);
2552 break;
2553
2554 case BIND_EXPR:
2555 case STMT_EXPR:
2556 case EXPR_STMT:
2557 case STATEMENT_LIST:
2558 /* We don't yet have a way of dumping statements in a
2559 human-readable format. */
2560 pp_string (pp, "({...})");
2561 break;
2562
2563 case LOOP_EXPR:
2564 pp_string (pp, "while (1) { ");
2565 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2566 pp_cxx_right_brace (pp);
2567 break;
2568
2569 case EXIT_EXPR:
2570 pp_string (pp, "if (");
2571 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2572 pp_string (pp, ") break; ");
2573 break;
2574
2575 case BASELINK:
2576 dump_expr (pp, BASELINK_FUNCTIONS (t), flags & ~TFF_EXPR_IN_PARENS);
2577 break;
2578
2579 case EMPTY_CLASS_EXPR:
2580 dump_type (pp, TREE_TYPE (t), flags);
2581 pp_cxx_left_paren (pp);
2582 pp_cxx_right_paren (pp);
2583 break;
2584
2585 case NON_DEPENDENT_EXPR:
2586 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2587 break;
2588
2589 case ARGUMENT_PACK_SELECT:
2590 dump_template_argument (pp, ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2591 break;
2592
2593 case RECORD_TYPE:
2594 case UNION_TYPE:
2595 case ENUMERAL_TYPE:
2596 case REAL_TYPE:
2597 case VOID_TYPE:
2598 case BOOLEAN_TYPE:
2599 case INTEGER_TYPE:
2600 case COMPLEX_TYPE:
2601 case VECTOR_TYPE:
2602 pp_type_specifier_seq (pp, t);
2603 break;
2604
2605 case TYPENAME_TYPE:
2606 /* We get here when we want to print a dependent type as an
2607 id-expression, without any disambiguator decoration. */
2608 pp->id_expression (t);
2609 break;
2610
2611 case TEMPLATE_TYPE_PARM:
2612 case TEMPLATE_TEMPLATE_PARM:
2613 case BOUND_TEMPLATE_TEMPLATE_PARM:
2614 dump_type (pp, t, flags);
2615 break;
2616
2617 case TRAIT_EXPR:
2618 pp_cxx_trait_expression (pp, t);
2619 break;
2620
2621 case VA_ARG_EXPR:
2622 pp_cxx_va_arg_expression (pp, t);
2623 break;
2624
2625 case OFFSETOF_EXPR:
2626 pp_cxx_offsetof_expression (pp, t);
2627 break;
2628
2629 case SCOPE_REF:
2630 dump_decl (pp, t, flags);
2631 break;
2632
2633 case EXPR_PACK_EXPANSION:
2634 case TYPEID_EXPR:
2635 case MEMBER_REF:
2636 case DOTSTAR_EXPR:
2637 case NEW_EXPR:
2638 case VEC_NEW_EXPR:
2639 case DELETE_EXPR:
2640 case VEC_DELETE_EXPR:
2641 case MODOP_EXPR:
2642 case ABS_EXPR:
2643 case CONJ_EXPR:
2644 case VECTOR_CST:
2645 case FIXED_CST:
2646 case UNORDERED_EXPR:
2647 case ORDERED_EXPR:
2648 case UNLT_EXPR:
2649 case UNLE_EXPR:
2650 case UNGT_EXPR:
2651 case UNGE_EXPR:
2652 case UNEQ_EXPR:
2653 case LTGT_EXPR:
2654 case COMPLEX_EXPR:
2655 case BIT_FIELD_REF:
2656 case FIX_TRUNC_EXPR:
2657 case FLOAT_EXPR:
2658 pp->expression (t);
2659 break;
2660
2661 case TRUTH_AND_EXPR:
2662 case TRUTH_OR_EXPR:
2663 case TRUTH_XOR_EXPR:
2664 if (flags & TFF_EXPR_IN_PARENS)
2665 pp_cxx_left_paren (pp);
2666 pp->expression (t);
2667 if (flags & TFF_EXPR_IN_PARENS)
2668 pp_cxx_right_paren (pp);
2669 break;
2670
2671 case OBJ_TYPE_REF:
2672 dump_expr (pp, resolve_virtual_fun_from_obj_type_ref (t), flags);
2673 break;
2674
2675 case LAMBDA_EXPR:
2676 pp_string (pp, M_("<lambda>"));
2677 break;
2678
2679 case PAREN_EXPR:
2680 pp_cxx_left_paren (pp);
2681 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2682 pp_cxx_right_paren (pp);
2683 break;
2684
2685 case PLACEHOLDER_EXPR:
2686 pp_string (pp, M_("*this"));
2687 break;
2688
2689 /* This list is incomplete, but should suffice for now.
2690 It is very important that `sorry' does not call
2691 `report_error_function'. That could cause an infinite loop. */
2692 default:
2693 pp_unsupported_tree (pp, t);
2694 /* fall through to ERROR_MARK... */
2695 case ERROR_MARK:
2696 pp_string (pp, M_("<expression error>"));
2697 break;
2698 }
2699 }
2700
2701 static void
2702 dump_binary_op (cxx_pretty_printer *pp, const char *opstring, tree t,
2703 int flags)
2704 {
2705 pp_cxx_left_paren (pp);
2706 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2707 pp_cxx_whitespace (pp);
2708 if (opstring)
2709 pp_cxx_ws_string (pp, opstring);
2710 else
2711 pp_string (pp, M_("<unknown operator>"));
2712 pp_cxx_whitespace (pp);
2713 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2714 pp_cxx_right_paren (pp);
2715 }
2716
2717 static void
2718 dump_unary_op (cxx_pretty_printer *pp, const char *opstring, tree t, int flags)
2719 {
2720 if (flags & TFF_EXPR_IN_PARENS)
2721 pp_cxx_left_paren (pp);
2722 pp_cxx_ws_string (pp, opstring);
2723 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2724 if (flags & TFF_EXPR_IN_PARENS)
2725 pp_cxx_right_paren (pp);
2726 }
2727
2728 static void
2729 reinit_cxx_pp (void)
2730 {
2731 pp_clear_output_area (cxx_pp);
2732 cxx_pp->padding = pp_none;
2733 pp_indentation (cxx_pp) = 0;
2734 pp_needs_newline (cxx_pp) = false;
2735 cxx_pp->enclosing_scope = current_function_decl;
2736 }
2737
2738 /* Same as pp_formatted_text, except the return string is a separate
2739 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2740
2741 inline const char *
2742 pp_ggc_formatted_text (pretty_printer *pp)
2743 {
2744 return ggc_strdup (pp_formatted_text (pp));
2745 }
2746
2747 /* Exported interface to stringifying types, exprs and decls under TFF_*
2748 control. */
2749
2750 const char *
2751 type_as_string (tree typ, int flags)
2752 {
2753 reinit_cxx_pp ();
2754 pp_translate_identifiers (cxx_pp) = false;
2755 dump_type (cxx_pp, typ, flags);
2756 return pp_ggc_formatted_text (cxx_pp);
2757 }
2758
2759 const char *
2760 type_as_string_translate (tree typ, int flags)
2761 {
2762 reinit_cxx_pp ();
2763 dump_type (cxx_pp, typ, flags);
2764 return pp_ggc_formatted_text (cxx_pp);
2765 }
2766
2767 const char *
2768 expr_as_string (tree decl, int flags)
2769 {
2770 reinit_cxx_pp ();
2771 pp_translate_identifiers (cxx_pp) = false;
2772 dump_expr (cxx_pp, decl, flags);
2773 return pp_ggc_formatted_text (cxx_pp);
2774 }
2775
2776 /* Wrap decl_as_string with options appropriate for dwarf. */
2777
2778 const char *
2779 decl_as_dwarf_string (tree decl, int flags)
2780 {
2781 const char *name;
2782 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2783 here will be adequate to get the desired behaviour. */
2784 cxx_pp->flags |= pp_c_flag_gnu_v3;
2785 name = decl_as_string (decl, flags);
2786 /* Subsequent calls to the pretty printer shouldn't use this style. */
2787 cxx_pp->flags &= ~pp_c_flag_gnu_v3;
2788 return name;
2789 }
2790
2791 const char *
2792 decl_as_string (tree decl, int flags)
2793 {
2794 reinit_cxx_pp ();
2795 pp_translate_identifiers (cxx_pp) = false;
2796 dump_decl (cxx_pp, decl, flags);
2797 return pp_ggc_formatted_text (cxx_pp);
2798 }
2799
2800 const char *
2801 decl_as_string_translate (tree decl, int flags)
2802 {
2803 reinit_cxx_pp ();
2804 dump_decl (cxx_pp, decl, flags);
2805 return pp_ggc_formatted_text (cxx_pp);
2806 }
2807
2808 /* Wrap lang_decl_name with options appropriate for dwarf. */
2809
2810 const char *
2811 lang_decl_dwarf_name (tree decl, int v, bool translate)
2812 {
2813 const char *name;
2814 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2815 here will be adequate to get the desired behaviour. */
2816 cxx_pp->flags |= pp_c_flag_gnu_v3;
2817 name = lang_decl_name (decl, v, translate);
2818 /* Subsequent calls to the pretty printer shouldn't use this style. */
2819 cxx_pp->flags &= ~pp_c_flag_gnu_v3;
2820 return name;
2821 }
2822
2823 /* Generate the three forms of printable names for cxx_printable_name. */
2824
2825 const char *
2826 lang_decl_name (tree decl, int v, bool translate)
2827 {
2828 if (v >= 2)
2829 return (translate
2830 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2831 : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2832
2833 reinit_cxx_pp ();
2834 pp_translate_identifiers (cxx_pp) = translate;
2835 if (v == 1
2836 && (DECL_CLASS_SCOPE_P (decl)
2837 || (DECL_NAMESPACE_SCOPE_P (decl)
2838 && CP_DECL_CONTEXT (decl) != global_namespace)))
2839 {
2840 dump_type (cxx_pp, CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2841 pp_cxx_colon_colon (cxx_pp);
2842 }
2843
2844 if (TREE_CODE (decl) == FUNCTION_DECL)
2845 dump_function_name (cxx_pp, decl, TFF_PLAIN_IDENTIFIER);
2846 else if ((DECL_NAME (decl) == NULL_TREE)
2847 && TREE_CODE (decl) == NAMESPACE_DECL)
2848 dump_decl (cxx_pp, decl, TFF_PLAIN_IDENTIFIER | TFF_UNQUALIFIED_NAME);
2849 else
2850 dump_decl (cxx_pp, DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2851
2852 return pp_ggc_formatted_text (cxx_pp);
2853 }
2854
2855 /* Return the location of a tree passed to %+ formats. */
2856
2857 location_t
2858 location_of (tree t)
2859 {
2860 if (TYPE_P (t))
2861 {
2862 t = TYPE_MAIN_DECL (t);
2863 if (t == NULL_TREE)
2864 return input_location;
2865 }
2866 else if (TREE_CODE (t) == OVERLOAD)
2867 t = OVL_FUNCTION (t);
2868
2869 if (DECL_P (t))
2870 return DECL_SOURCE_LOCATION (t);
2871 return EXPR_LOC_OR_LOC (t, input_location);
2872 }
2873
2874 /* Now the interfaces from error et al to dump_type et al. Each takes an
2875 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2876 function. */
2877
2878 static const char *
2879 decl_to_string (tree decl, int verbose)
2880 {
2881 int flags = 0;
2882
2883 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2884 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2885 flags = TFF_CLASS_KEY_OR_ENUM;
2886 if (verbose)
2887 flags |= TFF_DECL_SPECIFIERS;
2888 else if (TREE_CODE (decl) == FUNCTION_DECL)
2889 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2890 flags |= TFF_TEMPLATE_HEADER;
2891
2892 reinit_cxx_pp ();
2893 dump_decl (cxx_pp, decl, flags);
2894 return pp_ggc_formatted_text (cxx_pp);
2895 }
2896
2897 static const char *
2898 expr_to_string (tree decl)
2899 {
2900 reinit_cxx_pp ();
2901 dump_expr (cxx_pp, decl, 0);
2902 return pp_ggc_formatted_text (cxx_pp);
2903 }
2904
2905 static const char *
2906 fndecl_to_string (tree fndecl, int verbose)
2907 {
2908 int flags;
2909
2910 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2911 | TFF_TEMPLATE_HEADER;
2912 if (verbose)
2913 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2914 reinit_cxx_pp ();
2915 dump_decl (cxx_pp, fndecl, flags);
2916 return pp_ggc_formatted_text (cxx_pp);
2917 }
2918
2919
2920 static const char *
2921 code_to_string (enum tree_code c)
2922 {
2923 return get_tree_code_name (c);
2924 }
2925
2926 const char *
2927 language_to_string (enum languages c)
2928 {
2929 switch (c)
2930 {
2931 case lang_c:
2932 return "C";
2933
2934 case lang_cplusplus:
2935 return "C++";
2936
2937 case lang_java:
2938 return "Java";
2939
2940 default:
2941 gcc_unreachable ();
2942 }
2943 return NULL;
2944 }
2945
2946 /* Return the proper printed version of a parameter to a C++ function. */
2947
2948 static const char *
2949 parm_to_string (int p)
2950 {
2951 reinit_cxx_pp ();
2952 if (p < 0)
2953 pp_string (cxx_pp, "'this'");
2954 else
2955 pp_decimal_int (cxx_pp, p + 1);
2956 return pp_ggc_formatted_text (cxx_pp);
2957 }
2958
2959 static const char *
2960 op_to_string (enum tree_code p)
2961 {
2962 tree id = operator_name_info[p].identifier;
2963 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
2964 }
2965
2966 static const char *
2967 type_to_string (tree typ, int verbose)
2968 {
2969 int flags = 0;
2970 if (verbose)
2971 flags |= TFF_CLASS_KEY_OR_ENUM;
2972 flags |= TFF_TEMPLATE_HEADER;
2973
2974 reinit_cxx_pp ();
2975 dump_type (cxx_pp, typ, flags);
2976 /* If we're printing a type that involves typedefs, also print the
2977 stripped version. But sometimes the stripped version looks
2978 exactly the same, so we don't want it after all. To avoid printing
2979 it in that case, we play ugly obstack games. */
2980 if (typ && TYPE_P (typ) && typ != TYPE_CANONICAL (typ)
2981 && !uses_template_parms (typ))
2982 {
2983 int aka_start, aka_len; char *p;
2984 struct obstack *ob = pp_buffer (cxx_pp)->obstack;
2985 /* Remember the end of the initial dump. */
2986 int len = obstack_object_size (ob);
2987 tree aka = strip_typedefs (typ);
2988 pp_string (cxx_pp, " {aka");
2989 pp_cxx_whitespace (cxx_pp);
2990 /* And remember the start of the aka dump. */
2991 aka_start = obstack_object_size (ob);
2992 dump_type (cxx_pp, aka, flags);
2993 aka_len = obstack_object_size (ob) - aka_start;
2994 pp_right_brace (cxx_pp);
2995 p = (char*)obstack_base (ob);
2996 /* If they are identical, cut off the aka with a NUL. */
2997 if (len == aka_len && memcmp (p, p+aka_start, len) == 0)
2998 p[len] = '\0';
2999 }
3000 return pp_ggc_formatted_text (cxx_pp);
3001 }
3002
3003 static const char *
3004 assop_to_string (enum tree_code p)
3005 {
3006 tree id = assignment_operator_name_info[(int) p].identifier;
3007 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
3008 }
3009
3010 static const char *
3011 args_to_string (tree p, int verbose)
3012 {
3013 int flags = 0;
3014 if (verbose)
3015 flags |= TFF_CLASS_KEY_OR_ENUM;
3016
3017 if (p == NULL_TREE)
3018 return "";
3019
3020 if (TYPE_P (TREE_VALUE (p)))
3021 return type_as_string_translate (p, flags);
3022
3023 reinit_cxx_pp ();
3024 for (; p; p = TREE_CHAIN (p))
3025 {
3026 if (TREE_VALUE (p) == null_node)
3027 pp_cxx_ws_string (cxx_pp, "NULL");
3028 else
3029 dump_type (cxx_pp, error_type (TREE_VALUE (p)), flags);
3030 if (TREE_CHAIN (p))
3031 pp_separate_with_comma (cxx_pp);
3032 }
3033 return pp_ggc_formatted_text (cxx_pp);
3034 }
3035
3036 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3037 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3038 arguments. */
3039
3040 static const char *
3041 subst_to_string (tree p)
3042 {
3043 tree decl = TREE_PURPOSE (p);
3044 tree targs = TREE_VALUE (p);
3045 tree tparms = DECL_TEMPLATE_PARMS (decl);
3046 int flags = (TFF_DECL_SPECIFIERS|TFF_TEMPLATE_HEADER
3047 |TFF_NO_TEMPLATE_BINDINGS);
3048
3049 if (p == NULL_TREE)
3050 return "";
3051
3052 reinit_cxx_pp ();
3053 dump_template_decl (cxx_pp, TREE_PURPOSE (p), flags);
3054 dump_substitution (cxx_pp, NULL, tparms, targs, /*flags=*/0);
3055 return pp_ggc_formatted_text (cxx_pp);
3056 }
3057
3058 static const char *
3059 cv_to_string (tree p, int v)
3060 {
3061 reinit_cxx_pp ();
3062 cxx_pp->padding = v ? pp_before : pp_none;
3063 pp_cxx_cv_qualifier_seq (cxx_pp, p);
3064 return pp_ggc_formatted_text (cxx_pp);
3065 }
3066
3067 static const char *
3068 eh_spec_to_string (tree p, int /*v*/)
3069 {
3070 int flags = 0;
3071 reinit_cxx_pp ();
3072 dump_exception_spec (cxx_pp, p, flags);
3073 return pp_ggc_formatted_text (cxx_pp);
3074 }
3075
3076 /* Langhook for print_error_function. */
3077 void
3078 cxx_print_error_function (diagnostic_context *context, const char *file,
3079 diagnostic_info *diagnostic)
3080 {
3081 lhd_print_error_function (context, file, diagnostic);
3082 pp_set_prefix (context->printer, file);
3083 maybe_print_instantiation_context (context);
3084 }
3085
3086 static void
3087 cp_diagnostic_starter (diagnostic_context *context,
3088 diagnostic_info *diagnostic)
3089 {
3090 diagnostic_report_current_module (context, diagnostic_location (diagnostic));
3091 cp_print_error_function (context, diagnostic);
3092 maybe_print_instantiation_context (context);
3093 maybe_print_constexpr_context (context);
3094 pp_set_prefix (context->printer, diagnostic_build_prefix (context,
3095 diagnostic));
3096 }
3097
3098 /* Print current function onto BUFFER, in the process of reporting
3099 a diagnostic message. Called from cp_diagnostic_starter. */
3100 static void
3101 cp_print_error_function (diagnostic_context *context,
3102 diagnostic_info *diagnostic)
3103 {
3104 /* If we are in an instantiation context, current_function_decl is likely
3105 to be wrong, so just rely on print_instantiation_full_context. */
3106 if (current_instantiation ())
3107 return;
3108 if (diagnostic_last_function_changed (context, diagnostic))
3109 {
3110 const char *old_prefix = context->printer->prefix;
3111 const char *file = LOCATION_FILE (diagnostic_location (diagnostic));
3112 tree abstract_origin = diagnostic_abstract_origin (diagnostic);
3113 char *new_prefix = (file && abstract_origin == NULL)
3114 ? file_name_as_prefix (context, file) : NULL;
3115
3116 pp_set_prefix (context->printer, new_prefix);
3117
3118 if (current_function_decl == NULL)
3119 pp_string (context->printer, _("At global scope:"));
3120 else
3121 {
3122 tree fndecl, ao;
3123
3124 if (abstract_origin)
3125 {
3126 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
3127 while (TREE_CODE (ao) == BLOCK
3128 && BLOCK_ABSTRACT_ORIGIN (ao)
3129 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3130 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3131 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
3132 fndecl = ao;
3133 }
3134 else
3135 fndecl = current_function_decl;
3136
3137 pp_printf (context->printer, function_category (fndecl),
3138 cxx_printable_name_translate (fndecl, 2));
3139
3140 while (abstract_origin)
3141 {
3142 location_t *locus;
3143 tree block = abstract_origin;
3144
3145 locus = &BLOCK_SOURCE_LOCATION (block);
3146 fndecl = NULL;
3147 block = BLOCK_SUPERCONTEXT (block);
3148 while (block && TREE_CODE (block) == BLOCK
3149 && BLOCK_ABSTRACT_ORIGIN (block))
3150 {
3151 ao = BLOCK_ABSTRACT_ORIGIN (block);
3152
3153 while (TREE_CODE (ao) == BLOCK
3154 && BLOCK_ABSTRACT_ORIGIN (ao)
3155 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3156 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3157
3158 if (TREE_CODE (ao) == FUNCTION_DECL)
3159 {
3160 fndecl = ao;
3161 break;
3162 }
3163 else if (TREE_CODE (ao) != BLOCK)
3164 break;
3165
3166 block = BLOCK_SUPERCONTEXT (block);
3167 }
3168 if (fndecl)
3169 abstract_origin = block;
3170 else
3171 {
3172 while (block && TREE_CODE (block) == BLOCK)
3173 block = BLOCK_SUPERCONTEXT (block);
3174
3175 if (block && TREE_CODE (block) == FUNCTION_DECL)
3176 fndecl = block;
3177 abstract_origin = NULL;
3178 }
3179 if (fndecl)
3180 {
3181 expanded_location s = expand_location (*locus);
3182 pp_character (context->printer, ',');
3183 pp_newline (context->printer);
3184 if (s.file != NULL)
3185 {
3186 if (context->show_column && s.column != 0)
3187 pp_printf (context->printer,
3188 _(" inlined from %qs at %r%s:%d:%d%R"),
3189 cxx_printable_name_translate (fndecl, 2),
3190 "locus", s.file, s.line, s.column);
3191 else
3192 pp_printf (context->printer,
3193 _(" inlined from %qs at %r%s:%d%R"),
3194 cxx_printable_name_translate (fndecl, 2),
3195 "locus", s.file, s.line);
3196
3197 }
3198 else
3199 pp_printf (context->printer, _(" inlined from %qs"),
3200 cxx_printable_name_translate (fndecl, 2));
3201 }
3202 }
3203 pp_character (context->printer, ':');
3204 }
3205 pp_newline (context->printer);
3206
3207 diagnostic_set_last_function (context, diagnostic);
3208 pp_destroy_prefix (context->printer);
3209 context->printer->prefix = old_prefix;
3210 }
3211 }
3212
3213 /* Returns a description of FUNCTION using standard terminology. The
3214 result is a format string of the form "In CATEGORY %qs". */
3215 static const char *
3216 function_category (tree fn)
3217 {
3218 /* We can get called from the middle-end for diagnostics of function
3219 clones. Make sure we have language specific information before
3220 dereferencing it. */
3221 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
3222 && DECL_FUNCTION_MEMBER_P (fn))
3223 {
3224 if (DECL_STATIC_FUNCTION_P (fn))
3225 return _("In static member function %qs");
3226 else if (DECL_COPY_CONSTRUCTOR_P (fn))
3227 return _("In copy constructor %qs");
3228 else if (DECL_CONSTRUCTOR_P (fn))
3229 return _("In constructor %qs");
3230 else if (DECL_DESTRUCTOR_P (fn))
3231 return _("In destructor %qs");
3232 else if (LAMBDA_FUNCTION_P (fn))
3233 return _("In lambda function");
3234 else
3235 return _("In member function %qs");
3236 }
3237 else
3238 return _("In function %qs");
3239 }
3240
3241 /* Report the full context of a current template instantiation,
3242 onto BUFFER. */
3243 static void
3244 print_instantiation_full_context (diagnostic_context *context)
3245 {
3246 struct tinst_level *p = current_instantiation ();
3247 location_t location = input_location;
3248
3249 if (p)
3250 {
3251 pp_verbatim (context->printer,
3252 TREE_CODE (p->decl) == TREE_LIST
3253 ? _("%s: In substitution of %qS:\n")
3254 : _("%s: In instantiation of %q#D:\n"),
3255 LOCATION_FILE (location),
3256 p->decl);
3257
3258 location = p->locus;
3259 p = p->next;
3260 }
3261
3262 print_instantiation_partial_context (context, p, location);
3263 }
3264
3265 /* Helper function of print_instantiation_partial_context() that
3266 prints a single line of instantiation context. */
3267
3268 static void
3269 print_instantiation_partial_context_line (diagnostic_context *context,
3270 const struct tinst_level *t,
3271 location_t loc, bool recursive_p)
3272 {
3273 if (loc == UNKNOWN_LOCATION)
3274 return;
3275
3276 expanded_location xloc = expand_location (loc);
3277
3278 if (context->show_column)
3279 pp_verbatim (context->printer, _("%r%s:%d:%d:%R "),
3280 "locus", xloc.file, xloc.line, xloc.column);
3281 else
3282 pp_verbatim (context->printer, _("%r%s:%d:%R "),
3283 "locus", xloc.file, xloc.line);
3284
3285 if (t != NULL)
3286 {
3287 if (TREE_CODE (t->decl) == TREE_LIST)
3288 pp_verbatim (context->printer,
3289 recursive_p
3290 ? _("recursively required by substitution of %qS\n")
3291 : _("required by substitution of %qS\n"),
3292 t->decl);
3293 else
3294 pp_verbatim (context->printer,
3295 recursive_p
3296 ? _("recursively required from %q#D\n")
3297 : _("required from %q#D\n"),
3298 t->decl);
3299 }
3300 else
3301 {
3302 pp_verbatim (context->printer,
3303 recursive_p
3304 ? _("recursively required from here")
3305 : _("required from here"));
3306 }
3307 }
3308
3309 /* Same as print_instantiation_full_context but less verbose. */
3310
3311 static void
3312 print_instantiation_partial_context (diagnostic_context *context,
3313 struct tinst_level *t0, location_t loc)
3314 {
3315 struct tinst_level *t;
3316 int n_total = 0;
3317 int n;
3318 location_t prev_loc = loc;
3319
3320 for (t = t0; t != NULL; t = t->next)
3321 if (prev_loc != t->locus)
3322 {
3323 prev_loc = t->locus;
3324 n_total++;
3325 }
3326
3327 t = t0;
3328
3329 if (template_backtrace_limit
3330 && n_total > template_backtrace_limit)
3331 {
3332 int skip = n_total - template_backtrace_limit;
3333 int head = template_backtrace_limit / 2;
3334
3335 /* Avoid skipping just 1. If so, skip 2. */
3336 if (skip == 1)
3337 {
3338 skip = 2;
3339 head = (template_backtrace_limit - 1) / 2;
3340 }
3341
3342 for (n = 0; n < head; n++)
3343 {
3344 gcc_assert (t != NULL);
3345 if (loc != t->locus)
3346 print_instantiation_partial_context_line (context, t, loc,
3347 /*recursive_p=*/false);
3348 loc = t->locus;
3349 t = t->next;
3350 }
3351 if (t != NULL && skip > 0)
3352 {
3353 expanded_location xloc;
3354 xloc = expand_location (loc);
3355 if (context->show_column)
3356 pp_verbatim (context->printer,
3357 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3358 "contexts, use -ftemplate-backtrace-limit=0 to "
3359 "disable ]\n"),
3360 "locus", xloc.file, xloc.line, xloc.column, skip);
3361 else
3362 pp_verbatim (context->printer,
3363 _("%r%s:%d:%R [ skipping %d instantiation "
3364 "contexts, use -ftemplate-backtrace-limit=0 to "
3365 "disable ]\n"),
3366 "locus", xloc.file, xloc.line, skip);
3367
3368 do {
3369 loc = t->locus;
3370 t = t->next;
3371 } while (t != NULL && --skip > 0);
3372 }
3373 }
3374
3375 while (t != NULL)
3376 {
3377 while (t->next != NULL && t->locus == t->next->locus)
3378 {
3379 loc = t->locus;
3380 t = t->next;
3381 }
3382 print_instantiation_partial_context_line (context, t, loc,
3383 t->locus == loc);
3384 loc = t->locus;
3385 t = t->next;
3386 }
3387 print_instantiation_partial_context_line (context, NULL, loc,
3388 /*recursive_p=*/false);
3389 pp_newline (context->printer);
3390 }
3391
3392 /* Called from cp_thing to print the template context for an error. */
3393 static void
3394 maybe_print_instantiation_context (diagnostic_context *context)
3395 {
3396 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3397 return;
3398
3399 record_last_problematic_instantiation ();
3400 print_instantiation_full_context (context);
3401 }
3402 \f
3403 /* Report what constexpr call(s) we're trying to expand, if any. */
3404
3405 void
3406 maybe_print_constexpr_context (diagnostic_context *context)
3407 {
3408 vec<tree> call_stack = cx_error_context ();
3409 unsigned ix;
3410 tree t;
3411
3412 FOR_EACH_VEC_ELT (call_stack, ix, t)
3413 {
3414 expanded_location xloc = expand_location (EXPR_LOCATION (t));
3415 const char *s = expr_as_string (t, 0);
3416 if (context->show_column)
3417 pp_verbatim (context->printer,
3418 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3419 "locus", xloc.file, xloc.line, xloc.column, s);
3420 else
3421 pp_verbatim (context->printer,
3422 _("%r%s:%d:%R in constexpr expansion of %qs"),
3423 "locus", xloc.file, xloc.line, s);
3424 pp_newline (context->printer);
3425 }
3426 }
3427 \f
3428 /* Called from output_format -- during diagnostic message processing --
3429 to handle C++ specific format specifier with the following meanings:
3430 %A function argument-list.
3431 %C tree code.
3432 %D declaration.
3433 %E expression.
3434 %F function declaration.
3435 %L language as used in extern "lang".
3436 %O binary operator.
3437 %P function parameter whose position is indicated by an integer.
3438 %Q assignment operator.
3439 %S substitution (template + args)
3440 %T type.
3441 %V cv-qualifier.
3442 %X exception-specification. */
3443 static bool
3444 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
3445 int precision, bool wide, bool set_locus, bool verbose)
3446 {
3447 const char *result;
3448 tree t = NULL;
3449 #define next_tree (t = va_arg (*text->args_ptr, tree))
3450 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3451 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3452 #define next_int va_arg (*text->args_ptr, int)
3453
3454 if (precision != 0 || wide)
3455 return false;
3456
3457 switch (*spec)
3458 {
3459 case 'A': result = args_to_string (next_tree, verbose); break;
3460 case 'C': result = code_to_string (next_tcode); break;
3461 case 'D':
3462 {
3463 tree temp = next_tree;
3464 if (VAR_P (temp)
3465 && DECL_HAS_DEBUG_EXPR_P (temp))
3466 {
3467 temp = DECL_DEBUG_EXPR (temp);
3468 if (!DECL_P (temp))
3469 {
3470 result = expr_to_string (temp);
3471 break;
3472 }
3473 }
3474 result = decl_to_string (temp, verbose);
3475 }
3476 break;
3477 case 'E': result = expr_to_string (next_tree); break;
3478 case 'F': result = fndecl_to_string (next_tree, verbose); break;
3479 case 'L': result = language_to_string (next_lang); break;
3480 case 'O': result = op_to_string (next_tcode); break;
3481 case 'P': result = parm_to_string (next_int); break;
3482 case 'Q': result = assop_to_string (next_tcode); break;
3483 case 'S': result = subst_to_string (next_tree); break;
3484 case 'T': result = type_to_string (next_tree, verbose); break;
3485 case 'V': result = cv_to_string (next_tree, verbose); break;
3486 case 'X': result = eh_spec_to_string (next_tree, verbose); break;
3487
3488 case 'K':
3489 percent_K_format (text);
3490 return true;
3491
3492 default:
3493 return false;
3494 }
3495
3496 pp_string (pp, result);
3497 if (set_locus && t != NULL)
3498 text->set_location (0, location_of (t));
3499 return true;
3500 #undef next_tree
3501 #undef next_tcode
3502 #undef next_lang
3503 #undef next_int
3504 }
3505 \f
3506 /* Warn about the use of C++0x features when appropriate. */
3507 void
3508 maybe_warn_cpp0x (cpp0x_warn_str str)
3509 {
3510 if ((cxx_dialect == cxx98) && !in_system_header_at (input_location))
3511 /* We really want to suppress this warning in system headers,
3512 because libstdc++ uses variadic templates even when we aren't
3513 in C++0x mode. */
3514 switch (str)
3515 {
3516 case CPP0X_INITIALIZER_LISTS:
3517 pedwarn (input_location, 0,
3518 "extended initializer lists "
3519 "only available with -std=c++11 or -std=gnu++11");
3520 break;
3521 case CPP0X_EXPLICIT_CONVERSION:
3522 pedwarn (input_location, 0,
3523 "explicit conversion operators "
3524 "only available with -std=c++11 or -std=gnu++11");
3525 break;
3526 case CPP0X_VARIADIC_TEMPLATES:
3527 pedwarn (input_location, 0,
3528 "variadic templates "
3529 "only available with -std=c++11 or -std=gnu++11");
3530 break;
3531 case CPP0X_LAMBDA_EXPR:
3532 pedwarn (input_location, 0,
3533 "lambda expressions "
3534 "only available with -std=c++11 or -std=gnu++11");
3535 break;
3536 case CPP0X_AUTO:
3537 pedwarn (input_location, 0,
3538 "C++11 auto only available with -std=c++11 or -std=gnu++11");
3539 break;
3540 case CPP0X_SCOPED_ENUMS:
3541 pedwarn (input_location, 0,
3542 "scoped enums only available with -std=c++11 or -std=gnu++11");
3543 break;
3544 case CPP0X_DEFAULTED_DELETED:
3545 pedwarn (input_location, 0,
3546 "defaulted and deleted functions "
3547 "only available with -std=c++11 or -std=gnu++11");
3548 break;
3549 case CPP0X_INLINE_NAMESPACES:
3550 pedwarn (input_location, OPT_Wpedantic,
3551 "inline namespaces "
3552 "only available with -std=c++11 or -std=gnu++11");
3553 break;
3554 case CPP0X_OVERRIDE_CONTROLS:
3555 pedwarn (input_location, 0,
3556 "override controls (override/final) "
3557 "only available with -std=c++11 or -std=gnu++11");
3558 break;
3559 case CPP0X_NSDMI:
3560 pedwarn (input_location, 0,
3561 "non-static data member initializers "
3562 "only available with -std=c++11 or -std=gnu++11");
3563 break;
3564 case CPP0X_USER_DEFINED_LITERALS:
3565 pedwarn (input_location, 0,
3566 "user-defined literals "
3567 "only available with -std=c++11 or -std=gnu++11");
3568 break;
3569 case CPP0X_DELEGATING_CTORS:
3570 pedwarn (input_location, 0,
3571 "delegating constructors "
3572 "only available with -std=c++11 or -std=gnu++11");
3573 break;
3574 case CPP0X_INHERITING_CTORS:
3575 pedwarn (input_location, 0,
3576 "inheriting constructors "
3577 "only available with -std=c++11 or -std=gnu++11");
3578 break;
3579 case CPP0X_ATTRIBUTES:
3580 pedwarn (input_location, 0,
3581 "c++11 attributes "
3582 "only available with -std=c++11 or -std=gnu++11");
3583 break;
3584 case CPP0X_REF_QUALIFIER:
3585 pedwarn (input_location, 0,
3586 "ref-qualifiers "
3587 "only available with -std=c++11 or -std=gnu++11");
3588 break;
3589 default:
3590 gcc_unreachable ();
3591 }
3592 }
3593
3594 /* Warn about the use of variadic templates when appropriate. */
3595 void
3596 maybe_warn_variadic_templates (void)
3597 {
3598 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
3599 }
3600
3601
3602 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3603 option OPT with text GMSGID. Use this function to report
3604 diagnostics for constructs that are invalid C++98, but valid
3605 C++0x. */
3606 bool
3607 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
3608 {
3609 diagnostic_info diagnostic;
3610 va_list ap;
3611 bool ret;
3612
3613 va_start (ap, gmsgid);
3614 diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
3615 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
3616 diagnostic.option_index = opt;
3617 ret = report_diagnostic (&diagnostic);
3618 va_end (ap);
3619 return ret;
3620 }
3621
3622 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3623 we found when we tried to do the lookup. LOCATION is the location of
3624 the NAME identifier. */
3625
3626 void
3627 qualified_name_lookup_error (tree scope, tree name,
3628 tree decl, location_t location)
3629 {
3630 if (scope == error_mark_node)
3631 ; /* We already complained. */
3632 else if (TYPE_P (scope))
3633 {
3634 if (!COMPLETE_TYPE_P (scope))
3635 error_at (location, "incomplete type %qT used in nested name specifier",
3636 scope);
3637 else if (TREE_CODE (decl) == TREE_LIST)
3638 {
3639 error_at (location, "reference to %<%T::%D%> is ambiguous",
3640 scope, name);
3641 print_candidates (decl);
3642 }
3643 else
3644 error_at (location, "%qD is not a member of %qT", name, scope);
3645 }
3646 else if (scope != global_namespace)
3647 {
3648 error_at (location, "%qD is not a member of %qD", name, scope);
3649 suggest_alternatives_for (location, name);
3650 }
3651 else
3652 {
3653 error_at (location, "%<::%D%> has not been declared", name);
3654 suggest_alternatives_for (location, name);
3655 }
3656 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org