1 /* Perform -*- C++ -*- constant expression evaluation, including calls to 2 constexpr functions. These routines are used both during actual parsing 3 and during the instantiation of template functions. 4 5 Copyright (C) 1998-2018 Free Software Foundation, Inc. 6 7 This file is part of GCC. 8 9 GCC is free software; you can redistribute it and/or modify it 10 under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3, or (at your option) 12 any later version. 13 14 GCC is distributed in the hope that it will be useful, but 15 WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with GCC; see the file COPYING3. If not see 21 <http://www.gnu.org/licenses/>. */ 22 23 #include "config.h" 24 #include "system.h" 25 #include "coretypes.h" 26 #include "cp-tree.h" 27 #include "varasm.h" 28 #include "c-family/c-objc.h" 29 #include "tree-iterator.h" 30 #include "gimplify.h" 31 #include "builtins.h" 32 #include "tree-inline.h" 33 #include "ubsan.h" 34 #include "gimple-fold.h" 35 #include "timevar.h" 36 37 static bool verify_constant (tree, bool, bool *, bool *); 38 #define VERIFY_CONSTANT(X) \ 39 do { \ 40 if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \ 41 return t; \ 42 } while (0) 43 44 /* Returns true iff FUN is an instantiation of a constexpr function 45 template or a defaulted constexpr function. */ 46 47 bool 48 is_instantiation_of_constexpr (tree fun) 49 { 50 return ((DECL_TEMPLOID_INSTANTIATION (fun) 51 && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun))) 52 || (DECL_DEFAULTED_FN (fun) 53 && DECL_DECLARED_CONSTEXPR_P (fun))); 54 } 55 56 /* Return true if T is a literal type. */ 57 58 bool 59 literal_type_p (tree t) 60 { 61 if (SCALAR_TYPE_P (t) 62 || VECTOR_TYPE_P (t) 63 || TREE_CODE (t) == REFERENCE_TYPE 64 || (VOID_TYPE_P (t) && cxx_dialect >= cxx14)) 65 return true; 66 if (CLASS_TYPE_P (t)) 67 { 68 t = complete_type (t); 69 gcc_assert (COMPLETE_TYPE_P (t) || errorcount); 70 return CLASSTYPE_LITERAL_P (t); 71 } 72 if (TREE_CODE (t) == ARRAY_TYPE) 73 return literal_type_p (strip_array_types (t)); 74 return false; 75 } 76 77 /* If DECL is a variable declared `constexpr', require its type 78 be literal. Return error_mark_node if we give an error, the 79 DECL otherwise. */ 80 81 tree 82 ensure_literal_type_for_constexpr_object (tree decl) 83 { 84 tree type = TREE_TYPE (decl); 85 if (VAR_P (decl) 86 && (DECL_DECLARED_CONSTEXPR_P (decl) 87 || var_in_constexpr_fn (decl)) 88 && !processing_template_decl) 89 { 90 tree stype = strip_array_types (type); 91 if (CLASS_TYPE_P (stype) && !COMPLETE_TYPE_P (complete_type (stype))) 92 /* Don't complain here, we'll complain about incompleteness 93 when we try to initialize the variable. */; 94 else if (!literal_type_p (type)) 95 { 96 if (DECL_DECLARED_CONSTEXPR_P (decl)) 97 { 98 error ("the type %qT of %<constexpr%> variable %qD " 99 "is not literal", type, decl); 100 explain_non_literal_class (type); 101 decl = error_mark_node; 102 } 103 else 104 { 105 if (!is_instantiation_of_constexpr (current_function_decl)) 106 { 107 error ("variable %qD of non-literal type %qT in %<constexpr%> " 108 "function", decl, type); 109 explain_non_literal_class (type); 110 decl = error_mark_node; 111 } 112 cp_function_chain->invalid_constexpr = true; 113 } 114 } 115 else if (DECL_DECLARED_CONSTEXPR_P (decl) 116 && variably_modified_type_p (type, NULL_TREE)) 117 { 118 error ("%<constexpr%> variable %qD has variably-modified type %qT", 119 decl, type); 120 decl = error_mark_node; 121 } 122 } 123 return decl; 124 } 125 126 /* Representation of entries in the constexpr function definition table. */ 127 128 struct GTY((for_user)) constexpr_fundef { 129 tree decl; 130 tree body; 131 }; 132 133 struct constexpr_fundef_hasher : ggc_ptr_hash<constexpr_fundef> 134 { 135 static hashval_t hash (constexpr_fundef *); 136 static bool equal (constexpr_fundef *, constexpr_fundef *); 137 }; 138 139 /* This table holds all constexpr function definitions seen in 140 the current translation unit. */ 141 142 static GTY (()) hash_table<constexpr_fundef_hasher> *constexpr_fundef_table; 143 144 /* Utility function used for managing the constexpr function table. 145 Return true if the entries pointed to by P and Q are for the 146 same constexpr function. */ 147 148 inline bool 149 constexpr_fundef_hasher::equal (constexpr_fundef *lhs, constexpr_fundef *rhs) 150 { 151 return lhs->decl == rhs->decl; 152 } 153 154 /* Utility function used for managing the constexpr function table. 155 Return a hash value for the entry pointed to by Q. */ 156 157 inline hashval_t 158 constexpr_fundef_hasher::hash (constexpr_fundef *fundef) 159 { 160 return DECL_UID (fundef->decl); 161 } 162 163 /* Return a previously saved definition of function FUN. */ 164 165 static constexpr_fundef * 166 retrieve_constexpr_fundef (tree fun) 167 { 168 constexpr_fundef fundef = { NULL, NULL }; 169 if (constexpr_fundef_table == NULL) 170 return NULL; 171 172 fundef.decl = fun; 173 return constexpr_fundef_table->find (&fundef); 174 } 175 176 /* Check whether the parameter and return types of FUN are valid for a 177 constexpr function, and complain if COMPLAIN. */ 178 179 bool 180 is_valid_constexpr_fn (tree fun, bool complain) 181 { 182 bool ret = true; 183 184 if (DECL_INHERITED_CTOR (fun) 185 && TREE_CODE (fun) == TEMPLATE_DECL) 186 { 187 ret = false; 188 if (complain) 189 error ("inherited constructor %qD is not %<constexpr%>", 190 DECL_INHERITED_CTOR (fun)); 191 } 192 else 193 { 194 for (tree parm = FUNCTION_FIRST_USER_PARM (fun); 195 parm != NULL_TREE; parm = TREE_CHAIN (parm)) 196 if (!literal_type_p (TREE_TYPE (parm))) 197 { 198 ret = false; 199 if (complain) 200 { 201 error ("invalid type for parameter %d of %<constexpr%> " 202 "function %q+#D", DECL_PARM_INDEX (parm), fun); 203 explain_non_literal_class (TREE_TYPE (parm)); 204 } 205 } 206 } 207 208 if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun)) && cxx_dialect < cxx17) 209 { 210 ret = false; 211 if (complain) 212 inform (DECL_SOURCE_LOCATION (fun), 213 "lambdas are implicitly %<constexpr%> only in C++17 and later"); 214 } 215 else if (!DECL_CONSTRUCTOR_P (fun)) 216 { 217 tree rettype = TREE_TYPE (TREE_TYPE (fun)); 218 if (!literal_type_p (rettype)) 219 { 220 ret = false; 221 if (complain) 222 { 223 error ("invalid return type %qT of %<constexpr%> function %q+D", 224 rettype, fun); 225 explain_non_literal_class (rettype); 226 } 227 } 228 229 /* C++14 DR 1684 removed this restriction. */ 230 if (cxx_dialect < cxx14 231 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fun) 232 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun))) 233 { 234 ret = false; 235 if (complain 236 && pedwarn (DECL_SOURCE_LOCATION (fun), OPT_Wpedantic, 237 "enclosing class of %<constexpr%> non-static member " 238 "function %q+#D is not a literal type", fun)) 239 explain_non_literal_class (DECL_CONTEXT (fun)); 240 } 241 } 242 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun))) 243 { 244 ret = false; 245 if (complain) 246 error ("%q#T has virtual base classes", DECL_CONTEXT (fun)); 247 } 248 249 return ret; 250 } 251 252 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF 253 for a member of an anonymous aggregate, INIT is the initializer for that 254 member, and VEC_OUTER is the vector of constructor elements for the class 255 whose constructor we are processing. Add the initializer to the vector 256 and return true to indicate success. */ 257 258 static bool 259 build_anon_member_initialization (tree member, tree init, 260 vec<constructor_elt, va_gc> **vec_outer) 261 { 262 /* MEMBER presents the relevant fields from the inside out, but we need 263 to build up the initializer from the outside in so that we can reuse 264 previously built CONSTRUCTORs if this is, say, the second field in an 265 anonymous struct. So we use a vec as a stack. */ 266 auto_vec<tree, 2> fields; 267 do 268 { 269 fields.safe_push (TREE_OPERAND (member, 1)); 270 member = TREE_OPERAND (member, 0); 271 } 272 while (ANON_AGGR_TYPE_P (TREE_TYPE (member)) 273 && TREE_CODE (member) == COMPONENT_REF); 274 275 /* VEC has the constructor elements vector for the context of FIELD. 276 If FIELD is an anonymous aggregate, we will push inside it. */ 277 vec<constructor_elt, va_gc> **vec = vec_outer; 278 tree field; 279 while (field = fields.pop(), 280 ANON_AGGR_TYPE_P (TREE_TYPE (field))) 281 { 282 tree ctor; 283 /* If there is already an outer constructor entry for the anonymous 284 aggregate FIELD, use it; otherwise, insert one. */ 285 if (vec_safe_is_empty (*vec) 286 || (*vec)->last().index != field) 287 { 288 ctor = build_constructor (TREE_TYPE (field), NULL); 289 CONSTRUCTOR_APPEND_ELT (*vec, field, ctor); 290 } 291 else 292 ctor = (*vec)->last().value; 293 vec = &CONSTRUCTOR_ELTS (ctor); 294 } 295 296 /* Now we're at the innermost field, the one that isn't an anonymous 297 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */ 298 gcc_assert (fields.is_empty()); 299 CONSTRUCTOR_APPEND_ELT (*vec, field, init); 300 301 return true; 302 } 303 304 /* Subroutine of build_constexpr_constructor_member_initializers. 305 The expression tree T represents a data member initialization 306 in a (constexpr) constructor definition. Build a pairing of 307 the data member with its initializer, and prepend that pair 308 to the existing initialization pair INITS. */ 309 310 static bool 311 build_data_member_initialization (tree t, vec<constructor_elt, va_gc> **vec) 312 { 313 tree member, init; 314 if (TREE_CODE (t) == CLEANUP_POINT_EXPR) 315 t = TREE_OPERAND (t, 0); 316 if (TREE_CODE (t) == EXPR_STMT) 317 t = TREE_OPERAND (t, 0); 318 if (t == error_mark_node) 319 return false; 320 if (TREE_CODE (t) == STATEMENT_LIST) 321 { 322 tree_stmt_iterator i; 323 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i)) 324 { 325 if (! build_data_member_initialization (tsi_stmt (i), vec)) 326 return false; 327 } 328 return true; 329 } 330 if (TREE_CODE (t) == CLEANUP_STMT) 331 { 332 /* We can't see a CLEANUP_STMT in a constructor for a literal class, 333 but we can in a constexpr constructor for a non-literal class. Just 334 ignore it; either all the initialization will be constant, in which 335 case the cleanup can't run, or it can't be constexpr. 336 Still recurse into CLEANUP_BODY. */ 337 return build_data_member_initialization (CLEANUP_BODY (t), vec); 338 } 339 if (TREE_CODE (t) == CONVERT_EXPR) 340 t = TREE_OPERAND (t, 0); 341 if (TREE_CODE (t) == INIT_EXPR 342 /* vptr initialization shows up as a MODIFY_EXPR. In C++14 we only 343 use what this function builds for cx_check_missing_mem_inits, and 344 assignment in the ctor body doesn't count. */ 345 || (cxx_dialect < cxx14 && TREE_CODE (t) == MODIFY_EXPR)) 346 { 347 member = TREE_OPERAND (t, 0); 348 init = break_out_target_exprs (TREE_OPERAND (t, 1)); 349 } 350 else if (TREE_CODE (t) == CALL_EXPR) 351 { 352 tree fn = get_callee_fndecl (t); 353 if (!fn || !DECL_CONSTRUCTOR_P (fn)) 354 /* We're only interested in calls to subobject constructors. */ 355 return true; 356 member = CALL_EXPR_ARG (t, 0); 357 /* We don't use build_cplus_new here because it complains about 358 abstract bases. Leaving the call unwrapped means that it has the 359 wrong type, but cxx_eval_constant_expression doesn't care. */ 360 init = break_out_target_exprs (t); 361 } 362 else if (TREE_CODE (t) == BIND_EXPR) 363 return build_data_member_initialization (BIND_EXPR_BODY (t), vec); 364 else 365 /* Don't add anything else to the CONSTRUCTOR. */ 366 return true; 367 if (INDIRECT_REF_P (member)) 368 member = TREE_OPERAND (member, 0); 369 if (TREE_CODE (member) == NOP_EXPR) 370 { 371 tree op = member; 372 STRIP_NOPS (op); 373 if (TREE_CODE (op) == ADDR_EXPR) 374 { 375 gcc_assert (same_type_ignoring_top_level_qualifiers_p 376 (TREE_TYPE (TREE_TYPE (op)), 377 TREE_TYPE (TREE_TYPE (member)))); 378 /* Initializing a cv-qualified member; we need to look through 379 the const_cast. */ 380 member = op; 381 } 382 else if (op == current_class_ptr 383 && (same_type_ignoring_top_level_qualifiers_p 384 (TREE_TYPE (TREE_TYPE (member)), 385 current_class_type))) 386 /* Delegating constructor. */ 387 member = op; 388 else 389 { 390 /* This is an initializer for an empty base; keep it for now so 391 we can check it in cxx_eval_bare_aggregate. */ 392 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member)))); 393 } 394 } 395 if (TREE_CODE (member) == ADDR_EXPR) 396 member = TREE_OPERAND (member, 0); 397 if (TREE_CODE (member) == COMPONENT_REF) 398 { 399 tree aggr = TREE_OPERAND (member, 0); 400 if (TREE_CODE (aggr) == VAR_DECL) 401 /* Initializing a local variable, don't add anything. */ 402 return true; 403 if (TREE_CODE (aggr) != COMPONENT_REF) 404 /* Normal member initialization. */ 405 member = TREE_OPERAND (member, 1); 406 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr))) 407 /* Initializing a member of an anonymous union. */ 408 return build_anon_member_initialization (member, init, vec); 409 else 410 /* We're initializing a vtable pointer in a base. Leave it as 411 COMPONENT_REF so we remember the path to get to the vfield. */ 412 gcc_assert (TREE_TYPE (member) == vtbl_ptr_type_node); 413 } 414 415 /* Value-initialization can produce multiple initializers for the 416 same field; use the last one. */ 417 if (!vec_safe_is_empty (*vec) && (*vec)->last().index == member) 418 (*vec)->last().value = init; 419 else 420 CONSTRUCTOR_APPEND_ELT (*vec, member, init); 421 return true; 422 } 423 424 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval. 425 In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a 426 BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. */ 427 428 static bool 429 check_constexpr_bind_expr_vars (tree t) 430 { 431 gcc_assert (TREE_CODE (t) == BIND_EXPR); 432 433 for (tree var = BIND_EXPR_VARS (t); var; var = DECL_CHAIN (var)) 434 if (TREE_CODE (var) == TYPE_DECL 435 && DECL_IMPLICIT_TYPEDEF_P (var) 436 && !LAMBDA_TYPE_P (TREE_TYPE (var))) 437 return false; 438 return true; 439 } 440 441 /* Subroutine of check_constexpr_ctor_body. */ 442 443 static bool 444 check_constexpr_ctor_body_1 (tree last, tree list) 445 { 446 switch (TREE_CODE (list)) 447 { 448 case DECL_EXPR: 449 if (TREE_CODE (DECL_EXPR_DECL (list)) == USING_DECL 450 || TREE_CODE (DECL_EXPR_DECL (list)) == TYPE_DECL) 451 return true; 452 return false; 453 454 case CLEANUP_POINT_EXPR: 455 return check_constexpr_ctor_body (last, TREE_OPERAND (list, 0), 456 /*complain=*/false); 457 458 case BIND_EXPR: 459 if (!check_constexpr_bind_expr_vars (list) 460 || !check_constexpr_ctor_body (last, BIND_EXPR_BODY (list), 461 /*complain=*/false)) 462 return false; 463 return true; 464 465 case USING_STMT: 466 case STATIC_ASSERT: 467 case DEBUG_BEGIN_STMT: 468 return true; 469 470 default: 471 return false; 472 } 473 } 474 475 /* Make sure that there are no statements after LAST in the constructor 476 body represented by LIST. */ 477 478 bool 479 check_constexpr_ctor_body (tree last, tree list, bool complain) 480 { 481 /* C++14 doesn't require a constexpr ctor to have an empty body. */ 482 if (cxx_dialect >= cxx14) 483 return true; 484 485 bool ok = true; 486 if (TREE_CODE (list) == STATEMENT_LIST) 487 { 488 tree_stmt_iterator i = tsi_last (list); 489 for (; !tsi_end_p (i); tsi_prev (&i)) 490 { 491 tree t = tsi_stmt (i); 492 if (t == last) 493 break; 494 if (!check_constexpr_ctor_body_1 (last, t)) 495 { 496 ok = false; 497 break; 498 } 499 } 500 } 501 else if (list != last 502 && !check_constexpr_ctor_body_1 (last, list)) 503 ok = false; 504 if (!ok) 505 { 506 if (complain) 507 error ("%<constexpr%> constructor does not have empty body"); 508 DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false; 509 } 510 return ok; 511 } 512 513 /* V is a vector of constructor elements built up for the base and member 514 initializers of a constructor for TYPE. They need to be in increasing 515 offset order, which they might not be yet if TYPE has a primary base 516 which is not first in the base-clause or a vptr and at least one base 517 all of which are non-primary. */ 518 519 static vec<constructor_elt, va_gc> * 520 sort_constexpr_mem_initializers (tree type, vec<constructor_elt, va_gc> *v) 521 { 522 tree pri = CLASSTYPE_PRIMARY_BINFO (type); 523 tree field_type; 524 unsigned i; 525 constructor_elt *ce; 526 527 if (pri) 528 field_type = BINFO_TYPE (pri); 529 else if (TYPE_CONTAINS_VPTR_P (type)) 530 field_type = vtbl_ptr_type_node; 531 else 532 return v; 533 534 /* Find the element for the primary base or vptr and move it to the 535 beginning of the vec. */ 536 for (i = 0; vec_safe_iterate (v, i, &ce); ++i) 537 if (TREE_TYPE (ce->index) == field_type) 538 break; 539 540 if (i > 0 && i < vec_safe_length (v)) 541 { 542 vec<constructor_elt, va_gc> &vref = *v; 543 constructor_elt elt = vref[i]; 544 for (; i > 0; --i) 545 vref[i] = vref[i-1]; 546 vref[0] = elt; 547 } 548 549 return v; 550 } 551 552 /* Build compile-time evalable representations of member-initializer list 553 for a constexpr constructor. */ 554 555 static tree 556 build_constexpr_constructor_member_initializers (tree type, tree body) 557 { 558 vec<constructor_elt, va_gc> *vec = NULL; 559 bool ok = true; 560 while (true) 561 switch (TREE_CODE (body)) 562 { 563 case MUST_NOT_THROW_EXPR: 564 case EH_SPEC_BLOCK: 565 body = TREE_OPERAND (body, 0); 566 break; 567 568 case STATEMENT_LIST: 569 for (tree_stmt_iterator i = tsi_start (body); 570 !tsi_end_p (i); tsi_next (&i)) 571 { 572 body = tsi_stmt (i); 573 if (TREE_CODE (body) == BIND_EXPR) 574 break; 575 } 576 break; 577 578 case BIND_EXPR: 579 body = BIND_EXPR_BODY (body); 580 goto found; 581 582 default: 583 gcc_unreachable (); 584 } 585 found: 586 if (TREE_CODE (body) == CLEANUP_POINT_EXPR) 587 { 588 body = TREE_OPERAND (body, 0); 589 if (TREE_CODE (body) == EXPR_STMT) 590 body = TREE_OPERAND (body, 0); 591 if (TREE_CODE (body) == INIT_EXPR 592 && (same_type_ignoring_top_level_qualifiers_p 593 (TREE_TYPE (TREE_OPERAND (body, 0)), 594 current_class_type))) 595 { 596 /* Trivial copy. */ 597 return TREE_OPERAND (body, 1); 598 } 599 ok = build_data_member_initialization (body, &vec); 600 } 601 else if (TREE_CODE (body) == STATEMENT_LIST) 602 { 603 tree_stmt_iterator i; 604 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i)) 605 { 606 ok = build_data_member_initialization (tsi_stmt (i), &vec); 607 if (!ok) 608 break; 609 } 610 } 611 else if (TREE_CODE (body) == TRY_BLOCK) 612 { 613 error ("body of %<constexpr%> constructor cannot be " 614 "a function-try-block"); 615 return error_mark_node; 616 } 617 else if (EXPR_P (body)) 618 ok = build_data_member_initialization (body, &vec); 619 else 620 gcc_assert (errorcount > 0); 621 if (ok) 622 { 623 if (vec_safe_length (vec) > 0) 624 { 625 /* In a delegating constructor, return the target. */ 626 constructor_elt *ce = &(*vec)[0]; 627 if (ce->index == current_class_ptr) 628 { 629 body = ce->value; 630 vec_free (vec); 631 return body; 632 } 633 } 634 vec = sort_constexpr_mem_initializers (type, vec); 635 return build_constructor (type, vec); 636 } 637 else 638 return error_mark_node; 639 } 640 641 /* We have an expression tree T that represents a call, either CALL_EXPR 642 or AGGR_INIT_EXPR. If the call is lexically to a named function, 643 retrun the _DECL for that function. */ 644 645 static tree 646 get_function_named_in_call (tree t) 647 { 648 tree fun = cp_get_callee (t); 649 if (fun && TREE_CODE (fun) == ADDR_EXPR 650 && TREE_CODE (TREE_OPERAND (fun, 0)) == FUNCTION_DECL) 651 fun = TREE_OPERAND (fun, 0); 652 return fun; 653 } 654 655 /* Subroutine of register_constexpr_fundef. BODY is the body of a function 656 declared to be constexpr, or a sub-statement thereof. Returns the 657 return value if suitable, error_mark_node for a statement not allowed in 658 a constexpr function, or NULL_TREE if no return value was found. */ 659 660 tree 661 constexpr_fn_retval (tree body) 662 { 663 switch (TREE_CODE (body)) 664 { 665 case STATEMENT_LIST: 666 { 667 tree_stmt_iterator i; 668 tree expr = NULL_TREE; 669 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i)) 670 { 671 tree s = constexpr_fn_retval (tsi_stmt (i)); 672 if (s == error_mark_node) 673 return error_mark_node; 674 else if (s == NULL_TREE) 675 /* Keep iterating. */; 676 else if (expr) 677 /* Multiple return statements. */ 678 return error_mark_node; 679 else 680 expr = s; 681 } 682 return expr; 683 } 684 685 case RETURN_EXPR: 686 return break_out_target_exprs (TREE_OPERAND (body, 0)); 687 688 case DECL_EXPR: 689 { 690 tree decl = DECL_EXPR_DECL (body); 691 if (TREE_CODE (decl) == USING_DECL 692 /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. */ 693 || DECL_ARTIFICIAL (decl)) 694 return NULL_TREE; 695 return error_mark_node; 696 } 697 698 case CLEANUP_POINT_EXPR: 699 return constexpr_fn_retval (TREE_OPERAND (body, 0)); 700 701 case BIND_EXPR: 702 if (!check_constexpr_bind_expr_vars (body)) 703 return error_mark_node; 704 return constexpr_fn_retval (BIND_EXPR_BODY (body)); 705 706 case USING_STMT: 707 case DEBUG_BEGIN_STMT: 708 return NULL_TREE; 709 710 case CALL_EXPR: 711 { 712 tree fun = get_function_named_in_call (body); 713 if (fun != NULL_TREE 714 && DECL_FUNCTION_CODE (fun) == BUILT_IN_UNREACHABLE) 715 return NULL_TREE; 716 } 717 /* Fallthru. */ 718 719 default: 720 return error_mark_node; 721 } 722 } 723 724 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of 725 FUN; do the necessary transformations to turn it into a single expression 726 that we can store in the hash table. */ 727 728 static tree 729 massage_constexpr_body (tree fun, tree body) 730 { 731 if (DECL_CONSTRUCTOR_P (fun)) 732 body = build_constexpr_constructor_member_initializers 733 (DECL_CONTEXT (fun), body); 734 else if (cxx_dialect < cxx14) 735 { 736 if (TREE_CODE (body) == EH_SPEC_BLOCK) 737 body = EH_SPEC_STMTS (body); 738 if (TREE_CODE (body) == MUST_NOT_THROW_EXPR) 739 body = TREE_OPERAND (body, 0); 740 body = constexpr_fn_retval (body); 741 } 742 return body; 743 } 744 745 /* CTYPE is a type constructed from BODY. Return true if some 746 bases/fields are uninitialized, and complain if COMPLAIN. */ 747 748 static bool 749 cx_check_missing_mem_inits (tree ctype, tree body, bool complain) 750 { 751 unsigned nelts = 0; 752 753 if (body) 754 { 755 if (TREE_CODE (body) != CONSTRUCTOR) 756 return false; 757 nelts = CONSTRUCTOR_NELTS (body); 758 } 759 tree field = TYPE_FIELDS (ctype); 760 761 if (TREE_CODE (ctype) == UNION_TYPE) 762 { 763 if (nelts == 0 && next_initializable_field (field)) 764 { 765 if (complain) 766 error ("%<constexpr%> constructor for union %qT must " 767 "initialize exactly one non-static data member", ctype); 768 return true; 769 } 770 return false; 771 } 772 773 /* Iterate over the CONSTRUCTOR, checking any missing fields don't 774 need an explicit initialization. */ 775 bool bad = false; 776 for (unsigned i = 0; i <= nelts; ++i) 777 { 778 tree index = NULL_TREE; 779 if (i < nelts) 780 { 781 index = CONSTRUCTOR_ELT (body, i)->index; 782 /* Skip base and vtable inits. */ 783 if (TREE_CODE (index) != FIELD_DECL 784 || DECL_ARTIFICIAL (index)) 785 continue; 786 } 787 788 for (; field != index; field = DECL_CHAIN (field)) 789 { 790 tree ftype; 791 if (TREE_CODE (field) != FIELD_DECL) 792 continue; 793 if (DECL_UNNAMED_BIT_FIELD (field)) 794 continue; 795 if (DECL_ARTIFICIAL (field)) 796 continue; 797 if (ANON_AGGR_TYPE_P (TREE_TYPE (field))) 798 { 799 /* Recurse to check the anonummous aggregate member. */ 800 bad |= cx_check_missing_mem_inits 801 (TREE_TYPE (field), NULL_TREE, complain); 802 if (bad && !complain) 803 return true; 804 continue; 805 } 806 ftype = strip_array_types (TREE_TYPE (field)); 807 if (type_has_constexpr_default_constructor (ftype)) 808 { 809 /* It's OK to skip a member with a trivial constexpr ctor. 810 A constexpr ctor that isn't trivial should have been 811 added in by now. */ 812 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype) 813 || errorcount != 0); 814 continue; 815 } 816 if (!complain) 817 return true; 818 error ("member %qD must be initialized by mem-initializer " 819 "in %<constexpr%> constructor", field); 820 inform (DECL_SOURCE_LOCATION (field), "declared here"); 821 bad = true; 822 } 823 if (field == NULL_TREE) 824 break; 825 826 if (ANON_AGGR_TYPE_P (TREE_TYPE (index))) 827 { 828 /* Check the anonymous aggregate initializer is valid. */ 829 bad |= cx_check_missing_mem_inits 830 (TREE_TYPE (index), CONSTRUCTOR_ELT (body, i)->value, complain); 831 if (bad && !complain) 832 return true; 833 } 834 field = DECL_CHAIN (field); 835 } 836 837 return bad; 838 } 839 840 /* We are processing the definition of the constexpr function FUN. 841 Check that its BODY fulfills the propriate requirements and 842 enter it in the constexpr function definition table. 843 For constructor BODY is actually the TREE_LIST of the 844 member-initializer list. */ 845 846 tree 847 register_constexpr_fundef (tree fun, tree body) 848 { 849 constexpr_fundef entry; 850 constexpr_fundef **slot; 851 852 if (!is_valid_constexpr_fn (fun, !DECL_GENERATED_P (fun))) 853 return NULL; 854 855 tree massaged = massage_constexpr_body (fun, body); 856 if (massaged == NULL_TREE || massaged == error_mark_node) 857 { 858 if (!DECL_CONSTRUCTOR_P (fun)) 859 error ("body of %<constexpr%> function %qD not a return-statement", 860 fun); 861 return NULL; 862 } 863 864 if (!potential_rvalue_constant_expression (massaged)) 865 { 866 if (!DECL_GENERATED_P (fun)) 867 require_potential_rvalue_constant_expression (massaged); 868 return NULL; 869 } 870 871 if (DECL_CONSTRUCTOR_P (fun) 872 && cx_check_missing_mem_inits (DECL_CONTEXT (fun), 873 massaged, !DECL_GENERATED_P (fun))) 874 return NULL; 875 876 /* Create the constexpr function table if necessary. */ 877 if (constexpr_fundef_table == NULL) 878 constexpr_fundef_table 879 = hash_table<constexpr_fundef_hasher>::create_ggc (101); 880 881 entry.decl = fun; 882 entry.body = body; 883 slot = constexpr_fundef_table->find_slot (&entry, INSERT); 884 885 gcc_assert (*slot == NULL); 886 *slot = ggc_alloc<constexpr_fundef> (); 887 **slot = entry; 888 889 return fun; 890 } 891 892 /* FUN is a non-constexpr function called in a context that requires a 893 constant expression. If it comes from a constexpr template, explain why 894 the instantiation isn't constexpr. */ 895 896 void 897 explain_invalid_constexpr_fn (tree fun) 898 { 899 static hash_set<tree> *diagnosed; 900 tree body; 901 location_t save_loc; 902 /* Only diagnose defaulted functions, lambdas, or instantiations. */ 903 if (!DECL_DEFAULTED_FN (fun) 904 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun)) 905 && !is_instantiation_of_constexpr (fun)) 906 return; 907 if (diagnosed == NULL) 908 diagnosed = new hash_set<tree>; 909 if (diagnosed->add (fun)) 910 /* Already explained. */ 911 return; 912 913 save_loc = input_location; 914 if (!lambda_static_thunk_p (fun)) 915 { 916 /* Diagnostics should completely ignore the static thunk, so leave 917 input_location set to our caller's location. */ 918 input_location = DECL_SOURCE_LOCATION (fun); 919 inform (input_location, 920 "%qD is not usable as a %<constexpr%> function because:", fun); 921 } 922 /* First check the declaration. */ 923 if (is_valid_constexpr_fn (fun, true)) 924 { 925 /* Then if it's OK, the body. */ 926 if (!DECL_DECLARED_CONSTEXPR_P (fun) 927 && !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun))) 928 explain_implicit_non_constexpr (fun); 929 else 930 { 931 body = massage_constexpr_body (fun, DECL_SAVED_TREE (fun)); 932 require_potential_rvalue_constant_expression (body); 933 if (DECL_CONSTRUCTOR_P (fun)) 934 cx_check_missing_mem_inits (DECL_CONTEXT (fun), body, true); 935 } 936 } 937 input_location = save_loc; 938 } 939 940 /* Objects of this type represent calls to constexpr functions 941 along with the bindings of parameters to their arguments, for 942 the purpose of compile time evaluation. */ 943 944 struct GTY((for_user)) constexpr_call { 945 /* Description of the constexpr function definition. */ 946 constexpr_fundef *fundef; 947 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE 948 is a parameter _DECL and the TREE_VALUE is the value of the parameter. 949 Note: This arrangement is made to accommodate the use of 950 iterative_hash_template_arg (see pt.c). If you change this 951 representation, also change the hash calculation in 952 cxx_eval_call_expression. */ 953 tree bindings; 954 /* Result of the call. 955 NULL means the call is being evaluated. 956 error_mark_node means that the evaluation was erroneous; 957 otherwise, the actuall value of the call. */ 958 tree result; 959 /* The hash of this call; we remember it here to avoid having to 960 recalculate it when expanding the hash table. */ 961 hashval_t hash; 962 }; 963 964 struct constexpr_call_hasher : ggc_ptr_hash<constexpr_call> 965 { 966 static hashval_t hash (constexpr_call *); 967 static bool equal (constexpr_call *, constexpr_call *); 968 }; 969 970 enum constexpr_switch_state { 971 /* Used when processing a switch for the first time by cxx_eval_switch_expr 972 and default: label for that switch has not been seen yet. */ 973 css_default_not_seen, 974 /* Used when processing a switch for the first time by cxx_eval_switch_expr 975 and default: label for that switch has been seen already. */ 976 css_default_seen, 977 /* Used when processing a switch for the second time by 978 cxx_eval_switch_expr, where default: label should match. */ 979 css_default_processing 980 }; 981 982 /* The constexpr expansion context. CALL is the current function 983 expansion, CTOR is the current aggregate initializer, OBJECT is the 984 object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES 985 is a map of values of variables initialized within the expression. */ 986 987 struct constexpr_ctx { 988 /* The innermost call we're evaluating. */ 989 constexpr_call *call; 990 /* Values for any temporaries or local variables within the 991 constant-expression. */ 992 hash_map<tree,tree> *values; 993 /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we 994 aren't inside a loop. */ 995 hash_set<tree> *save_exprs; 996 /* The CONSTRUCTOR we're currently building up for an aggregate 997 initializer. */ 998 tree ctor; 999 /* The object we're building the CONSTRUCTOR for. */ 1000 tree object; 1001 /* If inside SWITCH_EXPR. */ 1002 constexpr_switch_state *css_state; 1003 /* Whether we should error on a non-constant expression or fail quietly. */ 1004 bool quiet; 1005 /* Whether we are strictly conforming to constant expression rules or 1006 trying harder to get a constant value. */ 1007 bool strict; 1008 }; 1009 1010 /* A table of all constexpr calls that have been evaluated by the 1011 compiler in this translation unit. */ 1012 1013 static GTY (()) hash_table<constexpr_call_hasher> *constexpr_call_table; 1014 1015 static tree cxx_eval_constant_expression (const constexpr_ctx *, tree, 1016 bool, bool *, bool *, tree * = NULL); 1017 1018 /* Compute a hash value for a constexpr call representation. */ 1019 1020 inline hashval_t 1021 constexpr_call_hasher::hash (constexpr_call *info) 1022 { 1023 return info->hash; 1024 } 1025 1026 /* Return true if the objects pointed to by P and Q represent calls 1027 to the same constexpr function with the same arguments. 1028 Otherwise, return false. */ 1029 1030 bool 1031 constexpr_call_hasher::equal (constexpr_call *lhs, constexpr_call *rhs) 1032 { 1033 tree lhs_bindings; 1034 tree rhs_bindings; 1035 if (lhs == rhs) 1036 return true; 1037 if (lhs->hash != rhs->hash) 1038 return false; 1039 if (!constexpr_fundef_hasher::equal (lhs->fundef, rhs->fundef)) 1040 return false; 1041 lhs_bindings = lhs->bindings; 1042 rhs_bindings = rhs->bindings; 1043 while (lhs_bindings != NULL && rhs_bindings != NULL) 1044 { 1045 tree lhs_arg = TREE_VALUE (lhs_bindings); 1046 tree rhs_arg = TREE_VALUE (rhs_bindings); 1047 gcc_assert (TREE_TYPE (lhs_arg) == TREE_TYPE (rhs_arg)); 1048 if (!cp_tree_equal (lhs_arg, rhs_arg)) 1049 return false; 1050 lhs_bindings = TREE_CHAIN (lhs_bindings); 1051 rhs_bindings = TREE_CHAIN (rhs_bindings); 1052 } 1053 return lhs_bindings == rhs_bindings; 1054 } 1055 1056 /* Initialize the constexpr call table, if needed. */ 1057 1058 static void 1059 maybe_initialize_constexpr_call_table (void) 1060 { 1061 if (constexpr_call_table == NULL) 1062 constexpr_call_table = hash_table<constexpr_call_hasher>::create_ggc (101); 1063 } 1064 1065 /* During constexpr CALL_EXPR evaluation, to avoid issues with sharing when 1066 a function happens to get called recursively, we unshare the callee 1067 function's body and evaluate this unshared copy instead of evaluating the 1068 original body. 1069 1070 FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function 1071 copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map 1072 that's keyed off of the original FUNCTION_DECL and whose value is a 1073 TREE_LIST of this function's unused copies awaiting reuse. 1074 1075 This is not GC-deletable to avoid GC affecting UID generation. */ 1076 1077 static GTY(()) hash_map<tree, tree> *fundef_copies_table; 1078 1079 /* Initialize FUNDEF_COPIES_TABLE if it's not initialized. */ 1080 1081 static void 1082 maybe_initialize_fundef_copies_table () 1083 { 1084 if (fundef_copies_table == NULL) 1085 fundef_copies_table = hash_map<tree,tree>::create_ggc (101); 1086 } 1087 1088 /* Reuse a copy or create a new unshared copy of the function FUN. 1089 Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE 1090 is parms, TYPE is result. */ 1091 1092 static tree 1093 get_fundef_copy (tree fun) 1094 { 1095 maybe_initialize_fundef_copies_table (); 1096 1097 tree copy; 1098 bool existed; 1099 tree *slot = &fundef_copies_table->get_or_insert (fun, &existed); 1100 1101 if (!existed) 1102 { 1103 /* There is no cached function available, or in use. We can use 1104 the function directly. That the slot is now created records 1105 that this function is now in use. */ 1106 copy = build_tree_list (DECL_SAVED_TREE (fun), DECL_ARGUMENTS (fun)); 1107 TREE_TYPE (copy) = DECL_RESULT (fun); 1108 } 1109 else if (*slot == NULL_TREE) 1110 { 1111 /* We've already used the function itself, so make a copy. */ 1112 copy = build_tree_list (NULL, NULL); 1113 TREE_PURPOSE (copy) = copy_fn (fun, TREE_VALUE (copy), TREE_TYPE (copy)); 1114 } 1115 else 1116 { 1117 /* We have a cached function available. */ 1118 copy = *slot; 1119 *slot = TREE_CHAIN (copy); 1120 } 1121 1122 return copy; 1123 } 1124 1125 /* Save the copy COPY of function FUN for later reuse by 1126 get_fundef_copy(). By construction, there will always be an entry 1127 to find. */ 1128 1129 static void 1130 save_fundef_copy (tree fun, tree copy) 1131 { 1132 tree *slot = fundef_copies_table->get (fun); 1133 TREE_CHAIN (copy) = *slot; 1134 *slot = copy; 1135 } 1136 1137 /* We have an expression tree T that represents a call, either CALL_EXPR 1138 or AGGR_INIT_EXPR. Return the Nth argument. */ 1139 1140 static inline tree 1141 get_nth_callarg (tree t, int n) 1142 { 1143 switch (TREE_CODE (t)) 1144 { 1145 case CALL_EXPR: 1146 return CALL_EXPR_ARG (t, n); 1147 1148 case AGGR_INIT_EXPR: 1149 return AGGR_INIT_EXPR_ARG (t, n); 1150 1151 default: 1152 gcc_unreachable (); 1153 return NULL; 1154 } 1155 } 1156 1157 /* Attempt to evaluate T which represents a call to a builtin function. 1158 We assume here that all builtin functions evaluate to scalar types 1159 represented by _CST nodes. */ 1160 1161 static tree 1162 cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t, tree fun, 1163 bool lval, 1164 bool *non_constant_p, bool *overflow_p) 1165 { 1166 const int nargs = call_expr_nargs (t); 1167 tree *args = (tree *) alloca (nargs * sizeof (tree)); 1168 tree new_call; 1169 int i; 1170 1171 /* Don't fold __builtin_constant_p within a constexpr function. */ 1172 bool bi_const_p = (DECL_FUNCTION_CODE (fun) == BUILT_IN_CONSTANT_P); 1173 1174 /* If we aren't requiring a constant expression, defer __builtin_constant_p 1175 in a constexpr function until we have values for the parameters. */ 1176 if (bi_const_p 1177 && ctx->quiet 1178 && current_function_decl 1179 && DECL_DECLARED_CONSTEXPR_P (current_function_decl)) 1180 { 1181 *non_constant_p = true; 1182 return t; 1183 } 1184 1185 /* Be permissive for arguments to built-ins; __builtin_constant_p should 1186 return constant false for a non-constant argument. */ 1187 constexpr_ctx new_ctx = *ctx; 1188 new_ctx.quiet = true; 1189 bool dummy1 = false, dummy2 = false; 1190 for (i = 0; i < nargs; ++i) 1191 { 1192 args[i] = CALL_EXPR_ARG (t, i); 1193 /* If builtin_valid_in_constant_expr_p is true, 1194 potential_constant_expression_1 has not recursed into the arguments 1195 of the builtin, verify it here. */ 1196 if (!builtin_valid_in_constant_expr_p (fun) 1197 || potential_constant_expression (args[i])) 1198 args[i] = cxx_eval_constant_expression (&new_ctx, args[i], false, 1199 &dummy1, &dummy2); 1200 if (bi_const_p) 1201 /* For __built_in_constant_p, fold all expressions with constant values 1202 even if they aren't C++ constant-expressions. */ 1203 args[i] = cp_fully_fold (args[i]); 1204 } 1205 1206 bool save_ffbcp = force_folding_builtin_constant_p; 1207 force_folding_builtin_constant_p = true; 1208 new_call = fold_builtin_call_array (EXPR_LOCATION (t), TREE_TYPE (t), 1209 CALL_EXPR_FN (t), nargs, args); 1210 force_folding_builtin_constant_p = save_ffbcp; 1211 if (new_call == NULL) 1212 { 1213 if (!*non_constant_p && !ctx->quiet) 1214 { 1215 /* Do not allow__builtin_unreachable in constexpr function. 1216 The __builtin_unreachable call with BUILTINS_LOCATION 1217 comes from cp_maybe_instrument_return. */ 1218 if (DECL_FUNCTION_CODE (fun) == BUILT_IN_UNREACHABLE 1219 && EXPR_LOCATION (t) == BUILTINS_LOCATION) 1220 error ("%<constexpr%> call flows off the end of the function"); 1221 else 1222 { 1223 new_call = build_call_array_loc (EXPR_LOCATION (t), TREE_TYPE (t), 1224 CALL_EXPR_FN (t), nargs, args); 1225 error ("%q+E is not a constant expression", new_call); 1226 } 1227 } 1228 *non_constant_p = true; 1229 return t; 1230 } 1231 1232 if (!is_constant_expression (new_call)) 1233 { 1234 if (!*non_constant_p && !ctx->quiet) 1235 error ("%q+E is not a constant expression", new_call); 1236 *non_constant_p = true; 1237 return t; 1238 } 1239 1240 return cxx_eval_constant_expression (&new_ctx, new_call, lval, 1241 non_constant_p, overflow_p); 1242 } 1243 1244 /* TEMP is the constant value of a temporary object of type TYPE. Adjust 1245 the type of the value to match. */ 1246 1247 static tree 1248 adjust_temp_type (tree type, tree temp) 1249 { 1250 if (TREE_TYPE (temp) == type) 1251 return temp; 1252 /* Avoid wrapping an aggregate value in a NOP_EXPR. */ 1253 if (TREE_CODE (temp) == CONSTRUCTOR) 1254 return build_constructor (type, CONSTRUCTOR_ELTS (temp)); 1255 if (TREE_CODE (temp) == EMPTY_CLASS_EXPR) 1256 return build0 (EMPTY_CLASS_EXPR, type); 1257 gcc_assert (scalarish_type_p (type)); 1258 return cp_fold_convert (type, temp); 1259 } 1260 1261 /* Callback for walk_tree used by unshare_constructor. */ 1262 1263 static tree 1264 find_constructor (tree *tp, int *walk_subtrees, void *) 1265 { 1266 if (TYPE_P (*tp)) 1267 *walk_subtrees = 0; 1268 if (TREE_CODE (*tp) == CONSTRUCTOR) 1269 return *tp; 1270 return NULL_TREE; 1271 } 1272 1273 /* If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a 1274 subexpression, return an unshared copy of T. Otherwise return T. */ 1275 1276 static tree 1277 unshare_constructor (tree t) 1278 { 1279 tree ctor = walk_tree (&t, find_constructor, NULL, NULL); 1280 if (ctor != NULL_TREE) 1281 return unshare_expr (t); 1282 return t; 1283 } 1284 1285 /* Subroutine of cxx_eval_call_expression. 1286 We are processing a call expression (either CALL_EXPR or 1287 AGGR_INIT_EXPR) in the context of CTX. Evaluate 1288 all arguments and bind their values to correspondings 1289 parameters, making up the NEW_CALL context. */ 1290 1291 static void 1292 cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t, 1293 constexpr_call *new_call, 1294 bool *non_constant_p, bool *overflow_p, 1295 bool *non_constant_args) 1296 { 1297 const int nargs = call_expr_nargs (t); 1298 tree fun = new_call->fundef->decl; 1299 tree parms = DECL_ARGUMENTS (fun); 1300 int i; 1301 tree *p = &new_call->bindings; 1302 for (i = 0; i < nargs; ++i) 1303 { 1304 tree x, arg; 1305 tree type = parms ? TREE_TYPE (parms) : void_type_node; 1306 x = get_nth_callarg (t, i); 1307 /* For member function, the first argument is a pointer to the implied 1308 object. For a constructor, it might still be a dummy object, in 1309 which case we get the real argument from ctx. */ 1310 if (i == 0 && DECL_CONSTRUCTOR_P (fun) 1311 && is_dummy_object (x)) 1312 { 1313 x = ctx->object; 1314 x = build_address (x); 1315 } 1316 arg = cxx_eval_constant_expression (ctx, x, /*lval=*/false, 1317 non_constant_p, overflow_p); 1318 /* Don't VERIFY_CONSTANT here. */ 1319 if (*non_constant_p && ctx->quiet) 1320 return; 1321 /* Just discard ellipsis args after checking their constantitude. */ 1322 if (!parms) 1323 continue; 1324 1325 if (!*non_constant_p) 1326 { 1327 /* Don't share a CONSTRUCTOR that might be changed. */ 1328 arg = unshare_constructor (arg); 1329 /* Make sure the binding has the same type as the parm. But 1330 only for constant args. */ 1331 if (TREE_CODE (type) != REFERENCE_TYPE) 1332 arg = adjust_temp_type (type, arg); 1333 if (!TREE_CONSTANT (arg)) 1334 *non_constant_args = true; 1335 *p = build_tree_list (parms, arg); 1336 p = &TREE_CHAIN (*p); 1337 } 1338 parms = TREE_CHAIN (parms); 1339 } 1340 } 1341 1342 /* Variables and functions to manage constexpr call expansion context. 1343 These do not need to be marked for PCH or GC. */ 1344 1345 /* FIXME remember and print actual constant arguments. */ 1346 static vec<tree> call_stack; 1347 static int call_stack_tick; 1348 static int last_cx_error_tick; 1349 1350 static bool 1351 push_cx_call_context (tree call) 1352 { 1353 ++call_stack_tick; 1354 if (!EXPR_HAS_LOCATION (call)) 1355 SET_EXPR_LOCATION (call, input_location); 1356 call_stack.safe_push (call); 1357 if (call_stack.length () > (unsigned) max_constexpr_depth) 1358 return false; 1359 return true; 1360 } 1361 1362 static void 1363 pop_cx_call_context (void) 1364 { 1365 ++call_stack_tick; 1366 call_stack.pop (); 1367 } 1368 1369 vec<tree> 1370 cx_error_context (void) 1371 { 1372 vec<tree> r = vNULL; 1373 if (call_stack_tick != last_cx_error_tick 1374 && !call_stack.is_empty ()) 1375 r = call_stack; 1376 last_cx_error_tick = call_stack_tick; 1377 return r; 1378 } 1379 1380 /* Evaluate a call T to a GCC internal function when possible and return 1381 the evaluated result or, under the control of CTX, give an error, set 1382 NON_CONSTANT_P, and return the unevaluated call T otherwise. */ 1383 1384 static tree 1385 cxx_eval_internal_function (const constexpr_ctx *ctx, tree t, 1386 bool lval, 1387 bool *non_constant_p, bool *overflow_p) 1388 { 1389 enum tree_code opcode = ERROR_MARK; 1390 1391 switch (CALL_EXPR_IFN (t)) 1392 { 1393 case IFN_UBSAN_NULL: 1394 case IFN_UBSAN_BOUNDS: 1395 case IFN_UBSAN_VPTR: 1396 case IFN_FALLTHROUGH: 1397 return void_node; 1398 1399 case IFN_ADD_OVERFLOW: 1400 opcode = PLUS_EXPR; 1401 break; 1402 case IFN_SUB_OVERFLOW: 1403 opcode = MINUS_EXPR; 1404 break; 1405 case IFN_MUL_OVERFLOW: 1406 opcode = MULT_EXPR; 1407 break; 1408 1409 case IFN_LAUNDER: 1410 return cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 0), 1411 false, non_constant_p, overflow_p); 1412 1413 default: 1414 if (!ctx->quiet) 1415 error_at (EXPR_LOC_OR_LOC (t, input_location), 1416 "call to internal function %qE", t); 1417 *non_constant_p = true; 1418 return t; 1419 } 1420 1421 /* Evaluate constant arguments using OPCODE and return a complex 1422 number containing the result and the overflow bit. */ 1423 tree arg0 = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 0), lval, 1424 non_constant_p, overflow_p); 1425 tree arg1 = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, 1), lval, 1426 non_constant_p, overflow_p); 1427 1428 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST) 1429 { 1430 location_t loc = EXPR_LOC_OR_LOC (t, input_location); 1431 tree type = TREE_TYPE (TREE_TYPE (t)); 1432 tree result = fold_binary_loc (loc, opcode, type, 1433 fold_convert_loc (loc, type, arg0), 1434 fold_convert_loc (loc, type, arg1)); 1435 tree ovf 1436 = build_int_cst (type, arith_overflowed_p (opcode, type, arg0, arg1)); 1437 /* Reset TREE_OVERFLOW to avoid warnings for the overflow. */ 1438 if (TREE_OVERFLOW (result)) 1439 TREE_OVERFLOW (result) = 0; 1440 1441 return build_complex (TREE_TYPE (t), result, ovf); 1442 } 1443 1444 *non_constant_p = true; 1445 return t; 1446 } 1447 1448 /* Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. */ 1449 1450 static void 1451 clear_no_implicit_zero (tree ctor) 1452 { 1453 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor)) 1454 { 1455 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = false; 1456 tree elt; unsigned HOST_WIDE_INT idx; 1457 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), idx, elt) 1458 if (TREE_CODE (elt) == CONSTRUCTOR) 1459 clear_no_implicit_zero (elt); 1460 } 1461 } 1462 1463 /* Subroutine of cxx_eval_constant_expression. 1464 Evaluate the call expression tree T in the context of OLD_CALL expression 1465 evaluation. */ 1466 1467 static tree 1468 cxx_eval_call_expression (const constexpr_ctx *ctx, tree t, 1469 bool lval, 1470 bool *non_constant_p, bool *overflow_p) 1471 { 1472 location_t loc = EXPR_LOC_OR_LOC (t, input_location); 1473 tree fun = get_function_named_in_call (t); 1474 constexpr_call new_call = { NULL, NULL, NULL, 0 }; 1475 bool depth_ok; 1476 1477 if (fun == NULL_TREE) 1478 return cxx_eval_internal_function (ctx, t, lval, 1479 non_constant_p, overflow_p); 1480 1481 if (TREE_CODE (fun) != FUNCTION_DECL) 1482 { 1483 /* Might be a constexpr function pointer. */ 1484 fun = cxx_eval_constant_expression (ctx, fun, 1485 /*lval*/false, non_constant_p, 1486 overflow_p); 1487 STRIP_NOPS (fun); 1488 if (TREE_CODE (fun) == ADDR_EXPR) 1489 fun = TREE_OPERAND (fun, 0); 1490 } 1491 if (TREE_CODE (fun) != FUNCTION_DECL) 1492 { 1493 if (!ctx->quiet && !*non_constant_p) 1494 error_at (loc, "expression %qE does not designate a %<constexpr%> " 1495 "function", fun); 1496 *non_constant_p = true; 1497 return t; 1498 } 1499 if (DECL_CLONED_FUNCTION_P (fun)) 1500 fun = DECL_CLONED_FUNCTION (fun); 1501 1502 if (is_ubsan_builtin_p (fun)) 1503 return void_node; 1504 1505 if (is_builtin_fn (fun)) 1506 return cxx_eval_builtin_function_call (ctx, t, fun, 1507 lval, non_constant_p, overflow_p); 1508 if (!DECL_DECLARED_CONSTEXPR_P (fun)) 1509 { 1510 if (!ctx->quiet) 1511 { 1512 if (!lambda_static_thunk_p (fun)) 1513 error_at (loc, "call to non-%<constexpr%> function %qD", fun); 1514 explain_invalid_constexpr_fn (fun); 1515 } 1516 *non_constant_p = true; 1517 return t; 1518 } 1519 1520 constexpr_ctx new_ctx = *ctx; 1521 if (DECL_CONSTRUCTOR_P (fun) && !ctx->object 1522 && TREE_CODE (t) == AGGR_INIT_EXPR) 1523 { 1524 /* We want to have an initialization target for an AGGR_INIT_EXPR. 1525 If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */ 1526 new_ctx.object = AGGR_INIT_EXPR_SLOT (t); 1527 tree ctor = new_ctx.ctor = build_constructor (DECL_CONTEXT (fun), NULL); 1528 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = true; 1529 ctx->values->put (new_ctx.object, ctor); 1530 ctx = &new_ctx; 1531 } 1532 1533 /* Shortcut trivial constructor/op=. */ 1534 if (trivial_fn_p (fun)) 1535 { 1536 tree init = NULL_TREE; 1537 if (call_expr_nargs (t) == 2) 1538 init = convert_from_reference (get_nth_callarg (t, 1)); 1539 else if (TREE_CODE (t) == AGGR_INIT_EXPR 1540 && AGGR_INIT_ZERO_FIRST (t)) 1541 init = build_zero_init (DECL_CONTEXT (fun), NULL_TREE, false); 1542 if (init) 1543 { 1544 tree op = get_nth_callarg (t, 0); 1545 if (is_dummy_object (op)) 1546 op = ctx->object; 1547 else 1548 op = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (op)), op); 1549 tree set = build2 (MODIFY_EXPR, TREE_TYPE (op), op, init); 1550 new_ctx.call = &new_call; 1551 return cxx_eval_constant_expression (&new_ctx, set, lval, 1552 non_constant_p, overflow_p); 1553 } 1554 } 1555 1556 /* We can't defer instantiating the function any longer. */ 1557 if (!DECL_INITIAL (fun) 1558 && DECL_TEMPLOID_INSTANTIATION (fun)) 1559 { 1560 location_t save_loc = input_location; 1561 input_location = loc; 1562 ++function_depth; 1563 instantiate_decl (fun, /*defer_ok*/false, /*expl_inst*/false); 1564 --function_depth; 1565 input_location = save_loc; 1566 } 1567 1568 /* If in direct recursive call, optimize definition search. */ 1569 if (ctx && ctx->call && ctx->call->fundef && ctx->call->fundef->decl == fun) 1570 new_call.fundef = ctx->call->fundef; 1571 else 1572 { 1573 new_call.fundef = retrieve_constexpr_fundef (fun); 1574 if (new_call.fundef == NULL || new_call.fundef->body == NULL 1575 || fun == current_function_decl) 1576 { 1577 if (!ctx->quiet) 1578 { 1579 /* We need to check for current_function_decl here in case we're 1580 being called during cp_fold_function, because at that point 1581 DECL_INITIAL is set properly and we have a fundef but we 1582 haven't lowered invisirefs yet (c++/70344). */ 1583 if (DECL_INITIAL (fun) == error_mark_node 1584 || fun == current_function_decl) 1585 error_at (loc, "%qD called in a constant expression before its " 1586 "definition is complete", fun); 1587 else if (DECL_INITIAL (fun)) 1588 { 1589 /* The definition of fun was somehow unsuitable. But pretend 1590 that lambda static thunks don't exist. */ 1591 if (!lambda_static_thunk_p (fun)) 1592 error_at (loc, "%qD called in a constant expression", fun); 1593 explain_invalid_constexpr_fn (fun); 1594 } 1595 else 1596 error_at (loc, "%qD used before its definition", fun); 1597 } 1598 *non_constant_p = true; 1599 return t; 1600 } 1601 } 1602 1603 bool non_constant_args = false; 1604 cxx_bind_parameters_in_call (ctx, t, &new_call, 1605 non_constant_p, overflow_p, &non_constant_args); 1606 if (*non_constant_p) 1607 return t; 1608 1609 depth_ok = push_cx_call_context (t); 1610 1611 tree result = NULL_TREE; 1612 1613 constexpr_call *entry = NULL; 1614 if (depth_ok && !non_constant_args && ctx->strict) 1615 { 1616 new_call.hash = iterative_hash_template_arg 1617 (new_call.bindings, constexpr_fundef_hasher::hash (new_call.fundef)); 1618 1619 /* If we have seen this call before, we are done. */ 1620 maybe_initialize_constexpr_call_table (); 1621 constexpr_call **slot 1622 = constexpr_call_table->find_slot (&new_call, INSERT); 1623 entry = *slot; 1624 if (entry == NULL) 1625 { 1626 /* We need to keep a pointer to the entry, not just the slot, as the 1627 slot can move in the call to cxx_eval_builtin_function_call. */ 1628 *slot = entry = ggc_alloc<constexpr_call> (); 1629 *entry = new_call; 1630 } 1631 /* Calls that are in progress have their result set to NULL, 1632 so that we can detect circular dependencies. */ 1633 else if (entry->result == NULL) 1634 { 1635 if (!ctx->quiet) 1636 error ("call has circular dependency"); 1637 *non_constant_p = true; 1638 entry->result = result = error_mark_node; 1639 } 1640 else 1641 result = entry->result; 1642 } 1643 1644 if (!depth_ok) 1645 { 1646 if (!ctx->quiet) 1647 error ("%<constexpr%> evaluation depth exceeds maximum of %d (use " 1648 "-fconstexpr-depth= to increase the maximum)", 1649 max_constexpr_depth); 1650 *non_constant_p = true; 1651 result = error_mark_node; 1652 } 1653 else 1654 { 1655 if (result && result != error_mark_node) 1656 /* OK */; 1657 else if (!DECL_SAVED_TREE (fun)) 1658 { 1659 /* When at_eof >= 2, cgraph has started throwing away 1660 DECL_SAVED_TREE, so fail quietly. FIXME we get here because of 1661 late code generation for VEC_INIT_EXPR, which needs to be 1662 completely reconsidered. */ 1663 gcc_assert (at_eof >= 2 && ctx->quiet); 1664 *non_constant_p = true; 1665 } 1666 else 1667 { 1668 tree body, parms, res; 1669 1670 /* Reuse or create a new unshared copy of this function's body. */ 1671 tree copy = get_fundef_copy (fun); 1672 body = TREE_PURPOSE (copy); 1673 parms = TREE_VALUE (copy); 1674 res = TREE_TYPE (copy); 1675 1676 /* Associate the bindings with the remapped parms. */ 1677 tree bound = new_call.bindings; 1678 tree remapped = parms; 1679 while (bound) 1680 { 1681 tree oparm = TREE_PURPOSE (bound); 1682 tree arg = TREE_VALUE (bound); 1683 gcc_assert (DECL_NAME (remapped) == DECL_NAME (oparm)); 1684 /* Don't share a CONSTRUCTOR that might be changed. */ 1685 arg = unshare_constructor (arg); 1686 ctx->values->put (remapped, arg); 1687 bound = TREE_CHAIN (bound); 1688 remapped = DECL_CHAIN (remapped); 1689 } 1690 /* Add the RESULT_DECL to the values map, too. */ 1691 tree slot = NULL_TREE; 1692 if (DECL_BY_REFERENCE (res)) 1693 { 1694 slot = AGGR_INIT_EXPR_SLOT (t); 1695 tree addr = build_address (slot); 1696 addr = build_nop (TREE_TYPE (res), addr); 1697 ctx->values->put (res, addr); 1698 ctx->values->put (slot, NULL_TREE); 1699 } 1700 else 1701 ctx->values->put (res, NULL_TREE); 1702 1703 /* Track the callee's evaluated SAVE_EXPRs so that we can forget 1704 their values after the call. */ 1705 constexpr_ctx ctx_with_save_exprs = *ctx; 1706 hash_set<tree> save_exprs; 1707 ctx_with_save_exprs.save_exprs = &save_exprs; 1708 ctx_with_save_exprs.call = &new_call; 1709 1710 tree jump_target = NULL_TREE; 1711 cxx_eval_constant_expression (&ctx_with_save_exprs, body, 1712 lval, non_constant_p, overflow_p, 1713 &jump_target); 1714 1715 if (DECL_CONSTRUCTOR_P (fun)) 1716 /* This can be null for a subobject constructor call, in 1717 which case what we care about is the initialization 1718 side-effects rather than the value. We could get at the 1719 value by evaluating *this, but we don't bother; there's 1720 no need to put such a call in the hash table. */ 1721 result = lval ? ctx->object : ctx->ctor; 1722 else if (VOID_TYPE_P (TREE_TYPE (res))) 1723 result = void_node; 1724 else 1725 { 1726 result = *ctx->values->get (slot ? slot : res); 1727 if (result == NULL_TREE && !*non_constant_p) 1728 { 1729 if (!ctx->quiet) 1730 error ("%<constexpr%> call flows off the end " 1731 "of the function"); 1732 *non_constant_p = true; 1733 } 1734 } 1735 1736 /* Forget the saved values of the callee's SAVE_EXPRs. */ 1737 for (hash_set<tree>::iterator iter = save_exprs.begin(); 1738 iter != save_exprs.end(); ++iter) 1739 ctx_with_save_exprs.values->remove (*iter); 1740 1741 /* Remove the parms/result from the values map. Is it worth 1742 bothering to do this when the map itself is only live for 1743 one constexpr evaluation? If so, maybe also clear out 1744 other vars from call, maybe in BIND_EXPR handling? */ 1745 ctx->values->remove (res); 1746 if (slot) 1747 ctx->values->remove (slot); 1748 for (tree parm = parms; parm; parm = TREE_CHAIN (parm)) 1749 ctx->values->remove (parm); 1750 1751 /* Make the unshared function copy we used available for re-use. */ 1752 save_fundef_copy (fun, copy); 1753 } 1754 1755 if (result == error_mark_node) 1756 *non_constant_p = true; 1757 if (*non_constant_p || *overflow_p) 1758 result = error_mark_node; 1759 else if (!result) 1760 result = void_node; 1761 if (entry) 1762 entry->result = result; 1763 } 1764 1765 /* The result of a constexpr function must be completely initialized. */ 1766 if (TREE_CODE (result) == CONSTRUCTOR) 1767 clear_no_implicit_zero (result); 1768 1769 pop_cx_call_context (); 1770 return unshare_constructor (result); 1771 } 1772 1773 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */ 1774 1775 bool 1776 reduced_constant_expression_p (tree t) 1777 { 1778 if (t == NULL_TREE) 1779 return false; 1780 1781 switch (TREE_CODE (t)) 1782 { 1783 case PTRMEM_CST: 1784 /* Even if we can't lower this yet, it's constant. */ 1785 return true; 1786 1787 case CONSTRUCTOR: 1788 /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */ 1789 tree idx, val, field; unsigned HOST_WIDE_INT i; 1790 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t)) 1791 { 1792 if (TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE) 1793 /* An initialized vector would have a VECTOR_CST. */ 1794 return false; 1795 else 1796 field = next_initializable_field (TYPE_FIELDS (TREE_TYPE (t))); 1797 } 1798 else 1799 field = NULL_TREE; 1800 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), i, idx, val) 1801 { 1802 /* If VAL is null, we're in the middle of initializing this 1803 element. */ 1804 if (!reduced_constant_expression_p (val)) 1805 return false; 1806 if (field) 1807 { 1808 if (idx != field) 1809 return false; 1810 field = next_initializable_field (DECL_CHAIN (field)); 1811 } 1812 } 1813 if (field) 1814 return false; 1815 else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t)) 1816 /* All the fields are initialized. */ 1817 CONSTRUCTOR_NO_IMPLICIT_ZERO (t) = false; 1818 return true; 1819 1820 default: 1821 /* FIXME are we calling this too much? */ 1822 return initializer_constant_valid_p (t, TREE_TYPE (t)) != NULL_TREE; 1823 } 1824 } 1825 1826 /* Some expressions may have constant operands but are not constant 1827 themselves, such as 1/0. Call this function to check for that 1828 condition. 1829 1830 We only call this in places that require an arithmetic constant, not in 1831 places where we might have a non-constant expression that can be a 1832 component of a constant expression, such as the address of a constexpr 1833 variable that might be dereferenced later. */ 1834 1835 static bool 1836 verify_constant (tree t, bool allow_non_constant, bool *non_constant_p, 1837 bool *overflow_p) 1838 { 1839 if (!*non_constant_p && !reduced_constant_expression_p (t)) 1840 { 1841 if (!allow_non_constant) 1842 error ("%q+E is not a constant expression", t); 1843 *non_constant_p = true; 1844 } 1845 if (TREE_OVERFLOW_P (t)) 1846 { 1847 if (!allow_non_constant) 1848 { 1849 permerror (input_location, "overflow in constant expression"); 1850 /* If we're being permissive (and are in an enforcing 1851 context), ignore the overflow. */ 1852 if (flag_permissive) 1853 return *non_constant_p; 1854 } 1855 *overflow_p = true; 1856 } 1857 return *non_constant_p; 1858 } 1859 1860 /* Check whether the shift operation with code CODE and type TYPE on LHS 1861 and RHS is undefined. If it is, give an error with an explanation, 1862 and return true; return false otherwise. */ 1863 1864 static bool 1865 cxx_eval_check_shift_p (location_t loc, const constexpr_ctx *ctx, 1866 enum tree_code code, tree type, tree lhs, tree rhs) 1867 { 1868 if ((code != LSHIFT_EXPR && code != RSHIFT_EXPR) 1869 || TREE_CODE (lhs) != INTEGER_CST 1870 || TREE_CODE (rhs) != INTEGER_CST) 1871 return false; 1872 1873 tree lhstype = TREE_TYPE (lhs); 1874 unsigned HOST_WIDE_INT uprec = TYPE_PRECISION (TREE_TYPE (lhs)); 1875 1876 /* [expr.shift] The behavior is undefined if the right operand 1877 is negative, or greater than or equal to the length in bits 1878 of the promoted left operand. */ 1879 if (tree_int_cst_sgn (rhs) == -1) 1880 { 1881 if (!ctx->quiet) 1882 permerror (loc, "right operand of shift expression %q+E is negative", 1883 build2_loc (loc, code, type, lhs, rhs)); 1884 return (!flag_permissive || ctx->quiet); 1885 } 1886 if (compare_tree_int (rhs, uprec) >= 0) 1887 { 1888 if (!ctx->quiet) 1889 permerror (loc, "right operand of shift expression %q+E is >= than " 1890 "the precision of the left operand", 1891 build2_loc (loc, code, type, lhs, rhs)); 1892 return (!flag_permissive || ctx->quiet); 1893 } 1894 1895 /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...] 1896 if E1 has a signed type and non-negative value, and E1x2^E2 is 1897 representable in the corresponding unsigned type of the result type, 1898 then that value, converted to the result type, is the resulting value; 1899 otherwise, the behavior is undefined. */ 1900 if (code == LSHIFT_EXPR && !TYPE_UNSIGNED (lhstype) 1901 && (cxx_dialect >= cxx11)) 1902 { 1903 if (tree_int_cst_sgn (lhs) == -1) 1904 { 1905 if (!ctx->quiet) 1906 permerror (loc, 1907 "left operand of shift expression %q+E is negative", 1908 build2_loc (loc, code, type, lhs, rhs)); 1909 return (!flag_permissive || ctx->quiet); 1910 } 1911 /* For signed x << y the following: 1912 (unsigned) x >> ((prec (lhs) - 1) - y) 1913 if > 1, is undefined. The right-hand side of this formula 1914 is the highest bit of the LHS that can be set (starting from 0), 1915 so that the shift doesn't overflow. We then right-shift the LHS 1916 to see whether any other bit is set making the original shift 1917 undefined -- the result is not representable in the corresponding 1918 unsigned type. */ 1919 tree t = build_int_cst (unsigned_type_node, uprec - 1); 1920 t = fold_build2 (MINUS_EXPR, unsigned_type_node, t, rhs); 1921 tree ulhs = fold_convert (unsigned_type_for (lhstype), lhs); 1922 t = fold_build2 (RSHIFT_EXPR, TREE_TYPE (ulhs), ulhs, t); 1923 if (tree_int_cst_lt (integer_one_node, t)) 1924 { 1925 if (!ctx->quiet) 1926 permerror (loc, "shift expression %q+E overflows", 1927 build2_loc (loc, code, type, lhs, rhs)); 1928 return (!flag_permissive || ctx->quiet); 1929 } 1930 } 1931 return false; 1932 } 1933 1934 /* Subroutine of cxx_eval_constant_expression. 1935 Attempt to reduce the unary expression tree T to a compile time value. 1936 If successful, return the value. Otherwise issue a diagnostic 1937 and return error_mark_node. */ 1938 1939 static tree 1940 cxx_eval_unary_expression (const constexpr_ctx *ctx, tree t, 1941 bool /*lval*/, 1942 bool *non_constant_p, bool *overflow_p) 1943 { 1944 tree r; 1945 tree orig_arg = TREE_OPERAND (t, 0); 1946 tree arg = cxx_eval_constant_expression (ctx, orig_arg, /*lval*/false, 1947 non_constant_p, overflow_p); 1948 VERIFY_CONSTANT (arg); 1949 location_t loc = EXPR_LOCATION (t); 1950 enum tree_code code = TREE_CODE (t); 1951 tree type = TREE_TYPE (t); 1952 r = fold_unary_loc (loc, code, type, arg); 1953 if (r == NULL_TREE) 1954 { 1955 if (arg == orig_arg) 1956 r = t; 1957 else 1958 r = build1_loc (loc, code, type, arg); 1959 } 1960 VERIFY_CONSTANT (r); 1961 return r; 1962 } 1963 1964 /* Helper function for cxx_eval_binary_expression. Try to optimize 1965 original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the 1966 generic folding should be used. */ 1967 1968 static tree 1969 cxx_fold_pointer_plus_expression (const constexpr_ctx *ctx, tree t, 1970 tree lhs, tree rhs, bool *non_constant_p, 1971 bool *overflow_p) 1972 { 1973 STRIP_NOPS (lhs); 1974 if (TREE_CODE (lhs) != ADDR_EXPR) 1975 return NULL_TREE; 1976 1977 lhs = TREE_OPERAND (lhs, 0); 1978 1979 /* &A[i] p+ j => &A[i + j] */ 1980 if (TREE_CODE (lhs) == ARRAY_REF 1981 && TREE_CODE (TREE_OPERAND (lhs, 1)) == INTEGER_CST 1982 && TREE_CODE (rhs) == INTEGER_CST 1983 && TYPE_SIZE_UNIT (TREE_TYPE (lhs)) 1984 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs))) == INTEGER_CST) 1985 { 1986 tree orig_type = TREE_TYPE (t); 1987 location_t loc = EXPR_LOCATION (t); 1988 tree type = TREE_TYPE (lhs); 1989 1990 t = fold_convert_loc (loc, ssizetype, TREE_OPERAND (lhs, 1)); 1991 tree nelts = array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs, 0))); 1992 nelts = cxx_eval_constant_expression (ctx, nelts, false, non_constant_p, 1993 overflow_p); 1994 if (*non_constant_p) 1995 return NULL_TREE; 1996 /* Don't fold an out-of-bound access. */ 1997 if (!tree_int_cst_le (t, nelts)) 1998 return NULL_TREE; 1999 rhs = cp_fold_convert (ssizetype, rhs); 2000 /* Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT. 2001 constexpr int A[1]; ... (char *)&A[0] + 1 */ 2002 if (!integer_zerop (fold_build2_loc (loc, TRUNC_MOD_EXPR, sizetype, 2003 rhs, TYPE_SIZE_UNIT (type)))) 2004 return NULL_TREE; 2005 /* Make sure to treat the second operand of POINTER_PLUS_EXPR 2006 as signed. */ 2007 rhs = fold_build2_loc (loc, EXACT_DIV_EXPR, ssizetype, rhs, 2008 TYPE_SIZE_UNIT (type)); 2009 t = size_binop_loc (loc, PLUS_EXPR, rhs, t); 2010 t = build4_loc (loc, ARRAY_REF, type, TREE_OPERAND (lhs, 0), 2011 t, NULL_TREE, NULL_TREE); 2012 t = cp_build_addr_expr (t, tf_warning_or_error); 2013 t = cp_fold_convert (orig_type, t); 2014 return cxx_eval_constant_expression (ctx, t, /*lval*/false, 2015 non_constant_p, overflow_p); 2016 } 2017 2018 return NULL_TREE; 2019 } 2020 2021 /* Subroutine of cxx_eval_constant_expression. 2022 Like cxx_eval_unary_expression, except for binary expressions. */ 2023 2024 static tree 2025 cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t, 2026 bool /*lval*/, 2027 bool *non_constant_p, bool *overflow_p) 2028 { 2029 tree r = NULL_TREE; 2030 tree orig_lhs = TREE_OPERAND (t, 0); 2031 tree orig_rhs = TREE_OPERAND (t, 1); 2032 tree lhs, rhs; 2033 lhs = cxx_eval_constant_expression (ctx, orig_lhs, /*lval*/false, 2034 non_constant_p, overflow_p); 2035 /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer 2036 subtraction. */ 2037 if (*non_constant_p) 2038 return t; 2039 rhs = cxx_eval_constant_expression (ctx, orig_rhs, /*lval*/false, 2040 non_constant_p, overflow_p); 2041 if (*non_constant_p) 2042 return t; 2043 2044 location_t loc = EXPR_LOCATION (t); 2045 enum tree_code code = TREE_CODE (t); 2046 tree type = TREE_TYPE (t); 2047 2048 if (code == EQ_EXPR || code == NE_EXPR) 2049 { 2050 bool is_code_eq = (code == EQ_EXPR); 2051 2052 if (TREE_CODE (lhs) == PTRMEM_CST 2053 && TREE_CODE (rhs) == PTRMEM_CST) 2054 r = constant_boolean_node (cp_tree_equal (lhs, rhs) == is_code_eq, 2055 type); 2056 else if ((TREE_CODE (lhs) == PTRMEM_CST 2057 || TREE_CODE (rhs) == PTRMEM_CST) 2058 && (null_member_pointer_value_p (lhs) 2059 || null_member_pointer_value_p (rhs))) 2060 r = constant_boolean_node (!is_code_eq, type); 2061 else if (TREE_CODE (lhs) == PTRMEM_CST) 2062 lhs = cplus_expand_constant (lhs); 2063 else if (TREE_CODE (rhs) == PTRMEM_CST) 2064 rhs = cplus_expand_constant (rhs); 2065 } 2066 if (code == POINTER_PLUS_EXPR && !*non_constant_p 2067 && integer_zerop (lhs) && !integer_zerop (rhs)) 2068 { 2069 if (!ctx->quiet) 2070 error ("arithmetic involving a null pointer in %qE", lhs); 2071 *non_constant_p = true; 2072 return t; 2073 } 2074 else if (code == POINTER_PLUS_EXPR) 2075 r = cxx_fold_pointer_plus_expression (ctx, t, lhs, rhs, non_constant_p, 2076 overflow_p); 2077 2078 if (r == NULL_TREE) 2079 r = fold_binary_loc (loc, code, type, lhs, rhs); 2080 2081 if (r == NULL_TREE) 2082 { 2083 if (lhs == orig_lhs && rhs == orig_rhs) 2084 r = t; 2085 else 2086 r = build2_loc (loc, code, type, lhs, rhs); 2087 } 2088 else if (cxx_eval_check_shift_p (loc, ctx, code, type, lhs, rhs)) 2089 *non_constant_p = true; 2090 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to 2091 a local array in a constexpr function. */ 2092 bool ptr = POINTER_TYPE_P (TREE_TYPE (lhs)); 2093 if (!ptr) 2094 VERIFY_CONSTANT (r); 2095 return r; 2096 } 2097 2098 /* Subroutine of cxx_eval_constant_expression. 2099 Attempt to evaluate condition expressions. Dead branches are not 2100 looked into. */ 2101 2102 static tree 2103 cxx_eval_conditional_expression (const constexpr_ctx *ctx, tree t, 2104 bool lval, 2105 bool *non_constant_p, bool *overflow_p, 2106 tree *jump_target) 2107 { 2108 tree val = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), 2109 /*lval*/false, 2110 non_constant_p, overflow_p); 2111 VERIFY_CONSTANT (val); 2112 /* Don't VERIFY_CONSTANT the other operands. */ 2113 if (integer_zerop (val)) 2114 return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2), 2115 lval, 2116 non_constant_p, overflow_p, 2117 jump_target); 2118 return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1), 2119 lval, 2120 non_constant_p, overflow_p, 2121 jump_target); 2122 } 2123 2124 /* Subroutine of cxx_eval_constant_expression. 2125 Attempt to evaluate vector condition expressions. Unlike 2126 cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal 2127 ternary arithmetics operation, where all 3 arguments have to be 2128 evaluated as constants and then folding computes the result from 2129 them. */ 2130 2131 static tree 2132 cxx_eval_vector_conditional_expression (const constexpr_ctx *ctx, tree t, 2133 bool *non_constant_p, bool *overflow_p) 2134 { 2135 tree arg1 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), 2136 /*lval*/false, 2137 non_constant_p, overflow_p); 2138 VERIFY_CONSTANT (arg1); 2139 tree arg2 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1), 2140 /*lval*/false, 2141 non_constant_p, overflow_p); 2142 VERIFY_CONSTANT (arg2); 2143 tree arg3 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2), 2144 /*lval*/false, 2145 non_constant_p, overflow_p); 2146 VERIFY_CONSTANT (arg3); 2147 location_t loc = EXPR_LOCATION (t); 2148 tree type = TREE_TYPE (t); 2149 tree r = fold_ternary_loc (loc, VEC_COND_EXPR, type, arg1, arg2, arg3); 2150 if (r == NULL_TREE) 2151 { 2152 if (arg1 == TREE_OPERAND (t, 0) 2153 && arg2 == TREE_OPERAND (t, 1) 2154 && arg3 == TREE_OPERAND (t, 2)) 2155 r = t; 2156 else 2157 r = build3_loc (loc, VEC_COND_EXPR, type, arg1, arg2, arg3); 2158 } 2159 VERIFY_CONSTANT (r); 2160 return r; 2161 } 2162 2163 /* Returns less than, equal to, or greater than zero if KEY is found to be 2164 less than, to match, or to be greater than the constructor_elt's INDEX. */ 2165 2166 static int 2167 array_index_cmp (tree key, tree index) 2168 { 2169 gcc_assert (TREE_CODE (key) == INTEGER_CST); 2170 2171 switch (TREE_CODE (index)) 2172 { 2173 case INTEGER_CST: 2174 return tree_int_cst_compare (key, index); 2175 case RANGE_EXPR: 2176 { 2177 tree lo = TREE_OPERAND (index, 0); 2178 tree hi = TREE_OPERAND (index, 1); 2179 if (tree_int_cst_lt (key, lo)) 2180 return -1; 2181 else if (tree_int_cst_lt (hi, key)) 2182 return 1; 2183 else 2184 return 0; 2185 } 2186 default: 2187 gcc_unreachable (); 2188 } 2189 } 2190 2191 /* Returns the index of the constructor_elt of ARY which matches DINDEX, or -1 2192 if none. If INSERT is true, insert a matching element rather than fail. */ 2193 2194 static HOST_WIDE_INT 2195 find_array_ctor_elt (tree ary, tree dindex, bool insert = false) 2196 { 2197 if (tree_int_cst_sgn (dindex) < 0) 2198 return -1; 2199 2200 unsigned HOST_WIDE_INT i = tree_to_uhwi (dindex); 2201 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (ary); 2202 unsigned HOST_WIDE_INT len = vec_safe_length (elts); 2203 2204 unsigned HOST_WIDE_INT end = len; 2205 unsigned HOST_WIDE_INT begin = 0; 2206 2207 /* If the last element of the CONSTRUCTOR has its own index, we can assume 2208 that the same is true of the other elements and index directly. */ 2209 if (end > 0) 2210 { 2211 tree cindex = (*elts)[end - 1].index; 2212 if (TREE_CODE (cindex) == INTEGER_CST 2213 && compare_tree_int (cindex, end - 1) == 0) 2214 { 2215 if (i < end) 2216 return i; 2217 else 2218 begin = end; 2219 } 2220 } 2221 2222 /* Otherwise, find a matching index by means of a binary search. */ 2223 while (begin != end) 2224 { 2225 unsigned HOST_WIDE_INT middle = (begin + end) / 2; 2226 constructor_elt &elt = (*elts)[middle]; 2227 tree idx = elt.index; 2228 2229 int cmp = array_index_cmp (dindex, idx); 2230 if (cmp < 0) 2231 end = middle; 2232 else if (cmp > 0) 2233 begin = middle + 1; 2234 else 2235 { 2236 if (insert && TREE_CODE (idx) == RANGE_EXPR) 2237 { 2238 /* We need to split the range. */ 2239 constructor_elt e; 2240 tree lo = TREE_OPERAND (idx, 0); 2241 tree hi = TREE_OPERAND (idx, 1); 2242 tree value = elt.value; 2243 dindex = fold_convert (sizetype, dindex); 2244 if (tree_int_cst_lt (lo, dindex)) 2245 { 2246 /* There are still some lower elts; shorten the range. */ 2247 tree new_hi = int_const_binop (MINUS_EXPR, dindex, 2248 size_one_node); 2249 if (tree_int_cst_equal (lo, new_hi)) 2250 /* Only one element left, no longer a range. */ 2251 elt.index = lo; 2252 else 2253 TREE_OPERAND (idx, 1) = new_hi; 2254 /* Append the element we want to insert. */ 2255 ++middle; 2256 e.index = dindex; 2257 e.value = unshare_constructor (value); 2258 vec_safe_insert (CONSTRUCTOR_ELTS (ary), middle, e); 2259 } 2260 else 2261 /* No lower elts, the range elt is now ours. */ 2262 elt.index = dindex; 2263 2264 if (tree_int_cst_lt (dindex, hi)) 2265 { 2266 /* There are still some higher elts; append a range. */ 2267 tree new_lo = int_const_binop (PLUS_EXPR, dindex, 2268 size_one_node); 2269 if (tree_int_cst_equal (new_lo, hi)) 2270 e.index = hi; 2271 else 2272 e.index = build2 (RANGE_EXPR, sizetype, new_lo, hi); 2273 e.value = unshare_constructor (value); 2274 vec_safe_insert (CONSTRUCTOR_ELTS (ary), middle + 1, e); 2275 } 2276 } 2277 return middle; 2278 } 2279 } 2280 2281 if (insert) 2282 { 2283 constructor_elt e = { dindex, NULL_TREE }; 2284 vec_safe_insert (CONSTRUCTOR_ELTS (ary), end, e); 2285 return end; 2286 } 2287 2288 return -1; 2289 } 2290 2291 /* Under the control of CTX, issue a detailed diagnostic for 2292 an out-of-bounds subscript INDEX into the expression ARRAY. */ 2293 2294 static void 2295 diag_array_subscript (const constexpr_ctx *ctx, tree array, tree index) 2296 { 2297 if (!ctx->quiet) 2298 { 2299 tree arraytype = TREE_TYPE (array); 2300 2301 /* Convert the unsigned array subscript to a signed integer to avoid 2302 printing huge numbers for small negative values. */ 2303 tree sidx = fold_convert (ssizetype, index); 2304 if (DECL_P (array)) 2305 { 2306 if (TYPE_DOMAIN (arraytype)) 2307 error ("array subscript value %qE is outside the bounds " 2308 "of array %qD of type %qT", sidx, array, arraytype); 2309 else 2310 error ("non-zero array subscript %qE is used with array %qD of " 2311 "type %qT with unknown bounds", sidx, array, arraytype); 2312 inform (DECL_SOURCE_LOCATION (array), "declared here"); 2313 } 2314 else if (TYPE_DOMAIN (arraytype)) 2315 error ("array subscript value %qE is outside the bounds " 2316 "of array type %qT", sidx, arraytype); 2317 else 2318 error ("non-zero array subscript %qE is used with array of type %qT " 2319 "with unknown bounds", sidx, arraytype); 2320 } 2321 } 2322 2323 /* Return the number of elements for TYPE (which is an ARRAY_TYPE or 2324 a VECTOR_TYPE). */ 2325 2326 static tree 2327 get_array_or_vector_nelts (const constexpr_ctx *ctx, tree type, 2328 bool *non_constant_p, bool *overflow_p) 2329 { 2330 tree nelts; 2331 if (TREE_CODE (type) == ARRAY_TYPE) 2332 { 2333 if (TYPE_DOMAIN (type)) 2334 nelts = array_type_nelts_top (type); 2335 else 2336 nelts = size_zero_node; 2337 } 2338 else if (VECTOR_TYPE_P (type)) 2339 nelts = size_int (TYPE_VECTOR_SUBPARTS (type)); 2340 else 2341 gcc_unreachable (); 2342 2343 /* For VLAs, the number of elements won't be an integer constant. */ 2344 nelts = cxx_eval_constant_expression (ctx, nelts, false, 2345 non_constant_p, overflow_p); 2346 return nelts; 2347 } 2348 2349 /* Extract element INDEX consisting of CHARS_PER_ELT chars from 2350 STRING_CST STRING. */ 2351 2352 static tree 2353 extract_string_elt (tree string, unsigned chars_per_elt, unsigned index) 2354 { 2355 tree type = cv_unqualified (TREE_TYPE (TREE_TYPE (string))); 2356 tree r; 2357 2358 if (chars_per_elt == 1) 2359 r = build_int_cst (type, TREE_STRING_POINTER (string)[index]); 2360 else 2361 { 2362 const unsigned char *ptr 2363 = ((const unsigned char *)TREE_STRING_POINTER (string) 2364 + index * chars_per_elt); 2365 r = native_interpret_expr (type, ptr, chars_per_elt); 2366 } 2367 return r; 2368 } 2369 2370 /* Subroutine of cxx_eval_constant_expression. 2371 Attempt to reduce a reference to an array slot. */ 2372 2373 static tree 2374 cxx_eval_array_reference (const constexpr_ctx *ctx, tree t, 2375 bool lval, 2376 bool *non_constant_p, bool *overflow_p) 2377 { 2378 tree oldary = TREE_OPERAND (t, 0); 2379 tree ary = cxx_eval_constant_expression (ctx, oldary, 2380 lval, 2381 non_constant_p, overflow_p); 2382 tree index, oldidx; 2383 HOST_WIDE_INT i = 0; 2384 tree elem_type = NULL_TREE; 2385 unsigned len = 0, elem_nchars = 1; 2386 if (*non_constant_p) 2387 return t; 2388 oldidx = TREE_OPERAND (t, 1); 2389 index = cxx_eval_constant_expression (ctx, oldidx, 2390 false, 2391 non_constant_p, overflow_p); 2392 VERIFY_CONSTANT (index); 2393 if (!lval) 2394 { 2395 elem_type = TREE_TYPE (TREE_TYPE (ary)); 2396 if (TREE_CODE (ary) == VIEW_CONVERT_EXPR 2397 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary, 0))) 2398 && TREE_TYPE (t) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary, 0)))) 2399 ary = TREE_OPERAND (ary, 0); 2400 if (TREE_CODE (ary) == CONSTRUCTOR) 2401 len = CONSTRUCTOR_NELTS (ary); 2402 else if (TREE_CODE (ary) == STRING_CST) 2403 { 2404 elem_nchars = (TYPE_PRECISION (elem_type) 2405 / TYPE_PRECISION (char_type_node)); 2406 len = (unsigned) TREE_STRING_LENGTH (ary) / elem_nchars; 2407 } 2408 else if (TREE_CODE (ary) == VECTOR_CST) 2409 /* We don't create variable-length VECTOR_CSTs. */ 2410 len = VECTOR_CST_NELTS (ary).to_constant (); 2411 else 2412 { 2413 /* We can't do anything with other tree codes, so use 2414 VERIFY_CONSTANT to complain and fail. */ 2415 VERIFY_CONSTANT (ary); 2416 gcc_unreachable (); 2417 } 2418 2419 if (!tree_fits_shwi_p (index) 2420 || (i = tree_to_shwi (index)) < 0) 2421 { 2422 diag_array_subscript (ctx, ary, index); 2423 *non_constant_p = true; 2424 return t; 2425 } 2426 } 2427 2428 tree nelts = get_array_or_vector_nelts (ctx, TREE_TYPE (ary), non_constant_p, 2429 overflow_p); 2430 VERIFY_CONSTANT (nelts); 2431 if ((lval 2432 ? !tree_int_cst_le (index, nelts) 2433 : !tree_int_cst_lt (index, nelts)) 2434 || tree_int_cst_sgn (index) < 0) 2435 { 2436 diag_array_subscript (ctx, ary, index); 2437 *non_constant_p = true; 2438 return t; 2439 } 2440 2441 if (lval && ary == oldary && index == oldidx) 2442 return t; 2443 else if (lval) 2444 return build4 (ARRAY_REF, TREE_TYPE (t), ary, index, NULL, NULL); 2445 2446 bool found; 2447 if (TREE_CODE (ary) == CONSTRUCTOR) 2448 { 2449 HOST_WIDE_INT ix = find_array_ctor_elt (ary, index); 2450 found = (ix >= 0); 2451 if (found) 2452 i = ix; 2453 } 2454 else 2455 found = (i < len); 2456 2457 if (found) 2458 { 2459 tree r; 2460 if (TREE_CODE (ary) == CONSTRUCTOR) 2461 r = (*CONSTRUCTOR_ELTS (ary))[i].value; 2462 else if (TREE_CODE (ary) == VECTOR_CST) 2463 r = VECTOR_CST_ELT (ary, i); 2464 else 2465 r = extract_string_elt (ary, elem_nchars, i); 2466 2467 if (r) 2468 /* Don't VERIFY_CONSTANT here. */ 2469 return r; 2470 2471 /* Otherwise the element doesn't have a value yet. */ 2472 } 2473 2474 /* Not found. */ 2475 2476 if (TREE_CODE (ary) == CONSTRUCTOR 2477 && CONSTRUCTOR_NO_IMPLICIT_ZERO (ary)) 2478 { 2479 /* 'ary' is part of the aggregate initializer we're currently 2480 building; if there's no initializer for this element yet, 2481 that's an error. */ 2482 if (!ctx->quiet) 2483 error ("accessing uninitialized array element"); 2484 *non_constant_p = true; 2485 return t; 2486 } 2487 2488 /* If it's within the array bounds but doesn't have an explicit 2489 initializer, it's initialized from {}. But use build_value_init 2490 directly for non-aggregates to avoid creating a garbage CONSTRUCTOR. */ 2491 tree val; 2492 if (CP_AGGREGATE_TYPE_P (elem_type)) 2493 { 2494 tree empty_ctor = build_constructor (init_list_type_node, NULL); 2495 val = digest_init (elem_type, empty_ctor, tf_warning_or_error); 2496 } 2497 else 2498 val = build_value_init (elem_type, tf_warning_or_error); 2499 return cxx_eval_constant_expression (ctx, val, lval, non_constant_p, 2500 overflow_p); 2501 } 2502 2503 /* Subroutine of cxx_eval_constant_expression. 2504 Attempt to reduce a field access of a value of class type. */ 2505 2506 static tree 2507 cxx_eval_component_reference (const constexpr_ctx *ctx, tree t, 2508 bool lval, 2509 bool *non_constant_p, bool *overflow_p) 2510 { 2511 unsigned HOST_WIDE_INT i; 2512 tree field; 2513 tree value; 2514 tree part = TREE_OPERAND (t, 1); 2515 tree orig_whole = TREE_OPERAND (t, 0); 2516 tree whole = cxx_eval_constant_expression (ctx, orig_whole, 2517 lval, 2518 non_constant_p, overflow_p); 2519 if (INDIRECT_REF_P (whole) 2520 && integer_zerop (TREE_OPERAND (whole, 0))) 2521 { 2522 if (!ctx->quiet) 2523 error ("dereferencing a null pointer in %qE", orig_whole); 2524 *non_constant_p = true; 2525 return t; 2526 } 2527 2528 if (TREE_CODE (whole) == PTRMEM_CST) 2529 whole = cplus_expand_constant (whole); 2530 if (whole == orig_whole) 2531 return t; 2532 if (lval) 2533 return fold_build3 (COMPONENT_REF, TREE_TYPE (t), 2534 whole, part, NULL_TREE); 2535 /* Don't VERIFY_CONSTANT here; we only want to check that we got a 2536 CONSTRUCTOR. */ 2537 if (!*non_constant_p && TREE_CODE (whole) != CONSTRUCTOR) 2538 { 2539 if (!ctx->quiet) 2540 error ("%qE is not a constant expression", orig_whole); 2541 *non_constant_p = true; 2542 } 2543 if (DECL_MUTABLE_P (part)) 2544 { 2545 if (!ctx->quiet) 2546 error ("mutable %qD is not usable in a constant expression", part); 2547 *non_constant_p = true; 2548 } 2549 if (*non_constant_p) 2550 return t; 2551 bool pmf = TYPE_PTRMEMFUNC_P (TREE_TYPE (whole)); 2552 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value) 2553 { 2554 /* Use name match for PMF fields, as a variant will have a 2555 different FIELD_DECL with a different type. */ 2556 if (pmf ? DECL_NAME (field) == DECL_NAME (part) 2557 : field == part) 2558 { 2559 if (value) 2560 return value; 2561 else 2562 /* We're in the middle of initializing it. */ 2563 break; 2564 } 2565 } 2566 if (TREE_CODE (TREE_TYPE (whole)) == UNION_TYPE 2567 && CONSTRUCTOR_NELTS (whole) > 0) 2568 { 2569 /* DR 1188 says we don't have to deal with this. */ 2570 if (!ctx->quiet) 2571 error ("accessing %qD member instead of initialized %qD member in " 2572 "constant expression", part, CONSTRUCTOR_ELT (whole, 0)->index); 2573 *non_constant_p = true; 2574 return t; 2575 } 2576 2577 /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty 2578 classes never get represented; throw together a value now. */ 2579 if (is_really_empty_class (TREE_TYPE (t))) 2580 return build_constructor (TREE_TYPE (t), NULL); 2581 2582 gcc_assert (DECL_CONTEXT (part) == TYPE_MAIN_VARIANT (TREE_TYPE (whole))); 2583 2584 if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole)) 2585 { 2586 /* 'whole' is part of the aggregate initializer we're currently 2587 building; if there's no initializer for this member yet, that's an 2588 error. */ 2589 if (!ctx->quiet) 2590 error ("accessing uninitialized member %qD", part); 2591 *non_constant_p = true; 2592 return t; 2593 } 2594 2595 /* If there's no explicit init for this field, it's value-initialized. */ 2596 value = build_value_init (TREE_TYPE (t), tf_warning_or_error); 2597 return cxx_eval_constant_expression (ctx, value, 2598 lval, 2599 non_constant_p, overflow_p); 2600 } 2601 2602 /* Subroutine of cxx_eval_constant_expression. 2603 Attempt to reduce a field access of a value of class type that is 2604 expressed as a BIT_FIELD_REF. */ 2605 2606 static tree 2607 cxx_eval_bit_field_ref (const constexpr_ctx *ctx, tree t, 2608 bool lval, 2609 bool *non_constant_p, bool *overflow_p) 2610 { 2611 tree orig_whole = TREE_OPERAND (t, 0); 2612 tree retval, fldval, utype, mask; 2613 bool fld_seen = false; 2614 HOST_WIDE_INT istart, isize; 2615 tree whole = cxx_eval_constant_expression (ctx, orig_whole, 2616 lval, 2617 non_constant_p, overflow_p); 2618 tree start, field, value; 2619 unsigned HOST_WIDE_INT i; 2620 2621 if (whole == orig_whole) 2622 return t; 2623 /* Don't VERIFY_CONSTANT here; we only want to check that we got a 2624 CONSTRUCTOR. */ 2625 if (!*non_constant_p 2626 && TREE_CODE (whole) != VECTOR_CST 2627 && TREE_CODE (whole) != CONSTRUCTOR) 2628 { 2629 if (!ctx->quiet) 2630 error ("%qE is not a constant expression", orig_whole); 2631 *non_constant_p = true; 2632 } 2633 if (*non_constant_p) 2634 return t; 2635 2636 if (TREE_CODE (whole) == VECTOR_CST) 2637 return fold_ternary (BIT_FIELD_REF, TREE_TYPE (t), whole, 2638 TREE_OPERAND (t, 1), TREE_OPERAND (t, 2)); 2639 2640 start = TREE_OPERAND (t, 2); 2641 istart = tree_to_shwi (start); 2642 isize = tree_to_shwi (TREE_OPERAND (t, 1)); 2643 utype = TREE_TYPE (t); 2644 if (!TYPE_UNSIGNED (utype)) 2645 utype = build_nonstandard_integer_type (TYPE_PRECISION (utype), 1); 2646 retval = build_int_cst (utype, 0); 2647 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value) 2648 { 2649 tree bitpos = bit_position (field); 2650 if (bitpos == start && DECL_SIZE (field) == TREE_OPERAND (t, 1)) 2651 return value; 2652 if (TREE_CODE (TREE_TYPE (field)) == INTEGER_TYPE 2653 && TREE_CODE (value) == INTEGER_CST 2654 && tree_fits_shwi_p (bitpos) 2655 && tree_fits_shwi_p (DECL_SIZE (field))) 2656 { 2657 HOST_WIDE_INT bit = tree_to_shwi (bitpos); 2658 HOST_WIDE_INT sz = tree_to_shwi (DECL_SIZE (field)); 2659 HOST_WIDE_INT shift; 2660 if (bit >= istart && bit + sz <= istart + isize) 2661 { 2662 fldval = fold_convert (utype, value); 2663 mask = build_int_cst_type (utype, -1); 2664 mask = fold_build2 (LSHIFT_EXPR, utype, mask, 2665 size_int (TYPE_PRECISION (utype) - sz)); 2666 mask = fold_build2 (RSHIFT_EXPR, utype, mask, 2667 size_int (TYPE_PRECISION (utype) - sz)); 2668 fldval = fold_build2 (BIT_AND_EXPR, utype, fldval, mask); 2669 shift = bit - istart; 2670 if (BYTES_BIG_ENDIAN) 2671 shift = TYPE_PRECISION (utype) - shift - sz; 2672 fldval = fold_build2 (LSHIFT_EXPR, utype, fldval, 2673 size_int (shift)); 2674 retval = fold_build2 (BIT_IOR_EXPR, utype, retval, fldval); 2675 fld_seen = true; 2676 } 2677 } 2678 } 2679 if (fld_seen) 2680 return fold_convert (TREE_TYPE (t), retval); 2681 gcc_unreachable (); 2682 return error_mark_node; 2683 } 2684 2685 /* Subroutine of cxx_eval_constant_expression. 2686 Evaluate a short-circuited logical expression T in the context 2687 of a given constexpr CALL. BAILOUT_VALUE is the value for 2688 early return. CONTINUE_VALUE is used here purely for 2689 sanity check purposes. */ 2690 2691 static tree 2692 cxx_eval_logical_expression (const constexpr_ctx *ctx, tree t, 2693 tree bailout_value, tree continue_value, 2694 bool lval, 2695 bool *non_constant_p, bool *overflow_p) 2696 { 2697 tree r; 2698 tree lhs = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), 2699 lval, 2700 non_constant_p, overflow_p); 2701 VERIFY_CONSTANT (lhs); 2702 if (tree_int_cst_equal (lhs, bailout_value)) 2703 return lhs; 2704 gcc_assert (tree_int_cst_equal (lhs, continue_value)); 2705 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1), 2706 lval, non_constant_p, 2707 overflow_p); 2708 VERIFY_CONSTANT (r); 2709 return r; 2710 } 2711 2712 /* REF is a COMPONENT_REF designating a particular field. V is a vector of 2713 CONSTRUCTOR elements to initialize (part of) an object containing that 2714 field. Return a pointer to the constructor_elt corresponding to the 2715 initialization of the field. */ 2716 2717 static constructor_elt * 2718 base_field_constructor_elt (vec<constructor_elt, va_gc> *v, tree ref) 2719 { 2720 tree aggr = TREE_OPERAND (ref, 0); 2721 tree field = TREE_OPERAND (ref, 1); 2722 HOST_WIDE_INT i; 2723 constructor_elt *ce; 2724 2725 gcc_assert (TREE_CODE (ref) == COMPONENT_REF); 2726 2727 if (TREE_CODE (aggr) == COMPONENT_REF) 2728 { 2729 constructor_elt *base_ce 2730 = base_field_constructor_elt (v, aggr); 2731 v = CONSTRUCTOR_ELTS (base_ce->value); 2732 } 2733 2734 for (i = 0; vec_safe_iterate (v, i, &ce); ++i) 2735 if (ce->index == field) 2736 return ce; 2737 2738 gcc_unreachable (); 2739 return NULL; 2740 } 2741 2742 /* Some of the expressions fed to the constexpr mechanism are calls to 2743 constructors, which have type void. In that case, return the type being 2744 initialized by the constructor. */ 2745 2746 static tree 2747 initialized_type (tree t) 2748 { 2749 if (TYPE_P (t)) 2750 return t; 2751 tree type = cv_unqualified (TREE_TYPE (t)); 2752 if (TREE_CODE (t) == CALL_EXPR || TREE_CODE (t) == AGGR_INIT_EXPR) 2753 { 2754 /* A constructor call has void type, so we need to look deeper. */ 2755 tree fn = get_function_named_in_call (t); 2756 if (fn && TREE_CODE (fn) == FUNCTION_DECL 2757 && DECL_CXX_CONSTRUCTOR_P (fn)) 2758 type = DECL_CONTEXT (fn); 2759 } 2760 return type; 2761 } 2762 2763 /* We're about to initialize element INDEX of an array or class from VALUE. 2764 Set up NEW_CTX appropriately by adjusting .object to refer to the 2765 subobject and creating a new CONSTRUCTOR if the element is itself 2766 a class or array. */ 2767 2768 static void 2769 init_subob_ctx (const constexpr_ctx *ctx, constexpr_ctx &new_ctx, 2770 tree index, tree &value) 2771 { 2772 new_ctx = *ctx; 2773 2774 if (index && TREE_CODE (index) != INTEGER_CST 2775 && TREE_CODE (index) != FIELD_DECL) 2776 /* This won't have an element in the new CONSTRUCTOR. */ 2777 return; 2778 2779 tree type = initialized_type (value); 2780 if (!AGGREGATE_TYPE_P (type) && !VECTOR_TYPE_P (type)) 2781 /* A non-aggregate member doesn't get its own CONSTRUCTOR. */ 2782 return; 2783 2784 /* The sub-aggregate initializer might contain a placeholder; 2785 update object to refer to the subobject and ctor to refer to 2786 the (newly created) sub-initializer. */ 2787 if (ctx->object) 2788 new_ctx.object = build_ctor_subob_ref (index, type, ctx->object); 2789 tree elt = build_constructor (type, NULL); 2790 CONSTRUCTOR_NO_IMPLICIT_ZERO (elt) = true; 2791 new_ctx.ctor = elt; 2792 2793 if (TREE_CODE (value) == TARGET_EXPR) 2794 /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. */ 2795 value = TARGET_EXPR_INITIAL (value); 2796 } 2797 2798 /* We're about to process an initializer for a class or array TYPE. Make 2799 sure that CTX is set up appropriately. */ 2800 2801 static void 2802 verify_ctor_sanity (const constexpr_ctx *ctx, tree type) 2803 { 2804 /* We don't bother building a ctor for an empty base subobject. */ 2805 if (is_empty_class (type)) 2806 return; 2807 2808 /* We're in the middle of an initializer that might involve placeholders; 2809 our caller should have created a CONSTRUCTOR for us to put the 2810 initializer into. We will either return that constructor or T. */ 2811 gcc_assert (ctx->ctor); 2812 gcc_assert (same_type_ignoring_top_level_qualifiers_p 2813 (type, TREE_TYPE (ctx->ctor))); 2814 /* We used to check that ctx->ctor was empty, but that isn't the case when 2815 the object is zero-initialized before calling the constructor. */ 2816 if (ctx->object) 2817 { 2818 tree otype = TREE_TYPE (ctx->object); 2819 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, otype) 2820 /* Handle flexible array members. */ 2821 || (TREE_CODE (otype) == ARRAY_TYPE 2822 && TYPE_DOMAIN (otype) == NULL_TREE 2823 && TREE_CODE (type) == ARRAY_TYPE 2824 && (same_type_ignoring_top_level_qualifiers_p 2825 (TREE_TYPE (type), TREE_TYPE (otype))))); 2826 } 2827 gcc_assert (!ctx->object || !DECL_P (ctx->object) 2828 || *(ctx->values->get (ctx->object)) == ctx->ctor); 2829 } 2830 2831 /* Subroutine of cxx_eval_constant_expression. 2832 The expression tree T denotes a C-style array or a C-style 2833 aggregate. Reduce it to a constant expression. */ 2834 2835 static tree 2836 cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t, 2837 bool lval, 2838 bool *non_constant_p, bool *overflow_p) 2839 { 2840 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t); 2841 bool changed = false; 2842 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t)); 2843 tree type = TREE_TYPE (t); 2844 2845 constexpr_ctx new_ctx; 2846 if (TYPE_PTRMEMFUNC_P (type) || VECTOR_TYPE_P (type)) 2847 { 2848 /* We don't really need the ctx->ctor business for a PMF or 2849 vector, but it's simpler to use the same code. */ 2850 new_ctx = *ctx; 2851 new_ctx.ctor = build_constructor (type, NULL); 2852 new_ctx.object = NULL_TREE; 2853 ctx = &new_ctx; 2854 }; 2855 verify_ctor_sanity (ctx, type); 2856 vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor); 2857 vec_alloc (*p, vec_safe_length (v)); 2858 2859 unsigned i; 2860 tree index, value; 2861 bool constant_p = true; 2862 bool side_effects_p = false; 2863 FOR_EACH_CONSTRUCTOR_ELT (v, i, index, value) 2864 { 2865 tree orig_value = value; 2866 init_subob_ctx (ctx, new_ctx, index, value); 2867 if (new_ctx.ctor != ctx->ctor) 2868 /* If we built a new CONSTRUCTOR, attach it now so that other 2869 initializers can refer to it. */ 2870 CONSTRUCTOR_APPEND_ELT (*p, index, new_ctx.ctor); 2871 tree elt = cxx_eval_constant_expression (&new_ctx, value, 2872 lval, 2873 non_constant_p, overflow_p); 2874 /* Don't VERIFY_CONSTANT here. */ 2875 if (ctx->quiet && *non_constant_p) 2876 break; 2877 if (elt != orig_value) 2878 changed = true; 2879 2880 if (!TREE_CONSTANT (elt)) 2881 constant_p = false; 2882 if (TREE_SIDE_EFFECTS (elt)) 2883 side_effects_p = true; 2884 if (index && TREE_CODE (index) == COMPONENT_REF) 2885 { 2886 /* This is an initialization of a vfield inside a base 2887 subaggregate that we already initialized; push this 2888 initialization into the previous initialization. */ 2889 constructor_elt *inner = base_field_constructor_elt (*p, index); 2890 inner->value = elt; 2891 changed = true; 2892 } 2893 else if (index 2894 && (TREE_CODE (index) == NOP_EXPR 2895 || TREE_CODE (index) == POINTER_PLUS_EXPR)) 2896 { 2897 /* This is an initializer for an empty base; now that we've 2898 checked that it's constant, we can ignore it. */ 2899 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index)))); 2900 changed = true; 2901 } 2902 else 2903 { 2904 if (new_ctx.ctor != ctx->ctor) 2905 { 2906 /* We appended this element above; update the value. */ 2907 gcc_assert ((*p)->last().index == index); 2908 (*p)->last().value = elt; 2909 } 2910 else 2911 CONSTRUCTOR_APPEND_ELT (*p, index, elt); 2912 /* Adding or replacing an element might change the ctor's flags. */ 2913 TREE_CONSTANT (ctx->ctor) = constant_p; 2914 TREE_SIDE_EFFECTS (ctx->ctor) = side_effects_p; 2915 } 2916 } 2917 if (*non_constant_p || !changed) 2918 return t; 2919 t = ctx->ctor; 2920 /* We're done building this CONSTRUCTOR, so now we can interpret an 2921 element without an explicit initializer as value-initialized. */ 2922 CONSTRUCTOR_NO_IMPLICIT_ZERO (t) = false; 2923 TREE_CONSTANT (t) = constant_p; 2924 TREE_SIDE_EFFECTS (t) = side_effects_p; 2925 if (VECTOR_TYPE_P (type)) 2926 t = fold (t); 2927 return t; 2928 } 2929 2930 /* Subroutine of cxx_eval_constant_expression. 2931 The expression tree T is a VEC_INIT_EXPR which denotes the desired 2932 initialization of a non-static data member of array type. Reduce it to a 2933 CONSTRUCTOR. 2934 2935 Note that apart from value-initialization (when VALUE_INIT is true), 2936 this is only intended to support value-initialization and the 2937 initializations done by defaulted constructors for classes with 2938 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT 2939 will either be NULL_TREE for the default constructor, or a COMPONENT_REF 2940 for the copy/move constructor. */ 2941 2942 static tree 2943 cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init, 2944 bool value_init, bool lval, 2945 bool *non_constant_p, bool *overflow_p) 2946 { 2947 tree elttype = TREE_TYPE (atype); 2948 verify_ctor_sanity (ctx, atype); 2949 vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor); 2950 bool pre_init = false; 2951 unsigned HOST_WIDE_INT i; 2952 2953 /* For the default constructor, build up a call to the default 2954 constructor of the element type. We only need to handle class types 2955 here, as for a constructor to be constexpr, all members must be 2956 initialized, which for a defaulted default constructor means they must 2957 be of a class type with a constexpr default constructor. */ 2958 if (TREE_CODE (elttype) == ARRAY_TYPE) 2959 /* We only do this at the lowest level. */; 2960 else if (value_init) 2961 { 2962 init = build_value_init (elttype, tf_warning_or_error); 2963 pre_init = true; 2964 } 2965 else if (!init) 2966 { 2967 vec<tree, va_gc> *argvec = make_tree_vector (); 2968 init = build_special_member_call (NULL_TREE, complete_ctor_identifier, 2969 &argvec, elttype, LOOKUP_NORMAL, 2970 tf_warning_or_error); 2971 release_tree_vector (argvec); 2972 init = build_aggr_init_expr (TREE_TYPE (init), init); 2973 pre_init = true; 2974 } 2975 2976 tree nelts = get_array_or_vector_nelts (ctx, atype, non_constant_p, 2977 overflow_p); 2978 unsigned HOST_WIDE_INT max = tree_to_uhwi (nelts); 2979 for (i = 0; i < max; ++i) 2980 { 2981 tree idx = build_int_cst (size_type_node, i); 2982 tree eltinit; 2983 bool reuse = false; 2984 constexpr_ctx new_ctx; 2985 init_subob_ctx (ctx, new_ctx, idx, pre_init ? init : elttype); 2986 if (new_ctx.ctor != ctx->ctor) 2987 CONSTRUCTOR_APPEND_ELT (*p, idx, new_ctx.ctor); 2988 if (TREE_CODE (elttype) == ARRAY_TYPE) 2989 { 2990 /* A multidimensional array; recurse. */ 2991 if (value_init || init == NULL_TREE) 2992 { 2993 eltinit = NULL_TREE; 2994 reuse = i == 0; 2995 } 2996 else 2997 eltinit = cp_build_array_ref (input_location, init, idx, 2998 tf_warning_or_error); 2999 eltinit = cxx_eval_vec_init_1 (&new_ctx, elttype, eltinit, value_init, 3000 lval, 3001 non_constant_p, overflow_p); 3002 } 3003 else if (pre_init) 3004 { 3005 /* Initializing an element using value or default initialization 3006 we just pre-built above. */ 3007 if (init == void_node) 3008 /* Trivial default-init, don't do anything to the CONSTRUCTOR. */ 3009 return ctx->ctor; 3010 eltinit = cxx_eval_constant_expression (&new_ctx, init, lval, 3011 non_constant_p, overflow_p); 3012 reuse = i == 0; 3013 } 3014 else 3015 { 3016 /* Copying an element. */ 3017 gcc_assert (same_type_ignoring_top_level_qualifiers_p 3018 (atype, TREE_TYPE (init))); 3019 eltinit = cp_build_array_ref (input_location, init, idx, 3020 tf_warning_or_error); 3021 if (!lvalue_p (init)) 3022 eltinit = move (eltinit); 3023 eltinit = force_rvalue (eltinit, tf_warning_or_error); 3024 eltinit = cxx_eval_constant_expression (&new_ctx, eltinit, lval, 3025 non_constant_p, overflow_p); 3026 } 3027 if (*non_constant_p && !ctx->quiet) 3028 break; 3029 if (new_ctx.ctor != ctx->ctor) 3030 { 3031 /* We appended this element above; update the value. */ 3032 gcc_assert ((*p)->last().index == idx); 3033 (*p)->last().value = eltinit; 3034 } 3035 else 3036 CONSTRUCTOR_APPEND_ELT (*p, idx, eltinit); 3037 /* Reuse the result of cxx_eval_constant_expression call 3038 from the first iteration to all others if it is a constant 3039 initializer that doesn't require relocations. */ 3040 if (reuse 3041 && max > 1 3042 && (eltinit == NULL_TREE 3043 || (initializer_constant_valid_p (eltinit, TREE_TYPE (eltinit)) 3044 == null_pointer_node))) 3045 { 3046 if (new_ctx.ctor != ctx->ctor) 3047 eltinit = new_ctx.ctor; 3048 tree range = build2 (RANGE_EXPR, size_type_node, 3049 build_int_cst (size_type_node, 1), 3050 build_int_cst (size_type_node, max - 1)); 3051 CONSTRUCTOR_APPEND_ELT (*p, range, unshare_constructor (eltinit)); 3052 break; 3053 } 3054 else if (i == 0) 3055 vec_safe_reserve (*p, max); 3056 } 3057 3058 if (!*non_constant_p) 3059 { 3060 init = ctx->ctor; 3061 CONSTRUCTOR_NO_IMPLICIT_ZERO (init) = false; 3062 } 3063 return init; 3064 } 3065 3066 static tree 3067 cxx_eval_vec_init (const constexpr_ctx *ctx, tree t, 3068 bool lval, 3069 bool *non_constant_p, bool *overflow_p) 3070 { 3071 tree atype = TREE_TYPE (t); 3072 tree init = VEC_INIT_EXPR_INIT (t); 3073 tree r = cxx_eval_vec_init_1 (ctx, atype, init, 3074 VEC_INIT_EXPR_VALUE_INIT (t), 3075 lval, non_constant_p, overflow_p); 3076 if (*non_constant_p) 3077 return t; 3078 else 3079 return r; 3080 } 3081 3082 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to 3083 match. We want to be less strict for simple *& folding; if we have a 3084 non-const temporary that we access through a const pointer, that should 3085 work. We handle this here rather than change fold_indirect_ref_1 3086 because we're dealing with things like ADDR_EXPR of INTEGER_CST which 3087 don't really make sense outside of constant expression evaluation. Also 3088 we want to allow folding to COMPONENT_REF, which could cause trouble 3089 with TBAA in fold_indirect_ref_1. 3090 3091 Try to keep this function synced with fold_indirect_ref_1. */ 3092 3093 static tree 3094 cxx_fold_indirect_ref (location_t loc, tree type, tree op0, bool *empty_base) 3095 { 3096 tree sub = op0; 3097 tree subtype; 3098 poly_uint64 const_op01; 3099 3100 STRIP_NOPS (sub); 3101 subtype = TREE_TYPE (sub); 3102 if (!POINTER_TYPE_P (subtype)) 3103 return NULL_TREE; 3104 3105 if (TREE_CODE (sub) == ADDR_EXPR) 3106 { 3107 tree op = TREE_OPERAND (sub, 0); 3108 tree optype = TREE_TYPE (op); 3109 3110 /* *&CONST_DECL -> to the value of the const decl. */ 3111 if (TREE_CODE (op) == CONST_DECL) 3112 return DECL_INITIAL (op); 3113 /* *&p => p; make sure to handle *&"str"[cst] here. */ 3114 if (same_type_ignoring_top_level_qualifiers_p (optype, type) 3115 /* Also handle the case where the desired type is an array of unknown 3116 bounds because the variable has had its bounds deduced since the 3117 ADDR_EXPR was created. */ 3118 || (TREE_CODE (type) == ARRAY_TYPE 3119 && TREE_CODE (optype) == ARRAY_TYPE 3120 && TYPE_DOMAIN (type) == NULL_TREE 3121 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype), 3122 TREE_TYPE (type)))) 3123 { 3124 tree fop = fold_read_from_constant_string (op); 3125 if (fop) 3126 return fop; 3127 else 3128 return op; 3129 } 3130 /* *(foo *)&fooarray => fooarray[0] */ 3131 else if (TREE_CODE (optype) == ARRAY_TYPE 3132 && (same_type_ignoring_top_level_qualifiers_p 3133 (type, TREE_TYPE (optype)))) 3134 { 3135 tree type_domain = TYPE_DOMAIN (optype); 3136 tree min_val = size_zero_node; 3137 if (type_domain && TYPE_MIN_VALUE (type_domain)) 3138 min_val = TYPE_MIN_VALUE (type_domain); 3139 return build4_loc (loc, ARRAY_REF, type, op, min_val, 3140 NULL_TREE, NULL_TREE); 3141 } 3142 /* *(foo *)&complexfoo => __real__ complexfoo */ 3143 else if (TREE_CODE (optype) == COMPLEX_TYPE 3144 && (same_type_ignoring_top_level_qualifiers_p 3145 (type, TREE_TYPE (optype)))) 3146 return fold_build1_loc (loc, REALPART_EXPR, type, op); 3147 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */ 3148 else if (VECTOR_TYPE_P (optype) 3149 && (same_type_ignoring_top_level_qualifiers_p 3150 (type, TREE_TYPE (optype)))) 3151 { 3152 tree part_width = TYPE_SIZE (type); 3153 tree index = bitsize_int (0); 3154 return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, 3155 index); 3156 } 3157 /* Also handle conversion to an empty base class, which 3158 is represented with a NOP_EXPR. */ 3159 else if (is_empty_class (type) 3160 && CLASS_TYPE_P (optype) 3161 && DERIVED_FROM_P (type, optype)) 3162 { 3163 *empty_base = true; 3164 return op; 3165 } 3166 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */ 3167 else if (RECORD_OR_UNION_TYPE_P (optype)) 3168 { 3169 tree field = TYPE_FIELDS (optype); 3170 for (; field; field = DECL_CHAIN (field)) 3171 if (TREE_CODE (field) == FIELD_DECL 3172 && TREE_TYPE (field) != error_mark_node 3173 && integer_zerop (byte_position (field)) 3174 && (same_type_ignoring_top_level_qualifiers_p 3175 (TREE_TYPE (field), type))) 3176 return fold_build3 (COMPONENT_REF, type, op, field, NULL_TREE); 3177 } 3178 } 3179 else if (TREE_CODE (sub) == POINTER_PLUS_EXPR 3180 && poly_int_tree_p (TREE_OPERAND (sub, 1), &const_op01)) 3181 { 3182 tree op00 = TREE_OPERAND (sub, 0); 3183 tree op01 = TREE_OPERAND (sub, 1); 3184 3185 STRIP_NOPS (op00); 3186 if (TREE_CODE (op00) == ADDR_EXPR) 3187 { 3188 tree op00type; 3189 op00 = TREE_OPERAND (op00, 0); 3190 op00type = TREE_TYPE (op00); 3191 3192 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */ 3193 if (VECTOR_TYPE_P (op00type) 3194 && same_type_ignoring_top_level_qualifiers_p 3195 (type, TREE_TYPE (op00type)) 3196 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned, 3197 but we want to treat offsets with MSB set as negative. 3198 For the code below negative offsets are invalid and 3199 TYPE_SIZE of the element is something unsigned, so 3200 check whether op01 fits into poly_int64, which implies 3201 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and 3202 then just use poly_uint64 because we want to treat the 3203 value as unsigned. */ 3204 && tree_fits_poly_int64_p (op01)) 3205 { 3206 tree part_width = TYPE_SIZE (type); 3207 poly_uint64 max_offset 3208 = (tree_to_uhwi (part_width) / BITS_PER_UNIT 3209 * TYPE_VECTOR_SUBPARTS (op00type)); 3210 if (known_lt (const_op01, max_offset)) 3211 { 3212 tree index = bitsize_int (const_op01 * BITS_PER_UNIT); 3213 return fold_build3_loc (loc, 3214 BIT_FIELD_REF, type, op00, 3215 part_width, index); 3216 } 3217 } 3218 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */ 3219 else if (TREE_CODE (op00type) == COMPLEX_TYPE 3220 && (same_type_ignoring_top_level_qualifiers_p 3221 (type, TREE_TYPE (op00type)))) 3222 { 3223 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type)), 3224 const_op01)) 3225 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00); 3226 } 3227 /* ((foo *)&fooarray)[1] => fooarray[1] */ 3228 else if (TREE_CODE (op00type) == ARRAY_TYPE 3229 && (same_type_ignoring_top_level_qualifiers_p 3230 (type, TREE_TYPE (op00type)))) 3231 { 3232 tree type_domain = TYPE_DOMAIN (op00type); 3233 tree min_val = size_zero_node; 3234 if (type_domain && TYPE_MIN_VALUE (type_domain)) 3235 min_val = TYPE_MIN_VALUE (type_domain); 3236 offset_int off = wi::to_offset (op01); 3237 offset_int el_sz = wi::to_offset (TYPE_SIZE_UNIT (type)); 3238 offset_int remainder; 3239 off = wi::divmod_trunc (off, el_sz, SIGNED, &remainder); 3240 if (remainder == 0 && TREE_CODE (min_val) == INTEGER_CST) 3241 { 3242 off = off + wi::to_offset (min_val); 3243 op01 = wide_int_to_tree (sizetype, off); 3244 return build4_loc (loc, ARRAY_REF, type, op00, op01, 3245 NULL_TREE, NULL_TREE); 3246 } 3247 } 3248 /* Also handle conversion to an empty base class, which 3249 is represented with a NOP_EXPR. */ 3250 else if (is_empty_class (type) 3251 && CLASS_TYPE_P (op00type) 3252 && DERIVED_FROM_P (type, op00type)) 3253 { 3254 *empty_base = true; 3255 return op00; 3256 } 3257 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */ 3258 else if (RECORD_OR_UNION_TYPE_P (op00type)) 3259 { 3260 tree field = TYPE_FIELDS (op00type); 3261 for (; field; field = DECL_CHAIN (field)) 3262 if (TREE_CODE (field) == FIELD_DECL 3263 && TREE_TYPE (field) != error_mark_node 3264 && tree_int_cst_equal (byte_position (field), op01) 3265 && (same_type_ignoring_top_level_qualifiers_p 3266 (TREE_TYPE (field), type))) 3267 return fold_build3 (COMPONENT_REF, type, op00, 3268 field, NULL_TREE); 3269 } 3270 } 3271 } 3272 /* *(foo *)fooarrptr => (*fooarrptr)[0] */ 3273 else if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE 3274 && (same_type_ignoring_top_level_qualifiers_p 3275 (type, TREE_TYPE (TREE_TYPE (subtype))))) 3276 { 3277 tree type_domain; 3278 tree min_val = size_zero_node; 3279 tree newsub 3280 = cxx_fold_indirect_ref (loc, TREE_TYPE (subtype), sub, NULL); 3281 if (newsub) 3282 sub = newsub; 3283 else 3284 sub = build1_loc (loc, INDIRECT_REF, TREE_TYPE (subtype), sub); 3285 type_domain = TYPE_DOMAIN (TREE_TYPE (sub)); 3286 if (type_domain && TYPE_MIN_VALUE (type_domain)) 3287 min_val = TYPE_MIN_VALUE (type_domain); 3288 return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE, 3289 NULL_TREE); 3290 } 3291 3292 return NULL_TREE; 3293 } 3294 3295 static tree 3296 cxx_eval_indirect_ref (const constexpr_ctx *ctx, tree t, 3297 bool lval, 3298 bool *non_constant_p, bool *overflow_p) 3299 { 3300 tree orig_op0 = TREE_OPERAND (t, 0); 3301 bool empty_base = false; 3302 3303 /* We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second 3304 operand is an integer-zero. Otherwise reject the MEM_REF for now. */ 3305 3306 if (TREE_CODE (t) == MEM_REF 3307 && (!TREE_OPERAND (t, 1) || !integer_zerop (TREE_OPERAND (t, 1)))) 3308 { 3309 gcc_assert (ctx->quiet); 3310 *non_constant_p = true; 3311 return t; 3312 } 3313 3314 /* First try to simplify it directly. */ 3315 tree r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), orig_op0, 3316 &empty_base); 3317 if (!r) 3318 { 3319 /* If that didn't work, evaluate the operand first. */ 3320 tree op0 = cxx_eval_constant_expression (ctx, orig_op0, 3321 /*lval*/false, non_constant_p, 3322 overflow_p); 3323 /* Don't VERIFY_CONSTANT here. */ 3324 if (*non_constant_p) 3325 return t; 3326 3327 if (!lval && integer_zerop (op0)) 3328 { 3329 if (!ctx->quiet) 3330 error ("dereferencing a null pointer"); 3331 *non_constant_p = true; 3332 return t; 3333 } 3334 3335 r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), op0, 3336 &empty_base); 3337 if (r == NULL_TREE) 3338 { 3339 /* We couldn't fold to a constant value. Make sure it's not 3340 something we should have been able to fold. */ 3341 tree sub = op0; 3342 STRIP_NOPS (sub); 3343 if (TREE_CODE (sub) == ADDR_EXPR) 3344 { 3345 gcc_assert (!same_type_ignoring_top_level_qualifiers_p 3346 (TREE_TYPE (TREE_TYPE (sub)), TREE_TYPE (t))); 3347 /* DR 1188 says we don't have to deal with this. */ 3348 if (!ctx->quiet) 3349 error ("accessing value of %qE through a %qT glvalue in a " 3350 "constant expression", build_fold_indirect_ref (sub), 3351 TREE_TYPE (t)); 3352 *non_constant_p = true; 3353 return t; 3354 } 3355 3356 if (lval && op0 != orig_op0) 3357 return build1 (INDIRECT_REF, TREE_TYPE (t), op0); 3358 if (!lval) 3359 VERIFY_CONSTANT (t); 3360 return t; 3361 } 3362 } 3363 3364 r = cxx_eval_constant_expression (ctx, r, 3365 lval, non_constant_p, overflow_p); 3366 if (*non_constant_p) 3367 return t; 3368 3369 /* If we're pulling out the value of an empty base, just return an empty 3370 CONSTRUCTOR. */ 3371 if (empty_base && !lval) 3372 { 3373 r = build_constructor (TREE_TYPE (t), NULL); 3374 TREE_CONSTANT (r) = true; 3375 } 3376 3377 return r; 3378 } 3379 3380 /* Complain about R, a VAR_DECL, not being usable in a constant expression. 3381 Shared between potential_constant_expression and 3382 cxx_eval_constant_expression. */ 3383 3384 static void 3385 non_const_var_error (tree r) 3386 { 3387 tree type = TREE_TYPE (r); 3388 error ("the value of %qD is not usable in a constant " 3389 "expression", r); 3390 /* Avoid error cascade. */ 3391 if (DECL_INITIAL (r) == error_mark_node) 3392 return; 3393 if (DECL_DECLARED_CONSTEXPR_P (r)) 3394 inform (DECL_SOURCE_LOCATION (r), 3395 "%qD used in its own initializer", r); 3396 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type)) 3397 { 3398 if (!CP_TYPE_CONST_P (type)) 3399 inform (DECL_SOURCE_LOCATION (r), 3400 "%q#D is not const", r); 3401 else if (CP_TYPE_VOLATILE_P (type)) 3402 inform (DECL_SOURCE_LOCATION (r), 3403 "%q#D is volatile", r); 3404 else if (!DECL_INITIAL (r) 3405 || !TREE_CONSTANT (DECL_INITIAL (r)) 3406 || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)) 3407 inform (DECL_SOURCE_LOCATION (r), 3408 "%qD was not initialized with a constant " 3409 "expression", r); 3410 else 3411 gcc_unreachable (); 3412 } 3413 else if (TREE_CODE (type) == REFERENCE_TYPE) 3414 inform (DECL_SOURCE_LOCATION (r), 3415 "%qD was not initialized with a constant " 3416 "expression", r); 3417 else 3418 { 3419 if (cxx_dialect >= cxx11 && !DECL_DECLARED_CONSTEXPR_P (r)) 3420 inform (DECL_SOURCE_LOCATION (r), 3421 "%qD was not declared %<constexpr%>", r); 3422 else 3423 inform (DECL_SOURCE_LOCATION (r), 3424 "%qD does not have integral or enumeration type", 3425 r); 3426 } 3427 } 3428 3429 /* Subroutine of cxx_eval_constant_expression. 3430 Like cxx_eval_unary_expression, except for trinary expressions. */ 3431 3432 static tree 3433 cxx_eval_trinary_expression (const constexpr_ctx *ctx, tree t, 3434 bool lval, 3435 bool *non_constant_p, bool *overflow_p) 3436 { 3437 int i; 3438 tree args[3]; 3439 tree val; 3440 3441 for (i = 0; i < 3; i++) 3442 { 3443 args[i] = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, i), 3444 lval, 3445 non_constant_p, overflow_p); 3446 VERIFY_CONSTANT (args[i]); 3447 } 3448 3449 val = fold_ternary_loc (EXPR_LOCATION (t), TREE_CODE (t), TREE_TYPE (t), 3450 args[0], args[1], args[2]); 3451 if (val == NULL_TREE) 3452 return t; 3453 VERIFY_CONSTANT (val); 3454 return val; 3455 } 3456 3457 /* True if T was declared in a function declared to be constexpr, and 3458 therefore potentially constant in C++14. */ 3459 3460 bool 3461 var_in_constexpr_fn (tree t) 3462 { 3463 tree ctx = DECL_CONTEXT (t); 3464 return (ctx && TREE_CODE (ctx) == FUNCTION_DECL 3465 && DECL_DECLARED_CONSTEXPR_P (ctx)); 3466 } 3467 3468 /* True if T was declared in a function that might be constexpr: either a 3469 function that was declared constexpr, or a C++17 lambda op(). */ 3470 3471 bool 3472 var_in_maybe_constexpr_fn (tree t) 3473 { 3474 if (cxx_dialect >= cxx17 3475 && DECL_FUNCTION_SCOPE_P (t) 3476 && LAMBDA_FUNCTION_P (DECL_CONTEXT (t))) 3477 return true; 3478 return var_in_constexpr_fn (t); 3479 } 3480 3481 /* We're assigning INIT to TARGET. In do_build_copy_constructor and 3482 build_over_call we implement trivial copy of a class with tail padding using 3483 assignment of character arrays, which is valid in normal code, but not in 3484 constexpr evaluation. We don't need to worry about clobbering tail padding 3485 in constexpr evaluation, so strip the type punning. */ 3486 3487 static void 3488 maybe_simplify_trivial_copy (tree &target, tree &init) 3489 { 3490 if (TREE_CODE (target) == MEM_REF 3491 && TREE_CODE (init) == MEM_REF 3492 && TREE_TYPE (target) == TREE_TYPE (init) 3493 && TREE_CODE (TREE_TYPE (target)) == ARRAY_TYPE 3494 && TREE_TYPE (TREE_TYPE (target)) == unsigned_char_type_node) 3495 { 3496 target = build_fold_indirect_ref (TREE_OPERAND (target, 0)); 3497 init = build_fold_indirect_ref (TREE_OPERAND (init, 0)); 3498 } 3499 } 3500 3501 /* Evaluate an INIT_EXPR or MODIFY_EXPR. */ 3502 3503 static tree 3504 cxx_eval_store_expression (const constexpr_ctx *ctx, tree t, 3505 bool lval, 3506 bool *non_constant_p, bool *overflow_p) 3507 { 3508 constexpr_ctx new_ctx = *ctx; 3509 3510 tree init = TREE_OPERAND (t, 1); 3511 if (TREE_CLOBBER_P (init)) 3512 /* Just ignore clobbers. */ 3513 return void_node; 3514 3515 /* First we figure out where we're storing to. */ 3516 tree target = TREE_OPERAND (t, 0); 3517 3518 maybe_simplify_trivial_copy (target, init); 3519 3520 tree type = TREE_TYPE (target); 3521 target = cxx_eval_constant_expression (ctx, target, 3522 true, 3523 non_constant_p, overflow_p); 3524 if (*non_constant_p) 3525 return t; 3526 3527 /* cxx_eval_array_reference for lval = true allows references one past 3528 end of array, because it does not know if it is just taking address 3529 (which is valid), or actual dereference. Here we know it is 3530 a dereference, so diagnose it here. */ 3531 for (tree probe = target; probe; ) 3532 { 3533 switch (TREE_CODE (probe)) 3534 { 3535 case ARRAY_REF: 3536 tree nelts, ary; 3537 ary = TREE_OPERAND (probe, 0); 3538 nelts = get_array_or_vector_nelts (ctx, TREE_TYPE (ary), 3539 non_constant_p, overflow_p); 3540 VERIFY_CONSTANT (nelts); 3541 gcc_assert (TREE_CODE (nelts) == INTEGER_CST 3542 && TREE_CODE (TREE_OPERAND (probe, 1)) == INTEGER_CST); 3543 if (wi::to_widest (TREE_OPERAND (probe, 1)) == wi::to_widest (nelts)) 3544 { 3545 diag_array_subscript (ctx, ary, TREE_OPERAND (probe, 1)); 3546 *non_constant_p = true; 3547 return t; 3548 } 3549 /* FALLTHRU */ 3550 3551 case BIT_FIELD_REF: 3552 case COMPONENT_REF: 3553 probe = TREE_OPERAND (probe, 0); 3554 continue; 3555 3556 default: 3557 probe = NULL_TREE; 3558 continue; 3559 } 3560 } 3561 3562 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target), type)) 3563 { 3564 /* For initialization of an empty base, the original target will be 3565 *(base*)this, which the above evaluation resolves to the object 3566 argument, which has the derived type rather than the base type. In 3567 this situation, just evaluate the initializer and return, since 3568 there's no actual data to store. */ 3569 gcc_assert (is_empty_class (type)); 3570 return cxx_eval_constant_expression (ctx, init, false, 3571 non_constant_p, overflow_p); 3572 } 3573 3574 /* And then find the underlying variable. */ 3575 vec<tree,va_gc> *refs = make_tree_vector(); 3576 tree object = NULL_TREE; 3577 for (tree probe = target; object == NULL_TREE; ) 3578 { 3579 switch (TREE_CODE (probe)) 3580 { 3581 case BIT_FIELD_REF: 3582 case COMPONENT_REF: 3583 case ARRAY_REF: 3584 vec_safe_push (refs, TREE_OPERAND (probe, 1)); 3585 vec_safe_push (refs, TREE_TYPE (probe)); 3586 probe = TREE_OPERAND (probe, 0); 3587 break; 3588 3589 default: 3590 object = probe; 3591 } 3592 } 3593 3594 /* And then find/build up our initializer for the path to the subobject 3595 we're initializing. */ 3596 tree *valp; 3597 if (object == ctx->object && VAR_P (object) 3598 && DECL_NAME (object) && ctx->call == NULL) 3599 /* The variable we're building up an aggregate initializer for is outside 3600 the constant-expression, so don't evaluate the store. We check 3601 DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. */ 3602 valp = NULL; 3603 else if (DECL_P (object)) 3604 valp = ctx->values->get (object); 3605 else 3606 valp = NULL; 3607 if (!valp) 3608 { 3609 /* A constant-expression cannot modify objects from outside the 3610 constant-expression. */ 3611 if (!ctx->quiet) 3612 error ("modification of %qE is not a constant expression", object); 3613 *non_constant_p = true; 3614 return t; 3615 } 3616 type = TREE_TYPE (object); 3617 bool no_zero_init = true; 3618 3619 vec<tree,va_gc> *ctors = make_tree_vector (); 3620 while (!refs->is_empty()) 3621 { 3622 if (*valp == NULL_TREE) 3623 { 3624 *valp = build_constructor (type, NULL); 3625 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) = no_zero_init; 3626 } 3627 else if (TREE_CODE (*valp) == STRING_CST) 3628 { 3629 /* An array was initialized with a string constant, and now 3630 we're writing into one of its elements. Explode the 3631 single initialization into a set of element 3632 initializations. */ 3633 gcc_assert (TREE_CODE (type) == ARRAY_TYPE); 3634 3635 tree string = *valp; 3636 tree elt_type = TREE_TYPE (type); 3637 unsigned chars_per_elt = (TYPE_PRECISION (elt_type) 3638 / TYPE_PRECISION (char_type_node)); 3639 unsigned num_elts = TREE_STRING_LENGTH (string) / chars_per_elt; 3640 tree ary_ctor = build_constructor (type, NULL); 3641 3642 vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor), num_elts); 3643 for (unsigned ix = 0; ix != num_elts; ix++) 3644 { 3645 constructor_elt elt = 3646 { 3647 build_int_cst (size_type_node, ix), 3648 extract_string_elt (string, chars_per_elt, ix) 3649 }; 3650 CONSTRUCTOR_ELTS (ary_ctor)->quick_push (elt); 3651 } 3652 3653 *valp = ary_ctor; 3654 } 3655 3656 /* If the value of object is already zero-initialized, any new ctors for 3657 subobjects will also be zero-initialized. */ 3658 no_zero_init = CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp); 3659 3660 vec_safe_push (ctors, *valp); 3661 3662 enum tree_code code = TREE_CODE (type); 3663 type = refs->pop(); 3664 tree index = refs->pop(); 3665 3666 constructor_elt *cep = NULL; 3667 if (code == ARRAY_TYPE) 3668 { 3669 HOST_WIDE_INT i 3670 = find_array_ctor_elt (*valp, index, /*insert*/true); 3671 gcc_assert (i >= 0); 3672 cep = CONSTRUCTOR_ELT (*valp, i); 3673 gcc_assert (TREE_CODE (cep->index) != RANGE_EXPR); 3674 } 3675 else 3676 { 3677 gcc_assert (TREE_CODE (index) == FIELD_DECL); 3678 3679 /* We must keep the CONSTRUCTOR's ELTS in FIELD order. 3680 Usually we meet initializers in that order, but it is 3681 possible for base types to be placed not in program 3682 order. */ 3683 tree fields = TYPE_FIELDS (DECL_CONTEXT (index)); 3684 unsigned HOST_WIDE_INT idx; 3685 3686 if (code == UNION_TYPE && CONSTRUCTOR_NELTS (*valp) 3687 && CONSTRUCTOR_ELT (*valp, 0)->index != index) 3688 /* Changing active member. */ 3689 vec_safe_truncate (CONSTRUCTOR_ELTS (*valp), 0); 3690 3691 for (idx = 0; 3692 vec_safe_iterate (CONSTRUCTOR_ELTS (*valp), idx, &cep); 3693 idx++, fields = DECL_CHAIN (fields)) 3694 { 3695 if (index == cep->index) 3696 goto found; 3697 3698 /* The field we're initializing must be on the field 3699 list. Look to see if it is present before the 3700 field the current ELT initializes. */ 3701 for (; fields != cep->index; fields = DECL_CHAIN (fields)) 3702 if (index == fields) 3703 goto insert; 3704 } 3705 3706 /* We fell off the end of the CONSTRUCTOR, so insert a new 3707 entry at the end. */ 3708 insert: 3709 { 3710 constructor_elt ce = { index, NULL_TREE }; 3711 3712 vec_safe_insert (CONSTRUCTOR_ELTS (*valp), idx, ce); 3713 cep = CONSTRUCTOR_ELT (*valp, idx); 3714 } 3715 found:; 3716 } 3717 valp = &cep->value; 3718 } 3719 release_tree_vector (refs); 3720 3721 if (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type)) 3722 { 3723 /* Create a new CONSTRUCTOR in case evaluation of the initializer 3724 wants to modify it. */ 3725 if (*valp == NULL_TREE) 3726 { 3727 *valp = build_constructor (type, NULL); 3728 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) = no_zero_init; 3729 } 3730 else if (TREE_CODE (*valp) == PTRMEM_CST) 3731 *valp = cplus_expand_constant (*valp); 3732 new_ctx.ctor = *valp; 3733 new_ctx.object = target; 3734 } 3735 3736 init = cxx_eval_constant_expression (&new_ctx, init, false, 3737 non_constant_p, overflow_p); 3738 /* Don't share a CONSTRUCTOR that might be changed later. */ 3739 init = unshare_constructor (init); 3740 if (target == object) 3741 /* The hash table might have moved since the get earlier. */ 3742 valp = ctx->values->get (object); 3743 3744 if (TREE_CODE (init) == CONSTRUCTOR) 3745 { 3746 /* An outer ctx->ctor might be pointing to *valp, so replace 3747 its contents. */ 3748 CONSTRUCTOR_ELTS (*valp) = CONSTRUCTOR_ELTS (init); 3749 TREE_CONSTANT (*valp) = TREE_CONSTANT (init); 3750 TREE_SIDE_EFFECTS (*valp) = TREE_SIDE_EFFECTS (init); 3751 CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) 3752 = CONSTRUCTOR_NO_IMPLICIT_ZERO (init); 3753 } 3754 else 3755 *valp = init; 3756 3757 /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing 3758 CONSTRUCTORs, if any. */ 3759 tree elt; 3760 unsigned i; 3761 bool c = TREE_CONSTANT (init); 3762 bool s = TREE_SIDE_EFFECTS (init); 3763 if (!c || s) 3764 FOR_EACH_VEC_SAFE_ELT (ctors, i, elt) 3765 { 3766 if (!c) 3767 TREE_CONSTANT (elt) = false; 3768 if (s) 3769 TREE_SIDE_EFFECTS (elt) = true; 3770 } 3771 release_tree_vector (ctors); 3772 3773 if (*non_constant_p) 3774 return t; 3775 else if (lval) 3776 return target; 3777 else 3778 return init; 3779 } 3780 3781 /* Evaluate a ++ or -- expression. */ 3782 3783 static tree 3784 cxx_eval_increment_expression (const constexpr_ctx *ctx, tree t, 3785 bool lval, 3786 bool *non_constant_p, bool *overflow_p) 3787 { 3788 enum tree_code code = TREE_CODE (t); 3789 tree type = TREE_TYPE (t); 3790 tree op = TREE_OPERAND (t, 0); 3791 tree offset = TREE_OPERAND (t, 1); 3792 gcc_assert (TREE_CONSTANT (offset)); 3793 3794 /* The operand as an lvalue. */ 3795 op = cxx_eval_constant_expression (ctx, op, true, 3796 non_constant_p, overflow_p); 3797 3798 /* The operand as an rvalue. */ 3799 tree val 3800 = cxx_eval_constant_expression (ctx, op, false, 3801 non_constant_p, overflow_p); 3802 /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to 3803 a local array in a constexpr function. */ 3804 bool ptr = POINTER_TYPE_P (TREE_TYPE (val)); 3805 if (!ptr) 3806 VERIFY_CONSTANT (val); 3807 3808 /* The modified value. */ 3809 bool inc = (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR); 3810 tree mod; 3811 if (POINTER_TYPE_P (type)) 3812 { 3813 /* The middle end requires pointers to use POINTER_PLUS_EXPR. */ 3814 offset = convert_to_ptrofftype (offset); 3815 if (!inc) 3816 offset = fold_build1 (NEGATE_EXPR, TREE_TYPE (offset), offset); 3817 mod = fold_build2 (POINTER_PLUS_EXPR, type, val, offset); 3818 } 3819 else 3820 mod = fold_build2 (inc ? PLUS_EXPR : MINUS_EXPR, type, val, offset); 3821 if (!ptr) 3822 VERIFY_CONSTANT (mod); 3823 3824 /* Storing the modified value. */ 3825 tree store = build2 (MODIFY_EXPR, type, op, mod); 3826 cxx_eval_constant_expression (ctx, store, 3827 true, non_constant_p, overflow_p); 3828 3829 /* And the value of the expression. */ 3830 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR) 3831 { 3832 /* Prefix ops are lvalues. */ 3833 if (lval) 3834 return op; 3835 else 3836 /* But we optimize when the caller wants an rvalue. */ 3837 return mod; 3838 } 3839 else 3840 /* Postfix ops are rvalues. */ 3841 return val; 3842 } 3843 3844 /* Predicates for the meaning of *jump_target. */ 3845 3846 static bool 3847 returns (tree *jump_target) 3848 { 3849 return *jump_target 3850 && (TREE_CODE (*jump_target) == RETURN_EXPR 3851 || (TREE_CODE (*jump_target) == LABEL_DECL 3852 && LABEL_DECL_CDTOR (*jump_target))); 3853 } 3854 3855 static bool 3856 breaks (tree *jump_target) 3857 { 3858 return *jump_target 3859 && ((TREE_CODE (*jump_target) == LABEL_DECL 3860 && LABEL_DECL_BREAK (*jump_target)) 3861 || TREE_CODE (*jump_target) == EXIT_EXPR); 3862 } 3863 3864 static bool 3865 continues (tree *jump_target) 3866 { 3867 return *jump_target 3868 && TREE_CODE (*jump_target) == LABEL_DECL 3869 && LABEL_DECL_CONTINUE (*jump_target); 3870 } 3871 3872 static bool 3873 switches (tree *jump_target) 3874 { 3875 return *jump_target 3876 && TREE_CODE (*jump_target) == INTEGER_CST; 3877 } 3878 3879 /* Subroutine of cxx_eval_statement_list. Determine whether the statement 3880 STMT matches *jump_target. If we're looking for a case label and we see 3881 the default label, note it in ctx->css_state. */ 3882 3883 static bool 3884 label_matches (const constexpr_ctx *ctx, tree *jump_target, tree stmt) 3885 { 3886 switch (TREE_CODE (*jump_target)) 3887 { 3888 case LABEL_DECL: 3889 if (TREE_CODE (stmt) == LABEL_EXPR 3890 && LABEL_EXPR_LABEL (stmt) == *jump_target) 3891 return true; 3892 break; 3893 3894 case INTEGER_CST: 3895 if (TREE_CODE (stmt) == CASE_LABEL_EXPR) 3896 { 3897 gcc_assert (ctx->css_state != NULL); 3898 if (!CASE_LOW (stmt)) 3899 { 3900 /* default: should appear just once in a SWITCH_EXPR 3901 body (excluding nested SWITCH_EXPR). */ 3902 gcc_assert (*ctx->css_state != css_default_seen); 3903 /* When evaluating SWITCH_EXPR body for the second time, 3904 return true for the default: label. */ 3905 if (*ctx->css_state == css_default_processing) 3906 return true; 3907 *ctx->css_state = css_default_seen; 3908 } 3909 else if (CASE_HIGH (stmt)) 3910 { 3911 if (tree_int_cst_le (CASE_LOW (stmt), *jump_target) 3912 && tree_int_cst_le (*jump_target, CASE_HIGH (stmt))) 3913 return true; 3914 } 3915 else if (tree_int_cst_equal (*jump_target, CASE_LOW (stmt))) 3916 return true; 3917 } 3918 break; 3919 3920 default: 3921 gcc_unreachable (); 3922 } 3923 return false; 3924 } 3925 3926 /* Evaluate a STATEMENT_LIST for side-effects. Handles various jump 3927 semantics, for switch, break, continue, and return. */ 3928 3929 static tree 3930 cxx_eval_statement_list (const constexpr_ctx *ctx, tree t, 3931 bool *non_constant_p, bool *overflow_p, 3932 tree *jump_target) 3933 { 3934 tree_stmt_iterator i; 3935 tree local_target; 3936 /* In a statement-expression we want to return the last value. 3937 For empty statement expression return void_node. */ 3938 tree r = void_node; 3939 if (!jump_target) 3940 { 3941 local_target = NULL_TREE; 3942 jump_target = &local_target; 3943 } 3944 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i)) 3945 { 3946 tree stmt = tsi_stmt (i); 3947 /* We've found a continue, so skip everything until we reach 3948 the label its jumping to. */ 3949 if (continues (jump_target)) 3950 { 3951 if (label_matches (ctx, jump_target, stmt)) 3952 /* Found it. */ 3953 *jump_target = NULL_TREE; 3954 else 3955 continue; 3956 } 3957 if (TREE_CODE (stmt) == DEBUG_BEGIN_STMT) 3958 continue; 3959 r = cxx_eval_constant_expression (ctx, stmt, false, 3960 non_constant_p, overflow_p, 3961 jump_target); 3962 if (*non_constant_p) 3963 break; 3964 if (returns (jump_target) || breaks (jump_target)) 3965 break; 3966 } 3967 return r; 3968 } 3969 3970 /* Evaluate a LOOP_EXPR for side-effects. Handles break and return 3971 semantics; continue semantics are covered by cxx_eval_statement_list. */ 3972 3973 static tree 3974 cxx_eval_loop_expr (const constexpr_ctx *ctx, tree t, 3975 bool *non_constant_p, bool *overflow_p, 3976 tree *jump_target) 3977 { 3978 constexpr_ctx new_ctx = *ctx; 3979 3980 tree body = TREE_OPERAND (t, 0); 3981 int count = 0; 3982 do 3983 { 3984 hash_set<tree> save_exprs; 3985 new_ctx.save_exprs = &save_exprs; 3986 3987 cxx_eval_constant_expression (&new_ctx, body, /*lval*/false, 3988 non_constant_p, overflow_p, jump_target); 3989 3990 /* Forget saved values of SAVE_EXPRs. */ 3991 for (hash_set<tree>::iterator iter = save_exprs.begin(); 3992 iter != save_exprs.end(); ++iter) 3993 new_ctx.values->remove (*iter); 3994 if (++count >= constexpr_loop_limit) 3995 { 3996 if (!ctx->quiet) 3997 error_at (EXPR_LOC_OR_LOC (t, input_location), 3998 "%<constexpr%> loop iteration count exceeds limit of %d " 3999 "(use -fconstexpr-loop-limit= to increase the limit)", 4000 constexpr_loop_limit); 4001 *non_constant_p = true; 4002 break; 4003 } 4004 } 4005 while (!returns (jump_target) 4006 && !breaks (jump_target) 4007 && !switches (jump_target) 4008 && !*non_constant_p); 4009 4010 if (breaks (jump_target)) 4011 *jump_target = NULL_TREE; 4012 4013 return NULL_TREE; 4014 } 4015 4016 /* Evaluate a SWITCH_EXPR for side-effects. Handles switch and break jump 4017 semantics. */ 4018 4019 static tree 4020 cxx_eval_switch_expr (const constexpr_ctx *ctx, tree t, 4021 bool *non_constant_p, bool *overflow_p, 4022 tree *jump_target) 4023 { 4024 tree cond = SWITCH_COND (t); 4025 cond = cxx_eval_constant_expression (ctx, cond, false, 4026 non_constant_p, overflow_p); 4027 VERIFY_CONSTANT (cond); 4028 *jump_target = cond; 4029 4030 tree body = SWITCH_BODY (t); 4031 constexpr_ctx new_ctx = *ctx; 4032 constexpr_switch_state css = css_default_not_seen; 4033 new_ctx.css_state = &css; 4034 cxx_eval_constant_expression (&new_ctx, body, false, 4035 non_constant_p, overflow_p, jump_target); 4036 if (switches (jump_target) && css == css_default_seen) 4037 { 4038 /* If the SWITCH_EXPR body has default: label, process it once again, 4039 this time instructing label_matches to return true for default: 4040 label on switches (jump_target). */ 4041 css = css_default_processing; 4042 cxx_eval_constant_expression (&new_ctx, body, false, 4043 non_constant_p, overflow_p, jump_target); 4044 } 4045 if (breaks (jump_target) || switches (jump_target)) 4046 *jump_target = NULL_TREE; 4047 return NULL_TREE; 4048 } 4049 4050 /* Find the object of TYPE under initialization in CTX. */ 4051 4052 static tree 4053 lookup_placeholder (const constexpr_ctx *ctx, bool lval, tree type) 4054 { 4055 if (!ctx) 4056 return NULL_TREE; 4057 4058 /* We could use ctx->object unconditionally, but using ctx->ctor when we 4059 can is a minor optimization. */ 4060 if (!lval && ctx->ctor && same_type_p (TREE_TYPE (ctx->ctor), type)) 4061 return ctx->ctor; 4062 4063 if (!ctx->object) 4064 return NULL_TREE; 4065 4066 /* Since an object cannot have a field of its own type, we can search outward 4067 from ctx->object to find the unique containing object of TYPE. */ 4068 tree ob = ctx->object; 4069 while (ob) 4070 { 4071 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (ob), type)) 4072 break; 4073 if (handled_component_p (ob)) 4074 ob = TREE_OPERAND (ob, 0); 4075 else 4076 ob = NULL_TREE; 4077 } 4078 4079 return ob; 4080 } 4081 4082 /* Attempt to reduce the expression T to a constant value. 4083 On failure, issue diagnostic and return error_mark_node. */ 4084 /* FIXME unify with c_fully_fold */ 4085 /* FIXME overflow_p is too global */ 4086 4087 static tree 4088 cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t, 4089 bool lval, 4090 bool *non_constant_p, bool *overflow_p, 4091 tree *jump_target) 4092 { 4093 constexpr_ctx new_ctx; 4094 tree r = t; 4095 4096 if (jump_target && *jump_target) 4097 { 4098 /* If we are jumping, ignore all statements/expressions except those 4099 that could have LABEL_EXPR or CASE_LABEL_EXPR in their bodies. */ 4100 switch (TREE_CODE (t)) 4101 { 4102 case BIND_EXPR: 4103 case STATEMENT_LIST: 4104 case LOOP_EXPR: 4105 case COND_EXPR: 4106 break; 4107 case LABEL_EXPR: 4108 case CASE_LABEL_EXPR: 4109 if (label_matches (ctx, jump_target, t)) 4110 /* Found it. */ 4111 *jump_target = NULL_TREE; 4112 return NULL_TREE; 4113 default: 4114 return NULL_TREE; 4115 } 4116 } 4117 if (t == error_mark_node) 4118 { 4119 *non_constant_p = true; 4120 return t; 4121 } 4122 if (CONSTANT_CLASS_P (t)) 4123 { 4124 if (TREE_OVERFLOW (t)) 4125 { 4126 if (!ctx->quiet) 4127 permerror (input_location, "overflow in constant expression"); 4128 if (!flag_permissive || ctx->quiet) 4129 *overflow_p = true; 4130 } 4131 4132 if (TREE_CODE (t) == INTEGER_CST 4133 && TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE 4134 && !integer_zerop (t)) 4135 { 4136 if (!ctx->quiet) 4137 error ("value %qE of type %qT is not a constant expression", 4138 t, TREE_TYPE (t)); 4139 *non_constant_p = true; 4140 } 4141 4142 return t; 4143 } 4144 4145 tree_code tcode = TREE_CODE (t); 4146 switch (tcode) 4147 { 4148 case RESULT_DECL: 4149 if (lval) 4150 return t; 4151 /* We ask for an rvalue for the RESULT_DECL when indirecting 4152 through an invisible reference, or in named return value 4153 optimization. */ 4154 if (tree *p = ctx->values->get (t)) 4155 return *p; 4156 else 4157 { 4158 if (!ctx->quiet) 4159 error ("%qE is not a constant expression", t); 4160 *non_constant_p = true; 4161 } 4162 break; 4163 4164 case VAR_DECL: 4165 if (DECL_HAS_VALUE_EXPR_P (t)) 4166 { 4167 if (is_normal_capture_proxy (t) 4168 && current_function_decl == DECL_CONTEXT (t)) 4169 { 4170 /* Function parms aren't constexpr within the function 4171 definition, so don't try to look at the closure. But if the 4172 captured variable is constant, try to evaluate it directly. */ 4173 r = DECL_CAPTURED_VARIABLE (t); 4174 tree type = TREE_TYPE (t); 4175 if (TYPE_REF_P (type) != TYPE_REF_P (TREE_TYPE (r))) 4176 { 4177 /* Adjust r to match the reference-ness of t. */ 4178 if (TYPE_REF_P (type)) 4179 r = build_address (r); 4180 else 4181 r = convert_from_reference (r); 4182 } 4183 } 4184 else 4185 r = DECL_VALUE_EXPR (t); 4186 return cxx_eval_constant_expression (ctx, r, lval, non_constant_p, 4187 overflow_p); 4188 } 4189 /* fall through */ 4190 case CONST_DECL: 4191 /* We used to not check lval for CONST_DECL, but darwin.c uses 4192 CONST_DECL for aggregate constants. */ 4193 if (lval) 4194 return t; 4195 if (COMPLETE_TYPE_P (TREE_TYPE (t)) 4196 && is_really_empty_class (TREE_TYPE (t))) 4197 { 4198 /* If the class is empty, we aren't actually loading anything. */ 4199 r = build_constructor (TREE_TYPE (t), NULL); 4200 TREE_CONSTANT (r) = true; 4201 } 4202 else if (ctx->strict) 4203 r = decl_really_constant_value (t); 4204 else 4205 r = decl_constant_value (t); 4206 if (TREE_CODE (r) == TARGET_EXPR 4207 && TREE_CODE (TARGET_EXPR_INITIAL (r)) == CONSTRUCTOR) 4208 r = TARGET_EXPR_INITIAL (r); 4209 if (VAR_P (r)) 4210 if (tree *p = ctx->values->get (r)) 4211 if (*p != NULL_TREE) 4212 r = *p; 4213 if (DECL_P (r)) 4214 { 4215 if (!ctx->quiet) 4216 non_const_var_error (r); 4217 *non_constant_p = true; 4218 } 4219 break; 4220 4221 case DEBUG_BEGIN_STMT: 4222 /* ??? It might be nice to retain this information somehow, so 4223 as to be able to step into a constexpr function call. */ 4224 /* Fall through. */ 4225 4226 case FUNCTION_DECL: 4227 case TEMPLATE_DECL: 4228 case LABEL_DECL: 4229 case LABEL_EXPR: 4230 case CASE_LABEL_EXPR: 4231 case PREDICT_EXPR: 4232 return t; 4233 4234 case PARM_DECL: 4235 if (lval && TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE) 4236 /* glvalue use. */; 4237 else if (tree *p = ctx->values->get (r)) 4238 r = *p; 4239 else if (lval) 4240 /* Defer in case this is only used for its type. */; 4241 else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE) 4242 /* Defer, there's no lvalue->rvalue conversion. */; 4243 else if (COMPLETE_TYPE_P (TREE_TYPE (t)) 4244 && is_really_empty_class (TREE_TYPE (t))) 4245 { 4246 /* If the class is empty, we aren't actually loading anything. */ 4247 r = build_constructor (TREE_TYPE (t), NULL); 4248 TREE_CONSTANT (r) = true; 4249 } 4250 else 4251 { 4252 if (!ctx->quiet) 4253 error ("%qE is not a constant expression", t); 4254 *non_constant_p = true; 4255 } 4256 break; 4257 4258 case CALL_EXPR: 4259 case AGGR_INIT_EXPR: 4260 r = cxx_eval_call_expression (ctx, t, lval, 4261 non_constant_p, overflow_p); 4262 break; 4263 4264 case DECL_EXPR: 4265 { 4266 r = DECL_EXPR_DECL (t); 4267 if (AGGREGATE_TYPE_P (TREE_TYPE (r)) 4268 || VECTOR_TYPE_P (TREE_TYPE (r))) 4269 { 4270 new_ctx = *ctx; 4271 new_ctx.object = r; 4272 new_ctx.ctor = build_constructor (TREE_TYPE (r), NULL); 4273 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true; 4274 new_ctx.values->put (r, new_ctx.ctor); 4275 ctx = &new_ctx; 4276 } 4277 4278 if (tree init = DECL_INITIAL (r)) 4279 { 4280 init = cxx_eval_constant_expression (ctx, init, 4281 false, 4282 non_constant_p, overflow_p); 4283 /* Don't share a CONSTRUCTOR that might be changed. */ 4284 init = unshare_constructor (init); 4285 ctx->values->put (r, init); 4286 } 4287 else if (ctx == &new_ctx) 4288 /* We gave it a CONSTRUCTOR above. */; 4289 else 4290 ctx->values->put (r, NULL_TREE); 4291 } 4292 break; 4293 4294 case TARGET_EXPR: 4295 if (!literal_type_p (TREE_TYPE (t))) 4296 { 4297 if (!ctx->quiet) 4298 { 4299 error ("temporary of non-literal type %qT in a " 4300 "constant expression", TREE_TYPE (t)); 4301 explain_non_literal_class (TREE_TYPE (t)); 4302 } 4303 *non_constant_p = true; 4304 break; 4305 } 4306 if ((AGGREGATE_TYPE_P (TREE_TYPE (t)) || VECTOR_TYPE_P (TREE_TYPE (t)))) 4307 { 4308 /* We're being expanded without an explicit target, so start 4309 initializing a new object; expansion with an explicit target 4310 strips the TARGET_EXPR before we get here. */ 4311 new_ctx = *ctx; 4312 new_ctx.ctor = build_constructor (TREE_TYPE (t), NULL); 4313 CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true; 4314 new_ctx.object = TARGET_EXPR_SLOT (t); 4315 ctx->values->put (new_ctx.object, new_ctx.ctor); 4316 ctx = &new_ctx; 4317 } 4318 /* Pass false for 'lval' because this indicates 4319 initialization of a temporary. */ 4320 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1), 4321 false, 4322 non_constant_p, overflow_p); 4323 if (!*non_constant_p) 4324 /* Adjust the type of the result to the type of the temporary. */ 4325 r = adjust_temp_type (TREE_TYPE (t), r); 4326 if (lval) 4327 { 4328 tree slot = TARGET_EXPR_SLOT (t); 4329 r = unshare_constructor (r); 4330 ctx->values->put (slot, r); 4331 return slot; 4332 } 4333 break; 4334 4335 case INIT_EXPR: 4336 case MODIFY_EXPR: 4337 gcc_assert (jump_target == NULL || *jump_target == NULL_TREE); 4338 r = cxx_eval_store_expression (ctx, t, lval, 4339 non_constant_p, overflow_p); 4340 break; 4341 4342 case SCOPE_REF: 4343 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1), 4344 lval, 4345 non_constant_p, overflow_p); 4346 break; 4347 4348 case RETURN_EXPR: 4349 if (TREE_OPERAND (t, 0) != NULL_TREE) 4350 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), 4351 lval, 4352 non_constant_p, overflow_p); 4353 if (jump_target) 4354 *jump_target = t; 4355 else 4356 { 4357 /* Can happen with ({ return true; }) && false; passed to 4358 maybe_constant_value. There is nothing to jump over in this 4359 case, and the bug will be diagnosed later. */ 4360 gcc_assert (ctx->quiet); 4361 *non_constant_p = true; 4362 } 4363 break; 4364 4365 case SAVE_EXPR: 4366 /* Avoid evaluating a SAVE_EXPR more than once. */ 4367 if (tree *p = ctx->values->get (t)) 4368 r = *p; 4369 else 4370 { 4371 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), false, 4372 non_constant_p, overflow_p); 4373 ctx->values->put (t, r); 4374 if (ctx->save_exprs) 4375 ctx->save_exprs->add (t); 4376 } 4377 break; 4378 4379 case NON_LVALUE_EXPR: 4380 case TRY_CATCH_EXPR: 4381 case TRY_BLOCK: 4382 case CLEANUP_POINT_EXPR: 4383 case MUST_NOT_THROW_EXPR: 4384 case EXPR_STMT: 4385 case EH_SPEC_BLOCK: 4386 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), 4387 lval, 4388 non_constant_p, overflow_p, 4389 jump_target); 4390 break; 4391 4392 case TRY_FINALLY_EXPR: 4393 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), lval, 4394 non_constant_p, overflow_p, 4395 jump_target); 4396 if (!*non_constant_p) 4397 /* Also evaluate the cleanup. */ 4398 cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1), true, 4399 non_constant_p, overflow_p, 4400 jump_target); 4401 break; 4402 4403 /* These differ from cxx_eval_unary_expression in that this doesn't 4404 check for a constant operand or result; an address can be 4405 constant without its operand being, and vice versa. */ 4406 case MEM_REF: 4407 case INDIRECT_REF: 4408 r = cxx_eval_indirect_ref (ctx, t, lval, 4409 non_constant_p, overflow_p); 4410 break; 4411 4412 case ADDR_EXPR: 4413 { 4414 tree oldop = TREE_OPERAND (t, 0); 4415 tree op = cxx_eval_constant_expression (ctx, oldop, 4416 /*lval*/true, 4417 non_constant_p, overflow_p); 4418 /* Don't VERIFY_CONSTANT here. */ 4419 if (*non_constant_p) 4420 return t; 4421 gcc_checking_assert (TREE_CODE (op) != CONSTRUCTOR); 4422 /* This function does more aggressive folding than fold itself. */ 4423 r = build_fold_addr_expr_with_type (op, TREE_TYPE (t)); 4424 if (TREE_CODE (r) == ADDR_EXPR && TREE_OPERAND (r, 0) == oldop) 4425 return t; 4426 break; 4427 } 4428 4429 case REALPART_EXPR: 4430 case IMAGPART_EXPR: 4431 if (lval) 4432 { 4433 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), lval, 4434 non_constant_p, overflow_p); 4435 if (r == error_mark_node) 4436 ; 4437 else if (r == TREE_OPERAND (t, 0)) 4438 r = t; 4439 else 4440 r = fold_build1 (TREE_CODE (t), TREE_TYPE (t), r); 4441 break; 4442 } 4443 /* FALLTHRU */ 4444 case CONJ_EXPR: 4445 case FIX_TRUNC_EXPR: 4446 case FLOAT_EXPR: 4447 case NEGATE_EXPR: 4448 case ABS_EXPR: 4449 case BIT_NOT_EXPR: 4450 case TRUTH_NOT_EXPR: 4451 case FIXED_CONVERT_EXPR: 4452 r = cxx_eval_unary_expression (ctx, t, lval, 4453 non_constant_p, overflow_p); 4454 break; 4455 4456 case SIZEOF_EXPR: 4457 r = fold_sizeof_expr (t); 4458 VERIFY_CONSTANT (r); 4459 break; 4460 4461 case COMPOUND_EXPR: 4462 { 4463 /* check_return_expr sometimes wraps a TARGET_EXPR in a 4464 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR 4465 introduced by build_call_a. */ 4466 tree op0 = TREE_OPERAND (t, 0); 4467 tree op1 = TREE_OPERAND (t, 1); 4468 STRIP_NOPS (op1); 4469 if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0)) 4470 || TREE_CODE (op1) == EMPTY_CLASS_EXPR) 4471 r = cxx_eval_constant_expression (ctx, op0, 4472 lval, non_constant_p, overflow_p, 4473 jump_target); 4474 else 4475 { 4476 /* Check that the LHS is constant and then discard it. */ 4477 cxx_eval_constant_expression (ctx, op0, 4478 true, non_constant_p, overflow_p, 4479 jump_target); 4480 if (*non_constant_p) 4481 return t; 4482 op1 = TREE_OPERAND (t, 1); 4483 r = cxx_eval_constant_expression (ctx, op1, 4484 lval, non_constant_p, overflow_p, 4485 jump_target); 4486 } 4487 } 4488 break; 4489 4490 case POINTER_PLUS_EXPR: 4491 case POINTER_DIFF_EXPR: 4492 case PLUS_EXPR: 4493 case MINUS_EXPR: 4494 case MULT_EXPR: 4495 case TRUNC_DIV_EXPR: 4496 case CEIL_DIV_EXPR: 4497 case FLOOR_DIV_EXPR: 4498 case ROUND_DIV_EXPR: 4499 case TRUNC_MOD_EXPR: 4500 case CEIL_MOD_EXPR: 4501 case ROUND_MOD_EXPR: 4502 case RDIV_EXPR: 4503 case EXACT_DIV_EXPR: 4504 case MIN_EXPR: 4505 case MAX_EXPR: 4506 case LSHIFT_EXPR: 4507 case RSHIFT_EXPR: 4508 case LROTATE_EXPR: 4509 case RROTATE_EXPR: 4510 case BIT_IOR_EXPR: 4511 case BIT_XOR_EXPR: 4512 case BIT_AND_EXPR: 4513 case TRUTH_XOR_EXPR: 4514 case LT_EXPR: 4515 case LE_EXPR: 4516 case GT_EXPR: 4517 case GE_EXPR: 4518 case EQ_EXPR: 4519 case NE_EXPR: 4520 case UNORDERED_EXPR: 4521 case ORDERED_EXPR: 4522 case UNLT_EXPR: 4523 case UNLE_EXPR: 4524 case UNGT_EXPR: 4525 case UNGE_EXPR: 4526 case UNEQ_EXPR: 4527 case LTGT_EXPR: 4528 case RANGE_EXPR: 4529 case COMPLEX_EXPR: 4530 r = cxx_eval_binary_expression (ctx, t, lval, 4531 non_constant_p, overflow_p); 4532 break; 4533 4534 /* fold can introduce non-IF versions of these; still treat them as 4535 short-circuiting. */ 4536 case TRUTH_AND_EXPR: 4537 case TRUTH_ANDIF_EXPR: 4538 r = cxx_eval_logical_expression (ctx, t, boolean_false_node, 4539 boolean_true_node, 4540 lval, 4541 non_constant_p, overflow_p); 4542 break; 4543 4544 case TRUTH_OR_EXPR: 4545 case TRUTH_ORIF_EXPR: 4546 r = cxx_eval_logical_expression (ctx, t, boolean_true_node, 4547 boolean_false_node, 4548 lval, 4549 non_constant_p, overflow_p); 4550 break; 4551 4552 case ARRAY_REF: 4553 r = cxx_eval_array_reference (ctx, t, lval, 4554 non_constant_p, overflow_p); 4555 break; 4556 4557 case COMPONENT_REF: 4558 if (is_overloaded_fn (t)) 4559 { 4560 /* We can only get here in checking mode via 4561 build_non_dependent_expr, because any expression that 4562 calls or takes the address of the function will have 4563 pulled a FUNCTION_DECL out of the COMPONENT_REF. */ 4564 gcc_checking_assert (ctx->quiet || errorcount); 4565 *non_constant_p = true; 4566 return t; 4567 } 4568 r = cxx_eval_component_reference (ctx, t, lval, 4569 non_constant_p, overflow_p); 4570 break; 4571 4572 case BIT_FIELD_REF: 4573 r = cxx_eval_bit_field_ref (ctx, t, lval, 4574 non_constant_p, overflow_p); 4575 break; 4576 4577 case COND_EXPR: 4578 if (jump_target && *jump_target) 4579 { 4580 tree orig_jump = *jump_target; 4581 /* When jumping to a label, the label might be either in the 4582 then or else blocks, so process then block first in skipping 4583 mode first, and if we are still in the skipping mode at its end, 4584 process the else block too. */ 4585 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1), 4586 lval, non_constant_p, overflow_p, 4587 jump_target); 4588 /* It's possible that we found the label in the then block. But 4589 it could have been followed by another jumping statement, e.g. 4590 say we're looking for case 1: 4591 if (cond) 4592 { 4593 // skipped statements 4594 case 1:; // clears up *jump_target 4595 return 1; // and sets it to a RETURN_EXPR 4596 } 4597 else { ... } 4598 in which case we need not go looking to the else block. 4599 (goto is not allowed in a constexpr function.) */ 4600 if (*jump_target == orig_jump) 4601 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2), 4602 lval, non_constant_p, overflow_p, 4603 jump_target); 4604 break; 4605 } 4606 r = cxx_eval_conditional_expression (ctx, t, lval, 4607 non_constant_p, overflow_p, 4608 jump_target); 4609 break; 4610 case VEC_COND_EXPR: 4611 r = cxx_eval_vector_conditional_expression (ctx, t, non_constant_p, 4612 overflow_p); 4613 break; 4614 4615 case CONSTRUCTOR: 4616 if (TREE_CONSTANT (t) && reduced_constant_expression_p (t)) 4617 { 4618 /* Don't re-process a constant CONSTRUCTOR, but do fold it to 4619 VECTOR_CST if applicable. */ 4620 verify_constructor_flags (t); 4621 if (TREE_CONSTANT (t)) 4622 return fold (t); 4623 } 4624 r = cxx_eval_bare_aggregate (ctx, t, lval, 4625 non_constant_p, overflow_p); 4626 break; 4627 4628 case VEC_INIT_EXPR: 4629 /* We can get this in a defaulted constructor for a class with a 4630 non-static data member of array type. Either the initializer will 4631 be NULL, meaning default-initialization, or it will be an lvalue 4632 or xvalue of the same type, meaning direct-initialization from the 4633 corresponding member. */ 4634 r = cxx_eval_vec_init (ctx, t, lval, 4635 non_constant_p, overflow_p); 4636 break; 4637 4638 case FMA_EXPR: 4639 case VEC_PERM_EXPR: 4640 r = cxx_eval_trinary_expression (ctx, t, lval, 4641 non_constant_p, overflow_p); 4642 break; 4643 4644 case NOP_EXPR: 4645 if (REINTERPRET_CAST_P (t)) 4646 { 4647 if (!ctx->quiet) 4648 error_at (EXPR_LOC_OR_LOC (t, input_location), 4649 "a reinterpret_cast is not a constant expression"); 4650 *non_constant_p = true; 4651 return t; 4652 } 4653 /* FALLTHROUGH. */ 4654 case CONVERT_EXPR: 4655 case VIEW_CONVERT_EXPR: 4656 case UNARY_PLUS_EXPR: 4657 { 4658 tree oldop = TREE_OPERAND (t, 0); 4659 4660 tree op = cxx_eval_constant_expression (ctx, oldop, 4661 lval, 4662 non_constant_p, overflow_p); 4663 if (*non_constant_p) 4664 return t; 4665 tree type = TREE_TYPE (t); 4666 if (TREE_CODE (op) == PTRMEM_CST 4667 && !TYPE_PTRMEM_P (type)) 4668 op = cplus_expand_constant (op); 4669 4670 if (TREE_CODE (op) == PTRMEM_CST && tcode == NOP_EXPR) 4671 { 4672 if (!same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (op)) 4673 && !can_convert_qual (type, op)) 4674 op = cplus_expand_constant (op); 4675 return cp_fold_convert (type, op); 4676 } 4677 4678 if (POINTER_TYPE_P (type) && TREE_CODE (op) == INTEGER_CST) 4679 { 4680 if (integer_zerop (op)) 4681 { 4682 if (TREE_CODE (type) == REFERENCE_TYPE) 4683 { 4684 if (!ctx->quiet) 4685 error_at (EXPR_LOC_OR_LOC (t, input_location), 4686 "dereferencing a null pointer"); 4687 *non_constant_p = true; 4688 return t; 4689 } 4690 else if (TREE_CODE (TREE_TYPE (op)) == POINTER_TYPE) 4691 { 4692 tree from = TREE_TYPE (op); 4693 4694 if (!can_convert (type, from, tf_none)) 4695 { 4696 if (!ctx->quiet) 4697 error_at (EXPR_LOC_OR_LOC (t, input_location), 4698 "conversion of %qT null pointer to %qT " 4699 "is not a constant expression", 4700 from, type); 4701 *non_constant_p = true; 4702 return t; 4703 } 4704 } 4705 } 4706 else 4707 { 4708 /* This detects for example: 4709 reinterpret_cast<void*>(sizeof 0) 4710 */ 4711 if (!ctx->quiet) 4712 error_at (EXPR_LOC_OR_LOC (t, input_location), 4713 "%<reinterpret_cast<%T>(%E)%> is not " 4714 "a constant expression", 4715 type, op); 4716 *non_constant_p = true; 4717 return t; 4718 } 4719 } 4720 4721 if (op == oldop && tcode != UNARY_PLUS_EXPR) 4722 /* We didn't fold at the top so we could check for ptr-int 4723 conversion. */ 4724 return fold (t); 4725 4726 if (tcode == UNARY_PLUS_EXPR) 4727 r = fold_convert (TREE_TYPE (t), op); 4728 else 4729 r = fold_build1 (tcode, type, op); 4730 4731 /* Conversion of an out-of-range value has implementation-defined 4732 behavior; the language considers it different from arithmetic 4733 overflow, which is undefined. */ 4734 if (TREE_OVERFLOW_P (r) && !TREE_OVERFLOW_P (op)) 4735 TREE_OVERFLOW (r) = false; 4736 } 4737 break; 4738 4739 case EMPTY_CLASS_EXPR: 4740 /* This is good enough for a function argument that might not get 4741 used, and they can't do anything with it, so just return it. */ 4742 return t; 4743 4744 case STATEMENT_LIST: 4745 new_ctx = *ctx; 4746 new_ctx.ctor = new_ctx.object = NULL_TREE; 4747 return cxx_eval_statement_list (&new_ctx, t, 4748 non_constant_p, overflow_p, jump_target); 4749 4750 case BIND_EXPR: 4751 return cxx_eval_constant_expression (ctx, BIND_EXPR_BODY (t), 4752 lval, 4753 non_constant_p, overflow_p, 4754 jump_target); 4755 4756 case PREINCREMENT_EXPR: 4757 case POSTINCREMENT_EXPR: 4758 case PREDECREMENT_EXPR: 4759 case POSTDECREMENT_EXPR: 4760 return cxx_eval_increment_expression (ctx, t, 4761 lval, non_constant_p, overflow_p); 4762 4763 case LAMBDA_EXPR: 4764 case NEW_EXPR: 4765 case VEC_NEW_EXPR: 4766 case DELETE_EXPR: 4767 case VEC_DELETE_EXPR: 4768 case THROW_EXPR: 4769 case MODOP_EXPR: 4770 /* GCC internal stuff. */ 4771 case VA_ARG_EXPR: 4772 case OBJ_TYPE_REF: 4773 case NON_DEPENDENT_EXPR: 4774 case BASELINK: 4775 case OFFSET_REF: 4776 if (!ctx->quiet) 4777 error_at (EXPR_LOC_OR_LOC (t, input_location), 4778 "expression %qE is not a constant expression", t); 4779 *non_constant_p = true; 4780 break; 4781 4782 case PLACEHOLDER_EXPR: 4783 /* Use of the value or address of the current object. */ 4784 if (tree ctor = lookup_placeholder (ctx, lval, TREE_TYPE (t))) 4785 return cxx_eval_constant_expression (ctx, ctor, lval, 4786 non_constant_p, overflow_p); 4787 /* A placeholder without a referent. We can get here when 4788 checking whether NSDMIs are noexcept, or in massage_init_elt; 4789 just say it's non-constant for now. */ 4790 gcc_assert (ctx->quiet); 4791 *non_constant_p = true; 4792 break; 4793 4794 case EXIT_EXPR: 4795 { 4796 tree cond = TREE_OPERAND (t, 0); 4797 cond = cxx_eval_constant_expression (ctx, cond, /*lval*/false, 4798 non_constant_p, overflow_p); 4799 VERIFY_CONSTANT (cond); 4800 if (integer_nonzerop (cond)) 4801 *jump_target = t; 4802 } 4803 break; 4804 4805 case GOTO_EXPR: 4806 *jump_target = TREE_OPERAND (t, 0); 4807 gcc_assert (breaks (jump_target) || continues (jump_target) 4808 /* Allow for jumping to a cdtor_label. */ 4809 || returns (jump_target)); 4810 break; 4811 4812 case LOOP_EXPR: 4813 cxx_eval_loop_expr (ctx, t, 4814 non_constant_p, overflow_p, jump_target); 4815 break; 4816 4817 case SWITCH_EXPR: 4818 cxx_eval_switch_expr (ctx, t, 4819 non_constant_p, overflow_p, jump_target); 4820 break; 4821 4822 case REQUIRES_EXPR: 4823 /* It's possible to get a requires-expression in a constant 4824 expression. For example: 4825 4826 template<typename T> concept bool C() { 4827 return requires (T t) { t; }; 4828 } 4829 4830 template<typename T> requires !C<T>() void f(T); 4831 4832 Normalization leaves f with the associated constraint 4833 '!requires (T t) { ... }' which is not transformed into 4834 a constraint. */ 4835 if (!processing_template_decl) 4836 return evaluate_constraint_expression (t, NULL_TREE); 4837 else 4838 *non_constant_p = true; 4839 return t; 4840 4841 case ANNOTATE_EXPR: 4842 r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), 4843 lval, 4844 non_constant_p, overflow_p, 4845 jump_target); 4846 break; 4847 4848 case USING_STMT: 4849 r = void_node; 4850 break; 4851 4852 default: 4853 if (STATEMENT_CODE_P (TREE_CODE (t))) 4854 { 4855 /* This function doesn't know how to deal with pre-genericize 4856 statements; this can only happen with statement-expressions, 4857 so for now just fail. */ 4858 if (!ctx->quiet) 4859 error_at (EXPR_LOCATION (t), 4860 "statement is not a constant expression"); 4861 } 4862 else 4863 internal_error ("unexpected expression %qE of kind %s", t, 4864 get_tree_code_name (TREE_CODE (t))); 4865 *non_constant_p = true; 4866 break; 4867 } 4868 4869 if (r == error_mark_node) 4870 *non_constant_p = true; 4871 4872 if (*non_constant_p) 4873 return t; 4874 else 4875 return r; 4876 } 4877 4878 static tree 4879 cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant, 4880 bool strict = true, tree object = NULL_TREE) 4881 { 4882 auto_timevar time (TV_CONSTEXPR); 4883 4884 bool non_constant_p = false; 4885 bool overflow_p = false; 4886 hash_map<tree,tree> map; 4887 4888 constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, NULL, 4889 allow_non_constant, strict }; 4890 4891 tree type = initialized_type (t); 4892 tree r = t; 4893 if (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type)) 4894 { 4895 /* In C++14 an NSDMI can participate in aggregate initialization, 4896 and can refer to the address of the object being initialized, so 4897 we need to pass in the relevant VAR_DECL if we want to do the 4898 evaluation in a single pass. The evaluation will dynamically 4899 update ctx.values for the VAR_DECL. We use the same strategy 4900 for C++11 constexpr constructors that refer to the object being 4901 initialized. */ 4902 ctx.ctor = build_constructor (type, NULL); 4903 CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx.ctor) = true; 4904 if (!object) 4905 { 4906 if (TREE_CODE (t) == TARGET_EXPR) 4907 object = TARGET_EXPR_SLOT (t); 4908 else if (TREE_CODE (t) == AGGR_INIT_EXPR) 4909 object = AGGR_INIT_EXPR_SLOT (t); 4910 } 4911 ctx.object = object; 4912 if (object) 4913 gcc_assert (same_type_ignoring_top_level_qualifiers_p 4914 (type, TREE_TYPE (object))); 4915 if (object && DECL_P (object)) 4916 map.put (object, ctx.ctor); 4917 if (TREE_CODE (r) == TARGET_EXPR) 4918 /* Avoid creating another CONSTRUCTOR when we expand the 4919 TARGET_EXPR. */ 4920 r = TARGET_EXPR_INITIAL (r); 4921 } 4922 4923 r = cxx_eval_constant_expression (&ctx, r, 4924 false, &non_constant_p, &overflow_p); 4925 4926 verify_constant (r, allow_non_constant, &non_constant_p, &overflow_p); 4927 4928 /* Mutable logic is a bit tricky: we want to allow initialization of 4929 constexpr variables with mutable members, but we can't copy those 4930 members to another constexpr variable. */ 4931 if (TREE_CODE (r) == CONSTRUCTOR 4932 && CONSTRUCTOR_MUTABLE_POISON (r)) 4933 { 4934 if (!allow_non_constant) 4935 error ("%qE is not a constant expression because it refers to " 4936 "mutable subobjects of %qT", t, type); 4937 non_constant_p = true; 4938 } 4939 4940 if (TREE_CODE (r) == CONSTRUCTOR 4941 && CONSTRUCTOR_NO_IMPLICIT_ZERO (r)) 4942 { 4943 if (!allow_non_constant) 4944 error ("%qE is not a constant expression because it refers to " 4945 "an incompletely initialized variable", t); 4946 TREE_CONSTANT (r) = false; 4947 non_constant_p = true; 4948 } 4949 4950 /* Technically we should check this for all subexpressions, but that 4951 runs into problems with our internal representation of pointer 4952 subtraction and the 5.19 rules are still in flux. */ 4953 if (CONVERT_EXPR_CODE_P (TREE_CODE (r)) 4954 && ARITHMETIC_TYPE_P (TREE_TYPE (r)) 4955 && TREE_CODE (TREE_OPERAND (r, 0)) == ADDR_EXPR) 4956 { 4957 if (!allow_non_constant) 4958 error ("conversion from pointer type %qT " 4959 "to arithmetic type %qT in a constant expression", 4960 TREE_TYPE (TREE_OPERAND (r, 0)), TREE_TYPE (r)); 4961 non_constant_p = true; 4962 } 4963 4964 if (!non_constant_p && overflow_p) 4965 non_constant_p = true; 4966 4967 /* Unshare the result unless it's a CONSTRUCTOR in which case it's already 4968 unshared. */ 4969 bool should_unshare = true; 4970 if (r == t || TREE_CODE (r) == CONSTRUCTOR) 4971 should_unshare = false; 4972 4973 if (non_constant_p && !allow_non_constant) 4974 return error_mark_node; 4975 else if (non_constant_p && TREE_CONSTANT (r)) 4976 { 4977 /* This isn't actually constant, so unset TREE_CONSTANT. 4978 Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires 4979 it to be set if it is invariant address, even when it is not 4980 a valid C++ constant expression. Wrap it with a NOP_EXPR 4981 instead. */ 4982 if (EXPR_P (r) && TREE_CODE (r) != ADDR_EXPR) 4983 r = copy_node (r); 4984 else if (TREE_CODE (r) == CONSTRUCTOR) 4985 r = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (r), r); 4986 else 4987 r = build_nop (TREE_TYPE (r), r); 4988 TREE_CONSTANT (r) = false; 4989 } 4990 else if (non_constant_p || r == t) 4991 return t; 4992 4993 if (should_unshare) 4994 r = unshare_expr (r); 4995 4996 if (TREE_CODE (r) == CONSTRUCTOR && CLASS_TYPE_P (TREE_TYPE (r))) 4997 { 4998 if (TREE_CODE (t) == TARGET_EXPR 4999 && TARGET_EXPR_INITIAL (t) == r) 5000 return t; 5001 else if (TREE_CODE (t) != CONSTRUCTOR) 5002 { 5003 r = get_target_expr (r); 5004 TREE_CONSTANT (r) = true; 5005 } 5006 } 5007 return r; 5008 } 5009 5010 /* Returns true if T is a valid subexpression of a constant expression, 5011 even if it isn't itself a constant expression. */ 5012 5013 bool 5014 is_sub_constant_expr (tree t) 5015 { 5016 bool non_constant_p = false; 5017 bool overflow_p = false; 5018 hash_map <tree, tree> map; 5019 5020 constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, NULL, true, true }; 5021 5022 cxx_eval_constant_expression (&ctx, t, false, &non_constant_p, 5023 &overflow_p); 5024 return !non_constant_p && !overflow_p; 5025 } 5026 5027 /* If T represents a constant expression returns its reduced value. 5028 Otherwise return error_mark_node. If T is dependent, then 5029 return NULL. */ 5030 5031 tree 5032 cxx_constant_value (tree t, tree decl) 5033 { 5034 return cxx_eval_outermost_constant_expr (t, false, true, decl); 5035 } 5036 5037 /* Helper routine for fold_simple function. Either return simplified 5038 expression T, otherwise NULL_TREE. 5039 In contrast to cp_fully_fold, and to maybe_constant_value, we try to fold 5040 even if we are within template-declaration. So be careful on call, as in 5041 such case types can be undefined. */ 5042 5043 static tree 5044 fold_simple_1 (tree t) 5045 { 5046 tree op1; 5047 enum tree_code code = TREE_CODE (t); 5048 5049 switch (code) 5050 { 5051 case INTEGER_CST: 5052 case REAL_CST: 5053 case VECTOR_CST: 5054 case FIXED_CST: 5055 case COMPLEX_CST: 5056 return t; 5057 5058 case SIZEOF_EXPR: 5059 return fold_sizeof_expr (t); 5060 5061 case ABS_EXPR: 5062 case CONJ_EXPR: 5063 case REALPART_EXPR: 5064 case IMAGPART_EXPR: 5065 case NEGATE_EXPR: 5066 case BIT_NOT_EXPR: 5067 case TRUTH_NOT_EXPR: 5068 case NOP_EXPR: 5069 case VIEW_CONVERT_EXPR: 5070 case CONVERT_EXPR: 5071 case FLOAT_EXPR: 5072 case FIX_TRUNC_EXPR: 5073 case FIXED_CONVERT_EXPR: 5074 case ADDR_SPACE_CONVERT_EXPR: 5075 5076 op1 = TREE_OPERAND (t, 0); 5077 5078 t = const_unop (code, TREE_TYPE (t), op1); 5079 if (!t) 5080 return NULL_TREE; 5081 5082 if (CONVERT_EXPR_CODE_P (code) 5083 && TREE_OVERFLOW_P (t) && !TREE_OVERFLOW_P (op1)) 5084 TREE_OVERFLOW (t) = false; 5085 return t; 5086 5087 default: 5088 return NULL_TREE; 5089 } 5090 } 5091 5092 /* If T is a simple constant expression, returns its simplified value. 5093 Otherwise returns T. In contrast to maybe_constant_value we 5094 simplify only few operations on constant-expressions, and we don't 5095 try to simplify constexpressions. */ 5096 5097 tree 5098 fold_simple (tree t) 5099 { 5100 if (processing_template_decl) 5101 return t; 5102 5103 tree r = fold_simple_1 (t); 5104 if (r) 5105 return r; 5106 5107 return t; 5108 } 5109 5110 /* If T is a constant expression, returns its reduced value. 5111 Otherwise, if T does not have TREE_CONSTANT set, returns T. 5112 Otherwise, returns a version of T without TREE_CONSTANT. */ 5113 5114 static GTY((deletable)) hash_map<tree, tree> *cv_cache; 5115 5116 tree 5117 maybe_constant_value (tree t, tree decl) 5118 { 5119 tree r; 5120 5121 if (!is_nondependent_constant_expression (t)) 5122 { 5123 if (TREE_OVERFLOW_P (t)) 5124 { 5125 t = build_nop (TREE_TYPE (t), t); 5126 TREE_CONSTANT (t) = false; 5127 } 5128 return t; 5129 } 5130 else if (CONSTANT_CLASS_P (t)) 5131 /* No caching or evaluation needed. */ 5132 return t; 5133 5134 if (cv_cache == NULL) 5135 cv_cache = hash_map<tree, tree>::create_ggc (101); 5136 if (tree *cached = cv_cache->get (t)) 5137 { 5138 r = *cached; 5139 if (r != t) 5140 { 5141 r = unshare_expr_without_location (r); 5142 protected_set_expr_location (r, EXPR_LOCATION (t)); 5143 } 5144 return r; 5145 } 5146 5147 r = cxx_eval_outermost_constant_expr (t, true, true, decl); 5148 gcc_checking_assert (r == t 5149 || CONVERT_EXPR_P (t) 5150 || TREE_CODE (t) == VIEW_CONVERT_EXPR 5151 || (TREE_CONSTANT (t) && !TREE_CONSTANT (r)) 5152 || !cp_tree_equal (r, t)); 5153 cv_cache->put (t, r); 5154 return r; 5155 } 5156 5157 /* Dispose of the whole CV_CACHE. */ 5158 5159 static void 5160 clear_cv_cache (void) 5161 { 5162 if (cv_cache != NULL) 5163 cv_cache->empty (); 5164 } 5165 5166 /* Dispose of the whole CV_CACHE and FOLD_CACHE. */ 5167 5168 void 5169 clear_cv_and_fold_caches (void) 5170 { 5171 clear_cv_cache (); 5172 clear_fold_cache (); 5173 } 5174 5175 /* Like maybe_constant_value but first fully instantiate the argument. 5176 5177 Note: this is equivalent to instantiate_non_dependent_expr_sfinae 5178 (t, complain) followed by maybe_constant_value but is more efficient, 5179 because calls instantiation_dependent_expression_p and 5180 potential_constant_expression at most once. */ 5181 5182 tree 5183 fold_non_dependent_expr (tree t, tsubst_flags_t complain /* = tf_none */) 5184 { 5185 if (t == NULL_TREE) 5186 return NULL_TREE; 5187 5188 /* If we're in a template, but T isn't value dependent, simplify 5189 it. We're supposed to treat: 5190 5191 template <typename T> void f(T[1 + 1]); 5192 template <typename T> void f(T[2]); 5193 5194 as two declarations of the same function, for example. */ 5195 if (processing_template_decl) 5196 { 5197 if (is_nondependent_constant_expression (t)) 5198 { 5199 processing_template_decl_sentinel s; 5200 t = instantiate_non_dependent_expr_internal (t, complain); 5201 5202 if (type_unknown_p (t) 5203 || BRACE_ENCLOSED_INITIALIZER_P (t)) 5204 { 5205 if (TREE_OVERFLOW_P (t)) 5206 { 5207 t = build_nop (TREE_TYPE (t), t); 5208 TREE_CONSTANT (t) = false; 5209 } 5210 return t; 5211 } 5212 5213 tree r = cxx_eval_outermost_constant_expr (t, true, true, NULL_TREE); 5214 /* cp_tree_equal looks through NOPs, so allow them. */ 5215 gcc_checking_assert (r == t 5216 || CONVERT_EXPR_P (t) 5217 || TREE_CODE (t) == VIEW_CONVERT_EXPR 5218 || (TREE_CONSTANT (t) && !TREE_CONSTANT (r)) 5219 || !cp_tree_equal (r, t)); 5220 return r; 5221 } 5222 else if (TREE_OVERFLOW_P (t)) 5223 { 5224 t = build_nop (TREE_TYPE (t), t); 5225 TREE_CONSTANT (t) = false; 5226 } 5227 return t; 5228 } 5229 5230 return maybe_constant_value (t); 5231 } 5232 5233 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather 5234 than wrapped in a TARGET_EXPR. */ 5235 5236 static tree 5237 maybe_constant_init_1 (tree t, tree decl, bool allow_non_constant) 5238 { 5239 if (!t) 5240 return t; 5241 if (TREE_CODE (t) == EXPR_STMT) 5242 t = TREE_OPERAND (t, 0); 5243 if (TREE_CODE (t) == CONVERT_EXPR 5244 && VOID_TYPE_P (TREE_TYPE (t))) 5245 t = TREE_OPERAND (t, 0); 5246 if (TREE_CODE (t) == INIT_EXPR) 5247 t = TREE_OPERAND (t, 1); 5248 if (TREE_CODE (t) == TARGET_EXPR) 5249 t = TARGET_EXPR_INITIAL (t); 5250 if (!is_nondependent_static_init_expression (t)) 5251 /* Don't try to evaluate it. */; 5252 else if (CONSTANT_CLASS_P (t) && allow_non_constant) 5253 /* No evaluation needed. */; 5254 else 5255 t = cxx_eval_outermost_constant_expr (t, allow_non_constant, false, decl); 5256 if (TREE_CODE (t) == TARGET_EXPR) 5257 { 5258 tree init = TARGET_EXPR_INITIAL (t); 5259 if (TREE_CODE (init) == CONSTRUCTOR) 5260 t = init; 5261 } 5262 return t; 5263 } 5264 5265 /* Wrapper for maybe_constant_init_1 which permits non constants. */ 5266 5267 tree 5268 maybe_constant_init (tree t, tree decl) 5269 { 5270 return maybe_constant_init_1 (t, decl, true); 5271 } 5272 5273 /* Wrapper for maybe_constant_init_1 which does not permit non constants. */ 5274 5275 tree 5276 cxx_constant_init (tree t, tree decl) 5277 { 5278 return maybe_constant_init_1 (t, decl, false); 5279 } 5280 5281 #if 0 5282 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */ 5283 /* Return true if the object referred to by REF has automatic or thread 5284 local storage. */ 5285 5286 enum { ck_ok, ck_bad, ck_unknown }; 5287 static int 5288 check_automatic_or_tls (tree ref) 5289 { 5290 machine_mode mode; 5291 poly_int64 bitsize, bitpos; 5292 tree offset; 5293 int volatilep = 0, unsignedp = 0; 5294 tree decl = get_inner_reference (ref, &bitsize, &bitpos, &offset, 5295 &mode, &unsignedp, &volatilep, false); 5296 duration_kind dk; 5297 5298 /* If there isn't a decl in the middle, we don't know the linkage here, 5299 and this isn't a constant expression anyway. */ 5300 if (!DECL_P (decl)) 5301 return ck_unknown; 5302 dk = decl_storage_duration (decl); 5303 return (dk == dk_auto || dk == dk_thread) ? ck_bad : ck_ok; 5304 } 5305 #endif 5306 5307 /* Return true if T denotes a potentially constant expression. Issue 5308 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true, 5309 an lvalue-rvalue conversion is implied. If NOW is true, we want to 5310 consider the expression in the current context, independent of constexpr 5311 substitution. 5312 5313 C++0x [expr.const] used to say 5314 5315 6 An expression is a potential constant expression if it is 5316 a constant expression where all occurrences of function 5317 parameters are replaced by arbitrary constant expressions 5318 of the appropriate type. 5319 5320 2 A conditional expression is a constant expression unless it 5321 involves one of the following as a potentially evaluated 5322 subexpression (3.2), but subexpressions of logical AND (5.14), 5323 logical OR (5.15), and conditional (5.16) operations that are 5324 not evaluated are not considered. */ 5325 5326 static bool 5327 potential_constant_expression_1 (tree t, bool want_rval, bool strict, bool now, 5328 tsubst_flags_t flags) 5329 { 5330 #define RECUR(T,RV) \ 5331 potential_constant_expression_1 ((T), (RV), strict, now, flags) 5332 5333 enum { any = false, rval = true }; 5334 int i; 5335 tree tmp; 5336 5337 if (t == error_mark_node) 5338 return false; 5339 if (t == NULL_TREE) 5340 return true; 5341 location_t loc = EXPR_LOC_OR_LOC (t, input_location); 5342 if (TREE_THIS_VOLATILE (t) && !DECL_P (t)) 5343 { 5344 if (flags & tf_error) 5345 error_at (loc, "expression %qE has side-effects", t); 5346 return false; 5347 } 5348 if (CONSTANT_CLASS_P (t)) 5349 return true; 5350 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPED) 5351 && TREE_TYPE (t) == error_mark_node) 5352 return false; 5353 5354 switch (TREE_CODE (t)) 5355 { 5356 case FUNCTION_DECL: 5357 case BASELINK: 5358 case TEMPLATE_DECL: 5359 case OVERLOAD: 5360 case TEMPLATE_ID_EXPR: 5361 case LABEL_DECL: 5362 case LABEL_EXPR: 5363 case CASE_LABEL_EXPR: 5364 case CONST_DECL: 5365 case SIZEOF_EXPR: 5366 case ALIGNOF_EXPR: 5367 case OFFSETOF_EXPR: 5368 case NOEXCEPT_EXPR: 5369 case TEMPLATE_PARM_INDEX: 5370 case TRAIT_EXPR: 5371 case IDENTIFIER_NODE: 5372 case USERDEF_LITERAL: 5373 /* We can see a FIELD_DECL in a pointer-to-member expression. */ 5374 case FIELD_DECL: 5375 case RESULT_DECL: 5376 case USING_DECL: 5377 case USING_STMT: 5378 case PLACEHOLDER_EXPR: 5379 case BREAK_STMT: 5380 case CONTINUE_STMT: 5381 case REQUIRES_EXPR: 5382 case STATIC_ASSERT: 5383 case DEBUG_BEGIN_STMT: 5384 return true; 5385 5386 case PARM_DECL: 5387 if (now) 5388 { 5389 if (flags & tf_error) 5390 error ("%qE is not a constant expression", t); 5391 return false; 5392 } 5393 return true; 5394 5395 case AGGR_INIT_EXPR: 5396 case CALL_EXPR: 5397 /* -- an invocation of a function other than a constexpr function 5398 or a constexpr constructor. */ 5399 { 5400 tree fun = get_function_named_in_call (t); 5401 const int nargs = call_expr_nargs (t); 5402 i = 0; 5403 5404 if (fun == NULL_TREE) 5405 { 5406 /* Reset to allow the function to continue past the end 5407 of the block below. Otherwise return early. */ 5408 bool bail = true; 5409 5410 if (TREE_CODE (t) == CALL_EXPR 5411 && CALL_EXPR_FN (t) == NULL_TREE) 5412 switch (CALL_EXPR_IFN (t)) 5413 { 5414 /* These should be ignored, they are optimized away from 5415 constexpr functions. */ 5416 case IFN_UBSAN_NULL: 5417 case IFN_UBSAN_BOUNDS: 5418 case IFN_UBSAN_VPTR: 5419 case IFN_FALLTHROUGH: 5420 return true; 5421 5422 case IFN_ADD_OVERFLOW: 5423 case IFN_SUB_OVERFLOW: 5424 case IFN_MUL_OVERFLOW: 5425 case IFN_LAUNDER: 5426 bail = false; 5427 5428 default: 5429 break; 5430 } 5431 5432 if (bail) 5433 { 5434 /* fold_call_expr can't do anything with IFN calls. */ 5435 if (flags & tf_error) 5436 error_at (loc, "call to internal function %qE", t); 5437 return false; 5438 } 5439 } 5440 5441 if (fun && is_overloaded_fn (fun)) 5442 { 5443 if (TREE_CODE (fun) == FUNCTION_DECL) 5444 { 5445 if (builtin_valid_in_constant_expr_p (fun)) 5446 return true; 5447 if (!DECL_DECLARED_CONSTEXPR_P (fun) 5448 /* Allow any built-in function; if the expansion 5449 isn't constant, we'll deal with that then. */ 5450 && !is_builtin_fn (fun)) 5451 { 5452 if (flags & tf_error) 5453 { 5454 error_at (loc, "call to non-%<constexpr%> function %qD", 5455 fun); 5456 explain_invalid_constexpr_fn (fun); 5457 } 5458 return false; 5459 } 5460 /* A call to a non-static member function takes the address 5461 of the object as the first argument. But in a constant 5462 expression the address will be folded away, so look 5463 through it now. */ 5464 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun) 5465 && !DECL_CONSTRUCTOR_P (fun)) 5466 { 5467 tree x = get_nth_callarg (t, 0); 5468 if (is_this_parameter (x)) 5469 return true; 5470 /* Don't require an immediately constant value, as 5471 constexpr substitution might not use the value. */ 5472 bool sub_now = false; 5473 if (!potential_constant_expression_1 (x, rval, strict, 5474 sub_now, flags)) 5475 return false; 5476 i = 1; 5477 } 5478 } 5479 else 5480 { 5481 if (!RECUR (fun, true)) 5482 return false; 5483 fun = get_first_fn (fun); 5484 } 5485 /* Skip initial arguments to base constructors. */ 5486 if (DECL_BASE_CONSTRUCTOR_P (fun)) 5487 i = num_artificial_parms_for (fun); 5488 fun = DECL_ORIGIN (fun); 5489 } 5490 else if (fun) 5491 { 5492 if (RECUR (fun, rval)) 5493 /* Might end up being a constant function pointer. */; 5494 else 5495 return false; 5496 } 5497 for (; i < nargs; ++i) 5498 { 5499 tree x = get_nth_callarg (t, i); 5500 /* In a template, reference arguments haven't been converted to 5501 REFERENCE_TYPE and we might not even know if the parameter 5502 is a reference, so accept lvalue constants too. */ 5503 bool rv = processing_template_decl ? any : rval; 5504 /* Don't require an immediately constant value, as constexpr 5505 substitution might not use the value of the argument. */ 5506 bool sub_now = false; 5507 if (!potential_constant_expression_1 (x, rv, strict, 5508 sub_now, flags)) 5509 return false; 5510 } 5511 return true; 5512 } 5513 5514 case NON_LVALUE_EXPR: 5515 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to 5516 -- an lvalue of integral type that refers to a non-volatile 5517 const variable or static data member initialized with 5518 constant expressions, or 5519 5520 -- an lvalue of literal type that refers to non-volatile 5521 object defined with constexpr, or that refers to a 5522 sub-object of such an object; */ 5523 return RECUR (TREE_OPERAND (t, 0), rval); 5524 5525 case VAR_DECL: 5526 if (DECL_HAS_VALUE_EXPR_P (t)) 5527 { 5528 if (now && is_normal_capture_proxy (t)) 5529 { 5530 /* -- in a lambda-expression, a reference to this or to a 5531 variable with automatic storage duration defined outside that 5532 lambda-expression, where the reference would be an 5533 odr-use. */ 5534 if (flags & tf_error) 5535 { 5536 tree cap = DECL_CAPTURED_VARIABLE (t); 5537 error ("lambda capture of %qE is not a constant expression", 5538 cap); 5539 if (!want_rval && decl_constant_var_p (cap)) 5540 inform (input_location, "because it is used as a glvalue"); 5541 } 5542 return false; 5543 } 5544 return RECUR (DECL_VALUE_EXPR (t), rval); 5545 } 5546 if (want_rval 5547 && !var_in_maybe_constexpr_fn (t) 5548 && !type_dependent_expression_p (t) 5549 && !decl_maybe_constant_var_p (t) 5550 && (strict 5551 || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t)) 5552 || (DECL_INITIAL (t) 5553 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t))) 5554 && COMPLETE_TYPE_P (TREE_TYPE (t)) 5555 && !is_really_empty_class (TREE_TYPE (t))) 5556 { 5557 if (flags & tf_error) 5558 non_const_var_error (t); 5559 return false; 5560 } 5561 return true; 5562 5563 case NOP_EXPR: 5564 case CONVERT_EXPR: 5565 case VIEW_CONVERT_EXPR: 5566 /* -- a reinterpret_cast. FIXME not implemented, and this rule 5567 may change to something more specific to type-punning (DR 1312). */ 5568 { 5569 tree from = TREE_OPERAND (t, 0); 5570 if (POINTER_TYPE_P (TREE_TYPE (t)) 5571 && TREE_CODE (from) == INTEGER_CST 5572 && !integer_zerop (from)) 5573 { 5574 if (flags & tf_error) 5575 error_at (loc, "reinterpret_cast from integer to pointer"); 5576 return false; 5577 } 5578 return (RECUR (from, TREE_CODE (t) != VIEW_CONVERT_EXPR)); 5579 } 5580 5581 case ADDRESSOF_EXPR: 5582 /* This is like ADDR_EXPR, except it won't form pointer-to-member. */ 5583 t = TREE_OPERAND (t, 0); 5584 goto handle_addr_expr; 5585 5586 case ADDR_EXPR: 5587 /* -- a unary operator & that is applied to an lvalue that 5588 designates an object with thread or automatic storage 5589 duration; */ 5590 t = TREE_OPERAND (t, 0); 5591 5592 if (TREE_CODE (t) == OFFSET_REF && PTRMEM_OK_P (t)) 5593 /* A pointer-to-member constant. */ 5594 return true; 5595 5596 handle_addr_expr: 5597 #if 0 5598 /* FIXME adjust when issue 1197 is fully resolved. For now don't do 5599 any checking here, as we might dereference the pointer later. If 5600 we remove this code, also remove check_automatic_or_tls. */ 5601 i = check_automatic_or_tls (t); 5602 if (i == ck_ok) 5603 return true; 5604 if (i == ck_bad) 5605 { 5606 if (flags & tf_error) 5607 error ("address-of an object %qE with thread local or " 5608 "automatic storage is not a constant expression", t); 5609 return false; 5610 } 5611 #endif 5612 return RECUR (t, any); 5613 5614 case REALPART_EXPR: 5615 case IMAGPART_EXPR: 5616 case COMPONENT_REF: 5617 case BIT_FIELD_REF: 5618 case ARROW_EXPR: 5619 case OFFSET_REF: 5620 /* -- a class member access unless its postfix-expression is 5621 of literal type or of pointer to literal type. */ 5622 /* This test would be redundant, as it follows from the 5623 postfix-expression being a potential constant expression. */ 5624 if (type_unknown_p (t)) 5625 return true; 5626 return RECUR (TREE_OPERAND (t, 0), want_rval); 5627 5628 case EXPR_PACK_EXPANSION: 5629 return RECUR (PACK_EXPANSION_PATTERN (t), want_rval); 5630 5631 case INDIRECT_REF: 5632 { 5633 tree x = TREE_OPERAND (t, 0); 5634 STRIP_NOPS (x); 5635 if (is_this_parameter (x) && !is_capture_proxy (x)) 5636 { 5637 if (!var_in_maybe_constexpr_fn (x)) 5638 { 5639 if (flags & tf_error) 5640 error_at (loc, "use of %<this%> in a constant expression"); 5641 return false; 5642 } 5643 return true; 5644 } 5645 return RECUR (x, rval); 5646 } 5647 5648 case STATEMENT_LIST: 5649 { 5650 tree_stmt_iterator i; 5651 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i)) 5652 { 5653 if (!RECUR (tsi_stmt (i), any)) 5654 return false; 5655 } 5656 return true; 5657 } 5658 break; 5659 5660 case MODIFY_EXPR: 5661 if (cxx_dialect < cxx14) 5662 goto fail; 5663 if (!RECUR (TREE_OPERAND (t, 0), any)) 5664 return false; 5665 if (!RECUR (TREE_OPERAND (t, 1), rval)) 5666 return false; 5667 return true; 5668 5669 case MODOP_EXPR: 5670 if (cxx_dialect < cxx14) 5671 goto fail; 5672 if (!RECUR (TREE_OPERAND (t, 0), rval)) 5673 return false; 5674 if (!RECUR (TREE_OPERAND (t, 2), rval)) 5675 return false; 5676 return true; 5677 5678 case DO_STMT: 5679 if (!RECUR (DO_COND (t), rval)) 5680 return false; 5681 if (!RECUR (DO_BODY (t), any)) 5682 return false; 5683 return true; 5684 5685 case FOR_STMT: 5686 if (!RECUR (FOR_INIT_STMT (t), any)) 5687 return false; 5688 if (!RECUR (FOR_COND (t), rval)) 5689 return false; 5690 if (!RECUR (FOR_EXPR (t), any)) 5691 return false; 5692 if (!RECUR (FOR_BODY (t), any)) 5693 return false; 5694 return true; 5695 5696 case RANGE_FOR_STMT: 5697 if (!RECUR (RANGE_FOR_EXPR (t), any)) 5698 return false; 5699 if (!RECUR (RANGE_FOR_BODY (t), any)) 5700 return false; 5701 return true; 5702 5703 case WHILE_STMT: 5704 if (!RECUR (WHILE_COND (t), rval)) 5705 return false; 5706 if (!RECUR (WHILE_BODY (t), any)) 5707 return false; 5708 return true; 5709 5710 case SWITCH_STMT: 5711 if (!RECUR (SWITCH_STMT_COND (t), rval)) 5712 return false; 5713 /* FIXME we don't check SWITCH_STMT_BODY currently, because even 5714 unreachable labels would be checked. */ 5715 return true; 5716 5717 case STMT_EXPR: 5718 return RECUR (STMT_EXPR_STMT (t), rval); 5719 5720 case LAMBDA_EXPR: 5721 if (cxx_dialect >= cxx17) 5722 /* In C++17 lambdas can be constexpr, don't give up yet. */ 5723 return true; 5724 else if (flags & tf_error) 5725 error_at (loc, "lambda-expression is not a constant expression " 5726 "before C++17"); 5727 return false; 5728 5729 case DYNAMIC_CAST_EXPR: 5730 case PSEUDO_DTOR_EXPR: 5731 case NEW_EXPR: 5732 case VEC_NEW_EXPR: 5733 case DELETE_EXPR: 5734 case VEC_DELETE_EXPR: 5735 case THROW_EXPR: 5736 case OMP_PARALLEL: 5737 case OMP_TASK: 5738 case OMP_FOR: 5739 case OMP_SIMD: 5740 case OMP_DISTRIBUTE: 5741 case OMP_TASKLOOP: 5742 case OMP_TEAMS: 5743 case OMP_TARGET_DATA: 5744 case OMP_TARGET: 5745 case OMP_SECTIONS: 5746 case OMP_ORDERED: 5747 case OMP_CRITICAL: 5748 case OMP_SINGLE: 5749 case OMP_SECTION: 5750 case OMP_MASTER: 5751 case OMP_TASKGROUP: 5752 case OMP_TARGET_UPDATE: 5753 case OMP_TARGET_ENTER_DATA: 5754 case OMP_TARGET_EXIT_DATA: 5755 case OMP_ATOMIC: 5756 case OMP_ATOMIC_READ: 5757 case OMP_ATOMIC_CAPTURE_OLD: 5758 case OMP_ATOMIC_CAPTURE_NEW: 5759 case OACC_PARALLEL: 5760 case OACC_KERNELS: 5761 case OACC_DATA: 5762 case OACC_HOST_DATA: 5763 case OACC_LOOP: 5764 case OACC_CACHE: 5765 case OACC_DECLARE: 5766 case OACC_ENTER_DATA: 5767 case OACC_EXIT_DATA: 5768 case OACC_UPDATE: 5769 /* GCC internal stuff. */ 5770 case VA_ARG_EXPR: 5771 case OBJ_TYPE_REF: 5772 case TRANSACTION_EXPR: 5773 case ASM_EXPR: 5774 case AT_ENCODE_EXPR: 5775 fail: 5776 if (flags & tf_error) 5777 error_at (loc, "expression %qE is not a constant expression", t); 5778 return false; 5779 5780 case TYPEID_EXPR: 5781 /* -- a typeid expression whose operand is of polymorphic 5782 class type; */ 5783 { 5784 tree e = TREE_OPERAND (t, 0); 5785 if (!TYPE_P (e) && !type_dependent_expression_p (e) 5786 && TYPE_POLYMORPHIC_P (TREE_TYPE (e))) 5787 { 5788 if (flags & tf_error) 5789 error_at (loc, "typeid-expression is not a constant expression " 5790 "because %qE is of polymorphic type", e); 5791 return false; 5792 } 5793 return true; 5794 } 5795 5796 case POINTER_DIFF_EXPR: 5797 case MINUS_EXPR: 5798 want_rval = true; 5799 goto binary; 5800 5801 case LT_EXPR: 5802 case LE_EXPR: 5803 case GT_EXPR: 5804 case GE_EXPR: 5805 case EQ_EXPR: 5806 case NE_EXPR: 5807 want_rval = true; 5808 goto binary; 5809 5810 case PREINCREMENT_EXPR: 5811 case POSTINCREMENT_EXPR: 5812 case PREDECREMENT_EXPR: 5813 case POSTDECREMENT_EXPR: 5814 if (cxx_dialect < cxx14) 5815 goto fail; 5816 goto unary; 5817 5818 case BIT_NOT_EXPR: 5819 /* A destructor. */ 5820 if (TYPE_P (TREE_OPERAND (t, 0))) 5821 return true; 5822 /* fall through. */ 5823 5824 case CONJ_EXPR: 5825 case SAVE_EXPR: 5826 case FIX_TRUNC_EXPR: 5827 case FLOAT_EXPR: 5828 case NEGATE_EXPR: 5829 case ABS_EXPR: 5830 case TRUTH_NOT_EXPR: 5831 case FIXED_CONVERT_EXPR: 5832 case UNARY_PLUS_EXPR: 5833 case UNARY_LEFT_FOLD_EXPR: 5834 case UNARY_RIGHT_FOLD_EXPR: 5835 unary: 5836 return RECUR (TREE_OPERAND (t, 0), rval); 5837 5838 case CAST_EXPR: 5839 case CONST_CAST_EXPR: 5840 case STATIC_CAST_EXPR: 5841 case REINTERPRET_CAST_EXPR: 5842 case IMPLICIT_CONV_EXPR: 5843 if (cxx_dialect < cxx11 5844 && !dependent_type_p (TREE_TYPE (t)) 5845 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))) 5846 /* In C++98, a conversion to non-integral type can't be part of a 5847 constant expression. */ 5848 { 5849 if (flags & tf_error) 5850 error_at (loc, 5851 "cast to non-integral type %qT in a constant expression", 5852 TREE_TYPE (t)); 5853 return false; 5854 } 5855 /* This might be a conversion from a class to a (potentially) literal 5856 type. Let's consider it potentially constant since the conversion 5857 might be a constexpr user-defined conversion. */ 5858 else if (cxx_dialect >= cxx11 5859 && (dependent_type_p (TREE_TYPE (t)) 5860 || !COMPLETE_TYPE_P (TREE_TYPE (t)) 5861 || literal_type_p (TREE_TYPE (t))) 5862 && TREE_OPERAND (t, 0)) 5863 { 5864 tree type = TREE_TYPE (TREE_OPERAND (t, 0)); 5865 /* If this is a dependent type, it could end up being a class 5866 with conversions. */ 5867 if (type == NULL_TREE || WILDCARD_TYPE_P (type)) 5868 return true; 5869 /* Or a non-dependent class which has conversions. */ 5870 else if (CLASS_TYPE_P (type) 5871 && (TYPE_HAS_CONVERSION (type) || dependent_scope_p (type))) 5872 return true; 5873 } 5874 5875 return (RECUR (TREE_OPERAND (t, 0), 5876 TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)); 5877 5878 case BIND_EXPR: 5879 return RECUR (BIND_EXPR_BODY (t), want_rval); 5880 5881 case CLEANUP_POINT_EXPR: 5882 case MUST_NOT_THROW_EXPR: 5883 case TRY_CATCH_EXPR: 5884 case TRY_BLOCK: 5885 case EH_SPEC_BLOCK: 5886 case EXPR_STMT: 5887 case PAREN_EXPR: 5888 case NON_DEPENDENT_EXPR: 5889 /* For convenience. */ 5890 case RETURN_EXPR: 5891 case LOOP_EXPR: 5892 case EXIT_EXPR: 5893 return RECUR (TREE_OPERAND (t, 0), want_rval); 5894 5895 case DECL_EXPR: 5896 tmp = DECL_EXPR_DECL (t); 5897 if (VAR_P (tmp) && !DECL_ARTIFICIAL (tmp)) 5898 { 5899 if (TREE_STATIC (tmp)) 5900 { 5901 if (flags & tf_error) 5902 error_at (DECL_SOURCE_LOCATION (tmp), "%qD declared " 5903 "%<static%> in %<constexpr%> context", tmp); 5904 return false; 5905 } 5906 else if (CP_DECL_THREAD_LOCAL_P (tmp)) 5907 { 5908 if (flags & tf_error) 5909 error_at (DECL_SOURCE_LOCATION (tmp), "%qD declared " 5910 "%<thread_local%> in %<constexpr%> context", tmp); 5911 return false; 5912 } 5913 else if (!check_for_uninitialized_const_var 5914 (tmp, /*constexpr_context_p=*/true, flags)) 5915 return false; 5916 } 5917 return RECUR (tmp, want_rval); 5918 5919 case TRY_FINALLY_EXPR: 5920 return (RECUR (TREE_OPERAND (t, 0), want_rval) 5921 && RECUR (TREE_OPERAND (t, 1), any)); 5922 5923 case SCOPE_REF: 5924 return RECUR (TREE_OPERAND (t, 1), want_rval); 5925 5926 case TARGET_EXPR: 5927 if (!TARGET_EXPR_DIRECT_INIT_P (t) 5928 && !literal_type_p (TREE_TYPE (t))) 5929 { 5930 if (flags & tf_error) 5931 { 5932 error_at (loc, "temporary of non-literal type %qT in a " 5933 "constant expression", TREE_TYPE (t)); 5934 explain_non_literal_class (TREE_TYPE (t)); 5935 } 5936 return false; 5937 } 5938 /* FALLTHRU */ 5939 case INIT_EXPR: 5940 return RECUR (TREE_OPERAND (t, 1), rval); 5941 5942 case CONSTRUCTOR: 5943 { 5944 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t); 5945 constructor_elt *ce; 5946 for (i = 0; vec_safe_iterate (v, i, &ce); ++i) 5947 if (!RECUR (ce->value, want_rval)) 5948 return false; 5949 return true; 5950 } 5951 5952 case TREE_LIST: 5953 { 5954 gcc_assert (TREE_PURPOSE (t) == NULL_TREE 5955 || DECL_P (TREE_PURPOSE (t))); 5956 if (!RECUR (TREE_VALUE (t), want_rval)) 5957 return false; 5958 if (TREE_CHAIN (t) == NULL_TREE) 5959 return true; 5960 return RECUR (TREE_CHAIN (t), want_rval); 5961 } 5962 5963 case TRUNC_DIV_EXPR: 5964 case CEIL_DIV_EXPR: 5965 case FLOOR_DIV_EXPR: 5966 case ROUND_DIV_EXPR: 5967 case TRUNC_MOD_EXPR: 5968 case CEIL_MOD_EXPR: 5969 case ROUND_MOD_EXPR: 5970 { 5971 tree denom = TREE_OPERAND (t, 1); 5972 if (!RECUR (denom, rval)) 5973 return false; 5974 /* We can't call cxx_eval_outermost_constant_expr on an expression 5975 that hasn't been through instantiate_non_dependent_expr yet. */ 5976 if (!processing_template_decl) 5977 denom = cxx_eval_outermost_constant_expr (denom, true); 5978 if (integer_zerop (denom)) 5979 { 5980 if (flags & tf_error) 5981 error ("division by zero is not a constant expression"); 5982 return false; 5983 } 5984 else 5985 { 5986 want_rval = true; 5987 return RECUR (TREE_OPERAND (t, 0), want_rval); 5988 } 5989 } 5990 5991 case COMPOUND_EXPR: 5992 { 5993 /* check_return_expr sometimes wraps a TARGET_EXPR in a 5994 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR 5995 introduced by build_call_a. */ 5996 tree op0 = TREE_OPERAND (t, 0); 5997 tree op1 = TREE_OPERAND (t, 1); 5998 STRIP_NOPS (op1); 5999 if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0)) 6000 || TREE_CODE (op1) == EMPTY_CLASS_EXPR) 6001 return RECUR (op0, want_rval); 6002 else 6003 goto binary; 6004 } 6005 6006 /* If the first operand is the non-short-circuit constant, look at 6007 the second operand; otherwise we only care about the first one for 6008 potentiality. */ 6009 case TRUTH_AND_EXPR: 6010 case TRUTH_ANDIF_EXPR: 6011 tmp = boolean_true_node; 6012 goto truth; 6013 case TRUTH_OR_EXPR: 6014 case TRUTH_ORIF_EXPR: 6015 tmp = boolean_false_node; 6016 truth: 6017 { 6018 tree op = TREE_OPERAND (t, 0); 6019 if (!RECUR (op, rval)) 6020 return false; 6021 if (!processing_template_decl) 6022 op = cxx_eval_outermost_constant_expr (op, true); 6023 if (tree_int_cst_equal (op, tmp)) 6024 return RECUR (TREE_OPERAND (t, 1), rval); 6025 else 6026 return true; 6027 } 6028 6029 case PLUS_EXPR: 6030 case MULT_EXPR: 6031 case POINTER_PLUS_EXPR: 6032 case RDIV_EXPR: 6033 case EXACT_DIV_EXPR: 6034 case MIN_EXPR: 6035 case MAX_EXPR: 6036 case LSHIFT_EXPR: 6037 case RSHIFT_EXPR: 6038 case LROTATE_EXPR: 6039 case RROTATE_EXPR: 6040 case BIT_IOR_EXPR: 6041 case BIT_XOR_EXPR: 6042 case BIT_AND_EXPR: 6043 case TRUTH_XOR_EXPR: 6044 case UNORDERED_EXPR: 6045 case ORDERED_EXPR: 6046 case UNLT_EXPR: 6047 case UNLE_EXPR: 6048 case UNGT_EXPR: 6049 case UNGE_EXPR: 6050 case UNEQ_EXPR: 6051 case LTGT_EXPR: 6052 case RANGE_EXPR: 6053 case COMPLEX_EXPR: 6054 want_rval = true; 6055 /* Fall through. */ 6056 case ARRAY_REF: 6057 case ARRAY_RANGE_REF: 6058 case MEMBER_REF: 6059 case DOTSTAR_EXPR: 6060 case MEM_REF: 6061 case BINARY_LEFT_FOLD_EXPR: 6062 case BINARY_RIGHT_FOLD_EXPR: 6063 binary: 6064 for (i = 0; i < 2; ++i) 6065 if (!RECUR (TREE_OPERAND (t, i), want_rval)) 6066 return false; 6067 return true; 6068 6069 case FMA_EXPR: 6070 case VEC_PERM_EXPR: 6071 for (i = 0; i < 3; ++i) 6072 if (!RECUR (TREE_OPERAND (t, i), true)) 6073 return false; 6074 return true; 6075 6076 case COND_EXPR: 6077 if (COND_EXPR_IS_VEC_DELETE (t)) 6078 { 6079 if (flags & tf_error) 6080 error_at (loc, "%<delete[]%> is not a constant expression"); 6081 return false; 6082 } 6083 /* Fall through. */ 6084 case IF_STMT: 6085 case VEC_COND_EXPR: 6086 /* If the condition is a known constant, we know which of the legs we 6087 care about; otherwise we only require that the condition and 6088 either of the legs be potentially constant. */ 6089 tmp = TREE_OPERAND (t, 0); 6090 if (!RECUR (tmp, rval)) 6091 return false; 6092 if (!processing_template_decl) 6093 tmp = cxx_eval_outermost_constant_expr (tmp, true); 6094 if (integer_zerop (tmp)) 6095 return RECUR (TREE_OPERAND (t, 2), want_rval); 6096 else if (TREE_CODE (tmp) == INTEGER_CST) 6097 return RECUR (TREE_OPERAND (t, 1), want_rval); 6098 for (i = 1; i < 3; ++i) 6099 if (potential_constant_expression_1 (TREE_OPERAND (t, i), 6100 want_rval, strict, now, tf_none)) 6101 return true; 6102 if (flags & tf_error) 6103 error_at (loc, "expression %qE is not a constant expression", t); 6104 return false; 6105 6106 case VEC_INIT_EXPR: 6107 if (VEC_INIT_EXPR_IS_CONSTEXPR (t)) 6108 return true; 6109 if (flags & tf_error) 6110 { 6111 error_at (loc, "non-constant array initialization"); 6112 diagnose_non_constexpr_vec_init (t); 6113 } 6114 return false; 6115 6116 case TYPE_DECL: 6117 case TAG_DEFN: 6118 /* We can see these in statement-expressions. */ 6119 return true; 6120 6121 case CLEANUP_STMT: 6122 case EMPTY_CLASS_EXPR: 6123 case PREDICT_EXPR: 6124 return false; 6125 6126 case GOTO_EXPR: 6127 { 6128 tree *target = &TREE_OPERAND (t, 0); 6129 /* Gotos representing break and continue are OK. */ 6130 if (breaks (target) || continues (target)) 6131 return true; 6132 if (flags & tf_error) 6133 error_at (loc, "%<goto%> is not a constant expression"); 6134 return false; 6135 } 6136 6137 case ANNOTATE_EXPR: 6138 return RECUR (TREE_OPERAND (t, 0), rval); 6139 6140 default: 6141 if (objc_is_property_ref (t)) 6142 return false; 6143 6144 sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t))); 6145 gcc_unreachable (); 6146 return false; 6147 } 6148 #undef RECUR 6149 } 6150 6151 /* The main entry point to the above. */ 6152 6153 bool 6154 potential_constant_expression (tree t) 6155 { 6156 return potential_constant_expression_1 (t, false, true, false, tf_none); 6157 } 6158 6159 /* As above, but require a constant rvalue. */ 6160 6161 bool 6162 potential_rvalue_constant_expression (tree t) 6163 { 6164 return potential_constant_expression_1 (t, true, true, false, tf_none); 6165 } 6166 6167 /* Like above, but complain about non-constant expressions. */ 6168 6169 bool 6170 require_potential_constant_expression (tree t) 6171 { 6172 return potential_constant_expression_1 (t, false, true, false, 6173 tf_warning_or_error); 6174 } 6175 6176 /* Cross product of the above. */ 6177 6178 bool 6179 require_potential_rvalue_constant_expression (tree t) 6180 { 6181 return potential_constant_expression_1 (t, true, true, false, 6182 tf_warning_or_error); 6183 } 6184 6185 /* Like above, but don't consider PARM_DECL a potential_constant_expression. */ 6186 6187 bool 6188 require_rvalue_constant_expression (tree t) 6189 { 6190 return potential_constant_expression_1 (t, true, true, true, 6191 tf_warning_or_error); 6192 } 6193 6194 /* Like potential_constant_expression, but don't consider possible constexpr 6195 substitution of the current function. That is, PARM_DECL qualifies under 6196 potential_constant_expression, but not here. 6197 6198 This is basically what you can check when any actual constant values might 6199 be value-dependent. */ 6200 6201 bool 6202 is_constant_expression (tree t) 6203 { 6204 return potential_constant_expression_1 (t, false, true, true, tf_none); 6205 } 6206 6207 /* Like above, but complain about non-constant expressions. */ 6208 6209 bool 6210 require_constant_expression (tree t) 6211 { 6212 return potential_constant_expression_1 (t, false, true, true, 6213 tf_warning_or_error); 6214 } 6215 6216 /* Like is_constant_expression, but allow const variables that are not allowed 6217 under constexpr rules. */ 6218 6219 bool 6220 is_static_init_expression (tree t) 6221 { 6222 return potential_constant_expression_1 (t, false, false, true, tf_none); 6223 } 6224 6225 /* Returns true if T is a potential constant expression that is not 6226 instantiation-dependent, and therefore a candidate for constant folding even 6227 in a template. */ 6228 6229 bool 6230 is_nondependent_constant_expression (tree t) 6231 { 6232 return (!type_unknown_p (t) 6233 && !BRACE_ENCLOSED_INITIALIZER_P (t) 6234 && is_constant_expression (t) 6235 && !instantiation_dependent_expression_p (t)); 6236 } 6237 6238 /* Returns true if T is a potential static initializer expression that is not 6239 instantiation-dependent. */ 6240 6241 bool 6242 is_nondependent_static_init_expression (tree t) 6243 { 6244 return (!type_unknown_p (t) 6245 && !BRACE_ENCLOSED_INITIALIZER_P (t) 6246 && is_static_init_expression (t) 6247 && !instantiation_dependent_expression_p (t)); 6248 } 6249 6250 /* Finalize constexpr processing after parsing. */ 6251 6252 void 6253 fini_constexpr (void) 6254 { 6255 /* The contexpr call and fundef copies tables are no longer needed. */ 6256 constexpr_call_table = NULL; 6257 fundef_copies_table = NULL; 6258 } 6259 6260 #include "gt-cp-constexpr.h" 6261