[libc++/abi/unwind] Rename Lit features for no exceptions to -fno-exceptions

[ldionne]

Summary

Instead of having different names for the same Lit feature accross code
bases, use the same name everywhere. This NFC commit is in preparation
for a refactor where all three projects will be using the same Lit
feature detection logic, and hence it won't be convenient to use
different names for the feature.

[ldionne]

This is a very simple change, but I wanted to ask whether someone was aware of a reason for having different names for libcxx-no-exceptions and libcxxabi-no-exceptions.

[dexonsmith]

no-exceptions sounds a bit better to me as a feature name rather than the Clang command-line argument, although what you have is probably okay too. (Unifying sounds great! I'll let someone else sign off though.)

[ldionne]

In D78370#1989936, @dexonsmith wrote:

no-exceptions sounds a bit better to me as a feature name rather than the Clang command-line argument, although what you have is probably okay too. (Unifying sounds great! I'll let someone else sign off though.)

We use -fmeow for other Lit features in libc++ pretty widely (e.g. -fmodules). I agree with you though, and I was planning on changing the names of many features once I'm done with the changes started in https://reviews.llvm.org/D78381.

[ldionne]

Rename to no-exceptions.

[ldionne]

Since this is NFC and I put up a review just to ask whether folks were aware of a reason for having different Lit feature names, I'll assume the answer is "there's no reason" and commit this tomorrow unless someone raises an issue.

libcxx/test/libcxx/algorithms/debug_less.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 // <algorithm>
 
 // template <class _Compare> struct __debug_less
 
 // __debug_less checks that a comparator actually provides a strict-weak ordering.
 
 struct DebugException {};

libcxx/test/libcxx/containers/associative/map/at.abort.pass.cpp

 
 // class map
 
 // mapped_type& at(const key_type& k);
 
 // Make sure we abort() when exceptions are disabled and we fetch a key that
 // is not in the map.
 
-// REQUIRES: libcpp-no-exceptions
+// REQUIRES: no-exceptions
 
 #include <csignal>
 #include <cstdlib>
 #include <map>
 
 #include "test_macros.h"
 
 

libcxx/test/libcxx/containers/associative/map/at.const.abort.pass.cpp

 
 // class map
 
 // const mapped_type& at(const key_type& k) const;
 
 // Make sure we abort() when exceptions are disabled and we fetch a key that
 // is not in the map.
 
-// REQUIRES: libcpp-no-exceptions
+// REQUIRES: no-exceptions
 
 #include <csignal>
 #include <cstdlib>
 #include <map>
 
 #include "test_macros.h"
 
 

libcxx/test/libcxx/containers/sequences/vector/asan_throw.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // Test asan vector annotations with a class that throws in a CTOR.
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "asan_testing.h"
 

libcxx/test/libcxx/containers/unord/unord.map/at.abort.pass.cpp

 
 // class unordered_map
 
 // mapped_type& at(const key_type& k);
 
 // Make sure we abort() when exceptions are disabled and we fetch a key that
 // is not in the map.
 
-// REQUIRES: libcpp-no-exceptions
+// REQUIRES: no-exceptions
 // UNSUPPORTED: c++98, c++03
 
 #include <csignal>
 #include <cstdlib>
 #include <unordered_map>
 
 #include "test_macros.h"
 
 
 int main(int, char**) {
     std::signal(SIGABRT, [](int) { std::_Exit(EXIT_SUCCESS); });
     std::unordered_map<int, int> map;
     map.at(1);
     return EXIT_FAILURE;
 }

libcxx/test/libcxx/containers/unord/unord.map/at.const.abort.pass.cpp

 
 // class unordered_map
 
 // const mapped_type& at(const key_type& k) const;
 
 // Make sure we abort() when exceptions are disabled and we fetch a key that
 // is not in the map.
 
-// REQUIRES: libcpp-no-exceptions
+// REQUIRES: no-exceptions
 // UNSUPPORTED: c++98, c++03
 
 #include <csignal>
 #include <cstdlib>
 #include <unordered_map>
 
 #include "test_macros.h"
 
 
 int main(int, char**) {
     std::signal(SIGABRT, [](int) { std::_Exit(EXIT_SUCCESS); });
     std::unordered_map<int, int> const map;
     map.at(1);
     return EXIT_FAILURE;
 }

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

 
 // template <class charT, class traits> class basic_ios
 
 // void clear(iostate state);
 
 // Make sure that we abort() when exceptions are disabled and the exception
 // flag is set for the iostate we pass to clear().
 
-// REQUIRES: libcpp-no-exceptions
+// REQUIRES: no-exceptions
 
 #include <csignal>
 #include <cstdlib>
 #include <ios>
 #include <streambuf>
 
 #include "test_macros.h"
 

libcxx/test/libcxx/localization/locales/locale.abort.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // class locale;
 
 // explicit locale( const char* std_name );
 
-// REQUIRES: libcpp-no-exceptions
+// REQUIRES: no-exceptions
 
 // Make sure we abort() when we construct a locale with a null name and
 // exceptions are disabled.
 
 #include <csignal>
 #include <cstdlib>
 #include <locale>
 

libcxx/test/libcxx/localization/locales/locale.category.abort.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // class locale;
 
 // locale(const locale& other, const char* std_name, category cat);
 
-// REQUIRES: libcpp-no-exceptions
+// REQUIRES: no-exceptions
 
 // Make sure we abort() when we construct a locale with a null name and
 // exceptions are disabled.
 
 #include <csignal>
 #include <cstdlib>
 #include <locale>
 

libcxx/test/libcxx/localization/locales/use_facet.abort.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <class Facet> const Facet& use_facet(const locale& loc);
 
-// REQUIRES: libcpp-no-exceptions
+// REQUIRES: no-exceptions
 
 // Make sure we abort() when we pass a facet not associated to the locale to
 // use_facet() and exceptions are disabled.
 
 #include <csignal>
 #include <cstdlib>
 #include <locale>
 

libcxx/test/libcxx/strings/iterators.exceptions.pass.cpp

 #include <initializer_list>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 static const bool expected = false;
 #else
-// Under libcpp-no-exceptions all noexcept expressions are trivially true, so
+// Under -fno-exceptions all noexcept expressions are trivially true, so
 // any check for a noexcept returning false must actually check for it being
 // true.
 static const bool expected = true;
 #endif
 
 int main(int, char**)
 {
 //  basic tests

libcxx/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <deque>
 
 // void push_back(const value_type& x);
 
 #include <deque>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include <cassert>

libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <deque>
 
 // void push_front(const value_type& x);
 
 #include <deque>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <forward_list>
 
 // void push_front(const value_type& x);
 
 #include <forward_list>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <list>
 
 // void push_back(const value_type& x);
 
 #include <list>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <list>
 
 // void push_front(const value_type& x);
 
 #include <list>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 // This test fails due to a stack overflow
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
 // <exception>
 
 // class nested_exception;
 

libcxx/test/std/language.support/support.exception/except.nested/rethrow_nested.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <exception>
 
 // class nested_exception;
 
 // void rethrow_nested [[noreturn]] () const;
 
 #include <exception>
 #include <cstdlib>

libcxx/test/std/language.support/support.exception/except.nested/throw_with_nested.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <exception>
 
 // class nested_exception;
 
 // template<class T> void throw_with_nested [[noreturn]] (T&& t);
 
 #include <exception>
 #include <cstdlib>

libcxx/test/std/language.support/support.exception/propagation/current_exception.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // This test needs to be rewritten for the Windows exception_ptr semantics
 // which copy the exception each time the exception_ptr is copied.
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <exception>
 
 // exception_ptr current_exception();
 
 #include <exception>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/language.support/support.exception/propagation/make_exception_ptr.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <exception>
 
 // template<class E> exception_ptr make_exception_ptr(E e);
 
 #include <exception>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/language.support/support.exception/propagation/rethrow_exception.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <exception>
 
 // void rethrow_exception [[noreturn]] (exception_ptr p);
 
 #include <exception>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/language.support/support.exception/uncaught/uncaught_exception.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // test uncaught_exception
 
 #include <exception>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A

libcxx/test/std/language.support/support.exception/uncaught/uncaught_exceptions.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
-// XFAIL: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 // std::uncaught_exceptions() was introduced in the dylib on Mac OS 10.12
 // XFAIL: with_system_cxx_lib=macosx10.11
 // XFAIL: with_system_cxx_lib=macosx10.10
 // XFAIL: with_system_cxx_lib=macosx10.9
 
 // However, std::uncaught_exceptions() gives the wrong answer in Mac OS 10.12
 // and 10.13, where it only gives 0 or 1. This was fixed later.

libcxx/test/std/re/re.alg/re.alg.match/exponential.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // UNSUPPORTED: c++98, c++03
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_match(BidirectionalIterator first, BidirectionalIterator last,
 //                  match_results<BidirectionalIterator, Allocator>& m,
 //                  const basic_regex<charT, traits>& e,
 //                  regex_constants::match_flag_type flags = regex_constants::match_default);

libcxx/test/std/re/re.alg/re.alg.replace/exponential.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 // template <class OutputIterator, class BidirectionalIterator,
 //           class traits, class charT, class ST, class SA>
 //     OutputIterator
 //     regex_replace(OutputIterator out,
 //                   BidirectionalIterator first, BidirectionalIterator last,
 //                   const basic_regex<charT, traits>& e,
 //                   const basic_string<charT, ST, SA>& fmt,

libcxx/test/std/re/re.alg/re.alg.search/exponential.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // UNSUPPORTED: c++98, c++03
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_search(BidirectionalIterator first, BidirectionalIterator last,
 //                  match_results<BidirectionalIterator, Allocator>& m,
 //                  const basic_regex<charT, traits>& e,
 //                  regex_constants::match_flag_type flags = regex_constants::match_default);

libcxx/test/std/re/re.grammar/excessive_brace_count.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // UNSUPPORTED: c++98, c++03
 
 // the "n" in `a{n}` should be within the numeric limits.
 
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
 

libcxx/test/std/re/re.grammar/excessive_brace_min_max.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // UNSUPPORTED: c++98, c++03
 
 // the "n" and "m" in `a{n,m}` should be within the numeric limits.
 // requirement "m >= n" should be checked.
 
 #include <regex>
 #include <cassert>
 #include "test_macros.h"

libcxx/test/std/re/re.regex/re.regex.construct/bad_backref.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <regex>
 
 // template <class charT, class traits = regex_traits<charT>> class basic_regex;
 
 // template <class ST, class SA>
 //    basic_regex(const basic_string<charT, ST, SA>& s);
 
 #include <regex>

libcxx/test/std/re/re.regex/re.regex.construct/bad_ctype.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <regex>
 
 // template <class charT, class traits = regex_traits<charT>> class basic_regex;
 
 // template <class ST, class SA>
 //    basic_regex(const basic_string<charT, ST, SA>& s);
 
 #include <regex>

libcxx/test/std/re/re.regex/re.regex.construct/bad_escape.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <regex>
 
 // template <class charT, class traits = regex_traits<charT>> class basic_regex;
 
 // template <class ST, class SA>
 //    basic_regex(const basic_string<charT, ST, SA>& s);
 
 #include <regex>

libcxx/test/std/re/re.regex/re.regex.construct/bad_range.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <regex>
 
 // template <class charT, class traits = regex_traits<charT>> class basic_regex;
 
 // template <class ST, class SA>
 //    basic_regex(const basic_string<charT, ST, SA>& s);
 
 #include <regex>

libcxx/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <regex>
 
 // template <class charT, class traits = regex_traits<charT>> class basic_regex;
 
 // template <class ST, class SA>
 //    basic_regex(const basic_string<charT, ST, SA>& s);
 
 #include <regex>

libcxx/test/std/strings/basic.string/string.capacity/max_size.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <string>
 
 // size_type max_size() const;
 
 // NOTE: asan and msan will fail for one of two reasons
 // 1. If allocator_may_return_null=0 then they will fail because the allocation
 //    returns null.
 // 2. If allocator_may_return_null=1 then they will fail because the allocation

libcxx/test/std/strings/basic.string/string.capacity/over_max_size.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // XFAIL: with_system_cxx_lib=macosx10.11
 // XFAIL: with_system_cxx_lib=macosx10.10
 // XFAIL: with_system_cxx_lib=macosx10.9
 
 // <string>
 
 // size_type max_size() const;
 

libcxx/test/std/thread/futures/futures.promise/set_exception.pass.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
 //
 //===----------------------------------------------------------------------===//
 //
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
 
 // class promise<R>
 
 // void set_exception(exception_ptr p);

libcxx/test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.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
 //
 //===----------------------------------------------------------------------===//
 //
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
 
 // class promise<R>
 
 // void promise::set_exception_at_thread_exit(exception_ptr p);

libcxx/test/std/thread/futures/futures.promise/set_rvalue.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03
-// UNSUPPORTED: libcpp-has-no-threads, libcpp-no-exceptions
+// UNSUPPORTED: libcpp-has-no-threads, no-exceptions
 
 // <future>
 
 // class promise<R>
 
 // void promise::set_value(R&& r);
 
 #include <future>

libcxx/test/std/thread/futures/futures.promise/set_value_void.pass.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
 //
 //===----------------------------------------------------------------------===//
 //
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
 
 // class promise<R>
 
 // void promise<void>::set_value();

libcxx/test/std/thread/futures/futures.shared_future/dtor.pass.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
 //
 //===----------------------------------------------------------------------===//
 //
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
 
 // class shared_future<R>
 
 // ~shared_future();

libcxx/test/std/thread/futures/futures.unique_future/dtor.pass.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
 //
 //===----------------------------------------------------------------------===//
 //
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
 
 // class future<R>
 
 // ~future();

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <condition_variable>
 
 // class condition_variable_any;
 
 // FILE_DEPENDENCIES: %t.exe
 // RUN: %{build}

libcxx/test/std/utilities/any/any.class/any.assign/copy.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_any_cast && !no-exceptions
 
 // <any>
 
 // any& operator=(any const &);
 
 // Test copy assignment
 
 #include <any>

libcxx/test/std/utilities/any/any.class/any.assign/move.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_any_cast && !no-exceptions
 
 // <any>
 
 // any& operator=(any &&);
 
 // Test move assignment.
 
 #include <any>

libcxx/test/std/utilities/any/any.class/any.assign/value.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_any_cast && !no-exceptions
 
 // <any>
 
 // template <class ValueType>
 // any& operator=(ValueType&&);
 
 // Test value copy and move assignment.
 

libcxx/test/std/utilities/any/any.class/any.cons/copy.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_any_cast && !no-exceptions
 
 // <any>
 
 // any(any const &);
 
 #include <any>
 #include <cassert>
 

libcxx/test/std/utilities/any/any.class/any.cons/in_place_type.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_any_cast && !no-exceptions
 
 // <any>
 
 // template <class T, class ...Args> any(in_place_type_t<T>, Args&&...);
 // template <class T, class U, class ...Args>
 // any(in_place_type_t<T>, initializer_list<U>, Args&&...);
 
 // Test construction from a value.

libcxx/test/std/utilities/any/any.class/any.cons/move.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_any_cast && !no-exceptions
 
 // <any>
 
 // any(any &&) noexcept;
 
 #include <any>
 #include <utility>
 #include <type_traits>

libcxx/test/std/utilities/any/any.class/any.cons/value.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_any_cast && !no-exceptions
 
 // <any>
 
 // template <class Value> any(Value &&)
 
 // Test construction from a value.
 // Concerns:
 // ---------

libcxx/test/std/utilities/any/any.class/any.modifiers/emplace.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_any_cast && !no-exceptions
 
 // <any>
 
 // template <class T, class ...Args> T& emplace(Args&&...);
 // template <class T, class U, class ...Args>
 // T& emplace(initializer_list<U>, Args&&...);
 
 #include <any>

libcxx/test/std/utilities/any/any.class/any.modifiers/reset.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_any_cast && !no-exceptions
 
 // <any>
 
 // any::reset() noexcept
 
 #include <any>
 #include <cassert>
 

libcxx/test/std/utilities/any/any.class/any.modifiers/swap.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_any_cast && !no-exceptions
 
 // <any>
 
 // any::swap(any &) noexcept
 
 // Test swap(large, small) and swap(small, large)
 
 #include <any>

libcxx/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_any_cast && !no-exceptions
 
 // <any>
 
 // template <class ValueType>
 // ValueType const* any_cast(any const *) noexcept;
 //
 // template <class ValueType>
 // ValueType * any_cast(any *) noexcept;

libcxx/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_any_cast && !no-exceptions
 
 // <any>
 
 // template <class ValueType>
 // ValueType const any_cast(any const&);
 //
 // template <class ValueType>
 // ValueType any_cast(any &);

libcxx/test/std/utilities/any/any.nonmembers/make_any.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_any_cast && !no-exceptions
 
 // <any>
 
 // template <class T, class ...Args> any make_any(Args&&...);
 // template <class T, class U, class ...Args>
 // any make_any(initializer_list<U>, Args&&...);
 
 #include <any>

libcxx/test/std/utilities/any/any.nonmembers/swap.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_any_cast && !no-exceptions
 
 // <any>
 
 // void swap(any &, any &) noexcept
 
 // swap(...) just wraps any::swap(...). That function is tested elsewhere.
 
 #include <any>

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <memory>
 
 // allocator:
 // T* allocate(size_t n);
 
 #include <memory>
 #include <cassert>
 

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator_throw.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <memory>
 
 // template<class D, class A> shared_ptr(nullptr_t, D d, A a);
 
 #include <memory>
 #include <cassert>
 #include "test_macros.h"
 #include "deleter_types.h"

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // UNSUPPORTED: sanitizer-new-delete
 
 // <memory>
 
 // shared_ptr
 
 // template<class D> shared_ptr(nullptr_t, D d);
 

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator_throw.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // <memory>
 
 // template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
 
 #include <memory>
 #include <cassert>
 #include "test_macros.h"
 #include "deleter_types.h"

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // UNSUPPORTED: sanitizer-new-delete
 
 // <memory>
 
 // shared_ptr
 
 // template<class Y, class D> shared_ptr(Y* p, D d);
 

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 // UNSUPPORTED: sanitizer-new-delete
 
 // <memory>
 
 // template<class Y> explicit shared_ptr(Y* p);
 
 
 #include <memory>

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.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
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_optional_access && !no-exceptions
 
 // <optional>
 
 // template <class U>
 //   constexpr EXPLICIT optional(U&& u);
 
 #include <optional>
 #include <type_traits>

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.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
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_optional_access && !no-exceptions
 
 // <optional>
 
 // constexpr optional(const T& v);
 
 #include <optional>
 #include <type_traits>
 #include <cassert>

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_optional_access && !no-exceptions
 
 // <optional>
 
 // constexpr optional(optional<T>&& rhs);
 
 #include <optional>
 #include <type_traits>
 #include <cassert>

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.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
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_optional_access && !no-exceptions
 
 // <optional>
 
 // constexpr optional(T&& v);
 
 #include <optional>
 #include <type_traits>
 #include <cassert>

libcxx/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_optional_access && !no-exceptions
 
 // <optional>
 
 // constexpr T& optional<T>::value() &;
 
 #include <optional>
 #include <type_traits>
 #include <cassert>

libcxx/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_optional_access && !no-exceptions
 
 // <optional>
 
 // constexpr const T& optional<T>::value() const &;
 
 #include <optional>
 #include <type_traits>
 #include <cassert>

libcxx/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_optional_access && !no-exceptions
 
 // <optional>
 
 // constexpr const T& optional<T>::value() const &&;
 
 #include <optional>
 #include <type_traits>
 #include <cassert>

libcxx/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <optional>
 
-// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_optional_access && !no-exceptions
 
 // constexpr T& optional<T>::value() &&;
 
 #include <optional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/utilities/optional/optional.specalg/make_optional.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_optional_access && !no-exceptions
 
 // <optional>
 //
 // template <class T>
 //   constexpr optional<decay_t<T>> make_optional(T&& v);
 
 #include <optional>
 #include <string>

libcxx/test/std/utilities/variant/variant.get/get_index.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <size_t I, class... Types>
 //   constexpr variant_alternative_t<I, variant<Types...>>&
 //   get(variant<Types...>& v);
 // template <size_t I, class... Types>
 //   constexpr variant_alternative_t<I, variant<Types...>>&&

libcxx/test/std/utilities/variant/variant.get/get_type.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class T, class... Types> constexpr T& get(variant<Types...>& v);
 // template <class T, class... Types> constexpr T&& get(variant<Types...>&& v);
 // template <class T, class... Types> constexpr const T& get(const
 // variant<Types...>& v);
 // template <class T, class... Types> constexpr const T&& get(const

libcxx/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // template <class T>
 // variant& operator=(T&&) noexcept(see below);
 

libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // variant& operator=(variant const&); // constexpr in C++20
 
 #include <cassert>

libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // variant& operator=(variant&&) noexcept(see below); // constexpr in C++20
 

libcxx/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // template <class T> constexpr variant(T&&) noexcept(see below);
 
 #include <cassert>

libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // variant(variant const&); // constexpr in C++20
 
 #include <cassert>

libcxx/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // constexpr variant() noexcept(see below);
 
 #include <cassert>

libcxx/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // template <size_t I, class ...Args>
 // constexpr explicit variant(in_place_index_t<I>, Args&&...);
 

libcxx/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // template <size_t I, class Up, class ...Args>
 // constexpr explicit
 // variant(in_place_index_t<I>, initializer_list<Up>, Args&&...);

libcxx/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // template <class Tp, class ...Args>
 // constexpr explicit variant(in_place_type_t<Tp>, Args&&...);
 

libcxx/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // template <class Tp, class Up, class ...Args>
 // constexpr explicit
 // variant(in_place_type_t<Tp>, initializer_list<Up>, Args&&...);

libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // variant(variant&&) noexcept(see below); // constexpr in C++20
 
 #include <cassert>

libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // template <size_t I, class ...Args>
 //   variant_alternative_t<I, variant<Types...>>& emplace(Args&&... args);
 

libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // template <size_t I, class U, class ...Args>
 //   variant_alternative_t<I, variant<Types...>>& emplace(initializer_list<U> il,Args&&... args);
 

libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // template <class T, class ...Args> T& emplace(Args&&... args);
 
 #include <cassert>

libcxx/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // template <class T, class U, class ...Args>
 //   T& emplace(initializer_list<U> il,Args&&... args);
 

libcxx/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // void swap(variant& rhs) noexcept(see below)
 
 #include <cassert>

libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access && !no-exceptions
 
 // <variant>
 // template <class Visitor, class... Variants>
 // constexpr see below visit(Visitor&& vis, Variants&&... vars);
 
 #include <cassert>
 #include <memory>
 #include <string>

libcxx/test/support/test.support/test_macros_header_exceptions.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 // "support/test_macros.hpp"
 
 // #define TEST_HAS_NO_EXCEPTIONS
 
 #include "test_macros.h"
 
 #if defined(TEST_HAS_NO_EXCEPTIONS)
 #error macro defined unexpectedly
 #endif
 
 int main(int, char**) {
     try { ((void)0); } catch (...) {}
 
   return 0;
 }

libcxx/utils/libcxx/test/config.py

def parse_config_site_and_add_features(self, header):
             self.config.available_features.add(m.lower()[1:].replace('_', '-'))
         return feature_macros
 
 
 
     def configure_compile_flags_exceptions(self):
         enable_exceptions = self.get_lit_bool('enable_exceptions', True)
         if not enable_exceptions:
-            self.config.available_features.add('libcpp-no-exceptions')
+            self.config.available_features.add('no-exceptions')
             self.cxx.compile_flags += ['-fno-exceptions']
 
     def configure_compile_flags_rtti(self):
         enable_rtti = self.get_lit_bool('enable_rtti', True)
         if not enable_rtti:
             self.config.available_features.add('-fno-rtti')
             self.cxx.compile_flags += ['-fno-rtti', '-D_LIBCPP_NO_RTTI']
 

libcxxabi/test/backtrace_test.pass.cpp

 //===---------------------- backtrace_test.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <assert.h>
 #include <stddef.h>
 #include <unwind.h>
 
 extern "C" _Unwind_Reason_Code
 trace_function(struct _Unwind_Context*, void* ntraced) {
   (*reinterpret_cast<size_t*>(ntraced))++;

libcxxabi/test/catch_array_01.pass.cpp

 //===---------------------- catch_array_01.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
 //
 //===----------------------------------------------------------------------===//
 
 // Can you have a catch clause of array type that catches anything?
 
 // GCC incorrectly allows array types to be caught by reference.
 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69372
 // XFAIL: gcc
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <cassert>
 
 int main()
 {
     typedef char Array[4];
     Array a = {'H', 'i', '!', 0};
     try

libcxxabi/test/catch_array_02.pass.cpp

 //===---------------------- catch_array_02.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
 //
 //===----------------------------------------------------------------------===//
 
 // Can you have a catch clause of array type that catches anything?
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <cassert>
 
 int main()
 {
     typedef char Array[4];
     Array a = {'H', 'i', '!', 0};
     try

libcxxabi/test/catch_class_01.pass.cpp

 //===---------------------- catch_class_01.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 struct A
 {
     static int count;

libcxxabi/test/catch_class_02.pass.cpp

 //===---------------------- catch_class_02.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 struct B
 {
     static int count;

libcxxabi/test/catch_class_03.pass.cpp

 //===---------------------- catch_class_03.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
 //
 //===----------------------------------------------------------------------===//
 
 /*
     This test checks that adjustedPtr is correct as there exist offsets in this
     object for the various subobjects, all of which have a unique id_ to
     check against.
 */
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 // Clang emits  warnings about exceptions of type 'Child' being caught by
 // an earlier handler of type 'Base'. Congrats clang, you've just
 // diagnosed the behavior under test.

libcxxabi/test/catch_class_04.pass.cpp

 //===---------------------- catch_class_04.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
 //
 //===----------------------------------------------------------------------===//
 
 /*
     This test checks that adjustedPtr is correct as there exist offsets in this
     object for the various subobjects, all of which have a unique id_ to
     check against.  It also checks that virtual bases work properly
 */
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 // Clang emits  warnings about exceptions of type 'Child' being caught by
 // an earlier handler of type 'Base'. Congrats clang, you've just
 // diagnosed the behavior under test.

libcxxabi/test/catch_const_pointer_nullptr.pass.cpp

 //===--------------------- catch_const_pointer_nullptr.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <cassert>
 
 // Clang emits  warnings about exceptions of type 'Child' being caught by
 // an earlier handler of type 'Base'. Congrats clang, you've just
 // diagnosed the behavior under test.
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wexceptions"

libcxxabi/test/catch_function_01.pass.cpp

 //===----------------------- catch_function_01.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
 //
 //===----------------------------------------------------------------------===//
 
 // Can you have a catch clause of array type that catches anything?
 
 // GCC incorrectly allows function pointer to be caught by reference.
 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69372
 // XFAIL: gcc
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <cassert>
 
 template <class Tp>
 bool can_convert(Tp) { return true; }
 
 template <class>
 bool can_convert(...) { return false; }

libcxxabi/test/catch_function_02.pass.cpp

 //===---------------------- catch_function_02.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
 //
 //===----------------------------------------------------------------------===//
 
 // Can you have a catch clause of array type that catches anything?
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <cassert>
 
 void f() {}
 
 int main()
 {
     typedef void Function();

libcxxabi/test/catch_function_03.pass.cpp

 //===---------------------- catch_function_03.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
 //
 //===----------------------------------------------------------------------===//
 
 // Can a noexcept function pointer be caught by a non-noexcept catch clause?
-// UNSUPPORTED: libcxxabi-no-exceptions, libcxxabi-no-noexcept-function-type
+// UNSUPPORTED: no-exceptions, libcxxabi-no-noexcept-function-type
 
 #include <cassert>
 
 template<bool Noexcept> void f() noexcept(Noexcept) {}
 template<bool Noexcept> using FnType = void() noexcept(Noexcept);
 
 template<bool ThrowNoexcept, bool CatchNoexcept>
 void check()

libcxxabi/test/catch_in_noexcept.pass.cpp

 //===---------------------- catch_in_noexcept.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++98, c++03, libcxxabi-no-exceptions
+// UNSUPPORTED: c++98, c++03
+// UNSUPPORTED: no-exceptions
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 struct A {};
 
 // Despite being marked as noexcept, this function must have an EHT entry that

libcxxabi/test/catch_member_data_pointer_01.pass.cpp

 //===----------------- catch_member_data_pointer_01.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <cassert>
 
 struct A
 {
     A() : i(0), j(0) {} // explicitly initialize 'i' to prevent warnings
     const int i;
     int j;

libcxxabi/test/catch_member_function_pointer_01.pass.cpp

 //===--------------- catch_member_function_pointer_01.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
 //
 //===----------------------------------------------------------------------===//
 
 // GCC incorrectly allows PMF type "void (T::*)()" to be caught as "void (T::*)() const"
 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69375
 // XFAIL: gcc
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 #include <cassert>
 
 struct A
 {
     void foo() {}
     void bar() const {}
 };
 

libcxxabi/test/catch_member_function_pointer_02.pass.cpp

 //===--------------- catch_member_function_pointer_02.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
 //
 //===----------------------------------------------------------------------===//
 
 // Can a noexcept member function pointer be caught by a non-noexcept catch
 // clause?
-// UNSUPPORTED: libcxxabi-no-exceptions, libcxxabi-no-noexcept-function-type
+// UNSUPPORTED: no-exceptions, libcxxabi-no-noexcept-function-type
 
 // GCC 7 and 8 support noexcept function types but this test still fails.
 // This is likely a bug in their implementation. Investigation needed.
 // XFAIL: gcc-7, gcc-8, gcc-9, gcc-10
 
 #include <cassert>
 
 struct X {

libcxxabi/test/catch_member_pointer_nullptr.pass.cpp

 //===----------------- catch_member_pointer_nullptr.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <cassert>
 
 #if __has_feature(cxx_nullptr)
 
 struct A
 {
     const int i;

libcxxabi/test/catch_multi_level_pointer.pass.cpp

 //===--------------------- catch_pointer_nullptr.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <cassert>
 #include <cstdlib>
 #include <iostream>
 
 // Roll our own assertion macro to get better error messages out of the tests.
 // In particular on systems that don't use __PRETTY_FUNCTION__ in assertions.
 #define my_assert(pred, msg) do_assert(pred, msg, __LINE__, __PRETTY_FUNCTION__)

libcxxabi/test/catch_pointer_nullptr.pass.cpp

 //===--------------------- catch_pointer_nullptr.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++98, c++03, libcxxabi-no-exceptions
+// UNSUPPORTED: c++98, c++03
+// UNSUPPORTED: no-exceptions
 
 #include <cassert>
 #include <cstdlib>
 
 struct A {};
 
 void test1()
 {

libcxxabi/test/catch_pointer_reference.pass.cpp

 //  |       o  a standard pointer conversion (4.10 [conv.ptr]) not involving   |
 //  |          conversions to private or protected or ambiguous classes        |
 //  \       o  a qualification conversion                                      /
 //     *  the handler is a pointer or pointer to member type and E is
 //        std::nullptr_t
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 #include <stdio.h>
 
 struct Base {};
 struct Derived  : Base {};

libcxxabi/test/catch_ptr.pass.cpp

 //===---------------------- catch_class_04.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
 //
 //===----------------------------------------------------------------------===//
 
 /*
     This test checks that adjustedPtr is correct as there exist offsets in this
     object for the various subobjects, all of which have a unique id_ to
     check against.  It also checks that virtual bases work properly
 */
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 // Clang emits  warnings about exceptions of type 'Child' being caught by
 // an earlier handler of type 'Base'. Congrats clang, you've just
 // diagnosed the behavior under test.

libcxxabi/test/catch_ptr_02.pass.cpp

 //===------------------------- catch_ptr_02.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <cassert>
 
 // Clang emits  warnings about exceptions of type 'Child' being caught by
 // an earlier handler of type 'Base'. Congrats clang, you've just
 // diagnosed the behavior under test.
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wexceptions"

libcxxabi/test/catch_reference_nullptr.pass.cpp

 //===--------------------- catch_pointer_nullptr.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++98, c++03, libcxxabi-no-exceptions
+// UNSUPPORTED: c++98, c++03,
+// UNSUPPORTED: no-exceptions
 
 #include <cassert>
 #include <cstdlib>
 
 struct A {};
 
 template<typename T, bool CanCatchNullptr>
 static void catch_nullptr_test() {

libcxxabi/test/cxa_vec_new_overflow_PR41395.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include "cxxabi.h"
 #include <new>
 #include <cassert>
 
 void dummy_ctor(void*) { assert(false && "should not be called"); }
 void dummy_dtor(void*) { assert(false && "should not be called"); }
 

libcxxabi/test/exception_object_alignment.2.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 // This test checks that the compiler does not make incorrect assumptions
 // about the alignment of the exception (only in that specific case, of
 // course).
 //
 // There was a bug where Clang would emit a call to memset assuming a 16-byte
 // aligned exception even when back-deploying to older Darwin systems where
 // exceptions are 8-byte aligned, which caused a segfault on those systems.

libcxxabi/test/exception_object_alignment.pass.cpp

 //===---------------- exception_object_alignment.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 // Check that the pointer __cxa_allocate_exception returns is aligned to the
 // default alignment for the target architecture.
 
 #include <cassert>
 #include <cstdint>
 #include <cxxabi.h>
 #include <type_traits>

libcxxabi/test/guard_threaded_test.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03
-// UNSUPPORTED: libcxxabi-no-threads, libcxxabi-no-exceptions
+// UNSUPPORTED: libcxxabi-no-threads
+// UNSUPPORTED: no-exceptions
 
 #define TESTING_CXA_GUARD
 #include "../src/cxa_guard_impl.h"
 #include <unordered_map>
 #include <thread>
 #include <atomic>
 #include <array>
 #include <cassert>

libcxxabi/test/incomplete_type.sh.cpp

 //===------------------------- incomplete_type.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
 //
 //===----------------------------------------------------------------------===//
 // https://itanium-cxx-abi.github.io/cxx-abi/abi.html#rtti-layout
 
 // Two abi::__pbase_type_info objects can always be compared for equality
 // (i.e. of the types represented) or ordering by comparison of their name
 // NTBS addresses. In addition, unless either or both have either of the
 // incomplete flags set, equality can be tested by comparing the type_info
 // addresses.
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 // NOTE: Link libc++abi explicitly and before libc++ so that libc++ doesn't drag
 // in the system libc++abi installation on OS X. (DYLD_LIBRARY_PATH is ignored
 // for shell tests because of Apple security features).
 
 // FILE_DEPENDENCIES: %t.exe
 // RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %t.one.o
 // RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %t.two.o -DTU_ONE

libcxxabi/test/inherited_exception.pass.cpp

 //          o  a standard pointer conversion (4.10 [conv.ptr]) not involving
 //             conversions to private or protected or ambiguous classes
 //          o  a qualification conversion
 //     *  the handler is a pointer or pointer to member type and E is
 //        std::nullptr_t
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 // Clang emits  warnings about exceptions of type 'Child' being caught by
 // an earlier handler of type 'Base'. Congrats clang, you've just
 // diagnosed the behavior under test.
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wexceptions"
 #endif
 

libcxxabi/test/libcxxabi/test/config.py

def configure_obj_root(self):
         super(Configuration, self).configure_obj_root()
 
     def has_cpp_feature(self, feature, required_value):
         return intMacroValue(self.cxx.dumpMacros().get('__cpp_' + feature, '0')) >= required_value
 
     def configure_features(self):
         super(Configuration, self).configure_features()
         if not self.get_lit_bool('enable_exceptions', True):
-            self.config.available_features.add('libcxxabi-no-exceptions')
+            self.config.available_features.add('no-exceptions')
         if not self.has_cpp_feature('noexcept_function_type', 201510):
             self.config.available_features.add('libcxxabi-no-noexcept-function-type')
         if not self.get_lit_bool('llvm_unwinder', False):
             self.config.available_features.add('libcxxabi-has-system-unwinder')
 
     def configure_compile_flags(self):
         self.cxx.compile_flags += [
             '-DLIBCXXABI_NO_TIMER',

libcxxabi/test/native/arm-linux-eabi/ttype-encoding-00.pass.sh.s

 @ RUN: %{cxx} %{flags} %{link_flags} %s -o %t.exe
 @ RUN: %t.exe
-@ UNSUPPORTED: libcxxabi-no-exceptions
+@ UNSUPPORTED: no-exceptions
 
 @ PURPOSE: Check that 0x00 is a valid value for ttype encoding.  LLVM and
 @ GCC 4.6 are generating 0x00 as ttype encoding.  libc++abi should provide
 @ legacy support.
 
 @ NOTE:
 @
 @ This file is generated from the following C++ source code:

libcxxabi/test/native/arm-linux-eabi/ttype-encoding-90.pass.sh.s

 @ RUN: %{cxx} %{flags} %{link_flags} %s -o %t.exe
 @ RUN: %t.exe
-@ UNSUPPORTED: libcxxabi-no-exceptions
+@ UNSUPPORTED: no-exceptions
 
 @ PURPOSE: Check that 0x90 is a valid value for ttype encoding.
 
 @ NOTE:
 @
 @ This file is generated from the following C++ source code and then change the
 @ `TType Encoding` to 0x90.
 @

libcxxabi/test/noexception1.pass.cpp

 //===----------------------- noexception1.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03
-// REQUIRES: libcxxabi-no-exceptions
+// REQUIRES: no-exceptions
 
 #include <cxxabi.h>
 #include <exception>
 #include <cassert>
 #include <stdlib.h>
 
 // namespace __cxxabiv1 {
 //      void __cxa_increment_exception_refcount(void *thrown_object) throw();

libcxxabi/test/noexception2.pass.cpp

 //===----------------------- noexception2.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03
-// REQUIRES: libcxxabi-no-exceptions
+// REQUIRES: no-exceptions
 
 #include <cxxabi.h>
 #include <exception>
 #include <cassert>
 #include <stdlib.h>
 
 // namespace __cxxabiv1 {
 //      void __cxa_decrement_exception_refcount(void *thrown_object) throw();

libcxxabi/test/noexception3.pass.cpp

 //===----------------------- noexception3.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03
-// REQUIRES: libcxxabi-no-exceptions
+// REQUIRES: no-exceptions
 
 #include <cxxabi.h>
 #include <exception>
 #include <cassert>
 #include <stdlib.h>
 
 // namespace __cxxabiv1 {
 //      void __cxa_rethrow_primary_exception(void* thrown_object);

libcxxabi/test/noexception4.pass.cpp

 //===----------------------- noexception4.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: libcxxabi-no-exceptions
+// REQUIRES: no-exceptions
 
 #include <cxxabi.h>
 #include <exception>
 #include <cassert>
 
 // namespace __cxxabiv1 {
 //      void *__cxa_current_primary_exception() throw();
 //      extern bool          __cxa_uncaught_exception () throw();

libcxxabi/test/test_aux_runtime.pass.cpp

 //===-------------------------- test_aux_runtime.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <typeinfo>
 #include <iostream>
 
 //  Test taken from 5.2.8.2
 //  When typeid is applied to a glvalue expression whose type is a polymorphic
 //  class type, (10.3), the result refers to a std::type_info object
 //  representing the type of the most derived object (1.8) (that is, the

libcxxabi/test/test_aux_runtime_op_array_new.pass.cpp

 //===-------------------------- test_aux_runtime_op_array_new.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <iostream>
 #include <cxxabi.h>
 
 //  If the expression passed to operator new[] would result in an overflow, the
 //  allocation function is not called, and a std::bad_array_new_length exception
 //  is thrown instead (5.3.4p7).
 bool bad_array_new_length_test() {

libcxxabi/test/test_exception_address_alignment.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 // UNSUPPORTED: c++98, c++03
 
 // The system unwind.h on OS X provides an incorrectly aligned _Unwind_Exception
 // type. That causes these tests to fail. This XFAIL is my best attempt at
 // working around this failure.
 // XFAIL: darwin && libcxxabi-has-system-unwinder
 
 // Test that the address of the exception object is properly aligned as required

libcxxabi/test/test_vector2.pass.cpp

 //===--------------------------- test_vector2.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include "cxxabi.h"
 
 #include <iostream>
 #include <cstdlib>
 
 void my_terminate () { exit ( 0 ); }
 

libcxxabi/test/test_vector3.pass.cpp

 //===------------------------- test_vector3.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include "cxxabi.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
 #include <exception>
 

libcxxabi/test/uncaught_exception.pass.cpp

 //===------------------- uncaught_exceptions.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 // This tests that libc++abi still provides __cxa_uncaught_exception() for
 // ABI compatibility, even though the Standard doesn't require it to.
 
 #include <cxxabi.h>
 #include <cassert>
 
 // namespace __cxxabiv1 {

libcxxabi/test/uncaught_exceptions.pass.cpp

 //===------------------- uncaught_exceptions.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <cxxabi.h>
 #include <cassert>
 
 // namespace __cxxabiv1 {
 //      extern unsigned int __cxa_uncaught_exceptions() throw();
 // }
 

libcxxabi/test/unwind_01.pass.cpp

 //===------------------------- unwind_01.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <assert.h>
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wunreachable-code"
 #endif
 
 struct A

libcxxabi/test/unwind_02.pass.cpp

 //===------------------------- unwind_02.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 #include <assert.h>
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wunreachable-code"
 #endif
 

libcxxabi/test/unwind_03.pass.cpp

 //===------------------------- unwind_03.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wunreachable-code"

libcxxabi/test/unwind_04.pass.cpp

 //===------------------------- unwind_04.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wunreachable-code"

libcxxabi/test/unwind_05.pass.cpp

 //===------------------------- unwind_05.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wunreachable-code"

libcxxabi/test/unwind_06.pass.cpp

 //===------------------------- unwind_06.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: libcxxabi-no-exceptions
+// UNSUPPORTED: no-exceptions
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 #include <stdio.h>
 
 // Compile with -Os to get compiler uses float registers to hold float variables
 

libunwind/test/libunwind/test/config.py

def configure_obj_root(self):
         super(Configuration, self).configure_obj_root()
 
     def has_cpp_feature(self, feature, required_value):
         return int(self.cxx.dumpMacros().get('__cpp_' + feature, 0)) >= required_value
 
     def configure_features(self):
         super(Configuration, self).configure_features()
         if not self.get_lit_bool('enable_exceptions', True):
-            self.config.available_features.add('libcxxabi-no-exceptions')
+            self.config.available_features.add('no-exceptions')
         if self.get_lit_bool('arm_ehabi', False):
             self.config.available_features.add('libunwind-arm-ehabi')
 
     def configure_compile_flags(self):
         self.cxx.compile_flags += ['-DLIBUNWIND_NO_TIMER']
         if not self.get_lit_bool('enable_exceptions', True):
             self.cxx.compile_flags += ['-fno-exceptions', '-DLIBUNWIND_HAS_NO_EXCEPTIONS']
         # Stack unwinding tests need unwinding tables and these are not