[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"

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