Merge branch 'vendor/GCC50' - gcc 5.0 snapshot 1 FEB 2015
[dragonfly.git] / contrib / gcc-5.0 / gcc / cp / constexpr.c
1 /* Perform -*- C++ -*- constant expression evaluation, including calls to
2    constexpr functions.  These routines are used both during actual parsing
3    and during the instantiation of template functions.
4
5    Copyright (C) 1998-2015 Free Software Foundation, Inc.
6
7    This file is part of GCC.
8
9    GCC is free software; you can redistribute it and/or modify it
10    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, but
15    WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17    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 "hash-set.h"
27 #include "machmode.h"
28 #include "vec.h"
29 #include "double-int.h"
30 #include "input.h"
31 #include "alias.h"
32 #include "symtab.h"
33 #include "options.h"
34 #include "wide-int.h"
35 #include "inchash.h"
36 #include "tree.h"
37 #include "varasm.h"
38 #include "cp-tree.h"
39 #include "c-family/c-objc.h"
40 #include "tree-iterator.h"
41 #include "gimplify.h"
42 #include "builtins.h"
43 #include "tree-inline.h"
44 #include "ubsan.h"
45
46 static bool verify_constant (tree, bool, bool *, bool *);
47 #define VERIFY_CONSTANT(X)                                              \
48 do {                                                                    \
49   if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
50     return t;                                                           \
51  } while (0)
52
53 /* Returns true iff FUN is an instantiation of a constexpr function
54    template or a defaulted constexpr function.  */
55
56 bool
57 is_instantiation_of_constexpr (tree fun)
58 {
59   return ((DECL_TEMPLOID_INSTANTIATION (fun)
60            && DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun)))
61           || (DECL_DEFAULTED_FN (fun)
62               && DECL_DECLARED_CONSTEXPR_P (fun)));
63 }
64
65 /* Return true if T is a literal type.   */
66
67 bool
68 literal_type_p (tree t)
69 {
70   if (SCALAR_TYPE_P (t)
71       || TREE_CODE (t) == VECTOR_TYPE
72       || TREE_CODE (t) == REFERENCE_TYPE
73       || (VOID_TYPE_P (t) && cxx_dialect >= cxx14))
74     return true;
75   if (CLASS_TYPE_P (t))
76     {
77       t = complete_type (t);
78       gcc_assert (COMPLETE_TYPE_P (t) || errorcount);
79       return CLASSTYPE_LITERAL_P (t);
80     }
81   if (TREE_CODE (t) == ARRAY_TYPE)
82     return literal_type_p (strip_array_types (t));
83   return false;
84 }
85
86 /* If DECL is a variable declared `constexpr', require its type
87    be literal.  Return the DECL if OK, otherwise NULL.  */
88
89 tree
90 ensure_literal_type_for_constexpr_object (tree decl)
91 {
92   tree type = TREE_TYPE (decl);
93   if (VAR_P (decl)
94       && (DECL_DECLARED_CONSTEXPR_P (decl)
95           || var_in_constexpr_fn (decl))
96       && !processing_template_decl)
97     {
98       tree stype = strip_array_types (type);
99       if (CLASS_TYPE_P (stype) && !COMPLETE_TYPE_P (complete_type (stype)))
100         /* Don't complain here, we'll complain about incompleteness
101            when we try to initialize the variable.  */;
102       else if (!literal_type_p (type))
103         {
104           if (DECL_DECLARED_CONSTEXPR_P (decl))
105             {
106               error ("the type %qT of constexpr variable %qD is not literal",
107                      type, decl);
108               explain_non_literal_class (type);
109             }
110           else
111             {
112               if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl))
113                 {
114                   error ("variable %qD of non-literal type %qT in %<constexpr%> "
115                          "function", decl, type);
116                   explain_non_literal_class (type);
117                 }
118               cp_function_chain->invalid_constexpr = true;
119             }
120           return NULL;
121         }
122     }
123   return decl;
124 }
125
126 /* Representation of entries in the constexpr function definition table.  */
127
128 struct GTY((for_user)) constexpr_fundef {
129   tree decl;
130   tree body;
131 };
132
133 struct constexpr_fundef_hasher : ggc_hasher<constexpr_fundef *>
134 {
135   static hashval_t hash (constexpr_fundef *);
136   static bool equal (constexpr_fundef *, constexpr_fundef *);
137 };
138
139 /* This table holds all constexpr function definitions seen in
140    the current translation unit.  */
141
142 static GTY (()) hash_table<constexpr_fundef_hasher> *constexpr_fundef_table;
143
144 /* Utility function used for managing the constexpr function table.
145    Return true if the entries pointed to by P and Q are for the
146    same constexpr function.  */
147
148 inline bool
149 constexpr_fundef_hasher::equal (constexpr_fundef *lhs, constexpr_fundef *rhs)
150 {
151   return lhs->decl == rhs->decl;
152 }
153
154 /* Utility function used for managing the constexpr function table.
155    Return a hash value for the entry pointed to by Q.  */
156
157 inline hashval_t
158 constexpr_fundef_hasher::hash (constexpr_fundef *fundef)
159 {
160   return DECL_UID (fundef->decl);
161 }
162
163 /* Return a previously saved definition of function FUN.   */
164
165 static constexpr_fundef *
166 retrieve_constexpr_fundef (tree fun)
167 {
168   constexpr_fundef fundef = { NULL, NULL };
169   if (constexpr_fundef_table == NULL)
170     return NULL;
171
172   fundef.decl = fun;
173   return constexpr_fundef_table->find (&fundef);
174 }
175
176 /* Check whether the parameter and return types of FUN are valid for a
177    constexpr function, and complain if COMPLAIN.  */
178
179 static bool
180 is_valid_constexpr_fn (tree fun, bool complain)
181 {
182   bool ret = true;
183
184   if (DECL_INHERITED_CTOR_BASE (fun)
185       && TREE_CODE (fun) == TEMPLATE_DECL)
186     {
187       ret = false;
188       if (complain)
189         error ("inherited constructor %qD is not constexpr",
190                get_inherited_ctor (fun));
191     }
192   else
193     {
194       for (tree parm = FUNCTION_FIRST_USER_PARM (fun);
195            parm != NULL_TREE; parm = TREE_CHAIN (parm))
196         if (!literal_type_p (TREE_TYPE (parm)))
197           {
198             ret = false;
199             if (complain)
200               {
201                 error ("invalid type for parameter %d of constexpr "
202                        "function %q+#D", DECL_PARM_INDEX (parm), fun);
203                 explain_non_literal_class (TREE_TYPE (parm));
204               }
205           }
206     }
207
208   if (!DECL_CONSTRUCTOR_P (fun))
209     {
210       tree rettype = TREE_TYPE (TREE_TYPE (fun));
211       if (!literal_type_p (rettype))
212         {
213           ret = false;
214           if (complain)
215             {
216               error ("invalid return type %qT of constexpr function %q+D",
217                      rettype, fun);
218               explain_non_literal_class (rettype);
219             }
220         }
221
222       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
223           && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun)))
224         {
225           ret = false;
226           if (complain)
227             {
228               error ("enclosing class of constexpr non-static member "
229                      "function %q+#D is not a literal type", fun);
230               explain_non_literal_class (DECL_CONTEXT (fun));
231             }
232         }
233     }
234   else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun)))
235     {
236       ret = false;
237       if (complain)
238         error ("%q#T has virtual base classes", DECL_CONTEXT (fun));
239     }
240
241   return ret;
242 }
243
244 /* Subroutine of build_data_member_initialization.  MEMBER is a COMPONENT_REF
245    for a member of an anonymous aggregate, INIT is the initializer for that
246    member, and VEC_OUTER is the vector of constructor elements for the class
247    whose constructor we are processing.  Add the initializer to the vector
248    and return true to indicate success.  */
249
250 static bool
251 build_anon_member_initialization (tree member, tree init,
252                                   vec<constructor_elt, va_gc> **vec_outer)
253 {
254   /* MEMBER presents the relevant fields from the inside out, but we need
255      to build up the initializer from the outside in so that we can reuse
256      previously built CONSTRUCTORs if this is, say, the second field in an
257      anonymous struct.  So we use a vec as a stack.  */
258   auto_vec<tree, 2> fields;
259   do
260     {
261       fields.safe_push (TREE_OPERAND (member, 1));
262       member = TREE_OPERAND (member, 0);
263     }
264   while (ANON_AGGR_TYPE_P (TREE_TYPE (member))
265          && TREE_CODE (member) == COMPONENT_REF);
266
267   /* VEC has the constructor elements vector for the context of FIELD.
268      If FIELD is an anonymous aggregate, we will push inside it.  */
269   vec<constructor_elt, va_gc> **vec = vec_outer;
270   tree field;
271   while (field = fields.pop(),
272          ANON_AGGR_TYPE_P (TREE_TYPE (field)))
273     {
274       tree ctor;
275       /* If there is already an outer constructor entry for the anonymous
276          aggregate FIELD, use it; otherwise, insert one.  */
277       if (vec_safe_is_empty (*vec)
278           || (*vec)->last().index != field)
279         {
280           ctor = build_constructor (TREE_TYPE (field), NULL);
281           CONSTRUCTOR_APPEND_ELT (*vec, field, ctor);
282         }
283       else
284         ctor = (*vec)->last().value;
285       vec = &CONSTRUCTOR_ELTS (ctor);
286     }
287
288   /* Now we're at the innermost field, the one that isn't an anonymous
289      aggregate.  Add its initializer to the CONSTRUCTOR and we're done.  */
290   gcc_assert (fields.is_empty());
291   CONSTRUCTOR_APPEND_ELT (*vec, field, init);
292
293   return true;
294 }
295
296 /* Subroutine of  build_constexpr_constructor_member_initializers.
297    The expression tree T represents a data member initialization
298    in a (constexpr) constructor definition.  Build a pairing of
299    the data member with its initializer, and prepend that pair
300    to the existing initialization pair INITS.  */
301
302 static bool
303 build_data_member_initialization (tree t, vec<constructor_elt, va_gc> **vec)
304 {
305   tree member, init;
306   if (TREE_CODE (t) == CLEANUP_POINT_EXPR)
307     t = TREE_OPERAND (t, 0);
308   if (TREE_CODE (t) == EXPR_STMT)
309     t = TREE_OPERAND (t, 0);
310   if (t == error_mark_node)
311     return false;
312   if (TREE_CODE (t) == STATEMENT_LIST)
313     {
314       tree_stmt_iterator i;
315       for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
316         {
317           if (! build_data_member_initialization (tsi_stmt (i), vec))
318             return false;
319         }
320       return true;
321     }
322   if (TREE_CODE (t) == CLEANUP_STMT)
323     {
324       /* We can't see a CLEANUP_STMT in a constructor for a literal class,
325          but we can in a constexpr constructor for a non-literal class.  Just
326          ignore it; either all the initialization will be constant, in which
327          case the cleanup can't run, or it can't be constexpr.
328          Still recurse into CLEANUP_BODY.  */
329       return build_data_member_initialization (CLEANUP_BODY (t), vec);
330     }
331   if (TREE_CODE (t) == CONVERT_EXPR)
332     t = TREE_OPERAND (t, 0);
333   if (TREE_CODE (t) == INIT_EXPR
334       /* vptr initialization shows up as a MODIFY_EXPR.  In C++14 we only
335          use what this function builds for cx_check_missing_mem_inits, and
336          assignment in the ctor body doesn't count.  */
337       || (cxx_dialect < cxx14 && TREE_CODE (t) == MODIFY_EXPR))
338     {
339       member = TREE_OPERAND (t, 0);
340       init = break_out_target_exprs (TREE_OPERAND (t, 1));
341     }
342   else if (TREE_CODE (t) == CALL_EXPR)
343     {
344       tree fn = get_callee_fndecl (t);
345       if (!fn || !DECL_CONSTRUCTOR_P (fn))
346         /* We're only interested in calls to subobject constructors.  */
347         return true;
348       member = CALL_EXPR_ARG (t, 0);
349       /* We don't use build_cplus_new here because it complains about
350          abstract bases.  Leaving the call unwrapped means that it has the
351          wrong type, but cxx_eval_constant_expression doesn't care.  */
352       init = break_out_target_exprs (t);
353     }
354   else if (TREE_CODE (t) == BIND_EXPR)
355     return build_data_member_initialization (BIND_EXPR_BODY (t), vec);
356   else
357     /* Don't add anything else to the CONSTRUCTOR.  */
358     return true;
359   if (INDIRECT_REF_P (member))
360     member = TREE_OPERAND (member, 0);
361   if (TREE_CODE (member) == NOP_EXPR)
362     {
363       tree op = member;
364       STRIP_NOPS (op);
365       if (TREE_CODE (op) == ADDR_EXPR)
366         {
367           gcc_assert (same_type_ignoring_top_level_qualifiers_p
368                       (TREE_TYPE (TREE_TYPE (op)),
369                        TREE_TYPE (TREE_TYPE (member))));
370           /* Initializing a cv-qualified member; we need to look through
371              the const_cast.  */
372           member = op;
373         }
374       else if (op == current_class_ptr
375                && (same_type_ignoring_top_level_qualifiers_p
376                    (TREE_TYPE (TREE_TYPE (member)),
377                     current_class_type)))
378         /* Delegating constructor.  */
379         member = op;
380       else
381         {
382           /* This is an initializer for an empty base; keep it for now so
383              we can check it in cxx_eval_bare_aggregate.  */
384           gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member))));
385         }
386     }
387   if (TREE_CODE (member) == ADDR_EXPR)
388     member = TREE_OPERAND (member, 0);
389   if (TREE_CODE (member) == COMPONENT_REF)
390     {
391       tree aggr = TREE_OPERAND (member, 0);
392       if (TREE_CODE (aggr) != COMPONENT_REF)
393         /* Normal member initialization.  */
394         member = TREE_OPERAND (member, 1);
395       else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr)))
396         /* Initializing a member of an anonymous union.  */
397         return build_anon_member_initialization (member, init, vec);
398       else
399         /* We're initializing a vtable pointer in a base.  Leave it as
400            COMPONENT_REF so we remember the path to get to the vfield.  */
401         gcc_assert (TREE_TYPE (member) == vtbl_ptr_type_node);
402     }
403
404   CONSTRUCTOR_APPEND_ELT (*vec, member, init);
405   return true;
406 }
407
408 /* Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.
409    In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a 
410    BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations.  */
411
412 static bool
413 check_constexpr_bind_expr_vars (tree t)
414 {
415   gcc_assert (TREE_CODE (t) == BIND_EXPR);
416
417   for (tree var = BIND_EXPR_VARS (t); var; var = DECL_CHAIN (var))
418     if (TREE_CODE (var) == TYPE_DECL
419         && DECL_IMPLICIT_TYPEDEF_P (var))
420       return false;
421   return true;
422 }
423
424 /* Subroutine of check_constexpr_ctor_body.  */
425
426 static bool
427 check_constexpr_ctor_body_1 (tree last, tree list)
428 {
429   switch (TREE_CODE (list))
430     {
431     case DECL_EXPR:
432       if (TREE_CODE (DECL_EXPR_DECL (list)) == USING_DECL)
433         return true;
434       return false;
435
436     case CLEANUP_POINT_EXPR:
437       return check_constexpr_ctor_body (last, TREE_OPERAND (list, 0),
438                                         /*complain=*/false);
439
440     case BIND_EXPR:
441        if (!check_constexpr_bind_expr_vars (list)
442            || !check_constexpr_ctor_body (last, BIND_EXPR_BODY (list),
443                                           /*complain=*/false))
444          return false;
445        return true;
446
447     case USING_STMT:
448     case STATIC_ASSERT:
449       return true;
450
451     default:
452       return false;
453     }
454 }
455
456 /* Make sure that there are no statements after LAST in the constructor
457    body represented by LIST.  */
458
459 bool
460 check_constexpr_ctor_body (tree last, tree list, bool complain)
461 {
462   /* C++14 doesn't require a constexpr ctor to have an empty body.  */
463   if (cxx_dialect >= cxx14)
464     return true;
465
466   bool ok = true;
467   if (TREE_CODE (list) == STATEMENT_LIST)
468     {
469       tree_stmt_iterator i = tsi_last (list);
470       for (; !tsi_end_p (i); tsi_prev (&i))
471         {
472           tree t = tsi_stmt (i);
473           if (t == last)
474             break;
475           if (!check_constexpr_ctor_body_1 (last, t))
476             {
477               ok = false;
478               break;
479             }
480         }
481     }
482   else if (list != last
483            && !check_constexpr_ctor_body_1 (last, list))
484     ok = false;
485   if (!ok)
486     {
487       if (complain)
488         error ("constexpr constructor does not have empty body");
489       DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;
490     }
491   return ok;
492 }
493
494 /* V is a vector of constructor elements built up for the base and member
495    initializers of a constructor for TYPE.  They need to be in increasing
496    offset order, which they might not be yet if TYPE has a primary base
497    which is not first in the base-clause or a vptr and at least one base
498    all of which are non-primary.  */
499
500 static vec<constructor_elt, va_gc> *
501 sort_constexpr_mem_initializers (tree type, vec<constructor_elt, va_gc> *v)
502 {
503   tree pri = CLASSTYPE_PRIMARY_BINFO (type);
504   tree field_type;
505   unsigned i;
506   constructor_elt *ce;
507
508   if (pri)
509     field_type = BINFO_TYPE (pri);
510   else if (TYPE_CONTAINS_VPTR_P (type))
511     field_type = vtbl_ptr_type_node;
512   else
513     return v;
514
515   /* Find the element for the primary base or vptr and move it to the
516      beginning of the vec.  */
517   for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
518     if (TREE_TYPE (ce->index) == field_type)
519       break;
520
521   if (i > 0 && i < vec_safe_length (v))
522     {
523       vec<constructor_elt, va_gc> &vref = *v;
524       constructor_elt elt = vref[i];
525       for (; i > 0; --i)
526         vref[i] = vref[i-1];
527       vref[0] = elt;
528     }
529
530   return v;
531 }
532
533 /* Build compile-time evalable representations of member-initializer list
534    for a constexpr constructor.  */
535
536 static tree
537 build_constexpr_constructor_member_initializers (tree type, tree body)
538 {
539   vec<constructor_elt, va_gc> *vec = NULL;
540   bool ok = true;
541   if (TREE_CODE (body) == MUST_NOT_THROW_EXPR
542       || TREE_CODE (body) == EH_SPEC_BLOCK)
543     body = TREE_OPERAND (body, 0);
544   if (TREE_CODE (body) == STATEMENT_LIST)
545     body = STATEMENT_LIST_HEAD (body)->stmt;
546   body = BIND_EXPR_BODY (body);
547   if (TREE_CODE (body) == CLEANUP_POINT_EXPR)
548     {
549       body = TREE_OPERAND (body, 0);
550       if (TREE_CODE (body) == EXPR_STMT)
551         body = TREE_OPERAND (body, 0);
552       if (TREE_CODE (body) == INIT_EXPR
553           && (same_type_ignoring_top_level_qualifiers_p
554               (TREE_TYPE (TREE_OPERAND (body, 0)),
555                current_class_type)))
556         {
557           /* Trivial copy.  */
558           return TREE_OPERAND (body, 1);
559         }
560       ok = build_data_member_initialization (body, &vec);
561     }
562   else if (TREE_CODE (body) == STATEMENT_LIST)
563     {
564       tree_stmt_iterator i;
565       for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
566         {
567           ok = build_data_member_initialization (tsi_stmt (i), &vec);
568           if (!ok)
569             break;
570         }
571     }
572   else if (TREE_CODE (body) == TRY_BLOCK)
573     {
574       error ("body of %<constexpr%> constructor cannot be "
575              "a function-try-block");
576       return error_mark_node;
577     }
578   else if (EXPR_P (body))
579     ok = build_data_member_initialization (body, &vec);
580   else
581     gcc_assert (errorcount > 0);
582   if (ok)
583     {
584       if (vec_safe_length (vec) > 0)
585         {
586           /* In a delegating constructor, return the target.  */
587           constructor_elt *ce = &(*vec)[0];
588           if (ce->index == current_class_ptr)
589             {
590               body = ce->value;
591               vec_free (vec);
592               return body;
593             }
594         }
595       vec = sort_constexpr_mem_initializers (type, vec);
596       return build_constructor (type, vec);
597     }
598   else
599     return error_mark_node;
600 }
601
602 /* Subroutine of register_constexpr_fundef.  BODY is the body of a function
603    declared to be constexpr, or a sub-statement thereof.  Returns the
604    return value if suitable, error_mark_node for a statement not allowed in
605    a constexpr function, or NULL_TREE if no return value was found.  */
606
607 static tree
608 constexpr_fn_retval (tree body)
609 {
610   switch (TREE_CODE (body))
611     {
612     case STATEMENT_LIST:
613       {
614         tree_stmt_iterator i;
615         tree expr = NULL_TREE;
616         for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
617           {
618             tree s = constexpr_fn_retval (tsi_stmt (i));
619             if (s == error_mark_node)
620               return error_mark_node;
621             else if (s == NULL_TREE)
622               /* Keep iterating.  */;
623             else if (expr)
624               /* Multiple return statements.  */
625               return error_mark_node;
626             else
627               expr = s;
628           }
629         return expr;
630       }
631
632     case RETURN_EXPR:
633       return break_out_target_exprs (TREE_OPERAND (body, 0));
634
635     case DECL_EXPR:
636       {
637         tree decl = DECL_EXPR_DECL (body);
638         if (TREE_CODE (decl) == USING_DECL
639             /* Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__.  */
640             || DECL_ARTIFICIAL (decl))
641           return NULL_TREE;
642         return error_mark_node;
643       }
644
645     case CLEANUP_POINT_EXPR:
646       return constexpr_fn_retval (TREE_OPERAND (body, 0));
647
648     case BIND_EXPR:
649       if (!check_constexpr_bind_expr_vars (body))
650         return error_mark_node;
651       return constexpr_fn_retval (BIND_EXPR_BODY (body));
652
653     case USING_STMT:
654       return NULL_TREE;
655
656     default:
657       return error_mark_node;
658     }
659 }
660
661 /* Subroutine of register_constexpr_fundef.  BODY is the DECL_SAVED_TREE of
662    FUN; do the necessary transformations to turn it into a single expression
663    that we can store in the hash table.  */
664
665 static tree
666 massage_constexpr_body (tree fun, tree body)
667 {
668   if (DECL_CONSTRUCTOR_P (fun))
669     body = build_constexpr_constructor_member_initializers
670       (DECL_CONTEXT (fun), body);
671   else if (cxx_dialect < cxx14)
672     {
673       if (TREE_CODE (body) == EH_SPEC_BLOCK)
674         body = EH_SPEC_STMTS (body);
675       if (TREE_CODE (body) == MUST_NOT_THROW_EXPR)
676         body = TREE_OPERAND (body, 0);
677       body = constexpr_fn_retval (body);
678     }
679   return body;
680 }
681
682 /* FUN is a constexpr constructor with massaged body BODY.  Return true
683    if some bases/fields are uninitialized, and complain if COMPLAIN.  */
684
685 static bool
686 cx_check_missing_mem_inits (tree fun, tree body, bool complain)
687 {
688   bool bad;
689   tree field;
690   unsigned i, nelts;
691   tree ctype;
692
693   if (TREE_CODE (body) != CONSTRUCTOR)
694     return false;
695
696   nelts = CONSTRUCTOR_NELTS (body);
697   ctype = DECL_CONTEXT (fun);
698   field = TYPE_FIELDS (ctype);
699
700   if (TREE_CODE (ctype) == UNION_TYPE)
701     {
702       if (nelts == 0 && next_initializable_field (field))
703         {
704           if (complain)
705             error ("%<constexpr%> constructor for union %qT must "
706                    "initialize exactly one non-static data member", ctype);
707           return true;
708         }
709       return false;
710     }
711
712   bad = false;
713   for (i = 0; i <= nelts; ++i)
714     {
715       tree index;
716       if (i == nelts)
717         index = NULL_TREE;
718       else
719         {
720           index = CONSTRUCTOR_ELT (body, i)->index;
721           /* Skip base and vtable inits.  */
722           if (TREE_CODE (index) != FIELD_DECL
723               || DECL_ARTIFICIAL (index))
724             continue;
725         }
726       for (; field != index; field = DECL_CHAIN (field))
727         {
728           tree ftype;
729           if (TREE_CODE (field) != FIELD_DECL
730               || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
731               || DECL_ARTIFICIAL (field))
732             continue;
733           ftype = strip_array_types (TREE_TYPE (field));
734           if (type_has_constexpr_default_constructor (ftype))
735             {
736               /* It's OK to skip a member with a trivial constexpr ctor.
737                  A constexpr ctor that isn't trivial should have been
738                  added in by now.  */
739               gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype)
740                                    || errorcount != 0);
741               continue;
742             }
743           if (!complain)
744             return true;
745           error ("member %qD must be initialized by mem-initializer "
746                  "in %<constexpr%> constructor", field);
747           inform (DECL_SOURCE_LOCATION (field), "declared here");
748           bad = true;
749         }
750       if (field == NULL_TREE)
751         break;
752       field = DECL_CHAIN (field);
753     }
754
755   return bad;
756 }
757
758 /* We are processing the definition of the constexpr function FUN.
759    Check that its BODY fulfills the propriate requirements and
760    enter it in the constexpr function definition table.
761    For constructor BODY is actually the TREE_LIST of the
762    member-initializer list.  */
763
764 tree
765 register_constexpr_fundef (tree fun, tree body)
766 {
767   constexpr_fundef entry;
768   constexpr_fundef **slot;
769
770   if (!is_valid_constexpr_fn (fun, !DECL_GENERATED_P (fun)))
771     return NULL;
772
773   body = massage_constexpr_body (fun, body);
774   if (body == NULL_TREE || body == error_mark_node)
775     {
776       if (!DECL_CONSTRUCTOR_P (fun))
777         error ("body of constexpr function %qD not a return-statement", fun);
778       return NULL;
779     }
780
781   if (!potential_rvalue_constant_expression (body))
782     {
783       if (!DECL_GENERATED_P (fun))
784         require_potential_rvalue_constant_expression (body);
785       return NULL;
786     }
787
788   if (DECL_CONSTRUCTOR_P (fun)
789       && cx_check_missing_mem_inits (fun, body, !DECL_GENERATED_P (fun)))
790     return NULL;
791
792   /* Create the constexpr function table if necessary.  */
793   if (constexpr_fundef_table == NULL)
794     constexpr_fundef_table
795       = hash_table<constexpr_fundef_hasher>::create_ggc (101);
796
797   entry.decl = fun;
798   entry.body = body;
799   slot = constexpr_fundef_table->find_slot (&entry, INSERT);
800
801   gcc_assert (*slot == NULL);
802   *slot = ggc_alloc<constexpr_fundef> ();
803   **slot = entry;
804
805   return fun;
806 }
807
808 /* FUN is a non-constexpr function called in a context that requires a
809    constant expression.  If it comes from a constexpr template, explain why
810    the instantiation isn't constexpr.  */
811
812 void
813 explain_invalid_constexpr_fn (tree fun)
814 {
815   static hash_set<tree> *diagnosed;
816   tree body;
817   location_t save_loc;
818   /* Only diagnose defaulted functions or instantiations.  */
819   if (!DECL_DEFAULTED_FN (fun)
820       && !is_instantiation_of_constexpr (fun))
821     return;
822   if (diagnosed == NULL)
823     diagnosed = new hash_set<tree>;
824   if (diagnosed->add (fun))
825     /* Already explained.  */
826     return;
827
828   save_loc = input_location;
829   input_location = DECL_SOURCE_LOCATION (fun);
830   inform (0, "%q+D is not usable as a constexpr function because:", fun);
831   /* First check the declaration.  */
832   if (is_valid_constexpr_fn (fun, true))
833     {
834       /* Then if it's OK, the body.  */
835       if (!DECL_DECLARED_CONSTEXPR_P (fun))
836         explain_implicit_non_constexpr (fun);
837       else
838         {
839           body = massage_constexpr_body (fun, DECL_SAVED_TREE (fun));
840           require_potential_rvalue_constant_expression (body);
841           if (DECL_CONSTRUCTOR_P (fun))
842             cx_check_missing_mem_inits (fun, body, true);
843         }
844     }
845   input_location = save_loc;
846 }
847
848 /* Objects of this type represent calls to constexpr functions
849    along with the bindings of parameters to their arguments, for
850    the purpose of compile time evaluation.  */
851
852 struct GTY((for_user)) constexpr_call {
853   /* Description of the constexpr function definition.  */
854   constexpr_fundef *fundef;
855   /* Parameter bindings environment.  A TREE_LIST where each TREE_PURPOSE
856      is a parameter _DECL and the TREE_VALUE is the value of the parameter.
857      Note: This arrangement is made to accommodate the use of
858      iterative_hash_template_arg (see pt.c).  If you change this
859      representation, also change the hash calculation in
860      cxx_eval_call_expression.  */
861   tree bindings;
862   /* Result of the call.
863        NULL means the call is being evaluated.
864        error_mark_node means that the evaluation was erroneous;
865        otherwise, the actuall value of the call.  */
866   tree result;
867   /* The hash of this call; we remember it here to avoid having to
868      recalculate it when expanding the hash table.  */
869   hashval_t hash;
870 };
871
872 struct constexpr_call_hasher : ggc_hasher<constexpr_call *>
873 {
874   static hashval_t hash (constexpr_call *);
875   static bool equal (constexpr_call *, constexpr_call *);
876 };
877
878 /* The constexpr expansion context.  CALL is the current function
879    expansion, CTOR is the current aggregate initializer, OBJECT is the
880    object being initialized by CTOR, either a VAR_DECL or a _REF.  VALUES
881    is a map of values of variables initialized within the expression.  */
882
883 struct constexpr_ctx {
884   /* The innermost call we're evaluating.  */
885   constexpr_call *call;
886   /* Values for any temporaries or local variables within the
887      constant-expression. */
888   hash_map<tree,tree> *values;
889   /* The CONSTRUCTOR we're currently building up for an aggregate
890      initializer.  */
891   tree ctor;
892   /* The object we're building the CONSTRUCTOR for.  */
893   tree object;
894   /* Whether we should error on a non-constant expression or fail quietly.  */
895   bool quiet;
896   /* Whether we are strictly conforming to constant expression rules or
897      trying harder to get a constant value.  */
898   bool strict;
899 };
900
901 /* A table of all constexpr calls that have been evaluated by the
902    compiler in this translation unit.  */
903
904 static GTY (()) hash_table<constexpr_call_hasher> *constexpr_call_table;
905
906 static tree cxx_eval_constant_expression (const constexpr_ctx *, tree,
907                                           bool, bool *, bool *, tree * = NULL);
908
909 /* Compute a hash value for a constexpr call representation.  */
910
911 inline hashval_t
912 constexpr_call_hasher::hash (constexpr_call *info)
913 {
914   return info->hash;
915 }
916
917 /* Return true if the objects pointed to by P and Q represent calls
918    to the same constexpr function with the same arguments.
919    Otherwise, return false.  */
920
921 bool
922 constexpr_call_hasher::equal (constexpr_call *lhs, constexpr_call *rhs)
923 {
924   tree lhs_bindings;
925   tree rhs_bindings;
926   if (lhs == rhs)
927     return 1;
928   if (!constexpr_fundef_hasher::equal (lhs->fundef, rhs->fundef))
929     return 0;
930   lhs_bindings = lhs->bindings;
931   rhs_bindings = rhs->bindings;
932   while (lhs_bindings != NULL && rhs_bindings != NULL)
933     {
934       tree lhs_arg = TREE_VALUE (lhs_bindings);
935       tree rhs_arg = TREE_VALUE (rhs_bindings);
936       gcc_assert (TREE_TYPE (lhs_arg) == TREE_TYPE (rhs_arg));
937       if (!cp_tree_equal (lhs_arg, rhs_arg))
938         return 0;
939       lhs_bindings = TREE_CHAIN (lhs_bindings);
940       rhs_bindings = TREE_CHAIN (rhs_bindings);
941     }
942   return lhs_bindings == rhs_bindings;
943 }
944
945 /* Initialize the constexpr call table, if needed.  */
946
947 static void
948 maybe_initialize_constexpr_call_table (void)
949 {
950   if (constexpr_call_table == NULL)
951     constexpr_call_table = hash_table<constexpr_call_hasher>::create_ggc (101);
952 }
953
954 /* We have an expression tree T that represents a call, either CALL_EXPR
955    or AGGR_INIT_EXPR.  If the call is lexically to a named function,
956    retrun the _DECL for that function.  */
957
958 static tree
959 get_function_named_in_call (tree t)
960 {
961   tree fun = NULL;
962   switch (TREE_CODE (t))
963     {
964     case CALL_EXPR:
965       fun = CALL_EXPR_FN (t);
966       break;
967
968     case AGGR_INIT_EXPR:
969       fun = AGGR_INIT_EXPR_FN (t);
970       break;
971
972     default:
973       gcc_unreachable();
974       break;
975     }
976   if (fun && TREE_CODE (fun) == ADDR_EXPR
977       && TREE_CODE (TREE_OPERAND (fun, 0)) == FUNCTION_DECL)
978     fun = TREE_OPERAND (fun, 0);
979   return fun;
980 }
981
982 /* We have an expression tree T that represents a call, either CALL_EXPR
983    or AGGR_INIT_EXPR.  Return the Nth argument.  */
984
985 static inline tree
986 get_nth_callarg (tree t, int n)
987 {
988   switch (TREE_CODE (t))
989     {
990     case CALL_EXPR:
991       return CALL_EXPR_ARG (t, n);
992
993     case AGGR_INIT_EXPR:
994       return AGGR_INIT_EXPR_ARG (t, n);
995
996     default:
997       gcc_unreachable ();
998       return NULL;
999     }
1000 }
1001
1002 /* Look up the binding of the function parameter T in a constexpr
1003    function call context CALL.  */
1004
1005 static tree
1006 lookup_parameter_binding (const constexpr_call *call, tree t)
1007 {
1008   tree b = purpose_member (t, call->bindings);
1009   return TREE_VALUE (b);
1010 }
1011
1012 /* Attempt to evaluate T which represents a call to a builtin function.
1013    We assume here that all builtin functions evaluate to scalar types
1014    represented by _CST nodes.  */
1015
1016 static tree
1017 cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t,
1018                                 bool lval,
1019                                 bool *non_constant_p, bool *overflow_p)
1020 {
1021   const int nargs = call_expr_nargs (t);
1022   tree *args = (tree *) alloca (nargs * sizeof (tree));
1023   tree new_call;
1024   int i;
1025   for (i = 0; i < nargs; ++i)
1026     {
1027       args[i] = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, i),
1028                                               lval,
1029                                               non_constant_p, overflow_p);
1030       if (ctx->quiet && *non_constant_p)
1031         return t;
1032     }
1033   if (*non_constant_p)
1034     return t;
1035   new_call = fold_build_call_array_loc (EXPR_LOCATION (t), TREE_TYPE (t),
1036                                         CALL_EXPR_FN (t), nargs, args);
1037   VERIFY_CONSTANT (new_call);
1038   return new_call;
1039 }
1040
1041 /* TEMP is the constant value of a temporary object of type TYPE.  Adjust
1042    the type of the value to match.  */
1043
1044 static tree
1045 adjust_temp_type (tree type, tree temp)
1046 {
1047   if (TREE_TYPE (temp) == type)
1048     return temp;
1049   /* Avoid wrapping an aggregate value in a NOP_EXPR.  */
1050   if (TREE_CODE (temp) == CONSTRUCTOR)
1051     return build_constructor (type, CONSTRUCTOR_ELTS (temp));
1052   gcc_assert (scalarish_type_p (type));
1053   return cp_fold_convert (type, temp);
1054 }
1055
1056 /* True if we want to use the new handling of constexpr calls based on
1057    DECL_SAVED_TREE.  */
1058 #define use_new_call true
1059
1060 /* Subroutine of cxx_eval_call_expression.
1061    We are processing a call expression (either CALL_EXPR or
1062    AGGR_INIT_EXPR) in the context of CTX.  Evaluate
1063    all arguments and bind their values to correspondings
1064    parameters, making up the NEW_CALL context.  */
1065
1066 static void
1067 cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t,
1068                              constexpr_call *new_call,
1069                              bool *non_constant_p, bool *overflow_p,
1070                              bool *non_constant_args)
1071 {
1072   const int nargs = call_expr_nargs (t);
1073   tree fun = new_call->fundef->decl;
1074   tree parms = DECL_ARGUMENTS (fun);
1075   int i;
1076   tree *p = &new_call->bindings;
1077   for (i = 0; i < nargs; ++i)
1078     {
1079       tree x, arg;
1080       tree type = parms ? TREE_TYPE (parms) : void_type_node;
1081       x = get_nth_callarg (t, i);
1082       /* For member function, the first argument is a pointer to the implied
1083          object.  For a constructor, it might still be a dummy object, in
1084          which case we get the real argument from ctx. */
1085       if (i == 0 && DECL_CONSTRUCTOR_P (fun)
1086           && is_dummy_object (x))
1087         {
1088           x = ctx->object;
1089           x = cp_build_addr_expr (x, tf_warning_or_error);
1090         }
1091       bool lval = false;
1092       if (parms && DECL_BY_REFERENCE (parms) && !use_new_call)
1093         {
1094           /* cp_genericize made this a reference for argument passing, but
1095              we don't want to treat it like one for C++11 constexpr
1096              evaluation.  C++14 constexpr evaluation uses the genericized
1097              DECL_SAVED_TREE.  */
1098           gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1099           gcc_assert (TREE_CODE (TREE_TYPE (x)) == REFERENCE_TYPE);
1100           type = TREE_TYPE (type);
1101           x = convert_from_reference (x);
1102           lval = true;
1103         }
1104       arg = cxx_eval_constant_expression (ctx, x, lval,
1105                                           non_constant_p, overflow_p);
1106       /* Don't VERIFY_CONSTANT here.  */
1107       if (*non_constant_p && ctx->quiet)
1108         return;
1109       /* Just discard ellipsis args after checking their constantitude.  */
1110       if (!parms)
1111         continue;
1112       if (*non_constant_p)
1113         /* Don't try to adjust the type of non-constant args.  */
1114         goto next;
1115
1116       /* Make sure the binding has the same type as the parm.  */
1117       if (TREE_CODE (type) != REFERENCE_TYPE)
1118         arg = adjust_temp_type (type, arg);
1119       if (!TREE_CONSTANT (arg))
1120         *non_constant_args = true;
1121       *p = build_tree_list (parms, arg);
1122       p = &TREE_CHAIN (*p);
1123     next:
1124       parms = TREE_CHAIN (parms);
1125     }
1126 }
1127
1128 /* Variables and functions to manage constexpr call expansion context.
1129    These do not need to be marked for PCH or GC.  */
1130
1131 /* FIXME remember and print actual constant arguments.  */
1132 static vec<tree> call_stack = vNULL;
1133 static int call_stack_tick;
1134 static int last_cx_error_tick;
1135
1136 static bool
1137 push_cx_call_context (tree call)
1138 {
1139   ++call_stack_tick;
1140   if (!EXPR_HAS_LOCATION (call))
1141     SET_EXPR_LOCATION (call, input_location);
1142   call_stack.safe_push (call);
1143   if (call_stack.length () > (unsigned) max_constexpr_depth)
1144     return false;
1145   return true;
1146 }
1147
1148 static void
1149 pop_cx_call_context (void)
1150 {
1151   ++call_stack_tick;
1152   call_stack.pop ();
1153 }
1154
1155 vec<tree> 
1156 cx_error_context (void)
1157 {
1158   vec<tree> r = vNULL;
1159   if (call_stack_tick != last_cx_error_tick
1160       && !call_stack.is_empty ())
1161     r = call_stack;
1162   last_cx_error_tick = call_stack_tick;
1163   return r;
1164 }
1165
1166 /* Subroutine of cxx_eval_constant_expression.
1167    Evaluate the call expression tree T in the context of OLD_CALL expression
1168    evaluation.  */
1169
1170 static tree
1171 cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
1172                           bool lval,
1173                           bool *non_constant_p, bool *overflow_p)
1174 {
1175   location_t loc = EXPR_LOC_OR_LOC (t, input_location);
1176   tree fun = get_function_named_in_call (t);
1177   constexpr_call new_call = { NULL, NULL, NULL, 0 };
1178   bool depth_ok;
1179
1180   if (fun == NULL_TREE)
1181     switch (CALL_EXPR_IFN (t))
1182       {
1183       case IFN_UBSAN_NULL:
1184       case IFN_UBSAN_BOUNDS:
1185       case IFN_UBSAN_VPTR:
1186         return void_node;
1187       default:
1188         if (!ctx->quiet)
1189           error_at (loc, "call to internal function");
1190         *non_constant_p = true;
1191         return t;
1192       }
1193
1194   if (TREE_CODE (fun) != FUNCTION_DECL)
1195     {
1196       /* Might be a constexpr function pointer.  */
1197       fun = cxx_eval_constant_expression (ctx, fun,
1198                                           /*lval*/false, non_constant_p,
1199                                           overflow_p);
1200       STRIP_NOPS (fun);
1201       if (TREE_CODE (fun) == ADDR_EXPR)
1202         fun = TREE_OPERAND (fun, 0);
1203     }
1204   if (TREE_CODE (fun) != FUNCTION_DECL)
1205     {
1206       if (!ctx->quiet && !*non_constant_p)
1207         error_at (loc, "expression %qE does not designate a constexpr "
1208                   "function", fun);
1209       *non_constant_p = true;
1210       return t;
1211     }
1212   if (DECL_CLONED_FUNCTION_P (fun))
1213     fun = DECL_CLONED_FUNCTION (fun);
1214
1215   if (is_ubsan_builtin_p (fun))
1216     return void_node;
1217
1218   if (is_builtin_fn (fun))
1219     return cxx_eval_builtin_function_call (ctx, t,
1220                                            lval, non_constant_p, overflow_p);
1221   if (!DECL_DECLARED_CONSTEXPR_P (fun))
1222     {
1223       if (!ctx->quiet)
1224         {
1225           error_at (loc, "call to non-constexpr function %qD", fun);
1226           explain_invalid_constexpr_fn (fun);
1227         }
1228       *non_constant_p = true;
1229       return t;
1230     }
1231
1232   /* Shortcut trivial constructor/op=.  */
1233   if (trivial_fn_p (fun))
1234     {
1235       if (call_expr_nargs (t) == 2)
1236         {
1237           tree arg = convert_from_reference (get_nth_callarg (t, 1));
1238           return cxx_eval_constant_expression (ctx, arg,
1239                                                lval, non_constant_p,
1240                                                overflow_p);
1241         }
1242       else if (TREE_CODE (t) == AGGR_INIT_EXPR
1243                && AGGR_INIT_ZERO_FIRST (t))
1244         return build_zero_init (DECL_CONTEXT (fun), NULL_TREE, false);
1245     }
1246
1247   /* If in direct recursive call, optimize definition search.  */
1248   if (ctx && ctx->call && ctx->call->fundef->decl == fun)
1249     new_call.fundef = ctx->call->fundef;
1250   else
1251     {
1252       new_call.fundef = retrieve_constexpr_fundef (fun);
1253       if (new_call.fundef == NULL || new_call.fundef->body == NULL)
1254         {
1255           if (!ctx->quiet)
1256             {
1257               if (DECL_INITIAL (fun))
1258                 {
1259                   /* The definition of fun was somehow unsuitable.  */
1260                   error_at (loc, "%qD called in a constant expression", fun);
1261                   explain_invalid_constexpr_fn (fun);
1262                 }
1263               else
1264                 error_at (loc, "%qD used before its definition", fun);
1265             }
1266           *non_constant_p = true;
1267           return t;
1268         }
1269     }
1270
1271   constexpr_ctx new_ctx = *ctx;
1272   if (DECL_CONSTRUCTOR_P (fun) && !ctx->object
1273       && TREE_CODE (t) == AGGR_INIT_EXPR)
1274     {
1275       /* We want to have an initialization target for an AGGR_INIT_EXPR.
1276          If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT.  */
1277       new_ctx.object = AGGR_INIT_EXPR_SLOT (t);
1278       tree ctor = new_ctx.ctor = build_constructor (DECL_CONTEXT (fun), NULL);
1279       CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = true;
1280       ctx->values->put (new_ctx.object, ctor);
1281       ctx = &new_ctx;
1282     }
1283
1284   bool non_constant_args = false;
1285   cxx_bind_parameters_in_call (ctx, t, &new_call,
1286                                non_constant_p, overflow_p, &non_constant_args);
1287   if (*non_constant_p)
1288     return t;
1289
1290   depth_ok = push_cx_call_context (t);
1291
1292   tree result = NULL_TREE;
1293
1294   constexpr_call *entry = NULL;
1295   if (!non_constant_args)
1296     {
1297       new_call.hash = iterative_hash_template_arg
1298         (new_call.bindings, constexpr_fundef_hasher::hash (new_call.fundef));
1299
1300       /* If we have seen this call before, we are done.  */
1301       maybe_initialize_constexpr_call_table ();
1302       constexpr_call **slot
1303         = constexpr_call_table->find_slot (&new_call, INSERT);
1304       entry = *slot;
1305       if (entry == NULL)
1306         {
1307           /* We need to keep a pointer to the entry, not just the slot, as the
1308              slot can move in the call to cxx_eval_builtin_function_call.  */
1309           *slot = entry = ggc_alloc<constexpr_call> ();
1310           *entry = new_call;
1311         }
1312       /* Calls which are in progress have their result set to NULL
1313          so that we can detect circular dependencies.  */
1314       else if (entry->result == NULL)
1315         {
1316           if (!ctx->quiet)
1317             error ("call has circular dependency");
1318           *non_constant_p = true;
1319           entry->result = result = error_mark_node;
1320         }
1321       else
1322         result = entry->result;
1323     }
1324
1325   if (!depth_ok)
1326     {
1327       if (!ctx->quiet)
1328         error ("constexpr evaluation depth exceeds maximum of %d (use "
1329                "-fconstexpr-depth= to increase the maximum)",
1330                max_constexpr_depth);
1331       *non_constant_p = true;
1332       result = error_mark_node;
1333     }
1334   else
1335     {
1336       if (!result || result == error_mark_node)
1337         {
1338           if (!use_new_call)
1339             {
1340               new_ctx.call = &new_call;
1341               result = (cxx_eval_constant_expression
1342                         (&new_ctx, new_call.fundef->body,
1343                          lval,
1344                          non_constant_p, overflow_p));
1345             }
1346           else
1347             {
1348               if (DECL_SAVED_TREE (fun) == NULL_TREE
1349                   && (DECL_CONSTRUCTOR_P (fun) || DECL_DESTRUCTOR_P (fun)))
1350                 /* The maybe-in-charge 'tor had its DECL_SAVED_TREE
1351                    cleared, try the first clone.  */
1352                 fun = DECL_CHAIN (fun);
1353               gcc_assert (DECL_SAVED_TREE (fun));
1354               tree parms, res;
1355
1356               /* Unshare the whole function body.  */
1357               tree body = copy_fn (fun, parms, res);
1358
1359               /* Associate the bindings with the remapped parms.  */
1360               tree bound = new_call.bindings;
1361               tree remapped = parms;
1362               while (bound)
1363                 {
1364                   tree oparm = TREE_PURPOSE (bound);
1365                   tree arg = TREE_VALUE (bound);
1366                   gcc_assert (DECL_NAME (remapped) == DECL_NAME (oparm));
1367                   ctx->values->put (remapped, arg);
1368                   bound = TREE_CHAIN (bound);
1369                   remapped = DECL_CHAIN (remapped);
1370                 }
1371               /* Add the RESULT_DECL to the values map, too.  */
1372               tree slot = NULL_TREE;
1373               if (DECL_BY_REFERENCE (res))
1374                 {
1375                   slot = AGGR_INIT_EXPR_SLOT (t);
1376                   tree addr = build_address (slot);
1377                   addr = build_nop (TREE_TYPE (res), addr);
1378                   ctx->values->put (res, addr);
1379                   ctx->values->put (slot, NULL_TREE);
1380                 }
1381               else
1382                 ctx->values->put (res, NULL_TREE);
1383
1384               tree jump_target = NULL_TREE;
1385               cxx_eval_constant_expression (ctx, body,
1386                                             lval, non_constant_p, overflow_p,
1387                                             &jump_target);
1388
1389               if (DECL_CONSTRUCTOR_P (fun))
1390                 /* This can be null for a subobject constructor call, in
1391                    which case what we care about is the initialization
1392                    side-effects rather than the value.  We could get at the
1393                    value by evaluating *this, but we don't bother; there's
1394                    no need to put such a call in the hash table.  */
1395                 result = lval ? ctx->object : ctx->ctor;
1396               else if (VOID_TYPE_P (TREE_TYPE (res)))
1397                 result = void_node;
1398               else
1399                 {
1400                   result = *ctx->values->get (slot ? slot : res);
1401                   if (result == NULL_TREE && !*non_constant_p)
1402                     {
1403                       if (!ctx->quiet)
1404                         error ("constexpr call flows off the end "
1405                                "of the function");
1406                       *non_constant_p = true;
1407                     }
1408                 }
1409
1410               /* Remove the parms/result from the values map.  Is it worth
1411                  bothering to do this when the map itself is only live for
1412                  one constexpr evaluation?  If so, maybe also clear out
1413                  other vars from call, maybe in BIND_EXPR handling?  */
1414               ctx->values->remove (res);
1415               if (slot)
1416                 ctx->values->remove (slot);
1417               for (tree parm = parms; parm; parm = TREE_CHAIN (parm))
1418                 ctx->values->remove (parm);
1419             }
1420         }
1421
1422       if (result == error_mark_node)
1423         *non_constant_p = true;
1424       if (*non_constant_p)
1425         result = error_mark_node;
1426       else if (result)
1427         {
1428           /* If this was a call to initialize an object, set the type of
1429              the CONSTRUCTOR to the type of that object.  */
1430           if (DECL_CONSTRUCTOR_P (fun) && !use_new_call)
1431             {
1432               tree ob_arg = get_nth_callarg (t, 0);
1433               STRIP_NOPS (ob_arg);
1434               gcc_assert (TYPE_PTR_P (TREE_TYPE (ob_arg))
1435                           && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg))));
1436               result = adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg)),
1437                                          result);
1438             }
1439         }
1440       else
1441         result = void_node;
1442       if (entry)
1443         entry->result = result;
1444     }
1445
1446   pop_cx_call_context ();
1447   return unshare_expr (result);
1448 }
1449
1450 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase.  */
1451
1452 bool
1453 reduced_constant_expression_p (tree t)
1454 {
1455   switch (TREE_CODE (t))
1456     {
1457     case PTRMEM_CST:
1458       /* Even if we can't lower this yet, it's constant.  */
1459       return true;
1460
1461     case CONSTRUCTOR:
1462       /* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR.  */
1463       tree elt; unsigned HOST_WIDE_INT idx;
1464       FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t), idx, elt)
1465         if (!reduced_constant_expression_p (elt))
1466           return false;
1467       return true;
1468
1469     default:
1470       /* FIXME are we calling this too much?  */
1471       return initializer_constant_valid_p (t, TREE_TYPE (t)) != NULL_TREE;
1472     }
1473 }
1474
1475 /* Some expressions may have constant operands but are not constant
1476    themselves, such as 1/0.  Call this function (or rather, the macro
1477    following it) to check for that condition.
1478
1479    We only call this in places that require an arithmetic constant, not in
1480    places where we might have a non-constant expression that can be a
1481    component of a constant expression, such as the address of a constexpr
1482    variable that might be dereferenced later.  */
1483
1484 static bool
1485 verify_constant (tree t, bool allow_non_constant, bool *non_constant_p,
1486                  bool *overflow_p)
1487 {
1488   if (!*non_constant_p && !reduced_constant_expression_p (t))
1489     {
1490       if (!allow_non_constant)
1491         error ("%q+E is not a constant expression", t);
1492       *non_constant_p = true;
1493     }
1494   if (TREE_OVERFLOW_P (t))
1495     {
1496       if (!allow_non_constant)
1497         {
1498           permerror (input_location, "overflow in constant expression");
1499           /* If we're being permissive (and are in an enforcing
1500              context), ignore the overflow.  */
1501           if (flag_permissive)
1502             return *non_constant_p;
1503         }
1504       *overflow_p = true;
1505     }
1506   return *non_constant_p;
1507 }
1508
1509 /* Check whether the shift operation with code CODE and type TYPE on LHS
1510    and RHS is undefined.  If it is, give an error with an explanation,
1511    and return true; return false otherwise.  */
1512
1513 static bool
1514 cxx_eval_check_shift_p (location_t loc, const constexpr_ctx *ctx,
1515                         enum tree_code code, tree type, tree lhs, tree rhs)
1516 {
1517   if ((code != LSHIFT_EXPR && code != RSHIFT_EXPR)
1518       || TREE_CODE (lhs) != INTEGER_CST
1519       || TREE_CODE (rhs) != INTEGER_CST)
1520     return false;
1521
1522   tree lhstype = TREE_TYPE (lhs);
1523   unsigned HOST_WIDE_INT uprec = TYPE_PRECISION (TREE_TYPE (lhs));
1524
1525   /* [expr.shift] The behavior is undefined if the right operand
1526      is negative, or greater than or equal to the length in bits
1527      of the promoted left operand.  */
1528   if (tree_int_cst_sgn (rhs) == -1)
1529     {
1530       if (!ctx->quiet)
1531         error_at (loc, "right operand of shift expression %q+E is negative",
1532                   build2_loc (loc, code, type, lhs, rhs));
1533       return true;
1534     }
1535   if (compare_tree_int (rhs, uprec) >= 0)
1536     {
1537       if (!ctx->quiet)
1538         error_at (loc, "right operand of shift expression %q+E is >= than "
1539                   "the precision of the left operand",
1540                   build2_loc (loc, code, type, lhs, rhs));
1541       return true;
1542     }
1543
1544   /* The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]
1545      if E1 has a signed type and non-negative value, and E1x2^E2 is
1546      representable in the corresponding unsigned type of the result type,
1547      then that value, converted to the result type, is the resulting value;
1548      otherwise, the behavior is undefined.  */
1549   if (code == LSHIFT_EXPR && !TYPE_UNSIGNED (lhstype)
1550       && (cxx_dialect >= cxx11))
1551     {
1552       if (tree_int_cst_sgn (lhs) == -1)
1553         {
1554           if (!ctx->quiet)
1555             error_at (loc, "left operand of shift expression %q+E is negative",
1556                       build2_loc (loc, code, type, lhs, rhs));
1557           return true;
1558         }
1559       /* For signed x << y the following:
1560          (unsigned) x >> ((prec (lhs) - 1) - y)
1561          if > 1, is undefined.  The right-hand side of this formula
1562          is the highest bit of the LHS that can be set (starting from 0),
1563          so that the shift doesn't overflow.  We then right-shift the LHS
1564          to see whether any other bit is set making the original shift
1565          undefined -- the result is not representable in the corresponding
1566          unsigned type.  */
1567       tree t = build_int_cst (unsigned_type_node, uprec - 1);
1568       t = fold_build2 (MINUS_EXPR, unsigned_type_node, t, rhs);
1569       tree ulhs = fold_convert (unsigned_type_for (lhstype), lhs);
1570       t = fold_build2 (RSHIFT_EXPR, TREE_TYPE (ulhs), ulhs, t);
1571       if (tree_int_cst_lt (integer_one_node, t))
1572         {
1573           if (!ctx->quiet)
1574             error_at (loc, "shift expression %q+E overflows",
1575                       build2_loc (loc, code, type, lhs, rhs));
1576           return true;
1577         }
1578     }
1579   return false;
1580 }
1581
1582 /* Subroutine of cxx_eval_constant_expression.
1583    Attempt to reduce the unary expression tree T to a compile time value.
1584    If successful, return the value.  Otherwise issue a diagnostic
1585    and return error_mark_node.  */
1586
1587 static tree
1588 cxx_eval_unary_expression (const constexpr_ctx *ctx, tree t,
1589                            bool /*lval*/,
1590                            bool *non_constant_p, bool *overflow_p)
1591 {
1592   tree r;
1593   tree orig_arg = TREE_OPERAND (t, 0);
1594   tree arg = cxx_eval_constant_expression (ctx, orig_arg, /*lval*/false,
1595                                            non_constant_p, overflow_p);
1596   VERIFY_CONSTANT (arg);
1597   location_t loc = EXPR_LOCATION (t);
1598   enum tree_code code = TREE_CODE (t);
1599   tree type = TREE_TYPE (t);
1600   r = fold_unary_loc (loc, code, type, arg);
1601   if (r == NULL_TREE)
1602     {
1603       if (arg == orig_arg)
1604         r = t;
1605       else
1606         r = build1_loc (loc, code, type, arg);
1607     }
1608   VERIFY_CONSTANT (r);
1609   return r;
1610 }
1611
1612 /* Subroutine of cxx_eval_constant_expression.
1613    Like cxx_eval_unary_expression, except for binary expressions.  */
1614
1615 static tree
1616 cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t,
1617                             bool /*lval*/,
1618                             bool *non_constant_p, bool *overflow_p)
1619 {
1620   tree r;
1621   tree orig_lhs = TREE_OPERAND (t, 0);
1622   tree orig_rhs = TREE_OPERAND (t, 1);
1623   tree lhs, rhs;
1624   lhs = cxx_eval_constant_expression (ctx, orig_lhs, /*lval*/false,
1625                                       non_constant_p, overflow_p);
1626   /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
1627      a local array in a constexpr function.  */
1628   bool ptr = POINTER_TYPE_P (TREE_TYPE (lhs));
1629   if (!ptr)
1630     VERIFY_CONSTANT (lhs);
1631   rhs = cxx_eval_constant_expression (ctx, orig_rhs, /*lval*/false,
1632                                       non_constant_p, overflow_p);
1633   if (!ptr)
1634     VERIFY_CONSTANT (rhs);
1635
1636   location_t loc = EXPR_LOCATION (t);
1637   enum tree_code code = TREE_CODE (t);
1638   tree type = TREE_TYPE (t);
1639   r = fold_binary_loc (loc, code, type, lhs, rhs);
1640   if (r == NULL_TREE)
1641     {
1642       if (lhs == orig_lhs && rhs == orig_rhs)
1643         r = t;
1644       else
1645         r = build2_loc (loc, code, type, lhs, rhs);
1646     }
1647   else if (cxx_eval_check_shift_p (loc, ctx, code, type, lhs, rhs))
1648     *non_constant_p = true;
1649   if (!ptr)
1650     VERIFY_CONSTANT (r);
1651   return r;
1652 }
1653
1654 /* Subroutine of cxx_eval_constant_expression.
1655    Attempt to evaluate condition expressions.  Dead branches are not
1656    looked into.  */
1657
1658 static tree
1659 cxx_eval_conditional_expression (const constexpr_ctx *ctx, tree t,
1660                                  bool lval,
1661                                  bool *non_constant_p, bool *overflow_p,
1662                                  tree *jump_target)
1663 {
1664   tree val = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
1665                                            /*lval*/false,
1666                                            non_constant_p, overflow_p);
1667   VERIFY_CONSTANT (val);
1668   /* Don't VERIFY_CONSTANT the other operands.  */
1669   if (integer_zerop (val))
1670     return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 2),
1671                                          lval,
1672                                          non_constant_p, overflow_p,
1673                                          jump_target);
1674   return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
1675                                        lval,
1676                                        non_constant_p, overflow_p,
1677                                        jump_target);
1678 }
1679
1680 /* Subroutine of cxx_eval_constant_expression.
1681    Attempt to reduce a reference to an array slot.  */
1682
1683 static tree
1684 cxx_eval_array_reference (const constexpr_ctx *ctx, tree t,
1685                           bool lval,
1686                           bool *non_constant_p, bool *overflow_p)
1687 {
1688   tree oldary = TREE_OPERAND (t, 0);
1689   tree ary = cxx_eval_constant_expression (ctx, oldary,
1690                                            lval,
1691                                            non_constant_p, overflow_p);
1692   tree index, oldidx;
1693   HOST_WIDE_INT i;
1694   tree elem_type;
1695   unsigned len, elem_nchars = 1;
1696   if (*non_constant_p)
1697     return t;
1698   oldidx = TREE_OPERAND (t, 1);
1699   index = cxx_eval_constant_expression (ctx, oldidx,
1700                                         false,
1701                                         non_constant_p, overflow_p);
1702   VERIFY_CONSTANT (index);
1703   if (lval && ary == oldary && index == oldidx)
1704     return t;
1705   else if (lval)
1706     return build4 (ARRAY_REF, TREE_TYPE (t), ary, index, NULL, NULL);
1707   elem_type = TREE_TYPE (TREE_TYPE (ary));
1708   if (TREE_CODE (ary) == CONSTRUCTOR)
1709     len = CONSTRUCTOR_NELTS (ary);
1710   else if (TREE_CODE (ary) == STRING_CST)
1711     {
1712       elem_nchars = (TYPE_PRECISION (elem_type)
1713                      / TYPE_PRECISION (char_type_node));
1714       len = (unsigned) TREE_STRING_LENGTH (ary) / elem_nchars;
1715     }
1716   else
1717     {
1718       /* We can't do anything with other tree codes, so use
1719          VERIFY_CONSTANT to complain and fail.  */
1720       VERIFY_CONSTANT (ary);
1721       gcc_unreachable ();
1722     }
1723   if (compare_tree_int (index, len) >= 0)
1724     {
1725       if (tree_int_cst_lt (index, array_type_nelts_top (TREE_TYPE (ary))))
1726         {
1727           /* If it's within the array bounds but doesn't have an explicit
1728              initializer, it's value-initialized.  */
1729           tree val = build_value_init (elem_type, tf_warning_or_error);
1730           return cxx_eval_constant_expression (ctx, val,
1731                                                lval,
1732                                                non_constant_p, overflow_p);
1733         }
1734
1735       if (!ctx->quiet)
1736         error ("array subscript out of bound");
1737       *non_constant_p = true;
1738       return t;
1739     }
1740   else if (tree_int_cst_lt (index, integer_zero_node))
1741     {
1742       if (!ctx->quiet)
1743         error ("negative array subscript");
1744       *non_constant_p = true;
1745       return t;
1746     }
1747   i = tree_to_shwi (index);
1748   if (TREE_CODE (ary) == CONSTRUCTOR)
1749     return (*CONSTRUCTOR_ELTS (ary))[i].value;
1750   else if (elem_nchars == 1)
1751     return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary))),
1752                           TREE_STRING_POINTER (ary)[i]);
1753   else
1754     {
1755       tree type = cv_unqualified (TREE_TYPE (TREE_TYPE (ary)));
1756       return native_interpret_expr (type, (const unsigned char *)
1757                                           TREE_STRING_POINTER (ary)
1758                                           + i * elem_nchars, elem_nchars);
1759     }
1760   /* Don't VERIFY_CONSTANT here.  */
1761 }
1762
1763 /* Subroutine of cxx_eval_constant_expression.
1764    Attempt to reduce a field access of a value of class type.  */
1765
1766 static tree
1767 cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
1768                               bool lval,
1769                               bool *non_constant_p, bool *overflow_p)
1770 {
1771   unsigned HOST_WIDE_INT i;
1772   tree field;
1773   tree value;
1774   tree part = TREE_OPERAND (t, 1);
1775   tree orig_whole = TREE_OPERAND (t, 0);
1776   tree whole = cxx_eval_constant_expression (ctx, orig_whole,
1777                                              lval,
1778                                              non_constant_p, overflow_p);
1779   if (whole == orig_whole)
1780     return t;
1781   if (lval)
1782     return fold_build3 (COMPONENT_REF, TREE_TYPE (t),
1783                         whole, part, NULL_TREE);
1784   /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1785      CONSTRUCTOR.  */
1786   if (!*non_constant_p && TREE_CODE (whole) != CONSTRUCTOR)
1787     {
1788       if (!ctx->quiet)
1789         error ("%qE is not a constant expression", orig_whole);
1790       *non_constant_p = true;
1791     }
1792   if (DECL_MUTABLE_P (part))
1793     {
1794       if (!ctx->quiet)
1795         error ("mutable %qD is not usable in a constant expression", part);
1796       *non_constant_p = true;
1797     }
1798   if (*non_constant_p)
1799     return t;
1800   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
1801     {
1802       if (field == part)
1803         {
1804           if (value)
1805             return value;
1806           else
1807             /* We're in the middle of initializing it.  */
1808             break;
1809         }
1810     }
1811   if (TREE_CODE (TREE_TYPE (whole)) == UNION_TYPE
1812       && CONSTRUCTOR_NELTS (whole) > 0)
1813     {
1814       /* DR 1188 says we don't have to deal with this.  */
1815       if (!ctx->quiet)
1816         error ("accessing %qD member instead of initialized %qD member in "
1817                "constant expression", part, CONSTRUCTOR_ELT (whole, 0)->index);
1818       *non_constant_p = true;
1819       return t;
1820     }
1821
1822   if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole))
1823     {
1824       /* 'whole' is part of the aggregate initializer we're currently
1825          building; if there's no initializer for this member yet, that's an
1826          error. */
1827       if (!ctx->quiet)
1828         error ("accessing uninitialized member %qD", part);
1829       *non_constant_p = true;
1830       return t;
1831     }
1832
1833   /* If there's no explicit init for this field, it's value-initialized.  */
1834   value = build_value_init (TREE_TYPE (t), tf_warning_or_error);
1835   return cxx_eval_constant_expression (ctx, value,
1836                                        lval,
1837                                        non_constant_p, overflow_p);
1838 }
1839
1840 /* Subroutine of cxx_eval_constant_expression.
1841    Attempt to reduce a field access of a value of class type that is
1842    expressed as a BIT_FIELD_REF.  */
1843
1844 static tree
1845 cxx_eval_bit_field_ref (const constexpr_ctx *ctx, tree t,
1846                         bool lval,
1847                         bool *non_constant_p, bool *overflow_p)
1848 {
1849   tree orig_whole = TREE_OPERAND (t, 0);
1850   tree retval, fldval, utype, mask;
1851   bool fld_seen = false;
1852   HOST_WIDE_INT istart, isize;
1853   tree whole = cxx_eval_constant_expression (ctx, orig_whole,
1854                                              lval,
1855                                              non_constant_p, overflow_p);
1856   tree start, field, value;
1857   unsigned HOST_WIDE_INT i;
1858
1859   if (whole == orig_whole)
1860     return t;
1861   /* Don't VERIFY_CONSTANT here; we only want to check that we got a
1862      CONSTRUCTOR.  */
1863   if (!*non_constant_p
1864       && TREE_CODE (whole) != VECTOR_CST
1865       && TREE_CODE (whole) != CONSTRUCTOR)
1866     {
1867       if (!ctx->quiet)
1868         error ("%qE is not a constant expression", orig_whole);
1869       *non_constant_p = true;
1870     }
1871   if (*non_constant_p)
1872     return t;
1873
1874   if (TREE_CODE (whole) == VECTOR_CST)
1875     return fold_ternary (BIT_FIELD_REF, TREE_TYPE (t), whole,
1876                          TREE_OPERAND (t, 1), TREE_OPERAND (t, 2));
1877
1878   start = TREE_OPERAND (t, 2);
1879   istart = tree_to_shwi (start);
1880   isize = tree_to_shwi (TREE_OPERAND (t, 1));
1881   utype = TREE_TYPE (t);
1882   if (!TYPE_UNSIGNED (utype))
1883     utype = build_nonstandard_integer_type (TYPE_PRECISION (utype), 1);
1884   retval = build_int_cst (utype, 0);
1885   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
1886     {
1887       tree bitpos = bit_position (field);
1888       if (bitpos == start && DECL_SIZE (field) == TREE_OPERAND (t, 1))
1889         return value;
1890       if (TREE_CODE (TREE_TYPE (field)) == INTEGER_TYPE
1891           && TREE_CODE (value) == INTEGER_CST
1892           && tree_fits_shwi_p (bitpos)
1893           && tree_fits_shwi_p (DECL_SIZE (field)))
1894         {
1895           HOST_WIDE_INT bit = tree_to_shwi (bitpos);
1896           HOST_WIDE_INT sz = tree_to_shwi (DECL_SIZE (field));
1897           HOST_WIDE_INT shift;
1898           if (bit >= istart && bit + sz <= istart + isize)
1899             {
1900               fldval = fold_convert (utype, value);
1901               mask = build_int_cst_type (utype, -1);
1902               mask = fold_build2 (LSHIFT_EXPR, utype, mask,
1903                                   size_int (TYPE_PRECISION (utype) - sz));
1904               mask = fold_build2 (RSHIFT_EXPR, utype, mask,
1905                                   size_int (TYPE_PRECISION (utype) - sz));
1906               fldval = fold_build2 (BIT_AND_EXPR, utype, fldval, mask);
1907               shift = bit - istart;
1908               if (BYTES_BIG_ENDIAN)
1909                 shift = TYPE_PRECISION (utype) - shift - sz;
1910               fldval = fold_build2 (LSHIFT_EXPR, utype, fldval,
1911                                     size_int (shift));
1912               retval = fold_build2 (BIT_IOR_EXPR, utype, retval, fldval);
1913               fld_seen = true;
1914             }
1915         }
1916     }
1917   if (fld_seen)
1918     return fold_convert (TREE_TYPE (t), retval);
1919   gcc_unreachable ();
1920   return error_mark_node;
1921 }
1922
1923 /* Subroutine of cxx_eval_constant_expression.
1924    Evaluate a short-circuited logical expression T in the context
1925    of a given constexpr CALL.  BAILOUT_VALUE is the value for
1926    early return.  CONTINUE_VALUE is used here purely for
1927    sanity check purposes.  */
1928
1929 static tree
1930 cxx_eval_logical_expression (const constexpr_ctx *ctx, tree t,
1931                              tree bailout_value, tree continue_value,
1932                              bool lval,
1933                              bool *non_constant_p, bool *overflow_p)
1934 {
1935   tree r;
1936   tree lhs = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
1937                                            lval,
1938                                            non_constant_p, overflow_p);
1939   VERIFY_CONSTANT (lhs);
1940   if (tree_int_cst_equal (lhs, bailout_value))
1941     return lhs;
1942   gcc_assert (tree_int_cst_equal (lhs, continue_value));
1943   r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
1944                                     lval, non_constant_p,
1945                                     overflow_p);
1946   VERIFY_CONSTANT (r);
1947   return r;
1948 }
1949
1950 /* REF is a COMPONENT_REF designating a particular field.  V is a vector of
1951    CONSTRUCTOR elements to initialize (part of) an object containing that
1952    field.  Return a pointer to the constructor_elt corresponding to the
1953    initialization of the field.  */
1954
1955 static constructor_elt *
1956 base_field_constructor_elt (vec<constructor_elt, va_gc> *v, tree ref)
1957 {
1958   tree aggr = TREE_OPERAND (ref, 0);
1959   tree field = TREE_OPERAND (ref, 1);
1960   HOST_WIDE_INT i;
1961   constructor_elt *ce;
1962
1963   gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
1964
1965   if (TREE_CODE (aggr) == COMPONENT_REF)
1966     {
1967       constructor_elt *base_ce
1968         = base_field_constructor_elt (v, aggr);
1969       v = CONSTRUCTOR_ELTS (base_ce->value);
1970     }
1971
1972   for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
1973     if (ce->index == field)
1974       return ce;
1975
1976   gcc_unreachable ();
1977   return NULL;
1978 }
1979
1980 /* Some of the expressions fed to the constexpr mechanism are calls to
1981    constructors, which have type void.  In that case, return the type being
1982    initialized by the constructor.  */
1983
1984 static tree
1985 initialized_type (tree t)
1986 {
1987   if (TYPE_P (t))
1988     return t;
1989   tree type = cv_unqualified (TREE_TYPE (t));
1990   if (TREE_CODE (t) == CALL_EXPR || TREE_CODE (t) == AGGR_INIT_EXPR)
1991     {
1992       /* A constructor call has void type, so we need to look deeper.  */
1993       tree fn = get_function_named_in_call (t);
1994       if (fn && TREE_CODE (fn) == FUNCTION_DECL
1995           && DECL_CXX_CONSTRUCTOR_P (fn))
1996         type = DECL_CONTEXT (fn);
1997     }
1998   return type;
1999 }
2000
2001 /* We're about to initialize element INDEX of an array or class from VALUE.
2002    Set up NEW_CTX appropriately by adjusting .object to refer to the
2003    subobject and creating a new CONSTRUCTOR if the element is itself
2004    a class or array.  */
2005
2006 static void
2007 init_subob_ctx (const constexpr_ctx *ctx, constexpr_ctx &new_ctx,
2008                tree index, tree &value)
2009 {
2010   new_ctx = *ctx;
2011
2012   if (index && TREE_CODE (index) != INTEGER_CST
2013       && TREE_CODE (index) != FIELD_DECL)
2014     /* This won't have an element in the new CONSTRUCTOR.  */
2015     return;
2016
2017   tree type = initialized_type (value);
2018   if (!AGGREGATE_TYPE_P (type) && !VECTOR_TYPE_P (type))
2019     /* A non-aggregate member doesn't get its own CONSTRUCTOR.  */
2020     return;
2021
2022   /* The sub-aggregate initializer might contain a placeholder;
2023      update object to refer to the subobject and ctor to refer to
2024      the (newly created) sub-initializer.  */
2025   if (ctx->object)
2026     new_ctx.object = build_ctor_subob_ref (index, type, ctx->object);
2027   tree elt = build_constructor (type, NULL);
2028   CONSTRUCTOR_NO_IMPLICIT_ZERO (elt) = true;
2029   new_ctx.ctor = elt;
2030
2031   if (TREE_CODE (value) == TARGET_EXPR)
2032     /* Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR.  */
2033     value = TARGET_EXPR_INITIAL (value);
2034 }
2035
2036 /* We're about to process an initializer for a class or array TYPE.  Make
2037    sure that CTX is set up appropriately.  */
2038
2039 static void
2040 verify_ctor_sanity (const constexpr_ctx *ctx, tree type)
2041 {
2042   /* We don't bother building a ctor for an empty base subobject.  */
2043   if (is_empty_class (type))
2044     return;
2045
2046   /* We're in the middle of an initializer that might involve placeholders;
2047      our caller should have created a CONSTRUCTOR for us to put the
2048      initializer into.  We will either return that constructor or T.  */
2049   gcc_assert (ctx->ctor);
2050   gcc_assert (same_type_ignoring_top_level_qualifiers_p
2051               (type, TREE_TYPE (ctx->ctor)));
2052   gcc_assert (CONSTRUCTOR_NELTS (ctx->ctor) == 0);
2053   if (ctx->object)
2054     gcc_assert (same_type_ignoring_top_level_qualifiers_p
2055                 (type, TREE_TYPE (ctx->object)));
2056   gcc_assert (!ctx->object || !DECL_P (ctx->object)
2057               || *(ctx->values->get (ctx->object)) == ctx->ctor);
2058 }
2059
2060 /* Subroutine of cxx_eval_constant_expression.
2061    The expression tree T denotes a C-style array or a C-style
2062    aggregate.  Reduce it to a constant expression.  */
2063
2064 static tree
2065 cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t,
2066                          bool lval,
2067                          bool *non_constant_p, bool *overflow_p)
2068 {
2069   vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
2070   bool changed = false;
2071   gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t));
2072
2073   verify_ctor_sanity (ctx, TREE_TYPE (t));
2074   vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
2075   vec_alloc (*p, vec_safe_length (v));
2076
2077   unsigned i; tree index, value;
2078   FOR_EACH_CONSTRUCTOR_ELT (v, i, index, value)
2079     {
2080       constexpr_ctx new_ctx;
2081       init_subob_ctx (ctx, new_ctx, index, value);
2082       if (new_ctx.ctor != ctx->ctor)
2083         /* If we built a new CONSTRUCTOR, attach it now so that other
2084            initializers can refer to it.  */
2085         CONSTRUCTOR_APPEND_ELT (*p, index, new_ctx.ctor);
2086       tree elt = cxx_eval_constant_expression (&new_ctx, value,
2087                                                lval,
2088                                                non_constant_p, overflow_p);
2089       /* Don't VERIFY_CONSTANT here.  */
2090       if (ctx->quiet && *non_constant_p)
2091         break;
2092       if (elt != value)
2093         changed = true;
2094       if (index && TREE_CODE (index) == COMPONENT_REF)
2095         {
2096           /* This is an initialization of a vfield inside a base
2097              subaggregate that we already initialized; push this
2098              initialization into the previous initialization.  */
2099           constructor_elt *inner = base_field_constructor_elt (*p, index);
2100           inner->value = elt;
2101           changed = true;
2102         }
2103       else if (index
2104                && (TREE_CODE (index) == NOP_EXPR
2105                    || TREE_CODE (index) == POINTER_PLUS_EXPR))
2106         {
2107           /* This is an initializer for an empty base; now that we've
2108              checked that it's constant, we can ignore it.  */
2109           gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index))));
2110           changed = true;
2111         }
2112       else if (new_ctx.ctor != ctx->ctor)
2113         {
2114           /* We appended this element above; update the value.  */
2115           gcc_assert ((*p)->last().index == index);
2116           (*p)->last().value = elt;
2117         }
2118       else
2119         CONSTRUCTOR_APPEND_ELT (*p, index, elt);
2120     }
2121   if (*non_constant_p || !changed)
2122     return t;
2123   t = ctx->ctor;
2124   /* We're done building this CONSTRUCTOR, so now we can interpret an
2125      element without an explicit initializer as value-initialized.  */
2126   CONSTRUCTOR_NO_IMPLICIT_ZERO (t) = false;
2127   if (TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
2128     t = fold (t);
2129   return t;
2130 }
2131
2132 /* Subroutine of cxx_eval_constant_expression.
2133    The expression tree T is a VEC_INIT_EXPR which denotes the desired
2134    initialization of a non-static data member of array type.  Reduce it to a
2135    CONSTRUCTOR.
2136
2137    Note that apart from value-initialization (when VALUE_INIT is true),
2138    this is only intended to support value-initialization and the
2139    initializations done by defaulted constructors for classes with
2140    non-static data members of array type.  In this case, VEC_INIT_EXPR_INIT
2141    will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2142    for the copy/move constructor.  */
2143
2144 static tree
2145 cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init,
2146                      bool value_init, bool lval,
2147                      bool *non_constant_p, bool *overflow_p)
2148 {
2149   tree elttype = TREE_TYPE (atype);
2150   unsigned HOST_WIDE_INT max = tree_to_uhwi (array_type_nelts_top (atype));
2151   verify_ctor_sanity (ctx, atype);
2152   vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
2153   vec_alloc (*p, max + 1);
2154   bool pre_init = false;
2155   unsigned HOST_WIDE_INT i;
2156
2157   /* For the default constructor, build up a call to the default
2158      constructor of the element type.  We only need to handle class types
2159      here, as for a constructor to be constexpr, all members must be
2160      initialized, which for a defaulted default constructor means they must
2161      be of a class type with a constexpr default constructor.  */
2162   if (TREE_CODE (elttype) == ARRAY_TYPE)
2163     /* We only do this at the lowest level.  */;
2164   else if (value_init)
2165     {
2166       init = build_value_init (elttype, tf_warning_or_error);
2167       pre_init = true;
2168     }
2169   else if (!init)
2170     {
2171       vec<tree, va_gc> *argvec = make_tree_vector ();
2172       init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
2173                                         &argvec, elttype, LOOKUP_NORMAL,
2174                                         tf_warning_or_error);
2175       release_tree_vector (argvec);
2176       init = build_aggr_init_expr (TREE_TYPE (init), init);
2177       pre_init = true;
2178     }
2179
2180   for (i = 0; i < max; ++i)
2181     {
2182       tree idx = build_int_cst (size_type_node, i);
2183       tree eltinit;
2184       constexpr_ctx new_ctx;
2185       init_subob_ctx (ctx, new_ctx, idx, pre_init ? init : elttype);
2186       if (new_ctx.ctor != ctx->ctor)
2187         CONSTRUCTOR_APPEND_ELT (*p, idx, new_ctx.ctor);
2188       if (TREE_CODE (elttype) == ARRAY_TYPE)
2189         {
2190           /* A multidimensional array; recurse.  */
2191           if (value_init || init == NULL_TREE)
2192             eltinit = NULL_TREE;
2193           else
2194             eltinit = cp_build_array_ref (input_location, init, idx,
2195                                           tf_warning_or_error);
2196           eltinit = cxx_eval_vec_init_1 (&new_ctx, elttype, eltinit, value_init,
2197                                          lval,
2198                                          non_constant_p, overflow_p);
2199         }
2200       else if (pre_init)
2201         {
2202           /* Initializing an element using value or default initialization
2203              we just pre-built above.  */
2204           eltinit = (cxx_eval_constant_expression
2205                      (&new_ctx, init,
2206                       lval, non_constant_p, overflow_p));
2207         }
2208       else
2209         {
2210           /* Copying an element.  */
2211           gcc_assert (same_type_ignoring_top_level_qualifiers_p
2212                       (atype, TREE_TYPE (init)));
2213           eltinit = cp_build_array_ref (input_location, init, idx,
2214                                         tf_warning_or_error);
2215           if (!real_lvalue_p (init))
2216             eltinit = move (eltinit);
2217           eltinit = force_rvalue (eltinit, tf_warning_or_error);
2218           eltinit = (cxx_eval_constant_expression
2219                      (&new_ctx, eltinit, lval,
2220                       non_constant_p, overflow_p));
2221         }
2222       if (*non_constant_p && !ctx->quiet)
2223         break;
2224       if (new_ctx.ctor != ctx->ctor)
2225         {
2226           /* We appended this element above; update the value.  */
2227           gcc_assert ((*p)->last().index == idx);
2228           (*p)->last().value = eltinit;
2229         }
2230       else
2231         CONSTRUCTOR_APPEND_ELT (*p, idx, eltinit);
2232     }
2233
2234   if (!*non_constant_p)
2235     {
2236       init = ctx->ctor;
2237       CONSTRUCTOR_NO_IMPLICIT_ZERO (init) = false;
2238     }
2239   return init;
2240 }
2241
2242 static tree
2243 cxx_eval_vec_init (const constexpr_ctx *ctx, tree t,
2244                    bool lval,
2245                    bool *non_constant_p, bool *overflow_p)
2246 {
2247   tree atype = TREE_TYPE (t);
2248   tree init = VEC_INIT_EXPR_INIT (t);
2249   tree r = cxx_eval_vec_init_1 (ctx, atype, init,
2250                                 VEC_INIT_EXPR_VALUE_INIT (t),
2251                                 lval, non_constant_p, overflow_p);
2252   if (*non_constant_p)
2253     return t;
2254   else
2255     return r;
2256 }
2257
2258 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
2259    match.  We want to be less strict for simple *& folding; if we have a
2260    non-const temporary that we access through a const pointer, that should
2261    work.  We handle this here rather than change fold_indirect_ref_1
2262    because we're dealing with things like ADDR_EXPR of INTEGER_CST which
2263    don't really make sense outside of constant expression evaluation.  Also
2264    we want to allow folding to COMPONENT_REF, which could cause trouble
2265    with TBAA in fold_indirect_ref_1.
2266
2267    Try to keep this function synced with fold_indirect_ref_1.  */
2268
2269 static tree
2270 cxx_fold_indirect_ref (location_t loc, tree type, tree op0, bool *empty_base)
2271 {
2272   tree sub, subtype;
2273
2274   sub = op0;
2275   STRIP_NOPS (sub);
2276   subtype = TREE_TYPE (sub);
2277   if (!POINTER_TYPE_P (subtype))
2278     return NULL_TREE;
2279
2280   if (TREE_CODE (sub) == ADDR_EXPR)
2281     {
2282       tree op = TREE_OPERAND (sub, 0);
2283       tree optype = TREE_TYPE (op);
2284
2285       /* *&CONST_DECL -> to the value of the const decl.  */
2286       if (TREE_CODE (op) == CONST_DECL)
2287         return DECL_INITIAL (op);
2288       /* *&p => p;  make sure to handle *&"str"[cst] here.  */
2289       if (same_type_ignoring_top_level_qualifiers_p (optype, type))
2290         {
2291           tree fop = fold_read_from_constant_string (op);
2292           if (fop)
2293             return fop;
2294           else
2295             return op;
2296         }
2297       /* *(foo *)&fooarray => fooarray[0] */
2298       else if (TREE_CODE (optype) == ARRAY_TYPE
2299                && (same_type_ignoring_top_level_qualifiers_p
2300                    (type, TREE_TYPE (optype))))
2301         {
2302           tree type_domain = TYPE_DOMAIN (optype);
2303           tree min_val = size_zero_node;
2304           if (type_domain && TYPE_MIN_VALUE (type_domain))
2305             min_val = TYPE_MIN_VALUE (type_domain);
2306           return build4_loc (loc, ARRAY_REF, type, op, min_val,
2307                              NULL_TREE, NULL_TREE);
2308         }
2309       /* *(foo *)&complexfoo => __real__ complexfoo */
2310       else if (TREE_CODE (optype) == COMPLEX_TYPE
2311                && (same_type_ignoring_top_level_qualifiers_p
2312                    (type, TREE_TYPE (optype))))
2313         return fold_build1_loc (loc, REALPART_EXPR, type, op);
2314       /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
2315       else if (TREE_CODE (optype) == VECTOR_TYPE
2316                && (same_type_ignoring_top_level_qualifiers_p
2317                    (type, TREE_TYPE (optype))))
2318         {
2319           tree part_width = TYPE_SIZE (type);
2320           tree index = bitsize_int (0);
2321           return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
2322         }
2323       /* Also handle conversion to an empty base class, which
2324          is represented with a NOP_EXPR.  */
2325       else if (is_empty_class (type)
2326                && CLASS_TYPE_P (optype)
2327                && DERIVED_FROM_P (type, optype))
2328         {
2329           *empty_base = true;
2330           return op;
2331         }
2332       /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
2333       else if (RECORD_OR_UNION_TYPE_P (optype))
2334         {
2335           tree field = TYPE_FIELDS (optype);
2336           for (; field; field = DECL_CHAIN (field))
2337             if (TREE_CODE (field) == FIELD_DECL
2338                 && integer_zerop (byte_position (field))
2339                 && (same_type_ignoring_top_level_qualifiers_p
2340                     (TREE_TYPE (field), type)))
2341               {
2342                 return fold_build3 (COMPONENT_REF, type, op, field, NULL_TREE);
2343                 break;
2344               }
2345         }
2346     }
2347   else if (TREE_CODE (sub) == POINTER_PLUS_EXPR
2348            && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
2349     {
2350       tree op00 = TREE_OPERAND (sub, 0);
2351       tree op01 = TREE_OPERAND (sub, 1);
2352
2353       STRIP_NOPS (op00);
2354       if (TREE_CODE (op00) == ADDR_EXPR)
2355         {
2356           tree op00type;
2357           op00 = TREE_OPERAND (op00, 0);
2358           op00type = TREE_TYPE (op00);
2359
2360           /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
2361           if (TREE_CODE (op00type) == VECTOR_TYPE
2362               && (same_type_ignoring_top_level_qualifiers_p
2363                   (type, TREE_TYPE (op00type))))
2364             {
2365               HOST_WIDE_INT offset = tree_to_shwi (op01);
2366               tree part_width = TYPE_SIZE (type);
2367               unsigned HOST_WIDE_INT part_widthi = tree_to_shwi (part_width)/BITS_PER_UNIT;
2368               unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
2369               tree index = bitsize_int (indexi);
2370
2371               if (offset / part_widthi < TYPE_VECTOR_SUBPARTS (op00type))
2372                 return fold_build3_loc (loc,
2373                                         BIT_FIELD_REF, type, op00,
2374                                         part_width, index);
2375
2376             }
2377           /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
2378           else if (TREE_CODE (op00type) == COMPLEX_TYPE
2379                    && (same_type_ignoring_top_level_qualifiers_p
2380                        (type, TREE_TYPE (op00type))))
2381             {
2382               tree size = TYPE_SIZE_UNIT (type);
2383               if (tree_int_cst_equal (size, op01))
2384                 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
2385             }
2386           /* ((foo *)&fooarray)[1] => fooarray[1] */
2387           else if (TREE_CODE (op00type) == ARRAY_TYPE
2388                    && (same_type_ignoring_top_level_qualifiers_p
2389                        (type, TREE_TYPE (op00type))))
2390             {
2391               tree type_domain = TYPE_DOMAIN (op00type);
2392               tree min_val = size_zero_node;
2393               if (type_domain && TYPE_MIN_VALUE (type_domain))
2394                 min_val = TYPE_MIN_VALUE (type_domain);
2395               op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
2396                                      TYPE_SIZE_UNIT (type));
2397               op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
2398               return build4_loc (loc, ARRAY_REF, type, op00, op01,
2399                                  NULL_TREE, NULL_TREE);
2400             }
2401           /* Also handle conversion to an empty base class, which
2402              is represented with a NOP_EXPR.  */
2403           else if (is_empty_class (type)
2404                    && CLASS_TYPE_P (op00type)
2405                    && DERIVED_FROM_P (type, op00type))
2406             {
2407               *empty_base = true;
2408               return op00;
2409             }
2410           /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
2411           else if (RECORD_OR_UNION_TYPE_P (op00type))
2412             {
2413               tree field = TYPE_FIELDS (op00type);
2414               for (; field; field = DECL_CHAIN (field))
2415                 if (TREE_CODE (field) == FIELD_DECL
2416                     && tree_int_cst_equal (byte_position (field), op01)
2417                     && (same_type_ignoring_top_level_qualifiers_p
2418                         (TREE_TYPE (field), type)))
2419                   {
2420                     return fold_build3 (COMPONENT_REF, type, op00,
2421                                      field, NULL_TREE);
2422                     break;
2423                   }
2424             }
2425         }
2426     }
2427   /* *(foo *)fooarrptr => (*fooarrptr)[0] */
2428   else if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
2429            && (same_type_ignoring_top_level_qualifiers_p
2430                (type, TREE_TYPE (TREE_TYPE (subtype)))))
2431     {
2432       tree type_domain;
2433       tree min_val = size_zero_node;
2434       tree newsub = cxx_fold_indirect_ref (loc, TREE_TYPE (subtype), sub, NULL);
2435       if (newsub)
2436         sub = newsub;
2437       else
2438         sub = build1_loc (loc, INDIRECT_REF, TREE_TYPE (subtype), sub);
2439       type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
2440       if (type_domain && TYPE_MIN_VALUE (type_domain))
2441         min_val = TYPE_MIN_VALUE (type_domain);
2442       return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
2443                          NULL_TREE);
2444     }
2445
2446   return NULL_TREE;
2447 }
2448
2449 static tree
2450 cxx_eval_indirect_ref (const constexpr_ctx *ctx, tree t,
2451                        bool lval,
2452                        bool *non_constant_p, bool *overflow_p)
2453 {
2454   tree orig_op0 = TREE_OPERAND (t, 0);
2455   tree op0 = cxx_eval_constant_expression (ctx, orig_op0,
2456                                            /*lval*/false, non_constant_p,
2457                                            overflow_p);
2458   bool empty_base = false;
2459   tree r;
2460
2461   /* Don't VERIFY_CONSTANT here.  */
2462   if (*non_constant_p)
2463     return t;
2464
2465   r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), op0,
2466                              &empty_base);
2467
2468   if (r)
2469     r = cxx_eval_constant_expression (ctx, r,
2470                                       lval, non_constant_p, overflow_p);
2471   else
2472     {
2473       tree sub = op0;
2474       STRIP_NOPS (sub);
2475       if (TREE_CODE (sub) == ADDR_EXPR)
2476         {
2477           /* We couldn't fold to a constant value.  Make sure it's not
2478              something we should have been able to fold.  */
2479           gcc_assert (!same_type_ignoring_top_level_qualifiers_p
2480                       (TREE_TYPE (TREE_TYPE (sub)), TREE_TYPE (t)));
2481           /* DR 1188 says we don't have to deal with this.  */
2482           if (!ctx->quiet)
2483             error ("accessing value of %qE through a %qT glvalue in a "
2484                    "constant expression", build_fold_indirect_ref (sub),
2485                    TREE_TYPE (t));
2486           *non_constant_p = true;
2487           return t;
2488         }
2489     }
2490
2491   /* If we're pulling out the value of an empty base, make sure
2492      that the whole object is constant and then return an empty
2493      CONSTRUCTOR.  */
2494   if (empty_base && !lval)
2495     {
2496       VERIFY_CONSTANT (r);
2497       r = build_constructor (TREE_TYPE (t), NULL);
2498       TREE_CONSTANT (r) = true;
2499     }
2500
2501   if (r == NULL_TREE)
2502     {
2503       if (lval && op0 != orig_op0)
2504         return build1 (INDIRECT_REF, TREE_TYPE (t), op0);
2505       if (!lval)
2506         VERIFY_CONSTANT (t);
2507       return t;
2508     }
2509   return r;
2510 }
2511
2512 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
2513    Shared between potential_constant_expression and
2514    cxx_eval_constant_expression.  */
2515
2516 static void
2517 non_const_var_error (tree r)
2518 {
2519   tree type = TREE_TYPE (r);
2520   error ("the value of %qD is not usable in a constant "
2521          "expression", r);
2522   /* Avoid error cascade.  */
2523   if (DECL_INITIAL (r) == error_mark_node)
2524     return;
2525   if (DECL_DECLARED_CONSTEXPR_P (r))
2526     inform (DECL_SOURCE_LOCATION (r),
2527             "%qD used in its own initializer", r);
2528   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
2529     {
2530       if (!CP_TYPE_CONST_P (type))
2531         inform (DECL_SOURCE_LOCATION (r),
2532                 "%q#D is not const", r);
2533       else if (CP_TYPE_VOLATILE_P (type))
2534         inform (DECL_SOURCE_LOCATION (r),
2535                 "%q#D is volatile", r);
2536       else if (!DECL_INITIAL (r)
2537                || !TREE_CONSTANT (DECL_INITIAL (r)))
2538         inform (DECL_SOURCE_LOCATION (r),
2539                 "%qD was not initialized with a constant "
2540                 "expression", r);
2541       else
2542         gcc_unreachable ();
2543     }
2544   else
2545     {
2546       if (cxx_dialect >= cxx11 && !DECL_DECLARED_CONSTEXPR_P (r))
2547         inform (DECL_SOURCE_LOCATION (r),
2548                 "%qD was not declared %<constexpr%>", r);
2549       else
2550         inform (DECL_SOURCE_LOCATION (r),
2551                 "%qD does not have integral or enumeration type",
2552                 r);
2553     }
2554 }
2555
2556 /* Subroutine of cxx_eval_constant_expression.
2557    Like cxx_eval_unary_expression, except for trinary expressions.  */
2558
2559 static tree
2560 cxx_eval_trinary_expression (const constexpr_ctx *ctx, tree t,
2561                              bool lval,
2562                              bool *non_constant_p, bool *overflow_p)
2563 {
2564   int i;
2565   tree args[3];
2566   tree val;
2567
2568   for (i = 0; i < 3; i++)
2569     {
2570       args[i] = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, i),
2571                                               lval,
2572                                               non_constant_p, overflow_p);
2573       VERIFY_CONSTANT (args[i]);
2574     }
2575
2576   val = fold_ternary_loc (EXPR_LOCATION (t), TREE_CODE (t), TREE_TYPE (t),
2577                           args[0], args[1], args[2]);
2578   if (val == NULL_TREE)
2579     return t;
2580   VERIFY_CONSTANT (val);
2581   return val;
2582 }
2583
2584 bool
2585 var_in_constexpr_fn (tree t)
2586 {
2587   tree ctx = DECL_CONTEXT (t);
2588   return (cxx_dialect >= cxx14 && ctx && TREE_CODE (ctx) == FUNCTION_DECL
2589           && DECL_DECLARED_CONSTEXPR_P (ctx));
2590 }
2591
2592 /* Evaluate an INIT_EXPR or MODIFY_EXPR.  */
2593
2594 static tree
2595 cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
2596                            bool lval,
2597                            bool *non_constant_p, bool *overflow_p)
2598 {
2599   constexpr_ctx new_ctx = *ctx;
2600
2601   /* First we figure out where we're storing to.  */
2602   tree target = TREE_OPERAND (t, 0);
2603   target = cxx_eval_constant_expression (ctx, target,
2604                                          true,
2605                                          non_constant_p, overflow_p);
2606   if (*non_constant_p)
2607     return t;
2608
2609   /* And then find the underlying variable.  */
2610   vec<tree,va_gc> *refs = make_tree_vector();
2611   tree object = NULL_TREE;
2612   for (tree probe = target; object == NULL_TREE; )
2613     {
2614       switch (TREE_CODE (probe))
2615         {
2616         case BIT_FIELD_REF:
2617         case COMPONENT_REF:
2618         case ARRAY_REF:
2619           vec_safe_push (refs, TREE_OPERAND (probe, 1));
2620           vec_safe_push (refs, TREE_TYPE (probe));
2621           probe = TREE_OPERAND (probe, 0);
2622           break;
2623
2624         default:
2625           object = probe;
2626         }
2627     }
2628
2629   /* And then find/build up our initializer for the path to the subobject
2630      we're initializing.  */
2631   tree *valp;
2632   if (DECL_P (object))
2633     valp = ctx->values->get (object);
2634   else
2635     valp = NULL;
2636   if (!valp)
2637     {
2638       /* A constant-expression cannot modify objects from outside the
2639          constant-expression.  */
2640       if (!ctx->quiet)
2641         error ("modification of %qE is not a constant-expression", object);
2642       *non_constant_p = true;
2643       return t;
2644     }
2645   tree type = TREE_TYPE (object);
2646   while (!refs->is_empty())
2647     {
2648       if (*valp == NULL_TREE)
2649         {
2650           *valp = build_constructor (type, NULL);
2651           CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) = true;
2652         }
2653
2654       constructor_elt ce;
2655       type = refs->pop();
2656       ce.index = refs->pop();
2657       ce.value = NULL_TREE;
2658
2659       unsigned HOST_WIDE_INT idx = 0;
2660       constructor_elt *cep = NULL;
2661       for (idx = 0;
2662            vec_safe_iterate (CONSTRUCTOR_ELTS (*valp), idx, &cep);
2663            idx++)
2664         /* ??? slow */
2665         if (cp_tree_equal (ce.index, cep->index))
2666           break;
2667       if (!cep)
2668         cep = vec_safe_push (CONSTRUCTOR_ELTS (*valp), ce);
2669       valp = &cep->value;
2670     }
2671   release_tree_vector (refs);
2672
2673   if ((AGGREGATE_TYPE_P (TREE_TYPE (t)) || VECTOR_TYPE_P (TREE_TYPE (t))))
2674     {
2675       /* Create a new CONSTRUCTOR in case evaluation of the initializer
2676          wants to modify it.  */
2677       *valp = new_ctx.ctor = build_constructor (TREE_TYPE (t), NULL);
2678       CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true;
2679       new_ctx.object = target;
2680     }
2681
2682   tree init = cxx_eval_constant_expression (&new_ctx, TREE_OPERAND (t, 1),
2683                                             false,
2684                                             non_constant_p, overflow_p);
2685   if (target == object)
2686     /* The hash table might have moved since the get earlier.  */
2687     ctx->values->put (object, init);
2688   else
2689     *valp = init;
2690
2691   if (*non_constant_p)
2692     return t;
2693   else if (lval)
2694     return target;
2695   else
2696     return init;
2697 }
2698
2699 /* Evaluate a ++ or -- expression.  */
2700
2701 static tree
2702 cxx_eval_increment_expression (const constexpr_ctx *ctx, tree t,
2703                               bool lval,
2704                               bool *non_constant_p, bool *overflow_p)
2705 {
2706   enum tree_code code = TREE_CODE (t);
2707   tree type = TREE_TYPE (t);
2708   tree op = TREE_OPERAND (t, 0);
2709   tree offset = TREE_OPERAND (t, 1);
2710   gcc_assert (TREE_CONSTANT (offset));
2711
2712   /* The operand as an lvalue.  */
2713   op = cxx_eval_constant_expression (ctx, op, true,
2714                                      non_constant_p, overflow_p);
2715
2716   /* The operand as an rvalue.  */
2717   tree val = rvalue (op);
2718   val = cxx_eval_constant_expression (ctx, val, false,
2719                                       non_constant_p, overflow_p);
2720   /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to
2721      a local array in a constexpr function.  */
2722   bool ptr = POINTER_TYPE_P (TREE_TYPE (val));
2723   if (!ptr)
2724     VERIFY_CONSTANT (val);
2725
2726   /* The modified value.  */
2727   bool inc = (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR);
2728   tree mod;
2729   if (POINTER_TYPE_P (type))
2730     {
2731       /* The middle end requires pointers to use POINTER_PLUS_EXPR.  */
2732       offset = convert_to_ptrofftype (offset);
2733       if (!inc)
2734         offset = fold_build1 (NEGATE_EXPR, TREE_TYPE (offset), offset);
2735       mod = fold_build2 (POINTER_PLUS_EXPR, type, val, offset);
2736     }
2737   else
2738     mod = fold_build2 (inc ? PLUS_EXPR : MINUS_EXPR, type, val, offset);
2739   if (!ptr)
2740     VERIFY_CONSTANT (mod);
2741
2742   /* Storing the modified value.  */
2743   tree store = build2 (MODIFY_EXPR, type, op, mod);
2744   cxx_eval_constant_expression (ctx, store,
2745                                 true, non_constant_p, overflow_p);
2746
2747   /* And the value of the expression.  */
2748   if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
2749     {
2750       /* Prefix ops are lvalues.  */
2751       if (lval)
2752         return op;
2753       else
2754         /* But we optimize when the caller wants an rvalue.  */
2755         return mod;
2756     }
2757   else
2758     /* Postfix ops are rvalues.  */
2759     return val;
2760 }
2761
2762 /* Predicates for the meaning of *jump_target.  */
2763
2764 static bool
2765 returns (tree *jump_target)
2766 {
2767   return *jump_target
2768     && TREE_CODE (*jump_target) == RETURN_EXPR;
2769 }
2770
2771 static bool
2772 breaks (tree *jump_target)
2773 {
2774   return *jump_target
2775     && TREE_CODE (*jump_target) == LABEL_DECL
2776     && LABEL_DECL_BREAK (*jump_target);
2777 }
2778
2779 static bool
2780 continues (tree *jump_target)
2781 {
2782   return *jump_target
2783     && TREE_CODE (*jump_target) == LABEL_DECL
2784     && LABEL_DECL_CONTINUE (*jump_target);
2785 }
2786
2787 static bool
2788 switches (tree *jump_target)
2789 {
2790   return *jump_target
2791     && TREE_CODE (*jump_target) == INTEGER_CST;
2792 }
2793
2794 /* Subroutine of cxx_eval_statement_list.  Determine whether the statement
2795    at I matches *jump_target.  If we're looking for a case label and we see
2796    the default label, copy I into DEFAULT_LABEL.  */
2797
2798 static bool
2799 label_matches (tree *jump_target, tree_stmt_iterator i,
2800                tree_stmt_iterator& default_label)
2801 {
2802   tree stmt = tsi_stmt (i);
2803   switch (TREE_CODE (*jump_target))
2804     {
2805     case LABEL_DECL:
2806       if (TREE_CODE (stmt) == LABEL_EXPR
2807           && LABEL_EXPR_LABEL (stmt) == *jump_target)
2808         return true;
2809       break;
2810
2811     case INTEGER_CST:
2812       if (TREE_CODE (stmt) == CASE_LABEL_EXPR)
2813         {
2814           if (!CASE_LOW (stmt))
2815             default_label = i;
2816           else if (tree_int_cst_equal (*jump_target, CASE_LOW (stmt)))
2817             return true;
2818         }
2819       break;
2820
2821     default:
2822       gcc_unreachable ();
2823     }
2824   return false;
2825 }
2826
2827 /* Evaluate a STATEMENT_LIST for side-effects.  Handles various jump
2828    semantics, for switch, break, continue, and return.  */
2829
2830 static tree
2831 cxx_eval_statement_list (const constexpr_ctx *ctx, tree t,
2832                          bool *non_constant_p, bool *overflow_p,
2833                          tree *jump_target)
2834 {
2835   tree_stmt_iterator i;
2836   tree_stmt_iterator default_label = tree_stmt_iterator();
2837   tree local_target;
2838   /* In a statement-expression we want to return the last value.  */
2839   tree r = NULL_TREE;
2840   if (!jump_target)
2841     {
2842       local_target = NULL_TREE;
2843       jump_target = &local_target;
2844     }
2845   for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
2846     {
2847     reenter:
2848       tree stmt = tsi_stmt (i);
2849       if (*jump_target)
2850         {
2851           if (TREE_CODE (stmt) == STATEMENT_LIST)
2852             /* The label we want might be inside.  */;
2853           else if (label_matches (jump_target, i, default_label))
2854             /* Found it.  */
2855             *jump_target = NULL_TREE;
2856           else
2857             continue;
2858         }
2859       r = cxx_eval_constant_expression (ctx, stmt, false,
2860                                         non_constant_p, overflow_p,
2861                                         jump_target);
2862       if (*non_constant_p)
2863         break;
2864       if (returns (jump_target) || breaks (jump_target))
2865         break;
2866     }
2867   if (switches (jump_target) && !tsi_end_p (default_label))
2868     {
2869       i = default_label;
2870       *jump_target = NULL_TREE;
2871       goto reenter;
2872     }
2873   return r;
2874 }
2875
2876 /* Evaluate a LOOP_EXPR for side-effects.  Handles break and return
2877    semantics; continue semantics are covered by cxx_eval_statement_list.  */
2878
2879 static tree
2880 cxx_eval_loop_expr (const constexpr_ctx *ctx, tree t,
2881                     bool *non_constant_p, bool *overflow_p,
2882                     tree *jump_target)
2883 {
2884   tree body = TREE_OPERAND (t, 0);
2885   while (true)
2886     {
2887       cxx_eval_statement_list (ctx, body,
2888                                non_constant_p, overflow_p, jump_target);
2889       if (returns (jump_target) || breaks (jump_target) || *non_constant_p)
2890         break;
2891     }
2892   if (breaks (jump_target))
2893     *jump_target = NULL_TREE;
2894   return NULL_TREE;
2895 }
2896
2897 /* Evaluate a SWITCH_EXPR for side-effects.  Handles switch and break jump
2898    semantics.  */
2899
2900 static tree
2901 cxx_eval_switch_expr (const constexpr_ctx *ctx, tree t,
2902                       bool *non_constant_p, bool *overflow_p,
2903                       tree *jump_target)
2904 {
2905   tree cond = TREE_OPERAND (t, 0);
2906   cond = cxx_eval_constant_expression (ctx, cond, false,
2907                                        non_constant_p, overflow_p);
2908   VERIFY_CONSTANT (cond);
2909   *jump_target = cond;
2910
2911   tree body = TREE_OPERAND (t, 1);
2912   cxx_eval_statement_list (ctx, body,
2913                            non_constant_p, overflow_p, jump_target);
2914   if (breaks (jump_target) || switches (jump_target))
2915     *jump_target = NULL_TREE;
2916   return NULL_TREE;
2917 }
2918
2919 /* Attempt to reduce the expression T to a constant value.
2920    On failure, issue diagnostic and return error_mark_node.  */
2921 /* FIXME unify with c_fully_fold */
2922 /* FIXME overflow_p is too global */
2923
2924 static tree
2925 cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
2926                               bool lval,
2927                               bool *non_constant_p, bool *overflow_p,
2928                               tree *jump_target)
2929 {
2930   constexpr_ctx new_ctx;
2931   tree r = t;
2932
2933   if (t == error_mark_node)
2934     {
2935       *non_constant_p = true;
2936       return t;
2937     }
2938   if (CONSTANT_CLASS_P (t))
2939     {
2940       if (TREE_CODE (t) == PTRMEM_CST)
2941         t = cplus_expand_constant (t);
2942       else if (TREE_OVERFLOW (t) && (!flag_permissive || ctx->quiet))
2943         *overflow_p = true;
2944       return t;
2945     }
2946
2947   switch (TREE_CODE (t))
2948     {
2949     case RESULT_DECL:
2950       if (lval)
2951         return t;
2952       /* We ask for an rvalue for the RESULT_DECL when indirecting
2953          through an invisible reference.  */
2954       gcc_assert (DECL_BY_REFERENCE (t));
2955       return (*ctx->values->get (t));
2956
2957     case VAR_DECL:
2958     case CONST_DECL:
2959       /* We used to not check lval for CONST_DECL, but darwin.c uses
2960          CONST_DECL for aggregate constants.  */
2961       if (lval)
2962         return t;
2963       if (ctx->strict)
2964         r = decl_really_constant_value (t);
2965       else
2966         r = decl_constant_value (t);
2967       if (TREE_CODE (r) == TARGET_EXPR
2968           && TREE_CODE (TARGET_EXPR_INITIAL (r)) == CONSTRUCTOR)
2969         r = TARGET_EXPR_INITIAL (r);
2970       if (TREE_CODE (r) == VAR_DECL)
2971         if (tree *p = ctx->values->get (r))
2972           r = *p;
2973       if (DECL_P (r))
2974         {
2975           if (!ctx->quiet)
2976             non_const_var_error (r);
2977           *non_constant_p = true;
2978         }
2979       break;
2980
2981     case FUNCTION_DECL:
2982     case TEMPLATE_DECL:
2983     case LABEL_DECL:
2984     case LABEL_EXPR:
2985     case CASE_LABEL_EXPR:
2986       return t;
2987
2988     case PARM_DECL:
2989       if (!use_new_call && ctx
2990           && ctx->call && DECL_CONTEXT (t) == ctx->call->fundef->decl)
2991         r = lookup_parameter_binding (ctx->call, t);
2992       else if (lval && TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
2993         /* glvalue use.  */;
2994       else if (tree *p = ctx->values->get (r))
2995         r = *p;
2996       else if (lval)
2997         /* Defer in case this is only used for its type.  */;
2998       else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
2999         /* Defer, there's no lvalue->rvalue conversion.  */;
3000       else if (is_empty_class (TREE_TYPE (t)))
3001         {
3002           /* If the class is empty, we aren't actually loading anything.  */
3003           r = build_constructor (TREE_TYPE (t), NULL);
3004           TREE_CONSTANT (r) = true;
3005         }
3006       else
3007         {
3008           if (!ctx->quiet)
3009             error ("%qE is not a constant expression", t);
3010           *non_constant_p = true;
3011         }
3012       break;
3013
3014     case CALL_EXPR:
3015     case AGGR_INIT_EXPR:
3016       r = cxx_eval_call_expression (ctx, t, lval,
3017                                     non_constant_p, overflow_p);
3018       break;
3019
3020     case DECL_EXPR:
3021       {
3022         r = DECL_EXPR_DECL (t);
3023         if (AGGREGATE_TYPE_P (TREE_TYPE (r))
3024             || VECTOR_TYPE_P (TREE_TYPE (r)))
3025           {
3026             new_ctx = *ctx;
3027             new_ctx.object = r;
3028             new_ctx.ctor = build_constructor (TREE_TYPE (r), NULL);
3029             CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true;
3030             new_ctx.values->put (r, new_ctx.ctor);
3031             ctx = &new_ctx;
3032           }
3033
3034         if (tree init = DECL_INITIAL (r))
3035           {
3036             init = cxx_eval_constant_expression (ctx, init,
3037                                                  false,
3038                                                  non_constant_p, overflow_p);
3039             ctx->values->put (r, init);
3040           }
3041         else if (ctx == &new_ctx)
3042           /* We gave it a CONSTRUCTOR above.  */;
3043         else
3044           ctx->values->put (r, NULL_TREE);
3045       }
3046       break;
3047
3048     case TARGET_EXPR:
3049       if (!literal_type_p (TREE_TYPE (t)))
3050         {
3051           if (!ctx->quiet)
3052             {
3053               error ("temporary of non-literal type %qT in a "
3054                      "constant expression", TREE_TYPE (t));
3055               explain_non_literal_class (TREE_TYPE (t));
3056             }
3057           *non_constant_p = true;
3058           break;
3059         }
3060       if ((AGGREGATE_TYPE_P (TREE_TYPE (t)) || VECTOR_TYPE_P (TREE_TYPE (t))))
3061         {
3062           /* We're being expanded without an explicit target, so start
3063              initializing a new object; expansion with an explicit target
3064              strips the TARGET_EXPR before we get here.  */
3065           new_ctx = *ctx;
3066           new_ctx.ctor = build_constructor (TREE_TYPE (t), NULL);
3067           CONSTRUCTOR_NO_IMPLICIT_ZERO (new_ctx.ctor) = true;
3068           new_ctx.object = TARGET_EXPR_SLOT (t);
3069           ctx->values->put (new_ctx.object, new_ctx.ctor);
3070           ctx = &new_ctx;
3071         }
3072       /* Pass false for 'lval' because this indicates
3073          initialization of a temporary.  */
3074       r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
3075                                         false,
3076                                         non_constant_p, overflow_p);
3077       if (!*non_constant_p)
3078         /* Adjust the type of the result to the type of the temporary.  */
3079         r = adjust_temp_type (TREE_TYPE (t), r);
3080       if (lval)
3081         {
3082           tree slot = TARGET_EXPR_SLOT (t);
3083           ctx->values->put (slot, r);
3084           return slot;
3085         }
3086       break;
3087
3088     case INIT_EXPR:
3089       if (!use_new_call)
3090         {
3091           /* In C++11 constexpr evaluation we are looking for the value,
3092              not the side-effect of the initialization.  */
3093           r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
3094                                             false,
3095                                             non_constant_p, overflow_p);
3096           break;
3097         }
3098       /* else fall through */
3099     case MODIFY_EXPR:
3100       r = cxx_eval_store_expression (ctx, t, lval,
3101                                      non_constant_p, overflow_p);
3102       break;
3103
3104     case SCOPE_REF:
3105       r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1),
3106                                         lval,
3107                                         non_constant_p, overflow_p);
3108       break;
3109
3110     case RETURN_EXPR:
3111       r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
3112                                         lval,
3113                                         non_constant_p, overflow_p);
3114       *jump_target = t;
3115       break;
3116
3117     case SAVE_EXPR:
3118       /* Avoid evaluating a SAVE_EXPR more than once.  */
3119       if (tree *p = ctx->values->get (t))
3120         r = *p;
3121       else
3122         {
3123           r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), false,
3124                                             non_constant_p, overflow_p);
3125           ctx->values->put (t, r);
3126         }
3127       break;
3128
3129     case NON_LVALUE_EXPR:
3130     case TRY_CATCH_EXPR:
3131     case CLEANUP_POINT_EXPR:
3132     case MUST_NOT_THROW_EXPR:
3133     case EXPR_STMT:
3134     case EH_SPEC_BLOCK:
3135       r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0),
3136                                         lval,
3137                                         non_constant_p, overflow_p,
3138                                         jump_target);
3139       break;
3140
3141       /* These differ from cxx_eval_unary_expression in that this doesn't
3142          check for a constant operand or result; an address can be
3143          constant without its operand being, and vice versa.  */
3144     case INDIRECT_REF:
3145       r = cxx_eval_indirect_ref (ctx, t, lval,
3146                                  non_constant_p, overflow_p);
3147       break;
3148
3149     case ADDR_EXPR:
3150       {
3151         tree oldop = TREE_OPERAND (t, 0);
3152         tree op = cxx_eval_constant_expression (ctx, oldop,
3153                                                 /*lval*/true,
3154                                                 non_constant_p, overflow_p);
3155         /* Don't VERIFY_CONSTANT here.  */
3156         if (*non_constant_p)
3157           return t;
3158         gcc_checking_assert (TREE_CODE (op) != CONSTRUCTOR);
3159         /* This function does more aggressive folding than fold itself.  */
3160         r = build_fold_addr_expr_with_type (op, TREE_TYPE (t));
3161         if (TREE_CODE (r) == ADDR_EXPR && TREE_OPERAND (r, 0) == oldop)
3162           return t;
3163         break;
3164       }
3165
3166     case REALPART_EXPR:
3167     case IMAGPART_EXPR:
3168     case CONJ_EXPR:
3169     case FIX_TRUNC_EXPR:
3170     case FLOAT_EXPR:
3171     case NEGATE_EXPR:
3172     case ABS_EXPR:
3173     case BIT_NOT_EXPR:
3174     case TRUTH_NOT_EXPR:
3175     case FIXED_CONVERT_EXPR:
3176       r = cxx_eval_unary_expression (ctx, t, lval,
3177                                      non_constant_p, overflow_p);
3178       break;
3179
3180     case SIZEOF_EXPR:
3181       if (SIZEOF_EXPR_TYPE_P (t))
3182         r = cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t, 0)),
3183                                         SIZEOF_EXPR, false);
3184       else if (TYPE_P (TREE_OPERAND (t, 0)))
3185         r = cxx_sizeof_or_alignof_type (TREE_OPERAND (t, 0), SIZEOF_EXPR,
3186                                         false);
3187       else
3188         r = cxx_sizeof_or_alignof_expr (TREE_OPERAND (t, 0), SIZEOF_EXPR,
3189                                         false);
3190       if (r == error_mark_node)
3191         r = size_one_node;
3192       VERIFY_CONSTANT (r);
3193       break;
3194
3195     case COMPOUND_EXPR:
3196       {
3197         /* check_return_expr sometimes wraps a TARGET_EXPR in a
3198            COMPOUND_EXPR; don't get confused.  Also handle EMPTY_CLASS_EXPR
3199            introduced by build_call_a.  */
3200         tree op0 = TREE_OPERAND (t, 0);
3201         tree op1 = TREE_OPERAND (t, 1);
3202         STRIP_NOPS (op1);
3203         if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0))
3204             || TREE_CODE (op1) == EMPTY_CLASS_EXPR)
3205           r = cxx_eval_constant_expression (ctx, op0,
3206                                             lval, non_constant_p, overflow_p,
3207                                             jump_target);
3208         else
3209           {
3210             /* Check that the LHS is constant and then discard it.  */
3211             cxx_eval_constant_expression (ctx, op0,
3212                                           true, non_constant_p, overflow_p,
3213                                           jump_target);
3214             op1 = TREE_OPERAND (t, 1);
3215             r = cxx_eval_constant_expression (ctx, op1,
3216                                               lval, non_constant_p, overflow_p,
3217                                               jump_target);
3218           }
3219       }
3220       break;
3221
3222     case POINTER_PLUS_EXPR:
3223     case PLUS_EXPR:
3224     case MINUS_EXPR:
3225     case MULT_EXPR:
3226     case TRUNC_DIV_EXPR:
3227     case CEIL_DIV_EXPR:
3228     case FLOOR_DIV_EXPR:
3229     case ROUND_DIV_EXPR:
3230     case TRUNC_MOD_EXPR:
3231     case CEIL_MOD_EXPR:
3232     case ROUND_MOD_EXPR:
3233     case RDIV_EXPR:
3234     case EXACT_DIV_EXPR:
3235     case MIN_EXPR:
3236     case MAX_EXPR:
3237     case LSHIFT_EXPR:
3238     case RSHIFT_EXPR:
3239     case LROTATE_EXPR:
3240     case RROTATE_EXPR:
3241     case BIT_IOR_EXPR:
3242     case BIT_XOR_EXPR:
3243     case BIT_AND_EXPR:
3244     case TRUTH_XOR_EXPR:
3245     case LT_EXPR:
3246     case LE_EXPR:
3247     case GT_EXPR:
3248     case GE_EXPR:
3249     case EQ_EXPR:
3250     case NE_EXPR:
3251     case UNORDERED_EXPR:
3252     case ORDERED_EXPR:
3253     case UNLT_EXPR:
3254     case UNLE_EXPR:
3255     case UNGT_EXPR:
3256     case UNGE_EXPR:
3257     case UNEQ_EXPR:
3258     case LTGT_EXPR:
3259     case RANGE_EXPR:
3260     case COMPLEX_EXPR:
3261       r = cxx_eval_binary_expression (ctx, t, lval,
3262                                       non_constant_p, overflow_p);
3263       break;
3264
3265       /* fold can introduce non-IF versions of these; still treat them as
3266          short-circuiting.  */
3267     case TRUTH_AND_EXPR:
3268     case TRUTH_ANDIF_EXPR:
3269       r = cxx_eval_logical_expression (ctx, t, boolean_false_node,
3270                                        boolean_true_node,
3271                                        lval,
3272                                        non_constant_p, overflow_p);
3273       break;
3274
3275     case TRUTH_OR_EXPR:
3276     case TRUTH_ORIF_EXPR:
3277       r = cxx_eval_logical_expression (ctx, t, boolean_true_node,
3278                                        boolean_false_node,
3279                                        lval,
3280                                        non_constant_p, overflow_p);
3281       break;
3282
3283     case ARRAY_REF:
3284       r = cxx_eval_array_reference (ctx, t, lval,
3285                                     non_constant_p, overflow_p);
3286       break;
3287
3288     case COMPONENT_REF:
3289       if (is_overloaded_fn (t))
3290         {
3291           /* We can only get here in checking mode via 
3292              build_non_dependent_expr,  because any expression that
3293              calls or takes the address of the function will have
3294              pulled a FUNCTION_DECL out of the COMPONENT_REF.  */
3295           gcc_checking_assert (ctx->quiet || errorcount);
3296           *non_constant_p = true;
3297           return t;
3298         }
3299       r = cxx_eval_component_reference (ctx, t, lval,
3300                                         non_constant_p, overflow_p);
3301       break;
3302
3303     case BIT_FIELD_REF:
3304       r = cxx_eval_bit_field_ref (ctx, t, lval,
3305                                   non_constant_p, overflow_p);
3306       break;
3307
3308     case COND_EXPR:
3309     case VEC_COND_EXPR:
3310       r = cxx_eval_conditional_expression (ctx, t, lval,
3311                                            non_constant_p, overflow_p,
3312                                            jump_target);
3313       break;
3314
3315     case CONSTRUCTOR:
3316       if (TREE_CONSTANT (t))
3317         /* Don't re-process a constant CONSTRUCTOR, but do fold it to
3318            VECTOR_CST if applicable.  */
3319         return fold (t);
3320       r = cxx_eval_bare_aggregate (ctx, t, lval,
3321                                    non_constant_p, overflow_p);
3322       break;
3323
3324     case VEC_INIT_EXPR:
3325       /* We can get this in a defaulted constructor for a class with a
3326          non-static data member of array type.  Either the initializer will
3327          be NULL, meaning default-initialization, or it will be an lvalue
3328          or xvalue of the same type, meaning direct-initialization from the
3329          corresponding member.  */
3330       r = cxx_eval_vec_init (ctx, t, lval,
3331                              non_constant_p, overflow_p);
3332       break;
3333
3334     case FMA_EXPR:
3335     case VEC_PERM_EXPR:
3336       r = cxx_eval_trinary_expression (ctx, t, lval,
3337                                        non_constant_p, overflow_p);
3338       break;
3339
3340     case CONVERT_EXPR:
3341     case VIEW_CONVERT_EXPR:
3342     case NOP_EXPR:
3343       {
3344         tree oldop = TREE_OPERAND (t, 0);
3345         tree op = cxx_eval_constant_expression (ctx, oldop,
3346                                                 lval,
3347                                                 non_constant_p, overflow_p);
3348         if (*non_constant_p)
3349           return t;
3350         if (POINTER_TYPE_P (TREE_TYPE (t))
3351             && TREE_CODE (op) == INTEGER_CST
3352             && !integer_zerop (op))
3353           {
3354             if (!ctx->quiet)
3355               error_at (EXPR_LOC_OR_LOC (t, input_location),
3356                         "reinterpret_cast from integer to pointer");
3357             *non_constant_p = true;
3358             return t;
3359           }
3360         if (op == oldop)
3361           /* We didn't fold at the top so we could check for ptr-int
3362              conversion.  */
3363           return fold (t);
3364         r = fold_build1 (TREE_CODE (t), TREE_TYPE (t), op);
3365         /* Conversion of an out-of-range value has implementation-defined
3366            behavior; the language considers it different from arithmetic
3367            overflow, which is undefined.  */
3368         if (TREE_OVERFLOW_P (r) && !TREE_OVERFLOW_P (op))
3369           TREE_OVERFLOW (r) = false;
3370       }
3371       break;
3372
3373     case EMPTY_CLASS_EXPR:
3374       /* This is good enough for a function argument that might not get
3375          used, and they can't do anything with it, so just return it.  */
3376       return t;
3377
3378     case STATEMENT_LIST:
3379       new_ctx = *ctx;
3380       new_ctx.ctor = new_ctx.object = NULL_TREE;
3381       return cxx_eval_statement_list (&new_ctx, t,
3382                                       non_constant_p, overflow_p, jump_target);
3383
3384     case BIND_EXPR:
3385       return cxx_eval_constant_expression (ctx, BIND_EXPR_BODY (t),
3386                                            lval,
3387                                            non_constant_p, overflow_p,
3388                                            jump_target);
3389
3390     case PREINCREMENT_EXPR:
3391     case POSTINCREMENT_EXPR:
3392     case PREDECREMENT_EXPR:
3393     case POSTDECREMENT_EXPR:
3394       return cxx_eval_increment_expression (ctx, t,
3395                                             lval, non_constant_p, overflow_p);
3396
3397     case LAMBDA_EXPR:
3398     case NEW_EXPR:
3399     case VEC_NEW_EXPR:
3400     case DELETE_EXPR:
3401     case VEC_DELETE_EXPR:
3402     case THROW_EXPR:
3403     case MODOP_EXPR:
3404       /* GCC internal stuff.  */
3405     case VA_ARG_EXPR:
3406     case OBJ_TYPE_REF:
3407     case WITH_CLEANUP_EXPR:
3408     case NON_DEPENDENT_EXPR:
3409     case BASELINK:
3410     case OFFSET_REF:
3411       if (!ctx->quiet)
3412         error_at (EXPR_LOC_OR_LOC (t, input_location),
3413                   "expression %qE is not a constant-expression", t);
3414       *non_constant_p = true;
3415       break;
3416
3417     case PLACEHOLDER_EXPR:
3418       if (!ctx || !ctx->ctor || (lval && !ctx->object))
3419         {
3420           /* A placeholder without a referent.  We can get here when
3421              checking whether NSDMIs are noexcept, or in massage_init_elt;
3422              just say it's non-constant for now.  */
3423           gcc_assert (ctx->quiet);
3424           *non_constant_p = true;
3425           break;
3426         }
3427       else
3428         {
3429           /* Use of the value or address of the current object.  We could
3430              use ctx->object unconditionally, but using ctx->ctor when we
3431              can is a minor optimization.  */
3432           tree ctor = lval ? ctx->object : ctx->ctor;
3433           gcc_assert (same_type_ignoring_top_level_qualifiers_p
3434                       (TREE_TYPE (t), TREE_TYPE (ctor)));
3435           return cxx_eval_constant_expression
3436             (ctx, ctor, lval,
3437              non_constant_p, overflow_p);
3438         }
3439       break;
3440
3441     case GOTO_EXPR:
3442       *jump_target = TREE_OPERAND (t, 0);
3443       gcc_assert (breaks (jump_target) || continues (jump_target));
3444       break;
3445
3446     case LOOP_EXPR:
3447       cxx_eval_loop_expr (ctx, t,
3448                           non_constant_p, overflow_p, jump_target);
3449       break;
3450
3451     case SWITCH_EXPR:
3452       cxx_eval_switch_expr (ctx, t,
3453                             non_constant_p, overflow_p, jump_target);
3454       break;
3455
3456     default:
3457       if (STATEMENT_CODE_P (TREE_CODE (t)))
3458         {
3459           /* This function doesn't know how to deal with pre-genericize
3460              statements; this can only happen with statement-expressions,
3461              so for now just fail.  */
3462           if (!ctx->quiet)
3463             error_at (EXPR_LOCATION (t),
3464                       "statement is not a constant-expression");
3465         }
3466       else
3467         internal_error ("unexpected expression %qE of kind %s", t,
3468                         get_tree_code_name (TREE_CODE (t)));
3469       *non_constant_p = true;
3470       break;
3471     }
3472
3473   if (r == error_mark_node)
3474     *non_constant_p = true;
3475
3476   if (*non_constant_p)
3477     return t;
3478   else
3479     return r;
3480 }
3481
3482 static tree
3483 cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,
3484                                   bool strict = true, tree object = NULL_TREE)
3485 {
3486   bool non_constant_p = false;
3487   bool overflow_p = false;
3488   hash_map<tree,tree> map;
3489   constexpr_ctx ctx = { NULL, &map, NULL, NULL, allow_non_constant, strict };
3490   tree type = initialized_type (t);
3491   tree r = t;
3492   if (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type))
3493     {
3494       /* In C++14 an NSDMI can participate in aggregate initialization,
3495          and can refer to the address of the object being initialized, so
3496          we need to pass in the relevant VAR_DECL if we want to do the
3497          evaluation in a single pass.  The evaluation will dynamically
3498          update ctx.values for the VAR_DECL.  We use the same strategy
3499          for C++11 constexpr constructors that refer to the object being
3500          initialized.  */
3501       ctx.ctor = build_constructor (type, NULL);
3502       CONSTRUCTOR_NO_IMPLICIT_ZERO (ctx.ctor) = true;
3503       if (!object)
3504         {
3505           if (TREE_CODE (t) == TARGET_EXPR)
3506             object = TARGET_EXPR_SLOT (t);
3507           else if (TREE_CODE (t) == AGGR_INIT_EXPR)
3508             object = AGGR_INIT_EXPR_SLOT (t);
3509         }
3510       ctx.object = object;
3511       if (object)
3512         gcc_assert (same_type_ignoring_top_level_qualifiers_p
3513                     (type, TREE_TYPE (object)));
3514       if (object && DECL_P (object))
3515         map.put (object, ctx.ctor);
3516       if (TREE_CODE (r) == TARGET_EXPR)
3517         /* Avoid creating another CONSTRUCTOR when we expand the
3518            TARGET_EXPR.  */
3519         r = TARGET_EXPR_INITIAL (r);
3520     }
3521
3522   r = cxx_eval_constant_expression (&ctx, r,
3523                                     false, &non_constant_p, &overflow_p);
3524
3525   verify_constant (r, allow_non_constant, &non_constant_p, &overflow_p);
3526
3527   /* Mutable logic is a bit tricky: we want to allow initialization of
3528      constexpr variables with mutable members, but we can't copy those
3529      members to another constexpr variable.  */
3530   if (TREE_CODE (r) == CONSTRUCTOR
3531       && CONSTRUCTOR_MUTABLE_POISON (r))
3532     {
3533       if (!allow_non_constant)
3534         error ("%qE is not a constant expression because it refers to "
3535                "mutable subobjects of %qT", t, type);
3536       non_constant_p = true;
3537     }
3538
3539   /* Technically we should check this for all subexpressions, but that
3540      runs into problems with our internal representation of pointer
3541      subtraction and the 5.19 rules are still in flux.  */
3542   if (CONVERT_EXPR_CODE_P (TREE_CODE (r))
3543       && ARITHMETIC_TYPE_P (TREE_TYPE (r))
3544       && TREE_CODE (TREE_OPERAND (r, 0)) == ADDR_EXPR)
3545     {
3546       if (!allow_non_constant)
3547         error ("conversion from pointer type %qT "
3548                "to arithmetic type %qT in a constant-expression",
3549                TREE_TYPE (TREE_OPERAND (r, 0)), TREE_TYPE (r));
3550       non_constant_p = true;
3551     }
3552
3553   if (!non_constant_p && overflow_p)
3554     non_constant_p = true;
3555
3556   if (non_constant_p && !allow_non_constant)
3557     return error_mark_node;
3558   else if (non_constant_p && TREE_CONSTANT (r))
3559     {
3560       /* This isn't actually constant, so unset TREE_CONSTANT.  */
3561       if (EXPR_P (r))
3562         r = copy_node (r);
3563       else if (TREE_CODE (r) == CONSTRUCTOR)
3564         r = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (r), r);
3565       else
3566         r = build_nop (TREE_TYPE (r), r);
3567       TREE_CONSTANT (r) = false;
3568     }
3569   else if (non_constant_p || r == t)
3570     return t;
3571
3572   if (TREE_CODE (r) == CONSTRUCTOR && CLASS_TYPE_P (TREE_TYPE (r)))
3573     {
3574       if (TREE_CODE (t) == TARGET_EXPR
3575           && TARGET_EXPR_INITIAL (t) == r)
3576         return t;
3577       else
3578         {
3579           r = get_target_expr (r);
3580           TREE_CONSTANT (r) = true;
3581           return r;
3582         }
3583     }
3584   else
3585     return r;
3586 }
3587
3588 /* Returns true if T is a valid subexpression of a constant expression,
3589    even if it isn't itself a constant expression.  */
3590
3591 bool
3592 is_sub_constant_expr (tree t)
3593 {
3594   bool non_constant_p = false;
3595   bool overflow_p = false;
3596   hash_map <tree, tree> map;
3597   constexpr_ctx ctx = { NULL, &map, NULL, NULL, true, true };
3598   cxx_eval_constant_expression (&ctx, t, false, &non_constant_p,
3599                                 &overflow_p);
3600   return !non_constant_p && !overflow_p;
3601 }
3602
3603 /* If T represents a constant expression returns its reduced value.
3604    Otherwise return error_mark_node.  If T is dependent, then
3605    return NULL.  */
3606
3607 tree
3608 cxx_constant_value (tree t, tree decl)
3609 {
3610   return cxx_eval_outermost_constant_expr (t, false, true, decl);
3611 }
3612
3613 /* If T is a constant expression, returns its reduced value.
3614    Otherwise, if T does not have TREE_CONSTANT set, returns T.
3615    Otherwise, returns a version of T without TREE_CONSTANT.  */
3616
3617 tree
3618 maybe_constant_value (tree t, tree decl)
3619 {
3620   tree r;
3621
3622   if (instantiation_dependent_expression_p (t)
3623       || type_unknown_p (t)
3624       || BRACE_ENCLOSED_INITIALIZER_P (t)
3625       || !potential_constant_expression (t))
3626     {
3627       if (TREE_OVERFLOW_P (t))
3628         {
3629           t = build_nop (TREE_TYPE (t), t);
3630           TREE_CONSTANT (t) = false;
3631         }
3632       return t;
3633     }
3634
3635   r = cxx_eval_outermost_constant_expr (t, true, true, decl);
3636 #ifdef ENABLE_CHECKING
3637   /* cp_tree_equal looks through NOPs, so allow them.  */
3638   gcc_assert (r == t
3639               || CONVERT_EXPR_P (t)
3640               || TREE_CODE (t) == VIEW_CONVERT_EXPR
3641               || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
3642               || !cp_tree_equal (r, t));
3643 #endif
3644   return r;
3645 }
3646
3647 /* Like maybe_constant_value but first fully instantiate the argument.
3648
3649    Note: this is equivalent to instantiate_non_dependent_expr_sfinae
3650    (t, tf_none) followed by maybe_constant_value but is more efficient,
3651    because calls instantiation_dependent_expression_p and
3652    potential_constant_expression at most once.  */
3653
3654 tree
3655 fold_non_dependent_expr (tree t)
3656 {
3657   if (t == NULL_TREE)
3658     return NULL_TREE;
3659
3660   /* If we're in a template, but T isn't value dependent, simplify
3661      it.  We're supposed to treat:
3662
3663        template <typename T> void f(T[1 + 1]);
3664        template <typename T> void f(T[2]);
3665
3666      as two declarations of the same function, for example.  */
3667   if (processing_template_decl)
3668     {
3669       if (!instantiation_dependent_expression_p (t)
3670           && potential_constant_expression (t))
3671         {
3672           processing_template_decl_sentinel s;
3673           t = instantiate_non_dependent_expr_internal (t, tf_none);
3674
3675           if (type_unknown_p (t)
3676               || BRACE_ENCLOSED_INITIALIZER_P (t))
3677             {
3678               if (TREE_OVERFLOW_P (t))
3679                 {
3680                   t = build_nop (TREE_TYPE (t), t);
3681                   TREE_CONSTANT (t) = false;
3682                 }
3683               return t;
3684             }
3685
3686           tree r = cxx_eval_outermost_constant_expr (t, true, true, NULL_TREE);
3687 #ifdef ENABLE_CHECKING
3688           /* cp_tree_equal looks through NOPs, so allow them.  */
3689           gcc_assert (r == t
3690                       || CONVERT_EXPR_P (t)
3691                       || TREE_CODE (t) == VIEW_CONVERT_EXPR
3692                       || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
3693                       || !cp_tree_equal (r, t));
3694 #endif
3695           return r;
3696         }
3697       else if (TREE_OVERFLOW_P (t))
3698         {
3699           t = build_nop (TREE_TYPE (t), t);
3700           TREE_CONSTANT (t) = false;
3701         }
3702       return t;
3703     }
3704
3705   return maybe_constant_value (t);
3706 }
3707
3708 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
3709    than wrapped in a TARGET_EXPR.  */
3710
3711 tree
3712 maybe_constant_init (tree t, tree decl)
3713 {
3714   if (TREE_CODE (t) == EXPR_STMT)
3715     t = TREE_OPERAND (t, 0);
3716   if (TREE_CODE (t) == CONVERT_EXPR
3717       && VOID_TYPE_P (TREE_TYPE (t)))
3718     t = TREE_OPERAND (t, 0);
3719   if (TREE_CODE (t) == INIT_EXPR)
3720     t = TREE_OPERAND (t, 1);
3721   if (instantiation_dependent_expression_p (t)
3722       || type_unknown_p (t)
3723       || BRACE_ENCLOSED_INITIALIZER_P (t)
3724       || !potential_static_init_expression (t))
3725     /* Don't try to evaluate it.  */;
3726   else
3727     t = cxx_eval_outermost_constant_expr (t, true, false, decl);
3728   if (TREE_CODE (t) == TARGET_EXPR)
3729     {
3730       tree init = TARGET_EXPR_INITIAL (t);
3731       if (TREE_CODE (init) == CONSTRUCTOR)
3732         t = init;
3733     }
3734   return t;
3735 }
3736
3737 #if 0
3738 /* FIXME see ADDR_EXPR section in potential_constant_expression_1.  */
3739 /* Return true if the object referred to by REF has automatic or thread
3740    local storage.  */
3741
3742 enum { ck_ok, ck_bad, ck_unknown };
3743 static int
3744 check_automatic_or_tls (tree ref)
3745 {
3746   machine_mode mode;
3747   HOST_WIDE_INT bitsize, bitpos;
3748   tree offset;
3749   int volatilep = 0, unsignedp = 0;
3750   tree decl = get_inner_reference (ref, &bitsize, &bitpos, &offset,
3751                                    &mode, &unsignedp, &volatilep, false);
3752   duration_kind dk;
3753
3754   /* If there isn't a decl in the middle, we don't know the linkage here,
3755      and this isn't a constant expression anyway.  */
3756   if (!DECL_P (decl))
3757     return ck_unknown;
3758   dk = decl_storage_duration (decl);
3759   return (dk == dk_auto || dk == dk_thread) ? ck_bad : ck_ok;
3760 }
3761 #endif
3762
3763 /* Return true if T denotes a potentially constant expression.  Issue
3764    diagnostic as appropriate under control of FLAGS.  If WANT_RVAL is true,
3765    an lvalue-rvalue conversion is implied.
3766
3767    C++0x [expr.const] used to say
3768
3769    6 An expression is a potential constant expression if it is
3770      a constant expression where all occurrences of function
3771      parameters are replaced by arbitrary constant expressions
3772      of the appropriate type.
3773
3774    2  A conditional expression is a constant expression unless it
3775       involves one of the following as a potentially evaluated
3776       subexpression (3.2), but subexpressions of logical AND (5.14),
3777       logical OR (5.15), and conditional (5.16) operations that are
3778       not evaluated are not considered.   */
3779
3780 static bool
3781 potential_constant_expression_1 (tree t, bool want_rval, bool strict,
3782                                  tsubst_flags_t flags)
3783 {
3784 #define RECUR(T,RV) potential_constant_expression_1 ((T), (RV), strict, flags)
3785   enum { any = false, rval = true };
3786   int i;
3787   tree tmp;
3788
3789   if (t == error_mark_node)
3790     return false;
3791   if (t == NULL_TREE)
3792     return true;
3793   if (TREE_THIS_VOLATILE (t))
3794     {
3795       if (flags & tf_error)
3796         error ("expression %qE has side-effects", t);
3797       return false;
3798     }
3799   if (CONSTANT_CLASS_P (t))
3800     return true;
3801
3802   switch (TREE_CODE (t))
3803     {
3804     case FUNCTION_DECL:
3805     case BASELINK:
3806     case TEMPLATE_DECL:
3807     case OVERLOAD:
3808     case TEMPLATE_ID_EXPR:
3809     case LABEL_DECL:
3810     case LABEL_EXPR:
3811     case CASE_LABEL_EXPR:
3812     case CONST_DECL:
3813     case SIZEOF_EXPR:
3814     case ALIGNOF_EXPR:
3815     case OFFSETOF_EXPR:
3816     case NOEXCEPT_EXPR:
3817     case TEMPLATE_PARM_INDEX:
3818     case TRAIT_EXPR:
3819     case IDENTIFIER_NODE:
3820     case USERDEF_LITERAL:
3821       /* We can see a FIELD_DECL in a pointer-to-member expression.  */
3822     case FIELD_DECL:
3823     case PARM_DECL:
3824     case USING_DECL:
3825     case USING_STMT:
3826     case PLACEHOLDER_EXPR:
3827     case BREAK_STMT:
3828     case CONTINUE_STMT:
3829       return true;
3830
3831     case AGGR_INIT_EXPR:
3832     case CALL_EXPR:
3833       /* -- an invocation of a function other than a constexpr function
3834             or a constexpr constructor.  */
3835       {
3836         tree fun = get_function_named_in_call (t);
3837         const int nargs = call_expr_nargs (t);
3838         i = 0;
3839
3840         if (fun == NULL_TREE)
3841           {
3842             if (TREE_CODE (t) == CALL_EXPR
3843                 && CALL_EXPR_FN (t) == NULL_TREE)
3844               switch (CALL_EXPR_IFN (t))
3845                 {
3846                 /* These should be ignored, they are optimized away from
3847                    constexpr functions.  */
3848                 case IFN_UBSAN_NULL:
3849                 case IFN_UBSAN_BOUNDS:
3850                 case IFN_UBSAN_VPTR:
3851                   return true;
3852                 default:
3853                   break;
3854                 }
3855             /* fold_call_expr can't do anything with IFN calls.  */
3856             if (flags & tf_error)
3857               error_at (EXPR_LOC_OR_LOC (t, input_location),
3858                         "call to internal function");
3859             return false;
3860           }
3861         if (is_overloaded_fn (fun))
3862           {
3863             if (TREE_CODE (fun) == FUNCTION_DECL)
3864               {
3865                 if (builtin_valid_in_constant_expr_p (fun))
3866                   return true;
3867                 if (!DECL_DECLARED_CONSTEXPR_P (fun)
3868                     /* Allow any built-in function; if the expansion
3869                        isn't constant, we'll deal with that then.  */
3870                     && !is_builtin_fn (fun))
3871                   {
3872                     if (flags & tf_error)
3873                       {
3874                         error_at (EXPR_LOC_OR_LOC (t, input_location),
3875                                   "call to non-constexpr function %qD", fun);
3876                         explain_invalid_constexpr_fn (fun);
3877                       }
3878                     return false;
3879                   }
3880                 /* A call to a non-static member function takes the address
3881                    of the object as the first argument.  But in a constant
3882                    expression the address will be folded away, so look
3883                    through it now.  */
3884                 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
3885                     && !DECL_CONSTRUCTOR_P (fun))
3886                   {
3887                     tree x = get_nth_callarg (t, 0);
3888                     if (is_this_parameter (x))
3889                       return true;
3890                     else if (!RECUR (x, rval))
3891                       return false;
3892                     i = 1;
3893                   }
3894               }
3895             else
3896               {
3897                 if (!RECUR (fun, true))
3898                   return false;
3899                 fun = get_first_fn (fun);
3900               }
3901             /* Skip initial arguments to base constructors.  */
3902             if (DECL_BASE_CONSTRUCTOR_P (fun))
3903               i = num_artificial_parms_for (fun);
3904             fun = DECL_ORIGIN (fun);
3905           }
3906         else
3907           {
3908             if (RECUR (fun, rval))
3909               /* Might end up being a constant function pointer.  */;
3910             else
3911               return false;
3912           }
3913         for (; i < nargs; ++i)
3914           {
3915             tree x = get_nth_callarg (t, i);
3916             /* In a template, reference arguments haven't been converted to
3917                REFERENCE_TYPE and we might not even know if the parameter
3918                is a reference, so accept lvalue constants too.  */
3919             bool rv = processing_template_decl ? any : rval;
3920             if (!RECUR (x, rv))
3921               return false;
3922           }
3923         return true;
3924       }
3925
3926     case NON_LVALUE_EXPR:
3927       /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
3928             -- an lvalue of integral type that refers to a non-volatile
3929                const variable or static data member initialized with
3930                constant expressions, or
3931
3932             -- an lvalue of literal type that refers to non-volatile
3933                object defined with constexpr, or that refers to a
3934                sub-object of such an object;  */
3935       return RECUR (TREE_OPERAND (t, 0), rval);
3936
3937     case VAR_DECL:
3938       if (want_rval
3939           && !decl_constant_var_p (t)
3940           && (strict
3941               || !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (t))
3942               || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t))
3943           && !var_in_constexpr_fn (t)
3944           && !type_dependent_expression_p (t))
3945         {
3946           if (flags & tf_error)
3947             non_const_var_error (t);
3948           return false;
3949         }
3950       return true;
3951
3952     case NOP_EXPR:
3953     case CONVERT_EXPR:
3954     case VIEW_CONVERT_EXPR:
3955       /* -- a reinterpret_cast.  FIXME not implemented, and this rule
3956          may change to something more specific to type-punning (DR 1312).  */
3957       {
3958         tree from = TREE_OPERAND (t, 0);
3959         if (POINTER_TYPE_P (TREE_TYPE (t))
3960             && TREE_CODE (from) == INTEGER_CST
3961             && !integer_zerop (from))
3962           {
3963             if (flags & tf_error)
3964               error_at (EXPR_LOC_OR_LOC (t, input_location),
3965                         "reinterpret_cast from integer to pointer");
3966             return false;
3967           }
3968         return (RECUR (from, TREE_CODE (t) != VIEW_CONVERT_EXPR));
3969       }
3970
3971     case ADDR_EXPR:
3972       /* -- a unary operator & that is applied to an lvalue that
3973             designates an object with thread or automatic storage
3974             duration;