[SystemZ][z/OS][libcxx] mark aligned allocation tests UNSUPPORTED on z/OS

[DanielMcIntosh-IBM]

Summary

zOS doesn't support aligned allocation, so these tests are failing.
For more details on aligned allocation in zOS, see
https://reviews.llvm.org/D87611 and https://reviews.llvm.org/D90178

[DanielMcIntosh-IBM]

Ping

[ldionne]

libcxx/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp

20

What is the -zos Lit feature? Is this using Lit's partial matching of triples?

This looks incorrect to me, since you only want to mark this as XFAIL when running against your system library (well, that or libc++ when configured as-if it were your system library).

[zibi]

libcxx/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp

20

Daniel, I think we want to use target-zos. You might want to wait until this is available upstream.

[DanielMcIntosh-IBM]

Update to address Louis's comments.

As per Zibi's comments, this PR depends on other changes that aren't yet
submitted for review. I will update again once those changes have been merged.

[DanielMcIntosh-IBM]

Updating with related changes instead of creating new PRs

Specifically, the downstream change this PR depended on was too small to warrant it's
own PR, and there were also a couple more align_val_t tests we'd disabled downstream

The changes still fit within the original PR description, so there's no need to update that

[ldionne]

LGTM, but just out of curiosity, will this stay unsupported forever, or will this be implemented eventually?

Normally, we try to support things unless we have a fundamental reason why it can't be done (for example supporting exceptions on an embedded system). But it seems a bit strange to me to mark aligned allocation function tests as unsupported based on the *architecture* - instead I would have expected it to be marked as unsupported based on specific OS versions that do not implement the feature yet.

[SeanP]

In D102798#2825509, @ldionne wrote:

LGTM, but just out of curiosity, will this stay unsupported forever, or will this be implemented eventually?

Normally, we try to support things unless we have a fundamental reason why it can't be done (for example supporting exceptions on an embedded system). But it seems a bit strange to me to mark aligned allocation function tests as unsupported based on the *architecture* - instead I would have expected it to be marked as unsupported based on specific OS versions that do not implement the feature yet.

As of today z/OS does not support aligned allocation. Once it is supported we will be able to say it is only supported in z/OS X.Y and above. The tag "s390-zos" is more than an architecture tag. It is more of an OS tag. We have zLinux on s390 as well. The s390-zos tag only covers z/OS, not zLinux. We can change that name if it helps clarify some confusion.

[DanielMcIntosh-IBM]

In D102798#2827705, @SeanP wrote:

In D102798#2825509, @ldionne wrote:

LGTM, but just out of curiosity, will this stay unsupported forever, or will this be implemented eventually?

Normally, we try to support things unless we have a fundamental reason why it can't be done (for example supporting exceptions on an embedded system). But it seems a bit strange to me to mark aligned allocation function tests as unsupported based on the *architecture* - instead I would have expected it to be marked as unsupported based on specific OS versions that do not implement the feature yet.

As of today z/OS does not support aligned allocation. Once it is supported we will be able to say it is only supported in z/OS X.Y and above. The tag "s390-zos" is more than an architecture tag. It is more of an OS tag. We have zLinux on s390 as well. The s390-zos tag only covers z/OS, not zLinux. We can change that name if it helps clarify some confusion.

I think better than changing the name is changing both the name and regular expression - instead of matching zos on the s390 architecture (and variants), just match zos, regardless of architecture. @ldionne Hopefully you can give some insight as to what is most clear for those not familiar with z/OS

[DanielMcIntosh-IBM]

Update PR based on internal discussions about whether to match targets based on
just zos or both s390 and zos.

Also update the way we specify UNSUPPORTED now that Lit supports regular
expressions inside UNSUPPORTED. Similar to the changes in commit
c360553c15a8e5aa94d2236eb73e7dfeab9543e5.

[ldionne]

As of today z/OS does not support aligned allocation. Once it is supported we will be able to say it is only supported in z/OS X.Y and above. The tag "s390-zos" is more than an architecture tag. It is more of an OS tag. We have zLinux on s390 as well. The s390-zos tag only covers z/OS, not zLinux. We can change that name if it helps clarify some confusion.

Thanks for the explanation. I think the approach taken here with the regular expression is by far the cleanest. Thanks.

libcxx/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp

 // Libc++ defers to the underlying MSVC library to provide the new/delete
 // definitions, which does not yet provide aligned allocation
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
 // The dylibs shipped before macosx10.13 do not contain the aligned allocation
 // functions, so trying to force using those with -faligned-allocation results
 // in a link error.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}}
 
+// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // AppleClang < 10 incorrectly warns that aligned allocation is not supported
 // even when it is supported.
 // UNSUPPORTED: apple-clang-9
 
 // XFAIL: sanitizer-new-delete, ubsan
 
 // GCC doesn't support the aligned-allocation flags.
 // XFAIL: gcc

libcxx/test/libcxx/language.support/support.dynamic/new_faligned_allocation.pass.cpp

 // definitions, which does not yet provide aligned allocation
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
 // The dylibs shipped before macosx10.13 do not contain the aligned allocation
 // functions, so trying to force using those with -faligned-allocation results
 // in a link error.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}}
 
+// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
 #include <new>
 #include <typeinfo>
 #include <string>
 #include <cassert>
 

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

 // UNSUPPORTED: clang-5, clang-6, clang-7
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
 // On Windows libc++ doesn't provide its own definitions for new/delete
 // but instead depends on the ones in VCRuntime. However VCRuntime does not
 // yet provide aligned new/delete definitions so this test fails to compile/link.
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
+// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 
 #include "test_macros.h"
 
 constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;

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

 
 // Aligned allocation was not provided before macosx10.14 and as a result we
 // get availability errors when the deployment target is older than macosx10.14.
 // However, support for that was broken prior to Clang 8 and AppleClang 11.
 // UNSUPPORTED: apple-clang-9, apple-clang-10
 // UNSUPPORTED: clang-5, clang-6, clang-7
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
+// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // test operator new
 
 #include <new>
 #include <cstddef>
 #include <cassert>
 #include <cstdint>
 #include <limits>
 

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

 
 // Aligned allocation was not provided before macosx10.14 and as a result we
 // get availability errors when the deployment target is older than macosx10.14.
 // However, support for that was broken prior to Clang 8 and AppleClang 11.
 // UNSUPPORTED: apple-clang-9, apple-clang-10
 // UNSUPPORTED: clang-5, clang-6, clang-7
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
+// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // test operator new (nothrow)
 
 #include <new>
 #include <cstddef>
 #include <cstdint>
 #include <cassert>
 #include <limits>
 

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

 
 // Aligned allocation was not provided before macosx10.14 and as a result we
 // get availability errors when the deployment target is older than macosx10.14.
 // However, support for that was broken prior to Clang 8 and AppleClang 11.
 // UNSUPPORTED: apple-clang-9, apple-clang-10
 // UNSUPPORTED: clang-5, clang-6, clang-7
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
+// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // test operator new nothrow by replacing only operator new
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 #include <limits>
 

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.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, c++11, c++14
 // UNSUPPORTED: sanitizer-new-delete
 
+// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // test operator new replacement
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cstdint>
 #include <cassert>
 #include <limits>

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

 // UNSUPPORTED: clang-5, clang-6, clang-7
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
 // On Windows libc++ doesn't provide its own definitions for new/delete
 // but instead depends on the ones in VCRuntime. However VCRuntime does not
 // yet provide aligned new/delete definitions so this test fails to compile/link.
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
+// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 
 #include "test_macros.h"
 
 constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;

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

 // However, support for that was broken prior to Clang 8 and AppleClang 11.
 // UNSUPPORTED: apple-clang-9, apple-clang-10
 // UNSUPPORTED: clang-5, clang-6, clang-7
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
 // asan and msan will not call the new handler.
 // UNSUPPORTED: sanitizer-new-delete
 
+// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // test operator new
 
 #include <new>
 #include <cstddef>
 #include <cassert>
 #include <cstdint>
 #include <limits>
 

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

 // However, support for that was broken prior to Clang 8 and AppleClang 11.
 // UNSUPPORTED: apple-clang-9, apple-clang-10
 // UNSUPPORTED: clang-5, clang-6, clang-7
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
 // asan and msan will not call the new handler.
 // UNSUPPORTED: sanitizer-new-delete
 
+// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // test operator new (nothrow)
 
 #include <new>
 #include <cstddef>
 #include <cstdint>
 #include <cassert>
 #include <limits>
 

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

 
 // Aligned allocation was not provided before macosx10.14 and as a result we
 // get availability errors when the deployment target is older than macosx10.14.
 // However, support for that was broken prior to Clang 8 and AppleClang 11.
 // UNSUPPORTED: apple-clang-9, apple-clang-10
 // UNSUPPORTED: clang-5, clang-6, clang-7
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 
+// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // test operator new nothrow by replacing only operator new
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 #include <limits>
 

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.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, c++11, c++14
 // UNSUPPORTED: sanitizer-new-delete
 
+// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
 // test operator new replacement
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cstdint>
 #include <cassert>
 #include <limits>