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