[libcxx] Move member function definition before it's explicit template instantiation declaration in <valarray> to satisfy GCC.

[EricWF]

Summary

GCC fail's to compile a number of <valarray> tests because three valarray member functions cannot be inlined at various points throughout the header. This is an error because these functions are marked always_inline. Moving the definition of these member functions to directly before the extern template declaration solves the problem.

An example failure can be found here: http://ds2.efcs.ca:8080/builders/gcc-builder/builds/36/steps/test.libcxx-cxx11/logs/FAIL%3A%20libc%2B%2B%3A%3Amultiply.pass.cpp

@rsmith Would you be able to weigh in here. I'm concerned that we might be in "ill formed: no diagnostic required" territory. Do you think GCC's behavior is reasonable?

[EricWF]

Another fix was committed as r255599. It simply puts the inline keyword on the declaration of the methods so that they are allowed to be inlined.

14.7.2 [temp.explicit]p10

Except for inline functions, declarations with types deduced from their initializer or return value (7.1.6.4),
const variables of literal types, variables of reference types, and class template specializations, explicit
instantiation declarations have the effect of suppressing the implicit instantiation of the entity to which they
refer. [ Note: The intent is that an inline function that is the subject of an explicit instantiation declaration
will still be implicitly instantiated when odr-used (3.2) so that the body can be considered for inlining, but
that no out-of-line copy of the inline function would be generated in the translation unit. — end note ]

include/valarray

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     valarray(initializer_list<value_type> __il);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     valarray(const slice_array<value_type>& __sa);
     valarray(const gslice_array<value_type>& __ga);
     valarray(const mask_array<value_type>& __ma);
     valarray(const indirect_array<value_type>& __ia);
+
     _LIBCPP_INLINE_VISIBILITY
     ~valarray();
 
     // assignment:
     valarray& operator=(const valarray& __v);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     valarray& operator=(valarray&& __v) _NOEXCEPT;
private:
     end(valarray<_Up>& __v);
 
     template <class _Up>
     friend
     const _Up*
     end(const valarray<_Up>& __v);
 };
 
+template <class _Tp>
+void
+valarray<_Tp>::resize(size_t __n, value_type __x)
+{
+    if (__begin_ != nullptr)
+    {
+        while (__end_ != __begin_)
+            (--__end_)->~value_type();
+        _VSTD::__deallocate(__begin_);
+        __begin_ = __end_ = nullptr;
+    }
+    if (__n)
+    {
+        __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type)));
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        try
+        {
+#endif  // _LIBCPP_NO_EXCEPTIONS
+            for (; __n; --__n, ++__end_)
+                ::new (__end_) value_type(__x);
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        }
+        catch (...)
+        {
+            resize(0);
+            throw;
+        }
+#endif  // _LIBCPP_NO_EXCEPTIONS
+    }
+}
+
+
+template <class _Tp>
+inline
+valarray<_Tp>::valarray(size_t __n)
+    : __begin_(0),
+      __end_(0)
+{
+    resize(__n);
+}
+
+template <class _Tp>
+inline
+valarray<_Tp>::~valarray()
+{
+    resize(0);
+}
+
+// The definition for these three functions must appear before they are used and
+// before these extern template declarations.
+// Otherwise GCC will fail to inline the definition which is an error because
+// the functions are declared always inline.
 _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::valarray(size_t))
 _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::~valarray())
 _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void valarray<size_t>::resize(size_t, size_t))
 
+
 template <class _Op, class _Tp>
 struct _UnaryOp<_Op, valarray<_Tp> >
 {
     typedef typename _Op::result_type result_type;
     typedef _Tp value_type;
 
     _Op __op_;
     const valarray<_Tp>& __a0_;
if (__n)
         for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i)
             ::new (__r.__end_) result_type(__expr_[__i]);
     }
     return __r;
 }
 
 // valarray
 
-template <class _Tp>
-inline
-valarray<_Tp>::valarray(size_t __n)
-    : __begin_(0),
-      __end_(0)
-{
-    resize(__n);
-}
 
 template <class _Tp>
 inline
 valarray<_Tp>::valarray(const value_type& __x, size_t __n)
     : __begin_(0),
       __end_(0)
 {
     resize(__n, __x);
#ifndef _LIBCPP_NO_EXCEPTIONS
         {
             resize(0);
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
-template <class _Tp>
-inline
-valarray<_Tp>::~valarray()
-{
-    resize(0);
-}
 
 template <class _Tp>
 valarray<_Tp>&
 valarray<_Tp>::operator=(const valarray& __v)
 {
     if (this != &__v)
     {
         if (size() != __v.size())
if (__n)
             __r.__end_ =
                 static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type)));
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) value_type(__f(*__p));
     }
     return __r;
 }
 
-template <class _Tp>
-void
-valarray<_Tp>::resize(size_t __n, value_type __x)
-{
-    if (__begin_ != nullptr)
-    {
-        while (__end_ != __begin_)
-            (--__end_)->~value_type();
-        _VSTD::__deallocate(__begin_);
-        __begin_ = __end_ = nullptr;
-    }
-    if (__n)
-    {
-        __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type)));
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        try
-        {
-#endif  // _LIBCPP_NO_EXCEPTIONS
-            for (; __n; --__n, ++__end_)
-                ::new (__end_) value_type(__x);
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            resize(0);
-            throw;
-        }
-#endif  // _LIBCPP_NO_EXCEPTIONS
-    }
-}
-
-template<class _Tp>
+template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
 
 template<class _Expr1, class _Expr2>