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 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 pp_identifier (cxx_pp, "<unresolved overloaded function type>");
291 /* A list of function parms. */
292 dump_parameters (t, flags);
295 case IDENTIFIER_NODE:
296 pp_cxx_tree_identifier (cxx_pp, t);
300 dump_type (BINFO_TYPE (t), flags);
306 dump_aggr_type (t, flags);
310 if (flags & TFF_CHASE_TYPEDEF)
312 dump_type (DECL_ORIGINAL_TYPE (t)
313 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
316 /* Else fall through. */
320 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
329 pp_type_specifier_seq (cxx_pp, t);
332 case TEMPLATE_TEMPLATE_PARM:
333 /* For parameters inside template signature. */
334 if (TYPE_IDENTIFIER (t))
335 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
337 pp_cxx_canonical_template_parameter (cxx_pp, t);
340 case BOUND_TEMPLATE_TEMPLATE_PARM:
342 tree args = TYPE_TI_ARGS (t);
343 pp_cxx_cv_qualifier_seq (cxx_pp, t);
344 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
345 pp_cxx_begin_template_argument_list (cxx_pp);
346 dump_template_argument_list (args, flags);
347 pp_cxx_end_template_argument_list (cxx_pp);
351 case TEMPLATE_TYPE_PARM:
352 pp_cxx_cv_qualifier_seq (cxx_pp, t);
353 if (TYPE_IDENTIFIER (t))
354 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
356 pp_cxx_canonical_template_parameter
357 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
360 /* This is not always necessary for pointers and such, but doing this
361 reduces code size. */
370 dump_type_prefix (t, flags);
371 dump_type_suffix (t, flags);
375 pp_cxx_cv_qualifier_seq (cxx_pp, t);
376 pp_cxx_identifier (cxx_pp,
377 TYPENAME_IS_ENUM_P (t) ? "enum"
378 : TYPENAME_IS_CLASS_P (t) ? "class"
380 dump_typename (t, flags);
383 case UNBOUND_CLASS_TEMPLATE:
384 dump_type (TYPE_CONTEXT (t), flags);
385 pp_cxx_colon_colon (cxx_pp);
386 pp_cxx_identifier (cxx_pp, "template");
387 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
391 pp_cxx_identifier (cxx_pp, "__typeof__");
392 pp_cxx_whitespace (cxx_pp);
393 pp_cxx_left_paren (cxx_pp);
394 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
395 pp_cxx_right_paren (cxx_pp);
398 case TYPE_PACK_EXPANSION:
399 dump_type (PACK_EXPANSION_PATTERN (t), flags);
400 pp_cxx_identifier (cxx_pp, "...");
403 case TYPE_ARGUMENT_PACK:
404 dump_template_argument (t, flags);
408 pp_cxx_identifier (cxx_pp, "decltype");
409 pp_cxx_whitespace (cxx_pp);
410 pp_cxx_left_paren (cxx_pp);
411 dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
412 pp_cxx_right_paren (cxx_pp);
416 pp_unsupported_tree (cxx_pp, t);
417 /* Fall through to error. */
420 pp_identifier (cxx_pp, "<type error>");
425 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
429 dump_typename (tree t, int flags)
431 tree ctx = TYPE_CONTEXT (t);
433 if (TREE_CODE (ctx) == TYPENAME_TYPE)
434 dump_typename (ctx, flags);
436 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
437 pp_cxx_colon_colon (cxx_pp);
438 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
441 /* Return the name of the supplied aggregate, or enumeral type. */
444 class_key_or_enum_as_string (tree t)
446 if (TREE_CODE (t) == ENUMERAL_TYPE)
448 else if (TREE_CODE (t) == UNION_TYPE)
450 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
456 /* Print out a class declaration T under the control of FLAGS,
457 in the form `class foo'. */
460 dump_aggr_type (tree t, int flags)
463 const char *variety = class_key_or_enum_as_string (t);
467 pp_cxx_cv_qualifier_seq (cxx_pp, t);
469 if (flags & TFF_CLASS_KEY_OR_ENUM)
470 pp_cxx_identifier (cxx_pp, variety);
472 if (flags & TFF_CHASE_TYPEDEF)
473 t = TYPE_MAIN_VARIANT (t);
475 name = TYPE_NAME (t);
479 typdef = !DECL_ARTIFICIAL (name);
480 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
481 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
482 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
483 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
485 if (! (flags & TFF_UNQUALIFIED_NAME))
486 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
487 flags &= ~TFF_UNQUALIFIED_NAME;
490 /* Because the template names are mangled, we have to locate
491 the most general template, and use that name. */
492 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
494 while (DECL_TEMPLATE_INFO (tpl))
495 tpl = DECL_TI_TEMPLATE (tpl);
498 name = DECL_NAME (name);
501 if (name == 0 || ANON_AGGRNAME_P (name))
503 if (flags & TFF_CLASS_KEY_OR_ENUM)
504 pp_identifier (cxx_pp, "<anonymous>");
506 pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
509 pp_cxx_tree_identifier (cxx_pp, name);
511 dump_template_parms (TYPE_TEMPLATE_INFO (t),
512 !CLASSTYPE_USE_TEMPLATE (t),
513 flags & ~TFF_TEMPLATE_HEADER);
516 /* Dump into the obstack the initial part of the output for a given type.
517 This is necessary when dealing with things like functions returning
520 return type of `int (* fee ())()': pointer -> function -> int. Both
521 pointer (and reference and offset) and function (and member) types must
522 deal with prefix and suffix.
524 Arrays must also do this for DECL nodes, like int a[], and for things like
528 dump_type_prefix (tree t, int flags)
530 if (TYPE_PTRMEMFUNC_P (t))
532 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
536 switch (TREE_CODE (t))
541 tree sub = TREE_TYPE (t);
543 dump_type_prefix (sub, flags);
544 if (TREE_CODE (sub) == ARRAY_TYPE)
546 pp_cxx_whitespace (cxx_pp);
547 pp_cxx_left_paren (cxx_pp);
549 if (TREE_CODE (t) == POINTER_TYPE)
550 pp_character(cxx_pp, '*');
551 else if (TREE_CODE (t) == REFERENCE_TYPE)
553 if (TYPE_REF_IS_RVALUE (t))
554 pp_string (cxx_pp, "&&");
556 pp_character (cxx_pp, '&');
558 pp_base (cxx_pp)->padding = pp_before;
559 pp_cxx_cv_qualifier_seq (cxx_pp, t);
565 dump_type_prefix (TREE_TYPE (t), flags);
566 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
568 pp_maybe_space (cxx_pp);
569 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
570 pp_cxx_left_paren (cxx_pp);
571 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
572 pp_cxx_colon_colon (cxx_pp);
574 pp_cxx_star (cxx_pp);
575 pp_cxx_cv_qualifier_seq (cxx_pp, t);
576 pp_base (cxx_pp)->padding = pp_before;
579 /* Can only be reached through function pointer -- this would not be
580 correct if FUNCTION_DECLs used it. */
582 dump_type_prefix (TREE_TYPE (t), flags);
583 pp_maybe_space (cxx_pp);
584 pp_cxx_left_paren (cxx_pp);
588 dump_type_prefix (TREE_TYPE (t), flags);
589 pp_maybe_space (cxx_pp);
590 pp_cxx_left_paren (cxx_pp);
591 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
592 pp_cxx_colon_colon (cxx_pp);
596 dump_type_prefix (TREE_TYPE (t), flags);
600 case IDENTIFIER_NODE:
605 case TEMPLATE_TYPE_PARM:
606 case TEMPLATE_TEMPLATE_PARM:
607 case BOUND_TEMPLATE_TEMPLATE_PARM:
619 case TYPE_PACK_EXPANSION:
620 dump_type (t, flags);
621 pp_base (cxx_pp)->padding = pp_before;
625 pp_unsupported_tree (cxx_pp, t);
628 pp_identifier (cxx_pp, "<typeprefixerror>");
633 /* Dump the suffix of type T, under control of FLAGS. This is the part
634 which appears after the identifier (or function parms). */
637 dump_type_suffix (tree t, int flags)
639 if (TYPE_PTRMEMFUNC_P (t))
640 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
642 switch (TREE_CODE (t))
647 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
648 pp_cxx_right_paren (cxx_pp);
649 dump_type_suffix (TREE_TYPE (t), flags);
652 /* Can only be reached through function pointer. */
657 pp_cxx_right_paren (cxx_pp);
658 arg = TYPE_ARG_TYPES (t);
659 if (TREE_CODE (t) == METHOD_TYPE)
660 arg = TREE_CHAIN (arg);
662 /* Function pointers don't have default args. Not in standard C++,
663 anyway; they may in g++, but we'll just pretend otherwise. */
664 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
666 if (TREE_CODE (t) == METHOD_TYPE)
667 pp_cxx_cv_qualifier_seq
668 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
670 pp_cxx_cv_qualifier_seq(cxx_pp, t);
671 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
672 dump_type_suffix (TREE_TYPE (t), flags);
677 pp_maybe_space (cxx_pp);
678 pp_cxx_left_bracket (cxx_pp);
681 tree dtype = TYPE_DOMAIN (t);
682 tree max = TYPE_MAX_VALUE (dtype);
683 if (host_integerp (max, 0))
684 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
685 else if (TREE_CODE (max) == MINUS_EXPR)
686 dump_expr (TREE_OPERAND (max, 0),
687 flags & ~TFF_EXPR_IN_PARENS);
689 dump_expr (fold_build2 (PLUS_EXPR, dtype, max,
690 build_int_cst (dtype, 1)),
691 flags & ~TFF_EXPR_IN_PARENS);
693 pp_cxx_right_bracket (cxx_pp);
694 dump_type_suffix (TREE_TYPE (t), flags);
698 case IDENTIFIER_NODE:
703 case TEMPLATE_TYPE_PARM:
704 case TEMPLATE_TEMPLATE_PARM:
705 case BOUND_TEMPLATE_TEMPLATE_PARM:
717 case TYPE_PACK_EXPANSION:
721 pp_unsupported_tree (cxx_pp, t);
723 /* Don't mark it here, we should have already done in
730 dump_global_iord (tree t)
732 const char *p = NULL;
734 if (DECL_GLOBAL_CTOR_P (t))
736 else if (DECL_GLOBAL_DTOR_P (t))
741 pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
745 dump_simple_decl (tree t, tree type, int flags)
747 if (flags & TFF_DECL_SPECIFIERS)
749 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
750 pp_maybe_space (cxx_pp);
752 if (! (flags & TFF_UNQUALIFIED_NAME)
753 && (!DECL_INITIAL (t)
754 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
755 dump_scope (CP_DECL_CONTEXT (t), flags);
756 flags &= ~TFF_UNQUALIFIED_NAME;
757 if ((flags & TFF_DECL_SPECIFIERS)
758 && DECL_TEMPLATE_PARM_P (t)
759 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
760 pp_identifier (cxx_pp, "...");
762 dump_decl (DECL_NAME (t), flags);
764 pp_identifier (cxx_pp, "<anonymous>");
765 if (flags & TFF_DECL_SPECIFIERS)
766 dump_type_suffix (type, flags);
769 /* Dump a human readable string for the decl T under control of FLAGS. */
772 dump_decl (tree t, int flags)
777 switch (TREE_CODE (t))
780 /* Don't say 'typedef class A' */
781 if (DECL_ARTIFICIAL (t))
783 if ((flags & TFF_DECL_SPECIFIERS)
784 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
786 /* Say `class T' not just `T'. */
787 pp_cxx_identifier (cxx_pp, "class");
789 /* Emit the `...' for a parameter pack. */
790 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
791 pp_cxx_identifier (cxx_pp, "...");
794 dump_type (TREE_TYPE (t), flags);
797 if (flags & TFF_DECL_SPECIFIERS)
798 pp_cxx_identifier (cxx_pp, "typedef");
799 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
800 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
805 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
807 pp_string (cxx_pp, "vtable for ");
808 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
809 dump_type (DECL_CONTEXT (t), flags);
812 /* Else fall through. */
815 dump_simple_decl (t, TREE_TYPE (t), flags);
819 pp_string (cxx_pp, "<return value> ");
820 dump_simple_decl (t, TREE_TYPE (t), flags);
824 if (flags & TFF_DECL_SPECIFIERS)
825 pp_cxx_declaration (cxx_pp, t);
828 if (! (flags & TFF_UNQUALIFIED_NAME))
829 dump_scope (CP_DECL_CONTEXT (t), flags);
830 flags &= ~TFF_UNQUALIFIED_NAME;
831 if (DECL_NAME (t) == NULL_TREE)
832 pp_identifier (cxx_pp, "<unnamed>");
834 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
839 pp_expression (cxx_pp, t);
843 dump_decl (TREE_OPERAND (t, 0), flags);
844 pp_cxx_left_bracket (cxx_pp);
845 dump_decl (TREE_OPERAND (t, 1), flags);
846 pp_cxx_right_bracket (cxx_pp);
849 /* So that we can do dump_decl on an aggr type. */
853 dump_type (t, flags);
857 /* This is a pseudo destructor call which has not been folded into
858 a PSEUDO_DTOR_EXPR yet. */
859 pp_cxx_complement (cxx_pp);
860 dump_type (TREE_OPERAND (t, 0), flags);
867 /* These special cases are duplicated here so that other functions
868 can feed identifiers to error and get them demangled properly. */
869 case IDENTIFIER_NODE:
870 if (IDENTIFIER_TYPENAME_P (t))
872 pp_cxx_identifier (cxx_pp, "operator");
873 /* Not exactly IDENTIFIER_TYPE_VALUE. */
874 dump_type (TREE_TYPE (t), flags);
878 pp_cxx_tree_identifier (cxx_pp, t);
885 if (DECL_CLASS_SCOPE_P (t))
887 dump_type (DECL_CONTEXT (t), flags);
888 pp_cxx_colon_colon (cxx_pp);
890 else if (DECL_CONTEXT (t))
892 dump_decl (DECL_CONTEXT (t), flags);
893 pp_cxx_colon_colon (cxx_pp);
895 dump_decl (DECL_NAME (t), flags);
899 /* If there's only one function, just treat it like an ordinary
905 if (! DECL_LANG_SPECIFIC (t))
906 pp_identifier (cxx_pp, "<built-in>");
907 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
908 dump_global_iord (t);
910 dump_function_decl (t, flags);
914 dump_template_decl (t, flags);
917 case TEMPLATE_ID_EXPR:
919 tree name = TREE_OPERAND (t, 0);
921 if (is_overloaded_fn (name))
922 name = DECL_NAME (get_first_fn (name));
923 dump_decl (name, flags);
924 pp_cxx_begin_template_argument_list (cxx_pp);
925 if (TREE_OPERAND (t, 1))
926 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
927 pp_cxx_end_template_argument_list (cxx_pp);
932 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
936 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
937 || (DECL_INITIAL (t) &&
938 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
939 dump_simple_decl (t, TREE_TYPE (t), flags);
940 else if (DECL_NAME (t))
941 dump_decl (DECL_NAME (t), flags);
942 else if (DECL_INITIAL (t))
943 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
945 pp_identifier (cxx_pp, "<enumerator>");
949 pp_cxx_identifier (cxx_pp, "using");
950 dump_type (USING_DECL_SCOPE (t), flags);
951 pp_cxx_colon_colon (cxx_pp);
952 dump_decl (DECL_NAME (t), flags);
956 pp_cxx_declaration (cxx_pp, t);
960 dump_decl (BASELINK_FUNCTIONS (t), flags);
963 case NON_DEPENDENT_EXPR:
964 dump_expr (t, flags);
967 case TEMPLATE_TYPE_PARM:
968 if (flags & TFF_DECL_SPECIFIERS)
969 pp_cxx_declaration (cxx_pp, t);
971 pp_type_id (cxx_pp, t);
974 case UNBOUND_CLASS_TEMPLATE:
975 case TYPE_PACK_EXPANSION:
977 dump_type (t, flags);
981 pp_unsupported_tree (cxx_pp, t);
982 /* Fall through to error. */
985 pp_identifier (cxx_pp, "<declaration error>");
990 /* Dump a template declaration T under control of FLAGS. This means the
991 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
994 dump_template_decl (tree t, int flags)
996 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1000 if (flags & TFF_TEMPLATE_HEADER)
1002 for (parms = orig_parms = nreverse (orig_parms);
1004 parms = TREE_CHAIN (parms))
1006 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1007 int len = TREE_VEC_LENGTH (inner_parms);
1009 pp_cxx_identifier (cxx_pp, "template");
1010 pp_cxx_begin_template_argument_list (cxx_pp);
1012 /* If we've shown the template prefix, we'd better show the
1013 parameters' and decl's type too. */
1014 flags |= TFF_DECL_SPECIFIERS;
1016 for (i = 0; i < len; i++)
1019 pp_separate_with_comma (cxx_pp);
1020 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1022 pp_cxx_end_template_argument_list (cxx_pp);
1023 pp_cxx_whitespace (cxx_pp);
1025 nreverse(orig_parms);
1027 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1029 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1030 pp_cxx_identifier (cxx_pp, "class");
1032 /* If this is a parameter pack, print the ellipsis. */
1033 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1034 pp_cxx_identifier (cxx_pp, "...");
1038 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1039 dump_type (TREE_TYPE (t),
1040 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1041 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1042 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1043 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1046 gcc_assert (TREE_TYPE (t));
1047 switch (NEXT_CODE (t))
1051 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1054 /* This case can occur with some invalid code. */
1055 dump_type (TREE_TYPE (t),
1056 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1057 | (flags & TFF_DECL_SPECIFIERS
1058 ? TFF_CLASS_KEY_OR_ENUM : 0));
1063 /* Pretty print a function decl. There are several ways we want to print a
1064 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1065 As error can only apply the '#' flag once to give 0 and 1 for V, there
1066 is %D which doesn't print the throw specs, and %F which does. */
1069 dump_function_decl (tree t, int flags)
1073 tree cname = NULL_TREE;
1074 tree template_args = NULL_TREE;
1075 tree template_parms = NULL_TREE;
1076 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1077 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1079 flags &= ~TFF_UNQUALIFIED_NAME;
1080 if (TREE_CODE (t) == TEMPLATE_DECL)
1081 t = DECL_TEMPLATE_RESULT (t);
1083 /* Pretty print template instantiations only. */
1084 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
1088 template_args = DECL_TI_ARGS (t);
1089 tmpl = most_general_template (t);
1090 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1092 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1097 fntype = TREE_TYPE (t);
1098 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1100 if (DECL_CLASS_SCOPE_P (t))
1101 cname = DECL_CONTEXT (t);
1102 /* This is for partially instantiated template methods. */
1103 else if (TREE_CODE (fntype) == METHOD_TYPE)
1104 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1106 if (!(flags & TFF_DECL_SPECIFIERS))
1108 else if (DECL_STATIC_FUNCTION_P (t))
1109 pp_cxx_identifier (cxx_pp, "static");
1110 else if (DECL_VIRTUAL_P (t))
1111 pp_cxx_identifier (cxx_pp, "virtual");
1113 /* Print the return type? */
1115 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1116 && !DECL_DESTRUCTOR_P (t);
1118 dump_type_prefix (TREE_TYPE (fntype), flags);
1120 /* Print the function name. */
1121 if (!do_outer_scope)
1125 dump_type (cname, flags);
1126 pp_cxx_colon_colon (cxx_pp);
1129 dump_scope (CP_DECL_CONTEXT (t), flags);
1131 dump_function_name (t, flags);
1133 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1135 dump_parameters (parmtypes, flags);
1137 if (TREE_CODE (fntype) == METHOD_TYPE)
1139 pp_base (cxx_pp)->padding = pp_before;
1140 pp_cxx_cv_qualifier_seq
1141 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1144 if (flags & TFF_EXCEPTION_SPECIFICATION)
1146 pp_base (cxx_pp)->padding = pp_before;
1147 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1151 dump_type_suffix (TREE_TYPE (fntype), flags);
1154 /* If T is a template instantiation, dump the parameter binding. */
1155 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1157 pp_cxx_whitespace (cxx_pp);
1158 pp_cxx_left_bracket (cxx_pp);
1159 pp_cxx_identifier (cxx_pp, "with");
1160 pp_cxx_whitespace (cxx_pp);
1161 dump_template_bindings (template_parms, template_args);
1162 pp_cxx_right_bracket (cxx_pp);
1166 /* Print a parameter list. If this is for a member function, the
1167 member object ptr (and any other hidden args) should have
1168 already been removed. */
1171 dump_parameters (tree parmtypes, int flags)
1174 pp_cxx_left_paren (cxx_pp);
1176 for (first = 1; parmtypes != void_list_node;
1177 parmtypes = TREE_CHAIN (parmtypes))
1180 pp_separate_with_comma (cxx_pp);
1184 pp_cxx_identifier (cxx_pp, "...");
1188 dump_type (TREE_VALUE (parmtypes), flags);
1190 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1192 pp_cxx_whitespace (cxx_pp);
1194 pp_cxx_whitespace (cxx_pp);
1195 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1199 pp_cxx_right_paren (cxx_pp);
1202 /* Print an exception specification. T is the exception specification. */
1205 dump_exception_spec (tree t, int flags)
1209 pp_cxx_identifier (cxx_pp, "throw");
1210 pp_cxx_whitespace (cxx_pp);
1211 pp_cxx_left_paren (cxx_pp);
1212 if (TREE_VALUE (t) != NULL_TREE)
1215 dump_type (TREE_VALUE (t), flags);
1219 pp_separate_with_comma (cxx_pp);
1221 pp_cxx_right_paren (cxx_pp);
1225 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1226 and destructors properly. */
1229 dump_function_name (tree t, int flags)
1231 tree name = DECL_NAME (t);
1233 /* We can get here with a decl that was synthesized by language-
1234 independent machinery (e.g. coverage.c) in which case it won't
1235 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1236 will crash. In this case it is safe just to print out the
1238 if (!DECL_LANG_SPECIFIC (t))
1240 pp_cxx_tree_identifier (cxx_pp, name);
1244 if (TREE_CODE (t) == TEMPLATE_DECL)
1245 t = DECL_TEMPLATE_RESULT (t);
1247 /* Don't let the user see __comp_ctor et al. */
1248 if (DECL_CONSTRUCTOR_P (t)
1249 || DECL_DESTRUCTOR_P (t))
1250 name = constructor_name (DECL_CONTEXT (t));
1252 if (DECL_DESTRUCTOR_P (t))
1254 pp_cxx_complement (cxx_pp);
1255 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1257 else if (DECL_CONV_FN_P (t))
1259 /* This cannot use the hack that the operator's return
1260 type is stashed off of its name because it may be
1261 used for error reporting. In the case of conflicting
1262 declarations, both will have the same name, yet
1263 the types will be different, hence the TREE_TYPE field
1264 of the first name will be clobbered by the second. */
1265 pp_cxx_identifier (cxx_pp, "operator");
1266 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1268 else if (IDENTIFIER_OPNAME_P (name))
1269 pp_cxx_tree_identifier (cxx_pp, name);
1271 dump_decl (name, flags);
1273 if (DECL_TEMPLATE_INFO (t)
1274 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1275 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1276 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1277 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1280 /* Dump the template parameters from the template info INFO under control of
1281 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1282 specialization (partial or complete). For partial specializations we show
1283 the specialized parameter values. For a primary template we show no
1287 dump_template_parms (tree info, int primary, int flags)
1289 tree args = info ? TI_ARGS (info) : NULL_TREE;
1291 if (primary && flags & TFF_TEMPLATE_NAME)
1293 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1294 pp_cxx_begin_template_argument_list (cxx_pp);
1296 /* Be careful only to print things when we have them, so as not
1297 to crash producing error messages. */
1298 if (args && !primary)
1302 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1303 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1305 len = TREE_VEC_LENGTH (args);
1307 for (ix = 0; ix != len; ix++)
1309 tree arg = TREE_VEC_ELT (args, ix);
1311 /* Only print a comma if we know there is an argument coming. In
1312 the case of an empty template argument pack, no actual
1313 argument will be printed. */
1315 && (!ARGUMENT_PACK_P (arg)
1316 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1317 pp_separate_with_comma (cxx_pp);
1320 pp_identifier (cxx_pp, "<template parameter error>");
1322 dump_template_argument (arg, flags);
1327 tree tpl = TI_TEMPLATE (info);
1328 tree parms = DECL_TEMPLATE_PARMS (tpl);
1331 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1332 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1334 for (ix = 0; ix != len; ix++)
1338 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1340 pp_identifier (cxx_pp, "<template parameter error>");
1344 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1347 pp_separate_with_comma (cxx_pp);
1349 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1352 pp_cxx_end_template_argument_list (cxx_pp);
1355 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1356 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1359 dump_call_expr_args (tree t, int flags, bool skipfirst)
1362 call_expr_arg_iterator iter;
1364 pp_cxx_left_paren (cxx_pp);
1365 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1371 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1372 if (more_call_expr_args_p (&iter))
1373 pp_separate_with_comma (cxx_pp);
1376 pp_cxx_right_paren (cxx_pp);
1379 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1380 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1384 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1387 aggr_init_expr_arg_iterator iter;
1389 pp_cxx_left_paren (cxx_pp);
1390 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1396 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1397 if (more_aggr_init_expr_args_p (&iter))
1398 pp_separate_with_comma (cxx_pp);
1401 pp_cxx_right_paren (cxx_pp);
1404 /* Print out a list of initializers (subr of dump_expr). */
1407 dump_expr_list (tree l, int flags)
1411 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1414 pp_separate_with_comma (cxx_pp);
1418 /* Print out a vector of initializers (subr of dump_expr). */
1421 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1423 unsigned HOST_WIDE_INT idx;
1426 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1428 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1429 if (idx != VEC_length (constructor_elt, v) - 1)
1430 pp_separate_with_comma (cxx_pp);
1435 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1436 function. Resolve it to a close relative -- in the sense of static
1437 type -- variant being overridden. That is close to what was written in
1438 the source code. Subroutine of dump_expr. */
1441 resolve_virtual_fun_from_obj_type_ref (tree ref)
1443 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1444 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1445 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1448 fun = TREE_CHAIN (fun);
1449 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1450 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1456 /* Print out an expression E under control of FLAGS. */
1459 dump_expr (tree t, int flags)
1464 if (STATEMENT_CLASS_P (t))
1466 pp_cxx_identifier (cxx_pp, "<statement>");
1470 switch (TREE_CODE (t))
1478 case NAMESPACE_DECL:
1481 case IDENTIFIER_NODE:
1482 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1489 pp_constant (cxx_pp, t);
1493 pp_cxx_identifier (cxx_pp, "throw");
1494 dump_expr (TREE_OPERAND (t, 0), flags);
1498 pp_ampersand (cxx_pp);
1499 dump_type (PTRMEM_CST_CLASS (t), flags);
1500 pp_cxx_colon_colon (cxx_pp);
1501 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1505 pp_cxx_left_paren (cxx_pp);
1506 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1507 pp_separate_with_comma (cxx_pp);
1508 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1509 pp_cxx_right_paren (cxx_pp);
1513 pp_cxx_left_paren (cxx_pp);
1514 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1515 pp_string (cxx_pp, " ? ");
1516 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1517 pp_string (cxx_pp, " : ");
1518 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1519 pp_cxx_right_paren (cxx_pp);
1523 if (TREE_HAS_CONSTRUCTOR (t))
1525 pp_cxx_identifier (cxx_pp, "new");
1526 pp_cxx_whitespace (cxx_pp);
1527 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1530 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1533 case AGGR_INIT_EXPR:
1535 tree fn = NULL_TREE;
1537 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1538 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1540 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1542 if (DECL_CONSTRUCTOR_P (fn))
1543 dump_type (DECL_CONTEXT (fn), flags);
1548 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1550 dump_aggr_init_expr_args (t, flags, true);
1555 tree fn = CALL_EXPR_FN (t);
1556 bool skipfirst = false;
1558 if (TREE_CODE (fn) == ADDR_EXPR)
1559 fn = TREE_OPERAND (fn, 0);
1561 /* Nobody is interested in seeing the guts of vcalls. */
1562 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1563 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1565 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1567 tree ob = CALL_EXPR_ARG (t, 0);
1568 if (TREE_CODE (ob) == ADDR_EXPR)
1570 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1571 pp_cxx_dot (cxx_pp);
1573 else if (TREE_CODE (ob) != PARM_DECL
1574 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1576 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1577 pp_cxx_arrow (cxx_pp);
1581 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1582 dump_call_expr_args (t, flags, skipfirst);
1588 tree type = TREE_OPERAND (t, 1);
1589 tree init = TREE_OPERAND (t, 2);
1590 if (NEW_EXPR_USE_GLOBAL (t))
1591 pp_cxx_colon_colon (cxx_pp);
1592 pp_cxx_identifier (cxx_pp, "new");
1593 if (TREE_OPERAND (t, 0))
1595 pp_cxx_left_paren (cxx_pp);
1596 dump_expr_list (TREE_OPERAND (t, 0), flags);
1597 pp_cxx_right_paren (cxx_pp);
1598 pp_cxx_whitespace (cxx_pp);
1600 if (TREE_CODE (type) == ARRAY_REF)
1601 type = build_cplus_array_type
1602 (TREE_OPERAND (type, 0),
1603 build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
1604 TREE_OPERAND (type, 1),
1605 integer_one_node)));
1606 dump_type (type, flags);
1609 pp_cxx_left_paren (cxx_pp);
1610 if (TREE_CODE (init) == TREE_LIST)
1611 dump_expr_list (init, flags);
1612 else if (init == void_zero_node)
1613 /* This representation indicates an empty initializer,
1614 e.g.: "new int()". */
1617 dump_expr (init, flags);
1618 pp_cxx_right_paren (cxx_pp);
1624 /* Note that this only works for G++ target exprs. If somebody
1625 builds a general TARGET_EXPR, there's no way to represent that
1626 it initializes anything other that the parameter slot for the
1627 default argument. Note we may have cleared out the first
1628 operand in expand_expr, so don't go killing ourselves. */
1629 if (TREE_OPERAND (t, 1))
1630 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1633 case POINTER_PLUS_EXPR:
1634 dump_binary_op ("+", t, flags);
1642 case TRUNC_DIV_EXPR:
1643 case TRUNC_MOD_EXPR:
1651 case TRUTH_ANDIF_EXPR:
1652 case TRUTH_ORIF_EXPR:
1659 case EXACT_DIV_EXPR:
1660 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1664 case FLOOR_DIV_EXPR:
1665 case ROUND_DIV_EXPR:
1667 dump_binary_op ("/", t, flags);
1671 case FLOOR_MOD_EXPR:
1672 case ROUND_MOD_EXPR:
1673 dump_binary_op ("%", t, flags);
1678 tree ob = TREE_OPERAND (t, 0);
1679 if (TREE_CODE (ob) == INDIRECT_REF)
1681 ob = TREE_OPERAND (ob, 0);
1682 if (TREE_CODE (ob) != PARM_DECL
1684 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1686 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1687 pp_cxx_arrow (cxx_pp);
1692 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1693 pp_cxx_dot (cxx_pp);
1695 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1700 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1701 pp_cxx_left_bracket (cxx_pp);
1702 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1703 pp_cxx_right_bracket (cxx_pp);
1706 case UNARY_PLUS_EXPR:
1707 dump_unary_op ("+", t, flags);
1711 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1712 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1713 /* An ADDR_EXPR can have reference type. In that case, we
1714 shouldn't print the `&' doing so indicates to the user
1715 that the expression has pointer type. */
1717 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1718 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1719 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1720 dump_unary_op ("&&", t, flags);
1722 dump_unary_op ("&", t, flags);
1726 if (TREE_HAS_CONSTRUCTOR (t))
1728 t = TREE_OPERAND (t, 0);
1729 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1730 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1731 dump_call_expr_args (t, flags, true);
1735 if (TREE_OPERAND (t,0) != NULL_TREE
1736 && TREE_TYPE (TREE_OPERAND (t, 0))
1737 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1738 dump_expr (TREE_OPERAND (t, 0), flags);
1740 dump_unary_op ("*", t, flags);
1746 case TRUTH_NOT_EXPR:
1747 case PREDECREMENT_EXPR:
1748 case PREINCREMENT_EXPR:
1749 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1752 case POSTDECREMENT_EXPR:
1753 case POSTINCREMENT_EXPR:
1754 pp_cxx_left_paren (cxx_pp);
1755 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1756 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1757 pp_cxx_right_paren (cxx_pp);
1760 case NON_LVALUE_EXPR:
1761 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1762 should be another level of INDIRECT_REF so that I don't have to do
1764 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1766 tree next = TREE_TYPE (TREE_TYPE (t));
1768 while (TREE_CODE (next) == POINTER_TYPE)
1769 next = TREE_TYPE (next);
1771 if (TREE_CODE (next) == FUNCTION_TYPE)
1773 if (flags & TFF_EXPR_IN_PARENS)
1774 pp_cxx_left_paren (cxx_pp);
1775 pp_cxx_star (cxx_pp);
1776 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1777 if (flags & TFF_EXPR_IN_PARENS)
1778 pp_cxx_right_paren (cxx_pp);
1781 /* Else fall through. */
1783 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1789 tree op = TREE_OPERAND (t, 0);
1791 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1793 /* It is a cast, but we cannot tell whether it is a
1794 reinterpret or static cast. Use the C style notation. */
1795 if (flags & TFF_EXPR_IN_PARENS)
1796 pp_cxx_left_paren (cxx_pp);
1797 pp_cxx_left_paren (cxx_pp);
1798 dump_type (TREE_TYPE (t), flags);
1799 pp_cxx_right_paren (cxx_pp);
1800 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1801 if (flags & TFF_EXPR_IN_PARENS)
1802 pp_cxx_right_paren (cxx_pp);
1805 dump_expr (op, flags);
1810 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1812 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1814 if (integer_zerop (idx))
1816 /* A NULL pointer-to-member constant. */
1817 pp_cxx_left_paren (cxx_pp);
1818 pp_cxx_left_paren (cxx_pp);
1819 dump_type (TREE_TYPE (t), flags);
1820 pp_cxx_right_paren (cxx_pp);
1821 pp_character (cxx_pp, '0');
1822 pp_cxx_right_paren (cxx_pp);
1825 else if (host_integerp (idx, 0))
1828 unsigned HOST_WIDE_INT n;
1830 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1831 t = TYPE_METHOD_BASETYPE (t);
1832 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1834 n = tree_low_cst (idx, 0);
1836 /* Map vtable index back one, to allow for the null pointer to
1840 while (n > 0 && virtuals)
1843 virtuals = TREE_CHAIN (virtuals);
1847 dump_expr (BV_FN (virtuals),
1848 flags | TFF_EXPR_IN_PARENS);
1853 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1855 dump_type (TREE_TYPE (t), 0);
1856 pp_cxx_left_paren (cxx_pp);
1857 pp_cxx_right_paren (cxx_pp);
1861 pp_cxx_left_brace (cxx_pp);
1862 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1863 pp_cxx_right_brace (cxx_pp);
1870 tree ob = TREE_OPERAND (t, 0);
1871 if (is_dummy_object (ob))
1873 t = TREE_OPERAND (t, 1);
1874 if (TREE_CODE (t) == FUNCTION_DECL)
1876 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1877 else if (BASELINK_P (t))
1878 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1879 flags | TFF_EXPR_IN_PARENS);
1881 dump_decl (t, flags);
1885 if (TREE_CODE (ob) == INDIRECT_REF)
1887 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1888 pp_cxx_arrow (cxx_pp);
1889 pp_cxx_star (cxx_pp);
1893 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1894 pp_cxx_dot (cxx_pp);
1895 pp_cxx_star (cxx_pp);
1897 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1902 case TEMPLATE_PARM_INDEX:
1903 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1907 if (TREE_OPERAND (t, 0) == NULL_TREE
1908 || TREE_CHAIN (TREE_OPERAND (t, 0)))
1910 dump_type (TREE_TYPE (t), flags);
1911 pp_cxx_left_paren (cxx_pp);
1912 dump_expr_list (TREE_OPERAND (t, 0), flags);
1913 pp_cxx_right_paren (cxx_pp);
1917 pp_cxx_left_paren (cxx_pp);
1918 dump_type (TREE_TYPE (t), flags);
1919 pp_cxx_right_paren (cxx_pp);
1920 pp_cxx_left_paren (cxx_pp);
1921 dump_expr_list (TREE_OPERAND (t, 0), flags);
1922 pp_cxx_right_paren (cxx_pp);
1926 case STATIC_CAST_EXPR:
1927 pp_cxx_identifier (cxx_pp, "static_cast");
1929 case REINTERPRET_CAST_EXPR:
1930 pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1932 case CONST_CAST_EXPR:
1933 pp_cxx_identifier (cxx_pp, "const_cast");
1935 case DYNAMIC_CAST_EXPR:
1936 pp_cxx_identifier (cxx_pp, "dynamic_cast");
1938 pp_cxx_begin_template_argument_list (cxx_pp);
1939 dump_type (TREE_TYPE (t), flags);
1940 pp_cxx_end_template_argument_list (cxx_pp);
1941 pp_cxx_left_paren (cxx_pp);
1942 dump_expr (TREE_OPERAND (t, 0), flags);
1943 pp_cxx_right_paren (cxx_pp);
1947 dump_expr (TREE_OPERAND (t, 0), flags);
1948 pp_cxx_arrow (cxx_pp);
1953 if (TREE_CODE (t) == SIZEOF_EXPR)
1954 pp_cxx_identifier (cxx_pp, "sizeof");
1957 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
1958 pp_cxx_identifier (cxx_pp, "__alignof__");
1960 pp_cxx_whitespace (cxx_pp);
1961 pp_cxx_left_paren (cxx_pp);
1962 if (TYPE_P (TREE_OPERAND (t, 0)))
1963 dump_type (TREE_OPERAND (t, 0), flags);
1965 dump_expr (TREE_OPERAND (t, 0), flags);
1966 pp_cxx_right_paren (cxx_pp);
1971 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1972 pp_cxx_whitespace (cxx_pp);
1973 dump_expr (TREE_OPERAND (t, 0), flags);
1977 pp_identifier (cxx_pp, "<unparsed>");
1980 case TRY_CATCH_EXPR:
1981 case WITH_CLEANUP_EXPR:
1982 case CLEANUP_POINT_EXPR:
1983 dump_expr (TREE_OPERAND (t, 0), flags);
1986 case PSEUDO_DTOR_EXPR:
1987 dump_expr (TREE_OPERAND (t, 2), flags);
1988 pp_cxx_dot (cxx_pp);
1989 dump_type (TREE_OPERAND (t, 0), flags);
1990 pp_cxx_colon_colon (cxx_pp);
1991 pp_cxx_complement (cxx_pp);
1992 dump_type (TREE_OPERAND (t, 1), flags);
1995 case TEMPLATE_ID_EXPR:
1996 dump_decl (t, flags);
2001 case STATEMENT_LIST:
2002 /* We don't yet have a way of dumping statements in a
2003 human-readable format. */
2004 pp_string (cxx_pp, "({...})");
2008 pp_string (cxx_pp, "while (1) { ");
2009 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2010 pp_cxx_right_brace (cxx_pp);
2014 pp_string (cxx_pp, "if (");
2015 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2016 pp_string (cxx_pp, ") break; ");
2020 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2023 case EMPTY_CLASS_EXPR:
2024 dump_type (TREE_TYPE (t), flags);
2025 pp_cxx_left_paren (cxx_pp);
2026 pp_cxx_right_paren (cxx_pp);
2029 case NON_DEPENDENT_EXPR:
2030 dump_expr (TREE_OPERAND (t, 0), flags);
2033 case ARGUMENT_PACK_SELECT:
2034 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2046 pp_type_specifier_seq (cxx_pp, t);
2050 /* We get here when we want to print a dependent type as an
2051 id-expression, without any disambiguator decoration. */
2052 pp_id_expression (cxx_pp, t);
2055 case TEMPLATE_TYPE_PARM:
2056 case BOUND_TEMPLATE_TEMPLATE_PARM:
2057 dump_type (t, flags);
2061 pp_cxx_trait_expression (cxx_pp, t);
2065 pp_cxx_va_arg_expression (cxx_pp, t);
2069 pp_cxx_offsetof_expression (cxx_pp, t);
2073 case EXPR_PACK_EXPANSION:
2078 case VEC_DELETE_EXPR:
2081 pp_expression (cxx_pp, t);
2085 dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2088 /* This list is incomplete, but should suffice for now.
2089 It is very important that `sorry' does not call
2090 `report_error_function'. That could cause an infinite loop. */
2092 pp_unsupported_tree (cxx_pp, t);
2093 /* fall through to ERROR_MARK... */
2095 pp_identifier (cxx_pp, "<expression error>");
2101 dump_binary_op (const char *opstring, tree t, int flags)
2103 pp_cxx_left_paren (cxx_pp);
2104 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2105 pp_cxx_whitespace (cxx_pp);
2107 pp_cxx_identifier (cxx_pp, opstring);
2109 pp_identifier (cxx_pp, "<unknown operator>");
2110 pp_cxx_whitespace (cxx_pp);
2111 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2112 pp_cxx_right_paren (cxx_pp);
2116 dump_unary_op (const char *opstring, tree t, int flags)
2118 if (flags & TFF_EXPR_IN_PARENS)
2119 pp_cxx_left_paren (cxx_pp);
2120 pp_cxx_identifier (cxx_pp, opstring);
2121 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2122 if (flags & TFF_EXPR_IN_PARENS)
2123 pp_cxx_right_paren (cxx_pp);
2127 reinit_cxx_pp (void)
2129 pp_clear_output_area (cxx_pp);
2130 pp_base (cxx_pp)->padding = pp_none;
2131 pp_indentation (cxx_pp) = 0;
2132 pp_needs_newline (cxx_pp) = false;
2133 cxx_pp->enclosing_scope = current_function_decl;
2137 /* Exported interface to stringifying types, exprs and decls under TFF_*
2141 type_as_string (tree typ, int flags)
2144 dump_type (typ, flags);
2145 return pp_formatted_text (cxx_pp);
2149 expr_as_string (tree decl, int flags)
2152 dump_expr (decl, flags);
2153 return pp_formatted_text (cxx_pp);
2157 decl_as_string (tree decl, int flags)
2160 dump_decl (decl, flags);
2161 return pp_formatted_text (cxx_pp);
2164 /* Generate the three forms of printable names for cxx_printable_name. */
2167 lang_decl_name (tree decl, int v)
2170 return decl_as_string (decl, TFF_DECL_SPECIFIERS);
2173 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
2175 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2176 pp_cxx_colon_colon (cxx_pp);
2179 if (TREE_CODE (decl) == FUNCTION_DECL)
2180 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2182 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2184 return pp_formatted_text (cxx_pp);
2187 /* Return the location of a tree passed to %+ formats. */
2190 location_of (tree t)
2192 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2193 t = DECL_CONTEXT (t);
2194 else if (TYPE_P (t))
2195 t = TYPE_MAIN_DECL (t);
2196 else if (TREE_CODE (t) == OVERLOAD)
2197 t = OVL_FUNCTION (t);
2199 return DECL_SOURCE_LOCATION (t);
2202 /* Now the interfaces from error et al to dump_type et al. Each takes an
2203 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2207 decl_to_string (tree decl, int verbose)
2211 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2212 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2213 flags = TFF_CLASS_KEY_OR_ENUM;
2215 flags |= TFF_DECL_SPECIFIERS;
2216 else if (TREE_CODE (decl) == FUNCTION_DECL)
2217 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2218 flags |= TFF_TEMPLATE_HEADER;
2221 dump_decl (decl, flags);
2222 return pp_formatted_text (cxx_pp);
2226 expr_to_string (tree decl)
2229 dump_expr (decl, 0);
2230 return pp_formatted_text (cxx_pp);
2234 fndecl_to_string (tree fndecl, int verbose)
2238 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2239 | TFF_TEMPLATE_HEADER;
2241 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2243 dump_decl (fndecl, flags);
2244 return pp_formatted_text (cxx_pp);
2249 code_to_string (enum tree_code c)
2251 return tree_code_name [c];
2255 language_to_string (enum languages c)
2262 case lang_cplusplus:
2274 /* Return the proper printed version of a parameter to a C++ function. */
2277 parm_to_string (int p)
2281 pp_string (cxx_pp, "'this'");
2283 pp_decimal_int (cxx_pp, p + 1);
2284 return pp_formatted_text (cxx_pp);
2288 op_to_string (enum tree_code p)
2290 tree id = operator_name_info[(int) p].identifier;
2291 return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2295 type_to_string (tree typ, int verbose)
2299 flags |= TFF_CLASS_KEY_OR_ENUM;
2300 flags |= TFF_TEMPLATE_HEADER;
2303 dump_type (typ, flags);
2304 return pp_formatted_text (cxx_pp);
2308 assop_to_string (enum tree_code p)
2310 tree id = assignment_operator_name_info[(int) p].identifier;
2311 return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2315 args_to_string (tree p, int verbose)
2319 flags |= TFF_CLASS_KEY_OR_ENUM;
2324 if (TYPE_P (TREE_VALUE (p)))
2325 return type_as_string (p, flags);
2328 for (; p; p = TREE_CHAIN (p))
2330 if (TREE_VALUE (p) == null_node)
2331 pp_cxx_identifier (cxx_pp, "NULL");
2333 dump_type (error_type (TREE_VALUE (p)), flags);
2335 pp_separate_with_comma (cxx_pp);
2337 return pp_formatted_text (cxx_pp);
2341 cv_to_string (tree p, int v)
2344 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2345 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2346 return pp_formatted_text (cxx_pp);
2349 /* Langhook for print_error_function. */
2351 cxx_print_error_function (diagnostic_context *context, const char *file,
2352 diagnostic_info *diagnostic)
2354 lhd_print_error_function (context, file, diagnostic);
2355 pp_base_set_prefix (context->printer, file);
2356 maybe_print_instantiation_context (context);
2360 cp_diagnostic_starter (diagnostic_context *context,
2361 diagnostic_info *diagnostic)
2363 diagnostic_report_current_module (context);
2364 cp_print_error_function (context, diagnostic);
2365 maybe_print_instantiation_context (context);
2366 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2370 cp_diagnostic_finalizer (diagnostic_context *context,
2371 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2373 pp_base_destroy_prefix (context->printer);
2376 /* Print current function onto BUFFER, in the process of reporting
2377 a diagnostic message. Called from cp_diagnostic_starter. */
2379 cp_print_error_function (diagnostic_context *context,
2380 diagnostic_info *diagnostic)
2382 if (diagnostic_last_function_changed (context, diagnostic))
2384 const char *old_prefix = context->printer->prefix;
2385 const char *file = LOCATION_FILE (diagnostic->location);
2386 tree abstract_origin = diagnostic->abstract_origin;
2387 char *new_prefix = (file && abstract_origin == NULL)
2388 ? file_name_as_prefix (file) : NULL;
2390 pp_base_set_prefix (context->printer, new_prefix);
2392 if (current_function_decl == NULL)
2393 pp_base_string (context->printer, "At global scope:");
2398 if (abstract_origin)
2400 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2401 while (TREE_CODE (ao) == BLOCK && BLOCK_ABSTRACT_ORIGIN (ao))
2402 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2403 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2407 fndecl = current_function_decl;
2409 pp_printf (context->printer, "In %s %qs",
2410 function_category (fndecl),
2411 cxx_printable_name (fndecl, 2));
2413 while (abstract_origin)
2416 tree block = abstract_origin;
2418 locus = &BLOCK_SOURCE_LOCATION (block);
2420 block = BLOCK_SUPERCONTEXT (block);
2421 while (block && TREE_CODE (block) == BLOCK
2422 && BLOCK_ABSTRACT_ORIGIN (block))
2424 ao = BLOCK_ABSTRACT_ORIGIN (block);
2426 while (TREE_CODE (ao) == BLOCK && BLOCK_ABSTRACT_ORIGIN (ao))
2427 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2429 if (TREE_CODE (ao) == FUNCTION_DECL)
2434 else if (TREE_CODE (ao) != BLOCK)
2437 block = BLOCK_SUPERCONTEXT (block);
2440 abstract_origin = block;
2443 while (block && TREE_CODE (block) == BLOCK)
2444 block = BLOCK_SUPERCONTEXT (block);
2446 if (TREE_CODE (block) == FUNCTION_DECL)
2448 abstract_origin = NULL;
2452 expanded_location s = expand_location (*locus);
2453 pp_base_character (context->printer, ',');
2454 pp_base_newline (context->printer);
2457 #ifdef USE_MAPPED_LOCATION
2458 if (flag_show_column && s.column != 0)
2459 pp_printf (context->printer,
2460 " inlined from %qs at %s:%d:%d",
2461 cxx_printable_name (fndecl, 2),
2462 s.file, s.line, s.column);
2465 pp_printf (context->printer,
2466 " inlined from %qs at %s:%d",
2467 cxx_printable_name (fndecl, 2),
2472 pp_printf (context->printer, " inlined from %qs",
2473 cxx_printable_name (fndecl, 2));
2476 pp_base_character (context->printer, ':');
2478 pp_base_newline (context->printer);
2480 diagnostic_set_last_function (context, diagnostic);
2481 pp_base_destroy_prefix (context->printer);
2482 context->printer->prefix = old_prefix;
2486 /* Returns a description of FUNCTION using standard terminology. */
2488 function_category (tree fn)
2490 if (DECL_FUNCTION_MEMBER_P (fn))
2492 if (DECL_STATIC_FUNCTION_P (fn))
2493 return "static member function";
2494 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2495 return "copy constructor";
2496 else if (DECL_CONSTRUCTOR_P (fn))
2497 return "constructor";
2498 else if (DECL_DESTRUCTOR_P (fn))
2499 return "destructor";
2501 return "member function";
2507 /* Report the full context of a current template instantiation,
2510 print_instantiation_full_context (diagnostic_context *context)
2512 struct tinst_level *p = current_instantiation ();
2513 location_t location = input_location;
2517 if (current_function_decl != p->decl
2518 && current_function_decl != NULL_TREE)
2519 /* We can get here during the processing of some synthesized
2520 method. Then, P->DECL will be the function that's causing
2525 if (current_function_decl == p->decl)
2526 /* Avoid redundancy with the "In function" line. */;
2528 pp_verbatim (context->printer,
2529 "%s: In instantiation of %qs:\n",
2530 LOCATION_FILE (location),
2531 decl_as_string (p->decl,
2532 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2534 location = p->locus;
2539 print_instantiation_partial_context (context, p, location);
2542 /* Same as above but less verbose. */
2544 print_instantiation_partial_context (diagnostic_context *context,
2545 struct tinst_level *t, location_t loc)
2547 expanded_location xloc;
2548 for (; ; t = t->next)
2550 xloc = expand_location (loc);
2553 pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n",
2554 xloc.file, xloc.line,
2555 decl_as_string (t->decl,
2556 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2559 pp_verbatim (context->printer, "%s:%d: instantiated from here",
2560 xloc.file, xloc.line);
2561 pp_base_newline (context->printer);
2564 /* Called from cp_thing to print the template context for an error. */
2566 maybe_print_instantiation_context (diagnostic_context *context)
2568 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2571 record_last_problematic_instantiation ();
2572 print_instantiation_full_context (context);
2575 /* Report the bare minimum context of a template instantiation. */
2577 print_instantiation_context (void)
2579 print_instantiation_partial_context
2580 (global_dc, current_instantiation (), input_location);
2581 diagnostic_flush_buffer (global_dc);
2584 /* Called from output_format -- during diagnostic message processing --
2585 to handle C++ specific format specifier with the following meanings:
2586 %A function argument-list.
2590 %F function declaration.
2591 %L language as used in extern "lang".
2593 %P function parameter whose position is indicated by an integer.
2594 %Q assignment operator.
2598 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2599 int precision, bool wide, bool set_locus, bool verbose)
2603 #define next_tree (t = va_arg (*text->args_ptr, tree))
2604 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2605 #define next_lang va_arg (*text->args_ptr, enum languages)
2606 #define next_int va_arg (*text->args_ptr, int)
2608 if (precision != 0 || wide)
2611 if (text->locus == NULL)
2616 case 'A': result = args_to_string (next_tree, verbose); break;
2617 case 'C': result = code_to_string (next_tcode); break;
2620 tree temp = next_tree;
2622 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2624 temp = DECL_DEBUG_EXPR (temp);
2627 result = expr_to_string (temp);
2631 result = decl_to_string (temp, verbose);
2634 case 'E': result = expr_to_string (next_tree); break;
2635 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2636 case 'L': result = language_to_string (next_lang); break;
2637 case 'O': result = op_to_string (next_tcode); break;
2638 case 'P': result = parm_to_string (next_int); break;
2639 case 'Q': result = assop_to_string (next_tcode); break;
2640 case 'T': result = type_to_string (next_tree, verbose); break;
2641 case 'V': result = cv_to_string (next_tree, verbose); break;
2647 pp_base_string (pp, result);
2648 if (set_locus && t != NULL)
2649 *text->locus = location_of (t);
2657 /* Callback from cpp_error for PFILE to print diagnostics arising from
2658 interpreting strings. The diagnostic is of type LEVEL; MSG is the
2659 translated message and AP the arguments. */
2662 cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
2663 const char *msg, va_list *ap)
2665 diagnostic_info diagnostic;
2666 diagnostic_t dlevel;
2669 case CPP_DL_WARNING:
2670 case CPP_DL_WARNING_SYSHDR:
2671 dlevel = DK_WARNING;
2673 case CPP_DL_PEDWARN:
2674 dlevel = pedantic_error_kind ();
2685 diagnostic_set_info_translated (&diagnostic, msg, ap,
2686 input_location, dlevel);
2687 report_diagnostic (&diagnostic);
2690 /* Warn about the use of variadic templates when appropriate. */
2692 maybe_warn_variadic_templates (void)
2694 if ((cxx_dialect == cxx98) && !in_system_header)
2695 /* We really want to suppress this warning in system headers,
2696 because libstdc++ uses variadic templates even when we aren't
2698 pedwarn ("ISO C++ does not include variadic templates");