1//===- ValueHandleTest.cpp - ValueHandle tests ----------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "llvm/IR/ValueHandle.h"
11#include "llvm/IR/Constants.h"
12#include "llvm/IR/Instructions.h"
13#include "llvm/IR/LLVMContext.h"
14#include "gtest/gtest.h"
15#include <memory>
16
17using namespace llvm;
18
19namespace {
20
21class ValueHandle : public testing::Test {
22protected:
23  Constant *ConstantV;
24  std::unique_ptr<BitCastInst> BitcastV;
25
26  ValueHandle() :
27    ConstantV(ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 0)),
28    BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(getGlobalContext()))) {
29  }
30};
31
32class ConcreteCallbackVH final : public CallbackVH {
33public:
34  ConcreteCallbackVH(Value *V) : CallbackVH(V) {}
35};
36
37TEST_F(ValueHandle, WeakVH_BasicOperation) {
38  WeakVH WVH(BitcastV.get());
39  EXPECT_EQ(BitcastV.get(), WVH);
40  WVH = ConstantV;
41  EXPECT_EQ(ConstantV, WVH);
42
43  // Make sure I can call a method on the underlying Value.  It
44  // doesn't matter which method.
45  EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), WVH->getType());
46  EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), (*WVH).getType());
47}
48
49TEST_F(ValueHandle, WeakVH_Comparisons) {
50  WeakVH BitcastWVH(BitcastV.get());
51  WeakVH ConstantWVH(ConstantV);
52
53  EXPECT_TRUE(BitcastWVH == BitcastWVH);
54  EXPECT_TRUE(BitcastV.get() == BitcastWVH);
55  EXPECT_TRUE(BitcastWVH == BitcastV.get());
56  EXPECT_FALSE(BitcastWVH == ConstantWVH);
57
58  EXPECT_TRUE(BitcastWVH != ConstantWVH);
59  EXPECT_TRUE(BitcastV.get() != ConstantWVH);
60  EXPECT_TRUE(BitcastWVH != ConstantV);
61  EXPECT_FALSE(BitcastWVH != BitcastWVH);
62
63  // Cast to Value* so comparisons work.
64  Value *BV = BitcastV.get();
65  Value *CV = ConstantV;
66  EXPECT_EQ(BV < CV, BitcastWVH < ConstantWVH);
67  EXPECT_EQ(BV <= CV, BitcastWVH <= ConstantWVH);
68  EXPECT_EQ(BV > CV, BitcastWVH > ConstantWVH);
69  EXPECT_EQ(BV >= CV, BitcastWVH >= ConstantWVH);
70
71  EXPECT_EQ(BV < CV, BitcastV.get() < ConstantWVH);
72  EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantWVH);
73  EXPECT_EQ(BV > CV, BitcastV.get() > ConstantWVH);
74  EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantWVH);
75
76  EXPECT_EQ(BV < CV, BitcastWVH < ConstantV);
77  EXPECT_EQ(BV <= CV, BitcastWVH <= ConstantV);
78  EXPECT_EQ(BV > CV, BitcastWVH > ConstantV);
79  EXPECT_EQ(BV >= CV, BitcastWVH >= ConstantV);
80}
81
82TEST_F(ValueHandle, WeakVH_FollowsRAUW) {
83  WeakVH WVH(BitcastV.get());
84  WeakVH WVH_Copy(WVH);
85  WeakVH WVH_Recreated(BitcastV.get());
86  BitcastV->replaceAllUsesWith(ConstantV);
87  EXPECT_EQ(ConstantV, WVH);
88  EXPECT_EQ(ConstantV, WVH_Copy);
89  EXPECT_EQ(ConstantV, WVH_Recreated);
90}
91
92TEST_F(ValueHandle, WeakVH_NullOnDeletion) {
93  WeakVH WVH(BitcastV.get());
94  WeakVH WVH_Copy(WVH);
95  WeakVH WVH_Recreated(BitcastV.get());
96  BitcastV.reset();
97  Value *null_value = nullptr;
98  EXPECT_EQ(null_value, WVH);
99  EXPECT_EQ(null_value, WVH_Copy);
100  EXPECT_EQ(null_value, WVH_Recreated);
101}
102
103
104TEST_F(ValueHandle, AssertingVH_BasicOperation) {
105  AssertingVH<CastInst> AVH(BitcastV.get());
106  CastInst *implicit_to_exact_type = AVH;
107  (void)implicit_to_exact_type;  // Avoid warning.
108
109  AssertingVH<Value> GenericAVH(BitcastV.get());
110  EXPECT_EQ(BitcastV.get(), GenericAVH);
111  GenericAVH = ConstantV;
112  EXPECT_EQ(ConstantV, GenericAVH);
113
114  // Make sure I can call a method on the underlying CastInst.  It
115  // doesn't matter which method.
116  EXPECT_FALSE(AVH->mayWriteToMemory());
117  EXPECT_FALSE((*AVH).mayWriteToMemory());
118}
119
120TEST_F(ValueHandle, AssertingVH_Const) {
121  const CastInst *ConstBitcast = BitcastV.get();
122  AssertingVH<const CastInst> AVH(ConstBitcast);
123  const CastInst *implicit_to_exact_type = AVH;
124  (void)implicit_to_exact_type;  // Avoid warning.
125}
126
127TEST_F(ValueHandle, AssertingVH_Comparisons) {
128  AssertingVH<Value> BitcastAVH(BitcastV.get());
129  AssertingVH<Value> ConstantAVH(ConstantV);
130
131  EXPECT_TRUE(BitcastAVH == BitcastAVH);
132  EXPECT_TRUE(BitcastV.get() == BitcastAVH);
133  EXPECT_TRUE(BitcastAVH == BitcastV.get());
134  EXPECT_FALSE(BitcastAVH == ConstantAVH);
135
136  EXPECT_TRUE(BitcastAVH != ConstantAVH);
137  EXPECT_TRUE(BitcastV.get() != ConstantAVH);
138  EXPECT_TRUE(BitcastAVH != ConstantV);
139  EXPECT_FALSE(BitcastAVH != BitcastAVH);
140
141  // Cast to Value* so comparisons work.
142  Value *BV = BitcastV.get();
143  Value *CV = ConstantV;
144  EXPECT_EQ(BV < CV, BitcastAVH < ConstantAVH);
145  EXPECT_EQ(BV <= CV, BitcastAVH <= ConstantAVH);
146  EXPECT_EQ(BV > CV, BitcastAVH > ConstantAVH);
147  EXPECT_EQ(BV >= CV, BitcastAVH >= ConstantAVH);
148
149  EXPECT_EQ(BV < CV, BitcastV.get() < ConstantAVH);
150  EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantAVH);
151  EXPECT_EQ(BV > CV, BitcastV.get() > ConstantAVH);
152  EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantAVH);
153
154  EXPECT_EQ(BV < CV, BitcastAVH < ConstantV);
155  EXPECT_EQ(BV <= CV, BitcastAVH <= ConstantV);
156  EXPECT_EQ(BV > CV, BitcastAVH > ConstantV);
157  EXPECT_EQ(BV >= CV, BitcastAVH >= ConstantV);
158}
159
160TEST_F(ValueHandle, AssertingVH_DoesNotFollowRAUW) {
161  AssertingVH<Value> AVH(BitcastV.get());
162  BitcastV->replaceAllUsesWith(ConstantV);
163  EXPECT_EQ(BitcastV.get(), AVH);
164}
165
166#ifdef NDEBUG
167
168TEST_F(ValueHandle, AssertingVH_ReducesToPointer) {
169  EXPECT_EQ(sizeof(CastInst *), sizeof(AssertingVH<CastInst>));
170}
171
172#else  // !NDEBUG
173
174#ifdef GTEST_HAS_DEATH_TEST
175
176TEST_F(ValueHandle, AssertingVH_Asserts) {
177  AssertingVH<Value> AVH(BitcastV.get());
178  EXPECT_DEATH({BitcastV.reset();},
179               "An asserting value handle still pointed to this value!");
180  AssertingVH<Value> Copy(AVH);
181  AVH = nullptr;
182  EXPECT_DEATH({BitcastV.reset();},
183               "An asserting value handle still pointed to this value!");
184  Copy = nullptr;
185  BitcastV.reset();
186}
187
188#endif  // GTEST_HAS_DEATH_TEST
189
190#endif  // NDEBUG
191
192TEST_F(ValueHandle, CallbackVH_BasicOperation) {
193  ConcreteCallbackVH CVH(BitcastV.get());
194  EXPECT_EQ(BitcastV.get(), CVH);
195  CVH = ConstantV;
196  EXPECT_EQ(ConstantV, CVH);
197
198  // Make sure I can call a method on the underlying Value.  It
199  // doesn't matter which method.
200  EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), CVH->getType());
201  EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), (*CVH).getType());
202}
203
204TEST_F(ValueHandle, CallbackVH_Comparisons) {
205  ConcreteCallbackVH BitcastCVH(BitcastV.get());
206  ConcreteCallbackVH ConstantCVH(ConstantV);
207
208  EXPECT_TRUE(BitcastCVH == BitcastCVH);
209  EXPECT_TRUE(BitcastV.get() == BitcastCVH);
210  EXPECT_TRUE(BitcastCVH == BitcastV.get());
211  EXPECT_FALSE(BitcastCVH == ConstantCVH);
212
213  EXPECT_TRUE(BitcastCVH != ConstantCVH);
214  EXPECT_TRUE(BitcastV.get() != ConstantCVH);
215  EXPECT_TRUE(BitcastCVH != ConstantV);
216  EXPECT_FALSE(BitcastCVH != BitcastCVH);
217
218  // Cast to Value* so comparisons work.
219  Value *BV = BitcastV.get();
220  Value *CV = ConstantV;
221  EXPECT_EQ(BV < CV, BitcastCVH < ConstantCVH);
222  EXPECT_EQ(BV <= CV, BitcastCVH <= ConstantCVH);
223  EXPECT_EQ(BV > CV, BitcastCVH > ConstantCVH);
224  EXPECT_EQ(BV >= CV, BitcastCVH >= ConstantCVH);
225
226  EXPECT_EQ(BV < CV, BitcastV.get() < ConstantCVH);
227  EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantCVH);
228  EXPECT_EQ(BV > CV, BitcastV.get() > ConstantCVH);
229  EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantCVH);
230
231  EXPECT_EQ(BV < CV, BitcastCVH < ConstantV);
232  EXPECT_EQ(BV <= CV, BitcastCVH <= ConstantV);
233  EXPECT_EQ(BV > CV, BitcastCVH > ConstantV);
234  EXPECT_EQ(BV >= CV, BitcastCVH >= ConstantV);
235}
236
237TEST_F(ValueHandle, CallbackVH_CallbackOnDeletion) {
238  class RecordingVH final : public CallbackVH {
239  public:
240    int DeletedCalls;
241    int AURWCalls;
242
243    RecordingVH() : DeletedCalls(0), AURWCalls(0) {}
244    RecordingVH(Value *V) : CallbackVH(V), DeletedCalls(0), AURWCalls(0) {}
245
246  private:
247    void deleted() override {
248      DeletedCalls++;
249      CallbackVH::deleted();
250    }
251    void allUsesReplacedWith(Value *) override { AURWCalls++; }
252  };
253
254  RecordingVH RVH;
255  RVH = BitcastV.get();
256  EXPECT_EQ(0, RVH.DeletedCalls);
257  EXPECT_EQ(0, RVH.AURWCalls);
258  BitcastV.reset();
259  EXPECT_EQ(1, RVH.DeletedCalls);
260  EXPECT_EQ(0, RVH.AURWCalls);
261}
262
263TEST_F(ValueHandle, CallbackVH_CallbackOnRAUW) {
264  class RecordingVH final : public CallbackVH {
265  public:
266    int DeletedCalls;
267    Value *AURWArgument;
268
269    RecordingVH() : DeletedCalls(0), AURWArgument(nullptr) {}
270    RecordingVH(Value *V)
271      : CallbackVH(V), DeletedCalls(0), AURWArgument(nullptr) {}
272
273  private:
274    void deleted() override {
275      DeletedCalls++;
276      CallbackVH::deleted();
277    }
278    void allUsesReplacedWith(Value *new_value) override {
279      EXPECT_EQ(nullptr, AURWArgument);
280      AURWArgument = new_value;
281    }
282  };
283
284  RecordingVH RVH;
285  RVH = BitcastV.get();
286  EXPECT_EQ(0, RVH.DeletedCalls);
287  EXPECT_EQ(nullptr, RVH.AURWArgument);
288  BitcastV->replaceAllUsesWith(ConstantV);
289  EXPECT_EQ(0, RVH.DeletedCalls);
290  EXPECT_EQ(ConstantV, RVH.AURWArgument);
291}
292
293TEST_F(ValueHandle, CallbackVH_DeletionCanRAUW) {
294  class RecoveringVH final : public CallbackVH {
295  public:
296    int DeletedCalls;
297    Value *AURWArgument;
298    LLVMContext *Context;
299
300    RecoveringVH() : DeletedCalls(0), AURWArgument(nullptr),
301                     Context(&getGlobalContext()) {}
302    RecoveringVH(Value *V)
303      : CallbackVH(V), DeletedCalls(0), AURWArgument(nullptr),
304        Context(&getGlobalContext()) {}
305
306  private:
307    void deleted() override {
308      getValPtr()->replaceAllUsesWith(Constant::getNullValue(Type::getInt32Ty(getGlobalContext())));
309      setValPtr(nullptr);
310    }
311    void allUsesReplacedWith(Value *new_value) override {
312      ASSERT_TRUE(nullptr != getValPtr());
313      EXPECT_EQ(1U, getValPtr()->getNumUses());
314      EXPECT_EQ(nullptr, AURWArgument);
315      AURWArgument = new_value;
316    }
317  };
318
319  // Normally, if a value has uses, deleting it will crash.  However, we can use
320  // a CallbackVH to remove the uses before the check for no uses.
321  RecoveringVH RVH;
322  RVH = BitcastV.get();
323  std::unique_ptr<BinaryOperator> BitcastUser(
324    BinaryOperator::CreateAdd(RVH,
325                              Constant::getNullValue(Type::getInt32Ty(getGlobalContext()))));
326  EXPECT_EQ(BitcastV.get(), BitcastUser->getOperand(0));
327  BitcastV.reset();  // Would crash without the ValueHandler.
328  EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(getGlobalContext())), RVH.AURWArgument);
329  EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(getGlobalContext())),
330            BitcastUser->getOperand(0));
331}
332
333TEST_F(ValueHandle, DestroyingOtherVHOnSameValueDoesntBreakIteration) {
334  // When a CallbackVH modifies other ValueHandles in its callbacks,
335  // that shouldn't interfere with non-modified ValueHandles receiving
336  // their appropriate callbacks.
337  //
338  // We create the active CallbackVH in the middle of a palindromic
339  // arrangement of other VHs so that the bad behavior would be
340  // triggered in whichever order callbacks run.
341
342  class DestroyingVH final : public CallbackVH {
343  public:
344    std::unique_ptr<WeakVH> ToClear[2];
345    DestroyingVH(Value *V) {
346      ToClear[0].reset(new WeakVH(V));
347      setValPtr(V);
348      ToClear[1].reset(new WeakVH(V));
349    }
350    void deleted() override {
351      ToClear[0].reset();
352      ToClear[1].reset();
353      CallbackVH::deleted();
354    }
355    void allUsesReplacedWith(Value *) override {
356      ToClear[0].reset();
357      ToClear[1].reset();
358    }
359  };
360
361  {
362    WeakVH ShouldBeVisited1(BitcastV.get());
363    DestroyingVH C(BitcastV.get());
364    WeakVH ShouldBeVisited2(BitcastV.get());
365
366    BitcastV->replaceAllUsesWith(ConstantV);
367    EXPECT_EQ(ConstantV, static_cast<Value*>(ShouldBeVisited1));
368    EXPECT_EQ(ConstantV, static_cast<Value*>(ShouldBeVisited2));
369  }
370
371  {
372    WeakVH ShouldBeVisited1(BitcastV.get());
373    DestroyingVH C(BitcastV.get());
374    WeakVH ShouldBeVisited2(BitcastV.get());
375
376    BitcastV.reset();
377    EXPECT_EQ(nullptr, static_cast<Value*>(ShouldBeVisited1));
378    EXPECT_EQ(nullptr, static_cast<Value*>(ShouldBeVisited2));
379  }
380}
381
382TEST_F(ValueHandle, AssertingVHCheckedLast) {
383  // If a CallbackVH exists to clear out a group of AssertingVHs on
384  // Value deletion, the CallbackVH should get a chance to do so
385  // before the AssertingVHs assert.
386
387  class ClearingVH final : public CallbackVH {
388  public:
389    AssertingVH<Value> *ToClear[2];
390    ClearingVH(Value *V,
391               AssertingVH<Value> &A0, AssertingVH<Value> &A1)
392      : CallbackVH(V) {
393      ToClear[0] = &A0;
394      ToClear[1] = &A1;
395    }
396
397    void deleted() override {
398      *ToClear[0] = nullptr;
399      *ToClear[1] = nullptr;
400      CallbackVH::deleted();
401    }
402  };
403
404  AssertingVH<Value> A1, A2;
405  A1 = BitcastV.get();
406  ClearingVH C(BitcastV.get(), A1, A2);
407  A2 = BitcastV.get();
408  // C.deleted() should run first, clearing the two AssertingVHs,
409  // which should prevent them from asserting.
410  BitcastV.reset();
411}
412
413}
414