llvm-project

1
//===- ValueHandleTest.cpp - ValueHandle tests ----------------------------===//
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/IR/ValueHandle.h"
10
#include "llvm/IR/Constants.h"
11
#include "llvm/IR/Instructions.h"
12
#include "llvm/IR/LLVMContext.h"
13
#include "gtest/gtest.h"
14
#include <memory>
15

16
using namespace llvm;
17

18
namespace {
19

20
class ValueHandle : public testing::Test {
21
protected:
22
  LLVMContext Context;
23
  Constant *ConstantV;
24
  std::unique_ptr<BitCastInst> BitcastV;
25

26
  ValueHandle()
27
      : ConstantV(ConstantInt::get(Type::getInt32Ty(Context), 0)),
28
        BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(Context))) {}
29
};
30

31
class ConcreteCallbackVH final : public CallbackVH {
32
public:
33
  ConcreteCallbackVH(Value *V) : CallbackVH(V) {}
34
};
35

36
TEST_F(ValueHandle, WeakVH_BasicOperation) {
37
  WeakVH WVH(BitcastV.get());
38
  EXPECT_EQ(BitcastV.get(), WVH);
39
  WVH = ConstantV;
40
  EXPECT_EQ(ConstantV, WVH);
41

42
  // Make sure I can call a method on the underlying Value.  It
43
  // doesn't matter which method.
44
  EXPECT_EQ(Type::getInt32Ty(Context), WVH->getType());
45
  EXPECT_EQ(Type::getInt32Ty(Context), (*WVH).getType());
46

47
  WVH = BitcastV.get();
48
  BitcastV->replaceAllUsesWith(ConstantV);
49
  EXPECT_EQ(WVH, BitcastV.get());
50
  BitcastV.reset();
51
  EXPECT_EQ(WVH, nullptr);
52
}
53

54
TEST_F(ValueHandle, WeakTrackingVH_BasicOperation) {
55
  WeakTrackingVH WVH(BitcastV.get());
56
  EXPECT_EQ(BitcastV.get(), WVH);
57
  WVH = ConstantV;
58
  EXPECT_EQ(ConstantV, WVH);
59

60
  // Make sure I can call a method on the underlying Value.  It
61
  // doesn't matter which method.
62
  EXPECT_EQ(Type::getInt32Ty(Context), WVH->getType());
63
  EXPECT_EQ(Type::getInt32Ty(Context), (*WVH).getType());
64
}
65

66
TEST_F(ValueHandle, WeakTrackingVH_Comparisons) {
67
  WeakTrackingVH BitcastWVH(BitcastV.get());
68
  WeakTrackingVH ConstantWVH(ConstantV);
69

70
  EXPECT_TRUE(BitcastWVH == BitcastWVH);
71
  EXPECT_TRUE(BitcastV.get() == BitcastWVH);
72
  EXPECT_TRUE(BitcastWVH == BitcastV.get());
73
  EXPECT_FALSE(BitcastWVH == ConstantWVH);
74

75
  EXPECT_TRUE(BitcastWVH != ConstantWVH);
76
  EXPECT_TRUE(BitcastV.get() != ConstantWVH);
77
  EXPECT_TRUE(BitcastWVH != ConstantV);
78
  EXPECT_FALSE(BitcastWVH != BitcastWVH);
79

80
  // Cast to Value* so comparisons work.
81
  Value *BV = BitcastV.get();
82
  Value *CV = ConstantV;
83
  EXPECT_EQ(BV < CV, BitcastWVH < ConstantWVH);
84
  EXPECT_EQ(BV <= CV, BitcastWVH <= ConstantWVH);
85
  EXPECT_EQ(BV > CV, BitcastWVH > ConstantWVH);
86
  EXPECT_EQ(BV >= CV, BitcastWVH >= ConstantWVH);
87

88
  EXPECT_EQ(BV < CV, BitcastV.get() < ConstantWVH);
89
  EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantWVH);
90
  EXPECT_EQ(BV > CV, BitcastV.get() > ConstantWVH);
91
  EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantWVH);
92

93
  EXPECT_EQ(BV < CV, BitcastWVH < ConstantV);
94
  EXPECT_EQ(BV <= CV, BitcastWVH <= ConstantV);
95
  EXPECT_EQ(BV > CV, BitcastWVH > ConstantV);
96
  EXPECT_EQ(BV >= CV, BitcastWVH >= ConstantV);
97
}
98

99
TEST_F(ValueHandle, WeakTrackingVH_FollowsRAUW) {
100
  WeakTrackingVH WVH(BitcastV.get());
101
  WeakTrackingVH WVH_Copy(WVH);
102
  WeakTrackingVH WVH_Recreated(BitcastV.get());
103
  BitcastV->replaceAllUsesWith(ConstantV);
104
  EXPECT_EQ(ConstantV, WVH);
105
  EXPECT_EQ(ConstantV, WVH_Copy);
106
  EXPECT_EQ(ConstantV, WVH_Recreated);
107
}
108

109
TEST_F(ValueHandle, WeakTrackingVH_NullOnDeletion) {
110
  WeakTrackingVH WVH(BitcastV.get());
111
  WeakTrackingVH WVH_Copy(WVH);
112
  WeakTrackingVH WVH_Recreated(BitcastV.get());
113
  BitcastV.reset();
114
  Value *null_value = nullptr;
115
  EXPECT_EQ(null_value, WVH);
116
  EXPECT_EQ(null_value, WVH_Copy);
117
  EXPECT_EQ(null_value, WVH_Recreated);
118
}
119

120

121
TEST_F(ValueHandle, AssertingVH_BasicOperation) {
122
  AssertingVH<CastInst> AVH(BitcastV.get());
123
  CastInst *implicit_to_exact_type = AVH;
124
  (void)implicit_to_exact_type;  // Avoid warning.
125

126
  AssertingVH<Value> GenericAVH(BitcastV.get());
127
  EXPECT_EQ(BitcastV.get(), GenericAVH);
128
  GenericAVH = ConstantV;
129
  EXPECT_EQ(ConstantV, GenericAVH);
130

131
  // Make sure I can call a method on the underlying CastInst.  It
132
  // doesn't matter which method.
133
  EXPECT_FALSE(AVH->mayWriteToMemory());
134
  EXPECT_FALSE((*AVH).mayWriteToMemory());
135
}
136

137
TEST_F(ValueHandle, AssertingVH_Const) {
138
  const CastInst *ConstBitcast = BitcastV.get();
139
  AssertingVH<const CastInst> AVH(ConstBitcast);
140
  const CastInst *implicit_to_exact_type = AVH;
141
  (void)implicit_to_exact_type;  // Avoid warning.
142
}
143

144
TEST_F(ValueHandle, AssertingVH_Comparisons) {
145
  AssertingVH<Value> BitcastAVH(BitcastV.get());
146
  AssertingVH<Value> ConstantAVH(ConstantV);
147

148
  EXPECT_TRUE(BitcastAVH == BitcastAVH);
149
  EXPECT_TRUE(BitcastV.get() == BitcastAVH);
150
  EXPECT_TRUE(BitcastAVH == BitcastV.get());
151
  EXPECT_FALSE(BitcastAVH == ConstantAVH);
152

153
  EXPECT_TRUE(BitcastAVH != ConstantAVH);
154
  EXPECT_TRUE(BitcastV.get() != ConstantAVH);
155
  EXPECT_TRUE(BitcastAVH != ConstantV);
156
  EXPECT_FALSE(BitcastAVH != BitcastAVH);
157

158
  // Cast to Value* so comparisons work.
159
  Value *BV = BitcastV.get();
160
  Value *CV = ConstantV;
161
  EXPECT_EQ(BV < CV, BitcastAVH < ConstantAVH);
162
  EXPECT_EQ(BV <= CV, BitcastAVH <= ConstantAVH);
163
  EXPECT_EQ(BV > CV, BitcastAVH > ConstantAVH);
164
  EXPECT_EQ(BV >= CV, BitcastAVH >= ConstantAVH);
165

166
  EXPECT_EQ(BV < CV, BitcastV.get() < ConstantAVH);
167
  EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantAVH);
168
  EXPECT_EQ(BV > CV, BitcastV.get() > ConstantAVH);
169
  EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantAVH);
170

171
  EXPECT_EQ(BV < CV, BitcastAVH < ConstantV);
172
  EXPECT_EQ(BV <= CV, BitcastAVH <= ConstantV);
173
  EXPECT_EQ(BV > CV, BitcastAVH > ConstantV);
174
  EXPECT_EQ(BV >= CV, BitcastAVH >= ConstantV);
175
}
176

177
TEST_F(ValueHandle, AssertingVH_DoesNotFollowRAUW) {
178
  AssertingVH<Value> AVH(BitcastV.get());
179
  BitcastV->replaceAllUsesWith(ConstantV);
180
  EXPECT_EQ(BitcastV.get(), AVH);
181
}
182

183
#ifdef NDEBUG
184

185
TEST_F(ValueHandle, AssertingVH_ReducesToPointer) {
186
  EXPECT_EQ(sizeof(CastInst *), sizeof(AssertingVH<CastInst>));
187
}
188

189
#elif LLVM_ENABLE_ABI_BREAKING_CHECKS // && !NDEBUG
190

191
#ifdef GTEST_HAS_DEATH_TEST
192

193
TEST_F(ValueHandle, AssertingVH_Asserts) {
194
  AssertingVH<Value> AVH(BitcastV.get());
195
  EXPECT_DEATH({BitcastV.reset();},
196
               "An asserting value handle still pointed to this value!");
197
  AssertingVH<Value> Copy(AVH);
198
  AVH = nullptr;
199
  EXPECT_DEATH({BitcastV.reset();},
200
               "An asserting value handle still pointed to this value!");
201
  Copy = nullptr;
202
  BitcastV.reset();
203
}
204

205
#endif  // GTEST_HAS_DEATH_TEST
206

207
#endif  // NDEBUG
208

209
TEST_F(ValueHandle, CallbackVH_BasicOperation) {
210
  ConcreteCallbackVH CVH(BitcastV.get());
211
  EXPECT_EQ(BitcastV.get(), CVH);
212
  CVH = ConstantV;
213
  EXPECT_EQ(ConstantV, CVH);
214

215
  // Make sure I can call a method on the underlying Value.  It
216
  // doesn't matter which method.
217
  EXPECT_EQ(Type::getInt32Ty(Context), CVH->getType());
218
  EXPECT_EQ(Type::getInt32Ty(Context), (*CVH).getType());
219
}
220

221
TEST_F(ValueHandle, CallbackVH_Comparisons) {
222
  ConcreteCallbackVH BitcastCVH(BitcastV.get());
223
  ConcreteCallbackVH ConstantCVH(ConstantV);
224

225
  EXPECT_TRUE(BitcastCVH == BitcastCVH);
226
  EXPECT_TRUE(BitcastV.get() == BitcastCVH);
227
  EXPECT_TRUE(BitcastCVH == BitcastV.get());
228
  EXPECT_FALSE(BitcastCVH == ConstantCVH);
229

230
  EXPECT_TRUE(BitcastCVH != ConstantCVH);
231
  EXPECT_TRUE(BitcastV.get() != ConstantCVH);
232
  EXPECT_TRUE(BitcastCVH != ConstantV);
233
  EXPECT_FALSE(BitcastCVH != BitcastCVH);
234

235
  // Cast to Value* so comparisons work.
236
  Value *BV = BitcastV.get();
237
  Value *CV = ConstantV;
238
  EXPECT_EQ(BV < CV, BitcastCVH < ConstantCVH);
239
  EXPECT_EQ(BV <= CV, BitcastCVH <= ConstantCVH);
240
  EXPECT_EQ(BV > CV, BitcastCVH > ConstantCVH);
241
  EXPECT_EQ(BV >= CV, BitcastCVH >= ConstantCVH);
242

243
  EXPECT_EQ(BV < CV, BitcastV.get() < ConstantCVH);
244
  EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantCVH);
245
  EXPECT_EQ(BV > CV, BitcastV.get() > ConstantCVH);
246
  EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantCVH);
247

248
  EXPECT_EQ(BV < CV, BitcastCVH < ConstantV);
249
  EXPECT_EQ(BV <= CV, BitcastCVH <= ConstantV);
250
  EXPECT_EQ(BV > CV, BitcastCVH > ConstantV);
251
  EXPECT_EQ(BV >= CV, BitcastCVH >= ConstantV);
252
}
253

254
TEST_F(ValueHandle, CallbackVH_CallbackOnDeletion) {
255
  class RecordingVH final : public CallbackVH {
256
  public:
257
    int DeletedCalls;
258
    int AURWCalls;
259

260
    RecordingVH() : DeletedCalls(0), AURWCalls(0) {}
261
    RecordingVH(Value *V) : CallbackVH(V), DeletedCalls(0), AURWCalls(0) {}
262

263
  private:
264
    void deleted() override {
265
      DeletedCalls++;
266
      CallbackVH::deleted();
267
    }
268
    void allUsesReplacedWith(Value *) override { AURWCalls++; }
269
  };
270

271
  RecordingVH RVH;
272
  RVH = BitcastV.get();
273
  EXPECT_EQ(0, RVH.DeletedCalls);
274
  EXPECT_EQ(0, RVH.AURWCalls);
275
  BitcastV.reset();
276
  EXPECT_EQ(1, RVH.DeletedCalls);
277
  EXPECT_EQ(0, RVH.AURWCalls);
278
}
279

280
TEST_F(ValueHandle, CallbackVH_CallbackOnRAUW) {
281
  class RecordingVH final : public CallbackVH {
282
  public:
283
    int DeletedCalls;
284
    Value *AURWArgument;
285

286
    RecordingVH() : DeletedCalls(0), AURWArgument(nullptr) {}
287
    RecordingVH(Value *V)
288
      : CallbackVH(V), DeletedCalls(0), AURWArgument(nullptr) {}
289

290
  private:
291
    void deleted() override {
292
      DeletedCalls++;
293
      CallbackVH::deleted();
294
    }
295
    void allUsesReplacedWith(Value *new_value) override {
296
      EXPECT_EQ(nullptr, AURWArgument);
297
      AURWArgument = new_value;
298
    }
299
  };
300

301
  RecordingVH RVH;
302
  RVH = BitcastV.get();
303
  EXPECT_EQ(0, RVH.DeletedCalls);
304
  EXPECT_EQ(nullptr, RVH.AURWArgument);
305
  BitcastV->replaceAllUsesWith(ConstantV);
306
  EXPECT_EQ(0, RVH.DeletedCalls);
307
  EXPECT_EQ(ConstantV, RVH.AURWArgument);
308
}
309

310
TEST_F(ValueHandle, CallbackVH_DeletionCanRAUW) {
311
  class RecoveringVH final : public CallbackVH {
312
  public:
313
    int DeletedCalls;
314
    Value *AURWArgument;
315
    LLVMContext *Context;
316

317
    RecoveringVH(LLVMContext &TheContext)
318
        : DeletedCalls(0), AURWArgument(nullptr), Context(&TheContext) {}
319

320
    RecoveringVH(LLVMContext &TheContext, Value *V)
321
        : CallbackVH(V), DeletedCalls(0), AURWArgument(nullptr),
322
          Context(&TheContext) {}
323

324
  private:
325
    void deleted() override {
326
      getValPtr()->replaceAllUsesWith(
327
          Constant::getNullValue(Type::getInt32Ty(*Context)));
328
      setValPtr(nullptr);
329
    }
330
    void allUsesReplacedWith(Value *new_value) override {
331
      ASSERT_TRUE(nullptr != getValPtr());
332
      EXPECT_EQ(1U, getValPtr()->getNumUses());
333
      EXPECT_EQ(nullptr, AURWArgument);
334
      AURWArgument = new_value;
335
    }
336
  };
337

338
  // Normally, if a value has uses, deleting it will crash.  However, we can use
339
  // a CallbackVH to remove the uses before the check for no uses.
340
  RecoveringVH RVH(Context);
341
  RVH = RecoveringVH(Context, BitcastV.get());
342
  std::unique_ptr<BinaryOperator> BitcastUser(BinaryOperator::CreateAdd(
343
      RVH, Constant::getNullValue(Type::getInt32Ty(Context))));
344
  EXPECT_EQ(BitcastV.get(), BitcastUser->getOperand(0));
345
  BitcastV.reset();  // Would crash without the ValueHandler.
346
  EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(Context)),
347
            RVH.AURWArgument);
348
  EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(Context)),
349
            BitcastUser->getOperand(0));
350
}
351

352
TEST_F(ValueHandle, DestroyingOtherVHOnSameValueDoesntBreakIteration) {
353
  // When a CallbackVH modifies other ValueHandles in its callbacks,
354
  // that shouldn't interfere with non-modified ValueHandles receiving
355
  // their appropriate callbacks.
356
  //
357
  // We create the active CallbackVH in the middle of a palindromic
358
  // arrangement of other VHs so that the bad behavior would be
359
  // triggered in whichever order callbacks run.
360

361
  class DestroyingVH final : public CallbackVH {
362
  public:
363
    std::unique_ptr<WeakTrackingVH> ToClear[2];
364
    DestroyingVH(Value *V) {
365
      ToClear[0].reset(new WeakTrackingVH(V));
366
      setValPtr(V);
367
      ToClear[1].reset(new WeakTrackingVH(V));
368
    }
369
    void deleted() override {
370
      ToClear[0].reset();
371
      ToClear[1].reset();
372
      CallbackVH::deleted();
373
    }
374
    void allUsesReplacedWith(Value *) override {
375
      ToClear[0].reset();
376
      ToClear[1].reset();
377
    }
378
  };
379

380
  {
381
    WeakTrackingVH ShouldBeVisited1(BitcastV.get());
382
    DestroyingVH C(BitcastV.get());
383
    WeakTrackingVH ShouldBeVisited2(BitcastV.get());
384

385
    BitcastV->replaceAllUsesWith(ConstantV);
386
    EXPECT_EQ(ConstantV, static_cast<Value*>(ShouldBeVisited1));
387
    EXPECT_EQ(ConstantV, static_cast<Value*>(ShouldBeVisited2));
388
  }
389

390
  {
391
    WeakTrackingVH ShouldBeVisited1(BitcastV.get());
392
    DestroyingVH C(BitcastV.get());
393
    WeakTrackingVH ShouldBeVisited2(BitcastV.get());
394

395
    BitcastV.reset();
396
    EXPECT_EQ(nullptr, static_cast<Value*>(ShouldBeVisited1));
397
    EXPECT_EQ(nullptr, static_cast<Value*>(ShouldBeVisited2));
398
  }
399
}
400

401
TEST_F(ValueHandle, AssertingVHCheckedLast) {
402
  // If a CallbackVH exists to clear out a group of AssertingVHs on
403
  // Value deletion, the CallbackVH should get a chance to do so
404
  // before the AssertingVHs assert.
405

406
  class ClearingVH final : public CallbackVH {
407
  public:
408
    AssertingVH<Value> *ToClear[2];
409
    ClearingVH(Value *V,
410
               AssertingVH<Value> &A0, AssertingVH<Value> &A1)
411
      : CallbackVH(V) {
412
      ToClear[0] = &A0;
413
      ToClear[1] = &A1;
414
    }
415

416
    void deleted() override {
417
      *ToClear[0] = nullptr;
418
      *ToClear[1] = nullptr;
419
      CallbackVH::deleted();
420
    }
421
  };
422

423
  AssertingVH<Value> A1, A2;
424
  A1 = BitcastV.get();
425
  ClearingVH C(BitcastV.get(), A1, A2);
426
  A2 = BitcastV.get();
427
  // C.deleted() should run first, clearing the two AssertingVHs,
428
  // which should prevent them from asserting.
429
  BitcastV.reset();
430
}
431

432
TEST_F(ValueHandle, PoisoningVH_BasicOperation) {
433
  PoisoningVH<CastInst> VH(BitcastV.get());
434
  CastInst *implicit_to_exact_type = VH;
435
  (void)implicit_to_exact_type; // Avoid warning.
436

437
  PoisoningVH<Value> GenericVH(BitcastV.get());
438
  EXPECT_EQ(BitcastV.get(), GenericVH);
439
  GenericVH = ConstantV;
440
  EXPECT_EQ(ConstantV, GenericVH);
441

442
  // Make sure I can call a method on the underlying CastInst.  It
443
  // doesn't matter which method.
444
  EXPECT_FALSE(VH->mayWriteToMemory());
445
  EXPECT_FALSE((*VH).mayWriteToMemory());
446
}
447

448
TEST_F(ValueHandle, PoisoningVH_Const) {
449
  const CastInst *ConstBitcast = BitcastV.get();
450
  PoisoningVH<const CastInst> VH(ConstBitcast);
451
  const CastInst *implicit_to_exact_type = VH;
452
  (void)implicit_to_exact_type; // Avoid warning.
453
}
454

455
TEST_F(ValueHandle, PoisoningVH_Comparisons) {
456
  PoisoningVH<Value> BitcastVH(BitcastV.get());
457
  PoisoningVH<Value> ConstantVH(ConstantV);
458

459
  EXPECT_TRUE(BitcastVH == BitcastVH);
460
  EXPECT_TRUE(BitcastV.get() == BitcastVH);
461
  EXPECT_TRUE(BitcastVH == BitcastV.get());
462
  EXPECT_FALSE(BitcastVH == ConstantVH);
463

464
  EXPECT_TRUE(BitcastVH != ConstantVH);
465
  EXPECT_TRUE(BitcastV.get() != ConstantVH);
466
  EXPECT_TRUE(BitcastVH != ConstantV);
467
  EXPECT_FALSE(BitcastVH != BitcastVH);
468

469
  // Cast to Value* so comparisons work.
470
  Value *BV = BitcastV.get();
471
  Value *CV = ConstantV;
472
  EXPECT_EQ(BV < CV, BitcastVH < ConstantVH);
473
  EXPECT_EQ(BV <= CV, BitcastVH <= ConstantVH);
474
  EXPECT_EQ(BV > CV, BitcastVH > ConstantVH);
475
  EXPECT_EQ(BV >= CV, BitcastVH >= ConstantVH);
476

477
  EXPECT_EQ(BV < CV, BitcastV.get() < ConstantVH);
478
  EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantVH);
479
  EXPECT_EQ(BV > CV, BitcastV.get() > ConstantVH);
480
  EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantVH);
481

482
  EXPECT_EQ(BV < CV, BitcastVH < ConstantV);
483
  EXPECT_EQ(BV <= CV, BitcastVH <= ConstantV);
484
  EXPECT_EQ(BV > CV, BitcastVH > ConstantV);
485
  EXPECT_EQ(BV >= CV, BitcastVH >= ConstantV);
486
}
487

488
TEST_F(ValueHandle, PoisoningVH_DoesNotFollowRAUW) {
489
  PoisoningVH<Value> VH(BitcastV.get());
490
  BitcastV->replaceAllUsesWith(ConstantV);
491
  EXPECT_TRUE(DenseMapInfo<PoisoningVH<Value>>::isEqual(VH, BitcastV.get()));
492
}
493

494
TEST_F(ValueHandle, AssertingVH_DenseMap) {
495
  DenseMap<AssertingVH<Value>, int> Map;
496
  Map.insert({BitcastV.get(), 1});
497
  Map.insert({ConstantV, 2});
498
  // These will create a temporary AssertingVH during lookup.
499
  EXPECT_TRUE(Map.contains(BitcastV.get()));
500
  EXPECT_TRUE(Map.contains(ConstantV));
501
  // These will not create a temporary AssertingVH.
502
  EXPECT_TRUE(Map.find_as(BitcastV.get()) != Map.end());
503
  EXPECT_TRUE(Map.find_as(ConstantV) != Map.end());
504
}
505

506
TEST_F(ValueHandle, PoisoningVH_DenseMap) {
507
  DenseMap<PoisoningVH<Value>, int> Map;
508
  Map.insert({BitcastV.get(), 1});
509
  Map.insert({ConstantV, 2});
510
  // These will create a temporary PoisoningVH during lookup.
511
  EXPECT_TRUE(Map.contains(BitcastV.get()));
512
  EXPECT_TRUE(Map.contains(ConstantV));
513
  // These will not create a temporary PoisoningVH.
514
  EXPECT_TRUE(Map.find_as(BitcastV.get()) != Map.end());
515
  EXPECT_TRUE(Map.find_as(ConstantV) != Map.end());
516
}
517

518
#ifdef NDEBUG
519

520
TEST_F(ValueHandle, PoisoningVH_ReducesToPointer) {
521
  EXPECT_EQ(sizeof(CastInst *), sizeof(PoisoningVH<CastInst>));
522
}
523

524
#else // !NDEBUG
525

526
TEST_F(ValueHandle, TrackingVH_Tracks) {
527
  TrackingVH<Value> VH(BitcastV.get());
528
  BitcastV->replaceAllUsesWith(ConstantV);
529
  EXPECT_EQ(VH, ConstantV);
530
}
531

532
#ifdef GTEST_HAS_DEATH_TEST
533
#if LLVM_ENABLE_ABI_BREAKING_CHECKS
534

535
TEST_F(ValueHandle, PoisoningVH_Asserts) {
536
  PoisoningVH<Value> VH(BitcastV.get());
537

538
  // The poisoned handle shouldn't assert when the value is deleted.
539
  BitcastV.reset(new BitCastInst(ConstantV, Type::getInt32Ty(Context)));
540
  // But should when we access the handle.
541
  EXPECT_DEATH((void)*VH, "Accessed a poisoned value handle!");
542

543
  // Now check that poison catches RAUW.
544
  VH = BitcastV.get();
545
  // The replace doesn't trigger anything immediately.
546
  BitcastV->replaceAllUsesWith(ConstantV);
547
  // But a use does.
548
  EXPECT_DEATH((void)*VH, "Accessed a poisoned value handle!");
549

550
  // Don't clear anything out here as destroying the handles should be fine.
551
}
552

553
#endif // LLVM_ENABLE_ABI_BREAKING_CHECKS
554

555
TEST_F(ValueHandle, TrackingVH_Asserts) {
556
  {
557
    TrackingVH<Value> VH(BitcastV.get());
558

559
    // The tracking handle shouldn't assert when the value is deleted.
560
    BitcastV.reset(new BitCastInst(ConstantV, Type::getInt32Ty(Context)));
561
    // But should when we access the handle.
562
    EXPECT_DEATH((void)*VH,
563
                 "TrackingVH must be non-null and valid on dereference!");
564
  }
565

566
  {
567
    TrackingVH<Instruction> VH(BitcastV.get());
568

569
    BitcastV->replaceAllUsesWith(ConstantV);
570
    EXPECT_DEATH((void)*VH,
571
                 "Tracked Value was replaced by one with an invalid type!");
572
  }
573
}
574

575
#endif // GTEST_HAS_DEATH_TEST
576

577
#endif // NDEBUG
578
}
579