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 = make_aggr_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 COMPLEX_CST:
1738       return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
1739         && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
1740
1741     case CONSTRUCTOR:
1742       /* We need to do this when determining whether or not two
1743          non-type pointer to member function template arguments
1744          are the same.  */
1745       if (!(same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
1746             /* The first operand is RTL.  */
1747             && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
1748         return false;
1749       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
1750
1751     case TREE_LIST:
1752       if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
1753         return false;
1754       if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
1755         return false;
1756       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
1757
1758     case SAVE_EXPR:
1759       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
1760
1761     case CALL_EXPR:
1762       {
1763         tree arg1, arg2;
1764         call_expr_arg_iterator iter1, iter2;
1765         if (!cp_tree_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
1766           return false;
1767         for (arg1 = first_call_expr_arg (t1, &iter1),
1768                arg2 = first_call_expr_arg (t2, &iter2);
1769              arg1 && arg2;
1770              arg1 = next_call_expr_arg (&iter1),
1771                arg2 = next_call_expr_arg (&iter2))
1772           if (!cp_tree_equal (arg1, arg2))
1773             return false;
1774         return (arg1 || arg2);
1775       }
1776
1777     case TARGET_EXPR:
1778       {
1779         tree o1 = TREE_OPERAND (t1, 0);
1780         tree o2 = TREE_OPERAND (t2, 0);
1781
1782         /* Special case: if either target is an unallocated VAR_DECL,
1783            it means that it's going to be unified with whatever the
1784            TARGET_EXPR is really supposed to initialize, so treat it
1785            as being equivalent to anything.  */
1786         if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
1787             && !DECL_RTL_SET_P (o1))
1788           /*Nop*/;
1789         else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
1790                  && !DECL_RTL_SET_P (o2))
1791           /*Nop*/;
1792         else if (!cp_tree_equal (o1, o2))
1793           return false;
1794
1795         return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
1796       }
1797
1798     case WITH_CLEANUP_EXPR:
1799       if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1800         return false;
1801       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
1802
1803     case COMPONENT_REF:
1804       if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
1805         return false;
1806       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
1807
1808     case VAR_DECL:
1809     case PARM_DECL:
1810     case CONST_DECL:
1811     case FUNCTION_DECL:
1812     case TEMPLATE_DECL:
1813     case IDENTIFIER_NODE:
1814     case SSA_NAME:
1815       return false;
1816
1817     case BASELINK:
1818       return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
1819               && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
1820               && cp_tree_equal (BASELINK_FUNCTIONS (t1),
1821                                 BASELINK_FUNCTIONS (t2)));
1822
1823     case TEMPLATE_PARM_INDEX:
1824       return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
1825               && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
1826               && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
1827                               TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
1828
1829     case TEMPLATE_ID_EXPR:
1830       {
1831         unsigned ix;
1832         tree vec1, vec2;
1833
1834         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1835           return false;
1836         vec1 = TREE_OPERAND (t1, 1);
1837         vec2 = TREE_OPERAND (t2, 1);
1838
1839         if (!vec1 || !vec2)
1840           return !vec1 && !vec2;
1841
1842         if (TREE_VEC_LENGTH (vec1) != TREE_VEC_LENGTH (vec2))
1843           return false;
1844
1845         for (ix = TREE_VEC_LENGTH (vec1); ix--;)
1846           if (!cp_tree_equal (TREE_VEC_ELT (vec1, ix),
1847                               TREE_VEC_ELT (vec2, ix)))
1848             return false;
1849
1850         return true;
1851       }
1852
1853     case SIZEOF_EXPR:
1854     case ALIGNOF_EXPR:
1855       {
1856         tree o1 = TREE_OPERAND (t1, 0);
1857         tree o2 = TREE_OPERAND (t2, 0);
1858
1859         if (TREE_CODE (o1) != TREE_CODE (o2))
1860           return false;
1861         if (TYPE_P (o1))
1862           return same_type_p (o1, o2);
1863         else
1864           return cp_tree_equal (o1, o2);
1865       }
1866
1867     case MODOP_EXPR:
1868       {
1869         tree t1_op1, t2_op1;
1870
1871         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1872           return false;
1873
1874         t1_op1 = TREE_OPERAND (t1, 1);
1875         t2_op1 = TREE_OPERAND (t2, 1);
1876         if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
1877           return false;
1878
1879         return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
1880       }
1881
1882     case PTRMEM_CST:
1883       /* Two pointer-to-members are the same if they point to the same
1884          field or function in the same class.  */
1885       if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
1886         return false;
1887
1888       return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
1889
1890     case OVERLOAD:
1891       if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
1892         return false;
1893       return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
1894
1895     case TRAIT_EXPR:
1896       if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
1897         return false;
1898       return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
1899         && same_type_p (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
1900
1901     default:
1902       break;
1903     }
1904
1905   switch (TREE_CODE_CLASS (code1))
1906     {
1907     case tcc_unary:
1908     case tcc_binary:
1909     case tcc_comparison:
1910     case tcc_expression:
1911     case tcc_vl_exp:
1912     case tcc_reference:
1913     case tcc_statement:
1914       {
1915         int i, n;
1916
1917         n = TREE_OPERAND_LENGTH (t1);
1918         if (TREE_CODE_CLASS (code1) == tcc_vl_exp
1919             && n != TREE_OPERAND_LENGTH (t2))
1920           return false;
1921
1922         for (i = 0; i < n; ++i)
1923           if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
1924             return false;
1925
1926         return true;
1927       }
1928
1929     case tcc_type:
1930       return same_type_p (t1, t2);
1931     default:
1932       gcc_unreachable ();
1933     }
1934   /* We can get here with --disable-checking.  */
1935   return false;
1936 }
1937
1938 /* The type of ARG when used as an lvalue.  */
1939
1940 tree
1941 lvalue_type (tree arg)
1942 {
1943   tree type = TREE_TYPE (arg);
1944   return type;
1945 }
1946
1947 /* The type of ARG for printing error messages; denote lvalues with
1948    reference types.  */
1949
1950 tree
1951 error_type (tree arg)
1952 {
1953   tree type = TREE_TYPE (arg);
1954
1955   if (TREE_CODE (type) == ARRAY_TYPE)
1956     ;
1957   else if (TREE_CODE (type) == ERROR_MARK)
1958     ;
1959   else if (real_lvalue_p (arg))
1960     type = build_reference_type (lvalue_type (arg));
1961   else if (IS_AGGR_TYPE (type))
1962     type = lvalue_type (arg);
1963
1964   return type;
1965 }
1966
1967 /* Does FUNCTION use a variable-length argument list?  */
1968
1969 int
1970 varargs_function_p (const_tree function)
1971 {
1972   const_tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
1973   for (; parm; parm = TREE_CHAIN (parm))
1974     if (TREE_VALUE (parm) == void_type_node)
1975       return 0;
1976   return 1;
1977 }
1978
1979 /* Returns 1 if decl is a member of a class.  */
1980
1981 int
1982 member_p (const_tree decl)
1983 {
1984   const_tree const ctx = DECL_CONTEXT (decl);
1985   return (ctx && TYPE_P (ctx));
1986 }
1987
1988 /* Create a placeholder for member access where we don't actually have an
1989    object that the access is against.  */
1990
1991 tree
1992 build_dummy_object (tree type)
1993 {
1994   tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
1995   return build_indirect_ref (decl, NULL);
1996 }
1997
1998 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
1999    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
2000    binfo path from current_class_type to TYPE, or 0.  */
2001
2002 tree
2003 maybe_dummy_object (tree type, tree* binfop)
2004 {
2005   tree decl, context;
2006   tree binfo;
2007
2008   if (current_class_type
2009       && (binfo = lookup_base (current_class_type, type,
2010                                ba_unique | ba_quiet, NULL)))
2011     context = current_class_type;
2012   else
2013     {
2014       /* Reference from a nested class member function.  */
2015       context = type;
2016       binfo = TYPE_BINFO (type);
2017     }
2018
2019   if (binfop)
2020     *binfop = binfo;
2021
2022   if (current_class_ref && context == current_class_type
2023       /* Kludge: Make sure that current_class_type is actually
2024          correct.  It might not be if we're in the middle of
2025          tsubst_default_argument.  */
2026       && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)),
2027                       current_class_type))
2028     decl = current_class_ref;
2029   else
2030     decl = build_dummy_object (context);
2031
2032   return decl;
2033 }
2034
2035 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
2036
2037 int
2038 is_dummy_object (const_tree ob)
2039 {
2040   if (TREE_CODE (ob) == INDIRECT_REF)
2041     ob = TREE_OPERAND (ob, 0);
2042   return (TREE_CODE (ob) == NOP_EXPR
2043           && TREE_OPERAND (ob, 0) == void_zero_node);
2044 }
2045
2046 /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
2047
2048 int
2049 pod_type_p (const_tree t)
2050 {
2051   /* This CONST_CAST is okay because strip_array_types returns it's
2052      argument unmodified and we assign it to a const_tree.  */
2053   t = strip_array_types (CONST_CAST_TREE(t));
2054
2055   if (t == error_mark_node)
2056     return 1;
2057   if (INTEGRAL_TYPE_P (t))
2058     return 1;  /* integral, character or enumeral type */
2059   if (FLOAT_TYPE_P (t))
2060     return 1;
2061   if (TYPE_PTR_P (t))
2062     return 1; /* pointer to non-member */
2063   if (TYPE_PTR_TO_MEMBER_P (t))
2064     return 1; /* pointer to member */
2065
2066   if (TREE_CODE (t) == VECTOR_TYPE)
2067     return 1; /* vectors are (small) arrays of scalars */
2068
2069   if (! CLASS_TYPE_P (t))
2070     return 0; /* other non-class type (reference or function) */
2071   if (CLASSTYPE_NON_POD_P (t))
2072     return 0;
2073   return 1;
2074 }
2075
2076 /* Nonzero iff type T is a class template implicit specialization.  */
2077
2078 bool
2079 class_tmpl_impl_spec_p (const_tree t)
2080 {
2081   return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
2082 }
2083
2084 /* Returns 1 iff zero initialization of type T means actually storing
2085    zeros in it.  */
2086
2087 int
2088 zero_init_p (const_tree t)
2089 {
2090   /* This CONST_CAST is okay because strip_array_types returns it's
2091      argument unmodified and we assign it to a const_tree.  */
2092   t = strip_array_types (CONST_CAST_TREE(t));
2093
2094   if (t == error_mark_node)
2095     return 1;
2096
2097   /* NULL pointers to data members are initialized with -1.  */
2098   if (TYPE_PTRMEM_P (t))
2099     return 0;
2100
2101   /* Classes that contain types that can't be zero-initialized, cannot
2102      be zero-initialized themselves.  */
2103   if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
2104     return 0;
2105
2106   return 1;
2107 }
2108
2109 /* Table of valid C++ attributes.  */
2110 const struct attribute_spec cxx_attribute_table[] =
2111 {
2112   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2113   { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute },
2114   { "com_interface",  0, 0, false, false, false, handle_com_interface_attribute },
2115   { "init_priority",  1, 1, true,  false, false, handle_init_priority_attribute },
2116   { NULL,             0, 0, false, false, false, NULL }
2117 };
2118
2119 /* Handle a "java_interface" attribute; arguments as in
2120    struct attribute_spec.handler.  */
2121 static tree
2122 handle_java_interface_attribute (tree* node,
2123                                  tree name,
2124                                  tree args ATTRIBUTE_UNUSED ,
2125                                  int flags,
2126                                  bool* no_add_attrs)
2127 {
2128   if (DECL_P (*node)
2129       || !CLASS_TYPE_P (*node)
2130       || !TYPE_FOR_JAVA (*node))
2131     {
2132       error ("%qE attribute can only be applied to Java class definitions",
2133              name);
2134       *no_add_attrs = true;
2135       return NULL_TREE;
2136     }
2137   if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
2138     *node = build_variant_type_copy (*node);
2139   TYPE_JAVA_INTERFACE (*node) = 1;
2140
2141   return NULL_TREE;
2142 }
2143
2144 /* Handle a "com_interface" attribute; arguments as in
2145    struct attribute_spec.handler.  */
2146 static tree
2147 handle_com_interface_attribute (tree* node,
2148                                 tree name,
2149                                 tree args ATTRIBUTE_UNUSED ,
2150                                 int flags ATTRIBUTE_UNUSED ,
2151                                 bool* no_add_attrs)
2152 {
2153   static int warned;
2154
2155   *no_add_attrs = true;
2156
2157   if (DECL_P (*node)
2158       || !CLASS_TYPE_P (*node)
2159       || *node != TYPE_MAIN_VARIANT (*node))
2160     {
2161       warning (OPT_Wattributes, "%qE attribute can only be applied "
2162                "to class definitions", name);
2163       return NULL_TREE;
2164     }
2165
2166   if (!warned++)
2167     warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
2168              name);
2169
2170   return NULL_TREE;
2171 }
2172
2173 /* Handle an "init_priority" attribute; arguments as in
2174    struct attribute_spec.handler.  */
2175 static tree
2176 handle_init_priority_attribute (tree* node,
2177                                 tree name,
2178                                 tree args,
2179                                 int flags ATTRIBUTE_UNUSED ,
2180                                 bool* no_add_attrs)
2181 {
2182   tree initp_expr = TREE_VALUE (args);
2183   tree decl = *node;
2184   tree type = TREE_TYPE (decl);
2185   int pri;
2186
2187   STRIP_NOPS (initp_expr);
2188
2189   if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
2190     {
2191       error ("requested init_priority is not an integer constant");
2192       *no_add_attrs = true;
2193       return NULL_TREE;
2194     }
2195
2196   pri = TREE_INT_CST_LOW (initp_expr);
2197
2198   type = strip_array_types (type);
2199
2200   if (decl == NULL_TREE
2201       || TREE_CODE (decl) != VAR_DECL
2202       || !TREE_STATIC (decl)
2203       || DECL_EXTERNAL (decl)
2204       || (TREE_CODE (type) != RECORD_TYPE
2205           && TREE_CODE (type) != UNION_TYPE)
2206       /* Static objects in functions are initialized the
2207          first time control passes through that
2208          function. This is not precise enough to pin down an
2209          init_priority value, so don't allow it.  */
2210       || current_function_decl)
2211     {
2212       error ("can only use %qE attribute on file-scope definitions "
2213              "of objects of class type", name);
2214       *no_add_attrs = true;
2215       return NULL_TREE;
2216     }
2217
2218   if (pri > MAX_INIT_PRIORITY || pri <= 0)
2219     {
2220       error ("requested init_priority is out of range");
2221       *no_add_attrs = true;
2222       return NULL_TREE;
2223     }
2224
2225   /* Check for init_priorities that are reserved for
2226      language and runtime support implementations.*/
2227   if (pri <= MAX_RESERVED_INIT_PRIORITY)
2228     {
2229       warning
2230         (0, "requested init_priority is reserved for internal use");
2231     }
2232
2233   if (SUPPORTS_INIT_PRIORITY)
2234     {
2235       SET_DECL_INIT_PRIORITY (decl, pri);
2236       DECL_HAS_INIT_PRIORITY_P (decl) = 1;
2237       return NULL_TREE;
2238     }
2239   else
2240     {
2241       error ("%qE attribute is not supported on this platform", name);
2242       *no_add_attrs = true;
2243       return NULL_TREE;
2244     }
2245 }
2246
2247 /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
2248    thing pointed to by the constant.  */
2249
2250 tree
2251 make_ptrmem_cst (tree type, tree member)
2252 {
2253   tree ptrmem_cst = make_node (PTRMEM_CST);
2254   TREE_TYPE (ptrmem_cst) = type;
2255   PTRMEM_CST_MEMBER (ptrmem_cst) = member;
2256   return ptrmem_cst;
2257 }
2258
2259 /* Build a variant of TYPE that has the indicated ATTRIBUTES.  May
2260    return an existing type if an appropriate type already exists.  */
2261
2262 tree
2263 cp_build_type_attribute_variant (tree type, tree attributes)
2264 {
2265   tree new_type;
2266
2267   new_type = build_type_attribute_variant (type, attributes);
2268   if (TREE_CODE (new_type) == FUNCTION_TYPE
2269       && (TYPE_RAISES_EXCEPTIONS (new_type)
2270           != TYPE_RAISES_EXCEPTIONS (type)))
2271     new_type = build_exception_variant (new_type,
2272                                         TYPE_RAISES_EXCEPTIONS (type));
2273
2274   /* Making a new main variant of a class type is broken.  */
2275   gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
2276
2277   return new_type;
2278 }
2279
2280 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
2281    Called only after doing all language independent checks.  Only
2282    to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
2283    compared in type_hash_eq.  */
2284
2285 bool
2286 cxx_type_hash_eq (const_tree typea, const_tree typeb)
2287 {
2288   gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE);
2289
2290   return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
2291                             TYPE_RAISES_EXCEPTIONS (typeb), 1);
2292 }
2293
2294 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
2295    traversal.  Called from walk_tree.  */
2296
2297 tree
2298 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
2299                   void *data, struct pointer_set_t *pset)
2300 {
2301   enum tree_code code = TREE_CODE (*tp);
2302   tree result;
2303
2304 #define WALK_SUBTREE(NODE)                              \
2305   do                                                    \
2306     {                                                   \
2307       result = cp_walk_tree (&(NODE), func, data, pset);        \
2308       if (result) goto out;                             \
2309     }                                                   \
2310   while (0)
2311
2312   /* Not one of the easy cases.  We must explicitly go through the
2313      children.  */
2314   result = NULL_TREE;
2315   switch (code)
2316     {
2317     case DEFAULT_ARG:
2318     case TEMPLATE_TEMPLATE_PARM:
2319     case BOUND_TEMPLATE_TEMPLATE_PARM:
2320     case UNBOUND_CLASS_TEMPLATE:
2321     case TEMPLATE_PARM_INDEX:
2322     case TEMPLATE_TYPE_PARM:
2323     case TYPENAME_TYPE:
2324     case TYPEOF_TYPE:
2325       /* None of these have subtrees other than those already walked
2326          above.  */
2327       *walk_subtrees_p = 0;
2328       break;
2329
2330     case BASELINK:
2331       WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
2332       *walk_subtrees_p = 0;
2333       break;
2334
2335     case PTRMEM_CST:
2336       WALK_SUBTREE (TREE_TYPE (*tp));
2337       *walk_subtrees_p = 0;
2338       break;
2339
2340     case TREE_LIST:
2341       WALK_SUBTREE (TREE_PURPOSE (*tp));
2342       break;
2343
2344     case OVERLOAD:
2345       WALK_SUBTREE (OVL_FUNCTION (*tp));
2346       WALK_SUBTREE (OVL_CHAIN (*tp));
2347       *walk_subtrees_p = 0;
2348       break;
2349
2350     case USING_DECL:
2351       WALK_SUBTREE (DECL_NAME (*tp));
2352       WALK_SUBTREE (USING_DECL_SCOPE (*tp));
2353       WALK_SUBTREE (USING_DECL_DECLS (*tp));
2354       *walk_subtrees_p = 0;
2355       break;
2356
2357     case RECORD_TYPE:
2358       if (TYPE_PTRMEMFUNC_P (*tp))
2359         WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
2360       break;
2361
2362     case TYPE_ARGUMENT_PACK:
2363     case NONTYPE_ARGUMENT_PACK:
2364       {
2365         tree args = ARGUMENT_PACK_ARGS (*tp);
2366         int i, len = TREE_VEC_LENGTH (args);
2367         for (i = 0; i < len; i++)
2368           WALK_SUBTREE (TREE_VEC_ELT (args, i));
2369       }
2370       break;
2371
2372     case TYPE_PACK_EXPANSION:
2373       WALK_SUBTREE (TREE_TYPE (*tp));
2374       *walk_subtrees_p = 0;
2375       break;
2376
2377     case EXPR_PACK_EXPANSION:
2378       WALK_SUBTREE (TREE_OPERAND (*tp, 0));
2379       *walk_subtrees_p = 0;
2380       break;
2381
2382     case CAST_EXPR:
2383       if (TREE_TYPE (*tp))
2384         WALK_SUBTREE (TREE_TYPE (*tp));
2385
2386       {
2387         int i;
2388         for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
2389           WALK_SUBTREE (TREE_OPERAND (*tp, i));
2390       }
2391       *walk_subtrees_p = 0;
2392       break;
2393
2394     case TRAIT_EXPR:
2395       WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
2396       WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
2397       *walk_subtrees_p = 0;
2398       break;
2399
2400     case DECLTYPE_TYPE:
2401       WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
2402       *walk_subtrees_p = 0;
2403       break;
2404
2405
2406     default:
2407       return NULL_TREE;
2408     }
2409
2410   /* We didn't find what we were looking for.  */
2411  out:
2412   return result;
2413
2414 #undef WALK_SUBTREE
2415 }
2416
2417 /* Like save_expr, but for C++.  */
2418
2419 tree
2420 cp_save_expr (tree expr)
2421 {
2422   /* There is no reason to create a SAVE_EXPR within a template; if
2423      needed, we can create the SAVE_EXPR when instantiating the
2424      template.  Furthermore, the middle-end cannot handle C++-specific
2425      tree codes.  */
2426   if (processing_template_decl)
2427     return expr;
2428   return save_expr (expr);
2429 }
2430
2431 /* Initialize tree.c.  */
2432
2433 void
2434 init_tree (void)
2435 {
2436   list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
2437 }
2438
2439 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2440    is.  Note that sfk_none is zero, so this function can be used as a
2441    predicate to test whether or not DECL is a special function.  */
2442
2443 special_function_kind
2444 special_function_p (const_tree decl)
2445 {
2446   /* Rather than doing all this stuff with magic names, we should
2447      probably have a field of type `special_function_kind' in
2448      DECL_LANG_SPECIFIC.  */
2449   if (DECL_COPY_CONSTRUCTOR_P (decl))
2450     return sfk_copy_constructor;
2451   if (DECL_CONSTRUCTOR_P (decl))
2452     return sfk_constructor;
2453   if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
2454     return sfk_assignment_operator;
2455   if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2456     return sfk_destructor;
2457   if (DECL_COMPLETE_DESTRUCTOR_P (decl))
2458     return sfk_complete_destructor;
2459   if (DECL_BASE_DESTRUCTOR_P (decl))
2460     return sfk_base_destructor;
2461   if (DECL_DELETING_DESTRUCTOR_P (decl))
2462     return sfk_deleting_destructor;
2463   if (DECL_CONV_FN_P (decl))
2464     return sfk_conversion;
2465
2466   return sfk_none;
2467 }
2468
2469 /* Returns nonzero if TYPE is a character type, including wchar_t.  */
2470
2471 int
2472 char_type_p (tree type)
2473 {
2474   return (same_type_p (type, char_type_node)
2475           || same_type_p (type, unsigned_char_type_node)
2476           || same_type_p (type, signed_char_type_node)
2477           || same_type_p (type, wchar_type_node));
2478 }
2479
2480 /* Returns the kind of linkage associated with the indicated DECL.  Th
2481    value returned is as specified by the language standard; it is
2482    independent of implementation details regarding template
2483    instantiation, etc.  For example, it is possible that a declaration
2484    to which this function assigns external linkage would not show up
2485    as a global symbol when you run `nm' on the resulting object file.  */
2486
2487 linkage_kind
2488 decl_linkage (tree decl)
2489 {
2490   /* This function doesn't attempt to calculate the linkage from first
2491      principles as given in [basic.link].  Instead, it makes use of
2492      the fact that we have already set TREE_PUBLIC appropriately, and
2493      then handles a few special cases.  Ideally, we would calculate
2494      linkage first, and then transform that into a concrete
2495      implementation.  */
2496
2497   /* Things that don't have names have no linkage.  */
2498   if (!DECL_NAME (decl))
2499     return lk_none;
2500
2501   /* Fields have no linkage.  */
2502   if (TREE_CODE (decl) == FIELD_DECL)
2503     return lk_none;
2504
2505   /* Things that are TREE_PUBLIC have external linkage.  */
2506   if (TREE_PUBLIC (decl))
2507     return lk_external;
2508
2509   if (TREE_CODE (decl) == NAMESPACE_DECL)
2510     return lk_external;
2511
2512   /* Linkage of a CONST_DECL depends on the linkage of the enumeration
2513      type.  */
2514   if (TREE_CODE (decl) == CONST_DECL)
2515     return decl_linkage (TYPE_NAME (TREE_TYPE (decl)));
2516
2517   /* Some things that are not TREE_PUBLIC have external linkage, too.
2518      For example, on targets that don't have weak symbols, we make all
2519      template instantiations have internal linkage (in the object
2520      file), but the symbols should still be treated as having external
2521      linkage from the point of view of the language.  */
2522   if (TREE_CODE (decl) != TYPE_DECL && DECL_LANG_SPECIFIC (decl)
2523       && DECL_COMDAT (decl))
2524     return lk_external;
2525
2526   /* Things in local scope do not have linkage, if they don't have
2527      TREE_PUBLIC set.  */
2528   if (decl_function_context (decl))
2529     return lk_none;
2530
2531   /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
2532      are considered to have external linkage for language purposes.  DECLs
2533      really meant to have internal linkage have DECL_THIS_STATIC set.  */
2534   if (TREE_CODE (decl) == TYPE_DECL)
2535     return lk_external;
2536   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
2537     {
2538       if (!DECL_THIS_STATIC (decl))
2539         return lk_external;
2540
2541       /* Static data members and static member functions from classes
2542          in anonymous namespace also don't have TREE_PUBLIC set.  */
2543       if (DECL_CLASS_CONTEXT (decl))
2544         return lk_external;
2545     }
2546
2547   /* Everything else has internal linkage.  */
2548   return lk_internal;
2549 }
2550 \f
2551 /* EXP is an expression that we want to pre-evaluate.  Returns (in
2552    *INITP) an expression that will perform the pre-evaluation.  The
2553    value returned by this function is a side-effect free expression
2554    equivalent to the pre-evaluated expression.  Callers must ensure
2555    that *INITP is evaluated before EXP.  */
2556
2557 tree
2558 stabilize_expr (tree exp, tree* initp)
2559 {
2560   tree init_expr;
2561
2562   if (!TREE_SIDE_EFFECTS (exp))
2563     init_expr = NULL_TREE;
2564   else if (!real_lvalue_p (exp)
2565            || !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp)))
2566     {
2567       init_expr = get_target_expr (exp);
2568       exp = TARGET_EXPR_SLOT (init_expr);
2569     }
2570   else
2571     {
2572       exp = build_unary_op (ADDR_EXPR, exp, 1);
2573       init_expr = get_target_expr (exp);
2574       exp = TARGET_EXPR_SLOT (init_expr);
2575       exp = build_indirect_ref (exp, 0);
2576     }
2577   *initp = init_expr;
2578
2579   gcc_assert (!TREE_SIDE_EFFECTS (exp));
2580   return exp;
2581 }
2582
2583 /* Add NEW, an expression whose value we don't care about, after the
2584    similar expression ORIG.  */
2585
2586 tree
2587 add_stmt_to_compound (tree orig, tree new)
2588 {
2589   if (!new || !TREE_SIDE_EFFECTS (new))
2590     return orig;
2591   if (!orig || !TREE_SIDE_EFFECTS (orig))
2592     return new;
2593   return build2 (COMPOUND_EXPR, void_type_node, orig, new);
2594 }
2595
2596 /* Like stabilize_expr, but for a call whose arguments we want to
2597    pre-evaluate.  CALL is modified in place to use the pre-evaluated
2598    arguments, while, upon return, *INITP contains an expression to
2599    compute the arguments.  */
2600
2601 void
2602 stabilize_call (tree call, tree *initp)
2603 {
2604   tree inits = NULL_TREE;
2605   int i;
2606   int nargs = call_expr_nargs (call);
2607
2608   if (call == error_mark_node || processing_template_decl)
2609     {
2610       *initp = NULL_TREE;
2611       return;
2612     }
2613
2614   gcc_assert (TREE_CODE (call) == CALL_EXPR);
2615
2616   for (i = 0; i < nargs; i++)
2617     {
2618       tree init;
2619       CALL_EXPR_ARG (call, i) =
2620         stabilize_expr (CALL_EXPR_ARG (call, i), &init);
2621       inits = add_stmt_to_compound (inits, init);
2622     }
2623
2624   *initp = inits;
2625 }
2626
2627 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
2628    to pre-evaluate.  CALL is modified in place to use the pre-evaluated
2629    arguments, while, upon return, *INITP contains an expression to
2630    compute the arguments.  */
2631
2632 void
2633 stabilize_aggr_init (tree call, tree *initp)
2634 {
2635   tree inits = NULL_TREE;
2636   int i;
2637   int nargs = aggr_init_expr_nargs (call);
2638
2639   if (call == error_mark_node)
2640     return;
2641
2642   gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
2643
2644   for (i = 0; i < nargs; i++)
2645     {
2646       tree init;
2647       AGGR_INIT_EXPR_ARG (call, i) =
2648         stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
2649       inits = add_stmt_to_compound (inits, init);
2650     }
2651
2652   *initp = inits;
2653 }
2654
2655 /* Like stabilize_expr, but for an initialization.
2656
2657    If the initialization is for an object of class type, this function
2658    takes care not to introduce additional temporaries.
2659
2660    Returns TRUE iff the expression was successfully pre-evaluated,
2661    i.e., if INIT is now side-effect free, except for, possible, a
2662    single call to a constructor.  */
2663
2664 bool
2665 stabilize_init (tree init, tree *initp)
2666 {
2667   tree t = init;
2668
2669   *initp = NULL_TREE;
2670
2671   if (t == error_mark_node || processing_template_decl)
2672     return true;
2673
2674   if (TREE_CODE (t) == INIT_EXPR
2675       && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR)
2676     {
2677       TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
2678       return true;
2679     }
2680
2681   if (TREE_CODE (t) == INIT_EXPR)
2682     t = TREE_OPERAND (t, 1);
2683   if (TREE_CODE (t) == TARGET_EXPR)
2684     t = TARGET_EXPR_INITIAL (t);
2685   if (TREE_CODE (t) == COMPOUND_EXPR)
2686     t = expr_last (t);
2687   if (TREE_CODE (t) == CONSTRUCTOR
2688       && EMPTY_CONSTRUCTOR_P (t))
2689     /* Default-initialization.  */
2690     return true;
2691
2692   /* If the initializer is a COND_EXPR, we can't preevaluate
2693      anything.  */
2694   if (TREE_CODE (t) == COND_EXPR)
2695     return false;
2696
2697   if (TREE_CODE (t) == CALL_EXPR)
2698     {
2699       stabilize_call (t, initp);
2700       return true;
2701     }
2702
2703   if (TREE_CODE (t) == AGGR_INIT_EXPR)
2704     {
2705       stabilize_aggr_init (t, initp);
2706       return true;
2707     }
2708
2709   /* The initialization is being performed via a bitwise copy -- and
2710      the item copied may have side effects.  */
2711   return TREE_SIDE_EFFECTS (init);
2712 }
2713
2714 /* Like "fold", but should be used whenever we might be processing the
2715    body of a template.  */
2716
2717 tree
2718 fold_if_not_in_template (tree expr)
2719 {
2720   /* In the body of a template, there is never any need to call
2721      "fold".  We will call fold later when actually instantiating the
2722      template.  Integral constant expressions in templates will be
2723      evaluated via fold_non_dependent_expr, as necessary.  */
2724   if (processing_template_decl)
2725     return expr;
2726
2727   /* Fold C++ front-end specific tree codes.  */
2728   if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
2729     return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
2730
2731   return fold (expr);
2732 }
2733
2734 /* Returns true if a cast to TYPE may appear in an integral constant
2735    expression.  */
2736
2737 bool
2738 cast_valid_in_integral_constant_expression_p (tree type)
2739 {
2740   return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
2741           || dependent_type_p (type)
2742           || type == error_mark_node);
2743 }
2744
2745 \f
2746 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
2747 /* Complain that some language-specific thing hanging off a tree
2748    node has been accessed improperly.  */
2749
2750 void
2751 lang_check_failed (const char* file, int line, const char* function)
2752 {
2753   internal_error ("lang_* check: failed in %s, at %s:%d",
2754                   function, trim_filename (file), line);
2755 }
2756 #endif /* ENABLE_TREE_CHECKING */
2757
2758 #include "gt-cp-tree.h"