re PR c++/53202 (Copy constructor not called when starting a thread)

PR c++/53202
	* semantics.c (build_data_member_initialization): Always keep
	initializer for empty base.
	(cxx_eval_bare_aggregate): Discard it here.

From-SVN: r188941

gcc/cp/ChangeLog

@@ -1,3 +1,10 @@
+2012-06-25  Jason Merrill  <jason@redhat.com>
+
+	PR c++/53202
+	* semantics.c (build_data_member_initialization): Always keep
+	initializer for empty base.
+	(cxx_eval_bare_aggregate): Discard it here.
+
 2012-06-25  Jakub Jelinek  <jakub@redhat.com>
 
 	PR c++/53594

gcc/cp/semantics.c

@@ -5817,12 +5817,9 @@ build_data_member_initialization (tree t, VEC(constructor_elt,gc) **vec)
 	member = op;
       else
 	{
-	  /* We don't put out anything for an empty base.  */
+	  /* This is an initializer for an empty base; keep it for now so
+	     we can check it in cxx_eval_bare_aggregate.  */
 	  gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member))));
-	  /* But if the initializer isn't constexpr, leave it in so we
-	     complain later.  */
-	  if (potential_constant_expression (init))
-	    return true;
 	}
     }
   if (TREE_CODE (member) == ADDR_EXPR)
@@ -7037,6 +7034,12 @@ cxx_eval_bare_aggregate (const constexpr_call *call, tree t,
 	  constructor_elt *inner = base_field_constructor_elt (n, ce->index);
 	  inner->value = elt;
 	}
+      else if (TREE_CODE (ce->index) == NOP_EXPR)
+	{
+	  /* This is an initializer for an empty base; now that we've
+	     checked that it's constant, we can ignore it.  */
+	  gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (ce->index))));
+	}
       else
 	CONSTRUCTOR_APPEND_ELT (n, ce->index, elt);
     }

gcc/testsuite/ChangeLog

@@ -1,3 +1,8 @@
+2012-06-25  Jason Merrill  <jason@redhat.com>
+
+	PR c++/53202
+	* g++.dg/cpp0x/constexpr-tuple.C: New.
+
 2012-06-25  Jakub Jelinek  <jakub@redhat.com>
 
 	PR target/53759

gcc/testsuite/g++.dg/cpp0x/constexpr-tuple.C

@@ -0,0 +1,106 @@
+// PR c++/53202
+// { dg-do run { target c++11 } }
+
+#include <tuple>
+
+template<typename Callable>
+  struct Bind_simple
+  {
+    explicit
+    Bind_simple(const Callable& callable)
+    : _M_bound(callable)
+    { }
+
+    Bind_simple(const Bind_simple&) = default;
+    Bind_simple(Bind_simple&&) = default;
+
+    auto operator()() -> decltype((*(Callable*)0)())
+    {
+      return std::get<0>(_M_bound)();
+    }
+
+  private:
+
+    std::tuple<Callable> _M_bound;
+  };
+
+template<typename Callable>
+  Bind_simple<Callable>
+  bind_simple(Callable& callable)
+  {
+    return Bind_simple<Callable>(callable);
+  }
+
+struct thread
+{
+  struct ImplBase { };
+
+  template<typename T>
+    struct Impl : ImplBase {
+      T t;
+      Impl(T&& t) : t(std::move(t)) { }
+    };
+
+  template<typename T>
+    thread(T& t)
+    {
+      auto p = make_routine(bind_simple(t));
+
+      p->t();
+
+      delete p;
+    }
+
+  template<typename Callable>
+    Impl<Callable>*
+    make_routine(Callable&& f)
+    {
+      return new Impl<Callable>(std::forward<Callable>(f));
+    }
+};
+
+
+int c;
+class background_hello
+{
+public:
+    background_hello()
+    {
+      __builtin_printf("default ctor called, this=%p\n", this);
+      ++c;
+    }
+
+    background_hello(const background_hello &)
+    {
+      __builtin_printf("copy ctor called\n");
+      ++c;
+    }
+
+    background_hello(background_hello &&)
+    {
+      __builtin_printf("move ctor called\n");
+      ++c;
+    }
+
+    void operator ()() const
+    {
+      __builtin_printf("void background_hello::operator()() called, this=%p\n", this);
+    }
+
+    ~background_hello()
+    {
+      __builtin_printf("destructor called, this=%p\n", this);
+      --c;
+    }
+
+};
+
+int main()
+{
+  {
+    background_hello bh;
+    thread t(bh);
+  }
+  if (c != 0)
+    __builtin_abort ();
+}