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