[libcxx] Don't define exception types with -fno-exceptions

[phosek]

Summary

When exceptions are disabled, that is when _HAS_EXCEPTIONS=0, the
vcruntime_exception.h header doesn't define the ABI base class
std::exception which breaks the libc++ build.

This change ifdefs out all subclass of exception/error to avoid
this issue. This can be also beneficial on other platforms that
disable exceptions because we don't need to distribute code that's
never going to be used.

For example, on Fuchsia, we ship both variants of libc++ (with and
without exceptions) and select the correct one using the multilib
mechanism. Since the first party code doesn't use exceptions, this
can reduce binary size and this change can help further in addition
to making libc++ usable on Windows with _HAC_EXCEPTIONS=0.

[phosek]

This is an alternative to D103947.

[ldionne]

I would like to avoid providing a different API for when exceptions are enabled vs disabled.

Do you guys know what the rationale is for the VC runtime not to provide std::exception? I think we should try to align with them. My ideal resolution would simply be that the VC runtime provides the std::exception class even when -fno-exceptions is used, since that's what all other platforms do.

[phosek]

In D106848#2907399, @ldionne wrote:

I would like to avoid providing a different API for when exceptions are enabled vs disabled.

Do you guys know what the rationale is for the VC runtime not to provide std::exception? I think we should try to align with them. My ideal resolution would simply be that the VC runtime provides the std::exception class even when -fno-exceptions is used, since that's what all other platforms do.

Would D103947 be a more acceptable solution? I don't know why VC runtime doesn't provide std::exception but even if we can convince Microsoft to change their approach, it's going to take years for that change to roll out so that strategy is not feasible for us since we would like to start using libc++ on Windows now.

[ldionne]

In D106848#2907997, @phosek wrote:

In D106848#2907399, @ldionne wrote:

I would like to avoid providing a different API for when exceptions are enabled vs disabled.

Do you guys know what the rationale is for the VC runtime not to provide std::exception? I think we should try to align with them. My ideal resolution would simply be that the VC runtime provides the std::exception class even when -fno-exceptions is used, since that's what all other platforms do.

Would D103947 be a more acceptable solution? I don't know why VC runtime doesn't provide std::exception but even if we can convince Microsoft to change their approach, it's going to take years for that change to roll out so that strategy is not feasible for us since we would like to start using libc++ on Windows now.

Yeah, my initial reaction is that D103947 is more in line with what we do in libc++ on other platforms, so we should go with that (after addressing some issues with that patch). But let's keep discussing on D103947 -- I have little context on Windows so I might be asking for silly things without knowing.

libcxx/CMakeLists.txt

 
 # Exception flags =============================================================
 function(cxx_add_exception_flags target)
   if (LIBCXX_ENABLE_EXCEPTIONS)
     # Catches C++ exceptions only and tells the compiler to assume that extern C
     # functions never throw a C++ exception.
     target_add_compile_flags_if_supported(${target} PUBLIC -EHsc)
   else()
+    if (LIBCXX_TARGETING_MSVC)
+      target_compile_definitions(${target} PUBLIC -D_HAS_EXCEPTIONS=0)
+    endif()
     target_add_compile_flags_if_supported(${target} PUBLIC -EHs- -EHa-)
     target_add_compile_flags_if_supported(${target} PUBLIC -fno-exceptions)
   endif()
 endfunction()
 
 # RTTI flags ==================================================================
 function(cxx_add_rtti_flags target)
   if (NOT LIBCXX_ENABLE_RTTI)

libcxx/include/__format/format_error.h

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
 class _LIBCPP_EXCEPTION_ABI format_error : public runtime_error {
 public:
   _LIBCPP_HIDE_FROM_ABI explicit format_error(const string& __s)
       : runtime_error(__s) {}
   _LIBCPP_HIDE_FROM_ABI explicit format_error(const char* __s)
       : runtime_error(__s) {}
   virtual ~format_error() noexcept;
 };
+#endif
 
 _LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void
 __throw_format_error(const char* __s) {
 #ifndef _LIBCPP_NO_EXCEPTIONS
   throw format_error(__s);
 #else
   (void)__s;
   _VSTD::abort();

libcxx/include/filesystem

inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const path::iterator& __lhs,
                                                  const path::iterator& __rhs) {
   return !(__lhs == __rhs);
 }
 
 // TODO(ldionne): We need to pop the pragma and push it again after
 //                filesystem_error to work around PR41078.
 _LIBCPP_AVAILABILITY_FILESYSTEM_POP
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
 class _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error {
 public:
   _LIBCPP_INLINE_VISIBILITY
   filesystem_error(const string& __what, error_code __ec)
       : system_error(__ec, __what),
         __storage_(make_shared<_Storage>(path(), path())) {
     __create_what(0);
   }
struct _LIBCPP_HIDDEN _Storage {
     _Storage(const path& __p1, const path& __p2) : __p1_(__p1), __p2_(__p2) {}
 
     path __p1_;
     path __p2_;
     string __what_;
   };
   shared_ptr<_Storage> __storage_;
 };
+#endif
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 template <class... _Args>
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_NO_EXCEPTIONS
 void __throw_filesystem_error(_Args&&... __args) {
   throw filesystem_error(_VSTD::forward<_Args>(__args)...);

libcxx/include/future

 
 inline _LIBCPP_INLINE_VISIBILITY
 error_condition
 make_error_condition(future_errc __e) _NOEXCEPT
 {
     return error_condition(static_cast<int>(__e), future_category());
 }
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_FUTURE_ERROR future_error
     : public logic_error
 {
     error_code __ec_;
 public:
     future_error(error_code __ec);
 
     _LIBCPP_INLINE_VISIBILITY
     const error_code& code() const _NOEXCEPT {return __ec_;}
 
     future_error(const future_error&) _NOEXCEPT = default;
     virtual ~future_error() _NOEXCEPT;
 };
+#endif
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_NO_EXCEPTIONS
 _LIBCPP_AVAILABILITY_FUTURE_ERROR
 #endif
 void __throw_future_error(future_errc _Ev)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
promise<_Rp>::promise(allocator_arg_t, const _Alloc& __a0)
     __state_ = _VSTD::addressof(*__hold.release());
 }
 
 template <class _Rp>
 promise<_Rp>::~promise()
 {
     if (__state_)
     {
+#ifndef _LIBCPP_NO_EXCEPTIONS
         if (!__state_->__has_value() && __state_->use_count() > 1)
             __state_->set_exception(make_exception_ptr(
                       future_error(make_error_code(future_errc::broken_promise))
                                                       ));
+#endif // _LIBCPP_NO_EXCEPTIONS
         __state_->__release_shared();
     }
 }
 
 template <class _Rp>
 future<_Rp>
 promise<_Rp>::get_future()
 {
promise<_Rp&>::promise(allocator_arg_t, const _Alloc& __a0)
     __state_ = _VSTD::addressof(*__hold.release());
 }
 
 template <class _Rp>
 promise<_Rp&>::~promise()
 {
     if (__state_)
     {
+#ifndef _LIBCPP_NO_EXCEPTIONS
         if (!__state_->__has_value() && __state_->use_count() > 1)
             __state_->set_exception(make_exception_ptr(
                       future_error(make_error_code(future_errc::broken_promise))
                                                       ));
+#endif // _LIBCPP_NO_EXCEPTIONS
         __state_->__release_shared();
     }
 }
 
 template <class _Rp>
 future<_Rp&>
 promise<_Rp&>::get_future()
 {

libcxx/include/ios

 
 inline _LIBCPP_INLINE_VISIBILITY
 error_condition
 make_error_condition(io_errc __e) _NOEXCEPT
 {
     return error_condition(static_cast<int>(__e), iostream_category());
 }
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
 class _LIBCPP_EXCEPTION_ABI ios_base::failure
     : public system_error
 {
 public:
     explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);
     explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);
     failure(const failure&) _NOEXCEPT = default;
     virtual ~failure() _NOEXCEPT;
 };
+#endif
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_failure(char const* __msg) {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw ios_base::failure(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();

libcxx/include/regex

enum error_type
     __re_err_grammar,
     __re_err_empty,
     __re_err_unknown,
     __re_err_parse
 };
 
 }  // regex_constants
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
 class _LIBCPP_EXCEPTION_ABI regex_error
     : public runtime_error
 {
     regex_constants::error_type __code_;
 public:
     explicit regex_error(regex_constants::error_type __ecode);
     regex_error(const regex_error&) _NOEXCEPT = default;
     virtual ~regex_error() _NOEXCEPT;
      _LIBCPP_INLINE_VISIBILITY
     regex_constants::error_type code() const {return __code_;}
 };
+#endif
 
 template <regex_constants::error_type _Ev>
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_regex_error()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw regex_error(_Ev);
 #else

libcxx/include/stdexcept

 };
 #endif // !_LIBCPP_ABI_VCRUNTIME
 
 _LIBCPP_END_NAMESPACE_STD
 
 namespace std  // purposefully not using versioning namespace
 {
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
 class _LIBCPP_EXCEPTION_ABI logic_error
     : public exception
 {
 #ifndef _LIBCPP_ABI_VCRUNTIME
 private:
     _VSTD::__libcpp_refstring __imp_;
 public:
     explicit logic_error(const string&);
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
     underflow_error(const underflow_error&) _NOEXCEPT = default;
     virtual ~underflow_error() _NOEXCEPT;
 #endif
 };
+#endif // _LIBCPP_NO_EXCEPTIONS
 
 }  // std
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // in the dylib
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);
 

libcxx/include/system_error

struct _LIBCPP_TEMPLATE_VIS hash<error_condition>
     size_t operator()(const error_condition& __ec) const _NOEXCEPT
     {
         return static_cast<size_t>(__ec.value());
     }
 };
 
 // system_error
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
 class _LIBCPP_TYPE_VIS system_error
     : public runtime_error
 {
     error_code __ec_;
 public:
     system_error(error_code __ec, const string& __what_arg);
     system_error(error_code __ec, const char* __what_arg);
     system_error(error_code __ec);
     system_error(int __ev, const error_category& __ecat, const string& __what_arg);
     system_error(int __ev, const error_category& __ecat, const char* __what_arg);
     system_error(int __ev, const error_category& __ecat);
     system_error(const system_error&) _NOEXCEPT = default;
     ~system_error() _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     const error_code& code() const _NOEXCEPT {return __ec_;}
 
 private:
     static string __init(const error_code&, string);
 };
+#endif
 
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS
 void __throw_system_error(int ev, const char* what_arg);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_SYSTEM_ERROR

libcxx/src/filesystem/operations.cpp

 #else
   typedef chrono::duration<rep, micro> __microsecs;
   timeval tv;
   gettimeofday(&tv, 0);
   return time_point(__secs(tv.tv_sec) + __microsecs(tv.tv_usec));
 #endif // CLOCK_REALTIME
 }
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
 filesystem_error::~filesystem_error() {}
 
 void filesystem_error::__create_what(int __num_paths) {
   const char* derived_what = system_error::what();
   __storage_->__what_ = [&]() -> string {
     switch (__num_paths) {
     case 0:
       return detail::format_string("filesystem error: %s", derived_what);
     case 1:
       return detail::format_string("filesystem error: %s [" PATH_CSTR_FMT "]",
                                    derived_what, path1().c_str());
     case 2:
       return detail::format_string("filesystem error: %s [" PATH_CSTR_FMT "] [" PATH_CSTR_FMT "]",
                                    derived_what, path1().c_str(), path2().c_str());
     }
     _LIBCPP_UNREACHABLE();
   }();
 }
+#endif
 
 static path __do_absolute(const path& p, path* cwd, error_code* ec) {
   if (ec)
     ec->clear();
   if (p.is_absolute())
     return p;
   *cwd = __current_path(ec);
   if (ec && *ec)

libcxx/src/format.cpp

 //===------------------------- format.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 "format"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
+
 format_error::~format_error() noexcept = default;
 
-#endif //_LIBCPP_STD_VER > 17
+#endif // _LIBCPP_NO_EXCEPTIONS
+
+#endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/future.cpp

 
 const error_category&
 future_category() noexcept
 {
     static __future_error_category __f;
     return __f;
 }
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
 future_error::future_error(error_code __ec)
     : logic_error(__ec.message()),
       __ec_(__ec)
 {
 }
 
 future_error::~future_error() noexcept
 {
 }
+#endif // _LIBCPP_NO_EXCEPTIONS
 
 void
 __assoc_sub_state::__on_zero_shared() noexcept
 {
     delete this;
 }
 
 void

libcxx/src/ios.cpp

 iostream_category() noexcept
 {
     static __iostream_category s;
     return s;
 }
 
 // ios_base::failure
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
+
 ios_base::failure::failure(const string& msg, const error_code& ec)
     : system_error(ec, msg)
 {
 }
 
 ios_base::failure::failure(const char* msg, const error_code& ec)
     : system_error(ec, msg)
 {
 }
 
 ios_base::failure::~failure() throw()
 {
 }
 
+#endif // _LIBCPP_NO_EXCEPTIONS
+
 // ios_base locale
 
 const ios_base::fmtflags ios_base::boolalpha;
 const ios_base::fmtflags ios_base::dec;
 const ios_base::fmtflags ios_base::fixed;
 const ios_base::fmtflags ios_base::hex;
 const ios_base::fmtflags ios_base::internal;
 const ios_base::fmtflags ios_base::left;

libcxx/src/optional.cpp

 
 
 #include <experimental/__config>
 
 //  Preserve std::experimental::bad_optional_access for ABI compatibility
 //  Even though it no longer exists in a header file
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
     : public std::logic_error
 {
 public:
   bad_optional_access() : std::logic_error("Bad optional Access") {}
 
 //  Get the key function ~bad_optional_access() into the dylib
     virtual ~bad_optional_access() noexcept;
 };
 
 bad_optional_access::~bad_optional_access() noexcept = default;
+#endif // _LIBCPP_NO_EXCEPTIONS
 
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL

libcxx/src/regex.cpp

 //===-------------------------- regex.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 "regex"
 #include "algorithm"
 #include "iterator"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
+
 static
 const char*
 make_error_type_string(regex_constants::error_type ecode)
 {
     switch (ecode)
     {
     case regex_constants::error_collate:
         return "The expression contained an invalid collating element name.";

 
 regex_error::regex_error(regex_constants::error_type ecode)
     : runtime_error(make_error_type_string(ecode)),
       __code_(ecode)
 {}
 
 regex_error::~regex_error() throw() {}
 
+#endif // _LIBCPP_NO_EXCEPTIONS
+
 namespace {
 
 struct collationnames
 {
     const char* elem_;
     char char_;
 };
 

libcxx/src/string.cpp

#else
     fprintf(stderr, "%s\n", msg.c_str());
     _VSTD::abort();
 #endif
 }
 
 inline
 void throw_from_string_out_of_range( const string& func )
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     throw_helper<out_of_range>(func + ": out of range");
+#endif
 }
 
 inline
 void throw_from_string_invalid_arg( const string& func )
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     throw_helper<invalid_argument>(func + ": no conversion");
+#endif
 }
 
 // as_integer
 
 template<typename V, typename S, typename F>
 inline
 V
 as_integer_helper(const string& func, const S& str, size_t* idx, int base, F f)

libcxx/src/support/runtime/stdexcept_default.ipp

 #include <cxxabi.h>
 #endif
 
 static_assert(sizeof(std::__libcpp_refstring) == sizeof(const char*), "");
 
 namespace std // purposefully not using versioning namespace
 {
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
+
 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_;

 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
+#endif // !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
+
+#endif // _LIBCPP_NO_EXCEPTIONS
 
 } // namespace std

libcxx/src/system_error.cpp

 string
 error_code::message() const
 {
     return __cat_->message(__val_);
 }
 
 // system_error
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
+
 string
 system_error::__init(const error_code& ec, string what_arg)
 {
     if (ec)
     {
         if (!what_arg.empty())
             what_arg += ": ";
         what_arg += ec.message();
: runtime_error(__init(error_code(ev, ecat), "")),
       __ec_(error_code(ev, ecat))
 {
 }
 
 system_error::~system_error() noexcept
 {
 }
 
+#endif // _LIBCPP_NO_EXCEPTIONS
+
 void
 __throw_system_error(int ev, const char* what_arg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw system_error(error_code(ev, system_category()), what_arg);
 #else
     (void)ev;
     (void)what_arg;
     _VSTD::abort();
 #endif
 }
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/utils/ci/buildkite-pipeline.yml

artifact_paths:
       - "**/test-results.xml"
     agents:
       queue: "windows"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
 
+  - label: "Windows -EHs- -EHa-"
+    command: "bash libcxx/utils/ci/run-buildbot windows-noexceptions"
+    artifact_paths:
+      - "**/test-results.xml"
+    agents:
+      queue: "windows"
+    retry:
+      automatic:
+        - exit_status: -1  # Agent was lost
+          limit: 2
+
   - label: "32 bit"
     command: "libcxx/utils/ci/run-buildbot generic-32bit"
     artifact_paths:
       - "**/test-results.xml"
     agents:
       queue: "libcxx-builders"
       os: "linux"
     retry:

libcxx/utils/ci/run-buildbot

windows-dll)
     ${NINJA} -vC "${BUILD_DIR}" check-cxx
 ;;
 windows-static)
     clean
     generate-cmake-libcxx-win -DLIBCXX_ENABLE_SHARED=OFF
     echo "+++ Running the libc++ tests"
     ${NINJA} -vC "${BUILD_DIR}" check-cxx
 ;;
+windows-noexceptions)
+    clean
+    generate-cmake-libcxx-win -DLIBCXX_ENABLE_EXCEPTIONS=OFF -DLIBCXX_ENABLE_EXPERIMENTAL_LIBRARY=OFF
+    echo "+++ Running the libc++ tests"
+    ${NINJA} -vC "${BUILD_DIR}" check-cxx
+;;
 #################################################################
 # Insert vendor-specific internal configurations below.
 #
 # This allows vendors to extend this file with their own internal
 # configurations without running into merge conflicts with upstream.
 #################################################################
 
 #################################################################
 *)
     echo "${BUILDER} is not a known configuration"
     exit 1
 ;;
 esac

libcxxabi/src/stdlib_stdexcept.cpp

 // This includes an implementation file from libc++.
 #include "src/include/refstring.h"
 
 static_assert(sizeof(std::__libcpp_refstring) == sizeof(const char *), "");
 
 namespace std  // purposefully not using versioning namespace
 {
 
+#ifndef _LIBCPP_NO_EXCEPTIONS
+
 logic_error::~logic_error() noexcept {}
 
 const char*
 logic_error::what() const noexcept
 {
     return __imp_.c_str();
 }
 

 invalid_argument::~invalid_argument() noexcept {}
 length_error::~length_error() noexcept {}
 out_of_range::~out_of_range() noexcept {}
 
 range_error::~range_error() noexcept {}
 overflow_error::~overflow_error() noexcept {}
 underflow_error::~underflow_error() noexcept {}
 
+#endif // _LIBCPP_NO_EXCEPTIONS
+
 }  // std