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, 2011, 2012
5 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #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"
36 #include "c-family/c-objc.h"
38 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
39 #define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
41 /* The global buffer where we dump everything. It is there only for
42 transitional purpose. It is expected, in the near future, to be
43 completely removed. */
44 static cxx_pretty_printer scratch_pretty_printer
;
45 #define cxx_pp (&scratch_pretty_printer)
47 /* Translate if being used for diagnostics, but not for dump files or
49 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
51 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
53 static const char *args_to_string (tree
, int);
54 static const char *assop_to_string (enum tree_code
);
55 static const char *code_to_string (enum tree_code
);
56 static const char *cv_to_string (tree
, int);
57 static const char *decl_to_string (tree
, int);
58 static const char *expr_to_string (tree
);
59 static const char *fndecl_to_string (tree
, int);
60 static const char *op_to_string (enum tree_code
);
61 static const char *parm_to_string (int);
62 static const char *type_to_string (tree
, int);
64 static void dump_alias_template_specialization (tree
, int);
65 static void dump_type (tree
, int);
66 static void dump_typename (tree
, int);
67 static void dump_simple_decl (tree
, tree
, int);
68 static void dump_decl (tree
, int);
69 static void dump_template_decl (tree
, int);
70 static void dump_function_decl (tree
, int);
71 static void dump_expr (tree
, int);
72 static void dump_unary_op (const char *, tree
, int);
73 static void dump_binary_op (const char *, tree
, int);
74 static void dump_aggr_type (tree
, int);
75 static void dump_type_prefix (tree
, int);
76 static void dump_type_suffix (tree
, int);
77 static void dump_function_name (tree
, int);
78 static void dump_call_expr_args (tree
, int, bool);
79 static void dump_aggr_init_expr_args (tree
, int, bool);
80 static void dump_expr_list (tree
, int);
81 static void dump_global_iord (tree
);
82 static void dump_parameters (tree
, int);
83 static void dump_exception_spec (tree
, int);
84 static void dump_template_argument (tree
, int);
85 static void dump_template_argument_list (tree
, int);
86 static void dump_template_parameter (tree
, int);
87 static void dump_template_bindings (tree
, tree
, VEC(tree
,gc
) *);
88 static void dump_scope (tree
, int);
89 static void dump_template_parms (tree
, int, int);
90 static int get_non_default_template_args_count (tree
, int);
91 static const char *function_category (tree
);
92 static void maybe_print_constexpr_context (diagnostic_context
*);
93 static void maybe_print_instantiation_context (diagnostic_context
*);
94 static void print_instantiation_full_context (diagnostic_context
*);
95 static void print_instantiation_partial_context (diagnostic_context
*,
98 static void cp_diagnostic_starter (diagnostic_context
*, diagnostic_info
*);
99 static void cp_diagnostic_finalizer (diagnostic_context
*, diagnostic_info
*);
100 static void cp_print_error_function (diagnostic_context
*, diagnostic_info
*);
102 static bool cp_printer (pretty_printer
*, text_info
*, const char *,
103 int, bool, bool, bool);
108 diagnostic_starter (global_dc
) = cp_diagnostic_starter
;
109 diagnostic_finalizer (global_dc
) = cp_diagnostic_finalizer
;
110 diagnostic_format_decoder (global_dc
) = cp_printer
;
112 pp_construct (pp_base (cxx_pp
), NULL
, 0);
113 pp_cxx_pretty_printer_init (cxx_pp
);
116 /* Dump a scope, if deemed necessary. */
119 dump_scope (tree scope
, int flags
)
121 int f
= flags
& (TFF_SCOPE
| TFF_CHASE_TYPEDEF
);
123 if (scope
== NULL_TREE
)
126 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
128 if (scope
!= global_namespace
)
130 dump_decl (scope
, f
);
131 pp_cxx_colon_colon (cxx_pp
);
134 else if (AGGREGATE_TYPE_P (scope
))
136 dump_type (scope
, f
);
137 pp_cxx_colon_colon (cxx_pp
);
139 else if ((flags
& TFF_SCOPE
) && TREE_CODE (scope
) == FUNCTION_DECL
)
141 dump_function_decl (scope
, f
);
142 pp_cxx_colon_colon (cxx_pp
);
146 /* Dump the template ARGument under control of FLAGS. */
149 dump_template_argument (tree arg
, int flags
)
151 if (ARGUMENT_PACK_P (arg
))
152 dump_template_argument_list (ARGUMENT_PACK_ARGS (arg
),
153 /* No default args in argument packs. */
154 flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
155 else if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
156 dump_type (arg
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
159 if (TREE_CODE (arg
) == TREE_LIST
)
160 arg
= TREE_VALUE (arg
);
162 dump_expr (arg
, (flags
| TFF_EXPR_IN_PARENS
) & ~TFF_CLASS_KEY_OR_ENUM
);
166 /* Count the number of template arguments ARGS whose value does not
167 match the (optional) default template parameter in PARAMS */
170 get_non_default_template_args_count (tree args
, int flags
)
172 int n
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args
));
174 if (/* We use this flag when generating debug information. We don't
175 want to expand templates at this point, for this may generate
176 new decls, which gets decl counts out of sync, which may in
177 turn cause codegen differences between compilations with and
179 (flags
& TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
) != 0
180 || !flag_pretty_templates
)
183 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args
));
186 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
190 dump_template_argument_list (tree args
, int flags
)
192 int n
= get_non_default_template_args_count (args
, flags
);
196 for (i
= 0; i
< n
; ++i
)
198 tree arg
= TREE_VEC_ELT (args
, i
);
200 /* Only print a comma if we know there is an argument coming. In
201 the case of an empty template argument pack, no actual
202 argument will be printed. */
204 && (!ARGUMENT_PACK_P (arg
)
205 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
206 pp_separate_with_comma (cxx_pp
);
208 dump_template_argument (arg
, flags
);
213 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
216 dump_template_parameter (tree parm
, int flags
)
221 if (parm
== error_mark_node
)
224 p
= TREE_VALUE (parm
);
225 a
= TREE_PURPOSE (parm
);
227 if (TREE_CODE (p
) == TYPE_DECL
)
229 if (flags
& TFF_DECL_SPECIFIERS
)
231 pp_cxx_ws_string (cxx_pp
, "class");
232 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p
)))
233 pp_cxx_ws_string (cxx_pp
, "...");
235 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (p
));
237 else if (DECL_NAME (p
))
238 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (p
));
240 pp_cxx_canonical_template_parameter (cxx_pp
, TREE_TYPE (p
));
243 dump_decl (p
, flags
| TFF_DECL_SPECIFIERS
);
245 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && a
!= NULL_TREE
)
247 pp_cxx_whitespace (cxx_pp
);
249 pp_cxx_whitespace (cxx_pp
);
250 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
251 dump_type (a
, flags
& ~TFF_CHASE_TYPEDEF
);
253 dump_expr (a
, flags
| TFF_EXPR_IN_PARENS
);
257 /* Dump, under control of FLAGS, a template-parameter-list binding.
258 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
262 dump_template_bindings (tree parms
, tree args
, VEC(tree
,gc
)* typenames
)
264 bool need_semicolon
= false;
270 tree p
= TREE_VALUE (parms
);
271 int lvl
= TMPL_PARMS_DEPTH (parms
);
274 tree lvl_args
= NULL_TREE
;
276 /* Don't crash if we had an invalid argument list. */
277 if (TMPL_ARGS_DEPTH (args
) >= lvl
)
278 lvl_args
= TMPL_ARGS_LEVEL (args
, lvl
);
280 for (i
= 0; i
< TREE_VEC_LENGTH (p
); ++i
)
282 tree arg
= NULL_TREE
;
284 /* Don't crash if we had an invalid argument list. */
285 if (lvl_args
&& NUM_TMPL_ARGS (lvl_args
) > arg_idx
)
286 arg
= TREE_VEC_ELT (lvl_args
, arg_idx
);
289 pp_separate_with_semicolon (cxx_pp
);
290 dump_template_parameter (TREE_VEC_ELT (p
, i
), TFF_PLAIN_IDENTIFIER
);
291 pp_cxx_whitespace (cxx_pp
);
293 pp_cxx_whitespace (cxx_pp
);
296 if (ARGUMENT_PACK_P (arg
))
297 pp_cxx_left_brace (cxx_pp
);
298 dump_template_argument (arg
, TFF_PLAIN_IDENTIFIER
);
299 if (ARGUMENT_PACK_P (arg
))
300 pp_cxx_right_brace (cxx_pp
);
303 pp_string (cxx_pp
, M_("<missing>"));
306 need_semicolon
= true;
309 parms
= TREE_CHAIN (parms
);
312 /* Don't bother with typenames for a partial instantiation. */
313 if (VEC_empty (tree
, typenames
) || uses_template_parms (args
))
316 FOR_EACH_VEC_ELT (tree
, typenames
, i
, t
)
319 pp_separate_with_semicolon (cxx_pp
);
320 dump_type (t
, TFF_PLAIN_IDENTIFIER
);
321 pp_cxx_whitespace (cxx_pp
);
323 pp_cxx_whitespace (cxx_pp
);
324 push_deferring_access_checks (dk_no_check
);
325 t
= tsubst (t
, args
, tf_none
, NULL_TREE
);
326 pop_deferring_access_checks ();
327 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
328 pp_simple_type_specifier doesn't know about it. */
329 t
= strip_typedefs (t
);
330 dump_type (t
, TFF_PLAIN_IDENTIFIER
);
334 /* Dump a human-readable equivalent of the alias template
335 specialization of T. */
338 dump_alias_template_specialization (tree t
, int flags
)
342 gcc_assert (alias_template_specialization_p (t
));
344 if (!(flags
& TFF_UNQUALIFIED_NAME
))
345 dump_scope (CP_DECL_CONTEXT (TYPE_NAME (t
)), flags
);
346 name
= TYPE_IDENTIFIER (t
);
347 pp_cxx_tree_identifier (cxx_pp
, name
);
348 dump_template_parms (TYPE_TEMPLATE_INFO (t
),
350 flags
& ~TFF_TEMPLATE_HEADER
);
353 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
357 dump_type (tree t
, int flags
)
362 /* Don't print e.g. "struct mytypedef". */
363 if (TYPE_P (t
) && typedef_variant_p (t
))
365 tree decl
= TYPE_NAME (t
);
366 if ((flags
& TFF_CHASE_TYPEDEF
)
367 || DECL_SELF_REFERENCE_P (decl
)
368 || (!flag_pretty_templates
369 && DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)))
370 t
= strip_typedefs (t
);
371 else if (alias_template_specialization_p (t
))
373 dump_alias_template_specialization (t
, flags
);
376 else if (same_type_p (t
, TREE_TYPE (decl
)))
380 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
381 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
386 if (TYPE_PTRMEMFUNC_P (t
))
389 switch (TREE_CODE (t
))
392 if (t
== init_list_type_node
)
393 pp_string (cxx_pp
, M_("<brace-enclosed initializer list>"));
394 else if (t
== unknown_type_node
)
395 pp_string (cxx_pp
, M_("<unresolved overloaded function type>"));
398 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
399 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
404 /* A list of function parms. */
405 dump_parameters (t
, flags
);
408 case IDENTIFIER_NODE
:
409 pp_cxx_tree_identifier (cxx_pp
, t
);
413 dump_type (BINFO_TYPE (t
), flags
);
419 dump_aggr_type (t
, flags
);
423 if (flags
& TFF_CHASE_TYPEDEF
)
425 dump_type (DECL_ORIGINAL_TYPE (t
)
426 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
), flags
);
429 /* Else fall through. */
433 dump_decl (t
, flags
& ~TFF_DECL_SPECIFIERS
);
442 case FIXED_POINT_TYPE
:
443 pp_type_specifier_seq (cxx_pp
, t
);
446 case TEMPLATE_TEMPLATE_PARM
:
447 /* For parameters inside template signature. */
448 if (TYPE_IDENTIFIER (t
))
449 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
451 pp_cxx_canonical_template_parameter (cxx_pp
, t
);
454 case BOUND_TEMPLATE_TEMPLATE_PARM
:
456 tree args
= TYPE_TI_ARGS (t
);
457 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
458 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
459 pp_cxx_begin_template_argument_list (cxx_pp
);
460 dump_template_argument_list (args
, flags
);
461 pp_cxx_end_template_argument_list (cxx_pp
);
465 case TEMPLATE_TYPE_PARM
:
466 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
467 if (TYPE_IDENTIFIER (t
))
468 pp_cxx_tree_identifier (cxx_pp
, TYPE_IDENTIFIER (t
));
470 pp_cxx_canonical_template_parameter
471 (cxx_pp
, TEMPLATE_TYPE_PARM_INDEX (t
));
474 /* This is not always necessary for pointers and such, but doing this
475 reduces code size. */
484 dump_type_prefix (t
, flags
);
485 dump_type_suffix (t
, flags
);
489 if (! (flags
& TFF_CHASE_TYPEDEF
)
490 && DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
492 dump_decl (TYPE_NAME (t
), TFF_PLAIN_IDENTIFIER
);
495 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
496 pp_cxx_ws_string (cxx_pp
,
497 TYPENAME_IS_ENUM_P (t
) ? "enum"
498 : TYPENAME_IS_CLASS_P (t
) ? "class"
500 dump_typename (t
, flags
);
503 case UNBOUND_CLASS_TEMPLATE
:
504 if (! (flags
& TFF_UNQUALIFIED_NAME
))
506 dump_type (TYPE_CONTEXT (t
), flags
);
507 pp_cxx_colon_colon (cxx_pp
);
509 pp_cxx_ws_string (cxx_pp
, "template");
510 dump_type (DECL_NAME (TYPE_NAME (t
)), flags
);
514 pp_cxx_ws_string (cxx_pp
, "__typeof__");
515 pp_cxx_whitespace (cxx_pp
);
516 pp_cxx_left_paren (cxx_pp
);
517 dump_expr (TYPEOF_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
518 pp_cxx_right_paren (cxx_pp
);
521 case UNDERLYING_TYPE
:
522 pp_cxx_ws_string (cxx_pp
, "__underlying_type");
523 pp_cxx_whitespace (cxx_pp
);
524 pp_cxx_left_paren (cxx_pp
);
525 dump_expr (UNDERLYING_TYPE_TYPE (t
), flags
& ~TFF_EXPR_IN_PARENS
);
526 pp_cxx_right_paren (cxx_pp
);
529 case TYPE_PACK_EXPANSION
:
530 dump_type (PACK_EXPANSION_PATTERN (t
), flags
);
531 pp_cxx_ws_string (cxx_pp
, "...");
534 case TYPE_ARGUMENT_PACK
:
535 dump_template_argument (t
, flags
);
539 pp_cxx_ws_string (cxx_pp
, "decltype");
540 pp_cxx_whitespace (cxx_pp
);
541 pp_cxx_left_paren (cxx_pp
);
542 dump_expr (DECLTYPE_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
543 pp_cxx_right_paren (cxx_pp
);
547 pp_string (cxx_pp
, "std::nullptr_t");
551 pp_unsupported_tree (cxx_pp
, t
);
552 /* Fall through to error. */
555 pp_string (cxx_pp
, M_("<type error>"));
560 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
564 dump_typename (tree t
, int flags
)
566 tree ctx
= TYPE_CONTEXT (t
);
568 if (TREE_CODE (ctx
) == TYPENAME_TYPE
)
569 dump_typename (ctx
, flags
);
571 dump_type (ctx
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
572 pp_cxx_colon_colon (cxx_pp
);
573 dump_decl (TYPENAME_TYPE_FULLNAME (t
), flags
);
576 /* Return the name of the supplied aggregate, or enumeral type. */
579 class_key_or_enum_as_string (tree t
)
581 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
583 if (SCOPED_ENUM_P (t
))
588 else if (TREE_CODE (t
) == UNION_TYPE
)
590 else if (TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_DECLARED_CLASS (t
))
596 /* Print out a class declaration T under the control of FLAGS,
597 in the form `class foo'. */
600 dump_aggr_type (tree t
, int flags
)
603 const char *variety
= class_key_or_enum_as_string (t
);
607 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
609 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
610 pp_cxx_ws_string (cxx_pp
, variety
);
612 name
= TYPE_NAME (t
);
616 typdef
= (!DECL_ARTIFICIAL (name
)
617 /* An alias specialization is not considered to be a
619 && !alias_template_specialization_p (t
));
622 && ((flags
& TFF_CHASE_TYPEDEF
)
623 || (!flag_pretty_templates
&& DECL_LANG_SPECIFIC (name
)
624 && DECL_TEMPLATE_INFO (name
))))
625 || DECL_SELF_REFERENCE_P (name
))
627 t
= TYPE_MAIN_VARIANT (t
);
628 name
= TYPE_NAME (t
);
632 tmplate
= !typdef
&& TREE_CODE (t
) != ENUMERAL_TYPE
633 && TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_TEMPLATE_INFO (t
)
634 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
635 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
637 if (! (flags
& TFF_UNQUALIFIED_NAME
))
638 dump_scope (CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
639 flags
&= ~TFF_UNQUALIFIED_NAME
;
642 /* Because the template names are mangled, we have to locate
643 the most general template, and use that name. */
644 tree tpl
= TYPE_TI_TEMPLATE (t
);
646 while (DECL_TEMPLATE_INFO (tpl
))
647 tpl
= DECL_TI_TEMPLATE (tpl
);
650 name
= DECL_NAME (name
);
653 if (name
== 0 || ANON_AGGRNAME_P (name
))
655 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
656 pp_string (cxx_pp
, M_("<anonymous>"));
658 pp_printf (pp_base (cxx_pp
), M_("<anonymous %s>"), variety
);
660 else if (LAMBDANAME_P (name
))
662 /* A lambda's "type" is essentially its signature. */
663 pp_string (cxx_pp
, M_("<lambda"));
664 if (lambda_function (t
))
665 dump_parameters (FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t
)),
667 pp_character(cxx_pp
, '>');
670 pp_cxx_tree_identifier (cxx_pp
, name
);
672 dump_template_parms (TYPE_TEMPLATE_INFO (t
),
673 !CLASSTYPE_USE_TEMPLATE (t
),
674 flags
& ~TFF_TEMPLATE_HEADER
);
677 /* Dump into the obstack the initial part of the output for a given type.
678 This is necessary when dealing with things like functions returning
681 return type of `int (* fee ())()': pointer -> function -> int. Both
682 pointer (and reference and offset) and function (and member) types must
683 deal with prefix and suffix.
685 Arrays must also do this for DECL nodes, like int a[], and for things like
689 dump_type_prefix (tree t
, int flags
)
691 if (TYPE_PTRMEMFUNC_P (t
))
693 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
697 switch (TREE_CODE (t
))
702 tree sub
= TREE_TYPE (t
);
704 dump_type_prefix (sub
, flags
);
705 if (TREE_CODE (sub
) == ARRAY_TYPE
706 || TREE_CODE (sub
) == FUNCTION_TYPE
)
708 pp_cxx_whitespace (cxx_pp
);
709 pp_cxx_left_paren (cxx_pp
);
710 pp_c_attributes_display (pp_c_base (cxx_pp
),
711 TYPE_ATTRIBUTES (sub
));
713 if (TREE_CODE (t
) == POINTER_TYPE
)
714 pp_character(cxx_pp
, '*');
715 else if (TREE_CODE (t
) == REFERENCE_TYPE
)
717 if (TYPE_REF_IS_RVALUE (t
))
718 pp_string (cxx_pp
, "&&");
720 pp_character (cxx_pp
, '&');
722 pp_base (cxx_pp
)->padding
= pp_before
;
723 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
729 dump_type_prefix (TREE_TYPE (t
), flags
);
730 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
732 pp_maybe_space (cxx_pp
);
733 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
734 pp_cxx_left_paren (cxx_pp
);
735 dump_type (TYPE_OFFSET_BASETYPE (t
), flags
);
736 pp_cxx_colon_colon (cxx_pp
);
738 pp_cxx_star (cxx_pp
);
739 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
740 pp_base (cxx_pp
)->padding
= pp_before
;
743 /* This can be reached without a pointer when dealing with
744 templates, e.g. std::is_function. */
746 dump_type_prefix (TREE_TYPE (t
), flags
);
750 dump_type_prefix (TREE_TYPE (t
), flags
);
751 pp_maybe_space (cxx_pp
);
752 pp_cxx_left_paren (cxx_pp
);
753 dump_aggr_type (TYPE_METHOD_BASETYPE (t
), flags
);
754 pp_cxx_colon_colon (cxx_pp
);
758 dump_type_prefix (TREE_TYPE (t
), flags
);
762 case IDENTIFIER_NODE
:
767 case TEMPLATE_TYPE_PARM
:
768 case TEMPLATE_TEMPLATE_PARM
:
769 case BOUND_TEMPLATE_TEMPLATE_PARM
:
780 case UNDERLYING_TYPE
:
782 case TYPE_PACK_EXPANSION
:
783 case FIXED_POINT_TYPE
:
785 dump_type (t
, flags
);
786 pp_base (cxx_pp
)->padding
= pp_before
;
790 pp_unsupported_tree (cxx_pp
, t
);
793 pp_string (cxx_pp
, M_("<typeprefixerror>"));
798 /* Dump the suffix of type T, under control of FLAGS. This is the part
799 which appears after the identifier (or function parms). */
802 dump_type_suffix (tree t
, int flags
)
804 if (TYPE_PTRMEMFUNC_P (t
))
805 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
807 switch (TREE_CODE (t
))
812 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
813 || TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
814 pp_cxx_right_paren (cxx_pp
);
815 dump_type_suffix (TREE_TYPE (t
), flags
);
822 if (TREE_CODE (t
) == METHOD_TYPE
)
823 /* Can only be reached through a pointer. */
824 pp_cxx_right_paren (cxx_pp
);
825 arg
= TYPE_ARG_TYPES (t
);
826 if (TREE_CODE (t
) == METHOD_TYPE
)
827 arg
= TREE_CHAIN (arg
);
829 /* Function pointers don't have default args. Not in standard C++,
830 anyway; they may in g++, but we'll just pretend otherwise. */
831 dump_parameters (arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
833 if (TREE_CODE (t
) == METHOD_TYPE
)
834 pp_cxx_cv_qualifier_seq (cxx_pp
, class_of_this_parm (t
));
836 pp_cxx_cv_qualifier_seq (cxx_pp
, t
);
837 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t
), flags
);
838 dump_type_suffix (TREE_TYPE (t
), flags
);
843 pp_maybe_space (cxx_pp
);
844 pp_cxx_left_bracket (cxx_pp
);
847 tree dtype
= TYPE_DOMAIN (t
);
848 tree max
= TYPE_MAX_VALUE (dtype
);
849 if (host_integerp (max
, 0))
850 pp_wide_integer (cxx_pp
, tree_low_cst (max
, 0) + 1);
851 else if (TREE_CODE (max
) == MINUS_EXPR
)
852 dump_expr (TREE_OPERAND (max
, 0),
853 flags
& ~TFF_EXPR_IN_PARENS
);
855 dump_expr (fold_build2_loc (input_location
,
856 PLUS_EXPR
, dtype
, max
,
857 build_int_cst (dtype
, 1)),
858 flags
& ~TFF_EXPR_IN_PARENS
);
860 pp_cxx_right_bracket (cxx_pp
);
861 dump_type_suffix (TREE_TYPE (t
), flags
);
865 case IDENTIFIER_NODE
:
870 case TEMPLATE_TYPE_PARM
:
871 case TEMPLATE_TEMPLATE_PARM
:
872 case BOUND_TEMPLATE_TEMPLATE_PARM
:
883 case UNDERLYING_TYPE
:
885 case TYPE_PACK_EXPANSION
:
886 case FIXED_POINT_TYPE
:
891 pp_unsupported_tree (cxx_pp
, t
);
893 /* Don't mark it here, we should have already done in
900 dump_global_iord (tree t
)
902 const char *p
= NULL
;
904 if (DECL_GLOBAL_CTOR_P (t
))
905 p
= M_("(static initializers for %s)");
906 else if (DECL_GLOBAL_DTOR_P (t
))
907 p
= M_("(static destructors for %s)");
911 pp_printf (pp_base (cxx_pp
), p
, input_filename
);
915 dump_simple_decl (tree t
, tree type
, int flags
)
917 if (flags
& TFF_DECL_SPECIFIERS
)
919 if (TREE_CODE (t
) == VAR_DECL
920 && DECL_DECLARED_CONSTEXPR_P (t
))
921 pp_cxx_ws_string (cxx_pp
, "constexpr");
922 dump_type_prefix (type
, flags
& ~TFF_UNQUALIFIED_NAME
);
923 pp_maybe_space (cxx_pp
);
925 if (! (flags
& TFF_UNQUALIFIED_NAME
)
926 && TREE_CODE (t
) != PARM_DECL
927 && (!DECL_INITIAL (t
)
928 || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
))
929 dump_scope (CP_DECL_CONTEXT (t
), flags
);
930 flags
&= ~TFF_UNQUALIFIED_NAME
;
931 if ((flags
& TFF_DECL_SPECIFIERS
)
932 && DECL_TEMPLATE_PARM_P (t
)
933 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t
)))
934 pp_string (cxx_pp
, "...");
936 dump_decl (DECL_NAME (t
), flags
);
938 pp_string (cxx_pp
, M_("<anonymous>"));
939 if (flags
& TFF_DECL_SPECIFIERS
)
940 dump_type_suffix (type
, flags
);
943 /* Dump a human readable string for the decl T under control of FLAGS. */
946 dump_decl (tree t
, int flags
)
951 /* If doing Objective-C++, give Objective-C a chance to demangle
952 Objective-C method names. */
953 if (c_dialect_objc ())
955 const char *demangled
= objc_maybe_printable_name (t
, flags
);
958 pp_string (cxx_pp
, demangled
);
963 switch (TREE_CODE (t
))
966 /* Don't say 'typedef class A' */
967 if (DECL_ARTIFICIAL (t
) && !DECL_SELF_REFERENCE_P (t
))
969 if ((flags
& TFF_DECL_SPECIFIERS
)
970 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
972 /* Say `class T' not just `T'. */
973 pp_cxx_ws_string (cxx_pp
, "class");
975 /* Emit the `...' for a parameter pack. */
976 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
977 pp_cxx_ws_string (cxx_pp
, "...");
980 dump_type (TREE_TYPE (t
), flags
);
983 if (TYPE_DECL_ALIAS_P (t
)
984 && (flags
& TFF_DECL_SPECIFIERS
985 || flags
& TFF_CLASS_KEY_OR_ENUM
))
987 pp_cxx_ws_string (cxx_pp
, "using");
988 dump_decl (DECL_NAME (t
), flags
);
989 pp_cxx_whitespace (cxx_pp
);
990 pp_cxx_ws_string (cxx_pp
, "=");
991 pp_cxx_whitespace (cxx_pp
);
992 dump_type (DECL_ORIGINAL_TYPE (t
), flags
);
995 if ((flags
& TFF_DECL_SPECIFIERS
)
996 && !DECL_SELF_REFERENCE_P (t
))
997 pp_cxx_ws_string (cxx_pp
, "typedef");
998 dump_simple_decl (t
, DECL_ORIGINAL_TYPE (t
)
999 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
1004 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
1006 pp_string (cxx_pp
, M_("vtable for "));
1007 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
1008 dump_type (DECL_CONTEXT (t
), flags
);
1011 /* Else fall through. */
1014 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
1018 pp_string (cxx_pp
, M_("<return value> "));
1019 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
1022 case NAMESPACE_DECL
:
1023 if (flags
& TFF_DECL_SPECIFIERS
)
1024 pp_cxx_declaration (cxx_pp
, t
);
1027 if (! (flags
& TFF_UNQUALIFIED_NAME
))
1028 dump_scope (CP_DECL_CONTEXT (t
), flags
);
1029 flags
&= ~TFF_UNQUALIFIED_NAME
;
1030 if (DECL_NAME (t
) == NULL_TREE
)
1032 if (!(pp_c_base (cxx_pp
)->flags
& pp_c_flag_gnu_v3
))
1033 pp_cxx_ws_string (cxx_pp
, M_("{anonymous}"));
1035 pp_cxx_ws_string (cxx_pp
, M_("(anonymous namespace)"));
1038 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
1043 dump_type (TREE_OPERAND (t
, 0), flags
);
1044 pp_string (cxx_pp
, "::");
1045 dump_decl (TREE_OPERAND (t
, 1), flags
|TFF_UNQUALIFIED_NAME
);
1049 dump_decl (TREE_OPERAND (t
, 0), flags
);
1050 pp_cxx_left_bracket (cxx_pp
);
1051 dump_decl (TREE_OPERAND (t
, 1), flags
);
1052 pp_cxx_right_bracket (cxx_pp
);
1055 /* So that we can do dump_decl on an aggr type. */
1059 dump_type (t
, flags
);
1063 /* This is a pseudo destructor call which has not been folded into
1064 a PSEUDO_DTOR_EXPR yet. */
1065 pp_cxx_complement (cxx_pp
);
1066 dump_type (TREE_OPERAND (t
, 0), flags
);
1073 /* These special cases are duplicated here so that other functions
1074 can feed identifiers to error and get them demangled properly. */
1075 case IDENTIFIER_NODE
:
1076 if (IDENTIFIER_TYPENAME_P (t
))
1078 pp_cxx_ws_string (cxx_pp
, "operator");
1079 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1080 dump_type (TREE_TYPE (t
), flags
);
1084 pp_cxx_tree_identifier (cxx_pp
, t
);
1090 t
= OVL_CURRENT (t
);
1091 if (DECL_CLASS_SCOPE_P (t
))
1093 dump_type (DECL_CONTEXT (t
), flags
);
1094 pp_cxx_colon_colon (cxx_pp
);
1096 else if (!DECL_FILE_SCOPE_P (t
))
1098 dump_decl (DECL_CONTEXT (t
), flags
);
1099 pp_cxx_colon_colon (cxx_pp
);
1101 dump_decl (DECL_NAME (t
), flags
);
1105 /* If there's only one function, just treat it like an ordinary
1107 t
= OVL_CURRENT (t
);
1111 if (! DECL_LANG_SPECIFIC (t
))
1112 pp_string (cxx_pp
, M_("<built-in>"));
1113 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1114 dump_global_iord (t
);
1116 dump_function_decl (t
, flags
);
1120 dump_template_decl (t
, flags
);
1123 case TEMPLATE_ID_EXPR
:
1125 tree name
= TREE_OPERAND (t
, 0);
1126 tree args
= TREE_OPERAND (t
, 1);
1128 if (is_overloaded_fn (name
))
1129 name
= DECL_NAME (get_first_fn (name
));
1130 dump_decl (name
, flags
);
1131 pp_cxx_begin_template_argument_list (cxx_pp
);
1132 if (args
== error_mark_node
)
1133 pp_string (cxx_pp
, M_("<template arguments error>"));
1135 dump_template_argument_list (args
, flags
);
1136 pp_cxx_end_template_argument_list (cxx_pp
);
1141 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
1145 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1146 || (DECL_INITIAL (t
) &&
1147 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1148 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
1149 else if (DECL_NAME (t
))
1150 dump_decl (DECL_NAME (t
), flags
);
1151 else if (DECL_INITIAL (t
))
1152 dump_expr (DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1154 pp_string (cxx_pp
, M_("<enumerator>"));
1158 pp_cxx_ws_string (cxx_pp
, "using");
1159 dump_type (USING_DECL_SCOPE (t
), flags
);
1160 pp_cxx_colon_colon (cxx_pp
);
1161 dump_decl (DECL_NAME (t
), flags
);
1165 pp_cxx_declaration (cxx_pp
, t
);
1169 dump_decl (BASELINK_FUNCTIONS (t
), flags
);
1172 case NON_DEPENDENT_EXPR
:
1173 dump_expr (t
, flags
);
1176 case TEMPLATE_TYPE_PARM
:
1177 if (flags
& TFF_DECL_SPECIFIERS
)
1178 pp_cxx_declaration (cxx_pp
, t
);
1180 pp_type_id (cxx_pp
, t
);
1183 case UNBOUND_CLASS_TEMPLATE
:
1184 case TYPE_PACK_EXPANSION
:
1186 dump_type (t
, flags
);
1190 pp_unsupported_tree (cxx_pp
, t
);
1191 /* Fall through to error. */
1194 pp_string (cxx_pp
, M_("<declaration error>"));
1199 /* Dump a template declaration T under control of FLAGS. This means the
1200 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1203 dump_template_decl (tree t
, int flags
)
1205 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1209 if (flags
& TFF_TEMPLATE_HEADER
)
1211 for (parms
= orig_parms
= nreverse (orig_parms
);
1213 parms
= TREE_CHAIN (parms
))
1215 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1216 int len
= TREE_VEC_LENGTH (inner_parms
);
1218 pp_cxx_ws_string (cxx_pp
, "template");
1219 pp_cxx_begin_template_argument_list (cxx_pp
);
1221 /* If we've shown the template prefix, we'd better show the
1222 parameters' and decl's type too. */
1223 flags
|= TFF_DECL_SPECIFIERS
;
1225 for (i
= 0; i
< len
; i
++)
1228 pp_separate_with_comma (cxx_pp
);
1229 dump_template_parameter (TREE_VEC_ELT (inner_parms
, i
), flags
);
1231 pp_cxx_end_template_argument_list (cxx_pp
);
1232 pp_cxx_whitespace (cxx_pp
);
1234 nreverse(orig_parms
);
1236 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1238 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1239 pp_cxx_ws_string (cxx_pp
, "class");
1241 /* If this is a parameter pack, print the ellipsis. */
1242 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1243 pp_cxx_ws_string (cxx_pp
, "...");
1247 if (DECL_CLASS_TEMPLATE_P (t
))
1248 dump_type (TREE_TYPE (t
),
1249 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1250 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1251 else if (DECL_TEMPLATE_RESULT (t
)
1252 && (TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == VAR_DECL
1253 /* Alias template. */
1254 || DECL_TYPE_TEMPLATE_P (t
)))
1255 dump_decl (DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1258 gcc_assert (TREE_TYPE (t
));
1259 switch (NEXT_CODE (t
))
1263 dump_function_decl (t
, flags
| TFF_TEMPLATE_NAME
);
1266 /* This case can occur with some invalid code. */
1267 dump_type (TREE_TYPE (t
),
1268 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1269 | (flags
& TFF_DECL_SPECIFIERS
1270 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1275 /* find_typenames looks through the type of the function template T
1276 and returns a VEC containing any typedefs, decltypes or TYPENAME_TYPEs
1279 struct find_typenames_t
1281 struct pointer_set_t
*p_set
;
1282 VEC (tree
,gc
) *typenames
;
1286 find_typenames_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
1288 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1289 tree mv
= NULL_TREE
;
1291 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1292 /* Add the type of the typedef without any additional cv-quals. */
1293 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1294 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1295 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1296 /* Add the typename without any cv-qualifiers. */
1297 mv
= TYPE_MAIN_VARIANT (*tp
);
1299 if (mv
&& (mv
== *tp
|| !pointer_set_insert (d
->p_set
, mv
)))
1300 VEC_safe_push (tree
, gc
, d
->typenames
, mv
);
1302 /* Search into class template arguments, which cp_walk_subtrees
1304 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1305 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1311 static VEC(tree
,gc
) *
1312 find_typenames (tree t
)
1314 struct find_typenames_t ft
;
1315 ft
.p_set
= pointer_set_create ();
1316 ft
.typenames
= NULL
;
1317 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1318 find_typenames_r
, &ft
, ft
.p_set
);
1319 pointer_set_destroy (ft
.p_set
);
1320 return ft
.typenames
;
1323 /* Pretty print a function decl. There are several ways we want to print a
1324 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1325 As error can only apply the '#' flag once to give 0 and 1 for V, there
1326 is %D which doesn't print the throw specs, and %F which does. */
1329 dump_function_decl (tree t
, int flags
)
1333 tree cname
= NULL_TREE
;
1334 tree template_args
= NULL_TREE
;
1335 tree template_parms
= NULL_TREE
;
1336 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1337 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1339 VEC(tree
,gc
) *typenames
= NULL
;
1341 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1343 /* A lambda's signature is essentially its "type", so defer. */
1344 gcc_assert (LAMBDA_TYPE_P (DECL_CONTEXT (t
)));
1345 dump_type (DECL_CONTEXT (t
), flags
);
1349 flags
&= ~TFF_UNQUALIFIED_NAME
;
1350 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1351 t
= DECL_TEMPLATE_RESULT (t
);
1353 /* Save the exceptions, in case t is a specialization and we are
1354 emitting an error about incompatible specifications. */
1355 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1357 /* Pretty print template instantiations only. */
1358 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1359 && flag_pretty_templates
)
1363 template_args
= DECL_TI_ARGS (t
);
1364 tmpl
= most_general_template (t
);
1365 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1367 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1369 typenames
= find_typenames (t
);
1373 fntype
= TREE_TYPE (t
);
1374 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1376 if (DECL_CLASS_SCOPE_P (t
))
1377 cname
= DECL_CONTEXT (t
);
1378 /* This is for partially instantiated template methods. */
1379 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1380 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1382 if (flags
& TFF_DECL_SPECIFIERS
)
1384 if (DECL_STATIC_FUNCTION_P (t
))
1385 pp_cxx_ws_string (cxx_pp
, "static");
1386 else if (DECL_VIRTUAL_P (t
))
1387 pp_cxx_ws_string (cxx_pp
, "virtual");
1389 if (DECL_DECLARED_CONSTEXPR_P (STRIP_TEMPLATE (t
)))
1390 pp_cxx_ws_string (cxx_pp
, "constexpr");
1393 /* Print the return type? */
1395 show_return
= !DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1396 && !DECL_DESTRUCTOR_P (t
);
1398 dump_type_prefix (TREE_TYPE (fntype
), flags
);
1400 /* Print the function name. */
1401 if (!do_outer_scope
)
1405 dump_type (cname
, flags
);
1406 pp_cxx_colon_colon (cxx_pp
);
1409 dump_scope (CP_DECL_CONTEXT (t
), flags
);
1411 dump_function_name (t
, flags
);
1413 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1415 dump_parameters (parmtypes
, flags
);
1417 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1419 pp_base (cxx_pp
)->padding
= pp_before
;
1420 pp_cxx_cv_qualifier_seq (cxx_pp
, class_of_this_parm (fntype
));
1423 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1425 pp_base (cxx_pp
)->padding
= pp_before
;
1426 dump_exception_spec (exceptions
, flags
);
1430 dump_type_suffix (TREE_TYPE (fntype
), flags
);
1432 /* If T is a template instantiation, dump the parameter binding. */
1433 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
)
1435 pp_cxx_whitespace (cxx_pp
);
1436 pp_cxx_left_bracket (cxx_pp
);
1437 pp_cxx_ws_string (cxx_pp
, M_("with"));
1438 pp_cxx_whitespace (cxx_pp
);
1439 dump_template_bindings (template_parms
, template_args
, typenames
);
1440 pp_cxx_right_bracket (cxx_pp
);
1443 else if (template_args
)
1445 bool need_comma
= false;
1447 pp_cxx_begin_template_argument_list (cxx_pp
);
1448 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1449 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1451 tree arg
= TREE_VEC_ELT (template_args
, i
);
1453 pp_separate_with_comma (cxx_pp
);
1454 if (ARGUMENT_PACK_P (arg
))
1455 pp_cxx_left_brace (cxx_pp
);
1456 dump_template_argument (arg
, TFF_PLAIN_IDENTIFIER
);
1457 if (ARGUMENT_PACK_P (arg
))
1458 pp_cxx_right_brace (cxx_pp
);
1461 pp_cxx_end_template_argument_list (cxx_pp
);
1465 /* Print a parameter list. If this is for a member function, the
1466 member object ptr (and any other hidden args) should have
1467 already been removed. */
1470 dump_parameters (tree parmtypes
, int flags
)
1473 flags
&= ~TFF_SCOPE
;
1474 pp_cxx_left_paren (cxx_pp
);
1476 for (first
= 1; parmtypes
!= void_list_node
;
1477 parmtypes
= TREE_CHAIN (parmtypes
))
1480 pp_separate_with_comma (cxx_pp
);
1484 pp_cxx_ws_string (cxx_pp
, "...");
1488 dump_type (TREE_VALUE (parmtypes
), flags
);
1490 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1492 pp_cxx_whitespace (cxx_pp
);
1494 pp_cxx_whitespace (cxx_pp
);
1495 dump_expr (TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1499 pp_cxx_right_paren (cxx_pp
);
1502 /* Print an exception specification. T is the exception specification. */
1505 dump_exception_spec (tree t
, int flags
)
1507 if (t
&& TREE_PURPOSE (t
))
1509 pp_cxx_ws_string (cxx_pp
, "noexcept");
1510 pp_cxx_whitespace (cxx_pp
);
1511 pp_cxx_left_paren (cxx_pp
);
1512 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1513 pp_cxx_ws_string (cxx_pp
, "<uninstantiated>");
1515 dump_expr (TREE_PURPOSE (t
), flags
);
1516 pp_cxx_right_paren (cxx_pp
);
1520 pp_cxx_ws_string (cxx_pp
, "throw");
1521 pp_cxx_whitespace (cxx_pp
);
1522 pp_cxx_left_paren (cxx_pp
);
1523 if (TREE_VALUE (t
) != NULL_TREE
)
1526 dump_type (TREE_VALUE (t
), flags
);
1530 pp_separate_with_comma (cxx_pp
);
1532 pp_cxx_right_paren (cxx_pp
);
1536 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1537 and destructors properly. */
1540 dump_function_name (tree t
, int flags
)
1542 tree name
= DECL_NAME (t
);
1544 /* We can get here with a decl that was synthesized by language-
1545 independent machinery (e.g. coverage.c) in which case it won't
1546 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1547 will crash. In this case it is safe just to print out the
1549 if (!DECL_LANG_SPECIFIC (t
))
1551 pp_cxx_tree_identifier (cxx_pp
, name
);
1555 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1556 t
= DECL_TEMPLATE_RESULT (t
);
1558 /* Don't let the user see __comp_ctor et al. */
1559 if (DECL_CONSTRUCTOR_P (t
)
1560 || DECL_DESTRUCTOR_P (t
))
1562 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1563 name
= get_identifier ("<lambda>");
1564 else if (TYPE_ANONYMOUS_P (DECL_CONTEXT (t
)))
1565 name
= get_identifier ("<constructor>");
1567 name
= constructor_name (DECL_CONTEXT (t
));
1570 if (DECL_DESTRUCTOR_P (t
))
1572 pp_cxx_complement (cxx_pp
);
1573 dump_decl (name
, TFF_PLAIN_IDENTIFIER
);
1575 else if (DECL_CONV_FN_P (t
))
1577 /* This cannot use the hack that the operator's return
1578 type is stashed off of its name because it may be
1579 used for error reporting. In the case of conflicting
1580 declarations, both will have the same name, yet
1581 the types will be different, hence the TREE_TYPE field
1582 of the first name will be clobbered by the second. */
1583 pp_cxx_ws_string (cxx_pp
, "operator");
1584 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1586 else if (name
&& IDENTIFIER_OPNAME_P (name
))
1587 pp_cxx_tree_identifier (cxx_pp
, name
);
1588 else if (name
&& UDLIT_OPER_P (name
))
1589 pp_cxx_tree_identifier (cxx_pp
, name
);
1591 dump_decl (name
, flags
);
1593 if (DECL_TEMPLATE_INFO (t
)
1594 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1595 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1596 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1597 dump_template_parms (DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
), flags
);
1600 /* Dump the template parameters from the template info INFO under control of
1601 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1602 specialization (partial or complete). For partial specializations we show
1603 the specialized parameter values. For a primary template we show no
1607 dump_template_parms (tree info
, int primary
, int flags
)
1609 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1611 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1613 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1614 pp_cxx_begin_template_argument_list (cxx_pp
);
1616 /* Be careful only to print things when we have them, so as not
1617 to crash producing error messages. */
1618 if (args
&& !primary
)
1621 len
= get_non_default_template_args_count (args
, flags
);
1623 args
= INNERMOST_TEMPLATE_ARGS (args
);
1624 for (ix
= 0; ix
!= len
; ix
++)
1626 tree arg
= TREE_VEC_ELT (args
, ix
);
1628 /* Only print a comma if we know there is an argument coming. In
1629 the case of an empty template argument pack, no actual
1630 argument will be printed. */
1632 && (!ARGUMENT_PACK_P (arg
)
1633 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1634 pp_separate_with_comma (cxx_pp
);
1637 pp_string (cxx_pp
, M_("<template parameter error>"));
1639 dump_template_argument (arg
, flags
);
1644 tree tpl
= TI_TEMPLATE (info
);
1645 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1648 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1649 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1651 for (ix
= 0; ix
!= len
; ix
++)
1655 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1657 pp_string (cxx_pp
, M_("<template parameter error>"));
1661 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1664 pp_separate_with_comma (cxx_pp
);
1666 dump_decl (parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1669 pp_cxx_end_template_argument_list (cxx_pp
);
1672 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1673 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1676 dump_call_expr_args (tree t
, int flags
, bool skipfirst
)
1679 call_expr_arg_iterator iter
;
1681 pp_cxx_left_paren (cxx_pp
);
1682 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1688 dump_expr (arg
, flags
| TFF_EXPR_IN_PARENS
);
1689 if (more_call_expr_args_p (&iter
))
1690 pp_separate_with_comma (cxx_pp
);
1693 pp_cxx_right_paren (cxx_pp
);
1696 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1697 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1701 dump_aggr_init_expr_args (tree t
, int flags
, bool skipfirst
)
1704 aggr_init_expr_arg_iterator iter
;
1706 pp_cxx_left_paren (cxx_pp
);
1707 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1713 dump_expr (arg
, flags
| TFF_EXPR_IN_PARENS
);
1714 if (more_aggr_init_expr_args_p (&iter
))
1715 pp_separate_with_comma (cxx_pp
);
1718 pp_cxx_right_paren (cxx_pp
);
1721 /* Print out a list of initializers (subr of dump_expr). */
1724 dump_expr_list (tree l
, int flags
)
1728 dump_expr (TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1731 pp_separate_with_comma (cxx_pp
);
1735 /* Print out a vector of initializers (subr of dump_expr). */
1738 dump_expr_init_vec (VEC(constructor_elt
,gc
) *v
, int flags
)
1740 unsigned HOST_WIDE_INT idx
;
1743 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1745 dump_expr (value
, flags
| TFF_EXPR_IN_PARENS
);
1746 if (idx
!= VEC_length (constructor_elt
, v
) - 1)
1747 pp_separate_with_comma (cxx_pp
);
1752 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1753 function. Resolve it to a close relative -- in the sense of static
1754 type -- variant being overridden. That is close to what was written in
1755 the source code. Subroutine of dump_expr. */
1758 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1760 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1761 HOST_WIDE_INT index
= tree_low_cst (OBJ_TYPE_REF_TOKEN (ref
), 1);
1762 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1765 fun
= TREE_CHAIN (fun
);
1766 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1767 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
1773 /* Print out an expression E under control of FLAGS. */
1776 dump_expr (tree t
, int flags
)
1781 if (STATEMENT_CLASS_P (t
))
1783 pp_cxx_ws_string (cxx_pp
, M_("<statement>"));
1787 switch (TREE_CODE (t
))
1795 case NAMESPACE_DECL
:
1799 case IDENTIFIER_NODE
:
1800 dump_decl (t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
1801 |TFF_TEMPLATE_HEADER
))
1802 | TFF_NO_FUNCTION_ARGUMENTS
));
1806 if (!DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
1807 dump_expr (SSA_NAME_VAR (t
), flags
);
1809 pp_cxx_ws_string (cxx_pp
, M_("<unknown>"));
1816 pp_constant (cxx_pp
, t
);
1819 case USERDEF_LITERAL
:
1820 pp_cxx_userdef_literal (cxx_pp
, t
);
1824 /* While waiting for caret diagnostics, avoid printing
1825 __cxa_allocate_exception, __cxa_throw, and the like. */
1826 pp_cxx_ws_string (cxx_pp
, M_("<throw-expression>"));
1830 pp_ampersand (cxx_pp
);
1831 dump_type (PTRMEM_CST_CLASS (t
), flags
);
1832 pp_cxx_colon_colon (cxx_pp
);
1833 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
1837 pp_cxx_left_paren (cxx_pp
);
1838 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1839 pp_separate_with_comma (cxx_pp
);
1840 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1841 pp_cxx_right_paren (cxx_pp
);
1845 pp_cxx_left_paren (cxx_pp
);
1846 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1847 pp_string (cxx_pp
, " ? ");
1848 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1849 pp_string (cxx_pp
, " : ");
1850 dump_expr (TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
1851 pp_cxx_right_paren (cxx_pp
);
1855 if (TREE_HAS_CONSTRUCTOR (t
))
1857 pp_cxx_ws_string (cxx_pp
, "new");
1858 pp_cxx_whitespace (cxx_pp
);
1859 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1862 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1865 case AGGR_INIT_EXPR
:
1867 tree fn
= NULL_TREE
;
1869 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
1870 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
1872 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
1874 if (DECL_CONSTRUCTOR_P (fn
))
1875 dump_type (DECL_CONTEXT (fn
), flags
);
1880 dump_expr (AGGR_INIT_EXPR_FN (t
), 0);
1882 dump_aggr_init_expr_args (t
, flags
, true);
1887 tree fn
= CALL_EXPR_FN (t
);
1888 bool skipfirst
= false;
1890 if (TREE_CODE (fn
) == ADDR_EXPR
)
1891 fn
= TREE_OPERAND (fn
, 0);
1893 /* Nobody is interested in seeing the guts of vcalls. */
1894 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
1895 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
1897 if (TREE_TYPE (fn
) != NULL_TREE
1898 && NEXT_CODE (fn
) == METHOD_TYPE
1899 && call_expr_nargs (t
))
1901 tree ob
= CALL_EXPR_ARG (t
, 0);
1902 if (TREE_CODE (ob
) == ADDR_EXPR
)
1904 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1905 pp_cxx_dot (cxx_pp
);
1907 else if (TREE_CODE (ob
) != PARM_DECL
1908 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
1910 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1911 pp_cxx_arrow (cxx_pp
);
1915 dump_expr (fn
, flags
| TFF_EXPR_IN_PARENS
);
1916 dump_call_expr_args (t
, flags
, skipfirst
);
1921 /* Note that this only works for G++ target exprs. If somebody
1922 builds a general TARGET_EXPR, there's no way to represent that
1923 it initializes anything other that the parameter slot for the
1924 default argument. Note we may have cleared out the first
1925 operand in expand_expr, so don't go killing ourselves. */
1926 if (TREE_OPERAND (t
, 1))
1927 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1930 case POINTER_PLUS_EXPR
:
1931 dump_binary_op ("+", t
, flags
);
1936 dump_binary_op (assignment_operator_name_info
[(int)NOP_EXPR
].name
,
1943 case TRUNC_DIV_EXPR
:
1944 case TRUNC_MOD_EXPR
:
1952 case TRUTH_ANDIF_EXPR
:
1953 case TRUTH_ORIF_EXPR
:
1960 case EXACT_DIV_EXPR
:
1961 dump_binary_op (operator_name_info
[(int) TREE_CODE (t
)].name
, t
, flags
);
1965 case FLOOR_DIV_EXPR
:
1966 case ROUND_DIV_EXPR
:
1968 dump_binary_op ("/", t
, flags
);
1972 case FLOOR_MOD_EXPR
:
1973 case ROUND_MOD_EXPR
:
1974 dump_binary_op ("%", t
, flags
);
1979 tree ob
= TREE_OPERAND (t
, 0);
1980 if (TREE_CODE (ob
) == INDIRECT_REF
)
1982 ob
= TREE_OPERAND (ob
, 0);
1983 if (TREE_CODE (ob
) != PARM_DECL
1985 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
1987 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1988 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
1989 pp_cxx_dot (cxx_pp
);
1991 pp_cxx_arrow (cxx_pp
);
1996 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1997 pp_cxx_dot (cxx_pp
);
1999 dump_expr (TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2004 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2005 pp_cxx_left_bracket (cxx_pp
);
2006 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2007 pp_cxx_right_bracket (cxx_pp
);
2010 case UNARY_PLUS_EXPR
:
2011 dump_unary_op ("+", t
, flags
);
2015 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2016 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2017 /* An ADDR_EXPR can have reference type. In that case, we
2018 shouldn't print the `&' doing so indicates to the user
2019 that the expression has pointer type. */
2021 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2022 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2023 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2024 dump_unary_op ("&&", t
, flags
);
2026 dump_unary_op ("&", t
, flags
);
2030 if (TREE_HAS_CONSTRUCTOR (t
))
2032 t
= TREE_OPERAND (t
, 0);
2033 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2034 dump_expr (CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2035 dump_call_expr_args (t
, flags
, true);
2039 if (TREE_OPERAND (t
,0) != NULL_TREE
2040 && TREE_TYPE (TREE_OPERAND (t
, 0))
2041 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2042 dump_expr (TREE_OPERAND (t
, 0), flags
);
2044 dump_unary_op ("*", t
, flags
);
2049 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2050 && integer_zerop (TREE_OPERAND (t
, 1)))
2051 dump_expr (TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2054 pp_cxx_star (cxx_pp
);
2055 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2057 pp_cxx_left_paren (cxx_pp
);
2058 if (!integer_onep (TYPE_SIZE_UNIT
2059 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2061 pp_cxx_left_paren (cxx_pp
);
2062 dump_type (ptr_type_node
, flags
);
2063 pp_cxx_right_paren (cxx_pp
);
2066 dump_expr (TREE_OPERAND (t
, 0), flags
);
2067 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2069 pp_cxx_ws_string (cxx_pp
, "+");
2070 dump_expr (fold_convert (ssizetype
, TREE_OPERAND (t
, 1)), flags
);
2071 pp_cxx_right_paren (cxx_pp
);
2078 case TRUTH_NOT_EXPR
:
2079 case PREDECREMENT_EXPR
:
2080 case PREINCREMENT_EXPR
:
2081 dump_unary_op (operator_name_info
[(int)TREE_CODE (t
)].name
, t
, flags
);
2084 case POSTDECREMENT_EXPR
:
2085 case POSTINCREMENT_EXPR
:
2086 pp_cxx_left_paren (cxx_pp
);
2087 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2088 pp_cxx_ws_string (cxx_pp
, operator_name_info
[(int)TREE_CODE (t
)].name
);
2089 pp_cxx_right_paren (cxx_pp
);
2092 case NON_LVALUE_EXPR
:
2093 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2094 should be another level of INDIRECT_REF so that I don't have to do
2096 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2098 tree next
= TREE_TYPE (TREE_TYPE (t
));
2100 while (TREE_CODE (next
) == POINTER_TYPE
)
2101 next
= TREE_TYPE (next
);
2103 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2105 if (flags
& TFF_EXPR_IN_PARENS
)
2106 pp_cxx_left_paren (cxx_pp
);
2107 pp_cxx_star (cxx_pp
);
2108 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2109 if (flags
& TFF_EXPR_IN_PARENS
)
2110 pp_cxx_right_paren (cxx_pp
);
2113 /* Else fall through. */
2115 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2119 case IMPLICIT_CONV_EXPR
:
2120 case VIEW_CONVERT_EXPR
:
2122 tree op
= TREE_OPERAND (t
, 0);
2123 tree ttype
= TREE_TYPE (t
);
2124 tree optype
= TREE_TYPE (op
);
2126 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2127 && POINTER_TYPE_P (ttype
)
2128 && POINTER_TYPE_P (optype
)
2129 && same_type_p (TREE_TYPE (optype
),
2132 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2133 dump_unary_op ("*", t
, flags
);
2135 dump_unary_op ("&", t
, flags
);
2137 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2139 /* It is a cast, but we cannot tell whether it is a
2140 reinterpret or static cast. Use the C style notation. */
2141 if (flags
& TFF_EXPR_IN_PARENS
)
2142 pp_cxx_left_paren (cxx_pp
);
2143 pp_cxx_left_paren (cxx_pp
);
2144 dump_type (TREE_TYPE (t
), flags
);
2145 pp_cxx_right_paren (cxx_pp
);
2146 dump_expr (op
, flags
| TFF_EXPR_IN_PARENS
);
2147 if (flags
& TFF_EXPR_IN_PARENS
)
2148 pp_cxx_right_paren (cxx_pp
);
2151 dump_expr (op
, flags
);
2156 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2158 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2160 if (integer_zerop (idx
))
2162 /* A NULL pointer-to-member constant. */
2163 pp_cxx_left_paren (cxx_pp
);
2164 pp_cxx_left_paren (cxx_pp
);
2165 dump_type (TREE_TYPE (t
), flags
);
2166 pp_cxx_right_paren (cxx_pp
);
2167 pp_character (cxx_pp
, '0');
2168 pp_cxx_right_paren (cxx_pp
);
2171 else if (host_integerp (idx
, 0))
2174 unsigned HOST_WIDE_INT n
;
2176 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2177 t
= TYPE_METHOD_BASETYPE (t
);
2178 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2180 n
= tree_low_cst (idx
, 0);
2182 /* Map vtable index back one, to allow for the null pointer to
2186 while (n
> 0 && virtuals
)
2189 virtuals
= TREE_CHAIN (virtuals
);
2193 dump_expr (BV_FN (virtuals
),
2194 flags
| TFF_EXPR_IN_PARENS
);
2199 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2200 pp_string (cxx_pp
, "<lambda closure object>");
2201 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2203 dump_type (TREE_TYPE (t
), 0);
2204 pp_cxx_left_paren (cxx_pp
);
2205 pp_cxx_right_paren (cxx_pp
);
2209 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2210 dump_type (TREE_TYPE (t
), 0);
2211 pp_cxx_left_brace (cxx_pp
);
2212 dump_expr_init_vec (CONSTRUCTOR_ELTS (t
), flags
);
2213 pp_cxx_right_brace (cxx_pp
);
2220 tree ob
= TREE_OPERAND (t
, 0);
2221 if (is_dummy_object (ob
))
2223 t
= TREE_OPERAND (t
, 1);
2224 if (TREE_CODE (t
) == FUNCTION_DECL
)
2226 dump_expr (t
, flags
| TFF_EXPR_IN_PARENS
);
2227 else if (BASELINK_P (t
))
2228 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
2229 flags
| TFF_EXPR_IN_PARENS
);
2231 dump_decl (t
, flags
);
2235 if (TREE_CODE (ob
) == INDIRECT_REF
)
2237 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2238 pp_cxx_arrow (cxx_pp
);
2239 pp_cxx_star (cxx_pp
);
2243 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
2244 pp_cxx_dot (cxx_pp
);
2245 pp_cxx_star (cxx_pp
);
2247 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2252 case TEMPLATE_PARM_INDEX
:
2253 dump_decl (TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2257 if (TREE_OPERAND (t
, 0) == NULL_TREE
2258 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2260 dump_type (TREE_TYPE (t
), flags
);
2261 pp_cxx_left_paren (cxx_pp
);
2262 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
2263 pp_cxx_right_paren (cxx_pp
);
2267 pp_cxx_left_paren (cxx_pp
);
2268 dump_type (TREE_TYPE (t
), flags
);
2269 pp_cxx_right_paren (cxx_pp
);
2270 pp_cxx_left_paren (cxx_pp
);
2271 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
2272 pp_cxx_right_paren (cxx_pp
);
2276 case STATIC_CAST_EXPR
:
2277 pp_cxx_ws_string (cxx_pp
, "static_cast");
2279 case REINTERPRET_CAST_EXPR
:
2280 pp_cxx_ws_string (cxx_pp
, "reinterpret_cast");
2282 case CONST_CAST_EXPR
:
2283 pp_cxx_ws_string (cxx_pp
, "const_cast");
2285 case DYNAMIC_CAST_EXPR
:
2286 pp_cxx_ws_string (cxx_pp
, "dynamic_cast");
2288 pp_cxx_begin_template_argument_list (cxx_pp
);
2289 dump_type (TREE_TYPE (t
), flags
);
2290 pp_cxx_end_template_argument_list (cxx_pp
);
2291 pp_cxx_left_paren (cxx_pp
);
2292 dump_expr (TREE_OPERAND (t
, 0), flags
);
2293 pp_cxx_right_paren (cxx_pp
);
2297 dump_expr (TREE_OPERAND (t
, 0), flags
);
2298 pp_cxx_arrow (cxx_pp
);
2303 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2304 pp_cxx_ws_string (cxx_pp
, "sizeof");
2307 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2308 pp_cxx_ws_string (cxx_pp
, "__alignof__");
2310 pp_cxx_whitespace (cxx_pp
);
2311 pp_cxx_left_paren (cxx_pp
);
2312 if (TYPE_P (TREE_OPERAND (t
, 0)))
2313 dump_type (TREE_OPERAND (t
, 0), flags
);
2315 dump_expr (TREE_OPERAND (t
, 0), flags
);
2316 pp_cxx_right_paren (cxx_pp
);
2319 case AT_ENCODE_EXPR
:
2320 pp_cxx_ws_string (cxx_pp
, "@encode");
2321 pp_cxx_whitespace (cxx_pp
);
2322 pp_cxx_left_paren (cxx_pp
);
2323 dump_type (TREE_OPERAND (t
, 0), flags
);
2324 pp_cxx_right_paren (cxx_pp
);
2328 pp_cxx_ws_string (cxx_pp
, "noexcept");
2329 pp_cxx_whitespace (cxx_pp
);
2330 pp_cxx_left_paren (cxx_pp
);
2331 dump_expr (TREE_OPERAND (t
, 0), flags
);
2332 pp_cxx_right_paren (cxx_pp
);
2337 pp_cxx_ws_string (cxx_pp
, operator_name_info
[TREE_CODE (t
)].name
);
2338 pp_cxx_whitespace (cxx_pp
);
2339 dump_expr (TREE_OPERAND (t
, 0), flags
);
2343 pp_string (cxx_pp
, M_("<unparsed>"));
2346 case TRY_CATCH_EXPR
:
2347 case WITH_CLEANUP_EXPR
:
2348 case CLEANUP_POINT_EXPR
:
2349 dump_expr (TREE_OPERAND (t
, 0), flags
);
2352 case PSEUDO_DTOR_EXPR
:
2353 dump_expr (TREE_OPERAND (t
, 2), flags
);
2354 pp_cxx_dot (cxx_pp
);
2355 dump_type (TREE_OPERAND (t
, 0), flags
);
2356 pp_cxx_colon_colon (cxx_pp
);
2357 pp_cxx_complement (cxx_pp
);
2358 dump_type (TREE_OPERAND (t
, 1), flags
);
2361 case TEMPLATE_ID_EXPR
:
2362 dump_decl (t
, flags
);
2368 case STATEMENT_LIST
:
2369 /* We don't yet have a way of dumping statements in a
2370 human-readable format. */
2371 pp_string (cxx_pp
, "({...})");
2375 pp_string (cxx_pp
, "while (1) { ");
2376 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2377 pp_cxx_right_brace (cxx_pp
);
2381 pp_string (cxx_pp
, "if (");
2382 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2383 pp_string (cxx_pp
, ") break; ");
2387 dump_expr (BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2390 case EMPTY_CLASS_EXPR
:
2391 dump_type (TREE_TYPE (t
), flags
);
2392 pp_cxx_left_paren (cxx_pp
);
2393 pp_cxx_right_paren (cxx_pp
);
2396 case NON_DEPENDENT_EXPR
:
2397 dump_expr (TREE_OPERAND (t
, 0), flags
);
2400 case ARGUMENT_PACK_SELECT
:
2401 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2413 pp_type_specifier_seq (cxx_pp
, t
);
2417 /* We get here when we want to print a dependent type as an
2418 id-expression, without any disambiguator decoration. */
2419 pp_id_expression (cxx_pp
, t
);
2422 case TEMPLATE_TYPE_PARM
:
2423 case TEMPLATE_TEMPLATE_PARM
:
2424 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2425 dump_type (t
, flags
);
2429 pp_cxx_trait_expression (cxx_pp
, t
);
2433 pp_cxx_va_arg_expression (cxx_pp
, t
);
2437 pp_cxx_offsetof_expression (cxx_pp
, t
);
2441 dump_decl (t
, flags
);
2444 case EXPR_PACK_EXPANSION
:
2451 case VEC_DELETE_EXPR
:
2457 case UNORDERED_EXPR
:
2467 case FIX_TRUNC_EXPR
:
2469 pp_expression (cxx_pp
, t
);
2472 case TRUTH_AND_EXPR
:
2474 case TRUTH_XOR_EXPR
:
2475 if (flags
& TFF_EXPR_IN_PARENS
)
2476 pp_cxx_left_paren (cxx_pp
);
2477 pp_expression (cxx_pp
, t
);
2478 if (flags
& TFF_EXPR_IN_PARENS
)
2479 pp_cxx_right_paren (cxx_pp
);
2483 dump_expr (resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2486 /* This list is incomplete, but should suffice for now.
2487 It is very important that `sorry' does not call
2488 `report_error_function'. That could cause an infinite loop. */
2490 pp_unsupported_tree (cxx_pp
, t
);
2491 /* fall through to ERROR_MARK... */
2493 pp_string (cxx_pp
, M_("<expression error>"));
2499 dump_binary_op (const char *opstring
, tree t
, int flags
)
2501 pp_cxx_left_paren (cxx_pp
);
2502 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2503 pp_cxx_whitespace (cxx_pp
);
2505 pp_cxx_ws_string (cxx_pp
, opstring
);
2507 pp_string (cxx_pp
, M_("<unknown operator>"));
2508 pp_cxx_whitespace (cxx_pp
);
2509 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2510 pp_cxx_right_paren (cxx_pp
);
2514 dump_unary_op (const char *opstring
, tree t
, int flags
)
2516 if (flags
& TFF_EXPR_IN_PARENS
)
2517 pp_cxx_left_paren (cxx_pp
);
2518 pp_cxx_ws_string (cxx_pp
, opstring
);
2519 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2520 if (flags
& TFF_EXPR_IN_PARENS
)
2521 pp_cxx_right_paren (cxx_pp
);
2525 reinit_cxx_pp (void)
2527 pp_clear_output_area (cxx_pp
);
2528 pp_base (cxx_pp
)->padding
= pp_none
;
2529 pp_indentation (cxx_pp
) = 0;
2530 pp_needs_newline (cxx_pp
) = false;
2531 cxx_pp
->enclosing_scope
= current_function_decl
;
2535 /* Exported interface to stringifying types, exprs and decls under TFF_*
2539 type_as_string (tree typ
, int flags
)
2542 pp_translate_identifiers (cxx_pp
) = false;
2543 dump_type (typ
, flags
);
2544 return pp_formatted_text (cxx_pp
);
2548 type_as_string_translate (tree typ
, int flags
)
2551 dump_type (typ
, flags
);
2552 return pp_formatted_text (cxx_pp
);
2556 expr_as_string (tree decl
, int flags
)
2559 pp_translate_identifiers (cxx_pp
) = false;
2560 dump_expr (decl
, flags
);
2561 return pp_formatted_text (cxx_pp
);
2564 /* Wrap decl_as_string with options appropriate for dwarf. */
2567 decl_as_dwarf_string (tree decl
, int flags
)
2570 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2571 here will be adequate to get the desired behaviour. */
2572 pp_c_base (cxx_pp
)->flags
|= pp_c_flag_gnu_v3
;
2573 name
= decl_as_string (decl
, flags
);
2574 /* Subsequent calls to the pretty printer shouldn't use this style. */
2575 pp_c_base (cxx_pp
)->flags
&= ~pp_c_flag_gnu_v3
;
2580 decl_as_string (tree decl
, int flags
)
2583 pp_translate_identifiers (cxx_pp
) = false;
2584 dump_decl (decl
, flags
);
2585 return pp_formatted_text (cxx_pp
);
2589 decl_as_string_translate (tree decl
, int flags
)
2592 dump_decl (decl
, flags
);
2593 return pp_formatted_text (cxx_pp
);
2596 /* Wrap lang_decl_name with options appropriate for dwarf. */
2599 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2602 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2603 here will be adequate to get the desired behaviour. */
2604 pp_c_base (cxx_pp
)->flags
|= pp_c_flag_gnu_v3
;
2605 name
= lang_decl_name (decl
, v
, translate
);
2606 /* Subsequent calls to the pretty printer shouldn't use this style. */
2607 pp_c_base (cxx_pp
)->flags
&= ~pp_c_flag_gnu_v3
;
2611 /* Generate the three forms of printable names for cxx_printable_name. */
2614 lang_decl_name (tree decl
, int v
, bool translate
)
2618 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2619 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2622 pp_translate_identifiers (cxx_pp
) = translate
;
2624 && (DECL_CLASS_SCOPE_P (decl
)
2625 || (DECL_NAMESPACE_SCOPE_P (decl
)
2626 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2628 dump_type (CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2629 pp_cxx_colon_colon (cxx_pp
);
2632 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2633 dump_function_name (decl
, TFF_PLAIN_IDENTIFIER
);
2634 else if ((DECL_NAME (decl
) == NULL_TREE
)
2635 && TREE_CODE (decl
) == NAMESPACE_DECL
)
2636 dump_decl (decl
, TFF_PLAIN_IDENTIFIER
);
2638 dump_decl (DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2640 return pp_formatted_text (cxx_pp
);
2643 /* Return the location of a tree passed to %+ formats. */
2646 location_of (tree t
)
2648 if (TREE_CODE (t
) == PARM_DECL
&& DECL_CONTEXT (t
))
2649 t
= DECL_CONTEXT (t
);
2650 else if (TYPE_P (t
))
2652 t
= TYPE_MAIN_DECL (t
);
2654 return input_location
;
2656 else if (TREE_CODE (t
) == OVERLOAD
)
2657 t
= OVL_FUNCTION (t
);
2660 return DECL_SOURCE_LOCATION (t
);
2661 return EXPR_LOC_OR_HERE (t
);
2664 /* Now the interfaces from error et al to dump_type et al. Each takes an
2665 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2669 decl_to_string (tree decl
, int verbose
)
2673 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2674 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2675 flags
= TFF_CLASS_KEY_OR_ENUM
;
2677 flags
|= TFF_DECL_SPECIFIERS
;
2678 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2679 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2680 flags
|= TFF_TEMPLATE_HEADER
;
2683 dump_decl (decl
, flags
);
2684 return pp_formatted_text (cxx_pp
);
2688 expr_to_string (tree decl
)
2691 dump_expr (decl
, 0);
2692 return pp_formatted_text (cxx_pp
);
2696 fndecl_to_string (tree fndecl
, int verbose
)
2700 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
2701 | TFF_TEMPLATE_HEADER
;
2703 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
2705 dump_decl (fndecl
, flags
);
2706 return pp_formatted_text (cxx_pp
);
2711 code_to_string (enum tree_code c
)
2713 return tree_code_name
[c
];
2717 language_to_string (enum languages c
)
2724 case lang_cplusplus
:
2736 /* Return the proper printed version of a parameter to a C++ function. */
2739 parm_to_string (int p
)
2743 pp_string (cxx_pp
, "'this'");
2745 pp_decimal_int (cxx_pp
, p
+ 1);
2746 return pp_formatted_text (cxx_pp
);
2750 op_to_string (enum tree_code p
)
2752 tree id
= operator_name_info
[(int) p
].identifier
;
2753 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
2757 type_to_string (tree typ
, int verbose
)
2761 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2762 flags
|= TFF_TEMPLATE_HEADER
;
2765 dump_type (typ
, flags
);
2766 /* If we're printing a type that involves typedefs, also print the
2767 stripped version. But sometimes the stripped version looks
2768 exactly the same, so we don't want it after all. To avoid printing
2769 it in that case, we play ugly obstack games. */
2770 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
2771 && !uses_template_parms (typ
))
2773 int aka_start
; char *p
;
2774 struct obstack
*ob
= pp_base (cxx_pp
)->buffer
->obstack
;
2775 /* Remember the end of the initial dump. */
2776 int len
= obstack_object_size (ob
);
2777 tree aka
= strip_typedefs (typ
);
2778 pp_string (cxx_pp
, " {aka");
2779 pp_cxx_whitespace (cxx_pp
);
2780 /* And remember the start of the aka dump. */
2781 aka_start
= obstack_object_size (ob
);
2782 dump_type (aka
, flags
);
2783 pp_character (cxx_pp
, '}');
2784 p
= (char*)obstack_base (ob
);
2785 /* If they are identical, cut off the aka with a NUL. */
2786 if (memcmp (p
, p
+aka_start
, len
) == 0)
2789 return pp_formatted_text (cxx_pp
);
2793 assop_to_string (enum tree_code p
)
2795 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
2796 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
2800 args_to_string (tree p
, int verbose
)
2804 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2809 if (TYPE_P (TREE_VALUE (p
)))
2810 return type_as_string_translate (p
, flags
);
2813 for (; p
; p
= TREE_CHAIN (p
))
2815 if (TREE_VALUE (p
) == null_node
)
2816 pp_cxx_ws_string (cxx_pp
, "NULL");
2818 dump_type (error_type (TREE_VALUE (p
)), flags
);
2820 pp_separate_with_comma (cxx_pp
);
2822 return pp_formatted_text (cxx_pp
);
2825 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
2826 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
2830 subst_to_string (tree p
)
2832 tree decl
= TREE_PURPOSE (p
);
2833 tree targs
= TREE_VALUE (p
);
2834 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
2835 int flags
= TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
;
2841 dump_template_decl (TREE_PURPOSE (p
), flags
);
2842 pp_cxx_whitespace (cxx_pp
);
2843 pp_cxx_left_bracket (cxx_pp
);
2844 pp_cxx_ws_string (cxx_pp
, M_("with"));
2845 pp_cxx_whitespace (cxx_pp
);
2846 dump_template_bindings (tparms
, targs
, NULL
);
2847 pp_cxx_right_bracket (cxx_pp
);
2848 return pp_formatted_text (cxx_pp
);
2852 cv_to_string (tree p
, int v
)
2855 pp_base (cxx_pp
)->padding
= v
? pp_before
: pp_none
;
2856 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
2857 return pp_formatted_text (cxx_pp
);
2860 /* Langhook for print_error_function. */
2862 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
2863 diagnostic_info
*diagnostic
)
2865 lhd_print_error_function (context
, file
, diagnostic
);
2866 pp_base_set_prefix (context
->printer
, file
);
2867 maybe_print_instantiation_context (context
);
2871 cp_diagnostic_starter (diagnostic_context
*context
,
2872 diagnostic_info
*diagnostic
)
2874 diagnostic_report_current_module (context
, diagnostic
->location
);
2875 cp_print_error_function (context
, diagnostic
);
2876 maybe_print_instantiation_context (context
);
2877 maybe_print_constexpr_context (context
);
2878 pp_base_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
2883 cp_diagnostic_finalizer (diagnostic_context
*context
,
2884 diagnostic_info
*diagnostic
)
2886 virt_loc_aware_diagnostic_finalizer (context
, diagnostic
);
2887 pp_base_destroy_prefix (context
->printer
);
2890 /* Print current function onto BUFFER, in the process of reporting
2891 a diagnostic message. Called from cp_diagnostic_starter. */
2893 cp_print_error_function (diagnostic_context
*context
,
2894 diagnostic_info
*diagnostic
)
2896 /* If we are in an instantiation context, current_function_decl is likely
2897 to be wrong, so just rely on print_instantiation_full_context. */
2898 if (current_instantiation ())
2900 if (diagnostic_last_function_changed (context
, diagnostic
))
2902 const char *old_prefix
= context
->printer
->prefix
;
2903 const char *file
= LOCATION_FILE (diagnostic
->location
);
2904 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
2905 char *new_prefix
= (file
&& abstract_origin
== NULL
)
2906 ? file_name_as_prefix (file
) : NULL
;
2908 pp_base_set_prefix (context
->printer
, new_prefix
);
2910 if (current_function_decl
== NULL
)
2911 pp_base_string (context
->printer
, _("At global scope:"));
2916 if (abstract_origin
)
2918 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
2919 while (TREE_CODE (ao
) == BLOCK
2920 && BLOCK_ABSTRACT_ORIGIN (ao
)
2921 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
2922 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
2923 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
2927 fndecl
= current_function_decl
;
2929 pp_printf (context
->printer
, function_category (fndecl
),
2930 cxx_printable_name_translate (fndecl
, 2));
2932 while (abstract_origin
)
2935 tree block
= abstract_origin
;
2937 locus
= &BLOCK_SOURCE_LOCATION (block
);
2939 block
= BLOCK_SUPERCONTEXT (block
);
2940 while (block
&& TREE_CODE (block
) == BLOCK
2941 && BLOCK_ABSTRACT_ORIGIN (block
))
2943 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
2945 while (TREE_CODE (ao
) == BLOCK
2946 && BLOCK_ABSTRACT_ORIGIN (ao
)
2947 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
2948 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
2950 if (TREE_CODE (ao
) == FUNCTION_DECL
)
2955 else if (TREE_CODE (ao
) != BLOCK
)
2958 block
= BLOCK_SUPERCONTEXT (block
);
2961 abstract_origin
= block
;
2964 while (block
&& TREE_CODE (block
) == BLOCK
)
2965 block
= BLOCK_SUPERCONTEXT (block
);
2967 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
2969 abstract_origin
= NULL
;
2973 expanded_location s
= expand_location (*locus
);
2974 pp_base_character (context
->printer
, ',');
2975 pp_base_newline (context
->printer
);
2978 if (context
->show_column
&& s
.column
!= 0)
2979 pp_printf (context
->printer
,
2980 _(" inlined from %qs at %s:%d:%d"),
2981 cxx_printable_name_translate (fndecl
, 2),
2982 s
.file
, s
.line
, s
.column
);
2984 pp_printf (context
->printer
,
2985 _(" inlined from %qs at %s:%d"),
2986 cxx_printable_name_translate (fndecl
, 2),
2991 pp_printf (context
->printer
, _(" inlined from %qs"),
2992 cxx_printable_name_translate (fndecl
, 2));
2995 pp_base_character (context
->printer
, ':');
2997 pp_base_newline (context
->printer
);
2999 diagnostic_set_last_function (context
, diagnostic
);
3000 pp_base_destroy_prefix (context
->printer
);
3001 context
->printer
->prefix
= old_prefix
;
3005 /* Returns a description of FUNCTION using standard terminology. The
3006 result is a format string of the form "In CATEGORY %qs". */
3008 function_category (tree fn
)
3010 /* We can get called from the middle-end for diagnostics of function
3011 clones. Make sure we have language specific information before
3012 dereferencing it. */
3013 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3014 && DECL_FUNCTION_MEMBER_P (fn
))
3016 if (DECL_STATIC_FUNCTION_P (fn
))
3017 return _("In static member function %qs");
3018 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3019 return _("In copy constructor %qs");
3020 else if (DECL_CONSTRUCTOR_P (fn
))
3021 return _("In constructor %qs");
3022 else if (DECL_DESTRUCTOR_P (fn
))
3023 return _("In destructor %qs");
3024 else if (LAMBDA_FUNCTION_P (fn
))
3025 return _("In lambda function");
3027 return _("In member function %qs");
3030 return _("In function %qs");
3033 /* Report the full context of a current template instantiation,
3036 print_instantiation_full_context (diagnostic_context
*context
)
3038 struct tinst_level
*p
= current_instantiation ();
3039 location_t location
= input_location
;
3043 pp_verbatim (context
->printer
,
3044 TREE_CODE (p
->decl
) == TREE_LIST
3045 ? _("%s: In substitution of %qS:\n")
3046 : _("%s: In instantiation of %q#D:\n"),
3047 LOCATION_FILE (location
),
3050 location
= p
->locus
;
3054 print_instantiation_partial_context (context
, p
, location
);
3057 /* Helper function of print_instantiation_partial_context() that
3058 prints a single line of instantiation context. */
3061 print_instantiation_partial_context_line (diagnostic_context
*context
,
3062 const struct tinst_level
*t
,
3063 location_t loc
, bool recursive_p
)
3065 expanded_location xloc
;
3066 xloc
= expand_location (loc
);
3068 if (context
->show_column
)
3069 pp_verbatim (context
->printer
, _("%s:%d:%d: "),
3070 xloc
.file
, xloc
.line
, xloc
.column
);
3072 pp_verbatim (context
->printer
, _("%s:%d: "),
3073 xloc
.file
, xloc
.line
);
3077 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3078 pp_verbatim (context
->printer
,
3080 ? _("recursively required by substitution of %qS\n")
3081 : _("required by substitution of %qS\n"),
3084 pp_verbatim (context
->printer
,
3086 ? _("recursively required from %q#D\n")
3087 : _("required from %q#D\n"),
3092 pp_verbatim (context
->printer
,
3094 ? _("recursively required from here")
3095 : _("required from here"));
3099 /* Same as print_instantiation_full_context but less verbose. */
3102 print_instantiation_partial_context (diagnostic_context
*context
,
3103 struct tinst_level
*t0
, location_t loc
)
3105 struct tinst_level
*t
;
3108 location_t prev_loc
= loc
;
3110 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3111 if (prev_loc
!= t
->locus
)
3113 prev_loc
= t
->locus
;
3119 if (template_backtrace_limit
3120 && n_total
> template_backtrace_limit
)
3122 int skip
= n_total
- template_backtrace_limit
;
3123 int head
= template_backtrace_limit
/ 2;
3125 /* Avoid skipping just 1. If so, skip 2. */
3129 head
= (template_backtrace_limit
- 1) / 2;
3132 for (n
= 0; n
< head
; n
++)
3134 gcc_assert (t
!= NULL
);
3135 if (loc
!= t
->locus
)
3136 print_instantiation_partial_context_line (context
, t
, loc
,
3137 /*recursive_p=*/false);
3141 if (t
!= NULL
&& skip
> 0)
3143 expanded_location xloc
;
3144 xloc
= expand_location (loc
);
3145 if (context
->show_column
)
3146 pp_verbatim (context
->printer
,
3147 _("%s:%d:%d: [ skipping %d instantiation contexts, "
3148 "use -ftemplate-backtrace-limit=0 to disable ]\n"),
3149 xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3151 pp_verbatim (context
->printer
,
3152 _("%s:%d: [ skipping %d instantiation contexts, "
3153 "use -ftemplate-backtrace-limit=0 to disable ]\n"),
3154 xloc
.file
, xloc
.line
, skip
);
3159 } while (t
!= NULL
&& --skip
> 0);
3165 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3170 print_instantiation_partial_context_line (context
, t
, loc
,
3175 print_instantiation_partial_context_line (context
, NULL
, loc
,
3176 /*recursive_p=*/false);
3177 pp_base_newline (context
->printer
);
3180 /* Called from cp_thing to print the template context for an error. */
3182 maybe_print_instantiation_context (diagnostic_context
*context
)
3184 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3187 record_last_problematic_instantiation ();
3188 print_instantiation_full_context (context
);
3191 /* Report the bare minimum context of a template instantiation. */
3193 print_instantiation_context (void)
3195 print_instantiation_partial_context
3196 (global_dc
, current_instantiation (), input_location
);
3197 diagnostic_flush_buffer (global_dc
);
3200 /* Report what constexpr call(s) we're trying to expand, if any. */
3203 maybe_print_constexpr_context (diagnostic_context
*context
)
3205 VEC(tree
,heap
) *call_stack
= cx_error_context ();
3209 FOR_EACH_VEC_ELT (tree
, call_stack
, ix
, t
)
3211 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3212 const char *s
= expr_as_string (t
, 0);
3213 if (context
->show_column
)
3214 pp_verbatim (context
->printer
,
3215 _("%s:%d:%d: in constexpr expansion of %qs"),
3216 xloc
.file
, xloc
.line
, xloc
.column
, s
);
3218 pp_verbatim (context
->printer
,
3219 _("%s:%d: in constexpr expansion of %qs"),
3220 xloc
.file
, xloc
.line
, s
);
3221 pp_base_newline (context
->printer
);
3225 /* Called from output_format -- during diagnostic message processing --
3226 to handle C++ specific format specifier with the following meanings:
3227 %A function argument-list.
3231 %F function declaration.
3232 %L language as used in extern "lang".
3234 %P function parameter whose position is indicated by an integer.
3235 %Q assignment operator.
3239 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
3240 int precision
, bool wide
, bool set_locus
, bool verbose
)
3244 #define next_tree (t = va_arg (*text->args_ptr, tree))
3245 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3246 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3247 #define next_int va_arg (*text->args_ptr, int)
3249 if (precision
!= 0 || wide
)
3252 if (text
->locus
== NULL
)
3257 case 'A': result
= args_to_string (next_tree
, verbose
); break;
3258 case 'C': result
= code_to_string (next_tcode
); break;
3261 tree temp
= next_tree
;
3263 && DECL_DEBUG_EXPR_IS_FROM (temp
) && DECL_DEBUG_EXPR (temp
))
3265 temp
= DECL_DEBUG_EXPR (temp
);
3268 result
= expr_to_string (temp
);
3272 result
= decl_to_string (temp
, verbose
);
3275 case 'E': result
= expr_to_string (next_tree
); break;
3276 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
3277 case 'L': result
= language_to_string (next_lang
); break;
3278 case 'O': result
= op_to_string (next_tcode
); break;
3279 case 'P': result
= parm_to_string (next_int
); break;
3280 case 'Q': result
= assop_to_string (next_tcode
); break;
3281 case 'S': result
= subst_to_string (next_tree
); break;
3282 case 'T': result
= type_to_string (next_tree
, verbose
); break;
3283 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
3286 percent_K_format (text
);
3293 pp_base_string (pp
, result
);
3294 if (set_locus
&& t
!= NULL
)
3295 *text
->locus
= location_of (t
);
3303 /* Warn about the use of C++0x features when appropriate. */
3305 maybe_warn_cpp0x (cpp0x_warn_str str
)
3307 if ((cxx_dialect
== cxx98
) && !in_system_header
)
3308 /* We really want to suppress this warning in system headers,
3309 because libstdc++ uses variadic templates even when we aren't
3313 case CPP0X_INITIALIZER_LISTS
:
3314 pedwarn (input_location
, 0,
3315 "extended initializer lists "
3316 "only available with -std=c++11 or -std=gnu++11");
3318 case CPP0X_EXPLICIT_CONVERSION
:
3319 pedwarn (input_location
, 0,
3320 "explicit conversion operators "
3321 "only available with -std=c++11 or -std=gnu++11");
3323 case CPP0X_VARIADIC_TEMPLATES
:
3324 pedwarn (input_location
, 0,
3325 "variadic templates "
3326 "only available with -std=c++11 or -std=gnu++11");
3328 case CPP0X_LAMBDA_EXPR
:
3329 pedwarn (input_location
, 0,
3330 "lambda expressions "
3331 "only available with -std=c++11 or -std=gnu++11");
3334 pedwarn (input_location
, 0,
3335 "C++0x auto only available with -std=c++11 or -std=gnu++11");
3337 case CPP0X_SCOPED_ENUMS
:
3338 pedwarn (input_location
, 0,
3339 "scoped enums only available with -std=c++11 or -std=gnu++11");
3341 case CPP0X_DEFAULTED_DELETED
:
3342 pedwarn (input_location
, 0,
3343 "defaulted and deleted functions "
3344 "only available with -std=c++11 or -std=gnu++11");
3346 case CPP0X_INLINE_NAMESPACES
:
3347 pedwarn (input_location
, OPT_Wpedantic
,
3348 "inline namespaces "
3349 "only available with -std=c++11 or -std=gnu++11");
3351 case CPP0X_OVERRIDE_CONTROLS
:
3352 pedwarn (input_location
, 0,
3353 "override controls (override/final) "
3354 "only available with -std=c++11 or -std=gnu++11");
3357 pedwarn (input_location
, 0,
3358 "non-static data member initializers "
3359 "only available with -std=c++11 or -std=gnu++11");
3361 case CPP0X_USER_DEFINED_LITERALS
:
3362 pedwarn (input_location
, 0,
3363 "user-defined literals "
3364 "only available with -std=c++11 or -std=gnu++11");
3366 case CPP0X_DELEGATING_CTORS
:
3367 pedwarn (input_location
, 0,
3368 "delegating constructors "
3369 "only available with -std=c++11 or -std=gnu++11");
3376 /* Warn about the use of variadic templates when appropriate. */
3378 maybe_warn_variadic_templates (void)
3380 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
3384 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3385 option OPT with text GMSGID. Use this function to report
3386 diagnostics for constructs that are invalid C++98, but valid
3389 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
3391 diagnostic_info diagnostic
;
3395 va_start (ap
, gmsgid
);
3396 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, location
,
3397 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
3398 diagnostic
.option_index
= opt
;
3399 ret
= report_diagnostic (&diagnostic
);
3404 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3405 we found when we tried to do the lookup. LOCATION is the location of
3406 the NAME identifier. */
3409 qualified_name_lookup_error (tree scope
, tree name
,
3410 tree decl
, location_t location
)
3412 if (scope
== error_mark_node
)
3413 ; /* We already complained. */
3414 else if (TYPE_P (scope
))
3416 if (!COMPLETE_TYPE_P (scope
))
3417 error_at (location
, "incomplete type %qT used in nested name specifier",
3419 else if (TREE_CODE (decl
) == TREE_LIST
)
3421 error_at (location
, "reference to %<%T::%D%> is ambiguous",
3423 print_candidates (decl
);
3426 error_at (location
, "%qD is not a member of %qT", name
, scope
);
3428 else if (scope
!= global_namespace
)
3430 error_at (location
, "%qD is not a member of %qD", name
, scope
);
3431 suggest_alternatives_for (location
, name
);
3435 error_at (location
, "%<::%D%> has not been declared", name
);
3436 suggest_alternatives_for (location
, name
);
