struct alignas(OverAligned) A {};
struct alignas(std::max_align_t) B {};
-B* volatile b; // Escape the memory
-A* volatile a;
-
int main()
{
reset();
{
- b = new B[2];
+ B *b = new B[2];
+ DoNotOptimize(b);
assert(0 == unsized_delete_called);
assert(0 == unsized_delete_nothrow_called);
assert(0 == aligned_delete_called);
delete [] b;
+ DoNotOptimize(b);
assert(1 == unsized_delete_called);
assert(0 == unsized_delete_nothrow_called);
assert(0 == aligned_delete_called);
}
reset();
{
- a = new A[2];
+ A *a = new A[2];
+ DoNotOptimize(a);
assert(0 == unsized_delete_called);
assert(0 == unsized_delete_nothrow_called);
assert(0 == aligned_delete_called);
delete [] a;
+ DoNotOptimize(a);
assert(0 == unsized_delete_called);
assert(0 == unsized_delete_nothrow_called);
assert(1 == aligned_delete_called);
assert(s <= sizeof(DummyData));
assert(static_cast<std::size_t>(a) == OverAligned);
++new_called;
- return DummyData;
+ void *Ret = DummyData;
+ DoNotOptimize(Ret);
+ return Ret;
}
void operator delete[](void* p, std::align_val_t) TEST_NOEXCEPT
assert(new_called == 1);
--new_called;
assert(p == DummyData);
+ DoNotOptimize(p);
}
std::set_new_handler(my_new_handler);
try
{
- void* volatile vp = operator new[] (std::numeric_limits<std::size_t>::max());
- ((void)vp);
+ void* vp = operator new[] (std::numeric_limits<std::size_t>::max());
+ DoNotOptimize(vp);
assert(false);
}
catch (std::bad_alloc&)
}
#endif
A* ap = new A[3];
+ DoNotOptimize(ap);
assert(ap);
assert(A_constructed == 3);
delete [] ap;
+ DoNotOptimize(ap);
assert(A_constructed == 0);
}
try
#endif
{
- void*volatile vp = operator new [] (std::numeric_limits<std::size_t>::max(), std::nothrow);
+ void* vp = operator new [] (std::numeric_limits<std::size_t>::max(), std::nothrow);
+ DoNotOptimize(vp);
assert(new_handler_called == 1);
assert(vp == 0);
}
}
#endif
A* ap = new(std::nothrow) A[3];
+ DoNotOptimize(ap);
assert(ap);
assert(A_constructed == 3);
delete [] ap;
+ DoNotOptimize(ap);
assert(A_constructed == 0);
}
std::free(p);
}
-volatile int A_constructed = 0;
+int A_constructed = 0;
struct A
{
~A() {--A_constructed;}
};
-A* volatile ap;
-
int main()
{
- ap = new (std::nothrow) A[3];
+ A *ap = new (std::nothrow) A[3];
+ DoNotOptimize(ap);
assert(ap);
assert(A_constructed == 3);
assert(new_called);
delete [] ap;
+ DoNotOptimize(ap);
assert(A_constructed == 0);
assert(!new_called);
}
#include "test_macros.h"
-volatile int new_called = 0;
+int new_called = 0;
void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
{
~A() {--A_constructed;}
};
-A* volatile ap;
-
int main()
{
- ap = new A[3];
+ A *ap = new A[3];
+ DoNotOptimize(ap);
assert(ap);
assert(A_constructed == 3);
assert(new_called == 1);
delete [] ap;
+ DoNotOptimize(ap);
assert(A_constructed == 0);
assert(new_called == 0);
}
// selected.
struct A { ~A() {} };
-A *volatile x;
-
int main()
{
- x = new A[3];
+ A *x = new A[3];
+ DoNotOptimize(x);
assert(0 == delete_called);
assert(0 == delete_nothrow_called);
delete [] x;
+ DoNotOptimize(x);
assert(1 == delete_called);
assert(0 == delete_nothrow_called);
}
struct alignas(OverAligned) A {};
struct alignas(std::max_align_t) B {};
-B* volatile bp;
-A* volatile ap;
-
int main()
{
reset();
{
- bp = new B;
+ B *bp = new B;
+ DoNotOptimize(bp);
assert(0 == unsized_delete_called);
assert(0 == unsized_delete_nothrow_called);
assert(0 == aligned_delete_called);
delete bp;
+ DoNotOptimize(bp);
assert(1 == unsized_delete_called);
assert(0 == unsized_delete_nothrow_called);
assert(0 == aligned_delete_called);
}
reset();
{
- ap = new A;
+ A *ap = new A;
+ DoNotOptimize(ap);
assert(0 == unsized_delete_called);
assert(0 == unsized_delete_nothrow_called);
assert(0 == aligned_delete_called);
delete ap;
+ DoNotOptimize(ap);
assert(0 == unsized_delete_called);
assert(0 == unsized_delete_nothrow_called);
assert(1 == aligned_delete_called);
assert(s <= sizeof(DummyData));
assert(static_cast<std::size_t>(a) == OverAligned);
++new_called;
- return DummyData;
+ void *Ret = DummyData;
+ DoNotOptimize(Ret);
+ return Ret;
}
void operator delete(void* p, std::align_val_t) TEST_NOEXCEPT
assert(new_called == 1);
--new_called;
assert(p == DummyData);
+ DoNotOptimize(DummyData);
}
~A() {A_constructed = false;}
};
-A* volatile ap;
-
int main()
{
- ap = new (std::nothrow) A;
+ A *ap = new (std::nothrow) A;
+ DoNotOptimize(ap);
assert(ap);
assert(A_constructed);
assert(new_called);
delete ap;
+ DoNotOptimize(ap);
assert(!A_constructed);
assert(!new_called);
}
~A() {A_constructed = false;}
};
-A *volatile ap;
-
int main()
{
- ap = new A;
+ A *ap = new A;
+ DoNotOptimize(ap);
assert(ap);
assert(A_constructed);
assert(new_called);
delete ap;
+ DoNotOptimize(ap);
assert(!A_constructed);
assert(!new_called);
}
std::free(p);
}
-int *volatile x;
-
int main()
{
- x = new int(42);
+ int *x = new int(42);
+ DoNotOptimize(x);
assert(0 == unsized_delete_called);
assert(0 == unsized_delete_nothrow_called);
assert(0 == sized_delete_called);
delete x;
+ DoNotOptimize(x);
assert(1 == unsized_delete_called);
assert(0 == sized_delete_called);
assert(0 == unsized_delete_nothrow_called);
std::free(p);
}
-int *volatile x;
-
int main()
{
- x = new int(42);
+ int *x = new int(42);
+ DoNotOptimize(x);
assert(0 == unsized_delete_called);
assert(0 == unsized_delete_nothrow_called);
assert(0 == sized_delete_called);
delete x;
+ DoNotOptimize(x);
assert(0 == unsized_delete_called);
assert(1 == sized_delete_called);
assert(0 == unsized_delete_nothrow_called);
std::free(p);
}
-int* volatile x;
-
int main()
{
- x = new int(42);
+ int *x = new int(42);
+ DoNotOptimize(x);
assert(0 == delete_called);
assert(0 == delete_nothrow_called);
delete x;
+ DoNotOptimize(x);
assert(1 == delete_called);
assert(0 == delete_nothrow_called);
}
std::free(p);
}
-int* volatile x;
-
int main()
{
- x = new int(42);
+ int *x = new int(42);
+ DoNotOptimize(x);
assert(0 == sized_delete_called);
assert(0 == unsized_delete_called);
assert(0 == unsized_delete_nothrow_called);
delete x;
+ DoNotOptimize(x);
assert(1 == sized_delete_called);
assert(0 == unsized_delete_called);
assert(0 == unsized_delete_nothrow_called);
#include <memory>
#include <cassert>
+#include <iostream>
#include "test_macros.h"
#include "count_new.hpp"
assert(T::constructed == 0);
globalMemCounter.last_new_size = 0;
globalMemCounter.last_new_align = 0;
- T* volatile ap = a.allocate(3);
+ T* ap = a.allocate(3);
+ DoNotOptimize(ap);
assert(globalMemCounter.checkOutstandingNewEq(1));
assert(globalMemCounter.checkNewCalledEq(1));
assert(globalMemCounter.checkAlignedNewCalledEq(ExpectAligned));
globalMemCounter.last_new_size = 0;
globalMemCounter.last_new_align = 0;
T* volatile ap2 = a.allocate(11, (const void*)5);
+ DoNotOptimize(ap2);
assert(globalMemCounter.checkOutstandingNewEq(1));
assert(globalMemCounter.checkNewCalledEq(1));
assert(globalMemCounter.checkAlignedNewCalledEq(ExpectAligned));
assert(T::constructed == 0);
globalMemCounter.last_delete_align = 0;
a.deallocate(ap2, 11);
+ DoNotOptimize(ap2);
assert(globalMemCounter.checkOutstandingNewEq(0));
assert(globalMemCounter.checkDeleteCalledEq(1));
assert(globalMemCounter.checkAlignedDeleteCalledEq(ExpectAligned));
#if defined(__GNUC__) || defined(__clang__)
template <class Tp>
-inline void DoNotOptimize(Tp const& value) {
- asm volatile("" : : "g"(value) : "memory");
+inline
+void DoNotOptimize(Tp const& value) {
+ asm volatile("" : : "r,m"(value) : "memory");
+}
+
+template <class Tp>
+inline void DoNotOptimize(Tp& value) {
+#if defined(__clang__)
+ asm volatile("" : "+r,m"(value) : : "memory");
+#else
+ asm volatile("" : "+m,r"(value) : : "memory");
+#endif
}
#else
#include <intrin.h>