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,
4 2003, 2004, 2005 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
24 #include "coretypes.h"
31 #include "diagnostic.h"
32 #include "langhooks-def.h"
33 #include "cxx-pretty-print.h"
35 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
37 /* The global buffer where we dump everything. It is there only for
38 transitional purpose. It is expected, in the near future, to be
39 completely removed. */
40 static cxx_pretty_printer scratch_pretty_printer;
41 #define cxx_pp (&scratch_pretty_printer)
43 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
45 static const char *args_to_string (tree, int);
46 static const char *assop_to_string (enum tree_code);
47 static const char *code_to_string (enum tree_code);
48 static const char *cv_to_string (tree, int);
49 static const char *decl_to_string (tree, int);
50 static const char *expr_to_string (tree);
51 static const char *fndecl_to_string (tree, int);
52 static const char *op_to_string (enum tree_code);
53 static const char *parm_to_string (int);
54 static const char *type_to_string (tree, int);
56 static void dump_type (tree, int);
57 static void dump_typename (tree, int);
58 static void dump_simple_decl (tree, tree, int);
59 static void dump_decl (tree, int);
60 static void dump_template_decl (tree, int);
61 static void dump_function_decl (tree, int);
62 static void dump_expr (tree, int);
63 static void dump_unary_op (const char *, tree, int);
64 static void dump_binary_op (const char *, tree, int);
65 static void dump_aggr_type (tree, int);
66 static void dump_type_prefix (tree, int);
67 static void dump_type_suffix (tree, int);
68 static void dump_function_name (tree, int);
69 static void dump_expr_list (tree, int);
70 static void dump_global_iord (tree);
71 static void dump_parameters (tree, int);
72 static void dump_exception_spec (tree, int);
73 static void dump_template_argument (tree, int);
74 static void dump_template_argument_list (tree, int);
75 static void dump_template_parameter (tree, int);
76 static void dump_template_bindings (tree, tree);
77 static void dump_scope (tree, int);
78 static void dump_template_parms (tree, int, int);
80 static const char *function_category (tree);
81 static void maybe_print_instantiation_context (diagnostic_context *);
82 static void print_instantiation_full_context (diagnostic_context *);
83 static void print_instantiation_partial_context (diagnostic_context *,
85 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
86 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
87 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
89 static bool cp_printer (pretty_printer *, text_info *, const char *,
90 int, bool, bool, bool);
91 static location_t location_of (tree);
96 diagnostic_starter (global_dc) = cp_diagnostic_starter;
97 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
98 diagnostic_format_decoder (global_dc) = cp_printer;
100 pp_construct (pp_base (cxx_pp), NULL, 0);
101 pp_cxx_pretty_printer_init (cxx_pp);
104 /* Dump a scope, if deemed necessary. */
107 dump_scope (tree scope, int flags)
109 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
111 if (scope == NULL_TREE)
114 if (TREE_CODE (scope) == NAMESPACE_DECL)
116 if (scope != global_namespace)
118 dump_decl (scope, f);
119 pp_cxx_colon_colon (cxx_pp);
122 else if (AGGREGATE_TYPE_P (scope))
124 dump_type (scope, f);
125 pp_cxx_colon_colon (cxx_pp);
127 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
129 dump_function_decl (scope, f);
130 pp_cxx_colon_colon (cxx_pp);
134 /* Dump the template ARGument under control of FLAGS. */
137 dump_template_argument (tree arg, int flags)
139 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
140 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
142 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
145 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
149 dump_template_argument_list (tree args, int flags)
151 int n = TREE_VEC_LENGTH (args);
155 for (i = 0; i< n; ++i)
158 pp_separate_with_comma (cxx_pp);
159 dump_template_argument (TREE_VEC_ELT (args, i), flags);
164 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
167 dump_template_parameter (tree parm, int flags)
172 if (parm == error_mark_node)
175 p = TREE_VALUE (parm);
176 a = TREE_PURPOSE (parm);
178 if (TREE_CODE (p) == TYPE_DECL)
180 if (flags & TFF_DECL_SPECIFIERS)
182 pp_cxx_identifier (cxx_pp, "class");
184 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
186 else if (DECL_NAME (p))
187 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
189 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
192 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
194 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
196 pp_cxx_whitespace (cxx_pp);
198 pp_cxx_whitespace (cxx_pp);
199 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
200 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
202 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
206 /* Dump, under control of FLAGS, a template-parameter-list binding.
207 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
211 dump_template_bindings (tree parms, tree args)
217 tree p = TREE_VALUE (parms);
218 int lvl = TMPL_PARMS_DEPTH (parms);
222 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
224 tree arg = NULL_TREE;
226 /* Don't crash if we had an invalid argument list. */
227 if (TMPL_ARGS_DEPTH (args) >= lvl)
229 tree lvl_args = TMPL_ARGS_LEVEL (args, lvl);
230 if (NUM_TMPL_ARGS (lvl_args) > arg_idx)
231 arg = TREE_VEC_ELT (lvl_args, arg_idx);
235 pp_separate_with_comma (cxx_pp);
236 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
237 pp_cxx_whitespace (cxx_pp);
239 pp_cxx_whitespace (cxx_pp);
241 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
243 pp_identifier (cxx_pp, "<missing>");
249 parms = TREE_CHAIN (parms);
253 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
257 dump_type (tree t, int flags)
262 if (TYPE_PTRMEMFUNC_P (t))
265 switch (TREE_CODE (t))
268 pp_identifier (cxx_pp, "<unresolved overloaded function type>");
272 /* A list of function parms. */
273 dump_parameters (t, flags);
276 case IDENTIFIER_NODE:
277 pp_cxx_tree_identifier (cxx_pp, t);
281 dump_type (BINFO_TYPE (t), flags);
287 dump_aggr_type (t, flags);
291 if (flags & TFF_CHASE_TYPEDEF)
293 dump_type (DECL_ORIGINAL_TYPE (t)
294 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
297 /* Else fall through. */
301 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
310 pp_type_specifier_seq (cxx_pp, t);
313 case TEMPLATE_TEMPLATE_PARM:
314 /* For parameters inside template signature. */
315 if (TYPE_IDENTIFIER (t))
316 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
318 pp_cxx_canonical_template_parameter (cxx_pp, t);
321 case BOUND_TEMPLATE_TEMPLATE_PARM:
323 tree args = TYPE_TI_ARGS (t);
324 pp_cxx_cv_qualifier_seq (cxx_pp, t);
325 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
326 pp_cxx_begin_template_argument_list (cxx_pp);
327 dump_template_argument_list (args, flags);
328 pp_cxx_end_template_argument_list (cxx_pp);
332 case TEMPLATE_TYPE_PARM:
333 pp_cxx_cv_qualifier_seq (cxx_pp, t);
334 if (TYPE_IDENTIFIER (t))
335 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
337 pp_cxx_canonical_template_parameter
338 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
341 /* This is not always necessary for pointers and such, but doing this
342 reduces code size. */
345 /* APPLE LOCAL blocks 6040305 */
346 case BLOCK_POINTER_TYPE:
353 dump_type_prefix (t, flags);
354 dump_type_suffix (t, flags);
358 pp_cxx_cv_qualifier_seq (cxx_pp, t);
359 pp_cxx_identifier (cxx_pp,
360 TYPENAME_IS_ENUM_P (t) ? "enum"
361 : TYPENAME_IS_CLASS_P (t) ? "class"
363 dump_typename (t, flags);
366 case UNBOUND_CLASS_TEMPLATE:
367 dump_type (TYPE_CONTEXT (t), flags);
368 pp_cxx_colon_colon (cxx_pp);
369 pp_cxx_identifier (cxx_pp, "template");
370 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
374 pp_cxx_identifier (cxx_pp, "__typeof__");
375 pp_cxx_whitespace (cxx_pp);
376 pp_cxx_left_paren (cxx_pp);
377 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
378 pp_cxx_right_paren (cxx_pp);
382 pp_unsupported_tree (cxx_pp, t);
383 /* Fall through to error. */
386 pp_identifier (cxx_pp, "<type error>");
391 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
395 dump_typename (tree t, int flags)
397 tree ctx = TYPE_CONTEXT (t);
399 if (TREE_CODE (ctx) == TYPENAME_TYPE)
400 dump_typename (ctx, flags);
402 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
403 pp_cxx_colon_colon (cxx_pp);
404 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
407 /* Return the name of the supplied aggregate, or enumeral type. */
410 class_key_or_enum_as_string (tree t)
412 if (TREE_CODE (t) == ENUMERAL_TYPE)
414 else if (TREE_CODE (t) == UNION_TYPE)
416 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
422 /* Print out a class declaration T under the control of FLAGS,
423 in the form `class foo'. */
426 dump_aggr_type (tree t, int flags)
429 const char *variety = class_key_or_enum_as_string (t);
433 pp_cxx_cv_qualifier_seq (cxx_pp, t);
435 if (flags & TFF_CLASS_KEY_OR_ENUM)
436 pp_cxx_identifier (cxx_pp, variety);
438 if (flags & TFF_CHASE_TYPEDEF)
439 t = TYPE_MAIN_VARIANT (t);
441 name = TYPE_NAME (t);
445 typdef = !DECL_ARTIFICIAL (name);
446 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
447 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
448 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
449 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
450 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
453 /* Because the template names are mangled, we have to locate
454 the most general template, and use that name. */
455 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
457 while (DECL_TEMPLATE_INFO (tpl))
458 tpl = DECL_TI_TEMPLATE (tpl);
461 name = DECL_NAME (name);
464 if (name == 0 || ANON_AGGRNAME_P (name))
466 if (flags & TFF_CLASS_KEY_OR_ENUM)
467 pp_identifier (cxx_pp, "<anonymous>");
469 pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
472 pp_cxx_tree_identifier (cxx_pp, name);
474 dump_template_parms (TYPE_TEMPLATE_INFO (t),
475 !CLASSTYPE_USE_TEMPLATE (t),
476 flags & ~TFF_TEMPLATE_HEADER);
479 /* Dump into the obstack the initial part of the output for a given type.
480 This is necessary when dealing with things like functions returning
483 return type of `int (* fee ())()': pointer -> function -> int. Both
484 pointer (and reference and offset) and function (and member) types must
485 deal with prefix and suffix.
487 Arrays must also do this for DECL nodes, like int a[], and for things like
491 dump_type_prefix (tree t, int flags)
493 if (TYPE_PTRMEMFUNC_P (t))
495 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
499 switch (TREE_CODE (t))
502 /* APPLE LOCAL blocks 6040305 */
503 case BLOCK_POINTER_TYPE:
506 tree sub = TREE_TYPE (t);
508 dump_type_prefix (sub, flags);
509 if (TREE_CODE (sub) == ARRAY_TYPE)
511 pp_cxx_whitespace (cxx_pp);
512 pp_cxx_left_paren (cxx_pp);
514 /* APPLE LOCAL begin blocks 6040305 */
515 pp_character (cxx_pp, "&*^"[(TREE_CODE (t) == POINTER_TYPE)
516 + (TREE_CODE (t) == BLOCK_POINTER_TYPE)*2]);
517 /* APPLE LOCAL end blocks 6040305 */
518 pp_base (cxx_pp)->padding = pp_before;
519 pp_cxx_cv_qualifier_seq (cxx_pp, t);
525 dump_type_prefix (TREE_TYPE (t), flags);
526 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
528 pp_maybe_space (cxx_pp);
529 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
530 pp_cxx_left_paren (cxx_pp);
531 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
532 pp_cxx_colon_colon (cxx_pp);
534 pp_cxx_star (cxx_pp);
535 pp_cxx_cv_qualifier_seq (cxx_pp, t);
536 pp_base (cxx_pp)->padding = pp_before;
539 /* Can only be reached through function pointer -- this would not be
540 correct if FUNCTION_DECLs used it. */
542 dump_type_prefix (TREE_TYPE (t), flags);
543 pp_maybe_space (cxx_pp);
544 pp_cxx_left_paren (cxx_pp);
548 dump_type_prefix (TREE_TYPE (t), flags);
549 pp_maybe_space (cxx_pp);
550 pp_cxx_left_paren (cxx_pp);
551 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
552 pp_cxx_colon_colon (cxx_pp);
556 dump_type_prefix (TREE_TYPE (t), flags);
560 case IDENTIFIER_NODE:
565 case TEMPLATE_TYPE_PARM:
566 case TEMPLATE_TEMPLATE_PARM:
567 case BOUND_TEMPLATE_TEMPLATE_PARM:
578 dump_type (t, flags);
579 pp_base (cxx_pp)->padding = pp_before;
583 pp_unsupported_tree (cxx_pp, t);
586 pp_identifier (cxx_pp, "<typeprefixerror>");
591 /* Dump the suffix of type T, under control of FLAGS. This is the part
592 which appears after the identifier (or function parms). */
595 dump_type_suffix (tree t, int flags)
597 if (TYPE_PTRMEMFUNC_P (t))
598 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
600 switch (TREE_CODE (t))
603 /* APPLE LOCAL blocks 6040305 */
604 case BLOCK_POINTER_TYPE:
607 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
608 pp_cxx_right_paren (cxx_pp);
609 dump_type_suffix (TREE_TYPE (t), flags);
612 /* Can only be reached through function pointer. */
617 pp_cxx_right_paren (cxx_pp);
618 arg = TYPE_ARG_TYPES (t);
619 if (TREE_CODE (t) == METHOD_TYPE)
620 arg = TREE_CHAIN (arg);
622 /* Function pointers don't have default args. Not in standard C++,
623 anyway; they may in g++, but we'll just pretend otherwise. */
624 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
626 if (TREE_CODE (t) == METHOD_TYPE)
627 pp_cxx_cv_qualifier_seq
628 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
630 pp_cxx_cv_qualifier_seq(cxx_pp, t);
631 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
632 dump_type_suffix (TREE_TYPE (t), flags);
637 pp_maybe_space (cxx_pp);
638 pp_cxx_left_bracket (cxx_pp);
641 if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
643 (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
644 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
645 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
646 flags & ~TFF_EXPR_IN_PARENS);
648 dump_expr (fold (cp_build_binary_op
649 (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
651 flags & ~TFF_EXPR_IN_PARENS);
653 pp_cxx_right_bracket (cxx_pp);
654 dump_type_suffix (TREE_TYPE (t), flags);
658 case IDENTIFIER_NODE:
663 case TEMPLATE_TYPE_PARM:
664 case TEMPLATE_TEMPLATE_PARM:
665 case BOUND_TEMPLATE_TEMPLATE_PARM:
679 pp_unsupported_tree (cxx_pp, t);
681 /* Don't mark it here, we should have already done in
688 dump_global_iord (tree t)
690 const char *p = NULL;
692 if (DECL_GLOBAL_CTOR_P (t))
694 else if (DECL_GLOBAL_DTOR_P (t))
699 pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
703 dump_simple_decl (tree t, tree type, int flags)
705 if (flags & TFF_DECL_SPECIFIERS)
707 dump_type_prefix (type, flags);
708 pp_maybe_space (cxx_pp);
710 if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
711 dump_scope (CP_DECL_CONTEXT (t), flags);
713 dump_decl (DECL_NAME (t), flags);
715 pp_identifier (cxx_pp, "<anonymous>");
716 if (flags & TFF_DECL_SPECIFIERS)
717 dump_type_suffix (type, flags);
720 /* Dump a human readable string for the decl T under control of FLAGS. */
723 dump_decl (tree t, int flags)
728 switch (TREE_CODE (t))
731 /* Don't say 'typedef class A' */
732 if (DECL_ARTIFICIAL (t))
734 if ((flags & TFF_DECL_SPECIFIERS)
735 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
736 /* Say `class T' not just `T'. */
737 pp_cxx_identifier (cxx_pp, "class");
739 dump_type (TREE_TYPE (t), flags);
742 if (flags & TFF_DECL_SPECIFIERS)
743 pp_cxx_identifier (cxx_pp, "typedef");
744 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
745 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
750 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
752 pp_string (cxx_pp, "vtable for ");
753 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
754 dump_type (DECL_CONTEXT (t), flags);
757 /* Else fall through. */
760 dump_simple_decl (t, TREE_TYPE (t), flags);
764 pp_string (cxx_pp, "<return value> ");
765 dump_simple_decl (t, TREE_TYPE (t), flags);
769 if (flags & TFF_DECL_SPECIFIERS)
770 pp_cxx_declaration (cxx_pp, t);
773 dump_scope (CP_DECL_CONTEXT (t), flags);
774 if (DECL_NAME (t) == NULL_TREE)
775 pp_identifier (cxx_pp, "<unnamed>");
777 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
782 pp_expression (cxx_pp, t);
786 dump_decl (TREE_OPERAND (t, 0), flags);
787 pp_cxx_left_bracket (cxx_pp);
788 dump_decl (TREE_OPERAND (t, 1), flags);
789 pp_cxx_right_bracket (cxx_pp);
792 /* So that we can do dump_decl on an aggr type. */
796 dump_type (t, flags);
800 /* This is a pseudo destructor call which has not been folded into
801 a PSEUDO_DTOR_EXPR yet. */
802 pp_cxx_complement (cxx_pp);
803 dump_type (TREE_OPERAND (t, 0), flags);
810 /* These special cases are duplicated here so that other functions
811 can feed identifiers to error and get them demangled properly. */
812 case IDENTIFIER_NODE:
813 if (IDENTIFIER_TYPENAME_P (t))
815 pp_cxx_identifier (cxx_pp, "operator");
816 /* Not exactly IDENTIFIER_TYPE_VALUE. */
817 dump_type (TREE_TYPE (t), flags);
821 pp_cxx_tree_identifier (cxx_pp, t);
828 if (DECL_CLASS_SCOPE_P (t))
830 dump_type (DECL_CONTEXT (t), flags);
831 pp_cxx_colon_colon (cxx_pp);
833 else if (DECL_CONTEXT (t))
835 dump_decl (DECL_CONTEXT (t), flags);
836 pp_cxx_colon_colon (cxx_pp);
838 dump_decl (DECL_NAME (t), flags);
842 /* If there's only one function, just treat it like an ordinary
848 if (! DECL_LANG_SPECIFIC (t))
849 pp_identifier (cxx_pp, "<built-in>");
850 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
851 dump_global_iord (t);
853 dump_function_decl (t, flags);
857 dump_template_decl (t, flags);
860 case TEMPLATE_ID_EXPR:
862 tree name = TREE_OPERAND (t, 0);
864 if (is_overloaded_fn (name))
865 name = DECL_NAME (get_first_fn (name));
866 dump_decl (name, flags);
867 pp_cxx_begin_template_argument_list (cxx_pp);
868 if (TREE_OPERAND (t, 1))
869 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
870 pp_cxx_end_template_argument_list (cxx_pp);
875 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
879 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
880 || (DECL_INITIAL (t) &&
881 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
882 dump_simple_decl (t, TREE_TYPE (t), flags);
883 else if (DECL_NAME (t))
884 dump_decl (DECL_NAME (t), flags);
885 else if (DECL_INITIAL (t))
886 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
888 pp_identifier (cxx_pp, "<enumerator>");
892 pp_cxx_identifier (cxx_pp, "using");
893 dump_type (USING_DECL_SCOPE (t), flags);
894 pp_cxx_colon_colon (cxx_pp);
895 dump_decl (DECL_NAME (t), flags);
899 dump_decl (BASELINK_FUNCTIONS (t), flags);
902 case NON_DEPENDENT_EXPR:
903 dump_expr (t, flags);
906 case TEMPLATE_TYPE_PARM:
907 if (flags & TFF_DECL_SPECIFIERS)
908 pp_cxx_declaration (cxx_pp, t);
910 pp_type_id (cxx_pp, t);
913 case UNBOUND_CLASS_TEMPLATE:
914 dump_type (t, flags);
918 pp_unsupported_tree (cxx_pp, t);
919 /* Fall through to error. */
922 pp_identifier (cxx_pp, "<declaration error>");
927 /* Dump a template declaration T under control of FLAGS. This means the
928 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
931 dump_template_decl (tree t, int flags)
933 tree orig_parms = DECL_TEMPLATE_PARMS (t);
937 if (flags & TFF_TEMPLATE_HEADER)
939 for (parms = orig_parms = nreverse (orig_parms);
941 parms = TREE_CHAIN (parms))
943 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
944 int len = TREE_VEC_LENGTH (inner_parms);
946 pp_cxx_identifier (cxx_pp, "template");
947 pp_cxx_begin_template_argument_list (cxx_pp);
949 /* If we've shown the template prefix, we'd better show the
950 parameters' and decl's type too. */
951 flags |= TFF_DECL_SPECIFIERS;
953 for (i = 0; i < len; i++)
956 pp_separate_with_comma (cxx_pp);
957 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
959 pp_cxx_end_template_argument_list (cxx_pp);
960 pp_cxx_whitespace (cxx_pp);
962 nreverse(orig_parms);
964 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
965 /* Say `template<arg> class TT' not just `template<arg> TT'. */
966 pp_cxx_identifier (cxx_pp, "class");
969 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
970 dump_type (TREE_TYPE (t),
971 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
972 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
973 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
974 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
977 gcc_assert (TREE_TYPE (t));
978 switch (NEXT_CODE (t))
982 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
985 /* This case can occur with some invalid code. */
986 dump_type (TREE_TYPE (t),
987 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
988 | (flags & TFF_DECL_SPECIFIERS
989 ? TFF_CLASS_KEY_OR_ENUM : 0));
994 /* Pretty print a function decl. There are several ways we want to print a
995 function declaration. The TFF_ bits in FLAGS tells us how to behave.
996 As error can only apply the '#' flag once to give 0 and 1 for V, there
997 is %D which doesn't print the throw specs, and %F which does. */
1000 dump_function_decl (tree t, int flags)
1004 tree cname = NULL_TREE;
1005 tree template_args = NULL_TREE;
1006 tree template_parms = NULL_TREE;
1007 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1009 if (TREE_CODE (t) == TEMPLATE_DECL)
1010 t = DECL_TEMPLATE_RESULT (t);
1012 /* Pretty print template instantiations only. */
1013 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
1017 template_args = DECL_TI_ARGS (t);
1018 tmpl = most_general_template (t);
1019 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1021 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1026 fntype = TREE_TYPE (t);
1027 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1029 if (DECL_CLASS_SCOPE_P (t))
1030 cname = DECL_CONTEXT (t);
1031 /* This is for partially instantiated template methods. */
1032 else if (TREE_CODE (fntype) == METHOD_TYPE)
1033 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1035 if (!(flags & TFF_DECL_SPECIFIERS))
1037 else if (DECL_STATIC_FUNCTION_P (t))
1038 pp_cxx_identifier (cxx_pp, "static");
1039 else if (DECL_VIRTUAL_P (t))
1040 pp_cxx_identifier (cxx_pp, "virtual");
1042 /* Print the return type? */
1044 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1045 && !DECL_DESTRUCTOR_P (t);
1047 dump_type_prefix (TREE_TYPE (fntype), flags);
1049 /* Print the function name. */
1052 dump_type (cname, flags);
1053 pp_cxx_colon_colon (cxx_pp);
1056 dump_scope (CP_DECL_CONTEXT (t), flags);
1058 dump_function_name (t, flags);
1060 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1062 dump_parameters (parmtypes, flags);
1064 if (TREE_CODE (fntype) == METHOD_TYPE)
1066 pp_base (cxx_pp)->padding = pp_before;
1067 pp_cxx_cv_qualifier_seq
1068 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1071 if (flags & TFF_EXCEPTION_SPECIFICATION)
1073 pp_base (cxx_pp)->padding = pp_before;
1074 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1078 dump_type_suffix (TREE_TYPE (fntype), flags);
1081 /* If T is a template instantiation, dump the parameter binding. */
1082 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1084 pp_cxx_whitespace (cxx_pp);
1085 pp_cxx_left_bracket (cxx_pp);
1086 pp_cxx_identifier (cxx_pp, "with");
1087 pp_cxx_whitespace (cxx_pp);
1088 dump_template_bindings (template_parms, template_args);
1089 pp_cxx_right_bracket (cxx_pp);
1093 /* Print a parameter list. If this is for a member function, the
1094 member object ptr (and any other hidden args) should have
1095 already been removed. */
1098 dump_parameters (tree parmtypes, int flags)
1102 pp_cxx_left_paren (cxx_pp);
1104 for (first = 1; parmtypes != void_list_node;
1105 parmtypes = TREE_CHAIN (parmtypes))
1108 pp_separate_with_comma (cxx_pp);
1112 pp_cxx_identifier (cxx_pp, "...");
1115 dump_type (TREE_VALUE (parmtypes), flags);
1117 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1119 pp_cxx_whitespace (cxx_pp);
1121 pp_cxx_whitespace (cxx_pp);
1122 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1126 pp_cxx_right_paren (cxx_pp);
1129 /* Print an exception specification. T is the exception specification. */
1132 dump_exception_spec (tree t, int flags)
1136 pp_cxx_identifier (cxx_pp, "throw");
1137 pp_cxx_whitespace (cxx_pp);
1138 pp_cxx_left_paren (cxx_pp);
1139 if (TREE_VALUE (t) != NULL_TREE)
1142 dump_type (TREE_VALUE (t), flags);
1146 pp_separate_with_comma (cxx_pp);
1148 pp_cxx_right_paren (cxx_pp);
1152 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1153 and destructors properly. */
1156 dump_function_name (tree t, int flags)
1158 tree name = DECL_NAME (t);
1160 /* We can get here with a decl that was synthesized by language-
1161 independent machinery (e.g. coverage.c) in which case it won't
1162 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1163 will crash. In this case it is safe just to print out the
1165 if (!DECL_LANG_SPECIFIC (t))
1167 pp_cxx_tree_identifier (cxx_pp, name);
1171 if (TREE_CODE (t) == TEMPLATE_DECL)
1172 t = DECL_TEMPLATE_RESULT (t);
1174 /* Don't let the user see __comp_ctor et al. */
1175 if (DECL_CONSTRUCTOR_P (t)
1176 || DECL_DESTRUCTOR_P (t))
1177 name = constructor_name (DECL_CONTEXT (t));
1179 if (DECL_DESTRUCTOR_P (t))
1181 pp_cxx_complement (cxx_pp);
1182 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1184 else if (DECL_CONV_FN_P (t))
1186 /* This cannot use the hack that the operator's return
1187 type is stashed off of its name because it may be
1188 used for error reporting. In the case of conflicting
1189 declarations, both will have the same name, yet
1190 the types will be different, hence the TREE_TYPE field
1191 of the first name will be clobbered by the second. */
1192 pp_cxx_identifier (cxx_pp, "operator");
1193 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1195 else if (IDENTIFIER_OPNAME_P (name))
1196 pp_cxx_tree_identifier (cxx_pp, name);
1198 dump_decl (name, flags);
1200 if (DECL_TEMPLATE_INFO (t)
1201 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1202 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1203 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1204 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1207 /* Dump the template parameters from the template info INFO under control of
1208 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1209 specialization (partial or complete). For partial specializations we show
1210 the specialized parameter values. For a primary template we show no
1214 dump_template_parms (tree info, int primary, int flags)
1216 tree args = info ? TI_ARGS (info) : NULL_TREE;
1218 if (primary && flags & TFF_TEMPLATE_NAME)
1220 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1221 pp_cxx_begin_template_argument_list (cxx_pp);
1223 /* Be careful only to print things when we have them, so as not
1224 to crash producing error messages. */
1225 if (args && !primary)
1229 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1230 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1232 len = TREE_VEC_LENGTH (args);
1234 for (ix = 0; ix != len; ix++)
1236 tree arg = TREE_VEC_ELT (args, ix);
1239 pp_separate_with_comma (cxx_pp);
1242 pp_identifier (cxx_pp, "<template parameter error>");
1244 dump_template_argument (arg, flags);
1249 tree tpl = TI_TEMPLATE (info);
1250 tree parms = DECL_TEMPLATE_PARMS (tpl);
1253 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1254 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1256 for (ix = 0; ix != len; ix++)
1260 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1262 pp_identifier (cxx_pp, "<template parameter error>");
1266 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1269 pp_separate_with_comma (cxx_pp);
1271 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1274 pp_cxx_end_template_argument_list (cxx_pp);
1277 /* Print out a list of initializers (subr of dump_expr). */
1280 dump_expr_list (tree l, int flags)
1284 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1287 pp_separate_with_comma (cxx_pp);
1291 /* Print out a vector of initializers (subr of dump_expr). */
1294 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1296 unsigned HOST_WIDE_INT idx;
1299 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1301 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1302 if (idx != VEC_length (constructor_elt, v) - 1)
1303 pp_separate_with_comma (cxx_pp);
1308 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1309 function. Resolve it to a close relative -- in the sense of static
1310 type -- variant being overridden. That is close to what was written in
1311 the source code. Subroutine of dump_expr. */
1314 resolve_virtual_fun_from_obj_type_ref (tree ref)
1316 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1317 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1318 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1321 fun = TREE_CHAIN (fun);
1322 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1323 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1329 /* Print out an expression E under control of FLAGS. */
1332 dump_expr (tree t, int flags)
1337 switch (TREE_CODE (t))
1345 case NAMESPACE_DECL:
1348 case IDENTIFIER_NODE:
1349 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1355 pp_constant (cxx_pp, t);
1359 pp_cxx_identifier (cxx_pp, "throw");
1360 dump_expr (TREE_OPERAND (t, 0), flags);
1364 pp_ampersand (cxx_pp);
1365 dump_type (PTRMEM_CST_CLASS (t), flags);
1366 pp_cxx_colon_colon (cxx_pp);
1367 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1371 pp_cxx_left_paren (cxx_pp);
1372 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1373 pp_separate_with_comma (cxx_pp);
1374 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1375 pp_cxx_right_paren (cxx_pp);
1379 pp_cxx_left_paren (cxx_pp);
1380 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1381 pp_string (cxx_pp, " ? ");
1382 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1383 pp_string (cxx_pp, " : ");
1384 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1385 pp_cxx_right_paren (cxx_pp);
1389 if (TREE_HAS_CONSTRUCTOR (t))
1391 pp_cxx_identifier (cxx_pp, "new");
1392 pp_cxx_whitespace (cxx_pp);
1393 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1396 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1399 case AGGR_INIT_EXPR:
1401 tree fn = NULL_TREE;
1403 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
1404 fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
1406 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1408 if (DECL_CONSTRUCTOR_P (fn))
1409 dump_type (DECL_CONTEXT (fn), flags);
1414 dump_expr (TREE_OPERAND (t, 0), 0);
1416 pp_cxx_left_paren (cxx_pp);
1417 if (TREE_OPERAND (t, 1))
1418 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1419 pp_cxx_right_paren (cxx_pp);
1424 tree fn = TREE_OPERAND (t, 0);
1425 tree args = TREE_OPERAND (t, 1);
1427 if (TREE_CODE (fn) == ADDR_EXPR)
1428 fn = TREE_OPERAND (fn, 0);
1430 /* Nobody is interested in seeing the guts of vcalls. */
1431 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1432 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1434 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1436 tree ob = TREE_VALUE (args);
1437 if (TREE_CODE (ob) == ADDR_EXPR)
1439 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1440 pp_cxx_dot (cxx_pp);
1442 else if (TREE_CODE (ob) != PARM_DECL
1443 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1445 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1446 pp_cxx_arrow (cxx_pp);
1448 args = TREE_CHAIN (args);
1450 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1451 pp_cxx_left_paren (cxx_pp);
1452 dump_expr_list (args, flags);
1453 pp_cxx_right_paren (cxx_pp);
1459 tree type = TREE_OPERAND (t, 1);
1460 tree init = TREE_OPERAND (t, 2);
1461 if (NEW_EXPR_USE_GLOBAL (t))
1462 pp_cxx_colon_colon (cxx_pp);
1463 pp_cxx_identifier (cxx_pp, "new");
1464 if (TREE_OPERAND (t, 0))
1466 pp_cxx_left_paren (cxx_pp);
1467 dump_expr_list (TREE_OPERAND (t, 0), flags);
1468 pp_cxx_right_paren (cxx_pp);
1469 pp_cxx_whitespace (cxx_pp);
1471 if (TREE_CODE (type) == ARRAY_REF)
1472 type = build_cplus_array_type
1473 (TREE_OPERAND (type, 0),
1474 build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
1475 TREE_OPERAND (type, 1),
1476 integer_one_node)));
1477 dump_type (type, flags);
1480 pp_cxx_left_paren (cxx_pp);
1481 if (TREE_CODE (init) == TREE_LIST)
1482 dump_expr_list (init, flags);
1483 else if (init == void_zero_node)
1484 /* This representation indicates an empty initializer,
1485 e.g.: "new int()". */
1488 dump_expr (init, flags);
1489 pp_cxx_right_paren (cxx_pp);
1495 /* Note that this only works for G++ target exprs. If somebody
1496 builds a general TARGET_EXPR, there's no way to represent that
1497 it initializes anything other that the parameter slot for the
1498 default argument. Note we may have cleared out the first
1499 operand in expand_expr, so don't go killing ourselves. */
1500 if (TREE_OPERAND (t, 1))
1501 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1509 case TRUNC_DIV_EXPR:
1510 case TRUNC_MOD_EXPR:
1518 case TRUTH_ANDIF_EXPR:
1519 case TRUTH_ORIF_EXPR:
1526 case EXACT_DIV_EXPR:
1527 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1531 case FLOOR_DIV_EXPR:
1532 case ROUND_DIV_EXPR:
1534 dump_binary_op ("/", t, flags);
1538 case FLOOR_MOD_EXPR:
1539 case ROUND_MOD_EXPR:
1540 dump_binary_op ("%", t, flags);
1545 tree ob = TREE_OPERAND (t, 0);
1546 if (TREE_CODE (ob) == INDIRECT_REF)
1548 ob = TREE_OPERAND (ob, 0);
1549 if (TREE_CODE (ob) != PARM_DECL
1551 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1553 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1554 pp_cxx_arrow (cxx_pp);
1559 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1560 pp_cxx_dot (cxx_pp);
1562 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1567 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1568 pp_cxx_left_bracket (cxx_pp);
1569 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1570 pp_cxx_right_bracket (cxx_pp);
1573 case UNARY_PLUS_EXPR:
1574 dump_unary_op ("+", t, flags);
1578 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1579 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1580 /* An ADDR_EXPR can have reference type. In that case, we
1581 shouldn't print the `&' doing so indicates to the user
1582 that the expression has pointer type. */
1584 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1585 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1586 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1587 dump_unary_op ("&&", t, flags);
1589 dump_unary_op ("&", t, flags);
1593 if (TREE_HAS_CONSTRUCTOR (t))
1595 t = TREE_OPERAND (t, 0);
1596 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1597 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1598 pp_cxx_left_paren (cxx_pp);
1599 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1600 pp_cxx_right_paren (cxx_pp);
1604 if (TREE_OPERAND (t,0) != NULL_TREE
1605 && TREE_TYPE (TREE_OPERAND (t, 0))
1606 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1607 dump_expr (TREE_OPERAND (t, 0), flags);
1609 dump_unary_op ("*", t, flags);
1615 case TRUTH_NOT_EXPR:
1616 case PREDECREMENT_EXPR:
1617 case PREINCREMENT_EXPR:
1618 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1621 case POSTDECREMENT_EXPR:
1622 case POSTINCREMENT_EXPR:
1623 pp_cxx_left_paren (cxx_pp);
1624 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1625 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1626 pp_cxx_right_paren (cxx_pp);
1629 case NON_LVALUE_EXPR:
1630 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1631 should be another level of INDIRECT_REF so that I don't have to do
1633 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1635 tree next = TREE_TYPE (TREE_TYPE (t));
1637 while (TREE_CODE (next) == POINTER_TYPE)
1638 next = TREE_TYPE (next);
1640 if (TREE_CODE (next) == FUNCTION_TYPE)
1642 if (flags & TFF_EXPR_IN_PARENS)
1643 pp_cxx_left_paren (cxx_pp);
1644 pp_cxx_star (cxx_pp);
1645 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1646 if (flags & TFF_EXPR_IN_PARENS)
1647 pp_cxx_right_paren (cxx_pp);
1650 /* Else fall through. */
1652 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1658 tree op = TREE_OPERAND (t, 0);
1660 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1662 /* It is a cast, but we cannot tell whether it is a
1663 reinterpret or static cast. Use the C style notation. */
1664 if (flags & TFF_EXPR_IN_PARENS)
1665 pp_cxx_left_paren (cxx_pp);
1666 pp_cxx_left_paren (cxx_pp);
1667 dump_type (TREE_TYPE (t), flags);
1668 pp_cxx_right_paren (cxx_pp);
1669 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1670 if (flags & TFF_EXPR_IN_PARENS)
1671 pp_cxx_right_paren (cxx_pp);
1674 dump_expr (op, flags);
1679 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1681 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1683 if (integer_zerop (idx))
1685 /* A NULL pointer-to-member constant. */
1686 pp_cxx_left_paren (cxx_pp);
1687 pp_cxx_left_paren (cxx_pp);
1688 dump_type (TREE_TYPE (t), flags);
1689 pp_cxx_right_paren (cxx_pp);
1690 pp_character (cxx_pp, '0');
1691 pp_cxx_right_paren (cxx_pp);
1694 else if (host_integerp (idx, 0))
1697 unsigned HOST_WIDE_INT n;
1699 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1700 t = TYPE_METHOD_BASETYPE (t);
1701 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1703 n = tree_low_cst (idx, 0);
1705 /* Map vtable index back one, to allow for the null pointer to
1709 while (n > 0 && virtuals)
1712 virtuals = TREE_CHAIN (virtuals);
1716 dump_expr (BV_FN (virtuals),
1717 flags | TFF_EXPR_IN_PARENS);
1722 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1724 dump_type (TREE_TYPE (t), 0);
1725 pp_cxx_left_paren (cxx_pp);
1726 pp_cxx_right_paren (cxx_pp);
1730 pp_cxx_left_brace (cxx_pp);
1731 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1732 pp_cxx_right_brace (cxx_pp);
1739 tree ob = TREE_OPERAND (t, 0);
1740 if (is_dummy_object (ob))
1742 t = TREE_OPERAND (t, 1);
1743 if (TREE_CODE (t) == FUNCTION_DECL)
1745 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1746 else if (BASELINK_P (t))
1747 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1748 flags | TFF_EXPR_IN_PARENS);
1750 dump_decl (t, flags);
1754 if (TREE_CODE (ob) == INDIRECT_REF)
1756 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1757 pp_cxx_arrow (cxx_pp);
1758 pp_cxx_star (cxx_pp);
1762 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1763 pp_cxx_dot (cxx_pp);
1764 pp_cxx_star (cxx_pp);
1766 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1771 case TEMPLATE_PARM_INDEX:
1772 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1776 pp_expression (cxx_pp, t);
1780 if (TREE_OPERAND (t, 0) == NULL_TREE
1781 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1783 dump_type (TREE_TYPE (t), flags);
1784 pp_cxx_left_paren (cxx_pp);
1785 dump_expr_list (TREE_OPERAND (t, 0), flags);
1786 pp_cxx_right_paren (cxx_pp);
1790 pp_cxx_left_paren (cxx_pp);
1791 dump_type (TREE_TYPE (t), flags);
1792 pp_cxx_right_paren (cxx_pp);
1793 pp_cxx_left_paren (cxx_pp);
1794 dump_expr_list (TREE_OPERAND (t, 0), flags);
1795 pp_cxx_right_paren (cxx_pp);
1799 case STATIC_CAST_EXPR:
1800 pp_cxx_identifier (cxx_pp, "static_cast");
1802 case REINTERPRET_CAST_EXPR:
1803 pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1805 case CONST_CAST_EXPR:
1806 pp_cxx_identifier (cxx_pp, "const_cast");
1808 case DYNAMIC_CAST_EXPR:
1809 pp_cxx_identifier (cxx_pp, "dynamic_cast");
1811 pp_cxx_begin_template_argument_list (cxx_pp);
1812 dump_type (TREE_TYPE (t), flags);
1813 pp_cxx_end_template_argument_list (cxx_pp);
1814 pp_cxx_left_paren (cxx_pp);
1815 dump_expr (TREE_OPERAND (t, 0), flags);
1816 pp_cxx_right_paren (cxx_pp);
1820 dump_expr (TREE_OPERAND (t, 0), flags);
1821 pp_cxx_arrow (cxx_pp);
1826 if (TREE_CODE (t) == SIZEOF_EXPR)
1827 pp_cxx_identifier (cxx_pp, "sizeof");
1830 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
1831 pp_cxx_identifier (cxx_pp, "__alignof__");
1833 pp_cxx_whitespace (cxx_pp);
1834 pp_cxx_left_paren (cxx_pp);
1835 if (TYPE_P (TREE_OPERAND (t, 0)))
1836 dump_type (TREE_OPERAND (t, 0), flags);
1838 dump_expr (TREE_OPERAND (t, 0), flags);
1839 pp_cxx_right_paren (cxx_pp);
1844 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1845 pp_cxx_whitespace (cxx_pp);
1846 dump_expr (TREE_OPERAND (t, 0), flags);
1850 pp_identifier (cxx_pp, "<unparsed>");
1853 case TRY_CATCH_EXPR:
1854 case WITH_CLEANUP_EXPR:
1855 case CLEANUP_POINT_EXPR:
1856 dump_expr (TREE_OPERAND (t, 0), flags);
1859 case PSEUDO_DTOR_EXPR:
1860 dump_expr (TREE_OPERAND (t, 2), flags);
1861 pp_cxx_dot (cxx_pp);
1862 dump_type (TREE_OPERAND (t, 0), flags);
1863 pp_cxx_colon_colon (cxx_pp);
1864 pp_cxx_complement (cxx_pp);
1865 dump_type (TREE_OPERAND (t, 1), flags);
1868 case TEMPLATE_ID_EXPR:
1869 dump_decl (t, flags);
1874 case STATEMENT_LIST:
1875 /* We don't yet have a way of dumping statements in a
1876 human-readable format. */
1877 pp_string (cxx_pp, "({...})");
1881 pp_string (cxx_pp, "while (1) { ");
1882 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1883 pp_cxx_right_brace (cxx_pp);
1887 pp_string (cxx_pp, "if (");
1888 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1889 pp_string (cxx_pp, ") break; ");
1893 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
1896 case EMPTY_CLASS_EXPR:
1897 dump_type (TREE_TYPE (t), flags);
1898 pp_cxx_left_paren (cxx_pp);
1899 pp_cxx_right_paren (cxx_pp);
1902 case NON_DEPENDENT_EXPR:
1903 dump_expr (TREE_OPERAND (t, 0), flags);
1906 /* This list is incomplete, but should suffice for now.
1907 It is very important that `sorry' does not call
1908 `report_error_function'. That could cause an infinite loop. */
1910 pp_unsupported_tree (cxx_pp, t);
1911 /* fall through to ERROR_MARK... */
1913 pp_identifier (cxx_pp, "<expression error>");
1919 dump_binary_op (const char *opstring, tree t, int flags)
1921 pp_cxx_left_paren (cxx_pp);
1922 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1923 pp_cxx_whitespace (cxx_pp);
1925 pp_cxx_identifier (cxx_pp, opstring);
1927 pp_identifier (cxx_pp, "<unknown operator>");
1928 pp_cxx_whitespace (cxx_pp);
1929 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1930 pp_cxx_right_paren (cxx_pp);
1934 dump_unary_op (const char *opstring, tree t, int flags)
1936 if (flags & TFF_EXPR_IN_PARENS)
1937 pp_cxx_left_paren (cxx_pp);
1938 pp_cxx_identifier (cxx_pp, opstring);
1939 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1940 if (flags & TFF_EXPR_IN_PARENS)
1941 pp_cxx_right_paren (cxx_pp);
1945 reinit_cxx_pp (void)
1947 pp_clear_output_area (cxx_pp);
1948 pp_base (cxx_pp)->padding = pp_none;
1949 pp_indentation (cxx_pp) = 0;
1950 pp_needs_newline (cxx_pp) = false;
1951 cxx_pp->enclosing_scope = 0;
1955 /* Exported interface to stringifying types, exprs and decls under TFF_*
1959 type_as_string (tree typ, int flags)
1962 dump_type (typ, flags);
1963 return pp_formatted_text (cxx_pp);
1967 expr_as_string (tree decl, int flags)
1970 dump_expr (decl, flags);
1971 return pp_formatted_text (cxx_pp);
1975 decl_as_string (tree decl, int flags)
1978 dump_decl (decl, flags);
1979 return pp_formatted_text (cxx_pp);
1982 /* Generate the three forms of printable names for cxx_printable_name. */
1985 lang_decl_name (tree decl, int v)
1988 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
1991 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
1993 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
1994 pp_cxx_colon_colon (cxx_pp);
1997 if (TREE_CODE (decl) == FUNCTION_DECL)
1998 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2000 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2002 return pp_formatted_text (cxx_pp);
2005 /* Return the location of a tree passed to %+ formats. */
2008 location_of (tree t)
2010 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2011 t = DECL_CONTEXT (t);
2012 else if (TYPE_P (t))
2013 t = TYPE_MAIN_DECL (t);
2014 else if (TREE_CODE (t) == OVERLOAD)
2015 t = OVL_FUNCTION (t);
2017 return DECL_SOURCE_LOCATION (t);
2020 /* Now the interfaces from error et al to dump_type et al. Each takes an
2021 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2025 decl_to_string (tree decl, int verbose)
2029 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2030 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2031 flags = TFF_CLASS_KEY_OR_ENUM;
2033 flags |= TFF_DECL_SPECIFIERS;
2034 else if (TREE_CODE (decl) == FUNCTION_DECL)
2035 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2036 flags |= TFF_TEMPLATE_HEADER;
2039 dump_decl (decl, flags);
2040 return pp_formatted_text (cxx_pp);
2044 expr_to_string (tree decl)
2047 dump_expr (decl, 0);
2048 return pp_formatted_text (cxx_pp);
2052 fndecl_to_string (tree fndecl, int verbose)
2056 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2057 | TFF_TEMPLATE_HEADER;
2059 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2061 dump_decl (fndecl, flags);
2062 return pp_formatted_text (cxx_pp);
2067 code_to_string (enum tree_code c)
2069 return tree_code_name [c];
2073 language_to_string (enum languages c)
2080 case lang_cplusplus:
2092 /* Return the proper printed version of a parameter to a C++ function. */
2095 parm_to_string (int p)
2099 pp_string (cxx_pp, "'this'");
2101 pp_decimal_int (cxx_pp, p + 1);
2102 return pp_formatted_text (cxx_pp);
2106 op_to_string (enum tree_code p)
2108 tree id = operator_name_info[(int) p].identifier;
2109 return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2113 type_to_string (tree typ, int verbose)
2117 flags |= TFF_CLASS_KEY_OR_ENUM;
2118 flags |= TFF_TEMPLATE_HEADER;
2121 dump_type (typ, flags);
2122 return pp_formatted_text (cxx_pp);
2126 assop_to_string (enum tree_code p)
2128 tree id = assignment_operator_name_info[(int) p].identifier;
2129 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2133 args_to_string (tree p, int verbose)
2137 flags |= TFF_CLASS_KEY_OR_ENUM;
2142 if (TYPE_P (TREE_VALUE (p)))
2143 return type_as_string (p, flags);
2146 for (; p; p = TREE_CHAIN (p))
2148 if (TREE_VALUE (p) == null_node)
2149 pp_cxx_identifier (cxx_pp, "NULL");
2151 dump_type (error_type (TREE_VALUE (p)), flags);
2153 pp_separate_with_comma (cxx_pp);
2155 return pp_formatted_text (cxx_pp);
2159 cv_to_string (tree p, int v)
2162 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2163 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2164 return pp_formatted_text (cxx_pp);
2167 /* Langhook for print_error_function. */
2169 cxx_print_error_function (diagnostic_context *context, const char *file)
2171 lhd_print_error_function (context, file);
2172 pp_base_set_prefix (context->printer, file);
2173 maybe_print_instantiation_context (context);
2177 cp_diagnostic_starter (diagnostic_context *context,
2178 diagnostic_info *diagnostic)
2180 diagnostic_report_current_module (context);
2181 cp_print_error_function (context, diagnostic);
2182 maybe_print_instantiation_context (context);
2183 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2187 cp_diagnostic_finalizer (diagnostic_context *context,
2188 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2190 pp_base_destroy_prefix (context->printer);
2193 /* Print current function onto BUFFER, in the process of reporting
2194 a diagnostic message. Called from cp_diagnostic_starter. */
2196 cp_print_error_function (diagnostic_context *context,
2197 diagnostic_info *diagnostic)
2199 if (diagnostic_last_function_changed (context))
2201 const char *old_prefix = context->printer->prefix;
2202 const char *file = LOCATION_FILE (diagnostic->location);
2203 char *new_prefix = file ? file_name_as_prefix (file) : NULL;
2205 pp_base_set_prefix (context->printer, new_prefix);
2207 if (current_function_decl == NULL)
2208 pp_base_string (context->printer, "At global scope:");
2210 pp_printf (context->printer, "In %s %qs:",
2211 function_category (current_function_decl),
2212 cxx_printable_name (current_function_decl, 2));
2213 pp_base_newline (context->printer);
2215 diagnostic_set_last_function (context);
2216 pp_base_destroy_prefix (context->printer);
2217 context->printer->prefix = old_prefix;
2221 /* Returns a description of FUNCTION using standard terminology. */
2223 function_category (tree fn)
2225 if (DECL_FUNCTION_MEMBER_P (fn))
2227 if (DECL_STATIC_FUNCTION_P (fn))
2228 return "static member function";
2229 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2230 return "copy constructor";
2231 else if (DECL_CONSTRUCTOR_P (fn))
2232 return "constructor";
2233 else if (DECL_DESTRUCTOR_P (fn))
2234 return "destructor";
2236 return "member function";
2242 /* Report the full context of a current template instantiation,
2245 print_instantiation_full_context (diagnostic_context *context)
2247 tree p = current_instantiation ();
2248 location_t location = input_location;
2252 if (current_function_decl != TINST_DECL (p)
2253 && current_function_decl != NULL_TREE)
2254 /* We can get here during the processing of some synthesized
2255 method. Then, TINST_DECL (p) will be the function that's causing
2260 if (current_function_decl == TINST_DECL (p))
2261 /* Avoid redundancy with the "In function" line. */;
2263 pp_verbatim (context->printer,
2264 "%s: In instantiation of %qs:\n",
2265 LOCATION_FILE (location),
2266 decl_as_string (TINST_DECL (p),
2267 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2269 location = TINST_LOCATION (p);
2274 print_instantiation_partial_context (context, p, location);
2277 /* Same as above but less verbose. */
2279 print_instantiation_partial_context (diagnostic_context *context,
2280 tree t, location_t loc)
2282 expanded_location xloc;
2283 for (; ; t = TREE_CHAIN (t))
2285 xloc = expand_location (loc);
2288 pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n",
2289 xloc.file, xloc.line,
2290 decl_as_string (TINST_DECL (t),
2291 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2292 loc = TINST_LOCATION (t);
2294 pp_verbatim (context->printer, "%s:%d: instantiated from here",
2295 xloc.file, xloc.line);
2296 pp_base_newline (context->printer);
2299 /* Called from cp_thing to print the template context for an error. */
2301 maybe_print_instantiation_context (diagnostic_context *context)
2303 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2306 record_last_problematic_instantiation ();
2307 print_instantiation_full_context (context);
2310 /* Report the bare minimum context of a template instantiation. */
2312 print_instantiation_context (void)
2314 print_instantiation_partial_context
2315 (global_dc, current_instantiation (), input_location);
2316 diagnostic_flush_buffer (global_dc);
2319 /* Called from output_format -- during diagnostic message processing --
2320 to handle C++ specific format specifier with the following meanings:
2321 %A function argument-list.
2325 %F function declaration.
2326 %L language as used in extern "lang".
2328 %P function parameter whose position is indicated by an integer.
2329 %Q assignment operator.
2333 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2334 int precision, bool wide, bool set_locus, bool verbose)
2338 #define next_tree (t = va_arg (*text->args_ptr, tree))
2339 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2340 #define next_lang va_arg (*text->args_ptr, enum languages)
2341 #define next_int va_arg (*text->args_ptr, int)
2343 if (precision != 0 || wide)
2346 if (text->locus == NULL)
2351 case 'A': result = args_to_string (next_tree, verbose); break;
2352 case 'C': result = code_to_string (next_tcode); break;
2355 tree temp = next_tree;
2357 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2359 temp = DECL_DEBUG_EXPR (temp);
2362 result = expr_to_string (temp);
2366 result = decl_to_string (temp, verbose);
2369 case 'E': result = expr_to_string (next_tree); break;
2370 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2371 case 'L': result = language_to_string (next_lang); break;
2372 case 'O': result = op_to_string (next_tcode); break;
2373 case 'P': result = parm_to_string (next_int); break;
2374 case 'Q': result = assop_to_string (next_tcode); break;
2375 case 'T': result = type_to_string (next_tree, verbose); break;
2376 case 'V': result = cv_to_string (next_tree, verbose); break;
2382 pp_base_string (pp, result);
2383 if (set_locus && t != NULL)
2384 *text->locus = location_of (t);
2392 /* Callback from cpp_error for PFILE to print diagnostics arising from
2393 interpreting strings. The diagnostic is of type LEVEL; MSG is the
2394 translated message and AP the arguments. */
2397 cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
2398 const char *msg, va_list *ap)
2400 diagnostic_info diagnostic;
2401 diagnostic_t dlevel;
2404 case CPP_DL_WARNING:
2405 case CPP_DL_WARNING_SYSHDR:
2406 dlevel = DK_WARNING;
2408 case CPP_DL_PEDWARN:
2409 dlevel = pedantic_error_kind ();
2420 diagnostic_set_info_translated (&diagnostic, msg, ap,
2421 input_location, dlevel);
2422 report_diagnostic (&diagnostic);