Fix ABI compatibility of `<stdexcept>` with VCRuntime.

[EricWF]

Summary

Currently, libc++'s <stdexcept> doesn't play nice with vcruntime. Specifically:

• logic_error and runtime_error have a different layout.
• libc++'s logic_error and runtime_error override what() but vcruntime does not.
• vcruntime uses weak vtables for <stdexcept> types.
• libc++'s <stdexcept> constructors and assignment operators may have different manglings than vcruntimes.

This patch makes libc++'s declarations in <stdexcept> match those provided by MSVC's STL as closely as possible.
If MSVC doesn't declare a special member, then neither do we. This ensures that the implicit definitions have the same linkage, visibility, triviality, and noexcept-ness.

[thomasanderson]

LGTM, thanks!

[ldionne]

Do we have a tester that uses vcruntime?

include/stdexcept

96

Ah, so libc++ is using std::string, and vcruntime is using std::__1::string? But libc++ only defines basic_string in namespace __1, so aren't both actually referring to std::__1::string? I'm a bit confused.

src/support/runtime/stdexcept_default.ipp

38

Indentation.

[thomasanderson]

src/support/runtime/stdexcept_default.ipp

50

copy-paste error: s/le/re

[EricWF]

include/stdexcept

96

The comment calls out the weirdness that std::logic_error isn't versioned, but std::__1::string is. So we don't actually provide the same as vcruntimes logic_error. But that shouldn't be a problem, and means we can put the constructor out-of-line.

[EricWF]

• Clang format new files.
• Fix preexisting copy/paste mistake.

include/stdexcept

 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#ifndef _LIBCPP_ABI_VCRUNTIME
 class _LIBCPP_HIDDEN __libcpp_refstring
 {
     const char* __imp_;
 
     bool __uses_refcount() const;
 public:
     explicit __libcpp_refstring(const char* __msg);
     __libcpp_refstring(const __libcpp_refstring& __s) _NOEXCEPT;
     __libcpp_refstring& operator=(const __libcpp_refstring& __s) _NOEXCEPT;
     ~__libcpp_refstring();
 
     const char* c_str() const _NOEXCEPT {return __imp_;}
 };
+#endif // !_LIBCPP_ABI_VCRUNTIME
 
 _LIBCPP_END_NAMESPACE_STD
 
 namespace std  // purposefully not using versioning namespace
 {
 
 class _LIBCPP_EXCEPTION_ABI logic_error
     : public exception
 {
+#ifndef _LIBCPP_ABI_VCRUNTIME
 private:
     _VSTD::__libcpp_refstring __imp_;
 public:
     explicit logic_error(const string&);
     explicit logic_error(const char*);
 
     logic_error(const logic_error&) _NOEXCEPT;
     logic_error& operator=(const logic_error&) _NOEXCEPT;
 
     virtual ~logic_error() _NOEXCEPT;
 
     virtual const char* what() const _NOEXCEPT;
+#else
+public:
+    explicit logic_error(const _VSTD::string&); // Symbol uses versioned std::string
+    _LIBCPP_INLINE_VISIBILITY explicit logic_error(const char* __s) : exception(__s) {}
+#endif
 };
 
 class _LIBCPP_EXCEPTION_ABI runtime_error
     : public exception
 {
+#ifndef _LIBCPP_ABI_VCRUNTIME
 private:
     _VSTD::__libcpp_refstring __imp_;
 public:
     explicit runtime_error(const string&);
     explicit runtime_error(const char*);
 
     runtime_error(const runtime_error&) _NOEXCEPT;
     runtime_error& operator=(const runtime_error&) _NOEXCEPT;
 
     virtual ~runtime_error() _NOEXCEPT;
 
     virtual const char* what() const _NOEXCEPT;
+#else
+public:
+   explicit runtime_error(const _VSTD::string&); // Symbol uses versioned std::string
+   _LIBCPP_INLINE_VISIBILITY explicit runtime_error(const char* __s) : exception(__s) {}
+#endif // _LIBCPP_ABI_VCRUNTIME
 };
 
 class _LIBCPP_EXCEPTION_ABI domain_error
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit domain_error(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit domain_error(const char* __s)   : logic_error(__s) {}
 
+#ifndef _LIBCPP_ABI_VCRUNTIME
     virtual ~domain_error() _NOEXCEPT;
+#endif
 };
 
 class _LIBCPP_EXCEPTION_ABI invalid_argument
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const char* __s)   : logic_error(__s) {}
 
+#ifndef _LIBCPP_ABI_VCRUNTIME
     virtual ~invalid_argument() _NOEXCEPT;
+#endif
 };
 
 class _LIBCPP_EXCEPTION_ABI length_error
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit length_error(const char* __s)   : logic_error(__s) {}
-
+#ifndef _LIBCPP_ABI_VCRUNTIME
     virtual ~length_error() _NOEXCEPT;
+#endif
 };
 
 class _LIBCPP_EXCEPTION_ABI out_of_range
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const char* __s)   : logic_error(__s) {}
 
+#ifndef _LIBCPP_ABI_VCRUNTIME
     virtual ~out_of_range() _NOEXCEPT;
+#endif
 };
 
 class _LIBCPP_EXCEPTION_ABI range_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit range_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit range_error(const char* __s)   : runtime_error(__s) {}
 
+#ifndef _LIBCPP_ABI_VCRUNTIME
     virtual ~range_error() _NOEXCEPT;
+#endif
 };
 
 class _LIBCPP_EXCEPTION_ABI overflow_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const char* __s)   : runtime_error(__s) {}
 
+#ifndef _LIBCPP_ABI_VCRUNTIME
     virtual ~overflow_error() _NOEXCEPT;
+#endif
 };
 
 class _LIBCPP_EXCEPTION_ABI underflow_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s)   : runtime_error(__s) {}
 
+#ifndef _LIBCPP_ABI_VCRUNTIME
     virtual ~underflow_error() _NOEXCEPT;
+#endif
 };
 
 }  // std
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // in the dylib
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);

src/stdexcept.cpp

 //===------------------------ stdexcept.cpp -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "stdexcept"
 #include "new"
 #include "string"
 #include "system_error"
-#include "include/refstring.h"
 
-/* For _LIBCPPABI_VERSION */
-#if !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) && \
-    (defined(LIBCXX_BUILDING_LIBCXXABI) || defined(__APPLE__) || defined(LIBCXXRT))
-#include <cxxabi.h>
-#endif
-
-static_assert(sizeof(std::__libcpp_refstring) == sizeof(const char *), "");
-
-
-namespace std  // purposefully not using versioning namespace
-{
-
-logic_error::logic_error(const string& msg) : __imp_(msg.c_str())
-{
-}
-
-logic_error::logic_error(const char* msg) : __imp_(msg)
-{
-}
-
-logic_error::logic_error(const logic_error& le) _NOEXCEPT : __imp_(le.__imp_)
-{
-}
-
-logic_error&
-logic_error::operator=(const logic_error& le) _NOEXCEPT
-{
-    __imp_ = le.__imp_;
-    return *this;
-}
-
-runtime_error::runtime_error(const string& msg) : __imp_(msg.c_str())
-{
-}
-
-runtime_error::runtime_error(const char* msg) : __imp_(msg)
-{
-}
-
-runtime_error::runtime_error(const runtime_error& le) _NOEXCEPT
-  : __imp_(le.__imp_)
-{
-}
-
-runtime_error&
-runtime_error::operator=(const runtime_error& le) _NOEXCEPT
-{
-    __imp_ = le.__imp_;
-    return *this;
-}
-
-#if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
-
-const char*
-logic_error::what() const _NOEXCEPT
-{
-    return __imp_.c_str();
-}
-
-const char*
-runtime_error::what() const _NOEXCEPT
-{
-    return __imp_.c_str();
-}
-
-#if !defined(_LIBCPP_ABI_VCRUNTIME)
-
-logic_error::~logic_error() _NOEXCEPT {}
-domain_error::~domain_error() _NOEXCEPT {}
-invalid_argument::~invalid_argument() _NOEXCEPT {}
-length_error::~length_error() _NOEXCEPT {}
-out_of_range::~out_of_range() _NOEXCEPT {}
-
-runtime_error::~runtime_error() _NOEXCEPT {}
-range_error::~range_error() _NOEXCEPT {}
-overflow_error::~overflow_error() _NOEXCEPT {}
-underflow_error::~underflow_error() _NOEXCEPT {}
 
+#ifdef _LIBCPP_ABI_VCRUNTIME
+#include "support/runtime/stdexcept_vcruntime.ipp"
+#else
+#include "support/runtime/stdexcept_default.ipp"
 #endif
-#endif
-
-}  // std

src/support/runtime/stdexcept_default.ipp

+//===--------------------- stdexcept_default.ipp --------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "../../include/refstring.h"
+
+/* For _LIBCPPABI_VERSION */
+#if !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) &&                           \
+    (defined(LIBCXX_BUILDING_LIBCXXABI) || defined(__APPLE__) ||               \
+     defined(LIBCXXRT))
+#include <cxxabi.h>
+#endif
+
+static_assert(sizeof(std::__libcpp_refstring) == sizeof(const char*), "");
+
+namespace std // purposefully not using versioning namespace
+{
+
+logic_error::logic_error(const string& msg) : __imp_(msg.c_str()) {}
+
+logic_error::logic_error(const char* msg) : __imp_(msg) {}
+
+logic_error::logic_error(const logic_error& le) _NOEXCEPT : __imp_(le.__imp_) {}
+
+logic_error& logic_error::operator=(const logic_error& le) _NOEXCEPT {
+  __imp_ = le.__imp_;
+  return *this;
+}
+
+runtime_error::runtime_error(const string& msg) : __imp_(msg.c_str()) {}
+
+runtime_error::runtime_error(const char* msg) : __imp_(msg) {}
+
+runtime_error::runtime_error(const runtime_error& re) _NOEXCEPT
+    : __imp_(re.__imp_) {}
+
+runtime_error& runtime_error::operator=(const runtime_error& re) _NOEXCEPT {
+  __imp_ = re.__imp_;
+  return *this;
+}
+
+#if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
+
+const char* logic_error::what() const _NOEXCEPT { return __imp_.c_str(); }
+
+const char* runtime_error::what() const _NOEXCEPT { return __imp_.c_str(); }
+
+logic_error::~logic_error() _NOEXCEPT {}
+domain_error::~domain_error() _NOEXCEPT {}
+invalid_argument::~invalid_argument() _NOEXCEPT {}
+length_error::~length_error() _NOEXCEPT {}
+out_of_range::~out_of_range() _NOEXCEPT {}
+
+runtime_error::~runtime_error() _NOEXCEPT {}
+range_error::~range_error() _NOEXCEPT {}
+overflow_error::~overflow_error() _NOEXCEPT {}
+underflow_error::~underflow_error() _NOEXCEPT {}
+
+#endif
+
+} // namespace std

src/support/runtime/stdexcept_vcruntime.ipp

+//===------------------- stdexcept_vcruntime.ipp --------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_ABI_VCRUNTIME
+#error This file may only be used when defering to vcruntime
+#endif
+
+namespace std {
+logic_error::logic_error(std::string const& s) : exception(s.c_str()) {}
+runtime_error::runtime_error(std::string const& s) : exception(s.c_str()) {}
+} // namespace std