llvm-project

1
//===----------------------------------------------------------------------===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8

9
// UNSUPPORTED: no-exceptions
10

11
// This test requires the fix in http://llvm.org/PR41395 (c4225e124f9e).
12
// XFAIL: using-built-library-before-llvm-9
13

14
#include "cxxabi.h"
15
#include <new>
16
#include <cassert>
17

18
void dummy_ctor(void*) { assert(false && "should not be called"); }
19
void dummy_dtor(void*) { assert(false && "should not be called"); }
20

21
void *dummy_alloc(size_t) { assert(false && "should not be called"); return nullptr; }
22
void dummy_dealloc(void*) { assert(false && "should not be called"); }
23
void dummy_dealloc_sized(void*, size_t) { assert(false && "should not be called"); }
24

25

26
bool check_mul_overflows(size_t x, size_t y) {
27
  size_t tmp = x * y;
28
  if (tmp / x != y)
29
    return true;
30
  return false;
31
}
32

33
bool check_add_overflows(size_t x, size_t y) {
34
  size_t tmp = x + y;
35
  if (tmp < x)
36
    return true;
37

38
  return false;
39
}
40

41
void test_overflow_in_multiplication() {
42
  const size_t elem_count = std::size_t(1) << (sizeof(std::size_t) * 8 - 2);
43
  const size_t elem_size = 8;
44
  const size_t padding = 0;
45
  assert(check_mul_overflows(elem_count, elem_size));
46

47
  try {
48
    __cxxabiv1::__cxa_vec_new(elem_count, elem_size, padding, dummy_ctor,
49
                              dummy_dtor);
50
    assert(false && "allocation should fail");
51
  } catch (std::bad_array_new_length const&) {
52
    // OK
53
  } catch (...) {
54
    assert(false && "unexpected exception");
55
  }
56

57
  try {
58
    __cxxabiv1::__cxa_vec_new2(elem_count, elem_size, padding, dummy_ctor,
59
                              dummy_dtor, &dummy_alloc, &dummy_dealloc);
60
    assert(false && "allocation should fail");
61
  } catch (std::bad_array_new_length const&) {
62
    // OK
63
  } catch (...) {
64
    assert(false && "unexpected exception");
65
  }
66

67
  try {
68
    __cxxabiv1::__cxa_vec_new3(elem_count, elem_size, padding, dummy_ctor,
69
                               dummy_dtor, &dummy_alloc, &dummy_dealloc_sized);
70
    assert(false && "allocation should fail");
71
  } catch (std::bad_array_new_length const&) {
72
    // OK
73
  } catch (...) {
74
    assert(false && "unexpected exception");
75
  }
76
}
77

78
void test_overflow_in_addition() {
79
  const size_t elem_size = 4;
80
  const size_t elem_count = static_cast<size_t>(-1) / 4u;
81
#if defined(_LIBCXXABI_ARM_EHABI)
82
  const size_t padding = 8;
83
#else
84
  const size_t padding = sizeof(std::size_t);
85
#endif
86
  assert(!check_mul_overflows(elem_count, elem_size));
87
  assert(check_add_overflows(elem_count * elem_size, padding));
88
  try {
89
    __cxxabiv1::__cxa_vec_new(elem_count, elem_size, padding, dummy_ctor,
90
                              dummy_dtor);
91
    assert(false && "allocation should fail");
92
  } catch (std::bad_array_new_length const&) {
93
    // OK
94
  } catch (...) {
95
    assert(false && "unexpected exception");
96
  }
97

98

99
  try {
100
    __cxxabiv1::__cxa_vec_new2(elem_count, elem_size, padding, dummy_ctor,
101
                               dummy_dtor, &dummy_alloc, &dummy_dealloc);
102
    assert(false && "allocation should fail");
103
  } catch (std::bad_array_new_length const&) {
104
    // OK
105
  } catch (...) {
106
    assert(false && "unexpected exception");
107
  }
108

109
  try {
110
    __cxxabiv1::__cxa_vec_new3(elem_count, elem_size, padding, dummy_ctor,
111
                               dummy_dtor, &dummy_alloc, &dummy_dealloc_sized);
112
    assert(false && "allocation should fail");
113
  } catch (std::bad_array_new_length const&) {
114
    // OK
115
  } catch (...) {
116
    assert(false && "unexpected exception");
117
  }
118
}
119

120
int main(int, char**) {
121
  test_overflow_in_multiplication();
122
  test_overflow_in_addition();
123

124
  return 0;
125
}
126