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