gcc/cp/tree.c

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