Google Git
Sign in
gnu / gcc / refs/tags/basepoints/gcc-13 / . / gcc / cp / error.cc
blob: 1e944ca3f750a16412d04d216a86a454a473e49e [file] [log] [blame]
/* Call-backs for C++ error reporting.
This code is non-reentrant.
Copyright (C) 1993-2022 Free Software Foundation, Inc.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
#include "config.h"
/* For use with name_hint. */
#define INCLUDE_MEMORY
#include "system.h"
#include "coretypes.h"
#include "cp-tree.h"
#include "stringpool.h"
#include "tree-diagnostic.h"
#include "langhooks-def.h"
#include "intl.h"
#include "cxx-pretty-print.h"
#include "tree-pretty-print.h"
#include "gimple-pretty-print.h"
#include "c-family/c-objc.h"
#include "ubsan.h"
#include "internal-fn.h"
#include "gcc-rich-location.h"
#include "cp-name-hint.h"
#define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
#define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
/* cxx_pp is a C++ front-end-specific pretty printer: this is where we
dump C++ ASTs as strings. It is mostly used only by the various
tree -> string functions that are occasionally called from the
debugger or by the front-end for things like
__PRETTY_FUNCTION__. */
static cxx_pretty_printer actual_pretty_printer;
static cxx_pretty_printer * const cxx_pp = &actual_pretty_printer;
/* Translate if being used for diagnostics, but not for dump files or
__PRETTY_FUNCTION. */
#define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
# define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
static const char *args_to_string (tree, int);
static const char *code_to_string (enum tree_code);
static const char *cv_to_string (tree, int);
static const char *decl_to_string (tree, int);
static const char *fndecl_to_string (tree, int);
static const char *op_to_string (bool, enum tree_code);
static const char *parm_to_string (int);
static const char *type_to_string (tree, int, bool, bool *, bool);
static void dump_alias_template_specialization (cxx_pretty_printer *, tree, int);
static void dump_type (cxx_pretty_printer *, tree, int);
static void dump_typename (cxx_pretty_printer *, tree, int);
static void dump_simple_decl (cxx_pretty_printer *, tree, tree, int);
static void dump_decl (cxx_pretty_printer *, tree, int);
static void dump_template_decl (cxx_pretty_printer *, tree, int);
static void dump_function_decl (cxx_pretty_printer *, tree, int);
static void dump_expr (cxx_pretty_printer *, tree, int);
static void dump_unary_op (cxx_pretty_printer *, const char *, tree, int);
static void dump_binary_op (cxx_pretty_printer *, const char *, tree, int);
static void dump_aggr_type (cxx_pretty_printer *, tree, int);
static void dump_type_prefix (cxx_pretty_printer *, tree, int);
static void dump_type_suffix (cxx_pretty_printer *, tree, int);
static void dump_function_name (cxx_pretty_printer *, tree, int);
static void dump_call_expr_args (cxx_pretty_printer *, tree, int, bool);
static void dump_aggr_init_expr_args (cxx_pretty_printer *, tree, int, bool);
static void dump_expr_list (cxx_pretty_printer *, tree, int);
static void dump_global_iord (cxx_pretty_printer *, tree);
static void dump_parameters (cxx_pretty_printer *, tree, int);
static void dump_ref_qualifier (cxx_pretty_printer *, tree, int);
static void dump_exception_spec (cxx_pretty_printer *, tree, int);
static void dump_template_argument (cxx_pretty_printer *, tree, int);
static void dump_template_argument_list (cxx_pretty_printer *, tree, int);
static void dump_template_parameter (cxx_pretty_printer *, tree, int);
static void dump_template_bindings (cxx_pretty_printer *, tree, tree,
vec<tree, va_gc> *);
static void dump_scope (cxx_pretty_printer *, tree, int);
static void dump_template_parms (cxx_pretty_printer *, tree, int, int);
static int get_non_default_template_args_count (tree, int);
static const char *function_category (tree);
static void maybe_print_constexpr_context (diagnostic_context *);
static void maybe_print_instantiation_context (diagnostic_context *);
static void print_instantiation_full_context (diagnostic_context *);
static void print_instantiation_partial_context (diagnostic_context *,
struct tinst_level *,
location_t);
static void maybe_print_constraint_context (diagnostic_context *);
static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
static bool cp_printer (pretty_printer *, text_info *, const char *,
int, bool, bool, bool, bool *, const char **);
/* Struct for handling %H or %I, which require delaying printing the
type until a postprocessing stage. */
class deferred_printed_type
{
public:
deferred_printed_type ()
: m_tree (NULL_TREE), m_buffer_ptr (NULL), m_verbose (false), m_quote (false)
{}
deferred_printed_type (tree type, const char **buffer_ptr, bool verbose,
bool quote)
: m_tree (type), m_buffer_ptr (buffer_ptr), m_verbose (verbose),
m_quote (quote)
{
gcc_assert (type);
gcc_assert (buffer_ptr);
}
/* The tree is not GTY-marked: they are only non-NULL within a
call to pp_format. */
tree m_tree;
const char **m_buffer_ptr;
bool m_verbose;
bool m_quote;
};
/* Subclass of format_postprocessor for the C++ frontend.
This handles the %H and %I formatting codes, printing them
in a postprocessing phase (since they affect each other). */
class cxx_format_postprocessor : public format_postprocessor
{
public:
cxx_format_postprocessor ()
: m_type_a (), m_type_b ()
{}
format_postprocessor *clone() const FINAL OVERRIDE
{
return new cxx_format_postprocessor ();
}
void handle (pretty_printer *pp) FINAL OVERRIDE;
deferred_printed_type m_type_a;
deferred_printed_type m_type_b;
};
/* CONTEXT->printer is a basic pretty printer that was constructed
presumably by diagnostic_initialize(), called early in the
compiler's initialization process (in general_init) Before the FE
is initialized. This (C++) FE-specific diagnostic initializer is
thus replacing the basic pretty printer with one that has C++-aware
capacities. */
void
cxx_initialize_diagnostics (diagnostic_context *context)
{
pretty_printer *base = context->printer;
cxx_pretty_printer *pp = XNEW (cxx_pretty_printer);
context->printer = new (pp) cxx_pretty_printer ();
/* It is safe to free this object because it was previously XNEW()'d. */
base->~pretty_printer ();
XDELETE (base);
c_common_diagnostics_set_defaults (context);
diagnostic_starter (context) = cp_diagnostic_starter;
/* diagnostic_finalizer is already c_diagnostic_finalizer. */
diagnostic_format_decoder (context) = cp_printer;
pp->m_format_postprocessor = new cxx_format_postprocessor ();
}
/* Dump an '@module' name suffix for DECL, if any. */
static void
dump_module_suffix (cxx_pretty_printer *pp, tree decl)
{
if (!modules_p ())
return;
if (!DECL_CONTEXT (decl))
return;
if (TREE_CODE (decl) != CONST_DECL
|| !UNSCOPED_ENUM_P (DECL_CONTEXT (decl)))
{
if (!DECL_NAMESPACE_SCOPE_P (decl))
return;
if (TREE_CODE (decl) == NAMESPACE_DECL
&& !DECL_NAMESPACE_ALIAS (decl)
&& (TREE_PUBLIC (decl) || !TREE_PUBLIC (CP_DECL_CONTEXT (decl))))
return;
}
if (unsigned m = get_originating_module (decl))
if (const char *n = module_name (m, false))
{
pp_character (pp, '@');
pp->padding = pp_none;
pp_string (pp, n);
}
}
/* The scope of the declaration we're currently printing, to avoid redundantly
dumping the same scope on parameter types. */
static tree current_dump_scope;
/* Dump a scope, if deemed necessary. */
static void
dump_scope (cxx_pretty_printer *pp, tree scope, int flags)
{
int f = flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF);
if (scope == NULL_TREE || scope == current_dump_scope)
return;
/* Enum values within an unscoped enum will be CONST_DECL with an
ENUMERAL_TYPE as their "scope". Use CP_TYPE_CONTEXT of the
ENUMERAL_TYPE, so as to print any enclosing namespace. */
if (UNSCOPED_ENUM_P (scope))
scope = CP_TYPE_CONTEXT (scope);
if (TREE_CODE (scope) == NAMESPACE_DECL)
{
if (scope != global_namespace)
{
dump_decl (pp, scope, f);
pp_cxx_colon_colon (pp);
}
}
else if (AGGREGATE_TYPE_P (scope)
|| SCOPED_ENUM_P (scope))
{
dump_type (pp, scope, f);
pp_cxx_colon_colon (pp);
}
else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
{
dump_function_decl (pp, scope, f | TFF_NO_TEMPLATE_BINDINGS);
pp_cxx_colon_colon (pp);
}
}
/* Dump the template ARGument under control of FLAGS. */
static void
dump_template_argument (cxx_pretty_printer *pp, tree arg, int flags)
{
if (ARGUMENT_PACK_P (arg))
dump_template_argument_list (pp, ARGUMENT_PACK_ARGS (arg),
/* No default args in argument packs. */
flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS);
else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
dump_type (pp, arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
else
{
if (TREE_CODE (arg) == TREE_LIST)
arg = TREE_VALUE (arg);
/* Strip implicit conversions. */
while (CONVERT_EXPR_P (arg))
arg = TREE_OPERAND (arg, 0);
dump_expr (pp, arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
}
}
/* Count the number of template arguments ARGS whose value does not
match the (optional) default template parameter in PARAMS */
static int
get_non_default_template_args_count (tree args, int flags)
{
int n = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args));
if (/* We use this flag when generating debug information. We don't
want to expand templates at this point, for this may generate
new decls, which gets decl counts out of sync, which may in
turn cause codegen differences between compilations with and
without -g. */
(flags & TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS) != 0
|| !flag_pretty_templates)
return n;
return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args));
}
/* Dump a template-argument-list ARGS (always a TREE_VEC) under control
of FLAGS. */
static void
dump_template_argument_list (cxx_pretty_printer *pp, tree args, int flags)
{
int n = get_non_default_template_args_count (args, flags);
int need_comma = 0;
int i;
for (i = 0; i < n; ++i)
{
tree arg = TREE_VEC_ELT (args, i);
/* Only print a comma if we know there is an argument coming. In
the case of an empty template argument pack, no actual
argument will be printed. */
if (need_comma
&& (!ARGUMENT_PACK_P (arg)
|| TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
pp_separate_with_comma (pp);
dump_template_argument (pp, arg, flags);
need_comma = 1;
}
}
/* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
static void
dump_template_parameter (cxx_pretty_printer *pp, tree parm, int flags)
{
tree p;
tree a;
if (parm == error_mark_node)
return;
p = TREE_VALUE (parm);
a = TREE_PURPOSE (parm);
if (TREE_CODE (p) == TYPE_DECL)
{
if (flags & TFF_DECL_SPECIFIERS)
{
pp_cxx_ws_string (pp, "class");
if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
pp_cxx_ws_string (pp, "...");
if (DECL_NAME (p))
pp_cxx_tree_identifier (pp, DECL_NAME (p));
}
else if (DECL_NAME (p))
pp_cxx_tree_identifier (pp, DECL_NAME (p));
else
pp_cxx_canonical_template_parameter (pp, TREE_TYPE (p));
}
else
dump_decl (pp, p, flags | TFF_DECL_SPECIFIERS);
if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
{
pp_cxx_whitespace (pp);
pp_equal (pp);
pp_cxx_whitespace (pp);
if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
dump_type (pp, a, flags & ~TFF_CHASE_TYPEDEF);
else
dump_expr (pp, a, flags | TFF_EXPR_IN_PARENS);
}
}
/* Dump, under control of FLAGS, a template-parameter-list binding.
PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
TREE_VEC. */
static void
dump_template_bindings (cxx_pretty_printer *pp, tree parms, tree args,
vec<tree, va_gc> *typenames)
{
/* Print "[with" and ']', conditional on whether anything is printed at all.
This is tied to whether a semicolon is needed to separate multiple template
parameters. */
struct prepost_semicolon
{
cxx_pretty_printer *pp;
bool need_semicolon;
void operator() ()
{
if (need_semicolon)
pp_separate_with_semicolon (pp);
else
{
pp_cxx_whitespace (pp);
pp_cxx_left_bracket (pp);
pp->translate_string ("with");
pp_cxx_whitespace (pp);
need_semicolon = true;
}
}
~prepost_semicolon ()
{
if (need_semicolon)
pp_cxx_right_bracket (pp);
}
} semicolon_or_introducer = {pp, false};
int i;
tree t;
while (parms)
{
tree p = TREE_VALUE (parms);
int lvl = TMPL_PARMS_DEPTH (parms);
int arg_idx = 0;
int i;
tree lvl_args = NULL_TREE;
/* Don't crash if we had an invalid argument list. */
if (TMPL_ARGS_DEPTH (args) >= lvl)
lvl_args = TMPL_ARGS_LEVEL (args, lvl);
for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
{
tree arg = NULL_TREE;
/* Don't crash if we had an invalid argument list. */
if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx)
arg = TREE_VEC_ELT (lvl_args, arg_idx);
tree parm_i = TREE_VEC_ELT (p, i);
/* If the template argument repeats the template parameter (T = T),
skip the parameter.*/
if (arg && TREE_CODE (arg) == TEMPLATE_TYPE_PARM
&& TREE_CODE (parm_i) == TREE_LIST
&& TREE_CODE (TREE_VALUE (parm_i)) == TYPE_DECL
&& TREE_CODE (TREE_TYPE (TREE_VALUE (parm_i)))
== TEMPLATE_TYPE_PARM
&& DECL_NAME (TREE_VALUE (parm_i))
== DECL_NAME (TREE_CHAIN (arg)))
continue;
semicolon_or_introducer ();
dump_template_parameter (pp, parm_i, TFF_PLAIN_IDENTIFIER);
pp_cxx_whitespace (pp);
pp_equal (pp);
pp_cxx_whitespace (pp);
if (arg)
{
if (ARGUMENT_PACK_P (arg))
pp_cxx_left_brace (pp);
dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER);
if (ARGUMENT_PACK_P (arg))
pp_cxx_right_brace (pp);
}
else
pp_string (pp, M_("<missing>"));
++arg_idx;
}
parms = TREE_CHAIN (parms);
}
/* Don't bother with typenames for a partial instantiation. */
if (vec_safe_is_empty (typenames) || uses_template_parms (args))
return;
/* Don't try to print typenames when we're processing a clone. */
if (current_function_decl
&& !DECL_LANG_SPECIFIC (current_function_decl))
return;
/* Don't try to do this once cgraph starts throwing away front-end
information. */
if (at_eof >= 2)
return;
FOR_EACH_VEC_SAFE_ELT (typenames, i, t)
{
semicolon_or_introducer ();
dump_type (pp, t, TFF_PLAIN_IDENTIFIER);
pp_cxx_whitespace (pp);
pp_equal (pp);
pp_cxx_whitespace (pp);
push_deferring_access_checks (dk_no_check);
t = tsubst (t, args, tf_none, NULL_TREE);
pop_deferring_access_checks ();
/* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
pp_simple_type_specifier doesn't know about it. */
t = strip_typedefs (t, NULL, STF_USER_VISIBLE);
dump_type (pp, t, TFF_PLAIN_IDENTIFIER);
}
}
/* Dump a human-readable equivalent of the alias template
specialization of T. */
static void
dump_alias_template_specialization (cxx_pretty_printer *pp, tree t, int flags)
{
gcc_assert (alias_template_specialization_p (t, nt_opaque));
tree decl = TYPE_NAME (t);
if (!(flags & TFF_UNQUALIFIED_NAME))
dump_scope (pp, CP_DECL_CONTEXT (decl), flags);
pp_cxx_tree_identifier (pp, DECL_NAME (decl));
dump_template_parms (pp, DECL_TEMPLATE_INFO (decl),
/*primary=*/false,
flags & ~TFF_TEMPLATE_HEADER);
}
/* Dump a human-readable equivalent of TYPE. FLAGS controls the
format. */
static void
dump_type (cxx_pretty_printer *pp, tree t, int flags)
{
if (t == NULL_TREE)
return;
/* Don't print e.g. "struct mytypedef". */
if (TYPE_P (t) && typedef_variant_p (t))
{
tree decl = TYPE_NAME (t);
if ((flags & TFF_CHASE_TYPEDEF)
|| DECL_SELF_REFERENCE_P (decl)
|| (!flag_pretty_templates
&& DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)))
{
unsigned int stf_flags = (!(pp->flags & pp_c_flag_gnu_v3)
? STF_USER_VISIBLE : 0);
t = strip_typedefs (t, NULL, stf_flags);
}
else if (alias_template_specialization_p (t, nt_opaque))
{
dump_alias_template_specialization (pp, t, flags);
return;
}
else if (same_type_p (t, TREE_TYPE (decl)))
t = decl;
else
{
pp_cxx_cv_qualifier_seq (pp, t);
if (! (flags & TFF_UNQUALIFIED_NAME))
dump_scope (pp, CP_DECL_CONTEXT (decl), flags);
pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
return;
}
}
if (TYPE_PTRMEMFUNC_P (t))
goto offset_type;
switch (TREE_CODE (t))
{
case LANG_TYPE:
if (t == init_list_type_node)
pp_string (pp, M_("<brace-enclosed initializer list>"));
else if (t == unknown_type_node)
pp_string (pp, M_("<unresolved overloaded function type>"));
else
{
pp_cxx_cv_qualifier_seq (pp, t);
pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
}
break;
case TREE_LIST:
/* A list of function parms. */
dump_parameters (pp, t, flags);
break;
case IDENTIFIER_NODE:
pp_cxx_tree_identifier (pp, t);
break;
case TREE_BINFO:
dump_type (pp, BINFO_TYPE (t), flags);
break;
case RECORD_TYPE:
case UNION_TYPE:
case ENUMERAL_TYPE:
dump_aggr_type (pp, t, flags);
break;
case TYPE_DECL:
if (flags & TFF_CHASE_TYPEDEF)
{
dump_type (pp, DECL_ORIGINAL_TYPE (t)
? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
break;
}
/* Fall through. */
case TEMPLATE_DECL:
case NAMESPACE_DECL:
dump_decl (pp, t, flags & ~TFF_DECL_SPECIFIERS);
break;
case INTEGER_TYPE:
case REAL_TYPE:
case VOID_TYPE:
case OPAQUE_TYPE:
case BOOLEAN_TYPE:
case COMPLEX_TYPE:
case VECTOR_TYPE:
case FIXED_POINT_TYPE:
pp_type_specifier_seq (pp, t);
break;
case TEMPLATE_TEMPLATE_PARM:
/* For parameters inside template signature. */
if (TYPE_IDENTIFIER (t))
pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
else
pp_cxx_canonical_template_parameter (pp, t);
break;
case BOUND_TEMPLATE_TEMPLATE_PARM:
{
tree args = TYPE_TI_ARGS (t);
pp_cxx_cv_qualifier_seq (pp, t);
pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
pp_cxx_begin_template_argument_list (pp);
dump_template_argument_list (pp, args, flags);
pp_cxx_end_template_argument_list (pp);
}
break;
case TEMPLATE_TYPE_PARM:
pp_cxx_cv_qualifier_seq (pp, t);
if (template_placeholder_p (t))
{
t = TREE_TYPE (CLASS_PLACEHOLDER_TEMPLATE (t));
pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
pp_string (pp, "<...auto...>");
}
else if (TYPE_IDENTIFIER (t))
pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
else
pp_cxx_canonical_template_parameter
(pp, TEMPLATE_TYPE_PARM_INDEX (t));
/* If this is a constrained placeholder, add the requirements. */
if (tree c = PLACEHOLDER_TYPE_CONSTRAINTS (t))
pp_cxx_constrained_type_spec (pp, c);
break;
/* This is not always necessary for pointers and such, but doing this
reduces code size. */
case ARRAY_TYPE:
case POINTER_TYPE:
case REFERENCE_TYPE:
case OFFSET_TYPE:
offset_type:
case FUNCTION_TYPE:
case METHOD_TYPE:
{
dump_type_prefix (pp, t, flags);
dump_type_suffix (pp, t, flags);
break;
}
case TYPENAME_TYPE:
if (! (flags & TFF_CHASE_TYPEDEF)
&& DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
{
dump_decl (pp, TYPE_NAME (t), TFF_PLAIN_IDENTIFIER);
break;
}
pp_cxx_cv_qualifier_seq (pp, t);
pp_cxx_ws_string (pp,
TYPENAME_IS_ENUM_P (t) ? "enum"
: TYPENAME_IS_CLASS_P (t) ? "class"
: "typename");
dump_typename (pp, t, flags);
break;
case UNBOUND_CLASS_TEMPLATE:
if (! (flags & TFF_UNQUALIFIED_NAME))
{
dump_type (pp, TYPE_CONTEXT (t), flags);
pp_cxx_colon_colon (pp);
}
pp_cxx_ws_string (pp, "template");
dump_type (pp, TYPE_IDENTIFIER (t), flags);
break;
case TYPEOF_TYPE:
pp_cxx_ws_string (pp, "__typeof__");
pp_cxx_whitespace (pp);
pp_cxx_left_paren (pp);
dump_expr (pp, TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
pp_cxx_right_paren (pp);
break;
case UNDERLYING_TYPE:
pp_cxx_ws_string (pp, "__underlying_type");
pp_cxx_whitespace (pp);
pp_cxx_left_paren (pp);
dump_expr (pp, UNDERLYING_TYPE_TYPE (t), flags & ~TFF_EXPR_IN_PARENS);
pp_cxx_right_paren (pp);
break;
case TYPE_PACK_EXPANSION:
dump_type (pp, PACK_EXPANSION_PATTERN (t), flags);
pp_cxx_ws_string (pp, "...");
break;
case TYPE_ARGUMENT_PACK:
dump_template_argument (pp, t, flags);
break;
case DECLTYPE_TYPE:
pp_cxx_ws_string (pp, "decltype");
pp_cxx_whitespace (pp);
pp_cxx_left_paren (pp);
dump_expr (pp, DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
pp_cxx_right_paren (pp);
break;
case NULLPTR_TYPE:
pp_string (pp, "std::nullptr_t");
break;
default:
pp_unsupported_tree (pp, t);
/* Fall through. */
case ERROR_MARK:
pp_string (pp, M_("<type error>"));
break;
}
}
/* Dump a TYPENAME_TYPE. We need to notice when the context is itself
a TYPENAME_TYPE. */
static void
dump_typename (cxx_pretty_printer *pp, tree t, int flags)
{
tree ctx = TYPE_CONTEXT (t);
if (TREE_CODE (ctx) == TYPENAME_TYPE)
dump_typename (pp, ctx, flags);
else
dump_type (pp, ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
pp_cxx_colon_colon (pp);
dump_decl (pp, TYPENAME_TYPE_FULLNAME (t), flags);
}
/* Return the name of the supplied aggregate, or enumeral type. */
const char *
class_key_or_enum_as_string (tree t)
{
if (TREE_CODE (t) == ENUMERAL_TYPE)
{
if (SCOPED_ENUM_P (t))
return "enum class";
else
return "enum";
}
else if (TREE_CODE (t) == UNION_TYPE)
return "union";
else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
return "class";
else
return "struct";
}
/* Disable warnings about missing quoting in GCC diagnostics for
the pp_verbatim call. Their format strings deliberately don't
follow GCC diagnostic conventions. */
#if __GNUC__ >= 10
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-diag"
#endif
/* Print out a class declaration T under the control of FLAGS,
in the form `class foo'. */
static void
dump_aggr_type (cxx_pretty_printer *pp, tree t, int flags)
{
const char *variety = class_key_or_enum_as_string (t);
int typdef = 0;
int tmplate = 0;
pp_cxx_cv_qualifier_seq (pp, t);
if (flags & TFF_CLASS_KEY_OR_ENUM)
pp_cxx_ws_string (pp, variety);
tree decl = TYPE_NAME (t);
if (decl)
{
typdef = (!DECL_ARTIFICIAL (decl)
/* An alias specialization is not considered to be a
typedef. */
&& !alias_template_specialization_p (t, nt_opaque));
if ((typdef
&& ((flags & TFF_CHASE_TYPEDEF)
|| (!flag_pretty_templates && DECL_LANG_SPECIFIC (decl)
&& DECL_TEMPLATE_INFO (decl))))
|| DECL_SELF_REFERENCE_P (decl))
{
t = TYPE_MAIN_VARIANT (t);
decl = TYPE_NAME (t);
typdef = 0;
}
tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
&& TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
&& (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
|| PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
if (! (flags & TFF_UNQUALIFIED_NAME))
dump_scope (pp, CP_DECL_CONTEXT (decl), flags | TFF_SCOPE);
flags &= ~TFF_UNQUALIFIED_NAME;
if (tmplate)
{
/* Because the template names are mangled, we have to locate
the most general template, and use that name. */
tree tpl = TYPE_TI_TEMPLATE (t);
while (DECL_TEMPLATE_INFO (tpl))
tpl = DECL_TI_TEMPLATE (tpl);
decl = tpl;
}
}
if (LAMBDA_TYPE_P (t))
{
/* A lambda's "type" is essentially its signature. */
pp_string (pp, M_("<lambda"));
if (lambda_function (t))
dump_parameters (pp,
FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)),
flags);
pp_greater (pp);
}
else if (!decl || IDENTIFIER_ANON_P (DECL_NAME (decl)))
{
if (flags & TFF_CLASS_KEY_OR_ENUM)
pp_string (pp, M_("<unnamed>"));
else
pp_printf (pp, M_("<unnamed %s>"), variety);
}
else
pp_cxx_tree_identifier (pp, DECL_NAME (decl));
dump_module_suffix (pp, decl);
if (tmplate)
dump_template_parms (pp, TYPE_TEMPLATE_INFO (t),
!CLASSTYPE_USE_TEMPLATE (t),
flags & ~TFF_TEMPLATE_HEADER);
}
#if __GNUC__ >= 10
#pragma GCC diagnostic pop
#endif
/* Dump into the obstack the initial part of the output for a given type.
This is necessary when dealing with things like functions returning
functions. Examples:
return type of `int (* fee ())()': pointer -> function -> int. Both
pointer (and reference and offset) and function (and member) types must
deal with prefix and suffix.
Arrays must also do this for DECL nodes, like int a[], and for things like
int *[]&. */
static void
dump_type_prefix (cxx_pretty_printer *pp, tree t, int flags)
{
if (TYPE_PTRMEMFUNC_P (t))
{
t = TYPE_PTRMEMFUNC_FN_TYPE (t);
goto offset_type;
}
switch (TREE_CODE (t))
{
case POINTER_TYPE:
case REFERENCE_TYPE:
{
tree sub = TREE_TYPE (t);
dump_type_prefix (pp, sub, flags);
if (TREE_CODE (sub) == ARRAY_TYPE
|| TREE_CODE (sub) == FUNCTION_TYPE)
{
pp_cxx_whitespace (pp);
pp_cxx_left_paren (pp);
pp_c_attributes_display (pp, TYPE_ATTRIBUTES (sub));
}
if (TYPE_PTR_P (t))
pp_star (pp);
else if (TYPE_REF_P (t))
{
if (TYPE_REF_IS_RVALUE (t))
pp_ampersand_ampersand (pp);
else
pp_ampersand (pp);
}
pp->padding = pp_before;
pp_cxx_cv_qualifier_seq (pp, t);
}
break;
case OFFSET_TYPE:
offset_type:
dump_type_prefix (pp, TREE_TYPE (t), flags);
if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
{
pp_maybe_space (pp);
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
pp_cxx_left_paren (pp);
dump_type (pp, TYPE_OFFSET_BASETYPE (t), flags);
pp_cxx_colon_colon (pp);
}
pp_cxx_star (pp);
pp_cxx_cv_qualifier_seq (pp, t);
pp->padding = pp_before;
break;
/* This can be reached without a pointer when dealing with
templates, e.g. std::is_function. */
case FUNCTION_TYPE:
dump_type_prefix (pp, TREE_TYPE (t), flags);
break;
case METHOD_TYPE:
dump_type_prefix (pp, TREE_TYPE (t), flags);
pp_maybe_space (pp);
pp_cxx_left_paren (pp);
dump_aggr_type (pp, TYPE_METHOD_BASETYPE (t), flags);
pp_cxx_colon_colon (pp);
break;
case ARRAY_TYPE:
dump_type_prefix (pp, TREE_TYPE (t), flags);
break;
case ENUMERAL_TYPE:
case IDENTIFIER_NODE:
case INTEGER_TYPE:
case BOOLEAN_TYPE:
case REAL_TYPE:
case RECORD_TYPE:
case TEMPLATE_TYPE_PARM:
case TEMPLATE_TEMPLATE_PARM:
case BOUND_TEMPLATE_TEMPLATE_PARM:
case TREE_LIST:
case TYPE_DECL:
case TREE_VEC:
case UNION_TYPE:
case LANG_TYPE:
case VOID_TYPE:
case OPAQUE_TYPE:
case TYPENAME_TYPE:
case COMPLEX_TYPE:
case VECTOR_TYPE:
case TYPEOF_TYPE:
case UNDERLYING_TYPE:
case DECLTYPE_TYPE:
case TYPE_PACK_EXPANSION:
case FIXED_POINT_TYPE:
case NULLPTR_TYPE:
dump_type (pp, t, flags);
pp->padding = pp_before;
break;
default:
pp_unsupported_tree (pp, t);
/* fall through. */
case ERROR_MARK:
pp_string (pp, M_("<typeprefixerror>"));
break;
}
}
/* Dump the suffix of type T, under control of FLAGS. This is the part
which appears after the identifier (or function parms). */
static void
dump_type_suffix (cxx_pretty_printer *pp, tree t, int flags)
{
if (TYPE_PTRMEMFUNC_P (t))
t = TYPE_PTRMEMFUNC_FN_TYPE (t);
switch (TREE_CODE (t))
{
case POINTER_TYPE:
case REFERENCE_TYPE:
case OFFSET_TYPE:
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
|| TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
pp_cxx_right_paren (pp);
if (TREE_CODE (t) == POINTER_TYPE)
flags |= TFF_POINTER;
dump_type_suffix (pp, TREE_TYPE (t), flags);
break;
case FUNCTION_TYPE:
case METHOD_TYPE:
{
tree arg;
if (TREE_CODE (t) == METHOD_TYPE)
/* Can only be reached through a pointer. */
pp_cxx_right_paren (pp);
arg = TYPE_ARG_TYPES (t);
if (TREE_CODE (t) == METHOD_TYPE)
arg = TREE_CHAIN (arg);
/* Function pointers don't have default args. Not in standard C++,
anyway; they may in g++, but we'll just pretend otherwise. */
dump_parameters (pp, arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
pp->padding = pp_before;
pp_cxx_cv_qualifiers (pp, type_memfn_quals (t),
TREE_CODE (t) == FUNCTION_TYPE
&& (flags & TFF_POINTER));
dump_ref_qualifier (pp, t, flags);
if (tx_safe_fn_type_p (t))
pp_cxx_ws_string (pp, "transaction_safe");
dump_exception_spec (pp, TYPE_RAISES_EXCEPTIONS (t), flags);
dump_type_suffix (pp, TREE_TYPE (t), flags);
break;
}
case ARRAY_TYPE:
pp_maybe_space (pp);
pp_cxx_left_bracket (pp);
if (tree dtype = TYPE_DOMAIN (t))
{
tree max = TYPE_MAX_VALUE (dtype);
/* Zero-length arrays have a null upper bound in C and SIZE_MAX
in C++. Handle both since the type might be constructed by
the middle end and end up here as a result of a warning (see
PR c++/97201). */
if (!max || integer_all_onesp (max))
pp_character (pp, '0');
else if (tree_fits_shwi_p (max))
pp_wide_integer (pp, tree_to_shwi (max) + 1);
else
{
STRIP_NOPS (max);
if (TREE_CODE (max) == SAVE_EXPR)
max = TREE_OPERAND (max, 0);
if (TREE_CODE (max) == MINUS_EXPR
|| TREE_CODE (max) == PLUS_EXPR)
{
max = TREE_OPERAND (max, 0);
while (CONVERT_EXPR_P (max))
max = TREE_OPERAND (max, 0);
}
else
max = fold_build2_loc (input_location,
PLUS_EXPR, dtype, max,
build_int_cst (dtype, 1));
dump_expr (pp, max, flags & ~TFF_EXPR_IN_PARENS);
}
}
pp_cxx_right_bracket (pp);
dump_type_suffix (pp, TREE_TYPE (t), flags);
break;
case ENUMERAL_TYPE:
case IDENTIFIER_NODE:
case INTEGER_TYPE:
case BOOLEAN_TYPE:
case REAL_TYPE:
case RECORD_TYPE:
case TEMPLATE_TYPE_PARM:
case TEMPLATE_TEMPLATE_PARM:
case BOUND_TEMPLATE_TEMPLATE_PARM:
case TREE_LIST:
case TYPE_DECL:
case TREE_VEC:
case UNION_TYPE:
case LANG_TYPE:
case VOID_TYPE:
case OPAQUE_TYPE:
case TYPENAME_TYPE:
case COMPLEX_TYPE:
case VECTOR_TYPE:
case TYPEOF_TYPE:
case UNDERLYING_TYPE:
case DECLTYPE_TYPE:
case TYPE_PACK_EXPANSION:
case FIXED_POINT_TYPE:
case NULLPTR_TYPE:
break;
default:
pp_unsupported_tree (pp, t);
case ERROR_MARK:
/* Don't mark it here, we should have already done in
dump_type_prefix. */
break;
}
}
static void
dump_global_iord (cxx_pretty_printer *pp, tree t)
{
const char *p = NULL;
if (DECL_GLOBAL_CTOR_P (t))
p = M_("(static initializers for %s)");
else if (DECL_GLOBAL_DTOR_P (t))
p = M_("(static destructors for %s)");
else
gcc_unreachable ();
pp_printf (pp, p, DECL_SOURCE_FILE (t));
}
static void
dump_simple_decl (cxx_pretty_printer *pp, tree t, tree type, int flags)
{
if (template_parm_object_p (t))
return dump_expr (pp, DECL_INITIAL (t), flags);
if (flags & TFF_DECL_SPECIFIERS)
{
if (concept_definition_p (t))
pp_cxx_ws_string (pp, "concept");
else if (VAR_P (t) && DECL_DECLARED_CONSTEXPR_P (t))
pp_cxx_ws_string (pp, "constexpr");
if (!standard_concept_p (t))
dump_type_prefix (pp, type, flags & ~TFF_UNQUALIFIED_NAME);
pp_maybe_space (pp);
}
if (! (flags & TFF_UNQUALIFIED_NAME)
&& TREE_CODE (t) != PARM_DECL
&& (!DECL_INITIAL (t)
|| TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
dump_scope (pp, CP_DECL_CONTEXT (t), flags);
flags &= ~TFF_UNQUALIFIED_NAME;
if ((flags & TFF_DECL_SPECIFIERS)
&& DECL_TEMPLATE_PARM_P (t)
&& TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
pp_string (pp, "...");
if (DECL_NAME (t))
{
if (TREE_CODE (t) == FIELD_DECL && DECL_NORMAL_CAPTURE_P (t))
{
pp_less (pp);
pp_string (pp, IDENTIFIER_POINTER (DECL_NAME (t)) + 2);
pp_string (pp, " capture>");
}
else
dump_decl (pp, DECL_NAME (t), flags);
}
else if (DECL_DECOMPOSITION_P (t))
pp_string (pp, M_("<structured bindings>"));
else
pp_string (pp, M_("<anonymous>"));
dump_module_suffix (pp, t);
if (flags & TFF_DECL_SPECIFIERS)
dump_type_suffix (pp, type, flags);
}
/* Print an IDENTIFIER_NODE that is the name of a declaration. */
static void
dump_decl_name (cxx_pretty_printer *pp, tree t, int flags)
{
/* These special cases are duplicated here so that other functions
can feed identifiers to error and get them demangled properly. */
if (IDENTIFIER_CONV_OP_P (t))
{
pp_cxx_ws_string (pp, "operator");
/* Not exactly IDENTIFIER_TYPE_VALUE. */
dump_type (pp, TREE_TYPE (t), flags);
return;
}
if (dguide_name_p (t))
{
dump_decl (pp, CLASSTYPE_TI_TEMPLATE (TREE_TYPE (t)),
TFF_UNQUALIFIED_NAME);
return;
}
const char *str = IDENTIFIER_POINTER (t);
if (startswith (str, "_ZGR"))
{
pp_cxx_ws_string (pp, "<temporary>");
return;
}
pp_cxx_tree_identifier (pp, t);
}
/* Dump a human readable string for the decl T under control of FLAGS. */
static void
dump_decl (cxx_pretty_printer *pp, tree t, int flags)
{
if (t == NULL_TREE)
return;
/* If doing Objective-C++, give Objective-C a chance to demangle
Objective-C method names. */
if (c_dialect_objc ())
{
const char *demangled = objc_maybe_printable_name (t, flags);
if (demangled)
{
pp_string (pp, demangled);
return;
}
}
switch (TREE_CODE (t))
{
case TYPE_DECL:
/* Don't say 'typedef class A' */
if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
{
if ((flags & TFF_DECL_SPECIFIERS)
&& TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
{
/* Say `class T' not just `T'. */
pp_cxx_ws_string (pp, "class");
/* Emit the `...' for a parameter pack. */
if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
pp_cxx_ws_string (pp, "...");
}
dump_type (pp, TREE_TYPE (t), flags);
break;
}
if (TYPE_DECL_ALIAS_P (t)
&& (flags & TFF_DECL_SPECIFIERS
|| flags & TFF_CLASS_KEY_OR_ENUM))
{
pp_cxx_ws_string (pp, "using");
dump_decl (pp, DECL_NAME (t), flags);
pp_cxx_whitespace (pp);
pp_cxx_ws_string (pp, "=");
pp_cxx_whitespace (pp);
dump_type (pp, (DECL_ORIGINAL_TYPE (t)
? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t)),
flags);
break;
}
if ((flags & TFF_DECL_SPECIFIERS)
&& !DECL_SELF_REFERENCE_P (t))
pp_cxx_ws_string (pp, "typedef");
dump_simple_decl (pp, t, DECL_ORIGINAL_TYPE (t)
? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
flags);
break;
case VAR_DECL:
if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
{
pp_string (pp, M_("vtable for "));
gcc_assert (TYPE_P (DECL_CONTEXT (t)));
dump_type (pp, DECL_CONTEXT (t), flags);
break;
}
/* Fall through. */
case FIELD_DECL:
case PARM_DECL:
dump_simple_decl (pp, t, TREE_TYPE (t), flags);
/* Handle variable template specializations. */
if (VAR_P (t)
&& DECL_LANG_SPECIFIC (t)
&& DECL_TEMPLATE_INFO (t)
&& PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)))
{
pp_cxx_begin_template_argument_list (pp);
tree args = INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t));
dump_template_argument_list (pp, args, flags);
pp_cxx_end_template_argument_list (pp);
}
break;
case RESULT_DECL:
pp_string (pp, M_("<return value> "));
dump_simple_decl (pp, t, TREE_TYPE (t), flags);
break;
case NAMESPACE_DECL:
if (flags & TFF_DECL_SPECIFIERS)
pp->declaration (t);
else
{
if (! (flags & TFF_UNQUALIFIED_NAME))
dump_scope (pp, CP_DECL_CONTEXT (t), flags);
flags &= ~TFF_UNQUALIFIED_NAME;
if (DECL_NAME (t) == NULL_TREE)
{
if (!(pp->flags & pp_c_flag_gnu_v3))
pp_cxx_ws_string (pp, M_("{anonymous}"));
else
pp_cxx_ws_string (pp, M_("(anonymous namespace)"));
}
else
pp_cxx_tree_identifier (pp, DECL_NAME (t));
}
break;
case SCOPE_REF:
dump_type (pp, TREE_OPERAND (t, 0), flags);
pp_cxx_colon_colon (pp);
dump_decl (pp, TREE_OPERAND (t, 1), TFF_UNQUALIFIED_NAME);
break;
case ARRAY_REF:
dump_decl (pp, TREE_OPERAND (t, 0), flags);
pp_cxx_left_bracket (pp);
dump_decl (pp, TREE_OPERAND (t, 1), flags);
pp_cxx_right_bracket (pp);
break;
/* So that we can do dump_decl on an aggr type. */
case RECORD_TYPE:
case UNION_TYPE:
case ENUMERAL_TYPE:
dump_type (pp, t, flags);
break;
case BIT_NOT_EXPR:
/* This is a pseudo destructor call which has not been folded into
a PSEUDO_DTOR_EXPR yet. */
pp_cxx_complement (pp);
dump_type (pp, TREE_OPERAND (t, 0), flags);
break;
case TYPE_EXPR:
gcc_unreachable ();
break;
case IDENTIFIER_NODE:
dump_decl_name (pp, t, flags);
break;
case OVERLOAD:
if (!OVL_SINGLE_P (t))
{
tree ctx = ovl_scope (t);
if (ctx != global_namespace)
{
if (TYPE_P (ctx))
dump_type (pp, ctx, flags);
else
dump_decl (pp, ctx, flags);
pp_cxx_colon_colon (pp);
}
dump_decl (pp, OVL_NAME (t), flags);
break;
}
/* If there's only one function, just treat it like an ordinary
FUNCTION_DECL. */
t = OVL_FIRST (t);
/* Fall through. */
case FUNCTION_DECL:
if (! DECL_LANG_SPECIFIC (t))
{
if (DECL_ABSTRACT_ORIGIN (t)
&& DECL_ABSTRACT_ORIGIN (t) != t)
dump_decl (pp, DECL_ABSTRACT_ORIGIN (t), flags);
else
dump_function_name (pp, t, flags);
}
else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
dump_global_iord (pp, t);
else
dump_function_decl (pp, t, flags);
break;
case TEMPLATE_DECL:
dump_template_decl (pp, t, flags);
break;
case CONCEPT_DECL:
dump_simple_decl (pp, t, TREE_TYPE (t), flags);
break;
case WILDCARD_DECL:
pp_string (pp, "<wildcard>");
break;
case TEMPLATE_ID_EXPR:
{
tree name = TREE_OPERAND (t, 0);
tree args = TREE_OPERAND (t, 1);
if (!identifier_p (name))
name = OVL_NAME (name);
dump_decl (pp, name, flags);
pp_cxx_begin_template_argument_list (pp);
if (args == error_mark_node)
pp_string (pp, M_("<template arguments error>"));
else if (args)
dump_template_argument_list
(pp, args, flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS);
pp_cxx_end_template_argument_list (pp);
}
break;
case LABEL_DECL:
if (DECL_NAME (t))
pp_cxx_tree_identifier (pp, DECL_NAME (t));
else
dump_generic_node (pp, t, 0, TDF_SLIM, false);
break;
case CONST_DECL:
if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
|| (DECL_INITIAL (t) &&
TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
dump_simple_decl (pp, t, TREE_TYPE (t), flags);
else if (DECL_NAME (t))
dump_decl (pp, DECL_NAME (t), flags);
else if (DECL_INITIAL (t))
dump_expr (pp, DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
else
pp_string (pp, M_("<enumerator>"));
break;
case USING_DECL:
{
pp_cxx_ws_string (pp, "using");
tree scope = USING_DECL_SCOPE (t);
bool variadic = false;
if (PACK_EXPANSION_P (scope))
{
scope = PACK_EXPANSION_PATTERN (scope);
variadic = true;
}
dump_type (pp, scope, flags);
pp_cxx_colon_colon (pp);
dump_decl (pp, DECL_NAME (t), flags);
if (variadic)
pp_cxx_ws_string (pp, "...");
}
break;
case STATIC_ASSERT:
pp->declaration (t);
break;
case BASELINK:
dump_decl (pp, BASELINK_FUNCTIONS (t), flags);
break;
case NON_DEPENDENT_EXPR:
dump_expr (pp, t, flags);
break;
case TEMPLATE_TYPE_PARM:
if (flags & TFF_DECL_SPECIFIERS)
pp->declaration (t);
else
pp->type_id (t);
break;
case UNBOUND_CLASS_TEMPLATE:
case TYPE_PACK_EXPANSION:
case TREE_BINFO:
dump_type (pp, t, flags);
break;
default:
pp_unsupported_tree (pp, t);
/* Fall through. */
case ERROR_MARK:
pp_string (pp, M_("<declaration error>"));
break;
}
}
/* Dump a template declaration T under control of FLAGS. This means the
'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
static void
dump_template_decl (cxx_pretty_printer *pp, tree t, int flags)
{
tree orig_parms = DECL_TEMPLATE_PARMS (t);
tree parms;
int i;
if (flags & TFF_TEMPLATE_HEADER)
{
for (parms = orig_parms = nreverse (orig_parms);
parms;
parms = TREE_CHAIN (parms))
{
tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
int len = TREE_VEC_LENGTH (inner_parms);
if (len == 0)
{
/* Skip over the dummy template levels of a template template
parm. */
gcc_assert (TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TEMPLATE_PARM);
continue;
}
pp_cxx_ws_string (pp, "template");
pp_cxx_begin_template_argument_list (pp);
/* If we've shown the template prefix, we'd better show the
parameters' and decl's type too. */
flags |= TFF_DECL_SPECIFIERS;
for (i = 0; i < len; i++)
{
if (i)
pp_separate_with_comma (pp);
dump_template_parameter (pp, TREE_VEC_ELT (inner_parms, i),
flags);
}
pp_cxx_end_template_argument_list (pp);
pp_cxx_whitespace (pp);
}
nreverse(orig_parms);
if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
{
/* Say `template<arg> class TT' not just `template<arg> TT'. */
pp_cxx_ws_string (pp, "class");
/* If this is a parameter pack, print the ellipsis. */
if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
pp_cxx_ws_string (pp, "...");
}
/* Only print the requirements if we're also printing
the template header. */
if (flag_concepts)
if (tree ci = get_constraints (t))
if (check_constraint_info (ci))
if (tree reqs = CI_TEMPLATE_REQS (ci))
{
pp_cxx_requires_clause (pp, reqs);
pp_cxx_whitespace (pp);
}
}
if (DECL_CLASS_TEMPLATE_P (t))
dump_type (pp, TREE_TYPE (t),
((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
| (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
else if (DECL_TEMPLATE_RESULT (t)
&& (VAR_P (DECL_TEMPLATE_RESULT (t))
/* Alias template. */
|| DECL_TYPE_TEMPLATE_P (t)
/* Concept definition. &*/
|| TREE_CODE (DECL_TEMPLATE_RESULT (t)) == CONCEPT_DECL))
dump_decl (pp, DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
else
{
gcc_assert (TREE_TYPE (t));
switch (NEXT_CODE (t))
{
case METHOD_TYPE:
case FUNCTION_TYPE:
dump_function_decl (pp, t, flags | TFF_TEMPLATE_NAME);
break;
default:
/* This case can occur with some invalid code. */
dump_type (pp, TREE_TYPE (t),
(flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
| (flags & TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM : 0));
}
}
}
/* find_typenames looks through the type of the function template T
and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
it finds. */
struct find_typenames_t
{
hash_set<tree> *p_set;
vec<tree, va_gc> *typenames;
};
static tree
find_typenames_r (tree *tp, int *walk_subtrees, void *data)
{
struct find_typenames_t *d = (struct find_typenames_t *)data;
tree mv = NULL_TREE;
if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
/* Add the type of the typedef without any additional cv-quals. */
mv = TREE_TYPE (TYPE_NAME (*tp));
else if (TREE_CODE (*tp) == TYPENAME_TYPE
|| TREE_CODE (*tp) == DECLTYPE_TYPE)
/* Add the typename without any cv-qualifiers. */
mv = TYPE_MAIN_VARIANT (*tp);
if (PACK_EXPANSION_P (*tp))
{
/* Don't mess with parameter packs since we don't remember
the pack expansion context for a particular typename. */
*walk_subtrees = false;
return NULL_TREE;
}
if (mv && (mv == *tp || !d->p_set->add (mv)))
vec_safe_push (d->typenames, mv);
return NULL_TREE;
}
static vec<tree, va_gc> *
find_typenames (tree t)
{
struct find_typenames_t ft;
ft.p_set = new hash_set<tree>;
ft.typenames = NULL;
cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
find_typenames_r, &ft, ft.p_set);
delete ft.p_set;
return ft.typenames;
}
/* Output the "[with ...]" clause for a template instantiation T iff
TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
formatting a deduction/substitution diagnostic rather than an
instantiation. */
static void
dump_substitution (cxx_pretty_printer *pp,
tree t, tree template_parms, tree template_args,
int flags)
{
if (template_parms != NULL_TREE && template_args != NULL_TREE
&& !(flags & TFF_NO_TEMPLATE_BINDINGS))
{
vec<tree, va_gc> *typenames = t ? find_typenames (t) : NULL;
dump_template_bindings (pp, template_parms, template_args, typenames);
}
}
/* Dump the lambda function FN including its 'mutable' qualifier and any
template bindings. */
static void
dump_lambda_function (cxx_pretty_printer *pp,
tree fn, tree template_parms, tree template_args,
int flags)
{
/* A lambda's signature is essentially its "type". */
dump_type (pp, DECL_CONTEXT (fn), flags);
if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn))) & TYPE_QUAL_CONST))
{
pp->padding = pp_before;
pp_c_ws_string (pp, "mutable");
}
dump_substitution (pp, fn, template_parms, template_args, flags);
}
/* Pretty print a function decl. There are several ways we want to print a
function declaration. The TFF_ bits in FLAGS tells us how to behave.
As error can only apply the '#' flag once to give 0 and 1 for V, there
is %D which doesn't print the throw specs, and %F which does. */
static void
dump_function_decl (cxx_pretty_printer *pp, tree t, int flags)
{
tree fntype;
tree parmtypes;
tree cname = NULL_TREE;
tree template_args = NULL_TREE;
tree template_parms = NULL_TREE;
int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
tree exceptions;
bool constexpr_p;
tree ret = NULL_TREE;
int dump_function_name_flags = flags & ~TFF_UNQUALIFIED_NAME;
flags = dump_function_name_flags & ~TFF_TEMPLATE_NAME;
if (TREE_CODE (t) == TEMPLATE_DECL)
t = DECL_TEMPLATE_RESULT (t);
/* Save the exceptions, in case t is a specialization and we are
emitting an error about incompatible specifications. */
exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
/* Likewise for the constexpr specifier, in case t is a specialization. */
constexpr_p = (DECL_DECLARED_CONSTEXPR_P (t)
&& !decl_implicit_constexpr_p (t));
/* Pretty print template instantiations only. */
if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
&& !(flags & TFF_NO_TEMPLATE_BINDINGS)
&& flag_pretty_templates)
{
tree tmpl;
template_args = DECL_TI_ARGS (t);
tmpl = most_general_template (t);
if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
{
template_parms = DECL_TEMPLATE_PARMS (tmpl);
t = tmpl;
}
}
if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t))
return dump_lambda_function (pp, t, template_parms, template_args, flags);
fntype = TREE_TYPE (t);
parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
if (DECL_CLASS_SCOPE_P (t))
cname = DECL_CONTEXT (t);
/* This is for partially instantiated template methods. */
else if (TREE_CODE (fntype) == METHOD_TYPE)
cname = TREE_TYPE (TREE_VALUE (parmtypes));
if (flags & TFF_DECL_SPECIFIERS)
{
if (DECL_STATIC_FUNCTION_P (t))
pp_cxx_ws_string (pp, "static");
else if (DECL_VIRTUAL_P (t))
pp_cxx_ws_string (pp, "virtual");
if (constexpr_p)
{
if (DECL_DECLARED_CONCEPT_P (t))
pp_cxx_ws_string (pp, "concept");
else if (DECL_IMMEDIATE_FUNCTION_P (t))
pp_cxx_ws_string (pp, "consteval");
else
pp_cxx_ws_string (pp, "constexpr");
}
}
/* Print the return type? */
if (show_return)
show_return = (!DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
&& !DECL_DESTRUCTOR_P (t) && !deduction_guide_p (t));
if (show_return)
{
ret = fndecl_declared_return_type (t);
dump_type_prefix (pp, ret, flags);
}
/* Print the function name. */
if (!do_outer_scope)
/* Nothing. */;
else if (cname)
{
dump_type (pp, cname, flags);
pp_cxx_colon_colon (pp);
}
else
dump_scope (pp, CP_DECL_CONTEXT (t), flags);
/* Name lookup for the rest of the function declarator is implicitly in the
scope of the function, so avoid printing redundant scope qualifiers. */
auto cds = make_temp_override (current_dump_scope, CP_DECL_CONTEXT (t));
dump_function_name (pp, t, dump_function_name_flags);
if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
{
dump_parameters (pp, parmtypes, flags);
if (TREE_CODE (fntype) == METHOD_TYPE)
{
pp->padding = pp_before;
pp_cxx_cv_qualifier_seq (pp, class_of_this_parm (fntype));
dump_ref_qualifier (pp, fntype, flags);
}
if (tx_safe_fn_type_p (fntype))
{
pp->padding = pp_before;
pp_cxx_ws_string (pp, "transaction_safe");
}
if (flags & TFF_EXCEPTION_SPECIFICATION)
{
pp->padding = pp_before;
dump_exception_spec (pp, exceptions, flags);
}
if (show_return)
dump_type_suffix (pp, ret, flags);
else if (deduction_guide_p (t))
{
pp_cxx_ws_string (pp, "->");
dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
}
if (flag_concepts)
if (tree ci = get_constraints (t))
if (tree reqs = CI_DECLARATOR_REQS (ci))
pp_cxx_requires_clause (pp, reqs);
dump_substitution (pp, t, template_parms, template_args, flags);
if (tree base = DECL_INHERITED_CTOR_BASE (t))
{
pp_cxx_ws_string (pp, "[inherited from");
dump_type (pp, base, TFF_PLAIN_IDENTIFIER);
pp_character (pp, ']');
}
}
else if (template_args)
{
bool need_comma = false;
int i;
pp_cxx_begin_template_argument_list (pp);
template_args = INNERMOST_TEMPLATE_ARGS (template_args);
for (i = 0; i < TREE_VEC_LENGTH (template_args); ++i)
{
tree arg = TREE_VEC_ELT (template_args, i);
if (need_comma)
pp_separate_with_comma (pp);
if (ARGUMENT_PACK_P (arg))
pp_cxx_left_brace (pp);
dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER);
if (ARGUMENT_PACK_P (arg))
pp_cxx_right_brace (pp);
need_comma = true;
}
pp_cxx_end_template_argument_list (pp);
}
}
/* Print a parameter list. If this is for a member function, the
member object ptr (and any other hidden args) should have
already been removed. */
static void
dump_parameters (cxx_pretty_printer *pp, tree parmtypes, int flags)
{
int first = 1;
flags &= ~TFF_SCOPE;
pp_cxx_left_paren (pp);
for (first = 1; parmtypes != void_list_node;
parmtypes = TREE_CHAIN (parmtypes))
{
if (!first)
pp_separate_with_comma (pp);
first = 0;
if (!parmtypes)
{
pp_cxx_ws_string (pp, "...");
break;
}
dump_type (pp, TREE_VALUE (parmtypes), flags);
if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
{
pp_cxx_whitespace (pp);
pp_equal (pp);
pp_cxx_whitespace (pp);
dump_expr (pp, TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
}
}
pp_cxx_right_paren (pp);
}
/* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
static void
dump_ref_qualifier (cxx_pretty_printer *pp, tree t, int flags ATTRIBUTE_UNUSED)
{
if (FUNCTION_REF_QUALIFIED (t))
{
pp->padding = pp_before;
if (FUNCTION_RVALUE_QUALIFIED (t))
pp_cxx_ws_string (pp, "&&");
else
pp_cxx_ws_string (pp, "&");
}
}
/* Print an exception specification. T is the exception specification. */
static void
dump_exception_spec (cxx_pretty_printer *pp, tree t, int flags)
{
if (t && TREE_PURPOSE (t))
{
pp_cxx_ws_string (pp, "noexcept");
if (!integer_onep (TREE_PURPOSE (t)))
{
pp_cxx_whitespace (pp);
pp_cxx_left_paren (pp);
if (DEFERRED_NOEXCEPT_SPEC_P (t))
pp_cxx_ws_string (pp, "<uninstantiated>");
else
dump_expr (pp, TREE_PURPOSE (t), flags);
pp_cxx_right_paren (pp);
}
}
else if (t)
{
pp_cxx_ws_string (pp, "throw");
pp_cxx_whitespace (pp);
pp_cxx_left_paren (pp);
if (TREE_VALUE (t) != NULL_TREE)
while (1)
{
dump_type (pp, TREE_VALUE (t), flags);
t = TREE_CHAIN (t);
if (!t)
break;
pp_separate_with_comma (pp);
}
pp_cxx_right_paren (pp);
}
}
/* Handle the function name for a FUNCTION_DECL node, grokking operators
and destructors properly. */
static void
dump_function_name (cxx_pretty_printer *pp, tree t, int flags)
{
tree name = DECL_NAME (t);
/* We can get here with a decl that was synthesized by language-
independent machinery (e.g. coverage.cc) in which case it won't
have a lang_specific structure attached and DECL_CONSTRUCTOR_P
will crash. In this case it is safe just to print out the
literal name. */
if (!DECL_LANG_SPECIFIC (t))
{
pp_cxx_tree_identifier (pp, name);
return;
}
if (TREE_CODE (t) == TEMPLATE_DECL)
t = DECL_TEMPLATE_RESULT (t);
/* Don't let the user see __comp_ctor et al. */
if (DECL_CONSTRUCTOR_P (t)
|| DECL_DESTRUCTOR_P (t))
{
if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
name = get_identifier ("<lambda>");
else if (TYPE_UNNAMED_P (DECL_CONTEXT (t)))
name = get_identifier ("<constructor>");
else
name = constructor_name (DECL_CONTEXT (t));
}
if (DECL_DESTRUCTOR_P (t))
{
pp_cxx_complement (pp);
dump_decl (pp, name, TFF_PLAIN_IDENTIFIER);
}
else if (DECL_CONV_FN_P (t))
{
/* This cannot use the hack that the operator's return
type is stashed off of its name because it may be
used for error reporting. In the case of conflicting
declarations, both will have the same name, yet
the types will be different, hence the TREE_TYPE field
of the first name will be clobbered by the second. */
pp_cxx_ws_string (pp, "operator");
dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
}
else
dump_decl (pp, name, flags);
dump_module_suffix (pp, t);
if (DECL_TEMPLATE_INFO (t)
&& !(flags & TFF_TEMPLATE_NAME)
&& !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
&& (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
|| PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
dump_template_parms (pp, DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t),
flags);
}
/* Dump the template parameters from the template info INFO under control of
FLAGS. PRIMARY indicates whether this is a primary template decl, or
specialization (partial or complete). For partial specializations we show
the specialized parameter values. For a primary template we show no
decoration. */
static void
dump_template_parms (cxx_pretty_printer *pp, tree info,
int primary, int flags)
{
tree args = info ? TI_ARGS (info) : NULL_TREE;
if (primary && flags & TFF_TEMPLATE_NAME)
return;
flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
pp_cxx_begin_template_argument_list (pp);
/* Be careful only to print things when we have them, so as not
to crash producing error messages. */
if (args && !primary)
{
int len, ix;
len = get_non_default_template_args_count (args, flags);
args = INNERMOST_TEMPLATE_ARGS (args);
for (ix = 0; ix != len; ix++)
{
tree arg = TREE_VEC_ELT (args, ix);
/* Only print a comma if we know there is an argument coming. In
the case of an empty template argument pack, no actual
argument will be printed. */
if (ix
&& (!ARGUMENT_PACK_P (arg)
|| TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
pp_separate_with_comma (pp);
if (!arg)
pp_string (pp, M_("<template parameter error>"));
else
dump_template_argument (pp, arg, flags);
}
}
else if (primary)
{
tree tpl = TI_TEMPLATE (info);
tree parms = DECL_TEMPLATE_PARMS (tpl);
int len, ix;
parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
len = parms ? TREE_VEC_LENGTH (parms) : 0;
for (ix = 0; ix != len; ix++)
{
tree parm;
if (TREE_VEC_ELT (parms, ix) == error_mark_node)
{
pp_string (pp, M_("<template parameter error>"));
continue;
}
parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
if (ix)
pp_separate_with_comma (pp);
dump_decl (pp, parm, flags & ~TFF_DECL_SPECIFIERS);
}
}
pp_cxx_end_template_argument_list (pp);
}
/* Print out the arguments of CALL_EXPR T as a parenthesized list using
flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
static void
dump_call_expr_args (cxx_pretty_printer *pp, tree t, int flags, bool skipfirst)
{
tree arg;
call_expr_arg_iterator iter;
pp_cxx_left_paren (pp);
FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
{
if (skipfirst)
skipfirst = false;
else
{
dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
if (more_call_expr_args_p (&iter))
pp_separate_with_comma (pp);
}
}
pp_cxx_right_paren (pp);
}
/* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
using flags FLAGS. Skip over the first argument if SKIPFIRST is
true. */
static void
dump_aggr_init_expr_args (cxx_pretty_printer *pp, tree t, int flags,
bool skipfirst)
{
tree arg;
aggr_init_expr_arg_iterator iter;
pp_cxx_left_paren (pp);
FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
{
if (skipfirst)
skipfirst = false;
else
{
dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
if (more_aggr_init_expr_args_p (&iter))
pp_separate_with_comma (pp);
}
}
pp_cxx_right_paren (pp);
}
/* Print out a list of initializers (subr of dump_expr). */
static void
dump_expr_list (cxx_pretty_printer *pp, tree l, int flags)
{
while (l)
{
dump_expr (pp, TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
l = TREE_CHAIN (l);
if (l)
pp_separate_with_comma (pp);
}
}
/* Print out a vector of initializers (subr of dump_expr). */
static void
dump_expr_init_vec (cxx_pretty_printer *pp, vec<constructor_elt, va_gc> *v,
int flags)
{
unsigned HOST_WIDE_INT idx;
tree value;
FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
{
dump_expr (pp, value, flags | TFF_EXPR_IN_PARENS);
if (idx != v->length () - 1)
pp_separate_with_comma (pp);
}
}
/* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
function. Resolve it to a close relative -- in the sense of static
type -- variant being overridden. That is close to what was written in
the source code. Subroutine of dump_expr. */
static tree
resolve_virtual_fun_from_obj_type_ref (tree ref)
{
tree obj_type = TREE_TYPE (OBJ_TYPE_REF_TOKEN (ref));
HOST_WIDE_INT index = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref));
tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
while (index)
{
fun = TREE_CHAIN (fun);
index -= (TARGET_VTABLE_USES_DESCRIPTORS
? TARGET_VTABLE_USES_DESCRIPTORS : 1);
}
return BV_FN (fun);
}
/* Print out an expression E under control of FLAGS. */
static void
dump_expr (cxx_pretty_printer *pp, tree t, int flags)
{
tree op;
if (t == 0)
return;
if (STATEMENT_CLASS_P (t))
{
pp_cxx_ws_string (pp, M_("<statement>"));
return;
}
switch (TREE_CODE (t))
{
case VAR_DECL:
case PARM_DECL:
case FIELD_DECL:
case CONST_DECL:
case FUNCTION_DECL:
case TEMPLATE_DECL:
case NAMESPACE_DECL:
case LABEL_DECL:
case WILDCARD_DECL:
case OVERLOAD:
case TYPE_DECL:
case USING_DECL:
case IDENTIFIER_NODE:
dump_decl (pp, t, ((flags & ~(TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE
|TFF_TEMPLATE_HEADER))
| TFF_NO_TEMPLATE_BINDINGS
| TFF_NO_FUNCTION_ARGUMENTS));
break;
case SSA_NAME:
if (SSA_NAME_VAR (t)
&& !DECL_ARTIFICIAL (SSA_NAME_VAR (t)))
dump_expr (pp, SSA_NAME_VAR (t), flags);
else
pp_cxx_ws_string (pp, M_("<unknown>"));
break;
case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case STRING_CST:
case COMPLEX_CST:
pp->constant (t);
break;
case USERDEF_LITERAL:
pp_cxx_userdef_literal (pp, t);
break;
case THROW_EXPR:
/* While waiting for caret diagnostics, avoid printing
__cxa_allocate_exception, __cxa_throw, and the like. */
pp_cxx_ws_string (pp, M_("<throw-expression>"));
break;
case PTRMEM_CST:
pp_ampersand (pp);
dump_type (pp, PTRMEM_CST_CLASS (t), flags);
pp_cxx_colon_colon (pp);
pp_cxx_tree_identifier (pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
break;
case COMPOUND_EXPR:
pp_cxx_left_paren (pp);
dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
pp_separate_with_comma (pp);
dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
pp_cxx_right_paren (pp);
break;
case COND_EXPR:
case VEC_COND_EXPR:
pp_cxx_left_paren (pp);
dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
pp_string (pp, " ? ");
dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
pp_string (pp, " : ");
dump_expr (pp, TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
pp_cxx_right_paren (pp);
break;
case SAVE_EXPR:
if (TREE_HAS_CONSTRUCTOR (t))
{
pp_cxx_ws_string (pp, "new");
pp_cxx_whitespace (pp);
dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
}
else
dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
break;
case AGGR_INIT_EXPR:
{
tree fn = NULL_TREE;
if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
if (fn && TREE_CODE (fn) == FUNCTION_DECL)
{
if (DECL_CONSTRUCTOR_P (fn))
dump_type (pp, DECL_CONTEXT (fn), flags);
else
dump_decl (pp, fn, 0);
}
else
dump_expr (pp, AGGR_INIT_EXPR_FN (t), 0);
}
dump_aggr_init_expr_args (pp, t, flags, true);
break;
case CALL_EXPR:
{
tree fn = CALL_EXPR_FN (t);
bool skipfirst = false;
/* Deal with internal functions. */
if (fn == NULL_TREE)
{
pp_string (pp, internal_fn_name (CALL_EXPR_IFN (t)));
dump_call_expr_args (pp, t, flags, skipfirst);
break;
}
if (TREE_CODE (fn) == ADDR_EXPR)
fn = TREE_OPERAND (fn, 0);
/* Nobody is interested in seeing the guts of vcalls. */
if (TREE_CODE (fn) == OBJ_TYPE_REF)
fn = resolve_virtual_fun_from_obj_type_ref (fn);
if (TREE_TYPE (fn) != NULL_TREE
&& NEXT_CODE (fn) == METHOD_TYPE
&& call_expr_nargs (t))
{
tree ob = CALL_EXPR_ARG (t, 0);
if (TREE_CODE (ob) == ADDR_EXPR)
{
dump_expr (pp, TREE_OPERAND (ob, 0),
flags | TFF_EXPR_IN_PARENS);
pp_cxx_dot (pp);
}
else if (!is_this_parameter (ob))
{
dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
pp_cxx_arrow (pp);
}
skipfirst = true;
}
if (flag_sanitize & SANITIZE_UNDEFINED
&& is_ubsan_builtin_p (fn))
{
pp_string (cxx_pp, M_("<ubsan routine call>"));
break;
}
dump_expr (pp, fn, flags | TFF_EXPR_IN_PARENS);
dump_call_expr_args (pp, t, flags, skipfirst);
}
break;
case TARGET_EXPR:
/* Note that this only works for G++ target exprs. If somebody
builds a general TARGET_EXPR, there's no way to represent that
it initializes anything other that the parameter slot for the
default argument. Note we may have cleared out the first
operand in expand_expr, so don't go killing ourselves. */
if (TREE_OPERAND (t, 1))
dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
break;
case POINTER_PLUS_EXPR:
dump_binary_op (pp, "+", t, flags);
break;
case POINTER_DIFF_EXPR:
dump_binary_op (pp, "-", t, flags);
break;
case INIT_EXPR:
case MODIFY_EXPR:
dump_binary_op (pp, OVL_OP_INFO (true, NOP_EXPR)->name, t, flags);
break;
case PLUS_EXPR:
case MINUS_EXPR:
case MULT_EXPR:
case TRUNC_DIV_EXPR:
case TRUNC_MOD_EXPR:
case MIN_EXPR:
case MAX_EXPR:
case LSHIFT_EXPR:
case RSHIFT_EXPR:
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:
case BIT_AND_EXPR:
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
case LT_EXPR:
case LE_EXPR:
case GT_EXPR:
case GE_EXPR:
case EQ_EXPR:
case NE_EXPR:
case SPACESHIP_EXPR:
case EXACT_DIV_EXPR:
dump_binary_op (pp, OVL_OP_INFO (false, TREE_CODE (t))->name, t, flags);
break;
case CEIL_DIV_EXPR:
case FLOOR_DIV_EXPR:
case ROUND_DIV_EXPR:
case RDIV_EXPR:
dump_binary_op (pp, "/", t, flags);
break;
case CEIL_MOD_EXPR:
case FLOOR_MOD_EXPR:
case ROUND_MOD_EXPR:
dump_binary_op (pp, "%", t, flags);
break;
case COMPONENT_REF:
{
tree ob = TREE_OPERAND (t, 0);
if (INDIRECT_REF_P (ob))
{
ob = TREE_OPERAND (ob, 0);
if (!is_this_parameter (ob)
&& !is_dummy_object (ob))
{
dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
if (TYPE_REF_P (TREE_TYPE (ob)))
pp_cxx_dot (pp);
else
pp_cxx_arrow (pp);
}
}
else
{
dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
if (TREE_CODE (ob) != ARROW_EXPR)
pp_cxx_dot (pp);
}
dump_expr (pp, TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
}
break;
case ARRAY_REF:
dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
pp_cxx_left_bracket (pp);
dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
pp_cxx_right_bracket (pp);
break;
case UNARY_PLUS_EXPR:
dump_unary_op (pp, "+", t, flags);
break;
case ADDR_EXPR:
if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
|| TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
/* An ADDR_EXPR can have reference type. In that case, we
shouldn't print the `&' doing so indicates to the user
that the expression has pointer type. */
|| (TREE_TYPE (t)
&& TYPE_REF_P (TREE_TYPE (t))))
dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
dump_unary_op (pp, "&&", t, flags);
else
dump_unary_op (pp, "&", t, flags);
break;
case INDIRECT_REF:
if (TREE_HAS_CONSTRUCTOR (t))
{
t = TREE_OPERAND (t, 0);
gcc_assert (TREE_CODE (t) == CALL_EXPR);
dump_expr (pp, CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
dump_call_expr_args (pp, t, flags, true);
}
else
{
if (TREE_OPERAND (t,0) != NULL_TREE
&& TREE_TYPE (TREE_OPERAND (t, 0))
&& NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
dump_expr (pp, TREE_OPERAND (t, 0), flags);
else
dump_unary_op (pp, "*", t, flags);
}
break;
case MEM_REF:
/* Delegate to the base "C" pretty printer. */
pp->c_pretty_printer::unary_expression (t);
break;
case TARGET_MEM_REF:
/* TARGET_MEM_REF can't appear directly from source, but can appear
during late GIMPLE optimizations and through late diagnostic we might
need to support it. Print it as dereferencing of a pointer after
cast to the TARGET_MEM_REF type, with pointer arithmetics on some
pointer to single byte types, so
*(type *)((char *) ptr + step * index + index2) if all the operands
are present and the casts are needed. */
pp_cxx_star (pp);
pp_cxx_left_paren (pp);
if (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (TMR_BASE (t)))) == NULL_TREE
|| !integer_onep (TYPE_SIZE_UNIT
(TREE_TYPE (TREE_TYPE (TMR_BASE (t))))))
{
if (TYPE_SIZE_UNIT (TREE_TYPE (t))
&& integer_onep (TYPE_SIZE_UNIT (TREE_TYPE (t))))
{
pp_cxx_left_paren (pp);
dump_type (pp, build_pointer_type (TREE_TYPE (t)), flags);
}
else
{
dump_type (pp, build_pointer_type (TREE_TYPE (t)), flags);
pp_cxx_right_paren (pp);
pp_cxx_left_paren (pp);
pp_cxx_left_paren (pp);
dump_type (pp, build_pointer_type (char_type_node), flags);
}
pp_cxx_right_paren (pp);
}
else if (!same_type_p (TREE_TYPE (t),
TREE_TYPE (TREE_TYPE (TMR_BASE (t)))))
{
dump_type (pp, build_pointer_type (TREE_TYPE (t)), flags);
pp_cxx_right_paren (pp);
pp_cxx_left_paren (pp);
}
dump_expr (pp, TMR_BASE (t), flags);
if (TMR_STEP (t) && TMR_INDEX (t))
{
pp_cxx_ws_string (pp, "+");
dump_expr (pp, TMR_INDEX (t), flags);
pp_cxx_ws_string (pp, "*");
dump_expr (pp, TMR_STEP (t), flags);
}
if (TMR_INDEX2 (t))
{
pp_cxx_ws_string (pp, "+");
dump_expr (pp, TMR_INDEX2 (t), flags);
}
if (!integer_zerop (TMR_OFFSET (t)))
{
pp_cxx_ws_string (pp, "+");
dump_expr (pp, fold_convert (ssizetype, TMR_OFFSET (t)), flags);
}
pp_cxx_right_paren (pp);
break;
case NEGATE_EXPR:
case BIT_NOT_EXPR:
case TRUTH_NOT_EXPR:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
dump_unary_op (pp, OVL_OP_INFO (false, TREE_CODE (t))->name, t, flags);
break;
case POSTDECREMENT_EXPR:
case POSTINCREMENT_EXPR:
pp_cxx_left_paren (pp);
dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
pp_cxx_ws_string (pp, OVL_OP_INFO (false, TREE_CODE (t))->name);
pp_cxx_right_paren (pp);
break;
case NON_LVALUE_EXPR:
/* FIXME: This is a KLUDGE workaround for a parsing problem. There
should be another level of INDIRECT_REF so that I don't have to do
this. */
if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
{
tree next = TREE_TYPE (TREE_TYPE (t));
while (TYPE_PTR_P (next))
next = TREE_TYPE (next);
if (TREE_CODE (next) == FUNCTION_TYPE)
{
if (flags & TFF_EXPR_IN_PARENS)
pp_cxx_left_paren (pp);
pp_cxx_star (pp);
dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
if (flags & TFF_EXPR_IN_PARENS)
pp_cxx_right_paren (pp);
break;
}
/* Else fall through. */
}
dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
break;
CASE_CONVERT:
case IMPLICIT_CONV_EXPR:
case VIEW_CONVERT_EXPR:
{
tree op = TREE_OPERAND (t, 0);
if (location_wrapper_p (t))
{
dump_expr (pp, op, flags);
break;
}
tree ttype = TREE_TYPE (t);
tree optype = TREE_TYPE (op);
if (TREE_CODE (ttype) != TREE_CODE (optype)
&& INDIRECT_TYPE_P (ttype)
&& INDIRECT_TYPE_P (optype)
&& same_type_p (TREE_TYPE (optype),
TREE_TYPE (ttype)))
{
if (TYPE_REF_P (ttype))
{
STRIP_NOPS (op);
if (TREE_CODE (op) == ADDR_EXPR)
dump_expr (pp, TREE_OPERAND (op, 0), flags);
else
dump_unary_op (pp, "*", t, flags);
}
else
dump_unary_op (pp, "&", t, flags);
}
else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
{
/* It is a cast, but we cannot tell whether it is a
reinterpret or static cast. Use the C style notation. */
if (flags & TFF_EXPR_IN_PARENS)
pp_cxx_left_paren (pp);
pp_cxx_left_paren (pp);
dump_type (pp, TREE_TYPE (t), flags);
pp_cxx_right_paren (pp);
dump_expr (pp, op, flags | TFF_EXPR_IN_PARENS);
if (flags & TFF_EXPR_IN_PARENS)
pp_cxx_right_paren (pp);
}
else
dump_expr (pp, op, flags);
break;
}
case CONSTRUCTOR:
if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
{
tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
if (integer_zerop (idx))
{
/* A NULL pointer-to-member constant. */
pp_cxx_left_paren (pp);
pp_cxx_left_paren (pp);
dump_type (pp, TREE_TYPE (t), flags);
pp_cxx_right_paren (pp);
pp_character (pp, '0');
pp_cxx_right_paren (pp);
break;
}
else if (tree_fits_shwi_p (idx))
{
tree virtuals;
unsigned HOST_WIDE_INT n;
t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
t = TYPE_METHOD_BASETYPE (t);
virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
n = tree_to_shwi (idx);
/* Map vtable index back one, to allow for the null pointer to
member. */
--n;
while (n > 0 && virtuals)
{
--n;
virtuals = TREE_CHAIN (virtuals);
}
if (virtuals)
{
dump_expr (pp, BV_FN (virtuals),
flags | TFF_EXPR_IN_PARENS);
break;
}
}
}
if (TREE_TYPE (t) && LAMBDA_TYPE_P (TREE_TYPE (t)))
pp_string (pp, "<lambda closure object>");
if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
{
dump_type (pp, TREE_TYPE (t), 0);
pp_cxx_left_paren (pp);
pp_cxx_right_paren (pp);
}
else
{
if (!BRACE_ENCLOSED_INITIALIZER_P (t))
dump_type (pp, TREE_TYPE (t), 0);
pp_cxx_left_brace (pp);
dump_expr_init_vec (pp, CONSTRUCTOR_ELTS (t), flags);
pp_cxx_right_brace (pp);
}
break;
case OFFSET_REF:
{
tree ob = TREE_OPERAND (t, 0);
if (is_dummy_object (ob))
{
t = TREE_OPERAND (t, 1);
if (TREE_CODE (t) == FUNCTION_DECL)
/* A::f */
dump_expr (pp, t, flags | TFF_EXPR_IN_PARENS);
else if (BASELINK_P (t))
dump_expr (pp, OVL_FIRST (BASELINK_FUNCTIONS (t)),
flags | TFF_EXPR_IN_PARENS);
else
dump_decl (pp, t, flags);
}
else
{
if (INDIRECT_REF_P (ob))
{
dump_expr (pp, TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
pp_cxx_arrow (pp);
pp_cxx_star (pp);
}
else
{
dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
pp_cxx_dot (pp);
pp_cxx_star (pp);
}
dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
}
break;
}
case TEMPLATE_PARM_INDEX:
dump_decl (pp, TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
break;
case CAST_EXPR:
if (TREE_OPERAND (t, 0) == NULL_TREE
|| TREE_CHAIN (TREE_OPERAND (t, 0)))
{
dump_type (pp, TREE_TYPE (t), flags);
pp_cxx_left_paren (pp);
dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
pp_cxx_right_paren (pp);
}
else
{
pp_cxx_left_paren (pp);
dump_type (pp, TREE_TYPE (t), flags);
pp_cxx_right_paren (pp);
pp_cxx_left_paren (pp);
dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
pp_cxx_right_paren (pp);
}
break;
case STATIC_CAST_EXPR:
pp_cxx_ws_string (pp, "static_cast");
goto cast;
case REINTERPRET_CAST_EXPR:
pp_cxx_ws_string (pp, "reinterpret_cast");
goto cast;
case CONST_CAST_EXPR:
pp_cxx_ws_string (pp, "const_cast");
goto cast;
case DYNAMIC_CAST_EXPR:
pp_cxx_ws_string (pp, "dynamic_cast");
cast:
pp_cxx_begin_template_argument_list (pp);
dump_type (pp, TREE_TYPE (t), flags);
pp_cxx_end_template_argument_list (pp);
pp_cxx_left_paren (pp);
dump_expr (pp, TREE_OPERAND (t, 0), flags);
pp_cxx_right_paren (pp);
break;
case ARROW_EXPR:
dump_expr (pp, TREE_OPERAND (t, 0), flags);
pp_cxx_arrow (pp);
break;
case SIZEOF_EXPR:
case ALIGNOF_EXPR:
if (TREE_CODE (t) == SIZEOF_EXPR)
pp_cxx_ws_string (pp, "sizeof");
else
{
gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
pp_cxx_ws_string (pp, "__alignof__");
}
op = TREE_OPERAND (t, 0);
if (PACK_EXPANSION_P (op))
{
pp_string (pp, "...");
op = PACK_EXPANSION_PATTERN (op);
}
pp_cxx_whitespace (pp);
pp_cxx_left_paren (pp);
if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t))
dump_type (pp, TREE_TYPE (op), flags);
else if (TYPE_P (TREE_OPERAND (t, 0)))
dump_type (pp, op, flags);
else
dump_expr (pp, op, flags);
pp_cxx_right_paren (pp);
break;
case AT_ENCODE_EXPR:
pp_cxx_ws_string (pp, "@encode");
pp_cxx_whitespace (pp);
pp_cxx_left_paren (pp);
dump_type (pp, TREE_OPERAND (t, 0), flags);
pp_cxx_right_paren (pp);
break;
case NOEXCEPT_EXPR:
pp_cxx_ws_string (pp, "noexcept");
pp_cxx_whitespace (pp);
pp_cxx_left_paren (pp);
dump_expr (pp, TREE_OPERAND (t, 0), flags);
pp_cxx_right_paren (pp);
break;
case REALPART_EXPR:
case IMAGPART_EXPR:
pp_cxx_ws_string (pp, OVL_OP_INFO (false, TREE_CODE (t))->name);
pp_cxx_whitespace (pp);
dump_expr (pp, TREE_OPERAND (t, 0), flags);
break;
case DEFERRED_PARSE:
pp_string (pp, M_("<unparsed>"));
break;
case TRY_CATCH_EXPR:
case CLEANUP_POINT_EXPR:
dump_expr (pp, TREE_OPERAND (t, 0), flags);
break;
case PSEUDO_DTOR_EXPR:
dump_expr (pp, TREE_OPERAND (t, 0), flags);
pp_cxx_dot (pp);
if (TREE_OPERAND (t, 1))
{
dump_type (pp, TREE_OPERAND (t, 1), flags);
pp_cxx_colon_colon (pp);
}
pp_cxx_complement (pp);
dump_type (pp, TREE_OPERAND (t, 2), flags);
break;
case TEMPLATE_ID_EXPR:
dump_decl (pp, t, flags);
break;
case BIND_EXPR:
case STMT_EXPR:
case EXPR_STMT:
case STATEMENT_LIST:
/* We don't yet have a way of dumping statements in a
human-readable format. */
pp_string (pp, "({...})");
break;
case LOOP_EXPR:
pp_string (pp, "while (1) { ");
dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
pp_cxx_right_brace (pp);
break;
case EXIT_EXPR:
pp_string (pp, "if (");
dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
pp_string (pp, ") break; ");
break;
case BASELINK:
dump_expr (pp, BASELINK_FUNCTIONS (t), flags & ~TFF_EXPR_IN_PARENS);
break;
case EMPTY_CLASS_EXPR:
dump_type (pp, TREE_TYPE (t), flags);
pp_cxx_left_paren (pp);
pp_cxx_right_paren (pp);
break;
case NON_DEPENDENT_EXPR:
dump_expr (pp, TREE_OPERAND (t, 0), flags);
break;
case ARGUMENT_PACK_SELECT:
dump_template_argument (pp, ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
break;
case RECORD_TYPE:
case UNION_TYPE:
case ENUMERAL_TYPE:
case REAL_TYPE:
case VOID_TYPE:
case OPAQUE_TYPE:
case BOOLEAN_TYPE:
case INTEGER_TYPE:
case COMPLEX_TYPE:
case VECTOR_TYPE:
case DECLTYPE_TYPE:
pp_type_specifier_seq (pp, t);
break;
case TYPENAME_TYPE:
/* We get here when we want to print a dependent type as an
id-expression, without any disambiguator decoration. */
pp->id_expression (t);
break;
case TEMPLATE_TYPE_PARM:
case TEMPLATE_TEMPLATE_PARM:
case BOUND_TEMPLATE_TEMPLATE_PARM:
dump_type (pp, t, flags);
break;
case TRAIT_EXPR:
pp_cxx_trait_expression (pp, t);
break;
case VA_ARG_EXPR:
pp_cxx_va_arg_expression (pp, t);
break;
case OFFSETOF_EXPR:
pp_cxx_offsetof_expression (pp, t);
break;
case ADDRESSOF_EXPR:
pp_cxx_addressof_expression (pp, t);
break;
case SCOPE_REF:
dump_decl (pp, t, flags);
break;
case EXPR_PACK_EXPANSION:
case UNARY_LEFT_FOLD_EXPR:
case UNARY_RIGHT_FOLD_EXPR:
case BINARY_LEFT_FOLD_EXPR:
case BINARY_RIGHT_FOLD_EXPR:
case TYPEID_EXPR:
case MEMBER_REF:
case DOTSTAR_EXPR:
case NEW_EXPR:
case VEC_NEW_EXPR:
case DELETE_EXPR:
case VEC_DELETE_EXPR:
case MODOP_EXPR:
case ABS_EXPR:
case ABSU_EXPR:
case CONJ_EXPR:
case VECTOR_CST:
case FIXED_CST:
case UNORDERED_EXPR:
case ORDERED_EXPR:
case UNLT_EXPR:
case UNLE_EXPR:
case UNGT_EXPR:
case UNGE_EXPR:
case UNEQ_EXPR:
case LTGT_EXPR:
case COMPLEX_EXPR:
case BIT_FIELD_REF:
case FIX_TRUNC_EXPR:
case FLOAT_EXPR:
pp->expression (t);
break;
case TRUTH_AND_EXPR:
case TRUTH_OR_EXPR:
case TRUTH_XOR_EXPR:
if (flags & TFF_EXPR_IN_PARENS)
pp_cxx_left_paren (pp);
pp->expression (t);
if (flags & TFF_EXPR_IN_PARENS)
pp_cxx_right_paren (pp);
break;
case OBJ_TYPE_REF:
dump_expr (pp, resolve_virtual_fun_from_obj_type_ref (t), flags);
break;
case LAMBDA_EXPR:
pp_string (pp, M_("<lambda>"));
break;
case PAREN_EXPR:
pp_cxx_left_paren (pp);
dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
pp_cxx_right_paren (pp);
break;
case REQUIRES_EXPR:
pp_cxx_requires_expr (cxx_pp, t);
break;
case SIMPLE_REQ:
pp_cxx_simple_requirement (cxx_pp, t);
break;
case TYPE_REQ:
pp_cxx_type_requirement (cxx_pp, t);
break;
case COMPOUND_REQ:
pp_cxx_compound_requirement (cxx_pp, t);
break;
case NESTED_REQ:
pp_cxx_nested_requirement (cxx_pp, t);
break;
case ATOMIC_CONSTR:
case CHECK_CONSTR:
case CONJ_CONSTR:
case DISJ_CONSTR:
{
pp_cxx_constraint (cxx_pp, t);
break;
}
case PLACEHOLDER_EXPR:
pp_string (pp, M_("*this"));
break;
case TREE_LIST:
dump_expr_list (pp, t, flags);
break;
/* This list is incomplete, but should suffice for now.
It is very important that `sorry' does not call
`report_error_function'. That could cause an infinite loop. */
default:
pp_unsupported_tree (pp, t);
/* Fall through. */
case ERROR_MARK:
pp_string (pp, M_("<expression error>"));
break;
}
}
static void
dump_binary_op (cxx_pretty_printer *pp, const char *opstring, tree t,
int flags)
{
pp_cxx_left_paren (pp);
dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
pp_cxx_whitespace (pp);
if (opstring)
pp_cxx_ws_string (pp, opstring);
else
pp_string (pp, M_("<unknown operator>"));
pp_cxx_whitespace (pp);
tree op1 = TREE_OPERAND (t, 1);
if (TREE_CODE (t) == POINTER_PLUS_EXPR
&& TREE_CODE (op1) == INTEGER_CST
&& tree_int_cst_sign_bit (op1))
/* A pointer minus an integer is represented internally as plus a very
large number, don't expose that to users. */
op1 = convert (ssizetype, op1);
dump_expr (pp, op1, flags | TFF_EXPR_IN_PARENS);
pp_cxx_right_paren (pp);
}
static void
dump_unary_op (cxx_pretty_printer *pp, const char *opstring, tree t, int flags)
{
if (flags & TFF_EXPR_IN_PARENS)
pp_cxx_left_paren (pp);
pp_cxx_ws_string (pp, opstring);
dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
if (flags & TFF_EXPR_IN_PARENS)
pp_cxx_right_paren (pp);
}
static void
reinit_cxx_pp (void)
{
pp_clear_output_area (cxx_pp);
cxx_pp->padding = pp_none;
pp_indentation (cxx_pp) = 0;
pp_needs_newline (cxx_pp) = false;
cxx_pp->enclosing_scope = current_function_decl;
}
/* Same as pp_formatted_text, except the return string is a separate
copy and has a GGC storage duration, e.g. an indefinite lifetime. */
inline const char *
pp_ggc_formatted_text (pretty_printer *pp)
{
return ggc_strdup (pp_formatted_text (pp));
}
/* Exported interface to stringifying types, exprs and decls under TFF_*
control. */
const char *
type_as_string (tree typ, int flags)
{
reinit_cxx_pp ();
pp_translate_identifiers (cxx_pp) = false;
dump_type (cxx_pp, typ, flags);
return pp_ggc_formatted_text (cxx_pp);
}
const char *
type_as_string_translate (tree typ, int flags)
{
reinit_cxx_pp ();
dump_type (cxx_pp, typ, flags);
return pp_ggc_formatted_text (cxx_pp);
}
const char *
expr_as_string (tree decl, int flags)
{
reinit_cxx_pp ();
pp_translate_identifiers (cxx_pp) = false;
dump_expr (cxx_pp, decl, flags);
return pp_ggc_formatted_text (cxx_pp);
}
/* Wrap decl_as_string with options appropriate for dwarf. */
const char *
decl_as_dwarf_string (tree decl, int flags)
{
const char *name;