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