| /* Perform -*- C++ -*- constant expression evaluation, including calls to |
| constexpr functions. These routines are used both during actual parsing |
| and during the instantiation of template functions. |
| |
| Copyright (C) 1998-2021 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" |
| #include "system.h" |
| #include "coretypes.h" |
| #include "cp-tree.h" |
| #include "varasm.h" |
| #include "c-family/c-objc.h" |
| #include "tree-iterator.h" |
| #include "gimplify.h" |
| #include "builtins.h" |
| #include "tree-inline.h" |
| #include "ubsan.h" |
| #include "gimple-fold.h" |
| #include "timevar.h" |
| #include "fold-const-call.h" |
| #include "stor-layout.h" |
| #include "cgraph.h" |
| #include "opts.h" |
| |
| static bool verify_constant (tree, bool, bool *, bool *); |
| #define VERIFY_CONSTANT(X) \ |
| do { \ |
| if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \ |
| return t; \ |
| } while (0) |
| |
| static HOST_WIDE_INT find_array_ctor_elt (tree ary, tree dindex, |
| bool insert = false); |
| static int array_index_cmp (tree key, tree index); |
| |
| /* Returns true iff FUN is an instantiation of a constexpr function |
| template or a defaulted constexpr function. */ |
| |
| bool |
| is_instantiation_of_constexpr (tree fun) |
| { |
| return ((DECL_TEMPLOID_INSTANTIATION (fun) |
| && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun))) |
| || (DECL_DEFAULTED_FN (fun) |
| && DECL_DECLARED_CONSTEXPR_P (fun))); |
| } |
| |
| /* Return true if T is a literal type. */ |
| |
| bool |
| literal_type_p (tree t) |
| { |
| if (SCALAR_TYPE_P (t) |
| || VECTOR_TYPE_P (t) |
| || TYPE_REF_P (t) |
| || (VOID_TYPE_P (t) && cxx_dialect >= cxx14)) |
| return true; |
| if (CLASS_TYPE_P (t)) |
| { |
| t = complete_type (t); |
| gcc_assert (COMPLETE_TYPE_P (t) || errorcount); |
| return CLASSTYPE_LITERAL_P (t); |
| } |
| if (TREE_CODE (t) == ARRAY_TYPE) |
| return literal_type_p (strip_array_types (t)); |
| return false; |
| } |
| |
| /* If DECL is a variable declared `constexpr', require its type |
| be literal. Return error_mark_node if we give an error, the |
| DECL otherwise. */ |
| |
| tree |
| ensure_literal_type_for_constexpr_object (tree decl) |
| { |
| tree type = TREE_TYPE (decl); |
| if (VAR_P (decl) |
| && (DECL_DECLARED_CONSTEXPR_P (decl) |
| || var_in_constexpr_fn (decl)) |
| && !processing_template_decl) |
| { |
| tree stype = strip_array_types (type); |
| if (CLASS_TYPE_P (stype) && !COMPLETE_TYPE_P (complete_type (stype))) |
| /* Don't complain here, we'll complain about incompleteness |
| when we try to initialize the variable. */; |
| else if (!literal_type_p (type)) |
| { |
| if (DECL_DECLARED_CONSTEXPR_P (decl)) |
| { |
| auto_diagnostic_group d; |
| error_at (DECL_SOURCE_LOCATION (decl), |
| "the type %qT of %<constexpr%> variable %qD " |
| "is not literal", type, decl); |
| explain_non_literal_class (type); |
| decl = error_mark_node; |
| } |
| else if (cxx_dialect < cxx23) |
| { |
| if (!is_instantiation_of_constexpr (current_function_decl)) |
| { |
| auto_diagnostic_group d; |
| error_at (DECL_SOURCE_LOCATION (decl), |
| "variable %qD of non-literal type %qT in " |
| "%<constexpr%> function only available with " |
| "%<-std=c++2b%> or %<-std=gnu++2b%>", decl, type); |
| explain_non_literal_class (type); |
| decl = error_mark_node; |
| } |
| cp_function_chain->invalid_constexpr = true; |
| } |
| } |
| else if (DECL_DECLARED_CONSTEXPR_P (decl) |
| && variably_modified_type_p (type, NULL_TREE)) |
| { |
| error_at (DECL_SOURCE_LOCATION (decl), |
| "%<constexpr%> variable %qD has variably-modified " |
| "type %qT", decl, type); |
| decl = error_mark_node; |
| } |
| } |
| return decl; |
| } |
| |
| struct constexpr_fundef_hasher : ggc_ptr_hash<constexpr_fundef> |
| { |
| static hashval_t hash (const constexpr_fundef *); |
| static bool equal (const constexpr_fundef *, const constexpr_fundef *); |
| }; |
| |
| /* This table holds all constexpr function definitions seen in |
| the current translation unit. */ |
| |
| static GTY (()) hash_table<constexpr_fundef_hasher> *constexpr_fundef_table; |
| |
| /* Utility function used for managing the constexpr function table. |
| Return true if the entries pointed to by P and Q are for the |
| same constexpr function. */ |
| |
| inline bool |
| constexpr_fundef_hasher::equal (const constexpr_fundef *lhs, |
| const constexpr_fundef *rhs) |
| { |
| return lhs->decl == rhs->decl; |
| } |
| |
| /* Utility function used for managing the constexpr function table. |
| Return a hash value for the entry pointed to by Q. */ |
| |
| inline hashval_t |
| constexpr_fundef_hasher::hash (const constexpr_fundef *fundef) |
| { |
| return DECL_UID (fundef->decl); |
| } |
| |
| /* Return a previously saved definition of function FUN. */ |
| |
| constexpr_fundef * |
| retrieve_constexpr_fundef (tree fun) |
| { |
| if (constexpr_fundef_table == NULL) |
| return NULL; |
| |
| constexpr_fundef fundef = { fun, NULL_TREE, NULL_TREE, NULL_TREE }; |
| return constexpr_fundef_table->find (&fundef); |
| } |
| |
| /* Check whether the parameter and return types of FUN are valid for a |
| constexpr function, and complain if COMPLAIN. */ |
| |
| bool |
| is_valid_constexpr_fn (tree fun, bool complain) |
| { |
| bool ret = true; |
| |
| if (DECL_INHERITED_CTOR (fun) |
| && TREE_CODE (fun) == TEMPLATE_DECL) |
| { |
| ret = false; |
| if (complain) |
| error ("inherited constructor %qD is not %<constexpr%>", |
| DECL_INHERITED_CTOR (fun)); |
| } |
| else |
| { |
| for (tree parm = FUNCTION_FIRST_USER_PARM (fun); |
| parm != NULL_TREE; parm = TREE_CHAIN (parm)) |
| if (!literal_type_p (TREE_TYPE (parm))) |
| { |
| ret = false; |
| if (complain) |
| { |
| auto_diagnostic_group d; |
| error ("invalid type for parameter %d of %<constexpr%> " |
| "function %q+#D", DECL_PARM_INDEX (parm), fun); |
| explain_non_literal_class (TREE_TYPE (parm)); |
| } |
| } |
| } |
| |
| if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun)) && cxx_dialect < cxx17) |
| { |
| ret = false; |
| if (complain) |
| inform (DECL_SOURCE_LOCATION (fun), |
| "lambdas are implicitly %<constexpr%> only in C++17 and later"); |
| } |
| else if (!DECL_CONSTRUCTOR_P (fun)) |
| { |
| tree rettype = TREE_TYPE (TREE_TYPE (fun)); |
| if (!literal_type_p (rettype)) |
| { |
| ret = false; |
| if (complain) |
| { |
| auto_diagnostic_group d; |
| error ("invalid return type %qT of %<constexpr%> function %q+D", |
| rettype, fun); |
| explain_non_literal_class (rettype); |
| } |
| } |
| |
| /* C++14 DR 1684 removed this restriction. */ |
| if (cxx_dialect < cxx14 |
| && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun) |
| && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun))) |
| { |
| ret = false; |
| if (complain) |
| { |
| auto_diagnostic_group d; |
| if (pedwarn (DECL_SOURCE_LOCATION (fun), OPT_Wpedantic, |
| "enclosing class of %<constexpr%> non-static" |
| " member function %q+#D is not a literal type", |
| fun)) |
| explain_non_literal_class (DECL_CONTEXT (fun)); |
| } |
| } |
| } |
| else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun))) |
| { |
| ret = false; |
| if (complain) |
| error ("%q#T has virtual base classes", DECL_CONTEXT (fun)); |
| } |
| |
| return ret; |
| } |
| |
| /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF |
| for a member of an anonymous aggregate, INIT is the initializer for that |
| member, and VEC_OUTER is the vector of constructor elements for the class |
| whose constructor we are processing. Add the initializer to the vector |
| and return true to indicate success. */ |
| |
| static bool |
| build_anon_member_initialization (tree member, tree init, |
| vec<constructor_elt, va_gc> **vec_outer) |
| { |
| /* MEMBER presents the relevant fields from the inside out, but we need |
| to build up the initializer from the outside in so that we can reuse |
| previously built CONSTRUCTORs if this is, say, the second field in an |
| anonymous struct. So we use a vec as a stack. */ |
| auto_vec<tree, 2> fields; |
| do |
| { |
| fields.safe_push (TREE_OPERAND (member, 1)); |
| member = TREE_OPERAND (member, 0); |
| } |
| while (ANON_AGGR_TYPE_P (TREE_TYPE (member)) |
| && TREE_CODE (member) == COMPONENT_REF); |
| |
| /* VEC has the constructor elements vector for the context of FIELD. |
| If FIELD is an anonymous aggregate, we will push inside it. */ |
| vec<constructor_elt, va_gc> **vec = vec_outer; |
| tree field; |
| while (field = fields.pop(), |
| ANON_AGGR_TYPE_P (TREE_TYPE (field))) |
| { |
| tree ctor; |
| /* If there is already an outer constructor entry for the anonymous |
| aggregate FIELD, use it; otherwise, insert one. */ |
| if (vec_safe_is_empty (*vec) |
| || (*vec)->last().index != field) |
| { |
| ctor = build_constructor (TREE_TYPE (field), NULL); |
| CONSTRUCTOR_APPEND_ELT (*vec, field, ctor); |
| } |
| else |
| ctor = (*vec)->last().value; |
| vec = &CONSTRUCTOR_ELTS (ctor); |
| } |
| |
| /* Now we're at the innermost field, the one that isn't an anonymous |
| aggregate. Add its initializer to the CONSTRUCTOR and we're done. */ |
| gcc_assert (fields.is_empty()); |
| CONSTRUCTOR_APPEND_ELT (*vec, field, init); |
| |
| return true; |
| } |
| |
| /* Subroutine of build_constexpr_constructor_member_initializers. |
| The expression tree T represents a data member initialization |
| in a (constexpr) constructor definition. Build a pairing of |
| the data member with its initializer, and prepend that pair |
| to the existing initialization pair INITS. */ |
| |
| static bool |
| build_data_member_initialization (tree t, vec<constructor_elt, va_gc> **vec) |
| { |
| tree member, init; |
| if (TREE_CODE (t) == CLEANUP_POINT_EXPR) |
| t = TREE_OPERAND (t, 0); |
| if (TREE_CODE (t) == EXPR_STMT) |
| t = TREE_OPERAND (t, 0); |
| if (t == error_mark_node) |
| return false; |
| if (TREE_CODE (t) == STATEMENT_LIST) |
| { |
| for (tree stmt : tsi_range (t)) |
| if (! build_data_member_initialization (stmt, vec)) |
| return false; |
| return true; |
| } |
| if (TREE_CODE (t) == CLEANUP_STMT) |
| { |
| /* We can't see a CLEANUP_STMT in a constructor for a literal class, |
| but we can in a constexpr constructor for a non-literal class. Just |
| ignore it; either all the initialization will be constant, in which |
| case the cleanup can't run, or it can't be constexpr. |
| Still recurse into CLEANUP_BODY. */ |
| return build_data_member_initialization (CLEANUP_BODY (t), vec); |
| } |
| if (TREE_CODE (t) == CONVERT_EXPR) |
| t = TREE_OPERAND (t, 0); |
| if (TREE_CODE (t) == INIT_EXPR |
| /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only |
| use what this function builds for cx_check_missing_mem_inits, and |
| assignment in the ctor body doesn't count. */ |
| || (cxx_dialect < cxx14 && TREE_CODE (t) == MODIFY_EXPR)) |
| { |
| member = TREE_OPERAND (t, 0); |
| init = break_out_target_exprs (TREE_OPERAND (t, 1)); |
| } |
| else if (TREE_CODE (t) == CALL_EXPR) |
| { |
| tree fn = get_callee_fndecl (t); |
| if (!fn || !DECL_CONSTRUCTOR_P (fn)) |
| /* We're only interested in calls to subobject constructors. */ |
| return true; |
| member = CALL_EXPR_ARG (t, 0); |
| /* We don't use build_cplus_new here because it complains about |
| abstract bases. Leaving the call unwrapped means that it has the |
| wrong type, but cxx_eval_constant_expression doesn't care. */ |
| init = break_out_target_exprs (t); |
| } |
| else if (TREE_CODE (t) == BIND_EXPR) |
| return build_data_member_initialization (BIND_EXPR_BODY (t), vec); |
| else |
| /* Don't add anything else to the CONSTRUCTOR. */ |
| return true; |
| if (INDIRECT_REF_P (member)) |
| member = TREE_OPERAND (member, 0); |
| if (TREE_CODE (member) == NOP_EXPR) |
| { |
| tree op = member; |
| STRIP_NOPS (op); |
| if (TREE_CODE (op) == ADDR_EXPR) |
| { |
| gcc_assert (same_type_ignoring_top_level_qualifiers_p |
| (TREE_TYPE (TREE_TYPE (op)), |
| TREE_TYPE (TREE_TYPE (member)))); |
| /* Initializing a cv-qualified member; we need to look through |
| the const_cast. */ |
| member = op; |
| } |
| else if (op == current_class_ptr |
| && (same_type_ignoring_top_level_qualifiers_p |
| (TREE_TYPE (TREE_TYPE (member)), |
| current_class_type))) |
| /* Delegating constructor. */ |
| member = op; |
| else |
| { |
| /* This is an initializer for an empty base; keep it for now so |
| we can check it in cxx_eval_bare_aggregate. */ |
| gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member)))); |
| } |
| } |
| if (TREE_CODE (member) == ADDR_EXPR) |
| member = TREE_OPERAND (member, 0); |
| if (TREE_CODE (member) == COMPONENT_REF) |
| { |
| tree aggr = TREE_OPERAND (member, 0); |
| if (TREE_CODE (aggr) == VAR_DECL) |
| /* Initializing a local variable, don't add anything. */ |
| return true; |
| if (TREE_CODE (aggr) != COMPONENT_REF) |
| /* Normal member initialization. */ |
| member = TREE_OPERAND (member, 1); |
| else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr))) |
| /* Initializing a member of an anonymous union. */ |
| return build_anon_member_initialization (member, init, vec); |
| else |
| /* We're initializing a vtable pointer in a base. Leave it as |
| COMPONENT_REF so we remember the path to get to the vfield. */ |
| gcc_assert (TREE_TYPE (member) == vtbl_ptr_type_node); |
| } |
| |
| /* Value-initialization can produce multiple initializers for the |
| same field; use the last one. */ |
| if (!vec_safe_is_empty (*vec) && (*vec)->last().index == member) |
| (*vec)->last().value = init; |
| else |
| CONSTRUCTOR_APPEND_ELT (*vec, member, init); |
| return true; |
| } |
| |
| /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval. |
| In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a |
| BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */ |
| |
| static bool |
| check_constexpr_bind_expr_vars (tree t) |
| { |
| gcc_assert (TREE_CODE (t) == BIND_EXPR); |
| |
| for (tree var = BIND_EXPR_VARS (t); var; var = DECL_CHAIN (var)) |
| if (TREE_CODE (var) == TYPE_DECL |
| && DECL_IMPLICIT_TYPEDEF_P (var) |
| && !LAMBDA_TYPE_P (TREE_TYPE (var))) |
| return false; |
| return true; |
| } |
| |
| /* Subroutine of check_constexpr_ctor_body. */ |
| |
| static bool |
| check_constexpr_ctor_body_1 (tree last, tree list) |
| { |
| switch (TREE_CODE (list)) |
| { |
| case DECL_EXPR: |
| if (TREE_CODE (DECL_EXPR_DECL (list)) == USING_DECL |
| || TREE_CODE (DECL_EXPR_DECL (list)) == TYPE_DECL) |
| return true; |
| return false; |
| |
| case CLEANUP_POINT_EXPR: |
| return check_constexpr_ctor_body (last, TREE_OPERAND (list, 0), |
| /*complain=*/false); |
| |
| case BIND_EXPR: |
| if (!check_constexpr_bind_expr_vars (list) |
| || !check_constexpr_ctor_body (last, BIND_EXPR_BODY (list), |
| /*complain=*/false)) |
| return false; |
| return true; |
| |
| case USING_STMT: |
| case STATIC_ASSERT: |
| case DEBUG_BEGIN_STMT: |
| return true; |
| |
| default: |
| return false; |
| } |
| } |
| |
| /* Make sure that there are no statements after LAST in the constructor |
| body represented by LIST. */ |
| |
| bool |
| check_constexpr_ctor_body (tree last, tree list, bool complain) |
| { |
| /* C++14 doesn't require a constexpr ctor to have an empty body. */ |
| if (cxx_dialect >= cxx14) |
| return true; |
| |
| bool ok = true; |
| if (TREE_CODE (list) == STATEMENT_LIST) |
| { |
| tree_stmt_iterator i = tsi_last (list); |
| for (; !tsi_end_p (i); tsi_prev (&i)) |
| { |
| tree t = tsi_stmt (i); |
| if (t == last) |
| break; |
| if (!check_constexpr_ctor_body_1 (last, t)) |
| { |
| ok = false; |
| break; |
| } |
| } |
| } |
| else if (list != last |
| && !check_constexpr_ctor_body_1 (last, list)) |
| ok = false; |
| if (!ok) |
| { |
| if (complain) |
| error ("%<constexpr%> constructor does not have empty body"); |
| DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false; |
| } |
| return ok; |
| } |
| |
| /* V is a vector of constructor elements built up for the base and member |
| initializers of a constructor for TYPE. They need to be in increasing |
| offset order, which they might not be yet if TYPE has a primary base |
| which is not first in the base-clause or a vptr and at least one base |
| all of which are non-primary. */ |
| |
| static vec<constructor_elt, va_gc> * |
| sort_constexpr_mem_initializers (tree type, vec<constructor_elt, va_gc> *v) |
| { |
| tree pri = CLASSTYPE_PRIMARY_BINFO (type); |
| tree field_type; |
| unsigned i; |
| constructor_elt *ce; |
| |
| if (pri) |
| field_type = BINFO_TYPE (pri); |
| else if (TYPE_CONTAINS_VPTR_P (type)) |
| field_type = vtbl_ptr_type_node; |
| else |
| return v; |
| |
| /* Find the element for the primary base or vptr and move it to the |
| beginning of the vec. */ |
| for (i = 0; vec_safe_iterate (v, i, &ce); ++i) |
| if (TREE_TYPE (ce->index) == field_type) |
| break; |
| |
| if (i > 0 && i < vec_safe_length (v)) |
| { |
| vec<constructor_elt, va_gc> &vref = *v; |
| constructor_elt elt = vref[i]; |
| for (; i > 0; --i) |
| vref[i] = vref[i-1]; |
| vref[0] = elt; |
| } |
| |
| return v; |
| } |
| |
| /* Build compile-time evalable representations of member-initializer list |
| for a constexpr constructor. */ |
| |
| static tree |
| build_constexpr_constructor_member_initializers (tree type, tree body) |
| { |
| vec<constructor_elt, va_gc> *vec = NULL; |
| bool ok = true; |
| while (true) |
| switch (TREE_CODE (body)) |
| { |
| case MUST_NOT_THROW_EXPR: |
| case EH_SPEC_BLOCK: |
| body = TREE_OPERAND (body, 0); |
| break; |
| |
| case STATEMENT_LIST: |
| for (tree stmt : tsi_range (body)) |
| { |
| body = stmt; |
| if (TREE_CODE (body) == BIND_EXPR) |
| break; |
| } |
| break; |
| |
| case BIND_EXPR: |
| body = BIND_EXPR_BODY (body); |
| goto found; |
| |
| default: |
| gcc_unreachable (); |
| } |
| found: |
| if (TREE_CODE (body) == TRY_BLOCK) |
| { |
| body = TREE_OPERAND (body, 0); |
| if (TREE_CODE (body) == BIND_EXPR) |
| body = BIND_EXPR_BODY (body); |
| } |
| if (TREE_CODE (body) == CLEANUP_POINT_EXPR) |
| { |
| body = TREE_OPERAND (body, 0); |
| if (TREE_CODE (body) == EXPR_STMT) |
| body = TREE_OPERAND (body, 0); |
| if (TREE_CODE (body) == INIT_EXPR |
| && (same_type_ignoring_top_level_qualifiers_p |
| (TREE_TYPE (TREE_OPERAND (body, 0)), |
| current_class_type))) |
| { |
| /* Trivial copy. */ |
| return TREE_OPERAND (body, 1); |
| } |
| ok = build_data_member_initialization (body, &vec); |
| } |
| else if (TREE_CODE (body) == STATEMENT_LIST) |
| { |
| for (tree stmt : tsi_range (body)) |
| { |
| ok = build_data_member_initialization (stmt, &vec); |
| if (!ok) |
| break; |
| } |
| } |
| else if (EXPR_P (body)) |
| ok = build_data_member_initialization (body, &vec); |
| else |
| gcc_assert (errorcount > 0); |
| if (ok) |
| { |
| if (vec_safe_length (vec) > 0) |
| { |
| /* In a delegating constructor, return the target. */ |
| constructor_elt *ce = &(*vec)[0]; |
| if (ce->index == current_class_ptr) |
| { |
| body = ce->value; |
| vec_free (vec); |
| return body; |
| } |
| } |
| vec = sort_constexpr_mem_initializers (type, vec); |
| return build_constructor (type, vec); |
| } |
| else |
| return error_mark_node; |
| } |
| |
| /* We have an expression tree T that represents a call, either CALL_EXPR |
| or AGGR_INIT_EXPR. If the call is lexically to a named function, |
| retrun the _DECL for that function. */ |
| |
| static tree |
| get_function_named_in_call (tree t) |
| { |
| tree fun = cp_get_callee (t); |
| if (fun && TREE_CODE (fun) == ADDR_EXPR |
| && TREE_CODE (TREE_OPERAND (fun, 0)) == FUNCTION_DECL) |
| fun = TREE_OPERAND (fun, 0); |
| return fun; |
| } |
| |
| /* Subroutine of check_constexpr_fundef. BODY is the body of a function |
| declared to be constexpr, or a sub-statement thereof. Returns the |
| return value if suitable, error_mark_node for a statement not allowed in |
| a constexpr function, or NULL_TREE if no return value was found. */ |
| |
| tree |
| constexpr_fn_retval (tree body) |
| { |
| switch (TREE_CODE (body)) |
| { |
| case STATEMENT_LIST: |
| { |
| tree expr = NULL_TREE; |
| for (tree stmt : tsi_range (body)) |
| { |
| tree s = constexpr_fn_retval (stmt); |
| if (s == error_mark_node) |
| return error_mark_node; |
| else if (s == NULL_TREE) |
| /* Keep iterating. */; |
| else if (expr) |
| /* Multiple return statements. */ |
| return error_mark_node; |
| else |
| expr = s; |
| } |
| return expr; |
| } |
| |
| case RETURN_EXPR: |
| return break_out_target_exprs (TREE_OPERAND (body, 0)); |
| |
| case DECL_EXPR: |
| { |
| tree decl = DECL_EXPR_DECL (body); |
| if (TREE_CODE (decl) == USING_DECL |
| /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */ |
| || DECL_ARTIFICIAL (decl)) |
| return NULL_TREE; |
| return error_mark_node; |
| } |
| |
| case CLEANUP_POINT_EXPR: |
| return constexpr_fn_retval (TREE_OPERAND (body, 0)); |
| |
| case BIND_EXPR: |
| if (!check_constexpr_bind_expr_vars (body)) |
| return error_mark_node; |
| return constexpr_fn_retval (BIND_EXPR_BODY (body)); |
| |
| case USING_STMT: |
| case DEBUG_BEGIN_STMT: |
| return NULL_TREE; |
| |
| case CALL_EXPR: |
| { |
| tree fun = get_function_named_in_call (body); |
| if (fun != NULL_TREE |
| && fndecl_built_in_p (fun, BUILT_IN_UNREACHABLE)) |
| return NULL_TREE; |
| } |
| /* Fallthru. */ |
| |
| default: |
| return error_mark_node; |
| } |
| } |
| |
| /* Subroutine of check_constexpr_fundef. BODY is the DECL_SAVED_TREE of |
| FUN; do the necessary transformations to turn it into a single expression |
| that we can store in the hash table. */ |
| |
| static tree |
| massage_constexpr_body (tree fun, tree body) |
| { |
| if (DECL_CONSTRUCTOR_P (fun)) |
| body = build_constexpr_constructor_member_initializers |
| (DECL_CONTEXT (fun), body); |
| else if (cxx_dialect < cxx14) |
| { |
| if (TREE_CODE (body) == EH_SPEC_BLOCK) |
| body = EH_SPEC_STMTS (body); |
| if (TREE_CODE (body) == MUST_NOT_THROW_EXPR) |
| body = TREE_OPERAND (body, 0); |
| body = constexpr_fn_retval (body); |
| } |
| return body; |
| } |
| |
| /* CTYPE is a type constructed from BODY. Return true if some |
| bases/fields are uninitialized, and complain if COMPLAIN. */ |
| |
| static bool |
| cx_check_missing_mem_inits (tree ctype, tree body, bool complain) |
| { |
| /* We allow uninitialized bases/fields in C++20. */ |
| if (cxx_dialect >= cxx20) |
| return false; |
| |
| unsigned nelts = 0; |
| |
| if (body) |
| { |
| if (TREE_CODE (body) != CONSTRUCTOR) |
| return false; |
| nelts = CONSTRUCTOR_NELTS (body); |
| } |
| tree field = TYPE_FIELDS (ctype); |
| |
| if (TREE_CODE (ctype) == UNION_TYPE) |
| { |
| if (nelts == 0 && next_initializable_field (field)) |
| { |
| if (complain) |
| error ("%<constexpr%> constructor for union %qT must " |
| "initialize exactly one non-static data member", ctype); |
| return true; |
| } |
| return false; |
| } |
| |
| /* Iterate over the CONSTRUCTOR, checking any missing fields don't |
| need an explicit initialization. */ |
| bool bad = false; |
| for (unsigned i = 0; i <= nelts; ++i) |
| { |
| tree index = NULL_TREE; |
| if (i < nelts) |
| { |
| index = CONSTRUCTOR_ELT (body, i)->index; |
| /* Skip base and vtable inits. */ |
| if (TREE_CODE (index) != FIELD_DECL |
| || DECL_ARTIFICIAL (index)) |
| continue; |
| } |
| |
| for (; field != index; field = DECL_CHAIN (field)) |
| { |
| tree ftype; |
| if (TREE_CODE (field) != FIELD_DECL) |
| continue; |
| if (DECL_UNNAMED_BIT_FIELD (field)) |
| continue; |
| if (DECL_ARTIFICIAL (field)) |
| continue; |
| if (ANON_AGGR_TYPE_P (TREE_TYPE (field))) |
| { |
| /* Recurse to check the anonymous aggregate member. */ |
| bad |= cx_check_missing_mem_inits |
| (TREE_TYPE (field), NULL_TREE, complain); |
| if (bad && !complain) |
| return true; |
| continue; |
| } |
| ftype = TREE_TYPE (field); |
| if (!ftype || !TYPE_P (ftype) || !COMPLETE_TYPE_P (ftype)) |
| /* A flexible array can't be intialized here, so don't complain |
| that it isn't. */ |
| continue; |
| if (is_empty_field (field)) |
| /* An empty field doesn't need an initializer. */ |
| continue; |
| ftype = strip_array_types (ftype); |
| if (type_has_constexpr_default_constructor (ftype)) |
| { |
| /* It's OK to skip a member with a trivial constexpr ctor. |
| A constexpr ctor that isn't trivial should have been |
| added in by now. */ |
| gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype) |
| || errorcount != 0); |
| continue; |
| } |
| if (!complain) |
| return true; |
| auto_diagnostic_group d; |
| error ("member %qD must be initialized by mem-initializer " |
| "in %<constexpr%> constructor", field); |
| inform (DECL_SOURCE_LOCATION (field), "declared here"); |
| bad = true; |
| } |
| if (field == NULL_TREE) |
| break; |
| |
| if (ANON_AGGR_TYPE_P (TREE_TYPE (index))) |
| { |
| /* Check the anonymous aggregate initializer is valid. */ |
| bad |= cx_check_missing_mem_inits |
| (TREE_TYPE (index), CONSTRUCTOR_ELT (body, i)->value, complain); |
| if (bad && !complain) |
| return true; |
| } |
| field = DECL_CHAIN (field); |
| } |
| |
| return bad; |
| } |
| |
| /* We are processing the definition of the constexpr function FUN. |
| Check that its body fulfills the apropriate requirements and |
| enter it in the constexpr function definition table. */ |
| |
| void |
| maybe_save_constexpr_fundef (tree fun) |
| { |
| if (processing_template_decl |
| || !DECL_DECLARED_CONSTEXPR_P (fun) |
| || cp_function_chain->invalid_constexpr |
| || (DECL_CLONED_FUNCTION_P (fun) && !DECL_DELETING_DESTRUCTOR_P (fun))) |
| return; |
| |
| if (!is_valid_constexpr_fn (fun, !DECL_GENERATED_P (fun))) |
| return; |
| |
| tree massaged = massage_constexpr_body (fun, DECL_SAVED_TREE (fun)); |
| if (massaged == NULL_TREE || massaged == error_mark_node) |
| { |
| if (!DECL_CONSTRUCTOR_P (fun)) |
| error ("body of %<constexpr%> function %qD not a return-statement", |
| fun); |
| return; |
| } |
| |
| bool potential = potential_rvalue_constant_expression (massaged); |
| if (!potential && !DECL_GENERATED_P (fun)) |
| require_potential_rvalue_constant_expression (massaged); |
| |
| if (DECL_CONSTRUCTOR_P (fun) |
| && cx_check_missing_mem_inits (DECL_CONTEXT (fun), |
| massaged, !DECL_GENERATED_P (fun))) |
| potential = false; |
| |
| if (!potential && !DECL_GENERATED_P (fun)) |
| return; |
| |
| constexpr_fundef entry = {fun, NULL_TREE, NULL_TREE, NULL_TREE}; |
| bool clear_ctx = false; |
| if (DECL_RESULT (fun) && DECL_CONTEXT (DECL_RESULT (fun)) == NULL_TREE) |
| { |
| clear_ctx = true; |
| DECL_CONTEXT (DECL_RESULT (fun)) = fun; |
| } |
| tree saved_fn = current_function_decl; |
| current_function_decl = fun; |
| entry.body = copy_fn (entry.decl, entry.parms, entry.result); |
| current_function_decl = saved_fn; |
| if (clear_ctx) |
| DECL_CONTEXT (DECL_RESULT (entry.decl)) = NULL_TREE; |
| if (!potential) |
| /* For a template instantiation, we want to remember the pre-generic body |
| for explain_invalid_constexpr_fn, but do tell cxx_eval_call_expression |
| that it doesn't need to bother trying to expand the function. */ |
| entry.result = error_mark_node; |
| |
| register_constexpr_fundef (entry); |
| } |
| |
| /* BODY is a validated and massaged definition of a constexpr |
| function. Register it in the hash table. */ |
| |
| void |
| register_constexpr_fundef (const constexpr_fundef &value) |
| { |
| /* Create the constexpr function table if necessary. */ |
| if (constexpr_fundef_table == NULL) |
| constexpr_fundef_table |
| = hash_table<constexpr_fundef_hasher>::create_ggc (101); |
| |
| constexpr_fundef **slot = constexpr_fundef_table->find_slot |
| (const_cast<constexpr_fundef *> (&value), INSERT); |
| |
| gcc_assert (*slot == NULL); |
| *slot = ggc_alloc<constexpr_fundef> (); |
| **slot = value; |
| } |
| |
| /* FUN is a non-constexpr function called in a context that requires a |
| constant expression. If it comes from a constexpr template, explain why |
| the instantiation isn't constexpr. */ |
| |
| void |
| explain_invalid_constexpr_fn (tree fun) |
| { |
| static hash_set<tree> *diagnosed; |
| tree body; |
| /* Only diagnose defaulted functions, lambdas, or instantiations. */ |
| if (!DECL_DEFAULTED_FN (fun) |
| && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun)) |
| && !is_instantiation_of_constexpr (fun)) |
| { |
| inform (DECL_SOURCE_LOCATION (fun), "%qD declared here", fun); |
| return; |
| } |
| if (diagnosed == NULL) |
| diagnosed = new hash_set<tree>; |
| if (diagnosed->add (fun)) |
| /* Already explained. */ |
| return; |
| |
| iloc_sentinel ils = input_location; |
| if (!lambda_static_thunk_p (fun)) |
| { |
| /* Diagnostics should completely ignore the static thunk, so leave |
| input_location set to our caller's location. */ |
| input_location = DECL_SOURCE_LOCATION (fun); |
| inform (input_location, |
| "%qD is not usable as a %<constexpr%> function because:", fun); |
| } |
| /* First check the declaration. */ |
| if (is_valid_constexpr_fn (fun, true)) |
| { |
| /* Then if it's OK, the body. */ |
| if (!DECL_DECLARED_CONSTEXPR_P (fun) |
| && DECL_DEFAULTED_FN (fun)) |
| explain_implicit_non_constexpr (fun); |
| else |
| { |
| if (constexpr_fundef *fd = retrieve_constexpr_fundef (fun)) |
| body = fd->body; |
| else |
| body = DECL_SAVED_TREE (fun); |
| body = massage_constexpr_body (fun, body); |
| require_potential_rvalue_constant_expression (body); |
| if (DECL_CONSTRUCTOR_P (fun)) |
| cx_check_missing_mem_inits (DECL_CONTEXT (fun), body, true); |
| } |
| } |
| } |
| |
| /* Objects of this type represent calls to constexpr functions |
| along with the bindings of parameters to their arguments, for |
| the purpose of compile time evaluation. */ |
| |
| struct GTY((for_user)) constexpr_call { |
| /* Description of the constexpr function definition. */ |
| constexpr_fundef *fundef; |
| /* Parameter bindings environment. A TREE_VEC of arguments. */ |
| tree bindings; |
| /* Result of the call. |
| NULL means the call is being evaluated. |
| error_mark_node means that the evaluation was erroneous; |
| otherwise, the actuall value of the call. */ |
| tree result; |
| /* The hash of this call; we remember it here to avoid having to |
| recalculate it when expanding the hash table. */ |
| hashval_t hash; |
| /* Whether __builtin_is_constant_evaluated() should evaluate to true. */ |
| bool manifestly_const_eval; |
| }; |
| |
| struct constexpr_call_hasher : ggc_ptr_hash<constexpr_call> |
| { |
| static hashval_t hash (constexpr_call *); |
| static bool equal (constexpr_call *, constexpr_call *); |
| }; |
| |
| enum constexpr_switch_state { |
| /* Used when processing a switch for the first time by cxx_eval_switch_expr |
| and default: label for that switch has not been seen yet. */ |
| css_default_not_seen, |
| /* Used when processing a switch for the first time by cxx_eval_switch_expr |
| and default: label for that switch has been seen already. */ |
| css_default_seen, |
| /* Used when processing a switch for the second time by |
| cxx_eval_switch_expr, where default: label should match. */ |
| css_default_processing |
| }; |
| |
| /* The constexpr expansion context part which needs one instance per |
| cxx_eval_outermost_constant_expr invocation. VALUES is a map of values of |
| variables initialized within the expression. */ |
| |
| struct constexpr_global_ctx { |
| /* Values for any temporaries or local variables within the |
| constant-expression. */ |
| hash_map<tree,tree> values; |
| /* Number of cxx_eval_constant_expression calls (except skipped ones, |
| on simple constants or location wrappers) encountered during current |
| cxx_eval_outermost_constant_expr call. */ |
| HOST_WIDE_INT constexpr_ops_count; |
| /* Heap VAR_DECLs created during the evaluation of the outermost constant |
| expression. */ |
| auto_vec<tree, 16> heap_vars; |
| /* Cleanups that need to be evaluated at the end of CLEANUP_POINT_EXPR. */ |
| vec<tree> *cleanups; |
| /* Number of heap VAR_DECL deallocations. */ |
| unsigned heap_dealloc_count; |
| /* Constructor. */ |
| constexpr_global_ctx () |
| : constexpr_ops_count (0), cleanups (NULL), heap_dealloc_count (0) {} |
| }; |
| |
| /* The constexpr expansion context. CALL is the current function |
| expansion, CTOR is the current aggregate initializer, OBJECT is the |
| object being initialized by CTOR, either a VAR_DECL or a _REF. */ |
| |
| struct constexpr_ctx { |
| /* The part of the context that needs to be unique to the whole |
| cxx_eval_outermost_constant_expr invocation. */ |
| constexpr_global_ctx *global; |
| /* The innermost call we're evaluating. */ |
| constexpr_call *call; |
| /* SAVE_EXPRs and TARGET_EXPR_SLOT vars of TARGET_EXPRs that we've seen |
| within the current LOOP_EXPR. NULL if we aren't inside a loop. */ |
| vec<tree> *save_exprs; |
| /* The CONSTRUCTOR we're currently building up for an aggregate |
| initializer. */ |
| tree ctor; |
| /* The object we're building the CONSTRUCTOR for. */ |
| tree object; |
| /* If inside SWITCH_EXPR. */ |
| constexpr_switch_state *css_state; |
| /* The aggregate initialization context inside which this one is nested. This |
| is used by lookup_placeholder to resolve PLACEHOLDER_EXPRs. */ |
| const constexpr_ctx *parent; |
| |
| /* Whether we should error on a non-constant expression or fail quietly. |
| This flag needs to be here, but some of the others could move to global |
| if they get larger than a word. */ |
| bool quiet; |
| /* Whether we are strictly conforming to constant expression rules or |
| trying harder to get a constant value. */ |
| bool strict; |
| /* Whether __builtin_is_constant_evaluated () should be true. */ |
| bool manifestly_const_eval; |
| }; |
| |
| /* This internal flag controls whether we should avoid doing anything during |
| constexpr evaluation that would cause extra DECL_UID generation, such as |
| template instantiation and function body copying. */ |
| |
| static bool uid_sensitive_constexpr_evaluation_value; |
| |
| /* An internal counter that keeps track of the number of times |
| uid_sensitive_constexpr_evaluation_p returned true. */ |
| |
| static unsigned uid_sensitive_constexpr_evaluation_true_counter; |
| |
| /* The accessor for uid_sensitive_constexpr_evaluation_value which also |
| increments the corresponding counter. */ |
| |
| static bool |
| uid_sensitive_constexpr_evaluation_p () |
| { |
| if (uid_sensitive_constexpr_evaluation_value) |
| { |
| ++uid_sensitive_constexpr_evaluation_true_counter; |
| return true; |
| } |
| else |
| return false; |
| } |
| |
| /* The default constructor for uid_sensitive_constexpr_evaluation_sentinel |
| enables the internal flag for uid_sensitive_constexpr_evaluation_p |
| during the lifetime of the sentinel object. Upon its destruction, the |
| previous value of uid_sensitive_constexpr_evaluation_p is restored. */ |
| |
| uid_sensitive_constexpr_evaluation_sentinel |
| ::uid_sensitive_constexpr_evaluation_sentinel () |
| : ovr (uid_sensitive_constexpr_evaluation_value, true) |
| { |
| } |
| |
| /* The default constructor for uid_sensitive_constexpr_evaluation_checker |
| records the current number of times that uid_sensitive_constexpr_evaluation_p |
| has been called and returned true. */ |
| |
| uid_sensitive_constexpr_evaluation_checker |
| ::uid_sensitive_constexpr_evaluation_checker () |
| : saved_counter (uid_sensitive_constexpr_evaluation_true_counter) |
| { |
| } |
| |
| /* Returns true iff uid_sensitive_constexpr_evaluation_p is true, and |
| some constexpr evaluation was restricted due to u_s_c_e_p being called |
| and returning true during the lifetime of this checker object. */ |
| |
| bool |
| uid_sensitive_constexpr_evaluation_checker::evaluation_restricted_p () const |
| { |
| return (uid_sensitive_constexpr_evaluation_value |
| && saved_counter != uid_sensitive_constexpr_evaluation_true_counter); |
| } |
| |
| |
| /* A table of all constexpr calls that have been evaluated by the |
| compiler in this translation unit. */ |
| |
| static GTY (()) hash_table<constexpr_call_hasher> *constexpr_call_table; |
| |
| static tree cxx_eval_constant_expression (const constexpr_ctx *, tree, |
| bool, bool *, bool *, tree * = NULL); |
| |
| /* Compute a hash value for a constexpr call representation. */ |
| |
| inline hashval_t |
| constexpr_call_hasher::hash (constexpr_call *info) |
| { |
| return info->hash; |
| } |
| |
| /* Return true if the objects pointed to by P and Q represent calls |
| to the same constexpr function with the same arguments. |
| Otherwise, return false. */ |
| |
| bool |
| constexpr_call_hasher::equal (constexpr_call *lhs, constexpr_call *rhs) |
| { |
| if (lhs == rhs) |
| return true; |
| if (lhs->hash != rhs->hash) |
| return false; |
| if (lhs->manifestly_const_eval != rhs->manifestly_const_eval) |
| return false; |
| if (!constexpr_fundef_hasher::equal (lhs->fundef, rhs->fundef)) |
| return false; |
| return cp_tree_equal (lhs->bindings, rhs->bindings); |
| } |
| |
| /* Initialize the constexpr call table, if needed. */ |
| |
| static void |
| maybe_initialize_constexpr_call_table (void) |
| { |
| if (constexpr_call_table == NULL) |
| constexpr_call_table = hash_table<constexpr_call_hasher>::create_ggc (101); |
| } |
| |
| /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when |
| a function happens to get called recursively, we unshare the callee |
| function's body and evaluate this unshared copy instead of evaluating the |
| original body. |
| |
| FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function |
| copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map |
| that's keyed off of the original FUNCTION_DECL and whose value is a |
| TREE_LIST of this function's unused copies awaiting reuse. |
| |
| This is not GC-deletable to avoid GC affecting UID generation. */ |
| |
| static GTY(()) decl_tree_map *fundef_copies_table; |
| |
| /* Reuse a copy or create a new unshared copy of the function FUN. |
| Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE |
| is parms, TYPE is result. */ |
| |
| static tree |
| get_fundef_copy (constexpr_fundef *fundef) |
| { |
| tree copy; |
| bool existed; |
| tree *slot = &(hash_map_safe_get_or_insert<hm_ggc> |
| (fundef_copies_table, fundef->decl, &existed, 127)); |
| |
| if (!existed) |
| { |
| /* There is no cached function available, or in use. We can use |
| the function directly. That the slot is now created records |
| that this function is now in use. */ |
| copy = build_tree_list (fundef->body, fundef->parms); |
| TREE_TYPE (copy) = fundef->result; |
| } |
| else if (*slot == NULL_TREE) |
| { |
| if (uid_sensitive_constexpr_evaluation_p ()) |
| return NULL_TREE; |
| |
| /* We've already used the function itself, so make a copy. */ |
| copy = build_tree_list (NULL, NULL); |
| tree saved_body = DECL_SAVED_TREE (fundef->decl); |
| tree saved_parms = DECL_ARGUMENTS (fundef->decl); |
| tree saved_result = DECL_RESULT (fundef->decl); |
| tree saved_fn = current_function_decl; |
| DECL_SAVED_TREE (fundef->decl) = fundef->body; |
| DECL_ARGUMENTS (fundef->decl) = fundef->parms; |
| DECL_RESULT (fundef->decl) = fundef->result; |
| current_function_decl = fundef->decl; |
| TREE_PURPOSE (copy) = copy_fn (fundef->decl, TREE_VALUE (copy), |
| TREE_TYPE (copy)); |
| current_function_decl = saved_fn; |
| DECL_RESULT (fundef->decl) = saved_result; |
| DECL_ARGUMENTS (fundef->decl) = saved_parms; |
| DECL_SAVED_TREE (fundef->decl) = saved_body; |
| } |
| else |
| { |
| /* We have a cached function available. */ |
| copy = *slot; |
| *slot = TREE_CHAIN (copy); |
| } |
| |
| return copy; |
| } |
| |
| /* Save the copy COPY of function FUN for later reuse by |
| get_fundef_copy(). By construction, there will always be an entry |
| to find. */ |
| |
| static void |
| save_fundef_copy (tree fun, tree copy) |
| { |
| tree *slot = fundef_copies_table->get (fun); |
| TREE_CHAIN (copy) = *slot; |
| *slot = copy; |
| } |
| |
| /* We have an expression tree T that represents a call, either CALL_EXPR |
| or AGGR_INIT_EXPR. Return the Nth argument. */ |
| |
| static inline tree |
| get_nth_callarg (tree t, int n) |
| { |
| switch (TREE_CODE (t)) |
| { |
| case CALL_EXPR: |
| return CALL_EXPR_ARG (t, n); |
| |
| case AGGR_INIT_EXPR: |
| return AGGR_INIT_EXPR_ARG (t, n); |
| |
| default: |
| gcc_unreachable (); |
| return NULL; |
| } |
| } |
| |
| /* Attempt to evaluate T which represents a call to a builtin function. |
| We assume here that all builtin functions evaluate to scalar types |
| represented by _CST nodes. */ |
| |
| static tree |
| cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t, tree fun, |
| bool lval, |
| bool *non_constant_p, bool *overflow_p) |
| { |
| const int nargs = call_expr_nargs (t); |
| tree *args = (tree *) alloca (nargs * sizeof (tree)); |
| tree new_call; |
| int i; |
| |
| /* Don't fold __builtin_constant_p within a constexpr function. */ |
| bool bi_const_p = DECL_IS_BUILTIN_CONSTANT_P (fun); |
| |
| /* If we aren't requiring a constant expression, defer __builtin_constant_p |
| in a constexpr function until we have values for the parameters. */ |
| if (bi_const_p |
| && !ctx->manifestly_const_eval |
| && current_function_decl |
| && DECL_DECLARED_CONSTEXPR_P (current_function_decl)) |
| { |
| *non_constant_p = true; |
| return t; |
| } |
| |
| /* For __builtin_is_constant_evaluated, defer it if not |
| ctx->manifestly_const_eval (as sometimes we try to constant evaluate |
| without manifestly_const_eval even expressions or parts thereof which |
| will later be manifestly const_eval evaluated), otherwise fold it to |
| true. */ |
| if (fndecl_built_in_p (fun, CP_BUILT_IN_IS_CONSTANT_EVALUATED, |
| BUILT_IN_FRONTEND)) |
| { |
| if (!ctx->manifestly_const_eval) |
| { |
| *non_constant_p = true; |
| return t; |
| } |
| return boolean_true_node; |
| } |
| |
| if (fndecl_built_in_p (fun, CP_BUILT_IN_SOURCE_LOCATION, BUILT_IN_FRONTEND)) |
| { |
| temp_override<tree> ovr (current_function_decl); |
| if (ctx->call && ctx->call->fundef) |
| current_function_decl = ctx->call->fundef->decl; |
| return fold_builtin_source_location (EXPR_LOCATION (t)); |
| } |
| |
| int strops = 0; |
| int strret = 0; |
| if (fndecl_built_in_p (fun, BUILT_IN_NORMAL)) |
| switch (DECL_FUNCTION_CODE (fun)) |
| { |
| case BUILT_IN_STRLEN: |
| case BUILT_IN_STRNLEN: |
| strops = 1; |
| break; |
| case BUILT_IN_MEMCHR: |
| case BUILT_IN_STRCHR: |
| case BUILT_IN_STRRCHR: |
| strops = 1; |
| strret = 1; |
| break; |
| case BUILT_IN_MEMCMP: |
| case BUILT_IN_STRCMP: |
| strops = 2; |
| break; |
| case BUILT_IN_STRSTR: |
| strops = 2; |
| strret = 1; |
| break; |
| case BUILT_IN_ASAN_POINTER_COMPARE: |
| case BUILT_IN_ASAN_POINTER_SUBTRACT: |
| /* These builtins shall be ignored during constant expression |
| evaluation. */ |
| return void_node; |
| default: |
| break; |
| } |
| |
| /* Be permissive for arguments to built-ins; __builtin_constant_p should |
| return constant false for a non-constant argument. */ |
| constexpr_ctx new_ctx = *ctx; |
| new_ctx.quiet = true; |
| for (i = 0; i < nargs; ++i) |
| { |
| tree arg = CALL_EXPR_ARG (t, i); |
| tree oarg = arg; |
| |
| /* To handle string built-ins we need to pass ADDR_EXPR<STRING_CST> since |
| expand_builtin doesn't know how to look in the values table. */ |
| bool strop = i < strops; |
| if (strop) |
| { |
| STRIP_NOPS (arg); |
| if (TREE_CODE (arg) == ADDR_EXPR) |
| arg = TREE_OPERAND (arg, 0); |
| else |
| strop = false; |
| } |
| |
| /* If builtin_valid_in_constant_expr_p is true, |
| potential_constant_expression_1 has not recursed into the arguments |
| of the builtin, verify it here. */ |
| if (!builtin_valid_in_constant_expr_p (fun) |
| || potential_constant_expression (arg)) |
| { |
| bool dummy1 = false, dummy2 = false; |
| arg = cxx_eval_constant_expression (&new_ctx, arg, false, |
| &dummy1, &dummy2); |
| } |
| |
| if (bi_const_p) |
| /* For __builtin_constant_p, fold all expressions with constant values |
| even if they aren't C++ constant-expressions. */ |
| arg = cp_fold_rvalue (arg); |
| else if (strop) |
| { |
| if (TREE_CODE (arg) == CONSTRUCTOR) |
| arg = braced_lists_to_strings (TREE_TYPE (arg), arg); |
| if (TREE_CODE (arg) == STRING_CST) |
| arg = build_address (arg); |
| else |
| arg = oarg; |
| } |
| |
| args[i] = arg; |
| } |
| |
| bool save_ffbcp = force_folding_builtin_constant_p; |
| force_folding_builtin_constant_p |= ctx->manifestly_const_eval; |
| tree save_cur_fn = current_function_decl; |
| /* Return name of ctx->call->fundef->decl for __builtin_FUNCTION (). */ |
| if (fndecl_built_in_p (fun, BUILT_IN_FUNCTION) |
| && ctx->call |
| && ctx->call->fundef) |
| current_function_decl = ctx->call->fundef->decl; |
| if (fndecl_built_in_p (fun, |
| CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS, |
| BUILT_IN_FRONTEND)) |
| { |
| location_t loc = EXPR_LOCATION (t); |
| if (nargs >= 1) |
| VERIFY_CONSTANT (args[0]); |
| new_call |
| = fold_builtin_is_pointer_inverconvertible_with_class (loc, nargs, |
| args); |
| } |
| else if (fndecl_built_in_p (fun, |
| CP_BUILT_IN_IS_CORRESPONDING_MEMBER, |
| BUILT_IN_FRONTEND)) |
| { |
| location_t loc = EXPR_LOCATION (t); |
| if (nargs >= 2) |
| { |
| VERIFY_CONSTANT (args[0]); |
| VERIFY_CONSTANT (args[1]); |
| } |
| new_call = fold_builtin_is_corresponding_member (loc, nargs, args); |
| } |
| else |
| new_call = fold_builtin_call_array (EXPR_LOCATION (t), TREE_TYPE (t), |
| CALL_EXPR_FN (t), nargs, args); |
| current_function_decl = save_cur_fn; |
| force_folding_builtin_constant_p = save_ffbcp; |
| if (new_call == NULL) |
| { |
| if (!*non_constant_p && !ctx->quiet) |
| { |
| /* Do not allow__builtin_unreachable in constexpr function. |
| The __builtin_unreachable call with BUILTINS_LOCATION |
| comes from cp_maybe_instrument_return. */ |
| if (fndecl_built_in_p (fun, BUILT_IN_UNREACHABLE) |
| && EXPR_LOCATION (t) == BUILTINS_LOCATION) |
| error ("%<constexpr%> call flows off the end of the function"); |
| else |
| { |
| new_call = build_call_array_loc (EXPR_LOCATION (t), TREE_TYPE (t), |
| CALL_EXPR_FN (t), nargs, args); |
| error ("%q+E is not a constant expression", new_call); |
| } |
| } |
| *non_constant_p = true; |
| return t; |
| } |
| |
| if (!potential_constant_expression (new_call)) |
| { |
| if (!*non_constant_p && !ctx->quiet) |
| error ("%q+E is not a constant expression", new_call); |
| *non_constant_p = true; |
| return t; |
| } |
| |
| if (strret) |
| { |
| /* memchr returns a pointer into the first argument, but we replaced the |
| argument above with a STRING_CST; put it back it now. */ |
| tree op = CALL_EXPR_ARG (t, strret-1); |
| STRIP_NOPS (new_call); |
| if (TREE_CODE (new_call) == POINTER_PLUS_EXPR) |
| TREE_OPERAND (new_call, 0) = op; |
| else if (TREE_CODE (new_call) == ADDR_EXPR) |
| new_call = op; |
| } |
| |
| return cxx_eval_constant_expression (&new_ctx, new_call, lval, |
| non_constant_p, overflow_p); |
| } |
| |
| /* TEMP is the constant value of a temporary object of type TYPE. Adjust |
| the type of the value to match. */ |
| |
| static tree |
| adjust_temp_type (tree type, tree temp) |
| { |
| if (same_type_p (TREE_TYPE (temp), type)) |
| return temp; |
| /* Avoid wrapping an aggregate value in a NOP_EXPR. */ |
| if (TREE_CODE (temp) == CONSTRUCTOR) |
| { |
| /* build_constructor wouldn't retain various CONSTRUCTOR flags. */ |
| tree t = copy_node (temp); |
| TREE_TYPE (t) = type; |
| return t; |
| } |
| if (TREE_CODE (temp) == EMPTY_CLASS_EXPR) |
| return build0 (EMPTY_CLASS_EXPR, type); |
| gcc_assert (scalarish_type_p (type)); |
| /* Now we know we're dealing with a scalar, and a prvalue of non-class |
| type is cv-unqualified. */ |
| return cp_fold_convert (cv_unqualified (type), temp); |
| } |
| |
| /* If T is a CONSTRUCTOR, return an unshared copy of T and any |
| sub-CONSTRUCTORs. Otherwise return T. |
| |
| We use this whenever we initialize an object as a whole, whether it's a |
| parameter, a local variable, or a subobject, so that subsequent |
| modifications don't affect other places where it was used. */ |
| |
| tree |
| unshare_constructor (tree t MEM_STAT_DECL) |
| { |
| if (!t || TREE_CODE (t) != CONSTRUCTOR) |
| return t; |
| auto_vec <tree*, 4> ptrs; |
| ptrs.safe_push (&t); |
| while (!ptrs.is_empty ()) |
| { |
| tree *p = ptrs.pop (); |
| tree n = copy_node (*p PASS_MEM_STAT); |
| CONSTRUCTOR_ELTS (n) = vec_safe_copy (CONSTRUCTOR_ELTS (*p) PASS_MEM_STAT); |
| *p = n; |
| vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (n); |
| constructor_elt *ce; |
| for (HOST_WIDE_INT i = 0; vec_safe_iterate (v, i, &ce); ++i) |
| if (ce->value && TREE_CODE (ce->value) == CONSTRUCTOR) |
| ptrs.safe_push (&ce->value); |
| } |
| return t; |
| } |
| |
| /* If T is a CONSTRUCTOR, ggc_free T and any sub-CONSTRUCTORs. */ |
| |
| static void |
| free_constructor (tree t) |
| { |
| if (!t || TREE_CODE (t) != CONSTRUCTOR) |
| return; |
| releasing_vec ctors; |
| vec_safe_push (ctors, t); |
| while (!ctors->is_empty ()) |
| { |
| tree c = ctors->pop (); |
| if (vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (c)) |
| { |
| constructor_elt *ce; |
| for (HOST_WIDE_INT i = 0; vec_safe_iterate (elts, i, &ce); ++i) |
| if (TREE_CODE (ce->value) == CONSTRUCTOR) |
| vec_safe_push (ctors, ce->value); |
| ggc_free (elts); |
| } |
| ggc_free (c); |
| } |
| } |
| |
| /* Helper function of cxx_bind_parameters_in_call. Return non-NULL |
| if *TP is address of a static variable (or part of it) currently being |
| constructed or of a heap artificial variable. */ |
| |
| static tree |
| addr_of_non_const_var (tree *tp, int *walk_subtrees, void *data) |
| { |
| if (TREE_CODE (*tp) == ADDR_EXPR) |
| if (tree var = get_base_address (TREE_OPERAND (*tp, 0))) |
| if (VAR_P (var) && TREE_STATIC (var)) |
| { |
| if (DECL_NAME (var) == heap_uninit_identifier |
| || DECL_NAME (var) == heap_identifier |
| || DECL_NAME (var) == heap_vec_uninit_identifier |
| || DECL_NAME (var) == heap_vec_identifier) |
| return var; |
| |
| constexpr_global_ctx *global = (constexpr_global_ctx *) data; |
| if (global->values.get (var)) |
| return var; |
| } |
| if (TYPE_P (*tp)) |
| *walk_subtrees = false; |
| return NULL_TREE; |
| } |
| |
| /* Subroutine of cxx_eval_call_expression. |
| We are processing a call expression (either CALL_EXPR or |
| AGGR_INIT_EXPR) in the context of CTX. Evaluate |
| all arguments and bind their values to correspondings |
| parameters, making up the NEW_CALL context. */ |
| |
| static tree |
| cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t, tree fun, |
| bool *non_constant_p, bool *overflow_p, |
| bool *non_constant_args) |
| { |
| const int nargs = call_expr_nargs (t); |
| tree parms = DECL_ARGUMENTS (fun); |
| int i; |
| /* We don't record ellipsis args below. */ |
| int nparms = list_length (parms); |
| int nbinds = nargs < nparms ? nargs : nparms; |
| tree binds = make_tree_vec (nbinds); |
| for (i = 0; i < nargs; ++i) |
| { |
| tree x, arg; |
| tree type = parms ? TREE_TYPE (parms) : void_type_node; |
| if (parms && DECL_BY_REFERENCE (parms)) |
| type = TREE_TYPE (type); |
| x = get_nth_callarg (t, i); |
| /* For member function, the first argument is a pointer to the implied |
| object. For a constructor, it might still be a dummy object, in |
| which case we get the real argument from ctx. */ |
| if (i == 0 && DECL_CONSTRUCTOR_P (fun) |
| && is_dummy_object (x)) |
| { |
| x = ctx->object; |
| x = build_address (x); |
| } |
| if (TREE_ADDRESSABLE (type)) |
| /* Undo convert_for_arg_passing work here. */ |
| x = convert_from_reference (x); |
| /* Normally we would strip a TARGET_EXPR in an initialization context |
| such as this, but here we do the elision differently: we keep the |
| TARGET_EXPR, and use its CONSTRUCTOR as the value of the parm. */ |
| arg = cxx_eval_constant_expression (ctx, x, /*lval=*/false, |
| non_constant_p, overflow_p); |
| /* Don't VERIFY_CONSTANT here. */ |
| if (*non_constant_p && ctx->quiet) |
| break; |
| /* Just discard ellipsis args after checking their constantitude. */ |
| if (!parms) |
| continue; |
| |
| if (!*non_constant_p) |
| { |
| /* Make sure the binding has the same type as the parm. But |
| only for constant args. */ |
| if (!TYPE_REF_P (type)) |
| arg = adjust_temp_type (type, arg); |
| if (!TREE_CONSTANT (arg)) |
| *non_constant_args = true; |
| else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) |
| /* The destructor needs to see any modifications the callee makes |
| to the argument. */ |
| *non_constant_args = true; |
| /* If arg is or contains address of a heap artificial variable or |
| of a static variable being constructed, avoid caching the |
| function call, as those variables might be modified by the |
| function, or might be modified by the callers in between |
| the cached function and just read by the function. */ |
| else if (!*non_constant_args |
| && cp_walk_tree (&arg, addr_of_non_const_var, ctx->global, |
| NULL)) |
| *non_constant_args = true; |
| |
| /* For virtual calls, adjust the this argument, so that it is |
| the object on which the method is called, rather than |
| one of its bases. */ |
| if (i == 0 && DECL_VIRTUAL_P (fun)) |
| { |
| tree addr = arg; |
| STRIP_NOPS (addr); |
| if (TREE_CODE (addr) == ADDR_EXPR) |
| { |
| tree obj = TREE_OPERAND (addr, 0); |
| while (TREE_CODE (obj) == COMPONENT_REF |
| && DECL_FIELD_IS_BASE (TREE_OPERAND (obj, 1)) |
| && !same_type_ignoring_top_level_qualifiers_p |
| (TREE_TYPE (obj), DECL_CONTEXT (fun))) |
| obj = TREE_OPERAND (obj, 0); |
| if (obj != TREE_OPERAND (addr, 0)) |
| arg = build_fold_addr_expr_with_type (obj, |
| TREE_TYPE (arg)); |
| } |
| } |
| TREE_VEC_ELT (binds, i) = arg; |
| } |
| parms = TREE_CHAIN (parms); |
| } |
| |
| return binds; |
| } |
| |
| /* Variables and functions to manage constexpr call expansion context. |
| These do not need to be marked for PCH or GC. */ |
| |
| /* FIXME remember and print actual constant arguments. */ |
| static vec<tree> call_stack; |
| static int call_stack_tick; |
| static int last_cx_error_tick; |
| |
| static int |
| push_cx_call_context (tree call) |
| { |
| ++call_stack_tick; |
| if (!EXPR_HAS_LOCATION (call)) |
| SET_EXPR_LOCATION (call, input_location); |
| call_stack.safe_push (call); |
| int len = call_stack.length (); |
| if (len > max_constexpr_depth) |
| return false; |
| return len; |
| } |
| |
| static void |
| pop_cx_call_context (void) |
| { |
| ++call_stack_tick; |
| call_stack.pop (); |
| } |
| |
| vec<tree> |
| cx_error_context (void) |
| { |
| vec<tree> r = vNULL; |
| if (call_stack_tick != last_cx_error_tick |
| && !call_stack.is_empty ()) |
| r = call_stack; |
| last_cx_error_tick = call_stack_tick; |
| return r; |
| } |
| |
| /* Evaluate a call T to a GCC internal function when possible and return |
| the evaluated result or, under the control of CTX, give an error, set |
| NON_CONSTANT_P, and return the unevaluated call T otherwise. */ |
| |
| static tree |
| cxx_eval_internal_function (const constexpr_ctx *ctx, tree t, |
| bool lval, |
| bool *non_constant_p, bool *overflow_p) |
| { |
| enum tree_code opcode = ERROR_MARK; |
| |
| switch (CALL_EXPR_IFN (t)) |
| { |
| case IFN_UBSAN_NULL: |
| case IFN_UBSAN_BOUNDS: |
| case IFN_UBSAN_VPTR: |
| case IFN_FALLTHROUGH: |
| return void_node; |
| |
| case IFN_ADD_OVERFLOW: |
| opcode = PLUS_EXPR; |
| break; |
| case IFN_SUB_OVERFLOW: |
| opcode = MINUS_EXPR; |
| break; |
| case IFN_MUL_OVERFLOW: |
| opcode = MULT_EXPR; |
| break; |
| |
| case IFN_LAUNDER: |
| return cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 0), |
| false, non_constant_p, overflow_p); |
| |
| case IFN_VEC_CONVERT: |
| { |
| tree arg = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 0), |
| false, non_constant_p, |
| overflow_p); |
| if (TREE_CODE (arg) == VECTOR_CST) |
| return fold_const_call (CFN_VEC_CONVERT, TREE_TYPE (t), arg); |
| else |
| { |
| *non_constant_p = true; |
| return t; |
| } |
| } |
| |
| default: |
| if (!ctx->quiet) |
| error_at (cp_expr_loc_or_input_loc (t), |
| "call to internal function %qE", t); |
| *non_constant_p = true; |
| return t; |
| } |
| |
| /* Evaluate constant arguments using OPCODE and return a complex |
| number containing the result and the overflow bit. */ |
| tree arg0 = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 0), lval, |
| non_constant_p, overflow_p); |
| tree arg1 = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 1), lval, |
| non_constant_p, overflow_p); |
| |
| if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST) |
| { |
| location_t loc = cp_expr_loc_or_input_loc (t); |
| tree type = TREE_TYPE (TREE_TYPE (t)); |
| tree result = fold_binary_loc (loc, opcode, type, |
| fold_convert_loc (loc, type, arg0), |
| fold_convert_loc (loc, type, arg1)); |
| tree ovf |
| = build_int_cst (type, arith_overflowed_p (opcode, type, arg0, arg1)); |
| /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */ |
| if (TREE_OVERFLOW (result)) |
| TREE_OVERFLOW (result) = 0; |
| |
| return build_complex (TREE_TYPE (t), result, ovf); |
| } |
| |
| *non_constant_p = true; |
| return t; |
| } |
| |
| /* Clean CONSTRUCTOR_NO_CLEARING from CTOR and its sub-aggregates. */ |
| |
| static void |
| clear_no_implicit_zero (tree ctor) |
| { |
| if (CONSTRUCTOR_NO_CLEARING (ctor)) |
| { |
| CONSTRUCTOR_NO_CLEARING (ctor) = false; |
| tree elt; unsigned HOST_WIDE_INT idx; |
| FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), idx, elt) |
| if (TREE_CODE (elt) == CONSTRUCTOR) |
| clear_no_implicit_zero (elt); |
| } |
| } |
| |
| /* Complain about a const object OBJ being modified in a constant expression. |
| EXPR is the MODIFY_EXPR expression performing the modification. */ |
| |
| static void |
| modifying_const_object_error (tree expr, tree obj) |
| { |
| location_t loc = cp_expr_loc_or_input_loc (expr); |
| auto_diagnostic_group d; |
| error_at (loc, "modifying a const object %qE is not allowed in " |
| "a constant expression", TREE_OPERAND (expr, 0)); |
| inform (location_of (obj), "originally declared %<const%> here"); |
| } |
| |
| /* Return true if FNDECL is a replaceable global allocation function that |
| should be useable during constant expression evaluation. */ |
| |
| static inline bool |
| cxx_replaceable_global_alloc_fn (tree fndecl) |
| { |
| return (cxx_dialect >= cxx20 |
| && IDENTIFIER_NEWDEL_OP_P (DECL_NAME (fndecl)) |
| && CP_DECL_CONTEXT (fndecl) == global_namespace |
| && (DECL_IS_REPLACEABLE_OPERATOR_NEW_P (fndecl) |
| || DECL_IS_OPERATOR_DELETE_P (fndecl))); |
| } |
| |
| /* Return true if FNDECL is a placement new function that should be |
| useable during constant expression evaluation of std::construct_at. */ |
| |
| static inline bool |
| cxx_placement_new_fn (tree fndecl) |
| { |
| if (cxx_dialect >= cxx20 |
| && IDENTIFIER_NEW_OP_P (DECL_NAME (fndecl)) |
| && CP_DECL_CONTEXT (fndecl) == global_namespace |
| && !DECL_IS_REPLACEABLE_OPERATOR_NEW_P (fndecl) |
| && TREE_CODE (TREE_TYPE (fndecl)) == FUNCTION_TYPE) |
| { |
| tree first_arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fndecl))); |
| if (TREE_VALUE (first_arg) == ptr_type_node |
| && TREE_CHAIN (first_arg) == void_list_node) |
| return true; |
| } |
| return false; |
| } |
| |
| /* Return true if FNDECL is std::construct_at. */ |
| |
| static inline bool |
| is_std_construct_at (tree fndecl) |
| { |
| if (!decl_in_std_namespace_p (fndecl)) |
| return false; |
| |
| tree name = DECL_NAME (fndecl); |
| return name && id_equal (name, "construct_at"); |
| } |
| |
| /* Overload for the above taking constexpr_call*. */ |
| |
| static inline bool |
| is_std_construct_at (const constexpr_call *call) |
| { |
| return (call |
| && call->fundef |
| && is_std_construct_at (call->fundef->decl)); |
| } |
| |
| /* Return true if FNDECL is std::allocator<T>::{,de}allocate. */ |
| |
| static inline bool |
| is_std_allocator_allocate (tree fndecl) |
| { |
| tree name = DECL_NAME (fndecl); |
| if (name == NULL_TREE |
| || !(id_equal (name, "allocate") || id_equal (name, "deallocate"))) |
| return false; |
| |
| tree ctx = DECL_CONTEXT (fndecl); |
| if (ctx == NULL_TREE || !CLASS_TYPE_P (ctx) || !TYPE_MAIN_DECL (ctx)) |
| return false; |
| |
| tree decl = TYPE_MAIN_DECL (ctx); |
| name = DECL_NAME (decl); |
| if (name == NULL_TREE || !id_equal (name, "allocator")) |
| return false; |
| |
| return decl_in_std_namespace_p (decl); |
| } |
| |
| /* Overload for the above taking constexpr_call*. */ |
| |
| static inline bool |
| is_std_allocator_allocate (const constexpr_call *call) |
| { |
| return (call |
| && call->fundef |
| && is_std_allocator_allocate (call->fundef->decl)); |
| } |
| |
| /* Return true if FNDECL is __dynamic_cast. */ |
| |
| static inline bool |
| cxx_dynamic_cast_fn_p (tree fndecl) |
| { |
| return (cxx_dialect >= cxx20 |
| && id_equal (DECL_NAME (fndecl), "__dynamic_cast") |
| && CP_DECL_CONTEXT (fndecl) == global_namespace); |
| } |
| |
| /* Often, we have an expression in the form of address + offset, e.g. |
| "&_ZTV1A + 16". Extract the object from it, i.e. "_ZTV1A". */ |
| |
| static tree |
| extract_obj_from_addr_offset (tree expr) |
| { |
| if (TREE_CODE (expr) == POINTER_PLUS_EXPR) |
| expr = TREE_OPERAND (expr, 0); |
| STRIP_NOPS (expr); |
| if (TREE_CODE (expr) == ADDR_EXPR) |
| expr = TREE_OPERAND (expr, 0); |
| return expr; |
| } |
| |
| /* Given a PATH like |
| |
| g.D.2181.D.2154.D.2102.D.2093 |
| |
| find a component with type TYPE. Return NULL_TREE if not found, and |
| error_mark_node if the component is not accessible. If STOP is non-null, |
| this function will return NULL_TREE if STOP is found before TYPE. */ |
| |
| static tree |
| get_component_with_type (tree path, tree type, tree stop) |
| { |
| while (true) |
| { |
| if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (path), type)) |
| /* Found it. */ |
| return path; |
| else if (stop |
| && (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (path), |
| stop))) |
| return NULL_TREE; |
| else if (TREE_CODE (path) == COMPONENT_REF |
| && DECL_FIELD_IS_BASE (TREE_OPERAND (path, 1))) |
| { |
| /* We need to check that the component we're accessing is in fact |
| accessible. */ |
| if (TREE_PRIVATE (TREE_OPERAND (path, 1)) |
| || TREE_PROTECTED (TREE_OPERAND (path, 1))) |
| return error_mark_node; |
| path = TREE_OPERAND (path, 0); |
| } |
| else |
| return NULL_TREE; |
| } |
| } |
| |
| /* Evaluate a call to __dynamic_cast (permitted by P1327R1). |
| |
| The declaration of __dynamic_cast is: |
| |
| void* __dynamic_cast (const void* __src_ptr, |
| const __class_type_info* __src_type, |
| const __class_type_info* __dst_type, |
| ptrdiff_t __src2dst); |
| |
| where src2dst has the following possible values |
| |
| >-1: src_type is a unique public non-virtual base of dst_type |
| dst_ptr + src2dst == src_ptr |
| -1: unspecified relationship |
| -2: src_type is not a public base of dst_type |
| -3: src_type is a multiple public non-virtual base of dst_type |
| |
| Since literal types can't have virtual bases, we only expect hint >=0, |
| -2, or -3. */ |
| |
| static tree |
| cxx_eval_dynamic_cast_fn (const constexpr_ctx *ctx, tree call, |
| bool *non_constant_p, bool *overflow_p) |
| { |
| /* T will be something like |
| __dynamic_cast ((B*) b, &_ZTI1B, &_ZTI1D, 8) |
| dismantle it. */ |
| gcc_assert (call_expr_nargs (call) == 4); |
| tsubst_flags_t complain = ctx->quiet ? tf_none : tf_warning_or_error; |
| tree obj = CALL_EXPR_ARG (call, 0); |
| tree type = CALL_EXPR_ARG (call, 2); |
| HOST_WIDE_INT hint = int_cst_value (CALL_EXPR_ARG (call, 3)); |
| location_t loc = cp_expr_loc_or_input_loc (call); |
| |
| /* Get the target type of the dynamic_cast. */ |
| gcc_assert (TREE_CODE (type) == ADDR_EXPR); |
| type = TREE_OPERAND (type, 0); |
| type = TREE_TYPE (DECL_NAME (type)); |
| |
| /* TYPE can only be either T* or T&. We can't know which of these it |
| is by looking at TYPE, but OBJ will be "(T*) x" in the first case, |
| and something like "(T*)(T&)(T*) x" in the second case. */ |
| bool reference_p = false; |
| while (CONVERT_EXPR_P (obj) || TREE_CODE (obj) == SAVE_EXPR) |
| { |
| reference_p |= TYPE_REF_P (TREE_TYPE (obj)); |
| obj = TREE_OPERAND (obj, 0); |
| } |
| |
| /* Evaluate the object so that we know its dynamic type. */ |
| obj = cxx_eval_constant_expression (ctx, obj, /*lval*/false, non_constant_p, |
| overflow_p); |
| if (*non_constant_p) |
| return call; |
| |
| /* We expect OBJ to be in form of &d.D.2102 when HINT == 0, |
| but when HINT is > 0, it can also be something like |
| &d.D.2102 + 18446744073709551608, which includes the BINFO_OFFSET. */ |
| obj = extract_obj_from_addr_offset (obj); |
| const tree objtype = TREE_TYPE (obj); |
| /* If OBJ doesn't refer to a base field, we're done. */ |
| if (tree t = (TREE_CODE (obj) == COMPONENT_REF |
| ? TREE_OPERAND (obj, 1) : obj)) |
| if (TREE_CODE (t) != FIELD_DECL || !DECL_FIELD_IS_BASE (t)) |
| { |
| if (reference_p) |
| { |
| if (!ctx->quiet) |
| { |
| error_at (loc, "reference %<dynamic_cast%> failed"); |
| inform (loc, "dynamic type %qT of its operand does " |
| "not have a base class of type %qT", |
| objtype, type); |
| } |
| *non_constant_p = true; |
| } |
| return integer_zero_node; |
| } |
| |
| /* [class.cdtor] When a dynamic_cast is used in a constructor ... |
| or in a destructor ... if the operand of the dynamic_cast refers |
| to the object under construction or destruction, this object is |
| considered to be a most derived object that has the type of the |
| constructor or destructor's class. */ |
| tree vtable = build_vfield_ref (obj, objtype); |
| vtable = cxx_eval_constant_expression (ctx, vtable, /*lval*/false, |
| non_constant_p, overflow_p); |
| if (*non_constant_p) |
| return call; |
| /* With -fsanitize=vptr, we initialize all vtable pointers to null, |
| so it's possible that we got a null pointer now. */ |
| if (integer_zerop (vtable)) |
| { |
| if (!ctx->quiet) |
| error_at (loc, "virtual table pointer is used uninitialized"); |
| *non_constant_p = true; |
| return integer_zero_node; |
| } |
| /* VTABLE will be &_ZTV1A + 16 or similar, get _ZTV1A. */ |
| vtable = extract_obj_from_addr_offset (vtable); |
| const tree mdtype = DECL_CONTEXT (vtable); |
| |
| /* Given dynamic_cast<T>(v), |
| |
| [expr.dynamic.cast] If C is the class type to which T points or refers, |
| the runtime check logically executes as follows: |
| |
| If, in the most derived object pointed (referred) to by v, v points |
| (refers) to a public base class subobject of a C object, and if only |
| one object of type C is derived from the subobject pointed (referred) |
| to by v the result points (refers) to that C object. |
| |
| In this case, HINT >= 0 or -3. */ |
| if (hint >= 0 || hint == -3) |
| { |
| /* Look for a component with type TYPE. */ |
| tree t = get_component_with_type (obj, type, mdtype); |
| /* If not accessible, give an error. */ |
| if (t == error_mark_node) |
| { |
| if (reference_p) |
| { |
| if (!ctx->quiet) |
| { |
| error_at (loc, "reference %<dynamic_cast%> failed"); |
| inform (loc, "static type %qT of its operand is a " |
| "non-public base class of dynamic type %qT", |
| objtype, type); |
| |
| } |
| *non_constant_p = true; |
| } |
| return integer_zero_node; |
| } |
| else if (t) |
| /* The result points to the TYPE object. */ |
| return cp_build_addr_expr (t, complain); |
| /* Else, TYPE was not found, because the HINT turned out to be wrong. |
| Fall through to the normal processing. */ |
| } |
| |
| /* Otherwise, if v points (refers) to a public base class subobject of the |
| most derived object, and the type of the most derived object has a base |
| class, of type C, that is unambiguous and public, the result points |
| (refers) to the C subobject of the most derived object. |
| |
| But it can also be an invalid case. */ |
| |
| /* Get the most derived object. */ |
| obj = get_component_with_type (obj, mdtype, NULL_TREE); |
| if (obj == error_mark_node) |
| { |
| if (reference_p) |
| { |
| if (!ctx->quiet) |
| { |
| error_at (loc, "reference %<dynamic_cast%> failed"); |
| inform (loc, "static type %qT of its operand is a non-public" |
| " base class of dynamic type %qT", objtype, mdtype); |
| } |
| *non_constant_p = true; |
| } |
| return integer_zero_node; |
| } |
| else |
| gcc_assert (obj); |
| |
| /* Check that the type of the most derived object has a base class |
| of type TYPE that is unambiguous and public. */ |
| base_kind b_kind; |
| tree binfo = lookup_base (mdtype, type, ba_check, &b_kind, tf_none); |
| if (!binfo || binfo == error_mark_node) |
| { |
| if (reference_p) |
| { |
| if (!ctx->quiet) |
| { |
| error_at (loc, "reference %<dynamic_cast%> failed"); |
| if (b_kind == bk_ambig) |
| inform (loc, "%qT is an ambiguous base class of dynamic " |
| "type %qT of its operand", type, mdtype); |
| else |
| inform (loc, "dynamic type %qT of its operand does not " |
| "have an unambiguous public base class %qT", |
| mdtype, type); |
| } |
| *non_constant_p = true; |
| } |
| return integer_zero_node; |
| } |
| /* If so, return the TYPE subobject of the most derived object. */ |
| obj = convert_to_base_statically (obj, binfo); |
| return cp_build_addr_expr (obj, complain); |
| } |
| |
| /* Data structure used by replace_result_decl and replace_result_decl_r. */ |
| |
| struct replace_result_decl_data |
| { |
| /* The RESULT_DECL we want to replace. */ |
| tree decl; |
| /* The replacement for DECL. */ |
| tree replacement; |
| /* Whether we've performed any replacements. */ |
| bool changed; |
| }; |
| |
| /* Helper function for replace_result_decl, called through cp_walk_tree. */ |
| |
| static tree |
| replace_result_decl_r (tree *tp, int *walk_subtrees, void *data) |
| { |
| replace_result_decl_data *d = (replace_result_decl_data *) data; |
| |
| if (*tp == d->decl) |
| { |
| *tp = unshare_expr (d->replacement); |
| d->changed = true; |
| *walk_subtrees = 0; |
| } |
| else if (TYPE_P (*tp)) |
| *walk_subtrees = 0; |
| |
| return NULL_TREE; |
| } |
| |
| /* Replace every occurrence of DECL, a RESULT_DECL, with (an unshared copy of) |
| REPLACEMENT within the reduced constant expression *TP. Returns true iff a |
| replacement was performed. */ |
| |
| static bool |
| replace_result_decl (tree *tp, tree decl, tree replacement) |
| { |
| gcc_checking_assert (TREE_CODE (decl) == RESULT_DECL |
| && (same_type_ignoring_top_level_qualifiers_p |
| (TREE_TYPE (decl), TREE_TYPE (replacement)))); |
| replace_result_decl_data data = { decl, replacement, false }; |
| cp_walk_tree_without_duplicates (tp, replace_result_decl_r, &data); |
| return data.changed; |
| } |
| |
| /* Evaluate the call T to virtual function thunk THUNK_FNDECL. */ |
| |
| static tree |
| cxx_eval_thunk_call (const constexpr_ctx *ctx, tree t, tree thunk_fndecl, |
| bool lval, |
| bool *non_constant_p, bool *overflow_p) |
| { |
| tree function = THUNK_TARGET (thunk_fndecl); |
| |
| /* virtual_offset is only set in the presence of virtual bases, which make |
| the class non-literal, so we don't need to handle it here. */ |
| if (THUNK_VIRTUAL_OFFSET (thunk_fndecl)) |
| { |
| gcc_assert (!DECL_DECLARED_CONSTEXPR_P (function)); |
| if (!ctx->quiet) |
| { |
| error ("call to non-%<constexpr%> function %qD", function); |
| explain_invalid_constexpr_fn (function); |
| } |
| *non_constant_p = true; |
| return t; |
| } |
| |
| tree new_call = copy_node (t); |
| CALL_EXPR_FN (new_call) = function; |
| TREE_TYPE (new_call) = TREE_TYPE (TREE_TYPE (function)); |
| |
| tree offset = size_int (THUNK_FIXED_OFFSET (thunk_fndecl)); |
| |
| if (DECL_THIS_THUNK_P (thunk_fndecl)) |
| { |
| /* 'this'-adjusting thunk. */ |
| tree this_arg = CALL_EXPR_ARG (t, 0); |
| this_arg = build2 (POINTER_PLUS_EXPR, TREE_TYPE (this_arg), |
| this_arg, offset); |
| CALL_EXPR_ARG (new_call, 0) = this_arg; |
| } |
| else |
| /* Return-adjusting thunk. */ |
| new_call = build2 (POINTER_PLUS_EXPR, TREE_TYPE (new_call), |
| new_call, offset); |
| |
| return cxx_eval_constant_expression (ctx, new_call, lval, |
| non_constant_p, overflow_p); |
| } |
| |
| /* If OBJECT is of const class type, evaluate it to a CONSTRUCTOR and set |
| its TREE_READONLY flag according to READONLY_P. Used for constexpr |
| 'tors to detect modifying const objects in a constexpr context. */ |
| |
| static void |
| cxx_set_object_constness (const constexpr_ctx *ctx, tree object, |
| bool readonly_p, bool *non_constant_p, |
| bool *overflow_p) |
| { |
| if (CLASS_TYPE_P (TREE_TYPE (object)) |
| && CP_TYPE_CONST_P (TREE_TYPE (object))) |
| { |
| /* Subobjects might not be stored in ctx->global->values but we |
| can get its CONSTRUCTOR by evaluating *this. */ |
| tree e = cxx_eval_constant_expression (ctx, object, /*lval*/false, |
| non_constant_p, overflow_p); |
| if (TREE_CODE (e) == CONSTRUCTOR && !*non_constant_p) |
| TREE_READONLY (e) = readonly_p; |
| } |
| } |
| |
| /* Subroutine of cxx_eval_constant_expression. |
| Evaluate the call expression tree T in the context of OLD_CALL expression |
| evaluation. */ |
| |
| static tree |
| cxx_eval_call_expression (const constexpr_ctx *ctx, tree t, |
| bool lval, |
| bool *non_constant_p, bool *overflow_p) |
| { |
| /* Handle concept checks separately. */ |
| if (concept_check_p (t)) |
| return evaluate_concept_check (t); |
| |
| location_t loc = cp_expr_loc_or_input_loc (t); |
| tree fun = get_function_named_in_call (t); |
| constexpr_call new_call |
| = { NULL, NULL, NULL, 0, ctx->manifestly_const_eval }; |
| int depth_ok; |
| |
| if (fun == NULL_TREE) |
| return cxx_eval_internal_function (ctx, t, lval, |
| non_constant_p, overflow_p); |
| |
| if (TREE_CODE (fun) != FUNCTION_DECL) |
| { |
| /* Might be a constexpr function pointer. */ |
| fun = cxx_eval_constant_expression (ctx, fun, |
| /*lval*/false, non_constant_p, |
| overflow_p); |
| STRIP_NOPS (fun); |
| if (TREE_CODE (fun) == ADDR_EXPR) |
| fun = TREE_OPERAND (fun, 0); |
| /* For TARGET_VTABLE_USES_DESCRIPTORS targets, there is no |
| indirection, the called expression is a pointer into the |
| virtual table which should contain FDESC_EXPR. Extract the |
| FUNCTION_DECL from there. */ |
| else if (TARGET_VTABLE_USES_DESCRIPTORS |
| && TREE_CODE (fun) == POINTER_PLUS_EXPR |
| && TREE_CODE (TREE_OPERAND (fun, 0)) == ADDR_EXPR |
| && TREE_CODE (TREE_OPERAND (fun, 1)) == INTEGER_CST) |
| { |
| tree d = TREE_OPERAND (TREE_OPERAND (fun, 0), 0); |
| if (VAR_P (d) |
| && DECL_VTABLE_OR_VTT_P (d) |
| && TREE_CODE (TREE_TYPE (d)) == ARRAY_TYPE |
| && TREE_TYPE (TREE_TYPE (d)) == vtable_entry_type |
| && DECL_INITIAL (d) |
| && TREE_CODE (DECL_INITIAL (d)) == CONSTRUCTOR) |
| { |
| tree i = int_const_binop (TRUNC_DIV_EXPR, TREE_OPERAND (fun, 1), |
| TYPE_SIZE_UNIT (vtable_entry_type)); |
| HOST_WIDE_INT idx = find_array_ctor_elt (DECL_INITIAL (d), i); |
| if (idx >= 0) |
| { |
| tree fdesc |
| = (*CONSTRUCTOR_ELTS (DECL_INITIAL (d)))[idx].value; |
| if (TREE_CODE (fdesc) == FDESC_EXPR |
| && integer_zerop (TREE_OPERAND (fdesc, 1))) |
| fun = TREE_OPERAND (fdesc, 0); |
| } |
| } |
| } |
| } |
| if (TREE_CODE (fun) != FUNCTION_DECL) |
| { |
| if (!ctx->quiet && !*non_constant_p) |
| error_at (loc, "expression %qE does not designate a %<constexpr%> " |
| "function", fun); |
| *non_constant_p = true; |
| return t; |
| } |
| if (DECL_CLONED_FUNCTION_P (fun) && !DECL_DELETING_DESTRUCTOR_P (fun)) |
| fun = DECL_CLONED_FUNCTION (fun); |
| |
| if (is_ubsan_builtin_p (fun)) |
| return void_node; |
| |
| if (fndecl_built_in_p (fun)) |
| return cxx_eval_builtin_function_call (ctx, t, fun, |
| lval, non_constant_p, overflow_p); |
| if (DECL_THUNK_P (fun)) |
| return cxx_eval_thunk_call (ctx, t, fun, lval, non_constant_p, overflow_p); |
| if (!DECL_DECLARED_CONSTEXPR_P (fun)) |
| { |
| if (TREE_CODE (t) == CALL_EXPR |
| && cxx_replaceable_global_alloc_fn (fun) |
| && (CALL_FROM_NEW_OR_DELETE_P (t) |
| || is_std_allocator_allocate (ctx->call))) |
| { |
| const int nargs = call_expr_nargs (t); |
| tree arg0 = NULL_TREE; |
| for (int i = 0; i < nargs; ++i) |
| { |
| tree arg = CALL_EXPR_ARG (t, i); |
| arg = cxx_eval_constant_expression (ctx, arg, false, |
| non_constant_p, overflow_p); |
| VERIFY_CONSTANT (arg); |
| if (i == 0) |
| arg0 = arg; |
| } |
| gcc_assert (arg0); |
| if (IDENTIFIER_NEW_OP_P (DECL_NAME (fun))) |
| { |
| tree type = build_array_type_nelts (char_type_node, |
| tree_to_uhwi (arg0)); |
| tree var = build_decl (loc, VAR_DECL, |
| (IDENTIFIER_OVL_OP_FLAGS (DECL_NAME (fun)) |
| & OVL_OP_FLAG_VEC) |
| ? heap_vec_uninit_identifier |
| : heap_uninit_identifier, |
| type); |
| DECL_ARTIFICIAL (var) = 1; |
| TREE_STATIC (var) = 1; |
| // Temporarily register the artificial var in varpool, |
| // so that comparisons of its address against NULL are folded |
| // through nonzero_address even with |
| // -fno-delete-null-pointer-checks or that comparison of |
| // addresses of different heap artificial vars is folded too. |
| // See PR98988 and PR99031. |
| varpool_node::finalize_decl (var); |
| ctx->global->heap_vars.safe_push (var); |
| ctx->global->values.put (var, NULL_TREE); |
| return fold_convert (ptr_type_node, build_address (var)); |
| } |
| else |
| { |
| STRIP_NOPS (arg0); |
| if (TREE_CODE (arg0) == ADDR_EXPR |
| && VAR_P (TREE_OPERAND (arg0, 0))) |
| { |
| tree var = TREE_OPERAND (arg0, 0); |
| if (DECL_NAME (var) == heap_uninit_identifier |
| || DECL_NAME (var) == heap_identifier) |
| { |
| if (IDENTIFIER_OVL_OP_FLAGS (DECL_NAME (fun)) |
| & OVL_OP_FLAG_VEC) |
| { |
| if (!ctx->quiet) |
| { |
| error_at (loc, "array deallocation of object " |
| "allocated with non-array " |
| "allocation"); |
| inform (DECL_SOURCE_LOCATION (var), |
| "allocation performed here"); |
| } |
| *non_constant_p = true; |
| return t; |
| } |
| DECL_NAME (var) = heap_deleted_identifier; |
| ctx->global->values.remove (var); |
| ctx->global->heap_dealloc_count++; |
| return void_node; |
| } |
| else if (DECL_NAME (var) == heap_vec_uninit_identifier |
| || DECL_NAME (var) == heap_vec_identifier) |
| { |
| if ((IDENTIFIER_OVL_OP_FLAGS (DECL_NAME (fun)) |
| & OVL_OP_FLAG_VEC) == 0) |
| { |
| if (!ctx->quiet) |
| { |
| error_at (loc, "non-array deallocation of " |
| "object allocated with array " |
| "allocation"); |
| inform (DECL_SOURCE_LOCATION (var), |
| "allocation performed here"); |
| } |
| *non_constant_p = true; |
| return t; |
| } |
| DECL_NAME (var) = heap_deleted_identifier; |
| ctx->global->values.remove (var); |
| ctx->global->heap_dealloc_count++; |
| return void_node; |
| } |
| else if (DECL_NAME (var) == heap_deleted_identifier) |
| { |
| if (!ctx->quiet) |
| error_at (loc, "deallocation of already deallocated " |
| "storage"); |
| *non_constant_p = true; |
| return t; |
| } |
| } |
| if (!ctx->quiet) |
| error_at (loc, "deallocation of storage that was " |
| "not previously allocated"); |
| *non_constant_p = true; |
| return t; |
| } |
| } |
| /* Allow placement new in std::construct_at, just return the second |
| argument. */ |
| if (TREE_CODE (t) == CALL_EXPR |
| && cxx_placement_new_fn (fun) |
| && is_std_construct_at (ctx->call)) |
| { |
| const int nargs = call_expr_nargs (t); |
| tree arg1 = NULL_TREE; |
| for (int i = 0; i < nargs; ++i) |
| { |
| tree arg = CALL_EXPR_ARG (t, i); |
| arg = cxx_eval_constant_expression (ctx, arg, false, |
| non_constant_p, overflow_p); |
| if (i == 1) |
| arg1 = arg; |
| else |
| VERIFY_CONSTANT (arg); |
| } |
| gcc_assert (arg1); |
| return arg1; |
| } |
| else if (cxx_dynamic_cast_fn_p (fun)) |
| return cxx_eval_dynamic_cast_fn (ctx, t, non_constant_p, overflow_p); |
| |
| if (!ctx->quiet) |
| { |
| if (!lambda_static_thunk_p (fun)) |
| error_at (loc, "call to non-%<constexpr%> function %qD", fun); |
| explain_invalid_constexpr_fn (fun); |
| } |
| *non_constant_p = true; |
| return t; |
| } |
| |
| constexpr_ctx new_ctx = *ctx; |
| if (DECL_CONSTRUCTOR_P (fun) && !ctx->object |
| && TREE_CODE (t) == AGGR_INIT_EXPR) |
| { |
| /* We want to have an initialization target for an AGGR_INIT_EXPR. |
| If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */ |
| new_ctx.object = AGGR_INIT_EXPR_SLOT (t); |
| tree ctor = new_ctx.ctor = build_constructor (DECL_CONTEXT (fun), NULL); |
| CONSTRUCTOR_NO_CLEARING (ctor) = true; |
| ctx->global->values.put (new_ctx.object, ctor); |
| ctx = &new_ctx; |
| } |
| |
| /* Shortcut trivial constructor/op=. */ |
| if (trivial_fn_p (fun)) |
| { |
| tree init = NULL_TREE; |
| if (call_expr_nargs (t) == 2) |
| init = convert_from_reference (get_nth_callarg (t, 1)); |
| else if (TREE_CODE (t) == AGGR_INIT_EXPR |
| && AGGR_INIT_ZERO_FIRST (t)) |
| init = build_zero_init (DECL_CONTEXT (fun), NULL_TREE, false); |
| if (init) |
| { |
| tree op = get_nth_callarg (t, 0); |
| if (is_dummy_object (op)) |
| op = ctx->object; |
| else |
| op = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (op)), op); |
| tree set = build2 (MODIFY_EXPR, TREE_TYPE (op), op, init); |
| new_ctx.call = &new_call; |
| return cxx_eval_constant_expression (&new_ctx, set, lval, |
| non_constant_p, overflow_p); |
| } |
| } |
| |
| bool non_constant_args = false; |
| new_call.bindings |
| = cxx_bind_parameters_in_call (ctx, t, fun, non_constant_p, |
| overflow_p, &non_constant_args); |
| |
| /* We build up the bindings list before we know whether we already have this |
| call cached. If we don't end up saving these bindings, ggc_free them when |
| this function exits. */ |
| class free_bindings |
| { |
| tree *bindings; |
| public: |
| free_bindings (tree &b): bindings (&b) { } |
| ~free_bindings () { if (bindings) ggc_free (*bindings); } |
| void preserve () { bindings = NULL; } |
| } fb (new_call.bindings); |
| |
| if (*non_constant_p) |
| return t; |
| |
| /* We can't defer instantiating the function any longer. */ |
| if (!DECL_INITIAL (fun) |
| && DECL_TEMPLOID_INSTANTIATION (fun) |
| && !uid_sensitive_constexpr_evaluation_p ()) |
| { |
| location_t save_loc = input_location; |
| input_location = loc; |
| ++function_depth; |
| if (ctx->manifestly_const_eval) |
| FNDECL_MANIFESTLY_CONST_EVALUATED (fun) = true; |
| instantiate_decl (fun, /*defer_ok*/false, /*expl_inst*/false); |
| --function_depth; |
| input_location = save_loc; |
| } |
| |
| /* If in direct recursive call, optimize definition search. */ |
| if (ctx && ctx->call && ctx->call->fundef && ctx->call->fundef->decl == fun) |
| new_call.fundef = ctx->call->fundef; |
| else |
| { |
| new_call.fundef = retrieve_constexpr_fundef (fun); |
| if (new_call.fundef == NULL || new_call.fundef->body == NULL |
| || new_call.fundef->result == error_mark_node |
| || fun == current_function_decl) |
| { |
| if (!ctx->quiet) |
| { |
| /* We need to check for current_function_decl here in case we're |
| being called during cp_fold_function, because at that point |
| DECL_INITIAL is set properly and we have a fundef but we |
| haven't lowered invisirefs yet (c++/70344). */ |
| if (DECL_INITIAL (fun) == error_mark_node |
| || fun == current_function_decl) |
| error_at (loc, "%qD called in a constant expression before its " |
| "definition is complete", fun); |
| else if (DECL_INITIAL (fun)) |
| { |
| /* The definition of fun was somehow unsuitable. But pretend |
| that lambda static thunks don't exist. */ |
| if (!lambda_static_thunk_p (fun)) |
| error_at (loc, "%qD called in a constant expression", fun); |
| explain_invalid_constexpr_fn (fun); |
| } |
| else |
| error_at (loc, "%qD used before its definition", fun); |
| } |
| *non_constant_p = true; |
| return t; |
| } |
| } |
| |
| depth_ok = push_cx_call_context (t); |
| |
| /* Remember the object we are constructing or destructing. */ |
| tree new_obj = NULL_TREE; |
| if (DECL_CONSTRUCTOR_P (fun) || DECL_DESTRUCTOR_P (fun)) |
| { |
| /* In a cdtor, it should be the first `this' argument. |
| At this point it has already been evaluated in the call |
| to cxx_bind_parameters_in_call. */ |
| new_obj = TREE_VEC_ELT (new_call.bindings, 0); |
| STRIP_NOPS (new_obj); |
| if (TREE_CODE (new_obj) == ADDR_EXPR) |
| new_obj = TREE_OPERAND (new_obj, 0); |
| |
| if (ctx->call && ctx->call->fundef |
| && DECL_CONSTRUCTOR_P (ctx->call->fundef->decl)) |
| { |
| tree cur_obj = TREE_VEC_ELT (ctx->call->bindings, 0); |
| STRIP_NOPS (cur_obj); |
| if (TREE_CODE (cur_obj) == ADDR_EXPR) |
| cur_obj = TREE_OPERAND (cur_obj, 0); |
| if (new_obj == cur_obj) |
| /* We're calling the target constructor of a delegating |
| constructor, or accessing a base subobject through a |
| NOP_EXPR as part of a call to a base constructor, so |
| there is no new (sub)object. */ |
| new_obj = NULL_TREE; |
| } |
| } |
| |
| tree result = NULL_TREE; |
| |
| constexpr_call *entry = NULL; |
| if (depth_ok && !non_constant_args && ctx->strict) |
| { |
| new_call.hash = constexpr_fundef_hasher::hash (new_call.fundef); |
| new_call.hash |
| = iterative_hash_template_arg (new_call.bindings, new_call.hash); |
| new_call.hash |
| = iterative_hash_object (ctx->manifestly_const_eval, new_call.hash); |
| |
| /* If we have seen this call before, we are done. */ |
| maybe_initialize_constexpr_call_table (); |
| constexpr_call **slot |
| = constexpr_call_table->find_slot (&new_call, INSERT); |
| entry = *slot; |
| if (entry == NULL) |
| { |
| /* Only cache up to constexpr_cache_depth to limit memory use. */ |
| if (depth_ok < constexpr_cache_depth) |
| { |
| /* We need to keep a pointer to the entry, not just the slot, as |
| the slot can move during evaluation of the body. */ |
| *slot = entry = ggc_alloc<constexpr_call> (); |
| *entry = new_call; |
| fb.preserve (); |
| } |
| } |
| /* Calls that are in progress have their result set to NULL, so that we |
| can detect circular dependencies. Now that we only cache up to |
| constexpr_cache_depth this won't catch circular dependencies that |
| start deeper, but they'll hit the recursion or ops limit. */ |
| else if (entry->result == NULL) |
| { |
| if (!ctx->quiet) |
| error ("call has circular dependency"); |
| *non_constant_p = true; |
| entry->result = result = error_mark_node; |
| } |
| else |
| result = entry->result; |
| } |
| |
| if (!depth_ok) |
| { |
| if (!ctx->quiet) |
| error ("%<constexpr%> evaluation depth exceeds maximum of %d (use " |
| "%<-fconstexpr-depth=%> to increase the maximum)", |
| max_constexpr_depth); |
| *non_constant_p = true; |
| result = error_mark_node; |
| } |
| else |
| { |
| bool cacheable = true; |
| if (result && result != error_mark_node) |
| /* OK */; |
| else if (!DECL_SAVED_TREE (fun)) |
| { |
| /* When at_eof >= 2, cgraph has started throwing away |
| DECL_SAVED_TREE, so fail quietly. FIXME we get here because of |
| late code generation for VEC_INIT_EXPR, which needs to be |
| completely reconsidered. */ |
| gcc_assert (at_eof >= 2 && ctx->quiet); |
| *non_constant_p = true; |
| } |
| else if (tree copy = get_fundef_copy (new_call.fundef)) |
| { |
| tree body, parms, res; |
| releasing_vec ctors; |
| |
| /* Reuse or create a new unshared copy of this function's body. */ |
| body = TREE_PURPOSE (copy); |
| parms = TREE_VALUE (copy); |
| res = TREE_TYPE (copy); |
| |
| /* Associate the bindings with the remapped parms. */ |
| tree bound = new_call.bindings; |
| tree remapped = parms; |
| for (int i = 0; i < TREE_VEC_LENGTH (bound); ++i) |
| { |
| tree arg = TREE_VEC_ELT (bound, i); |
| if (entry) |
| { |
| /* Unshare args going into the hash table to separate them |
| from the caller's context, for better GC and to avoid |
| problems with verify_gimple. */ |
| arg = unshare_expr_without_location (arg); |
| TREE_VEC_ELT (bound, i) = arg; |
| |
| /* And then unshare again so the callee doesn't change the |
| argument values in the hash table. XXX Could we unshare |
| lazily in cxx_eval_store_expression? */ |
| arg = unshare_constructor (arg); |
| if (TREE_CODE (arg) == CONSTRUCTOR) |
| vec_safe_push (ctors, arg); |
| } |
| ctx->global->values.put (remapped, arg); |
| remapped = DECL_CHAIN (remapped); |
| } |
| /* Add the RESULT_DECL to the values map, too. */ |
| gcc_assert (!DECL_BY_REFERENCE (res)); |
| ctx->global->values.put (res, NULL_TREE); |
| |
| /* Track the callee's evaluated SAVE_EXPRs and TARGET_EXPRs so that |
| we can forget their values after the call. */ |
| constexpr_ctx ctx_with_save_exprs = *ctx; |
| auto_vec<tree, 10> save_exprs; |
| ctx_with_save_exprs.save_exprs = &save_exprs; |
| ctx_with_save_exprs.call = &new_call; |
| unsigned save_heap_alloc_count = ctx->global->heap_vars.length (); |
| unsigned save_heap_dealloc_count = ctx->global->heap_dealloc_count; |
| |
| /* If this is a constexpr destructor, the object's const and volatile |
| semantics are no longer in effect; see [class.dtor]p5. */ |
| if (new_obj && DECL_DESTRUCTOR_P (fun)) |
| cxx_set_object_constness (ctx, new_obj, /*readonly_p=*/false, |
| non_constant_p, overflow_p); |
| |
| tree jump_target = NULL_TREE; |
| cxx_eval_constant_expression (&ctx_with_save_exprs, body, |
| lval, non_constant_p, overflow_p, |
| &jump_target); |
| |
| if (DECL_CONSTRUCTOR_P (fun)) |
| { |
| /* This can be null for a subobject constructor call, in |
| which case what we care about is the initialization |
| side-effects rather than the value. We could get at the |
| value by evaluating *this, but we don't bother; there's |
| no need to put such a call in the hash table. */ |
| result = lval ? ctx->object : ctx->ctor; |
| |
| /* If we've just evaluated a subobject constructor call for an |
| empty union member, it might not have produced a side effect |
| that actually activated the union member. So produce such a |
| side effect now to ensure the union appears initialized. */ |
| if (!result && new_obj |
| && TREE_CODE (new_obj) == COMPONENT_REF |
| && TREE_CODE (TREE_TYPE |
| (TREE_OPERAND (new_obj, 0))) == UNION_TYPE |
| && is_really_empty_class (TREE_TYPE (new_obj), |
| /*ignore_vptr*/false)) |
| { |
| tree activate = build2 (MODIFY_EXPR, TREE_TYPE (new_obj), |
| new_obj, |
| build_constructor (TREE_TYPE (new_obj), |
| NULL)); |
| cxx_eval_constant_expression (ctx, activate, lval, |
| non_constant_p, overflow_p); |
| ggc_free (activate); |
| } |
| } |
| else if (VOID_TYPE_P (TREE_TYPE (res))) |
| result = void_node; |
| else |
| { |
| result = *ctx->global->values.get (res); |
| if (result == NULL_TREE && !*non_constant_p) |
| { |
| if (!ctx->quiet) |
| error ("%<constexpr%> call flows off the end " |
| "of the function"); |
| *non_constant_p = true; |
| } |
| } |
| |
| /* At this point, the object's constructor will have run, so |
| the object is no longer under construction, and its possible |
| 'const' semantics now apply. Make a note of this fact by |
| marking the CONSTRUCTOR TREE_READONLY. */ |
| if (new_obj && DECL_CONSTRUCTOR_P (fun)) |
| cxx_set_object_constness (ctx, new_obj, /*readonly_p=*/true, |
| non_constant_p, overflow_p); |
| |
| /* Forget the saved values of the callee's SAVE_EXPRs and |
| TARGET_EXPRs. */ |
| for (tree save_expr : save_exprs) |
| ctx->global->values.remove (save_expr); |
| |
| /* Remove the parms/result from the values map. Is it worth |
| bothering to do this when the map itself is only live for |
| one constexpr evaluation? If so, maybe also clear out |
| other vars from call, maybe in BIND_EXPR handling? */ |
| ctx->global->values.remove (res); |
| for (tree parm = parms; parm; parm = TREE_CHAIN (parm)) |
| ctx->global->values.remove (parm); |
| |
| /* Free any parameter CONSTRUCTORs we aren't returning directly. */ |
| while (!ctors->is_empty ()) |
| { |
| tree c = ctors->pop (); |
| if (c != result) |
| free_constructor (c); |
| } |
| |
| /* Make the unshared function copy we used available for re-use. */ |
| save_fundef_copy (fun, copy); |
| |
| /* If the call allocated some heap object that hasn't been |
| deallocated during the call, or if it deallocated some heap |
| object it has not allocated, the call isn't really stateless |
| for the constexpr evaluation and should not be cached. |
| It is fine if the call allocates something and deallocates it |
| too. */ |
| if (entry |
| && (save_heap_alloc_count != ctx->global->heap_vars.length () |
| || (save_heap_dealloc_count |
| != ctx->global->heap_dealloc_count))) |
| { |
| tree heap_var; |
| unsigned int i; |
| if ((ctx->global->heap_vars.length () |
| - ctx->global->heap_dealloc_count) |
| != save_heap_alloc_count - save_heap_dealloc_count) |
| cacheable = false; |
| else |
| FOR_EACH_VEC_ELT_FROM (ctx->global->heap_vars, i, heap_var, |
| save_heap_alloc_count) |
| if (DECL_NAME (heap_var) != heap_deleted_identifier) |
| { |
| cacheable = false; |
| break; |
| } |
| } |
| |
| /* Rewrite all occurrences of the function's RESULT_DECL with the |
| current object under construction. */ |
| if (!*non_constant_p && ctx->object |
| && CLASS_TYPE_P (TREE_TYPE (res)) |
| && !is_empty_class (TREE_TYPE (res))) |
| if (replace_result_decl (&result, res, ctx->object)) |
| cacheable = false; |
| } |
| else |
| /* Couldn't get a function copy to evaluate. */ |
| *non_constant_p = true; |
| |
| if (result == error_mark_node) |
| *non_constant_p = true; |
| if (*non_constant_p || *overflow_p) |
| result = error_mark_node; |
| else if (!result) |
| result = void_node; |
| if (entry) |
| entry->result = cacheable ? result : error_mark_node; |
| } |
| |
| /* The result of a constexpr function must be completely initialized. |
| |
| However, in C++20, a constexpr constructor doesn't necessarily have |
| to initialize all the fields, so we don't clear CONSTRUCTOR_NO_CLEARING |
| in order to detect reading an unitialized object in constexpr instead |
| of value-initializing it. (reduced_constant_expression_p is expected to |
| take care of clearing the flag.) */ |
| if (TREE_CODE (result) == CONSTRUCTOR |
| && (cxx_dialect < cxx20 |
| || !DECL_CONSTRUCTOR_P (fun))) |
| clear_no_implicit_zero (result); |
| |
| pop_cx_call_context (); |
| return result; |
| } |
| |
| /* Return true if T is a valid constant initializer. If a CONSTRUCTOR |
| initializes all the members, the CONSTRUCTOR_NO_CLEARING flag will be |
| cleared. |
| FIXME speed this up, it's taking 16% of compile time on sieve testcase. */ |
| |
| bool |
| reduced_constant_expression_p (tree t) |
| { |
| if (t == NULL_TREE) |
| return false; |
| |
| switch (TREE_CODE (t)) |
| { |
| case PTRMEM_CST: |
| /* Even if we can't lower this yet, it's constant. */ |
| return true; |
| |
| case CONSTRUCTOR: |
| /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */ |
| tree idx, val, field; unsigned HOST_WIDE_INT i; |
| if (CONSTRUCTOR_NO_CLEARING (t)) |
| { |
| if (TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE) |
| /* An initialized vector would have a VECTOR_CST. */ |
| return false; |
| else if (cxx_dialect >= cxx20 |
| && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) |
| { |
| /* There must be a valid constant initializer at every array |
| index. */ |
| tree min = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (t))); |
| tree max = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (t))); |
| tree cursor = min; |
| FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), i, idx, val) |
| { |
| if (!reduced_constant_expression_p (val)) |
| return false; |
| if (array_index_cmp (cursor, idx) != 0) |
| return false; |
| if (TREE_CODE (idx) == RANGE_EXPR) |
| cursor = TREE_OPERAND (idx, 1); |
| cursor = int_const_binop (PLUS_EXPR, cursor, size_one_node); |
| } |
| if (find_array_ctor_elt (t, max) == -1) |
| return false; |
| goto ok; |
| } |
| else if (cxx_dialect >= cxx20 |
| && TREE_CODE (TREE_TYPE (t)) == UNION_TYPE) |
| { |
| if (CONSTRUCTOR_NELTS (t) == 0) |
| /* An initialized union has a constructor element. */ |
| return false; |
| /* And it only initializes one member. */ |
| field = NULL_TREE; |
| } |
| else |
| field = next_initializable_field (TYPE_FIELDS (TREE_TYPE (t))); |
| } |
| else |
| field = NULL_TREE; |
| FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), i, idx, val) |
| { |
| /* If VAL is null, we're in the middle of initializing this |
| element. */ |
| if (!reduced_constant_expression_p (val)) |
| return false; |
| /* Empty class field may or may not have an initializer. */ |
| for (; field && idx != field; |
| field = next_initializable_field (DECL_CHAIN (field))) |
| if (!is_really_empty_class (TREE_TYPE (field), |
| /*ignore_vptr*/false)) |
| return false; |
| if (field) |
| field = next_initializable_field (DECL_CHAIN (field)); |
| } |
| /* There could be a non-empty field at the end. */ |
| for (; field; field = next_initializable_field (DECL_CHAIN (field))) |
| if (!is_really_empty_class (TREE_TYPE (field), /*ignore_vptr*/false)) |
| return false; |
| ok: |
| if (CONSTRUCTOR_NO_CLEARING (t)) |
| /* All the fields are initialized. */ |
| CONSTRUCTOR_NO_CLEARING (t) = false; |
| return true; |
| |
| default: |
| /* FIXME are we calling this too much? */ |
| return initializer_constant_valid_p (t, TREE_TYPE (t)) != NULL_TREE; |
| } |
| } |
| |
| /* Some expressions may have constant operands but are not constant |
| themselves, such as 1/0. Call this function to check for that |
| condition. |
| |
| We only call this in places that require an arithmetic constant, not in |
| places where we might have a non-constant expression that can be a |
| component of a constant expression, such as the address of a constexpr |
| variable that might be dereferenced later. */ |
| |
| static bool |
| verify_constant (tree t, bool allow_non_constant, bool *non_constant_p, |
| bool *overflow_p) |
| { |
| if (!*non_constant_p && !reduced_constant_expression_p (t) |
| && t != void_node) |
| { |
| if (!allow_non_constant) |
| error ("%q+E is not a constant expression", t); |
| *non_constant_p = true; |
| } |
| if (TREE_OVERFLOW_P (t)) |
| { |
| if (!allow_non_constant) |
| { |
| permerror (input_location, "overflow in constant expression"); |
| /* If we're being permissive (and are in an enforcing |
| context), ignore the overflow. */ |
| if (flag_permissive) |
| return *non_constant_p; |
| } |
| *overflow_p = true; |
| } |
| return *non_constant_p; |
| } |
| |
| /* Check whether the shift operation with code CODE and type TYPE on LHS |
| and RHS is undefined. If it is, give an error with an explanation, |
| and return true; return false otherwise. */ |
| |
| static bool |
| cxx_eval_check_shift_p (location_t loc, const constexpr_ctx *ctx, |
| enum tree_code code, tree type, tree lhs, tree rhs) |
| { |
| if ((code != LSHIFT_EXPR && code != RSHIFT_EXPR) |
| || TREE_CODE (lhs) != INTEGER_CST |
| || TREE_CODE (rhs) != INTEGER_CST) |
| return false; |
| |
| tree lhstype = TREE_TYPE (lhs); |
| unsigned HOST_WIDE_INT uprec = TYPE_PRECISION (TREE_TYPE (lhs)); |
| |
| /* [expr.shift] The behavior is undefined if the right operand |
| is negative, or greater than or equal to the length in bits |
| of the promoted left operand. */ |
| if (tree_int_cst_sgn (rhs) == -1) |
| { |
| if (!ctx->quiet) |
| permerror (loc, "right operand of shift expression %q+E is negative", |
| build2_loc (loc, code, type, lhs, rhs)); |
| return (!flag_permissive || ctx->quiet); |
| } |
| if (compare_tree_int (rhs, uprec) >= 0) |
| { |
| if (!ctx->quiet) |
| permerror (loc, "right operand of shift expression %q+E is greater " |
| "than or equal to the precision %wu of the left operand", |
| build2_loc (loc, code, type, lhs, rhs), uprec); |
| return (!flag_permissive || ctx->quiet); |
| } |
| |
| /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...] |
| if E1 has a signed type and non-negative value, and E1x2^E2 is |
| representable in the corresponding unsigned type of the result type, |
| then that value, converted to the result type, is the resulting value; |
| otherwise, the behavior is undefined. |
| For C++20: |
| The value of E1 << E2 is the unique value congruent to E1 x 2^E2 modulo |
| 2^N, where N is the range exponent of the type of the result. */ |
| if (code == LSHIFT_EXPR |
| && !TYPE_UNSIGNED (lhstype) |
| && cxx_dialect >= cxx11 |
| && cxx_dialect < cxx20) |
| { |
| if (tree_int_cst_sgn (lhs) == -1) |
| { |
| if (!ctx->quiet) |
| permerror (loc, |
| "left operand of shift expression %q+E is negative", |
| build2_loc (loc, code, type, lhs, rhs)); |
| return (!flag_permissive || ctx->quiet); |
| } |
| /* For signed x << y the following: |
| (unsigned) x >> ((prec (lhs) - 1) - y) |
| if > 1, is undefined. The right-hand side of this formula |
| is the highest bit of the LHS that can be set (starting from 0), |
| so that the shift doesn't overflow. We then right-shift the LHS |
| to see whether any other bit is set making the original shift |
| undefined -- the result is not representable in the corresponding |
| unsigned type. */ |
| tree t = build_int_cst (unsigned_type_node, uprec - 1); |
| t = fold_build2 (MINUS_EXPR, unsigned_type_node, t, rhs); |
| tree ulhs = fold_convert (unsigned_type_for (lhstype), lhs); |
| t = fold_build2 (RSHIFT_EXPR, TREE_TYPE (ulhs), ulhs, t); |
| if (tree_int_cst_lt (integer_one_node, t)) |
| { |
| if (!ctx->quiet) |
| permerror (loc, "shift expression %q+E overflows", |
| build2_loc (loc, code, type, lhs, rhs)); |
| return (!flag_permissive || ctx->quiet); |
| } |
| } |
| return false; |
| } |
| |
| /* Subroutine of cxx_eval_constant_expression. |
| Attempt to reduce the unary expression tree T to a compile time value. |
| If successful, ret
|