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. */
351 dump_type_prefix (t, flags);
352 dump_type_suffix (t, flags);
356 pp_cxx_cv_qualifier_seq (cxx_pp, t);
357 pp_cxx_identifier (cxx_pp,
358 TYPENAME_IS_ENUM_P (t) ? "enum"
359 : TYPENAME_IS_CLASS_P (t) ? "class"
361 dump_typename (t, flags);
364 case UNBOUND_CLASS_TEMPLATE:
365 dump_type (TYPE_CONTEXT (t), flags);
366 pp_cxx_colon_colon (cxx_pp);
367 pp_cxx_identifier (cxx_pp, "template");
368 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
372 pp_cxx_identifier (cxx_pp, "__typeof__");
373 pp_cxx_whitespace (cxx_pp);
374 pp_cxx_left_paren (cxx_pp);
375 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
376 pp_cxx_right_paren (cxx_pp);
380 pp_unsupported_tree (cxx_pp, t);
381 /* Fall through to error. */
384 pp_identifier (cxx_pp, "<type error>");
389 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
393 dump_typename (tree t, int flags)
395 tree ctx = TYPE_CONTEXT (t);
397 if (TREE_CODE (ctx) == TYPENAME_TYPE)
398 dump_typename (ctx, flags);
400 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
401 pp_cxx_colon_colon (cxx_pp);
402 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
405 /* Return the name of the supplied aggregate, or enumeral type. */
408 class_key_or_enum_as_string (tree t)
410 if (TREE_CODE (t) == ENUMERAL_TYPE)
412 else if (TREE_CODE (t) == UNION_TYPE)
414 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
420 /* Print out a class declaration T under the control of FLAGS,
421 in the form `class foo'. */
424 dump_aggr_type (tree t, int flags)
427 const char *variety = class_key_or_enum_as_string (t);
431 pp_cxx_cv_qualifier_seq (cxx_pp, t);
433 if (flags & TFF_CLASS_KEY_OR_ENUM)
434 pp_cxx_identifier (cxx_pp, variety);
436 if (flags & TFF_CHASE_TYPEDEF)
437 t = TYPE_MAIN_VARIANT (t);
439 name = TYPE_NAME (t);
443 typdef = !DECL_ARTIFICIAL (name);
444 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
445 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
446 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
447 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
448 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
451 /* Because the template names are mangled, we have to locate
452 the most general template, and use that name. */
453 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
455 while (DECL_TEMPLATE_INFO (tpl))
456 tpl = DECL_TI_TEMPLATE (tpl);
459 name = DECL_NAME (name);
462 if (name == 0 || ANON_AGGRNAME_P (name))
464 if (flags & TFF_CLASS_KEY_OR_ENUM)
465 pp_identifier (cxx_pp, "<anonymous>");
467 pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
470 pp_cxx_tree_identifier (cxx_pp, name);
472 dump_template_parms (TYPE_TEMPLATE_INFO (t),
473 !CLASSTYPE_USE_TEMPLATE (t),
474 flags & ~TFF_TEMPLATE_HEADER);
477 /* Dump into the obstack the initial part of the output for a given type.
478 This is necessary when dealing with things like functions returning
481 return type of `int (* fee ())()': pointer -> function -> int. Both
482 pointer (and reference and offset) and function (and member) types must
483 deal with prefix and suffix.
485 Arrays must also do this for DECL nodes, like int a[], and for things like
489 dump_type_prefix (tree t, int flags)
491 if (TYPE_PTRMEMFUNC_P (t))
493 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
497 switch (TREE_CODE (t))
502 tree sub = TREE_TYPE (t);
504 dump_type_prefix (sub, flags);
505 if (TREE_CODE (sub) == ARRAY_TYPE)
507 pp_cxx_whitespace (cxx_pp);
508 pp_cxx_left_paren (cxx_pp);
510 pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]);
511 pp_base (cxx_pp)->padding = pp_before;
512 pp_cxx_cv_qualifier_seq (cxx_pp, t);
518 dump_type_prefix (TREE_TYPE (t), flags);
519 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
521 pp_maybe_space (cxx_pp);
522 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
523 pp_cxx_left_paren (cxx_pp);
524 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
525 pp_cxx_colon_colon (cxx_pp);
527 pp_cxx_star (cxx_pp);
528 pp_cxx_cv_qualifier_seq (cxx_pp, t);
529 pp_base (cxx_pp)->padding = pp_before;
532 /* Can only be reached through function pointer -- this would not be
533 correct if FUNCTION_DECLs used it. */
535 dump_type_prefix (TREE_TYPE (t), flags);
536 pp_maybe_space (cxx_pp);
537 pp_cxx_left_paren (cxx_pp);
541 dump_type_prefix (TREE_TYPE (t), flags);
542 pp_maybe_space (cxx_pp);
543 pp_cxx_left_paren (cxx_pp);
544 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
545 pp_cxx_colon_colon (cxx_pp);
549 dump_type_prefix (TREE_TYPE (t), flags);
553 case IDENTIFIER_NODE:
558 case TEMPLATE_TYPE_PARM:
559 case TEMPLATE_TEMPLATE_PARM:
560 case BOUND_TEMPLATE_TEMPLATE_PARM:
571 dump_type (t, flags);
572 pp_base (cxx_pp)->padding = pp_before;
576 pp_unsupported_tree (cxx_pp, t);
579 pp_identifier (cxx_pp, "<typeprefixerror>");
584 /* Dump the suffix of type T, under control of FLAGS. This is the part
585 which appears after the identifier (or function parms). */
588 dump_type_suffix (tree t, int flags)
590 if (TYPE_PTRMEMFUNC_P (t))
591 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
593 switch (TREE_CODE (t))
598 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
599 pp_cxx_right_paren (cxx_pp);
600 dump_type_suffix (TREE_TYPE (t), flags);
603 /* Can only be reached through function pointer. */
608 pp_cxx_right_paren (cxx_pp);
609 arg = TYPE_ARG_TYPES (t);
610 if (TREE_CODE (t) == METHOD_TYPE)
611 arg = TREE_CHAIN (arg);
613 /* Function pointers don't have default args. Not in standard C++,
614 anyway; they may in g++, but we'll just pretend otherwise. */
615 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
617 if (TREE_CODE (t) == METHOD_TYPE)
618 pp_cxx_cv_qualifier_seq
619 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
621 pp_cxx_cv_qualifier_seq(cxx_pp, t);
622 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
623 dump_type_suffix (TREE_TYPE (t), flags);
628 pp_maybe_space (cxx_pp);
629 pp_cxx_left_bracket (cxx_pp);
632 if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
634 (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
635 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
636 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
637 flags & ~TFF_EXPR_IN_PARENS);
639 dump_expr (fold (cp_build_binary_op
640 (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
642 flags & ~TFF_EXPR_IN_PARENS);
644 pp_cxx_right_bracket (cxx_pp);
645 dump_type_suffix (TREE_TYPE (t), flags);
649 case IDENTIFIER_NODE:
654 case TEMPLATE_TYPE_PARM:
655 case TEMPLATE_TEMPLATE_PARM:
656 case BOUND_TEMPLATE_TEMPLATE_PARM:
670 pp_unsupported_tree (cxx_pp, t);
672 /* Don't mark it here, we should have already done in
679 dump_global_iord (tree t)
681 const char *p = NULL;
683 if (DECL_GLOBAL_CTOR_P (t))
685 else if (DECL_GLOBAL_DTOR_P (t))
690 pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
694 dump_simple_decl (tree t, tree type, int flags)
696 if (flags & TFF_DECL_SPECIFIERS)
698 dump_type_prefix (type, flags);
699 pp_maybe_space (cxx_pp);
701 if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
702 dump_scope (CP_DECL_CONTEXT (t), flags);
704 dump_decl (DECL_NAME (t), flags);
706 pp_identifier (cxx_pp, "<anonymous>");
707 if (flags & TFF_DECL_SPECIFIERS)
708 dump_type_suffix (type, flags);
711 /* Dump a human readable string for the decl T under control of FLAGS. */
714 dump_decl (tree t, int flags)
719 switch (TREE_CODE (t))
722 /* Don't say 'typedef class A' */
723 if (DECL_ARTIFICIAL (t))
725 if ((flags & TFF_DECL_SPECIFIERS)
726 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
727 /* Say `class T' not just `T'. */
728 pp_cxx_identifier (cxx_pp, "class");
730 dump_type (TREE_TYPE (t), flags);
733 if (flags & TFF_DECL_SPECIFIERS)
734 pp_cxx_identifier (cxx_pp, "typedef");
735 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
736 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
741 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
743 pp_string (cxx_pp, "vtable for ");
744 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
745 dump_type (DECL_CONTEXT (t), flags);
748 /* Else fall through. */
751 dump_simple_decl (t, TREE_TYPE (t), flags);
755 pp_string (cxx_pp, "<return value> ");
756 dump_simple_decl (t, TREE_TYPE (t), flags);
760 if (flags & TFF_DECL_SPECIFIERS)
761 pp_cxx_declaration (cxx_pp, t);
764 dump_scope (CP_DECL_CONTEXT (t), flags);
765 if (DECL_NAME (t) == NULL_TREE)
766 pp_identifier (cxx_pp, "<unnamed>");
768 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
773 pp_expression (cxx_pp, t);
777 dump_decl (TREE_OPERAND (t, 0), flags);
778 pp_cxx_left_bracket (cxx_pp);
779 dump_decl (TREE_OPERAND (t, 1), flags);
780 pp_cxx_right_bracket (cxx_pp);
783 /* So that we can do dump_decl on an aggr type. */
787 dump_type (t, flags);
791 /* This is a pseudo destructor call which has not been folded into
792 a PSEUDO_DTOR_EXPR yet. */
793 pp_cxx_complement (cxx_pp);
794 dump_type (TREE_OPERAND (t, 0), flags);
801 /* These special cases are duplicated here so that other functions
802 can feed identifiers to error and get them demangled properly. */
803 case IDENTIFIER_NODE:
804 if (IDENTIFIER_TYPENAME_P (t))
806 pp_cxx_identifier (cxx_pp, "operator");
807 /* Not exactly IDENTIFIER_TYPE_VALUE. */
808 dump_type (TREE_TYPE (t), flags);
812 pp_cxx_tree_identifier (cxx_pp, t);
819 if (DECL_CLASS_SCOPE_P (t))
821 dump_type (DECL_CONTEXT (t), flags);
822 pp_cxx_colon_colon (cxx_pp);
824 else if (DECL_CONTEXT (t))
826 dump_decl (DECL_CONTEXT (t), flags);
827 pp_cxx_colon_colon (cxx_pp);
829 dump_decl (DECL_NAME (t), flags);
833 /* If there's only one function, just treat it like an ordinary
839 if (! DECL_LANG_SPECIFIC (t))
840 pp_identifier (cxx_pp, "<built-in>");
841 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
842 dump_global_iord (t);
844 dump_function_decl (t, flags);
848 dump_template_decl (t, flags);
851 case TEMPLATE_ID_EXPR:
853 tree name = TREE_OPERAND (t, 0);
855 if (is_overloaded_fn (name))
856 name = DECL_NAME (get_first_fn (name));
857 dump_decl (name, flags);
858 pp_cxx_begin_template_argument_list (cxx_pp);
859 if (TREE_OPERAND (t, 1))
860 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
861 pp_cxx_end_template_argument_list (cxx_pp);
866 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
870 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
871 || (DECL_INITIAL (t) &&
872 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
873 dump_simple_decl (t, TREE_TYPE (t), flags);
874 else if (DECL_NAME (t))
875 dump_decl (DECL_NAME (t), flags);
876 else if (DECL_INITIAL (t))
877 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
879 pp_identifier (cxx_pp, "<enumerator>");
883 pp_cxx_identifier (cxx_pp, "using");
884 dump_type (USING_DECL_SCOPE (t), flags);
885 pp_cxx_colon_colon (cxx_pp);
886 dump_decl (DECL_NAME (t), flags);
890 dump_decl (BASELINK_FUNCTIONS (t), flags);
893 case NON_DEPENDENT_EXPR:
894 dump_expr (t, flags);
897 case TEMPLATE_TYPE_PARM:
898 if (flags & TFF_DECL_SPECIFIERS)
899 pp_cxx_declaration (cxx_pp, t);
901 pp_type_id (cxx_pp, t);
905 pp_unsupported_tree (cxx_pp, t);
906 /* Fall through to error. */
909 pp_identifier (cxx_pp, "<declaration error>");
914 /* Dump a template declaration T under control of FLAGS. This means the
915 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
918 dump_template_decl (tree t, int flags)
920 tree orig_parms = DECL_TEMPLATE_PARMS (t);
924 if (flags & TFF_TEMPLATE_HEADER)
926 for (parms = orig_parms = nreverse (orig_parms);
928 parms = TREE_CHAIN (parms))
930 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
931 int len = TREE_VEC_LENGTH (inner_parms);
933 pp_cxx_identifier (cxx_pp, "template");
934 pp_cxx_begin_template_argument_list (cxx_pp);
936 /* If we've shown the template prefix, we'd better show the
937 parameters' and decl's type too. */
938 flags |= TFF_DECL_SPECIFIERS;
940 for (i = 0; i < len; i++)
943 pp_separate_with_comma (cxx_pp);
944 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
946 pp_cxx_end_template_argument_list (cxx_pp);
947 pp_cxx_whitespace (cxx_pp);
949 nreverse(orig_parms);
951 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
952 /* Say `template<arg> class TT' not just `template<arg> TT'. */
953 pp_cxx_identifier (cxx_pp, "class");
956 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
957 dump_type (TREE_TYPE (t),
958 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
959 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
960 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
961 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
964 gcc_assert (TREE_TYPE (t));
965 switch (NEXT_CODE (t))
969 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
972 /* This case can occur with some invalid code. */
973 dump_type (TREE_TYPE (t),
974 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
975 | (flags & TFF_DECL_SPECIFIERS
976 ? TFF_CLASS_KEY_OR_ENUM : 0));
981 /* Pretty print a function decl. There are several ways we want to print a
982 function declaration. The TFF_ bits in FLAGS tells us how to behave.
983 As error can only apply the '#' flag once to give 0 and 1 for V, there
984 is %D which doesn't print the throw specs, and %F which does. */
987 dump_function_decl (tree t, int flags)
991 tree cname = NULL_TREE;
992 tree template_args = NULL_TREE;
993 tree template_parms = NULL_TREE;
994 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
996 if (TREE_CODE (t) == TEMPLATE_DECL)
997 t = DECL_TEMPLATE_RESULT (t);
999 /* Pretty print template instantiations only. */
1000 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
1004 template_args = DECL_TI_ARGS (t);
1005 tmpl = most_general_template (t);
1006 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1008 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1013 fntype = TREE_TYPE (t);
1014 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1016 if (DECL_CLASS_SCOPE_P (t))
1017 cname = DECL_CONTEXT (t);
1018 /* This is for partially instantiated template methods. */
1019 else if (TREE_CODE (fntype) == METHOD_TYPE)
1020 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1022 if (!(flags & TFF_DECL_SPECIFIERS))
1024 else if (DECL_STATIC_FUNCTION_P (t))
1025 pp_cxx_identifier (cxx_pp, "static");
1026 else if (DECL_VIRTUAL_P (t))
1027 pp_cxx_identifier (cxx_pp, "virtual");
1029 /* Print the return type? */
1031 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1032 && !DECL_DESTRUCTOR_P (t);
1034 dump_type_prefix (TREE_TYPE (fntype), flags);
1036 /* Print the function name. */
1039 dump_type (cname, flags);
1040 pp_cxx_colon_colon (cxx_pp);
1043 dump_scope (CP_DECL_CONTEXT (t), flags);
1045 dump_function_name (t, flags);
1047 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1049 dump_parameters (parmtypes, flags);
1051 if (TREE_CODE (fntype) == METHOD_TYPE)
1053 pp_base (cxx_pp)->padding = pp_before;
1054 pp_cxx_cv_qualifier_seq
1055 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1058 if (flags & TFF_EXCEPTION_SPECIFICATION)
1060 pp_base (cxx_pp)->padding = pp_before;
1061 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1065 dump_type_suffix (TREE_TYPE (fntype), flags);
1068 /* If T is a template instantiation, dump the parameter binding. */
1069 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1071 pp_cxx_whitespace (cxx_pp);
1072 pp_cxx_left_bracket (cxx_pp);
1073 pp_cxx_identifier (cxx_pp, "with");
1074 pp_cxx_whitespace (cxx_pp);
1075 dump_template_bindings (template_parms, template_args);
1076 pp_cxx_right_bracket (cxx_pp);
1080 /* Print a parameter list. If this is for a member function, the
1081 member object ptr (and any other hidden args) should have
1082 already been removed. */
1085 dump_parameters (tree parmtypes, int flags)
1089 pp_cxx_left_paren (cxx_pp);
1091 for (first = 1; parmtypes != void_list_node;
1092 parmtypes = TREE_CHAIN (parmtypes))
1095 pp_separate_with_comma (cxx_pp);
1099 pp_cxx_identifier (cxx_pp, "...");
1102 dump_type (TREE_VALUE (parmtypes), flags);
1104 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1106 pp_cxx_whitespace (cxx_pp);
1108 pp_cxx_whitespace (cxx_pp);
1109 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1113 pp_cxx_right_paren (cxx_pp);
1116 /* Print an exception specification. T is the exception specification. */
1119 dump_exception_spec (tree t, int flags)
1123 pp_cxx_identifier (cxx_pp, "throw");
1124 pp_cxx_whitespace (cxx_pp);
1125 pp_cxx_left_paren (cxx_pp);
1126 if (TREE_VALUE (t) != NULL_TREE)
1129 dump_type (TREE_VALUE (t), flags);
1133 pp_separate_with_comma (cxx_pp);
1135 pp_cxx_right_paren (cxx_pp);
1139 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1140 and destructors properly. */
1143 dump_function_name (tree t, int flags)
1145 tree name = DECL_NAME (t);
1147 /* We can get here with a decl that was synthesized by language-
1148 independent machinery (e.g. coverage.c) in which case it won't
1149 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1150 will crash. In this case it is safe just to print out the
1152 if (!DECL_LANG_SPECIFIC (t))
1154 pp_cxx_tree_identifier (cxx_pp, name);
1158 if (TREE_CODE (t) == TEMPLATE_DECL)
1159 t = DECL_TEMPLATE_RESULT (t);
1161 /* Don't let the user see __comp_ctor et al. */
1162 if (DECL_CONSTRUCTOR_P (t)
1163 || DECL_DESTRUCTOR_P (t))
1164 name = constructor_name (DECL_CONTEXT (t));
1166 if (DECL_DESTRUCTOR_P (t))
1168 pp_cxx_complement (cxx_pp);
1169 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1171 else if (DECL_CONV_FN_P (t))
1173 /* This cannot use the hack that the operator's return
1174 type is stashed off of its name because it may be
1175 used for error reporting. In the case of conflicting
1176 declarations, both will have the same name, yet
1177 the types will be different, hence the TREE_TYPE field
1178 of the first name will be clobbered by the second. */
1179 pp_cxx_identifier (cxx_pp, "operator");
1180 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1182 else if (IDENTIFIER_OPNAME_P (name))
1183 pp_cxx_tree_identifier (cxx_pp, name);
1185 dump_decl (name, flags);
1187 if (DECL_TEMPLATE_INFO (t)
1188 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1189 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1190 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1191 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1194 /* Dump the template parameters from the template info INFO under control of
1195 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1196 specialization (partial or complete). For partial specializations we show
1197 the specialized parameter values. For a primary template we show no
1201 dump_template_parms (tree info, int primary, int flags)
1203 tree args = info ? TI_ARGS (info) : NULL_TREE;
1205 if (primary && flags & TFF_TEMPLATE_NAME)
1207 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1208 pp_cxx_begin_template_argument_list (cxx_pp);
1210 /* Be careful only to print things when we have them, so as not
1211 to crash producing error messages. */
1212 if (args && !primary)
1216 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1217 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1219 len = TREE_VEC_LENGTH (args);
1221 for (ix = 0; ix != len; ix++)
1223 tree arg = TREE_VEC_ELT (args, ix);
1226 pp_separate_with_comma (cxx_pp);
1229 pp_identifier (cxx_pp, "<template parameter error>");
1231 dump_template_argument (arg, flags);
1236 tree tpl = TI_TEMPLATE (info);
1237 tree parms = DECL_TEMPLATE_PARMS (tpl);
1240 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1241 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1243 for (ix = 0; ix != len; ix++)
1247 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1249 pp_identifier (cxx_pp, "<template parameter error>");
1253 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1256 pp_separate_with_comma (cxx_pp);
1258 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1261 pp_cxx_end_template_argument_list (cxx_pp);
1264 /* Print out a list of initializers (subr of dump_expr). */
1267 dump_expr_list (tree l, int flags)
1271 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1274 pp_separate_with_comma (cxx_pp);
1278 /* Print out a vector of initializers (subr of dump_expr). */
1281 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1283 unsigned HOST_WIDE_INT idx;
1286 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1288 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1289 if (idx != VEC_length (constructor_elt, v) - 1)
1290 pp_separate_with_comma (cxx_pp);
1295 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1296 function. Resolve it to a close relative -- in the sense of static
1297 type -- variant being overridden. That is close to what was written in
1298 the source code. Subroutine of dump_expr. */
1301 resolve_virtual_fun_from_obj_type_ref (tree ref)
1303 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1304 int index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1305 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1307 fun = TREE_CHAIN (fun);
1312 /* Print out an expression E under control of FLAGS. */
1315 dump_expr (tree t, int flags)
1320 switch (TREE_CODE (t))
1328 case NAMESPACE_DECL:
1331 case IDENTIFIER_NODE:
1332 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1338 pp_constant (cxx_pp, t);
1342 pp_cxx_identifier (cxx_pp, "throw");
1343 dump_expr (TREE_OPERAND (t, 0), flags);
1347 pp_ampersand (cxx_pp);
1348 dump_type (PTRMEM_CST_CLASS (t), flags);
1349 pp_cxx_colon_colon (cxx_pp);
1350 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1354 pp_cxx_left_paren (cxx_pp);
1355 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1356 pp_separate_with_comma (cxx_pp);
1357 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1358 pp_cxx_right_paren (cxx_pp);
1362 pp_cxx_left_paren (cxx_pp);
1363 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1364 pp_string (cxx_pp, " ? ");
1365 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1366 pp_string (cxx_pp, " : ");
1367 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1368 pp_cxx_right_paren (cxx_pp);
1372 if (TREE_HAS_CONSTRUCTOR (t))
1374 pp_cxx_identifier (cxx_pp, "new");
1375 pp_cxx_whitespace (cxx_pp);
1376 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1379 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1382 case AGGR_INIT_EXPR:
1384 tree fn = NULL_TREE;
1386 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
1387 fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
1389 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1391 if (DECL_CONSTRUCTOR_P (fn))
1392 dump_type (DECL_CONTEXT (fn), flags);
1397 dump_expr (TREE_OPERAND (t, 0), 0);
1399 pp_cxx_left_paren (cxx_pp);
1400 if (TREE_OPERAND (t, 1))
1401 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1402 pp_cxx_right_paren (cxx_pp);
1407 tree fn = TREE_OPERAND (t, 0);
1408 tree args = TREE_OPERAND (t, 1);
1410 if (TREE_CODE (fn) == ADDR_EXPR)
1411 fn = TREE_OPERAND (fn, 0);
1413 /* Nobody is interested in seeing the guts of vcalls. */
1414 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1415 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1417 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1419 tree ob = TREE_VALUE (args);
1420 if (TREE_CODE (ob) == ADDR_EXPR)
1422 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1425 else if (TREE_CODE (ob) != PARM_DECL
1426 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1428 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1431 args = TREE_CHAIN (args);
1433 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1434 pp_cxx_left_paren (cxx_pp);
1435 dump_expr_list (args, flags);
1436 pp_cxx_right_paren (cxx_pp);
1442 tree type = TREE_OPERAND (t, 1);
1443 tree init = TREE_OPERAND (t, 2);
1444 if (NEW_EXPR_USE_GLOBAL (t))
1445 pp_cxx_colon_colon (cxx_pp);
1446 pp_cxx_identifier (cxx_pp, "new");
1447 if (TREE_OPERAND (t, 0))
1449 pp_cxx_left_paren (cxx_pp);
1450 dump_expr_list (TREE_OPERAND (t, 0), flags);
1451 pp_cxx_right_paren (cxx_pp);
1452 pp_cxx_whitespace (cxx_pp);
1454 if (TREE_CODE (type) == ARRAY_REF)
1455 type = build_cplus_array_type
1456 (TREE_OPERAND (type, 0),
1457 build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
1458 TREE_OPERAND (type, 1),
1459 integer_one_node)));
1460 dump_type (type, flags);
1463 pp_cxx_left_paren (cxx_pp);
1464 if (TREE_CODE (init) == TREE_LIST)
1465 dump_expr_list (init, flags);
1466 else if (init == void_zero_node)
1467 /* This representation indicates an empty initializer,
1468 e.g.: "new int()". */
1471 dump_expr (init, flags);
1472 pp_cxx_right_paren (cxx_pp);
1478 /* Note that this only works for G++ target exprs. If somebody
1479 builds a general TARGET_EXPR, there's no way to represent that
1480 it initializes anything other that the parameter slot for the
1481 default argument. Note we may have cleared out the first
1482 operand in expand_expr, so don't go killing ourselves. */
1483 if (TREE_OPERAND (t, 1))
1484 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1492 case TRUNC_DIV_EXPR:
1493 case TRUNC_MOD_EXPR:
1501 case TRUTH_ANDIF_EXPR:
1502 case TRUTH_ORIF_EXPR:
1509 case EXACT_DIV_EXPR:
1510 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1514 case FLOOR_DIV_EXPR:
1515 case ROUND_DIV_EXPR:
1517 dump_binary_op ("/", t, flags);
1521 case FLOOR_MOD_EXPR:
1522 case ROUND_MOD_EXPR:
1523 dump_binary_op ("%", t, flags);
1528 tree ob = TREE_OPERAND (t, 0);
1529 if (TREE_CODE (ob) == INDIRECT_REF)
1531 ob = TREE_OPERAND (ob, 0);
1532 if (TREE_CODE (ob) != PARM_DECL
1534 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1536 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1537 pp_cxx_arrow (cxx_pp);
1542 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1543 pp_cxx_dot (cxx_pp);
1545 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1550 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1551 pp_cxx_left_bracket (cxx_pp);
1552 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1553 pp_cxx_right_bracket (cxx_pp);
1556 case UNARY_PLUS_EXPR:
1557 dump_unary_op ("+", t, flags);
1561 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1562 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1563 /* An ADDR_EXPR can have reference type. In that case, we
1564 shouldn't print the `&' doing so indicates to the user
1565 that the expression has pointer type. */
1567 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1568 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1569 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1570 dump_unary_op ("&&", t, flags);
1572 dump_unary_op ("&", t, flags);
1576 if (TREE_HAS_CONSTRUCTOR (t))
1578 t = TREE_OPERAND (t, 0);
1579 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1580 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1581 pp_cxx_left_paren (cxx_pp);
1582 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1583 pp_cxx_right_paren (cxx_pp);
1587 if (TREE_OPERAND (t,0) != NULL_TREE
1588 && TREE_TYPE (TREE_OPERAND (t, 0))
1589 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1590 dump_expr (TREE_OPERAND (t, 0), flags);
1592 dump_unary_op ("*", t, flags);
1598 case TRUTH_NOT_EXPR:
1599 case PREDECREMENT_EXPR:
1600 case PREINCREMENT_EXPR:
1601 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1604 case POSTDECREMENT_EXPR:
1605 case POSTINCREMENT_EXPR:
1606 pp_cxx_left_paren (cxx_pp);
1607 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1608 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1609 pp_cxx_right_paren (cxx_pp);
1612 case NON_LVALUE_EXPR:
1613 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1614 should be another level of INDIRECT_REF so that I don't have to do
1616 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1618 tree next = TREE_TYPE (TREE_TYPE (t));
1620 while (TREE_CODE (next) == POINTER_TYPE)
1621 next = TREE_TYPE (next);
1623 if (TREE_CODE (next) == FUNCTION_TYPE)
1625 if (flags & TFF_EXPR_IN_PARENS)
1626 pp_cxx_left_paren (cxx_pp);
1627 pp_cxx_star (cxx_pp);
1628 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1629 if (flags & TFF_EXPR_IN_PARENS)
1630 pp_cxx_right_paren (cxx_pp);
1633 /* Else fall through. */
1635 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1641 tree op = TREE_OPERAND (t, 0);
1643 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1645 /* It is a cast, but we cannot tell whether it is a
1646 reinterpret or static cast. Use the C style notation. */
1647 if (flags & TFF_EXPR_IN_PARENS)
1648 pp_cxx_left_paren (cxx_pp);
1649 pp_cxx_left_paren (cxx_pp);
1650 dump_type (TREE_TYPE (t), flags);
1651 pp_cxx_right_paren (cxx_pp);
1652 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1653 if (flags & TFF_EXPR_IN_PARENS)
1654 pp_cxx_right_paren (cxx_pp);
1657 dump_expr (op, flags);
1662 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1664 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1666 if (integer_zerop (idx))
1668 /* A NULL pointer-to-member constant. */
1669 pp_cxx_left_paren (cxx_pp);
1670 pp_cxx_left_paren (cxx_pp);
1671 dump_type (TREE_TYPE (t), flags);
1672 pp_cxx_right_paren (cxx_pp);
1673 pp_character (cxx_pp, '0');
1674 pp_cxx_right_paren (cxx_pp);
1677 else if (host_integerp (idx, 0))
1680 unsigned HOST_WIDE_INT n;
1682 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1683 t = TYPE_METHOD_BASETYPE (t);
1684 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1686 n = tree_low_cst (idx, 0);
1688 /* Map vtable index back one, to allow for the null pointer to
1692 while (n > 0 && virtuals)
1695 virtuals = TREE_CHAIN (virtuals);
1699 dump_expr (BV_FN (virtuals),
1700 flags | TFF_EXPR_IN_PARENS);
1705 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1707 dump_type (TREE_TYPE (t), 0);
1708 pp_cxx_left_paren (cxx_pp);
1709 pp_cxx_right_paren (cxx_pp);
1713 pp_cxx_left_brace (cxx_pp);
1714 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1715 pp_cxx_right_brace (cxx_pp);
1722 tree ob = TREE_OPERAND (t, 0);
1723 if (is_dummy_object (ob))
1725 t = TREE_OPERAND (t, 1);
1726 if (TREE_CODE (t) == FUNCTION_DECL)
1728 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1729 else if (BASELINK_P (t))
1730 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1731 flags | TFF_EXPR_IN_PARENS);
1733 dump_decl (t, flags);
1737 if (TREE_CODE (ob) == INDIRECT_REF)
1739 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1740 pp_cxx_arrow (cxx_pp);
1741 pp_cxx_star (cxx_pp);
1745 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1746 pp_cxx_dot (cxx_pp);
1747 pp_cxx_star (cxx_pp);
1749 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1754 case TEMPLATE_PARM_INDEX:
1755 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1759 pp_expression (cxx_pp, t);
1763 if (TREE_OPERAND (t, 0) == NULL_TREE
1764 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1766 dump_type (TREE_TYPE (t), flags);
1767 pp_cxx_left_paren (cxx_pp);
1768 dump_expr_list (TREE_OPERAND (t, 0), flags);
1769 pp_cxx_right_paren (cxx_pp);
1773 pp_cxx_left_paren (cxx_pp);
1774 dump_type (TREE_TYPE (t), flags);
1775 pp_cxx_right_paren (cxx_pp);
1776 pp_cxx_left_paren (cxx_pp);
1777 dump_expr_list (TREE_OPERAND (t, 0), flags);
1778 pp_cxx_right_paren (cxx_pp);
1782 case STATIC_CAST_EXPR:
1783 pp_cxx_identifier (cxx_pp, "static_cast");
1785 case REINTERPRET_CAST_EXPR:
1786 pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1788 case CONST_CAST_EXPR:
1789 pp_cxx_identifier (cxx_pp, "const_cast");
1791 case DYNAMIC_CAST_EXPR:
1792 pp_cxx_identifier (cxx_pp, "dynamic_cast");
1794 pp_cxx_begin_template_argument_list (cxx_pp);
1795 dump_type (TREE_TYPE (t), flags);
1796 pp_cxx_end_template_argument_list (cxx_pp);
1797 pp_cxx_left_paren (cxx_pp);
1798 dump_expr (TREE_OPERAND (t, 0), flags);
1799 pp_cxx_right_paren (cxx_pp);
1803 dump_expr (TREE_OPERAND (t, 0), flags);
1804 pp_cxx_arrow (cxx_pp);
1809 if (TREE_CODE (t) == SIZEOF_EXPR)
1810 pp_cxx_identifier (cxx_pp, "sizeof");
1813 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
1814 pp_cxx_identifier (cxx_pp, "__alignof__");
1816 pp_cxx_whitespace (cxx_pp);
1817 pp_cxx_left_paren (cxx_pp);
1818 if (TYPE_P (TREE_OPERAND (t, 0)))
1819 dump_type (TREE_OPERAND (t, 0), flags);
1821 dump_expr (TREE_OPERAND (t, 0), flags);
1822 pp_cxx_right_paren (cxx_pp);
1827 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1828 pp_cxx_whitespace (cxx_pp);
1829 dump_expr (TREE_OPERAND (t, 0), flags);
1833 pp_identifier (cxx_pp, "<unparsed>");
1836 case TRY_CATCH_EXPR:
1837 case WITH_CLEANUP_EXPR:
1838 case CLEANUP_POINT_EXPR:
1839 dump_expr (TREE_OPERAND (t, 0), flags);
1842 case PSEUDO_DTOR_EXPR:
1843 dump_expr (TREE_OPERAND (t, 2), flags);
1844 pp_cxx_dot (cxx_pp);
1845 dump_type (TREE_OPERAND (t, 0), flags);
1846 pp_cxx_colon_colon (cxx_pp);
1847 pp_cxx_complement (cxx_pp);
1848 dump_type (TREE_OPERAND (t, 1), flags);
1851 case TEMPLATE_ID_EXPR:
1852 dump_decl (t, flags);
1857 case STATEMENT_LIST:
1858 /* We don't yet have a way of dumping statements in a
1859 human-readable format. */
1860 pp_string (cxx_pp, "({...})");
1864 pp_string (cxx_pp, "while (1) { ");
1865 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1866 pp_cxx_right_brace (cxx_pp);
1870 pp_string (cxx_pp, "if (");
1871 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1872 pp_string (cxx_pp, ") break; ");
1876 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
1879 case EMPTY_CLASS_EXPR:
1880 dump_type (TREE_TYPE (t), flags);
1881 pp_cxx_left_paren (cxx_pp);
1882 pp_cxx_right_paren (cxx_pp);
1885 case NON_DEPENDENT_EXPR:
1886 dump_expr (TREE_OPERAND (t, 0), flags);
1889 /* This list is incomplete, but should suffice for now.
1890 It is very important that `sorry' does not call
1891 `report_error_function'. That could cause an infinite loop. */
1893 pp_unsupported_tree (cxx_pp, t);
1894 /* fall through to ERROR_MARK... */
1896 pp_identifier (cxx_pp, "<expression error>");
1902 dump_binary_op (const char *opstring, tree t, int flags)
1904 pp_cxx_left_paren (cxx_pp);
1905 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1906 pp_cxx_whitespace (cxx_pp);
1908 pp_cxx_identifier (cxx_pp, opstring);
1910 pp_identifier (cxx_pp, "<unknown operator>");
1911 pp_cxx_whitespace (cxx_pp);
1912 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1913 pp_cxx_right_paren (cxx_pp);
1917 dump_unary_op (const char *opstring, tree t, int flags)
1919 if (flags & TFF_EXPR_IN_PARENS)
1920 pp_cxx_left_paren (cxx_pp);
1921 pp_cxx_identifier (cxx_pp, opstring);
1922 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1923 if (flags & TFF_EXPR_IN_PARENS)
1924 pp_cxx_right_paren (cxx_pp);
1928 reinit_cxx_pp (void)
1930 pp_clear_output_area (cxx_pp);
1931 pp_base (cxx_pp)->padding = pp_none;
1932 pp_indentation (cxx_pp) = 0;
1933 pp_needs_newline (cxx_pp) = false;
1934 cxx_pp->enclosing_scope = 0;
1938 /* Exported interface to stringifying types, exprs and decls under TFF_*
1942 type_as_string (tree typ, int flags)
1945 dump_type (typ, flags);
1946 return pp_formatted_text (cxx_pp);
1950 expr_as_string (tree decl, int flags)
1953 dump_expr (decl, flags);
1954 return pp_formatted_text (cxx_pp);
1958 decl_as_string (tree decl, int flags)
1961 dump_decl (decl, flags);
1962 return pp_formatted_text (cxx_pp);
1965 /* Generate the three forms of printable names for cxx_printable_name. */
1968 lang_decl_name (tree decl, int v)
1971 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
1974 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
1976 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
1977 pp_cxx_colon_colon (cxx_pp);
1980 if (TREE_CODE (decl) == FUNCTION_DECL)
1981 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
1983 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
1985 return pp_formatted_text (cxx_pp);
1988 /* Return the location of a tree passed to %+ formats. */
1991 location_of (tree t)
1993 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
1994 t = DECL_CONTEXT (t);
1995 else if (TYPE_P (t))
1996 t = TYPE_MAIN_DECL (t);
1997 else if (TREE_CODE (t) == OVERLOAD)
1998 t = OVL_FUNCTION (t);
2000 return DECL_SOURCE_LOCATION (t);
2003 /* Now the interfaces from error et al to dump_type et al. Each takes an
2004 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2008 decl_to_string (tree decl, int verbose)
2012 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2013 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2014 flags = TFF_CLASS_KEY_OR_ENUM;
2016 flags |= TFF_DECL_SPECIFIERS;
2017 else if (TREE_CODE (decl) == FUNCTION_DECL)
2018 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2019 flags |= TFF_TEMPLATE_HEADER;
2022 dump_decl (decl, flags);
2023 return pp_formatted_text (cxx_pp);
2027 expr_to_string (tree decl)
2030 dump_expr (decl, 0);
2031 return pp_formatted_text (cxx_pp);
2035 fndecl_to_string (tree fndecl, int verbose)
2039 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2040 | TFF_TEMPLATE_HEADER;
2042 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2044 dump_decl (fndecl, flags);
2045 return pp_formatted_text (cxx_pp);
2050 code_to_string (enum tree_code c)
2052 return tree_code_name [c];
2056 language_to_string (enum languages c)
2063 case lang_cplusplus:
2075 /* Return the proper printed version of a parameter to a C++ function. */
2078 parm_to_string (int p)
2082 pp_string (cxx_pp, "'this'");
2084 pp_decimal_int (cxx_pp, p + 1);
2085 return pp_formatted_text (cxx_pp);
2089 op_to_string (enum tree_code p)
2091 tree id = operator_name_info[(int) p].identifier;
2092 return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2096 type_to_string (tree typ, int verbose)
2100 flags |= TFF_CLASS_KEY_OR_ENUM;
2101 flags |= TFF_TEMPLATE_HEADER;
2104 dump_type (typ, flags);
2105 return pp_formatted_text (cxx_pp);
2109 assop_to_string (enum tree_code p)
2111 tree id = assignment_operator_name_info[(int) p].identifier;
2112 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2116 args_to_string (tree p, int verbose)
2120 flags |= TFF_CLASS_KEY_OR_ENUM;
2125 if (TYPE_P (TREE_VALUE (p)))
2126 return type_as_string (p, flags);
2129 for (; p; p = TREE_CHAIN (p))
2131 if (TREE_VALUE (p) == null_node)
2132 pp_cxx_identifier (cxx_pp, "NULL");
2134 dump_type (error_type (TREE_VALUE (p)), flags);
2136 pp_separate_with_comma (cxx_pp);
2138 return pp_formatted_text (cxx_pp);
2142 cv_to_string (tree p, int v)
2145 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2146 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2147 return pp_formatted_text (cxx_pp);
2150 /* Langhook for print_error_function. */
2152 cxx_print_error_function (diagnostic_context *context, const char *file)
2154 lhd_print_error_function (context, file);
2155 pp_base_set_prefix (context->printer, file);
2156 maybe_print_instantiation_context (context);
2160 cp_diagnostic_starter (diagnostic_context *context,
2161 diagnostic_info *diagnostic)
2163 diagnostic_report_current_module (context);
2164 cp_print_error_function (context, diagnostic);
2165 maybe_print_instantiation_context (context);
2166 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2170 cp_diagnostic_finalizer (diagnostic_context *context,
2171 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2173 pp_base_destroy_prefix (context->printer);
2176 /* Print current function onto BUFFER, in the process of reporting
2177 a diagnostic message. Called from cp_diagnostic_starter. */
2179 cp_print_error_function (diagnostic_context *context,
2180 diagnostic_info *diagnostic)
2182 if (diagnostic_last_function_changed (context))
2184 const char *old_prefix = context->printer->prefix;
2185 const char *file = LOCATION_FILE (diagnostic->location);
2186 char *new_prefix = file ? file_name_as_prefix (file) : NULL;
2188 pp_base_set_prefix (context->printer, new_prefix);
2190 if (current_function_decl == NULL)
2191 pp_base_string (context->printer, "At global scope:");
2193 pp_printf (context->printer, "In %s %qs:",
2194 function_category (current_function_decl),
2195 cxx_printable_name (current_function_decl, 2));
2196 pp_base_newline (context->printer);
2198 diagnostic_set_last_function (context);
2199 pp_base_destroy_prefix (context->printer);
2200 context->printer->prefix = old_prefix;
2204 /* Returns a description of FUNCTION using standard terminology. */
2206 function_category (tree fn)
2208 if (DECL_FUNCTION_MEMBER_P (fn))
2210 if (DECL_STATIC_FUNCTION_P (fn))
2211 return "static member function";
2212 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2213 return "copy constructor";
2214 else if (DECL_CONSTRUCTOR_P (fn))
2215 return "constructor";
2216 else if (DECL_DESTRUCTOR_P (fn))
2217 return "destructor";
2219 return "member function";
2225 /* Report the full context of a current template instantiation,
2228 print_instantiation_full_context (diagnostic_context *context)
2230 tree p = current_instantiation ();
2231 location_t location = input_location;
2235 if (current_function_decl != TINST_DECL (p)
2236 && current_function_decl != NULL_TREE)
2237 /* We can get here during the processing of some synthesized
2238 method. Then, TINST_DECL (p) will be the function that's causing
2243 if (current_function_decl == TINST_DECL (p))
2244 /* Avoid redundancy with the "In function" line. */;
2246 pp_verbatim (context->printer,
2247 "%s: In instantiation of %qs:\n",
2248 LOCATION_FILE (location),
2249 decl_as_string (TINST_DECL (p),
2250 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2252 location = TINST_LOCATION (p);
2257 print_instantiation_partial_context (context, p, location);
2260 /* Same as above but less verbose. */
2262 print_instantiation_partial_context (diagnostic_context *context,
2263 tree t, location_t loc)
2265 expanded_location xloc;
2266 for (; ; t = TREE_CHAIN (t))
2268 xloc = expand_location (loc);
2271 pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n",
2272 xloc.file, xloc.line,
2273 decl_as_string (TINST_DECL (t),
2274 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2275 loc = TINST_LOCATION (t);
2277 pp_verbatim (context->printer, "%s:%d: instantiated from here",
2278 xloc.file, xloc.line);
2279 pp_base_newline (context->printer);
2282 /* Called from cp_thing to print the template context for an error. */
2284 maybe_print_instantiation_context (diagnostic_context *context)
2286 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2289 record_last_problematic_instantiation ();
2290 print_instantiation_full_context (context);
2293 /* Report the bare minimum context of a template instantiation. */
2295 print_instantiation_context (void)
2297 print_instantiation_partial_context
2298 (global_dc, current_instantiation (), input_location);
2299 diagnostic_flush_buffer (global_dc);
2302 /* Called from output_format -- during diagnostic message processing --
2303 to handle C++ specific format specifier with the following meanings:
2304 %A function argument-list.
2308 %F function declaration.
2309 %L language as used in extern "lang".
2311 %P function parameter whose position is indicated by an integer.
2312 %Q assignment operator.
2316 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2317 int precision, bool wide, bool set_locus, bool verbose)
2321 #define next_tree (t = va_arg (*text->args_ptr, tree))
2322 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2323 #define next_lang va_arg (*text->args_ptr, enum languages)
2324 #define next_int va_arg (*text->args_ptr, int)
2326 if (precision != 0 || wide)
2329 if (text->locus == NULL)
2334 case 'A': result = args_to_string (next_tree, verbose); break;
2335 case 'C': result = code_to_string (next_tcode); break;
2338 tree temp = next_tree;
2340 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2342 temp = DECL_DEBUG_EXPR (temp);
2345 result = expr_to_string (temp);
2349 result = decl_to_string (temp, verbose);
2352 case 'E': result = expr_to_string (next_tree); break;
2353 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2354 case 'L': result = language_to_string (next_lang); break;
2355 case 'O': result = op_to_string (next_tcode); break;
2356 case 'P': result = parm_to_string (next_int); break;
2357 case 'Q': result = assop_to_string (next_tcode); break;
2358 case 'T': result = type_to_string (next_tree, verbose); break;
2359 case 'V': result = cv_to_string (next_tree, verbose); break;
2365 pp_base_string (pp, result);
2366 if (set_locus && t != NULL)
2367 *text->locus = location_of (t);
2375 /* Callback from cpp_error for PFILE to print diagnostics arising from
2376 interpreting strings. The diagnostic is of type LEVEL; MSG is the
2377 translated message and AP the arguments. */
2380 cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
2381 const char *msg, va_list *ap)
2383 diagnostic_info diagnostic;
2384 diagnostic_t dlevel;
2387 case CPP_DL_WARNING:
2388 case CPP_DL_WARNING_SYSHDR:
2389 dlevel = DK_WARNING;
2391 case CPP_DL_PEDWARN:
2392 dlevel = pedantic_error_kind ();
2403 diagnostic_set_info_translated (&diagnostic, msg, ap,
2404 input_location, dlevel);
2405 report_diagnostic (&diagnostic);