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
#include "cxxabi.h"
10

11
#include <cassert>
12
#include <cstdio>
13
#include <cstdlib>
14

15
#include "test_macros.h"
16

17
//  Wrapper routines
18
void *my_alloc2 ( size_t sz ) {
19
    void *p = std::malloc ( sz );
20
//  std::printf ( "Allocated %ld bytes at %lx\n", sz, (unsigned long) p );
21
    return p;
22
}
23

24
void my_dealloc2 ( void *p ) {
25
//  std::printf ( "Freeing %lx\n", (unsigned long) p );
26
    std::free ( p );
27
}
28

29
void my_dealloc3 ( void *p, size_t ) {
30
//  std::printf ( "Freeing %lx (size %ld)\n", (unsigned long) p, sz );
31
    std::free ( p );
32
}
33

34
void my_construct ( void * ) {
35
//  std::printf ( "Constructing %lx\n", (unsigned long) p );
36
}
37

38
void my_destruct  ( void * ) {
39
//  std::printf ( "Destructing  %lx\n", (unsigned long) p );
40
}
41

42
int gCounter;
43
void count_construct ( void * ) { ++gCounter; }
44
void count_destruct  ( void * ) { --gCounter; }
45

46

47
int gConstructorCounter;
48
int gConstructorThrowTarget;
49
int gDestructorCounter;
50
int gDestructorThrowTarget;
51
void throw_construct ( void * ) {
52
#ifndef TEST_HAS_NO_EXCEPTIONS
53
    if ( gConstructorCounter   == gConstructorThrowTarget )
54
        throw 1;
55
    ++gConstructorCounter;
56
#endif
57
}
58
void throw_destruct  ( void * ) {
59
#ifndef TEST_HAS_NO_EXCEPTIONS
60
    if ( ++gDestructorCounter  == gDestructorThrowTarget  )
61
        throw 2;
62
#endif
63
}
64

65
#if __cplusplus >= 201103L
66
#   define CAN_THROW noexcept(false)
67
#else
68
#   define CAN_THROW
69
#endif
70

71
struct vec_on_stack {
72
    void *storage;
73
    vec_on_stack () : storage ( __cxxabiv1::__cxa_vec_new    (            10, 40, 8, throw_construct, throw_destruct )) {}
74
    ~vec_on_stack () CAN_THROW {__cxxabiv1::__cxa_vec_delete ( storage,       40, 8,                  throw_destruct );  }
75
};
76

77
//  Test calls with empty constructors and destructors
78
int test_empty ( ) {
79
    void *one, *two, *three;
80

81
//  Try with no padding and no con/destructors
82
    one     = __cxxabiv1::__cxa_vec_new ( 10, 40, 0, NULL, NULL );
83
    two     = __cxxabiv1::__cxa_vec_new2( 10, 40, 0, NULL, NULL, my_alloc2, my_dealloc2 );
84
    three   = __cxxabiv1::__cxa_vec_new3( 10, 40, 0, NULL, NULL, my_alloc2, my_dealloc3 );
85

86
    __cxxabiv1::__cxa_vec_delete ( one,       40, 0, NULL );
87
    __cxxabiv1::__cxa_vec_delete2( two,       40, 0, NULL, my_dealloc2 );
88
    __cxxabiv1::__cxa_vec_delete3( three,     40, 0, NULL, my_dealloc3 );
89

90
//  Try with no padding
91
    one     = __cxxabiv1::__cxa_vec_new ( 10, 40, 0, my_construct, my_destruct );
92
    two     = __cxxabiv1::__cxa_vec_new2( 10, 40, 0, my_construct, my_destruct, my_alloc2, my_dealloc2 );
93
    three   = __cxxabiv1::__cxa_vec_new3( 10, 40, 0, my_construct, my_destruct, my_alloc2, my_dealloc3 );
94

95
    __cxxabiv1::__cxa_vec_delete ( one,       40, 0, my_destruct );
96
    __cxxabiv1::__cxa_vec_delete2( two,       40, 0, my_destruct, my_dealloc2 );
97
    __cxxabiv1::__cxa_vec_delete3( three,     40, 0, my_destruct, my_dealloc3 );
98

99
//  Padding and no con/destructors
100
    one     = __cxxabiv1::__cxa_vec_new ( 10, 40, 8, NULL, NULL );
101
    two     = __cxxabiv1::__cxa_vec_new2( 10, 40, 8, NULL, NULL, my_alloc2, my_dealloc2 );
102
    three   = __cxxabiv1::__cxa_vec_new3( 10, 40, 8, NULL, NULL, my_alloc2, my_dealloc3 );
103

104
    __cxxabiv1::__cxa_vec_delete ( one,       40, 8, NULL );
105
    __cxxabiv1::__cxa_vec_delete2( two,       40, 8, NULL, my_dealloc2 );
106
    __cxxabiv1::__cxa_vec_delete3( three,     40, 8, NULL, my_dealloc3 );
107

108
//  Padding with con/destructors
109
    one     = __cxxabiv1::__cxa_vec_new ( 10, 40, 8, my_construct, my_destruct );
110
    two     = __cxxabiv1::__cxa_vec_new2( 10, 40, 8, my_construct, my_destruct, my_alloc2, my_dealloc2 );
111
    three   = __cxxabiv1::__cxa_vec_new3( 10, 40, 8, my_construct, my_destruct, my_alloc2, my_dealloc3 );
112

113
    __cxxabiv1::__cxa_vec_delete ( one,       40, 8, my_destruct );
114
    __cxxabiv1::__cxa_vec_delete2( two,       40, 8, my_destruct, my_dealloc2 );
115
    __cxxabiv1::__cxa_vec_delete3( three,     40, 8, my_destruct, my_dealloc3 );
116

117
    return 0;
118
}
119

120
//  Make sure the constructors and destructors are matched
121
int test_counted ( ) {
122
    int retVal = 0;
123
    void *one, *two, *three;
124

125
//  Try with no padding
126
    gCounter = 0;
127
    one     = __cxxabiv1::__cxa_vec_new ( 10, 40, 0, count_construct, count_destruct );
128
    two     = __cxxabiv1::__cxa_vec_new2( 10, 40, 0, count_construct, count_destruct, my_alloc2, my_dealloc2 );
129
    three   = __cxxabiv1::__cxa_vec_new3( 10, 40, 0, count_construct, count_destruct, my_alloc2, my_dealloc3 );
130

131
    __cxxabiv1::__cxa_vec_delete ( one,       40, 0, count_destruct );
132
    __cxxabiv1::__cxa_vec_delete2( two,       40, 0, count_destruct, my_dealloc2 );
133
    __cxxabiv1::__cxa_vec_delete3( three,     40, 0, count_destruct, my_dealloc3 );
134

135
//  Since there was no padding, the # of elements in the array are not stored
136
//  and the destructors are not called.
137
    if ( gCounter != 30 ) {
138
        std::printf("Mismatched Constructor/Destructor calls (1)\n");
139
        std::printf("  Expected 30, got %d\n", gCounter);
140
        retVal = 1;
141
    }
142

143
    gCounter = 0;
144
    one     = __cxxabiv1::__cxa_vec_new ( 10, 40, 8, count_construct, count_destruct );
145
    two     = __cxxabiv1::__cxa_vec_new2( 10, 40, 8, count_construct, count_destruct, my_alloc2, my_dealloc2 );
146
    three   = __cxxabiv1::__cxa_vec_new3( 10, 40, 8, count_construct, count_destruct, my_alloc2, my_dealloc3 );
147

148
    __cxxabiv1::__cxa_vec_delete ( one,       40, 8, count_destruct );
149
    __cxxabiv1::__cxa_vec_delete2( two,       40, 8, count_destruct, my_dealloc2 );
150
    __cxxabiv1::__cxa_vec_delete3( three,     40, 8, count_destruct, my_dealloc3 );
151

152
    if ( gCounter != 0 ) {
153
        std::printf("Mismatched Constructor/Destructor calls (2)\n");
154
        std::printf("  Expected 0, got %d\n", gCounter);
155
        retVal = 1;
156
    }
157

158
    return retVal;
159
}
160

161
#ifndef TEST_HAS_NO_EXCEPTIONS
162
//  Make sure the constructors and destructors are matched
163
int test_exception_in_constructor ( ) {
164
    int retVal = 0;
165
    void *one, *two, *three;
166

167
//  Try with no padding
168
    gConstructorCounter = gDestructorCounter = 0;
169
    gConstructorThrowTarget = 15;
170
    gDestructorThrowTarget  = -1;
171
    try {
172
        one = two = three = NULL;
173
        one     = __cxxabiv1::__cxa_vec_new ( 10, 40, 0, throw_construct, throw_destruct );
174
        two     = __cxxabiv1::__cxa_vec_new2( 10, 40, 0, throw_construct, throw_destruct, my_alloc2, my_dealloc2 );
175
        three   = __cxxabiv1::__cxa_vec_new3( 10, 40, 0, throw_construct, throw_destruct, my_alloc2, my_dealloc3 );
176
    }
177
    catch ( int i ) {}
178

179
    __cxxabiv1::__cxa_vec_delete ( one,       40, 0, throw_destruct );
180
    __cxxabiv1::__cxa_vec_delete2( two,       40, 0, throw_destruct, my_dealloc2 );
181
    __cxxabiv1::__cxa_vec_delete3( three,     40, 0, throw_destruct, my_dealloc3 );
182

183
//  Since there was no padding, the # of elements in the array are not stored
184
//  and the destructors are not called.
185
//  Since we threw after 15 calls to the constructor, we should see 5 calls to
186
//      the destructor from the partially constructed array.
187
    if ( gConstructorCounter - gDestructorCounter != 10 ) {
188
        std::printf("Mismatched Constructor/Destructor calls (1C)\n");
189
        std::printf("%d constructors, but %d destructors\n", gConstructorCounter, gDestructorCounter);
190
        retVal = 1;
191
    }
192

193
    gConstructorCounter = gDestructorCounter = 0;
194
    gConstructorThrowTarget = 15;
195
    gDestructorThrowTarget  = -1;
196
    try {
197
        one = two = three = NULL;
198
        one     = __cxxabiv1::__cxa_vec_new ( 10, 40, 8, throw_construct, throw_destruct );
199
        two     = __cxxabiv1::__cxa_vec_new2( 10, 40, 8, throw_construct, throw_destruct, my_alloc2, my_dealloc2 );
200
        three   = __cxxabiv1::__cxa_vec_new3( 10, 40, 8, throw_construct, throw_destruct, my_alloc2, my_dealloc3 );
201
    }
202
    catch ( int i ) {}
203

204
    __cxxabiv1::__cxa_vec_delete ( one,       40, 8, throw_destruct );
205
    __cxxabiv1::__cxa_vec_delete2( two,       40, 8, throw_destruct, my_dealloc2 );
206
    __cxxabiv1::__cxa_vec_delete3( three,     40, 8, throw_destruct, my_dealloc3 );
207

208
    if ( gConstructorCounter != gDestructorCounter ) {
209
        std::printf("Mismatched Constructor/Destructor calls (2C)\n");
210
        std::printf("%d constructors, but %d destructors\n", gConstructorCounter, gDestructorCounter);
211
        retVal = 1;
212
    }
213

214
    return retVal;
215
}
216
#endif
217

218
#ifndef TEST_HAS_NO_EXCEPTIONS
219
//  Make sure the constructors and destructors are matched
220
int test_exception_in_destructor ( ) {
221
    int retVal = 0;
222
    void *one, *two, *three;
223
    one = two = three = NULL;
224

225
//  Throw from within a destructor
226
    gConstructorCounter = gDestructorCounter = 0;
227
    gConstructorThrowTarget = -1;
228
    gDestructorThrowTarget  = 15;
229
    try {
230
        one = two = NULL;
231
        one     = __cxxabiv1::__cxa_vec_new ( 10, 40, 8, throw_construct, throw_destruct );
232
        two     = __cxxabiv1::__cxa_vec_new2( 10, 40, 8, throw_construct, throw_destruct, my_alloc2, my_dealloc2 );
233
    }
234
    catch ( int i ) {}
235

236
    try {
237
        __cxxabiv1::__cxa_vec_delete ( one,       40, 8, throw_destruct );
238
        __cxxabiv1::__cxa_vec_delete2( two,       40, 8, throw_destruct, my_dealloc2 );
239
        assert(false);
240
    }
241
    catch ( int i ) {}
242

243
//  We should have thrown in the middle of cleaning up "two", which means that
244
//  there should be 20 calls to the destructor and the try block should exit
245
//  before the assertion.
246
    if ( gConstructorCounter != 20 || gDestructorCounter != 20 ) {
247
        std::printf("Unexpected Constructor/Destructor calls (1D)\n");
248
        std::printf("Expected (20, 20), but got (%d, %d)\n", gConstructorCounter, gDestructorCounter);
249
        retVal = 1;
250
    }
251

252
//  Try throwing from a destructor - should be fine.
253
    gConstructorCounter = gDestructorCounter = 0;
254
    gConstructorThrowTarget = -1;
255
    gDestructorThrowTarget  = 5;
256
    try { vec_on_stack v; }
257
    catch ( int i ) {}
258

259
    if ( gConstructorCounter != gDestructorCounter ) {
260
        std::printf("Mismatched Constructor/Destructor calls (2D)\n");
261
        std::printf("%d constructors, but %d destructors\n", gConstructorCounter, gDestructorCounter);
262
        retVal = 1;
263
    }
264

265
    return retVal;
266
}
267
#endif
268

269
int main(int, char**) {
270
    int retVal = 0;
271
    retVal += test_empty ();
272
    retVal += test_counted ();
273
#ifndef TEST_HAS_NO_EXCEPTIONS
274
    retVal += test_exception_in_constructor ();
275
    retVal += test_exception_in_destructor ();
276
#endif
277
    return retVal;
278
}
279