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