1 /* Language-dependent node constructors for parse phase of GNU compiler. 2 Copyright (C) 1987-2017 Free Software Foundation, Inc. 3 Hacked by Michael Tiemann (tiemann@cygnus.com) 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 GCC is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "tree.h" 25 #include "cp-tree.h" 26 #include "gimple-expr.h" 27 #include "cgraph.h" 28 #include "stor-layout.h" 29 #include "print-tree.h" 30 #include "tree-iterator.h" 31 #include "tree-inline.h" 32 #include "debug.h" 33 #include "convert.h" 34 #include "gimplify.h" 35 #include "attribs.h" 36 37 static tree bot_manip (tree *, int *, void *); 38 static tree bot_replace (tree *, int *, void *); 39 static hashval_t list_hash_pieces (tree, tree, tree); 40 static tree build_target_expr (tree, tree, tsubst_flags_t); 41 static tree count_trees_r (tree *, int *, void *); 42 static tree verify_stmt_tree_r (tree *, int *, void *); 43 static tree build_local_temp (tree); 44 45 static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *); 46 static tree handle_abi_tag_attribute (tree *, tree, tree, int, bool *); 47 48 /* If REF is an lvalue, returns the kind of lvalue that REF is. 49 Otherwise, returns clk_none. */ 50 51 cp_lvalue_kind 52 lvalue_kind (const_tree ref) 53 { 54 cp_lvalue_kind op1_lvalue_kind = clk_none; 55 cp_lvalue_kind op2_lvalue_kind = clk_none; 56 57 /* Expressions of reference type are sometimes wrapped in 58 INDIRECT_REFs. INDIRECT_REFs are just internal compiler 59 representation, not part of the language, so we have to look 60 through them. */ 61 if (REFERENCE_REF_P (ref)) 62 return lvalue_kind (TREE_OPERAND (ref, 0)); 63 64 if (TREE_TYPE (ref) 65 && TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE) 66 { 67 /* unnamed rvalue references are rvalues */ 68 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref)) 69 && TREE_CODE (ref) != PARM_DECL 70 && !VAR_P (ref) 71 && TREE_CODE (ref) != COMPONENT_REF 72 /* Functions are always lvalues. */ 73 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref))) != FUNCTION_TYPE) 74 return clk_rvalueref; 75 76 /* lvalue references and named rvalue references are lvalues. */ 77 return clk_ordinary; 78 } 79 80 if (ref == current_class_ptr) 81 return clk_none; 82 83 switch (TREE_CODE (ref)) 84 { 85 case SAVE_EXPR: 86 return clk_none; 87 /* preincrements and predecrements are valid lvals, provided 88 what they refer to are valid lvals. */ 89 case PREINCREMENT_EXPR: 90 case PREDECREMENT_EXPR: 91 case TRY_CATCH_EXPR: 92 case WITH_CLEANUP_EXPR: 93 case REALPART_EXPR: 94 case IMAGPART_EXPR: 95 return lvalue_kind (TREE_OPERAND (ref, 0)); 96 97 case MEMBER_REF: 98 case DOTSTAR_EXPR: 99 if (TREE_CODE (ref) == MEMBER_REF) 100 op1_lvalue_kind = clk_ordinary; 101 else 102 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0)); 103 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref, 1)))) 104 op1_lvalue_kind = clk_none; 105 return op1_lvalue_kind; 106 107 case COMPONENT_REF: 108 if (BASELINK_P (TREE_OPERAND (ref, 1))) 109 { 110 tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (ref, 1)); 111 112 /* For static member function recurse on the BASELINK, we can get 113 here e.g. from reference_binding. If BASELINK_FUNCTIONS is 114 OVERLOAD, the overload is resolved first if possible through 115 resolve_address_of_overloaded_function. */ 116 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_STATIC_FUNCTION_P (fn)) 117 return lvalue_kind (TREE_OPERAND (ref, 1)); 118 } 119 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0)); 120 /* Look at the member designator. */ 121 if (!op1_lvalue_kind) 122 ; 123 else if (is_overloaded_fn (TREE_OPERAND (ref, 1))) 124 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some 125 situations. If we're seeing a COMPONENT_REF, it's a non-static 126 member, so it isn't an lvalue. */ 127 op1_lvalue_kind = clk_none; 128 else if (TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL) 129 /* This can be IDENTIFIER_NODE in a template. */; 130 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1))) 131 { 132 /* Clear the ordinary bit. If this object was a class 133 rvalue we want to preserve that information. */ 134 op1_lvalue_kind &= ~clk_ordinary; 135 /* The lvalue is for a bitfield. */ 136 op1_lvalue_kind |= clk_bitfield; 137 } 138 else if (DECL_PACKED (TREE_OPERAND (ref, 1))) 139 op1_lvalue_kind |= clk_packed; 140 141 return op1_lvalue_kind; 142 143 case STRING_CST: 144 case COMPOUND_LITERAL_EXPR: 145 return clk_ordinary; 146 147 case CONST_DECL: 148 /* CONST_DECL without TREE_STATIC are enumeration values and 149 thus not lvalues. With TREE_STATIC they are used by ObjC++ 150 in objc_build_string_object and need to be considered as 151 lvalues. */ 152 if (! TREE_STATIC (ref)) 153 return clk_none; 154 /* FALLTHRU */ 155 case VAR_DECL: 156 if (VAR_P (ref) && DECL_HAS_VALUE_EXPR_P (ref)) 157 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref))); 158 159 if (TREE_READONLY (ref) && ! TREE_STATIC (ref) 160 && DECL_LANG_SPECIFIC (ref) 161 && DECL_IN_AGGR_P (ref)) 162 return clk_none; 163 /* FALLTHRU */ 164 case INDIRECT_REF: 165 case ARROW_EXPR: 166 case ARRAY_REF: 167 case ARRAY_NOTATION_REF: 168 case PARM_DECL: 169 case RESULT_DECL: 170 case PLACEHOLDER_EXPR: 171 return clk_ordinary; 172 173 /* A scope ref in a template, left as SCOPE_REF to support later 174 access checking. */ 175 case SCOPE_REF: 176 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref))); 177 { 178 tree op = TREE_OPERAND (ref, 1); 179 if (TREE_CODE (op) == FIELD_DECL) 180 return (DECL_C_BIT_FIELD (op) ? clk_bitfield : clk_ordinary); 181 else 182 return lvalue_kind (op); 183 } 184 185 case MAX_EXPR: 186 case MIN_EXPR: 187 /* Disallow <? and >? as lvalues if either argument side-effects. */ 188 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0)) 189 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1))) 190 return clk_none; 191 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0)); 192 op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1)); 193 break; 194 195 case COND_EXPR: 196 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1) 197 ? TREE_OPERAND (ref, 1) 198 : TREE_OPERAND (ref, 0)); 199 op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 2)); 200 break; 201 202 case MODOP_EXPR: 203 /* We expect to see unlowered MODOP_EXPRs only during 204 template processing. */ 205 gcc_assert (processing_template_decl); 206 return clk_ordinary; 207 208 case MODIFY_EXPR: 209 case TYPEID_EXPR: 210 return clk_ordinary; 211 212 case COMPOUND_EXPR: 213 return lvalue_kind (TREE_OPERAND (ref, 1)); 214 215 case TARGET_EXPR: 216 return clk_class; 217 218 case VA_ARG_EXPR: 219 return (CLASS_TYPE_P (TREE_TYPE (ref)) ? clk_class : clk_none); 220 221 case CALL_EXPR: 222 /* We can see calls outside of TARGET_EXPR in templates. */ 223 if (CLASS_TYPE_P (TREE_TYPE (ref))) 224 return clk_class; 225 return clk_none; 226 227 case FUNCTION_DECL: 228 /* All functions (except non-static-member functions) are 229 lvalues. */ 230 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref) 231 ? clk_none : clk_ordinary); 232 233 case BASELINK: 234 /* We now represent a reference to a single static member function 235 with a BASELINK. */ 236 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns 237 its argument unmodified and we assign it to a const_tree. */ 238 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref))); 239 240 case NON_DEPENDENT_EXPR: 241 return lvalue_kind (TREE_OPERAND (ref, 0)); 242 243 default: 244 if (!TREE_TYPE (ref)) 245 return clk_none; 246 if (CLASS_TYPE_P (TREE_TYPE (ref)) 247 || TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE) 248 return clk_class; 249 break; 250 } 251 252 /* If one operand is not an lvalue at all, then this expression is 253 not an lvalue. */ 254 if (!op1_lvalue_kind || !op2_lvalue_kind) 255 return clk_none; 256 257 /* Otherwise, it's an lvalue, and it has all the odd properties 258 contributed by either operand. */ 259 op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind; 260 /* It's not an ordinary lvalue if it involves any other kind. */ 261 if ((op1_lvalue_kind & ~clk_ordinary) != clk_none) 262 op1_lvalue_kind &= ~clk_ordinary; 263 /* It can't be both a pseudo-lvalue and a non-addressable lvalue. 264 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */ 265 if ((op1_lvalue_kind & (clk_rvalueref|clk_class)) 266 && (op1_lvalue_kind & (clk_bitfield|clk_packed))) 267 op1_lvalue_kind = clk_none; 268 return op1_lvalue_kind; 269 } 270 271 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */ 272 273 cp_lvalue_kind 274 real_lvalue_p (const_tree ref) 275 { 276 cp_lvalue_kind kind = lvalue_kind (ref); 277 if (kind & (clk_rvalueref|clk_class)) 278 return clk_none; 279 else 280 return kind; 281 } 282 283 /* c-common wants us to return bool. */ 284 285 bool 286 lvalue_p (const_tree t) 287 { 288 return real_lvalue_p (t); 289 } 290 291 /* This differs from lvalue_p in that xvalues are included. */ 292 293 bool 294 glvalue_p (const_tree ref) 295 { 296 cp_lvalue_kind kind = lvalue_kind (ref); 297 if (kind & clk_class) 298 return false; 299 else 300 return (kind != clk_none); 301 } 302 303 /* This differs from glvalue_p in that class prvalues are included. */ 304 305 bool 306 obvalue_p (const_tree ref) 307 { 308 return (lvalue_kind (ref) != clk_none); 309 } 310 311 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue 312 reference), false otherwise. */ 313 314 bool 315 xvalue_p (const_tree ref) 316 { 317 return (lvalue_kind (ref) == clk_rvalueref); 318 } 319 320 /* True if REF is a bit-field. */ 321 322 bool 323 bitfield_p (const_tree ref) 324 { 325 return (lvalue_kind (ref) & clk_bitfield); 326 } 327 328 /* C++-specific version of stabilize_reference. */ 329 330 tree 331 cp_stabilize_reference (tree ref) 332 { 333 switch (TREE_CODE (ref)) 334 { 335 /* We need to treat specially anything stabilize_reference doesn't 336 handle specifically. */ 337 case VAR_DECL: 338 case PARM_DECL: 339 case RESULT_DECL: 340 CASE_CONVERT: 341 case FLOAT_EXPR: 342 case FIX_TRUNC_EXPR: 343 case INDIRECT_REF: 344 case COMPONENT_REF: 345 case BIT_FIELD_REF: 346 case ARRAY_REF: 347 case ARRAY_RANGE_REF: 348 case ERROR_MARK: 349 break; 350 default: 351 cp_lvalue_kind kind = lvalue_kind (ref); 352 if ((kind & ~clk_class) != clk_none) 353 { 354 tree type = unlowered_expr_type (ref); 355 bool rval = !!(kind & clk_rvalueref); 356 type = cp_build_reference_type (type, rval); 357 /* This inhibits warnings in, eg, cxx_mark_addressable 358 (c++/60955). */ 359 warning_sentinel s (extra_warnings); 360 ref = build_static_cast (type, ref, tf_error); 361 } 362 } 363 364 return stabilize_reference (ref); 365 } 366 367 /* Test whether DECL is a builtin that may appear in a 368 constant-expression. */ 369 370 bool 371 builtin_valid_in_constant_expr_p (const_tree decl) 372 { 373 if (!(TREE_CODE (decl) == FUNCTION_DECL 374 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)) 375 /* Not a built-in. */ 376 return false; 377 switch (DECL_FUNCTION_CODE (decl)) 378 { 379 /* These always have constant results like the corresponding 380 macros/symbol. */ 381 case BUILT_IN_FILE: 382 case BUILT_IN_FUNCTION: 383 case BUILT_IN_LINE: 384 385 /* The following built-ins are valid in constant expressions 386 when their arguments are. */ 387 case BUILT_IN_ADD_OVERFLOW_P: 388 case BUILT_IN_SUB_OVERFLOW_P: 389 case BUILT_IN_MUL_OVERFLOW_P: 390 391 /* These have constant results even if their operands are 392 non-constant. */ 393 case BUILT_IN_CONSTANT_P: 394 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE: 395 return true; 396 default: 397 return false; 398 } 399 } 400 401 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */ 402 403 static tree 404 build_target_expr (tree decl, tree value, tsubst_flags_t complain) 405 { 406 tree t; 407 tree type = TREE_TYPE (decl); 408 409 value = mark_rvalue_use (value); 410 411 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value)) 412 || TREE_TYPE (decl) == TREE_TYPE (value) 413 /* On ARM ctors return 'this'. */ 414 || (TYPE_PTR_P (TREE_TYPE (value)) 415 && TREE_CODE (value) == CALL_EXPR) 416 || useless_type_conversion_p (TREE_TYPE (decl), 417 TREE_TYPE (value))); 418 419 if (complain & tf_no_cleanup) 420 /* The caller is building a new-expr and does not need a cleanup. */ 421 t = NULL_TREE; 422 else 423 { 424 t = cxx_maybe_build_cleanup (decl, complain); 425 if (t == error_mark_node) 426 return error_mark_node; 427 } 428 t = build4 (TARGET_EXPR, type, decl, value, t, NULL_TREE); 429 if (EXPR_HAS_LOCATION (value)) 430 SET_EXPR_LOCATION (t, EXPR_LOCATION (value)); 431 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not 432 ignore the TARGET_EXPR. If there really turn out to be no 433 side-effects, then the optimizer should be able to get rid of 434 whatever code is generated anyhow. */ 435 TREE_SIDE_EFFECTS (t) = 1; 436 437 return t; 438 } 439 440 /* Return an undeclared local temporary of type TYPE for use in building a 441 TARGET_EXPR. */ 442 443 static tree 444 build_local_temp (tree type) 445 { 446 tree slot = build_decl (input_location, 447 VAR_DECL, NULL_TREE, type); 448 DECL_ARTIFICIAL (slot) = 1; 449 DECL_IGNORED_P (slot) = 1; 450 DECL_CONTEXT (slot) = current_function_decl; 451 layout_decl (slot, 0); 452 return slot; 453 } 454 455 /* Set various status flags when building an AGGR_INIT_EXPR object T. */ 456 457 static void 458 process_aggr_init_operands (tree t) 459 { 460 bool side_effects; 461 462 side_effects = TREE_SIDE_EFFECTS (t); 463 if (!side_effects) 464 { 465 int i, n; 466 n = TREE_OPERAND_LENGTH (t); 467 for (i = 1; i < n; i++) 468 { 469 tree op = TREE_OPERAND (t, i); 470 if (op && TREE_SIDE_EFFECTS (op)) 471 { 472 side_effects = 1; 473 break; 474 } 475 } 476 } 477 TREE_SIDE_EFFECTS (t) = side_effects; 478 } 479 480 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE, 481 FN, and SLOT. NARGS is the number of call arguments which are specified 482 as a tree array ARGS. */ 483 484 static tree 485 build_aggr_init_array (tree return_type, tree fn, tree slot, int nargs, 486 tree *args) 487 { 488 tree t; 489 int i; 490 491 t = build_vl_exp (AGGR_INIT_EXPR, nargs + 3); 492 TREE_TYPE (t) = return_type; 493 AGGR_INIT_EXPR_FN (t) = fn; 494 AGGR_INIT_EXPR_SLOT (t) = slot; 495 for (i = 0; i < nargs; i++) 496 AGGR_INIT_EXPR_ARG (t, i) = args[i]; 497 process_aggr_init_operands (t); 498 return t; 499 } 500 501 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its 502 target. TYPE is the type to be initialized. 503 504 Build an AGGR_INIT_EXPR to represent the initialization. This function 505 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used 506 to initialize another object, whereas a TARGET_EXPR can either 507 initialize another object or create its own temporary object, and as a 508 result building up a TARGET_EXPR requires that the type's destructor be 509 callable. */ 510 511 tree 512 build_aggr_init_expr (tree type, tree init) 513 { 514 tree fn; 515 tree slot; 516 tree rval; 517 int is_ctor; 518 519 /* Don't build AGGR_INIT_EXPR in a template. */ 520 if (processing_template_decl) 521 return init; 522 523 fn = cp_get_callee (init); 524 if (fn == NULL_TREE) 525 return convert (type, init); 526 527 is_ctor = (TREE_CODE (fn) == ADDR_EXPR 528 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL 529 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0))); 530 531 /* We split the CALL_EXPR into its function and its arguments here. 532 Then, in expand_expr, we put them back together. The reason for 533 this is that this expression might be a default argument 534 expression. In that case, we need a new temporary every time the 535 expression is used. That's what break_out_target_exprs does; it 536 replaces every AGGR_INIT_EXPR with a copy that uses a fresh 537 temporary slot. Then, expand_expr builds up a call-expression 538 using the new slot. */ 539 540 /* If we don't need to use a constructor to create an object of this 541 type, don't mess with AGGR_INIT_EXPR. */ 542 if (is_ctor || TREE_ADDRESSABLE (type)) 543 { 544 slot = build_local_temp (type); 545 546 if (TREE_CODE (init) == CALL_EXPR) 547 { 548 rval = build_aggr_init_array (void_type_node, fn, slot, 549 call_expr_nargs (init), 550 CALL_EXPR_ARGP (init)); 551 AGGR_INIT_FROM_THUNK_P (rval) 552 = CALL_FROM_THUNK_P (init); 553 } 554 else 555 { 556 rval = build_aggr_init_array (void_type_node, fn, slot, 557 aggr_init_expr_nargs (init), 558 AGGR_INIT_EXPR_ARGP (init)); 559 AGGR_INIT_FROM_THUNK_P (rval) 560 = AGGR_INIT_FROM_THUNK_P (init); 561 } 562 TREE_SIDE_EFFECTS (rval) = 1; 563 AGGR_INIT_VIA_CTOR_P (rval) = is_ctor; 564 TREE_NOTHROW (rval) = TREE_NOTHROW (init); 565 CALL_EXPR_OPERATOR_SYNTAX (rval) = CALL_EXPR_OPERATOR_SYNTAX (init); 566 CALL_EXPR_ORDERED_ARGS (rval) = CALL_EXPR_ORDERED_ARGS (init); 567 CALL_EXPR_REVERSE_ARGS (rval) = CALL_EXPR_REVERSE_ARGS (init); 568 } 569 else 570 rval = init; 571 572 return rval; 573 } 574 575 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its 576 target. TYPE is the type that this initialization should appear to 577 have. 578 579 Build an encapsulation of the initialization to perform 580 and return it so that it can be processed by language-independent 581 and language-specific expression expanders. */ 582 583 tree 584 build_cplus_new (tree type, tree init, tsubst_flags_t complain) 585 { 586 tree rval = build_aggr_init_expr (type, init); 587 tree slot; 588 589 if (!complete_type_or_maybe_complain (type, init, complain)) 590 return error_mark_node; 591 592 /* Make sure that we're not trying to create an instance of an 593 abstract class. */ 594 if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain)) 595 return error_mark_node; 596 597 if (TREE_CODE (rval) == AGGR_INIT_EXPR) 598 slot = AGGR_INIT_EXPR_SLOT (rval); 599 else if (TREE_CODE (rval) == CALL_EXPR 600 || TREE_CODE (rval) == CONSTRUCTOR) 601 slot = build_local_temp (type); 602 else 603 return rval; 604 605 rval = build_target_expr (slot, rval, complain); 606 607 if (rval != error_mark_node) 608 TARGET_EXPR_IMPLICIT_P (rval) = 1; 609 610 return rval; 611 } 612 613 /* Subroutine of build_vec_init_expr: Build up a single element 614 intialization as a proxy for the full array initialization to get things 615 marked as used and any appropriate diagnostics. 616 617 Since we're deferring building the actual constructor calls until 618 gimplification time, we need to build one now and throw it away so 619 that the relevant constructor gets mark_used before cgraph decides 620 what functions are needed. Here we assume that init is either 621 NULL_TREE, void_type_node (indicating value-initialization), or 622 another array to copy. */ 623 624 static tree 625 build_vec_init_elt (tree type, tree init, tsubst_flags_t complain) 626 { 627 tree inner_type = strip_array_types (type); 628 vec<tree, va_gc> *argvec; 629 630 if (integer_zerop (array_type_nelts_total (type)) 631 || !CLASS_TYPE_P (inner_type)) 632 /* No interesting initialization to do. */ 633 return integer_zero_node; 634 else if (init == void_type_node) 635 return build_value_init (inner_type, complain); 636 637 gcc_assert (init == NULL_TREE 638 || (same_type_ignoring_top_level_qualifiers_p 639 (type, TREE_TYPE (init)))); 640 641 argvec = make_tree_vector (); 642 if (init) 643 { 644 tree init_type = strip_array_types (TREE_TYPE (init)); 645 tree dummy = build_dummy_object (init_type); 646 if (!lvalue_p (init)) 647 dummy = move (dummy); 648 argvec->quick_push (dummy); 649 } 650 init = build_special_member_call (NULL_TREE, complete_ctor_identifier, 651 &argvec, inner_type, LOOKUP_NORMAL, 652 complain); 653 release_tree_vector (argvec); 654 655 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But 656 we don't want one here because we aren't creating a temporary. */ 657 if (TREE_CODE (init) == TARGET_EXPR) 658 init = TARGET_EXPR_INITIAL (init); 659 660 return init; 661 } 662 663 /* Return a TARGET_EXPR which expresses the initialization of an array to 664 be named later, either default-initialization or copy-initialization 665 from another array of the same type. */ 666 667 tree 668 build_vec_init_expr (tree type, tree init, tsubst_flags_t complain) 669 { 670 tree slot; 671 bool value_init = false; 672 tree elt_init = build_vec_init_elt (type, init, complain); 673 674 if (init == void_type_node) 675 { 676 value_init = true; 677 init = NULL_TREE; 678 } 679 680 slot = build_local_temp (type); 681 init = build2 (VEC_INIT_EXPR, type, slot, init); 682 TREE_SIDE_EFFECTS (init) = true; 683 SET_EXPR_LOCATION (init, input_location); 684 685 if (cxx_dialect >= cxx11 686 && potential_constant_expression (elt_init)) 687 VEC_INIT_EXPR_IS_CONSTEXPR (init) = true; 688 VEC_INIT_EXPR_VALUE_INIT (init) = value_init; 689 690 return init; 691 } 692 693 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context 694 that requires a constant expression. */ 695 696 void 697 diagnose_non_constexpr_vec_init (tree expr) 698 { 699 tree type = TREE_TYPE (VEC_INIT_EXPR_SLOT (expr)); 700 tree init, elt_init; 701 if (VEC_INIT_EXPR_VALUE_INIT (expr)) 702 init = void_type_node; 703 else 704 init = VEC_INIT_EXPR_INIT (expr); 705 706 elt_init = build_vec_init_elt (type, init, tf_warning_or_error); 707 require_potential_constant_expression (elt_init); 708 } 709 710 tree 711 build_array_copy (tree init) 712 { 713 return build_vec_init_expr (TREE_TYPE (init), init, tf_warning_or_error); 714 } 715 716 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the 717 indicated TYPE. */ 718 719 tree 720 build_target_expr_with_type (tree init, tree type, tsubst_flags_t complain) 721 { 722 gcc_assert (!VOID_TYPE_P (type)); 723 724 if (TREE_CODE (init) == TARGET_EXPR 725 || init == error_mark_node) 726 return init; 727 else if (CLASS_TYPE_P (type) && type_has_nontrivial_copy_init (type) 728 && !VOID_TYPE_P (TREE_TYPE (init)) 729 && TREE_CODE (init) != COND_EXPR 730 && TREE_CODE (init) != CONSTRUCTOR 731 && TREE_CODE (init) != VA_ARG_EXPR) 732 /* We need to build up a copy constructor call. A void initializer 733 means we're being called from bot_manip. COND_EXPR is a special 734 case because we already have copies on the arms and we don't want 735 another one here. A CONSTRUCTOR is aggregate initialization, which 736 is handled separately. A VA_ARG_EXPR is magic creation of an 737 aggregate; there's no additional work to be done. */ 738 return force_rvalue (init, complain); 739 740 return force_target_expr (type, init, complain); 741 } 742 743 /* Like the above function, but without the checking. This function should 744 only be used by code which is deliberately trying to subvert the type 745 system, such as call_builtin_trap. Or build_over_call, to avoid 746 infinite recursion. */ 747 748 tree 749 force_target_expr (tree type, tree init, tsubst_flags_t complain) 750 { 751 tree slot; 752 753 gcc_assert (!VOID_TYPE_P (type)); 754 755 slot = build_local_temp (type); 756 return build_target_expr (slot, init, complain); 757 } 758 759 /* Like build_target_expr_with_type, but use the type of INIT. */ 760 761 tree 762 get_target_expr_sfinae (tree init, tsubst_flags_t complain) 763 { 764 if (TREE_CODE (init) == AGGR_INIT_EXPR) 765 return build_target_expr (AGGR_INIT_EXPR_SLOT (init), init, complain); 766 else if (TREE_CODE (init) == VEC_INIT_EXPR) 767 return build_target_expr (VEC_INIT_EXPR_SLOT (init), init, complain); 768 else 769 { 770 init = convert_bitfield_to_declared_type (init); 771 return build_target_expr_with_type (init, TREE_TYPE (init), complain); 772 } 773 } 774 775 tree 776 get_target_expr (tree init) 777 { 778 return get_target_expr_sfinae (init, tf_warning_or_error); 779 } 780 781 /* If EXPR is a bitfield reference, convert it to the declared type of 782 the bitfield, and return the resulting expression. Otherwise, 783 return EXPR itself. */ 784 785 tree 786 convert_bitfield_to_declared_type (tree expr) 787 { 788 tree bitfield_type; 789 790 bitfield_type = is_bitfield_expr_with_lowered_type (expr); 791 if (bitfield_type) 792 expr = convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type), 793 expr); 794 return expr; 795 } 796 797 /* EXPR is being used in an rvalue context. Return a version of EXPR 798 that is marked as an rvalue. */ 799 800 tree 801 rvalue (tree expr) 802 { 803 tree type; 804 805 if (error_operand_p (expr)) 806 return expr; 807 808 expr = mark_rvalue_use (expr); 809 810 /* [basic.lval] 811 812 Non-class rvalues always have cv-unqualified types. */ 813 type = TREE_TYPE (expr); 814 if (!CLASS_TYPE_P (type) && cv_qualified_p (type)) 815 type = cv_unqualified (type); 816 817 /* We need to do this for rvalue refs as well to get the right answer 818 from decltype; see c++/36628. */ 819 if (!processing_template_decl && glvalue_p (expr)) 820 expr = build1 (NON_LVALUE_EXPR, type, expr); 821 else if (type != TREE_TYPE (expr)) 822 expr = build_nop (type, expr); 823 824 return expr; 825 } 826 827 828 struct cplus_array_info 829 { 830 tree type; 831 tree domain; 832 }; 833 834 struct cplus_array_hasher : ggc_ptr_hash<tree_node> 835 { 836 typedef cplus_array_info *compare_type; 837 838 static hashval_t hash (tree t); 839 static bool equal (tree, cplus_array_info *); 840 }; 841 842 /* Hash an ARRAY_TYPE. K is really of type `tree'. */ 843 844 hashval_t 845 cplus_array_hasher::hash (tree t) 846 { 847 hashval_t hash; 848 849 hash = TYPE_UID (TREE_TYPE (t)); 850 if (TYPE_DOMAIN (t)) 851 hash ^= TYPE_UID (TYPE_DOMAIN (t)); 852 return hash; 853 } 854 855 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really 856 of type `cplus_array_info*'. */ 857 858 bool 859 cplus_array_hasher::equal (tree t1, cplus_array_info *t2) 860 { 861 return (TREE_TYPE (t1) == t2->type && TYPE_DOMAIN (t1) == t2->domain); 862 } 863 864 /* Hash table containing dependent array types, which are unsuitable for 865 the language-independent type hash table. */ 866 static GTY (()) hash_table<cplus_array_hasher> *cplus_array_htab; 867 868 /* Build an ARRAY_TYPE without laying it out. */ 869 870 static tree 871 build_min_array_type (tree elt_type, tree index_type) 872 { 873 tree t = cxx_make_type (ARRAY_TYPE); 874 TREE_TYPE (t) = elt_type; 875 TYPE_DOMAIN (t) = index_type; 876 return t; 877 } 878 879 /* Set TYPE_CANONICAL like build_array_type_1, but using 880 build_cplus_array_type. */ 881 882 static void 883 set_array_type_canon (tree t, tree elt_type, tree index_type) 884 { 885 /* Set the canonical type for this new node. */ 886 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type) 887 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type))) 888 SET_TYPE_STRUCTURAL_EQUALITY (t); 889 else if (TYPE_CANONICAL (elt_type) != elt_type 890 || (index_type && TYPE_CANONICAL (index_type) != index_type)) 891 TYPE_CANONICAL (t) 892 = build_cplus_array_type (TYPE_CANONICAL (elt_type), 893 index_type 894 ? TYPE_CANONICAL (index_type) : index_type); 895 else 896 TYPE_CANONICAL (t) = t; 897 } 898 899 /* Like build_array_type, but handle special C++ semantics: an array of a 900 variant element type is a variant of the array of the main variant of 901 the element type. */ 902 903 tree 904 build_cplus_array_type (tree elt_type, tree index_type) 905 { 906 tree t; 907 908 if (elt_type == error_mark_node || index_type == error_mark_node) 909 return error_mark_node; 910 911 bool dependent = (uses_template_parms (elt_type) 912 || (index_type && uses_template_parms (index_type))); 913 914 if (elt_type != TYPE_MAIN_VARIANT (elt_type)) 915 /* Start with an array of the TYPE_MAIN_VARIANT. */ 916 t = build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type), 917 index_type); 918 else if (dependent) 919 { 920 /* Since type_hash_canon calls layout_type, we need to use our own 921 hash table. */ 922 cplus_array_info cai; 923 hashval_t hash; 924 925 if (cplus_array_htab == NULL) 926 cplus_array_htab = hash_table<cplus_array_hasher>::create_ggc (61); 927 928 hash = TYPE_UID (elt_type); 929 if (index_type) 930 hash ^= TYPE_UID (index_type); 931 cai.type = elt_type; 932 cai.domain = index_type; 933 934 tree *e = cplus_array_htab->find_slot_with_hash (&cai, hash, INSERT); 935 if (*e) 936 /* We have found the type: we're done. */ 937 return (tree) *e; 938 else 939 { 940 /* Build a new array type. */ 941 t = build_min_array_type (elt_type, index_type); 942 943 /* Store it in the hash table. */ 944 *e = t; 945 946 /* Set the canonical type for this new node. */ 947 set_array_type_canon (t, elt_type, index_type); 948 } 949 } 950 else 951 { 952 bool typeless_storage 953 = (elt_type == unsigned_char_type_node 954 || elt_type == signed_char_type_node 955 || elt_type == char_type_node 956 || (TREE_CODE (elt_type) == ENUMERAL_TYPE 957 && TYPE_CONTEXT (elt_type) == std_node 958 && !strcmp ("byte", TYPE_NAME_STRING (elt_type)))); 959 t = build_array_type (elt_type, index_type, typeless_storage); 960 } 961 962 /* Now check whether we already have this array variant. */ 963 if (elt_type != TYPE_MAIN_VARIANT (elt_type)) 964 { 965 tree m = t; 966 for (t = m; t; t = TYPE_NEXT_VARIANT (t)) 967 if (TREE_TYPE (t) == elt_type 968 && TYPE_NAME (t) == NULL_TREE 969 && TYPE_ATTRIBUTES (t) == NULL_TREE) 970 break; 971 if (!t) 972 { 973 t = build_min_array_type (elt_type, index_type); 974 set_array_type_canon (t, elt_type, index_type); 975 if (!dependent) 976 { 977 layout_type (t); 978 /* Make sure sizes are shared with the main variant. 979 layout_type can't be called after setting TYPE_NEXT_VARIANT, 980 as it will overwrite alignment etc. of all variants. */ 981 TYPE_SIZE (t) = TYPE_SIZE (m); 982 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (m); 983 TYPE_TYPELESS_STORAGE (t) = TYPE_TYPELESS_STORAGE (m); 984 } 985 986 TYPE_MAIN_VARIANT (t) = m; 987 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m); 988 TYPE_NEXT_VARIANT (m) = t; 989 } 990 } 991 992 /* Avoid spurious warnings with VLAs (c++/54583). */ 993 if (TYPE_SIZE (t) && EXPR_P (TYPE_SIZE (t))) 994 TREE_NO_WARNING (TYPE_SIZE (t)) = 1; 995 996 /* Push these needs up to the ARRAY_TYPE so that initialization takes 997 place more easily. */ 998 bool needs_ctor = (TYPE_NEEDS_CONSTRUCTING (t) 999 = TYPE_NEEDS_CONSTRUCTING (elt_type)); 1000 bool needs_dtor = (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) 1001 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type)); 1002 1003 if (!dependent && t == TYPE_MAIN_VARIANT (t) 1004 && !COMPLETE_TYPE_P (t) && COMPLETE_TYPE_P (elt_type)) 1005 { 1006 /* The element type has been completed since the last time we saw 1007 this array type; update the layout and 'tor flags for any variants 1008 that need it. */ 1009 layout_type (t); 1010 for (tree v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v)) 1011 { 1012 TYPE_NEEDS_CONSTRUCTING (v) = needs_ctor; 1013 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v) = needs_dtor; 1014 } 1015 } 1016 1017 return t; 1018 } 1019 1020 /* Return an ARRAY_TYPE with element type ELT and length N. */ 1021 1022 tree 1023 build_array_of_n_type (tree elt, int n) 1024 { 1025 return build_cplus_array_type (elt, build_index_type (size_int (n - 1))); 1026 } 1027 1028 /* True iff T is an N3639 array of runtime bound (VLA). These were 1029 approved for C++14 but then removed. */ 1030 1031 bool 1032 array_of_runtime_bound_p (tree t) 1033 { 1034 if (!t || TREE_CODE (t) != ARRAY_TYPE) 1035 return false; 1036 tree dom = TYPE_DOMAIN (t); 1037 if (!dom) 1038 return false; 1039 tree max = TYPE_MAX_VALUE (dom); 1040 return (!potential_rvalue_constant_expression (max) 1041 || (!value_dependent_expression_p (max) && !TREE_CONSTANT (max))); 1042 } 1043 1044 /* Return a reference type node referring to TO_TYPE. If RVAL is 1045 true, return an rvalue reference type, otherwise return an lvalue 1046 reference type. If a type node exists, reuse it, otherwise create 1047 a new one. */ 1048 tree 1049 cp_build_reference_type (tree to_type, bool rval) 1050 { 1051 tree lvalue_ref, t; 1052 1053 if (to_type == error_mark_node) 1054 return error_mark_node; 1055 1056 if (TREE_CODE (to_type) == REFERENCE_TYPE) 1057 { 1058 rval = rval && TYPE_REF_IS_RVALUE (to_type); 1059 to_type = TREE_TYPE (to_type); 1060 } 1061 1062 lvalue_ref = build_reference_type (to_type); 1063 if (!rval) 1064 return lvalue_ref; 1065 1066 /* This code to create rvalue reference types is based on and tied 1067 to the code creating lvalue reference types in the middle-end 1068 functions build_reference_type_for_mode and build_reference_type. 1069 1070 It works by putting the rvalue reference type nodes after the 1071 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so 1072 they will effectively be ignored by the middle end. */ 1073 1074 for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)); ) 1075 if (TYPE_REF_IS_RVALUE (t)) 1076 return t; 1077 1078 t = build_distinct_type_copy (lvalue_ref); 1079 1080 TYPE_REF_IS_RVALUE (t) = true; 1081 TYPE_NEXT_REF_TO (t) = TYPE_NEXT_REF_TO (lvalue_ref); 1082 TYPE_NEXT_REF_TO (lvalue_ref) = t; 1083 1084 if (TYPE_STRUCTURAL_EQUALITY_P (to_type)) 1085 SET_TYPE_STRUCTURAL_EQUALITY (t); 1086 else if (TYPE_CANONICAL (to_type) != to_type) 1087 TYPE_CANONICAL (t) 1088 = cp_build_reference_type (TYPE_CANONICAL (to_type), rval); 1089 else 1090 TYPE_CANONICAL (t) = t; 1091 1092 layout_type (t); 1093 1094 return t; 1095 1096 } 1097 1098 /* Returns EXPR cast to rvalue reference type, like std::move. */ 1099 1100 tree 1101 move (tree expr) 1102 { 1103 tree type = TREE_TYPE (expr); 1104 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE); 1105 type = cp_build_reference_type (type, /*rval*/true); 1106 return build_static_cast (type, expr, tf_warning_or_error); 1107 } 1108 1109 /* Used by the C++ front end to build qualified array types. However, 1110 the C version of this function does not properly maintain canonical 1111 types (which are not used in C). */ 1112 tree 1113 c_build_qualified_type (tree type, int type_quals, tree /* orig_qual_type */, 1114 size_t /* orig_qual_indirect */) 1115 { 1116 return cp_build_qualified_type (type, type_quals); 1117 } 1118 1119 1120 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles 1121 arrays correctly. In particular, if TYPE is an array of T's, and 1122 TYPE_QUALS is non-empty, returns an array of qualified T's. 1123 1124 FLAGS determines how to deal with ill-formed qualifications. If 1125 tf_ignore_bad_quals is set, then bad qualifications are dropped 1126 (this is permitted if TYPE was introduced via a typedef or template 1127 type parameter). If bad qualifications are dropped and tf_warning 1128 is set, then a warning is issued for non-const qualifications. If 1129 tf_ignore_bad_quals is not set and tf_error is not set, we 1130 return error_mark_node. Otherwise, we issue an error, and ignore 1131 the qualifications. 1132 1133 Qualification of a reference type is valid when the reference came 1134 via a typedef or template type argument. [dcl.ref] No such 1135 dispensation is provided for qualifying a function type. [dcl.fct] 1136 DR 295 queries this and the proposed resolution brings it into line 1137 with qualifying a reference. We implement the DR. We also behave 1138 in a similar manner for restricting non-pointer types. */ 1139 1140 tree 1141 cp_build_qualified_type_real (tree type, 1142 int type_quals, 1143 tsubst_flags_t complain) 1144 { 1145 tree result; 1146 int bad_quals = TYPE_UNQUALIFIED; 1147 1148 if (type == error_mark_node) 1149 return type; 1150 1151 if (type_quals == cp_type_quals (type)) 1152 return type; 1153 1154 if (TREE_CODE (type) == ARRAY_TYPE) 1155 { 1156 /* In C++, the qualification really applies to the array element 1157 type. Obtain the appropriately qualified element type. */ 1158 tree t; 1159 tree element_type 1160 = cp_build_qualified_type_real (TREE_TYPE (type), 1161 type_quals, 1162 complain); 1163 1164 if (element_type == error_mark_node) 1165 return error_mark_node; 1166 1167 /* See if we already have an identically qualified type. Tests 1168 should be equivalent to those in check_qualified_type. */ 1169 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) 1170 if (TREE_TYPE (t) == element_type 1171 && TYPE_NAME (t) == TYPE_NAME (type) 1172 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type) 1173 && attribute_list_equal (TYPE_ATTRIBUTES (t), 1174 TYPE_ATTRIBUTES (type))) 1175 break; 1176 1177 if (!t) 1178 { 1179 t = build_cplus_array_type (element_type, TYPE_DOMAIN (type)); 1180 1181 /* Keep the typedef name. */ 1182 if (TYPE_NAME (t) != TYPE_NAME (type)) 1183 { 1184 t = build_variant_type_copy (t); 1185 TYPE_NAME (t) = TYPE_NAME (type); 1186 SET_TYPE_ALIGN (t, TYPE_ALIGN (type)); 1187 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (type); 1188 } 1189 } 1190 1191 /* Even if we already had this variant, we update 1192 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case 1193 they changed since the variant was originally created. 1194 1195 This seems hokey; if there is some way to use a previous 1196 variant *without* coming through here, 1197 TYPE_NEEDS_CONSTRUCTING will never be updated. */ 1198 TYPE_NEEDS_CONSTRUCTING (t) 1199 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type)); 1200 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) 1201 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type)); 1202 return t; 1203 } 1204 else if (TREE_CODE (type) == TYPE_PACK_EXPANSION) 1205 { 1206 tree t = PACK_EXPANSION_PATTERN (type); 1207 1208 t = cp_build_qualified_type_real (t, type_quals, complain); 1209 return make_pack_expansion (t); 1210 } 1211 1212 /* A reference or method type shall not be cv-qualified. 1213 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295 1214 (in CD1) we always ignore extra cv-quals on functions. */ 1215 if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE) 1216 && (TREE_CODE (type) == REFERENCE_TYPE 1217 || TREE_CODE (type) == FUNCTION_TYPE 1218 || TREE_CODE (type) == METHOD_TYPE)) 1219 { 1220 if (TREE_CODE (type) == REFERENCE_TYPE) 1221 bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE); 1222 type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE); 1223 } 1224 1225 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */ 1226 if (TREE_CODE (type) == FUNCTION_TYPE) 1227 type_quals |= type_memfn_quals (type); 1228 1229 /* A restrict-qualified type must be a pointer (or reference) 1230 to object or incomplete type. */ 1231 if ((type_quals & TYPE_QUAL_RESTRICT) 1232 && TREE_CODE (type) != TEMPLATE_TYPE_PARM 1233 && TREE_CODE (type) != TYPENAME_TYPE 1234 && !POINTER_TYPE_P (type)) 1235 { 1236 bad_quals |= TYPE_QUAL_RESTRICT; 1237 type_quals &= ~TYPE_QUAL_RESTRICT; 1238 } 1239 1240 if (bad_quals == TYPE_UNQUALIFIED 1241 || (complain & tf_ignore_bad_quals)) 1242 /*OK*/; 1243 else if (!(complain & tf_error)) 1244 return error_mark_node; 1245 else 1246 { 1247 tree bad_type = build_qualified_type (ptr_type_node, bad_quals); 1248 error ("%qV qualifiers cannot be applied to %qT", 1249 bad_type, type); 1250 } 1251 1252 /* Retrieve (or create) the appropriately qualified variant. */ 1253 result = build_qualified_type (type, type_quals); 1254 1255 /* Preserve exception specs and ref-qualifier since build_qualified_type 1256 doesn't know about them. */ 1257 if (TREE_CODE (result) == FUNCTION_TYPE 1258 || TREE_CODE (result) == METHOD_TYPE) 1259 { 1260 result = build_exception_variant (result, TYPE_RAISES_EXCEPTIONS (type)); 1261 result = build_ref_qualified_type (result, type_memfn_rqual (type)); 1262 } 1263 1264 return result; 1265 } 1266 1267 /* Return TYPE with const and volatile removed. */ 1268 1269 tree 1270 cv_unqualified (tree type) 1271 { 1272 int quals; 1273 1274 if (type == error_mark_node) 1275 return type; 1276 1277 quals = cp_type_quals (type); 1278 quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE); 1279 return cp_build_qualified_type (type, quals); 1280 } 1281 1282 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes 1283 from ATTRIBS that affect type identity, and no others. If any are not 1284 applied, set *remove_attributes to true. */ 1285 1286 static tree 1287 apply_identity_attributes (tree result, tree attribs, bool *remove_attributes) 1288 { 1289 tree first_ident = NULL_TREE; 1290 tree new_attribs = NULL_TREE; 1291 tree *p = &new_attribs; 1292 1293 if (OVERLOAD_TYPE_P (result)) 1294 { 1295 /* On classes and enums all attributes are ingrained. */ 1296 gcc_assert (attribs == TYPE_ATTRIBUTES (result)); 1297 return result; 1298 } 1299 1300 for (tree a = attribs; a; a = TREE_CHAIN (a)) 1301 { 1302 const attribute_spec *as 1303 = lookup_attribute_spec (get_attribute_name (a)); 1304 if (as && as->affects_type_identity) 1305 { 1306 if (!first_ident) 1307 first_ident = a; 1308 else if (first_ident == error_mark_node) 1309 { 1310 *p = tree_cons (TREE_PURPOSE (a), TREE_VALUE (a), NULL_TREE); 1311 p = &TREE_CHAIN (*p); 1312 } 1313 } 1314 else if (first_ident) 1315 { 1316 for (tree a2 = first_ident; a2; a2 = TREE_CHAIN (a2)) 1317 { 1318 *p = tree_cons (TREE_PURPOSE (a2), TREE_VALUE (a2), NULL_TREE); 1319 p = &TREE_CHAIN (*p); 1320 } 1321 first_ident = error_mark_node; 1322 } 1323 } 1324 if (first_ident != error_mark_node) 1325 new_attribs = first_ident; 1326 1327 if (first_ident == attribs) 1328 /* All attributes affected type identity. */; 1329 else 1330 *remove_attributes = true; 1331 1332 return cp_build_type_attribute_variant (result, new_attribs); 1333 } 1334 1335 /* Builds a qualified variant of T that is not a typedef variant. 1336 E.g. consider the following declarations: 1337 typedef const int ConstInt; 1338 typedef ConstInt* PtrConstInt; 1339 If T is PtrConstInt, this function returns a type representing 1340 const int*. 1341 In other words, if T is a typedef, the function returns the underlying type. 1342 The cv-qualification and attributes of the type returned match the 1343 input type. 1344 They will always be compatible types. 1345 The returned type is built so that all of its subtypes 1346 recursively have their typedefs stripped as well. 1347 1348 This is different from just returning TYPE_CANONICAL (T) 1349 Because of several reasons: 1350 * If T is a type that needs structural equality 1351 its TYPE_CANONICAL (T) will be NULL. 1352 * TYPE_CANONICAL (T) desn't carry type attributes 1353 and loses template parameter names. 1354 1355 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't 1356 affect type identity, and set the referent to true if any were 1357 stripped. */ 1358 1359 tree 1360 strip_typedefs (tree t, bool *remove_attributes) 1361 { 1362 tree result = NULL, type = NULL, t0 = NULL; 1363 1364 if (!t || t == error_mark_node) 1365 return t; 1366 1367 if (TREE_CODE (t) == TREE_LIST) 1368 { 1369 bool changed = false; 1370 vec<tree,va_gc> *vec = make_tree_vector (); 1371 tree r = t; 1372 for (; t; t = TREE_CHAIN (t)) 1373 { 1374 gcc_assert (!TREE_PURPOSE (t)); 1375 tree elt = strip_typedefs (TREE_VALUE (t), remove_attributes); 1376 if (elt != TREE_VALUE (t)) 1377 changed = true; 1378 vec_safe_push (vec, elt); 1379 } 1380 if (changed) 1381 r = build_tree_list_vec (vec); 1382 release_tree_vector (vec); 1383 return r; 1384 } 1385 1386 gcc_assert (TYPE_P (t)); 1387 1388 if (t == TYPE_CANONICAL (t)) 1389 return t; 1390 1391 if (dependent_alias_template_spec_p (t)) 1392 /* DR 1558: However, if the template-id is dependent, subsequent 1393 template argument substitution still applies to the template-id. */ 1394 return t; 1395 1396 switch (TREE_CODE (t)) 1397 { 1398 case POINTER_TYPE: 1399 type = strip_typedefs (TREE_TYPE (t), remove_attributes); 1400 result = build_pointer_type (type); 1401 break; 1402 case REFERENCE_TYPE: 1403 type = strip_typedefs (TREE_TYPE (t), remove_attributes); 1404 result = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t)); 1405 break; 1406 case OFFSET_TYPE: 1407 t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t), remove_attributes); 1408 type = strip_typedefs (TREE_TYPE (t), remove_attributes); 1409 result = build_offset_type (t0, type); 1410 break; 1411 case RECORD_TYPE: 1412 if (TYPE_PTRMEMFUNC_P (t)) 1413 { 1414 t0 = strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t), remove_attributes); 1415 result = build_ptrmemfunc_type (t0); 1416 } 1417 break; 1418 case ARRAY_TYPE: 1419 type = strip_typedefs (TREE_TYPE (t), remove_attributes); 1420 t0 = strip_typedefs (TYPE_DOMAIN (t), remove_attributes); 1421 result = build_cplus_array_type (type, t0); 1422 break; 1423 case FUNCTION_TYPE: 1424 case METHOD_TYPE: 1425 { 1426 tree arg_types = NULL, arg_node, arg_node2, arg_type; 1427 bool changed; 1428 1429 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places 1430 around the compiler (e.g. cp_parser_late_parsing_default_args), we 1431 can't expect that re-hashing a function type will find a previous 1432 equivalent type, so try to reuse the input type if nothing has 1433 changed. If the type is itself a variant, that will change. */ 1434 bool is_variant = typedef_variant_p (t); 1435 if (remove_attributes 1436 && (TYPE_ATTRIBUTES (t) || TYPE_USER_ALIGN (t))) 1437 is_variant = true; 1438 1439 type = strip_typedefs (TREE_TYPE (t), remove_attributes); 1440 changed = type != TREE_TYPE (t) || is_variant; 1441 1442 for (arg_node = TYPE_ARG_TYPES (t); 1443 arg_node; 1444 arg_node = TREE_CHAIN (arg_node)) 1445 { 1446 if (arg_node == void_list_node) 1447 break; 1448 arg_type = strip_typedefs (TREE_VALUE (arg_node), 1449 remove_attributes); 1450 gcc_assert (arg_type); 1451 if (arg_type == TREE_VALUE (arg_node) && !changed) 1452 continue; 1453 1454 if (!changed) 1455 { 1456 changed = true; 1457 for (arg_node2 = TYPE_ARG_TYPES (t); 1458 arg_node2 != arg_node; 1459 arg_node2 = TREE_CHAIN (arg_node2)) 1460 arg_types 1461 = tree_cons (TREE_PURPOSE (arg_node2), 1462 TREE_VALUE (arg_node2), arg_types); 1463 } 1464 1465 arg_types 1466 = tree_cons (TREE_PURPOSE (arg_node), arg_type, arg_types); 1467 } 1468 1469 if (!changed) 1470 return t; 1471 1472 if (arg_types) 1473 arg_types = nreverse (arg_types); 1474 1475 /* A list of parameters not ending with an ellipsis 1476 must end with void_list_node. */ 1477 if (arg_node) 1478 arg_types = chainon (arg_types, void_list_node); 1479 1480 if (TREE_CODE (t) == METHOD_TYPE) 1481 { 1482 tree class_type = TREE_TYPE (TREE_VALUE (arg_types)); 1483 gcc_assert (class_type); 1484 result = 1485 build_method_type_directly (class_type, type, 1486 TREE_CHAIN (arg_types)); 1487 result 1488 = build_ref_qualified_type (result, type_memfn_rqual (t)); 1489 } 1490 else 1491 { 1492 result = build_function_type (type, 1493 arg_types); 1494 result = apply_memfn_quals (result, 1495 type_memfn_quals (t), 1496 type_memfn_rqual (t)); 1497 } 1498 1499 if (TYPE_RAISES_EXCEPTIONS (t)) 1500 result = build_exception_variant (result, 1501 TYPE_RAISES_EXCEPTIONS (t)); 1502 if (TYPE_HAS_LATE_RETURN_TYPE (t)) 1503 TYPE_HAS_LATE_RETURN_TYPE (result) = 1; 1504 } 1505 break; 1506 case TYPENAME_TYPE: 1507 { 1508 tree fullname = TYPENAME_TYPE_FULLNAME (t); 1509 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR 1510 && TREE_OPERAND (fullname, 1)) 1511 { 1512 tree args = TREE_OPERAND (fullname, 1); 1513 tree new_args = copy_node (args); 1514 bool changed = false; 1515 for (int i = 0; i < TREE_VEC_LENGTH (args); ++i) 1516 { 1517 tree arg = TREE_VEC_ELT (args, i); 1518 tree strip_arg; 1519 if (TYPE_P (arg)) 1520 strip_arg = strip_typedefs (arg, remove_attributes); 1521 else 1522 strip_arg = strip_typedefs_expr (arg, remove_attributes); 1523 TREE_VEC_ELT (new_args, i) = strip_arg; 1524 if (strip_arg != arg) 1525 changed = true; 1526 } 1527 if (changed) 1528 { 1529 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args) 1530 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args); 1531 fullname 1532 = lookup_template_function (TREE_OPERAND (fullname, 0), 1533 new_args); 1534 } 1535 else 1536 ggc_free (new_args); 1537 } 1538 result = make_typename_type (strip_typedefs (TYPE_CONTEXT (t), 1539 remove_attributes), 1540 fullname, typename_type, tf_none); 1541 /* Handle 'typedef typename A::N N;' */ 1542 if (typedef_variant_p (result)) 1543 result = TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (result))); 1544 } 1545 break; 1546 case DECLTYPE_TYPE: 1547 result = strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t), 1548 remove_attributes); 1549 if (result == DECLTYPE_TYPE_EXPR (t)) 1550 result = NULL_TREE; 1551 else 1552 result = (finish_decltype_type 1553 (result, 1554 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t), 1555 tf_none)); 1556 break; 1557 case UNDERLYING_TYPE: 1558 type = strip_typedefs (UNDERLYING_TYPE_TYPE (t), remove_attributes); 1559 result = finish_underlying_type (type); 1560 break; 1561 default: 1562 break; 1563 } 1564 1565 if (!result) 1566 { 1567 if (typedef_variant_p (t)) 1568 { 1569 /* Explicitly get the underlying type, as TYPE_MAIN_VARIANT doesn't 1570 strip typedefs with attributes. */ 1571 result = TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (t))); 1572 result = strip_typedefs (result); 1573 } 1574 else 1575 result = TYPE_MAIN_VARIANT (t); 1576 } 1577 gcc_assert (!typedef_variant_p (result)); 1578 1579 if (COMPLETE_TYPE_P (result) && !COMPLETE_TYPE_P (t)) 1580 /* If RESULT is complete and T isn't, it's likely the case that T 1581 is a variant of RESULT which hasn't been updated yet. Skip the 1582 attribute handling. */; 1583 else 1584 { 1585 if (TYPE_USER_ALIGN (t) != TYPE_USER_ALIGN (result) 1586 || TYPE_ALIGN (t) != TYPE_ALIGN (result)) 1587 { 1588 gcc_assert (TYPE_USER_ALIGN (t)); 1589 if (remove_attributes) 1590 *remove_attributes = true; 1591 else 1592 { 1593 if (TYPE_ALIGN (t) == TYPE_ALIGN (result)) 1594 result = build_variant_type_copy (result); 1595 else 1596 result = build_aligned_type (result, TYPE_ALIGN (t)); 1597 TYPE_USER_ALIGN (result) = true; 1598 } 1599 } 1600 1601 if (TYPE_ATTRIBUTES (t)) 1602 { 1603 if (remove_attributes) 1604 result = apply_identity_attributes (result, TYPE_ATTRIBUTES (t), 1605 remove_attributes); 1606 else 1607 result = cp_build_type_attribute_variant (result, 1608 TYPE_ATTRIBUTES (t)); 1609 } 1610 } 1611 1612 return cp_build_qualified_type (result, cp_type_quals (t)); 1613 } 1614 1615 /* Like strip_typedefs above, but works on expressions, so that in 1616 1617 template<class T> struct A 1618 { 1619 typedef T TT; 1620 B<sizeof(TT)> b; 1621 }; 1622 1623 sizeof(TT) is replaced by sizeof(T). */ 1624 1625 tree 1626 strip_typedefs_expr (tree t, bool *remove_attributes) 1627 { 1628 unsigned i,n; 1629 tree r, type, *ops; 1630 enum tree_code code; 1631 1632 if (t == NULL_TREE || t == error_mark_node) 1633 return t; 1634 1635 if (DECL_P (t) || CONSTANT_CLASS_P (t)) 1636 return t; 1637 1638 /* Some expressions have type operands, so let's handle types here rather 1639 than check TYPE_P in multiple places below. */ 1640 if (TYPE_P (t)) 1641 return strip_typedefs (t, remove_attributes); 1642 1643 code = TREE_CODE (t); 1644 switch (code) 1645 { 1646 case IDENTIFIER_NODE: 1647 case TEMPLATE_PARM_INDEX: 1648 case OVERLOAD: 1649 case BASELINK: 1650 case ARGUMENT_PACK_SELECT: 1651 return t; 1652 1653 case TRAIT_EXPR: 1654 { 1655 tree type1 = strip_typedefs (TRAIT_EXPR_TYPE1 (t), remove_attributes); 1656 tree type2 = strip_typedefs (TRAIT_EXPR_TYPE2 (t), remove_attributes); 1657 if (type1 == TRAIT_EXPR_TYPE1 (t) 1658 && type2 == TRAIT_EXPR_TYPE2 (t)) 1659 return t; 1660 r = copy_node (t); 1661 TRAIT_EXPR_TYPE1 (r) = type1; 1662 TRAIT_EXPR_TYPE2 (r) = type2; 1663 return r; 1664 } 1665 1666 case TREE_LIST: 1667 { 1668 vec<tree, va_gc> *vec = make_tree_vector (); 1669 bool changed = false; 1670 tree it; 1671 for (it = t; it; it = TREE_CHAIN (it)) 1672 { 1673 tree val = strip_typedefs_expr (TREE_VALUE (it), remove_attributes); 1674 vec_safe_push (vec, val); 1675 if (val != TREE_VALUE (it)) 1676 changed = true; 1677 gcc_assert (TREE_PURPOSE (it) == NULL_TREE); 1678 } 1679 if (changed) 1680 { 1681 r = NULL_TREE; 1682 FOR_EACH_VEC_ELT_REVERSE (*vec, i, it) 1683 r = tree_cons (NULL_TREE, it, r); 1684 } 1685 else 1686 r = t; 1687 release_tree_vector (vec); 1688 return r; 1689 } 1690 1691 case TREE_VEC: 1692 { 1693 bool changed = false; 1694 vec<tree, va_gc> *vec = make_tree_vector (); 1695 n = TREE_VEC_LENGTH (t); 1696 vec_safe_reserve (vec, n); 1697 for (i = 0; i < n; ++i) 1698 { 1699 tree op = strip_typedefs_expr (TREE_VEC_ELT (t, i), 1700 remove_attributes); 1701 vec->quick_push (op); 1702 if (op != TREE_VEC_ELT (t, i)) 1703 changed = true; 1704 } 1705 if (changed) 1706 { 1707 r = copy_node (t); 1708 for (i = 0; i < n; ++i) 1709 TREE_VEC_ELT (r, i) = (*vec)[i]; 1710 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r) 1711 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t); 1712 } 1713 else 1714 r = t; 1715 release_tree_vector (vec); 1716 return r; 1717 } 1718 1719 case CONSTRUCTOR: 1720 { 1721 bool changed = false; 1722 vec<constructor_elt, va_gc> *vec 1723 = vec_safe_copy (CONSTRUCTOR_ELTS (t)); 1724 n = CONSTRUCTOR_NELTS (t); 1725 type = strip_typedefs (TREE_TYPE (t), remove_attributes); 1726 for (i = 0; i < n; ++i) 1727 { 1728 constructor_elt *e = &(*vec)[i]; 1729 tree op = strip_typedefs_expr (e->value, remove_attributes); 1730 if (op != e->value) 1731 { 1732 changed = true; 1733 e->value = op; 1734 } 1735 gcc_checking_assert 1736 (e->index == strip_typedefs_expr (e->index, remove_attributes)); 1737 } 1738 1739 if (!changed && type == TREE_TYPE (t)) 1740 { 1741 vec_free (vec); 1742 return t; 1743 } 1744 else 1745 { 1746 r = copy_node (t); 1747 TREE_TYPE (r) = type; 1748 CONSTRUCTOR_ELTS (r) = vec; 1749 return r; 1750 } 1751 } 1752 1753 case LAMBDA_EXPR: 1754 error ("lambda-expression in a constant expression"); 1755 return error_mark_node; 1756 1757 default: 1758 break; 1759 } 1760 1761 gcc_assert (EXPR_P (t)); 1762 1763 n = TREE_OPERAND_LENGTH (t); 1764 ops = XALLOCAVEC (tree, n); 1765 type = TREE_TYPE (t); 1766 1767 switch (code) 1768 { 1769 CASE_CONVERT: 1770 case IMPLICIT_CONV_EXPR: 1771 case DYNAMIC_CAST_EXPR: 1772 case STATIC_CAST_EXPR: 1773 case CONST_CAST_EXPR: 1774 case REINTERPRET_CAST_EXPR: 1775 case CAST_EXPR: 1776 case NEW_EXPR: 1777 type = strip_typedefs (type, remove_attributes); 1778 /* fallthrough */ 1779 1780 default: 1781 for (i = 0; i < n; ++i) 1782 ops[i] = strip_typedefs_expr (TREE_OPERAND (t, i), remove_attributes); 1783 break; 1784 } 1785 1786 /* If nothing changed, return t. */ 1787 for (i = 0; i < n; ++i) 1788 if (ops[i] != TREE_OPERAND (t, i)) 1789 break; 1790 if (i == n && type == TREE_TYPE (t)) 1791 return t; 1792 1793 r = copy_node (t); 1794 TREE_TYPE (r) = type; 1795 for (i = 0; i < n; ++i) 1796 TREE_OPERAND (r, i) = ops[i]; 1797 return r; 1798 } 1799 1800 /* Makes a copy of BINFO and TYPE, which is to be inherited into a 1801 graph dominated by T. If BINFO is NULL, TYPE is a dependent base, 1802 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy. 1803 VIRT indicates whether TYPE is inherited virtually or not. 1804 IGO_PREV points at the previous binfo of the inheritance graph 1805 order chain. The newly copied binfo's TREE_CHAIN forms this 1806 ordering. 1807 1808 The CLASSTYPE_VBASECLASSES vector of T is constructed in the 1809 correct order. That is in the order the bases themselves should be 1810 constructed in. 1811 1812 The BINFO_INHERITANCE of a virtual base class points to the binfo 1813 of the most derived type. ??? We could probably change this so that 1814 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence 1815 remove a field. They currently can only differ for primary virtual 1816 virtual bases. */ 1817 1818 tree 1819 copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt) 1820 { 1821 tree new_binfo; 1822 1823 if (virt) 1824 { 1825 /* See if we've already made this virtual base. */ 1826 new_binfo = binfo_for_vbase (type, t); 1827 if (new_binfo) 1828 return new_binfo; 1829 } 1830 1831 new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0); 1832 BINFO_TYPE (new_binfo) = type; 1833 1834 /* Chain it into the inheritance graph. */ 1835 TREE_CHAIN (*igo_prev) = new_binfo; 1836 *igo_prev = new_binfo; 1837 1838 if (binfo && !BINFO_DEPENDENT_BASE_P (binfo)) 1839 { 1840 int ix; 1841 tree base_binfo; 1842 1843 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type)); 1844 1845 BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo); 1846 BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo); 1847 1848 /* We do not need to copy the accesses, as they are read only. */ 1849 BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo); 1850 1851 /* Recursively copy base binfos of BINFO. */ 1852 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++) 1853 { 1854 tree new_base_binfo; 1855 new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo), 1856 t, igo_prev, 1857 BINFO_VIRTUAL_P (base_binfo)); 1858 1859 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo)) 1860 BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo; 1861 BINFO_BASE_APPEND (new_binfo, new_base_binfo); 1862 } 1863 } 1864 else 1865 BINFO_DEPENDENT_BASE_P (new_binfo) = 1; 1866 1867 if (virt) 1868 { 1869 /* Push it onto the list after any virtual bases it contains 1870 will have been pushed. */ 1871 CLASSTYPE_VBASECLASSES (t)->quick_push (new_binfo); 1872 BINFO_VIRTUAL_P (new_binfo) = 1; 1873 BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t); 1874 } 1875 1876 return new_binfo; 1877 } 1878 1879 /* Hashing of lists so that we don't make duplicates. 1880 The entry point is `list_hash_canon'. */ 1881 1882 struct list_proxy 1883 { 1884 tree purpose; 1885 tree value; 1886 tree chain; 1887 }; 1888 1889 struct list_hasher : ggc_ptr_hash<tree_node> 1890 { 1891 typedef list_proxy *compare_type; 1892 1893 static hashval_t hash (tree); 1894 static bool equal (tree, list_proxy *); 1895 }; 1896 1897 /* Now here is the hash table. When recording a list, it is added 1898 to the slot whose index is the hash code mod the table size. 1899 Note that the hash table is used for several kinds of lists. 1900 While all these live in the same table, they are completely independent, 1901 and the hash code is computed differently for each of these. */ 1902 1903 static GTY (()) hash_table<list_hasher> *list_hash_table; 1904 1905 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy 1906 for a node we are thinking about adding). */ 1907 1908 bool 1909 list_hasher::equal (tree t, list_proxy *proxy) 1910 { 1911 return (TREE_VALUE (t) == proxy->value 1912 && TREE_PURPOSE (t) == proxy->purpose 1913 && TREE_CHAIN (t) == proxy->chain); 1914 } 1915 1916 /* Compute a hash code for a list (chain of TREE_LIST nodes 1917 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the 1918 TREE_COMMON slots), by adding the hash codes of the individual entries. */ 1919 1920 static hashval_t 1921 list_hash_pieces (tree purpose, tree value, tree chain) 1922 { 1923 hashval_t hashcode = 0; 1924 1925 if (chain) 1926 hashcode += TREE_HASH (chain); 1927 1928 if (value) 1929 hashcode += TREE_HASH (value); 1930 else 1931 hashcode += 1007; 1932 if (purpose) 1933 hashcode += TREE_HASH (purpose); 1934 else 1935 hashcode += 1009; 1936 return hashcode; 1937 } 1938 1939 /* Hash an already existing TREE_LIST. */ 1940 1941 hashval_t 1942 list_hasher::hash (tree t) 1943 { 1944 return list_hash_pieces (TREE_PURPOSE (t), 1945 TREE_VALUE (t), 1946 TREE_CHAIN (t)); 1947 } 1948 1949 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical 1950 object for an identical list if one already exists. Otherwise, build a 1951 new one, and record it as the canonical object. */ 1952 1953 tree 1954 hash_tree_cons (tree purpose, tree value, tree chain) 1955 { 1956 int hashcode = 0; 1957 tree *slot; 1958 struct list_proxy proxy; 1959 1960 /* Hash the list node. */ 1961 hashcode = list_hash_pieces (purpose, value, chain); 1962 /* Create a proxy for the TREE_LIST we would like to create. We 1963 don't actually create it so as to avoid creating garbage. */ 1964 proxy.purpose = purpose; 1965 proxy.value = value; 1966 proxy.chain = chain; 1967 /* See if it is already in the table. */ 1968 slot = list_hash_table->find_slot_with_hash (&proxy, hashcode, INSERT); 1969 /* If not, create a new node. */ 1970 if (!*slot) 1971 *slot = tree_cons (purpose, value, chain); 1972 return (tree) *slot; 1973 } 1974 1975 /* Constructor for hashed lists. */ 1976 1977 tree 1978 hash_tree_chain (tree value, tree chain) 1979 { 1980 return hash_tree_cons (NULL_TREE, value, chain); 1981 } 1982 1983 void 1984 debug_binfo (tree elem) 1985 { 1986 HOST_WIDE_INT n; 1987 tree virtuals; 1988 1989 fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC 1990 "\nvtable type:\n", 1991 TYPE_NAME_STRING (BINFO_TYPE (elem)), 1992 TREE_INT_CST_LOW (BINFO_OFFSET (elem))); 1993 debug_tree (BINFO_TYPE (elem)); 1994 if (BINFO_VTABLE (elem)) 1995 fprintf (stderr, "vtable decl \"%s\"\n", 1996 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem)))); 1997 else 1998 fprintf (stderr, "no vtable decl yet\n"); 1999 fprintf (stderr, "virtuals:\n"); 2000 virtuals = BINFO_VIRTUALS (elem); 2001 n = 0; 2002 2003 while (virtuals) 2004 { 2005 tree fndecl = TREE_VALUE (virtuals); 2006 fprintf (stderr, "%s [%ld =? %ld]\n", 2007 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)), 2008 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl))); 2009 ++n; 2010 virtuals = TREE_CHAIN (virtuals); 2011 } 2012 } 2013 2014 /* Build a representation for the qualified name SCOPE::NAME. TYPE is 2015 the type of the result expression, if known, or NULL_TREE if the 2016 resulting expression is type-dependent. If TEMPLATE_P is true, 2017 NAME is known to be a template because the user explicitly used the 2018 "template" keyword after the "::". 2019 2020 All SCOPE_REFs should be built by use of this function. */ 2021 2022 tree 2023 build_qualified_name (tree type, tree scope, tree name, bool template_p) 2024 { 2025 tree t; 2026 if (type == error_mark_node 2027 || scope == error_mark_node 2028 || name == error_mark_node) 2029 return error_mark_node; 2030 t = build2 (SCOPE_REF, type, scope, name); 2031 QUALIFIED_NAME_IS_TEMPLATE (t) = template_p; 2032 PTRMEM_OK_P (t) = true; 2033 if (type) 2034 t = convert_from_reference (t); 2035 return t; 2036 } 2037 2038 /* Like check_qualified_type, but also check ref-qualifier and exception 2039 specification. */ 2040 2041 static bool 2042 cp_check_qualified_type (const_tree cand, const_tree base, int type_quals, 2043 cp_ref_qualifier rqual, tree raises) 2044 { 2045 return (TYPE_QUALS (cand) == type_quals 2046 && check_base_type (cand, base) 2047 && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (cand), 2048 ce_exact) 2049 && type_memfn_rqual (cand) == rqual); 2050 } 2051 2052 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */ 2053 2054 tree 2055 build_ref_qualified_type (tree type, cp_ref_qualifier rqual) 2056 { 2057 tree t; 2058 2059 if (rqual == type_memfn_rqual (type)) 2060 return type; 2061 2062 int type_quals = TYPE_QUALS (type); 2063 tree raises = TYPE_RAISES_EXCEPTIONS (type); 2064 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) 2065 if (cp_check_qualified_type (t, type, type_quals, rqual, raises)) 2066 return t; 2067 2068 t = build_variant_type_copy (type); 2069 switch (rqual) 2070 { 2071 case REF_QUAL_RVALUE: 2072 FUNCTION_RVALUE_QUALIFIED (t) = 1; 2073 FUNCTION_REF_QUALIFIED (t) = 1; 2074 break; 2075 case REF_QUAL_LVALUE: 2076 FUNCTION_RVALUE_QUALIFIED (t) = 0; 2077 FUNCTION_REF_QUALIFIED (t) = 1; 2078 break; 2079 default: 2080 FUNCTION_REF_QUALIFIED (t) = 0; 2081 break; 2082 } 2083 2084 if (TYPE_STRUCTURAL_EQUALITY_P (type)) 2085 /* Propagate structural equality. */ 2086 SET_TYPE_STRUCTURAL_EQUALITY (t); 2087 else if (TYPE_CANONICAL (type) != type) 2088 /* Build the underlying canonical type, since it is different 2089 from TYPE. */ 2090 TYPE_CANONICAL (t) = build_ref_qualified_type (TYPE_CANONICAL (type), 2091 rqual); 2092 else 2093 /* T is its own canonical type. */ 2094 TYPE_CANONICAL (t) = t; 2095 2096 return t; 2097 } 2098 2099 /* Returns nonzero if X is an expression for a (possibly overloaded) 2100 function. If "f" is a function or function template, "f", "c->f", 2101 "c.f", "C::f", and "f<int>" will all be considered possibly 2102 overloaded functions. Returns 2 if the function is actually 2103 overloaded, i.e., if it is impossible to know the type of the 2104 function without performing overload resolution. */ 2105 2106 int 2107 is_overloaded_fn (tree x) 2108 { 2109 /* A baselink is also considered an overloaded function. */ 2110 if (TREE_CODE (x) == OFFSET_REF 2111 || TREE_CODE (x) == COMPONENT_REF) 2112 x = TREE_OPERAND (x, 1); 2113 if (BASELINK_P (x)) 2114 x = BASELINK_FUNCTIONS (x); 2115 if (TREE_CODE (x) == TEMPLATE_ID_EXPR) 2116 x = TREE_OPERAND (x, 0); 2117 if (DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x)) 2118 || (TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x))) 2119 return 2; 2120 return (TREE_CODE (x) == FUNCTION_DECL 2121 || TREE_CODE (x) == OVERLOAD); 2122 } 2123 2124 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name 2125 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return 2126 NULL_TREE. */ 2127 2128 tree 2129 dependent_name (tree x) 2130 { 2131 if (identifier_p (x)) 2132 return x; 2133 if (TREE_CODE (x) != COMPONENT_REF 2134 && TREE_CODE (x) != OFFSET_REF 2135 && TREE_CODE (x) != BASELINK 2136 && is_overloaded_fn (x)) 2137 return DECL_NAME (get_first_fn (x)); 2138 return NULL_TREE; 2139 } 2140 2141 /* Returns true iff X is an expression for an overloaded function 2142 whose type cannot be known without performing overload 2143 resolution. */ 2144 2145 bool 2146 really_overloaded_fn (tree x) 2147 { 2148 return is_overloaded_fn (x) == 2; 2149 } 2150 2151 tree 2152 get_fns (tree from) 2153 { 2154 gcc_assert (is_overloaded_fn (from)); 2155 /* A baselink is also considered an overloaded function. */ 2156 if (TREE_CODE (from) == OFFSET_REF 2157 || TREE_CODE (from) == COMPONENT_REF) 2158 from = TREE_OPERAND (from, 1); 2159 if (BASELINK_P (from)) 2160 from = BASELINK_FUNCTIONS (from); 2161 if (TREE_CODE (from) == TEMPLATE_ID_EXPR) 2162 from = TREE_OPERAND (from, 0); 2163 return from; 2164 } 2165 2166 tree 2167 get_first_fn (tree from) 2168 { 2169 return OVL_CURRENT (get_fns (from)); 2170 } 2171 2172 /* Return a new OVL node, concatenating it with the old one. */ 2173 2174 tree 2175 ovl_cons (tree decl, tree chain) 2176 { 2177 tree result = make_node (OVERLOAD); 2178 TREE_TYPE (result) = unknown_type_node; 2179 OVL_FUNCTION (result) = decl; 2180 TREE_CHAIN (result) = chain; 2181 2182 return result; 2183 } 2184 2185 /* Build a new overloaded function. If this is the first one, 2186 just return it; otherwise, ovl_cons the _DECLs */ 2187 2188 tree 2189 build_overload (tree decl, tree chain) 2190 { 2191 if (! chain && TREE_CODE (decl) != TEMPLATE_DECL) 2192 return decl; 2193 return ovl_cons (decl, chain); 2194 } 2195 2196 /* Return the scope where the overloaded functions OVL were found. */ 2197 2198 tree 2199 ovl_scope (tree ovl) 2200 { 2201 if (TREE_CODE (ovl) == OFFSET_REF 2202 || TREE_CODE (ovl) == COMPONENT_REF) 2203 ovl = TREE_OPERAND (ovl, 1); 2204 if (TREE_CODE (ovl) == BASELINK) 2205 return BINFO_TYPE (BASELINK_BINFO (ovl)); 2206 if (TREE_CODE (ovl) == TEMPLATE_ID_EXPR) 2207 ovl = TREE_OPERAND (ovl, 0); 2208 /* Skip using-declarations. */ 2209 while (TREE_CODE (ovl) == OVERLOAD && OVL_USED (ovl) && OVL_CHAIN (ovl)) 2210 ovl = OVL_CHAIN (ovl); 2211 return CP_DECL_CONTEXT (OVL_CURRENT (ovl)); 2212 } 2213 2214 #define PRINT_RING_SIZE 4 2215 2216 static const char * 2217 cxx_printable_name_internal (tree decl, int v, bool translate) 2218 { 2219 static unsigned int uid_ring[PRINT_RING_SIZE]; 2220 static char *print_ring[PRINT_RING_SIZE]; 2221 static bool trans_ring[PRINT_RING_SIZE]; 2222 static int ring_counter; 2223 int i; 2224 2225 /* Only cache functions. */ 2226 if (v < 2 2227 || TREE_CODE (decl) != FUNCTION_DECL 2228 || DECL_LANG_SPECIFIC (decl) == 0) 2229 return lang_decl_name (decl, v, translate); 2230 2231 /* See if this print name is lying around. */ 2232 for (i = 0; i < PRINT_RING_SIZE; i++) 2233 if (uid_ring[i] == DECL_UID (decl) && translate == trans_ring[i]) 2234 /* yes, so return it. */ 2235 return print_ring[i]; 2236 2237 if (++ring_counter == PRINT_RING_SIZE) 2238 ring_counter = 0; 2239 2240 if (current_function_decl != NULL_TREE) 2241 { 2242 /* There may be both translated and untranslated versions of the 2243 name cached. */ 2244 for (i = 0; i < 2; i++) 2245 { 2246 if (uid_ring[ring_counter] == DECL_UID (current_function_decl)) 2247 ring_counter += 1; 2248 if (ring_counter == PRINT_RING_SIZE) 2249 ring_counter = 0; 2250 } 2251 gcc_assert (uid_ring[ring_counter] != DECL_UID (current_function_decl)); 2252 } 2253 2254 free (print_ring[ring_counter]); 2255 2256 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v, translate)); 2257 uid_ring[ring_counter] = DECL_UID (decl); 2258 trans_ring[ring_counter] = translate; 2259 return print_ring[ring_counter]; 2260 } 2261 2262 const char * 2263 cxx_printable_name (tree decl, int v) 2264 { 2265 return cxx_printable_name_internal (decl, v, false); 2266 } 2267 2268 const char * 2269 cxx_printable_name_translate (tree decl, int v) 2270 { 2271 return cxx_printable_name_internal (decl, v, true); 2272 } 2273 2274 /* Return the canonical version of exception-specification RAISES for a C++17 2275 function type, for use in type comparison and building TYPE_CANONICAL. */ 2276 2277 tree 2278 canonical_eh_spec (tree raises) 2279 { 2280 if (raises == NULL_TREE) 2281 return raises; 2282 else if (DEFERRED_NOEXCEPT_SPEC_P (raises) 2283 || uses_template_parms (raises) 2284 || uses_template_parms (TREE_PURPOSE (raises))) 2285 /* Keep a dependent or deferred exception specification. */ 2286 return raises; 2287 else if (nothrow_spec_p (raises)) 2288 /* throw() -> noexcept. */ 2289 return noexcept_true_spec; 2290 else 2291 /* For C++17 type matching, anything else -> nothing. */ 2292 return NULL_TREE; 2293 } 2294 2295 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions 2296 listed in RAISES. */ 2297 2298 tree 2299 build_exception_variant (tree type, tree raises) 2300 { 2301 tree v; 2302 int type_quals; 2303 2304 if (comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (type), ce_exact)) 2305 return type; 2306 2307 type_quals = TYPE_QUALS (type); 2308 cp_ref_qualifier rqual = type_memfn_rqual (type); 2309 for (v = TYPE_MAIN_VARIANT (type); v; v = TYPE_NEXT_VARIANT (v)) 2310 if (cp_check_qualified_type (v, type, type_quals, rqual, raises)) 2311 return v; 2312 2313 /* Need to build a new variant. */ 2314 v = build_variant_type_copy (type); 2315 TYPE_RAISES_EXCEPTIONS (v) = raises; 2316 2317 if (!flag_noexcept_type) 2318 /* The exception-specification is not part of the canonical type. */ 2319 return v; 2320 2321 /* Canonicalize the exception specification. */ 2322 tree cr = canonical_eh_spec (raises); 2323 2324 if (TYPE_STRUCTURAL_EQUALITY_P (type)) 2325 /* Propagate structural equality. */ 2326 SET_TYPE_STRUCTURAL_EQUALITY (v); 2327 else if (TYPE_CANONICAL (type) != type || cr != raises) 2328 /* Build the underlying canonical type, since it is different 2329 from TYPE. */ 2330 TYPE_CANONICAL (v) = build_exception_variant (TYPE_CANONICAL (type), cr); 2331 else 2332 /* T is its own canonical type. */ 2333 TYPE_CANONICAL (v) = v; 2334 2335 return v; 2336 } 2337 2338 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new 2339 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template 2340 arguments. */ 2341 2342 tree 2343 bind_template_template_parm (tree t, tree newargs) 2344 { 2345 tree decl = TYPE_NAME (t); 2346 tree t2; 2347 2348 t2 = cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM); 2349 decl = build_decl (input_location, 2350 TYPE_DECL, DECL_NAME (decl), NULL_TREE); 2351 2352 /* These nodes have to be created to reflect new TYPE_DECL and template 2353 arguments. */ 2354 TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t)); 2355 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl; 2356 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2) 2357 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t), newargs); 2358 2359 TREE_TYPE (decl) = t2; 2360 TYPE_NAME (t2) = decl; 2361 TYPE_STUB_DECL (t2) = decl; 2362 TYPE_SIZE (t2) = 0; 2363 SET_TYPE_STRUCTURAL_EQUALITY (t2); 2364 2365 return t2; 2366 } 2367 2368 /* Called from count_trees via walk_tree. */ 2369 2370 static tree 2371 count_trees_r (tree *tp, int *walk_subtrees, void *data) 2372 { 2373 ++*((int *) data); 2374 2375 if (TYPE_P (*tp)) 2376 *walk_subtrees = 0; 2377 2378 return NULL_TREE; 2379 } 2380 2381 /* Debugging function for measuring the rough complexity of a tree 2382 representation. */ 2383 2384 int 2385 count_trees (tree t) 2386 { 2387 int n_trees = 0; 2388 cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees); 2389 return n_trees; 2390 } 2391 2392 /* Called from verify_stmt_tree via walk_tree. */ 2393 2394 static tree 2395 verify_stmt_tree_r (tree* tp, int * /*walk_subtrees*/, void* data) 2396 { 2397 tree t = *tp; 2398 hash_table<nofree_ptr_hash <tree_node> > *statements 2399 = static_cast <hash_table<nofree_ptr_hash <tree_node> > *> (data); 2400 tree_node **slot; 2401 2402 if (!STATEMENT_CODE_P (TREE_CODE (t))) 2403 return NULL_TREE; 2404 2405 /* If this statement is already present in the hash table, then 2406 there is a circularity in the statement tree. */ 2407 gcc_assert (!statements->find (t)); 2408 2409 slot = statements->find_slot (t, INSERT); 2410 *slot = t; 2411 2412 return NULL_TREE; 2413 } 2414 2415 /* Debugging function to check that the statement T has not been 2416 corrupted. For now, this function simply checks that T contains no 2417 circularities. */ 2418 2419 void 2420 verify_stmt_tree (tree t) 2421 { 2422 hash_table<nofree_ptr_hash <tree_node> > statements (37); 2423 cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL); 2424 } 2425 2426 /* Check if the type T depends on a type with no linkage and if so, return 2427 it. If RELAXED_P then do not consider a class type declared within 2428 a vague-linkage function to have no linkage. */ 2429 2430 tree 2431 no_linkage_check (tree t, bool relaxed_p) 2432 { 2433 tree r; 2434 2435 /* There's no point in checking linkage on template functions; we 2436 can't know their complete types. */ 2437 if (processing_template_decl) 2438 return NULL_TREE; 2439 2440 switch (TREE_CODE (t)) 2441 { 2442 case RECORD_TYPE: 2443 if (TYPE_PTRMEMFUNC_P (t)) 2444 goto ptrmem; 2445 /* Lambda types that don't have mangling scope have no linkage. We 2446 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because 2447 when we get here from pushtag none of the lambda information is 2448 set up yet, so we want to assume that the lambda has linkage and 2449 fix it up later if not. */ 2450 if (CLASSTYPE_LAMBDA_EXPR (t) 2451 && CLASSTYPE_LAMBDA_EXPR (t) != error_mark_node 2452 && LAMBDA_TYPE_EXTRA_SCOPE (t) == NULL_TREE) 2453 return t; 2454 /* Fall through. */ 2455 case UNION_TYPE: 2456 if (!CLASS_TYPE_P (t)) 2457 return NULL_TREE; 2458 /* Fall through. */ 2459 case ENUMERAL_TYPE: 2460 /* Only treat unnamed types as having no linkage if they're at 2461 namespace scope. This is core issue 966. */ 2462 if (TYPE_UNNAMED_P (t) && TYPE_NAMESPACE_SCOPE_P (t)) 2463 return t; 2464 2465 for (r = CP_TYPE_CONTEXT (t); ; ) 2466 { 2467 /* If we're a nested type of a !TREE_PUBLIC class, we might not 2468 have linkage, or we might just be in an anonymous namespace. 2469 If we're in a TREE_PUBLIC class, we have linkage. */ 2470 if (TYPE_P (r) && !TREE_PUBLIC (TYPE_NAME (r))) 2471 return no_linkage_check (TYPE_CONTEXT (t), relaxed_p); 2472 else if (TREE_CODE (r) == FUNCTION_DECL) 2473 { 2474 if (!relaxed_p || !vague_linkage_p (r)) 2475 return t; 2476 else 2477 r = CP_DECL_CONTEXT (r); 2478 } 2479 else 2480 break; 2481 } 2482 2483 return NULL_TREE; 2484 2485 case ARRAY_TYPE: 2486 case POINTER_TYPE: 2487 case REFERENCE_TYPE: 2488 case VECTOR_TYPE: 2489 return no_linkage_check (TREE_TYPE (t), relaxed_p); 2490 2491 case OFFSET_TYPE: 2492 ptrmem: 2493 r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t), 2494 relaxed_p); 2495 if (r) 2496 return r; 2497 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p); 2498 2499 case METHOD_TYPE: 2500 case FUNCTION_TYPE: 2501 { 2502 tree parm = TYPE_ARG_TYPES (t); 2503 if (TREE_CODE (t) == METHOD_TYPE) 2504 /* The 'this' pointer isn't interesting; a method has the same 2505 linkage (or lack thereof) as its enclosing class. */ 2506 parm = TREE_CHAIN (parm); 2507 for (; 2508 parm && parm != void_list_node; 2509 parm = TREE_CHAIN (parm)) 2510 { 2511 r = no_linkage_check (TREE_VALUE (parm), relaxed_p); 2512 if (r) 2513 return r; 2514 } 2515 return no_linkage_check (TREE_TYPE (t), relaxed_p); 2516 } 2517 2518 default: 2519 return NULL_TREE; 2520 } 2521 } 2522 2523 extern int depth_reached; 2524 2525 void 2526 cxx_print_statistics (void) 2527 { 2528 print_search_statistics (); 2529 print_class_statistics (); 2530 print_template_statistics (); 2531 if (GATHER_STATISTICS) 2532 fprintf (stderr, "maximum template instantiation depth reached: %d\n", 2533 depth_reached); 2534 } 2535 2536 /* Return, as an INTEGER_CST node, the number of elements for TYPE 2537 (which is an ARRAY_TYPE). This counts only elements of the top 2538 array. */ 2539 2540 tree 2541 array_type_nelts_top (tree type) 2542 { 2543 return fold_build2_loc (input_location, 2544 PLUS_EXPR, sizetype, 2545 array_type_nelts (type), 2546 size_one_node); 2547 } 2548 2549 /* Return, as an INTEGER_CST node, the number of elements for TYPE 2550 (which is an ARRAY_TYPE). This one is a recursive count of all 2551 ARRAY_TYPEs that are clumped together. */ 2552 2553 tree 2554 array_type_nelts_total (tree type) 2555 { 2556 tree sz = array_type_nelts_top (type); 2557 type = TREE_TYPE (type); 2558 while (TREE_CODE (type) == ARRAY_TYPE) 2559 { 2560 tree n = array_type_nelts_top (type); 2561 sz = fold_build2_loc (input_location, 2562 MULT_EXPR, sizetype, sz, n); 2563 type = TREE_TYPE (type); 2564 } 2565 return sz; 2566 } 2567 2568 /* Called from break_out_target_exprs via mapcar. */ 2569 2570 static tree 2571 bot_manip (tree* tp, int* walk_subtrees, void* data) 2572 { 2573 splay_tree target_remap = ((splay_tree) data); 2574 tree t = *tp; 2575 2576 if (!TYPE_P (t) && TREE_CONSTANT (t) && !TREE_SIDE_EFFECTS (t)) 2577 { 2578 /* There can't be any TARGET_EXPRs or their slot variables below this 2579 point. But we must make a copy, in case subsequent processing 2580 alters any part of it. For example, during gimplification a cast 2581 of the form (T) &X::f (where "f" is a member function) will lead 2582 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */ 2583 *walk_subtrees = 0; 2584 *tp = unshare_expr (t); 2585 return NULL_TREE; 2586 } 2587 if (TREE_CODE (t) == TARGET_EXPR) 2588 { 2589 tree u; 2590 2591 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR) 2592 { 2593 u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1), 2594 tf_warning_or_error); 2595 if (u == error_mark_node) 2596 return u; 2597 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t, 1))) 2598 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u, 1)) = true; 2599 } 2600 else 2601 u = build_target_expr_with_type (TREE_OPERAND (t, 1), TREE_TYPE (t), 2602 tf_warning_or_error); 2603 2604 TARGET_EXPR_IMPLICIT_P (u) = TARGET_EXPR_IMPLICIT_P (t); 2605 TARGET_EXPR_LIST_INIT_P (u) = TARGET_EXPR_LIST_INIT_P (t); 2606 TARGET_EXPR_DIRECT_INIT_P (u) = TARGET_EXPR_DIRECT_INIT_P (t); 2607 2608 /* Map the old variable to the new one. */ 2609 splay_tree_insert (target_remap, 2610 (splay_tree_key) TREE_OPERAND (t, 0), 2611 (splay_tree_value) TREE_OPERAND (u, 0)); 2612 2613 TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1)); 2614 if (TREE_OPERAND (u, 1) == error_mark_node) 2615 return error_mark_node; 2616 2617 /* Replace the old expression with the new version. */ 2618 *tp = u; 2619 /* We don't have to go below this point; the recursive call to 2620 break_out_target_exprs will have handled anything below this 2621 point. */ 2622 *walk_subtrees = 0; 2623 return NULL_TREE; 2624 } 2625 if (TREE_CODE (*tp) == SAVE_EXPR) 2626 { 2627 t = *tp; 2628 splay_tree_node n = splay_tree_lookup (target_remap, 2629 (splay_tree_key) t); 2630 if (n) 2631 { 2632 *tp = (tree)n->value; 2633 *walk_subtrees = 0; 2634 } 2635 else 2636 { 2637 copy_tree_r (tp, walk_subtrees, NULL); 2638 splay_tree_insert (target_remap, 2639 (splay_tree_key)t, 2640 (splay_tree_value)*tp); 2641 /* Make sure we don't remap an already-remapped SAVE_EXPR. */ 2642 splay_tree_insert (target_remap, 2643 (splay_tree_key)*tp, 2644 (splay_tree_value)*tp); 2645 } 2646 return NULL_TREE; 2647 } 2648 2649 /* Make a copy of this node. */ 2650 t = copy_tree_r (tp, walk_subtrees, NULL); 2651 if (TREE_CODE (*tp) == CALL_EXPR) 2652 { 2653 set_flags_from_callee (*tp); 2654 2655 /* builtin_LINE and builtin_FILE get the location where the default 2656 argument is expanded, not where the call was written. */ 2657 tree callee = get_callee_fndecl (*tp); 2658 if (callee && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL) 2659 switch (DECL_FUNCTION_CODE (callee)) 2660 { 2661 case BUILT_IN_FILE: 2662 case BUILT_IN_LINE: 2663 SET_EXPR_LOCATION (*tp, input_location); 2664 default: 2665 break; 2666 } 2667 } 2668 return t; 2669 } 2670 2671 /* Replace all remapped VAR_DECLs in T with their new equivalents. 2672 DATA is really a splay-tree mapping old variables to new 2673 variables. */ 2674 2675 static tree 2676 bot_replace (tree* t, int* /*walk_subtrees*/, void* data) 2677 { 2678 splay_tree target_remap = ((splay_tree) data); 2679 2680 if (VAR_P (*t)) 2681 { 2682 splay_tree_node n = splay_tree_lookup (target_remap, 2683 (splay_tree_key) *t); 2684 if (n) 2685 *t = (tree) n->value; 2686 } 2687 else if (TREE_CODE (*t) == PARM_DECL 2688 && DECL_NAME (*t) == this_identifier 2689 && !DECL_CONTEXT (*t)) 2690 { 2691 /* In an NSDMI we need to replace the 'this' parameter we used for 2692 parsing with the real one for this function. */ 2693 *t = current_class_ptr; 2694 } 2695 else if (TREE_CODE (*t) == CONVERT_EXPR 2696 && CONVERT_EXPR_VBASE_PATH (*t)) 2697 { 2698 /* In an NSDMI build_base_path defers building conversions to virtual 2699 bases, and we handle it here. */ 2700 tree basetype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t))); 2701 vec<tree, va_gc> *vbases = CLASSTYPE_VBASECLASSES (current_class_type); 2702 int i; tree binfo; 2703 FOR_EACH_VEC_SAFE_ELT (vbases, i, binfo) 2704 if (BINFO_TYPE (binfo) == basetype) 2705 break; 2706 *t = build_base_path (PLUS_EXPR, TREE_OPERAND (*t, 0), binfo, true, 2707 tf_warning_or_error); 2708 } 2709 2710 return NULL_TREE; 2711 } 2712 2713 /* When we parse a default argument expression, we may create 2714 temporary variables via TARGET_EXPRs. When we actually use the 2715 default-argument expression, we make a copy of the expression 2716 and replace the temporaries with appropriate local versions. */ 2717 2718 tree 2719 break_out_target_exprs (tree t) 2720 { 2721 static int target_remap_count; 2722 static splay_tree target_remap; 2723 2724 if (!target_remap_count++) 2725 target_remap = splay_tree_new (splay_tree_compare_pointers, 2726 /*splay_tree_delete_key_fn=*/NULL, 2727 /*splay_tree_delete_value_fn=*/NULL); 2728 if (cp_walk_tree (&t, bot_manip, target_remap, NULL) == error_mark_node) 2729 t = error_mark_node; 2730 cp_walk_tree (&t, bot_replace, target_remap, NULL); 2731 2732 if (!--target_remap_count) 2733 { 2734 splay_tree_delete (target_remap); 2735 target_remap = NULL; 2736 } 2737 2738 return t; 2739 } 2740 2741 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX, 2742 which we expect to have type TYPE. */ 2743 2744 tree 2745 build_ctor_subob_ref (tree index, tree type, tree obj) 2746 { 2747 if (index == NULL_TREE) 2748 /* Can't refer to a particular member of a vector. */ 2749 obj = NULL_TREE; 2750 else if (TREE_CODE (index) == INTEGER_CST) 2751 obj = cp_build_array_ref (input_location, obj, index, tf_none); 2752 else 2753 obj = build_class_member_access_expr (obj, index, NULL_TREE, 2754 /*reference*/false, tf_none); 2755 if (obj) 2756 { 2757 tree objtype = TREE_TYPE (obj); 2758 if (TREE_CODE (objtype) == ARRAY_TYPE && !TYPE_DOMAIN (objtype)) 2759 { 2760 /* When the destination object refers to a flexible array member 2761 verify that it matches the type of the source object except 2762 for its domain and qualifiers. */ 2763 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type), 2764 TYPE_MAIN_VARIANT (objtype), 2765 COMPARE_REDECLARATION)); 2766 } 2767 else 2768 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, objtype)); 2769 } 2770 2771 return obj; 2772 } 2773 2774 struct replace_placeholders_t 2775 { 2776 tree obj; /* The object to be substituted for a PLACEHOLDER_EXPR. */ 2777 bool seen; /* Whether we've encountered a PLACEHOLDER_EXPR. */ 2778 hash_set<tree> *pset; /* To avoid walking same trees multiple times. */ 2779 }; 2780 2781 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and 2782 build up subexpressions as we go deeper. */ 2783 2784 static tree 2785 replace_placeholders_r (tree* t, int* walk_subtrees, void* data_) 2786 { 2787 replace_placeholders_t *d = static_cast<replace_placeholders_t*>(data_); 2788 tree obj = d->obj; 2789 2790 if (TREE_CONSTANT (*t)) 2791 { 2792 *walk_subtrees = false; 2793 return NULL_TREE; 2794 } 2795 2796 switch (TREE_CODE (*t)) 2797 { 2798 case PLACEHOLDER_EXPR: 2799 { 2800 tree x = obj; 2801 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t), 2802 TREE_TYPE (x)); 2803 x = TREE_OPERAND (x, 0)) 2804 gcc_assert (handled_component_p (x)); 2805 *t = x; 2806 *walk_subtrees = false; 2807 d->seen = true; 2808 } 2809 break; 2810 2811 case CONSTRUCTOR: 2812 { 2813 constructor_elt *ce; 2814 vec<constructor_elt,va_gc> *v = CONSTRUCTOR_ELTS (*t); 2815 if (d->pset->add (*t)) 2816 { 2817 *walk_subtrees = false; 2818 return NULL_TREE; 2819 } 2820 for (unsigned i = 0; vec_safe_iterate (v, i, &ce); ++i) 2821 { 2822 tree *valp = &ce->value; 2823 tree type = TREE_TYPE (*valp); 2824 tree subob = obj; 2825 2826 if (TREE_CODE (*valp) == CONSTRUCTOR 2827 && AGGREGATE_TYPE_P (type)) 2828 { 2829 /* If we're looking at the initializer for OBJ, then build 2830 a sub-object reference. If we're looking at an 2831 initializer for another object, just pass OBJ down. */ 2832 if (same_type_ignoring_top_level_qualifiers_p 2833 (TREE_TYPE (*t), TREE_TYPE (obj))) 2834 subob = build_ctor_subob_ref (ce->index, type, obj); 2835 if (TREE_CODE (*valp) == TARGET_EXPR) 2836 valp = &TARGET_EXPR_INITIAL (*valp); 2837 } 2838 d->obj = subob; 2839 cp_walk_tree (valp, replace_placeholders_r, data_, NULL); 2840 d->obj = obj; 2841 } 2842 *walk_subtrees = false; 2843 break; 2844 } 2845 2846 default: 2847 if (d->pset->add (*t)) 2848 *walk_subtrees = false; 2849 break; 2850 } 2851 2852 return NULL_TREE; 2853 } 2854 2855 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if 2856 a PLACEHOLDER_EXPR has been encountered. */ 2857 2858 tree 2859 replace_placeholders (tree exp, tree obj, bool *seen_p) 2860 { 2861 /* This is only relevant for C++14. */ 2862 if (cxx_dialect < cxx14) 2863 return exp; 2864 2865 /* If the object isn't a (member of a) class, do nothing. */ 2866 tree op0 = obj; 2867 while (TREE_CODE (op0) == COMPONENT_REF) 2868 op0 = TREE_OPERAND (op0, 0); 2869 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0)))) 2870 return exp; 2871 2872 tree *tp = &exp; 2873 hash_set<tree> pset; 2874 replace_placeholders_t data = { obj, false, &pset }; 2875 if (TREE_CODE (exp) == TARGET_EXPR) 2876 tp = &TARGET_EXPR_INITIAL (exp); 2877 cp_walk_tree (tp, replace_placeholders_r, &data, NULL); 2878 if (seen_p) 2879 *seen_p = data.seen; 2880 return exp; 2881 } 2882 2883 /* Similar to `build_nt', but for template definitions of dependent 2884 expressions */ 2885 2886 tree 2887 build_min_nt_loc (location_t loc, enum tree_code code, ...) 2888 { 2889 tree t; 2890 int length; 2891 int i; 2892 va_list p; 2893 2894 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp); 2895 2896 va_start (p, code); 2897 2898 t = make_node (code); 2899 SET_EXPR_LOCATION (t, loc); 2900 length = TREE_CODE_LENGTH (code); 2901 2902 for (i = 0; i < length; i++) 2903 { 2904 tree x = va_arg (p, tree); 2905 TREE_OPERAND (t, i) = x; 2906 } 2907 2908 va_end (p); 2909 return t; 2910 } 2911 2912 2913 /* Similar to `build', but for template definitions. */ 2914 2915 tree 2916 build_min (enum tree_code code, tree tt, ...) 2917 { 2918 tree t; 2919 int length; 2920 int i; 2921 va_list p; 2922 2923 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp); 2924 2925 va_start (p, tt); 2926 2927 t = make_node (code); 2928 length = TREE_CODE_LENGTH (code); 2929 TREE_TYPE (t) = tt; 2930 2931 for (i = 0; i < length; i++) 2932 { 2933 tree x = va_arg (p, tree); 2934 TREE_OPERAND (t, i) = x; 2935 if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x)) 2936 TREE_SIDE_EFFECTS (t) = 1; 2937 } 2938 2939 va_end (p); 2940 return t; 2941 } 2942 2943 /* Similar to `build', but for template definitions of non-dependent 2944 expressions. NON_DEP is the non-dependent expression that has been 2945 built. */ 2946 2947 tree 2948 build_min_non_dep (enum tree_code code, tree non_dep, ...) 2949 { 2950 tree t; 2951 int length; 2952 int i; 2953 va_list p; 2954 2955 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp); 2956 2957 va_start (p, non_dep); 2958 2959 if (REFERENCE_REF_P (non_dep)) 2960 non_dep = TREE_OPERAND (non_dep, 0); 2961 2962 t = make_node (code); 2963 length = TREE_CODE_LENGTH (code); 2964 TREE_TYPE (t) = unlowered_expr_type (non_dep); 2965 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep); 2966 2967 for (i = 0; i < length; i++) 2968 { 2969 tree x = va_arg (p, tree); 2970 TREE_OPERAND (t, i) = x; 2971 } 2972 2973 if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR) 2974 /* This should not be considered a COMPOUND_EXPR, because it 2975 resolves to an overload. */ 2976 COMPOUND_EXPR_OVERLOADED (t) = 1; 2977 2978 va_end (p); 2979 return convert_from_reference (t); 2980 } 2981 2982 /* Similar to `build_nt_call_vec', but for template definitions of 2983 non-dependent expressions. NON_DEP is the non-dependent expression 2984 that has been built. */ 2985 2986 tree 2987 build_min_non_dep_call_vec (tree non_dep, tree fn, vec<tree, va_gc> *argvec) 2988 { 2989 tree t = build_nt_call_vec (fn, argvec); 2990 if (REFERENCE_REF_P (non_dep)) 2991 non_dep = TREE_OPERAND (non_dep, 0); 2992 TREE_TYPE (t) = TREE_TYPE (non_dep); 2993 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep); 2994 return convert_from_reference (t); 2995 } 2996 2997 /* Similar to build_min_non_dep, but for expressions that have been resolved to 2998 a call to an operator overload. OP is the operator that has been 2999 overloaded. NON_DEP is the non-dependent expression that's been built, 3000 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is 3001 the overload that NON_DEP is calling. */ 3002 3003 tree 3004 build_min_non_dep_op_overload (enum tree_code op, 3005 tree non_dep, 3006 tree overload, ...) 3007 { 3008 va_list p; 3009 int nargs, expected_nargs; 3010 tree fn, call; 3011 vec<tree, va_gc> *args; 3012 3013 non_dep = extract_call_expr (non_dep); 3014 3015 nargs = call_expr_nargs (non_dep); 3016 3017 expected_nargs = cp_tree_code_length (op); 3018 if ((op == POSTINCREMENT_EXPR 3019 || op == POSTDECREMENT_EXPR) 3020 /* With -fpermissive non_dep could be operator++(). */ 3021 && (!flag_permissive || nargs != expected_nargs)) 3022 expected_nargs += 1; 3023 gcc_assert (nargs == expected_nargs); 3024 3025 args = make_tree_vector (); 3026 va_start (p, overload); 3027 3028 if (TREE_CODE (TREE_TYPE (overload)) == FUNCTION_TYPE) 3029 { 3030 fn = overload; 3031 for (int i = 0; i < nargs; i++) 3032 { 3033 tree arg = va_arg (p, tree); 3034 vec_safe_push (args, arg); 3035 } 3036 } 3037 else if (TREE_CODE (TREE_TYPE (overload)) == METHOD_TYPE) 3038 { 3039 tree object = va_arg (p, tree); 3040 tree binfo = TYPE_BINFO (TREE_TYPE (object)); 3041 tree method = build_baselink (binfo, binfo, overload, NULL_TREE); 3042 fn = build_min (COMPONENT_REF, TREE_TYPE (overload), 3043 object, method, NULL_TREE); 3044 for (int i = 1; i < nargs; i++) 3045 { 3046 tree arg = va_arg (p, tree); 3047 vec_safe_push (args, arg); 3048 } 3049 } 3050 else 3051 gcc_unreachable (); 3052 3053 va_end (p); 3054 call = build_min_non_dep_call_vec (non_dep, fn, args); 3055 release_tree_vector (args); 3056 3057 tree call_expr = extract_call_expr (call); 3058 KOENIG_LOOKUP_P (call_expr) = KOENIG_LOOKUP_P (non_dep); 3059 CALL_EXPR_OPERATOR_SYNTAX (call_expr) = true; 3060 CALL_EXPR_ORDERED_ARGS (call_expr) = CALL_EXPR_ORDERED_ARGS (non_dep); 3061 CALL_EXPR_REVERSE_ARGS (call_expr) = CALL_EXPR_REVERSE_ARGS (non_dep); 3062 3063 return call; 3064 } 3065 3066 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */ 3067 3068 vec<tree, va_gc> * 3069 vec_copy_and_insert (vec<tree, va_gc> *old_vec, tree elt, unsigned idx) 3070 { 3071 unsigned len = vec_safe_length (old_vec); 3072 gcc_assert (idx <= len); 3073 3074 vec<tree, va_gc> *new_vec = NULL; 3075 vec_alloc (new_vec, len + 1); 3076 3077 unsigned i; 3078 for (i = 0; i < len; ++i) 3079 { 3080 if (i == idx) 3081 new_vec->quick_push (elt); 3082 new_vec->quick_push ((*old_vec)[i]); 3083 } 3084 if (i == idx) 3085 new_vec->quick_push (elt); 3086 3087 return new_vec; 3088 } 3089 3090 tree 3091 get_type_decl (tree t) 3092 { 3093 if (TREE_CODE (t) == TYPE_DECL) 3094 return t; 3095 if (TYPE_P (t)) 3096 return TYPE_STUB_DECL (t); 3097 gcc_assert (t == error_mark_node); 3098 return t; 3099 } 3100 3101 /* Returns the namespace that contains DECL, whether directly or 3102 indirectly. */ 3103 3104 tree 3105 decl_namespace_context (tree decl) 3106 { 3107 while (1) 3108 { 3109 if (TREE_CODE (decl) == NAMESPACE_DECL) 3110 return decl; 3111 else if (TYPE_P (decl)) 3112 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl)); 3113 else 3114 decl = CP_DECL_CONTEXT (decl); 3115 } 3116 } 3117 3118 /* Returns true if decl is within an anonymous namespace, however deeply 3119 nested, or false otherwise. */ 3120 3121 bool 3122 decl_anon_ns_mem_p (const_tree decl) 3123 { 3124 while (1) 3125 { 3126 if (decl == NULL_TREE || decl == error_mark_node) 3127 return false; 3128 if (TREE_CODE (decl) == NAMESPACE_DECL 3129 && DECL_NAME (decl) == NULL_TREE) 3130 return true; 3131 /* Classes and namespaces inside anonymous namespaces have 3132 TREE_PUBLIC == 0, so we can shortcut the search. */ 3133 else if (TYPE_P (decl)) 3134 return (TREE_PUBLIC (TYPE_MAIN_DECL (decl)) == 0); 3135 else if (TREE_CODE (decl) == NAMESPACE_DECL) 3136 return (TREE_PUBLIC (decl) == 0); 3137 else 3138 decl = DECL_CONTEXT (decl); 3139 } 3140 } 3141 3142 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two 3143 CALL_EXPRS. Return whether they are equivalent. */ 3144 3145 static bool 3146 called_fns_equal (tree t1, tree t2) 3147 { 3148 /* Core 1321: dependent names are equivalent even if the overload sets 3149 are different. But do compare explicit template arguments. */ 3150 tree name1 = dependent_name (t1); 3151 tree name2 = dependent_name (t2); 3152 if (name1 || name2) 3153 { 3154 tree targs1 = NULL_TREE, targs2 = NULL_TREE; 3155 3156 if (name1 != name2) 3157 return false; 3158 3159 if (TREE_CODE (t1) == TEMPLATE_ID_EXPR) 3160 targs1 = TREE_OPERAND (t1, 1); 3161 if (TREE_CODE (t2) == TEMPLATE_ID_EXPR) 3162 targs2 = TREE_OPERAND (t2, 1); 3163 return cp_tree_equal (targs1, targs2); 3164 } 3165 else 3166 return cp_tree_equal (t1, t2); 3167 } 3168 3169 /* Return truthvalue of whether T1 is the same tree structure as T2. 3170 Return 1 if they are the same. Return 0 if they are different. */ 3171 3172 bool 3173 cp_tree_equal (tree t1, tree t2) 3174 { 3175 enum tree_code code1, code2; 3176 3177 if (t1 == t2) 3178 return true; 3179 if (!t1 || !t2) 3180 return false; 3181 3182 code1 = TREE_CODE (t1); 3183 code2 = TREE_CODE (t2); 3184 3185 if (code1 != code2) 3186 return false; 3187 3188 switch (code1) 3189 { 3190 case VOID_CST: 3191 /* There's only a single VOID_CST node, so we should never reach 3192 here. */ 3193 gcc_unreachable (); 3194 3195 case INTEGER_CST: 3196 return tree_int_cst_equal (t1, t2); 3197 3198 case REAL_CST: 3199 return real_equal (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2)); 3200 3201 case STRING_CST: 3202 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2) 3203 && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2), 3204 TREE_STRING_LENGTH (t1)); 3205 3206 case FIXED_CST: 3207 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), 3208 TREE_FIXED_CST (t2)); 3209 3210 case COMPLEX_CST: 3211 return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2)) 3212 && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2)); 3213 3214 case VECTOR_CST: 3215 return operand_equal_p (t1, t2, OEP_ONLY_CONST); 3216 3217 case CONSTRUCTOR: 3218 /* We need to do this when determining whether or not two 3219 non-type pointer to member function template arguments 3220 are the same. */ 3221 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)) 3222 || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2)) 3223 return false; 3224 { 3225 tree field, value; 3226 unsigned int i; 3227 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value) 3228 { 3229 constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i); 3230 if (!cp_tree_equal (field, elt2->index) 3231 || !cp_tree_equal (value, elt2->value)) 3232 return false; 3233 } 3234 } 3235 return true; 3236 3237 case TREE_LIST: 3238 if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))) 3239 return false; 3240 if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2))) 3241 return false; 3242 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2)); 3243 3244 case SAVE_EXPR: 3245 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 3246 3247 case CALL_EXPR: 3248 { 3249 tree arg1, arg2; 3250 call_expr_arg_iterator iter1, iter2; 3251 if (!called_fns_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2))) 3252 return false; 3253 for (arg1 = first_call_expr_arg (t1, &iter1), 3254 arg2 = first_call_expr_arg (t2, &iter2); 3255 arg1 && arg2; 3256 arg1 = next_call_expr_arg (&iter1), 3257 arg2 = next_call_expr_arg (&iter2)) 3258 if (!cp_tree_equal (arg1, arg2)) 3259 return false; 3260 if (arg1 || arg2) 3261 return false; 3262 return true; 3263 } 3264 3265 case TARGET_EXPR: 3266 { 3267 tree o1 = TREE_OPERAND (t1, 0); 3268 tree o2 = TREE_OPERAND (t2, 0); 3269 3270 /* Special case: if either target is an unallocated VAR_DECL, 3271 it means that it's going to be unified with whatever the 3272 TARGET_EXPR is really supposed to initialize, so treat it 3273 as being equivalent to anything. */ 3274 if (VAR_P (o1) && DECL_NAME (o1) == NULL_TREE 3275 && !DECL_RTL_SET_P (o1)) 3276 /*Nop*/; 3277 else if (VAR_P (o2) && DECL_NAME (o2) == NULL_TREE 3278 && !DECL_RTL_SET_P (o2)) 3279 /*Nop*/; 3280 else if (!cp_tree_equal (o1, o2)) 3281 return false; 3282 3283 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)); 3284 } 3285 3286 case WITH_CLEANUP_EXPR: 3287 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))) 3288 return false; 3289 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1)); 3290 3291 case PARM_DECL: 3292 /* For comparing uses of parameters in late-specified return types 3293 with an out-of-class definition of the function, but can also come 3294 up for expressions that involve 'this' in a member function 3295 template. */ 3296 3297 if (comparing_specializations && !CONSTRAINT_VAR_P (t1)) 3298 /* When comparing hash table entries, only an exact match is 3299 good enough; we don't want to replace 'this' with the 3300 version from another function. But be more flexible 3301 with local parameters in a requires-expression. */ 3302 return false; 3303 3304 if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))) 3305 { 3306 if (DECL_ARTIFICIAL (t1) ^ DECL_ARTIFICIAL (t2)) 3307 return false; 3308 if (CONSTRAINT_VAR_P (t1) ^ CONSTRAINT_VAR_P (t2)) 3309 return false; 3310 if (DECL_ARTIFICIAL (t1) 3311 || (DECL_PARM_LEVEL (t1) == DECL_PARM_LEVEL (t2) 3312 && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2))) 3313 return true; 3314 } 3315 return false; 3316 3317 case VAR_DECL: 3318 case CONST_DECL: 3319 case FIELD_DECL: 3320 case FUNCTION_DECL: 3321 case TEMPLATE_DECL: 3322 case IDENTIFIER_NODE: 3323 case SSA_NAME: 3324 return false; 3325 3326 case BASELINK: 3327 return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2) 3328 && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2) 3329 && BASELINK_QUALIFIED_P (t1) == BASELINK_QUALIFIED_P (t2) 3330 && cp_tree_equal (BASELINK_FUNCTIONS (t1), 3331 BASELINK_FUNCTIONS (t2))); 3332 3333 case TEMPLATE_PARM_INDEX: 3334 return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2) 3335 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2) 3336 && (TEMPLATE_PARM_PARAMETER_PACK (t1) 3337 == TEMPLATE_PARM_PARAMETER_PACK (t2)) 3338 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)), 3339 TREE_TYPE (TEMPLATE_PARM_DECL (t2)))); 3340 3341 case TEMPLATE_ID_EXPR: 3342 return (cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)) 3343 && cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1))); 3344 3345 case CONSTRAINT_INFO: 3346 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1), 3347 CI_ASSOCIATED_CONSTRAINTS (t2)); 3348 3349 case CHECK_CONSTR: 3350 return (CHECK_CONSTR_CONCEPT (t1) == CHECK_CONSTR_CONCEPT (t2) 3351 && comp_template_args (CHECK_CONSTR_ARGS (t1), 3352 CHECK_CONSTR_ARGS (t2))); 3353 3354 case TREE_VEC: 3355 { 3356 unsigned ix; 3357 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2)) 3358 return false; 3359 for (ix = TREE_VEC_LENGTH (t1); ix--;) 3360 if (!cp_tree_equal (TREE_VEC_ELT (t1, ix), 3361 TREE_VEC_ELT (t2, ix))) 3362 return false; 3363 return true; 3364 } 3365 3366 case SIZEOF_EXPR: 3367 case ALIGNOF_EXPR: 3368 { 3369 tree o1 = TREE_OPERAND (t1, 0); 3370 tree o2 = TREE_OPERAND (t2, 0); 3371 3372 if (code1 == SIZEOF_EXPR) 3373 { 3374 if (SIZEOF_EXPR_TYPE_P (t1)) 3375 o1 = TREE_TYPE (o1); 3376 if (SIZEOF_EXPR_TYPE_P (t2)) 3377 o2 = TREE_TYPE (o2); 3378 } 3379 if (TREE_CODE (o1) != TREE_CODE (o2)) 3380 return false; 3381 if (TYPE_P (o1)) 3382 return same_type_p (o1, o2); 3383 else 3384 return cp_tree_equal (o1, o2); 3385 } 3386 3387 case MODOP_EXPR: 3388 { 3389 tree t1_op1, t2_op1; 3390 3391 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))) 3392 return false; 3393 3394 t1_op1 = TREE_OPERAND (t1, 1); 3395 t2_op1 = TREE_OPERAND (t2, 1); 3396 if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1)) 3397 return false; 3398 3399 return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2)); 3400 } 3401 3402 case PTRMEM_CST: 3403 /* Two pointer-to-members are the same if they point to the same 3404 field or function in the same class. */ 3405 if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2)) 3406 return false; 3407 3408 return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2)); 3409 3410 case OVERLOAD: 3411 if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2)) 3412 return false; 3413 return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2)); 3414 3415 case TRAIT_EXPR: 3416 if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2)) 3417 return false; 3418 return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2)) 3419 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2)); 3420 3421 case CAST_EXPR: 3422 case STATIC_CAST_EXPR: 3423 case REINTERPRET_CAST_EXPR: 3424 case CONST_CAST_EXPR: 3425 case DYNAMIC_CAST_EXPR: 3426 case IMPLICIT_CONV_EXPR: 3427 case NEW_EXPR: 3428 CASE_CONVERT: 3429 case NON_LVALUE_EXPR: 3430 case VIEW_CONVERT_EXPR: 3431 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))) 3432 return false; 3433 /* Now compare operands as usual. */ 3434 break; 3435 3436 case DEFERRED_NOEXCEPT: 3437 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1), 3438 DEFERRED_NOEXCEPT_PATTERN (t2)) 3439 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1), 3440 DEFERRED_NOEXCEPT_ARGS (t2))); 3441 break; 3442 3443 default: 3444 break; 3445 } 3446 3447 switch (TREE_CODE_CLASS (code1)) 3448 { 3449 case tcc_unary: 3450 case tcc_binary: 3451 case tcc_comparison: 3452 case tcc_expression: 3453 case tcc_vl_exp: 3454 case tcc_reference: 3455 case tcc_statement: 3456 { 3457 int i, n; 3458 3459 n = cp_tree_operand_length (t1); 3460 if (TREE_CODE_CLASS (code1) == tcc_vl_exp 3461 && n != TREE_OPERAND_LENGTH (t2)) 3462 return false; 3463 3464 for (i = 0; i < n; ++i) 3465 if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i))) 3466 return false; 3467 3468 return true; 3469 } 3470 3471 case tcc_type: 3472 return same_type_p (t1, t2); 3473 default: 3474 gcc_unreachable (); 3475 } 3476 /* We can get here with --disable-checking. */ 3477 return false; 3478 } 3479 3480 /* The type of ARG when used as an lvalue. */ 3481 3482 tree 3483 lvalue_type (tree arg) 3484 { 3485 tree type = TREE_TYPE (arg); 3486 return type; 3487 } 3488 3489 /* The type of ARG for printing error messages; denote lvalues with 3490 reference types. */ 3491 3492 tree 3493 error_type (tree arg) 3494 { 3495 tree type = TREE_TYPE (arg); 3496 3497 if (TREE_CODE (type) == ARRAY_TYPE) 3498 ; 3499 else if (TREE_CODE (type) == ERROR_MARK) 3500 ; 3501 else if (lvalue_p (arg)) 3502 type = build_reference_type (lvalue_type (arg)); 3503 else if (MAYBE_CLASS_TYPE_P (type)) 3504 type = lvalue_type (arg); 3505 3506 return type; 3507 } 3508 3509 /* Does FUNCTION use a variable-length argument list? */ 3510 3511 int 3512 varargs_function_p (const_tree function) 3513 { 3514 return stdarg_p (TREE_TYPE (function)); 3515 } 3516 3517 /* Returns 1 if decl is a member of a class. */ 3518 3519 int 3520 member_p (const_tree decl) 3521 { 3522 const_tree const ctx = DECL_CONTEXT (decl); 3523 return (ctx && TYPE_P (ctx)); 3524 } 3525 3526 /* Create a placeholder for member access where we don't actually have an 3527 object that the access is against. */ 3528 3529 tree 3530 build_dummy_object (tree type) 3531 { 3532 tree decl = build1 (CONVERT_EXPR, build_pointer_type (type), void_node); 3533 return cp_build_indirect_ref (decl, RO_NULL, tf_warning_or_error); 3534 } 3535 3536 /* We've gotten a reference to a member of TYPE. Return *this if appropriate, 3537 or a dummy object otherwise. If BINFOP is non-0, it is filled with the 3538 binfo path from current_class_type to TYPE, or 0. */ 3539 3540 tree 3541 maybe_dummy_object (tree type, tree* binfop) 3542 { 3543 tree decl, context; 3544 tree binfo; 3545 tree current = current_nonlambda_class_type (); 3546 3547 if (current 3548 && (binfo = lookup_base (current, type, ba_any, NULL, 3549 tf_warning_or_error))) 3550 context = current; 3551 else 3552 { 3553 /* Reference from a nested class member function. */ 3554 context = type; 3555 binfo = TYPE_BINFO (type); 3556 } 3557 3558 if (binfop) 3559 *binfop = binfo; 3560 3561 if (current_class_ref 3562 /* current_class_ref might not correspond to current_class_type if 3563 we're in tsubst_default_argument or a lambda-declarator; in either 3564 case, we want to use current_class_ref if it matches CONTEXT. */ 3565 && (same_type_ignoring_top_level_qualifiers_p 3566 (TREE_TYPE (current_class_ref), context))) 3567 decl = current_class_ref; 3568 else 3569 decl = build_dummy_object (context); 3570 3571 return decl; 3572 } 3573 3574 /* Returns 1 if OB is a placeholder object, or a pointer to one. */ 3575 3576 int 3577 is_dummy_object (const_tree ob) 3578 { 3579 if (INDIRECT_REF_P (ob)) 3580 ob = TREE_OPERAND (ob, 0); 3581 return (TREE_CODE (ob) == CONVERT_EXPR 3582 && TREE_OPERAND (ob, 0) == void_node); 3583 } 3584 3585 /* Returns 1 iff type T is something we want to treat as a scalar type for 3586 the purpose of deciding whether it is trivial/POD/standard-layout. */ 3587 3588 bool 3589 scalarish_type_p (const_tree t) 3590 { 3591 if (t == error_mark_node) 3592 return 1; 3593 3594 return (SCALAR_TYPE_P (t) || VECTOR_TYPE_P (t)); 3595 } 3596 3597 /* Returns true iff T requires non-trivial default initialization. */ 3598 3599 bool 3600 type_has_nontrivial_default_init (const_tree t) 3601 { 3602 t = strip_array_types (CONST_CAST_TREE (t)); 3603 3604 if (CLASS_TYPE_P (t)) 3605 return TYPE_HAS_COMPLEX_DFLT (t); 3606 else 3607 return 0; 3608 } 3609 3610 /* Returns true iff copying an object of type T (including via move 3611 constructor) is non-trivial. That is, T has no non-trivial copy 3612 constructors and no non-trivial move constructors. */ 3613 3614 bool 3615 type_has_nontrivial_copy_init (const_tree t) 3616 { 3617 t = strip_array_types (CONST_CAST_TREE (t)); 3618 3619 if (CLASS_TYPE_P (t)) 3620 { 3621 gcc_assert (COMPLETE_TYPE_P (t)); 3622 return ((TYPE_HAS_COPY_CTOR (t) 3623 && TYPE_HAS_COMPLEX_COPY_CTOR (t)) 3624 || TYPE_HAS_COMPLEX_MOVE_CTOR (t)); 3625 } 3626 else 3627 return 0; 3628 } 3629 3630 /* Returns 1 iff type T is a trivially copyable type, as defined in 3631 [basic.types] and [class]. */ 3632 3633 bool 3634 trivially_copyable_p (const_tree t) 3635 { 3636 t = strip_array_types (CONST_CAST_TREE (t)); 3637 3638 if (CLASS_TYPE_P (t)) 3639 return ((!TYPE_HAS_COPY_CTOR (t) 3640 || !TYPE_HAS_COMPLEX_COPY_CTOR (t)) 3641 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t) 3642 && (!TYPE_HAS_COPY_ASSIGN (t) 3643 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t)) 3644 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) 3645 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t)); 3646 else 3647 return !CP_TYPE_VOLATILE_P (t) && scalarish_type_p (t); 3648 } 3649 3650 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and 3651 [class]. */ 3652 3653 bool 3654 trivial_type_p (const_tree t) 3655 { 3656 t = strip_array_types (CONST_CAST_TREE (t)); 3657 3658 if (CLASS_TYPE_P (t)) 3659 return (TYPE_HAS_TRIVIAL_DFLT (t) 3660 && trivially_copyable_p (t)); 3661 else 3662 return scalarish_type_p (t); 3663 } 3664 3665 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */ 3666 3667 bool 3668 pod_type_p (const_tree t) 3669 { 3670 /* This CONST_CAST is okay because strip_array_types returns its 3671 argument unmodified and we assign it to a const_tree. */ 3672 t = strip_array_types (CONST_CAST_TREE(t)); 3673 3674 if (!CLASS_TYPE_P (t)) 3675 return scalarish_type_p (t); 3676 else if (cxx_dialect > cxx98) 3677 /* [class]/10: A POD struct is a class that is both a trivial class and a 3678 standard-layout class, and has no non-static data members of type 3679 non-POD struct, non-POD union (or array of such types). 3680 3681 We don't need to check individual members because if a member is 3682 non-std-layout or non-trivial, the class will be too. */ 3683 return (std_layout_type_p (t) && trivial_type_p (t)); 3684 else 3685 /* The C++98 definition of POD is different. */ 3686 return !CLASSTYPE_NON_LAYOUT_POD_P (t); 3687 } 3688 3689 /* Returns true iff T is POD for the purpose of layout, as defined in the 3690 C++ ABI. */ 3691 3692 bool 3693 layout_pod_type_p (const_tree t) 3694 { 3695 t = strip_array_types (CONST_CAST_TREE (t)); 3696 3697 if (CLASS_TYPE_P (t)) 3698 return !CLASSTYPE_NON_LAYOUT_POD_P (t); 3699 else 3700 return scalarish_type_p (t); 3701 } 3702 3703 /* Returns true iff T is a standard-layout type, as defined in 3704 [basic.types]. */ 3705 3706 bool 3707 std_layout_type_p (const_tree t) 3708 { 3709 t = strip_array_types (CONST_CAST_TREE (t)); 3710 3711 if (CLASS_TYPE_P (t)) 3712 return !CLASSTYPE_NON_STD_LAYOUT (t); 3713 else 3714 return scalarish_type_p (t); 3715 } 3716 3717 static bool record_has_unique_obj_representations (const_tree, const_tree); 3718 3719 /* Returns true iff T satisfies std::has_unique_object_representations<T>, 3720 as defined in [meta.unary.prop]. */ 3721 3722 bool 3723 type_has_unique_obj_representations (const_tree t) 3724 { 3725 bool ret; 3726 3727 t = strip_array_types (CONST_CAST_TREE (t)); 3728 3729 if (!trivially_copyable_p (t)) 3730 return false; 3731 3732 if (CLASS_TYPE_P (t) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t)) 3733 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t); 3734 3735 switch (TREE_CODE (t)) 3736 { 3737 case INTEGER_TYPE: 3738 case POINTER_TYPE: 3739 case REFERENCE_TYPE: 3740 /* If some backend has any paddings in these types, we should add 3741 a target hook for this and handle it there. */ 3742 return true; 3743 3744 case BOOLEAN_TYPE: 3745 /* For bool values other than 0 and 1 should only appear with 3746 undefined behavior. */ 3747 return true; 3748 3749 case ENUMERAL_TYPE: 3750 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t)); 3751 3752 case REAL_TYPE: 3753 /* XFmode certainly contains padding on x86, which the CPU doesn't store 3754 when storing long double values, so for that we have to return false. 3755 Other kinds of floating point values are questionable due to +.0/-.0 3756 and NaNs, let's play safe for now. */ 3757 return false; 3758 3759 case FIXED_POINT_TYPE: 3760 return false; 3761 3762 case OFFSET_TYPE: 3763 return true; 3764 3765 case COMPLEX_TYPE: 3766 case VECTOR_TYPE: 3767 return type_has_unique_obj_representations (TREE_TYPE (t)); 3768 3769 case RECORD_TYPE: 3770 ret = record_has_unique_obj_representations (t, TYPE_SIZE (t)); 3771 if (CLASS_TYPE_P (t)) 3772 { 3773 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t) = 1; 3774 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t) = ret; 3775 } 3776 return ret; 3777 3778 case UNION_TYPE: 3779 ret = true; 3780 bool any_fields; 3781 any_fields = false; 3782 for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field)) 3783 if (TREE_CODE (field) == FIELD_DECL) 3784 { 3785 any_fields = true; 3786 if (!type_has_unique_obj_representations (TREE_TYPE (field)) 3787 || simple_cst_equal (DECL_SIZE (field), TYPE_SIZE (t)) != 1) 3788 { 3789 ret = false; 3790 break; 3791 } 3792 } 3793 if (!any_fields && !integer_zerop (TYPE_SIZE (t))) 3794 ret = false; 3795 if (CLASS_TYPE_P (t)) 3796 { 3797 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t) = 1; 3798 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t) = ret; 3799 } 3800 return ret; 3801 3802 case NULLPTR_TYPE: 3803 return false; 3804 3805 case ERROR_MARK: 3806 return false; 3807 3808 default: 3809 gcc_unreachable (); 3810 } 3811 } 3812 3813 /* Helper function for type_has_unique_obj_representations. */ 3814 3815 static bool 3816 record_has_unique_obj_representations (const_tree t, const_tree sz) 3817 { 3818 for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field)) 3819 if (TREE_CODE (field) != FIELD_DECL) 3820 ; 3821 /* For bases, can't use type_has_unique_obj_representations here, as in 3822 struct S { int i : 24; S (); }; 3823 struct T : public S { int j : 8; T (); }; 3824 S doesn't have unique obj representations, but T does. */ 3825 else if (DECL_FIELD_IS_BASE (field)) 3826 { 3827 if (!record_has_unique_obj_representations (TREE_TYPE (field), 3828 DECL_SIZE (field))) 3829 return false; 3830 } 3831 else if (DECL_C_BIT_FIELD (field)) 3832 { 3833 tree btype = DECL_BIT_FIELD_TYPE (field); 3834 if (!type_has_unique_obj_representations (btype)) 3835 return false; 3836 } 3837 else if (!type_has_unique_obj_representations (TREE_TYPE (field))) 3838 return false; 3839 3840 offset_int cur = 0; 3841 for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field)) 3842 if (TREE_CODE (field) == FIELD_DECL) 3843 { 3844 offset_int fld = wi::to_offset (DECL_FIELD_OFFSET (field)); 3845 offset_int bitpos = wi::to_offset (DECL_FIELD_BIT_OFFSET (field)); 3846 fld = fld * BITS_PER_UNIT + bitpos; 3847 if (cur != fld) 3848 return false; 3849 if (DECL_SIZE (field)) 3850 { 3851 offset_int size = wi::to_offset (DECL_SIZE (field)); 3852 cur += size; 3853 } 3854 } 3855 if (cur != wi::to_offset (sz)) 3856 return false; 3857 3858 return true; 3859 } 3860 3861 /* Nonzero iff type T is a class template implicit specialization. */ 3862 3863 bool 3864 class_tmpl_impl_spec_p (const_tree t) 3865 { 3866 return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t); 3867 } 3868 3869 /* Returns 1 iff zero initialization of type T means actually storing 3870 zeros in it. */ 3871 3872 int 3873 zero_init_p (const_tree t) 3874 { 3875 /* This CONST_CAST is okay because strip_array_types returns its 3876 argument unmodified and we assign it to a const_tree. */ 3877 t = strip_array_types (CONST_CAST_TREE(t)); 3878 3879 if (t == error_mark_node) 3880 return 1; 3881 3882 /* NULL pointers to data members are initialized with -1. */ 3883 if (TYPE_PTRDATAMEM_P (t)) 3884 return 0; 3885 3886 /* Classes that contain types that can't be zero-initialized, cannot 3887 be zero-initialized themselves. */ 3888 if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t)) 3889 return 0; 3890 3891 return 1; 3892 } 3893 3894 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU 3895 warn_unused_result attribute. */ 3896 3897 static tree 3898 handle_nodiscard_attribute (tree *node, tree name, tree /*args*/, 3899 int /*flags*/, bool *no_add_attrs) 3900 { 3901 if (TREE_CODE (*node) == FUNCTION_DECL) 3902 { 3903 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node)))) 3904 warning (OPT_Wattributes, "%qE attribute applied to %qD with void " 3905 "return type", name, *node); 3906 } 3907 else if (OVERLOAD_TYPE_P (*node)) 3908 /* OK */; 3909 else 3910 { 3911 warning (OPT_Wattributes, "%qE attribute can only be applied to " 3912 "functions or to class or enumeration types", name); 3913 *no_add_attrs = true; 3914 } 3915 return NULL_TREE; 3916 } 3917 3918 /* Table of valid C++ attributes. */ 3919 const struct attribute_spec cxx_attribute_table[] = 3920 { 3921 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler, 3922 affects_type_identity } */ 3923 { "init_priority", 1, 1, true, false, false, 3924 handle_init_priority_attribute, false }, 3925 { "abi_tag", 1, -1, false, false, false, 3926 handle_abi_tag_attribute, true }, 3927 { NULL, 0, 0, false, false, false, NULL, false } 3928 }; 3929 3930 /* Table of C++ standard attributes. */ 3931 const struct attribute_spec std_attribute_table[] = 3932 { 3933 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler, 3934 affects_type_identity } */ 3935 { "maybe_unused", 0, 0, false, false, false, 3936 handle_unused_attribute, false }, 3937 { "nodiscard", 0, 0, false, false, false, 3938 handle_nodiscard_attribute, false }, 3939 { NULL, 0, 0, false, false, false, NULL, false } 3940 }; 3941 3942 /* Handle an "init_priority" attribute; arguments as in 3943 struct attribute_spec.handler. */ 3944 static tree 3945 handle_init_priority_attribute (tree* node, 3946 tree name, 3947 tree args, 3948 int /*flags*/, 3949 bool* no_add_attrs) 3950 { 3951 tree initp_expr = TREE_VALUE (args); 3952 tree decl = *node; 3953 tree type = TREE_TYPE (decl); 3954 int pri; 3955 3956 STRIP_NOPS (initp_expr); 3957 initp_expr = default_conversion (initp_expr); 3958 if (initp_expr) 3959 initp_expr = maybe_constant_value (initp_expr); 3960 3961 if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST) 3962 { 3963 error ("requested init_priority is not an integer constant"); 3964 cxx_constant_value (initp_expr); 3965 *no_add_attrs = true; 3966 return NULL_TREE; 3967 } 3968 3969 pri = TREE_INT_CST_LOW (initp_expr); 3970 3971 type = strip_array_types (type); 3972 3973 if (decl == NULL_TREE 3974 || !VAR_P (decl) 3975 || !TREE_STATIC (decl) 3976 || DECL_EXTERNAL (decl) 3977 || (TREE_CODE (type) != RECORD_TYPE 3978 && TREE_CODE (type) != UNION_TYPE) 3979 /* Static objects in functions are initialized the 3980 first time control passes through that 3981 function. This is not precise enough to pin down an 3982 init_priority value, so don't allow it. */ 3983 || current_function_decl) 3984 { 3985 error ("can only use %qE attribute on file-scope definitions " 3986 "of objects of class type", name); 3987 *no_add_attrs = true; 3988 return NULL_TREE; 3989 } 3990 3991 if (pri > MAX_INIT_PRIORITY || pri <= 0) 3992 { 3993 error ("requested init_priority is out of range"); 3994 *no_add_attrs = true; 3995 return NULL_TREE; 3996 } 3997 3998 /* Check for init_priorities that are reserved for 3999 language and runtime support implementations.*/ 4000 if (pri <= MAX_RESERVED_INIT_PRIORITY) 4001 { 4002 warning 4003 (0, "requested init_priority is reserved for internal use"); 4004 } 4005 4006 if (SUPPORTS_INIT_PRIORITY) 4007 { 4008 SET_DECL_INIT_PRIORITY (decl, pri); 4009 DECL_HAS_INIT_PRIORITY_P (decl) = 1; 4010 return NULL_TREE; 4011 } 4012 else 4013 { 4014 error ("%qE attribute is not supported on this platform", name); 4015 *no_add_attrs = true; 4016 return NULL_TREE; 4017 } 4018 } 4019 4020 /* DECL is being redeclared; the old declaration had the abi tags in OLD, 4021 and the new one has the tags in NEW_. Give an error if there are tags 4022 in NEW_ that weren't in OLD. */ 4023 4024 bool 4025 check_abi_tag_redeclaration (const_tree decl, const_tree old, const_tree new_) 4026 { 4027 if (old && TREE_CODE (TREE_VALUE (old)) == TREE_LIST) 4028 old = TREE_VALUE (old); 4029 if (new_ && TREE_CODE (TREE_VALUE (new_)) == TREE_LIST) 4030 new_ = TREE_VALUE (new_); 4031 bool err = false; 4032 for (const_tree t = new_; t; t = TREE_CHAIN (t)) 4033 { 4034 tree str = TREE_VALUE (t); 4035 for (const_tree in = old; in; in = TREE_CHAIN (in)) 4036 { 4037 tree ostr = TREE_VALUE (in); 4038 if (cp_tree_equal (str, ostr)) 4039 goto found; 4040 } 4041 error ("redeclaration of %qD adds abi tag %E", decl, str); 4042 err = true; 4043 found:; 4044 } 4045 if (err) 4046 { 4047 inform (DECL_SOURCE_LOCATION (decl), "previous declaration here"); 4048 return false; 4049 } 4050 return true; 4051 } 4052 4053 /* The abi_tag attribute with the name NAME was given ARGS. If they are 4054 ill-formed, give an error and return false; otherwise, return true. */ 4055 4056 bool 4057 check_abi_tag_args (tree args, tree name) 4058 { 4059 if (!args) 4060 { 4061 error ("the %qE attribute requires arguments", name); 4062 return false; 4063 } 4064 for (tree arg = args; arg; arg = TREE_CHAIN (arg)) 4065 { 4066 tree elt = TREE_VALUE (arg); 4067 if (TREE_CODE (elt) != STRING_CST 4068 || (!same_type_ignoring_top_level_qualifiers_p 4069 (strip_array_types (TREE_TYPE (elt)), 4070 char_type_node))) 4071 { 4072 error ("arguments to the %qE attribute must be narrow string " 4073 "literals", name); 4074 return false; 4075 } 4076 const char *begin = TREE_STRING_POINTER (elt); 4077 const char *end = begin + TREE_STRING_LENGTH (elt); 4078 for (const char *p = begin; p != end; ++p) 4079 { 4080 char c = *p; 4081 if (p == begin) 4082 { 4083 if (!ISALPHA (c) && c != '_') 4084 { 4085 error ("arguments to the %qE attribute must contain valid " 4086 "identifiers", name); 4087 inform (input_location, "%<%c%> is not a valid first " 4088 "character for an identifier", c); 4089 return false; 4090 } 4091 } 4092 else if (p == end - 1) 4093 gcc_assert (c == 0); 4094 else 4095 { 4096 if (!ISALNUM (c) && c != '_') 4097 { 4098 error ("arguments to the %qE attribute must contain valid " 4099 "identifiers", name); 4100 inform (input_location, "%<%c%> is not a valid character " 4101 "in an identifier", c); 4102 return false; 4103 } 4104 } 4105 } 4106 } 4107 return true; 4108 } 4109 4110 /* Handle an "abi_tag" attribute; arguments as in 4111 struct attribute_spec.handler. */ 4112 4113 static tree 4114 handle_abi_tag_attribute (tree* node, tree name, tree args, 4115 int flags, bool* no_add_attrs) 4116 { 4117 if (!check_abi_tag_args (args, name)) 4118 goto fail; 4119 4120 if (TYPE_P (*node)) 4121 { 4122 if (!OVERLOAD_TYPE_P (*node)) 4123 { 4124 error ("%qE attribute applied to non-class, non-enum type %qT", 4125 name, *node); 4126 goto fail; 4127 } 4128 else if (!(flags & (int)ATTR_FLAG_TYPE_IN_PLACE)) 4129 { 4130 error ("%qE attribute applied to %qT after its definition", 4131 name, *node); 4132 goto fail; 4133 } 4134 else if (CLASS_TYPE_P (*node) 4135 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node)) 4136 { 4137 warning (OPT_Wattributes, "ignoring %qE attribute applied to " 4138 "template instantiation %qT", name, *node); 4139 goto fail; 4140 } 4141 else if (CLASS_TYPE_P (*node) 4142 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node)) 4143 { 4144 warning (OPT_Wattributes, "ignoring %qE attribute applied to " 4145 "template specialization %qT", name, *node); 4146 goto fail; 4147 } 4148 4149 tree attributes = TYPE_ATTRIBUTES (*node); 4150 tree decl = TYPE_NAME (*node); 4151 4152 /* Make sure all declarations have the same abi tags. */ 4153 if (DECL_SOURCE_LOCATION (decl) != input_location) 4154 { 4155 if (!check_abi_tag_redeclaration (decl, 4156 lookup_attribute ("abi_tag", 4157 attributes), 4158 args)) 4159 goto fail; 4160 } 4161 } 4162 else 4163 { 4164 if (!VAR_OR_FUNCTION_DECL_P (*node)) 4165 { 4166 error ("%qE attribute applied to non-function, non-variable %qD", 4167 name, *node); 4168 goto fail; 4169 } 4170 else if (DECL_LANGUAGE (*node) == lang_c) 4171 { 4172 error ("%qE attribute applied to extern \"C\" declaration %qD", 4173 name, *node); 4174 goto fail; 4175 } 4176 } 4177 4178 return NULL_TREE; 4179 4180 fail: 4181 *no_add_attrs = true; 4182 return NULL_TREE; 4183 } 4184 4185 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the 4186 thing pointed to by the constant. */ 4187 4188 tree 4189 make_ptrmem_cst (tree type, tree member) 4190 { 4191 tree ptrmem_cst = make_node (PTRMEM_CST); 4192 TREE_TYPE (ptrmem_cst) = type; 4193 PTRMEM_CST_MEMBER (ptrmem_cst) = member; 4194 return ptrmem_cst; 4195 } 4196 4197 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May 4198 return an existing type if an appropriate type already exists. */ 4199 4200 tree 4201 cp_build_type_attribute_variant (tree type, tree attributes) 4202 { 4203 tree new_type; 4204 4205 new_type = build_type_attribute_variant (type, attributes); 4206 if (TREE_CODE (new_type) == FUNCTION_TYPE 4207 || TREE_CODE (new_type) == METHOD_TYPE) 4208 { 4209 new_type = build_exception_variant (new_type, 4210 TYPE_RAISES_EXCEPTIONS (type)); 4211 new_type = build_ref_qualified_type (new_type, 4212 type_memfn_rqual (type)); 4213 } 4214 4215 /* Making a new main variant of a class type is broken. */ 4216 gcc_assert (!CLASS_TYPE_P (type) || new_type == type); 4217 4218 return new_type; 4219 } 4220 4221 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes. 4222 Called only after doing all language independent checks. */ 4223 4224 bool 4225 cxx_type_hash_eq (const_tree typea, const_tree typeb) 4226 { 4227 gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE 4228 || TREE_CODE (typea) == METHOD_TYPE); 4229 4230 if (type_memfn_rqual (typea) != type_memfn_rqual (typeb)) 4231 return false; 4232 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea), 4233 TYPE_RAISES_EXCEPTIONS (typeb), ce_exact); 4234 } 4235 4236 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For 4237 C++, these are the exception-specifier and ref-qualifier. */ 4238 4239 tree 4240 cxx_copy_lang_qualifiers (const_tree typea, const_tree typeb) 4241 { 4242 tree type = CONST_CAST_TREE (typea); 4243 if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE) 4244 { 4245 type = build_exception_variant (type, TYPE_RAISES_EXCEPTIONS (typeb)); 4246 type = build_ref_qualified_type (type, type_memfn_rqual (typeb)); 4247 } 4248 return type; 4249 } 4250 4251 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order 4252 traversal. Called from walk_tree. */ 4253 4254 tree 4255 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func, 4256 void *data, hash_set<tree> *pset) 4257 { 4258 enum tree_code code = TREE_CODE (*tp); 4259 tree result; 4260 4261 #define WALK_SUBTREE(NODE) \ 4262 do \ 4263 { \ 4264 result = cp_walk_tree (&(NODE), func, data, pset); \ 4265 if (result) goto out; \ 4266 } \ 4267 while (0) 4268 4269 /* Not one of the easy cases. We must explicitly go through the 4270 children. */ 4271 result = NULL_TREE; 4272 switch (code) 4273 { 4274 case DEFAULT_ARG: 4275 case TEMPLATE_TEMPLATE_PARM: 4276 case BOUND_TEMPLATE_TEMPLATE_PARM: 4277 case UNBOUND_CLASS_TEMPLATE: 4278 case TEMPLATE_PARM_INDEX: 4279 case TEMPLATE_TYPE_PARM: 4280 case TYPENAME_TYPE: 4281 case TYPEOF_TYPE: 4282 case UNDERLYING_TYPE: 4283 /* None of these have subtrees other than those already walked 4284 above. */ 4285 *walk_subtrees_p = 0; 4286 break; 4287 4288 case BASELINK: 4289 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp)); 4290 *walk_subtrees_p = 0; 4291 break; 4292 4293 case PTRMEM_CST: 4294 WALK_SUBTREE (TREE_TYPE (*tp)); 4295 *walk_subtrees_p = 0; 4296 break; 4297 4298 case TREE_LIST: 4299 WALK_SUBTREE (TREE_PURPOSE (*tp)); 4300 break; 4301 4302 case OVERLOAD: 4303 WALK_SUBTREE (OVL_FUNCTION (*tp)); 4304 WALK_SUBTREE (OVL_CHAIN (*tp)); 4305 *walk_subtrees_p = 0; 4306 break; 4307 4308 case USING_DECL: 4309 WALK_SUBTREE (DECL_NAME (*tp)); 4310 WALK_SUBTREE (USING_DECL_SCOPE (*tp)); 4311 WALK_SUBTREE (USING_DECL_DECLS (*tp)); 4312 *walk_subtrees_p = 0; 4313 break; 4314 4315 case RECORD_TYPE: 4316 if (TYPE_PTRMEMFUNC_P (*tp)) 4317 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp)); 4318 break; 4319 4320 case TYPE_ARGUMENT_PACK: 4321 case NONTYPE_ARGUMENT_PACK: 4322 { 4323 tree args = ARGUMENT_PACK_ARGS (*tp); 4324 int i, len = TREE_VEC_LENGTH (args); 4325 for (i = 0; i < len; i++) 4326 WALK_SUBTREE (TREE_VEC_ELT (args, i)); 4327 } 4328 break; 4329 4330 case TYPE_PACK_EXPANSION: 4331 WALK_SUBTREE (TREE_TYPE (*tp)); 4332 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp)); 4333 *walk_subtrees_p = 0; 4334 break; 4335 4336 case EXPR_PACK_EXPANSION: 4337 WALK_SUBTREE (TREE_OPERAND (*tp, 0)); 4338 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp)); 4339 *walk_subtrees_p = 0; 4340 break; 4341 4342 case CAST_EXPR: 4343 case REINTERPRET_CAST_EXPR: 4344 case STATIC_CAST_EXPR: 4345 case CONST_CAST_EXPR: 4346 case DYNAMIC_CAST_EXPR: 4347 case IMPLICIT_CONV_EXPR: 4348 if (TREE_TYPE (*tp)) 4349 WALK_SUBTREE (TREE_TYPE (*tp)); 4350 4351 { 4352 int i; 4353 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i) 4354 WALK_SUBTREE (TREE_OPERAND (*tp, i)); 4355 } 4356 *walk_subtrees_p = 0; 4357 break; 4358 4359 case TRAIT_EXPR: 4360 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp)); 4361 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp)); 4362 *walk_subtrees_p = 0; 4363 break; 4364 4365 case DECLTYPE_TYPE: 4366 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp)); 4367 *walk_subtrees_p = 0; 4368 break; 4369 4370 case REQUIRES_EXPR: 4371 // Only recurse through the nested expression. Do not 4372 // walk the parameter list. Doing so causes false 4373 // positives in the pack expansion checker since the 4374 // requires parameters are introduced as pack expansions. 4375 WALK_SUBTREE (TREE_OPERAND (*tp, 1)); 4376 *walk_subtrees_p = 0; 4377 break; 4378 4379 case DECL_EXPR: 4380 /* User variables should be mentioned in BIND_EXPR_VARS 4381 and their initializers and sizes walked when walking 4382 the containing BIND_EXPR. Compiler temporaries are 4383 handled here. */ 4384 if (VAR_P (TREE_OPERAND (*tp, 0)) 4385 && DECL_ARTIFICIAL (TREE_OPERAND (*tp, 0)) 4386 && !TREE_STATIC (TREE_OPERAND (*tp, 0))) 4387 { 4388 tree decl = TREE_OPERAND (*tp, 0); 4389 WALK_SUBTREE (DECL_INITIAL (decl)); 4390 WALK_SUBTREE (DECL_SIZE (decl)); 4391 WALK_SUBTREE (DECL_SIZE_UNIT (decl)); 4392 } 4393 break; 4394 4395 default: 4396 return NULL_TREE; 4397 } 4398 4399 /* We didn't find what we were looking for. */ 4400 out: 4401 return result; 4402 4403 #undef WALK_SUBTREE 4404 } 4405 4406 /* Like save_expr, but for C++. */ 4407 4408 tree 4409 cp_save_expr (tree expr) 4410 { 4411 /* There is no reason to create a SAVE_EXPR within a template; if 4412 needed, we can create the SAVE_EXPR when instantiating the 4413 template. Furthermore, the middle-end cannot handle C++-specific 4414 tree codes. */ 4415 if (processing_template_decl) 4416 return expr; 4417 return save_expr (expr); 4418 } 4419 4420 /* Initialize tree.c. */ 4421 4422 void 4423 init_tree (void) 4424 { 4425 list_hash_table = hash_table<list_hasher>::create_ggc (61); 4426 register_scoped_attributes (std_attribute_table, NULL); 4427 } 4428 4429 /* Returns the kind of special function that DECL (a FUNCTION_DECL) 4430 is. Note that sfk_none is zero, so this function can be used as a 4431 predicate to test whether or not DECL is a special function. */ 4432 4433 special_function_kind 4434 special_function_p (const_tree decl) 4435 { 4436 /* Rather than doing all this stuff with magic names, we should 4437 probably have a field of type `special_function_kind' in 4438 DECL_LANG_SPECIFIC. */ 4439 if (DECL_INHERITED_CTOR (decl)) 4440 return sfk_inheriting_constructor; 4441 if (DECL_COPY_CONSTRUCTOR_P (decl)) 4442 return sfk_copy_constructor; 4443 if (DECL_MOVE_CONSTRUCTOR_P (decl)) 4444 return sfk_move_constructor; 4445 if (DECL_CONSTRUCTOR_P (decl)) 4446 return sfk_constructor; 4447 if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR) 4448 { 4449 if (copy_fn_p (decl)) 4450 return sfk_copy_assignment; 4451 if (move_fn_p (decl)) 4452 return sfk_move_assignment; 4453 } 4454 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)) 4455 return sfk_destructor; 4456 if (DECL_COMPLETE_DESTRUCTOR_P (decl)) 4457 return sfk_complete_destructor; 4458 if (DECL_BASE_DESTRUCTOR_P (decl)) 4459 return sfk_base_destructor; 4460 if (DECL_DELETING_DESTRUCTOR_P (decl)) 4461 return sfk_deleting_destructor; 4462 if (DECL_CONV_FN_P (decl)) 4463 return sfk_conversion; 4464 if (deduction_guide_p (decl)) 4465 return sfk_deduction_guide; 4466 4467 return sfk_none; 4468 } 4469 4470 /* Returns nonzero if TYPE is a character type, including wchar_t. */ 4471 4472 int 4473 char_type_p (tree type) 4474 { 4475 return (same_type_p (type, char_type_node) 4476 || same_type_p (type, unsigned_char_type_node) 4477 || same_type_p (type, signed_char_type_node) 4478 || same_type_p (type, char16_type_node) 4479 || same_type_p (type, char32_type_node) 4480 || same_type_p (type, wchar_type_node)); 4481 } 4482 4483 /* Returns the kind of linkage associated with the indicated DECL. Th 4484 value returned is as specified by the language standard; it is 4485 independent of implementation details regarding template 4486 instantiation, etc. For example, it is possible that a declaration 4487 to which this function assigns external linkage would not show up 4488 as a global symbol when you run `nm' on the resulting object file. */ 4489 4490 linkage_kind 4491 decl_linkage (tree decl) 4492 { 4493 /* This function doesn't attempt to calculate the linkage from first 4494 principles as given in [basic.link]. Instead, it makes use of 4495 the fact that we have already set TREE_PUBLIC appropriately, and 4496 then handles a few special cases. Ideally, we would calculate 4497 linkage first, and then transform that into a concrete 4498 implementation. */ 4499 4500 /* Things that don't have names have no linkage. */ 4501 if (!DECL_NAME (decl)) 4502 return lk_none; 4503 4504 /* Fields have no linkage. */ 4505 if (TREE_CODE (decl) == FIELD_DECL) 4506 return lk_none; 4507 4508 /* Things that are TREE_PUBLIC have external linkage. */ 4509 if (TREE_PUBLIC (decl)) 4510 return lk_external; 4511 4512 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants, 4513 check one of the "clones" for the real linkage. */ 4514 if ((DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl) 4515 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)) 4516 && DECL_CHAIN (decl) 4517 && DECL_CLONED_FUNCTION (DECL_CHAIN (decl))) 4518 return decl_linkage (DECL_CHAIN (decl)); 4519 4520 if (TREE_CODE (decl) == NAMESPACE_DECL) 4521 return lk_external; 4522 4523 /* Linkage of a CONST_DECL depends on the linkage of the enumeration 4524 type. */ 4525 if (TREE_CODE (decl) == CONST_DECL) 4526 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl))); 4527 4528 /* Things in local scope do not have linkage, if they don't have 4529 TREE_PUBLIC set. */ 4530 if (decl_function_context (decl)) 4531 return lk_none; 4532 4533 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but 4534 are considered to have external linkage for language purposes, as do 4535 template instantiations on targets without weak symbols. DECLs really 4536 meant to have internal linkage have DECL_THIS_STATIC set. */ 4537 if (TREE_CODE (decl) == TYPE_DECL) 4538 return lk_external; 4539 if (VAR_OR_FUNCTION_DECL_P (decl)) 4540 { 4541 if (!DECL_THIS_STATIC (decl)) 4542 return lk_external; 4543 4544 /* Static data members and static member functions from classes 4545 in anonymous namespace also don't have TREE_PUBLIC set. */ 4546 if (DECL_CLASS_CONTEXT (decl)) 4547 return lk_external; 4548 } 4549 4550 /* Everything else has internal linkage. */ 4551 return lk_internal; 4552 } 4553 4554 /* Returns the storage duration of the object or reference associated with 4555 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */ 4556 4557 duration_kind 4558 decl_storage_duration (tree decl) 4559 { 4560 if (TREE_CODE (decl) == PARM_DECL) 4561 return dk_auto; 4562 if (TREE_CODE (decl) == FUNCTION_DECL) 4563 return dk_static; 4564 gcc_assert (VAR_P (decl)); 4565 if (!TREE_STATIC (decl) 4566 && !DECL_EXTERNAL (decl)) 4567 return dk_auto; 4568 if (CP_DECL_THREAD_LOCAL_P (decl)) 4569 return dk_thread; 4570 return dk_static; 4571 } 4572 4573 /* EXP is an expression that we want to pre-evaluate. Returns (in 4574 *INITP) an expression that will perform the pre-evaluation. The 4575 value returned by this function is a side-effect free expression 4576 equivalent to the pre-evaluated expression. Callers must ensure 4577 that *INITP is evaluated before EXP. */ 4578 4579 tree 4580 stabilize_expr (tree exp, tree* initp) 4581 { 4582 tree init_expr; 4583 4584 if (!TREE_SIDE_EFFECTS (exp)) 4585 init_expr = NULL_TREE; 4586 else if (VOID_TYPE_P (TREE_TYPE (exp))) 4587 { 4588 init_expr = exp; 4589 exp = void_node; 4590 } 4591 /* There are no expressions with REFERENCE_TYPE, but there can be call 4592 arguments with such a type; just treat it as a pointer. */ 4593 else if (TREE_CODE (TREE_TYPE (exp)) == REFERENCE_TYPE 4594 || SCALAR_TYPE_P (TREE_TYPE (exp)) 4595 || !glvalue_p (exp)) 4596 { 4597 init_expr = get_target_expr (exp); 4598 exp = TARGET_EXPR_SLOT (init_expr); 4599 if (CLASS_TYPE_P (TREE_TYPE (exp))) 4600 exp = move (exp); 4601 else 4602 exp = rvalue (exp); 4603 } 4604 else 4605 { 4606 bool xval = !lvalue_p (exp); 4607 exp = cp_build_addr_expr (exp, tf_warning_or_error); 4608 init_expr = get_target_expr (exp); 4609 exp = TARGET_EXPR_SLOT (init_expr); 4610 exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error); 4611 if (xval) 4612 exp = move (exp); 4613 } 4614 *initp = init_expr; 4615 4616 gcc_assert (!TREE_SIDE_EFFECTS (exp)); 4617 return exp; 4618 } 4619 4620 /* Add NEW_EXPR, an expression whose value we don't care about, after the 4621 similar expression ORIG. */ 4622 4623 tree 4624 add_stmt_to_compound (tree orig, tree new_expr) 4625 { 4626 if (!new_expr || !TREE_SIDE_EFFECTS (new_expr)) 4627 return orig; 4628 if (!orig || !TREE_SIDE_EFFECTS (orig)) 4629 return new_expr; 4630 return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr); 4631 } 4632 4633 /* Like stabilize_expr, but for a call whose arguments we want to 4634 pre-evaluate. CALL is modified in place to use the pre-evaluated 4635 arguments, while, upon return, *INITP contains an expression to 4636 compute the arguments. */ 4637 4638 void 4639 stabilize_call (tree call, tree *initp) 4640 { 4641 tree inits = NULL_TREE; 4642 int i; 4643 int nargs = call_expr_nargs (call); 4644 4645 if (call == error_mark_node || processing_template_decl) 4646 { 4647 *initp = NULL_TREE; 4648 return; 4649 } 4650 4651 gcc_assert (TREE_CODE (call) == CALL_EXPR); 4652 4653 for (i = 0; i < nargs; i++) 4654 { 4655 tree init; 4656 CALL_EXPR_ARG (call, i) = 4657 stabilize_expr (CALL_EXPR_ARG (call, i), &init); 4658 inits = add_stmt_to_compound (inits, init); 4659 } 4660 4661 *initp = inits; 4662 } 4663 4664 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want 4665 to pre-evaluate. CALL is modified in place to use the pre-evaluated 4666 arguments, while, upon return, *INITP contains an expression to 4667 compute the arguments. */ 4668 4669 static void 4670 stabilize_aggr_init (tree call, tree *initp) 4671 { 4672 tree inits = NULL_TREE; 4673 int i; 4674 int nargs = aggr_init_expr_nargs (call); 4675 4676 if (call == error_mark_node) 4677 return; 4678 4679 gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR); 4680 4681 for (i = 0; i < nargs; i++) 4682 { 4683 tree init; 4684 AGGR_INIT_EXPR_ARG (call, i) = 4685 stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init); 4686 inits = add_stmt_to_compound (inits, init); 4687 } 4688 4689 *initp = inits; 4690 } 4691 4692 /* Like stabilize_expr, but for an initialization. 4693 4694 If the initialization is for an object of class type, this function 4695 takes care not to introduce additional temporaries. 4696 4697 Returns TRUE iff the expression was successfully pre-evaluated, 4698 i.e., if INIT is now side-effect free, except for, possibly, a 4699 single call to a constructor. */ 4700 4701 bool 4702 stabilize_init (tree init, tree *initp) 4703 { 4704 tree t = init; 4705 4706 *initp = NULL_TREE; 4707 4708 if (t == error_mark_node || processing_template_decl) 4709 return true; 4710 4711 if (TREE_CODE (t) == INIT_EXPR) 4712 t = TREE_OPERAND (t, 1); 4713 if (TREE_CODE (t) == TARGET_EXPR) 4714 t = TARGET_EXPR_INITIAL (t); 4715 4716 /* If the RHS can be stabilized without breaking copy elision, stabilize 4717 it. We specifically don't stabilize class prvalues here because that 4718 would mean an extra copy, but they might be stabilized below. */ 4719 if (TREE_CODE (init) == INIT_EXPR 4720 && TREE_CODE (t) != CONSTRUCTOR 4721 && TREE_CODE (t) != AGGR_INIT_EXPR 4722 && (SCALAR_TYPE_P (TREE_TYPE (t)) 4723 || glvalue_p (t))) 4724 { 4725 TREE_OPERAND (init, 1) = stabilize_expr (t, initp); 4726 return true; 4727 } 4728 4729 if (TREE_CODE (t) == COMPOUND_EXPR 4730 && TREE_CODE (init) == INIT_EXPR) 4731 { 4732 tree last = expr_last (t); 4733 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */ 4734 if (!TREE_SIDE_EFFECTS (last)) 4735 { 4736 *initp = t; 4737 TREE_OPERAND (init, 1) = last; 4738 return true; 4739 } 4740 } 4741 4742 if (TREE_CODE (t) == CONSTRUCTOR) 4743 { 4744 /* Aggregate initialization: stabilize each of the field 4745 initializers. */ 4746 unsigned i; 4747 constructor_elt *ce; 4748 bool good = true; 4749 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t); 4750 for (i = 0; vec_safe_iterate (v, i, &ce); ++i) 4751 { 4752 tree type = TREE_TYPE (ce->value); 4753 tree subinit; 4754 if (TREE_CODE (type) == REFERENCE_TYPE 4755 || SCALAR_TYPE_P (type)) 4756 ce->value = stabilize_expr (ce->value, &subinit); 4757 else if (!stabilize_init (ce->value, &subinit)) 4758 good = false; 4759 *initp = add_stmt_to_compound (*initp, subinit); 4760 } 4761 return good; 4762 } 4763 4764 if (TREE_CODE (t) == CALL_EXPR) 4765 { 4766 stabilize_call (t, initp); 4767 return true; 4768 } 4769 4770 if (TREE_CODE (t) == AGGR_INIT_EXPR) 4771 { 4772 stabilize_aggr_init (t, initp); 4773 return true; 4774 } 4775 4776 /* The initialization is being performed via a bitwise copy -- and 4777 the item copied may have side effects. */ 4778 return !TREE_SIDE_EFFECTS (init); 4779 } 4780 4781 /* Returns true if a cast to TYPE may appear in an integral constant 4782 expression. */ 4783 4784 bool 4785 cast_valid_in_integral_constant_expression_p (tree type) 4786 { 4787 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type) 4788 || cxx_dialect >= cxx11 4789 || dependent_type_p (type) 4790 || type == error_mark_node); 4791 } 4792 4793 /* Return true if we need to fix linkage information of DECL. */ 4794 4795 static bool 4796 cp_fix_function_decl_p (tree decl) 4797 { 4798 /* Skip if DECL is not externally visible. */ 4799 if (!TREE_PUBLIC (decl)) 4800 return false; 4801 4802 /* We need to fix DECL if it a appears to be exported but with no 4803 function body. Thunks do not have CFGs and we may need to 4804 handle them specially later. */ 4805 if (!gimple_has_body_p (decl) 4806 && !DECL_THUNK_P (decl) 4807 && !DECL_EXTERNAL (decl)) 4808 { 4809 struct cgraph_node *node = cgraph_node::get (decl); 4810 4811 /* Don't fix same_body aliases. Although they don't have their own 4812 CFG, they share it with what they alias to. */ 4813 if (!node || !node->alias 4814 || !vec_safe_length (node->ref_list.references)) 4815 return true; 4816 } 4817 4818 return false; 4819 } 4820 4821 /* Clean the C++ specific parts of the tree T. */ 4822 4823 void 4824 cp_free_lang_data (tree t) 4825 { 4826 if (TREE_CODE (t) == METHOD_TYPE 4827 || TREE_CODE (t) == FUNCTION_TYPE) 4828 { 4829 /* Default args are not interesting anymore. */ 4830 tree argtypes = TYPE_ARG_TYPES (t); 4831 while (argtypes) 4832 { 4833 TREE_PURPOSE (argtypes) = 0; 4834 argtypes = TREE_CHAIN (argtypes); 4835 } 4836 } 4837 else if (TREE_CODE (t) == FUNCTION_DECL 4838 && cp_fix_function_decl_p (t)) 4839 { 4840 /* If T is used in this translation unit at all, the definition 4841 must exist somewhere else since we have decided to not emit it 4842 in this TU. So make it an external reference. */ 4843 DECL_EXTERNAL (t) = 1; 4844 TREE_STATIC (t) = 0; 4845 } 4846 if (TREE_CODE (t) == NAMESPACE_DECL) 4847 { 4848 /* The list of users of a namespace isn't useful for the middle-end 4849 or debug generators. */ 4850 DECL_NAMESPACE_USERS (t) = NULL_TREE; 4851 /* Neither do we need the leftover chaining of namespaces 4852 from the binding level. */ 4853 DECL_CHAIN (t) = NULL_TREE; 4854 } 4855 } 4856 4857 /* Stub for c-common. Please keep in sync with c-decl.c. 4858 FIXME: If address space support is target specific, then this 4859 should be a C target hook. But currently this is not possible, 4860 because this function is called via REGISTER_TARGET_PRAGMAS. */ 4861 void 4862 c_register_addr_space (const char * /*word*/, addr_space_t /*as*/) 4863 { 4864 } 4865 4866 /* Return the number of operands in T that we care about for things like 4867 mangling. */ 4868 4869 int 4870 cp_tree_operand_length (const_tree t) 4871 { 4872 enum tree_code code = TREE_CODE (t); 4873 4874 if (TREE_CODE_CLASS (code) == tcc_vl_exp) 4875 return VL_EXP_OPERAND_LENGTH (t); 4876 4877 return cp_tree_code_length (code); 4878 } 4879 4880 /* Like cp_tree_operand_length, but takes a tree_code CODE. */ 4881 4882 int 4883 cp_tree_code_length (enum tree_code code) 4884 { 4885 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp); 4886 4887 switch (code) 4888 { 4889 case PREINCREMENT_EXPR: 4890 case PREDECREMENT_EXPR: 4891 case POSTINCREMENT_EXPR: 4892 case POSTDECREMENT_EXPR: 4893 return 1; 4894 4895 case ARRAY_REF: 4896 return 2; 4897 4898 case EXPR_PACK_EXPANSION: 4899 return 1; 4900 4901 default: 4902 return TREE_CODE_LENGTH (code); 4903 } 4904 } 4905 4906 /* Wrapper around warn_deprecated_use that doesn't warn for 4907 current_class_type. */ 4908 4909 void 4910 cp_warn_deprecated_use (tree node) 4911 { 4912 if (TYPE_P (node) 4913 && current_class_type 4914 && TYPE_MAIN_VARIANT (node) == current_class_type) 4915 return; 4916 warn_deprecated_use (node, NULL_TREE); 4917 } 4918 4919 /* Implement -Wzero_as_null_pointer_constant. Return true if the 4920 conditions for the warning hold, false otherwise. */ 4921 bool 4922 maybe_warn_zero_as_null_pointer_constant (tree expr, location_t loc) 4923 { 4924 if (c_inhibit_evaluation_warnings == 0 4925 && !NULLPTR_TYPE_P (TREE_TYPE (expr))) 4926 { 4927 warning_at (loc, OPT_Wzero_as_null_pointer_constant, 4928 "zero as null pointer constant"); 4929 return true; 4930 } 4931 return false; 4932 } 4933 4934 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) 4935 /* Complain that some language-specific thing hanging off a tree 4936 node has been accessed improperly. */ 4937 4938 void 4939 lang_check_failed (const char* file, int line, const char* function) 4940 { 4941 internal_error ("lang_* check: failed in %s, at %s:%d", 4942 function, trim_filename (file), line); 4943 } 4944 #endif /* ENABLE_TREE_CHECKING */ 4945 4946 #include "gt-cp-tree.h" 4947