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