db8c7e004a
We were not making any distinction between e.g. the "Apple-flavored" libc++ built from trunk and the system-provided standard library on Apple platforms. For example, any test that would be XFAILed on a back-deployment target would unexpectedly pass when run on that deployment target against the tip of trunk Apple-flavored libc++. In reality, that test would be expected to pass because we're running against the latest libc++, even if it is Apple-flavored. To solve this issue, we introduce a new feature that describes whether the Standard Library in use is the one provided by the system by default, and that notion is different from the underlying standard library flavor. We also refactor the existing Lit features to make a distinction between availability markup and the library we're running against at runtime, which otherwise limit the flexibility of what we can express in the test suite. Finally, we refactor some of the back-deployment versions that were incorrect (such as thinking that LLVM 10 was introduced in macOS 11, when in reality macOS 11 was synced with LLVM 11). Fixes #82107
126 lines
3.8 KiB
C++
126 lines
3.8 KiB
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: no-exceptions
|
|
|
|
// PR41395 isn't fixed until the dylib shipped with macOS 10.15
|
|
// XFAIL: stdlib=system && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}}
|
|
|
|
#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"); }
|
|
|
|
void *dummy_alloc(size_t) { assert(false && "should not be called"); return nullptr; }
|
|
void dummy_dealloc(void*) { assert(false && "should not be called"); }
|
|
void dummy_dealloc_sized(void*, size_t) { assert(false && "should not be called"); }
|
|
|
|
|
|
bool check_mul_overflows(size_t x, size_t y) {
|
|
size_t tmp = x * y;
|
|
if (tmp / x != y)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool check_add_overflows(size_t x, size_t y) {
|
|
size_t tmp = x + y;
|
|
if (tmp < x)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
void test_overflow_in_multiplication() {
|
|
const size_t elem_count = std::size_t(1) << (sizeof(std::size_t) * 8 - 2);
|
|
const size_t elem_size = 8;
|
|
const size_t padding = 0;
|
|
assert(check_mul_overflows(elem_count, elem_size));
|
|
|
|
try {
|
|
__cxxabiv1::__cxa_vec_new(elem_count, elem_size, padding, dummy_ctor,
|
|
dummy_dtor);
|
|
assert(false && "allocation should fail");
|
|
} catch (std::bad_array_new_length const&) {
|
|
// OK
|
|
} catch (...) {
|
|
assert(false && "unexpected exception");
|
|
}
|
|
|
|
try {
|
|
__cxxabiv1::__cxa_vec_new2(elem_count, elem_size, padding, dummy_ctor,
|
|
dummy_dtor, &dummy_alloc, &dummy_dealloc);
|
|
assert(false && "allocation should fail");
|
|
} catch (std::bad_array_new_length const&) {
|
|
// OK
|
|
} catch (...) {
|
|
assert(false && "unexpected exception");
|
|
}
|
|
|
|
try {
|
|
__cxxabiv1::__cxa_vec_new3(elem_count, elem_size, padding, dummy_ctor,
|
|
dummy_dtor, &dummy_alloc, &dummy_dealloc_sized);
|
|
assert(false && "allocation should fail");
|
|
} catch (std::bad_array_new_length const&) {
|
|
// OK
|
|
} catch (...) {
|
|
assert(false && "unexpected exception");
|
|
}
|
|
}
|
|
|
|
void test_overflow_in_addition() {
|
|
const size_t elem_size = 4;
|
|
const size_t elem_count = static_cast<size_t>(-1) / 4u;
|
|
#if defined(_LIBCXXABI_ARM_EHABI)
|
|
const size_t padding = 8;
|
|
#else
|
|
const size_t padding = sizeof(std::size_t);
|
|
#endif
|
|
assert(!check_mul_overflows(elem_count, elem_size));
|
|
assert(check_add_overflows(elem_count * elem_size, padding));
|
|
try {
|
|
__cxxabiv1::__cxa_vec_new(elem_count, elem_size, padding, dummy_ctor,
|
|
dummy_dtor);
|
|
assert(false && "allocation should fail");
|
|
} catch (std::bad_array_new_length const&) {
|
|
// OK
|
|
} catch (...) {
|
|
assert(false && "unexpected exception");
|
|
}
|
|
|
|
|
|
try {
|
|
__cxxabiv1::__cxa_vec_new2(elem_count, elem_size, padding, dummy_ctor,
|
|
dummy_dtor, &dummy_alloc, &dummy_dealloc);
|
|
assert(false && "allocation should fail");
|
|
} catch (std::bad_array_new_length const&) {
|
|
// OK
|
|
} catch (...) {
|
|
assert(false && "unexpected exception");
|
|
}
|
|
|
|
try {
|
|
__cxxabiv1::__cxa_vec_new3(elem_count, elem_size, padding, dummy_ctor,
|
|
dummy_dtor, &dummy_alloc, &dummy_dealloc_sized);
|
|
assert(false && "allocation should fail");
|
|
} catch (std::bad_array_new_length const&) {
|
|
// OK
|
|
} catch (...) {
|
|
assert(false && "unexpected exception");
|
|
}
|
|
}
|
|
|
|
int main(int, char**) {
|
|
test_overflow_in_multiplication();
|
|
test_overflow_in_addition();
|
|
|
|
return 0;
|
|
}
|