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