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 /* While waiting for caret diagnostics, avoid printing
1512 __cxa_allocate_exception, __cxa_throw, and the like. */
1513 pp_cxx_identifier (cxx_pp
, "<throw-expression>");
1517 pp_ampersand (cxx_pp
);
1518 dump_type (PTRMEM_CST_CLASS (t
), flags
);
1519 pp_cxx_colon_colon (cxx_pp
);
1520 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
1524 pp_cxx_left_paren (cxx_pp
);
1525 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1526 pp_separate_with_comma (cxx_pp
);
1527 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1528 pp_cxx_right_paren (cxx_pp
);
1532 pp_cxx_left_paren (cxx_pp
);
1533 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1534 pp_string (cxx_pp
, " ? ");
1535 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1536 pp_string (cxx_pp
, " : ");
1537 dump_expr (TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
1538 pp_cxx_right_paren (cxx_pp
);
1542 if (TREE_HAS_CONSTRUCTOR (t
))
1544 pp_cxx_identifier (cxx_pp
, "new");
1545 pp_cxx_whitespace (cxx_pp
);
1546 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1549 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1552 case AGGR_INIT_EXPR
:
1554 tree fn
= NULL_TREE
;
1556 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
1557 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
1559 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
1561 if (DECL_CONSTRUCTOR_P (fn
))
1562 dump_type (DECL_CONTEXT (fn
), flags
);
1567 dump_expr (AGGR_INIT_EXPR_FN (t
), 0);
1569 dump_aggr_init_expr_args (t
, flags
, true);
1574 tree fn
= CALL_EXPR_FN (t
);
1575 bool skipfirst
= false;
1577 if (TREE_CODE (fn
) == ADDR_EXPR
)
1578 fn
= TREE_OPERAND (fn
, 0);
1580 /* Nobody is interested in seeing the guts of vcalls. */
1581 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
1582 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
1584 if (TREE_TYPE (fn
) != NULL_TREE
&& NEXT_CODE (fn
) == METHOD_TYPE
)
1586 tree ob
= CALL_EXPR_ARG (t
, 0);
1587 if (TREE_CODE (ob
) == ADDR_EXPR
)
1589 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1590 pp_cxx_dot (cxx_pp
);
1592 else if (TREE_CODE (ob
) != PARM_DECL
1593 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
1595 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1596 pp_cxx_arrow (cxx_pp
);
1600 dump_expr (fn
, flags
| TFF_EXPR_IN_PARENS
);
1601 dump_call_expr_args (t
, flags
, skipfirst
);
1606 /* Note that this only works for G++ target exprs. If somebody
1607 builds a general TARGET_EXPR, there's no way to represent that
1608 it initializes anything other that the parameter slot for the
1609 default argument. Note we may have cleared out the first
1610 operand in expand_expr, so don't go killing ourselves. */
1611 if (TREE_OPERAND (t
, 1))
1612 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1615 case POINTER_PLUS_EXPR
:
1616 dump_binary_op ("+", t
, flags
);
1624 case TRUNC_DIV_EXPR
:
1625 case TRUNC_MOD_EXPR
:
1633 case TRUTH_ANDIF_EXPR
:
1634 case TRUTH_ORIF_EXPR
:
1641 case EXACT_DIV_EXPR
:
1642 dump_binary_op (operator_name_info
[(int) TREE_CODE (t
)].name
, t
, flags
);
1646 case FLOOR_DIV_EXPR
:
1647 case ROUND_DIV_EXPR
:
1649 dump_binary_op ("/", t
, flags
);
1653 case FLOOR_MOD_EXPR
:
1654 case ROUND_MOD_EXPR
:
1655 dump_binary_op ("%", t
, flags
);
1660 tree ob
= TREE_OPERAND (t
, 0);
1661 if (TREE_CODE (ob
) == INDIRECT_REF
)
1663 ob
= TREE_OPERAND (ob
, 0);
1664 if (TREE_CODE (ob
) != PARM_DECL
1666 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
1668 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1669 pp_cxx_arrow (cxx_pp
);
1674 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1675 pp_cxx_dot (cxx_pp
);
1677 dump_expr (TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
1682 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1683 pp_cxx_left_bracket (cxx_pp
);
1684 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1685 pp_cxx_right_bracket (cxx_pp
);
1688 case UNARY_PLUS_EXPR
:
1689 dump_unary_op ("+", t
, flags
);
1693 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
1694 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
1695 /* An ADDR_EXPR can have reference type. In that case, we
1696 shouldn't print the `&' doing so indicates to the user
1697 that the expression has pointer type. */
1699 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
1700 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1701 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
1702 dump_unary_op ("&&", t
, flags
);
1704 dump_unary_op ("&", t
, flags
);
1708 if (TREE_HAS_CONSTRUCTOR (t
))
1710 t
= TREE_OPERAND (t
, 0);
1711 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
1712 dump_expr (CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
1713 dump_call_expr_args (t
, flags
, true);
1717 if (TREE_OPERAND (t
,0) != NULL_TREE
1718 && TREE_TYPE (TREE_OPERAND (t
, 0))
1719 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
1720 dump_expr (TREE_OPERAND (t
, 0), flags
);
1722 dump_unary_op ("*", t
, flags
);
1728 case TRUTH_NOT_EXPR
:
1729 case PREDECREMENT_EXPR
:
1730 case PREINCREMENT_EXPR
:
1731 dump_unary_op (operator_name_info
[(int)TREE_CODE (t
)].name
, t
, flags
);
1734 case POSTDECREMENT_EXPR
:
1735 case POSTINCREMENT_EXPR
:
1736 pp_cxx_left_paren (cxx_pp
);
1737 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1738 pp_cxx_identifier (cxx_pp
, operator_name_info
[(int)TREE_CODE (t
)].name
);
1739 pp_cxx_right_paren (cxx_pp
);
1742 case NON_LVALUE_EXPR
:
1743 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1744 should be another level of INDIRECT_REF so that I don't have to do
1746 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
1748 tree next
= TREE_TYPE (TREE_TYPE (t
));
1750 while (TREE_CODE (next
) == POINTER_TYPE
)
1751 next
= TREE_TYPE (next
);
1753 if (TREE_CODE (next
) == FUNCTION_TYPE
)
1755 if (flags
& TFF_EXPR_IN_PARENS
)
1756 pp_cxx_left_paren (cxx_pp
);
1757 pp_cxx_star (cxx_pp
);
1758 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1759 if (flags
& TFF_EXPR_IN_PARENS
)
1760 pp_cxx_right_paren (cxx_pp
);
1763 /* Else fall through. */
1765 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1769 case VIEW_CONVERT_EXPR
:
1771 tree op
= TREE_OPERAND (t
, 0);
1773 if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
1775 /* It is a cast, but we cannot tell whether it is a
1776 reinterpret or static cast. Use the C style notation. */
1777 if (flags
& TFF_EXPR_IN_PARENS
)
1778 pp_cxx_left_paren (cxx_pp
);
1779 pp_cxx_left_paren (cxx_pp
);
1780 dump_type (TREE_TYPE (t
), flags
);
1781 pp_cxx_right_paren (cxx_pp
);
1782 dump_expr (op
, flags
| TFF_EXPR_IN_PARENS
);
1783 if (flags
& TFF_EXPR_IN_PARENS
)
1784 pp_cxx_right_paren (cxx_pp
);
1787 dump_expr (op
, flags
);
1792 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
1794 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
1796 if (integer_zerop (idx
))
1798 /* A NULL pointer-to-member constant. */
1799 pp_cxx_left_paren (cxx_pp
);
1800 pp_cxx_left_paren (cxx_pp
);
1801 dump_type (TREE_TYPE (t
), flags
);
1802 pp_cxx_right_paren (cxx_pp
);
1803 pp_character (cxx_pp
, '0');
1804 pp_cxx_right_paren (cxx_pp
);
1807 else if (host_integerp (idx
, 0))
1810 unsigned HOST_WIDE_INT n
;
1812 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
1813 t
= TYPE_METHOD_BASETYPE (t
);
1814 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
1816 n
= tree_low_cst (idx
, 0);
1818 /* Map vtable index back one, to allow for the null pointer to
1822 while (n
> 0 && virtuals
)
1825 virtuals
= TREE_CHAIN (virtuals
);
1829 dump_expr (BV_FN (virtuals
),
1830 flags
| TFF_EXPR_IN_PARENS
);
1835 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
1837 dump_type (TREE_TYPE (t
), 0);
1838 pp_cxx_left_paren (cxx_pp
);
1839 pp_cxx_right_paren (cxx_pp
);
1843 pp_cxx_left_brace (cxx_pp
);
1844 dump_expr_init_vec (CONSTRUCTOR_ELTS (t
), flags
);
1845 pp_cxx_right_brace (cxx_pp
);
1852 tree ob
= TREE_OPERAND (t
, 0);
1853 if (is_dummy_object (ob
))
1855 t
= TREE_OPERAND (t
, 1);
1856 if (TREE_CODE (t
) == FUNCTION_DECL
)
1858 dump_expr (t
, flags
| TFF_EXPR_IN_PARENS
);
1859 else if (BASELINK_P (t
))
1860 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
1861 flags
| TFF_EXPR_IN_PARENS
);
1863 dump_decl (t
, flags
);
1867 if (TREE_CODE (ob
) == INDIRECT_REF
)
1869 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1870 pp_cxx_arrow (cxx_pp
);
1871 pp_cxx_star (cxx_pp
);
1875 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1876 pp_cxx_dot (cxx_pp
);
1877 pp_cxx_star (cxx_pp
);
1879 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1884 case TEMPLATE_PARM_INDEX
:
1885 dump_decl (TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
1889 if (TREE_OPERAND (t
, 0) == NULL_TREE
1890 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
1892 dump_type (TREE_TYPE (t
), flags
);
1893 pp_cxx_left_paren (cxx_pp
);
1894 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1895 pp_cxx_right_paren (cxx_pp
);
1899 pp_cxx_left_paren (cxx_pp
);
1900 dump_type (TREE_TYPE (t
), flags
);
1901 pp_cxx_right_paren (cxx_pp
);
1902 pp_cxx_left_paren (cxx_pp
);
1903 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1904 pp_cxx_right_paren (cxx_pp
);
1908 case STATIC_CAST_EXPR
:
1909 pp_cxx_identifier (cxx_pp
, "static_cast");
1911 case REINTERPRET_CAST_EXPR
:
1912 pp_cxx_identifier (cxx_pp
, "reinterpret_cast");
1914 case CONST_CAST_EXPR
:
1915 pp_cxx_identifier (cxx_pp
, "const_cast");
1917 case DYNAMIC_CAST_EXPR
:
1918 pp_cxx_identifier (cxx_pp
, "dynamic_cast");
1920 pp_cxx_begin_template_argument_list (cxx_pp
);
1921 dump_type (TREE_TYPE (t
), flags
);
1922 pp_cxx_end_template_argument_list (cxx_pp
);
1923 pp_cxx_left_paren (cxx_pp
);
1924 dump_expr (TREE_OPERAND (t
, 0), flags
);
1925 pp_cxx_right_paren (cxx_pp
);
1929 dump_expr (TREE_OPERAND (t
, 0), flags
);
1930 pp_cxx_arrow (cxx_pp
);
1935 if (TREE_CODE (t
) == SIZEOF_EXPR
)
1936 pp_cxx_identifier (cxx_pp
, "sizeof");
1939 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
1940 pp_cxx_identifier (cxx_pp
, "__alignof__");
1942 pp_cxx_whitespace (cxx_pp
);
1943 pp_cxx_left_paren (cxx_pp
);
1944 if (TYPE_P (TREE_OPERAND (t
, 0)))
1945 dump_type (TREE_OPERAND (t
, 0), flags
);
1947 dump_expr (TREE_OPERAND (t
, 0), flags
);
1948 pp_cxx_right_paren (cxx_pp
);
1953 pp_cxx_identifier (cxx_pp
, operator_name_info
[TREE_CODE (t
)].name
);
1954 pp_cxx_whitespace (cxx_pp
);
1955 dump_expr (TREE_OPERAND (t
, 0), flags
);
1959 pp_identifier (cxx_pp
, "<unparsed>");
1962 case TRY_CATCH_EXPR
:
1963 case WITH_CLEANUP_EXPR
:
1964 case CLEANUP_POINT_EXPR
:
1965 dump_expr (TREE_OPERAND (t
, 0), flags
);
1968 case PSEUDO_DTOR_EXPR
:
1969 dump_expr (TREE_OPERAND (t
, 2), flags
);
1970 pp_cxx_dot (cxx_pp
);
1971 dump_type (TREE_OPERAND (t
, 0), flags
);
1972 pp_cxx_colon_colon (cxx_pp
);
1973 pp_cxx_complement (cxx_pp
);
1974 dump_type (TREE_OPERAND (t
, 1), flags
);
1977 case TEMPLATE_ID_EXPR
:
1978 dump_decl (t
, flags
);
1984 case STATEMENT_LIST
:
1985 /* We don't yet have a way of dumping statements in a
1986 human-readable format. */
1987 pp_string (cxx_pp
, "({...})");
1991 pp_string (cxx_pp
, "while (1) { ");
1992 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1993 pp_cxx_right_brace (cxx_pp
);
1997 pp_string (cxx_pp
, "if (");
1998 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1999 pp_string (cxx_pp
, ") break; ");
2003 dump_expr (get_first_fn (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2006 case EMPTY_CLASS_EXPR
:
2007 dump_type (TREE_TYPE (t
), flags
);
2008 pp_cxx_left_paren (cxx_pp
);
2009 pp_cxx_right_paren (cxx_pp
);
2012 case NON_DEPENDENT_EXPR
:
2013 dump_expr (TREE_OPERAND (t
, 0), flags
);
2016 case ARGUMENT_PACK_SELECT
:
2017 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2029 pp_type_specifier_seq (cxx_pp
, t
);
2033 /* We get here when we want to print a dependent type as an
2034 id-expression, without any disambiguator decoration. */
2035 pp_id_expression (cxx_pp
, t
);
2038 case TEMPLATE_TYPE_PARM
:
2039 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2040 dump_type (t
, flags
);
2044 pp_cxx_trait_expression (cxx_pp
, t
);
2048 pp_cxx_va_arg_expression (cxx_pp
, t
);
2052 pp_cxx_offsetof_expression (cxx_pp
, t
);
2056 case EXPR_PACK_EXPANSION
:
2063 case VEC_DELETE_EXPR
:
2069 case UNORDERED_EXPR
:
2079 case FIX_TRUNC_EXPR
:
2081 pp_expression (cxx_pp
, t
);
2084 case TRUTH_AND_EXPR
:
2086 case TRUTH_XOR_EXPR
:
2087 if (flags
& TFF_EXPR_IN_PARENS
)
2088 pp_cxx_left_paren (cxx_pp
);
2089 pp_expression (cxx_pp
, t
);
2090 if (flags
& TFF_EXPR_IN_PARENS
)
2091 pp_cxx_right_paren (cxx_pp
);
2095 dump_expr (resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2098 /* This list is incomplete, but should suffice for now.
2099 It is very important that `sorry' does not call
2100 `report_error_function'. That could cause an infinite loop. */
2102 pp_unsupported_tree (cxx_pp
, t
);
2103 /* fall through to ERROR_MARK... */
2105 pp_identifier (cxx_pp
, "<expression error>");
2111 dump_binary_op (const char *opstring
, tree t
, int flags
)
2113 pp_cxx_left_paren (cxx_pp
);
2114 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2115 pp_cxx_whitespace (cxx_pp
);
2117 pp_cxx_identifier (cxx_pp
, opstring
);
2119 pp_identifier (cxx_pp
, "<unknown operator>");
2120 pp_cxx_whitespace (cxx_pp
);
2121 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2122 pp_cxx_right_paren (cxx_pp
);
2126 dump_unary_op (const char *opstring
, tree t
, int flags
)
2128 if (flags
& TFF_EXPR_IN_PARENS
)
2129 pp_cxx_left_paren (cxx_pp
);
2130 pp_cxx_identifier (cxx_pp
, opstring
);
2131 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2132 if (flags
& TFF_EXPR_IN_PARENS
)
2133 pp_cxx_right_paren (cxx_pp
);
2137 reinit_cxx_pp (void)
2139 pp_clear_output_area (cxx_pp
);
2140 pp_base (cxx_pp
)->padding
= pp_none
;
2141 pp_indentation (cxx_pp
) = 0;
2142 pp_needs_newline (cxx_pp
) = false;
2143 cxx_pp
->enclosing_scope
= current_function_decl
;
2147 /* Exported interface to stringifying types, exprs and decls under TFF_*
2151 type_as_string (tree typ
, int flags
)
2154 dump_type (typ
, flags
);
2155 return pp_formatted_text (cxx_pp
);
2159 expr_as_string (tree decl
, int flags
)
2162 dump_expr (decl
, flags
);
2163 return pp_formatted_text (cxx_pp
);
2167 decl_as_string (tree decl
, int flags
)
2170 dump_decl (decl
, flags
);
2171 return pp_formatted_text (cxx_pp
);
2174 /* Generate the three forms of printable names for cxx_printable_name. */
2177 lang_decl_name (tree decl
, int v
)
2180 return decl_as_string (decl
, TFF_DECL_SPECIFIERS
);
2183 if (v
== 1 && DECL_CLASS_SCOPE_P (decl
))
2185 dump_type (CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2186 pp_cxx_colon_colon (cxx_pp
);
2189 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2190 dump_function_name (decl
, TFF_PLAIN_IDENTIFIER
);
2192 dump_decl (DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2194 return pp_formatted_text (cxx_pp
);
2197 /* Return the location of a tree passed to %+ formats. */
2200 location_of (tree t
)
2202 if (TREE_CODE (t
) == PARM_DECL
&& DECL_CONTEXT (t
))
2203 t
= DECL_CONTEXT (t
);
2204 else if (TYPE_P (t
))
2205 t
= TYPE_MAIN_DECL (t
);
2206 else if (TREE_CODE (t
) == OVERLOAD
)
2207 t
= OVL_FUNCTION (t
);
2209 return DECL_SOURCE_LOCATION (t
);
2212 /* Now the interfaces from error et al to dump_type et al. Each takes an
2213 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2217 decl_to_string (tree decl
, int verbose
)
2221 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2222 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2223 flags
= TFF_CLASS_KEY_OR_ENUM
;
2225 flags
|= TFF_DECL_SPECIFIERS
;
2226 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2227 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2228 flags
|= TFF_TEMPLATE_HEADER
;
2231 dump_decl (decl
, flags
);
2232 return pp_formatted_text (cxx_pp
);
2236 expr_to_string (tree decl
)
2239 dump_expr (decl
, 0);
2240 return pp_formatted_text (cxx_pp
);
2244 fndecl_to_string (tree fndecl
, int verbose
)
2248 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
2249 | TFF_TEMPLATE_HEADER
;
2251 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
2253 dump_decl (fndecl
, flags
);
2254 return pp_formatted_text (cxx_pp
);
2259 code_to_string (enum tree_code c
)
2261 return tree_code_name
[c
];
2265 language_to_string (enum languages c
)
2272 case lang_cplusplus
:
2284 /* Return the proper printed version of a parameter to a C++ function. */
2287 parm_to_string (int p
)
2291 pp_string (cxx_pp
, "'this'");
2293 pp_decimal_int (cxx_pp
, p
+ 1);
2294 return pp_formatted_text (cxx_pp
);
2298 op_to_string (enum tree_code p
)
2300 tree id
= operator_name_info
[(int) p
].identifier
;
2301 return id
? IDENTIFIER_POINTER (id
) : "<unknown>";
2305 type_to_string (tree typ
, int verbose
)
2309 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2310 flags
|= TFF_TEMPLATE_HEADER
;
2313 dump_type (typ
, flags
);
2314 return pp_formatted_text (cxx_pp
);
2318 assop_to_string (enum tree_code p
)
2320 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
2321 return id
? IDENTIFIER_POINTER (id
) : "{unknown}";
2325 args_to_string (tree p
, int verbose
)
2329 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2334 if (TYPE_P (TREE_VALUE (p
)))
2335 return type_as_string (p
, flags
);
2338 for (; p
; p
= TREE_CHAIN (p
))
2340 if (TREE_VALUE (p
) == null_node
)
2341 pp_cxx_identifier (cxx_pp
, "NULL");
2343 dump_type (error_type (TREE_VALUE (p
)), flags
);
2345 pp_separate_with_comma (cxx_pp
);
2347 return pp_formatted_text (cxx_pp
);
2351 cv_to_string (tree p
, int v
)
2354 pp_base (cxx_pp
)->padding
= v
? pp_before
: pp_none
;
2355 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
2356 return pp_formatted_text (cxx_pp
);
2359 /* Langhook for print_error_function. */
2361 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
2362 diagnostic_info
*diagnostic
)
2364 lhd_print_error_function (context
, file
, diagnostic
);
2365 pp_base_set_prefix (context
->printer
, file
);
2366 maybe_print_instantiation_context (context
);
2370 cp_diagnostic_starter (diagnostic_context
*context
,
2371 diagnostic_info
*diagnostic
)
2373 diagnostic_report_current_module (context
);
2374 cp_print_error_function (context
, diagnostic
);
2375 maybe_print_instantiation_context (context
);
2376 pp_base_set_prefix (context
->printer
, diagnostic_build_prefix (diagnostic
));
2380 cp_diagnostic_finalizer (diagnostic_context
*context
,
2381 diagnostic_info
*diagnostic ATTRIBUTE_UNUSED
)
2383 pp_base_destroy_prefix (context
->printer
);
2386 /* Print current function onto BUFFER, in the process of reporting
2387 a diagnostic message. Called from cp_diagnostic_starter. */
2389 cp_print_error_function (diagnostic_context
*context
,
2390 diagnostic_info
*diagnostic
)
2392 if (diagnostic_last_function_changed (context
, diagnostic
))
2394 const char *old_prefix
= context
->printer
->prefix
;
2395 const char *file
= LOCATION_FILE (diagnostic
->location
);
2396 tree abstract_origin
= diagnostic
->abstract_origin
;
2397 char *new_prefix
= (file
&& abstract_origin
== NULL
)
2398 ? file_name_as_prefix (file
) : NULL
;
2400 pp_base_set_prefix (context
->printer
, new_prefix
);
2402 if (current_function_decl
== NULL
)
2403 pp_base_string (context
->printer
, "At global scope:");
2408 if (abstract_origin
)
2410 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
2411 while (TREE_CODE (ao
) == BLOCK
2412 && BLOCK_ABSTRACT_ORIGIN (ao
)
2413 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
2414 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
2415 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
2419 fndecl
= current_function_decl
;
2421 pp_printf (context
->printer
, "In %s %qs",
2422 function_category (fndecl
),
2423 cxx_printable_name (fndecl
, 2));
2425 while (abstract_origin
)
2428 tree block
= abstract_origin
;
2430 locus
= &BLOCK_SOURCE_LOCATION (block
);
2432 block
= BLOCK_SUPERCONTEXT (block
);
2433 while (block
&& TREE_CODE (block
) == BLOCK
2434 && BLOCK_ABSTRACT_ORIGIN (block
))
2436 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
2438 while (TREE_CODE (ao
) == BLOCK
2439 && BLOCK_ABSTRACT_ORIGIN (ao
)
2440 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
2441 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
2443 if (TREE_CODE (ao
) == FUNCTION_DECL
)
2448 else if (TREE_CODE (ao
) != BLOCK
)
2451 block
= BLOCK_SUPERCONTEXT (block
);
2454 abstract_origin
= block
;
2457 while (block
&& TREE_CODE (block
) == BLOCK
)
2458 block
= BLOCK_SUPERCONTEXT (block
);
2460 if (TREE_CODE (block
) == FUNCTION_DECL
)
2462 abstract_origin
= NULL
;
2466 expanded_location s
= expand_location (*locus
);
2467 pp_base_character (context
->printer
, ',');
2468 pp_base_newline (context
->printer
);
2471 if (flag_show_column
&& s
.column
!= 0)
2472 pp_printf (context
->printer
,
2473 " inlined from %qs at %s:%d:%d",
2474 cxx_printable_name (fndecl
, 2),
2475 s
.file
, s
.line
, s
.column
);
2477 pp_printf (context
->printer
,
2478 " inlined from %qs at %s:%d",
2479 cxx_printable_name (fndecl
, 2),
2484 pp_printf (context
->printer
, " inlined from %qs",
2485 cxx_printable_name (fndecl
, 2));
2488 pp_base_character (context
->printer
, ':');
2490 pp_base_newline (context
->printer
);
2492 diagnostic_set_last_function (context
, diagnostic
);
2493 pp_base_destroy_prefix (context
->printer
);
2494 context
->printer
->prefix
= old_prefix
;
2498 /* Returns a description of FUNCTION using standard terminology. */
2500 function_category (tree fn
)
2502 if (DECL_FUNCTION_MEMBER_P (fn
))
2504 if (DECL_STATIC_FUNCTION_P (fn
))
2505 return "static member function";
2506 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
2507 return "copy constructor";
2508 else if (DECL_CONSTRUCTOR_P (fn
))
2509 return "constructor";
2510 else if (DECL_DESTRUCTOR_P (fn
))
2511 return "destructor";
2513 return "member function";
2519 /* Report the full context of a current template instantiation,
2522 print_instantiation_full_context (diagnostic_context
*context
)
2524 struct tinst_level
*p
= current_instantiation ();
2525 location_t location
= input_location
;
2529 if (current_function_decl
!= p
->decl
2530 && current_function_decl
!= NULL_TREE
)
2531 /* We can get here during the processing of some synthesized
2532 method. Then, P->DECL will be the function that's causing
2537 if (current_function_decl
== p
->decl
)
2538 /* Avoid redundancy with the "In function" line. */;
2540 pp_verbatim (context
->printer
,
2541 "%s: In instantiation of %qs:\n",
2542 LOCATION_FILE (location
),
2543 decl_as_string (p
->decl
,
2544 TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
));
2546 location
= p
->locus
;
2551 print_instantiation_partial_context (context
, p
, location
);
2554 /* Same as above but less verbose. */
2556 print_instantiation_partial_context (diagnostic_context
*context
,
2557 struct tinst_level
*t
, location_t loc
)
2559 expanded_location xloc
;
2560 for (; ; t
= t
->next
)
2562 xloc
= expand_location (loc
);
2565 pp_verbatim (context
->printer
, "%s:%d: instantiated from %qs\n",
2566 xloc
.file
, xloc
.line
,
2567 decl_as_string (t
->decl
,
2568 TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
));
2571 pp_verbatim (context
->printer
, "%s:%d: instantiated from here",
2572 xloc
.file
, xloc
.line
);
2573 pp_base_newline (context
->printer
);
2576 /* Called from cp_thing to print the template context for an error. */
2578 maybe_print_instantiation_context (diagnostic_context
*context
)
2580 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2583 record_last_problematic_instantiation ();
2584 print_instantiation_full_context (context
);
2587 /* Report the bare minimum context of a template instantiation. */
2589 print_instantiation_context (void)
2591 print_instantiation_partial_context
2592 (global_dc
, current_instantiation (), input_location
);
2593 diagnostic_flush_buffer (global_dc
);
2596 /* Called from output_format -- during diagnostic message processing --
2597 to handle C++ specific format specifier with the following meanings:
2598 %A function argument-list.
2602 %F function declaration.
2603 %L language as used in extern "lang".
2605 %P function parameter whose position is indicated by an integer.
2606 %Q assignment operator.
2610 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
2611 int precision
, bool wide
, bool set_locus
, bool verbose
)
2615 #define next_tree (t = va_arg (*text->args_ptr, tree))
2616 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2617 #define next_lang va_arg (*text->args_ptr, enum languages)
2618 #define next_int va_arg (*text->args_ptr, int)
2620 if (precision
!= 0 || wide
)
2623 if (text
->locus
== NULL
)
2628 case 'A': result
= args_to_string (next_tree
, verbose
); break;
2629 case 'C': result
= code_to_string (next_tcode
); break;
2632 tree temp
= next_tree
;
2634 && DECL_DEBUG_EXPR_IS_FROM (temp
) && DECL_DEBUG_EXPR (temp
))
2636 temp
= DECL_DEBUG_EXPR (temp
);
2639 result
= expr_to_string (temp
);
2643 result
= decl_to_string (temp
, verbose
);
2646 case 'E': result
= expr_to_string (next_tree
); break;
2647 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
2648 case 'L': result
= language_to_string (next_lang
); break;
2649 case 'O': result
= op_to_string (next_tcode
); break;
2650 case 'P': result
= parm_to_string (next_int
); break;
2651 case 'Q': result
= assop_to_string (next_tcode
); break;
2652 case 'T': result
= type_to_string (next_tree
, verbose
); break;
2653 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
2659 pp_base_string (pp
, result
);
2660 if (set_locus
&& t
!= NULL
)
2661 *text
->locus
= location_of (t
);
2669 /* Callback from cpp_error for PFILE to print diagnostics arising from
2670 interpreting strings. The diagnostic is of type LEVEL; MSG is the
2671 translated message and AP the arguments. */
2674 cp_cpp_error (cpp_reader
*pfile ATTRIBUTE_UNUSED
, int level
,
2675 const char *msg
, va_list *ap
)
2677 diagnostic_info diagnostic
;
2678 diagnostic_t dlevel
;
2681 case CPP_DL_WARNING
:
2682 case CPP_DL_WARNING_SYSHDR
:
2683 dlevel
= DK_WARNING
;
2685 case CPP_DL_PEDWARN
:
2686 dlevel
= DK_PEDWARN
;
2697 diagnostic_set_info_translated (&diagnostic
, msg
, ap
,
2698 input_location
, dlevel
);
2699 report_diagnostic (&diagnostic
);
2702 /* Warn about the use of C++0x features when appropriate. */
2704 maybe_warn_cpp0x (const char* str
)
2706 if ((cxx_dialect
== cxx98
) && !in_system_header
)
2707 /* We really want to suppress this warning in system headers,
2708 because libstdc++ uses variadic templates even when we aren't
2710 pedwarn (input_location
, 0, "%s only available with -std=c++0x or -std=gnu++0x", str
);
2713 /* Warn about the use of variadic templates when appropriate. */
2715 maybe_warn_variadic_templates (void)
2717 maybe_warn_cpp0x ("variadic templates");