blob: ff19c7e377717b910b74debdf1675ea2299d9e34 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
// { dg-do run }
// Origin: Mark Mitchell <mark@codesourcery.com>
#if defined (__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100
#include <cstdlib>
#include <new>
void* p;
void* operator new[](size_t s) throw (std::bad_alloc)
{
// Record the base of the last array allocated.
p = malloc (s);
return p;
}
template <typename T>
void check_no_cookie (int i)
{
void* a = new T[7];
if (p != a)
exit (i);
}
template <typename T>
void check_no_placement_cookie (int i)
{
p = malloc (13 * sizeof (T));
void* a = new (p) T[13];
if (p != a)
exit (i);
}
template <typename T>
void check_cookie (int i)
{
void* a = new T[11];
size_t x;
// Compute the cookie location manually.
#ifdef __ARM_EABI__
x = 8;
#else
x = __alignof__ (T);
if (x < sizeof (size_t))
x = sizeof (size_t);
#endif
if ((char *) a - x != (char *) p)
exit (i);
// Check the cookie value.
size_t *sp = ((size_t *) a) - 1;
if (*sp != 11)
exit (i);
#ifdef __ARM_EABI__
sp = ((size_t *) a) - 2;
if (*sp != sizeof (T))
exit (i);
#endif
}
template <typename T>
void check_placement_cookie (int i)
{
p = malloc (sizeof (T) * 11 + 100);
void* a = new (p) T[11];
size_t x;
// Compute the cookie location manually.
#ifdef __ARM_EABI__
x = 8;
#else
x = __alignof__ (T);
if (x < sizeof (size_t))
x = sizeof (size_t);
#endif
if ((char *) a - x != (char *) p)
exit (i);
// Check the cookie value.
size_t *sp = ((size_t *) a) - 1;
if (*sp != 11)
exit (i);
#ifdef __ARM_EABI__
sp = ((size_t *) a) - 2;
if (*sp != sizeof (T))
exit (i);
#endif
}
struct X {};
template <typename T>
struct Y { int i; virtual void f () {} };
// A class with a non-trivial destructor -- it needs a cookie.
struct Z { ~Z () {} };
// Likewise, but this class needs a bigger cookie so that the array
// elements are correctly aligned.
struct Z2 { ~Z2 () {} long double d; };
struct W1 { void operator delete[] (void *, size_t) {} };
struct W2 { void operator delete[] (void *) {}
void operator delete[] (void *, size_t) {} };
struct W3 { void operator delete[] (void *, size_t) {}
void operator delete[] (void *) {} };
struct W4 : public W1 {};
struct V { void *operator new[] (size_t s, void *p)
{ return p; }
~V () {}
};
int main ()
{
// There should be no cookies for types with trivial destructors.
check_no_cookie<int> (1);
check_no_cookie<X> (2);
check_no_cookie<Y<double> > (3);
// There should be no cookies for allocations using global placement
// new.
check_no_placement_cookie<int> (4);
check_no_placement_cookie<X> (5);
check_no_placement_cookie<Z> (6);
// There should be a cookie when using a non-trivial destructor.
check_cookie<Z> (7);
check_cookie<Z2> (8);
// There should be a cookie when using the two-argument array delete
// operator.
check_cookie<W1> (9);
check_cookie<W4> (10);
// But not when the one-argument version is also available.
check_no_cookie<W2> (11);
check_no_cookie<W3> (12);
// There should be a cookie when using a non-global placement new.
check_placement_cookie<V> (13);
}
#else /* !(defined (__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100) */
int main ()
{
}
#endif /* !(defined (__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100) */
|
