diff options
Diffstat (limited to 'gcc/cp/pt.c')
-rw-r--r-- | gcc/cp/pt.c | 194 |
1 files changed, 122 insertions, 72 deletions
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 2d033e3771a..2bba571b97e 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -6165,7 +6165,7 @@ unify_template_argument_mismatch (bool explain_p, tree parm, tree arg) { if (explain_p) inform (input_location, - " template argument %qE does not match %qD", arg, parm); + " template argument %qE does not match %qE", arg, parm); return 1; } @@ -9563,7 +9563,8 @@ can_complete_type_without_circularity (tree type) return 1; } -static tree tsubst_omp_clauses (tree, bool, bool, tree, tsubst_flags_t, tree); +static tree tsubst_omp_clauses (tree, enum c_omp_region_type, tree, + tsubst_flags_t, tree); /* Instantiate a single dependent attribute T (a TREE_LIST), and return either T or a new TREE_LIST, possibly a chain in the case of a pack expansion. */ @@ -9582,10 +9583,10 @@ tsubst_attribute (tree t, tree *decl_p, tree args, get_attribute_name (t))) { tree clauses = TREE_VALUE (val); - clauses = tsubst_omp_clauses (clauses, true, false, args, + clauses = tsubst_omp_clauses (clauses, C_ORT_OMP_DECLARE_SIMD, args, complain, in_decl); c_omp_declare_simd_clauses_to_decls (*decl_p, clauses); - clauses = finish_omp_clauses (clauses, false, true); + clauses = finish_omp_clauses (clauses, C_ORT_OMP_DECLARE_SIMD); tree parms = DECL_ARGUMENTS (*decl_p); clauses = c_omp_declare_simd_clauses_to_numbers (parms, clauses); @@ -11699,16 +11700,9 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain) if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL) { tree spec; - bool dependent_p; - /* If T is not dependent, just return it. We have to - increment PROCESSING_TEMPLATE_DECL because - value_dependent_expression_p assumes that nothing is - dependent when PROCESSING_TEMPLATE_DECL is zero. */ - ++processing_template_decl; - dependent_p = value_dependent_expression_p (t); - --processing_template_decl; - if (!dependent_p) + /* If T is not dependent, just return it. */ + if (!uses_template_parms (DECL_TI_ARGS (t))) RETURN (t); /* Calculate the most general template of which R is a @@ -14535,7 +14529,7 @@ tsubst_omp_clause_decl (tree decl, tree args, tsubst_flags_t complain, /* Like tsubst_copy, but specifically for OpenMP clauses. */ static tree -tsubst_omp_clauses (tree clauses, bool declare_simd, bool allow_fields, +tsubst_omp_clauses (tree clauses, enum c_omp_region_type ort, tree args, tsubst_flags_t complain, tree in_decl) { tree new_clauses = NULL_TREE, nc, oc; @@ -14685,7 +14679,7 @@ tsubst_omp_clauses (tree clauses, bool declare_simd, bool allow_fields, default: gcc_unreachable (); } - if (allow_fields) + if ((ort & C_ORT_OMP_DECLARE_SIMD) == C_ORT_OMP) switch (OMP_CLAUSE_CODE (nc)) { case OMP_CLAUSE_SHARED: @@ -14747,9 +14741,9 @@ tsubst_omp_clauses (tree clauses, bool declare_simd, bool allow_fields, } new_clauses = nreverse (new_clauses); - if (!declare_simd) + if (ort != C_ORT_OMP_DECLARE_SIMD) { - new_clauses = finish_omp_clauses (new_clauses, allow_fields); + new_clauses = finish_omp_clauses (new_clauses, ort); if (linear_no_step) for (nc = new_clauses; nc; nc = OMP_CLAUSE_CHAIN (nc)) if (nc == linear_no_step) @@ -14970,7 +14964,7 @@ tsubst_omp_for_iterator (tree t, int i, tree declv, tree orig_declv, { tree c = build_omp_clause (input_location, OMP_CLAUSE_PRIVATE); OMP_CLAUSE_DECL (c) = decl; - c = finish_omp_clauses (c, true); + c = finish_omp_clauses (c, C_ORT_OMP); if (c) { OMP_CLAUSE_CHAIN (c) = *clauses; @@ -15452,7 +15446,7 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl, case OACC_KERNELS: case OACC_PARALLEL: - tmp = tsubst_omp_clauses (OMP_CLAUSES (t), false, false, args, complain, + tmp = tsubst_omp_clauses (OMP_CLAUSES (t), C_ORT_ACC, args, complain, in_decl); stmt = begin_omp_parallel (); RECUR (OMP_BODY (t)); @@ -15461,8 +15455,8 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl, case OMP_PARALLEL: r = push_omp_privatization_clauses (OMP_PARALLEL_COMBINED (t)); - tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t), false, true, - args, complain, in_decl); + tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t), C_ORT_OMP, args, + complain, in_decl); if (OMP_PARALLEL_COMBINED (t)) omp_parallel_combined_clauses = &tmp; stmt = begin_omp_parallel (); @@ -15475,8 +15469,8 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl, case OMP_TASK: r = push_omp_privatization_clauses (false); - tmp = tsubst_omp_clauses (OMP_TASK_CLAUSES (t), false, true, - args, complain, in_decl); + tmp = tsubst_omp_clauses (OMP_TASK_CLAUSES (t), C_ORT_OMP, args, + complain, in_decl); stmt = begin_omp_task (); RECUR (OMP_TASK_BODY (t)); finish_omp_task (tmp, stmt); @@ -15495,12 +15489,17 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl, tree declv = NULL_TREE, initv = NULL_TREE, condv = NULL_TREE; tree orig_declv = NULL_TREE; tree incrv = NULL_TREE; + enum c_omp_region_type ort = C_ORT_OMP; int i; + if (TREE_CODE (t) == CILK_SIMD || TREE_CODE (t) == CILK_FOR) + ort = C_ORT_CILK; + else if (TREE_CODE (t) == OACC_LOOP) + ort = C_ORT_ACC; + r = push_omp_privatization_clauses (OMP_FOR_INIT (t) == NULL_TREE); - clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t), false, - TREE_CODE (t) != OACC_LOOP, - args, complain, in_decl); + clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t), ort, args, complain, + in_decl); if (OMP_FOR_INIT (t) != NULL_TREE) { declv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t))); @@ -15556,8 +15555,8 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl, case OMP_CRITICAL: r = push_omp_privatization_clauses (TREE_CODE (t) == OMP_TEAMS && OMP_TEAMS_COMBINED (t)); - tmp = tsubst_omp_clauses (OMP_CLAUSES (t), false, true, - args, complain, in_decl); + tmp = tsubst_omp_clauses (OMP_CLAUSES (t), C_ORT_OMP, args, complain, + in_decl); stmt = push_stmt_list (); RECUR (OMP_BODY (t)); stmt = pop_stmt_list (stmt); @@ -15572,9 +15571,9 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl, case OACC_DATA: case OMP_TARGET_DATA: case OMP_TARGET: - tmp = tsubst_omp_clauses (OMP_CLAUSES (t), false, - TREE_CODE (t) != OACC_DATA, - args, complain, in_decl); + tmp = tsubst_omp_clauses (OMP_CLAUSES (t), (TREE_CODE (t) == OACC_DATA) + ? C_ORT_ACC : C_ORT_OMP, args, complain, + in_decl); keep_next_level (true); stmt = begin_omp_structured_block (); @@ -15619,8 +15618,8 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl, case OACC_DECLARE: t = copy_node (t); - tmp = tsubst_omp_clauses (OACC_DECLARE_CLAUSES (t), false, false, - args, complain, in_decl); + tmp = tsubst_omp_clauses (OACC_DECLARE_CLAUSES (t), C_ORT_ACC, args, + complain, in_decl); OACC_DECLARE_CLAUSES (t) = tmp; add_stmt (t); break; @@ -15628,8 +15627,8 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl, case OMP_TARGET_UPDATE: case OMP_TARGET_ENTER_DATA: case OMP_TARGET_EXIT_DATA: - tmp = tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t), false, true, - args, complain, in_decl); + tmp = tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t), C_ORT_OMP, args, + complain, in_decl); t = copy_node (t); OMP_STANDALONE_CLAUSES (t) = tmp; add_stmt (t); @@ -15638,16 +15637,16 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl, case OACC_ENTER_DATA: case OACC_EXIT_DATA: case OACC_UPDATE: - tmp = tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t), false, false, - args, complain, in_decl); + tmp = tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t), C_ORT_ACC, args, + complain, in_decl); t = copy_node (t); OMP_STANDALONE_CLAUSES (t) = tmp; add_stmt (t); break; case OMP_ORDERED: - tmp = tsubst_omp_clauses (OMP_ORDERED_CLAUSES (t), false, true, - args, complain, in_decl); + tmp = tsubst_omp_clauses (OMP_ORDERED_CLAUSES (t), C_ORT_OMP, args, + complain, in_decl); stmt = push_stmt_list (); RECUR (OMP_BODY (t)); stmt = pop_stmt_list (stmt); @@ -17322,12 +17321,14 @@ instantiate_template_1 (tree tmpl, tree orig_args, tsubst_flags_t complain) /* Check to see if we already have this specialization. */ gen_tmpl = most_general_template (tmpl); - if (tmpl != gen_tmpl) - /* The TMPL is a partial instantiation. To get a full set of - arguments we must add the arguments used to perform the - partial instantiation. */ - targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl), - targ_ptr); + if (TMPL_ARGS_DEPTH (targ_ptr) + < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl))) + /* targ_ptr only has the innermost template args, so add the outer ones + from tmpl, which could be either a partial instantiation or gen_tmpl (in + the case of a non-dependent call within a template definition). */ + targ_ptr = (add_outermost_template_args + (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (tmpl)), + targ_ptr)); /* It would be nice to avoid hashing here and then again in tsubst_decl, but it doesn't seem to be on the hot path. */ @@ -17577,6 +17578,13 @@ fn_type_unification (tree fn, tree tinst; tree r = error_mark_node; + tree full_targs = targs; + if (TMPL_ARGS_DEPTH (targs) + < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (fn))) + full_targs = (add_outermost_template_args + (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (fn)), + targs)); + if (decltype_p) complain |= tf_decltype; @@ -17622,6 +17630,14 @@ fn_type_unification (tree fn, location_t loc = input_location; bool incomplete = false; + if (explicit_targs == error_mark_node) + goto fail; + + if (TMPL_ARGS_DEPTH (explicit_targs) + < TMPL_ARGS_DEPTH (full_targs)) + explicit_targs = add_outermost_template_args (full_targs, + explicit_targs); + /* Adjust any explicit template arguments before entering the substitution context. */ explicit_targs @@ -17701,6 +17717,7 @@ fn_type_unification (tree fn, goto fail; /* Place the explicitly specified arguments in TARGS. */ + explicit_targs = INNERMOST_TEMPLATE_ARGS (explicit_targs); for (i = NUM_TMPL_ARGS (explicit_targs); i--;) TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (explicit_targs, i); } @@ -17750,7 +17767,7 @@ fn_type_unification (tree fn, checks = NULL; ok = !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn), - targs, parms, args, nargs, /*subr=*/0, + full_targs, parms, args, nargs, /*subr=*/0, strict, flags, &checks, explain_p); if (!explain_p) pop_tinst_level (); @@ -18246,7 +18263,7 @@ unify_one_argument (tree tparms, tree targs, tree parm, tree arg, static int type_unification_real (tree tparms, - tree targs, + tree full_targs, tree xparms, const tree *xargs, unsigned int xnargs, @@ -18269,6 +18286,8 @@ type_unification_real (tree tparms, gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST); gcc_assert (ntparms > 0); + tree targs = INNERMOST_TEMPLATE_ARGS (full_targs); + /* Reset the number of non-defaulted template arguments contained in TARGS. */ NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs) = NULL_TREE; @@ -18303,7 +18322,7 @@ type_unification_real (tree tparms, arg = args[ia]; ++ia; - if (unify_one_argument (tparms, targs, parm, arg, subr, strict, + if (unify_one_argument (tparms, full_targs, parm, arg, subr, strict, explain_p)) return 1; } @@ -18323,7 +18342,7 @@ type_unification_real (tree tparms, /* Copy the parameter into parmvec. */ TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms); - if (unify_pack_expansion (tparms, targs, parmvec, argvec, strict, + if (unify_pack_expansion (tparms, full_targs, parmvec, argvec, strict, /*subr=*/subr, explain_p)) return 1; @@ -18484,8 +18503,8 @@ type_unification_real (tree tparms, location_t save_loc = input_location; if (DECL_P (parm)) input_location = DECL_SOURCE_LOCATION (parm); - arg = tsubst_template_arg (arg, targs, complain, NULL_TREE); - arg = convert_template_argument (parm, arg, targs, complain, + arg = tsubst_template_arg (arg, full_targs, complain, NULL_TREE); + arg = convert_template_argument (parm, arg, full_targs, complain, i, NULL_TREE); input_location = save_loc; *checks = get_deferred_access_checks (); @@ -22647,6 +22666,17 @@ value_dependent_expression_p (tree expression) switch (TREE_CODE (expression)) { + case BASELINK: + /* A dependent member function of the current instantiation. */ + return dependent_type_p (BINFO_TYPE (BASELINK_BINFO (expression))); + + case FUNCTION_DECL: + /* A dependent member function of the current instantiation. */ + if (DECL_CLASS_SCOPE_P (expression) + && dependent_type_p (DECL_CONTEXT (expression))) + return true; + break; + case IDENTIFIER_NODE: /* A name that has not been looked up -- must be dependent. */ return true; @@ -22791,10 +22821,10 @@ value_dependent_expression_p (tree expression) case CALL_EXPR: { + if (value_dependent_expression_p (CALL_EXPR_FN (expression))) + return true; tree fn = get_callee_fndecl (expression); int i, nargs; - if (!fn && value_dependent_expression_p (CALL_EXPR_FN (expression))) - return true; nargs = call_expr_nargs (expression); for (i = 0; i < nargs; ++i) { @@ -22958,13 +22988,6 @@ type_dependent_expression_p (tree expression) || dependent_scope_p (scope)); } - /* A function template specialization is type-dependent if it has any - dependent template arguments. */ - if (TREE_CODE (expression) == FUNCTION_DECL - && DECL_LANG_SPECIFIC (expression) - && DECL_TEMPLATE_INFO (expression)) - return any_dependent_template_arguments_p (DECL_TI_ARGS (expression)); - if (TREE_CODE (expression) == TEMPLATE_DECL && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression)) return false; @@ -23017,13 +23040,18 @@ type_dependent_expression_p (tree expression) && DECL_INITIAL (expression)) return true; - /* A variable template specialization is type-dependent if it has any - dependent template arguments. */ - if (VAR_P (expression) + /* A function or variable template-id is type-dependent if it has any + dependent template arguments. Note that we only consider the innermost + template arguments here, since those are the ones that come from the + template-id; the template arguments for the enclosing class do not make it + type-dependent, they only make a member function value-dependent. */ + if (VAR_OR_FUNCTION_DECL_P (expression) && DECL_LANG_SPECIFIC (expression) && DECL_TEMPLATE_INFO (expression) - && variable_template_p (DECL_TI_TEMPLATE (expression))) - return any_dependent_template_arguments_p (DECL_TI_ARGS (expression)); + && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (expression)) + && (any_dependent_template_arguments_p + (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression))))) + return true; /* Always dependent, on the number of arguments if nothing else. */ if (TREE_CODE (expression) == EXPR_PACK_EXPANSION) @@ -23081,6 +23109,22 @@ type_dependent_expression_p (tree expression) return (dependent_type_p (TREE_TYPE (expression))); } +/* [temp.dep.expr]/5: A class member access expression (5.2.5) is + type-dependent if the expression refers to a member of the current + instantiation and the type of the referenced member is dependent, or the + class member access expression refers to a member of an unknown + specialization. + + This function returns true if the OBJECT in such a class member access + expression is of an unknown specialization. */ + +bool +type_dependent_object_expression_p (tree object) +{ + tree scope = TREE_TYPE (object); + return (!scope || dependent_scope_p (scope)); +} + /* walk_tree callback function for instantiation_dependent_expression_p, below. Returns non-zero if a dependent subexpression is found. */ @@ -23285,9 +23329,18 @@ dependent_template_arg_p (tree arg) if (TREE_CODE (arg) == ARGUMENT_PACK_SELECT) arg = ARGUMENT_PACK_SELECT_ARG (arg); - if (TREE_CODE (arg) == TEMPLATE_DECL - || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM) - return dependent_template_p (arg); + if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM) + return true; + if (TREE_CODE (arg) == TEMPLATE_DECL) + { + if (DECL_TEMPLATE_PARM_P (arg)) + return true; + /* A member template of a dependent class is not necessarily + type-dependent, but it is a dependent template argument because it + will be a member of an unknown specialization to that template. */ + tree scope = CP_DECL_CONTEXT (arg); + return TYPE_P (scope) && dependent_type_p (scope); + } else if (ARGUMENT_PACK_P (arg)) { tree args = ARGUMENT_PACK_ARGS (arg); @@ -23383,7 +23436,7 @@ any_dependent_template_arguments_p (const_tree args) return false; } -/* Returns TRUE if the template TMPL is dependent. */ +/* Returns TRUE if the template TMPL is type-dependent. */ bool dependent_template_p (tree tmpl) @@ -23406,9 +23459,6 @@ dependent_template_p (tree tmpl) /* So are names that have not been looked up. */ if (TREE_CODE (tmpl) == SCOPE_REF || identifier_p (tmpl)) return true; - /* So are member templates of dependent classes. */ - if (TYPE_P (CP_DECL_CONTEXT (tmpl))) - return dependent_type_p (DECL_CONTEXT (tmpl)); return false; } |