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
);
146 dump_expr (arg
, (flags
| TFF_EXPR_IN_PARENS
) & ~TFF_CLASS_KEY_OR_ENUM
);
149 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
153 dump_template_argument_list (tree args
, int flags
)
155 int n
= TREE_VEC_LENGTH (args
);
159 for (i
= 0; i
< n
; ++i
)
161 tree arg
= TREE_VEC_ELT (args
, i
);
163 /* Only print a comma if we know there is an argument coming. In
164 the case of an empty template argument pack, no actual
165 argument will be printed. */
167 && (!ARGUMENT_PACK_P (arg
)
168 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
169 pp_separate_with_comma (cxx_pp
);
171 dump_template_argument (arg
, flags
);
176 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
179 dump_template_parameter (tree parm
, int flags
)
184 if (parm
== error_mark_node
)
187 p
= TREE_VALUE (parm
);
188 a
= TREE_PURPOSE (parm
);
190 if (TREE_CODE (p
) == TYPE_DECL
)
192 if (flags
& TFF_DECL_SPECIFIERS
)
194 pp_cxx_identifier (cxx_pp
, "class");
195 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p
)))
196 pp_cxx_identifier (cxx_pp
, "...");
198 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (p
));
200 else if (DECL_NAME (p
))
201 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (p
));
203 pp_cxx_canonical_template_parameter (cxx_pp
, TREE_TYPE (p
));
206 dump_decl (p
, flags
| TFF_DECL_SPECIFIERS
);
208 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && a
!= NULL_TREE
)
210 pp_cxx_whitespace (cxx_pp
);
212 pp_cxx_whitespace (cxx_pp
);
213 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
214 dump_type (a
, flags
& ~TFF_CHASE_TYPEDEF
);
216 dump_expr (a
, flags
| TFF_EXPR_IN_PARENS
);
220 /* Dump, under control of FLAGS, a template-parameter-list binding.
221 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
225 dump_template_bindings (tree parms
, tree args
)
231 tree p
= TREE_VALUE (parms
);
232 int lvl
= TMPL_PARMS_DEPTH (parms
);
236 for (i
= 0; i
< TREE_VEC_LENGTH (p
); ++i
)
238 tree arg
= NULL_TREE
;
240 /* Don't crash if we had an invalid argument list. */
241 if (TMPL_ARGS_DEPTH (args
) >= lvl
)
243 tree lvl_args
= TMPL_ARGS_LEVEL (args
, lvl
);
244 if (NUM_TMPL_ARGS (lvl_args
) > arg_idx
)
245 arg
= TREE_VEC_ELT (lvl_args
, arg_idx
);
249 pp_separate_with_comma (cxx_pp
);
250 dump_template_parameter (TREE_VEC_ELT (p
, i
), TFF_PLAIN_IDENTIFIER
);
251 pp_cxx_whitespace (cxx_pp
);
253 pp_cxx_whitespace (cxx_pp
);
255 dump_template_argument (arg
, TFF_PLAIN_IDENTIFIER
);
257 pp_identifier (cxx_pp
, "<missing>");
263 parms
= TREE_CHAIN (parms
);
267 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
271 dump_type (tree t
, int flags
)
276 if (TYPE_PTRMEMFUNC_P (t
))
279 switch (TREE_CODE (t
))
282 pp_identifier (cxx_pp
, "<unresolved overloaded function type>");
286 /* A list of function parms. */
287 dump_parameters (t
, flags
);
290 case IDENTIFIER_NODE
:
291 pp_cxx_tree_identifier (cxx_pp
, t
);
295 dump_type (BINFO_TYPE (t
), flags
);
301 dump_aggr_type (t
, flags
);
305 if (flags
& TFF_CHASE_TYPEDEF
)
307 dump_type (DECL_ORIGINAL_TYPE (t
)
308 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
), flags
);
311 /* Else fall through. */
315 dump_decl (t
, flags
& ~TFF_DECL_SPECIFIERS
);
324 pp_type_specifier_seq (cxx_pp
, t
);
327 case TEMPLATE_TEMPLATE_PARM
:
328 /* For parameters inside template signature. */
329 if (TYPE_IDENTIFIER (t
))
330 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
332 pp_cxx_canonical_template_parameter (cxx_pp
, t
);
335 case BOUND_TEMPLATE_TEMPLATE_PARM
:
337 tree args
= TYPE_TI_ARGS (t
);
338 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
339 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
340 pp_cxx_begin_template_argument_list (cxx_pp
);
341 dump_template_argument_list (args
, flags
);
342 pp_cxx_end_template_argument_list (cxx_pp
);
346 case TEMPLATE_TYPE_PARM
:
347 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
348 if (TYPE_IDENTIFIER (t
))
349 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
351 pp_cxx_canonical_template_parameter
352 (cxx_pp
, TEMPLATE_TYPE_PARM_INDEX (t
));
355 /* This is not always necessary for pointers and such, but doing this
356 reduces code size. */
365 dump_type_prefix (t
, flags
);
366 dump_type_suffix (t
, flags
);
370 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
371 pp_cxx_identifier (cxx_pp
,
372 TYPENAME_IS_ENUM_P (t
) ? "enum"
373 : TYPENAME_IS_CLASS_P (t
) ? "class"
375 dump_typename (t
, flags
);
378 case UNBOUND_CLASS_TEMPLATE
:
379 dump_type (TYPE_CONTEXT (t
), flags
);
380 pp_cxx_colon_colon (cxx_pp
);
381 pp_cxx_identifier (cxx_pp
, "template");
382 dump_type (DECL_NAME (TYPE_NAME (t
)), flags
);
386 pp_cxx_identifier (cxx_pp
, "__typeof__");
387 pp_cxx_whitespace (cxx_pp
);
388 pp_cxx_left_paren (cxx_pp
);
389 dump_expr (TYPEOF_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
390 pp_cxx_right_paren (cxx_pp
);
393 case TYPE_PACK_EXPANSION
:
394 dump_type (PACK_EXPANSION_PATTERN (t
), flags
);
395 pp_cxx_identifier (cxx_pp
, "...");
398 case TYPE_ARGUMENT_PACK
:
399 dump_template_argument (t
, flags
);
403 pp_cxx_identifier (cxx_pp
, "decltype");
404 pp_cxx_whitespace (cxx_pp
);
405 pp_cxx_left_paren (cxx_pp
);
406 dump_expr (DECLTYPE_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
407 pp_cxx_right_paren (cxx_pp
);
411 pp_unsupported_tree (cxx_pp
, t
);
412 /* Fall through to error. */
415 pp_identifier (cxx_pp
, "<type error>");
420 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
424 dump_typename (tree t
, int flags
)
426 tree ctx
= TYPE_CONTEXT (t
);
428 if (TREE_CODE (ctx
) == TYPENAME_TYPE
)
429 dump_typename (ctx
, flags
);
431 dump_type (ctx
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
432 pp_cxx_colon_colon (cxx_pp
);
433 dump_decl (TYPENAME_TYPE_FULLNAME (t
), flags
);
436 /* Return the name of the supplied aggregate, or enumeral type. */
439 class_key_or_enum_as_string (tree t
)
441 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
443 else if (TREE_CODE (t
) == UNION_TYPE
)
445 else if (TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_DECLARED_CLASS (t
))
451 /* Print out a class declaration T under the control of FLAGS,
452 in the form `class foo'. */
455 dump_aggr_type (tree t
, int flags
)
458 const char *variety
= class_key_or_enum_as_string (t
);
462 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
464 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
465 pp_cxx_identifier (cxx_pp
, variety
);
467 if (flags
& TFF_CHASE_TYPEDEF
)
468 t
= TYPE_MAIN_VARIANT (t
);
470 name
= TYPE_NAME (t
);
474 typdef
= !DECL_ARTIFICIAL (name
);
475 tmplate
= !typdef
&& TREE_CODE (t
) != ENUMERAL_TYPE
476 && TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_TEMPLATE_INFO (t
)
477 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
478 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
480 if (! (flags
& TFF_UNQUALIFIED_NAME
))
481 dump_scope (CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
482 flags
&= ~TFF_UNQUALIFIED_NAME
;
485 /* Because the template names are mangled, we have to locate
486 the most general template, and use that name. */
487 tree tpl
= CLASSTYPE_TI_TEMPLATE (t
);
489 while (DECL_TEMPLATE_INFO (tpl
))
490 tpl
= DECL_TI_TEMPLATE (tpl
);
493 name
= DECL_NAME (name
);
496 if (name
== 0 || ANON_AGGRNAME_P (name
))
498 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
499 pp_identifier (cxx_pp
, "<anonymous>");
501 pp_printf (pp_base (cxx_pp
), "<anonymous %s>", variety
);
504 pp_cxx_tree_identifier (cxx_pp
, name
);
506 dump_template_parms (TYPE_TEMPLATE_INFO (t
),
507 !CLASSTYPE_USE_TEMPLATE (t
),
508 flags
& ~TFF_TEMPLATE_HEADER
);
511 /* Dump into the obstack the initial part of the output for a given type.
512 This is necessary when dealing with things like functions returning
515 return type of `int (* fee ())()': pointer -> function -> int. Both
516 pointer (and reference and offset) and function (and member) types must
517 deal with prefix and suffix.
519 Arrays must also do this for DECL nodes, like int a[], and for things like
523 dump_type_prefix (tree t
, int flags
)
525 if (TYPE_PTRMEMFUNC_P (t
))
527 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
531 switch (TREE_CODE (t
))
536 tree sub
= TREE_TYPE (t
);
538 dump_type_prefix (sub
, flags
);
539 if (TREE_CODE (sub
) == ARRAY_TYPE
)
541 pp_cxx_whitespace (cxx_pp
);
542 pp_cxx_left_paren (cxx_pp
);
544 if (TREE_CODE (t
) == POINTER_TYPE
)
545 pp_character(cxx_pp
, '*');
546 else if (TREE_CODE (t
) == REFERENCE_TYPE
)
548 if (TYPE_REF_IS_RVALUE (t
))
549 pp_string (cxx_pp
, "&&");
551 pp_character (cxx_pp
, '&');
553 pp_base (cxx_pp
)->padding
= pp_before
;
554 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
560 dump_type_prefix (TREE_TYPE (t
), flags
);
561 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
563 pp_maybe_space (cxx_pp
);
564 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
565 pp_cxx_left_paren (cxx_pp
);
566 dump_type (TYPE_OFFSET_BASETYPE (t
), flags
);
567 pp_cxx_colon_colon (cxx_pp
);
569 pp_cxx_star (cxx_pp
);
570 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
571 pp_base (cxx_pp
)->padding
= pp_before
;
574 /* Can only be reached through function pointer -- this would not be
575 correct if FUNCTION_DECLs used it. */
577 dump_type_prefix (TREE_TYPE (t
), flags
);
578 pp_maybe_space (cxx_pp
);
579 pp_cxx_left_paren (cxx_pp
);
583 dump_type_prefix (TREE_TYPE (t
), flags
);
584 pp_maybe_space (cxx_pp
);
585 pp_cxx_left_paren (cxx_pp
);
586 dump_aggr_type (TYPE_METHOD_BASETYPE (t
), flags
);
587 pp_cxx_colon_colon (cxx_pp
);
591 dump_type_prefix (TREE_TYPE (t
), flags
);
595 case IDENTIFIER_NODE
:
600 case TEMPLATE_TYPE_PARM
:
601 case TEMPLATE_TEMPLATE_PARM
:
602 case BOUND_TEMPLATE_TEMPLATE_PARM
:
614 dump_type (t
, flags
);
615 pp_base (cxx_pp
)->padding
= pp_before
;
619 pp_unsupported_tree (cxx_pp
, t
);
622 pp_identifier (cxx_pp
, "<typeprefixerror>");
627 /* Dump the suffix of type T, under control of FLAGS. This is the part
628 which appears after the identifier (or function parms). */
631 dump_type_suffix (tree t
, int flags
)
633 if (TYPE_PTRMEMFUNC_P (t
))
634 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
636 switch (TREE_CODE (t
))
641 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
642 pp_cxx_right_paren (cxx_pp
);
643 dump_type_suffix (TREE_TYPE (t
), flags
);
646 /* Can only be reached through function pointer. */
651 pp_cxx_right_paren (cxx_pp
);
652 arg
= TYPE_ARG_TYPES (t
);
653 if (TREE_CODE (t
) == METHOD_TYPE
)
654 arg
= TREE_CHAIN (arg
);
656 /* Function pointers don't have default args. Not in standard C++,
657 anyway; they may in g++, but we'll just pretend otherwise. */
658 dump_parameters (arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
660 if (TREE_CODE (t
) == METHOD_TYPE
)
661 pp_cxx_cv_qualifier_seq
662 (cxx_pp
, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))));
664 pp_cxx_cv_qualifier_seq(cxx_pp
, t
);
665 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t
), flags
);
666 dump_type_suffix (TREE_TYPE (t
), flags
);
671 pp_maybe_space (cxx_pp
);
672 pp_cxx_left_bracket (cxx_pp
);
675 tree dtype
= TYPE_DOMAIN (t
);
676 tree max
= TYPE_MAX_VALUE (dtype
);
677 if (host_integerp (max
, 0))
678 pp_wide_integer (cxx_pp
, tree_low_cst (max
, 0) + 1);
679 else if (TREE_CODE (max
) == MINUS_EXPR
)
680 dump_expr (TREE_OPERAND (max
, 0),
681 flags
& ~TFF_EXPR_IN_PARENS
);
683 dump_expr (fold_build2 (PLUS_EXPR
, dtype
, max
,
684 build_int_cst (dtype
, 1)),
685 flags
& ~TFF_EXPR_IN_PARENS
);
687 pp_cxx_right_bracket (cxx_pp
);
688 dump_type_suffix (TREE_TYPE (t
), flags
);
692 case IDENTIFIER_NODE
:
697 case TEMPLATE_TYPE_PARM
:
698 case TEMPLATE_TEMPLATE_PARM
:
699 case BOUND_TEMPLATE_TEMPLATE_PARM
:
714 pp_unsupported_tree (cxx_pp
, t
);
716 /* Don't mark it here, we should have already done in
723 dump_global_iord (tree t
)
725 const char *p
= NULL
;
727 if (DECL_GLOBAL_CTOR_P (t
))
729 else if (DECL_GLOBAL_DTOR_P (t
))
734 pp_printf (pp_base (cxx_pp
), "(static %s for %s)", p
, input_filename
);
738 dump_simple_decl (tree t
, tree type
, int flags
)
740 if (flags
& TFF_DECL_SPECIFIERS
)
742 dump_type_prefix (type
, flags
& ~TFF_UNQUALIFIED_NAME
);
743 pp_maybe_space (cxx_pp
);
745 if (! (flags
& TFF_UNQUALIFIED_NAME
)
746 && (!DECL_INITIAL (t
)
747 || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
))
748 dump_scope (CP_DECL_CONTEXT (t
), flags
);
749 flags
&= ~TFF_UNQUALIFIED_NAME
;
751 dump_decl (DECL_NAME (t
), flags
);
753 pp_identifier (cxx_pp
, "<anonymous>");
754 if (flags
& TFF_DECL_SPECIFIERS
)
755 dump_type_suffix (type
, flags
);
758 /* Dump a human readable string for the decl T under control of FLAGS. */
761 dump_decl (tree t
, int flags
)
766 switch (TREE_CODE (t
))
769 /* Don't say 'typedef class A' */
770 if (DECL_ARTIFICIAL (t
))
772 if ((flags
& TFF_DECL_SPECIFIERS
)
773 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
774 /* Say `class T' not just `T'. */
775 pp_cxx_identifier (cxx_pp
, "class");
777 dump_type (TREE_TYPE (t
), flags
);
780 if (flags
& TFF_DECL_SPECIFIERS
)
781 pp_cxx_identifier (cxx_pp
, "typedef");
782 dump_simple_decl (t
, DECL_ORIGINAL_TYPE (t
)
783 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
788 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
790 pp_string (cxx_pp
, "vtable for ");
791 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
792 dump_type (DECL_CONTEXT (t
), flags
);
795 /* Else fall through. */
798 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
802 pp_string (cxx_pp
, "<return value> ");
803 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
807 if (flags
& TFF_DECL_SPECIFIERS
)
808 pp_cxx_declaration (cxx_pp
, t
);
811 if (! (flags
& TFF_UNQUALIFIED_NAME
))
812 dump_scope (CP_DECL_CONTEXT (t
), flags
);
813 flags
&= ~TFF_UNQUALIFIED_NAME
;
814 if (DECL_NAME (t
) == NULL_TREE
)
815 pp_identifier (cxx_pp
, "<unnamed>");
817 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
822 pp_expression (cxx_pp
, t
);
826 dump_decl (TREE_OPERAND (t
, 0), flags
);
827 pp_cxx_left_bracket (cxx_pp
);
828 dump_decl (TREE_OPERAND (t
, 1), flags
);
829 pp_cxx_right_bracket (cxx_pp
);
832 /* So that we can do dump_decl on an aggr type. */
836 dump_type (t
, flags
);
840 /* This is a pseudo destructor call which has not been folded into
841 a PSEUDO_DTOR_EXPR yet. */
842 pp_cxx_complement (cxx_pp
);
843 dump_type (TREE_OPERAND (t
, 0), flags
);
850 /* These special cases are duplicated here so that other functions
851 can feed identifiers to error and get them demangled properly. */
852 case IDENTIFIER_NODE
:
853 if (IDENTIFIER_TYPENAME_P (t
))
855 pp_cxx_identifier (cxx_pp
, "operator");
856 /* Not exactly IDENTIFIER_TYPE_VALUE. */
857 dump_type (TREE_TYPE (t
), flags
);
861 pp_cxx_tree_identifier (cxx_pp
, t
);
868 if (DECL_CLASS_SCOPE_P (t
))
870 dump_type (DECL_CONTEXT (t
), flags
);
871 pp_cxx_colon_colon (cxx_pp
);
873 else if (DECL_CONTEXT (t
))
875 dump_decl (DECL_CONTEXT (t
), flags
);
876 pp_cxx_colon_colon (cxx_pp
);
878 dump_decl (DECL_NAME (t
), flags
);
882 /* If there's only one function, just treat it like an ordinary
888 if (! DECL_LANG_SPECIFIC (t
))
889 pp_identifier (cxx_pp
, "<built-in>");
890 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
891 dump_global_iord (t
);
893 dump_function_decl (t
, flags
);
897 dump_template_decl (t
, flags
);
900 case TEMPLATE_ID_EXPR
:
902 tree name
= TREE_OPERAND (t
, 0);
904 if (is_overloaded_fn (name
))
905 name
= DECL_NAME (get_first_fn (name
));
906 dump_decl (name
, flags
);
907 pp_cxx_begin_template_argument_list (cxx_pp
);
908 if (TREE_OPERAND (t
, 1))
909 dump_template_argument_list (TREE_OPERAND (t
, 1), flags
);
910 pp_cxx_end_template_argument_list (cxx_pp
);
915 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
919 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
920 || (DECL_INITIAL (t
) &&
921 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
922 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
923 else if (DECL_NAME (t
))
924 dump_decl (DECL_NAME (t
), flags
);
925 else if (DECL_INITIAL (t
))
926 dump_expr (DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
928 pp_identifier (cxx_pp
, "<enumerator>");
932 pp_cxx_identifier (cxx_pp
, "using");
933 dump_type (USING_DECL_SCOPE (t
), flags
);
934 pp_cxx_colon_colon (cxx_pp
);
935 dump_decl (DECL_NAME (t
), flags
);
939 pp_cxx_declaration (cxx_pp
, t
);
943 dump_decl (BASELINK_FUNCTIONS (t
), flags
);
946 case NON_DEPENDENT_EXPR
:
947 dump_expr (t
, flags
);
950 case TEMPLATE_TYPE_PARM
:
951 if (flags
& TFF_DECL_SPECIFIERS
)
952 pp_cxx_declaration (cxx_pp
, t
);
954 pp_type_id (cxx_pp
, t
);
957 case UNBOUND_CLASS_TEMPLATE
:
958 case TYPE_PACK_EXPANSION
:
959 dump_type (t
, flags
);
963 pp_unsupported_tree (cxx_pp
, t
);
964 /* Fall through to error. */
967 pp_identifier (cxx_pp
, "<declaration error>");
972 /* Dump a template declaration T under control of FLAGS. This means the
973 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
976 dump_template_decl (tree t
, int flags
)
978 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
982 if (flags
& TFF_TEMPLATE_HEADER
)
984 for (parms
= orig_parms
= nreverse (orig_parms
);
986 parms
= TREE_CHAIN (parms
))
988 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
989 int len
= TREE_VEC_LENGTH (inner_parms
);
991 pp_cxx_identifier (cxx_pp
, "template");
992 pp_cxx_begin_template_argument_list (cxx_pp
);
994 /* If we've shown the template prefix, we'd better show the
995 parameters' and decl's type too. */
996 flags
|= TFF_DECL_SPECIFIERS
;
998 for (i
= 0; i
< len
; i
++)
1001 pp_separate_with_comma (cxx_pp
);
1002 dump_template_parameter (TREE_VEC_ELT (inner_parms
, i
), flags
);
1004 pp_cxx_end_template_argument_list (cxx_pp
);
1005 pp_cxx_whitespace (cxx_pp
);
1007 nreverse(orig_parms
);
1009 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1010 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1011 pp_cxx_identifier (cxx_pp
, "class");
1014 if (TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == TYPE_DECL
)
1015 dump_type (TREE_TYPE (t
),
1016 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1017 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1018 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == VAR_DECL
)
1019 dump_decl (DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1022 gcc_assert (TREE_TYPE (t
));
1023 switch (NEXT_CODE (t
))
1027 dump_function_decl (t
, flags
| TFF_TEMPLATE_NAME
);
1030 /* This case can occur with some invalid code. */
1031 dump_type (TREE_TYPE (t
),
1032 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1033 | (flags
& TFF_DECL_SPECIFIERS
1034 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1039 /* Pretty print a function decl. There are several ways we want to print a
1040 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1041 As error can only apply the '#' flag once to give 0 and 1 for V, there
1042 is %D which doesn't print the throw specs, and %F which does. */
1045 dump_function_decl (tree t
, int flags
)
1049 tree cname
= NULL_TREE
;
1050 tree template_args
= NULL_TREE
;
1051 tree template_parms
= NULL_TREE
;
1052 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1053 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1055 flags
&= ~TFF_UNQUALIFIED_NAME
;
1056 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1057 t
= DECL_TEMPLATE_RESULT (t
);
1059 /* Pretty print template instantiations only. */
1060 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
))
1064 template_args
= DECL_TI_ARGS (t
);
1065 tmpl
= most_general_template (t
);
1066 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1068 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1073 fntype
= TREE_TYPE (t
);
1074 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1076 if (DECL_CLASS_SCOPE_P (t
))
1077 cname
= DECL_CONTEXT (t
);
1078 /* This is for partially instantiated template methods. */
1079 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1080 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1082 if (!(flags
& TFF_DECL_SPECIFIERS
))
1084 else if (DECL_STATIC_FUNCTION_P (t
))
1085 pp_cxx_identifier (cxx_pp
, "static");
1086 else if (DECL_VIRTUAL_P (t
))
1087 pp_cxx_identifier (cxx_pp
, "virtual");
1089 /* Print the return type? */
1091 show_return
= !DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1092 && !DECL_DESTRUCTOR_P (t
);
1094 dump_type_prefix (TREE_TYPE (fntype
), flags
);
1096 /* Print the function name. */
1097 if (!do_outer_scope
)
1101 dump_type (cname
, flags
);
1102 pp_cxx_colon_colon (cxx_pp
);
1105 dump_scope (CP_DECL_CONTEXT (t
), flags
);
1107 dump_function_name (t
, flags
);
1109 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1111 dump_parameters (parmtypes
, flags
);
1113 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1115 pp_base (cxx_pp
)->padding
= pp_before
;
1116 pp_cxx_cv_qualifier_seq
1117 (cxx_pp
, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype
))));
1120 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1122 pp_base (cxx_pp
)->padding
= pp_before
;
1123 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype
), flags
);
1127 dump_type_suffix (TREE_TYPE (fntype
), flags
);
1130 /* If T is a template instantiation, dump the parameter binding. */
1131 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
)
1133 pp_cxx_whitespace (cxx_pp
);
1134 pp_cxx_left_bracket (cxx_pp
);
1135 pp_cxx_identifier (cxx_pp
, "with");
1136 pp_cxx_whitespace (cxx_pp
);
1137 dump_template_bindings (template_parms
, template_args
);
1138 pp_cxx_right_bracket (cxx_pp
);
1142 /* Print a parameter list. If this is for a member function, the
1143 member object ptr (and any other hidden args) should have
1144 already been removed. */
1147 dump_parameters (tree parmtypes
, int flags
)
1150 pp_cxx_left_paren (cxx_pp
);
1152 for (first
= 1; parmtypes
!= void_list_node
;
1153 parmtypes
= TREE_CHAIN (parmtypes
))
1156 pp_separate_with_comma (cxx_pp
);
1160 pp_cxx_identifier (cxx_pp
, "...");
1164 dump_type (TREE_VALUE (parmtypes
), flags
);
1166 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1168 pp_cxx_whitespace (cxx_pp
);
1170 pp_cxx_whitespace (cxx_pp
);
1171 dump_expr (TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1175 pp_cxx_right_paren (cxx_pp
);
1178 /* Print an exception specification. T is the exception specification. */
1181 dump_exception_spec (tree t
, int flags
)
1185 pp_cxx_identifier (cxx_pp
, "throw");
1186 pp_cxx_whitespace (cxx_pp
);
1187 pp_cxx_left_paren (cxx_pp
);
1188 if (TREE_VALUE (t
) != NULL_TREE
)
1191 dump_type (TREE_VALUE (t
), flags
);
1195 pp_separate_with_comma (cxx_pp
);
1197 pp_cxx_right_paren (cxx_pp
);
1201 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1202 and destructors properly. */
1205 dump_function_name (tree t
, int flags
)
1207 tree name
= DECL_NAME (t
);
1209 /* We can get here with a decl that was synthesized by language-
1210 independent machinery (e.g. coverage.c) in which case it won't
1211 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1212 will crash. In this case it is safe just to print out the
1214 if (!DECL_LANG_SPECIFIC (t
))
1216 pp_cxx_tree_identifier (cxx_pp
, name
);
1220 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1221 t
= DECL_TEMPLATE_RESULT (t
);
1223 /* Don't let the user see __comp_ctor et al. */
1224 if (DECL_CONSTRUCTOR_P (t
)
1225 || DECL_DESTRUCTOR_P (t
))
1226 name
= constructor_name (DECL_CONTEXT (t
));
1228 if (DECL_DESTRUCTOR_P (t
))
1230 pp_cxx_complement (cxx_pp
);
1231 dump_decl (name
, TFF_PLAIN_IDENTIFIER
);
1233 else if (DECL_CONV_FN_P (t
))
1235 /* This cannot use the hack that the operator's return
1236 type is stashed off of its name because it may be
1237 used for error reporting. In the case of conflicting
1238 declarations, both will have the same name, yet
1239 the types will be different, hence the TREE_TYPE field
1240 of the first name will be clobbered by the second. */
1241 pp_cxx_identifier (cxx_pp
, "operator");
1242 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1244 else if (IDENTIFIER_OPNAME_P (name
))
1245 pp_cxx_tree_identifier (cxx_pp
, name
);
1247 dump_decl (name
, flags
);
1249 if (DECL_TEMPLATE_INFO (t
)
1250 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1251 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1252 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1253 dump_template_parms (DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
), flags
);
1256 /* Dump the template parameters from the template info INFO under control of
1257 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1258 specialization (partial or complete). For partial specializations we show
1259 the specialized parameter values. For a primary template we show no
1263 dump_template_parms (tree info
, int primary
, int flags
)
1265 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1267 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1269 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1270 pp_cxx_begin_template_argument_list (cxx_pp
);
1272 /* Be careful only to print things when we have them, so as not
1273 to crash producing error messages. */
1274 if (args
&& !primary
)
1278 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
1279 args
= TREE_VEC_ELT (args
, TREE_VEC_LENGTH (args
) - 1);
1281 len
= TREE_VEC_LENGTH (args
);
1283 for (ix
= 0; ix
!= len
; ix
++)
1285 tree arg
= TREE_VEC_ELT (args
, ix
);
1287 /* Only print a comma if we know there is an argument coming. In
1288 the case of an empty template argument pack, no actual
1289 argument will be printed. */
1291 && (!ARGUMENT_PACK_P (arg
)
1292 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1293 pp_separate_with_comma (cxx_pp
);
1296 pp_identifier (cxx_pp
, "<template parameter error>");
1298 dump_template_argument (arg
, flags
);
1303 tree tpl
= TI_TEMPLATE (info
);
1304 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1307 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1308 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1310 for (ix
= 0; ix
!= len
; ix
++)
1314 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1316 pp_identifier (cxx_pp
, "<template parameter error>");
1320 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1323 pp_separate_with_comma (cxx_pp
);
1325 dump_decl (parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1328 pp_cxx_end_template_argument_list (cxx_pp
);
1331 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1332 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1335 dump_call_expr_args (tree t
, int flags
, bool skipfirst
)
1338 call_expr_arg_iterator iter
;
1340 pp_cxx_left_paren (cxx_pp
);
1341 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1347 dump_expr (arg
, flags
| TFF_EXPR_IN_PARENS
);
1348 if (more_call_expr_args_p (&iter
))
1349 pp_separate_with_comma (cxx_pp
);
1352 pp_cxx_right_paren (cxx_pp
);
1355 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1356 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1360 dump_aggr_init_expr_args (tree t
, int flags
, bool skipfirst
)
1363 aggr_init_expr_arg_iterator iter
;
1365 pp_cxx_left_paren (cxx_pp
);
1366 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1372 dump_expr (arg
, flags
| TFF_EXPR_IN_PARENS
);
1373 if (more_aggr_init_expr_args_p (&iter
))
1374 pp_separate_with_comma (cxx_pp
);
1377 pp_cxx_right_paren (cxx_pp
);
1380 /* Print out a list of initializers (subr of dump_expr). */
1383 dump_expr_list (tree l
, int flags
)
1387 dump_expr (TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1390 pp_separate_with_comma (cxx_pp
);
1394 /* Print out a vector of initializers (subr of dump_expr). */
1397 dump_expr_init_vec (VEC(constructor_elt
,gc
) *v
, int flags
)
1399 unsigned HOST_WIDE_INT idx
;
1402 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1404 dump_expr (value
, flags
| TFF_EXPR_IN_PARENS
);
1405 if (idx
!= VEC_length (constructor_elt
, v
) - 1)
1406 pp_separate_with_comma (cxx_pp
);
1411 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1412 function. Resolve it to a close relative -- in the sense of static
1413 type -- variant being overridden. That is close to what was written in
1414 the source code. Subroutine of dump_expr. */
1417 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1419 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1420 HOST_WIDE_INT index
= tree_low_cst (OBJ_TYPE_REF_TOKEN (ref
), 1);
1421 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1424 fun
= TREE_CHAIN (fun
);
1425 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1426 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
1432 /* Print out an expression E under control of FLAGS. */
1435 dump_expr (tree t
, int flags
)
1440 switch (TREE_CODE (t
))
1448 case NAMESPACE_DECL
:
1451 case IDENTIFIER_NODE
:
1452 dump_decl (t
, (flags
& ~TFF_DECL_SPECIFIERS
) | TFF_NO_FUNCTION_ARGUMENTS
);
1459 pp_constant (cxx_pp
, t
);
1463 pp_cxx_identifier (cxx_pp
, "throw");
1464 dump_expr (TREE_OPERAND (t
, 0), flags
);
1468 pp_ampersand (cxx_pp
);
1469 dump_type (PTRMEM_CST_CLASS (t
), flags
);
1470 pp_cxx_colon_colon (cxx_pp
);
1471 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
1475 pp_cxx_left_paren (cxx_pp
);
1476 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1477 pp_separate_with_comma (cxx_pp
);
1478 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1479 pp_cxx_right_paren (cxx_pp
);
1483 pp_cxx_left_paren (cxx_pp
);
1484 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1485 pp_string (cxx_pp
, " ? ");
1486 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1487 pp_string (cxx_pp
, " : ");
1488 dump_expr (TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
1489 pp_cxx_right_paren (cxx_pp
);
1493 if (TREE_HAS_CONSTRUCTOR (t
))
1495 pp_cxx_identifier (cxx_pp
, "new");
1496 pp_cxx_whitespace (cxx_pp
);
1497 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1500 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1503 case AGGR_INIT_EXPR
:
1505 tree fn
= NULL_TREE
;
1507 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
1508 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
1510 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
1512 if (DECL_CONSTRUCTOR_P (fn
))
1513 dump_type (DECL_CONTEXT (fn
), flags
);
1518 dump_expr (AGGR_INIT_EXPR_FN (t
), 0);
1520 dump_aggr_init_expr_args (t
, flags
, true);
1525 tree fn
= CALL_EXPR_FN (t
);
1526 bool skipfirst
= false;
1528 if (TREE_CODE (fn
) == ADDR_EXPR
)
1529 fn
= TREE_OPERAND (fn
, 0);
1531 /* Nobody is interested in seeing the guts of vcalls. */
1532 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
1533 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
1535 if (TREE_TYPE (fn
) != NULL_TREE
&& NEXT_CODE (fn
) == METHOD_TYPE
)
1537 tree ob
= CALL_EXPR_ARG (t
, 0);
1538 if (TREE_CODE (ob
) == ADDR_EXPR
)
1540 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1541 pp_cxx_dot (cxx_pp
);
1543 else if (TREE_CODE (ob
) != PARM_DECL
1544 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
1546 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1547 pp_cxx_arrow (cxx_pp
);
1551 dump_expr (fn
, flags
| TFF_EXPR_IN_PARENS
);
1552 dump_call_expr_args (t
, flags
, skipfirst
);
1558 tree type
= TREE_OPERAND (t
, 1);
1559 tree init
= TREE_OPERAND (t
, 2);
1560 if (NEW_EXPR_USE_GLOBAL (t
))
1561 pp_cxx_colon_colon (cxx_pp
);
1562 pp_cxx_identifier (cxx_pp
, "new");
1563 if (TREE_OPERAND (t
, 0))
1565 pp_cxx_left_paren (cxx_pp
);
1566 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1567 pp_cxx_right_paren (cxx_pp
);
1568 pp_cxx_whitespace (cxx_pp
);
1570 if (TREE_CODE (type
) == ARRAY_REF
)
1571 type
= build_cplus_array_type
1572 (TREE_OPERAND (type
, 0),
1573 build_index_type (fold_build2 (MINUS_EXPR
, integer_type_node
,
1574 TREE_OPERAND (type
, 1),
1575 integer_one_node
)));
1576 dump_type (type
, flags
);
1579 pp_cxx_left_paren (cxx_pp
);
1580 if (TREE_CODE (init
) == TREE_LIST
)
1581 dump_expr_list (init
, flags
);
1582 else if (init
== void_zero_node
)
1583 /* This representation indicates an empty initializer,
1584 e.g.: "new int()". */
1587 dump_expr (init
, flags
);
1588 pp_cxx_right_paren (cxx_pp
);
1594 /* Note that this only works for G++ target exprs. If somebody
1595 builds a general TARGET_EXPR, there's no way to represent that
1596 it initializes anything other that the parameter slot for the
1597 default argument. Note we may have cleared out the first
1598 operand in expand_expr, so don't go killing ourselves. */
1599 if (TREE_OPERAND (t
, 1))
1600 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1603 case POINTER_PLUS_EXPR
:
1604 dump_binary_op ("+", t
, flags
);
1612 case TRUNC_DIV_EXPR
:
1613 case TRUNC_MOD_EXPR
:
1621 case TRUTH_ANDIF_EXPR
:
1622 case TRUTH_ORIF_EXPR
:
1629 case EXACT_DIV_EXPR
:
1630 dump_binary_op (operator_name_info
[(int) TREE_CODE (t
)].name
, t
, flags
);
1634 case FLOOR_DIV_EXPR
:
1635 case ROUND_DIV_EXPR
:
1637 dump_binary_op ("/", t
, flags
);
1641 case FLOOR_MOD_EXPR
:
1642 case ROUND_MOD_EXPR
:
1643 dump_binary_op ("%", t
, flags
);
1648 tree ob
= TREE_OPERAND (t
, 0);
1649 if (TREE_CODE (ob
) == INDIRECT_REF
)
1651 ob
= TREE_OPERAND (ob
, 0);
1652 if (TREE_CODE (ob
) != PARM_DECL
1654 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
1656 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1657 pp_cxx_arrow (cxx_pp
);
1662 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1663 pp_cxx_dot (cxx_pp
);
1665 dump_expr (TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
1670 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1671 pp_cxx_left_bracket (cxx_pp
);
1672 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1673 pp_cxx_right_bracket (cxx_pp
);
1676 case UNARY_PLUS_EXPR
:
1677 dump_unary_op ("+", t
, flags
);
1681 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
1682 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
1683 /* An ADDR_EXPR can have reference type. In that case, we
1684 shouldn't print the `&' doing so indicates to the user
1685 that the expression has pointer type. */
1687 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
1688 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1689 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
1690 dump_unary_op ("&&", t
, flags
);
1692 dump_unary_op ("&", t
, flags
);
1696 if (TREE_HAS_CONSTRUCTOR (t
))
1698 t
= TREE_OPERAND (t
, 0);
1699 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
1700 dump_expr (CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
1701 dump_call_expr_args (t
, flags
, true);
1705 if (TREE_OPERAND (t
,0) != NULL_TREE
1706 && TREE_TYPE (TREE_OPERAND (t
, 0))
1707 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
1708 dump_expr (TREE_OPERAND (t
, 0), flags
);
1710 dump_unary_op ("*", t
, flags
);
1716 case TRUTH_NOT_EXPR
:
1717 case PREDECREMENT_EXPR
:
1718 case PREINCREMENT_EXPR
:
1719 dump_unary_op (operator_name_info
[(int)TREE_CODE (t
)].name
, t
, flags
);
1722 case POSTDECREMENT_EXPR
:
1723 case POSTINCREMENT_EXPR
:
1724 pp_cxx_left_paren (cxx_pp
);
1725 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1726 pp_cxx_identifier (cxx_pp
, operator_name_info
[(int)TREE_CODE (t
)].name
);
1727 pp_cxx_right_paren (cxx_pp
);
1730 case NON_LVALUE_EXPR
:
1731 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1732 should be another level of INDIRECT_REF so that I don't have to do
1734 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
1736 tree next
= TREE_TYPE (TREE_TYPE (t
));
1738 while (TREE_CODE (next
) == POINTER_TYPE
)
1739 next
= TREE_TYPE (next
);
1741 if (TREE_CODE (next
) == FUNCTION_TYPE
)
1743 if (flags
& TFF_EXPR_IN_PARENS
)
1744 pp_cxx_left_paren (cxx_pp
);
1745 pp_cxx_star (cxx_pp
);
1746 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1747 if (flags
& TFF_EXPR_IN_PARENS
)
1748 pp_cxx_right_paren (cxx_pp
);
1751 /* Else fall through. */
1753 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1759 tree op
= TREE_OPERAND (t
, 0);
1761 if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
1763 /* It is a cast, but we cannot tell whether it is a
1764 reinterpret or static cast. Use the C style notation. */
1765 if (flags
& TFF_EXPR_IN_PARENS
)
1766 pp_cxx_left_paren (cxx_pp
);
1767 pp_cxx_left_paren (cxx_pp
);
1768 dump_type (TREE_TYPE (t
), flags
);
1769 pp_cxx_right_paren (cxx_pp
);
1770 dump_expr (op
, flags
| TFF_EXPR_IN_PARENS
);
1771 if (flags
& TFF_EXPR_IN_PARENS
)
1772 pp_cxx_right_paren (cxx_pp
);
1775 dump_expr (op
, flags
);
1780 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
1782 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
1784 if (integer_zerop (idx
))
1786 /* A NULL pointer-to-member constant. */
1787 pp_cxx_left_paren (cxx_pp
);
1788 pp_cxx_left_paren (cxx_pp
);
1789 dump_type (TREE_TYPE (t
), flags
);
1790 pp_cxx_right_paren (cxx_pp
);
1791 pp_character (cxx_pp
, '0');
1792 pp_cxx_right_paren (cxx_pp
);
1795 else if (host_integerp (idx
, 0))
1798 unsigned HOST_WIDE_INT n
;
1800 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
1801 t
= TYPE_METHOD_BASETYPE (t
);
1802 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
1804 n
= tree_low_cst (idx
, 0);
1806 /* Map vtable index back one, to allow for the null pointer to
1810 while (n
> 0 && virtuals
)
1813 virtuals
= TREE_CHAIN (virtuals
);
1817 dump_expr (BV_FN (virtuals
),
1818 flags
| TFF_EXPR_IN_PARENS
);
1823 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
1825 dump_type (TREE_TYPE (t
), 0);
1826 pp_cxx_left_paren (cxx_pp
);
1827 pp_cxx_right_paren (cxx_pp
);
1831 pp_cxx_left_brace (cxx_pp
);
1832 dump_expr_init_vec (CONSTRUCTOR_ELTS (t
), flags
);
1833 pp_cxx_right_brace (cxx_pp
);
1840 tree ob
= TREE_OPERAND (t
, 0);
1841 if (is_dummy_object (ob
))
1843 t
= TREE_OPERAND (t
, 1);
1844 if (TREE_CODE (t
) == FUNCTION_DECL
)
1846 dump_expr (t
, flags
| TFF_EXPR_IN_PARENS
);
1847 else if (BASELINK_P (t
))
1848 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
1849 flags
| TFF_EXPR_IN_PARENS
);
1851 dump_decl (t
, flags
);
1855 if (TREE_CODE (ob
) == INDIRECT_REF
)
1857 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1858 pp_cxx_arrow (cxx_pp
);
1859 pp_cxx_star (cxx_pp
);
1863 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1864 pp_cxx_dot (cxx_pp
);
1865 pp_cxx_star (cxx_pp
);
1867 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1872 case TEMPLATE_PARM_INDEX
:
1873 dump_decl (TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
1877 pp_expression (cxx_pp
, t
);
1881 if (TREE_OPERAND (t
, 0) == NULL_TREE
1882 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
1884 dump_type (TREE_TYPE (t
), flags
);
1885 pp_cxx_left_paren (cxx_pp
);
1886 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1887 pp_cxx_right_paren (cxx_pp
);
1891 pp_cxx_left_paren (cxx_pp
);
1892 dump_type (TREE_TYPE (t
), flags
);
1893 pp_cxx_right_paren (cxx_pp
);
1894 pp_cxx_left_paren (cxx_pp
);
1895 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
1896 pp_cxx_right_paren (cxx_pp
);
1900 case STATIC_CAST_EXPR
:
1901 pp_cxx_identifier (cxx_pp
, "static_cast");
1903 case REINTERPRET_CAST_EXPR
:
1904 pp_cxx_identifier (cxx_pp
, "reinterpret_cast");
1906 case CONST_CAST_EXPR
:
1907 pp_cxx_identifier (cxx_pp
, "const_cast");
1909 case DYNAMIC_CAST_EXPR
:
1910 pp_cxx_identifier (cxx_pp
, "dynamic_cast");
1912 pp_cxx_begin_template_argument_list (cxx_pp
);
1913 dump_type (TREE_TYPE (t
), flags
);
1914 pp_cxx_end_template_argument_list (cxx_pp
);
1915 pp_cxx_left_paren (cxx_pp
);
1916 dump_expr (TREE_OPERAND (t
, 0), flags
);
1917 pp_cxx_right_paren (cxx_pp
);
1921 dump_expr (TREE_OPERAND (t
, 0), flags
);
1922 pp_cxx_arrow (cxx_pp
);
1927 if (TREE_CODE (t
) == SIZEOF_EXPR
)
1928 pp_cxx_identifier (cxx_pp
, "sizeof");
1931 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
1932 pp_cxx_identifier (cxx_pp
, "__alignof__");
1934 pp_cxx_whitespace (cxx_pp
);
1935 pp_cxx_left_paren (cxx_pp
);
1936 if (TYPE_P (TREE_OPERAND (t
, 0)))
1937 dump_type (TREE_OPERAND (t
, 0), flags
);
1939 dump_expr (TREE_OPERAND (t
, 0), flags
);
1940 pp_cxx_right_paren (cxx_pp
);
1945 pp_cxx_identifier (cxx_pp
, operator_name_info
[TREE_CODE (t
)].name
);
1946 pp_cxx_whitespace (cxx_pp
);
1947 dump_expr (TREE_OPERAND (t
, 0), flags
);
1951 pp_identifier (cxx_pp
, "<unparsed>");
1954 case TRY_CATCH_EXPR
:
1955 case WITH_CLEANUP_EXPR
:
1956 case CLEANUP_POINT_EXPR
:
1957 dump_expr (TREE_OPERAND (t
, 0), flags
);
1960 case PSEUDO_DTOR_EXPR
:
1961 dump_expr (TREE_OPERAND (t
, 2), flags
);
1962 pp_cxx_dot (cxx_pp
);
1963 dump_type (TREE_OPERAND (t
, 0), flags
);
1964 pp_cxx_colon_colon (cxx_pp
);
1965 pp_cxx_complement (cxx_pp
);
1966 dump_type (TREE_OPERAND (t
, 1), flags
);
1969 case TEMPLATE_ID_EXPR
:
1970 dump_decl (t
, flags
);
1975 case STATEMENT_LIST
:
1976 /* We don't yet have a way of dumping statements in a
1977 human-readable format. */
1978 pp_string (cxx_pp
, "({...})");
1982 pp_string (cxx_pp
, "while (1) { ");
1983 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1984 pp_cxx_right_brace (cxx_pp
);
1988 pp_string (cxx_pp
, "if (");
1989 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1990 pp_string (cxx_pp
, ") break; ");
1994 dump_expr (get_first_fn (t
), flags
& ~TFF_EXPR_IN_PARENS
);
1997 case EMPTY_CLASS_EXPR
:
1998 dump_type (TREE_TYPE (t
), flags
);
1999 pp_cxx_left_paren (cxx_pp
);
2000 pp_cxx_right_paren (cxx_pp
);
2003 case NON_DEPENDENT_EXPR
:
2004 dump_expr (TREE_OPERAND (t
, 0), flags
);
2007 case EXPR_PACK_EXPANSION
:
2008 dump_expr (PACK_EXPANSION_PATTERN (t
), flags
);
2009 pp_cxx_identifier (cxx_pp
, "...");
2012 case ARGUMENT_PACK_SELECT
:
2013 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2025 pp_type_specifier_seq (cxx_pp
, t
);
2029 /* We get here when we want to print a dependent type as an
2030 id-expression, without any disambiguator decoration. */
2031 pp_id_expression (cxx_pp
, t
);
2034 case TEMPLATE_TYPE_PARM
:
2035 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2036 dump_type (t
, flags
);
2040 pp_cxx_trait_expression (cxx_pp
, t
);
2044 pp_cxx_typeid_expression (cxx_pp
, t
);
2048 pp_cxx_va_arg_expression (cxx_pp
, t
);
2052 case VEC_DELETE_EXPR
:
2053 pp_cxx_delete_expression (cxx_pp
, t
);
2056 /* This list is incomplete, but should suffice for now.
2057 It is very important that `sorry' does not call
2058 `report_error_function'. That could cause an infinite loop. */
2060 pp_unsupported_tree (cxx_pp
, t
);
2061 /* fall through to ERROR_MARK... */
2063 pp_identifier (cxx_pp
, "<expression error>");
2069 dump_binary_op (const char *opstring
, tree t
, int flags
)
2071 pp_cxx_left_paren (cxx_pp
);
2072 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2073 pp_cxx_whitespace (cxx_pp
);
2075 pp_cxx_identifier (cxx_pp
, opstring
);
2077 pp_identifier (cxx_pp
, "<unknown operator>");
2078 pp_cxx_whitespace (cxx_pp
);
2079 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2080 pp_cxx_right_paren (cxx_pp
);
2084 dump_unary_op (const char *opstring
, tree t
, int flags
)
2086 if (flags
& TFF_EXPR_IN_PARENS
)
2087 pp_cxx_left_paren (cxx_pp
);
2088 pp_cxx_identifier (cxx_pp
, opstring
);
2089 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2090 if (flags
& TFF_EXPR_IN_PARENS
)
2091 pp_cxx_right_paren (cxx_pp
);
2095 reinit_cxx_pp (void)
2097 pp_clear_output_area (cxx_pp
);
2098 pp_base (cxx_pp
)->padding
= pp_none
;
2099 pp_indentation (cxx_pp
) = 0;
2100 pp_needs_newline (cxx_pp
) = false;
2101 cxx_pp
->enclosing_scope
= 0;
2105 /* Exported interface to stringifying types, exprs and decls under TFF_*
2109 type_as_string (tree typ
, int flags
)
2112 dump_type (typ
, flags
);
2113 return pp_formatted_text (cxx_pp
);
2117 expr_as_string (tree decl
, int flags
)
2120 dump_expr (decl
, flags
);
2121 return pp_formatted_text (cxx_pp
);
2125 decl_as_string (tree decl
, int flags
)
2128 dump_decl (decl
, flags
);
2129 return pp_formatted_text (cxx_pp
);
2132 /* Generate the three forms of printable names for cxx_printable_name. */
2135 lang_decl_name (tree decl
, int v
)
2138 return decl_as_string (decl
, TFF_DECL_SPECIFIERS
);
2141 if (v
== 1 && DECL_CLASS_SCOPE_P (decl
))
2143 dump_type (CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2144 pp_cxx_colon_colon (cxx_pp
);
2147 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2148 dump_function_name (decl
, TFF_PLAIN_IDENTIFIER
);
2150 dump_decl (DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2152 return pp_formatted_text (cxx_pp
);
2155 /* Return the location of a tree passed to %+ formats. */
2158 location_of (tree t
)
2160 if (TREE_CODE (t
) == PARM_DECL
&& DECL_CONTEXT (t
))
2161 t
= DECL_CONTEXT (t
);
2162 else if (TYPE_P (t
))
2163 t
= TYPE_MAIN_DECL (t
);
2164 else if (TREE_CODE (t
) == OVERLOAD
)
2165 t
= OVL_FUNCTION (t
);
2167 return DECL_SOURCE_LOCATION (t
);
2170 /* Now the interfaces from error et al to dump_type et al. Each takes an
2171 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2175 decl_to_string (tree decl
, int verbose
)
2179 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2180 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2181 flags
= TFF_CLASS_KEY_OR_ENUM
;
2183 flags
|= TFF_DECL_SPECIFIERS
;
2184 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2185 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2186 flags
|= TFF_TEMPLATE_HEADER
;
2189 dump_decl (decl
, flags
);
2190 return pp_formatted_text (cxx_pp
);
2194 expr_to_string (tree decl
)
2197 dump_expr (decl
, 0);
2198 return pp_formatted_text (cxx_pp
);
2202 fndecl_to_string (tree fndecl
, int verbose
)
2206 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
2207 | TFF_TEMPLATE_HEADER
;
2209 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
2211 dump_decl (fndecl
, flags
);
2212 return pp_formatted_text (cxx_pp
);
2217 code_to_string (enum tree_code c
)
2219 return tree_code_name
[c
];
2223 language_to_string (enum languages c
)
2230 case lang_cplusplus
:
2242 /* Return the proper printed version of a parameter to a C++ function. */
2245 parm_to_string (int p
)
2249 pp_string (cxx_pp
, "'this'");
2251 pp_decimal_int (cxx_pp
, p
+ 1);
2252 return pp_formatted_text (cxx_pp
);
2256 op_to_string (enum tree_code p
)
2258 tree id
= operator_name_info
[(int) p
].identifier
;
2259 return id
? IDENTIFIER_POINTER (id
) : "<unknown>";
2263 type_to_string (tree typ
, int verbose
)
2267 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2268 flags
|= TFF_TEMPLATE_HEADER
;
2271 dump_type (typ
, flags
);
2272 return pp_formatted_text (cxx_pp
);
2276 assop_to_string (enum tree_code p
)
2278 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
2279 return id
? IDENTIFIER_POINTER (id
) : "{unknown}";
2283 args_to_string (tree p
, int verbose
)
2287 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2292 if (TYPE_P (TREE_VALUE (p
)))
2293 return type_as_string (p
, flags
);
2296 for (; p
; p
= TREE_CHAIN (p
))
2298 if (TREE_VALUE (p
) == null_node
)
2299 pp_cxx_identifier (cxx_pp
, "NULL");
2301 dump_type (error_type (TREE_VALUE (p
)), flags
);
2303 pp_separate_with_comma (cxx_pp
);
2305 return pp_formatted_text (cxx_pp
);
2309 cv_to_string (tree p
, int v
)
2312 pp_base (cxx_pp
)->padding
= v
? pp_before
: pp_none
;
2313 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
2314 return pp_formatted_text (cxx_pp
);
2317 /* Langhook for print_error_function. */
2319 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
2320 diagnostic_info
*diagnostic
)
2322 lhd_print_error_function (context
, file
, diagnostic
);
2323 pp_base_set_prefix (context
->printer
, file
);
2324 maybe_print_instantiation_context (context
);
2328 cp_diagnostic_starter (diagnostic_context
*context
,
2329 diagnostic_info
*diagnostic
)
2331 diagnostic_report_current_module (context
);
2332 cp_print_error_function (context
, diagnostic
);
2333 maybe_print_instantiation_context (context
);
2334 pp_base_set_prefix (context
->printer
, diagnostic_build_prefix (diagnostic
));
2338 cp_diagnostic_finalizer (diagnostic_context
*context
,
2339 diagnostic_info
*diagnostic ATTRIBUTE_UNUSED
)
2341 pp_base_destroy_prefix (context
->printer
);
2344 /* Print current function onto BUFFER, in the process of reporting
2345 a diagnostic message. Called from cp_diagnostic_starter. */
2347 cp_print_error_function (diagnostic_context
*context
,
2348 diagnostic_info
*diagnostic
)
2350 if (diagnostic_last_function_changed (context
, diagnostic
))
2352 const char *old_prefix
= context
->printer
->prefix
;
2353 const char *file
= LOCATION_FILE (diagnostic
->location
);
2354 tree abstract_origin
= diagnostic
->abstract_origin
;
2355 char *new_prefix
= (file
&& abstract_origin
== NULL
)
2356 ? file_name_as_prefix (file
) : NULL
;
2358 pp_base_set_prefix (context
->printer
, new_prefix
);
2360 if (current_function_decl
== NULL
)
2361 pp_base_string (context
->printer
, "At global scope:");
2366 if (abstract_origin
)
2368 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
2369 while (TREE_CODE (ao
) == BLOCK
&& BLOCK_ABSTRACT_ORIGIN (ao
))
2370 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
2371 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
2375 fndecl
= current_function_decl
;
2377 pp_printf (context
->printer
, "In %s %qs",
2378 function_category (fndecl
),
2379 cxx_printable_name (fndecl
, 2));
2381 while (abstract_origin
)
2384 tree block
= abstract_origin
;
2386 locus
= &BLOCK_SOURCE_LOCATION (block
);
2388 block
= BLOCK_SUPERCONTEXT (block
);
2389 while (block
&& TREE_CODE (block
) == BLOCK
2390 && BLOCK_ABSTRACT_ORIGIN (block
))
2392 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
2394 while (TREE_CODE (ao
) == BLOCK
&& BLOCK_ABSTRACT_ORIGIN (ao
))
2395 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
2397 if (TREE_CODE (ao
) == FUNCTION_DECL
)
2402 else if (TREE_CODE (ao
) != BLOCK
)
2405 block
= BLOCK_SUPERCONTEXT (block
);
2408 abstract_origin
= block
;
2411 while (block
&& TREE_CODE (block
) == BLOCK
)
2412 block
= BLOCK_SUPERCONTEXT (block
);
2414 if (TREE_CODE (block
) == FUNCTION_DECL
)
2416 abstract_origin
= NULL
;
2420 expanded_location s
= expand_location (*locus
);
2421 pp_base_character (context
->printer
, ',');
2422 pp_base_newline (context
->printer
);
2425 #ifdef USE_MAPPED_LOCATION
2426 if (flag_show_column
&& s
.column
!= 0)
2427 pp_printf (context
->printer
,
2428 " inlined from %qs at %s:%d:%d",
2429 cxx_printable_name (fndecl
, 2),
2430 s
.file
, s
.line
, s
.column
);
2433 pp_printf (context
->printer
,
2434 " inlined from %qs at %s:%d",
2435 cxx_printable_name (fndecl
, 2),
2440 pp_printf (context
->printer
, " inlined from %qs",
2441 cxx_printable_name (fndecl
, 2));
2444 pp_base_character (context
->printer
, ':');
2446 pp_base_newline (context
->printer
);
2448 diagnostic_set_last_function (context
, diagnostic
);
2449 pp_base_destroy_prefix (context
->printer
);
2450 context
->printer
->prefix
= old_prefix
;
2454 /* Returns a description of FUNCTION using standard terminology. */
2456 function_category (tree fn
)
2458 if (DECL_FUNCTION_MEMBER_P (fn
))
2460 if (DECL_STATIC_FUNCTION_P (fn
))
2461 return "static member function";
2462 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
2463 return "copy constructor";
2464 else if (DECL_CONSTRUCTOR_P (fn
))
2465 return "constructor";
2466 else if (DECL_DESTRUCTOR_P (fn
))
2467 return "destructor";
2469 return "member function";
2475 /* Report the full context of a current template instantiation,
2478 print_instantiation_full_context (diagnostic_context
*context
)
2480 struct tinst_level
*p
= current_instantiation ();
2481 location_t location
= input_location
;
2485 if (current_function_decl
!= p
->decl
2486 && current_function_decl
!= NULL_TREE
)
2487 /* We can get here during the processing of some synthesized
2488 method. Then, P->DECL will be the function that's causing
2493 if (current_function_decl
== p
->decl
)
2494 /* Avoid redundancy with the "In function" line. */;
2496 pp_verbatim (context
->printer
,
2497 "%s: In instantiation of %qs:\n",
2498 LOCATION_FILE (location
),
2499 decl_as_string (p
->decl
,
2500 TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
));
2502 location
= p
->locus
;
2507 print_instantiation_partial_context (context
, p
, location
);
2510 /* Same as above but less verbose. */
2512 print_instantiation_partial_context (diagnostic_context
*context
,
2513 struct tinst_level
*t
, location_t loc
)
2515 expanded_location xloc
;
2516 for (; ; t
= t
->next
)
2518 xloc
= expand_location (loc
);
2521 pp_verbatim (context
->printer
, "%s:%d: instantiated from %qs\n",
2522 xloc
.file
, xloc
.line
,
2523 decl_as_string (t
->decl
,
2524 TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
));
2527 pp_verbatim (context
->printer
, "%s:%d: instantiated from here",
2528 xloc
.file
, xloc
.line
);
2529 pp_base_newline (context
->printer
);
2532 /* Called from cp_thing to print the template context for an error. */
2534 maybe_print_instantiation_context (diagnostic_context
*context
)
2536 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2539 record_last_problematic_instantiation ();
2540 print_instantiation_full_context (context
);
2543 /* Report the bare minimum context of a template instantiation. */
2545 print_instantiation_context (void)
2547 print_instantiation_partial_context
2548 (global_dc
, current_instantiation (), input_location
);
2549 diagnostic_flush_buffer (global_dc
);
2552 /* Called from output_format -- during diagnostic message processing --
2553 to handle C++ specific format specifier with the following meanings:
2554 %A function argument-list.
2558 %F function declaration.
2559 %L language as used in extern "lang".
2561 %P function parameter whose position is indicated by an integer.
2562 %Q assignment operator.
2566 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
2567 int precision
, bool wide
, bool set_locus
, bool verbose
)
2571 #define next_tree (t = va_arg (*text->args_ptr, tree))
2572 #define next_tcode va_arg (*text->args_ptr, enum tree_code)
2573 #define next_lang va_arg (*text->args_ptr, enum languages)
2574 #define next_int va_arg (*text->args_ptr, int)
2576 if (precision
!= 0 || wide
)
2579 if (text
->locus
== NULL
)
2584 case 'A': result
= args_to_string (next_tree
, verbose
); break;
2585 case 'C': result
= code_to_string (next_tcode
); break;
2588 tree temp
= next_tree
;
2590 && DECL_DEBUG_EXPR_IS_FROM (temp
) && DECL_DEBUG_EXPR (temp
))
2592 temp
= DECL_DEBUG_EXPR (temp
);
2595 result
= expr_to_string (temp
);
2599 result
= decl_to_string (temp
, verbose
);
2602 case 'E': result
= expr_to_string (next_tree
); break;
2603 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
2604 case 'L': result
= language_to_string (next_lang
); break;
2605 case 'O': result
= op_to_string (next_tcode
); break;
2606 case 'P': result
= parm_to_string (next_int
); break;
2607 case 'Q': result
= assop_to_string (next_tcode
); break;
2608 case 'T': result
= type_to_string (next_tree
, verbose
); break;
2609 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
2615 pp_base_string (pp
, result
);
2616 if (set_locus
&& t
!= NULL
)
2617 *text
->locus
= location_of (t
);
2625 /* Callback from cpp_error for PFILE to print diagnostics arising from
2626 interpreting strings. The diagnostic is of type LEVEL; MSG is the
2627 translated message and AP the arguments. */
2630 cp_cpp_error (cpp_reader
*pfile ATTRIBUTE_UNUSED
, int level
,
2631 const char *msg
, va_list *ap
)
2633 diagnostic_info diagnostic
;
2634 diagnostic_t dlevel
;
2637 case CPP_DL_WARNING
:
2638 case CPP_DL_WARNING_SYSHDR
:
2639 dlevel
= DK_WARNING
;
2641 case CPP_DL_PEDWARN
:
2642 dlevel
= pedantic_error_kind ();
2653 diagnostic_set_info_translated (&diagnostic
, msg
, ap
,
2654 input_location
, dlevel
);
2655 report_diagnostic (&diagnostic
);
2658 /* Warn about the use of variadic templates when appropriate. */
2660 maybe_warn_variadic_templates (void)
2662 if ((cxx_dialect
== cxx98
) && !in_system_header
)
2663 /* We really want to suppress this warning in system headers,
2664 because libstdc++ uses variadic templates even when we aren't
2666 pedwarn ("ISO C++ does not include variadic templates");