gcc/cp/typeck2.c

   1 /* Report error messages, build initializers, and perform
   2    some front-end optimizations for C++ compiler.
   3    Copyright (C) 1987-2018 Free Software Foundation, Inc.
   4    Hacked by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22
  23 /* This file is part of the C++ front end.
  24    It contains routines to build C++ expressions given their operands,
  25    including computing the types of the result, C and C++ specific error
  26    checks, and some optimization.  */
  27
  28 #include "config.h"
  29 #include "system.h"
  30 #include "coretypes.h"
  31 #include "cp-tree.h"
  32 #include "stor-layout.h"
  33 #include "varasm.h"
  34 #include "intl.h"
  35
  36 static tree
  37 process_init_constructor (tree type, tree init, int nested,
  38                           tsubst_flags_t complain);
  39
  40
  41 /* Print an error message stemming from an attempt to use
  42    BASETYPE as a base class for TYPE.  */
  43
  44 tree
  45 error_not_base_type (tree basetype, tree type)
  46 {
  47   if (TREE_CODE (basetype) == FUNCTION_DECL)
  48     basetype = DECL_CONTEXT (basetype);
  49   error ("type %qT is not a base type for type %qT", basetype, type);
  50   return error_mark_node;
  51 }
  52
  53 tree
  54 binfo_or_else (tree base, tree type)
  55 {
  56   tree binfo = lookup_base (type, base, ba_unique,
  57                             NULL, tf_warning_or_error);
  58
  59   if (binfo == error_mark_node)
  60     return NULL_TREE;
  61   else if (!binfo)
  62     error_not_base_type (base, type);
  63   return binfo;
  64 }
  65
  66 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
  67    value may not be changed thereafter.  */
  68
  69 void
  70 cxx_readonly_error (tree arg, enum lvalue_use errstring)
  71 {
  72
  73 /* This macro is used to emit diagnostics to ensure that all format
  74    strings are complete sentences, visible to gettext and checked at
  75    compile time.  */
  76
  77 #define ERROR_FOR_ASSIGNMENT(AS, ASM, IN, DE, ARG)                      \
  78   do {                                                                  \
  79     switch (errstring)                                                  \
  80       {                                                                 \
  81       case lv_assign:                                                   \
  82         error(AS, ARG);                                                 \
  83         break;                                                          \
  84       case lv_asm:                                                      \
  85         error(ASM, ARG);                                                \
  86         break;                                                          \
  87       case lv_increment:                                                \
  88         error (IN, ARG);                                                \
  89         break;                                                          \
  90       case lv_decrement:                                               \
  91         error (DE, ARG);                                                \
  92         break;                                                          \
  93       default:                                                          \
  94         gcc_unreachable ();                                             \
  95       }                                                                 \
  96   } while (0)
  97
  98   /* Handle C++-specific things first.  */
  99
 100   if (VAR_P (arg)
 101       && DECL_LANG_SPECIFIC (arg)
 102       && DECL_IN_AGGR_P (arg)
 103       && !TREE_STATIC (arg))
 104     ERROR_FOR_ASSIGNMENT (G_("assignment of "
 105                              "constant field %qD"),
 106                           G_("constant field %qD "
 107                              "used as %<asm%> output"),
 108                           G_("increment of "
 109                              "constant field %qD"),
 110                           G_("decrement of "
 111                              "constant field %qD"),
 112                           arg);
 113   else if (INDIRECT_REF_P (arg)
 114            && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
 115            && (VAR_P (TREE_OPERAND (arg, 0))
 116                || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
 117     ERROR_FOR_ASSIGNMENT (G_("assignment of "
 118                              "read-only reference %qD"),
 119                           G_("read-only reference %qD "
 120                              "used as %<asm%> output"),
 121                           G_("increment of "
 122                              "read-only reference %qD"),
 123                           G_("decrement of "
 124                              "read-only reference %qD"),
 125                           TREE_OPERAND (arg, 0));
 126   else
 127     readonly_error (input_location, arg, errstring);
 128 }
 129
 130 \f
 131 /* Structure that holds information about declarations whose type was
 132    incomplete and we could not check whether it was abstract or not.  */
 133
 134 struct GTY((chain_next ("%h.next"), for_user)) pending_abstract_type {
 135   /* Declaration which we are checking for abstractness. It is either
 136      a DECL node, or an IDENTIFIER_NODE if we do not have a full
 137      declaration available.  */
 138   tree decl;
 139
 140   /* Type which will be checked for abstractness.  */
 141   tree type;
 142
 143   /* Kind of use in an unnamed declarator.  */
 144   enum abstract_class_use use;
 145
 146   /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
 147      because DECLs already carry locus information.  */
 148   location_t locus;
 149
 150   /* Link to the next element in list.  */
 151   struct pending_abstract_type* next;
 152 };
 153
 154 struct abstract_type_hasher : ggc_ptr_hash<pending_abstract_type>
 155 {
 156   typedef tree compare_type;
 157   static hashval_t hash (pending_abstract_type *);
 158   static bool equal (pending_abstract_type *, tree);
 159 };
 160
 161 /* Compute the hash value of the node VAL. This function is used by the
 162    hash table abstract_pending_vars.  */
 163
 164 hashval_t
 165 abstract_type_hasher::hash (pending_abstract_type *pat)
 166 {
 167   return (hashval_t) TYPE_UID (pat->type);
 168 }
 169
 170
 171 /* Compare node VAL1 with the type VAL2. This function is used by the
 172    hash table abstract_pending_vars.  */
 173
 174 bool
 175 abstract_type_hasher::equal (pending_abstract_type *pat1, tree type2)
 176 {
 177   return (pat1->type == type2);
 178 }
 179
 180 /* Hash table that maintains pending_abstract_type nodes, for which we still
 181    need to check for type abstractness.  The key of the table is the type
 182    of the declaration.  */
 183 static GTY (()) hash_table<abstract_type_hasher> *abstract_pending_vars = NULL;
 184
 185 static int abstract_virtuals_error_sfinae (tree, tree, abstract_class_use, tsubst_flags_t);
 186
 187 /* This function is called after TYPE is completed, and will check if there
 188    are pending declarations for which we still need to verify the abstractness
 189    of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
 190    turned out to be incomplete.  */
 191
 192 void
 193 complete_type_check_abstract (tree type)
 194 {
 195   struct pending_abstract_type *pat;
 196   location_t cur_loc = input_location;
 197
 198   gcc_assert (COMPLETE_TYPE_P (type));
 199
 200   if (!abstract_pending_vars)
 201     return;
 202
 203   /* Retrieve the list of pending declarations for this type.  */
 204   pending_abstract_type **slot
 205     = abstract_pending_vars->find_slot_with_hash (type, TYPE_UID (type),
 206                                                   NO_INSERT);
 207   if (!slot)
 208     return;
 209   pat = *slot;
 210   gcc_assert (pat);
 211
 212   /* If the type is not abstract, do not do anything.  */
 213   if (CLASSTYPE_PURE_VIRTUALS (type))
 214     {
 215       struct pending_abstract_type *prev = 0, *next;
 216
 217       /* Reverse the list to emit the errors in top-down order.  */
 218       for (; pat; pat = next)
 219         {
 220           next = pat->next;
 221           pat->next = prev;
 222           prev = pat;
 223         }
 224       pat = prev;
 225
 226       /* Go through the list, and call abstract_virtuals_error for each
 227         element: it will issue a diagnostic if the type is abstract.  */
 228       while (pat)
 229         {
 230           gcc_assert (type == pat->type);
 231
 232           /* Tweak input_location so that the diagnostic appears at the correct
 233             location. Notice that this is only needed if the decl is an
 234             IDENTIFIER_NODE.  */
 235           input_location = pat->locus;
 236           abstract_virtuals_error_sfinae (pat->decl, pat->type, pat->use,
 237                                           tf_warning_or_error);
 238           pat = pat->next;
 239         }
 240     }
 241
 242   abstract_pending_vars->clear_slot (slot);
 243
 244   input_location = cur_loc;
 245 }
 246
 247
 248 /* If TYPE has abstract virtual functions, issue an error about trying
 249    to create an object of that type.  DECL is the object declared, or
 250    NULL_TREE if the declaration is unavailable, in which case USE specifies
 251    the kind of invalid use.  Returns 1 if an error occurred; zero if
 252    all was well.  */
 253
 254 static int
 255 abstract_virtuals_error_sfinae (tree decl, tree type, abstract_class_use use,
 256                                 tsubst_flags_t complain)
 257 {
 258   vec<tree, va_gc> *pure;
 259
 260   /* This function applies only to classes. Any other entity can never
 261      be abstract.  */
 262   if (!CLASS_TYPE_P (type))
 263     return 0;
 264   type = TYPE_MAIN_VARIANT (type);
 265
 266 #if 0
 267   /* Instantiation here seems to be required by the standard,
 268      but breaks e.g. boost::bind.  FIXME!  */
 269   /* In SFINAE, non-N3276 context, force instantiation.  */
 270   if (!(complain & (tf_error|tf_decltype)))
 271     complete_type (type);
 272 #endif
 273
 274   /* If the type is incomplete, we register it within a hash table,
 275      so that we can check again once it is completed. This makes sense
 276      only for objects for which we have a declaration or at least a
 277      name.  */
 278   if (!COMPLETE_TYPE_P (type) && (complain & tf_error))
 279     {
 280       struct pending_abstract_type *pat;
 281
 282       gcc_assert (!decl || DECL_P (decl) || identifier_p (decl));
 283
 284       if (!abstract_pending_vars)
 285         abstract_pending_vars
 286           = hash_table<abstract_type_hasher>::create_ggc (31);
 287
 288       pending_abstract_type **slot
 289         = abstract_pending_vars->find_slot_with_hash (type, TYPE_UID (type),
 290                                                       INSERT);
 291
 292       pat = ggc_alloc<pending_abstract_type> ();
 293       pat->type = type;
 294       pat->decl = decl;
 295       pat->use = use;
 296       pat->locus = ((decl && DECL_P (decl))
 297                     ? DECL_SOURCE_LOCATION (decl)
 298                     : input_location);
 299
 300       pat->next = *slot;
 301       *slot = pat;
 302
 303       return 0;
 304     }
 305
 306   if (!TYPE_SIZE (type))
 307     /* TYPE is being defined, and during that time
 308        CLASSTYPE_PURE_VIRTUALS holds the inline friends.  */
 309     return 0;
 310
 311   pure = CLASSTYPE_PURE_VIRTUALS (type);
 312   if (!pure)
 313     return 0;
 314
 315   if (!(complain & tf_error))
 316     return 1;
 317
 318   if (decl)
 319     {
 320       if (VAR_P (decl))
 321         error ("cannot declare variable %q+D to be of abstract "
 322                "type %qT", decl, type);
 323       else if (TREE_CODE (decl) == PARM_DECL)
 324         {
 325           if (DECL_NAME (decl))
 326             error ("cannot declare parameter %q+D to be of abstract type %qT",
 327                    decl, type);
 328           else
 329             error ("cannot declare parameter to be of abstract type %qT",
 330                    type);
 331         }
 332       else if (TREE_CODE (decl) == FIELD_DECL)
 333         error ("cannot declare field %q+D to be of abstract type %qT",
 334                decl, type);
 335       else if (TREE_CODE (decl) == FUNCTION_DECL
 336                && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
 337         error ("invalid abstract return type for member function %q+#D", decl);
 338       else if (TREE_CODE (decl) == FUNCTION_DECL)
 339         error ("invalid abstract return type for function %q+#D", decl);
 340       else if (identifier_p (decl))
 341         /* Here we do not have location information.  */
 342         error ("invalid abstract type %qT for %qE", type, decl);
 343       else
 344         error ("invalid abstract type for %q+D", decl);
 345     }
 346   else switch (use)
 347     {
 348     case ACU_ARRAY:
 349       error ("creating array of %qT, which is an abstract class type", type);
 350       break;
 351     case ACU_CAST:
 352       error ("invalid cast to abstract class type %qT", type);
 353       break;
 354     case ACU_NEW:
 355       error ("invalid new-expression of abstract class type %qT", type);
 356       break;
 357     case ACU_RETURN:
 358       error ("invalid abstract return type %qT", type);
 359       break;
 360     case ACU_PARM:
 361       error ("invalid abstract parameter type %qT", type);
 362       break;
 363     case ACU_THROW:
 364       error ("expression of abstract class type %qT cannot "
 365              "be used in throw-expression", type);
 366       break;
 367     case ACU_CATCH:
 368       error ("cannot declare catch parameter to be of abstract "
 369              "class type %qT", type);
 370       break;
 371     default:
 372       error ("cannot allocate an object of abstract type %qT", type);
 373     }
 374
 375   /* Only go through this once.  */
 376   if (pure->length ())
 377     {
 378       unsigned ix;
 379       tree fn;
 380
 381       inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
 382               "  because the following virtual functions are pure within %qT:",
 383               type);
 384
 385       FOR_EACH_VEC_ELT (*pure, ix, fn)
 386         if (! DECL_CLONED_FUNCTION_P (fn)
 387             || DECL_COMPLETE_DESTRUCTOR_P (fn))
 388           inform (DECL_SOURCE_LOCATION (fn), "\t%#qD", fn);
 389
 390       /* Now truncate the vector.  This leaves it non-null, so we know
 391          there are pure virtuals, but empty so we don't list them out
 392          again.  */
 393       pure->truncate (0);
 394     }
 395
 396   return 1;
 397 }
 398
 399 int
 400 abstract_virtuals_error_sfinae (tree decl, tree type, tsubst_flags_t complain)
 401 {
 402   return abstract_virtuals_error_sfinae (decl, type, ACU_UNKNOWN, complain);
 403 }
 404
 405 int
 406 abstract_virtuals_error_sfinae (abstract_class_use use, tree type,
 407                                 tsubst_flags_t complain)
 408 {
 409   return abstract_virtuals_error_sfinae (NULL_TREE, type, use, complain);
 410 }
 411
 412
 413 /* Wrapper for the above function in the common case of wanting errors.  */
 414
 415 int
 416 abstract_virtuals_error (tree decl, tree type)
 417 {
 418   return abstract_virtuals_error_sfinae (decl, type, tf_warning_or_error);
 419 }
 420
 421 int
 422 abstract_virtuals_error (abstract_class_use use, tree type)
 423 {
 424   return abstract_virtuals_error_sfinae (use, type, tf_warning_or_error);
 425 }
 426
 427 /* Print an inform about the declaration of the incomplete type TYPE.  */
 428
 429 void
 430 cxx_incomplete_type_inform (const_tree type)
 431 {
 432   if (!TYPE_MAIN_DECL (type))
 433     return;
 434
 435   location_t loc = DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type));
 436   tree ptype = strip_top_quals (CONST_CAST_TREE (type));
 437
 438   if (current_class_type
 439       && TYPE_BEING_DEFINED (current_class_type)
 440       && same_type_p (ptype, current_class_type))
 441     inform (loc, "definition of %q#T is not complete until "
 442             "the closing brace", ptype);
 443   else if (!TYPE_TEMPLATE_INFO (ptype))
 444     inform (loc, "forward declaration of %q#T", ptype);
 445   else
 446     inform (loc, "declaration of %q#T", ptype);
 447 }
 448
 449 /* Print an error message for invalid use of an incomplete type.
 450    VALUE is the expression that was used (or 0 if that isn't known)
 451    and TYPE is the type that was invalid.  DIAG_KIND indicates the
 452    type of diagnostic (see diagnostic.def).  */
 453
 454 void
 455 cxx_incomplete_type_diagnostic (location_t loc, const_tree value,
 456                                 const_tree type, diagnostic_t diag_kind)
 457 {
 458   bool is_decl = false, complained = false;
 459
 460   gcc_assert (diag_kind == DK_WARNING
 461               || diag_kind == DK_PEDWARN
 462               || diag_kind == DK_ERROR);
 463
 464   /* Avoid duplicate error message.  */
 465   if (TREE_CODE (type) == ERROR_MARK)
 466     return;
 467
 468   if (value != 0 && (VAR_P (value)
 469                      || TREE_CODE (value) == PARM_DECL
 470                      || TREE_CODE (value) == FIELD_DECL))
 471     {
 472       complained = emit_diagnostic (diag_kind, DECL_SOURCE_LOCATION (value), 0,
 473                                     "%qD has incomplete type", value);
 474       is_decl = true;
 475     }
 476  retry:
 477   /* We must print an error message.  Be clever about what it says.  */
 478
 479   switch (TREE_CODE (type))
 480     {
 481     case RECORD_TYPE:
 482     case UNION_TYPE:
 483     case ENUMERAL_TYPE:
 484       if (!is_decl)
 485         complained = emit_diagnostic (diag_kind, loc, 0,
 486                                       "invalid use of incomplete type %q#T",
 487                                       type);
 488       if (complained)
 489         cxx_incomplete_type_inform (type);
 490       break;
 491
 492     case VOID_TYPE:
 493       emit_diagnostic (diag_kind, loc, 0,
 494                        "invalid use of %qT", type);
 495       break;
 496
 497     case ARRAY_TYPE:
 498       if (TYPE_DOMAIN (type))
 499         {
 500           type = TREE_TYPE (type);
 501           goto retry;
 502         }
 503       emit_diagnostic (diag_kind, loc, 0,
 504                        "invalid use of array with unspecified bounds");
 505       break;
 506
 507     case OFFSET_TYPE:
 508     bad_member:
 509       {
 510         tree member = TREE_OPERAND (value, 1);
 511         if (is_overloaded_fn (member))
 512           member = get_first_fn (member);
 513
 514         if (DECL_FUNCTION_MEMBER_P (member)
 515             && ! flag_ms_extensions)
 516           emit_diagnostic (diag_kind, loc, 0,
 517                            "invalid use of member function %qD "
 518                            "(did you forget the %<()%> ?)", member);
 519         else
 520           emit_diagnostic (diag_kind, loc, 0,
 521                            "invalid use of member %qD "
 522                            "(did you forget the %<&%> ?)", member);
 523       }
 524       break;
 525
 526     case TEMPLATE_TYPE_PARM:
 527       if (is_auto (type))
 528         {
 529           if (CLASS_PLACEHOLDER_TEMPLATE (type))
 530             emit_diagnostic (diag_kind, loc, 0,
 531                              "invalid use of placeholder %qT", type);
 532           else
 533             emit_diagnostic (diag_kind, loc, 0,
 534                              "invalid use of %qT", type);
 535         }
 536       else
 537         emit_diagnostic (diag_kind, loc, 0,
 538                          "invalid use of template type parameter %qT", type);
 539       break;
 540
 541     case BOUND_TEMPLATE_TEMPLATE_PARM:
 542       emit_diagnostic (diag_kind, loc, 0,
 543                        "invalid use of template template parameter %qT",
 544                        TYPE_NAME (type));
 545       break;
 546
 547     case TYPENAME_TYPE:
 548     case DECLTYPE_TYPE:
 549       emit_diagnostic (diag_kind, loc, 0,
 550                        "invalid use of dependent type %qT", type);
 551       break;
 552
 553     case LANG_TYPE:
 554       if (type == init_list_type_node)
 555         {
 556           emit_diagnostic (diag_kind, loc, 0,
 557                            "invalid use of brace-enclosed initializer list");
 558           break;
 559         }
 560       gcc_assert (type == unknown_type_node);
 561       if (value && TREE_CODE (value) == COMPONENT_REF)
 562         goto bad_member;
 563       else if (value && TREE_CODE (value) == ADDR_EXPR)
 564         emit_diagnostic (diag_kind, loc, 0,
 565                          "address of overloaded function with no contextual "
 566                          "type information");
 567       else if (value && TREE_CODE (value) == OVERLOAD)
 568         emit_diagnostic (diag_kind, loc, 0,
 569                          "overloaded function with no contextual type information");
 570       else
 571         emit_diagnostic (diag_kind, loc, 0,
 572                          "insufficient contextual information to determine type");
 573       break;
 574
 575     default:
 576       gcc_unreachable ();
 577     }
 578 }
 579
 580 /* Print an error message for invalid use of an incomplete type.
 581    VALUE is the expression that was used (or 0 if that isn't known)
 582    and TYPE is the type that was invalid.  */
 583
 584 void
 585 cxx_incomplete_type_error (location_t loc, const_tree value, const_tree type)
 586 {
 587   cxx_incomplete_type_diagnostic (loc, value, type, DK_ERROR);
 588 }
 589
 590 \f
 591 /* The recursive part of split_nonconstant_init.  DEST is an lvalue
 592    expression to which INIT should be assigned.  INIT is a CONSTRUCTOR.
 593    Return true if the whole of the value was initialized by the
 594    generated statements.  */
 595
 596 static bool
 597 split_nonconstant_init_1 (tree dest, tree init)
 598 {
 599   unsigned HOST_WIDE_INT idx;
 600   tree field_index, value;
 601   tree type = TREE_TYPE (dest);
 602   tree inner_type = NULL;
 603   bool array_type_p = false;
 604   bool complete_p = true;
 605   HOST_WIDE_INT num_split_elts = 0;
 606
 607   switch (TREE_CODE (type))
 608     {
 609     case ARRAY_TYPE:
 610       inner_type = TREE_TYPE (type);
 611       array_type_p = true;
 612       if ((TREE_SIDE_EFFECTS (init)
 613            && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
 614           || vla_type_p (type))
 615         {
 616           /* For an array, we only need/want a single cleanup region rather
 617              than one per element.  */
 618           tree code = build_vec_init (dest, NULL_TREE, init, false, 1,
 619                                       tf_warning_or_error);
 620           add_stmt (code);
 621           return true;
 622         }
 623       /* FALLTHRU */
 624
 625     case RECORD_TYPE:
 626     case UNION_TYPE:
 627     case QUAL_UNION_TYPE:
 628       FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
 629                                 field_index, value)
 630         {
 631           /* The current implementation of this algorithm assumes that
 632              the field was set for all the elements. This is usually done
 633              by process_init_constructor.  */
 634           gcc_assert (field_index);
 635
 636           if (!array_type_p)
 637             inner_type = TREE_TYPE (field_index);
 638
 639           if (TREE_CODE (value) == CONSTRUCTOR)
 640             {
 641               tree sub;
 642
 643               if (array_type_p)
 644                 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
 645                               NULL_TREE, NULL_TREE);
 646               else
 647                 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
 648                               NULL_TREE);
 649
 650               if (!split_nonconstant_init_1 (sub, value))
 651                 complete_p = false;
 652               else
 653                 CONSTRUCTOR_ELTS (init)->ordered_remove (idx--);
 654               num_split_elts++;
 655             }
 656           else if (!initializer_constant_valid_p (value, inner_type))
 657             {
 658               tree code;
 659               tree sub;
 660
 661               /* FIXME: Ordered removal is O(1) so the whole function is
 662                  worst-case quadratic. This could be fixed using an aside
 663                  bitmap to record which elements must be removed and remove
 664                  them all at the same time. Or by merging
 665                  split_non_constant_init into process_init_constructor_array,
 666                  that is separating constants from non-constants while building
 667                  the vector.  */
 668               CONSTRUCTOR_ELTS (init)->ordered_remove (idx);
 669               --idx;
 670
 671               if (TREE_CODE (field_index) == RANGE_EXPR)
 672                 {
 673                   /* Use build_vec_init to initialize a range.  */
 674                   tree low = TREE_OPERAND (field_index, 0);
 675                   tree hi = TREE_OPERAND (field_index, 1);
 676                   sub = build4 (ARRAY_REF, inner_type, dest, low,
 677                                 NULL_TREE, NULL_TREE);
 678                   sub = cp_build_addr_expr (sub, tf_warning_or_error);
 679                   tree max = size_binop (MINUS_EXPR, hi, low);
 680                   code = build_vec_init (sub, max, value, false, 0,
 681                                          tf_warning_or_error);
 682                   add_stmt (code);
 683                   if (tree_fits_shwi_p (max))
 684                     num_split_elts += tree_to_shwi (max);
 685                 }
 686               else
 687                 {
 688                   if (array_type_p)
 689                     sub = build4 (ARRAY_REF, inner_type, dest, field_index,
 690                                   NULL_TREE, NULL_TREE);
 691                   else
 692                     sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
 693                                   NULL_TREE);
 694
 695                   code = build2 (INIT_EXPR, inner_type, sub, value);
 696                   code = build_stmt (input_location, EXPR_STMT, code);
 697                   code = maybe_cleanup_point_expr_void (code);
 698                   add_stmt (code);
 699                   if (tree cleanup
 700                       = cxx_maybe_build_cleanup (sub, tf_warning_or_error))
 701                     finish_eh_cleanup (cleanup);
 702                 }
 703
 704               num_split_elts++;
 705             }
 706         }
 707       break;
 708
 709     case VECTOR_TYPE:
 710       if (!initializer_constant_valid_p (init, type))
 711         {
 712           tree code;
 713           tree cons = copy_node (init);
 714           CONSTRUCTOR_ELTS (init) = NULL;
 715           code = build2 (MODIFY_EXPR, type, dest, cons);
 716           code = build_stmt (input_location, EXPR_STMT, code);
 717           add_stmt (code);
 718           num_split_elts += CONSTRUCTOR_NELTS (init);
 719         }
 720       break;
 721
 722     default:
 723       gcc_unreachable ();
 724     }
 725
 726   /* The rest of the initializer is now a constant. */
 727   TREE_CONSTANT (init) = 1;
 728
 729   /* We didn't split out anything.  */
 730   if (num_split_elts == 0)
 731     return false;
 732
 733   return complete_p && complete_ctor_at_level_p (TREE_TYPE (init),
 734                                                  num_split_elts, inner_type);
 735 }
 736
 737 /* A subroutine of store_init_value.  Splits non-constant static
 738    initializer INIT into a constant part and generates code to
 739    perform the non-constant part of the initialization to DEST.
 740    Returns the code for the runtime init.  */
 741
 742 tree
 743 split_nonconstant_init (tree dest, tree init)
 744 {
 745   tree code;
 746
 747   if (TREE_CODE (init) == TARGET_EXPR)
 748     init = TARGET_EXPR_INITIAL (init);
 749   if (TREE_CODE (init) == CONSTRUCTOR)
 750     {
 751       init = cp_fully_fold (init);
 752       code = push_stmt_list ();
 753       if (split_nonconstant_init_1 (dest, init))
 754         init = NULL_TREE;
 755       code = pop_stmt_list (code);
 756       DECL_INITIAL (dest) = init;
 757       TREE_READONLY (dest) = 0;
 758     }
 759   else if (TREE_CODE (init) == STRING_CST
 760            && array_of_runtime_bound_p (TREE_TYPE (dest)))
 761     code = build_vec_init (dest, NULL_TREE, init, /*value-init*/false,
 762                            /*from array*/1, tf_warning_or_error);
 763   else
 764     code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
 765
 766   return code;
 767 }
 768
 769 /* Perform appropriate conversions on the initial value of a variable,
 770    store it in the declaration DECL,
 771    and print any error messages that are appropriate.
 772    If the init is invalid, store an ERROR_MARK.
 773
 774    C++: Note that INIT might be a TREE_LIST, which would mean that it is
 775    a base class initializer for some aggregate type, hopefully compatible
 776    with DECL.  If INIT is a single element, and DECL is an aggregate
 777    type, we silently convert INIT into a TREE_LIST, allowing a constructor
 778    to be called.
 779
 780    If INIT is a TREE_LIST and there is no constructor, turn INIT
 781    into a CONSTRUCTOR and use standard initialization techniques.
 782    Perhaps a warning should be generated?
 783
 784    Returns code to be executed if initialization could not be performed
 785    for static variable.  In that case, caller must emit the code.  */
 786
 787 tree
 788 store_init_value (tree decl, tree init, vec<tree, va_gc>** cleanups, int flags)
 789 {
 790   tree value, type;
 791
 792   /* If variable's type was invalidly declared, just ignore it.  */
 793
 794   type = TREE_TYPE (decl);
 795   if (TREE_CODE (type) == ERROR_MARK)
 796     return NULL_TREE;
 797
 798   if (MAYBE_CLASS_TYPE_P (type))
 799     {
 800       if (TREE_CODE (init) == TREE_LIST)
 801         {
 802           error ("constructor syntax used, but no constructor declared "
 803                  "for type %qT", type);
 804           init = build_constructor_from_list (init_list_type_node, nreverse (init));
 805         }
 806     }
 807
 808   /* End of special C++ code.  */
 809
 810   if (flags & LOOKUP_ALREADY_DIGESTED)
 811     value = init;
 812   else
 813     /* Digest the specified initializer into an expression.  */
 814     value = digest_init_flags (type, init, flags, tf_warning_or_error);
 815
 816   value = extend_ref_init_temps (decl, value, cleanups);
 817
 818   /* In C++11 constant expression is a semantic, not syntactic, property.
 819      In C++98, make sure that what we thought was a constant expression at
 820      template definition time is still constant and otherwise perform this
 821      as optimization, e.g. to fold SIZEOF_EXPRs in the initializer.  */
 822   if (decl_maybe_constant_var_p (decl) || TREE_STATIC (decl))
 823     {
 824       bool const_init;
 825       tree oldval = value;
 826       value = fold_non_dependent_expr (value);
 827       if (DECL_DECLARED_CONSTEXPR_P (decl)
 828           || (DECL_IN_AGGR_P (decl)
 829               && DECL_INITIALIZED_IN_CLASS_P (decl)
 830               && !DECL_VAR_DECLARED_INLINE_P (decl)))
 831         {
 832           /* Diagnose a non-constant initializer for constexpr variable or
 833              non-inline in-class-initialized static data member.  */
 834           if (!require_constant_expression (value))
 835             value = error_mark_node;
 836           else
 837             value = cxx_constant_init (value, decl);
 838         }
 839       else
 840         value = maybe_constant_init (value, decl);
 841       if (TREE_CODE (value) == CONSTRUCTOR && cp_has_mutable_p (type))
 842         /* Poison this CONSTRUCTOR so it can't be copied to another
 843            constexpr variable.  */
 844         CONSTRUCTOR_MUTABLE_POISON (value) = true;
 845       const_init = (reduced_constant_expression_p (value)
 846                     || error_operand_p (value));
 847       DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = const_init;
 848       /* FIXME setting TREE_CONSTANT on refs breaks the back end.  */
 849       if (!TYPE_REF_P (type))
 850         TREE_CONSTANT (decl) = const_init && decl_maybe_constant_var_p (decl);
 851       if (!const_init)
 852         value = oldval;
 853     }
 854   value = cp_fully_fold (value);
 855
 856   /* Handle aggregate NSDMI in non-constant initializers, too.  */
 857   value = replace_placeholders (value, decl);
 858
 859   /* DECL may change value; purge caches.  */
 860   clear_cv_and_fold_caches ();
 861
 862   /* If the initializer is not a constant, fill in DECL_INITIAL with
 863      the bits that are constant, and then return an expression that
 864      will perform the dynamic initialization.  */
 865   if (value != error_mark_node
 866       && (TREE_SIDE_EFFECTS (value)
 867           || vla_type_p (type)
 868           || ! reduced_constant_expression_p (value)))
 869     return split_nonconstant_init (decl, value);
 870   /* If the value is a constant, just put it in DECL_INITIAL.  If DECL
 871      is an automatic variable, the middle end will turn this into a
 872      dynamic initialization later.  */
 873   DECL_INITIAL (decl) = value;
 874   return NULL_TREE;
 875 }
 876
 877 \f
 878 /* Give diagnostic about narrowing conversions within { }.  */
 879
 880 bool
 881 check_narrowing (tree type, tree init, tsubst_flags_t complain)
 882 {
 883   tree ftype = unlowered_expr_type (init);
 884   bool ok = true;
 885   REAL_VALUE_TYPE d;
 886
 887   if (((!warn_narrowing || !(complain & tf_warning))
 888        && cxx_dialect == cxx98)
 889       || !ARITHMETIC_TYPE_P (type))
 890     return ok;
 891
 892   if (BRACE_ENCLOSED_INITIALIZER_P (init)
 893       && TREE_CODE (type) == COMPLEX_TYPE)
 894     {
 895       tree elttype = TREE_TYPE (type);
 896       if (CONSTRUCTOR_NELTS (init) > 0)
 897         ok &= check_narrowing (elttype, CONSTRUCTOR_ELT (init, 0)->value,
 898                                complain);
 899       if (CONSTRUCTOR_NELTS (init) > 1)
 900         ok &= check_narrowing (elttype, CONSTRUCTOR_ELT (init, 1)->value,
 901                                complain);
 902       return ok;
 903     }
 904
 905   init = fold_non_dependent_expr (init, complain);
 906
 907   if (TREE_CODE (type) == INTEGER_TYPE
 908       && TREE_CODE (ftype) == REAL_TYPE)
 909     ok = false;
 910   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
 911            && CP_INTEGRAL_TYPE_P (type))
 912     {
 913       if (TREE_CODE (ftype) == ENUMERAL_TYPE)
 914         /* Check for narrowing based on the values of the enumeration. */
 915         ftype = ENUM_UNDERLYING_TYPE (ftype);
 916       if ((tree_int_cst_lt (TYPE_MAX_VALUE (type),
 917                             TYPE_MAX_VALUE (ftype))
 918            || tree_int_cst_lt (TYPE_MIN_VALUE (ftype),
 919                                TYPE_MIN_VALUE (type)))
 920           && (TREE_CODE (init) != INTEGER_CST
 921               || !int_fits_type_p (init, type)))
 922         ok = false;
 923     }
 924   else if (TREE_CODE (ftype) == REAL_TYPE
 925            && TREE_CODE (type) == REAL_TYPE)
 926     {
 927       if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
 928         {
 929           if (TREE_CODE (init) == REAL_CST)
 930             {
 931               /* Issue 703: Loss of precision is OK as long as the value is
 932                  within the representable range of the new type.  */
 933               REAL_VALUE_TYPE r;
 934               d = TREE_REAL_CST (init);
 935               real_convert (&r, TYPE_MODE (type), &d);
 936               if (real_isinf (&r))
 937                 ok = false;
 938             }
 939           else
 940             ok = false;
 941         }
 942     }
 943   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
 944            && TREE_CODE (type) == REAL_TYPE)
 945     {
 946       ok = false;
 947       if (TREE_CODE (init) == INTEGER_CST)
 948         {
 949           d = real_value_from_int_cst (0, init);
 950           if (exact_real_truncate (TYPE_MODE (type), &d))
 951             ok = true;
 952         }
 953     }
 954
 955   bool almost_ok = ok;
 956   if (!ok && !CONSTANT_CLASS_P (init) && (complain & tf_warning_or_error))
 957     {
 958       tree folded = cp_fully_fold (init);
 959       if (TREE_CONSTANT (folded) && check_narrowing (type, folded, tf_none))
 960         almost_ok = true;
 961     }
 962
 963   if (!ok)
 964     {
 965       location_t loc = cp_expr_loc_or_loc (init, input_location);
 966       if (cxx_dialect == cxx98)
 967         {
 968           if (complain & tf_warning)
 969             warning_at (loc, OPT_Wnarrowing, "narrowing conversion of %qE "
 970                         "from %qH to %qI inside { } is ill-formed in C++11",
 971                         init, ftype, type);
 972           ok = true;
 973         }
 974       else if (!CONSTANT_CLASS_P (init))
 975         {
 976           if (complain & tf_warning_or_error)
 977             {
 978               if ((!almost_ok || pedantic)
 979                   && pedwarn (loc, OPT_Wnarrowing,
 980                               "narrowing conversion of %qE "
 981                               "from %qH to %qI inside { }",
 982                               init, ftype, type)
 983                   && almost_ok)
 984                 inform (loc, " the expression has a constant value but is not "
 985                         "a C++ constant-expression");
 986               ok = true;
 987             }
 988         }
 989       else if (complain & tf_error)
 990         {
 991           int savederrorcount = errorcount;
 992           global_dc->pedantic_errors = 1;
 993           pedwarn (loc, OPT_Wnarrowing,
 994                    "narrowing conversion of %qE from %qH to %qI "
 995                    "inside { }", init, ftype, type);
 996           if (errorcount == savederrorcount)
 997             ok = true;
 998           global_dc->pedantic_errors = flag_pedantic_errors;
 999         }
1000     }
1001
1002   return ok;
1003 }
1004
1005 /* Process the initializer INIT for a variable of type TYPE, emitting
1006    diagnostics for invalid initializers and converting the initializer as
1007    appropriate.
1008
1009    For aggregate types, it assumes that reshape_init has already run, thus the
1010    initializer will have the right shape (brace elision has been undone).
1011
1012    NESTED is non-zero iff we are being called for an element of a CONSTRUCTOR,
1013    2 iff the element of a CONSTRUCTOR is inside another CONSTRUCTOR.  */
1014
1015 static tree
1016 digest_init_r (tree type, tree init, int nested, int flags,
1017                tsubst_flags_t complain)
1018 {
1019   enum tree_code code = TREE_CODE (type);
1020
1021   if (error_operand_p (init))
1022     return error_mark_node;
1023
1024   gcc_assert (init);
1025
1026   /* We must strip the outermost array type when completing the type,
1027      because the its bounds might be incomplete at the moment.  */
1028   if (!complete_type_or_maybe_complain (code == ARRAY_TYPE
1029                                         ? TREE_TYPE (type) : type, NULL_TREE,
1030                                         complain))
1031     return error_mark_node;
1032
1033   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
1034      (g++.old-deja/g++.law/casts2.C).  */
1035   if (TREE_CODE (init) == NON_LVALUE_EXPR)
1036     init = TREE_OPERAND (init, 0);
1037
1038   location_t loc = cp_expr_loc_or_loc (init, input_location);
1039
1040   /* Initialization of an array of chars from a string constant. The initializer
1041      can be optionally enclosed in braces, but reshape_init has already removed
1042      them if they were present.  */
1043   if (code == ARRAY_TYPE)
1044     {
1045       if (nested && !TYPE_DOMAIN (type))
1046         /* C++ flexible array members have a null domain.  */
1047         pedwarn (loc, OPT_Wpedantic,
1048                  "initialization of a flexible array member");
1049
1050       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
1051       if (char_type_p (typ1)
1052           /*&& init */
1053           && TREE_CODE (init) == STRING_CST)
1054         {
1055           tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
1056
1057           if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
1058             {
1059               if (char_type != char_type_node)
1060                 {
1061                   if (complain & tf_error)
1062                     error_at (loc, "char-array initialized from wide string");
1063                   return error_mark_node;
1064                 }
1065             }
1066           else
1067             {
1068               if (char_type == char_type_node)
1069                 {
1070                   if (complain & tf_error)
1071                     error_at (loc,
1072                               "int-array initialized from non-wide string");
1073                   return error_mark_node;
1074                 }
1075               else if (char_type != typ1)
1076                 {
1077                   if (complain & tf_error)
1078                     error_at (loc, "int-array initialized from incompatible "
1079                               "wide string");
1080                   return error_mark_node;
1081                 }
1082             }
1083
1084           if (nested == 2 && !TYPE_DOMAIN (type))
1085             {
1086               if (complain & tf_error)
1087                 error_at (loc, "initialization of flexible array member "
1088                                "in a nested context");
1089               return error_mark_node;
1090             }
1091
1092           if (type != TREE_TYPE (init)
1093               && !variably_modified_type_p (type, NULL_TREE))
1094             {
1095               init = copy_node (init);
1096               TREE_TYPE (init) = type;
1097             }
1098           if (TYPE_DOMAIN (type) && TREE_CONSTANT (TYPE_SIZE (type)))
1099             {
1100               /* Not a flexible array member.  */
1101               int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
1102               size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
1103               /* In C it is ok to subtract 1 from the length of the string
1104                  because it's ok to ignore the terminating null char that is
1105                  counted in the length of the constant, but in C++ this would
1106                  be invalid.  */
1107               if (size < TREE_STRING_LENGTH (init))
1108                 permerror (loc, "initializer-string for array "
1109                            "of chars is too long");
1110             }
1111           return init;
1112         }
1113     }
1114
1115   /* Handle scalar types (including conversions) and references.  */
1116   if ((code != COMPLEX_TYPE || BRACE_ENCLOSED_INITIALIZER_P (init))
1117       && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
1118     {
1119       if (nested)
1120         flags |= LOOKUP_NO_NARROWING;
1121       init = convert_for_initialization (0, type, init, flags,
1122                                          ICR_INIT, NULL_TREE, 0,
1123                                          complain);
1124
1125       return init;
1126     }
1127
1128   /* Come here only for aggregates: records, arrays, unions, complex numbers
1129      and vectors.  */
1130   gcc_assert (code == ARRAY_TYPE
1131               || VECTOR_TYPE_P (type)
1132               || code == RECORD_TYPE
1133               || code == UNION_TYPE
1134               || code == COMPLEX_TYPE);
1135
1136   /* "If T is a class type and the initializer list has a single
1137      element of type cv U, where U is T or a class derived from T,
1138      the object is initialized from that element."  */
1139   if (flag_checking
1140       && cxx_dialect >= cxx11
1141       && BRACE_ENCLOSED_INITIALIZER_P (init)
1142       && CONSTRUCTOR_NELTS (init) == 1
1143       && ((CLASS_TYPE_P (type) && !CLASSTYPE_NON_AGGREGATE (type))
1144           || VECTOR_TYPE_P (type)))
1145     {
1146       tree elt = CONSTRUCTOR_ELT (init, 0)->value;
1147       if (reference_related_p (type, TREE_TYPE (elt)))
1148         /* We should have fixed this in reshape_init.  */
1149         gcc_unreachable ();
1150     }
1151
1152   if (BRACE_ENCLOSED_INITIALIZER_P (init)
1153       && !TYPE_NON_AGGREGATE_CLASS (type))
1154     return process_init_constructor (type, init, nested, complain);
1155   else
1156     {
1157       if (COMPOUND_LITERAL_P (init) && code == ARRAY_TYPE)
1158         {
1159           if (complain & tf_error)
1160             error_at (loc, "cannot initialize aggregate of type %qT with "
1161                       "a compound literal", type);
1162
1163           return error_mark_node;
1164         }
1165
1166       if (code == ARRAY_TYPE
1167           && !BRACE_ENCLOSED_INITIALIZER_P (init))
1168         {
1169           /* Allow the result of build_array_copy and of
1170              build_value_init_noctor.  */
1171           if ((TREE_CODE (init) == VEC_INIT_EXPR
1172                || TREE_CODE (init) == CONSTRUCTOR)
1173               && (same_type_ignoring_top_level_qualifiers_p
1174                   (type, TREE_TYPE (init))))
1175             return init;
1176
1177           if (complain & tf_error)
1178             error_at (loc, "array must be initialized with a brace-enclosed"
1179                       " initializer");
1180           return error_mark_node;
1181         }
1182
1183       return convert_for_initialization (NULL_TREE, type, init,
1184                                          flags,
1185                                          ICR_INIT, NULL_TREE, 0,
1186                                          complain);
1187     }
1188 }
1189
1190 tree
1191 digest_init (tree type, tree init, tsubst_flags_t complain)
1192 {
1193   return digest_init_r (type, init, 0, LOOKUP_IMPLICIT, complain);
1194 }
1195
1196 tree
1197 digest_init_flags (tree type, tree init, int flags, tsubst_flags_t complain)
1198 {
1199   return digest_init_r (type, init, 0, flags, complain);
1200 }
1201
1202 /* Process the initializer INIT for an NSDMI DECL (a FIELD_DECL).  */
1203 tree
1204 digest_nsdmi_init (tree decl, tree init, tsubst_flags_t complain)
1205 {
1206   gcc_assert (TREE_CODE (decl) == FIELD_DECL);
1207
1208   tree type = TREE_TYPE (decl);
1209   int flags = LOOKUP_IMPLICIT;
1210   if (DIRECT_LIST_INIT_P (init))
1211     flags = LOOKUP_NORMAL;
1212   if (BRACE_ENCLOSED_INITIALIZER_P (init)
1213       && CP_AGGREGATE_TYPE_P (type))
1214     init = reshape_init (type, init, complain);
1215   init = digest_init_flags (type, init, flags, complain);
1216   if (TREE_CODE (init) == TARGET_EXPR)
1217     /* This represents the whole initialization.  */
1218     TARGET_EXPR_DIRECT_INIT_P (init) = true;
1219   return init;
1220 }
1221 \f
1222 /* Set of flags used within process_init_constructor to describe the
1223    initializers.  */
1224 #define PICFLAG_ERRONEOUS 1
1225 #define PICFLAG_NOT_ALL_CONSTANT 2
1226 #define PICFLAG_NOT_ALL_SIMPLE 4
1227 #define PICFLAG_SIDE_EFFECTS 8
1228
1229 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
1230    describe it.  */
1231
1232 static int
1233 picflag_from_initializer (tree init)
1234 {
1235   if (init == error_mark_node)
1236     return PICFLAG_ERRONEOUS;
1237   else if (!TREE_CONSTANT (init))
1238     {
1239       if (TREE_SIDE_EFFECTS (init))
1240         return PICFLAG_SIDE_EFFECTS;
1241       else
1242         return PICFLAG_NOT_ALL_CONSTANT;
1243     }
1244   else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
1245     return PICFLAG_NOT_ALL_SIMPLE;
1246   return 0;
1247 }
1248
1249 /* Adjust INIT for going into a CONSTRUCTOR.  */
1250
1251 static tree
1252 massage_init_elt (tree type, tree init, int nested, tsubst_flags_t complain)
1253 {
1254   init = digest_init_r (type, init, nested ? 2 : 1, LOOKUP_IMPLICIT, complain);
1255   /* Strip a simple TARGET_EXPR when we know this is an initializer.  */
1256   if (SIMPLE_TARGET_EXPR_P (init))
1257     init = TARGET_EXPR_INITIAL (init);
1258   /* When we defer constant folding within a statement, we may want to
1259      defer this folding as well.  */
1260   tree t = fold_non_dependent_expr (init, complain);
1261   t = maybe_constant_init (t);
1262   if (TREE_CONSTANT (t))
1263     init = t;
1264   return init;
1265 }
1266
1267 /* Subroutine of process_init_constructor, which will process an initializer
1268    INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1269    which describe the initializers.  */
1270
1271 static int
1272 process_init_constructor_array (tree type, tree init, int nested,
1273                                 tsubst_flags_t complain)
1274 {
1275   unsigned HOST_WIDE_INT i, len = 0;
1276   int flags = 0;
1277   bool unbounded = false;
1278   constructor_elt *ce;
1279   vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (init);
1280
1281   gcc_assert (TREE_CODE (type) == ARRAY_TYPE
1282               || VECTOR_TYPE_P (type));
1283
1284   if (TREE_CODE (type) == ARRAY_TYPE)
1285     {
1286       /* C++ flexible array members have a null domain.  */
1287       tree domain = TYPE_DOMAIN (type);
1288       if (domain && TREE_CONSTANT (TYPE_MAX_VALUE (domain)))
1289         len = wi::ext (wi::to_offset (TYPE_MAX_VALUE (domain))
1290                        - wi::to_offset (TYPE_MIN_VALUE (domain)) + 1,
1291                        TYPE_PRECISION (TREE_TYPE (domain)),
1292                        TYPE_SIGN (TREE_TYPE (domain))).to_uhwi ();
1293       else
1294         unbounded = true;  /* Take as many as there are.  */
1295
1296       if (nested == 2 && !domain && !vec_safe_is_empty (v))
1297         {
1298           if (complain & tf_error)
1299             error_at (cp_expr_loc_or_loc (init, input_location),
1300                       "initialization of flexible array member "
1301                       "in a nested context");
1302           return PICFLAG_ERRONEOUS;
1303         }
1304     }
1305   else
1306     /* Vectors are like simple fixed-size arrays.  */
1307     unbounded = !TYPE_VECTOR_SUBPARTS (type).is_constant (&len);
1308
1309   /* There must not be more initializers than needed.  */
1310   if (!unbounded && vec_safe_length (v) > len)
1311     {
1312       if (complain & tf_error)
1313         error ("too many initializers for %qT", type);
1314       else
1315         return PICFLAG_ERRONEOUS;
1316     }
1317
1318   FOR_EACH_VEC_SAFE_ELT (v, i, ce)
1319     {
1320       if (!ce->index)
1321         ce->index = size_int (i);
1322       else if (!check_array_designated_initializer (ce, i))
1323         ce->index = error_mark_node;
1324       gcc_assert (ce->value);
1325       ce->value
1326         = massage_init_elt (TREE_TYPE (type), ce->value, nested, complain);
1327
1328       gcc_checking_assert
1329         (ce->value == error_mark_node
1330          || (same_type_ignoring_top_level_qualifiers_p
1331              (strip_array_types (TREE_TYPE (type)),
1332               strip_array_types (TREE_TYPE (ce->value)))));
1333
1334       flags |= picflag_from_initializer (ce->value);
1335     }
1336
1337   /* No more initializers. If the array is unbounded, we are done. Otherwise,
1338      we must add initializers ourselves.  */
1339   if (!unbounded)
1340     for (; i < len; ++i)
1341       {
1342         tree next;
1343
1344         if (type_build_ctor_call (TREE_TYPE (type)))
1345           {
1346             /* If this type needs constructors run for default-initialization,
1347                we can't rely on the back end to do it for us, so make the
1348                initialization explicit by list-initializing from T{}.  */
1349             next = build_constructor (init_list_type_node, NULL);
1350             next = massage_init_elt (TREE_TYPE (type), next, nested, complain);
1351             if (initializer_zerop (next))
1352               /* The default zero-initialization is fine for us; don't
1353                  add anything to the CONSTRUCTOR.  */
1354               next = NULL_TREE;
1355           }
1356         else if (!zero_init_p (TREE_TYPE (type)))
1357           next = build_zero_init (TREE_TYPE (type),
1358                                   /*nelts=*/NULL_TREE,
1359                                   /*static_storage_p=*/false);
1360         else
1361           /* The default zero-initialization is fine for us; don't
1362              add anything to the CONSTRUCTOR.  */
1363           next = NULL_TREE;
1364
1365         if (next)
1366           {
1367             flags |= picflag_from_initializer (next);
1368             if (len > i+1
1369                 && (initializer_constant_valid_p (next, TREE_TYPE (next))
1370                     == null_pointer_node))
1371               {
1372                 tree range = build2 (RANGE_EXPR, size_type_node,
1373                                      build_int_cst (size_type_node, i),
1374                                      build_int_cst (size_type_node, len - 1));
1375                 CONSTRUCTOR_APPEND_ELT (v, range, next);
1376                 break;
1377               }
1378             else
1379               CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
1380           }
1381         else
1382           /* Don't bother checking all the other elements.  */
1383           break;
1384       }
1385
1386   CONSTRUCTOR_ELTS (init) = v;
1387   return flags;
1388 }
1389
1390 /* Subroutine of process_init_constructor, which will process an initializer
1391    INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1392    the initializers.  */
1393
1394 static int
1395 process_init_constructor_record (tree type, tree init, int nested,
1396                                  tsubst_flags_t complain)
1397 {
1398   vec<constructor_elt, va_gc> *v = NULL;
1399   tree field;
1400   int skipped = 0;
1401
1402   gcc_assert (TREE_CODE (type) == RECORD_TYPE);
1403   gcc_assert (!CLASSTYPE_VBASECLASSES (type));
1404   gcc_assert (!TYPE_BINFO (type)
1405               || cxx_dialect >= cxx17
1406               || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
1407   gcc_assert (!TYPE_POLYMORPHIC_P (type));
1408
1409  restart:
1410   int flags = 0;
1411   unsigned HOST_WIDE_INT idx = 0;
1412   int designator_skip = -1;
1413   /* Generally, we will always have an index for each initializer (which is
1414      a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1415      reshape_init. So we need to handle both cases.  */
1416   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
1417     {
1418       tree next;
1419       tree type;
1420
1421       if (TREE_CODE (field) != FIELD_DECL
1422           || (DECL_ARTIFICIAL (field)
1423               && !(cxx_dialect >= cxx17 && DECL_FIELD_IS_BASE (field))))
1424         continue;
1425
1426       if (DECL_UNNAMED_BIT_FIELD (field))
1427         continue;
1428
1429       /* If this is a bitfield, first convert to the declared type.  */
1430       type = TREE_TYPE (field);
1431       if (DECL_BIT_FIELD_TYPE (field))
1432         type = DECL_BIT_FIELD_TYPE (field);
1433       if (type == error_mark_node)
1434         return PICFLAG_ERRONEOUS;
1435
1436       next = NULL_TREE;
1437       if (idx < CONSTRUCTOR_NELTS (init))
1438         {
1439           constructor_elt *ce = &(*CONSTRUCTOR_ELTS (init))[idx];
1440           if (ce->index)
1441             {
1442               /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1443                  latter case can happen in templates where lookup has to be
1444                  deferred.  */
1445               gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1446                           || identifier_p (ce->index));
1447               if (ce->index == field || ce->index == DECL_NAME (field))
1448                 next = ce->value;
1449               else if (ANON_AGGR_TYPE_P (type)
1450                        && search_anon_aggr (type,
1451                                             TREE_CODE (ce->index) == FIELD_DECL
1452                                             ? DECL_NAME (ce->index)
1453                                             : ce->index))
1454                 /* If the element is an anonymous union object and the
1455                    initializer list is a designated-initializer-list, the
1456                    anonymous union object is initialized by the
1457                    designated-initializer-list { D }, where D is the
1458                    designated-initializer-clause naming a member of the
1459                    anonymous union object.  */
1460                 next = build_constructor_single (init_list_type_node,
1461                                                  ce->index, ce->value);
1462               else
1463                 {
1464                   ce = NULL;
1465                   if (designator_skip == -1)
1466                     designator_skip = 1;
1467                 }
1468             }
1469           else
1470             {
1471               designator_skip = 0;
1472               next = ce->value;
1473             }
1474
1475           if (ce)
1476             {
1477               gcc_assert (ce->value);
1478               next = massage_init_elt (type, next, nested, complain);
1479               ++idx;
1480             }
1481         }
1482       if (next)
1483         /* Already handled above.  */;
1484       else if (DECL_INITIAL (field))
1485         {
1486           if (skipped > 0)
1487             {
1488               /* We're using an NSDMI past a field with implicit
1489                  zero-init.  Go back and make it explicit.  */
1490               skipped = -1;
1491               vec_safe_truncate (v, 0);
1492               goto restart;
1493             }
1494           /* C++14 aggregate NSDMI.  */
1495           next = get_nsdmi (field, /*ctor*/false, complain);
1496           if (!CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init)
1497               && find_placeholders (next))
1498             CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = 1;
1499         }
1500       else if (type_build_ctor_call (TREE_TYPE (field)))
1501         {
1502           /* If this type needs constructors run for
1503              default-initialization, we can't rely on the back end to do it
1504              for us, so build up TARGET_EXPRs.  If the type in question is
1505              a class, just build one up; if it's an array, recurse.  */
1506           next = build_constructor (init_list_type_node, NULL);
1507           next = massage_init_elt (TREE_TYPE (field), next, nested, complain);
1508
1509           /* Warn when some struct elements are implicitly initialized.  */
1510           if ((complain & tf_warning)
1511               && !EMPTY_CONSTRUCTOR_P (init))
1512             warning (OPT_Wmissing_field_initializers,
1513                      "missing initializer for member %qD", field);
1514         }
1515       else
1516         {
1517           const_tree fldtype = TREE_TYPE (field);
1518           if (TYPE_REF_P (fldtype))
1519             {
1520               if (complain & tf_error)
1521                 error ("member %qD is uninitialized reference", field);
1522               else
1523                 return PICFLAG_ERRONEOUS;
1524             }
1525           else if (CLASSTYPE_REF_FIELDS_NEED_INIT (fldtype))
1526             {
1527               if (complain & tf_error)
1528                 error ("member %qD with uninitialized reference fields", field);
1529               else
1530                 return PICFLAG_ERRONEOUS;
1531             }
1532
1533           /* Warn when some struct elements are implicitly initialized
1534              to zero.  However, avoid issuing the warning for flexible
1535              array members since they need not have any elements.  */
1536           if ((TREE_CODE (fldtype) != ARRAY_TYPE || TYPE_DOMAIN (fldtype))
1537               && (complain & tf_warning)
1538               && !EMPTY_CONSTRUCTOR_P (init))
1539             warning (OPT_Wmissing_field_initializers,
1540                      "missing initializer for member %qD", field);
1541
1542           if (!zero_init_p (fldtype)
1543               || skipped < 0)
1544             next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1545                                     /*static_storage_p=*/false);
1546           else
1547             {
1548               /* The default zero-initialization is fine for us; don't
1549                  add anything to the CONSTRUCTOR.  */
1550               skipped = 1;
1551               continue;
1552             }
1553         }
1554
1555       /* If this is a bitfield, now convert to the lowered type.  */
1556       if (type != TREE_TYPE (field))
1557         next = cp_convert_and_check (TREE_TYPE (field), next, complain);
1558       flags |= picflag_from_initializer (next);
1559       CONSTRUCTOR_APPEND_ELT (v, field, next);
1560     }
1561
1562   if (idx < CONSTRUCTOR_NELTS (init))
1563     {
1564       if (complain & tf_error)
1565         {
1566           constructor_elt *ce = &(*CONSTRUCTOR_ELTS (init))[idx];
1567           /* For better diagnostics, try to find out if it is really
1568              the case of too many initializers or if designators are
1569              in incorrect order.  */
1570           if (designator_skip == 1 && ce->index)
1571             {
1572               gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1573                           || identifier_p (ce->index));
1574               for (field = TYPE_FIELDS (type);
1575                    field; field = DECL_CHAIN (field))
1576                 {
1577                   if (TREE_CODE (field) != FIELD_DECL
1578                       || (DECL_ARTIFICIAL (field)
1579                           && !(cxx_dialect >= cxx17
1580                                && DECL_FIELD_IS_BASE (field))))
1581                     continue;
1582
1583                   if (DECL_UNNAMED_BIT_FIELD (field))
1584                     continue;
1585
1586                   if (ce->index == field || ce->index == DECL_NAME (field))
1587                     break;
1588                   if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1589                     {
1590                       tree t
1591                         = search_anon_aggr (TREE_TYPE (field),
1592                                             TREE_CODE (ce->index) == FIELD_DECL
1593                                             ? DECL_NAME (ce->index)
1594                                             : ce->index);
1595                       if (t)
1596                         {
1597                           field = t;
1598                           break;
1599                         }
1600                     }
1601                 }
1602             }
1603           if (field)
1604             error ("designator order for field %qD does not match declaration "
1605                    "order in %qT", field, type);
1606           else
1607             error ("too many initializers for %qT", type);
1608         }
1609       else
1610         return PICFLAG_ERRONEOUS;
1611     }
1612
1613   CONSTRUCTOR_ELTS (init) = v;
1614   return flags;
1615 }
1616
1617 /* Subroutine of process_init_constructor, which will process a single
1618    initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1619    which describe the initializer.  */
1620
1621 static int
1622 process_init_constructor_union (tree type, tree init, int nested,
1623                                 tsubst_flags_t complain)
1624 {
1625   constructor_elt *ce;
1626   int len;
1627
1628   /* If the initializer was empty, use the union's NSDMI if it has one.
1629      Otherwise use default zero initialization.  */
1630   if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init)))
1631     {
1632       for (tree field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1633         {
1634           if (TREE_CODE (field) == FIELD_DECL
1635               && DECL_INITIAL (field) != NULL_TREE)
1636             {
1637               tree val = get_nsdmi (field, /*in_ctor=*/false, complain);
1638               if (!CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init)
1639                   && find_placeholders (val))
1640                 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = 1;
1641               CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (init), field, val);
1642               break;
1643             }
1644         }
1645
1646       if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init)))
1647         return 0;
1648     }
1649
1650   len = CONSTRUCTOR_ELTS (init)->length ();
1651   if (len > 1)
1652     {
1653       if (!(complain & tf_error))
1654         return PICFLAG_ERRONEOUS;
1655       error ("too many initializers for %qT", type);
1656       CONSTRUCTOR_ELTS (init)->block_remove (1, len-1);
1657     }
1658
1659   ce = &(*CONSTRUCTOR_ELTS (init))[0];
1660
1661   /* If this element specifies a field, initialize via that field.  */
1662   if (ce->index)
1663     {
1664       if (TREE_CODE (ce->index) == FIELD_DECL)
1665         ;
1666       else if (identifier_p (ce->index))
1667         {
1668           /* This can happen within a cast, see g++.dg/opt/cse2.C.  */
1669           tree name = ce->index;
1670           tree field;
1671           for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1672             if (DECL_NAME (field) == name)
1673               break;
1674           if (!field)
1675             {
1676               if (complain & tf_error)
1677                 error ("no field %qD found in union being initialized",
1678                        field);
1679               ce->value = error_mark_node;
1680             }
1681           ce->index = field;
1682         }
1683       else
1684         {
1685           gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1686                       || TREE_CODE (ce->index) == RANGE_EXPR);
1687           if (complain & tf_error)
1688             error ("index value instead of field name in union initializer");
1689           ce->value = error_mark_node;
1690         }
1691     }
1692   else
1693     {
1694       /* Find the first named field.  ANSI decided in September 1990
1695          that only named fields count here.  */
1696       tree field = TYPE_FIELDS (type);
1697       while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1698         field = TREE_CHAIN (field);
1699       if (field == NULL_TREE)
1700         {
1701           if (complain & tf_error)
1702             error ("too many initializers for %qT", type);
1703           ce->value = error_mark_node;
1704         }
1705       ce->index = field;
1706     }
1707
1708   if (ce->value && ce->value != error_mark_node)
1709     ce->value = massage_init_elt (TREE_TYPE (ce->index), ce->value, nested,
1710                                   complain);
1711
1712   return picflag_from_initializer (ce->value);
1713 }
1714
1715 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1716    constructor is a brace-enclosed initializer, and will be modified in-place.
1717
1718    Each element is converted to the right type through digest_init, and
1719    missing initializers are added following the language rules (zero-padding,
1720    etc.).
1721
1722    After the execution, the initializer will have TREE_CONSTANT if all elts are
1723    constant, and TREE_STATIC set if, in addition, all elts are simple enough
1724    constants that the assembler and linker can compute them.
1725
1726    The function returns the initializer itself, or error_mark_node in case
1727    of error.  */
1728
1729 static tree
1730 process_init_constructor (tree type, tree init, int nested,
1731                           tsubst_flags_t complain)
1732 {
1733   int flags;
1734
1735   gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1736
1737   if (TREE_CODE (type) == ARRAY_TYPE || VECTOR_TYPE_P (type))
1738     flags = process_init_constructor_array (type, init, nested, complain);
1739   else if (TREE_CODE (type) == RECORD_TYPE)
1740     flags = process_init_constructor_record (type, init, nested, complain);
1741   else if (TREE_CODE (type) == UNION_TYPE)
1742     flags = process_init_constructor_union (type, init, nested, complain);
1743   else
1744     gcc_unreachable ();
1745
1746   if (flags & PICFLAG_ERRONEOUS)
1747     return error_mark_node;
1748
1749   TREE_TYPE (init) = type;
1750   if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1751     cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1752   if (flags & PICFLAG_SIDE_EFFECTS)
1753     {
1754       TREE_CONSTANT (init) = false;
1755       TREE_SIDE_EFFECTS (init) = true;
1756     }
1757   else if (flags & PICFLAG_NOT_ALL_CONSTANT)
1758     /* Make sure TREE_CONSTANT isn't set from build_constructor.  */
1759     TREE_CONSTANT (init) = false;
1760   else
1761     {
1762       TREE_CONSTANT (init) = 1;
1763       if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1764         TREE_STATIC (init) = 1;
1765     }
1766   return init;
1767 }
1768 \f
1769 /* Given a structure or union value DATUM, construct and return
1770    the structure or union component which results from narrowing
1771    that value to the base specified in BASETYPE.  For example, given the
1772    hierarchy
1773
1774    class L { int ii; };
1775    class A : L { ... };
1776    class B : L { ... };
1777    class C : A, B { ... };
1778
1779    and the declaration
1780
1781    C x;
1782
1783    then the expression
1784
1785    x.A::ii refers to the ii member of the L part of
1786    the A part of the C object named by X.  In this case,
1787    DATUM would be x, and BASETYPE would be A.
1788
1789    I used to think that this was nonconformant, that the standard specified
1790    that first we look up ii in A, then convert x to an L& and pull out the
1791    ii part.  But in fact, it does say that we convert x to an A&; A here
1792    is known as the "naming class".  (jason 2000-12-19)
1793
1794    BINFO_P points to a variable initialized either to NULL_TREE or to the
1795    binfo for the specific base subobject we want to convert to.  */
1796
1797 tree
1798 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1799 {
1800   tree binfo;
1801
1802   if (datum == error_mark_node)
1803     return error_mark_node;
1804   if (*binfo_p)
1805     binfo = *binfo_p;
1806   else
1807     binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check,
1808                          NULL, tf_warning_or_error);
1809
1810   if (!binfo || binfo == error_mark_node)
1811     {
1812       *binfo_p = NULL_TREE;
1813       if (!binfo)
1814         error_not_base_type (basetype, TREE_TYPE (datum));
1815       return error_mark_node;
1816     }
1817
1818   *binfo_p = binfo;
1819   return build_base_path (PLUS_EXPR, datum, binfo, 1,
1820                           tf_warning_or_error);
1821 }
1822
1823 /* Build a reference to an object specified by the C++ `->' operator.
1824    Usually this just involves dereferencing the object, but if the
1825    `->' operator is overloaded, then such overloads must be
1826    performed until an object which does not have the `->' operator
1827    overloaded is found.  An error is reported when circular pointer
1828    delegation is detected.  */
1829
1830 tree
1831 build_x_arrow (location_t loc, tree expr, tsubst_flags_t complain)
1832 {
1833   tree orig_expr = expr;
1834   tree type = TREE_TYPE (expr);
1835   tree last_rval = NULL_TREE;
1836   vec<tree, va_gc> *types_memoized = NULL;
1837
1838   if (type == error_mark_node)
1839     return error_mark_node;
1840
1841   if (processing_template_decl)
1842     {
1843       if (type && TYPE_PTR_P (type)
1844           && !dependent_scope_p (TREE_TYPE (type)))
1845         /* Pointer to current instantiation, don't treat as dependent.  */;
1846       else if (type_dependent_expression_p (expr))
1847         return build_min_nt_loc (loc, ARROW_EXPR, expr);
1848       expr = build_non_dependent_expr (expr);
1849     }
1850
1851   if (MAYBE_CLASS_TYPE_P (type))
1852     {
1853       struct tinst_level *actual_inst = current_instantiation ();
1854       tree fn = NULL;
1855
1856       while ((expr = build_new_op (loc, COMPONENT_REF,
1857                                    LOOKUP_NORMAL, expr, NULL_TREE, NULL_TREE,
1858                                    &fn, complain)))
1859         {
1860           if (expr == error_mark_node)
1861             return error_mark_node;
1862
1863           /* This provides a better instantiation backtrace in case of
1864              error.  */
1865           if (fn && DECL_USE_TEMPLATE (fn))
1866             push_tinst_level_loc (fn,
1867                                   (current_instantiation () != actual_inst)
1868                                   ? DECL_SOURCE_LOCATION (fn)
1869                                   : input_location);
1870           fn = NULL;
1871
1872           if (vec_member (TREE_TYPE (expr), types_memoized))
1873             {
1874               if (complain & tf_error)
1875                 error ("circular pointer delegation detected");
1876               return error_mark_node;
1877             }
1878
1879           vec_safe_push (types_memoized, TREE_TYPE (expr));
1880           last_rval = expr;
1881         }
1882
1883       while (current_instantiation () != actual_inst)
1884         pop_tinst_level ();
1885
1886       if (last_rval == NULL_TREE)
1887         {
1888           if (complain & tf_error)
1889             error ("base operand of %<->%> has non-pointer type %qT", type);
1890           return error_mark_node;
1891         }
1892
1893       if (TYPE_REF_P (TREE_TYPE (last_rval)))
1894         last_rval = convert_from_reference (last_rval);
1895     }
1896   else
1897     last_rval = decay_conversion (expr, complain);
1898
1899   if (TYPE_PTR_P (TREE_TYPE (last_rval)))
1900     {
1901       if (processing_template_decl)
1902         {
1903           expr = build_min (ARROW_EXPR, TREE_TYPE (TREE_TYPE (last_rval)),
1904                             orig_expr);
1905           TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (last_rval);
1906           return expr;
1907         }
1908
1909       return cp_build_indirect_ref (last_rval, RO_ARROW, complain);
1910     }
1911
1912   if (complain & tf_error)
1913     {
1914       if (types_memoized)
1915         error ("result of %<operator->()%> yields non-pointer result");
1916       else
1917         error ("base operand of %<->%> is not a pointer");
1918     }
1919   return error_mark_node;
1920 }
1921
1922 /* Return an expression for "DATUM .* COMPONENT".  DATUM has not
1923    already been checked out to be of aggregate type.  */
1924
1925 tree
1926 build_m_component_ref (tree datum, tree component, tsubst_flags_t complain)
1927 {
1928   tree ptrmem_type;
1929   tree objtype;
1930   tree type;
1931   tree binfo;
1932   tree ctype;
1933
1934   if (error_operand_p (datum) || error_operand_p (component))
1935     return error_mark_node;
1936
1937   datum = mark_lvalue_use (datum);
1938   component = mark_rvalue_use (component);
1939
1940   ptrmem_type = TREE_TYPE (component);
1941   if (!TYPE_PTRMEM_P (ptrmem_type))
1942     {
1943       if (complain & tf_error)
1944         error ("%qE cannot be used as a member pointer, since it is of "
1945                "type %qT", component, ptrmem_type);
1946       return error_mark_node;
1947     }
1948
1949   objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1950   if (! MAYBE_CLASS_TYPE_P (objtype))
1951     {
1952       if (complain & tf_error)
1953         error ("cannot apply member pointer %qE to %qE, which is of "
1954                "non-class type %qT", component, datum, objtype);
1955       return error_mark_node;
1956     }
1957
1958   type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1959   ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1960
1961   if (!COMPLETE_TYPE_P (ctype))
1962     {
1963       if (!same_type_p (ctype, objtype))
1964         goto mismatch;
1965       binfo = NULL;
1966     }
1967   else
1968     {
1969       binfo = lookup_base (objtype, ctype, ba_check, NULL, complain);
1970
1971       if (!binfo)
1972         {
1973         mismatch:
1974           if (complain & tf_error)
1975             error ("pointer to member type %qT incompatible with object "
1976                    "type %qT", type, objtype);
1977           return error_mark_node;
1978         }
1979       else if (binfo == error_mark_node)
1980         return error_mark_node;
1981     }
1982
1983   if (TYPE_PTRDATAMEM_P (ptrmem_type))
1984     {
1985       bool is_lval = real_lvalue_p (datum);
1986       tree ptype;
1987
1988       /* Compute the type of the field, as described in [expr.ref].
1989          There's no such thing as a mutable pointer-to-member, so
1990          things are not as complex as they are for references to
1991          non-static data members.  */
1992       type = cp_build_qualified_type (type,
1993                                       (cp_type_quals (type)
1994                                        | cp_type_quals (TREE_TYPE (datum))));
1995
1996       datum = build_address (datum);
1997
1998       /* Convert object to the correct base.  */
1999       if (binfo)
2000         {
2001           datum = build_base_path (PLUS_EXPR, datum, binfo, 1, complain);
2002           if (datum == error_mark_node)
2003             return error_mark_node;
2004         }
2005
2006       /* Build an expression for "object + offset" where offset is the
2007          value stored in the pointer-to-data-member.  */
2008       ptype = build_pointer_type (type);
2009       datum = fold_build_pointer_plus (fold_convert (ptype, datum), component);
2010       datum = cp_build_fold_indirect_ref (datum);
2011       if (datum == error_mark_node)
2012         return error_mark_node;
2013
2014       /* If the object expression was an rvalue, return an rvalue.  */
2015       if (!is_lval)
2016         datum = move (datum);
2017       return datum;
2018     }
2019   else
2020     {
2021       /* 5.5/6: In a .* expression whose object expression is an rvalue, the
2022          program is ill-formed if the second operand is a pointer to member
2023          function with ref-qualifier & (for C++2A: unless its cv-qualifier-seq
2024          is const). In a .* expression whose object expression is an lvalue,
2025          the program is ill-formed if the second operand is a pointer to member
2026          function with ref-qualifier &&.  */
2027       if (FUNCTION_REF_QUALIFIED (type))
2028         {
2029           bool lval = lvalue_p (datum);
2030           if (lval && FUNCTION_RVALUE_QUALIFIED (type))
2031             {
2032               if (complain & tf_error)
2033                 error ("pointer-to-member-function type %qT requires an rvalue",
2034                        ptrmem_type);
2035               return error_mark_node;
2036             }
2037           else if (!lval && !FUNCTION_RVALUE_QUALIFIED (type))
2038             {
2039               if ((type_memfn_quals (type)
2040                    & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE))
2041                   != TYPE_QUAL_CONST)
2042                 {
2043                   if (complain & tf_error)
2044                     error ("pointer-to-member-function type %qT requires "
2045                            "an lvalue", ptrmem_type);
2046                   return error_mark_node;
2047                 }
2048               else if (cxx_dialect < cxx2a)
2049                 {
2050                   if (complain & tf_warning_or_error)
2051                     pedwarn (input_location, OPT_Wpedantic,
2052                              "pointer-to-member-function type %qT requires "
2053                              "an lvalue before C++2a", ptrmem_type);
2054                   else
2055                     return error_mark_node;
2056                 }
2057             }
2058         }
2059       return build2 (OFFSET_REF, type, datum, component);
2060     }
2061 }
2062
2063 /* Return a tree node for the expression TYPENAME '(' PARMS ')'.  */
2064
2065 tree
2066 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
2067 {
2068   /* This is either a call to a constructor,
2069      or a C cast in C++'s `functional' notation.  */
2070
2071   /* The type to which we are casting.  */
2072   tree type;
2073   vec<tree, va_gc> *parmvec;
2074
2075   if (error_operand_p (exp) || parms == error_mark_node)
2076     return error_mark_node;
2077
2078   if (TREE_CODE (exp) == TYPE_DECL)
2079     {
2080       type = TREE_TYPE (exp);
2081
2082       if (DECL_ARTIFICIAL (exp))
2083         cp_warn_deprecated_use (type);
2084     }
2085   else
2086     type = exp;
2087
2088   /* We need to check this explicitly, since value-initialization of
2089      arrays is allowed in other situations.  */
2090   if (TREE_CODE (type) == ARRAY_TYPE)
2091     {
2092       if (complain & tf_error)
2093         error ("functional cast to array type %qT", type);
2094       return error_mark_node;
2095     }
2096
2097   if (tree anode = type_uses_auto (type))
2098     {
2099       if (!CLASS_PLACEHOLDER_TEMPLATE (anode))
2100         {
2101           if (complain & tf_error)
2102             error_at (DECL_SOURCE_LOCATION (TEMPLATE_TYPE_DECL (anode)),
2103                       "invalid use of %qT", anode);
2104           return error_mark_node;
2105         }
2106       else if (!parms)
2107         {
2108           if (complain & tf_error)
2109             error ("cannot deduce template arguments for %qT from ()", anode);
2110           return error_mark_node;
2111         }
2112       else
2113         type = do_auto_deduction (type, parms, anode, complain,
2114                                   adc_variable_type);
2115     }
2116
2117   if (processing_template_decl)
2118     {
2119       tree t;
2120
2121       /* Diagnose this even in a template.  We could also try harder
2122          to give all the usual errors when the type and args are
2123          non-dependent...  */
2124       if (TYPE_REF_P (type) && !parms)
2125         {
2126           if (complain & tf_error)
2127             error ("invalid value-initialization of reference type");
2128           return error_mark_node;
2129         }
2130
2131       t = build_min (CAST_EXPR, type, parms);
2132       /* We don't know if it will or will not have side effects.  */
2133       TREE_SIDE_EFFECTS (t) = 1;
2134       return t;
2135     }
2136
2137   if (! MAYBE_CLASS_TYPE_P (type))
2138     {
2139       if (parms == NULL_TREE)
2140         {
2141           if (VOID_TYPE_P (type))
2142             return void_node;
2143           return build_value_init (cv_unqualified (type), complain);
2144         }
2145
2146       /* This must build a C cast.  */
2147       parms = build_x_compound_expr_from_list (parms, ELK_FUNC_CAST, complain);
2148       return cp_build_c_cast (type, parms, complain);
2149     }
2150
2151   /* Prepare to evaluate as a call to a constructor.  If this expression
2152      is actually used, for example,
2153
2154      return X (arg1, arg2, ...);
2155
2156      then the slot being initialized will be filled in.  */
2157
2158   if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
2159     return error_mark_node;
2160   if (abstract_virtuals_error_sfinae (ACU_CAST, type, complain))
2161     return error_mark_node;
2162
2163   /* [expr.type.conv]
2164
2165      If the expression list is a single-expression, the type
2166      conversion is equivalent (in definedness, and if defined in
2167      meaning) to the corresponding cast expression.  */
2168   if (parms && TREE_CHAIN (parms) == NULL_TREE)
2169     return cp_build_c_cast (type, TREE_VALUE (parms), complain);
2170
2171   /* [expr.type.conv]
2172
2173      The expression T(), where T is a simple-type-specifier for a
2174      non-array complete object type or the (possibly cv-qualified)
2175      void type, creates an rvalue of the specified type, which is
2176      value-initialized.  */
2177
2178   if (parms == NULL_TREE)
2179     {
2180       exp = build_value_init (type, complain);
2181       exp = get_target_expr_sfinae (exp, complain);
2182       return exp;
2183     }
2184
2185   /* Call the constructor.  */
2186   parmvec = make_tree_vector ();
2187   for (; parms != NULL_TREE; parms = TREE_CHAIN (parms))
2188     vec_safe_push (parmvec, TREE_VALUE (parms));
2189   exp = build_special_member_call (NULL_TREE, complete_ctor_identifier,
2190                                    &parmvec, type, LOOKUP_NORMAL, complain);
2191   release_tree_vector (parmvec);
2192
2193   if (exp == error_mark_node)
2194     return error_mark_node;
2195
2196   return build_cplus_new (type, exp, complain);
2197 }
2198 \f
2199
2200 /* Add new exception specifier SPEC, to the LIST we currently have.
2201    If it's already in LIST then do nothing.
2202    Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
2203    know what we're doing.  */
2204
2205 tree
2206 add_exception_specifier (tree list, tree spec, int complain)
2207 {
2208   bool ok;
2209   tree core = spec;
2210   bool is_ptr;
2211   diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
2212
2213   if (spec == error_mark_node)
2214     return list;
2215
2216   gcc_assert (spec && (!list || TREE_VALUE (list)));
2217
2218   /* [except.spec] 1, type in an exception specifier shall not be
2219      incomplete, or pointer or ref to incomplete other than pointer
2220      to cv void.  */
2221   is_ptr = TYPE_PTR_P (core);
2222   if (is_ptr || TYPE_REF_P (core))
2223     core = TREE_TYPE (core);
2224   if (complain < 0)
2225     ok = true;
2226   else if (VOID_TYPE_P (core))
2227     ok = is_ptr;
2228   else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
2229     ok = true;
2230   else if (processing_template_decl)
2231     ok = true;
2232   else
2233     {
2234       ok = true;
2235       /* 15.4/1 says that types in an exception specifier must be complete,
2236          but it seems more reasonable to only require this on definitions
2237          and calls.  So just give a pedwarn at this point; we will give an
2238          error later if we hit one of those two cases.  */
2239       if (!COMPLETE_TYPE_P (complete_type (core)))
2240         diag_type = DK_PEDWARN; /* pedwarn */
2241     }
2242
2243   if (ok)
2244     {
2245       tree probe;
2246
2247       for (probe = list; probe; probe = TREE_CHAIN (probe))
2248         if (same_type_p (TREE_VALUE (probe), spec))
2249           break;
2250       if (!probe)
2251         list = tree_cons (NULL_TREE, spec, list);
2252     }
2253   else
2254     diag_type = DK_ERROR; /* error */
2255
2256   if (diag_type != DK_UNSPECIFIED
2257       && (complain & tf_warning_or_error))
2258     cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
2259
2260   return list;
2261 }
2262
2263 /* Like nothrow_spec_p, but don't abort on deferred noexcept.  */
2264
2265 static bool
2266 nothrow_spec_p_uninst (const_tree spec)
2267 {
2268   if (DEFERRED_NOEXCEPT_SPEC_P (spec))
2269     return false;
2270   return nothrow_spec_p (spec);
2271 }
2272
2273 /* Combine the two exceptions specifier lists LIST and ADD, and return
2274    their union.  */
2275
2276 tree
2277 merge_exception_specifiers (tree list, tree add)
2278 {
2279   tree noex, orig_list;
2280
2281   /* No exception-specifier or noexcept(false) are less strict than
2282      anything else.  Prefer the newer variant (LIST).  */
2283   if (!list || list == noexcept_false_spec)
2284     return list;
2285   else if (!add || add == noexcept_false_spec)
2286     return add;
2287
2288   /* noexcept(true) and throw() are stricter than anything else.
2289      As above, prefer the more recent one (LIST).  */
2290   if (nothrow_spec_p_uninst (add))
2291     return list;
2292
2293   /* Two implicit noexcept specs (e.g. on a destructor) are equivalent.  */
2294   if (UNEVALUATED_NOEXCEPT_SPEC_P (add)
2295       && UNEVALUATED_NOEXCEPT_SPEC_P (list))
2296     return list;
2297   /* We should have instantiated other deferred noexcept specs by now.  */
2298   gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (add));
2299
2300   if (nothrow_spec_p_uninst (list))
2301     return add;
2302   noex = TREE_PURPOSE (list);
2303   gcc_checking_assert (!TREE_PURPOSE (add)
2304                        || errorcount || !flag_exceptions
2305                        || cp_tree_equal (noex, TREE_PURPOSE (add)));
2306
2307   /* Combine the dynamic-exception-specifiers, if any.  */
2308   orig_list = list;
2309   for (; add && TREE_VALUE (add); add = TREE_CHAIN (add))
2310     {
2311       tree spec = TREE_VALUE (add);
2312       tree probe;
2313
2314       for (probe = orig_list; probe && TREE_VALUE (probe);
2315            probe = TREE_CHAIN (probe))
2316         if (same_type_p (TREE_VALUE (probe), spec))
2317           break;
2318       if (!probe)
2319         {
2320           spec = build_tree_list (NULL_TREE, spec);
2321           TREE_CHAIN (spec) = list;
2322           list = spec;
2323         }
2324     }
2325
2326   /* Keep the noexcept-specifier at the beginning of the list.  */
2327   if (noex != TREE_PURPOSE (list))
2328     list = tree_cons (noex, TREE_VALUE (list), TREE_CHAIN (list));
2329
2330   return list;
2331 }
2332
2333 /* Subroutine of build_call.  Ensure that each of the types in the
2334    exception specification is complete.  Technically, 15.4/1 says that
2335    they need to be complete when we see a declaration of the function,
2336    but we should be able to get away with only requiring this when the
2337    function is defined or called.  See also add_exception_specifier.  */
2338
2339 void
2340 require_complete_eh_spec_types (tree fntype, tree decl)
2341 {
2342   tree raises;
2343   /* Don't complain about calls to op new.  */
2344   if (decl && DECL_ARTIFICIAL (decl))
2345     return;
2346   for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
2347        raises = TREE_CHAIN (raises))
2348     {
2349       tree type = TREE_VALUE (raises);
2350       if (type && !COMPLETE_TYPE_P (type))
2351         {
2352           if (decl)
2353             error
2354               ("call to function %qD which throws incomplete type %q#T",
2355                decl, type);
2356           else
2357             error ("call to function which throws incomplete type %q#T",
2358                    decl);
2359         }
2360     }
2361 }
2362
2363 \f
2364 #include "gt-cp-typeck2.h"