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