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