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