[libcxx] Make it possible to build a no-exceptions variant of libcxx.

[rmaprath]

Summary

Fixes a small omission in libcxx that prevents libcxx being built when -DLIBCXX_ENABLE_EXCEPTIONS=0 is used.

I will do a follow-up patch to introduce the new libc++ build to the buildbot.

[rmaprath]

Patch updated to add XFAILS for all those tests that are failing on the new (-fno-exceptions) library variant. Follow-up patches will progressively un-XFAIL these tests (i.e. adapt them to cope with the new library variant).

[jroelofs]

LGTM

[rmaprath]

Thanks Jon!

Committed as r252598. The current buildbots are happy (except for the ARM one, which seem to have gone away).

I will update D14293 to include the new runs.

Cheers,

• Asiri

src/future.cpp

 {
     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();
     }
 }

test/libcxx/containers/sequences/vector/asan_throw.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // Test asan vector annotations with a class that throws in a CTOR.
 
 #include <vector>

test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: c++98, c++03, c++11
 
 // dynarray.cons

test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default_throws_bad_alloc.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // dynarray.cons
 
 // explicit dynarray(size_type c);

test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/at.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // dynarray.overview
 
 // const_reference at(size_type n) const;

test/std/containers/associative/map/map.access/at.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <map>
 
 // class map

test/std/containers/sequences/array/at.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <array>
 
 // reference operator[] (size_type)

test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <deque>
 
 // void push_back(const value_type& x);

test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <deque>
 
 // void push_front(const value_type& x);

test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <forward_list>
 
 // void push_front(const value_type& x);

test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <list>
 
 // template <InputIterator Iter>

test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <list>
 
 // iterator insert(const_iterator position, size_type n, const value_type& x);

test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <list>
 
 // iterator insert(const_iterator position, const value_type& x);

test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <list>
 
 // void push_back(const value_type& x);

test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <list>
 
 // void push_front(const value_type& x);

test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <vector>
 
 // void push_back(const value_type& x);

test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <unordered_map>
 
 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,

test/std/depr/depr.c.headers/uchar_h.pass.cpp

 //
 // XFAIL: apple-darwin
 // XFAIL: newlib
+// XFAIL: libcpp-no-exceptions
 
 // <uchar.h>
 

test/std/experimental/optional/optional.object/optional.object.assign/copy.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // optional<T>& operator=(const optional<T>& rhs);

test/std/experimental/optional/optional.object/optional.object.assign/emplace.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // template <class... Args> void optional<T>::emplace(Args&&... args);

test/std/experimental/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // template <class U, class... Args>

test/std/experimental/optional/optional.object/optional.object.assign/move.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // optional<T>& operator=(optional<T>&& rhs)

test/std/experimental/optional/optional.object/optional.object.ctor/const_T.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++98, c++03, c++11
+// XFAIL: libcpp-no-exceptions
 
 // <optional>
 

test/std/experimental/optional/optional.object/optional.object.ctor/copy.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // optional(const optional<T>& rhs);

test/std/experimental/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++98, c++03, c++11
+// XFAIL: libcpp-no-exceptions
 
 // <optional>
 

test/std/experimental/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // template <class U, class... Args>

test/std/experimental/optional/optional.object/optional.object.ctor/move.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // optional(optional<T>&& rhs) noexcept(is_nothrow_move_constructible<T>::value);

test/std/experimental/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++98, c++03, c++11
+// XFAIL: libcpp-no-exceptions
 
 // <optional>
 

test/std/experimental/optional/optional.object/optional.object.observe/value.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // T& optional<T>::value();

test/std/experimental/optional/optional.object/optional.object.observe/value_const.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // constexpr const T& optional<T>::value() const;

test/std/experimental/optional/optional.object/optional.object.swap/swap.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // void swap(optional&)

test/std/experimental/optional/optional.specalg/swap.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // template <class T> void swap(optional<T>& x, optional<T>& y)

test/std/experimental/string.view/string.view.access/at.pass.cpp

 // NOTE: Older versions of clang have a bug where they fail to evalute
 // string_view::at as a constant expression.
 // XFAIL: clang-3.4, clang-3.3
+// XFAIL: libcpp-no-exceptions
 
 // <string_view>
 

test/std/experimental/string.view/string.view.ops/compare.pointer_size.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1, const charT* s) const;

test/std/experimental/string.view/string.view.ops/compare.size_size_sv.pass.cpp

 //===----------------------------------------------------------------------===//
 
 
+// XFAIL: libcpp-no-exceptions
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1, basic_string_view str) const;

test/std/experimental/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp

 //===----------------------------------------------------------------------===//
 
 
+// XFAIL: libcpp-no-exceptions
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1,

test/std/experimental/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 
 
+// XFAIL: libcpp-no-exceptions
 // <string_view>
 
 // constexpr int compare(size_type pos1, size_type n1, basic_string_view str,

test/std/experimental/string.view/string.view.ops/copy.pass.cpp

 //===----------------------------------------------------------------------===//
 
 
+// XFAIL: libcpp-no-exceptions
 // <string_view>
 
 // size_type copy(charT* s, size_type n, size_type pos = 0) const;

test/std/experimental/string.view/string.view.ops/substr.pass.cpp

 //===----------------------------------------------------------------------===//
 
 
+// XFAIL: libcpp-no-exceptions
 // <string_view>
 
 // constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;

test/std/input.output/iostream.format/output.streams/ostream_sentry/destruct.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <ostream>
 
 // template <class charT, class traits = char_traits<charT> >

test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <ios>
 
 // template <class charT, class traits> class basic_ios

test/std/input.output/iostreams.base/ios/iostate.flags/clear.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <ios>
 
 // template <class charT, class traits> class basic_ios

test/std/input.output/iostreams.base/ios/iostate.flags/exceptions_iostate.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <ios>
 
 // template <class charT, class traits> class basic_ios

test/std/input.output/iostreams.base/ios/iostate.flags/setstate.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <ios>
 
 // template <class charT, class traits> class basic_ios

test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // test operator new[]
 // NOTE: asan and msan will not call the new handler.
 // UNSUPPORTED: sanitizer-new-delete

test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // test operator new [] (nothrow)
 // NOTE: asan and msan will not call the new handler.
 // UNSUPPORTED: sanitizer-new-delete

test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // test operator new
 
 // asan and msan will not call the new handler.

test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // test operator new (nothrow)
 
 // asan and msan will not call the new handler.

test/std/language.support/support.exception/except.nested/assign.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <exception>
 
 // class nested_exception;

test/std/language.support/support.exception/except.nested/ctor_copy.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <exception>
 
 // class nested_exception;

test/std/language.support/support.exception/except.nested/ctor_default.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <exception>
 
 // class nested_exception;

test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <exception>
 
 // class nested_exception;

test/std/language.support/support.exception/except.nested/rethrow_nested.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <exception>
 
 // class nested_exception;

test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <exception>
 
 // class nested_exception;

test/std/language.support/support.exception/propagation/current_exception.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <exception>
 
 // exception_ptr current_exception();

test/std/language.support/support.exception/propagation/make_exception_ptr.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <exception>
 
 // template<class E> exception_ptr make_exception_ptr(E e);

test/std/language.support/support.exception/propagation/rethrow_exception.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <exception>
 
 // void rethrow_exception [[noreturn]] (exception_ptr p);

test/std/language.support/support.exception/uncaught/uncaught_exception.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // test uncaught_exception
 
 #include <exception>

test/std/language.support/support.exception/uncaught/uncaught_exceptions.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // test uncaught_exceptions
 
 #include <exception>

test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <locale>
 
 // template <class charT> class collate_byname

test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <locale>
 
 // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>

test/std/localization/locales/locale.global.templates/use_facet.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <locale>
 
 // template <class Facet> const Facet& use_facet(const locale& loc);

test/std/localization/locales/locale/locale.members/combine.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <locale>
 
 // template <class Facet> locale combine(const locale& other) const;

test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <complex>
 
 // template<class T>

test/std/numerics/rand/rand.device/ctor.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <random>
 
 // class random_device;

test/std/numerics/rand/rand.device/eval.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <random>
 
 // class random_device;

test/std/re/re.alg/re.alg.search/grep.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>

test/std/re/re.regex/re.regex.assign/assign.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <regex>
 
 // template <class charT, class traits = regex_traits<charT>> class basic_regex;

test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <regex>
 
 // template <class charT, class traits = regex_traits<charT>> class basic_regex;

test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <regex>
 
 // template <class charT, class traits = regex_traits<charT>> class basic_regex;

test/std/strings/basic.string/string.access/at.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // const_reference at(size_type pos) const;

test/std/strings/basic.string/string.capacity/capacity.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // size_type capacity() const;

test/std/strings/basic.string/string.capacity/max_size.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // size_type max_size() const;

test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // size_type max_size() const;

test/std/strings/basic.string/string.capacity/reserve.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // void reserve(size_type res_arg=0);

test/std/strings/basic.string/string.capacity/resize_size.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // void resize(size_type n);

test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // void resize(size_type n, charT c);

test/std/strings/basic.string/string.cons/substr.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string(const basic_string<charT,traits,Allocator>& str,

test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&

test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&

test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // size_type copy(charT* s, size_type n, size_type pos = 0) const;

test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&

test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&

test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&

test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&

test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&

test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&

test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&

test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&

test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&

test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&

test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&

test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // int compare(size_type pos, size_type n1, const charT *s) const;

test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // int compare(size_type pos, size_type n1, const charT *s, size_type n2) const;

test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // int compare(size_type pos1, size_type n1, const basic_string& str) const;

test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // int compare(size_type pos1, size_type n1, const basic_string& str,

test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string substr(size_type pos = 0, size_type n = npos) const;

test/std/strings/string.conversions/stod.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // double stod(const string& str, size_t *idx = 0);

test/std/strings/string.conversions/stof.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin11
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin12
 

test/std/strings/string.conversions/stoi.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // int stoi(const string& str, size_t *idx = 0, int base = 10);

test/std/strings/string.conversions/stol.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin11
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin12
 

test/std/strings/string.conversions/stold.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <string>
 
 // long double stold(const string& str, size_t *idx = 0);

test/std/strings/string.conversions/stoll.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin11
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin12
 

test/std/strings/string.conversions/stoul.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin11
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin12
 

test/std/strings/string.conversions/stoull.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin11
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin12
 

test/std/thread/futures/futures.async/async.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.promise/dtor.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.promise/get_future.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.promise/move_assign.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.promise/move_ctor.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.promise/set_exception.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.promise/set_lvalue.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.promise/set_rvalue.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <future>

test/std/thread/futures/futures.promise/set_value_const.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.promise/set_value_void.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.shared_future/dtor.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.shared_future/get.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.tas/futures.task.members/dtor.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.tas/futures.task.members/get_future.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.tas/futures.task.members/make_ready_at_thread_exit.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.tas/futures.task.members/operator.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.tas/futures.task.members/reset.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.unique_future/dtor.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/futures/futures.unique_future/get.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 

test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <condition_variable>

test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>

test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11
 

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11
 

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11
 

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11
 

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11
 

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>

test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>

test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <thread>

test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <memory>
 
 // template <class InputIterator, class ForwardIterator>

test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <memory>
 
 // template <class InputIterator, class Size, class ForwardIterator>

test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <memory>
 
 // template <class ForwardIterator, class Size, class T>

test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <memory>
 
 // template <class ForwardIterator, class T>

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <memory>
 
 // template<class Y> explicit shared_ptr(auto_ptr<Y>&& r);

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator_throw.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <memory>
 
 // template<class D, class A> shared_ptr(nullptr_t, D d, A a);

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <memory>
 
 // shared_ptr

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator_throw.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <memory>
 
 // template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <memory>
 
 // shared_ptr

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <memory>
 
 // template<class Y> explicit shared_ptr(Y* p);

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <memory>
 
 // template <class Y, class D> explicit shared_ptr(unique_ptr<Y, D>&&r);

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // <memory>
 
 // shared_ptr

test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // template <class charT>
 //     explicit bitset(const charT* str,
 //                     typename basic_string<charT>::size_type n = basic_string<charT>::npos,

test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // test bitset(string, pos, n, zero, one);
 
 #include <bitset>

test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // test bitset<N>& flip(size_t pos);
 
 #include <bitset>

test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // test bitset<N>& reset(size_t pos);
 
 #include <bitset>

test/std/utilities/template.bitset/bitset.members/set_one.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // test bitset<N>& set(size_t pos, bool val = true);
 
 #include <bitset>

test/std/utilities/template.bitset/bitset.members/test.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: libcpp-no-exceptions
 // test constexpr bool test(size_t pos) const;
 
 #include <bitset>