[libc++] Add a job running GCC with C++11

[ldionne]

Summary

This configuration is interesting because GCC has a different level of
strictness for some C++ rules. In particular, it implements the older
standards more stringently than Clang, which can help find places where
we are non-conforming (especially in the test suite).

[ldionne]

Try to workaround some failures

[ldionne]

Hopefully fix the remaining errors

[ldionne]

Fix libc++abi failures

[ldionne]

Rebase onto main -- the libc++abi failures should be fixed

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp

 
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     typedef std::atomic<T> A;
-    A t = T();
-    bool b1 = std::atomic_is_lock_free(static_cast<const A*>(&t));
-    volatile A vt = T();
-    bool b2 = std::atomic_is_lock_free(static_cast<const volatile A*>(&vt));
+    T t = T();
+    A a(t);
+    bool b1 = std::atomic_is_lock_free(static_cast<const A*>(&a));
+    volatile A va(t);
+    bool b2 = std::atomic_is_lock_free(static_cast<const volatile A*>(&va));
     assert(b1 == b2);
   }
 };
 
 struct A {
   char x[4];
 };
 
 int main(int, char**) {
   TestFn<A>()();
   TestEachAtomicType<TestFn>()();
   return 0;
 }

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/A.h

 class A
 {
     int id_;
 public:
     explicit A(int id) : id_(id) {++count;}
     A(const A& a) : id_(a.id_) {++count;}
     ~A() {assert(id_ >= 0); id_ = -1; --count;}
 
+    A& operator=(const A& other) { id_ = other.id_; return *this; }
+
     int id() const {return id_;}
 
     static int count;
 };
 
 int A::count = 0;
 
 #endif // A_H

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/AB.h

 class A
 {
     int id_;
 public:
     explicit A(int id) : id_(id) {++count;}
     A(const A& a) : id_(a.id_) {++count;}
     virtual ~A() {assert(id_ >= 0); id_ = -1; --count;}
 
+    A& operator=(const A& other) { id_ = other.id_; return *this; }
+
     static int count;
 };
 
 int A::count = 0;
 
 class B
     : public A
 {

libcxx/test/std/input.output/file.streams/c.files/cstdio.pass.cpp

#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     static_assert((std::is_same<decltype(std::rename("","")), int>::value), "");
     static_assert((std::is_same<decltype(std::tmpfile()), std::FILE*>::value), "");
     static_assert((std::is_same<decltype(std::tmpnam(cp)), char*>::value), "");
 #endif
 
 #ifndef _LIBCPP_HAS_NO_STDIN
     static_assert((std::is_same<decltype(std::getchar()), int>::value), "");
 #if TEST_STD_VER <= 11
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wdeprecated-declarations" // disable the warning from the C library
     static_assert((std::is_same<decltype(std::gets(cp)), char*>::value), "");
+#   pragma GCC diagnostic pop
 #endif
     static_assert((std::is_same<decltype(std::scanf(" ")), int>::value), "");
     static_assert((std::is_same<decltype(std::vscanf(" ",va)), int>::value), "");
 #endif
 
 #ifndef _LIBCPP_HAS_NO_STDOUT
     static_assert((std::is_same<decltype(std::printf(" ")), int>::value), "");
     static_assert((std::is_same<decltype(std::putchar(0)), int>::value), "");
     static_assert((std::is_same<decltype(std::puts("")), int>::value), "");
     static_assert((std::is_same<decltype(std::vprintf(" ",va)), int>::value), "");
 #endif
 
   return 0;
 }

libcxx/test/std/strings/string.view/string.view.ops/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
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: gcc-10, gcc-11
-//     GCC's __builtin_strlen isn't constexpr yet
+// GCC's __builtin_strlen isn't constexpr yet
+// XFAIL: (gcc-10 || gcc-11) && !(c++11 || c++14 || c++17)
 // UNSUPPORTED: LIBCXX-DEBUG-FIXME
 
 // <string_view>
 
 // size_type copy(charT* s, size_type n, size_type pos = 0) const;
 
 // Throws: out_of_range if pos > size().
 // Remarks: Let rlen be the smaller of n and size() - pos.

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp

struct A {
   virtual ~A() { --count; }
 };
 
 int A::count = 0;
 
 struct B : public A {
   static int count;
   B() { ++count; }
-  B(const B&) { ++count; }
+  B(const B& b) : A(b) { ++count; }
   virtual ~B() { --count; }
 };
 
 int B::count = 0;
 
 struct C {};
 
 struct Deleter {

libcxx/test/support/test_macros.h

 #   endif
 # define TEST_ALIGNAS(...) __attribute__((__aligned__(__VA_ARGS__)))
 # define TEST_CONSTEXPR
 # define TEST_NOEXCEPT throw()
 # define TEST_NOEXCEPT_FALSE
 # define TEST_NOEXCEPT_COND(...)
 #endif
 
-#if TEST_STD_VER >= 17
+#if TEST_STD_VER >= 11
 # define TEST_THROW_SPEC(...)
 #else
 # define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
 #endif
 
 #if TEST_STD_VER >= 14
 # define TEST_CONSTEXPR_CXX14 constexpr
 #else

libcxx/utils/ci/buildkite-pipeline.yml

- label: "C++03"
     agents:
       queue: "libcxx-builders"
       os: "linux"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
 
-  - label: "GCC 11"
+  - label: "GCC 11 / C++latest"
     command: "libcxx/utils/ci/run-buildbot generic-gcc"
     artifact_paths:
       - "**/test-results.xml"
     agents:
       queue: "libcxx-builders"
       os: "linux"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
 
   #
   # All other supported configurations of libc++.
   #
   - wait
 
+  - label: "GCC 11 / C++11"
+    command: "libcxx/utils/ci/run-buildbot generic-gcc-cxx11"
+    artifact_paths:
+      - "**/test-results.xml"
+    agents:
+      queue: "libcxx-builders"
+      os: "linux"
+    retry:
+      automatic:
+        - exit_status: -1  # Agent was lost
+          limit: 2
+
   - label: "Clang 11"
     command: "libcxx/utils/ci/run-buildbot generic-clang-11"
     artifact_paths:
       - "**/test-results.xml"
     agents:
       queue: "libcxx-builders"
       os: "linux"
     retry:

libcxx/utils/ci/run-buildbot

 ;;
 generic-gcc)
     export CC=gcc-11
     export CXX=g++-11
     clean
     generate-cmake
     check-cxx-cxxabi
 ;;
+generic-gcc-cxx11)
+    export CC=gcc-11
+    export CXX=g++-11
+    clean
+    generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-cxx11.cmake"
+    check-cxx-cxxabi
+;;
 generic-asan)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-asan.cmake"
     check-cxx-cxxabi
 ;;
 generic-msan)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-msan.cmake"

libcxx/utils/libcxx/test/features.py

DEFAULT_FEATURES = [
   Feature(name='fdelayed-template-parsing',     when=lambda cfg: hasCompileFlag(cfg, '-fdelayed-template-parsing')),
   Feature(name='libcpp-no-if-constexpr',        when=lambda cfg: '__cpp_if_constexpr' not in featureTestMacros(cfg)),
   Feature(name='libcpp-no-structured-bindings', when=lambda cfg: '__cpp_structured_bindings' not in featureTestMacros(cfg)),
   Feature(name='libcpp-no-deduction-guides',    when=lambda cfg: featureTestMacros(cfg).get('__cpp_deduction_guides', 0) < 201611),
   Feature(name='libcpp-no-concepts',            when=lambda cfg: featureTestMacros(cfg).get('__cpp_concepts', 0) < 201907),
   Feature(name='has-fobjc-arc',                 when=lambda cfg: hasCompileFlag(cfg, '-xobjective-c++ -fobjc-arc') and
                                                                  sys.platform.lower().strip() == 'darwin'), # TODO: this doesn't handle cross-compiling to Apple platforms.
   Feature(name='objective-c++',                 when=lambda cfg: hasCompileFlag(cfg, '-xobjective-c++ -fobjc-arc')),
+  Feature(name='no-noexcept-function-type',     when=lambda cfg: featureTestMacros(cfg).get('__cpp_noexcept_function_type', 0) < 201510),
 
   Feature(name='non-lockfree-atomics',
           when=lambda cfg: sourceBuilds(cfg, """
             #include <atomic>
             struct Large { int storage[100]; };
             std::atomic<Large> x;
             int main(int, char**) { (void)x.load(); return 0; }
           """)),

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: no-exceptions, libcxxabi-no-noexcept-function-type
+// UNSUPPORTED: no-exceptions, 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_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: no-exceptions, libcxxabi-no-noexcept-function-type
+// UNSUPPORTED: no-exceptions, 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, gcc-11
 
 #include <cassert>
 
 struct X {

libcxxabi/test/libcxxabi/test/config.py

def configure_src_root(self):
         self.libcxx_src_root = self.get_lit_conf(
             'libcxx_src_root',
             os.path.join(self.libcxxabi_src_root, '/../libcxx'))
 
     def configure_obj_root(self):
         self.libcxxabi_obj_root = self.get_lit_conf('libcxxabi_obj_root')
         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.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',
             '-D_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS',
         ]

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: no-exceptions
 // REQUIRES: c++03 || c++11 || c++14
 
 #include <assert.h>
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wunreachable-code"
+#pragma GCC diagnostic ignored "-Wdeprecated" // dynamic exception specifications are deprecated
 #endif
 
 struct A
 {
     static int count;
     int id_;
     A() : id_(++count) {}
     ~A() {assert(id_ == count--);}

libcxxabi/test/unwind_03.pass.cpp

 // REQUIRES: c++03 || c++11 || c++14
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wunreachable-code"
+#pragma GCC diagnostic ignored "-Wdeprecated" // dynamic exception specifications are deprecated
 #endif
 
 struct A
 {
     static int count;
     int id_;
     A() : id_(++count) {}
     ~A() {assert(id_ == count--);}

libcxxabi/test/unwind_04.pass.cpp

 // REQUIRES: c++03 || c++11 || c++14
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wunreachable-code"
+#pragma GCC diagnostic ignored "-Wdeprecated" // dynamic exception specifications are deprecated
 #endif
 
 struct A
 {
     static int count;
     int id_;
     A() : id_(++count) {}
     ~A() {assert(id_ == count--);}

libcxxabi/test/unwind_05.pass.cpp

 // REQUIRES: c++03 || c++11 || c++14
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wunreachable-code"
+#pragma GCC diagnostic ignored "-Wdeprecated" // dynamic exception specifications are deprecated
 #endif
 
 struct A
 {
     static int count;
     int id_;
     A() : id_(++count) {}
     ~A() {assert(id_ == count--);}