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 Free Software Foundation, Inc. 4 Hacked by Michael Tiemann (tiemann@cygnus.com) 5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2, or (at your option) 11any later version. 12 13GCC is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with GCC; see the file COPYING. If not, write to 20the Free Software Foundation, 51 Franklin Street, Fifth Floor, 21Boston, MA 02110-1301, USA. */ 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 "real.h" 31#include "rtl.h" 32#include "toplev.h" 33#include "insn-config.h" 34#include "integrate.h" 35#include "tree-inline.h" 36#include "debug.h" 37#include "target.h" 38 39static tree bot_manip (tree *, int *, void *); 40static tree bot_replace (tree *, int *, void *); 41static tree build_cplus_array_type_1 (tree, tree); 42static int list_hash_eq (const void *, const void *); 43static hashval_t list_hash_pieces (tree, tree, tree); 44static hashval_t list_hash (const void *); 45static cp_lvalue_kind lvalue_p_1 (tree, int); 46static tree build_target_expr (tree, tree); 47static tree count_trees_r (tree *, int *, void *); 48static tree verify_stmt_tree_r (tree *, int *, void *); 49static tree find_tree_r (tree *, int *, void *); 50static tree build_local_temp (tree); 51 52static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *); 53static tree handle_com_interface_attribute (tree *, tree, tree, int, bool *); 54static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *); 55 56/* If REF is an lvalue, returns the kind of lvalue that REF is. 57 Otherwise, returns clk_none. If TREAT_CLASS_RVALUES_AS_LVALUES is 58 nonzero, rvalues of class type are considered lvalues. */ 59 60static cp_lvalue_kind 61lvalue_p_1 (tree ref, 62 int treat_class_rvalues_as_lvalues) 63{ 64 cp_lvalue_kind op1_lvalue_kind = clk_none; 65 cp_lvalue_kind op2_lvalue_kind = clk_none; 66 67 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE) 68 return clk_ordinary; 69 70 if (ref == current_class_ptr) 71 return clk_none; 72 73 switch (TREE_CODE (ref)) 74 { 75 /* preincrements and predecrements are valid lvals, provided 76 what they refer to are valid lvals. */ 77 case PREINCREMENT_EXPR: 78 case PREDECREMENT_EXPR: 79 case SAVE_EXPR: 80 case TRY_CATCH_EXPR: 81 case WITH_CLEANUP_EXPR: 82 case REALPART_EXPR: 83 case IMAGPART_EXPR: 84 return lvalue_p_1 (TREE_OPERAND (ref, 0), 85 treat_class_rvalues_as_lvalues); 86 87 case COMPONENT_REF: 88 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0), 89 treat_class_rvalues_as_lvalues); 90 /* Look at the member designator. */ 91 if (!op1_lvalue_kind 92 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some 93 situations. */ 94 || TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL) 95 ; 96 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1))) 97 { 98 /* Clear the ordinary bit. If this object was a class 99 rvalue we want to preserve that information. */ 100 op1_lvalue_kind &= ~clk_ordinary; 101 /* The lvalue is for a bitfield. */ 102 op1_lvalue_kind |= clk_bitfield; 103 } 104 else if (DECL_PACKED (TREE_OPERAND (ref, 1))) 105 op1_lvalue_kind |= clk_packed; 106 107 return op1_lvalue_kind; 108 109 case STRING_CST: 110 return clk_ordinary; 111 112 case CONST_DECL: 113 case VAR_DECL: 114 if (TREE_READONLY (ref) && ! TREE_STATIC (ref) 115 && DECL_LANG_SPECIFIC (ref) 116 && DECL_IN_AGGR_P (ref)) 117 return clk_none; 118 case INDIRECT_REF: 119 case ARRAY_REF: 120 case PARM_DECL: 121 case RESULT_DECL: 122 if (TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE) 123 return clk_ordinary; 124 break; 125 126 /* A currently unresolved scope ref. */ 127 case SCOPE_REF: 128 gcc_unreachable (); 129 case MAX_EXPR: 130 case MIN_EXPR: 131 /* Disallow <? and >? as lvalues if either argument side-effects. */ 132 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0)) 133 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1))) 134 return clk_none; 135 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0), 136 treat_class_rvalues_as_lvalues); 137 op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1), 138 treat_class_rvalues_as_lvalues); 139 break; 140 141 case COND_EXPR: 142 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1), 143 treat_class_rvalues_as_lvalues); 144 op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 2), 145 treat_class_rvalues_as_lvalues); 146 break; 147 148 case MODIFY_EXPR: 149 return clk_ordinary; 150 151 case COMPOUND_EXPR: 152 return lvalue_p_1 (TREE_OPERAND (ref, 1), 153 treat_class_rvalues_as_lvalues); 154 155 case TARGET_EXPR: 156 return treat_class_rvalues_as_lvalues ? clk_class : clk_none; 157 158 case VA_ARG_EXPR: 159 return (treat_class_rvalues_as_lvalues 160 && CLASS_TYPE_P (TREE_TYPE (ref)) 161 ? clk_class : clk_none); 162 163 case CALL_EXPR: 164 /* Any class-valued call would be wrapped in a TARGET_EXPR. */ 165 return clk_none; 166 167 case FUNCTION_DECL: 168 /* All functions (except non-static-member functions) are 169 lvalues. */ 170 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref) 171 ? clk_none : clk_ordinary); 172 173 case NON_DEPENDENT_EXPR: 174 /* We must consider NON_DEPENDENT_EXPRs to be lvalues so that 175 things like "&E" where "E" is an expression with a 176 non-dependent type work. It is safe to be lenient because an 177 error will be issued when the template is instantiated if "E" 178 is not an lvalue. */ 179 return clk_ordinary; 180 181 default: 182 break; 183 } 184 185 /* If one operand is not an lvalue at all, then this expression is 186 not an lvalue. */ 187 if (!op1_lvalue_kind || !op2_lvalue_kind) 188 return clk_none; 189 190 /* Otherwise, it's an lvalue, and it has all the odd properties 191 contributed by either operand. */ 192 op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind; 193 /* It's not an ordinary lvalue if it involves either a bit-field or 194 a class rvalue. */ 195 if ((op1_lvalue_kind & ~clk_ordinary) != clk_none) 196 op1_lvalue_kind &= ~clk_ordinary; 197 return op1_lvalue_kind; 198} 199 200/* Returns the kind of lvalue that REF is, in the sense of 201 [basic.lval]. This function should really be named lvalue_p; it 202 computes the C++ definition of lvalue. */ 203 204cp_lvalue_kind 205real_lvalue_p (tree ref) 206{ 207 return lvalue_p_1 (ref, 208 /*treat_class_rvalues_as_lvalues=*/0); 209} 210 211/* This differs from real_lvalue_p in that class rvalues are 212 considered lvalues. */ 213 214int 215lvalue_p (tree ref) 216{ 217 return 218 (lvalue_p_1 (ref, /*class rvalue ok*/ 1) != clk_none); 219} 220 221/* Test whether DECL is a builtin that may appear in a 222 constant-expression. */ 223 224bool 225builtin_valid_in_constant_expr_p (tree decl) 226{ 227 /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing 228 in constant-expressions. We may want to add other builtins later. */ 229 return DECL_IS_BUILTIN_CONSTANT_P (decl); 230} 231 232/* Build a TARGET_EXPR, initializing the DECL with the VALUE. */ 233 234static tree 235build_target_expr (tree decl, tree value) 236{ 237 tree t; 238 239 t = build4 (TARGET_EXPR, TREE_TYPE (decl), decl, value, 240 cxx_maybe_build_cleanup (decl), NULL_TREE); 241 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not 242 ignore the TARGET_EXPR. If there really turn out to be no 243 side-effects, then the optimizer should be able to get rid of 244 whatever code is generated anyhow. */ 245 TREE_SIDE_EFFECTS (t) = 1; 246 247 return t; 248} 249 250/* Return an undeclared local temporary of type TYPE for use in building a 251 TARGET_EXPR. */ 252 253static tree 254build_local_temp (tree type) 255{ 256 tree slot = build_decl (VAR_DECL, NULL_TREE, type); 257 DECL_ARTIFICIAL (slot) = 1; 258 DECL_IGNORED_P (slot) = 1; 259 DECL_CONTEXT (slot) = current_function_decl; 260 layout_decl (slot, 0); 261 return slot; 262} 263 264/* INIT is a CALL_EXPR which needs info about its target. 265 TYPE is the type that this initialization should appear to have. 266 267 Build an encapsulation of the initialization to perform 268 and return it so that it can be processed by language-independent 269 and language-specific expression expanders. */ 270 271tree 272build_cplus_new (tree type, tree init) 273{ 274 tree fn; 275 tree slot; 276 tree rval; 277 int is_ctor; 278 279 /* Make sure that we're not trying to create an instance of an 280 abstract class. */ 281 abstract_virtuals_error (NULL_TREE, type); 282 283 if (TREE_CODE (init) != CALL_EXPR && TREE_CODE (init) != AGGR_INIT_EXPR) 284 return convert (type, init); 285 286 fn = TREE_OPERAND (init, 0); 287 is_ctor = (TREE_CODE (fn) == ADDR_EXPR 288 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL 289 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0))); 290 291 slot = build_local_temp (type); 292 293 /* We split the CALL_EXPR into its function and its arguments here. 294 Then, in expand_expr, we put them back together. The reason for 295 this is that this expression might be a default argument 296 expression. In that case, we need a new temporary every time the 297 expression is used. That's what break_out_target_exprs does; it 298 replaces every AGGR_INIT_EXPR with a copy that uses a fresh 299 temporary slot. Then, expand_expr builds up a call-expression 300 using the new slot. */ 301 302 /* If we don't need to use a constructor to create an object of this 303 type, don't mess with AGGR_INIT_EXPR. */ 304 if (is_ctor || TREE_ADDRESSABLE (type)) 305 { 306 rval = build3 (AGGR_INIT_EXPR, void_type_node, fn, 307 TREE_OPERAND (init, 1), slot); 308 TREE_SIDE_EFFECTS (rval) = 1; 309 AGGR_INIT_VIA_CTOR_P (rval) = is_ctor; 310 } 311 else 312 rval = init; 313 314 rval = build_target_expr (slot, rval); 315 316 return rval; 317} 318 319/* Build a TARGET_EXPR using INIT to initialize a new temporary of the 320 indicated TYPE. */ 321 322tree 323build_target_expr_with_type (tree init, tree type) 324{ 325 tree slot; 326 327 gcc_assert (!VOID_TYPE_P (type)); 328 329 if (TREE_CODE (init) == TARGET_EXPR) 330 return init; 331 else if (CLASS_TYPE_P (type) && !TYPE_HAS_TRIVIAL_INIT_REF (type) 332 && TREE_CODE (init) != COND_EXPR 333 && TREE_CODE (init) != CONSTRUCTOR 334 && TREE_CODE (init) != VA_ARG_EXPR) 335 /* We need to build up a copy constructor call. COND_EXPR is a special 336 case because we already have copies on the arms and we don't want 337 another one here. A CONSTRUCTOR is aggregate initialization, which 338 is handled separately. A VA_ARG_EXPR is magic creation of an 339 aggregate; there's no additional work to be done. */ 340 return force_rvalue (init); 341 342 slot = build_local_temp (type); 343 return build_target_expr (slot, init); 344} 345 346/* Like the above function, but without the checking. This function should 347 only be used by code which is deliberately trying to subvert the type 348 system, such as call_builtin_trap. */ 349 350tree 351force_target_expr (tree type, tree init) 352{ 353 tree slot; 354 355 gcc_assert (!VOID_TYPE_P (type)); 356 357 slot = build_local_temp (type); 358 return build_target_expr (slot, init); 359} 360 361/* Like build_target_expr_with_type, but use the type of INIT. */ 362 363tree 364get_target_expr (tree init) 365{ 366 return build_target_expr_with_type (init, TREE_TYPE (init)); 367} 368 369/* EXPR is being used in an rvalue context. Return a version of EXPR 370 that is marked as an rvalue. */ 371 372tree 373rvalue (tree expr) 374{ 375 tree type; 376 if (real_lvalue_p (expr)) 377 { 378 type = TREE_TYPE (expr); 379 /* [basic.lval] 380 381 Non-class rvalues always have cv-unqualified types. */ 382 if (!CLASS_TYPE_P (type)) 383 type = TYPE_MAIN_VARIANT (type); 384 expr = build1 (NON_LVALUE_EXPR, type, expr); 385 } 386 return expr; 387} 388 389 390static tree 391build_cplus_array_type_1 (tree elt_type, tree index_type) 392{ 393 tree t; 394 395 if (elt_type == error_mark_node || index_type == error_mark_node) 396 return error_mark_node; 397 398 if (dependent_type_p (elt_type) 399 || (index_type 400 && value_dependent_expression_p (TYPE_MAX_VALUE (index_type)))) 401 { 402 t = make_node (ARRAY_TYPE); 403 TREE_TYPE (t) = elt_type; 404 TYPE_DOMAIN (t) = index_type; 405 } 406 else 407 t = build_array_type (elt_type, index_type); 408 409 /* Push these needs up so that initialization takes place 410 more easily. */ 411 TYPE_NEEDS_CONSTRUCTING (t) 412 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type)); 413 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) 414 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type)); 415 return t; 416} 417 418tree 419build_cplus_array_type (tree elt_type, tree index_type) 420{ 421 tree t; 422 int type_quals = cp_type_quals (elt_type); 423 424 if (type_quals != TYPE_UNQUALIFIED) 425 elt_type = cp_build_qualified_type (elt_type, TYPE_UNQUALIFIED); 426 427 t = build_cplus_array_type_1 (elt_type, index_type); 428 429 if (type_quals != TYPE_UNQUALIFIED) 430 t = cp_build_qualified_type (t, type_quals); 431 432 return t; 433} 434 435/* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles 436 arrays correctly. In particular, if TYPE is an array of T's, and 437 TYPE_QUALS is non-empty, returns an array of qualified T's. 438 439 FLAGS determines how to deal with illformed qualifications. If 440 tf_ignore_bad_quals is set, then bad qualifications are dropped 441 (this is permitted if TYPE was introduced via a typedef or template 442 type parameter). If bad qualifications are dropped and tf_warning 443 is set, then a warning is issued for non-const qualifications. If 444 tf_ignore_bad_quals is not set and tf_error is not set, we 445 return error_mark_node. Otherwise, we issue an error, and ignore 446 the qualifications. 447 448 Qualification of a reference type is valid when the reference came 449 via a typedef or template type argument. [dcl.ref] No such 450 dispensation is provided for qualifying a function type. [dcl.fct] 451 DR 295 queries this and the proposed resolution brings it into line 452 with qualifying a reference. We implement the DR. We also behave 453 in a similar manner for restricting non-pointer types. */ 454 455tree 456cp_build_qualified_type_real (tree type, 457 int type_quals, 458 tsubst_flags_t complain) 459{ 460 tree result; 461 int bad_quals = TYPE_UNQUALIFIED; 462 463 if (type == error_mark_node) 464 return type; 465 466 if (type_quals == cp_type_quals (type)) 467 return type; 468 469 if (TREE_CODE (type) == ARRAY_TYPE) 470 { 471 /* In C++, the qualification really applies to the array element 472 type. Obtain the appropriately qualified element type. */ 473 tree t; 474 tree element_type 475 = cp_build_qualified_type_real (TREE_TYPE (type), 476 type_quals, 477 complain); 478 479 if (element_type == error_mark_node) 480 return error_mark_node; 481 482 /* See if we already have an identically qualified type. */ 483 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) 484 if (cp_type_quals (t) == type_quals 485 && TYPE_NAME (t) == TYPE_NAME (type) 486 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)) 487 break; 488 489 if (!t) 490 { 491 /* Make a new array type, just like the old one, but with the 492 appropriately qualified element type. */ 493 t = build_variant_type_copy (type); 494 TREE_TYPE (t) = element_type; 495 } 496 497 /* Even if we already had this variant, we update 498 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case 499 they changed since the variant was originally created. 500 501 This seems hokey; if there is some way to use a previous 502 variant *without* coming through here, 503 TYPE_NEEDS_CONSTRUCTING will never be updated. */ 504 TYPE_NEEDS_CONSTRUCTING (t) 505 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type)); 506 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) 507 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type)); 508 return t; 509 } 510 else if (TYPE_PTRMEMFUNC_P (type)) 511 { 512 /* For a pointer-to-member type, we can't just return a 513 cv-qualified version of the RECORD_TYPE. If we do, we 514 haven't changed the field that contains the actual pointer to 515 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */ 516 tree t; 517 518 t = TYPE_PTRMEMFUNC_FN_TYPE (type); 519 t = cp_build_qualified_type_real (t, type_quals, complain); 520 return build_ptrmemfunc_type (t); 521 } 522 523 /* A reference or method type shall not be cv qualified. 524 [dcl.ref], [dct.fct] */ 525 if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE) 526 && (TREE_CODE (type) == REFERENCE_TYPE 527 || TREE_CODE (type) == METHOD_TYPE)) 528 { 529 bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE); 530 type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE); 531 } 532 533 /* A restrict-qualified type must be a pointer (or reference) 534 to object or incomplete type, or a function type. */ 535 if ((type_quals & TYPE_QUAL_RESTRICT) 536 && TREE_CODE (type) != TEMPLATE_TYPE_PARM 537 && TREE_CODE (type) != TYPENAME_TYPE 538 && TREE_CODE (type) != FUNCTION_TYPE 539 && !POINTER_TYPE_P (type)) 540 { 541 bad_quals |= TYPE_QUAL_RESTRICT; 542 type_quals &= ~TYPE_QUAL_RESTRICT; 543 } 544 545 if (bad_quals == TYPE_UNQUALIFIED) 546 /*OK*/; 547 else if (!(complain & (tf_error | tf_ignore_bad_quals))) 548 return error_mark_node; 549 else 550 { 551 if (complain & tf_ignore_bad_quals) 552 /* We're not going to warn about constifying things that can't 553 be constified. */ 554 bad_quals &= ~TYPE_QUAL_CONST; 555 if (bad_quals) 556 { 557 tree bad_type = build_qualified_type (ptr_type_node, bad_quals); 558 559 if (!(complain & tf_ignore_bad_quals)) 560 error ("%qV qualifiers cannot be applied to %qT", 561 bad_type, type); 562 } 563 } 564 565 /* Retrieve (or create) the appropriately qualified variant. */ 566 result = build_qualified_type (type, type_quals); 567 568 /* If this was a pointer-to-method type, and we just made a copy, 569 then we need to unshare the record that holds the cached 570 pointer-to-member-function type, because these will be distinct 571 between the unqualified and qualified types. */ 572 if (result != type 573 && TREE_CODE (type) == POINTER_TYPE 574 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE) 575 TYPE_LANG_SPECIFIC (result) = NULL; 576 577 return result; 578} 579 580/* Returns the canonical version of TYPE. In other words, if TYPE is 581 a typedef, returns the underlying type. The cv-qualification of 582 the type returned matches the type input; they will always be 583 compatible types. */ 584 585tree 586canonical_type_variant (tree t) 587{ 588 return cp_build_qualified_type (TYPE_MAIN_VARIANT (t), cp_type_quals (t)); 589} 590 591/* Makes a copy of BINFO and TYPE, which is to be inherited into a 592 graph dominated by T. If BINFO is NULL, TYPE is a dependent base, 593 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy. 594 VIRT indicates whether TYPE is inherited virtually or not. 595 IGO_PREV points at the previous binfo of the inheritance graph 596 order chain. The newly copied binfo's TREE_CHAIN forms this 597 ordering. 598 599 The CLASSTYPE_VBASECLASSES vector of T is constructed in the 600 correct order. That is in the order the bases themselves should be 601 constructed in. 602 603 The BINFO_INHERITANCE of a virtual base class points to the binfo 604 of the most derived type. ??? We could probably change this so that 605 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence 606 remove a field. They currently can only differ for primary virtual 607 virtual bases. */ 608 609tree 610copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt) 611{ 612 tree new_binfo; 613 614 if (virt) 615 { 616 /* See if we've already made this virtual base. */ 617 new_binfo = binfo_for_vbase (type, t); 618 if (new_binfo) 619 return new_binfo; 620 } 621 622 new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0); 623 BINFO_TYPE (new_binfo) = type; 624 625 /* Chain it into the inheritance graph. */ 626 TREE_CHAIN (*igo_prev) = new_binfo; 627 *igo_prev = new_binfo; 628 629 if (binfo) 630 { 631 int ix; 632 tree base_binfo; 633 634 gcc_assert (!BINFO_DEPENDENT_BASE_P (binfo)); 635 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type)); 636 637 BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo); 638 BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo); 639 640 /* We do not need to copy the accesses, as they are read only. */ 641 BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo); 642 643 /* Recursively copy base binfos of BINFO. */ 644 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++) 645 { 646 tree new_base_binfo; 647 648 gcc_assert (!BINFO_DEPENDENT_BASE_P (base_binfo)); 649 new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo), 650 t, igo_prev, 651 BINFO_VIRTUAL_P (base_binfo)); 652 653 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo)) 654 BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo; 655 BINFO_BASE_APPEND (new_binfo, new_base_binfo); 656 } 657 } 658 else 659 BINFO_DEPENDENT_BASE_P (new_binfo) = 1; 660 661 if (virt) 662 { 663 /* Push it onto the list after any virtual bases it contains 664 will have been pushed. */ 665 VEC_quick_push (tree, CLASSTYPE_VBASECLASSES (t), new_binfo); 666 BINFO_VIRTUAL_P (new_binfo) = 1; 667 BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t); 668 } 669 670 return new_binfo; 671} 672 673/* Hashing of lists so that we don't make duplicates. 674 The entry point is `list_hash_canon'. */ 675 676/* Now here is the hash table. When recording a list, it is added 677 to the slot whose index is the hash code mod the table size. 678 Note that the hash table is used for several kinds of lists. 679 While all these live in the same table, they are completely independent, 680 and the hash code is computed differently for each of these. */ 681 682static GTY ((param_is (union tree_node))) htab_t list_hash_table; 683 684struct list_proxy 685{ 686 tree purpose; 687 tree value; 688 tree chain; 689}; 690 691/* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy 692 for a node we are thinking about adding). */ 693 694static int 695list_hash_eq (const void* entry, const void* data) 696{ 697 tree t = (tree) entry; 698 struct list_proxy *proxy = (struct list_proxy *) data; 699 700 return (TREE_VALUE (t) == proxy->value 701 && TREE_PURPOSE (t) == proxy->purpose 702 && TREE_CHAIN (t) == proxy->chain); 703} 704 705/* Compute a hash code for a list (chain of TREE_LIST nodes 706 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the 707 TREE_COMMON slots), by adding the hash codes of the individual entries. */ 708 709static hashval_t 710list_hash_pieces (tree purpose, tree value, tree chain) 711{ 712 hashval_t hashcode = 0; 713 714 if (chain) 715 hashcode += TREE_HASH (chain); 716 717 if (value) 718 hashcode += TREE_HASH (value); 719 else 720 hashcode += 1007; 721 if (purpose) 722 hashcode += TREE_HASH (purpose); 723 else 724 hashcode += 1009; 725 return hashcode; 726} 727 728/* Hash an already existing TREE_LIST. */ 729 730static hashval_t 731list_hash (const void* p) 732{ 733 tree t = (tree) p; 734 return list_hash_pieces (TREE_PURPOSE (t), 735 TREE_VALUE (t), 736 TREE_CHAIN (t)); 737} 738 739/* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical 740 object for an identical list if one already exists. Otherwise, build a 741 new one, and record it as the canonical object. */ 742 743tree 744hash_tree_cons (tree purpose, tree value, tree chain) 745{ 746 int hashcode = 0; 747 void **slot; 748 struct list_proxy proxy; 749 750 /* Hash the list node. */ 751 hashcode = list_hash_pieces (purpose, value, chain); 752 /* Create a proxy for the TREE_LIST we would like to create. We 753 don't actually create it so as to avoid creating garbage. */ 754 proxy.purpose = purpose; 755 proxy.value = value; 756 proxy.chain = chain; 757 /* See if it is already in the table. */ 758 slot = htab_find_slot_with_hash (list_hash_table, &proxy, hashcode, 759 INSERT); 760 /* If not, create a new node. */ 761 if (!*slot) 762 *slot = tree_cons (purpose, value, chain); 763 return *slot; 764} 765 766/* Constructor for hashed lists. */ 767 768tree 769hash_tree_chain (tree value, tree chain) 770{ 771 return hash_tree_cons (NULL_TREE, value, chain); 772} 773 774void 775debug_binfo (tree elem) 776{ 777 HOST_WIDE_INT n; 778 tree virtuals; 779 780 fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC 781 "\nvtable type:\n", 782 TYPE_NAME_STRING (BINFO_TYPE (elem)), 783 TREE_INT_CST_LOW (BINFO_OFFSET (elem))); 784 debug_tree (BINFO_TYPE (elem)); 785 if (BINFO_VTABLE (elem)) 786 fprintf (stderr, "vtable decl \"%s\"\n", 787 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem)))); 788 else 789 fprintf (stderr, "no vtable decl yet\n"); 790 fprintf (stderr, "virtuals:\n"); 791 virtuals = BINFO_VIRTUALS (elem); 792 n = 0; 793 794 while (virtuals) 795 { 796 tree fndecl = TREE_VALUE (virtuals); 797 fprintf (stderr, "%s [%ld =? %ld]\n", 798 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)), 799 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl))); 800 ++n; 801 virtuals = TREE_CHAIN (virtuals); 802 } 803} 804 805/* Build a representation for the qualified name SCOPE::NAME. TYPE is 806 the type of the result expression, if known, or NULL_TREE if the 807 resulting expression is type-dependent. If TEMPLATE_P is true, 808 NAME is known to be a template because the user explicitly used the 809 "template" keyword after the "::". 810 811 All SCOPE_REFs should be built by use of this function. */ 812 813tree 814build_qualified_name (tree type, tree scope, tree name, bool template_p) 815{ 816 tree t; 817 if (type == error_mark_node 818 || scope == error_mark_node 819 || name == error_mark_node) 820 return error_mark_node; 821 t = build2 (SCOPE_REF, type, scope, name); 822 QUALIFIED_NAME_IS_TEMPLATE (t) = template_p; 823 return t; 824} 825 826int 827is_overloaded_fn (tree x) 828{ 829 /* A baselink is also considered an overloaded function. */ 830 if (TREE_CODE (x) == OFFSET_REF 831 || TREE_CODE (x) == COMPONENT_REF) 832 x = TREE_OPERAND (x, 1); 833 if (BASELINK_P (x)) 834 x = BASELINK_FUNCTIONS (x); 835 return (TREE_CODE (x) == FUNCTION_DECL 836 || TREE_CODE (x) == TEMPLATE_ID_EXPR 837 || DECL_FUNCTION_TEMPLATE_P (x) 838 || TREE_CODE (x) == OVERLOAD); 839} 840 841int 842really_overloaded_fn (tree x) 843{ 844 /* A baselink is also considered an overloaded function. */ 845 if (TREE_CODE (x) == OFFSET_REF) 846 x = TREE_OPERAND (x, 1); 847 if (BASELINK_P (x)) 848 x = BASELINK_FUNCTIONS (x); 849 850 return ((TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x)) 851 || DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x)) 852 || TREE_CODE (x) == TEMPLATE_ID_EXPR); 853} 854 855tree 856get_first_fn (tree from) 857{ 858 gcc_assert (is_overloaded_fn (from)); 859 /* A baselink is also considered an overloaded function. */ 860 if (TREE_CODE (from) == COMPONENT_REF) 861 from = TREE_OPERAND (from, 1); 862 if (BASELINK_P (from)) 863 from = BASELINK_FUNCTIONS (from); 864 return OVL_CURRENT (from); 865} 866 867/* Return a new OVL node, concatenating it with the old one. */ 868 869tree 870ovl_cons (tree decl, tree chain) 871{ 872 tree result = make_node (OVERLOAD); 873 TREE_TYPE (result) = unknown_type_node; 874 OVL_FUNCTION (result) = decl; 875 TREE_CHAIN (result) = chain; 876 877 return result; 878} 879 880/* Build a new overloaded function. If this is the first one, 881 just return it; otherwise, ovl_cons the _DECLs */ 882 883tree 884build_overload (tree decl, tree chain) 885{ 886 if (! chain && TREE_CODE (decl) != TEMPLATE_DECL) 887 return decl; 888 if (chain && TREE_CODE (chain) != OVERLOAD) 889 chain = ovl_cons (chain, NULL_TREE); 890 return ovl_cons (decl, chain); 891} 892 893 894#define PRINT_RING_SIZE 4 895 896const char * 897cxx_printable_name (tree decl, int v) 898{ 899 static tree decl_ring[PRINT_RING_SIZE]; 900 static char *print_ring[PRINT_RING_SIZE]; 901 static int ring_counter; 902 int i; 903 904 /* Only cache functions. */ 905 if (v < 2 906 || TREE_CODE (decl) != FUNCTION_DECL 907 || DECL_LANG_SPECIFIC (decl) == 0) 908 return lang_decl_name (decl, v); 909 910 /* See if this print name is lying around. */ 911 for (i = 0; i < PRINT_RING_SIZE; i++) 912 if (decl_ring[i] == decl) 913 /* yes, so return it. */ 914 return print_ring[i]; 915 916 if (++ring_counter == PRINT_RING_SIZE) 917 ring_counter = 0; 918 919 if (current_function_decl != NULL_TREE) 920 { 921 if (decl_ring[ring_counter] == current_function_decl) 922 ring_counter += 1; 923 if (ring_counter == PRINT_RING_SIZE) 924 ring_counter = 0; 925 gcc_assert (decl_ring[ring_counter] != current_function_decl); 926 } 927 928 if (print_ring[ring_counter]) 929 free (print_ring[ring_counter]); 930 931 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v)); 932 decl_ring[ring_counter] = decl; 933 return print_ring[ring_counter]; 934} 935 936/* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions 937 listed in RAISES. */ 938 939tree 940build_exception_variant (tree type, tree raises) 941{ 942 tree v = TYPE_MAIN_VARIANT (type); 943 int type_quals = TYPE_QUALS (type); 944 945 for (; v; v = TYPE_NEXT_VARIANT (v)) 946 if (check_qualified_type (v, type, type_quals) 947 && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), 1)) 948 return v; 949 950 /* Need to build a new variant. */ 951 v = build_variant_type_copy (type); 952 TYPE_RAISES_EXCEPTIONS (v) = raises; 953 return v; 954} 955 956/* Given a TEMPLATE_TEMPLATE_PARM node T, create a new 957 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template 958 arguments. */ 959 960tree 961bind_template_template_parm (tree t, tree newargs) 962{ 963 tree decl = TYPE_NAME (t); 964 tree t2; 965 966 t2 = make_aggr_type (BOUND_TEMPLATE_TEMPLATE_PARM); 967 decl = build_decl (TYPE_DECL, DECL_NAME (decl), NULL_TREE); 968 969 /* These nodes have to be created to reflect new TYPE_DECL and template 970 arguments. */ 971 TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t)); 972 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl; 973 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2) 974 = tree_cons (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t), 975 newargs, NULL_TREE); 976 977 TREE_TYPE (decl) = t2; 978 TYPE_NAME (t2) = decl; 979 TYPE_STUB_DECL (t2) = decl; 980 TYPE_SIZE (t2) = 0; 981 982 return t2; 983} 984 985/* Called from count_trees via walk_tree. */ 986 987static tree 988count_trees_r (tree *tp, int *walk_subtrees, void *data) 989{ 990 ++*((int *) data); 991 992 if (TYPE_P (*tp)) 993 *walk_subtrees = 0; 994 995 return NULL_TREE; 996} 997 998/* Debugging function for measuring the rough complexity of a tree 999 representation. */ 1000 1001int 1002count_trees (tree t) 1003{ 1004 int n_trees = 0; 1005 walk_tree_without_duplicates (&t, count_trees_r, &n_trees); 1006 return n_trees; 1007} 1008 1009/* Called from verify_stmt_tree via walk_tree. */ 1010 1011static tree 1012verify_stmt_tree_r (tree* tp, 1013 int* walk_subtrees ATTRIBUTE_UNUSED , 1014 void* data) 1015{ 1016 tree t = *tp; 1017 htab_t *statements = (htab_t *) data; 1018 void **slot; 1019 1020 if (!STATEMENT_CODE_P (TREE_CODE (t))) 1021 return NULL_TREE; 1022 1023 /* If this statement is already present in the hash table, then 1024 there is a circularity in the statement tree. */ 1025 gcc_assert (!htab_find (*statements, t)); 1026 1027 slot = htab_find_slot (*statements, t, INSERT); 1028 *slot = t; 1029 1030 return NULL_TREE; 1031} 1032 1033/* Debugging function to check that the statement T has not been 1034 corrupted. For now, this function simply checks that T contains no 1035 circularities. */ 1036 1037void 1038verify_stmt_tree (tree t) 1039{ 1040 htab_t statements; 1041 statements = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL); 1042 walk_tree (&t, verify_stmt_tree_r, &statements, NULL); 1043 htab_delete (statements); 1044} 1045 1046/* Called from find_tree via walk_tree. */ 1047 1048static tree 1049find_tree_r (tree* tp, 1050 int* walk_subtrees ATTRIBUTE_UNUSED , 1051 void* data) 1052{ 1053 if (*tp == (tree) data) 1054 return (tree) data; 1055 1056 return NULL_TREE; 1057} 1058 1059/* Returns X if X appears in the tree structure rooted at T. */ 1060 1061tree 1062find_tree (tree t, tree x) 1063{ 1064 return walk_tree_without_duplicates (&t, find_tree_r, x); 1065} 1066 1067/* Check if the type T depends on a type with no linkage and if so, return 1068 it. If RELAXED_P then do not consider a class type declared within 1069 a TREE_PUBLIC function to have no linkage. */ 1070 1071tree 1072no_linkage_check (tree t, bool relaxed_p) 1073{ 1074 tree r; 1075 1076 /* There's no point in checking linkage on template functions; we 1077 can't know their complete types. */ 1078 if (processing_template_decl) 1079 return NULL_TREE; 1080 1081 switch (TREE_CODE (t)) 1082 { 1083 tree fn; 1084 1085 case RECORD_TYPE: 1086 if (TYPE_PTRMEMFUNC_P (t)) 1087 goto ptrmem; 1088 /* Fall through. */ 1089 case UNION_TYPE: 1090 if (!CLASS_TYPE_P (t)) 1091 return NULL_TREE; 1092 /* Fall through. */ 1093 case ENUMERAL_TYPE: 1094 if (TYPE_ANONYMOUS_P (t)) 1095 return t; 1096 fn = decl_function_context (TYPE_MAIN_DECL (t)); 1097 if (fn && (!relaxed_p || !TREE_PUBLIC (fn))) 1098 return t; 1099 return NULL_TREE; 1100 1101 case ARRAY_TYPE: 1102 case POINTER_TYPE: 1103 case REFERENCE_TYPE: 1104 return no_linkage_check (TREE_TYPE (t), relaxed_p); 1105 1106 case OFFSET_TYPE: 1107 ptrmem: 1108 r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t), 1109 relaxed_p); 1110 if (r) 1111 return r; 1112 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p); 1113 1114 case METHOD_TYPE: 1115 r = no_linkage_check (TYPE_METHOD_BASETYPE (t), relaxed_p); 1116 if (r) 1117 return r; 1118 /* Fall through. */ 1119 case FUNCTION_TYPE: 1120 { 1121 tree parm; 1122 for (parm = TYPE_ARG_TYPES (t); 1123 parm && parm != void_list_node; 1124 parm = TREE_CHAIN (parm)) 1125 { 1126 r = no_linkage_check (TREE_VALUE (parm), relaxed_p); 1127 if (r) 1128 return r; 1129 } 1130 return no_linkage_check (TREE_TYPE (t), relaxed_p); 1131 } 1132 1133 default: 1134 return NULL_TREE; 1135 } 1136} 1137 1138#ifdef GATHER_STATISTICS 1139extern int depth_reached; 1140#endif 1141 1142void 1143cxx_print_statistics (void) 1144{ 1145 print_search_statistics (); 1146 print_class_statistics (); 1147#ifdef GATHER_STATISTICS 1148 fprintf (stderr, "maximum template instantiation depth reached: %d\n", 1149 depth_reached); 1150#endif 1151} 1152 1153/* Return, as an INTEGER_CST node, the number of elements for TYPE 1154 (which is an ARRAY_TYPE). This counts only elements of the top 1155 array. */ 1156 1157tree 1158array_type_nelts_top (tree type) 1159{ 1160 return fold_build2 (PLUS_EXPR, sizetype, 1161 array_type_nelts (type), 1162 integer_one_node); 1163} 1164 1165/* Return, as an INTEGER_CST node, the number of elements for TYPE 1166 (which is an ARRAY_TYPE). This one is a recursive count of all 1167 ARRAY_TYPEs that are clumped together. */ 1168 1169tree 1170array_type_nelts_total (tree type) 1171{ 1172 tree sz = array_type_nelts_top (type); 1173 type = TREE_TYPE (type); 1174 while (TREE_CODE (type) == ARRAY_TYPE) 1175 { 1176 tree n = array_type_nelts_top (type); 1177 sz = fold_build2 (MULT_EXPR, sizetype, sz, n); 1178 type = TREE_TYPE (type); 1179 } 1180 return sz; 1181} 1182 1183/* Called from break_out_target_exprs via mapcar. */ 1184 1185static tree 1186bot_manip (tree* tp, int* walk_subtrees, void* data) 1187{ 1188 splay_tree target_remap = ((splay_tree) data); 1189 tree t = *tp; 1190 1191 if (!TYPE_P (t) && TREE_CONSTANT (t)) 1192 { 1193 /* There can't be any TARGET_EXPRs or their slot variables below 1194 this point. We used to check !TREE_SIDE_EFFECTS, but then we 1195 failed to copy an ADDR_EXPR of the slot VAR_DECL. */ 1196 *walk_subtrees = 0; 1197 return NULL_TREE; 1198 } 1199 if (TREE_CODE (t) == TARGET_EXPR) 1200 { 1201 tree u; 1202 1203 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR) 1204 { 1205 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 1), 0), 0)); 1206 u = build_cplus_new 1207 (TREE_TYPE (t), break_out_target_exprs (TREE_OPERAND (t, 1))); 1208 } 1209 else 1210 { 1211 u = build_target_expr_with_type 1212 (break_out_target_exprs (TREE_OPERAND (t, 1)), TREE_TYPE (t)); 1213 } 1214 1215 /* Map the old variable to the new one. */ 1216 splay_tree_insert (target_remap, 1217 (splay_tree_key) TREE_OPERAND (t, 0), 1218 (splay_tree_value) TREE_OPERAND (u, 0)); 1219 1220 /* Replace the old expression with the new version. */ 1221 *tp = u; 1222 /* We don't have to go below this point; the recursive call to 1223 break_out_target_exprs will have handled anything below this 1224 point. */ 1225 *walk_subtrees = 0; 1226 return NULL_TREE; 1227 } 1228 else if (TREE_CODE (t) == CALL_EXPR) 1229 mark_used (TREE_OPERAND (TREE_OPERAND (t, 0), 0)); 1230 1231 /* Make a copy of this node. */ 1232 return copy_tree_r (tp, walk_subtrees, NULL); 1233} 1234 1235/* Replace all remapped VAR_DECLs in T with their new equivalents. 1236 DATA is really a splay-tree mapping old variables to new 1237 variables. */ 1238 1239static tree 1240bot_replace (tree* t, 1241 int* walk_subtrees ATTRIBUTE_UNUSED , 1242 void* data) 1243{ 1244 splay_tree target_remap = ((splay_tree) data); 1245 1246 if (TREE_CODE (*t) == VAR_DECL) 1247 { 1248 splay_tree_node n = splay_tree_lookup (target_remap, 1249 (splay_tree_key) *t); 1250 if (n) 1251 *t = (tree) n->value; 1252 } 1253 1254 return NULL_TREE; 1255} 1256 1257/* When we parse a default argument expression, we may create 1258 temporary variables via TARGET_EXPRs. When we actually use the 1259 default-argument expression, we make a copy of the expression, but 1260 we must replace the temporaries with appropriate local versions. */ 1261 1262tree 1263break_out_target_exprs (tree t) 1264{ 1265 static int target_remap_count; 1266 static splay_tree target_remap; 1267 1268 if (!target_remap_count++) 1269 target_remap = splay_tree_new (splay_tree_compare_pointers, 1270 /*splay_tree_delete_key_fn=*/NULL, 1271 /*splay_tree_delete_value_fn=*/NULL); 1272 walk_tree (&t, bot_manip, target_remap, NULL); 1273 walk_tree (&t, bot_replace, target_remap, NULL); 1274 1275 if (!--target_remap_count) 1276 { 1277 splay_tree_delete (target_remap); 1278 target_remap = NULL; 1279 } 1280 1281 return t; 1282} 1283 1284/* Similar to `build_nt', but for template definitions of dependent 1285 expressions */ 1286 1287tree 1288build_min_nt (enum tree_code code, ...) 1289{ 1290 tree t; 1291 int length; 1292 int i; 1293 va_list p; 1294 1295 va_start (p, code); 1296 1297 t = make_node (code); 1298 length = TREE_CODE_LENGTH (code); 1299 1300 for (i = 0; i < length; i++) 1301 { 1302 tree x = va_arg (p, tree); 1303 TREE_OPERAND (t, i) = x; 1304 } 1305 1306 va_end (p); 1307 return t; 1308} 1309 1310/* Similar to `build', but for template definitions. */ 1311 1312tree 1313build_min (enum tree_code code, tree tt, ...) 1314{ 1315 tree t; 1316 int length; 1317 int i; 1318 va_list p; 1319 1320 va_start (p, tt); 1321 1322 t = make_node (code); 1323 length = TREE_CODE_LENGTH (code); 1324 TREE_TYPE (t) = tt; 1325 1326 for (i = 0; i < length; i++) 1327 { 1328 tree x = va_arg (p, tree); 1329 TREE_OPERAND (t, i) = x; 1330 if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x)) 1331 TREE_SIDE_EFFECTS (t) = 1; 1332 } 1333 1334 va_end (p); 1335 return t; 1336} 1337 1338/* Similar to `build', but for template definitions of non-dependent 1339 expressions. NON_DEP is the non-dependent expression that has been 1340 built. */ 1341 1342tree 1343build_min_non_dep (enum tree_code code, tree non_dep, ...) 1344{ 1345 tree t; 1346 int length; 1347 int i; 1348 va_list p; 1349 1350 va_start (p, non_dep); 1351 1352 t = make_node (code); 1353 length = TREE_CODE_LENGTH (code); 1354 TREE_TYPE (t) = TREE_TYPE (non_dep); 1355 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep); 1356 1357 for (i = 0; i < length; i++) 1358 { 1359 tree x = va_arg (p, tree); 1360 TREE_OPERAND (t, i) = x; 1361 } 1362 1363 if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR) 1364 /* This should not be considered a COMPOUND_EXPR, because it 1365 resolves to an overload. */ 1366 COMPOUND_EXPR_OVERLOADED (t) = 1; 1367 1368 va_end (p); 1369 return t; 1370} 1371 1372tree 1373get_type_decl (tree t) 1374{ 1375 if (TREE_CODE (t) == TYPE_DECL) 1376 return t; 1377 if (TYPE_P (t)) 1378 return TYPE_STUB_DECL (t); 1379 gcc_assert (t == error_mark_node); 1380 return t; 1381} 1382 1383/* Returns the namespace that contains DECL, whether directly or 1384 indirectly. */ 1385 1386tree 1387decl_namespace_context (tree decl) 1388{ 1389 while (1) 1390 { 1391 if (TREE_CODE (decl) == NAMESPACE_DECL) 1392 return decl; 1393 else if (TYPE_P (decl)) 1394 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl)); 1395 else 1396 decl = CP_DECL_CONTEXT (decl); 1397 } 1398} 1399 1400/* Return truthvalue of whether T1 is the same tree structure as T2. 1401 Return 1 if they are the same. Return 0 if they are different. */ 1402 1403bool 1404cp_tree_equal (tree t1, tree t2) 1405{ 1406 enum tree_code code1, code2; 1407 1408 if (t1 == t2) 1409 return true; 1410 if (!t1 || !t2) 1411 return false; 1412 1413 for (code1 = TREE_CODE (t1); 1414 code1 == NOP_EXPR || code1 == CONVERT_EXPR 1415 || code1 == NON_LVALUE_EXPR; 1416 code1 = TREE_CODE (t1)) 1417 t1 = TREE_OPERAND (t1, 0); 1418 for (code2 = TREE_CODE (t2); 1419 code2 == NOP_EXPR || code2 == CONVERT_EXPR 1420 || code1 == NON_LVALUE_EXPR; 1421 code2 = TREE_CODE (t2)) 1422 t2 = TREE_OPERAND (t2, 0); 1423 1424 /* They might have become equal now. */ 1425 if (t1 == t2) 1426 return true; 1427 1428 if (code1 != code2) 1429 return false; 1430 1431 switch (code1) 1432 { 1433 case INTEGER_CST: 1434 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2) 1435 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2); 1436 1437 case REAL_CST: 1438 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2)); 1439 1440 case STRING_CST: 1441 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2) 1442 && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2), 1443 TREE_STRING_LENGTH (t1)); 1444 1445 case COMPLEX_CST: 1446 return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2)) 1447 && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2)); 1448 1449 case CONSTRUCTOR: 1450 /* We need to do this when determining whether or not two 1451 non-type pointer to member function template arguments 1452 are the same. */ 1453 if (!(same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)) 1454 /* The first operand is RTL. */ 1455 && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0))) 1456 return false; 1457 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)); 1458 1459 case TREE_LIST: 1460 if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))) 1461 return false; 1462 if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2))) 1463 return false; 1464 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2)); 1465 1466 case SAVE_EXPR: 1467 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 1468 1469 case CALL_EXPR: 1470 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))) 1471 return false; 1472 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)); 1473 1474 case TARGET_EXPR: 1475 { 1476 tree o1 = TREE_OPERAND (t1, 0); 1477 tree o2 = TREE_OPERAND (t2, 0); 1478 1479 /* Special case: if either target is an unallocated VAR_DECL, 1480 it means that it's going to be unified with whatever the 1481 TARGET_EXPR is really supposed to initialize, so treat it 1482 as being equivalent to anything. */ 1483 if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE 1484 && !DECL_RTL_SET_P (o1)) 1485 /*Nop*/; 1486 else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE 1487 && !DECL_RTL_SET_P (o2)) 1488 /*Nop*/; 1489 else if (!cp_tree_equal (o1, o2)) 1490 return false; 1491 1492 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)); 1493 } 1494 1495 case WITH_CLEANUP_EXPR: 1496 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))) 1497 return false; 1498 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1)); 1499 1500 case COMPONENT_REF: 1501 if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1)) 1502 return false; 1503 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 1504 1505 case VAR_DECL: 1506 case PARM_DECL: 1507 case CONST_DECL: 1508 case FUNCTION_DECL: 1509 case TEMPLATE_DECL: 1510 case IDENTIFIER_NODE: 1511 case SSA_NAME: 1512 return false; 1513 1514 case BASELINK: 1515 return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2) 1516 && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2) 1517 && cp_tree_equal (BASELINK_FUNCTIONS (t1), 1518 BASELINK_FUNCTIONS (t2))); 1519 1520 case TEMPLATE_PARM_INDEX: 1521 return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2) 1522 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2) 1523 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)), 1524 TREE_TYPE (TEMPLATE_PARM_DECL (t2)))); 1525 1526 case TEMPLATE_ID_EXPR: 1527 { 1528 unsigned ix; 1529 tree vec1, vec2; 1530 1531 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))) 1532 return false; 1533 vec1 = TREE_OPERAND (t1, 1); 1534 vec2 = TREE_OPERAND (t2, 1); 1535 1536 if (!vec1 || !vec2) 1537 return !vec1 && !vec2; 1538 1539 if (TREE_VEC_LENGTH (vec1) != TREE_VEC_LENGTH (vec2)) 1540 return false; 1541 1542 for (ix = TREE_VEC_LENGTH (vec1); ix--;) 1543 if (!cp_tree_equal (TREE_VEC_ELT (vec1, ix), 1544 TREE_VEC_ELT (vec2, ix))) 1545 return false; 1546 1547 return true; 1548 } 1549 1550 case SIZEOF_EXPR: 1551 case ALIGNOF_EXPR: 1552 { 1553 tree o1 = TREE_OPERAND (t1, 0); 1554 tree o2 = TREE_OPERAND (t2, 0); 1555 1556 if (TREE_CODE (o1) != TREE_CODE (o2)) 1557 return false; 1558 if (TYPE_P (o1)) 1559 return same_type_p (o1, o2); 1560 else 1561 return cp_tree_equal (o1, o2); 1562 } 1563 1564 case PTRMEM_CST: 1565 /* Two pointer-to-members are the same if they point to the same 1566 field or function in the same class. */ 1567 if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2)) 1568 return false; 1569 1570 return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2)); 1571 1572 case OVERLOAD: 1573 if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2)) 1574 return false; 1575 return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2)); 1576 1577 default: 1578 break; 1579 } 1580 1581 switch (TREE_CODE_CLASS (code1)) 1582 { 1583 case tcc_unary: 1584 case tcc_binary: 1585 case tcc_comparison: 1586 case tcc_expression: 1587 case tcc_reference: 1588 case tcc_statement: 1589 { 1590 int i; 1591 1592 for (i = 0; i < TREE_CODE_LENGTH (code1); ++i) 1593 if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i))) 1594 return false; 1595 1596 return true; 1597 } 1598 1599 case tcc_type: 1600 return same_type_p (t1, t2); 1601 default: 1602 gcc_unreachable (); 1603 } 1604 /* We can get here with --disable-checking. */ 1605 return false; 1606} 1607 1608/* The type of ARG when used as an lvalue. */ 1609 1610tree 1611lvalue_type (tree arg) 1612{ 1613 tree type = TREE_TYPE (arg); 1614 return type; 1615} 1616 1617/* The type of ARG for printing error messages; denote lvalues with 1618 reference types. */ 1619 1620tree 1621error_type (tree arg) 1622{ 1623 tree type = TREE_TYPE (arg); 1624 1625 if (TREE_CODE (type) == ARRAY_TYPE) 1626 ; 1627 else if (TREE_CODE (type) == ERROR_MARK) 1628 ; 1629 else if (real_lvalue_p (arg)) 1630 type = build_reference_type (lvalue_type (arg)); 1631 else if (IS_AGGR_TYPE (type)) 1632 type = lvalue_type (arg); 1633 1634 return type; 1635} 1636 1637/* Does FUNCTION use a variable-length argument list? */ 1638 1639int 1640varargs_function_p (tree function) 1641{ 1642 tree parm = TYPE_ARG_TYPES (TREE_TYPE (function)); 1643 for (; parm; parm = TREE_CHAIN (parm)) 1644 if (TREE_VALUE (parm) == void_type_node) 1645 return 0; 1646 return 1; 1647} 1648 1649/* Returns 1 if decl is a member of a class. */ 1650 1651int 1652member_p (tree decl) 1653{ 1654 const tree ctx = DECL_CONTEXT (decl); 1655 return (ctx && TYPE_P (ctx)); 1656} 1657 1658/* Create a placeholder for member access where we don't actually have an 1659 object that the access is against. */ 1660 1661tree 1662build_dummy_object (tree type) 1663{ 1664 tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node); 1665 return build_indirect_ref (decl, NULL); 1666} 1667 1668/* We've gotten a reference to a member of TYPE. Return *this if appropriate, 1669 or a dummy object otherwise. If BINFOP is non-0, it is filled with the 1670 binfo path from current_class_type to TYPE, or 0. */ 1671 1672tree 1673maybe_dummy_object (tree type, tree* binfop) 1674{ 1675 tree decl, context; 1676 tree binfo; 1677 1678 if (current_class_type 1679 && (binfo = lookup_base (current_class_type, type, 1680 ba_unique | ba_quiet, NULL))) 1681 context = current_class_type; 1682 else 1683 { 1684 /* Reference from a nested class member function. */ 1685 context = type; 1686 binfo = TYPE_BINFO (type); 1687 } 1688 1689 if (binfop) 1690 *binfop = binfo; 1691 1692 if (current_class_ref && context == current_class_type 1693 /* Kludge: Make sure that current_class_type is actually 1694 correct. It might not be if we're in the middle of 1695 tsubst_default_argument. */ 1696 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)), 1697 current_class_type)) 1698 decl = current_class_ref; 1699 else 1700 decl = build_dummy_object (context); 1701 1702 return decl; 1703} 1704 1705/* Returns 1 if OB is a placeholder object, or a pointer to one. */ 1706 1707int 1708is_dummy_object (tree ob) 1709{ 1710 if (TREE_CODE (ob) == INDIRECT_REF) 1711 ob = TREE_OPERAND (ob, 0); 1712 return (TREE_CODE (ob) == NOP_EXPR 1713 && TREE_OPERAND (ob, 0) == void_zero_node); 1714} 1715 1716/* Returns 1 iff type T is a POD type, as defined in [basic.types]. */ 1717 1718int 1719pod_type_p (tree t) 1720{ 1721 t = strip_array_types (t); 1722 1723 if (t == error_mark_node) 1724 return 1; 1725 if (INTEGRAL_TYPE_P (t)) 1726 return 1; /* integral, character or enumeral type */ 1727 if (FLOAT_TYPE_P (t)) 1728 return 1; 1729 if (TYPE_PTR_P (t)) 1730 return 1; /* pointer to non-member */ 1731 if (TYPE_PTR_TO_MEMBER_P (t)) 1732 return 1; /* pointer to member */ 1733 1734 if (TREE_CODE (t) == VECTOR_TYPE) 1735 return 1; /* vectors are (small) arrays of scalars */ 1736 1737 if (! CLASS_TYPE_P (t)) 1738 return 0; /* other non-class type (reference or function) */ 1739 if (CLASSTYPE_NON_POD_P (t)) 1740 return 0; 1741 return 1; 1742} 1743 1744/* Returns 1 iff zero initialization of type T means actually storing 1745 zeros in it. */ 1746 1747int 1748zero_init_p (tree t) 1749{ 1750 t = strip_array_types (t); 1751 1752 if (t == error_mark_node) 1753 return 1; 1754 1755 /* NULL pointers to data members are initialized with -1. */ 1756 if (TYPE_PTRMEM_P (t)) 1757 return 0; 1758 1759 /* Classes that contain types that can't be zero-initialized, cannot 1760 be zero-initialized themselves. */ 1761 if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t)) 1762 return 0; 1763 1764 return 1; 1765} 1766 1767/* Table of valid C++ attributes. */ 1768const struct attribute_spec cxx_attribute_table[] = 1769{ 1770 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */ 1771 { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute }, 1772 { "com_interface", 0, 0, false, false, false, handle_com_interface_attribute }, 1773 { "init_priority", 1, 1, true, false, false, handle_init_priority_attribute }, 1774 { NULL, 0, 0, false, false, false, NULL } 1775}; 1776 1777/* Handle a "java_interface" attribute; arguments as in 1778 struct attribute_spec.handler. */ 1779static tree 1780handle_java_interface_attribute (tree* node, 1781 tree name, 1782 tree args ATTRIBUTE_UNUSED , 1783 int flags, 1784 bool* no_add_attrs) 1785{ 1786 if (DECL_P (*node) 1787 || !CLASS_TYPE_P (*node) 1788 || !TYPE_FOR_JAVA (*node)) 1789 { 1790 error ("%qE attribute can only be applied to Java class definitions", 1791 name); 1792 *no_add_attrs = true; 1793 return NULL_TREE; 1794 } 1795 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE)) 1796 *node = build_variant_type_copy (*node); 1797 TYPE_JAVA_INTERFACE (*node) = 1; 1798 1799 return NULL_TREE; 1800} 1801 1802/* Handle a "com_interface" attribute; arguments as in 1803 struct attribute_spec.handler. */ 1804static tree 1805handle_com_interface_attribute (tree* node, 1806 tree name, 1807 tree args ATTRIBUTE_UNUSED , 1808 int flags ATTRIBUTE_UNUSED , 1809 bool* no_add_attrs) 1810{ 1811 static int warned; 1812 1813 *no_add_attrs = true; 1814 1815 if (DECL_P (*node) 1816 || !CLASS_TYPE_P (*node) 1817 || *node != TYPE_MAIN_VARIANT (*node)) 1818 { 1819 warning (OPT_Wattributes, "%qE attribute can only be applied " 1820 "to class definitions", name); 1821 return NULL_TREE; 1822 } 1823 1824 if (!warned++) 1825 warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default", 1826 name); 1827 1828 return NULL_TREE; 1829} 1830 1831/* Handle an "init_priority" attribute; arguments as in 1832 struct attribute_spec.handler. */ 1833static tree 1834handle_init_priority_attribute (tree* node, 1835 tree name, 1836 tree args, 1837 int flags ATTRIBUTE_UNUSED , 1838 bool* no_add_attrs) 1839{ 1840 tree initp_expr = TREE_VALUE (args); 1841 tree decl = *node; 1842 tree type = TREE_TYPE (decl); 1843 int pri; 1844 1845 STRIP_NOPS (initp_expr); 1846 1847 if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST) 1848 { 1849 error ("requested init_priority is not an integer constant"); 1850 *no_add_attrs = true; 1851 return NULL_TREE; 1852 } 1853 1854 pri = TREE_INT_CST_LOW (initp_expr); 1855 1856 type = strip_array_types (type); 1857 1858 if (decl == NULL_TREE 1859 || TREE_CODE (decl) != VAR_DECL 1860 || !TREE_STATIC (decl) 1861 || DECL_EXTERNAL (decl) 1862 || (TREE_CODE (type) != RECORD_TYPE 1863 && TREE_CODE (type) != UNION_TYPE) 1864 /* Static objects in functions are initialized the 1865 first time control passes through that 1866 function. This is not precise enough to pin down an 1867 init_priority value, so don't allow it. */ 1868 || current_function_decl) 1869 { 1870 error ("can only use %qE attribute on file-scope definitions " 1871 "of objects of class type", name); 1872 *no_add_attrs = true; 1873 return NULL_TREE; 1874 } 1875 1876 if (pri > MAX_INIT_PRIORITY || pri <= 0) 1877 { 1878 error ("requested init_priority is out of range"); 1879 *no_add_attrs = true; 1880 return NULL_TREE; 1881 } 1882 1883 /* Check for init_priorities that are reserved for 1884 language and runtime support implementations.*/ 1885 if (pri <= MAX_RESERVED_INIT_PRIORITY) 1886 { 1887 warning 1888 (0, "requested init_priority is reserved for internal use"); 1889 } 1890 1891 if (SUPPORTS_INIT_PRIORITY) 1892 { 1893 SET_DECL_INIT_PRIORITY (decl, pri); 1894 DECL_HAS_INIT_PRIORITY_P (decl) = 1; 1895 return NULL_TREE; 1896 } 1897 else 1898 { 1899 error ("%qE attribute is not supported on this platform", name); 1900 *no_add_attrs = true; 1901 return NULL_TREE; 1902 } 1903} 1904 1905/* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the 1906 thing pointed to by the constant. */ 1907 1908tree 1909make_ptrmem_cst (tree type, tree member) 1910{ 1911 tree ptrmem_cst = make_node (PTRMEM_CST); 1912 TREE_TYPE (ptrmem_cst) = type; 1913 PTRMEM_CST_MEMBER (ptrmem_cst) = member; 1914 return ptrmem_cst; 1915} 1916 1917/* Build a variant of TYPE that has the indicated ATTRIBUTES. May 1918 return an existing type of an appropriate type already exists. */ 1919 1920tree 1921cp_build_type_attribute_variant (tree type, tree attributes) 1922{ 1923 tree new_type; 1924 1925 new_type = build_type_attribute_variant (type, attributes); 1926 if (TREE_CODE (new_type) == FUNCTION_TYPE 1927 && (TYPE_RAISES_EXCEPTIONS (new_type) 1928 != TYPE_RAISES_EXCEPTIONS (type))) 1929 new_type = build_exception_variant (new_type, 1930 TYPE_RAISES_EXCEPTIONS (type)); 1931 return new_type; 1932} 1933 1934/* Apply FUNC to all language-specific sub-trees of TP in a pre-order 1935 traversal. Called from walk_tree. */ 1936 1937tree 1938cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func, 1939 void *data, struct pointer_set_t *pset) 1940{ 1941 enum tree_code code = TREE_CODE (*tp); 1942 location_t save_locus; 1943 tree result; 1944 1945#define WALK_SUBTREE(NODE) \ 1946 do \ 1947 { \ 1948 result = walk_tree (&(NODE), func, data, pset); \ 1949 if (result) goto out; \ 1950 } \ 1951 while (0) 1952 1953 /* Set input_location here so we get the right instantiation context 1954 if we call instantiate_decl from inlinable_function_p. */ 1955 save_locus = input_location; 1956 if (EXPR_HAS_LOCATION (*tp)) 1957 input_location = EXPR_LOCATION (*tp); 1958 1959 /* Not one of the easy cases. We must explicitly go through the 1960 children. */ 1961 result = NULL_TREE; 1962 switch (code) 1963 { 1964 case DEFAULT_ARG: 1965 case TEMPLATE_TEMPLATE_PARM: 1966 case BOUND_TEMPLATE_TEMPLATE_PARM: 1967 case UNBOUND_CLASS_TEMPLATE: 1968 case TEMPLATE_PARM_INDEX: 1969 case TEMPLATE_TYPE_PARM: 1970 case TYPENAME_TYPE: 1971 case TYPEOF_TYPE: 1972 case BASELINK: 1973 /* None of these have subtrees other than those already walked 1974 above. */ 1975 *walk_subtrees_p = 0; 1976 break; 1977 1978 case TINST_LEVEL: 1979 WALK_SUBTREE (TINST_DECL (*tp)); 1980 *walk_subtrees_p = 0; 1981 break; 1982 1983 case PTRMEM_CST: 1984 WALK_SUBTREE (TREE_TYPE (*tp)); 1985 *walk_subtrees_p = 0; 1986 break; 1987 1988 case TREE_LIST: 1989 WALK_SUBTREE (TREE_PURPOSE (*tp)); 1990 break; 1991 1992 case OVERLOAD: 1993 WALK_SUBTREE (OVL_FUNCTION (*tp)); 1994 WALK_SUBTREE (OVL_CHAIN (*tp)); 1995 *walk_subtrees_p = 0; 1996 break; 1997 1998 case RECORD_TYPE: 1999 if (TYPE_PTRMEMFUNC_P (*tp)) 2000 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp)); 2001 break; 2002 2003 default: 2004 input_location = save_locus; 2005 return NULL_TREE; 2006 } 2007 2008 /* We didn't find what we were looking for. */ 2009 out: 2010 input_location = save_locus; 2011 return result; 2012 2013#undef WALK_SUBTREE 2014} 2015 2016/* Decide whether there are language-specific reasons to not inline a 2017 function as a tree. */ 2018 2019int 2020cp_cannot_inline_tree_fn (tree* fnp) 2021{ 2022 tree fn = *fnp; 2023 2024 /* We can inline a template instantiation only if it's fully 2025 instantiated. */ 2026 if (DECL_TEMPLATE_INFO (fn) 2027 && TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn))) 2028 { 2029 /* Don't instantiate functions that are not going to be 2030 inlined. */ 2031 if (!DECL_INLINE (DECL_TEMPLATE_RESULT 2032 (template_for_substitution (fn)))) 2033 return 1; 2034 2035 fn = *fnp = instantiate_decl (fn, /*defer_ok=*/0, /*undefined_ok=*/0); 2036 2037 if (TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn))) 2038 return 1; 2039 } 2040 2041 if (flag_really_no_inline 2042 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) == NULL) 2043 return 1; 2044 2045 /* Don't auto-inline functions that might be replaced at link-time 2046 with an alternative definition. */ 2047 if (!DECL_DECLARED_INLINE_P (fn) && DECL_REPLACEABLE_P (fn)) 2048 { 2049 DECL_UNINLINABLE (fn) = 1; 2050 return 1; 2051 } 2052 2053 if (varargs_function_p (fn)) 2054 { 2055 DECL_UNINLINABLE (fn) = 1; 2056 return 1; 2057 } 2058 2059 if (! function_attribute_inlinable_p (fn)) 2060 { 2061 DECL_UNINLINABLE (fn) = 1; 2062 return 1; 2063 } 2064 2065 return 0; 2066} 2067 2068/* Add any pending functions other than the current function (already 2069 handled by the caller), that thus cannot be inlined, to FNS_P, then 2070 return the latest function added to the array, PREV_FN. */ 2071 2072tree 2073cp_add_pending_fn_decls (void* fns_p, tree prev_fn) 2074{ 2075 varray_type *fnsp = (varray_type *)fns_p; 2076 struct saved_scope *s; 2077 2078 for (s = scope_chain; s; s = s->prev) 2079 if (s->function_decl && s->function_decl != prev_fn) 2080 { 2081 VARRAY_PUSH_TREE (*fnsp, s->function_decl); 2082 prev_fn = s->function_decl; 2083 } 2084 2085 return prev_fn; 2086} 2087 2088/* Determine whether VAR is a declaration of an automatic variable in 2089 function FN. */ 2090 2091int 2092cp_auto_var_in_fn_p (tree var, tree fn) 2093{ 2094 return (DECL_P (var) && DECL_CONTEXT (var) == fn 2095 && nonstatic_local_decl_p (var)); 2096} 2097 2098/* Initialize tree.c. */ 2099 2100void 2101init_tree (void) 2102{ 2103 list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL); 2104} 2105 2106/* Returns the kind of special function that DECL (a FUNCTION_DECL) 2107 is. Note that sfk_none is zero, so this function can be used as a 2108 predicate to test whether or not DECL is a special function. */ 2109 2110special_function_kind 2111special_function_p (tree decl) 2112{ 2113 /* Rather than doing all this stuff with magic names, we should 2114 probably have a field of type `special_function_kind' in 2115 DECL_LANG_SPECIFIC. */ 2116 if (DECL_COPY_CONSTRUCTOR_P (decl)) 2117 return sfk_copy_constructor; 2118 if (DECL_CONSTRUCTOR_P (decl)) 2119 return sfk_constructor; 2120 if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR) 2121 return sfk_assignment_operator; 2122 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)) 2123 return sfk_destructor; 2124 if (DECL_COMPLETE_DESTRUCTOR_P (decl)) 2125 return sfk_complete_destructor; 2126 if (DECL_BASE_DESTRUCTOR_P (decl)) 2127 return sfk_base_destructor; 2128 if (DECL_DELETING_DESTRUCTOR_P (decl)) 2129 return sfk_deleting_destructor; 2130 if (DECL_CONV_FN_P (decl)) 2131 return sfk_conversion; 2132 2133 return sfk_none; 2134} 2135 2136/* Returns nonzero if TYPE is a character type, including wchar_t. */ 2137 2138int 2139char_type_p (tree type) 2140{ 2141 return (same_type_p (type, char_type_node) 2142 || same_type_p (type, unsigned_char_type_node) 2143 || same_type_p (type, signed_char_type_node) 2144 || same_type_p (type, wchar_type_node)); 2145} 2146 2147/* Returns the kind of linkage associated with the indicated DECL. Th 2148 value returned is as specified by the language standard; it is 2149 independent of implementation details regarding template 2150 instantiation, etc. For example, it is possible that a declaration 2151 to which this function assigns external linkage would not show up 2152 as a global symbol when you run `nm' on the resulting object file. */ 2153 2154linkage_kind 2155decl_linkage (tree decl) 2156{ 2157 /* This function doesn't attempt to calculate the linkage from first 2158 principles as given in [basic.link]. Instead, it makes use of 2159 the fact that we have already set TREE_PUBLIC appropriately, and 2160 then handles a few special cases. Ideally, we would calculate 2161 linkage first, and then transform that into a concrete 2162 implementation. */ 2163 2164 /* Things that don't have names have no linkage. */ 2165 if (!DECL_NAME (decl)) 2166 return lk_none; 2167 2168 /* Things that are TREE_PUBLIC have external linkage. */ 2169 if (TREE_PUBLIC (decl)) 2170 return lk_external; 2171 2172 /* Linkage of a CONST_DECL depends on the linkage of the enumeration 2173 type. */ 2174 if (TREE_CODE (decl) == CONST_DECL) 2175 return decl_linkage (TYPE_NAME (TREE_TYPE (decl))); 2176 2177 /* Some things that are not TREE_PUBLIC have external linkage, too. 2178 For example, on targets that don't have weak symbols, we make all 2179 template instantiations have internal linkage (in the object 2180 file), but the symbols should still be treated as having external 2181 linkage from the point of view of the language. */ 2182 if (TREE_CODE (decl) != TYPE_DECL && DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl)) 2183 return lk_external; 2184 2185 /* Things in local scope do not have linkage, if they don't have 2186 TREE_PUBLIC set. */ 2187 if (decl_function_context (decl)) 2188 return lk_none; 2189 2190 /* Everything else has internal linkage. */ 2191 return lk_internal; 2192} 2193 2194/* EXP is an expression that we want to pre-evaluate. Returns (in 2195 *INITP) an expression that will perform the pre-evaluation. The 2196 value returned by this function is a side-effect free expression 2197 equivalent to the pre-evaluated expression. Callers must ensure 2198 that *INITP is evaluated before EXP. */ 2199 2200tree 2201stabilize_expr (tree exp, tree* initp) 2202{ 2203 tree init_expr; 2204 2205 if (!TREE_SIDE_EFFECTS (exp)) 2206 init_expr = NULL_TREE; 2207 else if (!real_lvalue_p (exp) 2208 || !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp))) 2209 { 2210 init_expr = get_target_expr (exp); 2211 exp = TARGET_EXPR_SLOT (init_expr); 2212 } 2213 else 2214 { 2215 exp = build_unary_op (ADDR_EXPR, exp, 1); 2216 init_expr = get_target_expr (exp); 2217 exp = TARGET_EXPR_SLOT (init_expr); 2218 exp = build_indirect_ref (exp, 0); 2219 } 2220 *initp = init_expr; 2221 2222 gcc_assert (!TREE_SIDE_EFFECTS (exp)); 2223 return exp; 2224} 2225 2226/* Add NEW, an expression whose value we don't care about, after the 2227 similar expression ORIG. */ 2228 2229tree 2230add_stmt_to_compound (tree orig, tree new) 2231{ 2232 if (!new || !TREE_SIDE_EFFECTS (new)) 2233 return orig; 2234 if (!orig || !TREE_SIDE_EFFECTS (orig)) 2235 return new; 2236 return build2 (COMPOUND_EXPR, void_type_node, orig, new); 2237} 2238 2239/* Like stabilize_expr, but for a call whose arguments we want to 2240 pre-evaluate. CALL is modified in place to use the pre-evaluated 2241 arguments, while, upon return, *INITP contains an expression to 2242 compute the arguments. */ 2243 2244void 2245stabilize_call (tree call, tree *initp) 2246{ 2247 tree inits = NULL_TREE; 2248 tree t; 2249 2250 if (call == error_mark_node) 2251 return; 2252 2253 gcc_assert (TREE_CODE (call) == CALL_EXPR 2254 || TREE_CODE (call) == AGGR_INIT_EXPR); 2255 2256 for (t = TREE_OPERAND (call, 1); t; t = TREE_CHAIN (t)) 2257 if (TREE_SIDE_EFFECTS (TREE_VALUE (t))) 2258 { 2259 tree init; 2260 TREE_VALUE (t) = stabilize_expr (TREE_VALUE (t), &init); 2261 inits = add_stmt_to_compound (inits, init); 2262 } 2263 2264 *initp = inits; 2265} 2266 2267/* Like stabilize_expr, but for an initialization. 2268 2269 If the initialization is for an object of class type, this function 2270 takes care not to introduce additional temporaries. 2271 2272 Returns TRUE iff the expression was successfully pre-evaluated, 2273 i.e., if INIT is now side-effect free, except for, possible, a 2274 single call to a constructor. */ 2275 2276bool 2277stabilize_init (tree init, tree *initp) 2278{ 2279 tree t = init; 2280 2281 *initp = NULL_TREE; 2282 2283 if (t == error_mark_node) 2284 return true; 2285 2286 if (TREE_CODE (t) == INIT_EXPR 2287 && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR) 2288 { 2289 TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp); 2290 return true; 2291 } 2292 2293 if (TREE_CODE (t) == INIT_EXPR) 2294 t = TREE_OPERAND (t, 1); 2295 if (TREE_CODE (t) == TARGET_EXPR) 2296 t = TARGET_EXPR_INITIAL (t); 2297 if (TREE_CODE (t) == COMPOUND_EXPR) 2298 t = expr_last (t); 2299 if (TREE_CODE (t) == CONSTRUCTOR 2300 && EMPTY_CONSTRUCTOR_P (t)) 2301 /* Default-initialization. */ 2302 return true; 2303 2304 /* If the initializer is a COND_EXPR, we can't preevaluate 2305 anything. */ 2306 if (TREE_CODE (t) == COND_EXPR) 2307 return false; 2308 2309 if (TREE_CODE (t) == CALL_EXPR 2310 || TREE_CODE (t) == AGGR_INIT_EXPR) 2311 { 2312 stabilize_call (t, initp); 2313 return true; 2314 } 2315 2316 /* The initialization is being performed via a bitwise copy -- and 2317 the item copied may have side effects. */ 2318 return TREE_SIDE_EFFECTS (init); 2319} 2320 2321/* Like "fold", but should be used whenever we might be processing the 2322 body of a template. */ 2323 2324tree 2325fold_if_not_in_template (tree expr) 2326{ 2327 /* In the body of a template, there is never any need to call 2328 "fold". We will call fold later when actually instantiating the 2329 template. Integral constant expressions in templates will be 2330 evaluated via fold_non_dependent_expr, as necessary. */ 2331 if (processing_template_decl) 2332 return expr; 2333 2334 /* Fold C++ front-end specific tree codes. */ 2335 if (TREE_CODE (expr) == UNARY_PLUS_EXPR) 2336 return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0)); 2337 2338 return fold (expr); 2339} 2340 2341 2342#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) 2343/* Complain that some language-specific thing hanging off a tree 2344 node has been accessed improperly. */ 2345 2346void 2347lang_check_failed (const char* file, int line, const char* function) 2348{ 2349 internal_error ("lang_* check: failed in %s, at %s:%d", 2350 function, trim_filename (file), line); 2351} 2352#endif /* ENABLE_TREE_CHECKING */ 2353 2354#include "gt-cp-tree.h" 2355