1 //=== - llvm/unittest/Support/TrailingObjectsTest.cpp ---------------------===//
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 "llvm/Support/TrailingObjects.h"
10 #include "gtest/gtest.h"
11 
12 using namespace llvm;
13 
14 namespace {
15 // This class, beyond being used by the test case, a nice
16 // demonstration of the intended usage of TrailingObjects, with a
17 // single trailing array.
18 class Class1 final : protected TrailingObjects<Class1, short> {
19   friend TrailingObjects;
20 
21   unsigned NumShorts;
22 
23 protected:
24   size_t numTrailingObjects(OverloadToken<short>) const { return NumShorts; }
25 
26   Class1(int *ShortArray, unsigned NumShorts) : NumShorts(NumShorts) {
27     std::uninitialized_copy(ShortArray, ShortArray + NumShorts,
28                             getTrailingObjects<short>());
29   }
30 
31 public:
32   static Class1 *create(int *ShortArray, unsigned NumShorts) {
33     void *Mem = ::operator new(totalSizeToAlloc<short>(NumShorts));
34     return new (Mem) Class1(ShortArray, NumShorts);
35   }
36   void operator delete(void *p) { ::operator delete(p); }
37 
38   short get(unsigned Num) const { return getTrailingObjects<short>()[Num]; }
39 
40   unsigned numShorts() const { return NumShorts; }
41 
42   // Pull some protected members in as public, for testability.
43   template <typename... Ty>
44   using FixedSizeStorage = TrailingObjects::FixedSizeStorage<Ty...>;
45 
46   using TrailingObjects::totalSizeToAlloc;
47   using TrailingObjects::additionalSizeToAlloc;
48   using TrailingObjects::getTrailingObjects;
49 };
50 
51 // Here, there are two singular optional object types appended.  Note
52 // that the alignment of Class2 is automatically increased to account
53 // for the alignment requirements of the trailing objects.
54 class Class2 final : protected TrailingObjects<Class2, double, short> {
55   friend TrailingObjects;
56 
57   bool HasShort, HasDouble;
58 
59 protected:
60   size_t numTrailingObjects(OverloadToken<short>) const {
61     return HasShort ? 1 : 0;
62   }
63   size_t numTrailingObjects(OverloadToken<double>) const {
64     return HasDouble ? 1 : 0;
65   }
66 
67   Class2(bool HasShort, bool HasDouble)
68       : HasShort(HasShort), HasDouble(HasDouble) {}
69 
70 public:
71   static Class2 *create(short S = 0, double D = 0.0) {
72     bool HasShort = S != 0;
73     bool HasDouble = D != 0.0;
74 
75     void *Mem =
76         ::operator new(totalSizeToAlloc<double, short>(HasDouble, HasShort));
77     Class2 *C = new (Mem) Class2(HasShort, HasDouble);
78     if (HasShort)
79       *C->getTrailingObjects<short>() = S;
80     if (HasDouble)
81       *C->getTrailingObjects<double>() = D;
82     return C;
83   }
84   void operator delete(void *p) { ::operator delete(p); }
85 
86   short getShort() const {
87     if (!HasShort)
88       return 0;
89     return *getTrailingObjects<short>();
90   }
91 
92   double getDouble() const {
93     if (!HasDouble)
94       return 0.0;
95     return *getTrailingObjects<double>();
96   }
97 
98   // Pull some protected members in as public, for testability.
99   template <typename... Ty>
100   using FixedSizeStorage = TrailingObjects::FixedSizeStorage<Ty...>;
101 
102   using TrailingObjects::totalSizeToAlloc;
103   using TrailingObjects::additionalSizeToAlloc;
104   using TrailingObjects::getTrailingObjects;
105 };
106 
107 TEST(TrailingObjects, OneArg) {
108   int arr[] = {1, 2, 3};
109   Class1 *C = Class1::create(arr, 3);
110   EXPECT_EQ(sizeof(Class1), sizeof(unsigned));
111   EXPECT_EQ(Class1::additionalSizeToAlloc<short>(1), sizeof(short));
112   EXPECT_EQ(Class1::additionalSizeToAlloc<short>(3), sizeof(short) * 3);
113 
114   EXPECT_EQ(alignof(Class1),
115             alignof(Class1::FixedSizeStorage<short>::with_counts<1>::type));
116   EXPECT_EQ(sizeof(Class1::FixedSizeStorage<short>::with_counts<1>::type),
117             llvm::alignTo(Class1::totalSizeToAlloc<short>(1), alignof(Class1)));
118   EXPECT_EQ(Class1::totalSizeToAlloc<short>(1), sizeof(Class1) + sizeof(short));
119 
120   EXPECT_EQ(alignof(Class1),
121             alignof(Class1::FixedSizeStorage<short>::with_counts<3>::type));
122   EXPECT_EQ(sizeof(Class1::FixedSizeStorage<short>::with_counts<3>::type),
123             llvm::alignTo(Class1::totalSizeToAlloc<short>(3), alignof(Class1)));
124   EXPECT_EQ(Class1::totalSizeToAlloc<short>(3),
125             sizeof(Class1) + sizeof(short) * 3);
126 
127   EXPECT_EQ(C->getTrailingObjects<short>(), reinterpret_cast<short *>(C + 1));
128   EXPECT_EQ(C->get(0), 1);
129   EXPECT_EQ(C->get(2), 3);
130   delete C;
131 }
132 
133 TEST(TrailingObjects, TwoArg) {
134   Class2 *C1 = Class2::create(4);
135   Class2 *C2 = Class2::create(0, 4.2);
136 
137   EXPECT_EQ(sizeof(Class2), llvm::alignTo(sizeof(bool) * 2, alignof(double)));
138   EXPECT_EQ(alignof(Class2), alignof(double));
139 
140   EXPECT_EQ((Class2::additionalSizeToAlloc<double, short>(1, 0)),
141             sizeof(double));
142   EXPECT_EQ((Class2::additionalSizeToAlloc<double, short>(0, 1)),
143             sizeof(short));
144   EXPECT_EQ((Class2::additionalSizeToAlloc<double, short>(3, 1)),
145             sizeof(double) * 3 + sizeof(short));
146 
147   EXPECT_EQ(
148       alignof(Class2),
149       (alignof(
150           Class2::FixedSizeStorage<double, short>::with_counts<1, 1>::type)));
151   EXPECT_EQ(
152       sizeof(Class2::FixedSizeStorage<double, short>::with_counts<1, 1>::type),
153       llvm::alignTo(Class2::totalSizeToAlloc<double, short>(1, 1),
154                     alignof(Class2)));
155   EXPECT_EQ((Class2::totalSizeToAlloc<double, short>(1, 1)),
156             sizeof(Class2) + sizeof(double) + sizeof(short));
157 
158   EXPECT_EQ(C1->getDouble(), 0);
159   EXPECT_EQ(C1->getShort(), 4);
160   EXPECT_EQ(C1->getTrailingObjects<double>(),
161             reinterpret_cast<double *>(C1 + 1));
162   EXPECT_EQ(C1->getTrailingObjects<short>(), reinterpret_cast<short *>(C1 + 1));
163 
164   EXPECT_EQ(C2->getDouble(), 4.2);
165   EXPECT_EQ(C2->getShort(), 0);
166   EXPECT_EQ(C2->getTrailingObjects<double>(),
167             reinterpret_cast<double *>(C2 + 1));
168   EXPECT_EQ(C2->getTrailingObjects<short>(),
169             reinterpret_cast<short *>(reinterpret_cast<double *>(C2 + 1) + 1));
170   delete C1;
171   delete C2;
172 }
173 
174 // This test class is not trying to be a usage demo, just asserting
175 // that three args does actually work too (it's the same code as
176 // handles the second arg, so it's basically covered by the above, but
177 // just in case..)
178 class Class3 final : public TrailingObjects<Class3, double, short, bool> {
179   friend TrailingObjects;
180 
181   size_t numTrailingObjects(OverloadToken<double>) const { return 1; }
182   size_t numTrailingObjects(OverloadToken<short>) const { return 1; }
183 };
184 
185 TEST(TrailingObjects, ThreeArg) {
186   EXPECT_EQ((Class3::additionalSizeToAlloc<double, short, bool>(1, 1, 3)),
187             sizeof(double) + sizeof(short) + 3 * sizeof(bool));
188   EXPECT_EQ(sizeof(Class3), llvm::alignTo(1, alignof(double)));
189 
190   EXPECT_EQ(
191       alignof(Class3),
192       (alignof(Class3::FixedSizeStorage<double, short,
193                                         bool>::with_counts<1, 1, 3>::type)));
194   EXPECT_EQ(
195       sizeof(Class3::FixedSizeStorage<double, short,
196                                       bool>::with_counts<1, 1, 3>::type),
197       llvm::alignTo(Class3::totalSizeToAlloc<double, short, bool>(1, 1, 3),
198                     alignof(Class3)));
199 
200   std::unique_ptr<char[]> P(new char[1000]);
201   Class3 *C = reinterpret_cast<Class3 *>(P.get());
202   EXPECT_EQ(C->getTrailingObjects<double>(), reinterpret_cast<double *>(C + 1));
203   EXPECT_EQ(C->getTrailingObjects<short>(),
204             reinterpret_cast<short *>(reinterpret_cast<double *>(C + 1) + 1));
205   EXPECT_EQ(
206       C->getTrailingObjects<bool>(),
207       reinterpret_cast<bool *>(
208           reinterpret_cast<short *>(reinterpret_cast<double *>(C + 1) + 1) +
209           1));
210 }
211 
212 class Class4 final : public TrailingObjects<Class4, char, long> {
213   friend TrailingObjects;
214   size_t numTrailingObjects(OverloadToken<char>) const { return 1; }
215 };
216 
217 TEST(TrailingObjects, Realignment) {
218   EXPECT_EQ((Class4::additionalSizeToAlloc<char, long>(1, 1)),
219             llvm::alignTo(sizeof(long) + 1, alignof(long)));
220   EXPECT_EQ(sizeof(Class4), llvm::alignTo(1, alignof(long)));
221 
222   EXPECT_EQ(
223       alignof(Class4),
224       (alignof(Class4::FixedSizeStorage<char, long>::with_counts<1, 1>::type)));
225   EXPECT_EQ(
226       sizeof(Class4::FixedSizeStorage<char, long>::with_counts<1, 1>::type),
227       llvm::alignTo(Class4::totalSizeToAlloc<char, long>(1, 1),
228                     alignof(Class4)));
229 
230   std::unique_ptr<char[]> P(new char[1000]);
231   Class4 *C = reinterpret_cast<Class4 *>(P.get());
232   EXPECT_EQ(C->getTrailingObjects<char>(), reinterpret_cast<char *>(C + 1));
233   EXPECT_EQ(C->getTrailingObjects<long>(),
234             reinterpret_cast<long *>(llvm::alignAddr(
235                 reinterpret_cast<char *>(C + 1) + 1, Align::Of<long>())));
236 }
237 }
238 
239 // Test the use of TrailingObjects with a template class. This
240 // previously failed to compile due to a bug in MSVC's member access
241 // control/lookup handling for OverloadToken.
242 template <typename Derived>
243 class Class5Tmpl : private llvm::TrailingObjects<Derived, float, int> {
244   using TrailingObjects = typename llvm::TrailingObjects<Derived, float>;
245   friend TrailingObjects;
246 
247   size_t numTrailingObjects(
248       typename TrailingObjects::template OverloadToken<float>) const {
249     return 1;
250   }
251 
252   size_t numTrailingObjects(
253       typename TrailingObjects::template OverloadToken<int>) const {
254     return 2;
255   }
256 };
257 
258 class Class5 : public Class5Tmpl<Class5> {};
259