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, 2006, 2007, 2008, 2009 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 3, 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 COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
30 #include "diagnostic.h"
31 #include "langhooks-def.h"
32 #include "cxx-pretty-print.h"
34 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
36 /* The global buffer where we dump everything. It is there only for
37 transitional purpose. It is expected, in the near future, to be
38 completely removed. */
39 static cxx_pretty_printer scratch_pretty_printer;
40 #define cxx_pp (&scratch_pretty_printer)
42 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
44 static const char *args_to_string (tree, int);
45 static const char *assop_to_string (enum tree_code);
46 static const char *code_to_string (enum tree_code);
47 static const char *cv_to_string (tree, int);
48 static const char *decl_to_string (tree, int);
49 static const char *expr_to_string (tree);
50 static const char *fndecl_to_string (tree, int);
51 static const char *op_to_string (enum tree_code);
52 static const char *parm_to_string (int);
53 static const char *type_to_string (tree, int);
55 static void dump_type (tree, int);
56 static void dump_typename (tree, int);
57 static void dump_simple_decl (tree, tree, int);
58 static void dump_decl (tree, int);
59 static void dump_template_decl (tree, int);
60 static void dump_function_decl (tree, int);
61 static void dump_expr (tree, int);
62 static void dump_unary_op (const char *, tree, int);
63 static void dump_binary_op (const char *, tree, int);
64 static void dump_aggr_type (tree, int);
65 static void dump_type_prefix (tree, int);
66 static void dump_type_suffix (tree, int);
67 static void dump_function_name (tree, int);
68 static void dump_call_expr_args (tree, int, bool);
69 static void dump_aggr_init_expr_args (tree, int, bool);
70 static void dump_expr_list (tree, int);
71 static void dump_global_iord (tree);
72 static void dump_parameters (tree, int);
73 static void dump_exception_spec (tree, int);
74 static void dump_template_argument (tree, int);
75 static void dump_template_argument_list (tree, int);
76 static void dump_template_parameter (tree, int);
77 static void dump_template_bindings (tree, tree);
78 static void dump_scope (tree, int);
79 static void dump_template_parms (tree, int, int);
81 static const char *function_category (tree);
82 static void maybe_print_instantiation_context (diagnostic_context *);
83 static void print_instantiation_full_context (diagnostic_context *);
84 static void print_instantiation_partial_context (diagnostic_context *,
87 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
88 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
89 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
91 static bool cp_printer (pretty_printer *, text_info *, const char *,
92 int, bool, bool, bool);
93 static location_t location_of (tree);
98 diagnostic_starter (global_dc) = cp_diagnostic_starter;
99 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
100 diagnostic_format_decoder (global_dc) = cp_printer;
102 pp_construct (pp_base (cxx_pp), NULL, 0);
103 pp_cxx_pretty_printer_init (cxx_pp);
106 /* Dump a scope, if deemed necessary. */
109 dump_scope (tree scope, int flags)
111 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
113 if (scope == NULL_TREE)
116 if (TREE_CODE (scope) == NAMESPACE_DECL)
118 if (scope != global_namespace)
120 dump_decl (scope, f);
121 pp_cxx_colon_colon (cxx_pp);
124 else if (AGGREGATE_TYPE_P (scope))
126 dump_type (scope, f);
127 pp_cxx_colon_colon (cxx_pp);
129 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
131 dump_function_decl (scope, f);
132 pp_cxx_colon_colon (cxx_pp);
136 /* Dump the template ARGument under control of FLAGS. */
139 dump_template_argument (tree arg, int flags)
141 if (ARGUMENT_PACK_P (arg))
142 dump_template_argument_list (ARGUMENT_PACK_ARGS (arg), flags);
143 else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
144 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
147 if (TREE_CODE (arg) == TREE_LIST)
148 arg = TREE_VALUE (arg);
150 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
154 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
158 dump_template_argument_list (tree args, int flags)
160 int n = TREE_VEC_LENGTH (args);
164 for (i = 0; i< n; ++i)
166 tree arg = TREE_VEC_ELT (args, i);
168 /* Only print a comma if we know there is an argument coming. In
169 the case of an empty template argument pack, no actual
170 argument will be printed. */
172 && (!ARGUMENT_PACK_P (arg)
173 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
174 pp_separate_with_comma (cxx_pp);
176 dump_template_argument (arg, flags);
181 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
184 dump_template_parameter (tree parm, int flags)
189 if (parm == error_mark_node)
192 p = TREE_VALUE (parm);
193 a = TREE_PURPOSE (parm);
195 if (TREE_CODE (p) == TYPE_DECL)
197 if (flags & TFF_DECL_SPECIFIERS)
199 pp_cxx_identifier (cxx_pp, "class");
200 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
201 pp_cxx_identifier (cxx_pp, "...");
203 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
205 else if (DECL_NAME (p))
206 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
208 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
211 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
213 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
215 pp_cxx_whitespace (cxx_pp);
217 pp_cxx_whitespace (cxx_pp);
218 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
219 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
221 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
225 /* Dump, under control of FLAGS, a template-parameter-list binding.
226 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
230 dump_template_bindings (tree parms, tree args)
236 tree p = TREE_VALUE (parms);
237 int lvl = TMPL_PARMS_DEPTH (parms);
241 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
243 tree arg = NULL_TREE;
245 /* Don't crash if we had an invalid argument list. */
246 if (TMPL_ARGS_DEPTH (args) >= lvl)
248 tree lvl_args = TMPL_ARGS_LEVEL (args, lvl);
249 if (NUM_TMPL_ARGS (lvl_args) > arg_idx)
250 arg = TREE_VEC_ELT (lvl_args, arg_idx);
254 pp_separate_with_comma (cxx_pp);
255 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
256 pp_cxx_whitespace (cxx_pp);
258 pp_cxx_whitespace (cxx_pp);
260 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
262 pp_identifier (cxx_pp, "<missing>");
268 parms = TREE_CHAIN (parms);
272 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
276 dump_type (tree t, int flags)
281 if (TYPE_PTRMEMFUNC_P (t))
284 switch (TREE_CODE (t))
287 if (t == init_list_type_node)
288 pp_identifier (cxx_pp, "<brace-enclosed initializer list>");
290 pp_identifier (cxx_pp, "<unresolved overloaded function type>");
294 /* A list of function parms. */
295 dump_parameters (t, flags);
298 case IDENTIFIER_NODE:
299 pp_cxx_tree_identifier (cxx_pp, t);
303 dump_type (BINFO_TYPE (t), flags);
309 dump_aggr_type (t, flags);
313 if (flags & TFF_CHASE_TYPEDEF)
315 dump_type (DECL_ORIGINAL_TYPE (t)
316 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
319 /* Else fall through. */
323 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
332 case FIXED_POINT_TYPE:
333 pp_type_specifier_seq (cxx_pp, t);
336 case TEMPLATE_TEMPLATE_PARM:
337 /* For parameters inside template signature. */
338 if (TYPE_IDENTIFIER (t))
339 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
341 pp_cxx_canonical_template_parameter (cxx_pp, t);
344 case BOUND_TEMPLATE_TEMPLATE_PARM:
346 tree args = TYPE_TI_ARGS (t);
347 pp_cxx_cv_qualifier_seq (cxx_pp, t);
348 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
349 pp_cxx_begin_template_argument_list (cxx_pp);
350 dump_template_argument_list (args, flags);
351 pp_cxx_end_template_argument_list (cxx_pp);
355 case TEMPLATE_TYPE_PARM:
356 pp_cxx_cv_qualifier_seq (cxx_pp, t);
357 if (TYPE_IDENTIFIER (t))
358 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
360 pp_cxx_canonical_template_parameter
361 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
364 /* This is not always necessary for pointers and such, but doing this
365 reduces code size. */
374 dump_type_prefix (t, flags);
375 dump_type_suffix (t, flags);
379 pp_cxx_cv_qualifier_seq (cxx_pp, t);
380 pp_cxx_identifier (cxx_pp,
381 TYPENAME_IS_ENUM_P (t) ? "enum"
382 : TYPENAME_IS_CLASS_P (t) ? "class"
384 dump_typename (t, flags);
387 case UNBOUND_CLASS_TEMPLATE:
388 dump_type (TYPE_CONTEXT (t), flags);
389 pp_cxx_colon_colon (cxx_pp);
390 pp_cxx_identifier (cxx_pp, "template");
391 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
395 pp_cxx_identifier (cxx_pp, "__typeof__");
396 pp_cxx_whitespace (cxx_pp);
397 pp_cxx_left_paren (cxx_pp);
398 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
399 pp_cxx_right_paren (cxx_pp);
402 case TYPE_PACK_EXPANSION:
403 dump_type (PACK_EXPANSION_PATTERN (t), flags);
404 pp_cxx_identifier (cxx_pp, "...");
407 case TYPE_ARGUMENT_PACK:
408 dump_template_argument (t, flags);
412 pp_cxx_identifier (cxx_pp, "decltype");
413 pp_cxx_whitespace (cxx_pp);
414 pp_cxx_left_paren (cxx_pp);
415 dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
416 pp_cxx_right_paren (cxx_pp);
420 pp_unsupported_tree (cxx_pp, t);
421 /* Fall through to error. */
424 pp_identifier (cxx_pp, "<type error>");
429 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
433 dump_typename (tree t, int flags)
435 tree ctx = TYPE_CONTEXT (t);
437 if (TREE_CODE (ctx) == TYPENAME_TYPE)
438 dump_typename (ctx, flags);
440 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
441 pp_cxx_colon_colon (cxx_pp);
442 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
445 /* Return the name of the supplied aggregate, or enumeral type. */
448 class_key_or_enum_as_string (tree t)
450 if (TREE_CODE (t) == ENUMERAL_TYPE)
452 if (SCOPED_ENUM_P (t))
457 else if (TREE_CODE (t) == UNION_TYPE)
459 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
465 /* Print out a class declaration T under the control of FLAGS,
466 in the form `class foo'. */
469 dump_aggr_type (tree t, int flags)
472 const char *variety = class_key_or_enum_as_string (t);
476 pp_cxx_cv_qualifier_seq (cxx_pp, t);
478 if (flags & TFF_CLASS_KEY_OR_ENUM)
479 pp_cxx_identifier (cxx_pp, variety);
481 if (flags & TFF_CHASE_TYPEDEF)
482 t = TYPE_MAIN_VARIANT (t);
484 name = TYPE_NAME (t);
488 typdef = !DECL_ARTIFICIAL (name);
489 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
490 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
491 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
492 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
494 if (! (flags & TFF_UNQUALIFIED_NAME))
495 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
496 flags &= ~TFF_UNQUALIFIED_NAME;
499 /* Because the template names are mangled, we have to locate
500 the most general template, and use that name. */
501 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
503 while (DECL_TEMPLATE_INFO (tpl))
504 tpl = DECL_TI_TEMPLATE (tpl);
507 name = DECL_NAME (name);
510 if (name == 0 || ANON_AGGRNAME_P (name))
512 if (flags & TFF_CLASS_KEY_OR_ENUM)
513 pp_identifier (cxx_pp, "<anonymous>");
515 pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
518 pp_cxx_tree_identifier (cxx_pp, name);
520 dump_template_parms (TYPE_TEMPLATE_INFO (t),
521 !CLASSTYPE_USE_TEMPLATE (t),
522 flags & ~TFF_TEMPLATE_HEADER);
525 /* Dump into the obstack the initial part of the output for a given type.
526 This is necessary when dealing with things like functions returning
529 return type of `int (* fee ())()': pointer -> function -> int. Both
530 pointer (and reference and offset) and function (and member) types must
531 deal with prefix and suffix.
533 Arrays must also do this for DECL nodes, like int a[], and for things like
537 dump_type_prefix (tree t, int flags)
539 if (TYPE_PTRMEMFUNC_P (t))
541 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
545 switch (TREE_CODE (t))
550 tree sub = TREE_TYPE (t);
552 dump_type_prefix (sub, flags);
553 if (TREE_CODE (sub) == ARRAY_TYPE)
555 pp_cxx_whitespace (cxx_pp);
556 pp_cxx_left_paren (cxx_pp);
558 if (TREE_CODE (t) == POINTER_TYPE)
559 pp_character(cxx_pp, '*');
560 else if (TREE_CODE (t) == REFERENCE_TYPE)
562 if (TYPE_REF_IS_RVALUE (t))
563 pp_string (cxx_pp, "&&");
565 pp_character (cxx_pp, '&');
567 pp_base (cxx_pp)->padding = pp_before;
568 pp_cxx_cv_qualifier_seq (cxx_pp, t);
574 dump_type_prefix (TREE_TYPE (t), flags);
575 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
577 pp_maybe_space (cxx_pp);
578 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
579 pp_cxx_left_paren (cxx_pp);
580 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
581 pp_cxx_colon_colon (cxx_pp);
583 pp_cxx_star (cxx_pp);
584 pp_cxx_cv_qualifier_seq (cxx_pp, t);
585 pp_base (cxx_pp)->padding = pp_before;
588 /* Can only be reached through function pointer -- this would not be
589 correct if FUNCTION_DECLs used it. */
591 dump_type_prefix (TREE_TYPE (t), flags);
592 pp_maybe_space (cxx_pp);
593 pp_cxx_left_paren (cxx_pp);
597 dump_type_prefix (TREE_TYPE (t), flags);
598 pp_maybe_space (cxx_pp);
599 pp_cxx_left_paren (cxx_pp);
600 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
601 pp_cxx_colon_colon (cxx_pp);
605 dump_type_prefix (TREE_TYPE (t), flags);
609 case IDENTIFIER_NODE:
614 case TEMPLATE_TYPE_PARM:
615 case TEMPLATE_TEMPLATE_PARM:
616 case BOUND_TEMPLATE_TEMPLATE_PARM:
628 case TYPE_PACK_EXPANSION:
629 case FIXED_POINT_TYPE:
630 dump_type (t, flags);
631 pp_base (cxx_pp)->padding = pp_before;
635 pp_unsupported_tree (cxx_pp, t);
638 pp_identifier (cxx_pp, "<typeprefixerror>");
643 /* Dump the suffix of type T, under control of FLAGS. This is the part
644 which appears after the identifier (or function parms). */
647 dump_type_suffix (tree t, int flags)
649 if (TYPE_PTRMEMFUNC_P (t))
650 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
652 switch (TREE_CODE (t))
657 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
658 pp_cxx_right_paren (cxx_pp);
659 dump_type_suffix (TREE_TYPE (t), flags);
662 /* Can only be reached through function pointer. */
667 pp_cxx_right_paren (cxx_pp);
668 arg = TYPE_ARG_TYPES (t);
669 if (TREE_CODE (t) == METHOD_TYPE)
670 arg = TREE_CHAIN (arg);
672 /* Function pointers don't have default args. Not in standard C++,
673 anyway; they may in g++, but we'll just pretend otherwise. */
674 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
676 if (TREE_CODE (t) == METHOD_TYPE)
677 pp_cxx_cv_qualifier_seq
678 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
680 pp_cxx_cv_qualifier_seq(cxx_pp, t);
681 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
682 dump_type_suffix (TREE_TYPE (t), flags);
687 pp_maybe_space (cxx_pp);
688 pp_cxx_left_bracket (cxx_pp);
691 tree dtype = TYPE_DOMAIN (t);
692 tree max = TYPE_MAX_VALUE (dtype);
693 if (host_integerp (max, 0))
694 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
695 else if (TREE_CODE (max) == MINUS_EXPR)
696 dump_expr (TREE_OPERAND (max, 0),
697 flags & ~TFF_EXPR_IN_PARENS);
699 dump_expr (fold_build2 (PLUS_EXPR, dtype, max,
700 build_int_cst (dtype, 1)),
701 flags & ~TFF_EXPR_IN_PARENS);
703 pp_cxx_right_bracket (cxx_pp);
704 dump_type_suffix (TREE_TYPE (t), flags);
708 case IDENTIFIER_NODE:
713 case TEMPLATE_TYPE_PARM:
714 case TEMPLATE_TEMPLATE_PARM:
715 case BOUND_TEMPLATE_TEMPLATE_PARM:
727 case TYPE_PACK_EXPANSION:
728 case FIXED_POINT_TYPE:
732 pp_unsupported_tree (cxx_pp, t);
734 /* Don't mark it here, we should have already done in
741 dump_global_iord (tree t)
743 const char *p = NULL;
745 if (DECL_GLOBAL_CTOR_P (t))
747 else if (DECL_GLOBAL_DTOR_P (t))
752 pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
756 dump_simple_decl (tree t, tree type, int flags)
758 if (flags & TFF_DECL_SPECIFIERS)
760 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
761 pp_maybe_space (cxx_pp);
763 if (! (flags & TFF_UNQUALIFIED_NAME)
764 && (!DECL_INITIAL (t)
765 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
766 dump_scope (CP_DECL_CONTEXT (t), flags);
767 flags &= ~TFF_UNQUALIFIED_NAME;
768 if ((flags & TFF_DECL_SPECIFIERS)
769 && DECL_TEMPLATE_PARM_P (t)
770 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
771 pp_identifier (cxx_pp, "...");
773 dump_decl (DECL_NAME (t), flags);
775 pp_identifier (cxx_pp, "<anonymous>");
776 if (flags & TFF_DECL_SPECIFIERS)
777 dump_type_suffix (type, flags);
780 /* Dump a human readable string for the decl T under control of FLAGS. */
783 dump_decl (tree t, int flags)
788 switch (TREE_CODE (t))
791 /* Don't say 'typedef class A' */
792 if (DECL_ARTIFICIAL (t))
794 if ((flags & TFF_DECL_SPECIFIERS)
795 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
797 /* Say `class T' not just `T'. */
798 pp_cxx_identifier (cxx_pp, "class");
800 /* Emit the `...' for a parameter pack. */
801 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
802 pp_cxx_identifier (cxx_pp, "...");
805 dump_type (TREE_TYPE (t), flags);
808 if (flags & TFF_DECL_SPECIFIERS)
809 pp_cxx_identifier (cxx_pp, "typedef");
810 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
811 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
816 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
818 pp_string (cxx_pp, "vtable for ");
819 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
820 dump_type (DECL_CONTEXT (t), flags);
823 /* Else fall through. */
826 dump_simple_decl (t, TREE_TYPE (t), flags);
830 pp_string (cxx_pp, "<return value> ");
831 dump_simple_decl (t, TREE_TYPE (t), flags);
835 if (flags & TFF_DECL_SPECIFIERS)
836 pp_cxx_declaration (cxx_pp, t);
839 if (! (flags & TFF_UNQUALIFIED_NAME))
840 dump_scope (CP_DECL_CONTEXT (t), flags);
841 flags &= ~TFF_UNQUALIFIED_NAME;
842 if (DECL_NAME (t) == NULL_TREE)
843 pp_identifier (cxx_pp, "<unnamed>");
845 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
850 pp_expression (cxx_pp, t);
854 dump_decl (TREE_OPERAND (t, 0), flags);
855 pp_cxx_left_bracket (cxx_pp);
856 dump_decl (TREE_OPERAND (t, 1), flags);
857 pp_cxx_right_bracket (cxx_pp);
860 /* So that we can do dump_decl on an aggr type. */
864 dump_type (t, flags);
868 /* This is a pseudo destructor call which has not been folded into
869 a PSEUDO_DTOR_EXPR yet. */
870 pp_cxx_complement (cxx_pp);
871 dump_type (TREE_OPERAND (t, 0), flags);
878 /* These special cases are duplicated here so that other functions
879 can feed identifiers to error and get them demangled properly. */
880 case IDENTIFIER_NODE:
881 if (IDENTIFIER_TYPENAME_P (t))
883 pp_cxx_identifier (cxx_pp, "operator");
884 /* Not exactly IDENTIFIER_TYPE_VALUE. */
885 dump_type (TREE_TYPE (t), flags);
889 pp_cxx_tree_identifier (cxx_pp, t);
896 if (DECL_CLASS_SCOPE_P (t))
898 dump_type (DECL_CONTEXT (t), flags);
899 pp_cxx_colon_colon (cxx_pp);
901 else if (DECL_CONTEXT (t))
903 dump_decl (DECL_CONTEXT (t), flags);
904 pp_cxx_colon_colon (cxx_pp);
906 dump_decl (DECL_NAME (t), flags);
910 /* If there's only one function, just treat it like an ordinary
916 if (! DECL_LANG_SPECIFIC (t))
917 pp_identifier (cxx_pp, "<built-in>");
918 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
919 dump_global_iord (t);
921 dump_function_decl (t, flags);
925 dump_template_decl (t, flags);
928 case TEMPLATE_ID_EXPR:
930 tree name = TREE_OPERAND (t, 0);
932 if (is_overloaded_fn (name))
933 name = DECL_NAME (get_first_fn (name));
934 dump_decl (name, flags);
935 pp_cxx_begin_template_argument_list (cxx_pp);
936 if (TREE_OPERAND (t, 1))
937 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
938 pp_cxx_end_template_argument_list (cxx_pp);
943 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
947 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
948 || (DECL_INITIAL (t) &&
949 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
950 dump_simple_decl (t, TREE_TYPE (t), flags);
951 else if (DECL_NAME (t))
952 dump_decl (DECL_NAME (t), flags);
953 else if (DECL_INITIAL (t))
954 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
956 pp_identifier (cxx_pp, "<enumerator>");
960 pp_cxx_identifier (cxx_pp, "using");
961 dump_type (USING_DECL_SCOPE (t), flags);
962 pp_cxx_colon_colon (cxx_pp);
963 dump_decl (DECL_NAME (t), flags);
967 pp_cxx_declaration (cxx_pp, t);
971 dump_decl (BASELINK_FUNCTIONS (t), flags);
974 case NON_DEPENDENT_EXPR:
975 dump_expr (t, flags);
978 case TEMPLATE_TYPE_PARM:
979 if (flags & TFF_DECL_SPECIFIERS)
980 pp_cxx_declaration (cxx_pp, t);
982 pp_type_id (cxx_pp, t);
985 case UNBOUND_CLASS_TEMPLATE:
986 case TYPE_PACK_EXPANSION:
988 dump_type (t, flags);
992 pp_unsupported_tree (cxx_pp, t);
993 /* Fall through to error. */
996 pp_identifier (cxx_pp, "<declaration error>");
1001 /* Dump a template declaration T under control of FLAGS. This means the
1002 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1005 dump_template_decl (tree t, int flags)
1007 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1011 if (flags & TFF_TEMPLATE_HEADER)
1013 for (parms = orig_parms = nreverse (orig_parms);
1015 parms = TREE_CHAIN (parms))
1017 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1018 int len = TREE_VEC_LENGTH (inner_parms);
1020 pp_cxx_identifier (cxx_pp, "template");
1021 pp_cxx_begin_template_argument_list (cxx_pp);
1023 /* If we've shown the template prefix, we'd better show the
1024 parameters' and decl's type too. */
1025 flags |= TFF_DECL_SPECIFIERS;
1027 for (i = 0; i < len; i++)
1030 pp_separate_with_comma (cxx_pp);
1031 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1033 pp_cxx_end_template_argument_list (cxx_pp);
1034 pp_cxx_whitespace (cxx_pp);
1036 nreverse(orig_parms);
1038 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1040 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1041 pp_cxx_identifier (cxx_pp, "class");
1043 /* If this is a parameter pack, print the ellipsis. */
1044 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1045 pp_cxx_identifier (cxx_pp, "...");
1049 if (DECL_TEMPLATE_RESULT (t)
1050 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1051 dump_type (TREE_TYPE (t),
1052 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1053 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1054 else if (DECL_TEMPLATE_RESULT (t)
1055 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1056 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1059 gcc_assert (TREE_TYPE (t));
1060 switch (NEXT_CODE (t))
1064 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1067 /* This case can occur with some invalid code. */
1068 dump_type (TREE_TYPE (t),
1069 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1070 | (flags & TFF_DECL_SPECIFIERS
1071 ? TFF_CLASS_KEY_OR_ENUM : 0));
1076 /* Pretty print a function decl. There are several ways we want to print a
1077 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1078 As error can only apply the '#' flag once to give 0 and 1 for V, there
1079 is %D which doesn't print the throw specs, and %F which does. */
1082 dump_function_decl (tree t, int flags)
1086 tree cname = NULL_TREE;
1087 tree template_args = NULL_TREE;
1088 tree template_parms = NULL_TREE;
1089 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1090 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1093 flags &= ~TFF_UNQUALIFIED_NAME;
1094 if (TREE_CODE (t) == TEMPLATE_DECL)
1095 t = DECL_TEMPLATE_RESULT (t);
1097 /* Save the exceptions, in case t is a specialization and we are
1098 emitting an error about incompatible specifications. */
1099 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1101 /* Pretty print template instantiations only. */
1102 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
1106 template_args = DECL_TI_ARGS (t);
1107 tmpl = most_general_template (t);
1108 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1110 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1115 fntype = TREE_TYPE (t);
1116 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1118 if (DECL_CLASS_SCOPE_P (t))
1119 cname = DECL_CONTEXT (t);
1120 /* This is for partially instantiated template methods. */
1121 else if (TREE_CODE (fntype) == METHOD_TYPE)
1122 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1124 if (!(flags & TFF_DECL_SPECIFIERS))
1126 else if (DECL_STATIC_FUNCTION_P (t))
1127 pp_cxx_identifier (cxx_pp, "static");
1128 else if (DECL_VIRTUAL_P (t))
1129 pp_cxx_identifier (cxx_pp, "virtual");
1131 /* Print the return type? */
1133 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1134 && !DECL_DESTRUCTOR_P (t);
1136 dump_type_prefix (TREE_TYPE (fntype), flags);
1138 /* Print the function name. */
1139 if (!do_outer_scope)
1143 dump_type (cname, flags);
1144 pp_cxx_colon_colon (cxx_pp);
1147 dump_scope (CP_DECL_CONTEXT (t), flags);
1149 dump_function_name (t, flags);
1151 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1153 dump_parameters (parmtypes, flags);
1155 if (TREE_CODE (fntype) == METHOD_TYPE)
1157 pp_base (cxx_pp)->padding = pp_before;
1158 pp_cxx_cv_qualifier_seq
1159 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1162 if (flags & TFF_EXCEPTION_SPECIFICATION)
1164 pp_base (cxx_pp)->padding = pp_before;
1165 dump_exception_spec (exceptions, flags);
1169 dump_type_suffix (TREE_TYPE (fntype), flags);
1172 /* If T is a template instantiation, dump the parameter binding. */
1173 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1175 pp_cxx_whitespace (cxx_pp);
1176 pp_cxx_left_bracket (cxx_pp);
1177 pp_cxx_identifier (cxx_pp, "with");
1178 pp_cxx_whitespace (cxx_pp);
1179 dump_template_bindings (template_parms, template_args);
1180 pp_cxx_right_bracket (cxx_pp);
1184 /* Print a parameter list. If this is for a member function, the
1185 member object ptr (and any other hidden args) should have
1186 already been removed. */
1189 dump_parameters (tree parmtypes, int flags)
1192 pp_cxx_left_paren (cxx_pp);
1194 for (first = 1; parmtypes != void_list_node;
1195 parmtypes = TREE_CHAIN (parmtypes))
1198 pp_separate_with_comma (cxx_pp);
1202 pp_cxx_identifier (cxx_pp, "...");
1206 dump_type (TREE_VALUE (parmtypes), flags);
1208 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1210 pp_cxx_whitespace (cxx_pp);
1212 pp_cxx_whitespace (cxx_pp);
1213 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1217 pp_cxx_right_paren (cxx_pp);
1220 /* Print an exception specification. T is the exception specification. */
1223 dump_exception_spec (tree t, int flags)
1227 pp_cxx_identifier (cxx_pp, "throw");
1228 pp_cxx_whitespace (cxx_pp);
1229 pp_cxx_left_paren (cxx_pp);
1230 if (TREE_VALUE (t) != NULL_TREE)
1233 dump_type (TREE_VALUE (t), flags);
1237 pp_separate_with_comma (cxx_pp);
1239 pp_cxx_right_paren (cxx_pp);
1243 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1244 and destructors properly. */
1247 dump_function_name (tree t, int flags)
1249 tree name = DECL_NAME (t);
1251 /* We can get here with a decl that was synthesized by language-
1252 independent machinery (e.g. coverage.c) in which case it won't
1253 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1254 will crash. In this case it is safe just to print out the
1256 if (!DECL_LANG_SPECIFIC (t))
1258 pp_cxx_tree_identifier (cxx_pp, name);
1262 if (TREE_CODE (t) == TEMPLATE_DECL)
1263 t = DECL_TEMPLATE_RESULT (t);
1265 /* Don't let the user see __comp_ctor et al. */
1266 if (DECL_CONSTRUCTOR_P (t)
1267 || DECL_DESTRUCTOR_P (t))
1268 name = constructor_name (DECL_CONTEXT (t));
1270 if (DECL_DESTRUCTOR_P (t))
1272 pp_cxx_complement (cxx_pp);
1273 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1275 else if (DECL_CONV_FN_P (t))
1277 /* This cannot use the hack that the operator's return
1278 type is stashed off of its name because it may be
1279 used for error reporting. In the case of conflicting
1280 declarations, both will have the same name, yet
1281 the types will be different, hence the TREE_TYPE field
1282 of the first name will be clobbered by the second. */
1283 pp_cxx_identifier (cxx_pp, "operator");
1284 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1286 else if (IDENTIFIER_OPNAME_P (name))
1287 pp_cxx_tree_identifier (cxx_pp, name);
1289 dump_decl (name, flags);
1291 if (DECL_TEMPLATE_INFO (t)
1292 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1293 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1294 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1295 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1298 /* Dump the template parameters from the template info INFO under control of
1299 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1300 specialization (partial or complete). For partial specializations we show
1301 the specialized parameter values. For a primary template we show no
1305 dump_template_parms (tree info, int primary, int flags)
1307 tree args = info ? TI_ARGS (info) : NULL_TREE;
1309 if (primary && flags & TFF_TEMPLATE_NAME)
1311 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1312 pp_cxx_begin_template_argument_list (cxx_pp);
1314 /* Be careful only to print things when we have them, so as not
1315 to crash producing error messages. */
1316 if (args && !primary)
1320 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1321 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1323 len = TREE_VEC_LENGTH (args);
1325 for (ix = 0; ix != len; ix++)
1327 tree arg = TREE_VEC_ELT (args, ix);
1329 /* Only print a comma if we know there is an argument coming. In
1330 the case of an empty template argument pack, no actual
1331 argument will be printed. */
1333 && (!ARGUMENT_PACK_P (arg)
1334 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1335 pp_separate_with_comma (cxx_pp);
1338 pp_identifier (cxx_pp, "<template parameter error>");
1340 dump_template_argument (arg, flags);
1345 tree tpl = TI_TEMPLATE (info);
1346 tree parms = DECL_TEMPLATE_PARMS (tpl);
1349 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1350 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1352 for (ix = 0; ix != len; ix++)
1356 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1358 pp_identifier (cxx_pp, "<template parameter error>");
1362 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1365 pp_separate_with_comma (cxx_pp);
1367 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1370 pp_cxx_end_template_argument_list (cxx_pp);
1373 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1374 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1377 dump_call_expr_args (tree t, int flags, bool skipfirst)
1380 call_expr_arg_iterator iter;
1382 pp_cxx_left_paren (cxx_pp);
1383 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1389 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1390 if (more_call_expr_args_p (&iter))
1391 pp_separate_with_comma (cxx_pp);
1394 pp_cxx_right_paren (cxx_pp);
1397 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1398 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1402 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1405 aggr_init_expr_arg_iterator iter;
1407 pp_cxx_left_paren (cxx_pp);
1408 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1414 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1415 if (more_aggr_init_expr_args_p (&iter))
1416 pp_separate_with_comma (cxx_pp);
1419 pp_cxx_right_paren (cxx_pp);
1422 /* Print out a list of initializers (subr of dump_expr). */
1425 dump_expr_list (tree l, int flags)
1429 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1432 pp_separate_with_comma (cxx_pp);
1436 /* Print out a vector of initializers (subr of dump_expr). */
1439 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1441 unsigned HOST_WIDE_INT idx;
1444 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1446 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1447 if (idx != VEC_length (constructor_elt, v) - 1)
1448 pp_separate_with_comma (cxx_pp);
1453 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1454 function. Resolve it to a close relative -- in the sense of static
1455 type -- variant being overridden. That is close to what was written in
1456 the source code. Subroutine of dump_expr. */
1459 resolve_virtual_fun_from_obj_type_ref (tree ref)
1461 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1462 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1463 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1466 fun = TREE_CHAIN (fun);
1467 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1468 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1474 /* Print out an expression E under control of FLAGS. */
1477 dump_expr (tree t, int flags)
1482 if (STATEMENT_CLASS_P (t))
1484 pp_cxx_identifier (cxx_pp, "<statement>");
1488 switch (TREE_CODE (t))
1496 case NAMESPACE_DECL:
1499 case IDENTIFIER_NODE:
1500 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1507 pp_constant (cxx_pp, t);
1511 pp_cxx_identifier (cxx_pp, "throw");
1512 dump_expr (TREE_OPERAND (t, 0), flags);
1516 pp_ampersand (cxx_pp);
1517 dump_type (PTRMEM_CST_CLASS (t), flags);
1518 pp_cxx_colon_colon (cxx_pp);
1519 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1523 pp_cxx_left_paren (cxx_pp);
1524 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1525 pp_separate_with_comma (cxx_pp);
1526 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1527 pp_cxx_right_paren (cxx_pp);
1531 pp_cxx_left_paren (cxx_pp);
1532 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1533 pp_string (cxx_pp, " ? ");
1534 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1535 pp_string (cxx_pp, " : ");
1536 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1537 pp_cxx_right_paren (cxx_pp);
1541 if (TREE_HAS_CONSTRUCTOR (t))
1543 pp_cxx_identifier (cxx_pp, "new");
1544 pp_cxx_whitespace (cxx_pp);
1545 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1548 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1551 case AGGR_INIT_EXPR:
1553 tree fn = NULL_TREE;
1555 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1556 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1558 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1560 if (DECL_CONSTRUCTOR_P (fn))
1561 dump_type (DECL_CONTEXT (fn), flags);
1566 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1568 dump_aggr_init_expr_args (t, flags, true);
1573 tree fn = CALL_EXPR_FN (t);
1574 bool skipfirst = false;
1576 if (TREE_CODE (fn) == ADDR_EXPR)
1577 fn = TREE_OPERAND (fn, 0);
1579 /* Nobody is interested in seeing the guts of vcalls. */
1580 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1581 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1583 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1585 tree ob = CALL_EXPR_ARG (t, 0);
1586 if (TREE_CODE (ob) == ADDR_EXPR)
1588 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1589 pp_cxx_dot (cxx_pp);
1591 else if (TREE_CODE (ob) != PARM_DECL
1592 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1594 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1595 pp_cxx_arrow (cxx_pp);
1599 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1600 dump_call_expr_args (t, flags, skipfirst);
1605 /* Note that this only works for G++ target exprs. If somebody
1606 builds a general TARGET_EXPR, there's no way to represent that
1607 it initializes anything other that the parameter slot for the
1608 default argument. Note we may have cleared out the first
1609 operand in expand_expr, so don't go killing ourselves. */
1610 if (TREE_OPERAND (t, 1))
1611 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1614 case POINTER_PLUS_EXPR:
1615 dump_binary_op ("+", t, flags);
1623 case TRUNC_DIV_EXPR:
1624 case TRUNC_MOD_EXPR:
1632 case TRUTH_ANDIF_EXPR:
1633 case TRUTH_ORIF_EXPR:
1640 case EXACT_DIV_EXPR:
1641 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1645 case FLOOR_DIV_EXPR:
1646 case ROUND_DIV_EXPR:
1648 dump_binary_op ("/", t, flags);
1652 case FLOOR_MOD_EXPR:
1653 case ROUND_MOD_EXPR:
1654 dump_binary_op ("%", t, flags);
1659 tree ob = TREE_OPERAND (t, 0);
1660 if (TREE_CODE (ob) == INDIRECT_REF)
1662 ob = TREE_OPERAND (ob, 0);
1663 if (TREE_CODE (ob) != PARM_DECL
1665 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1667 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1668 pp_cxx_arrow (cxx_pp);
1673 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1674 pp_cxx_dot (cxx_pp);
1676 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1681 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1682 pp_cxx_left_bracket (cxx_pp);
1683 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1684 pp_cxx_right_bracket (cxx_pp);
1687 case UNARY_PLUS_EXPR:
1688 dump_unary_op ("+", t, flags);
1692 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1693 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1694 /* An ADDR_EXPR can have reference type. In that case, we
1695 shouldn't print the `&' doing so indicates to the user
1696 that the expression has pointer type. */
1698 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1699 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1700 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1701 dump_unary_op ("&&", t, flags);
1703 dump_unary_op ("&", t, flags);
1707 if (TREE_HAS_CONSTRUCTOR (t))
1709 t = TREE_OPERAND (t, 0);
1710 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1711 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1712 dump_call_expr_args (t, flags, true);
1716 if (TREE_OPERAND (t,0) != NULL_TREE
1717 && TREE_TYPE (TREE_OPERAND (t, 0))
1718 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1719 dump_expr (TREE_OPERAND (t, 0), flags);
1721 dump_unary_op ("*", t, flags);
1727 case TRUTH_NOT_EXPR:
1728 case PREDECREMENT_EXPR:
1729 case PREINCREMENT_EXPR:
1730 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1733 case POSTDECREMENT_EXPR:
1734 case POSTINCREMENT_EXPR:
1735 pp_cxx_left_paren (cxx_pp);
1736 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1737 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1738 pp_cxx_right_paren (cxx_pp);
1741 case NON_LVALUE_EXPR:
1742 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1743 should be another level of INDIRECT_REF so that I don't have to do
1745 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1747 tree next = TREE_TYPE (TREE_TYPE (t));
1749 while (TREE_CODE (next) == POINTER_TYPE)
1750 next = TREE_TYPE (next);
1752 if (TREE_CODE (next) == FUNCTION_TYPE)
1754 if (flags & TFF_EXPR_IN_PARENS)
1755 pp_cxx_left_paren (cxx_pp);
1756 pp_cxx_star (cxx_pp);
1757 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1758 if (flags & TFF_EXPR_IN_PARENS)
1759 pp_cxx_right_paren (cxx_pp);
1762 /* Else fall through. */
1764 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1768 case VIEW_CONVERT_EXPR:
1770 tree op = TREE_OPERAND (t, 0);
1772 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1774 /* It is a cast, but we cannot tell whether it is a
1775 reinterpret or static cast. Use the C style notation. */
1776 if (flags & TFF_EXPR_IN_PARENS)
1777 pp_cxx_left_paren (cxx_pp);
1778 pp_cxx_left_paren (cxx_pp);
1779 dump_type (TREE_TYPE (t), flags);
1780 pp_cxx_right_paren (cxx_pp);
1781 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1782 if (flags & TFF_EXPR_IN_PARENS)
1783 pp_cxx_right_paren (cxx_pp);
1786 dump_expr (op, flags);
1791 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1793 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1795 if (integer_zerop (idx))
1797 /* A NULL pointer-to-member constant. */
1798 pp_cxx_left_paren (cxx_pp);
1799 pp_cxx_left_paren (cxx_pp);
1800 dump_type (TREE_TYPE (t), flags);
1801 pp_cxx_right_paren (cxx_pp);
1802 pp_character (cxx_pp, '0');
1803 pp_cxx_right_paren (cxx_pp);
1806 else if (host_integerp (idx, 0))
1809 unsigned HOST_WIDE_INT n;
1811 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1812 t = TYPE_METHOD_BASETYPE (t);
1813 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1815 n = tree_low_cst (idx, 0);
1817 /* Map vtable index back one, to allow for the null pointer to
1821 while (n > 0 && virtuals)
1824 virtuals = TREE_CHAIN (virtuals);
1828 dump_expr (BV_FN (virtuals),
1829 flags | TFF_EXPR_IN_PARENS);
1834 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1836 dump_type (TREE_TYPE (t), 0);
1837 pp_cxx_left_paren (cxx_pp);
1838 pp_cxx_right_paren (cxx_pp);
1842 pp_cxx_left_brace (cxx_pp);
1843 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1844 pp_cxx_right_brace (cxx_pp);
1851 tree ob = TREE_OPERAND (t, 0);
1852 if (is_dummy_object (ob))
1854 t = TREE_OPERAND (t, 1);
1855 if (TREE_CODE (t) == FUNCTION_DECL)
1857 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1858 else if (BASELINK_P (t))
1859 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1860 flags | TFF_EXPR_IN_PARENS);
1862 dump_decl (t, flags);
1866 if (TREE_CODE (ob) == INDIRECT_REF)
1868 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1869 pp_cxx_arrow (cxx_pp);
1870 pp_cxx_star (cxx_pp);
1874 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1875 pp_cxx_dot (cxx_pp);
1876 pp_cxx_star (cxx_pp);
1878 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1883 case TEMPLATE_PARM_INDEX:
1884 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1888 if (TREE_OPERAND (t, 0) == NULL_TREE
1889 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1891 dump_type (TREE_TYPE (t), flags);
1892 pp_cxx_left_paren (cxx_pp);
1893 dump_expr_list (TREE_OPERAND (t, 0), flags);
1894 pp_cxx_right_paren (cxx_pp);
1898 pp_cxx_left_paren (cxx_pp);
1899 dump_type (TREE_TYPE (t), flags);
1900 pp_cxx_right_paren (cxx_pp);
1901 pp_cxx_left_paren (cxx_pp);
1902 dump_expr_list (TREE_OPERAND (t, 0), flags);
1903 pp_cxx_right_paren (cxx_pp);
1907 case STATIC_CAST_EXPR:
1908 pp_cxx_identifier (cxx_pp, "static_cast");
1910 case REINTERPRET_CAST_EXPR:
1911 pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1913 case CONST_CAST_EXPR:
1914 pp_cxx_identifier (cxx_pp, "const_cast");
1916 case DYNAMIC_CAST_EXPR:
1917 pp_cxx_identifier (cxx_pp, "dynamic_cast");
1919 pp_cxx_begin_template_argument_list (cxx_pp);
1920 dump_type (TREE_TYPE (t), flags);
1921 pp_cxx_end_template_argument_list (cxx_pp);
1922 pp_cxx_left_paren (cxx_pp);
1923 dump_expr (TREE_OPERAND (t, 0), flags);
1924 pp_cxx_right_paren (cxx_pp);
1928 dump_expr (TREE_OPERAND (t, 0), flags);
1929 pp_cxx_arrow (cxx_pp);
1934 if (TREE_CODE (t) == SIZEOF_EXPR)
1935 pp_cxx_identifier (cxx_pp, "sizeof");
1938 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
1939 pp_cxx_identifier (cxx_pp, "__alignof__");
1941 pp_cxx_whitespace (cxx_pp);
1942 pp_cxx_left_paren (cxx_pp);
1943 if (TYPE_P (TREE_OPERAND (t, 0)))
1944 dump_type (TREE_OPERAND (t, 0), flags);
1946 dump_expr (TREE_OPERAND (t, 0), flags);
1947 pp_cxx_right_paren (cxx_pp);
1952 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1953 pp_cxx_whitespace (cxx_pp);
1954 dump_expr (TREE_OPERAND (t, 0), flags);
1958 pp_identifier (cxx_pp, "<unparsed>");
1961 case TRY_CATCH_EXPR:
1962 case WITH_CLEANUP_EXPR:
1963 case CLEANUP_POINT_EXPR:
1964 dump_expr (TREE_OPERAND (t, 0), flags);
1967 case PSEUDO_DTOR_EXPR:
1968 dump_expr (TREE_OPERAND (t, 2), flags);
1969 pp_cxx_dot (cxx_pp);
1970 dump_type (TREE_OPERAND (t, 0), flags);
1971 pp_cxx_colon_colon (cxx_pp);
1972 pp_cxx_complement (cxx_pp);
1973 dump_type (TREE_OPERAND (t, 1), flags);
1976 case TEMPLATE_ID_EXPR:
1977 dump_decl (t, flags);
1983 case STATEMENT_LIST:
1984 /* We don't yet have a way of dumping statements in a
1985 human-readable format. */
1986 pp_string (cxx_pp, "({...})");
1990 pp_string (cxx_pp, "while (1) { ");
1991 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1992 pp_cxx_right_brace (cxx_pp);
1996 pp_string (cxx_pp, "if (");
1997 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1998 pp_string (cxx_pp, ") break; ");
2002 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2005 case EMPTY_CLASS_EXPR:
2006 dump_type (TREE_TYPE (t), flags);
2007 pp_cxx_left_paren (cxx_pp);
2008 pp_cxx_right_paren (cxx_pp);
2011 case NON_DEPENDENT_EXPR:
2012 dump_expr (TREE_OPERAND (t, 0), flags);
2015 case ARGUMENT_PACK_SELECT:
2016 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2028 pp_type_specifier_seq (cxx_pp, t);
2032 /* We get here when we want to print a dependent type as an
2033 id-expression, without any disambiguator decoration. */
2034 pp_id_expression (cxx_pp, t);
2037 case TEMPLATE_TYPE_PARM:
2038 case BOUND_TEMPLATE_TEMPLATE_PARM:
2039 dump_type (t, flags);
2043 pp_cxx_trait_expression (cxx_pp, t);
2047 pp_cxx_va_arg_expression (cxx_pp, t);
2051 pp_cxx_offsetof_expression (cxx_pp, t);
2055 case EXPR_PACK_EXPANSION:
2062 case VEC_DELETE_EXPR:
2068 case UNORDERED_EXPR:
2078 case FIX_TRUNC_EXPR:
2080 pp_expression (cxx_pp, t);
2083 case TRUTH_AND_EXPR:
2085 case TRUTH_XOR_EXPR:
2086 if (flags & TFF_EXPR_IN_PARENS)
2087 pp_cxx_left_paren (cxx_pp);
2088 pp_expression (cxx_pp, t);
2089 if (flags & TFF_EXPR_IN_PARENS)
2090 pp_cxx_right_paren (cxx_pp);
2094 dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2097 /* This list is incomplete, but should suffice for now.
2098 It is very important that `sorry' does not call
2099 `report_error_function'. That could cause an infinite loop. */
2101 pp_unsupported_tree (cxx_pp, t);
2102 /* fall through to ERROR_MARK... */
2104 pp_identifier (cxx_pp, "<expression error>");
2110 dump_binary_op (const char *opstring, tree t, int flags)
2112 pp_cxx_left_paren (cxx_pp);
2113 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2114 pp_cxx_whitespace (cxx_pp);
2116 pp_cxx_identifier (cxx_pp, opstring);
2118 pp_identifier (cxx_pp, "<unknown operator>");
2119 pp_cxx_whitespace (cxx_pp);
2120 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2121 pp_cxx_right_paren (cxx_pp);
2125 dump_unary_op (const char *opstring, tree t, int flags)
2127 if (flags & TFF_EXPR_IN_PARENS)
2128 pp_cxx_left_paren (cxx_pp);
2129 pp_cxx_identifier (cxx_pp, opstring);
2130 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2131 if (flags & TFF_EXPR_IN_PARENS)
2132 pp_cxx_right_paren (cxx_pp);
2136 reinit_cxx_pp (void)
2138 pp_clear_output_area (cxx_pp);
2139 pp_base (cxx_pp)->padding = pp_none;
2140 pp_indentation (cxx_pp) = 0;
2141 pp_needs_newline (cxx_pp) = false;
2142 cxx_pp->enclosing_scope = current_function_decl;
2146 /* Exported interface to stringifying types, exprs and decls under TFF_*
2150 type_as_string (tree typ, int flags)
2153 dump_type (typ, flags);
2154 return pp_formatted_text (cxx_pp);
2158 expr_as_string (tree decl, int flags)
2161 dump_expr (decl, flags);
2162 return pp_formatted_text (cxx_pp);
2166 decl_as_string (tree decl, int flags)
2169 dump_decl (decl, flags);
2170 return pp_formatted_text (cxx_pp);
2173 /* Generate the three forms of printable names for cxx_printable_name. */
2176 lang_decl_name (tree decl, int v)
2179 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
2182 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
2184 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2185 pp_cxx_colon_colon (cxx_pp);
2188 if (TREE_CODE (decl) == FUNCTION_DECL)
2189 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2191 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2193 return pp_formatted_text (cxx_pp);
2196 /* Return the location of a tree passed to %+ formats. */
2199 location_of (tree t)
2201 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2202 t = DECL_CONTEXT (t);
2203 else if (TYPE_P (t))
2204 t = TYPE_MAIN_DECL (t);
2205 else if (TREE_CODE (t) == OVERLOAD)
2206 t = OVL_FUNCTION (t);
2208 return DECL_SOURCE_LOCATION (t);
2211 /* Now the interfaces from error et al to dump_type et al. Each takes an
2212 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2216 decl_to_string (tree decl, int verbose)
2220 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2221 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2222 flags = TFF_CLASS_KEY_OR_ENUM;
2224 flags |= TFF_DECL_SPECIFIERS;
2225 else if (TREE_CODE (decl) == FUNCTION_DECL)
2226 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2227 flags |= TFF_TEMPLATE_HEADER;
2230 dump_decl (decl, flags);
2231 return pp_formatted_text (cxx_pp);
2235 expr_to_string (tree decl)
2238 dump_expr (decl, 0);
2239 return pp_formatted_text (cxx_pp);
2243 fndecl_to_string (tree fndecl, int verbose)
2247 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2248 | TFF_TEMPLATE_HEADER;
2250 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2252 dump_decl (fndecl, flags);
2253 return pp_formatted_text (cxx_pp);
2258 code_to_string (enum tree_code c)
2260 return tree_code_name [c];
2264 language_to_string (enum languages c)
2271 case lang_cplusplus:
2283 /* Return the proper printed version of a parameter to a C++ function. */
2286 parm_to_string (int p)
2290 pp_string (cxx_pp, "'this'");
2292 pp_decimal_int (cxx_pp, p + 1);
2293 return pp_formatted_text (cxx_pp);
2297 op_to_string (enum tree_code p)
2299 tree id = operator_name_info[(int) p].identifier;
2300 return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2304 type_to_string (tree typ, int verbose)
2308 flags |= TFF_CLASS_KEY_OR_ENUM;
2309 flags |= TFF_TEMPLATE_HEADER;
2312 dump_type (typ, flags);
2313 return pp_formatted_text (cxx_pp);
2317 assop_to_string (enum tree_code p)
2319 tree id = assignment_operator_name_info[(int) p].identifier;
2320 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2324 args_to_string (tree p, int verbose)
2328 flags |= TFF_CLASS_KEY_OR_ENUM;
2333 if (TYPE_P (TREE_VALUE (p)))
2334 return type_as_string (p, flags);
2337 for (; p; p = TREE_CHAIN (p))
2339 if (TREE_VALUE (p) == null_node)
2340 pp_cxx_identifier (cxx_pp, "NULL");
2342 dump_type (error_type (TREE_VALUE (p)), flags);
2344 pp_separate_with_comma (cxx_pp);
2346 return pp_formatted_text (cxx_pp);
2350 cv_to_string (tree p, int v)
2353 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2354 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2355 return pp_formatted_text (cxx_pp);
2358 /* Langhook for print_error_function. */
2360 cxx_print_error_function (diagnostic_context *context, const char *file,
2361 diagnostic_info *diagnostic)
2363 lhd_print_error_function (context, file, diagnostic);
2364 pp_base_set_prefix (context->printer, file);
2365 maybe_print_instantiation_context (context);
2369 cp_diagnostic_starter (diagnostic_context *context,
2370 diagnostic_info *diagnostic)
2372 diagnostic_report_current_module (context);
2373 cp_print_error_function (context, diagnostic);
2374 maybe_print_instantiation_context (context);
2375 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2379 cp_diagnostic_finalizer (diagnostic_context *context,
2380 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2382 pp_base_destroy_prefix (context->printer);
2385 /* Print current function onto BUFFER, in the process of reporting
2386 a diagnostic message. Called from cp_diagnostic_starter. */
2388 cp_print_error_function (diagnostic_context *context,
2389 diagnostic_info *diagnostic)
2391 if (diagnostic_last_function_changed (context, diagnostic))
2393 const char *old_prefix = context->printer->prefix;
2394 const char *file = LOCATION_FILE (diagnostic->location);
2395 tree abstract_origin = diagnostic->abstract_origin;
2396 char *new_prefix = (file && abstract_origin == NULL)
2397 ? file_name_as_prefix (file) : NULL;
2399 pp_base_set_prefix (context->printer, new_prefix);
2401 if (current_function_decl == NULL)
2402 pp_base_string (context->printer, "At global scope:");
2407 if (abstract_origin)
2409 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2410 while (TREE_CODE (ao) == BLOCK
2411 && BLOCK_ABSTRACT_ORIGIN (ao)
2412 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2413 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2414 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2418 fndecl = current_function_decl;
2420 pp_printf (context->printer, "In %s %qs",
2421 function_category (fndecl),
2422 cxx_printable_name (fndecl, 2));
2424 while (abstract_origin)
2427 tree block = abstract_origin;
2429 locus = &BLOCK_SOURCE_LOCATION (block);
2431 block = BLOCK_SUPERCONTEXT (block);
2432 while (block && TREE_CODE (block) == BLOCK
2433 && BLOCK_ABSTRACT_ORIGIN (block))
2435 ao = BLOCK_ABSTRACT_ORIGIN (block);
2437 while (TREE_CODE (ao) == BLOCK
2438 && BLOCK_ABSTRACT_ORIGIN (ao)
2439 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2440 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2442 if (TREE_CODE (ao) == FUNCTION_DECL)
2447 else if (TREE_CODE (ao) != BLOCK)
2450 block = BLOCK_SUPERCONTEXT (block);
2453 abstract_origin = block;
2456 while (block && TREE_CODE (block) == BLOCK)
2457 block = BLOCK_SUPERCONTEXT (block);
2459 if (TREE_CODE (block) == FUNCTION_DECL)
2461 abstract_origin = NULL;
2465 expanded_location s = expand_location (*locus);
2466 pp_base_character (context->printer, ',');
2467 pp_base_newline (context->printer);
2470 if (flag_show_column && s.column != 0)
2471 pp_printf (context->printer,
2472 " inlined from %qs at %s:%d:%d",
2473 cxx_printable_name (fndecl, 2),
2474 s.file, s.line, s.column);
2476 pp_printf (context->printer,
2477 " inlined from %qs at %s:%d",
2478 cxx_printable_name (fndecl, 2),
2483 pp_printf (context->printer, " inlined from %qs",
2484 cxx_printable_name (fndecl, 2));
2487 pp_base_character (context->printer, ':');
2489 pp_base_newline (context->printer);
2491 diagnostic_set_last_function (context, diagnostic);
2492 pp_base_destroy_prefix (context->printer);
2493 context->printer->prefix = old_prefix;
2497 /* Returns a description of FUNCTION using standard terminology. */
2499 function_category (tree fn)
2501 if (DECL_FUNCTION_MEMBER_P (fn))
2503 if (DECL_STATIC_FUNCTION_P (fn))
2504 return "static member function";
2505 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2506 return "copy constructor";
2507 else if (DECL_CONSTRUCTOR_P (fn))
2508 return "constructor";
2509 else if (DECL_DESTRUCTOR_P (fn))
2510 return "destructor";
2512 return "member function";
2518 /* Report the full context of a current template instantiation,
2521 print_instantiation_full_context (diagnostic_context *context)
2523 struct tinst_level *p = current_instantiation ();
2524 location_t location = input_location;
2528 if (current_function_decl != p->decl
2529 && current_function_decl != NULL_TREE)
2530 /* We can get here during the processing of some synthesized
2531 method. Then, P->DECL will be the function that's causing
2536 if (current_function_decl == p->decl)
2537 /* Avoid redundancy with the "In function" line. */;
2539 pp_verbatim (context->printer,
2540 "%s: In instantiation of %qs:\n",
2541 LOCATION_FILE (location),
2542 decl_as_string (p->decl,
2543 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2545 location = p->locus;
2550 print_instantiation_partial_context (context, p, location);
2553 /* Same as above but less verbose. */
2555 print_instantiation_partial_context (diagnostic_context *context,
2556 struct tinst_level *t, location_t loc)
2558 expanded_location xloc;
2559 for (; ; t = t->next)
2561 xloc = expand_location (loc);
2564 pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n",
2565 xloc.file, xloc.line,
2566 decl_as_string (t->decl,
2567 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2570 pp_verbatim (context->printer, "%s:%d: instantiated from here",
2571 xloc.file, xloc.line);
2572 pp_base_newline (context->printer);
2575 /* Called from cp_thing to print the template context for an error. */
2577 maybe_print_instantiation_context (diagnostic_context *context)
2579 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2582 record_last_problematic_instantiation ();
2583 print_instantiation_full_context (context);
2586 /* Report the bare minimum context of a template instantiation. */
2588 print_instantiation_context (void)
2590 print_instantiation_partial_context
2591 (global_dc, current_instantiation (), input_location);
2592 diagnostic_flush_buffer (global_dc);
2595 /* Called from output_format -- during diagnostic message processing --
2596 to handle C++ specific format specifier with the following meanings:
2597 %A function argument-list.
2601 %F function declaration.
2602 %L language as used in extern "lang".
2604 %P function parameter whose position is indicated by an integer.
2605 %Q assignment operator.
2609 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2610 int precision, bool wide, bool set_locus, bool verbose)
2614 #define next_tree (t = va_arg (*text->args_ptr, tree))
2615 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2616 #define next_lang va_arg (*text->args_ptr, enum languages)
2617 #define next_int va_arg (*text->args_ptr, int)
2619 if (precision != 0 || wide)
2622 if (text->locus == NULL)
2627 case 'A': result = args_to_string (next_tree, verbose); break;
2628 case 'C': result = code_to_string (next_tcode); break;
2631 tree temp = next_tree;
2633 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2635 temp = DECL_DEBUG_EXPR (temp);
2638 result = expr_to_string (temp);
2642 result = decl_to_string (temp, verbose);
2645 case 'E': result = expr_to_string (next_tree); break;
2646 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2647 case 'L': result = language_to_string (next_lang); break;
2648 case 'O': result = op_to_string (next_tcode); break;
2649 case 'P': result = parm_to_string (next_int); break;
2650 case 'Q': result = assop_to_string (next_tcode); break;
2651 case 'T': result = type_to_string (next_tree, verbose); break;
2652 case 'V': result = cv_to_string (next_tree, verbose); break;
2658 pp_base_string (pp, result);
2659 if (set_locus && t != NULL)
2660 *text->locus = location_of (t);
2668 /* Callback from cpp_error for PFILE to print diagnostics arising from
2669 interpreting strings. The diagnostic is of type LEVEL; MSG is the
2670 translated message and AP the arguments. */
2673 cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
2674 const char *msg, va_list *ap)
2676 diagnostic_info diagnostic;
2677 diagnostic_t dlevel;
2680 case CPP_DL_WARNING:
2681 case CPP_DL_WARNING_SYSHDR:
2682 dlevel = DK_WARNING;
2684 case CPP_DL_PEDWARN:
2685 dlevel = DK_PEDWARN;
2696 diagnostic_set_info_translated (&diagnostic, msg, ap,
2697 input_location, dlevel);
2698 report_diagnostic (&diagnostic);
2701 /* Warn about the use of C++0x features when appropriate. */
2703 maybe_warn_cpp0x (const char* str)
2705 if ((cxx_dialect == cxx98) && !in_system_header)
2706 /* We really want to suppress this warning in system headers,
2707 because libstdc++ uses variadic templates even when we aren't
2709 pedwarn (input_location, 0, "%s only available with -std=c++0x or -std=gnu++0x", str);
2712 /* Warn about the use of variadic templates when appropriate. */
2714 maybe_warn_variadic_templates (void)
2716 maybe_warn_cpp0x ("variadic templates");