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, 2003,
4 2004, 2005, 2006, 2007, 2008, 2009, 2010 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"
29 #include "diagnostic.h"
30 #include "tree-diagnostic.h"
31 #include "langhooks-def.h"
33 #include "cxx-pretty-print.h"
34 #include "tree-pretty-print.h"
35 #include "pointer-set.h"
37 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
39 /* The global buffer where we dump everything. It is there only for
40 transitional purpose. It is expected, in the near future, to be
41 completely removed. */
42 static cxx_pretty_printer scratch_pretty_printer
;
43 #define cxx_pp (&scratch_pretty_printer)
45 /* Translate if being used for diagnostics, but not for dump files or
47 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
49 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
51 static const char *args_to_string (tree
, int);
52 static const char *assop_to_string (enum tree_code
);
53 static const char *code_to_string (enum tree_code
);
54 static const char *cv_to_string (tree
, int);
55 static const char *decl_to_string (tree
, int);
56 static const char *expr_to_string (tree
);
57 static const char *fndecl_to_string (tree
, int);
58 static const char *op_to_string (enum tree_code
);
59 static const char *parm_to_string (int);
60 static const char *type_to_string (tree
, int);
62 static void dump_type (tree
, int);
63 static void dump_typename (tree
, int);
64 static void dump_simple_decl (tree
, tree
, int);
65 static void dump_decl (tree
, int);
66 static void dump_template_decl (tree
, int);
67 static void dump_function_decl (tree
, int);
68 static void dump_expr (tree
, int);
69 static void dump_unary_op (const char *, tree
, int);
70 static void dump_binary_op (const char *, tree
, int);
71 static void dump_aggr_type (tree
, int);
72 static void dump_type_prefix (tree
, int);
73 static void dump_type_suffix (tree
, int);
74 static void dump_function_name (tree
, int);
75 static void dump_call_expr_args (tree
, int, bool);
76 static void dump_aggr_init_expr_args (tree
, int, bool);
77 static void dump_expr_list (tree
, int);
78 static void dump_global_iord (tree
);
79 static void dump_parameters (tree
, int);
80 static void dump_exception_spec (tree
, int);
81 static void dump_template_argument (tree
, int);
82 static void dump_template_argument_list (tree
, int);
83 static void dump_template_parameter (tree
, int);
84 static void dump_template_bindings (tree
, tree
, VEC(tree
,gc
) *);
85 static void dump_scope (tree
, int);
86 static void dump_template_parms (tree
, int, int);
87 static int get_non_default_template_args_count (tree
, int);
88 static const char *function_category (tree
);
89 static void maybe_print_instantiation_context (diagnostic_context
*);
90 static void print_instantiation_full_context (diagnostic_context
*);
91 static void print_instantiation_partial_context (diagnostic_context
*,
94 static void cp_diagnostic_starter (diagnostic_context
*, diagnostic_info
*);
95 static void cp_diagnostic_finalizer (diagnostic_context
*, diagnostic_info
*);
96 static void cp_print_error_function (diagnostic_context
*, diagnostic_info
*);
98 static bool cp_printer (pretty_printer
*, text_info
*, const char *,
99 int, bool, bool, bool);
100 static location_t
location_of (tree
);
105 diagnostic_starter (global_dc
) = cp_diagnostic_starter
;
106 diagnostic_finalizer (global_dc
) = cp_diagnostic_finalizer
;
107 diagnostic_format_decoder (global_dc
) = cp_printer
;
109 pp_construct (pp_base (cxx_pp
), NULL
, 0);
110 pp_cxx_pretty_printer_init (cxx_pp
);
113 /* Dump a scope, if deemed necessary. */
116 dump_scope (tree scope
, int flags
)
118 int f
= flags
& (TFF_SCOPE
| TFF_CHASE_TYPEDEF
);
120 if (scope
== NULL_TREE
)
123 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
125 if (scope
!= global_namespace
)
127 dump_decl (scope
, f
);
128 pp_cxx_colon_colon (cxx_pp
);
131 else if (AGGREGATE_TYPE_P (scope
))
133 dump_type (scope
, f
);
134 pp_cxx_colon_colon (cxx_pp
);
136 else if ((flags
& TFF_SCOPE
) && TREE_CODE (scope
) == FUNCTION_DECL
)
138 dump_function_decl (scope
, f
);
139 pp_cxx_colon_colon (cxx_pp
);
143 /* Dump the template ARGument under control of FLAGS. */
146 dump_template_argument (tree arg
, int flags
)
148 if (ARGUMENT_PACK_P (arg
))
149 dump_template_argument_list (ARGUMENT_PACK_ARGS (arg
), flags
);
150 else if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
151 dump_type (arg
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
154 if (TREE_CODE (arg
) == TREE_LIST
)
155 arg
= TREE_VALUE (arg
);
157 dump_expr (arg
, (flags
| TFF_EXPR_IN_PARENS
) & ~TFF_CLASS_KEY_OR_ENUM
);
161 /* Count the number of template arguments ARGS whose value does not
162 match the (optional) default template parameter in PARAMS */
165 get_non_default_template_args_count (tree args
, int flags
)
167 int n
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args
));
169 if (/* We use this flag when generating debug information. We don't
170 want to expand templates at this point, for this may generate
171 new decls, which gets decl counts out of sync, which may in
172 turn cause codegen differences between compilations with and
174 (flags
& TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
) != 0
175 || !flag_pretty_templates
)
178 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args
));
181 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
185 dump_template_argument_list (tree args
, int flags
)
187 int n
= get_non_default_template_args_count (args
, flags
);
191 for (i
= 0; i
< n
; ++i
)
193 tree arg
= TREE_VEC_ELT (args
, i
);
195 /* Only print a comma if we know there is an argument coming. In
196 the case of an empty template argument pack, no actual
197 argument will be printed. */
199 && (!ARGUMENT_PACK_P (arg
)
200 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
201 pp_separate_with_comma (cxx_pp
);
203 dump_template_argument (arg
, flags
);
208 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
211 dump_template_parameter (tree parm
, int flags
)
216 if (parm
== error_mark_node
)
219 p
= TREE_VALUE (parm
);
220 a
= TREE_PURPOSE (parm
);
222 if (TREE_CODE (p
) == TYPE_DECL
)
224 if (flags
& TFF_DECL_SPECIFIERS
)
226 pp_cxx_ws_string (cxx_pp
, "class");
227 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p
)))
228 pp_cxx_ws_string (cxx_pp
, "...");
230 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (p
));
232 else if (DECL_NAME (p
))
233 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (p
));
235 pp_cxx_canonical_template_parameter (cxx_pp
, TREE_TYPE (p
));
238 dump_decl (p
, flags
| TFF_DECL_SPECIFIERS
);
240 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && a
!= NULL_TREE
)
242 pp_cxx_whitespace (cxx_pp
);
244 pp_cxx_whitespace (cxx_pp
);
245 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
246 dump_type (a
, flags
& ~TFF_CHASE_TYPEDEF
);
248 dump_expr (a
, flags
| TFF_EXPR_IN_PARENS
);
252 /* Dump, under control of FLAGS, a template-parameter-list binding.
253 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
257 dump_template_bindings (tree parms
, tree args
, VEC(tree
,gc
)* typenames
)
265 tree p
= TREE_VALUE (parms
);
266 int lvl
= TMPL_PARMS_DEPTH (parms
);
269 tree lvl_args
= NULL_TREE
;
271 /* Don't crash if we had an invalid argument list. */
272 if (TMPL_ARGS_DEPTH (args
) >= lvl
)
273 lvl_args
= TMPL_ARGS_LEVEL (args
, lvl
);
275 for (i
= 0; i
< TREE_VEC_LENGTH (p
); ++i
)
277 tree arg
= NULL_TREE
;
279 /* Don't crash if we had an invalid argument list. */
280 if (lvl_args
&& NUM_TMPL_ARGS (lvl_args
) > arg_idx
)
281 arg
= TREE_VEC_ELT (lvl_args
, arg_idx
);
284 pp_separate_with_comma (cxx_pp
);
285 dump_template_parameter (TREE_VEC_ELT (p
, i
), TFF_PLAIN_IDENTIFIER
);
286 pp_cxx_whitespace (cxx_pp
);
288 pp_cxx_whitespace (cxx_pp
);
291 if (ARGUMENT_PACK_P (arg
))
292 pp_cxx_left_brace (cxx_pp
);
293 dump_template_argument (arg
, TFF_PLAIN_IDENTIFIER
);
294 if (ARGUMENT_PACK_P (arg
))
295 pp_cxx_right_brace (cxx_pp
);
298 pp_string (cxx_pp
, M_("<missing>"));
304 parms
= TREE_CHAIN (parms
);
307 for (i
= 0; VEC_iterate (tree
, typenames
, i
, t
); ++i
)
310 pp_separate_with_comma (cxx_pp
);
311 dump_type (t
, TFF_PLAIN_IDENTIFIER
);
312 pp_cxx_whitespace (cxx_pp
);
314 pp_cxx_whitespace (cxx_pp
);
315 t
= tsubst (t
, args
, tf_none
, NULL_TREE
);
316 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
317 pp_simple_type_specifier doesn't know about it. */
318 t
= strip_typedefs (t
);
319 dump_type (t
, TFF_PLAIN_IDENTIFIER
);
323 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
327 dump_type (tree t
, int flags
)
332 /* Don't print e.g. "struct mytypedef". */
333 if (TYPE_P (t
) && typedef_variant_p (t
))
335 tree decl
= TYPE_NAME (t
);
336 if ((flags
& TFF_CHASE_TYPEDEF
)
337 || DECL_SELF_REFERENCE_P (decl
)
338 || (!flag_pretty_templates
339 && DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)))
340 t
= strip_typedefs (t
);
341 else if (same_type_p (t
, TREE_TYPE (decl
)))
345 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
346 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
351 if (TYPE_PTRMEMFUNC_P (t
))
354 switch (TREE_CODE (t
))
357 if (t
== init_list_type_node
)
358 pp_string (cxx_pp
, M_("<brace-enclosed initializer list>"));
359 else if (t
== unknown_type_node
)
360 pp_string (cxx_pp
, M_("<unresolved overloaded function type>"));
363 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
364 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
369 /* A list of function parms. */
370 dump_parameters (t
, flags
);
373 case IDENTIFIER_NODE
:
374 pp_cxx_tree_identifier (cxx_pp
, t
);
378 dump_type (BINFO_TYPE (t
), flags
);
384 dump_aggr_type (t
, flags
);
388 if (flags
& TFF_CHASE_TYPEDEF
)
390 dump_type (DECL_ORIGINAL_TYPE (t
)
391 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
), flags
);
394 /* Else fall through. */
398 dump_decl (t
, flags
& ~TFF_DECL_SPECIFIERS
);
407 case FIXED_POINT_TYPE
:
408 pp_type_specifier_seq (cxx_pp
, t
);
411 case TEMPLATE_TEMPLATE_PARM
:
412 /* For parameters inside template signature. */
413 if (TYPE_IDENTIFIER (t
))
414 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
416 pp_cxx_canonical_template_parameter (cxx_pp
, t
);
419 case BOUND_TEMPLATE_TEMPLATE_PARM
:
421 tree args
= TYPE_TI_ARGS (t
);
422 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
423 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
424 pp_cxx_begin_template_argument_list (cxx_pp
);
425 dump_template_argument_list (args
, flags
);
426 pp_cxx_end_template_argument_list (cxx_pp
);
430 case TEMPLATE_TYPE_PARM
:
431 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
432 if (TYPE_IDENTIFIER (t
))
433 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
435 pp_cxx_canonical_template_parameter
436 (cxx_pp
, TEMPLATE_TYPE_PARM_INDEX (t
));
439 /* This is not always necessary for pointers and such, but doing this
440 reduces code size. */
449 dump_type_prefix (t
, flags
);
450 dump_type_suffix (t
, flags
);
454 if (! (flags
& TFF_CHASE_TYPEDEF
)
455 && DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
457 dump_decl (TYPE_NAME (t
), TFF_PLAIN_IDENTIFIER
);
460 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
461 pp_cxx_ws_string (cxx_pp
,
462 TYPENAME_IS_ENUM_P (t
) ? "enum"
463 : TYPENAME_IS_CLASS_P (t
) ? "class"
465 dump_typename (t
, flags
);
468 case UNBOUND_CLASS_TEMPLATE
:
469 if (! (flags
& TFF_UNQUALIFIED_NAME
))
471 dump_type (TYPE_CONTEXT (t
), flags
);
472 pp_cxx_colon_colon (cxx_pp
);
474 pp_cxx_ws_string (cxx_pp
, "template");
475 dump_type (DECL_NAME (TYPE_NAME (t
)), flags
);
479 pp_cxx_ws_string (cxx_pp
, "__typeof__");
480 pp_cxx_whitespace (cxx_pp
);
481 pp_cxx_left_paren (cxx_pp
);
482 dump_expr (TYPEOF_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
483 pp_cxx_right_paren (cxx_pp
);
486 case TYPE_PACK_EXPANSION
:
487 dump_type (PACK_EXPANSION_PATTERN (t
), flags
);
488 pp_cxx_ws_string (cxx_pp
, "...");
491 case TYPE_ARGUMENT_PACK
:
492 dump_template_argument (t
, flags
);
496 pp_cxx_ws_string (cxx_pp
, "decltype");
497 pp_cxx_whitespace (cxx_pp
);
498 pp_cxx_left_paren (cxx_pp
);
499 dump_expr (DECLTYPE_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
500 pp_cxx_right_paren (cxx_pp
);
504 pp_unsupported_tree (cxx_pp
, t
);
505 /* Fall through to error. */
508 pp_string (cxx_pp
, M_("<type error>"));
513 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
517 dump_typename (tree t
, int flags
)
519 tree ctx
= TYPE_CONTEXT (t
);
521 if (TREE_CODE (ctx
) == TYPENAME_TYPE
)
522 dump_typename (ctx
, flags
);
524 dump_type (ctx
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
525 pp_cxx_colon_colon (cxx_pp
);
526 dump_decl (TYPENAME_TYPE_FULLNAME (t
), flags
);
529 /* Return the name of the supplied aggregate, or enumeral type. */
532 class_key_or_enum_as_string (tree t
)
534 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
536 if (SCOPED_ENUM_P (t
))
541 else if (TREE_CODE (t
) == UNION_TYPE
)
543 else if (TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_DECLARED_CLASS (t
))
549 /* Print out a class declaration T under the control of FLAGS,
550 in the form `class foo'. */
553 dump_aggr_type (tree t
, int flags
)
556 const char *variety
= class_key_or_enum_as_string (t
);
560 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
562 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
563 pp_cxx_ws_string (cxx_pp
, variety
);
565 name
= TYPE_NAME (t
);
569 typdef
= !DECL_ARTIFICIAL (name
);
572 && ((flags
& TFF_CHASE_TYPEDEF
)
573 || (!flag_pretty_templates
&& DECL_LANG_SPECIFIC (name
)
574 && DECL_TEMPLATE_INFO (name
))))
575 || DECL_SELF_REFERENCE_P (name
))
577 t
= TYPE_MAIN_VARIANT (t
);
578 name
= TYPE_NAME (t
);
582 tmplate
= !typdef
&& TREE_CODE (t
) != ENUMERAL_TYPE
583 && TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_TEMPLATE_INFO (t
)
584 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
585 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
587 if (! (flags
& TFF_UNQUALIFIED_NAME
))
588 dump_scope (CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
589 flags
&= ~TFF_UNQUALIFIED_NAME
;
592 /* Because the template names are mangled, we have to locate
593 the most general template, and use that name. */
594 tree tpl
= CLASSTYPE_TI_TEMPLATE (t
);
596 while (DECL_TEMPLATE_INFO (tpl
))
597 tpl
= DECL_TI_TEMPLATE (tpl
);
600 name
= DECL_NAME (name
);
603 if (name
== 0 || ANON_AGGRNAME_P (name
))
605 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
606 pp_string (cxx_pp
, M_("<anonymous>"));
608 pp_printf (pp_base (cxx_pp
), M_("<anonymous %s>"), variety
);
610 else if (LAMBDANAME_P (name
))
612 /* A lambda's "type" is essentially its signature. */
613 pp_string (cxx_pp
, M_("<lambda"));
614 if (lambda_function (t
))
615 dump_parameters (FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t
)),
617 pp_character(cxx_pp
, '>');
620 pp_cxx_tree_identifier (cxx_pp
, name
);
622 dump_template_parms (TYPE_TEMPLATE_INFO (t
),
623 !CLASSTYPE_USE_TEMPLATE (t
),
624 flags
& ~TFF_TEMPLATE_HEADER
);
627 /* Dump into the obstack the initial part of the output for a given type.
628 This is necessary when dealing with things like functions returning
631 return type of `int (* fee ())()': pointer -> function -> int. Both
632 pointer (and reference and offset) and function (and member) types must
633 deal with prefix and suffix.
635 Arrays must also do this for DECL nodes, like int a[], and for things like
639 dump_type_prefix (tree t
, int flags
)
641 if (TYPE_PTRMEMFUNC_P (t
))
643 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
647 switch (TREE_CODE (t
))
652 tree sub
= TREE_TYPE (t
);
654 dump_type_prefix (sub
, flags
);
655 if (TREE_CODE (sub
) == ARRAY_TYPE
656 || TREE_CODE (sub
) == FUNCTION_TYPE
)
658 pp_cxx_whitespace (cxx_pp
);
659 pp_cxx_left_paren (cxx_pp
);
661 if (TREE_CODE (t
) == POINTER_TYPE
)
662 pp_character(cxx_pp
, '*');
663 else if (TREE_CODE (t
) == REFERENCE_TYPE
)
665 if (TYPE_REF_IS_RVALUE (t
))
666 pp_string (cxx_pp
, "&&");
668 pp_character (cxx_pp
, '&');
670 pp_base (cxx_pp
)->padding
= pp_before
;
671 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
677 dump_type_prefix (TREE_TYPE (t
), flags
);
678 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
680 pp_maybe_space (cxx_pp
);
681 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
682 pp_cxx_left_paren (cxx_pp
);
683 dump_type (TYPE_OFFSET_BASETYPE (t
), flags
);
684 pp_cxx_colon_colon (cxx_pp
);
686 pp_cxx_star (cxx_pp
);
687 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
688 pp_base (cxx_pp
)->padding
= pp_before
;
691 /* This can be reached without a pointer when dealing with
692 templates, e.g. std::is_function. */
694 dump_type_prefix (TREE_TYPE (t
), flags
);
698 dump_type_prefix (TREE_TYPE (t
), flags
);
699 pp_maybe_space (cxx_pp
);
700 pp_cxx_left_paren (cxx_pp
);
701 dump_aggr_type (TYPE_METHOD_BASETYPE (t
), flags
);
702 pp_cxx_colon_colon (cxx_pp
);
706 dump_type_prefix (TREE_TYPE (t
), flags
);
710 case IDENTIFIER_NODE
:
715 case TEMPLATE_TYPE_PARM
:
716 case TEMPLATE_TEMPLATE_PARM
:
717 case BOUND_TEMPLATE_TEMPLATE_PARM
:
729 case TYPE_PACK_EXPANSION
:
730 case FIXED_POINT_TYPE
:
731 dump_type (t
, flags
);
732 pp_base (cxx_pp
)->padding
= pp_before
;
736 pp_unsupported_tree (cxx_pp
, t
);
739 pp_string (cxx_pp
, M_("<typeprefixerror>"));
744 /* Dump the suffix of type T, under control of FLAGS. This is the part
745 which appears after the identifier (or function parms). */
748 dump_type_suffix (tree t
, int flags
)
750 if (TYPE_PTRMEMFUNC_P (t
))
751 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
753 switch (TREE_CODE (t
))
758 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
759 || TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
760 pp_cxx_right_paren (cxx_pp
);
761 dump_type_suffix (TREE_TYPE (t
), flags
);
768 if (TREE_CODE (t
) == METHOD_TYPE
)
769 /* Can only be reached through a pointer. */
770 pp_cxx_right_paren (cxx_pp
);
771 arg
= TYPE_ARG_TYPES (t
);
772 if (TREE_CODE (t
) == METHOD_TYPE
)
773 arg
= TREE_CHAIN (arg
);
775 /* Function pointers don't have default args. Not in standard C++,
776 anyway; they may in g++, but we'll just pretend otherwise. */
777 dump_parameters (arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
779 if (TREE_CODE (t
) == METHOD_TYPE
)
780 pp_cxx_cv_qualifier_seq
781 (cxx_pp
, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))));
783 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
784 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t
), flags
);
785 dump_type_suffix (TREE_TYPE (t
), flags
);
790 pp_maybe_space (cxx_pp
);
791 pp_cxx_left_bracket (cxx_pp
);
794 tree dtype
= TYPE_DOMAIN (t
);
795 tree max
= TYPE_MAX_VALUE (dtype
);
796 if (host_integerp (max
, 0))
797 pp_wide_integer (cxx_pp
, tree_low_cst (max
, 0) + 1);
798 else if (TREE_CODE (max
) == MINUS_EXPR
)
799 dump_expr (TREE_OPERAND (max
, 0),
800 flags
& ~TFF_EXPR_IN_PARENS
);
802 dump_expr (fold_build2_loc (input_location
,
803 PLUS_EXPR
, dtype
, max
,
804 build_int_cst (dtype
, 1)),
805 flags
& ~TFF_EXPR_IN_PARENS
);
807 pp_cxx_right_bracket (cxx_pp
);
808 dump_type_suffix (TREE_TYPE (t
), flags
);
812 case IDENTIFIER_NODE
:
817 case TEMPLATE_TYPE_PARM
:
818 case TEMPLATE_TEMPLATE_PARM
:
819 case BOUND_TEMPLATE_TEMPLATE_PARM
:
831 case TYPE_PACK_EXPANSION
:
832 case FIXED_POINT_TYPE
:
836 pp_unsupported_tree (cxx_pp
, t
);
838 /* Don't mark it here, we should have already done in
845 dump_global_iord (tree t
)
847 const char *p
= NULL
;
849 if (DECL_GLOBAL_CTOR_P (t
))
850 p
= M_("(static initializers for %s)");
851 else if (DECL_GLOBAL_DTOR_P (t
))
852 p
= M_("(static destructors for %s)");
856 pp_printf (pp_base (cxx_pp
), p
, input_filename
);
860 dump_simple_decl (tree t
, tree type
, int flags
)
862 if (flags
& TFF_DECL_SPECIFIERS
)
864 dump_type_prefix (type
, flags
& ~TFF_UNQUALIFIED_NAME
);
865 pp_maybe_space (cxx_pp
);
867 if (! (flags
& TFF_UNQUALIFIED_NAME
)
868 && TREE_CODE (t
) != PARM_DECL
869 && (!DECL_INITIAL (t
)
870 || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
))
871 dump_scope (CP_DECL_CONTEXT (t
), flags
);
872 flags
&= ~TFF_UNQUALIFIED_NAME
;
873 if ((flags
& TFF_DECL_SPECIFIERS
)
874 && DECL_TEMPLATE_PARM_P (t
)
875 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t
)))
876 pp_string (cxx_pp
, "...");
878 dump_decl (DECL_NAME (t
), flags
);
880 pp_string (cxx_pp
, M_("<anonymous>"));
881 if (flags
& TFF_DECL_SPECIFIERS
)
882 dump_type_suffix (type
, flags
);
885 /* Dump a human readable string for the decl T under control of FLAGS. */
888 dump_decl (tree t
, int flags
)
893 switch (TREE_CODE (t
))
896 /* Don't say 'typedef class A' */
897 if (DECL_ARTIFICIAL (t
) && !DECL_SELF_REFERENCE_P (t
))
899 if ((flags
& TFF_DECL_SPECIFIERS
)
900 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
902 /* Say `class T' not just `T'. */
903 pp_cxx_ws_string (cxx_pp
, "class");
905 /* Emit the `...' for a parameter pack. */
906 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
907 pp_cxx_ws_string (cxx_pp
, "...");
910 dump_type (TREE_TYPE (t
), flags
);
913 if ((flags
& TFF_DECL_SPECIFIERS
)
914 && !DECL_SELF_REFERENCE_P (t
))
915 pp_cxx_ws_string (cxx_pp
, "typedef");
916 dump_simple_decl (t
, DECL_ORIGINAL_TYPE (t
)
917 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
922 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
924 pp_string (cxx_pp
, M_("vtable for "));
925 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
926 dump_type (DECL_CONTEXT (t
), flags
);
929 /* Else fall through. */
932 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
936 pp_string (cxx_pp
, M_("<return value> "));
937 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
941 if (flags
& TFF_DECL_SPECIFIERS
)
942 pp_cxx_declaration (cxx_pp
, t
);
945 if (! (flags
& TFF_UNQUALIFIED_NAME
))
946 dump_scope (CP_DECL_CONTEXT (t
), flags
);
947 flags
&= ~TFF_UNQUALIFIED_NAME
;
948 if (DECL_NAME (t
) == NULL_TREE
)
949 pp_cxx_ws_string (cxx_pp
, M_("{anonymous}"));
951 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
956 dump_type (TREE_OPERAND (t
, 0), flags
);
957 pp_string (cxx_pp
, "::");
958 dump_decl (TREE_OPERAND (t
, 1), flags
|TFF_UNQUALIFIED_NAME
);
962 dump_decl (TREE_OPERAND (t
, 0), flags
);
963 pp_cxx_left_bracket (cxx_pp
);
964 dump_decl (TREE_OPERAND (t
, 1), flags
);
965 pp_cxx_right_bracket (cxx_pp
);
968 /* So that we can do dump_decl on an aggr type. */
972 dump_type (t
, flags
);
976 /* This is a pseudo destructor call which has not been folded into
977 a PSEUDO_DTOR_EXPR yet. */
978 pp_cxx_complement (cxx_pp
);
979 dump_type (TREE_OPERAND (t
, 0), flags
);
986 /* These special cases are duplicated here so that other functions
987 can feed identifiers to error and get them demangled properly. */
988 case IDENTIFIER_NODE
:
989 if (IDENTIFIER_TYPENAME_P (t
))
991 pp_cxx_ws_string (cxx_pp
, "operator");
992 /* Not exactly IDENTIFIER_TYPE_VALUE. */
993 dump_type (TREE_TYPE (t
), flags
);
997 pp_cxx_tree_identifier (cxx_pp
, t
);
1003 t
= OVL_CURRENT (t
);
1004 if (DECL_CLASS_SCOPE_P (t
))
1006 dump_type (DECL_CONTEXT (t
), flags
);
1007 pp_cxx_colon_colon (cxx_pp
);
1009 else if (DECL_CONTEXT (t
))
1011 dump_decl (DECL_CONTEXT (t
), flags
);
1012 pp_cxx_colon_colon (cxx_pp
);
1014 dump_decl (DECL_NAME (t
), flags
);
1018 /* If there's only one function, just treat it like an ordinary
1020 t
= OVL_CURRENT (t
);
1024 if (! DECL_LANG_SPECIFIC (t
))
1025 pp_string (cxx_pp
, M_("<built-in>"));
1026 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1027 dump_global_iord (t
);
1029 dump_function_decl (t
, flags
);
1033 dump_template_decl (t
, flags
);
1036 case TEMPLATE_ID_EXPR
:
1038 tree name
= TREE_OPERAND (t
, 0);
1040 if (is_overloaded_fn (name
))
1041 name
= DECL_NAME (get_first_fn (name
));
1042 dump_decl (name
, flags
);
1043 pp_cxx_begin_template_argument_list (cxx_pp
);
1044 if (TREE_OPERAND (t
, 1))
1045 dump_template_argument_list (TREE_OPERAND (t
, 1), flags
);
1046 pp_cxx_end_template_argument_list (cxx_pp
);
1051 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
1055 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1056 || (DECL_INITIAL (t
) &&
1057 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1058 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
1059 else if (DECL_NAME (t
))
1060 dump_decl (DECL_NAME (t
), flags
);
1061 else if (DECL_INITIAL (t
))
1062 dump_expr (DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1064 pp_string (cxx_pp
, M_("<enumerator>"));
1068 pp_cxx_ws_string (cxx_pp
, "using");
1069 dump_type (USING_DECL_SCOPE (t
), flags
);
1070 pp_cxx_colon_colon (cxx_pp
);
1071 dump_decl (DECL_NAME (t
), flags
);
1075 pp_cxx_declaration (cxx_pp
, t
);
1079 dump_decl (BASELINK_FUNCTIONS (t
), flags
);
1082 case NON_DEPENDENT_EXPR
:
1083 dump_expr (t
, flags
);
1086 case TEMPLATE_TYPE_PARM
:
1087 if (flags
& TFF_DECL_SPECIFIERS
)
1088 pp_cxx_declaration (cxx_pp
, t
);
1090 pp_type_id (cxx_pp
, t
);
1093 case UNBOUND_CLASS_TEMPLATE
:
1094 case TYPE_PACK_EXPANSION
:
1096 dump_type (t
, flags
);
1100 pp_unsupported_tree (cxx_pp
, t
);
1101 /* Fall through to error. */
1104 pp_string (cxx_pp
, M_("<declaration error>"));
1109 /* Dump a template declaration T under control of FLAGS. This means the
1110 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1113 dump_template_decl (tree t
, int flags
)
1115 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1119 if (flags
& TFF_TEMPLATE_HEADER
)
1121 for (parms
= orig_parms
= nreverse (orig_parms
);
1123 parms
= TREE_CHAIN (parms
))
1125 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1126 int len
= TREE_VEC_LENGTH (inner_parms
);
1128 pp_cxx_ws_string (cxx_pp
, "template");
1129 pp_cxx_begin_template_argument_list (cxx_pp
);
1131 /* If we've shown the template prefix, we'd better show the
1132 parameters' and decl's type too. */
1133 flags
|= TFF_DECL_SPECIFIERS
;
1135 for (i
= 0; i
< len
; i
++)
1138 pp_separate_with_comma (cxx_pp
);
1139 dump_template_parameter (TREE_VEC_ELT (inner_parms
, i
), flags
);
1141 pp_cxx_end_template_argument_list (cxx_pp
);
1142 pp_cxx_whitespace (cxx_pp
);
1144 nreverse(orig_parms
);
1146 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1148 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1149 pp_cxx_ws_string (cxx_pp
, "class");
1151 /* If this is a parameter pack, print the ellipsis. */
1152 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1153 pp_cxx_ws_string (cxx_pp
, "...");
1157 if (DECL_TEMPLATE_RESULT (t
)
1158 && TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == TYPE_DECL
)
1159 dump_type (TREE_TYPE (t
),
1160 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1161 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1162 else if (DECL_TEMPLATE_RESULT (t
)
1163 && TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == VAR_DECL
)
1164 dump_decl (DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1167 gcc_assert (TREE_TYPE (t
));
1168 switch (NEXT_CODE (t
))
1172 dump_function_decl (t
, flags
| TFF_TEMPLATE_NAME
);
1175 /* This case can occur with some invalid code. */
1176 dump_type (TREE_TYPE (t
),
1177 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1178 | (flags
& TFF_DECL_SPECIFIERS
1179 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1184 /* find_typenames looks through the type of the function template T
1185 and returns a VEC containing any typedefs, decltypes or TYPENAME_TYPEs
1188 struct find_typenames_t
1190 struct pointer_set_t
*p_set
;
1191 VEC (tree
,gc
) *typenames
;
1195 find_typenames_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
1197 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1198 tree mv
= NULL_TREE
;
1200 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1201 /* Add the type of the typedef without any additional cv-quals. */
1202 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1203 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1204 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1205 /* Add the typename without any cv-qualifiers. */
1206 mv
= TYPE_MAIN_VARIANT (*tp
);
1208 if (mv
&& (mv
== *tp
|| !pointer_set_insert (d
->p_set
, mv
)))
1209 VEC_safe_push (tree
, gc
, d
->typenames
, mv
);
1211 /* Search into class template arguments, which cp_walk_subtrees
1213 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1214 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1220 static VEC(tree
,gc
) *
1221 find_typenames (tree t
)
1223 struct find_typenames_t ft
;
1224 ft
.p_set
= pointer_set_create ();
1225 ft
.typenames
= NULL
;
1226 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1227 find_typenames_r
, &ft
, ft
.p_set
);
1228 pointer_set_destroy (ft
.p_set
);
1229 return ft
.typenames
;
1232 /* Pretty print a function decl. There are several ways we want to print a
1233 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1234 As error can only apply the '#' flag once to give 0 and 1 for V, there
1235 is %D which doesn't print the throw specs, and %F which does. */
1238 dump_function_decl (tree t
, int flags
)
1242 tree cname
= NULL_TREE
;
1243 tree template_args
= NULL_TREE
;
1244 tree template_parms
= NULL_TREE
;
1245 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1246 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1248 VEC(tree
,gc
) *typenames
= NULL
;
1250 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1252 /* A lambda's signature is essentially its "type", so defer. */
1253 gcc_assert (LAMBDA_TYPE_P (DECL_CONTEXT (t
)));
1254 dump_type (DECL_CONTEXT (t
), flags
);
1258 flags
&= ~TFF_UNQUALIFIED_NAME
;
1259 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1260 t
= DECL_TEMPLATE_RESULT (t
);
1262 /* Save the exceptions, in case t is a specialization and we are
1263 emitting an error about incompatible specifications. */
1264 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1266 /* Pretty print template instantiations only. */
1267 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1268 && flag_pretty_templates
)
1272 template_args
= DECL_TI_ARGS (t
);
1273 tmpl
= most_general_template (t
);
1274 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1276 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1278 typenames
= find_typenames (t
);
1282 fntype
= TREE_TYPE (t
);
1283 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1285 if (DECL_CLASS_SCOPE_P (t
))
1286 cname
= DECL_CONTEXT (t
);
1287 /* This is for partially instantiated template methods. */
1288 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1289 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1291 if (!(flags
& TFF_DECL_SPECIFIERS
))
1293 else if (DECL_STATIC_FUNCTION_P (t
))
1294 pp_cxx_ws_string (cxx_pp
, "static");
1295 else if (DECL_VIRTUAL_P (t
))
1296 pp_cxx_ws_string (cxx_pp
, "virtual");
1298 /* Print the return type? */
1300 show_return
= !DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1301 && !DECL_DESTRUCTOR_P (t
);
1303 dump_type_prefix (TREE_TYPE (fntype
), flags
);
1305 /* Print the function name. */
1306 if (!do_outer_scope
)
1310 dump_type (cname
, flags
);
1311 pp_cxx_colon_colon (cxx_pp
);
1314 dump_scope (CP_DECL_CONTEXT (t
), flags
);
1316 dump_function_name (t
, flags
);
1318 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1320 dump_parameters (parmtypes
, flags
);
1322 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1324 pp_base (cxx_pp
)->padding
= pp_before
;
1325 pp_cxx_cv_qualifier_seq
1326 (cxx_pp
, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype
))));
1329 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1331 pp_base (cxx_pp
)->padding
= pp_before
;
1332 dump_exception_spec (exceptions
, flags
);
1336 dump_type_suffix (TREE_TYPE (fntype
), flags
);
1339 /* If T is a template instantiation, dump the parameter binding. */
1340 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
)
1342 pp_cxx_whitespace (cxx_pp
);
1343 pp_cxx_left_bracket (cxx_pp
);
1344 pp_cxx_ws_string (cxx_pp
, M_("with"));
1345 pp_cxx_whitespace (cxx_pp
);
1346 dump_template_bindings (template_parms
, template_args
, typenames
);
1347 pp_cxx_right_bracket (cxx_pp
);
1351 /* Print a parameter list. If this is for a member function, the
1352 member object ptr (and any other hidden args) should have
1353 already been removed. */
1356 dump_parameters (tree parmtypes
, int flags
)
1359 flags
&= ~TFF_SCOPE
;
1360 pp_cxx_left_paren (cxx_pp
);
1362 for (first
= 1; parmtypes
!= void_list_node
;
1363 parmtypes
= TREE_CHAIN (parmtypes
))
1366 pp_separate_with_comma (cxx_pp
);
1370 pp_cxx_ws_string (cxx_pp
, "...");
1374 dump_type (TREE_VALUE (parmtypes
), flags
);
1376 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1378 pp_cxx_whitespace (cxx_pp
);
1380 pp_cxx_whitespace (cxx_pp
);
1381 dump_expr (TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1385 pp_cxx_right_paren (cxx_pp
);
1388 /* Print an exception specification. T is the exception specification. */
1391 dump_exception_spec (tree t
, int flags
)
1393 if (t
&& TREE_PURPOSE (t
))
1395 pp_cxx_ws_string (cxx_pp
, "noexcept");
1396 pp_cxx_whitespace (cxx_pp
);
1397 pp_cxx_left_paren (cxx_pp
);
1398 dump_expr (TREE_PURPOSE (t
), flags
);
1399 pp_cxx_right_paren (cxx_pp
);
1403 pp_cxx_ws_string (cxx_pp
, "throw");
1404 pp_cxx_whitespace (cxx_pp
);
1405 pp_cxx_left_paren (cxx_pp
);
1406 if (TREE_VALUE (t
) != NULL_TREE
)
1409 dump_type (TREE_VALUE (t
), flags
);
1413 pp_separate_with_comma (cxx_pp
);
1415 pp_cxx_right_paren (cxx_pp
);
1419 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1420 and destructors properly. */
1423 dump_function_name (tree t
, int flags
)
1425 tree name
= DECL_NAME (t
);
1427 /* We can get here with a decl that was synthesized by language-
1428 independent machinery (e.g. coverage.c) in which case it won't
1429 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1430 will crash. In this case it is safe just to print out the
1432 if (!DECL_LANG_SPECIFIC (t
))
1434 pp_cxx_tree_identifier (cxx_pp
, name
);
1438 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1439 t
= DECL_TEMPLATE_RESULT (t
);
1441 /* Don't let the user see __comp_ctor et al. */
1442 if (DECL_CONSTRUCTOR_P (t
)
1443 || DECL_DESTRUCTOR_P (t
))
1445 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1446 name
= get_identifier ("<lambda>");
1448 name
= constructor_name (DECL_CONTEXT (t
));
1451 if (DECL_DESTRUCTOR_P (t
))
1453 pp_cxx_complement (cxx_pp
);
1454 dump_decl (name
, TFF_PLAIN_IDENTIFIER
);
1456 else if (DECL_CONV_FN_P (t
))
1458 /* This cannot use the hack that the operator's return
1459 type is stashed off of its name because it may be
1460 used for error reporting. In the case of conflicting
1461 declarations, both will have the same name, yet
1462 the types will be different, hence the TREE_TYPE field
1463 of the first name will be clobbered by the second. */
1464 pp_cxx_ws_string (cxx_pp
, "operator");
1465 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1467 else if (name
&& IDENTIFIER_OPNAME_P (name
))
1468 pp_cxx_tree_identifier (cxx_pp
, name
);
1470 dump_decl (name
, flags
);
1472 if (DECL_TEMPLATE_INFO (t
)
1473 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1474 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1475 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1476 dump_template_parms (DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
), flags
);
1479 /* Dump the template parameters from the template info INFO under control of
1480 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1481 specialization (partial or complete). For partial specializations we show
1482 the specialized parameter values. For a primary template we show no
1486 dump_template_parms (tree info
, int primary
, int flags
)
1488 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1490 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1492 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1493 pp_cxx_begin_template_argument_list (cxx_pp
);
1495 /* Be careful only to print things when we have them, so as not
1496 to crash producing error messages. */
1497 if (args
&& !primary
)
1500 len
= get_non_default_template_args_count (args
, flags
);
1502 args
= INNERMOST_TEMPLATE_ARGS (args
);
1503 for (ix
= 0; ix
!= len
; ix
++)
1505 tree arg
= TREE_VEC_ELT (args
, ix
);
1507 /* Only print a comma if we know there is an argument coming. In
1508 the case of an empty template argument pack, no actual
1509 argument will be printed. */
1511 && (!ARGUMENT_PACK_P (arg
)
1512 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1513 pp_separate_with_comma (cxx_pp
);
1516 pp_string (cxx_pp
, M_("<template parameter error>"));
1518 dump_template_argument (arg
, flags
);
1523 tree tpl
= TI_TEMPLATE (info
);
1524 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1527 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1528 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1530 for (ix
= 0; ix
!= len
; ix
++)
1534 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1536 pp_string (cxx_pp
, M_("<template parameter error>"));
1540 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1543 pp_separate_with_comma (cxx_pp
);
1545 dump_decl (parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1548 pp_cxx_end_template_argument_list (cxx_pp
);
1551 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1552 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1555 dump_call_expr_args (tree t
, int flags
, bool skipfirst
)
1558 call_expr_arg_iterator iter
;
1560 pp_cxx_left_paren (cxx_pp
);
1561 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1567 dump_expr (arg
, flags
| TFF_EXPR_IN_PARENS
);
1568 if (more_call_expr_args_p (&iter
))
1569 pp_separate_with_comma (cxx_pp
);
1572 pp_cxx_right_paren (cxx_pp
);
1575 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1576 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1580 dump_aggr_init_expr_args (tree t
, int flags
, bool skipfirst
)
1583 aggr_init_expr_arg_iterator iter
;
1585 pp_cxx_left_paren (cxx_pp
);
1586 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1592 dump_expr (arg
, flags
| TFF_EXPR_IN_PARENS
);
1593 if (more_aggr_init_expr_args_p (&iter
))
1594 pp_separate_with_comma (cxx_pp
);
1597 pp_cxx_right_paren (cxx_pp
);
1600 /* Print out a list of initializers (subr of dump_expr). */
1603 dump_expr_list (tree l
, int flags
)
1607 dump_expr (TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1610 pp_separate_with_comma (cxx_pp
);
1614 /* Print out a vector of initializers (subr of dump_expr). */
1617 dump_expr_init_vec (VEC(constructor_elt
,gc
) *v
, int flags
)
1619 unsigned HOST_WIDE_INT idx
;
1622 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1624 dump_expr (value
, flags
| TFF_EXPR_IN_PARENS
);
1625 if (idx
!= VEC_length (constructor_elt
, v
) - 1)
1626 pp_separate_with_comma (cxx_pp
);
1631 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1632 function. Resolve it to a close relative -- in the sense of static
1633 type -- variant being overridden. That is close to what was written in
1634 the source code. Subroutine of dump_expr. */
1637 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1639 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1640 HOST_WIDE_INT index
= tree_low_cst (OBJ_TYPE_REF_TOKEN (ref
), 1);
1641 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1644 fun
= TREE_CHAIN (fun
);
1645 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1646 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
1652 /* Print out an expression E under control of FLAGS. */
1655 dump_expr (tree t
, int flags
)
1660 if (STATEMENT_CLASS_P (t
))
1662 pp_cxx_ws_string (cxx_pp
, M_("<statement>"));
1666 switch (TREE_CODE (t
))
1674 case NAMESPACE_DECL
:
1677 case IDENTIFIER_NODE
:
1678 dump_decl (t
, (flags
& ~TFF_DECL_SPECIFIERS
) | TFF_NO_FUNCTION_ARGUMENTS
);
1685 pp_constant (cxx_pp
, t
);
1689 /* While waiting for caret diagnostics, avoid printing
1690 __cxa_allocate_exception, __cxa_throw, and the like. */
1691 pp_cxx_ws_string (cxx_pp
, M_("<throw-expression>"));
1695 pp_ampersand (cxx_pp
);
1696 dump_type (PTRMEM_CST_CLASS (t
), flags
);
1697 pp_cxx_colon_colon (cxx_pp
);
1698 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
1702 pp_cxx_left_paren (cxx_pp
);
1703 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1704 pp_separate_with_comma (cxx_pp
);
1705 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1706 pp_cxx_right_paren (cxx_pp
);
1710 pp_cxx_left_paren (cxx_pp
);
1711 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1712 pp_string (cxx_pp
, " ? ");
1713 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1714 pp_string (cxx_pp
, " : ");
1715 dump_expr (TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
1716 pp_cxx_right_paren (cxx_pp
);
1720 if (TREE_HAS_CONSTRUCTOR (t
))
1722 pp_cxx_ws_string (cxx_pp
, "new");
1723 pp_cxx_whitespace (cxx_pp
);
1724 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1727 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1730 case AGGR_INIT_EXPR
:
1732 tree fn
= NULL_TREE
;
1734 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
1735 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
1737 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
1739 if (DECL_CONSTRUCTOR_P (fn
))
1740 dump_type (DECL_CONTEXT (fn
), flags
);
1745 dump_expr (AGGR_INIT_EXPR_FN (t
), 0);
1747 dump_aggr_init_expr_args (t
, flags
, true);
1752 tree fn
= CALL_EXPR_FN (t
);
1753 bool skipfirst
= false;
1755 if (TREE_CODE (fn
) == ADDR_EXPR
)
1756 fn
= TREE_OPERAND (fn
, 0);
1758 /* Nobody is interested in seeing the guts of vcalls. */
1759 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
1760 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
1762 if (TREE_TYPE (fn
) != NULL_TREE
1763 && NEXT_CODE (fn
) == METHOD_TYPE
1764 && call_expr_nargs (t
))
1766 tree ob
= CALL_EXPR_ARG (t
, 0);
1767 if (TREE_CODE (ob
) == ADDR_EXPR
)
1769 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1770 pp_cxx_dot (cxx_pp
);
1772 else if (TREE_CODE (ob
) != PARM_DECL
1773 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
1775 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1776 pp_cxx_arrow (cxx_pp
);
1780 dump_expr (fn
, flags
| TFF_EXPR_IN_PARENS
);
1781 dump_call_expr_args (t
, flags
, skipfirst
);
1786 /* Note that this only works for G++ target exprs. If somebody
1787 builds a general TARGET_EXPR, there's no way to represent that
1788 it initializes anything other that the parameter slot for the
1789 default argument. Note we may have cleared out the first
1790 operand in expand_expr, so don't go killing ourselves. */
1791 if (TREE_OPERAND (t
, 1))
1792 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1795 case POINTER_PLUS_EXPR
:
1796 dump_binary_op ("+", t
, flags
);
1804 case TRUNC_DIV_EXPR
:
1805 case TRUNC_MOD_EXPR
:
1813 case TRUTH_ANDIF_EXPR
:
1814 case TRUTH_ORIF_EXPR
:
1821 case EXACT_DIV_EXPR
:
1822 dump_binary_op (operator_name_info
[(int) TREE_CODE (t
)].name
, t
, flags
);
1826 case FLOOR_DIV_EXPR
:
1827 case ROUND_DIV_EXPR
:
1829 dump_binary_op ("/", t
, flags
);
1833 case FLOOR_MOD_EXPR
:
1834 case ROUND_MOD_EXPR
:
1835 dump_binary_op ("%", t
, flags
);
1840 tree ob
= TREE_OPERAND (t
, 0);
1841 if (TREE_CODE (ob
) == INDIRECT_REF
)
1843 ob
= TREE_OPERAND (ob
, 0);
1844 if (TREE_CODE (ob
) != PARM_DECL
1846 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
1848 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1849 pp_cxx_arrow (cxx_pp
);
1854 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1855 pp_cxx_dot (cxx_pp
);
1857 dump_expr (TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
1862 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1863 pp_cxx_left_bracket (cxx_pp
);
1864 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1865 pp_cxx_right_bracket (cxx_pp
);
1868 case UNARY_PLUS_EXPR
:
1869 dump_unary_op ("+", t
, flags
);
1873 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
1874 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
1875 /* An ADDR_EXPR can have reference type. In that case, we
1876 shouldn't print the `&' doing so indicates to the user
1877 that the expression has pointer type. */
1879 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
1880 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1881 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
1882 dump_unary_op ("&&", t
, flags
);
1884 dump_unary_op ("&", t
, flags
);
1888 if (TREE_HAS_CONSTRUCTOR (t
))
1890 t
= TREE_OPERAND (t
, 0);
1891 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
1892 dump_expr (CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
1893 dump_call_expr_args (t
, flags
, true);
1897 if (TREE_OPERAND (t
,0) != NULL_TREE
1898 && TREE_TYPE (TREE_OPERAND (t
, 0))
1899 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
1900 dump_expr (TREE_OPERAND (t
, 0), flags
);
1902 dump_unary_op ("*", t
, flags
);
1908 case TRUTH_NOT_EXPR
:
1909 case PREDECREMENT_EXPR
:
1910 case PREINCREMENT_EXPR
:
1911 dump_unary_op (operator_name_info
[(int)TREE_CODE (t
)].name
, t
, flags
);
1914 case POSTDECREMENT_EXPR
:
1915 case POSTINCREMENT_EXPR
:
1916 pp_cxx_left_paren (cxx_pp
);
1917 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1918 pp_cxx_ws_string (cxx_pp
, operator_name_info
[(int)TREE_CODE (t
)].name
);
1919 pp_cxx_right_paren (cxx_pp
);
1922 case NON_LVALUE_EXPR
:
1923 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1924 should be another level of INDIRECT_REF so that I don't have to do
1926 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
1928 tree next
= TREE_TYPE (TREE_TYPE (t
));
1930 while (TREE_CODE (next
) == POINTER_TYPE
)
1931 next
= TREE_TYPE (next
);
1933 if (TREE_CODE (next
) == FUNCTION_TYPE
)
1935 if (flags
& TFF_EXPR_IN_PARENS
)
1936 pp_cxx_left_paren (cxx_pp
);
1937 pp_cxx_star (cxx_pp
);
1938 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
1939 if (flags
& TFF_EXPR_IN_PARENS
)
1940 pp_cxx_right_paren (cxx_pp
);
1943 /* Else fall through. */
1945 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1949 case VIEW_CONVERT_EXPR
:
1951 tree op
= TREE_OPERAND (t
, 0);
1953 if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
1955 /* It is a cast, but we cannot tell whether it is a
1956 reinterpret or static cast. Use the C style notation. */
1957 if (flags
& TFF_EXPR_IN_PARENS
)
1958 pp_cxx_left_paren (cxx_pp
);
1959 pp_cxx_left_paren (cxx_pp
);
1960 dump_type (TREE_TYPE (t
), flags
);
1961 pp_cxx_right_paren (cxx_pp
);
1962 dump_expr (op
, flags
| TFF_EXPR_IN_PARENS
);
1963 if (flags
& TFF_EXPR_IN_PARENS
)
1964 pp_cxx_right_paren (cxx_pp
);
1967 dump_expr (op
, flags
);
1972 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
1974 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
1976 if (integer_zerop (idx
))
1978 /* A NULL pointer-to-member constant. */
1979 pp_cxx_left_paren (cxx_pp
);
1980 pp_cxx_left_paren (cxx_pp
);
1981 dump_type (TREE_TYPE (t
), flags
);
1982 pp_cxx_right_paren (cxx_pp
);
1983 pp_character (cxx_pp
, '0');
1984 pp_cxx_right_paren (cxx_pp
);
1987 else if (host_integerp (idx
, 0))
1990 unsigned HOST_WIDE_INT n
;
1992 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
1993 t
= TYPE_METHOD_BASETYPE (t
);
1994 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
1996 n
= tree_low_cst (idx
, 0);
1998 /* Map vtable index back one, to allow for the null pointer to
2002 while (n
> 0 && virtuals
)
2005 virtuals
= TREE_CHAIN (virtuals
);
2009 dump_expr (BV_FN (virtuals
),
2010 flags
| TFF_EXPR_IN_PARENS
);
2015 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2017 dump_type (TREE_TYPE (t
), 0);
2018 pp_cxx_left_paren (cxx_pp
);
2019 pp_cxx_right_paren (cxx_pp
);
2023 pp_cxx_left_brace (cxx_pp
);
2024 dump_expr_init_vec (CONSTRUCTOR_ELTS (t
), flags
);
2025 pp_cxx_right_brace (cxx_pp
);
2032 tree ob
= TREE_OPERAND (t
, 0);
2033 if (is_dummy_object (ob
))
2035 t
= TREE_OPERAND (t
, 1);
2036 if (TREE_CODE (t
) == FUNCTION_DECL
)
2038 dump_expr (t
, flags
| TFF_EXPR_IN_PARENS
);
2039 else if (BASELINK_P (t
))
2040 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
2041 flags
| TFF_EXPR_IN_PARENS
);
2043 dump_decl (t
, flags
);
2047 if (TREE_CODE (ob
) == INDIRECT_REF
)
2049 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2050 pp_cxx_arrow (cxx_pp
);
2051 pp_cxx_star (cxx_pp
);
2055 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
2056 pp_cxx_dot (cxx_pp
);
2057 pp_cxx_star (cxx_pp
);
2059 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2064 case TEMPLATE_PARM_INDEX
:
2065 dump_decl (TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2069 if (TREE_OPERAND (t
, 0) == NULL_TREE
2070 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2072 dump_type (TREE_TYPE (t
), flags
);
2073 pp_cxx_left_paren (cxx_pp
);
2074 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
2075 pp_cxx_right_paren (cxx_pp
);
2079 pp_cxx_left_paren (cxx_pp
);
2080 dump_type (TREE_TYPE (t
), flags
);
2081 pp_cxx_right_paren (cxx_pp
);
2082 pp_cxx_left_paren (cxx_pp
);
2083 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
2084 pp_cxx_right_paren (cxx_pp
);
2088 case STATIC_CAST_EXPR
:
2089 pp_cxx_ws_string (cxx_pp
, "static_cast");
2091 case REINTERPRET_CAST_EXPR
:
2092 pp_cxx_ws_string (cxx_pp
, "reinterpret_cast");
2094 case CONST_CAST_EXPR
:
2095 pp_cxx_ws_string (cxx_pp
, "const_cast");
2097 case DYNAMIC_CAST_EXPR
:
2098 pp_cxx_ws_string (cxx_pp
, "dynamic_cast");
2100 pp_cxx_begin_template_argument_list (cxx_pp
);
2101 dump_type (TREE_TYPE (t
), flags
);
2102 pp_cxx_end_template_argument_list (cxx_pp
);
2103 pp_cxx_left_paren (cxx_pp
);
2104 dump_expr (TREE_OPERAND (t
, 0), flags
);
2105 pp_cxx_right_paren (cxx_pp
);
2109 dump_expr (TREE_OPERAND (t
, 0), flags
);
2110 pp_cxx_arrow (cxx_pp
);
2115 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2116 pp_cxx_ws_string (cxx_pp
, "sizeof");
2119 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2120 pp_cxx_ws_string (cxx_pp
, "__alignof__");
2122 pp_cxx_whitespace (cxx_pp
);
2123 pp_cxx_left_paren (cxx_pp
);
2124 if (TYPE_P (TREE_OPERAND (t
, 0)))
2125 dump_type (TREE_OPERAND (t
, 0), flags
);
2127 dump_expr (TREE_OPERAND (t
, 0), flags
);
2128 pp_cxx_right_paren (cxx_pp
);
2132 pp_cxx_ws_string (cxx_pp
, "noexcept");
2133 pp_cxx_whitespace (cxx_pp
);
2134 pp_cxx_left_paren (cxx_pp
);
2135 dump_expr (TREE_OPERAND (t
, 0), flags
);
2136 pp_cxx_right_paren (cxx_pp
);
2141 pp_cxx_ws_string (cxx_pp
, operator_name_info
[TREE_CODE (t
)].name
);
2142 pp_cxx_whitespace (cxx_pp
);
2143 dump_expr (TREE_OPERAND (t
, 0), flags
);
2147 pp_string (cxx_pp
, M_("<unparsed>"));
2150 case TRY_CATCH_EXPR
:
2151 case WITH_CLEANUP_EXPR
:
2152 case CLEANUP_POINT_EXPR
:
2153 dump_expr (TREE_OPERAND (t
, 0), flags
);
2156 case PSEUDO_DTOR_EXPR
:
2157 dump_expr (TREE_OPERAND (t
, 2), flags
);
2158 pp_cxx_dot (cxx_pp
);
2159 dump_type (TREE_OPERAND (t
, 0), flags
);
2160 pp_cxx_colon_colon (cxx_pp
);
2161 pp_cxx_complement (cxx_pp
);
2162 dump_type (TREE_OPERAND (t
, 1), flags
);
2165 case TEMPLATE_ID_EXPR
:
2166 dump_decl (t
, flags
);
2172 case STATEMENT_LIST
:
2173 /* We don't yet have a way of dumping statements in a
2174 human-readable format. */
2175 pp_string (cxx_pp
, "({...})");
2179 pp_string (cxx_pp
, "while (1) { ");
2180 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2181 pp_cxx_right_brace (cxx_pp
);
2185 pp_string (cxx_pp
, "if (");
2186 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2187 pp_string (cxx_pp
, ") break; ");
2191 dump_expr (get_first_fn (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2194 case EMPTY_CLASS_EXPR
:
2195 dump_type (TREE_TYPE (t
), flags
);
2196 pp_cxx_left_paren (cxx_pp
);
2197 pp_cxx_right_paren (cxx_pp
);
2200 case NON_DEPENDENT_EXPR
:
2201 dump_expr (TREE_OPERAND (t
, 0), flags
);
2204 case ARGUMENT_PACK_SELECT
:
2205 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2217 pp_type_specifier_seq (cxx_pp
, t
);
2221 /* We get here when we want to print a dependent type as an
2222 id-expression, without any disambiguator decoration. */
2223 pp_id_expression (cxx_pp
, t
);
2226 case TEMPLATE_TYPE_PARM
:
2227 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2228 dump_type (t
, flags
);
2232 pp_cxx_trait_expression (cxx_pp
, t
);
2236 pp_cxx_va_arg_expression (cxx_pp
, t
);
2240 pp_cxx_offsetof_expression (cxx_pp
, t
);
2244 dump_decl (t
, flags
);
2247 case EXPR_PACK_EXPANSION
:
2254 case VEC_DELETE_EXPR
:
2260 case UNORDERED_EXPR
:
2270 case FIX_TRUNC_EXPR
:
2272 pp_expression (cxx_pp
, t
);
2275 case TRUTH_AND_EXPR
:
2277 case TRUTH_XOR_EXPR
:
2278 if (flags
& TFF_EXPR_IN_PARENS
)
2279 pp_cxx_left_paren (cxx_pp
);
2280 pp_expression (cxx_pp
, t
);
2281 if (flags
& TFF_EXPR_IN_PARENS
)
2282 pp_cxx_right_paren (cxx_pp
);
2286 dump_expr (resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2289 /* This list is incomplete, but should suffice for now.
2290 It is very important that `sorry' does not call
2291 `report_error_function'. That could cause an infinite loop. */
2293 pp_unsupported_tree (cxx_pp
, t
);
2294 /* fall through to ERROR_MARK... */
2296 pp_string (cxx_pp
, M_("<expression error>"));
2302 dump_binary_op (const char *opstring
, tree t
, int flags
)
2304 pp_cxx_left_paren (cxx_pp
);
2305 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2306 pp_cxx_whitespace (cxx_pp
);
2308 pp_cxx_ws_string (cxx_pp
, opstring
);
2310 pp_string (cxx_pp
, M_("<unknown operator>"));
2311 pp_cxx_whitespace (cxx_pp
);
2312 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2313 pp_cxx_right_paren (cxx_pp
);
2317 dump_unary_op (const char *opstring
, tree t
, int flags
)
2319 if (flags
& TFF_EXPR_IN_PARENS
)
2320 pp_cxx_left_paren (cxx_pp
);
2321 pp_cxx_ws_string (cxx_pp
, opstring
);
2322 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2323 if (flags
& TFF_EXPR_IN_PARENS
)
2324 pp_cxx_right_paren (cxx_pp
);
2328 reinit_cxx_pp (void)
2330 pp_clear_output_area (cxx_pp
);
2331 pp_base (cxx_pp
)->padding
= pp_none
;
2332 pp_indentation (cxx_pp
) = 0;
2333 pp_needs_newline (cxx_pp
) = false;
2334 cxx_pp
->enclosing_scope
= current_function_decl
;
2338 /* Exported interface to stringifying types, exprs and decls under TFF_*
2342 type_as_string (tree typ
, int flags
)
2345 pp_translate_identifiers (cxx_pp
) = false;
2346 dump_type (typ
, flags
);
2347 return pp_formatted_text (cxx_pp
);
2351 type_as_string_translate (tree typ
, int flags
)
2354 dump_type (typ
, flags
);
2355 return pp_formatted_text (cxx_pp
);
2359 expr_as_string (tree decl
, int flags
)
2362 pp_translate_identifiers (cxx_pp
) = false;
2363 dump_expr (decl
, flags
);
2364 return pp_formatted_text (cxx_pp
);
2368 decl_as_string (tree decl
, int flags
)
2371 pp_translate_identifiers (cxx_pp
) = false;
2372 dump_decl (decl
, flags
);
2373 return pp_formatted_text (cxx_pp
);
2377 decl_as_string_translate (tree decl
, int flags
)
2380 dump_decl (decl
, flags
);
2381 return pp_formatted_text (cxx_pp
);
2384 /* Generate the three forms of printable names for cxx_printable_name. */
2387 lang_decl_name (tree decl
, int v
, bool translate
)
2391 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2392 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2395 pp_translate_identifiers (cxx_pp
) = translate
;
2397 && (DECL_CLASS_SCOPE_P (decl
)
2398 || (DECL_NAMESPACE_SCOPE_P (decl
)
2399 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2401 dump_type (CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2402 pp_cxx_colon_colon (cxx_pp
);
2405 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2406 dump_function_name (decl
, TFF_PLAIN_IDENTIFIER
);
2408 dump_decl (DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2410 return pp_formatted_text (cxx_pp
);
2413 /* Return the location of a tree passed to %+ formats. */
2416 location_of (tree t
)
2418 if (TREE_CODE (t
) == PARM_DECL
&& DECL_CONTEXT (t
))
2419 t
= DECL_CONTEXT (t
);
2420 else if (TYPE_P (t
))
2421 t
= TYPE_MAIN_DECL (t
);
2422 else if (TREE_CODE (t
) == OVERLOAD
)
2423 t
= OVL_FUNCTION (t
);
2425 return DECL_SOURCE_LOCATION (t
);
2428 /* Now the interfaces from error et al to dump_type et al. Each takes an
2429 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2433 decl_to_string (tree decl
, int verbose
)
2437 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2438 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2439 flags
= TFF_CLASS_KEY_OR_ENUM
;
2441 flags
|= TFF_DECL_SPECIFIERS
;
2442 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2443 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2444 flags
|= TFF_TEMPLATE_HEADER
;
2447 dump_decl (decl
, flags
);
2448 return pp_formatted_text (cxx_pp
);
2452 expr_to_string (tree decl
)
2455 dump_expr (decl
, 0);
2456 return pp_formatted_text (cxx_pp
);
2460 fndecl_to_string (tree fndecl
, int verbose
)
2464 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
2465 | TFF_TEMPLATE_HEADER
;
2467 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
2469 dump_decl (fndecl
, flags
);
2470 return pp_formatted_text (cxx_pp
);
2475 code_to_string (enum tree_code c
)
2477 return tree_code_name
[c
];
2481 language_to_string (enum languages c
)
2488 case lang_cplusplus
:
2500 /* Return the proper printed version of a parameter to a C++ function. */
2503 parm_to_string (int p
)
2507 pp_string (cxx_pp
, "'this'");
2509 pp_decimal_int (cxx_pp
, p
+ 1);
2510 return pp_formatted_text (cxx_pp
);
2514 op_to_string (enum tree_code p
)
2516 tree id
= operator_name_info
[(int) p
].identifier
;
2517 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
2521 type_to_string (tree typ
, int verbose
)
2525 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2526 flags
|= TFF_TEMPLATE_HEADER
;
2529 dump_type (typ
, flags
);
2530 return pp_formatted_text (cxx_pp
);
2534 assop_to_string (enum tree_code p
)
2536 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
2537 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
2541 args_to_string (tree p
, int verbose
)
2545 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2550 if (TYPE_P (TREE_VALUE (p
)))
2551 return type_as_string_translate (p
, flags
);
2554 for (; p
; p
= TREE_CHAIN (p
))
2556 if (TREE_VALUE (p
) == null_node
)
2557 pp_cxx_ws_string (cxx_pp
, "NULL");
2559 dump_type (error_type (TREE_VALUE (p
)), flags
);
2561 pp_separate_with_comma (cxx_pp
);
2563 return pp_formatted_text (cxx_pp
);
2567 cv_to_string (tree p
, int v
)
2570 pp_base (cxx_pp
)->padding
= v
? pp_before
: pp_none
;
2571 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
2572 return pp_formatted_text (cxx_pp
);
2575 /* Langhook for print_error_function. */
2577 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
2578 diagnostic_info
*diagnostic
)
2580 lhd_print_error_function (context
, file
, diagnostic
);
2581 pp_base_set_prefix (context
->printer
, file
);
2582 maybe_print_instantiation_context (context
);
2586 cp_diagnostic_starter (diagnostic_context
*context
,
2587 diagnostic_info
*diagnostic
)
2589 diagnostic_report_current_module (context
);
2590 cp_print_error_function (context
, diagnostic
);
2591 maybe_print_instantiation_context (context
);
2592 pp_base_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
2597 cp_diagnostic_finalizer (diagnostic_context
*context
,
2598 diagnostic_info
*diagnostic ATTRIBUTE_UNUSED
)
2600 pp_base_destroy_prefix (context
->printer
);
2603 /* Print current function onto BUFFER, in the process of reporting
2604 a diagnostic message. Called from cp_diagnostic_starter. */
2606 cp_print_error_function (diagnostic_context
*context
,
2607 diagnostic_info
*diagnostic
)
2609 if (diagnostic_last_function_changed (context
, diagnostic
))
2611 const char *old_prefix
= context
->printer
->prefix
;
2612 const char *file
= LOCATION_FILE (diagnostic
->location
);
2613 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
2614 char *new_prefix
= (file
&& abstract_origin
== NULL
)
2615 ? file_name_as_prefix (file
) : NULL
;
2617 pp_base_set_prefix (context
->printer
, new_prefix
);
2619 if (current_function_decl
== NULL
)
2620 pp_base_string (context
->printer
, _("At global scope:"));
2625 if (abstract_origin
)
2627 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
2628 while (TREE_CODE (ao
) == BLOCK
2629 && BLOCK_ABSTRACT_ORIGIN (ao
)
2630 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
2631 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
2632 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
2636 fndecl
= current_function_decl
;
2638 pp_printf (context
->printer
, function_category (fndecl
),
2639 cxx_printable_name_translate (fndecl
, 2));
2641 while (abstract_origin
)
2644 tree block
= abstract_origin
;
2646 locus
= &BLOCK_SOURCE_LOCATION (block
);
2648 block
= BLOCK_SUPERCONTEXT (block
);
2649 while (block
&& TREE_CODE (block
) == BLOCK
2650 && BLOCK_ABSTRACT_ORIGIN (block
))
2652 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
2654 while (TREE_CODE (ao
) == BLOCK
2655 && BLOCK_ABSTRACT_ORIGIN (ao
)
2656 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
2657 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
2659 if (TREE_CODE (ao
) == FUNCTION_DECL
)
2664 else if (TREE_CODE (ao
) != BLOCK
)
2667 block
= BLOCK_SUPERCONTEXT (block
);
2670 abstract_origin
= block
;
2673 while (block
&& TREE_CODE (block
) == BLOCK
)
2674 block
= BLOCK_SUPERCONTEXT (block
);
2676 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
2678 abstract_origin
= NULL
;
2682 expanded_location s
= expand_location (*locus
);
2683 pp_base_character (context
->printer
, ',');
2684 pp_base_newline (context
->printer
);
2687 if (context
->show_column
&& s
.column
!= 0)
2688 pp_printf (context
->printer
,
2689 _(" inlined from %qs at %s:%d:%d"),
2690 cxx_printable_name_translate (fndecl
, 2),
2691 s
.file
, s
.line
, s
.column
);
2693 pp_printf (context
->printer
,
2694 _(" inlined from %qs at %s:%d"),
2695 cxx_printable_name_translate (fndecl
, 2),
2700 pp_printf (context
->printer
, _(" inlined from %qs"),
2701 cxx_printable_name_translate (fndecl
, 2));
2704 pp_base_character (context
->printer
, ':');
2706 pp_base_newline (context
->printer
);
2708 diagnostic_set_last_function (context
, diagnostic
);
2709 pp_base_destroy_prefix (context
->printer
);
2710 context
->printer
->prefix
= old_prefix
;
2714 /* Returns a description of FUNCTION using standard terminology. The
2715 result is a format string of the form "In CATEGORY %qs". */
2717 function_category (tree fn
)
2719 /* We can get called from the middle-end for diagnostics of function
2720 clones. Make sure we have language specific information before
2721 dereferencing it. */
2722 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
2723 && DECL_FUNCTION_MEMBER_P (fn
))
2725 if (DECL_STATIC_FUNCTION_P (fn
))
2726 return _("In static member function %qs");
2727 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
2728 return _("In copy constructor %qs");
2729 else if (DECL_CONSTRUCTOR_P (fn
))
2730 return _("In constructor %qs");
2731 else if (DECL_DESTRUCTOR_P (fn
))
2732 return _("In destructor %qs");
2733 else if (LAMBDA_FUNCTION_P (fn
))
2734 return _("In lambda function");
2736 return _("In member function %qs");
2739 return _("In function %qs");
2742 /* Report the full context of a current template instantiation,
2745 print_instantiation_full_context (diagnostic_context
*context
)
2747 struct tinst_level
*p
= current_instantiation ();
2748 location_t location
= input_location
;
2752 if (current_function_decl
!= p
->decl
2753 && current_function_decl
!= NULL_TREE
)
2754 /* We can get here during the processing of some synthesized
2755 method. Then, P->DECL will be the function that's causing
2760 if (current_function_decl
== p
->decl
)
2761 /* Avoid redundancy with the "In function" line. */;
2763 pp_verbatim (context
->printer
,
2764 _("%s: In instantiation of %qs:\n"),
2765 LOCATION_FILE (location
),
2766 decl_as_string_translate (p
->decl
,
2767 TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
));
2769 location
= p
->locus
;
2774 print_instantiation_partial_context (context
, p
, location
);
2777 /* Helper function of print_instantiation_partial_context() that
2778 prints a single line of instantiation context. */
2781 print_instantiation_partial_context_line (diagnostic_context
*context
,
2782 const struct tinst_level
*t
,
2783 location_t loc
, bool recursive_p
)
2785 expanded_location xloc
;
2786 xloc
= expand_location (loc
);
2791 str
= decl_as_string_translate (t
->decl
,
2792 TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
);
2793 if (context
->show_column
)
2794 pp_verbatim (context
->printer
,
2796 ? _("%s:%d:%d: recursively instantiated from %qs\n")
2797 : _("%s:%d:%d: instantiated from %qs\n"),
2798 xloc
.file
, xloc
.line
, xloc
.column
, str
);
2800 pp_verbatim (context
->printer
,
2802 ? _("%s:%d: recursively instantiated from %qs\n")
2803 : _("%s:%d: recursively instantiated from %qs\n"),
2804 xloc
.file
, xloc
.line
, str
);
2808 if (context
->show_column
)
2809 pp_verbatim (context
->printer
,
2811 ? _("%s:%d:%d: recursively instantiated from here")
2812 : _("%s:%d:%d: instantiated from here"),
2813 xloc
.file
, xloc
.line
, xloc
.column
);
2815 pp_verbatim (context
->printer
,
2817 ? _("%s:%d: recursively instantiated from here")
2818 : _("%s:%d: instantiated from here"),
2819 xloc
.file
, xloc
.line
);
2823 /* Same as print_instantiation_full_context but less verbose. */
2826 print_instantiation_partial_context (diagnostic_context
*context
,
2827 struct tinst_level
*t0
, location_t loc
)
2829 struct tinst_level
*t
;
2832 location_t prev_loc
= loc
;
2834 for (t
= t0
; t
!= NULL
; t
= t
->next
)
2835 if (prev_loc
!= t
->locus
)
2837 prev_loc
= t
->locus
;
2845 int skip
= n_total
- 10;
2846 for (n
= 0; n
< 5; n
++)
2848 gcc_assert (t
!= NULL
);
2849 if (loc
!= t
->locus
)
2850 print_instantiation_partial_context_line (context
, t
, loc
,
2851 /*recursive_p=*/false);
2855 if (t
!= NULL
&& skip
> 1)
2857 expanded_location xloc
;
2858 xloc
= expand_location (loc
);
2859 if (context
->show_column
)
2860 pp_verbatim (context
->printer
,
2861 _("%s:%d:%d: [ skipping %d instantiation contexts ]\n"),
2862 xloc
.file
, xloc
.line
, xloc
.column
, skip
);
2864 pp_verbatim (context
->printer
,
2865 _("%s:%d: [ skipping %d instantiation contexts ]\n"),
2866 xloc
.file
, xloc
.line
, skip
);
2871 } while (t
!= NULL
&& --skip
> 0);
2877 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
2882 print_instantiation_partial_context_line (context
, t
, loc
,
2887 print_instantiation_partial_context_line (context
, NULL
, loc
,
2888 /*recursive_p=*/false);
2889 pp_base_newline (context
->printer
);
2892 /* Called from cp_thing to print the template context for an error. */
2894 maybe_print_instantiation_context (diagnostic_context
*context
)
2896 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2899 record_last_problematic_instantiation ();
2900 print_instantiation_full_context (context
);
2903 /* Report the bare minimum context of a template instantiation. */
2905 print_instantiation_context (void)
2907 print_instantiation_partial_context
2908 (global_dc
, current_instantiation (), input_location
);
2909 diagnostic_flush_buffer (global_dc
);
2912 /* Called from output_format -- during diagnostic message processing --
2913 to handle C++ specific format specifier with the following meanings:
2914 %A function argument-list.
2918 %F function declaration.
2919 %L language as used in extern "lang".
2921 %P function parameter whose position is indicated by an integer.
2922 %Q assignment operator.
2926 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
2927 int precision
, bool wide
, bool set_locus
, bool verbose
)
2931 #define next_tree (t = va_arg (*text->args_ptr, tree))
2932 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
2933 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
2934 #define next_int va_arg (*text->args_ptr, int)
2936 if (precision
!= 0 || wide
)
2939 if (text
->locus
== NULL
)
2944 case 'A': result
= args_to_string (next_tree
, verbose
); break;
2945 case 'C': result
= code_to_string (next_tcode
); break;
2948 tree temp
= next_tree
;
2950 && DECL_DEBUG_EXPR_IS_FROM (temp
) && DECL_DEBUG_EXPR (temp
))
2952 temp
= DECL_DEBUG_EXPR (temp
);
2955 result
= expr_to_string (temp
);
2959 result
= decl_to_string (temp
, verbose
);
2962 case 'E': result
= expr_to_string (next_tree
); break;
2963 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
2964 case 'L': result
= language_to_string (next_lang
); break;
2965 case 'O': result
= op_to_string (next_tcode
); break;
2966 case 'P': result
= parm_to_string (next_int
); break;
2967 case 'Q': result
= assop_to_string (next_tcode
); break;
2968 case 'T': result
= type_to_string (next_tree
, verbose
); break;
2969 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
2972 percent_K_format (text
);
2979 pp_base_string (pp
, result
);
2980 if (set_locus
&& t
!= NULL
)
2981 *text
->locus
= location_of (t
);
2989 /* Warn about the use of C++0x features when appropriate. */
2991 maybe_warn_cpp0x (cpp0x_warn_str str
)
2993 if ((cxx_dialect
== cxx98
) && !in_system_header
)
2994 /* We really want to suppress this warning in system headers,
2995 because libstdc++ uses variadic templates even when we aren't
2999 case CPP0X_INITIALIZER_LISTS
:
3000 pedwarn (input_location
, 0,
3001 "extended initializer lists "
3002 "only available with -std=c++0x or -std=gnu++0x");
3004 case CPP0X_EXPLICIT_CONVERSION
:
3005 pedwarn (input_location
, 0,
3006 "explicit conversion operators "
3007 "only available with -std=c++0x or -std=gnu++0x");
3009 case CPP0X_VARIADIC_TEMPLATES
:
3010 pedwarn (input_location
, 0,
3011 "variadic templates "
3012 "only available with -std=c++0x or -std=gnu++0x");
3014 case CPP0X_LAMBDA_EXPR
:
3015 pedwarn (input_location
, 0,
3016 "lambda expressions "
3017 "only available with -std=c++0x or -std=gnu++0x");
3020 pedwarn (input_location
, 0,
3021 "C++0x auto only available with -std=c++0x or -std=gnu++0x");
3023 case CPP0X_SCOPED_ENUMS
:
3024 pedwarn (input_location
, 0,
3025 "scoped enums only available with -std=c++0x or -std=gnu++0x");
3027 case CPP0X_DEFAULTED_DELETED
:
3028 pedwarn (input_location
, 0,
3029 "defaulted and deleted functions "
3030 "only available with -std=c++0x or -std=gnu++0x");
3037 /* Warn about the use of variadic templates when appropriate. */
3039 maybe_warn_variadic_templates (void)
3041 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
3045 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3046 option OPT with text GMSGID. Use this function to report
3047 diagnostics for constructs that are invalid C++98, but valid
3050 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
3052 diagnostic_info diagnostic
;
3055 va_start (ap
, gmsgid
);
3056 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, location
,
3057 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
3058 diagnostic
.option_index
= opt
;
3060 return report_diagnostic (&diagnostic
);