[SystemZ][z/OS][libcxx] Mark tests that require runtime linking as unsupported on z/OS

[DanielMcIntosh-IBM]

Summary

z/OS doesn't currently have runtime linking, so a call to new or delete won't
invoke any user-defined new or delete operators unless the operator is visible
when the call is processed by the linker. Notably, if a call to new or delete
is compiled as part of a shared library, it is impossible for an application to
change which definition that call invokes. This includes calls compiled as part
of the standard library.

Many tests rely on user-defined new and delete operators to count allocations.
Any such tests will not work on z/OS.

[mstorsjo]

Notably, if a call to new or delete is compiled as part of a shared library, it is impossible for an application to change which definition that call invokes. This includes calls compiled as part of the standard library.

Many tests rely on user-defined new and delete operators to count allocations. Any such tests will not work on z/OS.

FWIW, Windows also has this same situation (where operator new/delete in the executable can't override operator new/delete in the already linked libc++ DLL).

But opting out of the whole tests is a bit overkill IMO. For the Windows/DLL situation, we have finegrained macros that omit exactly those checks of the tests while keeping the rest of the tests running. I think it would be much better to generalize those existing macros to something platform independent.

libcxx/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp

48

Here's an example on how this aspect only is waived in the Windows/DLL configuration.

[mstorsjo]

(Also, for the topic of "naming things", I'd say "runtime linking" is a bit vague here - runtime symbol interposition/overriding or something like that is probably more precise?)

[ldionne]

I agree with @mstorsjo 's suggestions. Can you try to make this platform-independent?

[• Quuxplusone]

libcxx/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp

48

Perhaps the macro's sense could be flipped, something like

ASSERT_VIA_OVERRIDDEN_NEW(globalMemCounter.checkDeleteArrayCalledEq(1));

similar to our existing ASSERT_NOEXCEPT and ASSERT_SAME_TYPE testing macros. Then, on platforms that support overridden new and delete operators, that macro would expand to assert; and on other platforms (Win32, z/OS) it would expand to a no-op.

[DanielMcIntosh-IBM]

Given the nature of these changes, they're fairly low priority for us to get upstream right now, but I will come back to these at a later date to address the comments and get this into a state where it is suitable to merge

libcxx/test/std/input.output/filesystems/class.path/path.member/path.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++03
 
+// z/OS doesn't currently have runtime linking. This prevents calls to new and
+// delete in the standard library (like the one caused by the allocation in the
+// string constructor) from invoking user-defined versions of those operators
+// (like the ones in count_new.h). Thus, globalMemCounter doesn't see the
+// new we expect it to.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // <filesystem>
 
 // class path
 
 // path& operator=(path&&) noexcept
 
 #include "filesystem_include.h"
 #include <type_traits>

libcxx/test/std/input.output/filesystems/class.path/path.member/path.concat.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++03
 
 // These tests require locale for non-char paths
 // UNSUPPORTED: libcpp-has-no-localization
 
+// z/OS doesn't currently have runtime linking. This prevents calls to new and
+// delete in the standard library (like the one during path concatenation
+// caused by basic_string::__grow_by_and_replace) from invoking user-defined
+// versions of those operators (like the ones in count_new.h). Thus,
+// RequireAllocationGuard doesn't see the new we expect it to.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // <filesystem>
 
 // class path
 
 // path& operator+=(const path& x);
 // path& operator+=(const string_type& x);
 // path& operator+=(string_view x);
 // path& operator+=(const value_type* x);

libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/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++03
 
+// z/OS doesn't currently have runtime linking. This prevents calls to new and
+// delete in the standard library (like the one caused by the allocation in the
+// string constructor) from invoking user-defined versions of those operators
+// (like the ones in count_new.h). Thus, globalMemCounter doesn't see the
+// new we expect it to.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // <filesystem>
 
 // class path
 
 // path(path&&) noexcept
 
 #include "filesystem_include.h"
 #include <type_traits>

libcxx/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/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
 //
 //===----------------------------------------------------------------------===//
 
+// z/OS doesn't currently have runtime linking. This prevents calls to new and
+// delete in the standard library (like the one in ctype<char>::~ctype) from
+// invoking user-defined versions of those operators (like the ones in
+// count_new.h). Thus, globalMemCounter doesn't see the delete[] it's expecting.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // <locale>
 
 // template <> class ctype<char>
 
 // ~ctype();
 
 #include <locale>
 #include <cassert>
int main(int, char**)
     assert(globalMemCounter.checkDeleteArrayCalledEq(0));
     {
         std::locale l(std::locale::classic(),
             new std::ctype<char>(new std::ctype<char>::mask[256], true));
         assert(globalMemCounter.checkDeleteArrayCalledEq(0));
     }
     // On windows, the operator new from count_new.h can't override the default
     // operator for calls within the libc++ DLL.
     TEST_NOT_WIN32_DLL(assert(globalMemCounter.checkDeleteArrayCalledEq(1)));
 
   return 0;
 }

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.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-has-no-threads
 
+// z/OS doesn't currently have runtime linking. This prevents calls to new and
+// delete in the standard library (like the one caused by the argument copy in
+// the thread constructor) from invoking user-defined versions of those
+// operators.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // <thread>
 
 // class thread
 
 // template <class F, class ...Args> thread(F&& f, Args&&... args);
 
 // UNSUPPORTED: sanitizer-new-delete