From 5d80a306744bf10263a1f69ceda3ac8366ba6606 Mon Sep 17 00:00:00 2001 From: Douglas Gregor Date: Sat, 10 Mar 2007 01:58:58 +0000 Subject: [PATCH] re PR c++/20599 (variadic template support) 2007-03-09 Douglas Gregor PR c++/20599 * typeck.c (check_return_expr): Check for bare parameter packs. (comptypes): Compare template parameter packs and type pack expansions. * decl.c (grokdeclarator): Deal with the declaration of function parameter packs. (grokparms): Verify that the (optional) function parameter pack is at the end of the parameter list. (xref_basetypes): Handle pack expansions in the base class. (cp_tree_node_structure): Handle ARGUMENT_PACK_SELECT. * cp-tree.def (TYPE_ARGUMENT_PACK): New. (NONTYPE_ARGUMENT_PACK): New. (TYPE_PACK_EXPANSION): New. (EXPR_PACK_EXPANSION): New. (ARGUMENT_PACK_SELECT): New. * cp-objcp-common.c (cp_tree_size): Compute size of (NON)TYPE_ARGUMENT_PACK, (TYPE|EXPR)_PACK_EXPANSION, and ARGUMENT_PACK_SELECT. * error.c (dump_template_argument): Print template argument packs. (dump_template_argument_list): Ditto. (dump_template_parameter): Dump `...' for template type parameter packs. (dump_type): Dump TYPE_PACK_EXPANSION nodes. (dump_parameters): Print function parameter packs. (dump_template_parms): Print template argument packs. (dump_expr): Dump EXPR_PACK_EXPANSION nodes. (maybe_warn_variadic_templates): New. * operators.def: Add ellipsis operator for EXPR_PACK_EXPANSION. * tree.c (cp_walk_subtrees): Walk BASELINK, TYPE_ARGUMENT_PACK, NONTYPE_ARGUMENT_PACK, TYPE_PACK_EXPANSION, EXPR_PACK_EXPANSION, CAST_EXPR. * mangle.c (write_type): Mangle TYPE_PACK_EXPANSION. (write_template_arg): Write argument packs as separate arguments. * cp-tree.h (struct template_parm_index_s): Add flag that indicates that the template parameter is actually a parameter pack. (struct tree_argument_pack_select): New. (enum cp_tree_node_structure_enum): Add TS_CP_ARGUMENT_PACK_SELECT. (union lang_tree_node): Add argument_pack_select. (FUNCTION_PARAMETER_PACK_P): New. (PACK_EXPANSION_P): New. (PACK_EXPANSION_PATTERN): New. (SET_PACK_EXPANSION_PATTERN): New. (PACK_EXPANSION_PARAMETER_PACKS): New. (ARGUMENT_PACK_P): New. (ARGUMENT_PACK_ARGS): New. (SET_ARGUMENT_PACK_ARGS): New. (ARGUMENT_PACK_INCOMPLETE_P): New. (ARGUMENT_PACK_EXPLICIT_ARGS): New. (TEMPLATE_PARM_PARAMETER_PACK): New. (TEMPLATE_TYPE_PARAMETER_PACK): New. (ARGUMENT_PACK_SELECT_FROM_PACK): New. (ARGUMENT_PACK_SELECT_INDEX): New. (ARGUMENT_PACK_SELECT_ARG): New. (struct cp_declarator): Add parameter_pack_p flag. (maybe_warn_variadic_templates): Declare. (process_template_parm): Add bool parameter IS_PARAMETER_PACK, to indicate a template parameter pack. (uses_parameter_packs): Declare. (template_parameter_pack_p): Declare. (template_parms_variadic_p): Declare. (make_pack_expansion): Declare. (check_for_bare_parameter_packs): Declare. * cxx-pretty-print.c (pp_cxx_unary_expression): Print sizeof... expressions. (pp_cxx_expression): Print pack expansions and non-type argument packs. (pp_cxx_exception_specification): Print pack expansions. (pp_cxx_direct_declarator): Print ellipsis for parameter packs. (pp_cxx_ctor_initializer): Print pack expansions. (pp_cxx_type_id): Print pack expansions. (pp_cxx_template_argument_list): Print argument packs. (pp_cxx_template_parameter): Print ellipsis for template parameter packs. * pt.c (comp_template_parms): Compare template parameter packs. (template_parameter_pack_p): New. (template_parms_variadic_p): New. (template_args_variadic_p): New. (make_ith_pack_parameter_name): New. (struct find_parameter_pack_data): New. (find_parameter_packs_r): New. (uses_parameter_packs): New. (make_pack_expansion): New. (check_for_bare_parameter_packs): New. (expand_template_argument_pack): New. (reduce_template_parm_level): Propagate parameter pack flag. (process_template_parm): Add is_parameter_pack parameter to state when the parameter is actually a parameter pack. Create template parameter packs when is_parameter_pack is true. (current_template_args): The argument for a template parameter pack is an argument pack containing a single pack expansion. (process_partial_specialization): When checking that non-type argument expressions do not involve template parameters, loop over the arguments in argument packs separately. (push_template_decl_real): Check that the type of the declaration does not have any bare parameter packs. Check that primary templates have no more than one parameter pack, and that it comes at the end of the template parameter list. (convert_template_argument): Handle coercions for pack expansion expressions by coercing the pattern then rebuilding the expansion. (coerce_template_parms): When coercing the arguments for a variadic template, pack "extra" arguments into an argument pack. (coerce_template_template_parms): Cannot coerce between parameter packs and non-pack parameters. (template_args_equal): Compare PACK_EXPANSION_P expressions. (comp_template_args): Expand all template arguments packs before comparing template argument lists. (mangle_class_name_for_template): Make argument packs as separate template arguments. (for_each_template_parm_r): No need to handle BASELINK. (instantiate_class_template): Handle pack expansions in the base class list. (tsubst_pack_expansion): New. (tsubst_template_args): Handle substitutions of argument packs and pack expansion into template argument lists. (tsubst_decl): Expand function parameter packs into separate function parameters. (tsubst_arg_types): Expand a type pack expansion into separate argument types. (tsubst_exception_specification): Handle pack expansions in exception specifiers. (tsubst): See through ARGUMENT_PACK_SELECT arguments when replacing a template parameter with its argument. If we encounter a substitution for an argument pack, just return the parameter itself. (tsubst_copy): sizeof(X...) returns the number of elements in parameter pack X. See through ARGUMENT_PACK_SELECT when the PARM_DECL is a parameter pack. (tsubst_expr): Expression pack expansions and argument packs cannot show up here; they will all be handled through function calls, sizeof, and template argument lists. (tsubst_copy_and_build): sizeof(X...) returns the number of elements in parameter pack X. Handle pack expansions in TREE_LIST and CONSTRUCTOR nodes. (fn_type_unification): Handle "incomplete" explicit template argument lists that specify some of the arguments for a template parameter pack. (type_unification_real): Unify arguments against pack expansions. (template_parm_level_and_index): New, helper function. (unify_pack_expansion): New. (unify): Unify argument packs on an argument-by-argument basis, handling variadic argument packs as well. (more_specialized_fn): Handle unification of function parameter packs. All things being equal, prefer non-variadic function templates to variadic function templates. (more_specialized_class): Prefer the variadic class template partial specialization that binds fewer arguments to a parameter pack. (regenerate_decl_from_template): Expand function parameter packs into separate parameters. (instantiate_decl): Ditto. (tsubst_initializer_list): Handle pack expansions for base-class initializers. (dependent_type_p_r): Determine dependent types in argument packs and pack expansions. (value_dependent_expression_p): Determine value-dependence of non-type argument packs. (dependent_template_arg_p): Handle argument packs. * semantics.c (finish_cond): Check for bare parameter packs. (finish_expr_stmt): Ditto. (finish_for_expr): Ditto. (finish_switch_cond): Ditto. (finish_mem_initializers): Ditto. * name-lookup.c (arg_assoc_type): Handle pack expansions and argument packs. * decl2.c (cp_build_parm_decl): Mark function parameter packs. * parser.c (make_declarator): Declarator is not an expansion. (make_pointer_declarator): Transfer parameter pack flag to outer declarator. (make_reference_declarator): Ditto. (make_ptrmem_declarator): Ditto. (make_call_declarator): Ditto. (make_array_declarator): Ditto. (cp_parser_postfix_expression): Allow pack expansion expressions in the argument list for a call expression. (cp_parser_parenthesized_expression_list): Add new parameter ALLOW_EXPANSION_P. When true, parse the ellipsis to mean "expand into separate arguments." (cp_parser_new_placement): Allow pack expansion expressions. (cp_parser_new_initializer): Ditto. (cp_parser_mem_initializer_list): Allow ellipsis to create a base-class initializer expansion. (cp_parser_mem_initializer): Ditto. (cp_parser_template_parameter_list): Keep track of whether the template parameter is a template parameter pack. (cp_parser_template_parameter): Parse the ellipsis to indicate a template parameter pack. (cp_parser_type_parameter): Ditto. (cp_parser_template_argument_list): Parse the ellipsis to indicate a pack expansion. (cp_parser_direct_declarator): Parse the ellipsis to indicate that this declarator is a parameter pack. (cp_parser_parameter_declaration): The ellipsis does not end the parameter declaration, because it might be a parameter pack. Parse the ellipsis to indicate a parameter pack. (cp_parser_initializer): Allow pack expansions. (cp_parser_initializer_list): Allow ellipsis to create an initializer expansion. (cp_parser_base_clause): Allow ellipsis to create a base specifier expansion. (cp_parser_type_id_list): Allow ellipsis to create an exception specifier expansion. (cp_parser_attribute_list): Don't allow pack expansions. (cp_parser_functional_cast): Allow pack expansions. (cp_parser_sizeof_operand): Allow ellipsis following "sizeof" to compute the length of a parameter pack. (cp_parser_next_token_ends_template_argument_p): An ellipsis can end a template argument. * tree.c (cp_walk_subtrees): Walk BASELINK, TYPE_ARGUMENT_PACK, NONTYPE_ARGUMENT_PACK, TYPE_PACK_EXPANSION, EXPR_PACK_EXPANSION, CAST_EXPR. From-SVN: r122788 --- gcc/cp/ChangeLog | 214 ++++ gcc/cp/cp-objcp-common.c | 11 + gcc/cp/cp-tree.def | 70 ++ gcc/cp/cp-tree.h | 109 +- gcc/cp/cxx-pretty-print.c | 132 +- gcc/cp/decl.c | 24 + gcc/cp/decl2.c | 6 + gcc/cp/error.c | 80 +- gcc/cp/mangle.c | 15 +- gcc/cp/name-lookup.c | 12 + gcc/cp/operators.def | 3 + gcc/cp/parser.c | 370 +++++- gcc/cp/pt.c | 2381 +++++++++++++++++++++++++++++++++---- gcc/cp/semantics.c | 23 +- gcc/cp/tree.c | 38 +- gcc/cp/typeck.c | 13 +- 16 files changed, 3220 insertions(+), 281 deletions(-) diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 8d0ba18a79cd..886b305c4a89 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,217 @@ +2007-03-09 Douglas Gregor + + PR c++/20599 + * typeck.c (check_return_expr): Check for bare parameter packs. + (comptypes): Compare template parameter packs and + type pack expansions. + * decl.c (grokdeclarator): Deal with the declaration of function + parameter packs. + (grokparms): Verify that the (optional) function parameter pack is + at the end of the parameter list. + (xref_basetypes): Handle pack expansions in the base class. + (cp_tree_node_structure): Handle ARGUMENT_PACK_SELECT. + * cp-tree.def (TYPE_ARGUMENT_PACK): New. + (NONTYPE_ARGUMENT_PACK): New. + (TYPE_PACK_EXPANSION): New. + (EXPR_PACK_EXPANSION): New. + (ARGUMENT_PACK_SELECT): New. + * cp-objcp-common.c (cp_tree_size): Compute size of + (NON)TYPE_ARGUMENT_PACK, (TYPE|EXPR)_PACK_EXPANSION, and + ARGUMENT_PACK_SELECT. + * error.c (dump_template_argument): Print template argument packs. + (dump_template_argument_list): Ditto. + (dump_template_parameter): Dump `...' for template type parameter + packs. + (dump_type): Dump TYPE_PACK_EXPANSION nodes. + (dump_parameters): Print function parameter packs. + (dump_template_parms): Print template argument packs. + (dump_expr): Dump EXPR_PACK_EXPANSION nodes. + (maybe_warn_variadic_templates): New. + * operators.def: Add ellipsis operator for EXPR_PACK_EXPANSION. + * tree.c (cp_walk_subtrees): Walk BASELINK, TYPE_ARGUMENT_PACK, + NONTYPE_ARGUMENT_PACK, TYPE_PACK_EXPANSION, EXPR_PACK_EXPANSION, + CAST_EXPR. + * mangle.c (write_type): Mangle TYPE_PACK_EXPANSION. + (write_template_arg): Write argument packs as separate arguments. + * cp-tree.h (struct template_parm_index_s): Add flag that + indicates that the template parameter is actually a parameter + pack. + (struct tree_argument_pack_select): New. + (enum cp_tree_node_structure_enum): Add TS_CP_ARGUMENT_PACK_SELECT. + (union lang_tree_node): Add argument_pack_select. + (FUNCTION_PARAMETER_PACK_P): New. + (PACK_EXPANSION_P): New. + (PACK_EXPANSION_PATTERN): New. + (SET_PACK_EXPANSION_PATTERN): New. + (PACK_EXPANSION_PARAMETER_PACKS): New. + (ARGUMENT_PACK_P): New. + (ARGUMENT_PACK_ARGS): New. + (SET_ARGUMENT_PACK_ARGS): New. + (ARGUMENT_PACK_INCOMPLETE_P): New. + (ARGUMENT_PACK_EXPLICIT_ARGS): New. + (TEMPLATE_PARM_PARAMETER_PACK): New. + (TEMPLATE_TYPE_PARAMETER_PACK): New. + (ARGUMENT_PACK_SELECT_FROM_PACK): New. + (ARGUMENT_PACK_SELECT_INDEX): New. + (ARGUMENT_PACK_SELECT_ARG): New. + (struct cp_declarator): Add parameter_pack_p flag. + (maybe_warn_variadic_templates): Declare. + (process_template_parm): Add bool parameter IS_PARAMETER_PACK, to + indicate a template parameter pack. + (uses_parameter_packs): Declare. + (template_parameter_pack_p): Declare. + (template_parms_variadic_p): Declare. + (make_pack_expansion): Declare. + (check_for_bare_parameter_packs): Declare. + * cxx-pretty-print.c (pp_cxx_unary_expression): Print + sizeof... expressions. + (pp_cxx_expression): Print pack expansions and non-type argument + packs. + (pp_cxx_exception_specification): Print pack expansions. + (pp_cxx_direct_declarator): Print ellipsis for parameter packs. + (pp_cxx_ctor_initializer): Print pack expansions. + (pp_cxx_type_id): Print pack expansions. + (pp_cxx_template_argument_list): Print argument packs. + (pp_cxx_template_parameter): Print ellipsis for template parameter + packs. + * pt.c (comp_template_parms): Compare template parameter packs. + (template_parameter_pack_p): New. + (template_parms_variadic_p): New. + (template_args_variadic_p): New. + (make_ith_pack_parameter_name): New. + (struct find_parameter_pack_data): New. + (find_parameter_packs_r): New. + (uses_parameter_packs): New. + (make_pack_expansion): New. + (check_for_bare_parameter_packs): New. + (expand_template_argument_pack): New. + (reduce_template_parm_level): Propagate parameter pack flag. + (process_template_parm): Add is_parameter_pack parameter to state + when the parameter is actually a parameter pack. Create template + parameter packs when is_parameter_pack is true. + (current_template_args): The argument for a template parameter + pack is an argument pack containing a single pack expansion. + (process_partial_specialization): When checking that non-type + argument expressions do not involve template parameters, loop over + the arguments in argument packs separately. + (push_template_decl_real): Check that the type of the declaration + does not have any bare parameter packs. Check that primary + templates have no more than one parameter pack, and that it comes + at the end of the template parameter list. + (convert_template_argument): Handle coercions for pack expansion + expressions by coercing the pattern then rebuilding the expansion. + (coerce_template_parms): When coercing the arguments for a + variadic template, pack "extra" arguments into an argument pack. + (coerce_template_template_parms): Cannot coerce between parameter + packs and non-pack parameters. + (template_args_equal): Compare PACK_EXPANSION_P expressions. + (comp_template_args): Expand all template arguments packs before + comparing template argument lists. + (mangle_class_name_for_template): Make argument packs as separate + template arguments. + (for_each_template_parm_r): No need to handle BASELINK. + (instantiate_class_template): Handle pack expansions in the base + class list. + (tsubst_pack_expansion): New. + (tsubst_template_args): Handle substitutions of argument packs and + pack expansion into template argument lists. + (tsubst_decl): Expand function parameter packs into separate + function parameters. + (tsubst_arg_types): Expand a type pack expansion into separate + argument types. + (tsubst_exception_specification): Handle pack expansions in + exception specifiers. + (tsubst): See through ARGUMENT_PACK_SELECT arguments when + replacing a template parameter with its argument. If we encounter + a substitution for an argument pack, just return the parameter + itself. + (tsubst_copy): sizeof(X...) returns the number of elements in + parameter pack X. See through ARGUMENT_PACK_SELECT when the + PARM_DECL is a parameter pack. + (tsubst_expr): Expression pack expansions and argument packs + cannot show up here; they will all be handled through function + calls, sizeof, and template argument lists. + (tsubst_copy_and_build): sizeof(X...) returns the number of + elements in parameter pack X. Handle pack expansions in TREE_LIST + and CONSTRUCTOR nodes. + (fn_type_unification): Handle "incomplete" explicit template + argument lists that specify some of the arguments for a template + parameter pack. + (type_unification_real): Unify arguments against pack expansions. + (template_parm_level_and_index): New, helper function. + (unify_pack_expansion): New. + (unify): Unify argument packs on an argument-by-argument basis, + handling variadic argument packs as well. + (more_specialized_fn): Handle unification of function parameter + packs. All things being equal, prefer non-variadic function + templates to variadic function templates. + (more_specialized_class): Prefer the variadic class template + partial specialization that binds fewer arguments to a parameter + pack. + (regenerate_decl_from_template): Expand function parameter packs + into separate parameters. + (instantiate_decl): Ditto. + (tsubst_initializer_list): Handle pack expansions for base-class + initializers. + (dependent_type_p_r): Determine dependent types in argument packs + and pack expansions. + (value_dependent_expression_p): Determine value-dependence of + non-type argument packs. + (dependent_template_arg_p): Handle argument packs. + * semantics.c (finish_cond): Check for bare parameter packs. + (finish_expr_stmt): Ditto. + (finish_for_expr): Ditto. + (finish_switch_cond): Ditto. + (finish_mem_initializers): Ditto. + * name-lookup.c (arg_assoc_type): Handle pack expansions and + argument packs. + * decl2.c (cp_build_parm_decl): Mark function parameter packs. + * parser.c (make_declarator): Declarator is not an expansion. + (make_pointer_declarator): Transfer parameter pack flag to outer + declarator. + (make_reference_declarator): Ditto. + (make_ptrmem_declarator): Ditto. + (make_call_declarator): Ditto. + (make_array_declarator): Ditto. + (cp_parser_postfix_expression): Allow pack expansion expressions + in the argument list for a call expression. + (cp_parser_parenthesized_expression_list): Add new parameter + ALLOW_EXPANSION_P. When true, parse the ellipsis to mean "expand + into separate arguments." + (cp_parser_new_placement): Allow pack expansion expressions. + (cp_parser_new_initializer): Ditto. + (cp_parser_mem_initializer_list): Allow ellipsis to create a + base-class initializer expansion. + (cp_parser_mem_initializer): Ditto. + (cp_parser_template_parameter_list): Keep track of whether the + template parameter is a template parameter pack. + (cp_parser_template_parameter): Parse the ellipsis to indicate a + template parameter pack. + (cp_parser_type_parameter): Ditto. + (cp_parser_template_argument_list): Parse the ellipsis to indicate + a pack expansion. + (cp_parser_direct_declarator): Parse the ellipsis to indicate that + this declarator is a parameter pack. + (cp_parser_parameter_declaration): The ellipsis does not end the + parameter declaration, because it might be a parameter pack. Parse + the ellipsis to indicate a parameter pack. + (cp_parser_initializer): Allow pack expansions. + (cp_parser_initializer_list): Allow ellipsis to create an + initializer expansion. + (cp_parser_base_clause): Allow ellipsis to create a base specifier + expansion. + (cp_parser_type_id_list): Allow ellipsis to create an exception + specifier expansion. + (cp_parser_attribute_list): Don't allow pack expansions. + (cp_parser_functional_cast): Allow pack expansions. + (cp_parser_sizeof_operand): Allow ellipsis following "sizeof" to + compute the length of a parameter pack. + (cp_parser_next_token_ends_template_argument_p): An ellipsis can + end a template argument. + * tree.c (cp_walk_subtrees): Walk BASELINK, TYPE_ARGUMENT_PACK, + NONTYPE_ARGUMENT_PACK, TYPE_PACK_EXPANSION, EXPR_PACK_EXPANSION, + CAST_EXPR. + 2007-03-09 Dirk Mueller * cp/call.c (build_new_op): Call warn_logical_operator. diff --git a/gcc/cp/cp-objcp-common.c b/gcc/cp/cp-objcp-common.c index 372e8e5ac3e0..7b1841e3fa74 100644 --- a/gcc/cp/cp-objcp-common.c +++ b/gcc/cp/cp-objcp-common.c @@ -124,6 +124,17 @@ cp_tree_size (enum tree_code code) case DEFAULT_ARG: return sizeof (struct tree_default_arg); case OVERLOAD: return sizeof (struct tree_overload); case STATIC_ASSERT: return sizeof (struct tree_static_assert); + case TYPE_ARGUMENT_PACK: + case TYPE_PACK_EXPANSION: + return sizeof (struct tree_common); + + case NONTYPE_ARGUMENT_PACK: + case EXPR_PACK_EXPANSION: + return sizeof (struct tree_exp); + + case ARGUMENT_PACK_SELECT: + return sizeof (struct tree_argument_pack_select); + default: gcc_unreachable (); } diff --git a/gcc/cp/cp-tree.def b/gcc/cp/cp-tree.def index bcc6b54223ce..83e1e53cbc75 100644 --- a/gcc/cp/cp-tree.def +++ b/gcc/cp/cp-tree.def @@ -352,6 +352,76 @@ DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1) literal) to be displayed if the condition fails to hold. */ DEFTREECODE (STATIC_ASSERT, "static_assert", tcc_exceptional, 0) +/* Represents an argument pack of types (or templates). An argument + pack stores zero or more arguments that will be used to instantiate + a parameter pack. + + ARGUMENT_PACK_ARGS retrieves the arguments stored in the argument + pack. + + Example: + template + class tuple { ... }; + + tuple t; + + Values is a (template) parameter pack. When tuple is instantiated, the Values parameter pack is instantiated + with the argment pack . ARGUMENT_PACK_ARGS will + be a TREE_VEC containing int, float, and double. */ +DEFTREECODE (TYPE_ARGUMENT_PACK, "type_argument_pack", tcc_type, 0) + +/* Represents an argument pack of values, which can be used either for + non-type template arguments or function call arguments. + + NONTYPE_ARGUMENT_PACK plays precisely the same role as + TYPE_ARGUMENT_PACK, but will be used for packing non-type template + arguments (e.g., "int... Dimensions") or function arguments ("const + Args&... args"). */ +DEFTREECODE (NONTYPE_ARGUMENT_PACK, "nontype_argument_pack", tcc_expression, 1) + +/* Represents a type expression that will be expanded into a list of + types when instantiated with one or more argument packs. + + PACK_EXPANSION_PATTERN retrieves the expansion pattern. This is + the type or expression that we will substitute into with each + argument in an argument pack. + + SET_PACK_EXPANSION_PATTERN sets the expansion pattern. + + PACK_EXPANSION_PARAMETER_PACKS contains a TREE_LIST of the parameter + packs that are used in this pack expansion. + + Example: + template + struct tied : tuple { + // ... + }; + + The derivation from tuple contains a TYPE_PACK_EXPANSION for the + template arguments. Its EXPR_PACK_EXPANSION is "Values&" and its + PACK_EXPANSION_PARAMETER_PACKS will contain "Values". */ +DEFTREECODE (TYPE_PACK_EXPANSION, "type_pack_expansion", tcc_type, 0) + +/* Represents an expression that will be expanded into a list of + expressions when instantiated with one or more argument packs. + + EXPR_PACK_EXPANSION plays precisely the same role as TYPE_PACK_EXPANSION, + but will be used for expressions. */ +DEFTREECODE (EXPR_PACK_EXPANSION, "expr_pack_expansion", tcc_expression, 1) + +/* Selects the Ith parameter out of an argument pack. This node will + be used when instantiating pack expansions; see + tsubst_pack_expansion. + + ARGUMENT_PACK_SELECT_FROM_PACK contains the *_ARGUMENT_PACK node + from which the argument will be selected. + + ARGUMENT_PACK_SELECT_INDEX contains the index into the argument + pack that will be returned by this ARGUMENT_PACK_SELECT node. The + index is a machine integer. */ +DEFTREECODE (ARGUMENT_PACK_SELECT, "argument_pack_select", tcc_exceptional, 0) + /* Local variables: mode:c diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 95e278ce6540..c90d5290eb37 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -103,6 +103,7 @@ struct diagnostic_context; 1: C_TYPEDEF_EXPLICITLY_SIGNED (in TYPE_DECL). DECL_TEMPLATE_INSTANTIATED (in a VAR_DECL or a FUNCTION_DECL) DECL_MEMBER_TEMPLATE_P (in TEMPLATE_DECL) + FUNCTION_PARAMETER_PACK_P (in PARM_DECL) 2: DECL_THIS_EXTERN (in VAR_DECL or FUNCTION_DECL). DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL) 3: DECL_IN_AGGR_P. @@ -222,6 +223,10 @@ struct template_parm_index_s GTY(()) HOST_WIDE_INT level; HOST_WIDE_INT orig_level; tree decl; + + /* When true, indicates that this parameter is actually a parameter + pack, for variadic templates. */ + BOOL_BITFIELD parameter_pack; }; typedef struct template_parm_index_s template_parm_index; @@ -469,6 +474,13 @@ struct tree_static_assert GTY (()) location_t location; }; +struct tree_argument_pack_select GTY (()) +{ + struct tree_common common; + tree argument_pack; + int index; +}; + enum cp_tree_node_structure_enum { TS_CP_GENERIC, TS_CP_IDENTIFIER, @@ -481,6 +493,7 @@ enum cp_tree_node_structure_enum { TS_CP_WRAPPER, TS_CP_DEFAULT_ARG, TS_CP_STATIC_ASSERT, + TS_CP_ARGUMENT_PACK_SELECT, LAST_TS_CP_ENUM }; @@ -499,6 +512,8 @@ union lang_tree_node GTY((desc ("cp_tree_node_structure (&%h)"), struct lang_identifier GTY ((tag ("TS_CP_IDENTIFIER"))) identifier; struct tree_static_assert GTY ((tag ("TS_CP_STATIC_ASSERT"))) static_assertion; + struct tree_argument_pack_select GTY ((tag ("TS_CP_ARGUMENT_PACK_SELECT"))) + argument_pack_select; }; @@ -2188,7 +2203,7 @@ extern void decl_shadowed_for_var_insert (tree, tree); /* Nonzero if the template arguments is actually a vector of vectors, rather than just a vector. */ #define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \ - (NODE && TREE_VEC_ELT (NODE, 0) \ + (NODE && TREE_VEC_ELT (NODE, 0) \ && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC) /* The depth of a template argument vector. When called directly by @@ -2295,6 +2310,84 @@ extern void decl_shadowed_for_var_insert (tree, tree); the class definition is complete. */ #define TEMPLATE_PARMS_FOR_INLINE(NODE) TREE_LANG_FLAG_1 (NODE) +/* Determine if a parameter (i.e., a PARM_DECL) is a function + parameter pack. */ +#define FUNCTION_PARAMETER_PACK_P(NODE) \ + (DECL_LANG_FLAG_1 (PARM_DECL_CHECK (NODE))) + +/* Determines if NODE is an expansion of one or more parameter packs, + e.g., a TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION. */ +#define PACK_EXPANSION_P(NODE) \ + (TREE_CODE (NODE) == TYPE_PACK_EXPANSION \ + || TREE_CODE (NODE) == EXPR_PACK_EXPANSION) + +/* Extracts the type or expression pattern from a TYPE_PACK_EXPANSION or + EXPR_PACK_EXPANSION. */ +#define PACK_EXPANSION_PATTERN(NODE) \ + (TREE_CODE (NODE) == TYPE_PACK_EXPANSION? TREE_TYPE (NODE) \ + : TREE_OPERAND (NODE, 0)) + +/* Sets the type or expression pattern for a TYPE_PACK_EXPANSION or + EXPR_PACK_EXPANSION. */ +#define SET_PACK_EXPANSION_PATTERN(NODE,VALUE) \ + if (TREE_CODE (NODE) == TYPE_PACK_EXPANSION) \ + TREE_TYPE (NODE) = VALUE; \ + else \ + TREE_OPERAND (NODE, 0) = VALUE + +/* The list of parameter packs used in the PACK_EXPANSION_* node. The + TREE_VALUE of each TREE_LIST contains the parameter packs. */ +#define PACK_EXPANSION_PARAMETER_PACKS(NODE) TREE_CHAIN (NODE) + +/* Determine if this is an argument pack. */ +#define ARGUMENT_PACK_P(NODE) \ + (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK \ + || TREE_CODE (NODE) == NONTYPE_ARGUMENT_PACK) + +/* The arguments stored in an argument pack. Arguments are stored in a + TREE_VEC, which may have length zero. */ +#define ARGUMENT_PACK_ARGS(NODE) \ + (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK? TREE_TYPE (NODE) \ + : TREE_OPERAND (NODE, 0)) + +/* Set the arguments stored in an argument pack. VALUE must be a + TREE_VEC. */ +#define SET_ARGUMENT_PACK_ARGS(NODE,VALUE) \ + if (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK) \ + TREE_TYPE (NODE) = VALUE; \ + else \ + TREE_OPERAND (NODE, 0) = VALUE + +/* Whether the argument pack is "incomplete", meaning that more + arguments can still be deduced. Incomplete argument packs are only + used when the user has provided an explicit template argument list + for a variadic function template. Some of the explicit template + arguments will be placed into the beginning of the argument pack, + but additional arguments might still be deduced. */ +#define ARGUMENT_PACK_INCOMPLETE_P(NODE) \ + TREE_LANG_FLAG_0 (ARGUMENT_PACK_ARGS (NODE)) + +/* When ARGUMENT_PACK_INCOMPLETE_P, stores the explicit template + arguments used to fill this pack. */ +#define ARGUMENT_PACK_EXPLICIT_ARGS(NODE) \ + TREE_TYPE (ARGUMENT_PACK_ARGS (NODE)) + +/* In an ARGUMENT_PACK_SELECT, the argument pack from which an + argument will be selected. */ +#define ARGUMENT_PACK_SELECT_FROM_PACK(NODE) \ + (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->argument_pack) + +/* In an ARGUMENT_PACK_SELECT, the index of the argument we want to + select. */ +#define ARGUMENT_PACK_SELECT_INDEX(NODE) \ + (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->index) + +/* In an ARGUMENT_PACK_SELECT, the actual underlying argument that the + ARGUMENT_PACK_SELECT represents. */ +#define ARGUMENT_PACK_SELECT_ARG(NODE) \ + TREE_VEC_ELT (ARGUMENT_PACK_ARGS (ARGUMENT_PACK_SELECT_FROM_PACK (NODE)), \ + ARGUMENT_PACK_SELECT_INDEX (NODE)); + /* In a FUNCTION_DECL, the saved language-specific per-function data. */ #define DECL_SAVED_FUNCTION_DATA(NODE) \ (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (NODE)) \ @@ -3612,6 +3705,7 @@ enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, OP_FLAG, TYPENAME_FLAG }; #define TEMPLATE_PARM_DESCENDANTS(NODE) (TREE_CHAIN (NODE)) #define TEMPLATE_PARM_ORIG_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->orig_level) #define TEMPLATE_PARM_DECL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->decl) +#define TEMPLATE_PARM_PARAMETER_PACK(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->parameter_pack) /* These macros are for accessing the fields of TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM and BOUND_TEMPLATE_TEMPLATE_PARM nodes. */ @@ -3626,6 +3720,8 @@ enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, OP_FLAG, TYPENAME_FLAG }; (TEMPLATE_PARM_ORIG_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE))) #define TEMPLATE_TYPE_DECL(NODE) \ (TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (NODE))) +#define TEMPLATE_TYPE_PARAMETER_PACK(NODE) \ + (TEMPLATE_PARM_PARAMETER_PACK (TEMPLATE_TYPE_PARM_INDEX (NODE))) /* These constants can used as bit flags in the process of tree formatting. @@ -3812,6 +3908,9 @@ struct cp_declarator { cdk_id and cdk_error, guaranteed to be NULL. */ cp_declarator *declarator; location_t id_loc; /* Currently only set for cdk_id. */ + /* Whether we parsed an ellipsis (`...') just before the declarator, + to indicate this is a parameter pack. */ + bool parameter_pack_p; union { /* For identifiers. */ struct { @@ -4104,6 +4203,7 @@ extern const char *lang_decl_name (tree, int); extern const char *language_to_string (enum languages); extern const char *class_key_or_enum_as_string (tree); extern void print_instantiation_context (void); +extern void maybe_warn_variadic_templates (void); /* in except.c */ extern void init_exception_processing (void); @@ -4194,7 +4294,7 @@ extern void end_specialization (void); extern void begin_explicit_instantiation (void); extern void end_explicit_instantiation (void); extern tree check_explicit_specialization (tree, tree, int, int); -extern tree process_template_parm (tree, tree, bool); +extern tree process_template_parm (tree, tree, bool, bool); extern tree end_template_parm_list (tree); extern void end_template_decl (void); extern tree push_template_decl (tree); @@ -4215,6 +4315,11 @@ extern void do_decl_instantiation (tree, tree); extern void do_type_instantiation (tree, tree, tsubst_flags_t); extern tree instantiate_decl (tree, int, bool); extern int comp_template_parms (tree, tree); +extern bool uses_parameter_packs (tree); +extern bool template_parameter_pack_p (tree); +extern bool template_parms_variadic_p (tree); +extern tree make_pack_expansion (tree); +extern void check_for_bare_parameter_packs (tree); extern int template_class_depth (tree); extern int is_specialization_of (tree, tree); extern bool is_specialization_of_friend (tree, tree); diff --git a/gcc/cp/cxx-pretty-print.c b/gcc/cp/cxx-pretty-print.c index 5c13362df954..e250bf78a2fa 100644 --- a/gcc/cp/cxx-pretty-print.c +++ b/gcc/cp/cxx-pretty-print.c @@ -659,6 +659,7 @@ pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t) unary-operator cast-expression sizeof unary-expression sizeof ( type-id ) + sizeof ... ( identifier ) new-expression delete-expression @@ -686,6 +687,21 @@ pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t) break; case SIZEOF_EXPR: + if (PACK_EXPANSION_P (TREE_OPERAND (t, 0))) + { + pp_cxx_identifier (pp, "sizeof"); + pp_cxx_identifier (pp, "..."); + pp_cxx_whitespace (pp); + pp_cxx_left_paren (pp); + if (TYPE_P (TREE_OPERAND (t, 0))) + pp_cxx_type_id (pp, TREE_OPERAND (t, 0)); + else + pp_unary_expression (pp, TREE_OPERAND (t, 0)); + pp_cxx_right_paren (pp); + break; + } + /* Fall through */ + case ALIGNOF_EXPR: pp_cxx_identifier (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__"); pp_cxx_whitespace (pp); @@ -1000,6 +1016,24 @@ pp_cxx_expression (cxx_pretty_printer *pp, tree t) pp_cxx_expression (pp, t); break; + case EXPR_PACK_EXPANSION: + pp_cxx_expression (pp, PACK_EXPANSION_PATTERN (t)); + pp_cxx_identifier (pp, "..."); + break; + + case NONTYPE_ARGUMENT_PACK: + { + tree args = ARGUMENT_PACK_ARGS (t); + int i, len = TREE_VEC_LENGTH (args); + for (i = 0; i < len; ++i) + { + if (i > 0) + pp_cxx_separate_with (pp, ','); + pp_cxx_expression (pp, TREE_VEC_ELT (args, i)); + } + } + break; + default: pp_c_expression (pp_c_base (pp), t); break; @@ -1290,6 +1324,7 @@ static void pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t) { tree ex_spec = TYPE_RAISES_EXCEPTIONS (t); + bool need_comma = false; if (!TYPE_NOTHROW_P (t) && ex_spec == NULL) return; @@ -1297,9 +1332,28 @@ pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t) pp_cxx_left_paren (pp); for (; ex_spec && TREE_VALUE (ex_spec); ex_spec = TREE_CHAIN (ex_spec)) { - pp_cxx_type_id (pp, TREE_VALUE (ex_spec)); - if (TREE_CHAIN (ex_spec)) - pp_cxx_separate_with (pp, ','); + tree type = TREE_VALUE (ex_spec); + tree argpack = NULL_TREE; + int i, len = 1; + + if (ARGUMENT_PACK_P (type)) + { + argpack = ARGUMENT_PACK_ARGS (type); + len = TREE_VEC_LENGTH (argpack); + } + + for (i = 0; i < len; ++i) + { + if (argpack) + type = TREE_VEC_ELT (argpack, i); + + if (need_comma) + pp_cxx_separate_with (pp, ','); + else + need_comma = true; + + pp_cxx_type_id (pp, type); + } } pp_cxx_right_paren (pp); } @@ -1323,6 +1377,13 @@ pp_cxx_direct_declarator (cxx_pretty_printer *pp, tree t) if (DECL_NAME (t)) { pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t)); + + if ((TREE_CODE (t) == PARM_DECL && FUNCTION_PARAMETER_PACK_P (t)) + || template_parameter_pack_p (t)) + /* A function parameter pack or non-type template + parameter pack. */ + pp_cxx_identifier (pp, "..."); + pp_cxx_id_expression (pp, DECL_NAME (t)); } pp_cxx_abstract_declarator (pp, TREE_TYPE (t)); @@ -1388,8 +1449,16 @@ pp_cxx_ctor_initializer (cxx_pretty_printer *pp, tree t) pp_cxx_whitespace (pp); for (; t; t = TREE_CHAIN (t)) { - pp_cxx_primary_expression (pp, TREE_PURPOSE (t)); + tree purpose = TREE_PURPOSE (t); + bool is_pack = PACK_EXPANSION_P (purpose); + + if (is_pack) + pp_cxx_primary_expression (pp, PACK_EXPANSION_PATTERN (purpose)); + else + pp_cxx_primary_expression (pp, purpose); pp_cxx_call_argument_list (pp, TREE_VALUE (t)); + if (is_pack) + pp_cxx_identifier (pp, "..."); if (TREE_CHAIN (t)) pp_cxx_separate_with (pp, ','); } @@ -1510,6 +1579,11 @@ pp_cxx_type_id (cxx_pretty_printer *pp, tree t) pp_cxx_type_specifier_seq (pp, t); break; + case TYPE_PACK_EXPANSION: + pp_cxx_type_id (pp, PACK_EXPANSION_PATTERN (t)); + pp_cxx_identifier (pp, "..."); + break; + default: pp_c_type_id (pp_c_base (pp), t); break; @@ -1519,30 +1593,50 @@ pp_cxx_type_id (cxx_pretty_printer *pp, tree t) } /* template-argument-list: - template-argument - template-argument-list, template-argument + template-argument ...(opt) + template-argument-list, template-argument ...(opt) template-argument: assignment-expression type-id - template-name */ + template-name */ static void pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t) { int i; + bool need_comma = false; + if (t == NULL) return; for (i = 0; i < TREE_VEC_LENGTH (t); ++i) { tree arg = TREE_VEC_ELT (t, i); - if (i != 0) - pp_cxx_separate_with (pp, ','); - if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL - && TYPE_P (DECL_TEMPLATE_RESULT (arg)))) - pp_cxx_type_id (pp, arg); - else - pp_cxx_expression (pp, arg); + tree argpack = NULL_TREE; + int idx, len = 1; + + if (ARGUMENT_PACK_P (arg)) + { + argpack = ARGUMENT_PACK_ARGS (arg); + len = TREE_VEC_LENGTH (argpack); + } + + for (idx = 0; idx < len; idx++) + { + if (argpack) + arg = TREE_VEC_ELT (argpack, idx); + + if (need_comma) + pp_cxx_separate_with (pp, ','); + else + need_comma = true; + + if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL + && TYPE_P (DECL_TEMPLATE_RESULT (arg)))) + pp_cxx_type_id (pp, arg); + else + pp_cxx_expression (pp, arg); + } } } @@ -1837,11 +1931,11 @@ pp_cxx_template_parameter_list (cxx_pretty_printer *pp, tree t) parameter-declaration type-parameter: - class identifier(opt) - class identifier(op) = type-id + class ...(opt) identifier(opt) + class identifier(opt) = type-id typename identifier(opt) - typename identifier(opt) = type-id - template < template-parameter-list > class identifier(opt) + typename ...(opt) identifier(opt) = type-id + template < template-parameter-list > class ...(opt) identifier(opt) template < template-parameter-list > class identifier(opt) = template-name */ static void @@ -1852,6 +1946,8 @@ pp_cxx_template_parameter (cxx_pretty_printer *pp, tree t) { case TYPE_DECL: pp_cxx_identifier (pp, "class"); + if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t))) + pp_cxx_identifier (pp, "..."); if (DECL_NAME (parameter)) pp_cxx_tree_identifier (pp, DECL_NAME (parameter)); /* FIXME: Chech if we should print also default argument. */ diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 62c1aafef8ed..318085a02b42 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -6967,6 +6967,7 @@ grokdeclarator (const cp_declarator *declarator, cp_storage_class storage_class; bool unsigned_p, signed_p, short_p, long_p, thread_p; bool type_was_error_mark_node = false; + bool parameter_pack_p = declarator? declarator->parameter_pack_p : false; bool set_no_warning = false; signed_p = declspecs->specs[(int)ds_signed]; @@ -7938,6 +7939,16 @@ grokdeclarator (const cp_declarator *declarator, attrlist = &returned_attrs; } + /* Handle parameter packs. */ + if (parameter_pack_p) + { + if (decl_context == PARM) + /* Turn the type into a pack expansion.*/ + type = make_pack_expansion (type); + else + error ("non-parameter %qs cannot be a parameter pack", name); + } + /* Did array size calculations overflow? */ if (TREE_CODE (type) == ARRAY_TYPE @@ -8940,6 +8951,11 @@ grokparms (cp_parameter_declarator *first_parm, tree *parms) init = check_default_argument (decl, init); } + if (TREE_CODE (decl) == PARM_DECL + && FUNCTION_PARAMETER_PACK_P (decl) + && parm->next) + error ("parameter packs must be at the end of the parameter list"); + TREE_CHAIN (decl) = decls; decls = decl; result = tree_cons (init, type, result); @@ -9941,6 +9957,8 @@ xref_basetypes (tree ref, tree base_list) if (access == access_default_node) access = default_access; + if (PACK_EXPANSION_P (basetype)) + basetype = PACK_EXPANSION_PATTERN (basetype); if (TREE_CODE (basetype) == TYPE_DECL) basetype = TREE_TYPE (basetype); if (TREE_CODE (basetype) != RECORD_TYPE @@ -9986,6 +10004,11 @@ xref_basetypes (tree ref, tree base_list) error ("duplicate base type %qT invalid", basetype); return false; } + + if (PACK_EXPANSION_P (TREE_VALUE (base_list))) + /* Regenerate the pack expansion for the bases. */ + basetype = make_pack_expansion (basetype); + TYPE_MARKED_P (basetype) = 1; base_binfo = copy_binfo (base_binfo, basetype, ref, @@ -11695,6 +11718,7 @@ cp_tree_node_structure (union lang_tree_node * t) case PTRMEM_CST: return TS_CP_PTRMEM; case BASELINK: return TS_CP_BASELINK; case STATIC_ASSERT: return TS_CP_STATIC_ASSERT; + case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT; default: return TS_CP_GENERIC; } } diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index a1664b81bcd9..bd078330b0a9 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -136,6 +136,12 @@ cp_build_parm_decl (tree name, tree type) sees templates. */ if (!processing_template_decl) DECL_ARG_TYPE (parm) = type_passed_as (type); + + /* If the type is a pack expansion, then we have a function + parameter pack. */ + if (type && TREE_CODE (type) == TYPE_PACK_EXPANSION) + FUNCTION_PARAMETER_PACK_P (parm) = 1; + return parm; } diff --git a/gcc/cp/error.c b/gcc/cp/error.c index 5779805d80ce..41a7e1d0d207 100644 --- a/gcc/cp/error.c +++ b/gcc/cp/error.c @@ -138,7 +138,9 @@ dump_scope (tree scope, int flags) static void dump_template_argument (tree arg, int flags) { - if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL) + if (ARGUMENT_PACK_P (arg)) + dump_template_argument_list (ARGUMENT_PACK_ARGS (arg), flags); + else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL) dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM); else dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM); @@ -156,9 +158,17 @@ dump_template_argument_list (tree args, int flags) for (i = 0; i< n; ++i) { - if (need_comma) + 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 (cxx_pp); - dump_template_argument (TREE_VEC_ELT (args, i), flags); + + dump_template_argument (arg, flags); need_comma = 1; } } @@ -182,6 +192,8 @@ dump_template_parameter (tree parm, int flags) if (flags & TFF_DECL_SPECIFIERS) { pp_cxx_identifier (cxx_pp, "class"); + if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p))) + pp_cxx_identifier (cxx_pp, "..."); if (DECL_NAME (p)) pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p)); } @@ -378,6 +390,11 @@ dump_type (tree t, int flags) pp_cxx_right_paren (cxx_pp); break; + case TYPE_PACK_EXPANSION: + dump_type (PACK_EXPANSION_PATTERN (t), flags); + pp_cxx_identifier (cxx_pp, "..."); + break; + default: pp_unsupported_tree (cxx_pp, t); /* Fall through to error. */ @@ -1102,8 +1119,7 @@ dump_function_decl (tree t, int flags) static void dump_parameters (tree parmtypes, int flags) { - int first; - + int first = 1; pp_cxx_left_paren (cxx_pp); for (first = 1; parmtypes != void_list_node; @@ -1117,7 +1133,22 @@ dump_parameters (tree parmtypes, int flags) pp_cxx_identifier (cxx_pp, "..."); break; } - dump_type (TREE_VALUE (parmtypes), flags); + if (ARGUMENT_PACK_P (TREE_VALUE (parmtypes))) + { + tree types = ARGUMENT_PACK_ARGS (TREE_VALUE (parmtypes)); + int i, len = TREE_VEC_LENGTH (types); + first = 1; + for (i = 0; i < len; ++i) + { + if (!first) + pp_separate_with_comma (cxx_pp); + first = 0; + + dump_type (TREE_VEC_ELT (types, i), flags); + } + } + else + dump_type (TREE_VALUE (parmtypes), flags); if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes)) { @@ -1240,14 +1271,19 @@ dump_template_parms (tree info, int primary, int flags) { tree arg = TREE_VEC_ELT (args, ix); - if (ix) - pp_separate_with_comma (cxx_pp); - - if (!arg) - pp_identifier (cxx_pp, "