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