The problem in this PR is that we get
error: constexpr call flows off the end of the function
for a valid testcase, but not in C++17 mode. That's because in C++17 we
execute:
4321 if (cxx_dialect >= cxx17 && !BINFO_VIRTUAL_P (binfo))
4322 {
4323 tree decl = build_base_field_1 (t, basetype, next_field);
4324 DECL_FIELD_OFFSET (decl) = BINFO_OFFSET (binfo);
4325 DECL_FIELD_BIT_OFFSET (decl) = bitsize_zero_node;
4326 SET_DECL_OFFSET_ALIGN (decl, BITS_PER_UNIT);
4327 }
which puts some additional fields into some classes. This makes a difference
for split_nonconstant_init:
751 if (split_nonconstant_init_1 (dest, init))
752 init = NULL_TREE;
where split_nonconstant_init_1 is true so that means that the DECL_INITIAL will
be null. Why is split_nonconstant_init_1 true? Because it ends up calling
complete_ctor_at_level_p with
6114 return count_type_elements (type, true) == num_elts;
but the count_type_elements result differs between c++14/c++17 precisely
because of the fields added in build_base_field. But we should only add those
fields when initializing aggregates with bases, which is not what's happening
in this testcase.
With DECL_INITIAL being null, we error here (result is NULL):
1702 result = *ctx->values->get (slot ? slot : res);
1703 if (result == NULL_TREE && !*non_constant_p)
1704 {
1705 if (!ctx->quiet)
1706 error ("%<constexpr%> call flows off the end "
1707 "of the function");
1708 *non_constant_p = true;
1709 }
I think the problem is that we're dealing with an empty class here, for which
we should just generate an empty ctor, as in few other spots.
Bootstrapped/regtested on x86_64-linux, ok for trunk?
2018-01-18 Marek Polacek <pola...@redhat.com>
PR c++/81933
* constexpr.c (cxx_eval_call_expression): When evaluating a call whose
result's type is an empty class, return empty constructor.
* g++.dg/cpp1y/constexpr-empty4.C: New test.
diff --git gcc/cp/constexpr.c gcc/cp/constexpr.c
index 8984613aa41..0ff74b98437 100644
--- gcc/cp/constexpr.c
+++ gcc/cp/constexpr.c
@@ -1701,7 +1701,15 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree
t,
result = void_node;
else
{
- result = *ctx->values->get (slot ? slot : res);
+ tree retval = slot ? slot : res;
+ /* If the class is empty, we aren't actually loading anything. */
+ if (is_really_empty_class (TREE_TYPE (retval)))
+ {
+ result = build_constructor (TREE_TYPE (retval), NULL);
+ TREE_CONSTANT (result) = true;
+ }
+ else
+ result = *ctx->values->get (retval);
if (result == NULL_TREE && !*non_constant_p)
{
if (!ctx->quiet)
diff --git gcc/testsuite/g++.dg/cpp1y/constexpr-empty4.C
gcc/testsuite/g++.dg/cpp1y/constexpr-empty4.C
index e69de29bb2d..059220f8268 100644
--- gcc/testsuite/g++.dg/cpp1y/constexpr-empty4.C
+++ gcc/testsuite/g++.dg/cpp1y/constexpr-empty4.C
@@ -0,0 +1,51 @@
+// PR c++/81933
+// { dg-do compile { target c++14 } }
+
+namespace std {
+template <typename _Tp> struct __decay_and_strip { typedef _Tp __type; };
+template <int> struct enable_if { typedef int type; };
+template <typename _Head> struct _Head_base {
+ constexpr _Head_base(_Head) {}
+};
+template <unsigned long, typename...> struct _Tuple_impl;
+template <unsigned long _Idx, typename _Head, typename... _Tail>
+struct _Tuple_impl<_Idx, _Head, _Tail...> : _Tuple_impl<1, _Tail...>, // {
dg-warning "direct base" }
+ _Head_base<_Head> {
+ typedef _Tuple_impl<1, _Tail...> _Inherited;
+ typedef _Head_base<_Head> _Base;
+ constexpr _Tuple_impl(_Head __head, _Tail... __tail)
+ : _Inherited(__tail...), _Base(__head) {}
+ _Tuple_impl(const _Tuple_impl &) = default;
+ _Tuple_impl(_Tuple_impl &&);
+};
+template <unsigned long _Idx, typename _Head>
+struct _Tuple_impl<_Idx, _Head> : _Head_base<_Head> {
+ typedef _Head_base<_Head> _Base;
+ constexpr _Tuple_impl(_Head __head) : _Base(__head) {}
+};
+template <int> struct _TC {
+ static constexpr bool _NotSameTuple() { return true; }
+};
+template <typename... _Elements> class tuple : _Tuple_impl<0, _Elements...> {
+ typedef _Tuple_impl<0, _Elements...> _Inherited;
+
+public:
+ template <typename... _UElements,
+ enable_if<_TC<1>::_NotSameTuple()>::type = false>
+ constexpr tuple(_UElements... __elements) : _Inherited(__elements...) {}
+ tuple(const tuple &) = default;
+};
+template <typename... _Elements>
+constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
+ make_tuple(_Elements... __args) {
+ typedef tuple<typename __decay_and_strip<_Elements>::__type...>
__result_type;
+ return __result_type(__args...);
+}
+}
+struct any_udt {};
+template <typename... Tuples> constexpr auto flatten(Tuples... tuples) {
+ auto all = std::make_tuple(tuples...);
+ auto flat(all);
+ return flat;
+}
+constexpr auto fail = flatten(any_udt{}, any_udt{});
Marek
