/* Change flag_abi_version to be the actual current ABI level, for the
benefit of c_cpp_builtins, and to make comparison simpler. */
- const int latest_abi_version = 18;
+ const int latest_abi_version = 19;
/* Generate compatibility aliases for ABI v13 (8.2) by default. */
const int abi_compat_default = 13;
; 18: Corrects errors in mangling of lambdas with additional context.
; Default in G++ 13.
;
+; 19: Emits ABI tags if needed in structured binding mangled names.
+; Default in G++ 14.
+;
; Additional positive integers will be assigned as new versions of
; the ABI become the default version of the ABI.
fabi-version=
extern void note_break_stmt (void);
extern bool note_iteration_stmt_body_start (void);
extern void note_iteration_stmt_body_end (bool);
-extern void determine_local_discriminator (tree);
+extern void determine_local_discriminator (tree, tree = NULL_TREE);
extern bool member_like_constrained_friend_p (tree);
extern bool fns_correspond (tree, tree);
extern int decls_match (tree, tree, bool = true);
extern void start_decl_1 (tree, bool);
extern bool check_array_initializer (tree, tree, tree);
extern void omp_declare_variant_finalize (tree, tree);
-extern void cp_finish_decl (tree, tree, bool, tree, int);
+struct cp_decomp { tree decl; unsigned int count; };
+extern void cp_finish_decl (tree, tree, bool, tree, int, cp_decomp * = nullptr);
extern tree lookup_decomp_type (tree);
-extern void cp_maybe_mangle_decomp (tree, tree, unsigned int);
-extern void cp_finish_decomp (tree, tree, unsigned int);
+extern void cp_finish_decomp (tree, cp_decomp *);
extern int cp_complete_array_type (tree *, tree, bool);
extern int cp_complete_array_type_or_error (tree *, tree, bool, tsubst_flags_t);
extern tree build_ptrmemfunc_type (tree);
extern bool maybe_clone_body (tree);
/* In parser.cc */
-extern tree cp_convert_range_for (tree, tree, tree, tree, unsigned int, bool,
+extern tree cp_convert_range_for (tree, tree, tree, cp_decomp *, bool,
unsigned short, bool);
extern void cp_convert_omp_range_for (tree &, tree &, tree &,
tree &, tree &, tree &, tree &, tree &);
generally very few of these in any particular function. */
void
-determine_local_discriminator (tree decl)
+determine_local_discriminator (tree decl, tree name)
{
auto_cond_timevar tv (TV_NAME_LOOKUP);
retrofit_lang_decl (decl);
tree ctx = DECL_CONTEXT (decl);
- tree name = (TREE_CODE (decl) == TYPE_DECL
- && TYPE_UNNAMED_P (TREE_TYPE (decl))
- ? NULL_TREE : DECL_NAME (decl));
size_t nelts = vec_safe_length (local_entities);
+ if (name == NULL_TREE)
+ name = (TREE_CODE (decl) == TYPE_DECL
+ && TYPE_UNNAMED_P (TREE_TYPE (decl))
+ ? NULL_TREE : DECL_NAME (decl));
for (size_t i = 0; i < nelts; i += 2)
{
tree *pair = &(*local_entities)[i];
void
maybe_commonize_var (tree decl)
{
- /* Don't mess with __FUNCTION__ and similar. */
- if (DECL_ARTIFICIAL (decl))
+ /* Don't mess with __FUNCTION__ and similar. But do handle structured
+ bindings. */
+ if (DECL_ARTIFICIAL (decl) && !DECL_DECOMPOSITION_P (decl))
return;
/* Static data in a function with comdat linkage also has comdat
}
}
+static void cp_maybe_mangle_decomp (tree, cp_decomp *);
+
/* Finish processing of a declaration;
install its line number and initial value.
If the length of an array type is not known before,
true, then INIT is an integral constant expression.
FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
- if the (init) syntax was used. */
+ if the (init) syntax was used.
+
+ DECOMP is first identifier's DECL and identifier count in a structured
+ bindings, nullptr if not a structured binding. */
void
cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
- tree asmspec_tree, int flags)
+ tree asmspec_tree, int flags, cp_decomp *decomp)
{
vec<tree, va_gc> *cleanups = NULL;
const char *asmspec = NULL;
return;
}
+ if (decomp)
+ cp_maybe_mangle_decomp (decl, decomp);
+
/* If this is a local variable that will need a mangled name,
register it now. We must do this before processing the
initializer for the variable, since the initialization might
/* Mangle a decomposition declaration if needed. Arguments like
in cp_finish_decomp. */
-void
-cp_maybe_mangle_decomp (tree decl, tree first, unsigned int count)
+static void
+cp_maybe_mangle_decomp (tree decl, cp_decomp *decomp)
{
if (!processing_template_decl
&& !error_operand_p (decl)
&& TREE_STATIC (decl))
{
auto_vec<tree, 16> v;
- v.safe_grow (count, true);
- tree d = first;
- for (unsigned int i = 0; i < count; i++, d = DECL_CHAIN (d))
- v[count - i - 1] = d;
+ v.safe_grow (decomp->count, true);
+ tree d = decomp->decl;
+ for (unsigned int i = 0; i < decomp->count; i++, d = DECL_CHAIN (d))
+ v[decomp->count - i - 1] = d;
+ if (DECL_FUNCTION_SCOPE_P (decl))
+ {
+ size_t sz = 3;
+ for (unsigned int i = 0; i < decomp->count; ++i)
+ sz += IDENTIFIER_LENGTH (DECL_NAME (v[i])) + 1;
+ char *name = XALLOCAVEC (char, sz);
+ name[0] = 'D';
+ name[1] = 'C';
+ char *p = name + 2;
+ for (unsigned int i = 0; i < decomp->count; ++i)
+ {
+ size_t len = IDENTIFIER_LENGTH (DECL_NAME (v[i]));
+ *p++ = ' ';
+ memcpy (p, IDENTIFIER_POINTER (DECL_NAME (v[i])), len);
+ p += len;
+ }
+ *p = '\0';
+ determine_local_discriminator (decl, get_identifier (name));
+ }
SET_DECL_ASSEMBLER_NAME (decl, mangle_decomp (decl, v));
maybe_apply_pragma_weak (decl);
}
those decls. */
void
-cp_finish_decomp (tree decl, tree first, unsigned int count)
+cp_finish_decomp (tree decl, cp_decomp *decomp)
{
+ tree first = decomp->decl;
+ unsigned count = decomp->count;
if (error_operand_p (decl))
{
error_out:
add_substitution (substitution);
}
-/* As the list of identifiers for the structured binding declaration
- DECL is likely gone, try to recover the DC <source-name>+ E portion
- from its mangled name. Return pointer to the DC and set len to
- the length up to and including the terminating E. On failure
- return NULL. */
-
-static const char *
-find_decomp_unqualified_name (tree decl, size_t *len)
-{
- const char *p = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
- const char *end = p + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl));
- bool nested = false;
- if (!startswith (p, "_Z"))
- return NULL;
- p += 2;
- if (startswith (p, "St"))
- p += 2;
- else if (*p == 'N')
- {
- nested = true;
- ++p;
- while (ISDIGIT (p[0]))
- {
- char *e;
- long num = strtol (p, &e, 10);
- if (num >= 1 && num < end - e)
- p = e + num;
- else
- break;
- }
- }
- if (!startswith (p, "DC"))
- return NULL;
- if (nested)
- {
- if (end[-1] != 'E')
- return NULL;
- --end;
- }
- if (end[-1] != 'E')
- return NULL;
- *len = end - p;
- return p;
-}
-
/* "For the purposes of mangling, the name of an anonymous union is considered
to be the name of the first named data member found by a pre-order,
depth-first, declaration-order walk of the data members of the anonymous
{
found = true;
gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
- const char *decomp_str = NULL;
- size_t decomp_len = 0;
- if (VAR_P (decl)
- && DECL_DECOMPOSITION_P (decl)
- && DECL_NAME (decl) == NULL_TREE
- && DECL_NAMESPACE_SCOPE_P (decl))
- decomp_str = find_decomp_unqualified_name (decl, &decomp_len);
- if (decomp_str)
- write_chars (decomp_str, decomp_len);
- else
- write_source_name (DECL_ASSEMBLER_NAME (decl));
+ write_source_name (DECL_ASSEMBLER_NAME (decl));
}
else if (DECL_DECLARES_FUNCTION_P (decl))
{
location_t saved_loc = input_location;
input_location = DECL_SOURCE_LOCATION (decl);
+ check_abi_tags (decl);
start_mangling (decl);
write_string ("_Z");
gcc_assert (context != NULL_TREE);
bool nested = false;
+ bool local = false;
if (DECL_NAMESPACE_STD_P (context))
write_string ("St");
+ else if (TREE_CODE (context) == FUNCTION_DECL)
+ {
+ local = true;
+ write_char ('Z');
+ write_encoding (context);
+ write_char ('E');
+ }
else if (context != global_namespace)
{
nested = true;
write_char ('N');
- write_prefix (decl_mangling_context (decl));
+ write_prefix (context);
}
write_string ("DC");
write_unqualified_name (d);
write_char ('E');
+ if (tree tags = get_abi_tags (decl))
+ {
+ /* We didn't emit ABI tags for structured bindings before ABI 19. */
+ if (!G.need_abi_warning
+ && TREE_PUBLIC (decl)
+ && abi_warn_or_compat_version_crosses (19))
+ G.need_abi_warning = 1;
+
+ if (abi_version_at_least (19))
+ write_abi_tags (tags);
+ }
+
if (nested)
write_char ('E');
+ else if (local && DECL_DISCRIMINATOR_P (decl))
+ write_discriminator (discriminator_for_local_entity (decl));
tree id = finish_mangling_get_identifier ();
if (DEBUG_MANGLE)
IDENTIFIER_POINTER (id));
input_location = saved_loc;
+
+ if (warn_abi && G.need_abi_warning)
+ {
+ const char fabi_version[] = "-fabi-version";
+ tree id2 = id;
+ int save_ver = flag_abi_version;
+
+ if (flag_abi_version != warn_abi_version)
+ {
+ flag_abi_version = warn_abi_version;
+ id2 = mangle_decomp (decl, decls);
+ flag_abi_version = save_ver;
+ }
+
+ if (id2 == id)
+ /* OK. */;
+ else if (warn_abi_version != 0
+ && abi_version_at_least (warn_abi_version))
+ warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
+ "the mangled name of %qD changed between "
+ "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
+ G.entity, fabi_version, warn_abi_version, id2,
+ fabi_version, save_ver, id);
+ else
+ warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
+ "the mangled name of %qD changes between "
+ "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
+ G.entity, fabi_version, save_ver, id,
+ fabi_version, warn_abi_version, id2);
+ }
+
return id;
}
/* The name of a guard variable for a reference temporary should refer
to the reference, not the temporary. */
write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
+ else if (DECL_DECOMPOSITION_P (variable)
+ && DECL_NAME (variable) == NULL_TREE
+ && startswith (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (variable)),
+ "_Z"))
+ /* The name of a guard variable for a structured binding needs special
+ casing. */
+ write_string (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (variable)) + 2);
else
write_name (variable, /*ignore_local_scope=*/0);
}
start_mangling (variable);
write_string ("_ZGR");
check_abi_tags (variable);
- write_name (variable, /*ignore_local_scope=*/0);
+ write_guarded_var_name (variable);
/* Avoid name clashes with aggregate initialization of multiple
references at once. */
write_compact_number (current_ref_temp_count++);
static tree cp_parser_range_for
(cp_parser *, tree, tree, tree, bool, unsigned short, bool, bool);
static void do_range_for_auto_deduction
- (tree, tree, tree, unsigned int);
+ (tree, tree, cp_decomp *);
static tree cp_parser_perform_range_for_lookup
(tree, tree *, tree *);
static tree cp_parser_range_for_member_function
tree stmt, range_expr;
auto_vec <cxx_binding *, 16> bindings;
auto_vec <tree, 16> names;
- tree decomp_first_name = NULL_TREE;
- unsigned int decomp_cnt = 0;
+ cp_decomp decomp_d, *decomp = NULL;
/* Get the range declaration momentarily out of the way so that
the range expression doesn't clash with it. */
{
tree d = range_decl;
range_decl = TREE_OPERAND (v, 0);
- decomp_cnt = tree_to_uhwi (TREE_OPERAND (v, 1)) + 1;
- decomp_first_name = d;
- for (unsigned int i = 0; i < decomp_cnt; i++, d = DECL_CHAIN (d))
+ decomp = &decomp_d;
+ decomp->count = tree_to_uhwi (TREE_OPERAND (v, 1)) + 1;
+ decomp->decl = d;
+ for (unsigned int i = 0; i < decomp->count;
+ i++, d = DECL_CHAIN (d))
{
tree name = DECL_NAME (d);
names.safe_push (name);
if (!type_dependent_expression_p (range_expr)
/* do_auto_deduction doesn't mess with template init-lists. */
&& !BRACE_ENCLOSED_INITIALIZER_P (range_expr))
- do_range_for_auto_deduction (range_decl, range_expr, decomp_first_name,
- decomp_cnt);
+ do_range_for_auto_deduction (range_decl, range_expr, decomp);
}
else
{
stmt = begin_for_stmt (scope, init);
- stmt = cp_convert_range_for (stmt, range_decl, range_expr,
- decomp_first_name, decomp_cnt, ivdep,
- unroll, novector);
+ stmt = cp_convert_range_for (stmt, range_decl, range_expr, decomp,
+ ivdep, unroll, novector);
}
return stmt;
}
a shortcut version of cp_convert_range_for. */
static void
-do_range_for_auto_deduction (tree decl, tree range_expr,
- tree decomp_first_name, unsigned int decomp_cnt)
+do_range_for_auto_deduction (tree decl, tree range_expr, cp_decomp *decomp)
{
tree auto_node = type_uses_auto (TREE_TYPE (decl));
if (auto_node)
tf_warning_or_error,
adc_variable_type);
if (VAR_P (decl) && DECL_DECOMPOSITION_P (decl))
- cp_finish_decomp (decl, decomp_first_name, decomp_cnt);
+ cp_finish_decomp (decl, decomp);
}
}
}
tree
cp_convert_range_for (tree statement, tree range_decl, tree range_expr,
- tree decomp_first_name, unsigned int decomp_cnt,
- bool ivdep, unsigned short unroll, bool novector)
+ cp_decomp *decomp, bool ivdep, unsigned short unroll,
+ bool novector)
{
tree begin, end;
tree iter_type, begin_expr, end_expr;
tf_warning_or_error);
finish_for_expr (expression, statement);
- if (VAR_P (range_decl) && DECL_DECOMPOSITION_P (range_decl))
- cp_maybe_mangle_decomp (range_decl, decomp_first_name, decomp_cnt);
-
/* The declaration is initialized with *__begin inside the loop body. */
tree deref_begin = build_x_indirect_ref (input_location, begin, RO_UNARY_STAR,
NULL_TREE, tf_warning_or_error);
cp_finish_decl (range_decl, deref_begin,
/*is_constant_init*/false, NULL_TREE,
- LOOKUP_ONLYCONVERTING);
+ LOOKUP_ONLYCONVERTING, decomp);
if (VAR_P (range_decl) && DECL_DECOMPOSITION_P (range_decl))
- cp_finish_decomp (range_decl, decomp_first_name, decomp_cnt);
+ cp_finish_decomp (range_decl, decomp);
warn_for_range_copy (range_decl, deref_begin);
if (decl != error_mark_node)
{
- cp_maybe_mangle_decomp (decl, prev, v.length ());
+ cp_decomp decomp = { prev, v.length () };
cp_finish_decl (decl, initializer, non_constant_p, NULL_TREE,
- (is_direct_init ? LOOKUP_NORMAL : LOOKUP_IMPLICIT));
- cp_finish_decomp (decl, prev, v.length ());
+ (is_direct_init ? LOOKUP_NORMAL : LOOKUP_IMPLICIT),
+ &decomp);
+ cp_finish_decomp (decl, &decomp);
}
}
else if (decl != error_mark_node)
{
*maybe_range_for_decl = prev;
+ cp_decomp decomp = { prev, v.length () };
/* Ensure DECL_VALUE_EXPR is created for all the decls but
the underlying DECL. */
- cp_finish_decomp (decl, prev, v.length ());
+ cp_finish_decomp (decl, &decomp);
}
if (pushed_scope)
&& !BRACE_ENCLOSED_INITIALIZER_P (init))
{
tree d = decl;
- tree decomp_first_name = NULL_TREE;
- unsigned decomp_cnt = 0;
+ cp_decomp decomp_d, *decomp = NULL;
if (decl != error_mark_node && DECL_HAS_VALUE_EXPR_P (decl))
{
tree v = DECL_VALUE_EXPR (decl);
&& DECL_DECOMPOSITION_P (TREE_OPERAND (v, 0)))
{
d = TREE_OPERAND (v, 0);
- decomp_cnt = tree_to_uhwi (TREE_OPERAND (v, 1)) + 1;
- decomp_first_name = decl;
+ decomp = &decomp_d;
+ decomp->count = tree_to_uhwi (TREE_OPERAND (v, 1)) + 1;
+ decomp->decl = decl;
}
}
- do_range_for_auto_deduction (d, init, decomp_first_name, decomp_cnt);
+ do_range_for_auto_deduction (d, init, decomp);
}
cond = global_namespace;
incr = NULL_TREE;
decl = begin;
/* Defer popping sl here. */
- tree decomp_first_name = NULL_TREE;
- unsigned decomp_cnt = 0;
+ cp_decomp decomp_d, *decomp = NULL;
if (orig_decl != error_mark_node && DECL_HAS_VALUE_EXPR_P (orig_decl))
{
tree v = DECL_VALUE_EXPR (orig_decl);
{
tree d = orig_decl;
orig_decl = TREE_OPERAND (v, 0);
- decomp_cnt = tree_to_uhwi (TREE_OPERAND (v, 1)) + 1;
- decomp_first_name = d;
+ decomp = &decomp_d;
+ decomp->count = tree_to_uhwi (TREE_OPERAND (v, 1)) + 1;
+ decomp->decl = d;
}
}
{
TREE_TYPE (orig_decl) = do_auto_deduction (TREE_TYPE (orig_decl),
t, auto_node);
- if (decomp_first_name)
+ if (decomp)
{
++processing_template_decl;
- cp_finish_decomp (orig_decl, decomp_first_name, decomp_cnt);
+ cp_finish_decomp (orig_decl, decomp);
--processing_template_decl;
if (!processing_template_decl)
clear_has_value_expr = true;
the whole loop nest. The remaining elements are decls of derived
decomposition variables that are bound inside the loop body. This
structure is further mangled by finish_omp_for into the form required
- for the OMP_FOR_ORIG_DECLS field of the OMP_FOR tree node. */
+ for the OMP_FOR_ORIG_DECLS field of the OMP_FOR tree node. */\
+ unsigned decomp_cnt = decomp ? decomp->count : 0;
tree v = make_tree_vec (decomp_cnt + 3);
TREE_VEC_ELT (v, 0) = range_temp_decl;
TREE_VEC_ELT (v, 1) = end;
name but the DECL_VALUE_EXPR will be dependent. Hide those
from folding of other loop initializers e.g. for warning
purposes until cp_finish_omp_range_for. */
- gcc_checking_assert (DECL_HAS_VALUE_EXPR_P (decomp_first_name)
- || (TREE_TYPE (decomp_first_name)
+ gcc_checking_assert (DECL_HAS_VALUE_EXPR_P (decomp->decl)
+ || (TREE_TYPE (decomp->decl)
== error_mark_node));
- DECL_HAS_VALUE_EXPR_P (decomp_first_name) = 0;
+ DECL_HAS_VALUE_EXPR_P (decomp->decl) = 0;
}
- TREE_VEC_ELT (v, i + 3) = decomp_first_name;
- decomp_first_name = DECL_CHAIN (decomp_first_name);
+ TREE_VEC_ELT (v, i + 3) = decomp->decl;
+ decomp->decl = DECL_CHAIN (decomp->decl);
}
orig_decl = tree_cons (NULL_TREE, NULL_TREE, v);
}
gcc_assert (TREE_CODE (orig) == TREE_LIST
&& TREE_CODE (TREE_CHAIN (orig)) == TREE_VEC);
tree decl = TREE_VEC_ELT (TREE_CHAIN (orig), 2);
- tree decomp_first_name = NULL_TREE;
- unsigned int decomp_cnt = 0;
+ cp_decomp decomp_d, *decomp = NULL;
if (VAR_P (decl) && DECL_DECOMPOSITION_P (decl))
{
- decomp_first_name = TREE_VEC_ELT (TREE_CHAIN (orig), 3);
- decomp_cnt = TREE_VEC_LENGTH (TREE_CHAIN (orig)) - 3;
+ decomp = &decomp_d;
+ decomp_d.decl = TREE_VEC_ELT (TREE_CHAIN (orig), 3);
+ decomp_d.count = TREE_VEC_LENGTH (TREE_CHAIN (orig)) - 3;
if (TREE_PUBLIC (TREE_CHAIN (orig)))
{
/* Undo temporary clearing of DECL_HAS_VALUE_EXPR_P done
by cp_convert_omp_range_for above. */
TREE_PUBLIC (TREE_CHAIN (orig)) = 0;
- tree d = decomp_first_name;
- for (unsigned i = 0; i < decomp_cnt; i++)
+ tree d = decomp_d.decl;
+ for (unsigned i = 0; i < decomp_d.count; i++)
{
if (TREE_TYPE (d) != error_mark_node)
DECL_HAS_VALUE_EXPR_P (d) = 1;
d = DECL_CHAIN (d);
}
}
- cp_maybe_mangle_decomp (decl, decomp_first_name, decomp_cnt);
}
/* The declaration is initialized with *__begin inside the loop body. */
build_x_indirect_ref (input_location, begin, RO_UNARY_STAR,
NULL_TREE, tf_warning_or_error),
/*is_constant_init*/false, NULL_TREE,
- LOOKUP_ONLYCONVERTING);
+ LOOKUP_ONLYCONVERTING, decomp);
if (VAR_P (decl) && DECL_DECOMPOSITION_P (decl))
- cp_finish_decomp (decl, decomp_first_name, decomp_cnt);
+ cp_finish_decomp (decl, decomp);
}
/* Return true if next tokens contain a standard attribute that contains
static tree *omp_parallel_combined_clauses;
static tree tsubst_decomp_names (tree, tree, tree, tsubst_flags_t, tree,
- tree *, unsigned int *);
+ cp_decomp *);
/* Substitute one OMP_FOR iterator. */
&& VAR_P (TREE_OPERAND (v, 0))
&& DECL_DECOMPOSITION_P (TREE_OPERAND (v, 0)))
{
- tree decomp_first = NULL_TREE;
- unsigned decomp_cnt = 0;
+ cp_decomp decomp_d = { NULL_TREE, 0 };
tree d = tsubst_decl (TREE_OPERAND (v, 0), args, complain);
maybe_push_decl (d);
d = tsubst_decomp_names (d, TREE_OPERAND (v, 0), args, complain,
- in_decl, &decomp_first, &decomp_cnt);
+ in_decl, &decomp_d);
decomp = true;
if (d == error_mark_node)
decl = error_mark_node;
else
- for (unsigned int i = 0; i < decomp_cnt; i++)
+ for (unsigned int i = 0; i < decomp_d.count; i++)
{
- if (!DECL_HAS_VALUE_EXPR_P (decomp_first))
+ if (!DECL_HAS_VALUE_EXPR_P (decomp_d.decl))
{
tree v = build_nt (ARRAY_REF, d,
- size_int (decomp_cnt - i - 1),
+ size_int (decomp_d.count - i - 1),
NULL_TREE, NULL_TREE);
- SET_DECL_VALUE_EXPR (decomp_first, v);
- DECL_HAS_VALUE_EXPR_P (decomp_first) = 1;
+ SET_DECL_VALUE_EXPR (decomp_d.decl, v);
+ DECL_HAS_VALUE_EXPR_P (decomp_d.decl) = 1;
}
- fit_decomposition_lang_decl (decomp_first, d);
- decomp_first = DECL_CHAIN (decomp_first);
+ fit_decomposition_lang_decl (decomp_d.decl, d);
+ decomp_d.decl = DECL_CHAIN (decomp_d.decl);
}
}
}
static tree
tsubst_decomp_names (tree decl, tree pattern_decl, tree args,
- tsubst_flags_t complain, tree in_decl, tree *first,
- unsigned int *cnt)
+ tsubst_flags_t complain, tree in_decl, cp_decomp *decomp)
{
tree decl2, decl3, prev = decl;
- *cnt = 0;
+ decomp->count = 0;
gcc_assert (DECL_NAME (decl) == NULL_TREE);
for (decl2 = DECL_CHAIN (pattern_decl);
decl2
&& DECL_NAME (decl2);
decl2 = DECL_CHAIN (decl2))
{
- if (TREE_TYPE (decl2) == error_mark_node && *cnt == 0)
+ if (TREE_TYPE (decl2) == error_mark_node && decomp->count == 0)
{
gcc_assert (errorcount);
return error_mark_node;
}
- (*cnt)++;
+ decomp->count++;
gcc_assert (DECL_DECOMP_BASE (decl2) == pattern_decl);
gcc_assert (DECL_HAS_VALUE_EXPR_P (decl2));
tree v = DECL_VALUE_EXPR (decl2);
else
prev = decl3;
}
- *first = prev;
+ decomp->decl = prev;
return decl;
}
else
{
bool const_init = false;
- unsigned int cnt = 0;
- tree first = NULL_TREE, ndecl = error_mark_node;
+ cp_decomp decomp_d, *decomp = NULL;
+ tree ndecl = error_mark_node;
tree asmspec_tree = NULL_TREE;
maybe_push_decl (decl);
if (VAR_P (decl)
&& DECL_DECOMPOSITION_P (decl)
&& TREE_TYPE (pattern_decl) != error_mark_node)
- ndecl = tsubst_decomp_names (decl, pattern_decl, args,
- complain, in_decl, &first,
- &cnt);
+ {
+ decomp = &decomp_d;
+ ndecl = tsubst_decomp_names (decl, pattern_decl, args,
+ complain, in_decl, decomp);
+ }
init = tsubst_init (init, decl, args, complain, in_decl);
const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
(pattern_decl));
- if (ndecl != error_mark_node)
- cp_maybe_mangle_decomp (ndecl, first, cnt);
-
/* In a non-template function, VLA type declarations are
handled in grokdeclarator; for templates, handle them
now. */
TREE_TYPE (asmspec_tree) = char_array_type_node;
}
- cp_finish_decl (decl, init, const_init, asmspec_tree, 0);
+ cp_finish_decl (decl, init, const_init, asmspec_tree, 0,
+ decomp);
if (ndecl != error_mark_node)
- cp_finish_decomp (ndecl, first, cnt);
+ cp_finish_decomp (ndecl, decomp);
}
}
}
maybe_push_decl (decl);
expr = RECUR (RANGE_FOR_EXPR (t));
- tree decomp_first = NULL_TREE;
- unsigned decomp_cnt = 0;
+ cp_decomp decomp_d, *decomp = NULL;
if (VAR_P (decl) && DECL_DECOMPOSITION_P (decl))
- decl = tsubst_decomp_names (decl, RANGE_FOR_DECL (t), args,
- complain, in_decl,
- &decomp_first, &decomp_cnt);
+ {
+ decomp = &decomp_d;
+ decl = tsubst_decomp_names (decl, RANGE_FOR_DECL (t), args,
+ complain, in_decl, decomp);
+ }
if (processing_template_decl)
{
RANGE_FOR_UNROLL (stmt) = RANGE_FOR_UNROLL (t);
RANGE_FOR_NOVECTOR (stmt) = RANGE_FOR_NOVECTOR (t);
finish_range_for_decl (stmt, decl, expr);
- if (decomp_first && decl != error_mark_node)
- cp_finish_decomp (decl, decomp_first, decomp_cnt);
+ if (decomp && decl != error_mark_node)
+ cp_finish_decomp (decl, decomp);
}
else
{
unsigned short unroll = (RANGE_FOR_UNROLL (t)
? tree_to_uhwi (RANGE_FOR_UNROLL (t)) : 0);
- stmt = cp_convert_range_for (stmt, decl, expr,
- decomp_first, decomp_cnt,
+ stmt = cp_convert_range_for (stmt, decl, expr, decomp,
RANGE_FOR_IVDEP (t), unroll,
RANGE_FOR_NOVECTOR (t));
}
Version 18, which first appeard in G++ 13, fixes manglings of lambdas
that have additional context.
+Version 19, which first appeard in G++ 14, fixes manglings of structured
+bindings to include ABI tags.
+
See also @option{-Wabi}.
@opindex fabi-compat-version
// This testcase will need to be kept in sync with c_common_post_options.
// { dg-options "-fabi-version=0" }
-#if __GXX_ABI_VERSION != 1018
+#if __GXX_ABI_VERSION != 1019
#error "Incorrect value of __GXX_ABI_VERSION"
#endif
--- /dev/null
+// PR c++/111069
+// { dg-do compile { target c++11 } }
+// { dg-options "" }
+
+extern int a[2];
+struct Y { int b, c, d; };
+
+inline int
+freddy ()
+{
+ static auto [i, j] = a; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ static auto [k, l] = a; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ int ret = ++i + ++k;
+ {
+ static auto [i, j] = a; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ static auto [k, l] = a; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ ret += ++i + ++k;
+ }
+ {
+ static auto [i, j] = a; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ static auto [k, l] = a; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ ret += ++i + ++k;
+ }
+ return ret;
+}
+
+namespace N
+{
+ namespace M
+ {
+ template <int N>
+ inline int
+ corge ()
+ {
+ static auto [i, j] = a; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ static auto && [u, v, w] = Y{}; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ int ret = ++i + ++u;
+ {
+ static auto && [u, v, w] = Y{}; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ ret += ++v;
+ }
+ return ret;
+ }
+ }
+}
+
+int (*p) () = &freddy;
+int (*q) () = N::M::corge<3>;
+
+// { dg-final { scan-assembler "_ZZ6freddyvEDC1i1jE" } }
+// { dg-final { scan-assembler "_ZZ6freddyvEDC1i1jE_0" } }
+// { dg-final { scan-assembler "_ZZ6freddyvEDC1i1jE_1" } }
+// { dg-final { scan-assembler "_ZZ6freddyvEDC1k1lE" } }
+// { dg-final { scan-assembler "_ZZ6freddyvEDC1k1lE_0" } }
+// { dg-final { scan-assembler "_ZZ6freddyvEDC1k1lE_1" } }
+// { dg-final { scan-assembler "_ZZN1N1M5corgeILi3EEEivEDC1i1jE" } }
+// { dg-final { scan-assembler "_ZGVZ6freddyvEDC1i1jE" } }
+// { dg-final { scan-assembler "_ZGVZ6freddyvEDC1i1jE_0" } }
+// { dg-final { scan-assembler "_ZGVZ6freddyvEDC1i1jE_1" } }
+// { dg-final { scan-assembler "_ZGVZ6freddyvEDC1k1lE" } }
+// { dg-final { scan-assembler "_ZGVZ6freddyvEDC1k1lE_0" } }
+// { dg-final { scan-assembler "_ZGVZ6freddyvEDC1k1lE_1" } }
+// { dg-final { scan-assembler "_ZGVZN1N1M5corgeILi3EEEivEDC1i1jE" } }
+// { dg-final { scan-assembler "_ZGRZN1N1M5corgeILi3EEEivEDC1u1v1wE_" } }
+// { dg-final { scan-assembler "_ZGRZN1N1M5corgeILi3EEEivEDC1u1v1wE_0_" } }
--- /dev/null
+// PR c++/111069
+// { dg-do compile { target c++11 } }
+// { dg-options "" }
+
+struct [[gnu::abi_tag ("foobar")]] S { int i; };
+extern S a[2];
+struct [[gnu::abi_tag ("qux")]] T { int i; S j; int k; };
+extern T b[2];
+
+namespace N {
+ auto [i, j] = a; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ auto [k, l] = b; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+}
+
+inline int
+foo ()
+{
+ static auto [m, n] = a; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ static auto [o, p] = b; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ int ret = ++N::i.i + ++N::k.i;
+ {
+ static auto [m, n] = a; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+
+ ret += ++n.i;
+ }
+ {
+ static auto [m, n] = a; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+
+ ret += ++n.i;
+ }
+ ret += ++m.i + ++o.i;
+ return ret;
+}
+
+template <typename T>
+inline int
+bar ()
+{
+ static auto [m, n] = a; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ static auto [o, p] = b; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ int ret = 0;
+ {
+ static auto [m, n] = a; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ ret += ++n.i;
+ }
+ {
+ static auto [m, n] = a; // { dg-warning "structured bindings only available with" "" { target c++14_down } }
+ // { dg-warning "structured binding declaration can be 'static' only in" "" { target c++17_down } .-1 }
+ ret += ++n.i;
+ }
+ ret += ++m.i + ++o.i;
+ return ret;
+}
+
+int (*p) () = &foo;
+int (*q) () = &bar<T>;
+
+// { dg-final { scan-assembler "_ZZ3foovEDC1m1nEB6foobar" } }
+// { dg-final { scan-assembler "_ZZ3foovEDC1m1nEB6foobar_0" } }
+// { dg-final { scan-assembler "_ZZ3foovEDC1m1nEB6foobar_1" } }
+// { dg-final { scan-assembler "_ZZ3foovEDC1o1pEB3qux" } }
+// { dg-final { scan-assembler "_ZZ3barI1TB3quxEivEDC1m1nEB6foobar" } }
+// { dg-final { scan-assembler "_ZZ3barI1TB3quxEivEDC1m1nEB6foobar_0" } }
+// { dg-final { scan-assembler "_ZZ3barI1TB3quxEivEDC1m1nEB6foobar_1" } }
+// { dg-final { scan-assembler "_ZZ3barI1TB3quxEivEDC1o1pEB3qux" } }
+// { dg-final { scan-assembler "_ZN1NDC1i1jEB6foobarE" } }
+// { dg-final { scan-assembler "_ZN1NDC1k1lEB3quxE" } }
+// { dg-final { scan-assembler "_ZGVZ3foovEDC1m1nEB6foobar" } }
+// { dg-final { scan-assembler "_ZGVZ3foovEDC1m1nEB6foobar_0" } }
+// { dg-final { scan-assembler "_ZGVZ3foovEDC1m1nEB6foobar_1" } }
+// { dg-final { scan-assembler "_ZGVZ3foovEDC1o1pEB3qux" } }
+// { dg-final { scan-assembler "_ZGVZ3barI1TB3quxEivEDC1m1nEB6foobar" } }
+// { dg-final { scan-assembler "_ZGVZ3barI1TB3quxEivEDC1m1nEB6foobar_0" } }
+// { dg-final { scan-assembler "_ZGVZ3barI1TB3quxEivEDC1m1nEB6foobar_1" } }
+// { dg-final { scan-assembler "_ZGVZ3barI1TB3quxEivEDC1o1pEB3qux" } }
projects / thirdparty / gcc.git / commitdiff
