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