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
, va_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
, va_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_safe_is_empty (typenames
) || uses_template_parms (args
))
316 FOR_EACH_VEC_SAFE_ELT (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 (LAMBDA_TYPE_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 (integer_all_onesp (max
))
850 pp_character (cxx_pp
, '0');
851 else if (host_integerp (max
, 0))
852 pp_wide_integer (cxx_pp
, tree_low_cst (max
, 0) + 1);
853 else if (TREE_CODE (max
) == MINUS_EXPR
)
854 dump_expr (TREE_OPERAND (max
, 0),
855 flags
& ~TFF_EXPR_IN_PARENS
);
857 dump_expr (fold_build2_loc (input_location
,
858 PLUS_EXPR
, dtype
, max
,
859 build_int_cst (dtype
, 1)),
860 flags
& ~TFF_EXPR_IN_PARENS
);
862 pp_cxx_right_bracket (cxx_pp
);
863 dump_type_suffix (TREE_TYPE (t
), flags
);
867 case IDENTIFIER_NODE
:
872 case TEMPLATE_TYPE_PARM
:
873 case TEMPLATE_TEMPLATE_PARM
:
874 case BOUND_TEMPLATE_TEMPLATE_PARM
:
885 case UNDERLYING_TYPE
:
887 case TYPE_PACK_EXPANSION
:
888 case FIXED_POINT_TYPE
:
893 pp_unsupported_tree (cxx_pp
, t
);
895 /* Don't mark it here, we should have already done in
902 dump_global_iord (tree t
)
904 const char *p
= NULL
;
906 if (DECL_GLOBAL_CTOR_P (t
))
907 p
= M_("(static initializers for %s)");
908 else if (DECL_GLOBAL_DTOR_P (t
))
909 p
= M_("(static destructors for %s)");
913 pp_printf (pp_base (cxx_pp
), p
, input_filename
);
917 dump_simple_decl (tree t
, tree type
, int flags
)
919 if (flags
& TFF_DECL_SPECIFIERS
)
921 if (TREE_CODE (t
) == VAR_DECL
922 && DECL_DECLARED_CONSTEXPR_P (t
))
923 pp_cxx_ws_string (cxx_pp
, "constexpr");
924 dump_type_prefix (type
, flags
& ~TFF_UNQUALIFIED_NAME
);
925 pp_maybe_space (cxx_pp
);
927 if (! (flags
& TFF_UNQUALIFIED_NAME
)
928 && TREE_CODE (t
) != PARM_DECL
929 && (!DECL_INITIAL (t
)
930 || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
))
931 dump_scope (CP_DECL_CONTEXT (t
), flags
);
932 flags
&= ~TFF_UNQUALIFIED_NAME
;
933 if ((flags
& TFF_DECL_SPECIFIERS
)
934 && DECL_TEMPLATE_PARM_P (t
)
935 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t
)))
936 pp_string (cxx_pp
, "...");
938 dump_decl (DECL_NAME (t
), flags
);
940 pp_string (cxx_pp
, M_("<anonymous>"));
941 if (flags
& TFF_DECL_SPECIFIERS
)
942 dump_type_suffix (type
, flags
);
945 /* Dump a human readable string for the decl T under control of FLAGS. */
948 dump_decl (tree t
, int flags
)
953 /* If doing Objective-C++, give Objective-C a chance to demangle
954 Objective-C method names. */
955 if (c_dialect_objc ())
957 const char *demangled
= objc_maybe_printable_name (t
, flags
);
960 pp_string (cxx_pp
, demangled
);
965 switch (TREE_CODE (t
))
968 /* Don't say 'typedef class A' */
969 if (DECL_ARTIFICIAL (t
) && !DECL_SELF_REFERENCE_P (t
))
971 if ((flags
& TFF_DECL_SPECIFIERS
)
972 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
974 /* Say `class T' not just `T'. */
975 pp_cxx_ws_string (cxx_pp
, "class");
977 /* Emit the `...' for a parameter pack. */
978 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
979 pp_cxx_ws_string (cxx_pp
, "...");
982 dump_type (TREE_TYPE (t
), flags
);
985 if (TYPE_DECL_ALIAS_P (t
)
986 && (flags
& TFF_DECL_SPECIFIERS
987 || flags
& TFF_CLASS_KEY_OR_ENUM
))
989 pp_cxx_ws_string (cxx_pp
, "using");
990 dump_decl (DECL_NAME (t
), flags
);
991 pp_cxx_whitespace (cxx_pp
);
992 pp_cxx_ws_string (cxx_pp
, "=");
993 pp_cxx_whitespace (cxx_pp
);
994 dump_type (DECL_ORIGINAL_TYPE (t
), flags
);
997 if ((flags
& TFF_DECL_SPECIFIERS
)
998 && !DECL_SELF_REFERENCE_P (t
))
999 pp_cxx_ws_string (cxx_pp
, "typedef");
1000 dump_simple_decl (t
, DECL_ORIGINAL_TYPE (t
)
1001 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
1006 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
1008 pp_string (cxx_pp
, M_("vtable for "));
1009 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
1010 dump_type (DECL_CONTEXT (t
), flags
);
1013 /* Else fall through. */
1016 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
1020 pp_string (cxx_pp
, M_("<return value> "));
1021 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
1024 case NAMESPACE_DECL
:
1025 if (flags
& TFF_DECL_SPECIFIERS
)
1026 pp_cxx_declaration (cxx_pp
, t
);
1029 if (! (flags
& TFF_UNQUALIFIED_NAME
))
1030 dump_scope (CP_DECL_CONTEXT (t
), flags
);
1031 flags
&= ~TFF_UNQUALIFIED_NAME
;
1032 if (DECL_NAME (t
) == NULL_TREE
)
1034 if (!(pp_c_base (cxx_pp
)->flags
& pp_c_flag_gnu_v3
))
1035 pp_cxx_ws_string (cxx_pp
, M_("{anonymous}"));
1037 pp_cxx_ws_string (cxx_pp
, M_("(anonymous namespace)"));
1040 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
1045 dump_type (TREE_OPERAND (t
, 0), flags
);
1046 pp_string (cxx_pp
, "::");
1047 dump_decl (TREE_OPERAND (t
, 1), TFF_UNQUALIFIED_NAME
);
1051 dump_decl (TREE_OPERAND (t
, 0), flags
);
1052 pp_cxx_left_bracket (cxx_pp
);
1053 dump_decl (TREE_OPERAND (t
, 1), flags
);
1054 pp_cxx_right_bracket (cxx_pp
);
1057 /* So that we can do dump_decl on an aggr type. */
1061 dump_type (t
, flags
);
1065 /* This is a pseudo destructor call which has not been folded into
1066 a PSEUDO_DTOR_EXPR yet. */
1067 pp_cxx_complement (cxx_pp
);
1068 dump_type (TREE_OPERAND (t
, 0), flags
);
1075 /* These special cases are duplicated here so that other functions
1076 can feed identifiers to error and get them demangled properly. */
1077 case IDENTIFIER_NODE
:
1078 if (IDENTIFIER_TYPENAME_P (t
))
1080 pp_cxx_ws_string (cxx_pp
, "operator");
1081 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1082 dump_type (TREE_TYPE (t
), flags
);
1086 pp_cxx_tree_identifier (cxx_pp
, t
);
1092 t
= OVL_CURRENT (t
);
1093 if (DECL_CLASS_SCOPE_P (t
))
1095 dump_type (DECL_CONTEXT (t
), flags
);
1096 pp_cxx_colon_colon (cxx_pp
);
1098 else if (!DECL_FILE_SCOPE_P (t
))
1100 dump_decl (DECL_CONTEXT (t
), flags
);
1101 pp_cxx_colon_colon (cxx_pp
);
1103 dump_decl (DECL_NAME (t
), flags
);
1107 /* If there's only one function, just treat it like an ordinary
1109 t
= OVL_CURRENT (t
);
1113 if (! DECL_LANG_SPECIFIC (t
))
1114 pp_string (cxx_pp
, M_("<built-in>"));
1115 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1116 dump_global_iord (t
);
1118 dump_function_decl (t
, flags
);
1122 dump_template_decl (t
, flags
);
1125 case TEMPLATE_ID_EXPR
:
1127 tree name
= TREE_OPERAND (t
, 0);
1128 tree args
= TREE_OPERAND (t
, 1);
1130 if (is_overloaded_fn (name
))
1131 name
= DECL_NAME (get_first_fn (name
));
1132 dump_decl (name
, flags
);
1133 pp_cxx_begin_template_argument_list (cxx_pp
);
1134 if (args
== error_mark_node
)
1135 pp_string (cxx_pp
, M_("<template arguments error>"));
1137 dump_template_argument_list (args
, flags
);
1138 pp_cxx_end_template_argument_list (cxx_pp
);
1143 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (t
));
1147 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1148 || (DECL_INITIAL (t
) &&
1149 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1150 dump_simple_decl (t
, TREE_TYPE (t
), flags
);
1151 else if (DECL_NAME (t
))
1152 dump_decl (DECL_NAME (t
), flags
);
1153 else if (DECL_INITIAL (t
))
1154 dump_expr (DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1156 pp_string (cxx_pp
, M_("<enumerator>"));
1160 pp_cxx_ws_string (cxx_pp
, "using");
1161 dump_type (USING_DECL_SCOPE (t
), flags
);
1162 pp_cxx_colon_colon (cxx_pp
);
1163 dump_decl (DECL_NAME (t
), flags
);
1167 pp_cxx_declaration (cxx_pp
, t
);
1171 dump_decl (BASELINK_FUNCTIONS (t
), flags
);
1174 case NON_DEPENDENT_EXPR
:
1175 dump_expr (t
, flags
);
1178 case TEMPLATE_TYPE_PARM
:
1179 if (flags
& TFF_DECL_SPECIFIERS
)
1180 pp_cxx_declaration (cxx_pp
, t
);
1182 pp_type_id (cxx_pp
, t
);
1185 case UNBOUND_CLASS_TEMPLATE
:
1186 case TYPE_PACK_EXPANSION
:
1188 dump_type (t
, flags
);
1192 pp_unsupported_tree (cxx_pp
, t
);
1193 /* Fall through to error. */
1196 pp_string (cxx_pp
, M_("<declaration error>"));
1201 /* Dump a template declaration T under control of FLAGS. This means the
1202 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1205 dump_template_decl (tree t
, int flags
)
1207 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1211 if (flags
& TFF_TEMPLATE_HEADER
)
1213 for (parms
= orig_parms
= nreverse (orig_parms
);
1215 parms
= TREE_CHAIN (parms
))
1217 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1218 int len
= TREE_VEC_LENGTH (inner_parms
);
1220 pp_cxx_ws_string (cxx_pp
, "template");
1221 pp_cxx_begin_template_argument_list (cxx_pp
);
1223 /* If we've shown the template prefix, we'd better show the
1224 parameters' and decl's type too. */
1225 flags
|= TFF_DECL_SPECIFIERS
;
1227 for (i
= 0; i
< len
; i
++)
1230 pp_separate_with_comma (cxx_pp
);
1231 dump_template_parameter (TREE_VEC_ELT (inner_parms
, i
), flags
);
1233 pp_cxx_end_template_argument_list (cxx_pp
);
1234 pp_cxx_whitespace (cxx_pp
);
1236 nreverse(orig_parms
);
1238 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1240 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1241 pp_cxx_ws_string (cxx_pp
, "class");
1243 /* If this is a parameter pack, print the ellipsis. */
1244 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1245 pp_cxx_ws_string (cxx_pp
, "...");
1249 if (DECL_CLASS_TEMPLATE_P (t
))
1250 dump_type (TREE_TYPE (t
),
1251 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1252 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1253 else if (DECL_TEMPLATE_RESULT (t
)
1254 && (TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == VAR_DECL
1255 /* Alias template. */
1256 || DECL_TYPE_TEMPLATE_P (t
)))
1257 dump_decl (DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1260 gcc_assert (TREE_TYPE (t
));
1261 switch (NEXT_CODE (t
))
1265 dump_function_decl (t
, flags
| TFF_TEMPLATE_NAME
);
1268 /* This case can occur with some invalid code. */
1269 dump_type (TREE_TYPE (t
),
1270 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1271 | (flags
& TFF_DECL_SPECIFIERS
1272 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1277 /* find_typenames looks through the type of the function template T
1278 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1281 struct find_typenames_t
1283 struct pointer_set_t
*p_set
;
1284 vec
<tree
, va_gc
> *typenames
;
1288 find_typenames_r (tree
*tp
, int * /*walk_subtrees*/, void *data
)
1290 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1291 tree mv
= NULL_TREE
;
1293 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1294 /* Add the type of the typedef without any additional cv-quals. */
1295 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1296 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1297 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1298 /* Add the typename without any cv-qualifiers. */
1299 mv
= TYPE_MAIN_VARIANT (*tp
);
1301 if (mv
&& (mv
== *tp
|| !pointer_set_insert (d
->p_set
, mv
)))
1302 vec_safe_push (d
->typenames
, mv
);
1304 /* Search into class template arguments, which cp_walk_subtrees
1306 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1307 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1313 static vec
<tree
, va_gc
> *
1314 find_typenames (tree t
)
1316 struct find_typenames_t ft
;
1317 ft
.p_set
= pointer_set_create ();
1318 ft
.typenames
= NULL
;
1319 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1320 find_typenames_r
, &ft
, ft
.p_set
);
1321 pointer_set_destroy (ft
.p_set
);
1322 return ft
.typenames
;
1325 /* Pretty print a function decl. There are several ways we want to print a
1326 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1327 As error can only apply the '#' flag once to give 0 and 1 for V, there
1328 is %D which doesn't print the throw specs, and %F which does. */
1331 dump_function_decl (tree t
, int flags
)
1335 tree cname
= NULL_TREE
;
1336 tree template_args
= NULL_TREE
;
1337 tree template_parms
= NULL_TREE
;
1338 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1339 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1341 vec
<tree
, va_gc
> *typenames
= NULL
;
1343 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1345 /* A lambda's signature is essentially its "type", so defer. */
1346 gcc_assert (LAMBDA_TYPE_P (DECL_CONTEXT (t
)));
1347 dump_type (DECL_CONTEXT (t
), flags
);
1351 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1352 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1353 t
= DECL_TEMPLATE_RESULT (t
);
1355 /* Save the exceptions, in case t is a specialization and we are
1356 emitting an error about incompatible specifications. */
1357 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1359 /* Pretty print template instantiations only. */
1360 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1361 && flag_pretty_templates
)
1365 template_args
= DECL_TI_ARGS (t
);
1366 tmpl
= most_general_template (t
);
1367 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1369 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1371 typenames
= find_typenames (t
);
1375 fntype
= TREE_TYPE (t
);
1376 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1378 if (DECL_CLASS_SCOPE_P (t
))
1379 cname
= DECL_CONTEXT (t
);
1380 /* This is for partially instantiated template methods. */
1381 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1382 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1384 if (flags
& TFF_DECL_SPECIFIERS
)
1386 if (DECL_STATIC_FUNCTION_P (t
))
1387 pp_cxx_ws_string (cxx_pp
, "static");
1388 else if (DECL_VIRTUAL_P (t
))
1389 pp_cxx_ws_string (cxx_pp
, "virtual");
1391 if (DECL_DECLARED_CONSTEXPR_P (STRIP_TEMPLATE (t
)))
1392 pp_cxx_ws_string (cxx_pp
, "constexpr");
1395 /* Print the return type? */
1397 show_return
= !DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1398 && !DECL_DESTRUCTOR_P (t
);
1400 dump_type_prefix (TREE_TYPE (fntype
), flags
);
1402 /* Print the function name. */
1403 if (!do_outer_scope
)
1407 dump_type (cname
, flags
);
1408 pp_cxx_colon_colon (cxx_pp
);
1411 dump_scope (CP_DECL_CONTEXT (t
), flags
);
1413 dump_function_name (t
, flags
);
1415 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1417 dump_parameters (parmtypes
, flags
);
1419 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1421 pp_base (cxx_pp
)->padding
= pp_before
;
1422 pp_cxx_cv_qualifier_seq (cxx_pp
, class_of_this_parm (fntype
));
1425 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1427 pp_base (cxx_pp
)->padding
= pp_before
;
1428 dump_exception_spec (exceptions
, flags
);
1432 dump_type_suffix (TREE_TYPE (fntype
), flags
);
1434 /* If T is a template instantiation, dump the parameter binding. */
1435 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
)
1437 pp_cxx_whitespace (cxx_pp
);
1438 pp_cxx_left_bracket (cxx_pp
);
1439 pp_cxx_ws_string (cxx_pp
, M_("with"));
1440 pp_cxx_whitespace (cxx_pp
);
1441 dump_template_bindings (template_parms
, template_args
, typenames
);
1442 pp_cxx_right_bracket (cxx_pp
);
1445 else if (template_args
)
1447 bool need_comma
= false;
1449 pp_cxx_begin_template_argument_list (cxx_pp
);
1450 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1451 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1453 tree arg
= TREE_VEC_ELT (template_args
, i
);
1455 pp_separate_with_comma (cxx_pp
);
1456 if (ARGUMENT_PACK_P (arg
))
1457 pp_cxx_left_brace (cxx_pp
);
1458 dump_template_argument (arg
, TFF_PLAIN_IDENTIFIER
);
1459 if (ARGUMENT_PACK_P (arg
))
1460 pp_cxx_right_brace (cxx_pp
);
1463 pp_cxx_end_template_argument_list (cxx_pp
);
1467 /* Print a parameter list. If this is for a member function, the
1468 member object ptr (and any other hidden args) should have
1469 already been removed. */
1472 dump_parameters (tree parmtypes
, int flags
)
1475 flags
&= ~TFF_SCOPE
;
1476 pp_cxx_left_paren (cxx_pp
);
1478 for (first
= 1; parmtypes
!= void_list_node
;
1479 parmtypes
= TREE_CHAIN (parmtypes
))
1482 pp_separate_with_comma (cxx_pp
);
1486 pp_cxx_ws_string (cxx_pp
, "...");
1490 dump_type (TREE_VALUE (parmtypes
), flags
);
1492 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1494 pp_cxx_whitespace (cxx_pp
);
1496 pp_cxx_whitespace (cxx_pp
);
1497 dump_expr (TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1501 pp_cxx_right_paren (cxx_pp
);
1504 /* Print an exception specification. T is the exception specification. */
1507 dump_exception_spec (tree t
, int flags
)
1509 if (t
&& TREE_PURPOSE (t
))
1511 pp_cxx_ws_string (cxx_pp
, "noexcept");
1512 pp_cxx_whitespace (cxx_pp
);
1513 pp_cxx_left_paren (cxx_pp
);
1514 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1515 pp_cxx_ws_string (cxx_pp
, "<uninstantiated>");
1517 dump_expr (TREE_PURPOSE (t
), flags
);
1518 pp_cxx_right_paren (cxx_pp
);
1522 pp_cxx_ws_string (cxx_pp
, "throw");
1523 pp_cxx_whitespace (cxx_pp
);
1524 pp_cxx_left_paren (cxx_pp
);
1525 if (TREE_VALUE (t
) != NULL_TREE
)
1528 dump_type (TREE_VALUE (t
), flags
);
1532 pp_separate_with_comma (cxx_pp
);
1534 pp_cxx_right_paren (cxx_pp
);
1538 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1539 and destructors properly. */
1542 dump_function_name (tree t
, int flags
)
1544 tree name
= DECL_NAME (t
);
1546 /* We can get here with a decl that was synthesized by language-
1547 independent machinery (e.g. coverage.c) in which case it won't
1548 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1549 will crash. In this case it is safe just to print out the
1551 if (!DECL_LANG_SPECIFIC (t
))
1553 pp_cxx_tree_identifier (cxx_pp
, name
);
1557 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1558 t
= DECL_TEMPLATE_RESULT (t
);
1560 /* Don't let the user see __comp_ctor et al. */
1561 if (DECL_CONSTRUCTOR_P (t
)
1562 || DECL_DESTRUCTOR_P (t
))
1564 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1565 name
= get_identifier ("<lambda>");
1566 else if (TYPE_ANONYMOUS_P (DECL_CONTEXT (t
)))
1567 name
= get_identifier ("<constructor>");
1569 name
= constructor_name (DECL_CONTEXT (t
));
1572 if (DECL_DESTRUCTOR_P (t
))
1574 pp_cxx_complement (cxx_pp
);
1575 dump_decl (name
, TFF_PLAIN_IDENTIFIER
);
1577 else if (DECL_CONV_FN_P (t
))
1579 /* This cannot use the hack that the operator's return
1580 type is stashed off of its name because it may be
1581 used for error reporting. In the case of conflicting
1582 declarations, both will have the same name, yet
1583 the types will be different, hence the TREE_TYPE field
1584 of the first name will be clobbered by the second. */
1585 pp_cxx_ws_string (cxx_pp
, "operator");
1586 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1588 else if (name
&& IDENTIFIER_OPNAME_P (name
))
1589 pp_cxx_tree_identifier (cxx_pp
, name
);
1590 else if (name
&& UDLIT_OPER_P (name
))
1591 pp_cxx_tree_identifier (cxx_pp
, name
);
1593 dump_decl (name
, flags
);
1595 if (DECL_TEMPLATE_INFO (t
)
1596 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1597 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1598 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1599 dump_template_parms (DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
), flags
);
1602 /* Dump the template parameters from the template info INFO under control of
1603 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1604 specialization (partial or complete). For partial specializations we show
1605 the specialized parameter values. For a primary template we show no
1609 dump_template_parms (tree info
, int primary
, int flags
)
1611 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1613 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1615 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1616 pp_cxx_begin_template_argument_list (cxx_pp
);
1618 /* Be careful only to print things when we have them, so as not
1619 to crash producing error messages. */
1620 if (args
&& !primary
)
1623 len
= get_non_default_template_args_count (args
, flags
);
1625 args
= INNERMOST_TEMPLATE_ARGS (args
);
1626 for (ix
= 0; ix
!= len
; ix
++)
1628 tree arg
= TREE_VEC_ELT (args
, ix
);
1630 /* Only print a comma if we know there is an argument coming. In
1631 the case of an empty template argument pack, no actual
1632 argument will be printed. */
1634 && (!ARGUMENT_PACK_P (arg
)
1635 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1636 pp_separate_with_comma (cxx_pp
);
1639 pp_string (cxx_pp
, M_("<template parameter error>"));
1641 dump_template_argument (arg
, flags
);
1646 tree tpl
= TI_TEMPLATE (info
);
1647 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1650 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1651 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1653 for (ix
= 0; ix
!= len
; ix
++)
1657 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1659 pp_string (cxx_pp
, M_("<template parameter error>"));
1663 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1666 pp_separate_with_comma (cxx_pp
);
1668 dump_decl (parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1671 pp_cxx_end_template_argument_list (cxx_pp
);
1674 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1675 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1678 dump_call_expr_args (tree t
, int flags
, bool skipfirst
)
1681 call_expr_arg_iterator iter
;
1683 pp_cxx_left_paren (cxx_pp
);
1684 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1690 dump_expr (arg
, flags
| TFF_EXPR_IN_PARENS
);
1691 if (more_call_expr_args_p (&iter
))
1692 pp_separate_with_comma (cxx_pp
);
1695 pp_cxx_right_paren (cxx_pp
);
1698 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1699 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1703 dump_aggr_init_expr_args (tree t
, int flags
, bool skipfirst
)
1706 aggr_init_expr_arg_iterator iter
;
1708 pp_cxx_left_paren (cxx_pp
);
1709 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1715 dump_expr (arg
, flags
| TFF_EXPR_IN_PARENS
);
1716 if (more_aggr_init_expr_args_p (&iter
))
1717 pp_separate_with_comma (cxx_pp
);
1720 pp_cxx_right_paren (cxx_pp
);
1723 /* Print out a list of initializers (subr of dump_expr). */
1726 dump_expr_list (tree l
, int flags
)
1730 dump_expr (TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1733 pp_separate_with_comma (cxx_pp
);
1737 /* Print out a vector of initializers (subr of dump_expr). */
1740 dump_expr_init_vec (vec
<constructor_elt
, va_gc
> *v
, int flags
)
1742 unsigned HOST_WIDE_INT idx
;
1745 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1747 dump_expr (value
, flags
| TFF_EXPR_IN_PARENS
);
1748 if (idx
!= v
->length () - 1)
1749 pp_separate_with_comma (cxx_pp
);
1754 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1755 function. Resolve it to a close relative -- in the sense of static
1756 type -- variant being overridden. That is close to what was written in
1757 the source code. Subroutine of dump_expr. */
1760 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1762 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1763 HOST_WIDE_INT index
= tree_low_cst (OBJ_TYPE_REF_TOKEN (ref
), 1);
1764 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1767 fun
= TREE_CHAIN (fun
);
1768 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1769 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
1775 /* Print out an expression E under control of FLAGS. */
1778 dump_expr (tree t
, int flags
)
1783 if (STATEMENT_CLASS_P (t
))
1785 pp_cxx_ws_string (cxx_pp
, M_("<statement>"));
1789 switch (TREE_CODE (t
))
1797 case NAMESPACE_DECL
:
1801 case IDENTIFIER_NODE
:
1802 dump_decl (t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
1803 |TFF_TEMPLATE_HEADER
))
1804 | TFF_NO_FUNCTION_ARGUMENTS
));
1808 if (SSA_NAME_VAR (t
)
1809 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
1810 dump_expr (SSA_NAME_VAR (t
), flags
);
1812 pp_cxx_ws_string (cxx_pp
, M_("<unknown>"));
1819 pp_constant (cxx_pp
, t
);
1822 case USERDEF_LITERAL
:
1823 pp_cxx_userdef_literal (cxx_pp
, t
);
1827 /* While waiting for caret diagnostics, avoid printing
1828 __cxa_allocate_exception, __cxa_throw, and the like. */
1829 pp_cxx_ws_string (cxx_pp
, M_("<throw-expression>"));
1833 pp_ampersand (cxx_pp
);
1834 dump_type (PTRMEM_CST_CLASS (t
), flags
);
1835 pp_cxx_colon_colon (cxx_pp
);
1836 pp_cxx_tree_identifier (cxx_pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
1840 pp_cxx_left_paren (cxx_pp
);
1841 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1842 pp_separate_with_comma (cxx_pp
);
1843 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1844 pp_cxx_right_paren (cxx_pp
);
1848 pp_cxx_left_paren (cxx_pp
);
1849 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1850 pp_string (cxx_pp
, " ? ");
1851 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1852 pp_string (cxx_pp
, " : ");
1853 dump_expr (TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
1854 pp_cxx_right_paren (cxx_pp
);
1858 if (TREE_HAS_CONSTRUCTOR (t
))
1860 pp_cxx_ws_string (cxx_pp
, "new");
1861 pp_cxx_whitespace (cxx_pp
);
1862 dump_type (TREE_TYPE (TREE_TYPE (t
)), flags
);
1865 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1868 case AGGR_INIT_EXPR
:
1870 tree fn
= NULL_TREE
;
1872 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
1873 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
1875 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
1877 if (DECL_CONSTRUCTOR_P (fn
))
1878 dump_type (DECL_CONTEXT (fn
), flags
);
1883 dump_expr (AGGR_INIT_EXPR_FN (t
), 0);
1885 dump_aggr_init_expr_args (t
, flags
, true);
1890 tree fn
= CALL_EXPR_FN (t
);
1891 bool skipfirst
= false;
1893 if (TREE_CODE (fn
) == ADDR_EXPR
)
1894 fn
= TREE_OPERAND (fn
, 0);
1896 /* Nobody is interested in seeing the guts of vcalls. */
1897 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
1898 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
1900 if (TREE_TYPE (fn
) != NULL_TREE
1901 && NEXT_CODE (fn
) == METHOD_TYPE
1902 && call_expr_nargs (t
))
1904 tree ob
= CALL_EXPR_ARG (t
, 0);
1905 if (TREE_CODE (ob
) == ADDR_EXPR
)
1907 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
1908 pp_cxx_dot (cxx_pp
);
1910 else if (TREE_CODE (ob
) != PARM_DECL
1911 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
1913 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1914 pp_cxx_arrow (cxx_pp
);
1918 dump_expr (fn
, flags
| TFF_EXPR_IN_PARENS
);
1919 dump_call_expr_args (t
, flags
, skipfirst
);
1924 /* Note that this only works for G++ target exprs. If somebody
1925 builds a general TARGET_EXPR, there's no way to represent that
1926 it initializes anything other that the parameter slot for the
1927 default argument. Note we may have cleared out the first
1928 operand in expand_expr, so don't go killing ourselves. */
1929 if (TREE_OPERAND (t
, 1))
1930 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1933 case POINTER_PLUS_EXPR
:
1934 dump_binary_op ("+", t
, flags
);
1939 dump_binary_op (assignment_operator_name_info
[(int)NOP_EXPR
].name
,
1946 case TRUNC_DIV_EXPR
:
1947 case TRUNC_MOD_EXPR
:
1955 case TRUTH_ANDIF_EXPR
:
1956 case TRUTH_ORIF_EXPR
:
1963 case EXACT_DIV_EXPR
:
1964 dump_binary_op (operator_name_info
[(int) TREE_CODE (t
)].name
, t
, flags
);
1968 case FLOOR_DIV_EXPR
:
1969 case ROUND_DIV_EXPR
:
1971 dump_binary_op ("/", t
, flags
);
1975 case FLOOR_MOD_EXPR
:
1976 case ROUND_MOD_EXPR
:
1977 dump_binary_op ("%", t
, flags
);
1982 tree ob
= TREE_OPERAND (t
, 0);
1983 if (TREE_CODE (ob
) == INDIRECT_REF
)
1985 ob
= TREE_OPERAND (ob
, 0);
1986 if (TREE_CODE (ob
) != PARM_DECL
1988 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
1990 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
1991 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
1992 pp_cxx_dot (cxx_pp
);
1994 pp_cxx_arrow (cxx_pp
);
1999 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
2000 pp_cxx_dot (cxx_pp
);
2002 dump_expr (TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2007 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2008 pp_cxx_left_bracket (cxx_pp
);
2009 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2010 pp_cxx_right_bracket (cxx_pp
);
2013 case UNARY_PLUS_EXPR
:
2014 dump_unary_op ("+", t
, flags
);
2018 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2019 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2020 /* An ADDR_EXPR can have reference type. In that case, we
2021 shouldn't print the `&' doing so indicates to the user
2022 that the expression has pointer type. */
2024 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2025 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2026 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2027 dump_unary_op ("&&", t
, flags
);
2029 dump_unary_op ("&", t
, flags
);
2033 if (TREE_HAS_CONSTRUCTOR (t
))
2035 t
= TREE_OPERAND (t
, 0);
2036 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2037 dump_expr (CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2038 dump_call_expr_args (t
, flags
, true);
2042 if (TREE_OPERAND (t
,0) != NULL_TREE
2043 && TREE_TYPE (TREE_OPERAND (t
, 0))
2044 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2045 dump_expr (TREE_OPERAND (t
, 0), flags
);
2047 dump_unary_op ("*", t
, flags
);
2052 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2053 && integer_zerop (TREE_OPERAND (t
, 1)))
2054 dump_expr (TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2057 pp_cxx_star (cxx_pp
);
2058 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2060 pp_cxx_left_paren (cxx_pp
);
2061 if (!integer_onep (TYPE_SIZE_UNIT
2062 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2064 pp_cxx_left_paren (cxx_pp
);
2065 dump_type (ptr_type_node
, flags
);
2066 pp_cxx_right_paren (cxx_pp
);
2069 dump_expr (TREE_OPERAND (t
, 0), flags
);
2070 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2072 pp_cxx_ws_string (cxx_pp
, "+");
2073 dump_expr (fold_convert (ssizetype
, TREE_OPERAND (t
, 1)), flags
);
2074 pp_cxx_right_paren (cxx_pp
);
2081 case TRUTH_NOT_EXPR
:
2082 case PREDECREMENT_EXPR
:
2083 case PREINCREMENT_EXPR
:
2084 dump_unary_op (operator_name_info
[(int)TREE_CODE (t
)].name
, t
, flags
);
2087 case POSTDECREMENT_EXPR
:
2088 case POSTINCREMENT_EXPR
:
2089 pp_cxx_left_paren (cxx_pp
);
2090 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2091 pp_cxx_ws_string (cxx_pp
, operator_name_info
[(int)TREE_CODE (t
)].name
);
2092 pp_cxx_right_paren (cxx_pp
);
2095 case NON_LVALUE_EXPR
:
2096 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2097 should be another level of INDIRECT_REF so that I don't have to do
2099 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2101 tree next
= TREE_TYPE (TREE_TYPE (t
));
2103 while (TREE_CODE (next
) == POINTER_TYPE
)
2104 next
= TREE_TYPE (next
);
2106 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2108 if (flags
& TFF_EXPR_IN_PARENS
)
2109 pp_cxx_left_paren (cxx_pp
);
2110 pp_cxx_star (cxx_pp
);
2111 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2112 if (flags
& TFF_EXPR_IN_PARENS
)
2113 pp_cxx_right_paren (cxx_pp
);
2116 /* Else fall through. */
2118 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2122 case IMPLICIT_CONV_EXPR
:
2123 case VIEW_CONVERT_EXPR
:
2125 tree op
= TREE_OPERAND (t
, 0);
2126 tree ttype
= TREE_TYPE (t
);
2127 tree optype
= TREE_TYPE (op
);
2129 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2130 && POINTER_TYPE_P (ttype
)
2131 && POINTER_TYPE_P (optype
)
2132 && same_type_p (TREE_TYPE (optype
),
2135 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2136 dump_unary_op ("*", t
, flags
);
2138 dump_unary_op ("&", t
, flags
);
2140 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2142 /* It is a cast, but we cannot tell whether it is a
2143 reinterpret or static cast. Use the C style notation. */
2144 if (flags
& TFF_EXPR_IN_PARENS
)
2145 pp_cxx_left_paren (cxx_pp
);
2146 pp_cxx_left_paren (cxx_pp
);
2147 dump_type (TREE_TYPE (t
), flags
);
2148 pp_cxx_right_paren (cxx_pp
);
2149 dump_expr (op
, flags
| TFF_EXPR_IN_PARENS
);
2150 if (flags
& TFF_EXPR_IN_PARENS
)
2151 pp_cxx_right_paren (cxx_pp
);
2154 dump_expr (op
, flags
);
2159 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2161 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2163 if (integer_zerop (idx
))
2165 /* A NULL pointer-to-member constant. */
2166 pp_cxx_left_paren (cxx_pp
);
2167 pp_cxx_left_paren (cxx_pp
);
2168 dump_type (TREE_TYPE (t
), flags
);
2169 pp_cxx_right_paren (cxx_pp
);
2170 pp_character (cxx_pp
, '0');
2171 pp_cxx_right_paren (cxx_pp
);
2174 else if (host_integerp (idx
, 0))
2177 unsigned HOST_WIDE_INT n
;
2179 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2180 t
= TYPE_METHOD_BASETYPE (t
);
2181 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2183 n
= tree_low_cst (idx
, 0);
2185 /* Map vtable index back one, to allow for the null pointer to
2189 while (n
> 0 && virtuals
)
2192 virtuals
= TREE_CHAIN (virtuals
);
2196 dump_expr (BV_FN (virtuals
),
2197 flags
| TFF_EXPR_IN_PARENS
);
2202 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2203 pp_string (cxx_pp
, "<lambda closure object>");
2204 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2206 dump_type (TREE_TYPE (t
), 0);
2207 pp_cxx_left_paren (cxx_pp
);
2208 pp_cxx_right_paren (cxx_pp
);
2212 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2213 dump_type (TREE_TYPE (t
), 0);
2214 pp_cxx_left_brace (cxx_pp
);
2215 dump_expr_init_vec (CONSTRUCTOR_ELTS (t
), flags
);
2216 pp_cxx_right_brace (cxx_pp
);
2223 tree ob
= TREE_OPERAND (t
, 0);
2224 if (is_dummy_object (ob
))
2226 t
= TREE_OPERAND (t
, 1);
2227 if (TREE_CODE (t
) == FUNCTION_DECL
)
2229 dump_expr (t
, flags
| TFF_EXPR_IN_PARENS
);
2230 else if (BASELINK_P (t
))
2231 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
2232 flags
| TFF_EXPR_IN_PARENS
);
2234 dump_decl (t
, flags
);
2238 if (TREE_CODE (ob
) == INDIRECT_REF
)
2240 dump_expr (TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2241 pp_cxx_arrow (cxx_pp
);
2242 pp_cxx_star (cxx_pp
);
2246 dump_expr (ob
, flags
| TFF_EXPR_IN_PARENS
);
2247 pp_cxx_dot (cxx_pp
);
2248 pp_cxx_star (cxx_pp
);
2250 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2255 case TEMPLATE_PARM_INDEX
:
2256 dump_decl (TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2260 if (TREE_OPERAND (t
, 0) == NULL_TREE
2261 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2263 dump_type (TREE_TYPE (t
), flags
);
2264 pp_cxx_left_paren (cxx_pp
);
2265 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
2266 pp_cxx_right_paren (cxx_pp
);
2270 pp_cxx_left_paren (cxx_pp
);
2271 dump_type (TREE_TYPE (t
), flags
);
2272 pp_cxx_right_paren (cxx_pp
);
2273 pp_cxx_left_paren (cxx_pp
);
2274 dump_expr_list (TREE_OPERAND (t
, 0), flags
);
2275 pp_cxx_right_paren (cxx_pp
);
2279 case STATIC_CAST_EXPR
:
2280 pp_cxx_ws_string (cxx_pp
, "static_cast");
2282 case REINTERPRET_CAST_EXPR
:
2283 pp_cxx_ws_string (cxx_pp
, "reinterpret_cast");
2285 case CONST_CAST_EXPR
:
2286 pp_cxx_ws_string (cxx_pp
, "const_cast");
2288 case DYNAMIC_CAST_EXPR
:
2289 pp_cxx_ws_string (cxx_pp
, "dynamic_cast");
2291 pp_cxx_begin_template_argument_list (cxx_pp
);
2292 dump_type (TREE_TYPE (t
), flags
);
2293 pp_cxx_end_template_argument_list (cxx_pp
);
2294 pp_cxx_left_paren (cxx_pp
);
2295 dump_expr (TREE_OPERAND (t
, 0), flags
);
2296 pp_cxx_right_paren (cxx_pp
);
2300 dump_expr (TREE_OPERAND (t
, 0), flags
);
2301 pp_cxx_arrow (cxx_pp
);
2306 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2307 pp_cxx_ws_string (cxx_pp
, "sizeof");
2310 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2311 pp_cxx_ws_string (cxx_pp
, "__alignof__");
2313 pp_cxx_whitespace (cxx_pp
);
2314 pp_cxx_left_paren (cxx_pp
);
2315 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2316 dump_type (TREE_TYPE (TREE_OPERAND (t
, 0)), flags
);
2317 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2318 dump_type (TREE_OPERAND (t
, 0), flags
);
2320 dump_expr (TREE_OPERAND (t
, 0), flags
);
2321 pp_cxx_right_paren (cxx_pp
);
2324 case AT_ENCODE_EXPR
:
2325 pp_cxx_ws_string (cxx_pp
, "@encode");
2326 pp_cxx_whitespace (cxx_pp
);
2327 pp_cxx_left_paren (cxx_pp
);
2328 dump_type (TREE_OPERAND (t
, 0), flags
);
2329 pp_cxx_right_paren (cxx_pp
);
2333 pp_cxx_ws_string (cxx_pp
, "noexcept");
2334 pp_cxx_whitespace (cxx_pp
);
2335 pp_cxx_left_paren (cxx_pp
);
2336 dump_expr (TREE_OPERAND (t
, 0), flags
);
2337 pp_cxx_right_paren (cxx_pp
);
2342 pp_cxx_ws_string (cxx_pp
, operator_name_info
[TREE_CODE (t
)].name
);
2343 pp_cxx_whitespace (cxx_pp
);
2344 dump_expr (TREE_OPERAND (t
, 0), flags
);
2348 pp_string (cxx_pp
, M_("<unparsed>"));
2351 case TRY_CATCH_EXPR
:
2352 case WITH_CLEANUP_EXPR
:
2353 case CLEANUP_POINT_EXPR
:
2354 dump_expr (TREE_OPERAND (t
, 0), flags
);
2357 case PSEUDO_DTOR_EXPR
:
2358 dump_expr (TREE_OPERAND (t
, 2), flags
);
2359 pp_cxx_dot (cxx_pp
);
2360 dump_type (TREE_OPERAND (t
, 0), flags
);
2361 pp_cxx_colon_colon (cxx_pp
);
2362 pp_cxx_complement (cxx_pp
);
2363 dump_type (TREE_OPERAND (t
, 1), flags
);
2366 case TEMPLATE_ID_EXPR
:
2367 dump_decl (t
, flags
);
2373 case STATEMENT_LIST
:
2374 /* We don't yet have a way of dumping statements in a
2375 human-readable format. */
2376 pp_string (cxx_pp
, "({...})");
2380 pp_string (cxx_pp
, "while (1) { ");
2381 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2382 pp_cxx_right_brace (cxx_pp
);
2386 pp_string (cxx_pp
, "if (");
2387 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2388 pp_string (cxx_pp
, ") break; ");
2392 dump_expr (BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2395 case EMPTY_CLASS_EXPR
:
2396 dump_type (TREE_TYPE (t
), flags
);
2397 pp_cxx_left_paren (cxx_pp
);
2398 pp_cxx_right_paren (cxx_pp
);
2401 case NON_DEPENDENT_EXPR
:
2402 dump_expr (TREE_OPERAND (t
, 0), flags
);
2405 case ARGUMENT_PACK_SELECT
:
2406 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2418 pp_type_specifier_seq (cxx_pp
, t
);
2422 /* We get here when we want to print a dependent type as an
2423 id-expression, without any disambiguator decoration. */
2424 pp_id_expression (cxx_pp
, t
);
2427 case TEMPLATE_TYPE_PARM
:
2428 case TEMPLATE_TEMPLATE_PARM
:
2429 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2430 dump_type (t
, flags
);
2434 pp_cxx_trait_expression (cxx_pp
, t
);
2438 pp_cxx_va_arg_expression (cxx_pp
, t
);
2442 pp_cxx_offsetof_expression (cxx_pp
, t
);
2446 dump_decl (t
, flags
);
2449 case EXPR_PACK_EXPANSION
:
2456 case VEC_DELETE_EXPR
:
2462 case UNORDERED_EXPR
:
2472 case FIX_TRUNC_EXPR
:
2474 pp_expression (cxx_pp
, t
);
2477 case TRUTH_AND_EXPR
:
2479 case TRUTH_XOR_EXPR
:
2480 if (flags
& TFF_EXPR_IN_PARENS
)
2481 pp_cxx_left_paren (cxx_pp
);
2482 pp_expression (cxx_pp
, t
);
2483 if (flags
& TFF_EXPR_IN_PARENS
)
2484 pp_cxx_right_paren (cxx_pp
);
2488 dump_expr (resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2491 /* This list is incomplete, but should suffice for now.
2492 It is very important that `sorry' does not call
2493 `report_error_function'. That could cause an infinite loop. */
2495 pp_unsupported_tree (cxx_pp
, t
);
2496 /* fall through to ERROR_MARK... */
2498 pp_string (cxx_pp
, M_("<expression error>"));
2504 dump_binary_op (const char *opstring
, tree t
, int flags
)
2506 pp_cxx_left_paren (cxx_pp
);
2507 dump_expr (TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2508 pp_cxx_whitespace (cxx_pp
);
2510 pp_cxx_ws_string (cxx_pp
, opstring
);
2512 pp_string (cxx_pp
, M_("<unknown operator>"));
2513 pp_cxx_whitespace (cxx_pp
);
2514 dump_expr (TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2515 pp_cxx_right_paren (cxx_pp
);
2519 dump_unary_op (const char *opstring
, tree t
, int flags
)
2521 if (flags
& TFF_EXPR_IN_PARENS
)
2522 pp_cxx_left_paren (cxx_pp
);
2523 pp_cxx_ws_string (cxx_pp
, opstring
);
2524 dump_expr (TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2525 if (flags
& TFF_EXPR_IN_PARENS
)
2526 pp_cxx_right_paren (cxx_pp
);
2530 reinit_cxx_pp (void)
2532 pp_clear_output_area (cxx_pp
);
2533 pp_base (cxx_pp
)->padding
= pp_none
;
2534 pp_indentation (cxx_pp
) = 0;
2535 pp_needs_newline (cxx_pp
) = false;
2536 cxx_pp
->enclosing_scope
= current_function_decl
;
2540 /* Exported interface to stringifying types, exprs and decls under TFF_*
2544 type_as_string (tree typ
, int flags
)
2547 pp_translate_identifiers (cxx_pp
) = false;
2548 dump_type (typ
, flags
);
2549 return pp_formatted_text (cxx_pp
);
2553 type_as_string_translate (tree typ
, int flags
)
2556 dump_type (typ
, flags
);
2557 return pp_formatted_text (cxx_pp
);
2561 expr_as_string (tree decl
, int flags
)
2564 pp_translate_identifiers (cxx_pp
) = false;
2565 dump_expr (decl
, flags
);
2566 return pp_formatted_text (cxx_pp
);
2569 /* Wrap decl_as_string with options appropriate for dwarf. */
2572 decl_as_dwarf_string (tree decl
, int flags
)
2575 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2576 here will be adequate to get the desired behaviour. */
2577 pp_c_base (cxx_pp
)->flags
|= pp_c_flag_gnu_v3
;
2578 name
= decl_as_string (decl
, flags
);
2579 /* Subsequent calls to the pretty printer shouldn't use this style. */
2580 pp_c_base (cxx_pp
)->flags
&= ~pp_c_flag_gnu_v3
;
2585 decl_as_string (tree decl
, int flags
)
2588 pp_translate_identifiers (cxx_pp
) = false;
2589 dump_decl (decl
, flags
);
2590 return pp_formatted_text (cxx_pp
);
2594 decl_as_string_translate (tree decl
, int flags
)
2597 dump_decl (decl
, flags
);
2598 return pp_formatted_text (cxx_pp
);
2601 /* Wrap lang_decl_name with options appropriate for dwarf. */
2604 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2607 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2608 here will be adequate to get the desired behaviour. */
2609 pp_c_base (cxx_pp
)->flags
|= pp_c_flag_gnu_v3
;
2610 name
= lang_decl_name (decl
, v
, translate
);
2611 /* Subsequent calls to the pretty printer shouldn't use this style. */
2612 pp_c_base (cxx_pp
)->flags
&= ~pp_c_flag_gnu_v3
;
2616 /* Generate the three forms of printable names for cxx_printable_name. */
2619 lang_decl_name (tree decl
, int v
, bool translate
)
2623 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2624 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2627 pp_translate_identifiers (cxx_pp
) = translate
;
2629 && (DECL_CLASS_SCOPE_P (decl
)
2630 || (DECL_NAMESPACE_SCOPE_P (decl
)
2631 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2633 dump_type (CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2634 pp_cxx_colon_colon (cxx_pp
);
2637 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2638 dump_function_name (decl
, TFF_PLAIN_IDENTIFIER
);
2639 else if ((DECL_NAME (decl
) == NULL_TREE
)
2640 && TREE_CODE (decl
) == NAMESPACE_DECL
)
2641 dump_decl (decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
2643 dump_decl (DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2645 return pp_formatted_text (cxx_pp
);
2648 /* Return the location of a tree passed to %+ formats. */
2651 location_of (tree t
)
2653 if (TREE_CODE (t
) == PARM_DECL
&& DECL_CONTEXT (t
))
2654 t
= DECL_CONTEXT (t
);
2655 else if (TYPE_P (t
))
2657 t
= TYPE_MAIN_DECL (t
);
2659 return input_location
;
2661 else if (TREE_CODE (t
) == OVERLOAD
)
2662 t
= OVL_FUNCTION (t
);
2665 return DECL_SOURCE_LOCATION (t
);
2666 return EXPR_LOC_OR_HERE (t
);
2669 /* Now the interfaces from error et al to dump_type et al. Each takes an
2670 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2674 decl_to_string (tree decl
, int verbose
)
2678 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2679 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2680 flags
= TFF_CLASS_KEY_OR_ENUM
;
2682 flags
|= TFF_DECL_SPECIFIERS
;
2683 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2684 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2685 flags
|= TFF_TEMPLATE_HEADER
;
2688 dump_decl (decl
, flags
);
2689 return pp_formatted_text (cxx_pp
);
2693 expr_to_string (tree decl
)
2696 dump_expr (decl
, 0);
2697 return pp_formatted_text (cxx_pp
);
2701 fndecl_to_string (tree fndecl
, int verbose
)
2705 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
2706 | TFF_TEMPLATE_HEADER
;
2708 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
2710 dump_decl (fndecl
, flags
);
2711 return pp_formatted_text (cxx_pp
);
2716 code_to_string (enum tree_code c
)
2718 return tree_code_name
[c
];
2722 language_to_string (enum languages c
)
2729 case lang_cplusplus
:
2741 /* Return the proper printed version of a parameter to a C++ function. */
2744 parm_to_string (int p
)
2748 pp_string (cxx_pp
, "'this'");
2750 pp_decimal_int (cxx_pp
, p
+ 1);
2751 return pp_formatted_text (cxx_pp
);
2755 op_to_string (enum tree_code p
)
2757 tree id
= operator_name_info
[(int) p
].identifier
;
2758 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
2762 type_to_string (tree typ
, int verbose
)
2766 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2767 flags
|= TFF_TEMPLATE_HEADER
;
2770 dump_type (typ
, flags
);
2771 /* If we're printing a type that involves typedefs, also print the
2772 stripped version. But sometimes the stripped version looks
2773 exactly the same, so we don't want it after all. To avoid printing
2774 it in that case, we play ugly obstack games. */
2775 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
2776 && !uses_template_parms (typ
))
2778 int aka_start
; char *p
;
2779 struct obstack
*ob
= pp_base (cxx_pp
)->buffer
->obstack
;
2780 /* Remember the end of the initial dump. */
2781 int len
= obstack_object_size (ob
);
2782 tree aka
= strip_typedefs (typ
);
2783 pp_string (cxx_pp
, " {aka");
2784 pp_cxx_whitespace (cxx_pp
);
2785 /* And remember the start of the aka dump. */
2786 aka_start
= obstack_object_size (ob
);
2787 dump_type (aka
, flags
);
2788 pp_character (cxx_pp
, '}');
2789 p
= (char*)obstack_base (ob
);
2790 /* If they are identical, cut off the aka with a NUL. */
2791 if (memcmp (p
, p
+aka_start
, len
) == 0)
2794 return pp_formatted_text (cxx_pp
);
2798 assop_to_string (enum tree_code p
)
2800 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
2801 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
2805 args_to_string (tree p
, int verbose
)
2809 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2814 if (TYPE_P (TREE_VALUE (p
)))
2815 return type_as_string_translate (p
, flags
);
2818 for (; p
; p
= TREE_CHAIN (p
))
2820 if (TREE_VALUE (p
) == null_node
)
2821 pp_cxx_ws_string (cxx_pp
, "NULL");
2823 dump_type (error_type (TREE_VALUE (p
)), flags
);
2825 pp_separate_with_comma (cxx_pp
);
2827 return pp_formatted_text (cxx_pp
);
2830 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
2831 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
2835 subst_to_string (tree p
)
2837 tree decl
= TREE_PURPOSE (p
);
2838 tree targs
= TREE_VALUE (p
);
2839 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
2840 int flags
= TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
;
2846 dump_template_decl (TREE_PURPOSE (p
), flags
);
2847 pp_cxx_whitespace (cxx_pp
);
2848 pp_cxx_left_bracket (cxx_pp
);
2849 pp_cxx_ws_string (cxx_pp
, M_("with"));
2850 pp_cxx_whitespace (cxx_pp
);
2851 dump_template_bindings (tparms
, targs
, NULL
);
2852 pp_cxx_right_bracket (cxx_pp
);
2853 return pp_formatted_text (cxx_pp
);
2857 cv_to_string (tree p
, int v
)
2860 pp_base (cxx_pp
)->padding
= v
? pp_before
: pp_none
;
2861 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
2862 return pp_formatted_text (cxx_pp
);
2865 /* Langhook for print_error_function. */
2867 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
2868 diagnostic_info
*diagnostic
)
2870 lhd_print_error_function (context
, file
, diagnostic
);
2871 pp_base_set_prefix (context
->printer
, file
);
2872 maybe_print_instantiation_context (context
);
2876 cp_diagnostic_starter (diagnostic_context
*context
,
2877 diagnostic_info
*diagnostic
)
2879 diagnostic_report_current_module (context
, diagnostic
->location
);
2880 cp_print_error_function (context
, diagnostic
);
2881 maybe_print_instantiation_context (context
);
2882 maybe_print_constexpr_context (context
);
2883 pp_base_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
2888 cp_diagnostic_finalizer (diagnostic_context
*context
,
2889 diagnostic_info
*diagnostic
)
2891 virt_loc_aware_diagnostic_finalizer (context
, diagnostic
);
2892 pp_base_destroy_prefix (context
->printer
);
2895 /* Print current function onto BUFFER, in the process of reporting
2896 a diagnostic message. Called from cp_diagnostic_starter. */
2898 cp_print_error_function (diagnostic_context
*context
,
2899 diagnostic_info
*diagnostic
)
2901 /* If we are in an instantiation context, current_function_decl is likely
2902 to be wrong, so just rely on print_instantiation_full_context. */
2903 if (current_instantiation ())
2905 if (diagnostic_last_function_changed (context
, diagnostic
))
2907 const char *old_prefix
= context
->printer
->prefix
;
2908 const char *file
= LOCATION_FILE (diagnostic
->location
);
2909 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
2910 char *new_prefix
= (file
&& abstract_origin
== NULL
)
2911 ? file_name_as_prefix (file
) : NULL
;
2913 pp_base_set_prefix (context
->printer
, new_prefix
);
2915 if (current_function_decl
== NULL
)
2916 pp_base_string (context
->printer
, _("At global scope:"));
2921 if (abstract_origin
)
2923 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
2924 while (TREE_CODE (ao
) == BLOCK
2925 && BLOCK_ABSTRACT_ORIGIN (ao
)
2926 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
2927 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
2928 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
2932 fndecl
= current_function_decl
;
2934 pp_printf (context
->printer
, function_category (fndecl
),
2935 cxx_printable_name_translate (fndecl
, 2));
2937 while (abstract_origin
)
2940 tree block
= abstract_origin
;
2942 locus
= &BLOCK_SOURCE_LOCATION (block
);
2944 block
= BLOCK_SUPERCONTEXT (block
);
2945 while (block
&& TREE_CODE (block
) == BLOCK
2946 && BLOCK_ABSTRACT_ORIGIN (block
))
2948 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
2950 while (TREE_CODE (ao
) == BLOCK
2951 && BLOCK_ABSTRACT_ORIGIN (ao
)
2952 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
2953 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
2955 if (TREE_CODE (ao
) == FUNCTION_DECL
)
2960 else if (TREE_CODE (ao
) != BLOCK
)
2963 block
= BLOCK_SUPERCONTEXT (block
);
2966 abstract_origin
= block
;
2969 while (block
&& TREE_CODE (block
) == BLOCK
)
2970 block
= BLOCK_SUPERCONTEXT (block
);
2972 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
2974 abstract_origin
= NULL
;
2978 expanded_location s
= expand_location (*locus
);
2979 pp_base_character (context
->printer
, ',');
2980 pp_base_newline (context
->printer
);
2983 if (context
->show_column
&& s
.column
!= 0)
2984 pp_printf (context
->printer
,
2985 _(" inlined from %qs at %s:%d:%d"),
2986 cxx_printable_name_translate (fndecl
, 2),
2987 s
.file
, s
.line
, s
.column
);
2989 pp_printf (context
->printer
,
2990 _(" inlined from %qs at %s:%d"),
2991 cxx_printable_name_translate (fndecl
, 2),
2996 pp_printf (context
->printer
, _(" inlined from %qs"),
2997 cxx_printable_name_translate (fndecl
, 2));
3000 pp_base_character (context
->printer
, ':');
3002 pp_base_newline (context
->printer
);
3004 diagnostic_set_last_function (context
, diagnostic
);
3005 pp_base_destroy_prefix (context
->printer
);
3006 context
->printer
->prefix
= old_prefix
;
3010 /* Returns a description of FUNCTION using standard terminology. The
3011 result is a format string of the form "In CATEGORY %qs". */
3013 function_category (tree fn
)
3015 /* We can get called from the middle-end for diagnostics of function
3016 clones. Make sure we have language specific information before
3017 dereferencing it. */
3018 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3019 && DECL_FUNCTION_MEMBER_P (fn
))
3021 if (DECL_STATIC_FUNCTION_P (fn
))
3022 return _("In static member function %qs");
3023 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3024 return _("In copy constructor %qs");
3025 else if (DECL_CONSTRUCTOR_P (fn
))
3026 return _("In constructor %qs");
3027 else if (DECL_DESTRUCTOR_P (fn
))
3028 return _("In destructor %qs");
3029 else if (LAMBDA_FUNCTION_P (fn
))
3030 return _("In lambda function");
3032 return _("In member function %qs");
3035 return _("In function %qs");
3038 /* Report the full context of a current template instantiation,
3041 print_instantiation_full_context (diagnostic_context
*context
)
3043 struct tinst_level
*p
= current_instantiation ();
3044 location_t location
= input_location
;
3048 pp_verbatim (context
->printer
,
3049 TREE_CODE (p
->decl
) == TREE_LIST
3050 ? _("%s: In substitution of %qS:\n")
3051 : _("%s: In instantiation of %q#D:\n"),
3052 LOCATION_FILE (location
),
3055 location
= p
->locus
;
3059 print_instantiation_partial_context (context
, p
, location
);
3062 /* Helper function of print_instantiation_partial_context() that
3063 prints a single line of instantiation context. */
3066 print_instantiation_partial_context_line (diagnostic_context
*context
,
3067 const struct tinst_level
*t
,
3068 location_t loc
, bool recursive_p
)
3070 expanded_location xloc
;
3071 xloc
= expand_location (loc
);
3073 if (context
->show_column
)
3074 pp_verbatim (context
->printer
, _("%s:%d:%d: "),
3075 xloc
.file
, xloc
.line
, xloc
.column
);
3077 pp_verbatim (context
->printer
, _("%s:%d: "),
3078 xloc
.file
, xloc
.line
);
3082 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3083 pp_verbatim (context
->printer
,
3085 ? _("recursively required by substitution of %qS\n")
3086 : _("required by substitution of %qS\n"),
3089 pp_verbatim (context
->printer
,
3091 ? _("recursively required from %q#D\n")
3092 : _("required from %q#D\n"),
3097 pp_verbatim (context
->printer
,
3099 ? _("recursively required from here")
3100 : _("required from here"));
3104 /* Same as print_instantiation_full_context but less verbose. */
3107 print_instantiation_partial_context (diagnostic_context
*context
,
3108 struct tinst_level
*t0
, location_t loc
)
3110 struct tinst_level
*t
;
3113 location_t prev_loc
= loc
;
3115 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3116 if (prev_loc
!= t
->locus
)
3118 prev_loc
= t
->locus
;
3124 if (template_backtrace_limit
3125 && n_total
> template_backtrace_limit
)
3127 int skip
= n_total
- template_backtrace_limit
;
3128 int head
= template_backtrace_limit
/ 2;
3130 /* Avoid skipping just 1. If so, skip 2. */
3134 head
= (template_backtrace_limit
- 1) / 2;
3137 for (n
= 0; n
< head
; n
++)
3139 gcc_assert (t
!= NULL
);
3140 if (loc
!= t
->locus
)
3141 print_instantiation_partial_context_line (context
, t
, loc
,
3142 /*recursive_p=*/false);
3146 if (t
!= NULL
&& skip
> 0)
3148 expanded_location xloc
;
3149 xloc
= expand_location (loc
);
3150 if (context
->show_column
)
3151 pp_verbatim (context
->printer
,
3152 _("%s:%d:%d: [ skipping %d instantiation contexts, "
3153 "use -ftemplate-backtrace-limit=0 to disable ]\n"),
3154 xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3156 pp_verbatim (context
->printer
,
3157 _("%s:%d: [ skipping %d instantiation contexts, "
3158 "use -ftemplate-backtrace-limit=0 to disable ]\n"),
3159 xloc
.file
, xloc
.line
, skip
);
3164 } while (t
!= NULL
&& --skip
> 0);
3170 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3175 print_instantiation_partial_context_line (context
, t
, loc
,
3180 print_instantiation_partial_context_line (context
, NULL
, loc
,
3181 /*recursive_p=*/false);
3182 pp_base_newline (context
->printer
);
3185 /* Called from cp_thing to print the template context for an error. */
3187 maybe_print_instantiation_context (diagnostic_context
*context
)
3189 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3192 record_last_problematic_instantiation ();
3193 print_instantiation_full_context (context
);
3196 /* Report the bare minimum context of a template instantiation. */
3198 print_instantiation_context (void)
3200 print_instantiation_partial_context
3201 (global_dc
, current_instantiation (), input_location
);
3202 pp_base_newline (global_dc
->printer
);
3203 diagnostic_flush_buffer (global_dc
);
3206 /* Report what constexpr call(s) we're trying to expand, if any. */
3209 maybe_print_constexpr_context (diagnostic_context
*context
)
3211 vec
<tree
> call_stack
= cx_error_context ();
3215 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3217 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3218 const char *s
= expr_as_string (t
, 0);
3219 if (context
->show_column
)
3220 pp_verbatim (context
->printer
,
3221 _("%s:%d:%d: in constexpr expansion of %qs"),
3222 xloc
.file
, xloc
.line
, xloc
.column
, s
);
3224 pp_verbatim (context
->printer
,
3225 _("%s:%d: in constexpr expansion of %qs"),
3226 xloc
.file
, xloc
.line
, s
);
3227 pp_base_newline (context
->printer
);
3231 /* Called from output_format -- during diagnostic message processing --
3232 to handle C++ specific format specifier with the following meanings:
3233 %A function argument-list.
3237 %F function declaration.
3238 %L language as used in extern "lang".
3240 %P function parameter whose position is indicated by an integer.
3241 %Q assignment operator.
3245 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
3246 int precision
, bool wide
, bool set_locus
, bool verbose
)
3250 #define next_tree (t = va_arg (*text->args_ptr, tree))
3251 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3252 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3253 #define next_int va_arg (*text->args_ptr, int)
3255 if (precision
!= 0 || wide
)
3258 if (text
->locus
== NULL
)
3263 case 'A': result
= args_to_string (next_tree
, verbose
); break;
3264 case 'C': result
= code_to_string (next_tcode
); break;
3267 tree temp
= next_tree
;
3269 && DECL_DEBUG_EXPR_IS_FROM (temp
) && DECL_DEBUG_EXPR (temp
))
3271 temp
= DECL_DEBUG_EXPR (temp
);
3274 result
= expr_to_string (temp
);
3278 result
= decl_to_string (temp
, verbose
);
3281 case 'E': result
= expr_to_string (next_tree
); break;
3282 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
3283 case 'L': result
= language_to_string (next_lang
); break;
3284 case 'O': result
= op_to_string (next_tcode
); break;
3285 case 'P': result
= parm_to_string (next_int
); break;
3286 case 'Q': result
= assop_to_string (next_tcode
); break;
3287 case 'S': result
= subst_to_string (next_tree
); break;
3288 case 'T': result
= type_to_string (next_tree
, verbose
); break;
3289 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
3292 percent_K_format (text
);
3299 pp_base_string (pp
, result
);
3300 if (set_locus
&& t
!= NULL
)
3301 *text
->locus
= location_of (t
);
3309 /* Warn about the use of C++0x features when appropriate. */
3311 maybe_warn_cpp0x (cpp0x_warn_str str
)
3313 if ((cxx_dialect
== cxx98
) && !in_system_header
)
3314 /* We really want to suppress this warning in system headers,
3315 because libstdc++ uses variadic templates even when we aren't
3319 case CPP0X_INITIALIZER_LISTS
:
3320 pedwarn (input_location
, 0,
3321 "extended initializer lists "
3322 "only available with -std=c++11 or -std=gnu++11");
3324 case CPP0X_EXPLICIT_CONVERSION
:
3325 pedwarn (input_location
, 0,
3326 "explicit conversion operators "
3327 "only available with -std=c++11 or -std=gnu++11");
3329 case CPP0X_VARIADIC_TEMPLATES
:
3330 pedwarn (input_location
, 0,
3331 "variadic templates "
3332 "only available with -std=c++11 or -std=gnu++11");
3334 case CPP0X_LAMBDA_EXPR
:
3335 pedwarn (input_location
, 0,
3336 "lambda expressions "
3337 "only available with -std=c++11 or -std=gnu++11");
3340 pedwarn (input_location
, 0,
3341 "C++0x auto only available with -std=c++11 or -std=gnu++11");
3343 case CPP0X_SCOPED_ENUMS
:
3344 pedwarn (input_location
, 0,
3345 "scoped enums only available with -std=c++11 or -std=gnu++11");
3347 case CPP0X_DEFAULTED_DELETED
:
3348 pedwarn (input_location
, 0,
3349 "defaulted and deleted functions "
3350 "only available with -std=c++11 or -std=gnu++11");
3352 case CPP0X_INLINE_NAMESPACES
:
3353 pedwarn (input_location
, OPT_Wpedantic
,
3354 "inline namespaces "
3355 "only available with -std=c++11 or -std=gnu++11");
3357 case CPP0X_OVERRIDE_CONTROLS
:
3358 pedwarn (input_location
, 0,
3359 "override controls (override/final) "
3360 "only available with -std=c++11 or -std=gnu++11");
3363 pedwarn (input_location
, 0,
3364 "non-static data member initializers "
3365 "only available with -std=c++11 or -std=gnu++11");
3367 case CPP0X_USER_DEFINED_LITERALS
:
3368 pedwarn (input_location
, 0,
3369 "user-defined literals "
3370 "only available with -std=c++11 or -std=gnu++11");
3372 case CPP0X_DELEGATING_CTORS
:
3373 pedwarn (input_location
, 0,
3374 "delegating constructors "
3375 "only available with -std=c++11 or -std=gnu++11");
3377 case CPP0X_INHERITING_CTORS
:
3378 pedwarn (input_location
, 0,
3379 "inheriting constructors "
3380 "only available with -std=c++11 or -std=gnu++11");
3382 case CPP0X_ATTRIBUTES
:
3383 pedwarn (input_location
, 0,
3385 "only available with -std=c++11 or -std=gnu++11");
3392 /* Warn about the use of variadic templates when appropriate. */
3394 maybe_warn_variadic_templates (void)
3396 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
3400 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3401 option OPT with text GMSGID. Use this function to report
3402 diagnostics for constructs that are invalid C++98, but valid
3405 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
3407 diagnostic_info diagnostic
;
3411 va_start (ap
, gmsgid
);
3412 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, location
,
3413 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
3414 diagnostic
.option_index
= opt
;
3415 ret
= report_diagnostic (&diagnostic
);
3420 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3421 we found when we tried to do the lookup. LOCATION is the location of
3422 the NAME identifier. */
3425 qualified_name_lookup_error (tree scope
, tree name
,
3426 tree decl
, location_t location
)
3428 if (scope
== error_mark_node
)
3429 ; /* We already complained. */
3430 else if (TYPE_P (scope
))
3432 if (!COMPLETE_TYPE_P (scope
))
3433 error_at (location
, "incomplete type %qT used in nested name specifier",
3435 else if (TREE_CODE (decl
) == TREE_LIST
)
3437 error_at (location
, "reference to %<%T::%D%> is ambiguous",
3439 print_candidates (decl
);
3442 error_at (location
, "%qD is not a member of %qT", name
, scope
);
3444 else if (scope
!= global_namespace
)
3446 error_at (location
, "%qD is not a member of %qD", name
, scope
);
3447 suggest_alternatives_for (location
, name
);
3451 error_at (location
, "%<::%D%> has not been declared", name
);
3452 suggest_alternatives_for (location
, name
);
