libcxxabi/test/test_vector1.pass.cpp

   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 }