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
1930   return NULL_TREE;
1931 }
1932
1933 /* When we parse a default argument expression, we may create
1934    temporary variables via TARGET_EXPRs.  When we actually use the
1935    default-argument expression, we make a copy of the expression
1936    and replace the temporaries with appropriate local versions.  */
1937
1938 tree
1939 break_out_target_exprs (tree t)
1940 {
1941   static int target_remap_count;
1942   static splay_tree target_remap;
1943
1944   if (!target_remap_count++)
1945     target_remap = splay_tree_new (splay_tree_compare_pointers,
1946                                    /*splay_tree_delete_key_fn=*/NULL,
1947                                    /*splay_tree_delete_value_fn=*/NULL);
1948   cp_walk_tree (&t, bot_manip, target_remap, NULL);
1949   cp_walk_tree (&t, bot_replace, target_remap, NULL);
1950
1951   if (!--target_remap_count)
1952     {
1953       splay_tree_delete (target_remap);
1954       target_remap = NULL;
1955     }
1956
1957   return t;
1958 }
1959
1960 /* Similar to `build_nt', but for template definitions of dependent
1961    expressions  */
1962
1963 tree
1964 build_min_nt (enum tree_code code, ...)
1965 {
1966   tree t;
1967   int length;
1968   int i;
1969   va_list p;
1970
1971   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1972
1973   va_start (p, code);
1974
1975   t = make_node (code);
1976   length = TREE_CODE_LENGTH (code);
1977
1978   for (i = 0; i < length; i++)
1979     {
1980       tree x = va_arg (p, tree);
1981       TREE_OPERAND (t, i) = x;
1982     }
1983
1984   va_end (p);
1985   return t;
1986 }
1987
1988
1989 /* Similar to `build', but for template definitions.  */
1990
1991 tree
1992 build_min (enum tree_code code, tree tt, ...)
1993 {
1994   tree t;
1995   int length;
1996   int i;
1997   va_list p;
1998
1999   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2000
2001   va_start (p, tt);
2002
2003   t = make_node (code);
2004   length = TREE_CODE_LENGTH (code);
2005   TREE_TYPE (t) = tt;
2006
2007   for (i = 0; i < length; i++)
2008     {
2009       tree x = va_arg (p, tree);
2010       TREE_OPERAND (t, i) = x;
2011       if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
2012         TREE_SIDE_EFFECTS (t) = 1;
2013     }
2014
2015   va_end (p);
2016   return t;
2017 }
2018
2019 /* Similar to `build', but for template definitions of non-dependent
2020    expressions. NON_DEP is the non-dependent expression that has been
2021    built.  */
2022
2023 tree
2024 build_min_non_dep (enum tree_code code, tree non_dep, ...)
2025 {
2026   tree t;
2027   int length;
2028   int i;
2029   va_list p;
2030
2031   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2032
2033   va_start (p, non_dep);
2034
2035   if (REFERENCE_REF_P (non_dep))
2036     non_dep = TREE_OPERAND (non_dep, 0);
2037
2038   t = make_node (code);
2039   length = TREE_CODE_LENGTH (code);
2040   TREE_TYPE (t) = TREE_TYPE (non_dep);
2041   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
2042
2043   for (i = 0; i < length; i++)
2044     {
2045       tree x = va_arg (p, tree);
2046       TREE_OPERAND (t, i) = x;
2047     }
2048
2049   if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
2050     /* This should not be considered a COMPOUND_EXPR, because it
2051        resolves to an overload.  */
2052     COMPOUND_EXPR_OVERLOADED (t) = 1;
2053
2054   va_end (p);
2055   return convert_from_reference (t);
2056 }
2057
2058 /* Similar to `build_nt_call_vec', but for template definitions of
2059    non-dependent expressions. NON_DEP is the non-dependent expression
2060    that has been built.  */
2061
2062 tree
2063 build_min_non_dep_call_vec (tree non_dep, tree fn, VEC(tree,gc) *argvec)
2064 {
2065   tree t = build_nt_call_vec (fn, argvec);
2066   if (REFERENCE_REF_P (non_dep))
2067     non_dep = TREE_OPERAND (non_dep, 0);
2068   TREE_TYPE (t) = TREE_TYPE (non_dep);
2069   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
2070   return convert_from_reference (t);
2071 }
2072
2073 tree
2074 get_type_decl (tree t)
2075 {
2076   if (TREE_CODE (t) == TYPE_DECL)
2077     return t;
2078   if (TYPE_P (t))
2079     return TYPE_STUB_DECL (t);
2080   gcc_assert (t == error_mark_node);
2081   return t;
2082 }
2083
2084 /* Returns the namespace that contains DECL, whether directly or
2085    indirectly.  */
2086
2087 tree
2088 decl_namespace_context (tree decl)
2089 {
2090   while (1)
2091     {
2092       if (TREE_CODE (decl) == NAMESPACE_DECL)
2093         return decl;
2094       else if (TYPE_P (decl))
2095         decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
2096       else
2097         decl = CP_DECL_CONTEXT (decl);
2098     }
2099 }
2100
2101 /* Returns true if decl is within an anonymous namespace, however deeply
2102    nested, or false otherwise.  */
2103
2104 bool
2105 decl_anon_ns_mem_p (const_tree decl)
2106 {
2107   while (1)
2108     {
2109       if (decl == NULL_TREE || decl == error_mark_node)
2110         return false;
2111       if (TREE_CODE (decl) == NAMESPACE_DECL
2112           && DECL_NAME (decl) == NULL_TREE)
2113         return true;
2114       /* Classes and namespaces inside anonymous namespaces have
2115          TREE_PUBLIC == 0, so we can shortcut the search.  */
2116       else if (TYPE_P (decl))
2117         return (TREE_PUBLIC (TYPE_NAME (decl)) == 0);
2118       else if (TREE_CODE (decl) == NAMESPACE_DECL)
2119         return (TREE_PUBLIC (decl) == 0);
2120       else
2121         decl = DECL_CONTEXT (decl);
2122     }
2123 }
2124
2125 /* Return truthvalue of whether T1 is the same tree structure as T2.
2126    Return 1 if they are the same. Return 0 if they are different.  */
2127
2128 bool
2129 cp_tree_equal (tree t1, tree t2)
2130 {
2131   enum tree_code code1, code2;
2132
2133   if (t1 == t2)
2134     return true;
2135   if (!t1 || !t2)
2136     return false;
2137
2138   for (code1 = TREE_CODE (t1);
2139        CONVERT_EXPR_CODE_P (code1)
2140          || code1 == NON_LVALUE_EXPR;
2141        code1 = TREE_CODE (t1))
2142     t1 = TREE_OPERAND (t1, 0);
2143   for (code2 = TREE_CODE (t2);
2144        CONVERT_EXPR_CODE_P (code2)
2145          || code1 == NON_LVALUE_EXPR;
2146        code2 = TREE_CODE (t2))
2147     t2 = TREE_OPERAND (t2, 0);
2148
2149   /* They might have become equal now.  */
2150   if (t1 == t2)
2151     return true;
2152
2153   if (code1 != code2)
2154     return false;
2155
2156   switch (code1)
2157     {
2158     case INTEGER_CST:
2159       return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2160         && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2161
2162     case REAL_CST:
2163       return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2164
2165     case STRING_CST:
2166       return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2167         && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2168                     TREE_STRING_LENGTH (t1));
2169
2170     case FIXED_CST:
2171       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
2172                                      TREE_FIXED_CST (t2));
2173
2174     case COMPLEX_CST:
2175       return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
2176         && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
2177
2178     case CONSTRUCTOR:
2179       /* We need to do this when determining whether or not two
2180          non-type pointer to member function template arguments
2181          are the same.  */
2182       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2183           || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
2184         return false;
2185       {
2186         tree field, value;
2187         unsigned int i;
2188         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
2189           {
2190             constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
2191             if (!cp_tree_equal (field, elt2->index)
2192                 || !cp_tree_equal (value, elt2->value))
2193               return false;
2194           }
2195       }
2196       return true;
2197
2198     case TREE_LIST:
2199       if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
2200         return false;
2201       if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
2202         return false;
2203       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2204
2205     case SAVE_EXPR:
2206       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2207
2208     case CALL_EXPR:
2209       {
2210         tree arg1, arg2;
2211         call_expr_arg_iterator iter1, iter2;
2212         /* Core 1321: dependent names are equivalent even if the
2213            overload sets are different.  */
2214         tree name1 = dependent_name (CALL_EXPR_FN (t1));
2215         tree name2 = dependent_name (CALL_EXPR_FN (t2));
2216         if (!(name1 && name2 && name1 == name2)
2217             && !cp_tree_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
2218           return false;
2219         for (arg1 = first_call_expr_arg (t1, &iter1),
2220                arg2 = first_call_expr_arg (t2, &iter2);
2221              arg1 && arg2;
2222              arg1 = next_call_expr_arg (&iter1),
2223                arg2 = next_call_expr_arg (&iter2))
2224           if (!cp_tree_equal (arg1, arg2))
2225             return false;
2226         if (arg1 || arg2)
2227           return false;
2228         return true;
2229       }
2230
2231     case TARGET_EXPR:
2232       {
2233         tree o1 = TREE_OPERAND (t1, 0);
2234         tree o2 = TREE_OPERAND (t2, 0);
2235
2236         /* Special case: if either target is an unallocated VAR_DECL,
2237            it means that it's going to be unified with whatever the
2238            TARGET_EXPR is really supposed to initialize, so treat it
2239            as being equivalent to anything.  */
2240         if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
2241             && !DECL_RTL_SET_P (o1))
2242           /*Nop*/;
2243         else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
2244                  && !DECL_RTL_SET_P (o2))
2245           /*Nop*/;
2246         else if (!cp_tree_equal (o1, o2))
2247           return false;
2248
2249         return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2250       }
2251
2252     case WITH_CLEANUP_EXPR:
2253       if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2254         return false;
2255       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
2256
2257     case COMPONENT_REF:
2258       if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
2259         return false;
2260       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2261
2262     case PARM_DECL:
2263       /* For comparing uses of parameters in late-specified return types
2264          with an out-of-class definition of the function, but can also come
2265          up for expressions that involve 'this' in a member function
2266          template.  */
2267       if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2268         {
2269           if (DECL_ARTIFICIAL (t1) ^ DECL_ARTIFICIAL (t2))
2270             return false;
2271           if (DECL_ARTIFICIAL (t1)
2272               || (DECL_PARM_LEVEL (t1) == DECL_PARM_LEVEL (t2)
2273                   && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2)))
2274             return true;
2275         }
2276       return false;
2277
2278     case VAR_DECL:
2279     case CONST_DECL:
2280     case FUNCTION_DECL:
2281     case TEMPLATE_DECL:
2282     case IDENTIFIER_NODE:
2283     case SSA_NAME:
2284       return false;
2285
2286     case BASELINK:
2287       return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
2288               && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
2289               && cp_tree_equal (BASELINK_FUNCTIONS (t1),
2290                                 BASELINK_FUNCTIONS (t2)));
2291
2292     case TEMPLATE_PARM_INDEX:
2293       if (TEMPLATE_PARM_NUM_SIBLINGS (t1)
2294           != TEMPLATE_PARM_NUM_SIBLINGS (t2))
2295         return false;
2296       return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2297               && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
2298               && (TEMPLATE_PARM_PARAMETER_PACK (t1)
2299                   == TEMPLATE_PARM_PARAMETER_PACK (t2))
2300               && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
2301                               TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
2302
2303     case TEMPLATE_ID_EXPR:
2304       {
2305         unsigned ix;
2306         tree vec1, vec2;
2307
2308         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2309           return false;
2310         vec1 = TREE_OPERAND (t1, 1);
2311         vec2 = TREE_OPERAND (t2, 1);
2312
2313         if (!vec1 || !vec2)
2314           return !vec1 && !vec2;
2315
2316         if (TREE_VEC_LENGTH (vec1) != TREE_VEC_LENGTH (vec2))
2317           return false;
2318
2319         for (ix = TREE_VEC_LENGTH (vec1); ix--;)
2320           if (!cp_tree_equal (TREE_VEC_ELT (vec1, ix),
2321                               TREE_VEC_ELT (vec2, ix)))
2322             return false;
2323
2324         return true;
2325       }
2326
2327     case SIZEOF_EXPR:
2328     case ALIGNOF_EXPR:
2329       {
2330         tree o1 = TREE_OPERAND (t1, 0);
2331         tree o2 = TREE_OPERAND (t2, 0);
2332
2333         if (TREE_CODE (o1) != TREE_CODE (o2))
2334           return false;
2335         if (TYPE_P (o1))
2336           return same_type_p (o1, o2);
2337         else
2338           return cp_tree_equal (o1, o2);
2339       }
2340
2341     case MODOP_EXPR:
2342       {
2343         tree t1_op1, t2_op1;
2344
2345         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2346           return false;
2347
2348         t1_op1 = TREE_OPERAND (t1, 1);
2349         t2_op1 = TREE_OPERAND (t2, 1);
2350         if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
2351           return false;
2352
2353         return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
2354       }
2355
2356     case PTRMEM_CST:
2357       /* Two pointer-to-members are the same if they point to the same
2358          field or function in the same class.  */
2359       if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
2360         return false;
2361
2362       return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
2363
2364     case OVERLOAD:
2365       if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
2366         return false;
2367       return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
2368
2369     case TRAIT_EXPR:
2370       if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
2371         return false;
2372       return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
2373         && same_type_p (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
2374
2375     case CAST_EXPR:
2376     case STATIC_CAST_EXPR:
2377     case REINTERPRET_CAST_EXPR:
2378     case CONST_CAST_EXPR:
2379     case DYNAMIC_CAST_EXPR:
2380     case NEW_EXPR:
2381       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2382         return false;
2383       /* Now compare operands as usual.  */
2384       break;
2385
2386     case DEFERRED_NOEXCEPT:
2387       return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1),
2388                              DEFERRED_NOEXCEPT_PATTERN (t2))
2389               && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1),
2390                                      DEFERRED_NOEXCEPT_ARGS (t2)));
2391       break;
2392
2393     default:
2394       break;
2395     }
2396
2397   switch (TREE_CODE_CLASS (code1))
2398     {
2399     case tcc_unary:
2400     case tcc_binary:
2401     case tcc_comparison:
2402     case tcc_expression:
2403     case tcc_vl_exp:
2404     case tcc_reference:
2405     case tcc_statement:
2406       {
2407         int i, n;
2408
2409         n = cp_tree_operand_length (t1);
2410         if (TREE_CODE_CLASS (code1) == tcc_vl_exp
2411             && n != TREE_OPERAND_LENGTH (t2))
2412           return false;
2413
2414         for (i = 0; i < n; ++i)
2415           if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
2416             return false;
2417
2418         return true;
2419       }
2420
2421     case tcc_type:
2422       return same_type_p (t1, t2);
2423     default:
2424       gcc_unreachable ();
2425     }
2426   /* We can get here with --disable-checking.  */
2427   return false;
2428 }
2429
2430 /* The type of ARG when used as an lvalue.  */
2431
2432 tree
2433 lvalue_type (tree arg)
2434 {
2435   tree type = TREE_TYPE (arg);
2436   return type;
2437 }
2438
2439 /* The type of ARG for printing error messages; denote lvalues with
2440    reference types.  */
2441
2442 tree
2443 error_type (tree arg)
2444 {
2445   tree type = TREE_TYPE (arg);
2446
2447   if (TREE_CODE (type) == ARRAY_TYPE)
2448     ;
2449   else if (TREE_CODE (type) == ERROR_MARK)
2450     ;
2451   else if (real_lvalue_p (arg))
2452     type = build_reference_type (lvalue_type (arg));
2453   else if (MAYBE_CLASS_TYPE_P (type))
2454     type = lvalue_type (arg);
2455
2456   return type;
2457 }
2458
2459 /* Does FUNCTION use a variable-length argument list?  */
2460
2461 int
2462 varargs_function_p (const_tree function)
2463 {
2464   return stdarg_p (TREE_TYPE (function));
2465 }
2466
2467 /* Returns 1 if decl is a member of a class.  */
2468
2469 int
2470 member_p (const_tree decl)
2471 {
2472   const_tree const ctx = DECL_CONTEXT (decl);
2473   return (ctx && TYPE_P (ctx));
2474 }
2475
2476 /* Create a placeholder for member access where we don't actually have an
2477    object that the access is against.  */
2478
2479 tree
2480 build_dummy_object (tree type)
2481 {
2482   tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
2483   return cp_build_indirect_ref (decl, RO_NULL, tf_warning_or_error);
2484 }
2485
2486 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
2487    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
2488    binfo path from current_class_type to TYPE, or 0.  */
2489
2490 tree
2491 maybe_dummy_object (tree type, tree* binfop)
2492 {
2493   tree decl, context;
2494   tree binfo;
2495   tree current = current_nonlambda_class_type ();
2496
2497   if (current
2498       && (binfo = lookup_base (current, type, ba_any, NULL)))
2499     context = current;
2500   else
2501     {
2502       /* Reference from a nested class member function.  */
2503       context = type;
2504       binfo = TYPE_BINFO (type);
2505     }
2506
2507   if (binfop)
2508     *binfop = binfo;
2509
2510   if (current_class_ref
2511       /* current_class_ref might not correspond to current_class_type if
2512          we're in tsubst_default_argument or a lambda-declarator; in either
2513          case, we want to use current_class_ref if it matches CONTEXT.  */
2514       && (same_type_ignoring_top_level_qualifiers_p
2515           (TREE_TYPE (current_class_ref), context)))
2516     decl = current_class_ref;
2517   else if (current != current_class_type
2518            && context == nonlambda_method_basetype ())
2519     /* In a lambda, need to go through 'this' capture.  */
2520     decl = (build_x_indirect_ref
2521             ((lambda_expr_this_capture
2522               (CLASSTYPE_LAMBDA_EXPR (current_class_type))),
2523              RO_NULL, tf_warning_or_error));
2524   else
2525     decl = build_dummy_object (context);
2526
2527   return decl;
2528 }
2529
2530 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
2531
2532 int
2533 is_dummy_object (const_tree ob)
2534 {
2535   if (TREE_CODE (ob) == INDIRECT_REF)
2536     ob = TREE_OPERAND (ob, 0);
2537   return (TREE_CODE (ob) == NOP_EXPR
2538           && TREE_OPERAND (ob, 0) == void_zero_node);
2539 }
2540
2541 /* Returns 1 iff type T is something we want to treat as a scalar type for
2542    the purpose of deciding whether it is trivial/POD/standard-layout.  */
2543
2544 static bool
2545 scalarish_type_p (const_tree t)
2546 {
2547   if (t == error_mark_node)
2548     return 1;
2549
2550   return (SCALAR_TYPE_P (t)
2551           || TREE_CODE (t) == VECTOR_TYPE);
2552 }
2553
2554 /* Returns true iff T requires non-trivial default initialization.  */
2555
2556 bool
2557 type_has_nontrivial_default_init (const_tree t)
2558 {
2559   t = strip_array_types (CONST_CAST_TREE (t));
2560
2561   if (CLASS_TYPE_P (t))
2562     return TYPE_HAS_COMPLEX_DFLT (t);
2563   else
2564     return 0;
2565 }
2566
2567 /* Returns true iff copying an object of type T (including via move
2568    constructor) is non-trivial.  That is, T has no non-trivial copy
2569    constructors and no non-trivial move constructors.  */
2570
2571 bool
2572 type_has_nontrivial_copy_init (const_tree t)
2573 {
2574   t = strip_array_types (CONST_CAST_TREE (t));
2575
2576   if (CLASS_TYPE_P (t))
2577     {
2578       gcc_assert (COMPLETE_TYPE_P (t));
2579       return ((TYPE_HAS_COPY_CTOR (t)
2580                && TYPE_HAS_COMPLEX_COPY_CTOR (t))
2581               || TYPE_HAS_COMPLEX_MOVE_CTOR (t));
2582     }
2583   else
2584     return 0;
2585 }
2586
2587 /* Returns 1 iff type T is a trivially copyable type, as defined in
2588    [basic.types] and [class].  */
2589
2590 bool
2591 trivially_copyable_p (const_tree t)
2592 {
2593   t = strip_array_types (CONST_CAST_TREE (t));
2594
2595   if (CLASS_TYPE_P (t))
2596     return ((!TYPE_HAS_COPY_CTOR (t)
2597              || !TYPE_HAS_COMPLEX_COPY_CTOR (t))
2598             && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)
2599             && (!TYPE_HAS_COPY_ASSIGN (t)
2600                 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t))
2601             && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
2602             && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
2603   else
2604     return scalarish_type_p (t);
2605 }
2606
2607 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
2608    [class].  */
2609
2610 bool
2611 trivial_type_p (const_tree t)
2612 {
2613   t = strip_array_types (CONST_CAST_TREE (t));
2614
2615   if (CLASS_TYPE_P (t))
2616     return (TYPE_HAS_TRIVIAL_DFLT (t)
2617             && trivially_copyable_p (t));
2618   else
2619     return scalarish_type_p (t);
2620 }
2621
2622 /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
2623
2624 bool
2625 pod_type_p (const_tree t)
2626 {
2627   /* This CONST_CAST is okay because strip_array_types returns its
2628      argument unmodified and we assign it to a const_tree.  */
2629   t = strip_array_types (CONST_CAST_TREE(t));
2630
2631   if (!CLASS_TYPE_P (t))
2632     return scalarish_type_p (t);
2633   else if (cxx_dialect > cxx98)
2634     /* [class]/10: A POD struct is a class that is both a trivial class and a
2635        standard-layout class, and has no non-static data members of type
2636        non-POD struct, non-POD union (or array of such types).
2637
2638        We don't need to check individual members because if a member is
2639        non-std-layout or non-trivial, the class will be too.  */
2640     return (std_layout_type_p (t) && trivial_type_p (t));
2641   else
2642     /* The C++98 definition of POD is different.  */
2643     return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2644 }
2645
2646 /* Returns true iff T is POD for the purpose of layout, as defined in the
2647    C++ ABI.  */
2648
2649 bool
2650 layout_pod_type_p (const_tree t)
2651 {
2652   t = strip_array_types (CONST_CAST_TREE (t));
2653
2654   if (CLASS_TYPE_P (t))
2655     return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2656   else
2657     return scalarish_type_p (t);
2658 }
2659
2660 /* Returns true iff T is a standard-layout type, as defined in
2661    [basic.types].  */
2662
2663 bool
2664 std_layout_type_p (const_tree t)
2665 {
2666   t = strip_array_types (CONST_CAST_TREE (t));
2667
2668   if (CLASS_TYPE_P (t))
2669     return !CLASSTYPE_NON_STD_LAYOUT (t);
2670   else
2671     return scalarish_type_p (t);
2672 }
2673
2674 /* Nonzero iff type T is a class template implicit specialization.  */
2675
2676 bool
2677 class_tmpl_impl_spec_p (const_tree t)
2678 {
2679   return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
2680 }
2681
2682 /* Returns 1 iff zero initialization of type T means actually storing
2683    zeros in it.  */
2684
2685 int
2686 zero_init_p (const_tree t)
2687 {
2688   /* This CONST_CAST is okay because strip_array_types returns its
2689      argument unmodified and we assign it to a const_tree.  */
2690   t = strip_array_types (CONST_CAST_TREE(t));
2691
2692   if (t == error_mark_node)
2693     return 1;
2694
2695   /* NULL pointers to data members are initialized with -1.  */
2696   if (TYPE_PTRMEM_P (t))
2697     return 0;
2698
2699   /* Classes that contain types that can't be zero-initialized, cannot
2700      be zero-initialized themselves.  */
2701   if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
2702     return 0;
2703
2704   return 1;
2705 }
2706
2707 /* Table of valid C++ attributes.  */
2708 const struct attribute_spec cxx_attribute_table[] =
2709 {
2710   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
2711        affects_type_identity } */
2712   { "java_interface", 0, 0, false, false, false,
2713     handle_java_interface_attribute, false },
2714   { "com_interface",  0, 0, false, false, false,
2715     handle_com_interface_attribute, false },
2716   { "init_priority",  1, 1, true,  false, false,
2717     handle_init_priority_attribute, false },
2718   { NULL,             0, 0, false, false, false, NULL, false }
2719 };
2720
2721 /* Handle a "java_interface" attribute; arguments as in
2722    struct attribute_spec.handler.  */
2723 static tree
2724 handle_java_interface_attribute (tree* node,
2725                                  tree name,
2726                                  tree args ATTRIBUTE_UNUSED ,
2727                                  int flags,
2728                                  bool* no_add_attrs)
2729 {
2730   if (DECL_P (*node)
2731       || !CLASS_TYPE_P (*node)
2732       || !TYPE_FOR_JAVA (*node))
2733     {
2734       error ("%qE attribute can only be applied to Java class definitions",
2735              name);
2736       *no_add_attrs = true;
2737       return NULL_TREE;
2738     }
2739   if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
2740     *node = build_variant_type_copy (*node);
2741   TYPE_JAVA_INTERFACE (*node) = 1;
2742
2743   return NULL_TREE;
2744 }
2745
2746 /* Handle a "com_interface" attribute; arguments as in
2747    struct attribute_spec.handler.  */
2748 static tree
2749 handle_com_interface_attribute (tree* node,
2750                                 tree name,
2751                                 tree args ATTRIBUTE_UNUSED ,
2752                                 int flags ATTRIBUTE_UNUSED ,
2753                                 bool* no_add_attrs)
2754 {
2755   static int warned;
2756
2757   *no_add_attrs = true;
2758
2759   if (DECL_P (*node)
2760       || !CLASS_TYPE_P (*node)
2761       || *node != TYPE_MAIN_VARIANT (*node))
2762     {
2763       warning (OPT_Wattributes, "%qE attribute can only be applied "
2764                "to class definitions", name);
2765       return NULL_TREE;
2766     }
2767
2768   if (!warned++)
2769     warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
2770              name);
2771
2772   return NULL_TREE;
2773 }
2774
2775 /* Handle an "init_priority" attribute; arguments as in
2776    struct attribute_spec.handler.  */
2777 static tree
2778 handle_init_priority_attribute (tree* node,
2779                                 tree name,
2780                                 tree args,
2781                                 int flags ATTRIBUTE_UNUSED ,
2782                                 bool* no_add_attrs)
2783 {
2784   tree initp_expr = TREE_VALUE (args);
2785   tree decl = *node;
2786   tree type = TREE_TYPE (decl);
2787   int pri;
2788
2789   STRIP_NOPS (initp_expr);
2790
2791   if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
2792     {
2793       error ("requested init_priority is not an integer constant");
2794       *no_add_attrs = true;
2795       return NULL_TREE;
2796     }
2797
2798   pri = TREE_INT_CST_LOW (initp_expr);
2799
2800   type = strip_array_types (type);
2801
2802   if (decl == NULL_TREE
2803       || TREE_CODE (decl) != VAR_DECL
2804       || !TREE_STATIC (decl)
2805       || DECL_EXTERNAL (decl)
2806       || (TREE_CODE (type) != RECORD_TYPE
2807           && TREE_CODE (type) != UNION_TYPE)
2808       /* Static objects in functions are initialized the
2809          first time control passes through that
2810          function. This is not precise enough to pin down an
2811          init_priority value, so don't allow it.  */
2812       || current_function_decl)
2813     {
2814       error ("can only use %qE attribute on file-scope definitions "
2815              "of objects of class type", name);
2816       *no_add_attrs = true;
2817       return NULL_TREE;
2818     }
2819
2820   if (pri > MAX_INIT_PRIORITY || pri <= 0)
2821     {
2822       error ("requested init_priority is out of range");
2823       *no_add_attrs = true;
2824       return NULL_TREE;
2825     }
2826
2827   /* Check for init_priorities that are reserved for
2828      language and runtime support implementations.*/
2829   if (pri <= MAX_RESERVED_INIT_PRIORITY)
2830     {
2831       warning
2832         (0, "requested init_priority is reserved for internal use");
2833     }
2834
2835   if (SUPPORTS_INIT_PRIORITY)
2836     {
2837       SET_DECL_INIT_PRIORITY (decl, pri);
2838       DECL_HAS_INIT_PRIORITY_P (decl) = 1;
2839       return NULL_TREE;
2840     }
2841   else
2842     {
2843       error ("%qE attribute is not supported on this platform", name);
2844       *no_add_attrs = true;
2845       return NULL_TREE;
2846     }
2847 }
2848
2849 /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
2850    thing pointed to by the constant.  */
2851
2852 tree
2853 make_ptrmem_cst (tree type, tree member)
2854 {
2855   tree ptrmem_cst = make_node (PTRMEM_CST);
2856   TREE_TYPE (ptrmem_cst) = type;
2857   PTRMEM_CST_MEMBER (ptrmem_cst) = member;
2858   return ptrmem_cst;
2859 }
2860
2861 /* Build a variant of TYPE that has the indicated ATTRIBUTES.  May
2862    return an existing type if an appropriate type already exists.  */
2863
2864 tree
2865 cp_build_type_attribute_variant (tree type, tree attributes)
2866 {
2867   tree new_type;
2868
2869   new_type = build_type_attribute_variant (type, attributes);
2870   if (TREE_CODE (new_type) == FUNCTION_TYPE
2871       || TREE_CODE (new_type) == METHOD_TYPE)
2872     new_type = build_exception_variant (new_type,
2873                                         TYPE_RAISES_EXCEPTIONS (type));
2874
2875   /* Making a new main variant of a class type is broken.  */
2876   gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
2877
2878   return new_type;
2879 }
2880
2881 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
2882    Called only after doing all language independent checks.  Only
2883    to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
2884    compared in type_hash_eq.  */
2885
2886 bool
2887 cxx_type_hash_eq (const_tree typea, const_tree typeb)
2888 {
2889   gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE
2890               || TREE_CODE (typea) == METHOD_TYPE);
2891
2892   return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
2893                             TYPE_RAISES_EXCEPTIONS (typeb), ce_exact);
2894 }
2895
2896 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
2897    traversal.  Called from walk_tree.  */
2898
2899 tree
2900 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
2901                   void *data, struct pointer_set_t *pset)
2902 {
2903   enum tree_code code = TREE_CODE (*tp);
2904   tree result;
2905
2906 #define WALK_SUBTREE(NODE)                              \
2907   do                                                    \
2908     {                                                   \
2909       result = cp_walk_tree (&(NODE), func, data, pset);        \
2910       if (result) goto out;                             \
2911     }                                                   \
2912   while (0)
2913
2914   /* Not one of the easy cases.  We must explicitly go through the
2915      children.  */
2916   result = NULL_TREE;
2917   switch (code)
2918     {
2919     case DEFAULT_ARG:
2920     case TEMPLATE_TEMPLATE_PARM:
2921     case BOUND_TEMPLATE_TEMPLATE_PARM:
2922     case UNBOUND_CLASS_TEMPLATE:
2923     case TEMPLATE_PARM_INDEX:
2924     case TEMPLATE_TYPE_PARM:
2925     case TYPENAME_TYPE:
2926     case TYPEOF_TYPE:
2927     case UNDERLYING_TYPE:
2928       /* None of these have subtrees other than those already walked
2929          above.  */
2930       *walk_subtrees_p = 0;
2931       break;
2932
2933     case BASELINK:
2934       WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
2935       *walk_subtrees_p = 0;
2936       break;
2937
2938     case PTRMEM_CST:
2939       WALK_SUBTREE (TREE_TYPE (*tp));
2940       *walk_subtrees_p = 0;
2941       break;
2942
2943     case TREE_LIST:
2944       WALK_SUBTREE (TREE_PURPOSE (*tp));
2945       break;
2946
2947     case OVERLOAD:
2948       WALK_SUBTREE (OVL_FUNCTION (*tp));
2949       WALK_SUBTREE (OVL_CHAIN (*tp));
2950       *walk_subtrees_p = 0;
2951       break;
2952
2953     case USING_DECL:
2954       WALK_SUBTREE (DECL_NAME (*tp));
2955       WALK_SUBTREE (USING_DECL_SCOPE (*tp));
2956       WALK_SUBTREE (USING_DECL_DECLS (*tp));
2957       *walk_subtrees_p = 0;
2958       break;
2959
2960     case RECORD_TYPE:
2961       if (TYPE_PTRMEMFUNC_P (*tp))
2962         WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
2963       break;
2964
2965     case TYPE_ARGUMENT_PACK:
2966     case NONTYPE_ARGUMENT_PACK:
2967       {
2968         tree args = ARGUMENT_PACK_ARGS (*tp);
2969         int i, len = TREE_VEC_LENGTH (args);
2970         for (i = 0; i < len; i++)
2971           WALK_SUBTREE (TREE_VEC_ELT (args, i));
2972       }
2973       break;
2974
2975     case TYPE_PACK_EXPANSION:
2976       WALK_SUBTREE (TREE_TYPE (*tp));
2977       *walk_subtrees_p = 0;
2978       break;
2979
2980     case EXPR_PACK_EXPANSION:
2981       WALK_SUBTREE (TREE_OPERAND (*tp, 0));
2982       *walk_subtrees_p = 0;
2983       break;
2984
2985     case CAST_EXPR:
2986     case REINTERPRET_CAST_EXPR:
2987     case STATIC_CAST_EXPR:
2988     case CONST_CAST_EXPR:
2989     case DYNAMIC_CAST_EXPR:
2990       if (TREE_TYPE (*tp))
2991         WALK_SUBTREE (TREE_TYPE (*tp));
2992
2993       {
2994         int i;
2995         for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
2996           WALK_SUBTREE (TREE_OPERAND (*tp, i));
2997       }
2998       *walk_subtrees_p = 0;
2999       break;
3000
3001     case TRAIT_EXPR:
3002       WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
3003       WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
3004       *walk_subtrees_p = 0;
3005       break;
3006
3007     case DECLTYPE_TYPE:
3008       WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
3009       *walk_subtrees_p = 0;
3010       break;
3011
3012
3013     default:
3014       return NULL_TREE;
3015     }
3016
3017   /* We didn't find what we were looking for.  */
3018  out:
3019   return result;
3020
3021 #undef WALK_SUBTREE
3022 }
3023
3024 /* Like save_expr, but for C++.  */
3025
3026 tree
3027 cp_save_expr (tree expr)
3028 {
3029   /* There is no reason to create a SAVE_EXPR within a template; if
3030      needed, we can create the SAVE_EXPR when instantiating the
3031      template.  Furthermore, the middle-end cannot handle C++-specific
3032      tree codes.  */
3033   if (processing_template_decl)
3034     return expr;
3035   return save_expr (expr);
3036 }
3037
3038 /* Initialize tree.c.  */
3039
3040 void
3041 init_tree (void)
3042 {
3043   list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
3044 }
3045
3046 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
3047    is.  Note that sfk_none is zero, so this function can be used as a
3048    predicate to test whether or not DECL is a special function.  */
3049
3050 special_function_kind
3051 special_function_p (const_tree decl)
3052 {
3053   /* Rather than doing all this stuff with magic names, we should
3054      probably have a field of type `special_function_kind' in
3055      DECL_LANG_SPECIFIC.  */
3056   if (DECL_COPY_CONSTRUCTOR_P (decl))
3057     return sfk_copy_constructor;
3058   if (DECL_MOVE_CONSTRUCTOR_P (decl))
3059     return sfk_move_constructor;
3060   if (DECL_CONSTRUCTOR_P (decl))
3061     return sfk_constructor;
3062   if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
3063     {
3064       if (copy_fn_p (decl))
3065         return sfk_copy_assignment;
3066       if (move_fn_p (decl))
3067         return sfk_move_assignment;
3068     }
3069   if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
3070     return sfk_destructor;
3071   if (DECL_COMPLETE_DESTRUCTOR_P (decl))
3072     return sfk_complete_destructor;
3073   if (DECL_BASE_DESTRUCTOR_P (decl))
3074     return sfk_base_destructor;
3075   if (DECL_DELETING_DESTRUCTOR_P (decl))
3076     return sfk_deleting_destructor;
3077   if (DECL_CONV_FN_P (decl))
3078     return sfk_conversion;
3079
3080   return sfk_none;
3081 }
3082
3083 /* Returns nonzero if TYPE is a character type, including wchar_t.  */
3084
3085 int
3086 char_type_p (tree type)
3087 {
3088   return (same_type_p (type, char_type_node)
3089           || same_type_p (type, unsigned_char_type_node)
3090           || same_type_p (type, signed_char_type_node)
3091           || same_type_p (type, char16_type_node)
3092           || same_type_p (type, char32_type_node)
3093           || same_type_p (type, wchar_type_node));
3094 }
3095
3096 /* Returns the kind of linkage associated with the indicated DECL.  Th
3097    value returned is as specified by the language standard; it is
3098    independent of implementation details regarding template
3099    instantiation, etc.  For example, it is possible that a declaration
3100    to which this function assigns external linkage would not show up
3101    as a global symbol when you run `nm' on the resulting object file.  */
3102
3103 linkage_kind
3104 decl_linkage (tree decl)
3105 {
3106   /* This function doesn't attempt to calculate the linkage from first
3107      principles as given in [basic.link].  Instead, it makes use of
3108      the fact that we have already set TREE_PUBLIC appropriately, and
3109      then handles a few special cases.  Ideally, we would calculate
3110      linkage first, and then transform that into a concrete
3111      implementation.  */
3112
3113   /* Things that don't have names have no linkage.  */
3114   if (!DECL_NAME (decl))
3115     return lk_none;
3116
3117   /* Fields have no linkage.  */
3118   if (TREE_CODE (decl) == FIELD_DECL)
3119     return lk_none;
3120
3121   /* Things that are TREE_PUBLIC have external linkage.  */
3122   if (TREE_PUBLIC (decl))
3123     return lk_external;
3124
3125   if (TREE_CODE (decl) == NAMESPACE_DECL)
3126     return lk_external;
3127
3128   /* Linkage of a CONST_DECL depends on the linkage of the enumeration
3129      type.  */
3130   if (TREE_CODE (decl) == CONST_DECL)
3131     return decl_linkage (TYPE_NAME (TREE_TYPE (decl)));
3132
3133   /* Some things that are not TREE_PUBLIC have external linkage, too.
3134      For example, on targets that don't have weak symbols, we make all
3135      template instantiations have internal linkage (in the object
3136      file), but the symbols should still be treated as having external
3137      linkage from the point of view of the language.  */
3138   if ((TREE_CODE (decl) == FUNCTION_DECL
3139        || TREE_CODE (decl) == VAR_DECL)
3140       && DECL_COMDAT (decl))
3141     return lk_external;
3142
3143   /* Things in local scope do not have linkage, if they don't have
3144      TREE_PUBLIC set.  */
3145   if (decl_function_context (decl))
3146     return lk_none;
3147
3148   /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
3149      are considered to have external linkage for language purposes.  DECLs
3150      really meant to have internal linkage have DECL_THIS_STATIC set.  */
3151   if (TREE_CODE (decl) == TYPE_DECL)
3152     return lk_external;
3153   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3154     {
3155       if (!DECL_THIS_STATIC (decl))
3156         return lk_external;
3157
3158       /* Static data members and static member functions from classes
3159          in anonymous namespace also don't have TREE_PUBLIC set.  */
3160       if (DECL_CLASS_CONTEXT (decl))
3161         return lk_external;
3162     }
3163
3164   /* Everything else has internal linkage.  */
3165   return lk_internal;
3166 }
3167
3168 /* Returns the storage duration of the object or reference associated with
3169    the indicated DECL, which should be a VAR_DECL or PARM_DECL.  */
3170
3171 duration_kind
3172 decl_storage_duration (tree decl)
3173 {
3174   if (TREE_CODE (decl) == PARM_DECL)
3175     return dk_auto;
3176   if (TREE_CODE (decl) == FUNCTION_DECL)
3177     return dk_static;
3178   gcc_assert (TREE_CODE (decl) == VAR_DECL);
3179   if (!TREE_STATIC (decl)
3180       && !DECL_EXTERNAL (decl))
3181     return dk_auto;
3182   if (DECL_THREAD_LOCAL_P (decl))
3183     return dk_thread;
3184   return dk_static;
3185 }
3186 \f
3187 /* EXP is an expression that we want to pre-evaluate.  Returns (in
3188    *INITP) an expression that will perform the pre-evaluation.  The
3189    value returned by this function is a side-effect free expression
3190    equivalent to the pre-evaluated expression.  Callers must ensure
3191    that *INITP is evaluated before EXP.  */
3192
3193 tree
3194 stabilize_expr (tree exp, tree* initp)
3195 {
3196   tree init_expr;
3197
3198   if (!TREE_SIDE_EFFECTS (exp))
3199     init_expr = NULL_TREE;
3200   /* There are no expressions with REFERENCE_TYPE, but there can be call
3201      arguments with such a type; just treat it as a pointer.  */
3202   else if (TREE_CODE (TREE_TYPE (exp)) == REFERENCE_TYPE
3203            || SCALAR_TYPE_P (TREE_TYPE (exp))
3204            || !lvalue_or_rvalue_with_address_p (exp))
3205     {
3206       init_expr = get_target_expr (exp);
3207       exp = TARGET_EXPR_SLOT (init_expr);
3208     }
3209   else
3210     {
3211       bool xval = !real_lvalue_p (exp);
3212       exp = cp_build_addr_expr (exp, tf_warning_or_error);
3213       init_expr = get_target_expr (exp);
3214       exp = TARGET_EXPR_SLOT (init_expr);
3215       exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
3216       if (xval)
3217         exp = move (exp);
3218     }
3219   *initp = init_expr;
3220
3221   gcc_assert (!TREE_SIDE_EFFECTS (exp));
3222   return exp;
3223 }
3224
3225 /* Add NEW_EXPR, an expression whose value we don't care about, after the
3226    similar expression ORIG.  */
3227
3228 tree
3229 add_stmt_to_compound (tree orig, tree new_expr)
3230 {
3231   if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
3232     return orig;
3233   if (!orig || !TREE_SIDE_EFFECTS (orig))
3234     return new_expr;
3235   return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
3236 }
3237
3238 /* Like stabilize_expr, but for a call whose arguments we want to
3239    pre-evaluate.  CALL is modified in place to use the pre-evaluated
3240    arguments, while, upon return, *INITP contains an expression to
3241    compute the arguments.  */
3242
3243 void
3244 stabilize_call (tree call, tree *initp)
3245 {
3246   tree inits = NULL_TREE;
3247   int i;
3248   int nargs = call_expr_nargs (call);
3249
3250   if (call == error_mark_node || processing_template_decl)
3251     {
3252       *initp = NULL_TREE;
3253       return;
3254     }
3255
3256   gcc_assert (TREE_CODE (call) == CALL_EXPR);
3257
3258   for (i = 0; i < nargs; i++)
3259     {
3260       tree init;
3261       CALL_EXPR_ARG (call, i) =
3262         stabilize_expr (CALL_EXPR_ARG (call, i), &init);
3263       inits = add_stmt_to_compound (inits, init);
3264     }
3265
3266   *initp = inits;
3267 }
3268
3269 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
3270    to pre-evaluate.  CALL is modified in place to use the pre-evaluated
3271    arguments, while, upon return, *INITP contains an expression to
3272    compute the arguments.  */
3273
3274 void
3275 stabilize_aggr_init (tree call, tree *initp)
3276 {
3277   tree inits = NULL_TREE;
3278   int i;
3279   int nargs = aggr_init_expr_nargs (call);
3280
3281   if (call == error_mark_node)
3282     return;
3283
3284   gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
3285
3286   for (i = 0; i < nargs; i++)
3287     {
3288       tree init;
3289       AGGR_INIT_EXPR_ARG (call, i) =
3290         stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
3291       inits = add_stmt_to_compound (inits, init);
3292     }
3293
3294   *initp = inits;
3295 }
3296
3297 /* Like stabilize_expr, but for an initialization.
3298
3299    If the initialization is for an object of class type, this function
3300    takes care not to introduce additional temporaries.
3301
3302    Returns TRUE iff the expression was successfully pre-evaluated,
3303    i.e., if INIT is now side-effect free, except for, possible, a
3304    single call to a constructor.  */
3305
3306 bool
3307 stabilize_init (tree init, tree *initp)
3308 {
3309   tree t = init;
3310
3311   *initp = NULL_TREE;
3312
3313   if (t == error_mark_node || processing_template_decl)
3314     return true;
3315
3316   if (TREE_CODE (t) == INIT_EXPR
3317       && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR
3318       && TREE_CODE (TREE_OPERAND (t, 1)) != AGGR_INIT_EXPR)
3319     {
3320       TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
3321       return true;
3322     }
3323
3324   if (TREE_CODE (t) == INIT_EXPR)
3325     t = TREE_OPERAND (t, 1);
3326   if (TREE_CODE (t) == TARGET_EXPR)
3327     t = TARGET_EXPR_INITIAL (t);
3328   if (TREE_CODE (t) == COMPOUND_EXPR)
3329     t = expr_last (t);
3330   if (TREE_CODE (t) == CONSTRUCTOR)
3331     {
3332       /* Aggregate initialization: stabilize each of the field
3333          initializers.  */
3334       unsigned i;
3335       tree value;
3336       bool good = true;
3337       FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t), i, value)
3338         if (!stabilize_init (value, initp))
3339           good = false;
3340       return good;
3341     }
3342
3343   /* If the initializer is a COND_EXPR, we can't preevaluate
3344      anything.  */
3345   if (TREE_CODE (t) == COND_EXPR)
3346     return false;
3347
3348   if (TREE_CODE (t) == CALL_EXPR)
3349     {
3350       stabilize_call (t, initp);
3351       return true;
3352     }
3353
3354   if (TREE_CODE (t) == AGGR_INIT_EXPR)
3355     {
3356       stabilize_aggr_init (t, initp);
3357       return true;
3358     }
3359
3360   /* The initialization is being performed via a bitwise copy -- and
3361      the item copied may have side effects.  */
3362   return TREE_SIDE_EFFECTS (init);
3363 }
3364
3365 /* Like "fold", but should be used whenever we might be processing the
3366    body of a template.  */
3367
3368 tree
3369 fold_if_not_in_template (tree expr)
3370 {
3371   /* In the body of a template, there is never any need to call
3372      "fold".  We will call fold later when actually instantiating the
3373      template.  Integral constant expressions in templates will be
3374      evaluated via fold_non_dependent_expr, as necessary.  */
3375   if (processing_template_decl)
3376     return expr;
3377
3378   /* Fold C++ front-end specific tree codes.  */
3379   if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
3380     return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
3381
3382   return fold (expr);
3383 }
3384
3385 /* Returns true if a cast to TYPE may appear in an integral constant
3386    expression.  */
3387
3388 bool
3389 cast_valid_in_integral_constant_expression_p (tree type)
3390 {
3391   return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
3392           || cxx_dialect >= cxx0x
3393           || dependent_type_p (type)
3394           || type == error_mark_node);
3395 }
3396
3397 /* Return true if we need to fix linkage information of DECL.  */
3398
3399 static bool
3400 cp_fix_function_decl_p (tree decl)
3401 {
3402   /* Skip if DECL is not externally visible.  */
3403   if (!TREE_PUBLIC (decl))
3404     return false;
3405
3406   /* We need to fix DECL if it a appears to be exported but with no
3407      function body.  Thunks do not have CFGs and we may need to
3408      handle them specially later.   */
3409   if (!gimple_has_body_p (decl)
3410       && !DECL_THUNK_P (decl)
3411       && !DECL_EXTERNAL (decl))
3412     {
3413       struct cgraph_node *node = cgraph_get_node (decl);
3414
3415       /* Don't fix same_body aliases.  Although they don't have their own
3416          CFG, they share it with what they alias to.  */
3417       if (!node || !node->alias
3418           || !VEC_length (ipa_ref_t, node->ref_list.references))
3419         return true;
3420     }
3421
3422   return false;
3423 }
3424
3425 /* Clean the C++ specific parts of the tree T. */
3426
3427 void
3428 cp_free_lang_data (tree t)
3429 {
3430   if (TREE_CODE (t) == METHOD_TYPE
3431       || TREE_CODE (t) == FUNCTION_TYPE)
3432     {
3433       /* Default args are not interesting anymore.  */
3434       tree argtypes = TYPE_ARG_TYPES (t);
3435       while (argtypes)
3436         {
3437           TREE_PURPOSE (argtypes) = 0;
3438           argtypes = TREE_CHAIN (argtypes);
3439         }
3440     }
3441   else if (TREE_CODE (t) == FUNCTION_DECL
3442            && cp_fix_function_decl_p (t))
3443     {
3444       /* If T is used in this translation unit at all,  the definition
3445          must exist somewhere else since we have decided to not emit it
3446          in this TU.  So make it an external reference.  */
3447       DECL_EXTERNAL (t) = 1;
3448       TREE_STATIC (t) = 0;
3449     }
3450   if (CP_AGGREGATE_TYPE_P (t)
3451       && TYPE_NAME (t))
3452     {
3453       tree name = TYPE_NAME (t);
3454       if (TREE_CODE (name) == TYPE_DECL)
3455         name = DECL_NAME (name);
3456       /* Drop anonymous names.  */
3457       if (name != NULL_TREE
3458           && ANON_AGGRNAME_P (name))
3459         TYPE_NAME (t) = NULL_TREE;
3460     }
3461   if (TREE_CODE (t) == NAMESPACE_DECL)
3462     {
3463       /* The list of users of a namespace isn't useful for the middle-end
3464          or debug generators.  */
3465       DECL_NAMESPACE_USERS (t) = NULL_TREE;
3466       /* Neither do we need the leftover chaining of namespaces
3467          from the binding level.  */
3468       DECL_CHAIN (t) = NULL_TREE;
3469     }
3470 }
3471
3472 /* Stub for c-common.  Please keep in sync with c-decl.c.
3473    FIXME: If address space support is target specific, then this
3474    should be a C target hook.  But currently this is not possible,
3475    because this function is called via REGISTER_TARGET_PRAGMAS.  */
3476 void
3477 c_register_addr_space (const char *word ATTRIBUTE_UNUSED,
3478                        addr_space_t as ATTRIBUTE_UNUSED)
3479 {
3480 }
3481
3482 /* Return the number of operands in T that we care about for things like
3483    mangling.  */
3484
3485 int
3486 cp_tree_operand_length (const_tree t)
3487 {
3488   enum tree_code code = TREE_CODE (t);
3489
3490   switch (code)
3491     {
3492     case PREINCREMENT_EXPR:
3493     case PREDECREMENT_EXPR:
3494     case POSTINCREMENT_EXPR:
3495     case POSTDECREMENT_EXPR:
3496       return 1;
3497
3498     case ARRAY_REF:
3499       return 2;
3500
3501     case EXPR_PACK_EXPANSION:
3502       return 1;
3503
3504     default:
3505       return TREE_OPERAND_LENGTH (t);
3506     }
3507 }
3508 \f
3509 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3510 /* Complain that some language-specific thing hanging off a tree
3511    node has been accessed improperly.  */
3512
3513 void
3514 lang_check_failed (const char* file, int line, const char* function)
3515 {
3516   internal_error ("lang_* check: failed in %s, at %s:%d",
3517                   function, trim_filename (file), line);
3518 }
3519 #endif /* ENABLE_TREE_CHECKING */
3520
3521 #include "gt-cp-tree.h"