unittests/IR/ValueHandleTest.cpp

   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
  17 using namespace llvm;
  18
  19 namespace {
  20
  21 class ValueHandle : public testing::Test {
  22 protected:
  23   LLVMContext Context;
  24   Constant *ConstantV;
  25   std::unique_ptr<BitCastInst> BitcastV;
  26
  27   ValueHandle()
  28       : ConstantV(ConstantInt::get(Type::getInt32Ty(Context), 0)),
  29         BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(Context))) {}
  30 };
  31
  32 class ConcreteCallbackVH final : public CallbackVH {
  33 public:
  34   ConcreteCallbackVH(Value *V) : CallbackVH(V) {}
  35 };
  36
  37 TEST_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(Context), WVH->getType());
  46   EXPECT_EQ(Type::getInt32Ty(Context), (*WVH).getType());
  47
  48   WVH = BitcastV.get();
  49   BitcastV->replaceAllUsesWith(ConstantV);
  50   EXPECT_EQ(WVH, BitcastV.get());
  51   BitcastV.reset();
  52   EXPECT_EQ(WVH, nullptr);
  53 }
  54
  55 TEST_F(ValueHandle, WeakTrackingVH_BasicOperation) {
  56   WeakTrackingVH WVH(BitcastV.get());
  57   EXPECT_EQ(BitcastV.get(), WVH);
  58   WVH = ConstantV;
  59   EXPECT_EQ(ConstantV, WVH);
  60
  61   // Make sure I can call a method on the underlying Value.  It
  62   // doesn't matter which method.
  63   EXPECT_EQ(Type::getInt32Ty(Context), WVH->getType());
  64   EXPECT_EQ(Type::getInt32Ty(Context), (*WVH).getType());
  65 }
  66
  67 TEST_F(ValueHandle, WeakTrackingVH_Comparisons) {
  68   WeakTrackingVH BitcastWVH(BitcastV.get());
  69   WeakTrackingVH ConstantWVH(ConstantV);
  70
  71   EXPECT_TRUE(BitcastWVH == BitcastWVH);
  72   EXPECT_TRUE(BitcastV.get() == BitcastWVH);
  73   EXPECT_TRUE(BitcastWVH == BitcastV.get());
  74   EXPECT_FALSE(BitcastWVH == ConstantWVH);
  75
  76   EXPECT_TRUE(BitcastWVH != ConstantWVH);
  77   EXPECT_TRUE(BitcastV.get() != ConstantWVH);
  78   EXPECT_TRUE(BitcastWVH != ConstantV);
  79   EXPECT_FALSE(BitcastWVH != BitcastWVH);
  80
  81   // Cast to Value* so comparisons work.
  82   Value *BV = BitcastV.get();
  83   Value *CV = ConstantV;
  84   EXPECT_EQ(BV < CV, BitcastWVH < ConstantWVH);
  85   EXPECT_EQ(BV <= CV, BitcastWVH <= ConstantWVH);
  86   EXPECT_EQ(BV > CV, BitcastWVH > ConstantWVH);
  87   EXPECT_EQ(BV >= CV, BitcastWVH >= ConstantWVH);
  88
  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   EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantWVH);
  93
  94   EXPECT_EQ(BV < CV, BitcastWVH < ConstantV);
  95   EXPECT_EQ(BV <= CV, BitcastWVH <= ConstantV);
  96   EXPECT_EQ(BV > CV, BitcastWVH > ConstantV);
  97   EXPECT_EQ(BV >= CV, BitcastWVH >= ConstantV);
  98 }
  99
 100 TEST_F(ValueHandle, WeakTrackingVH_FollowsRAUW) {
 101   WeakTrackingVH WVH(BitcastV.get());
 102   WeakTrackingVH WVH_Copy(WVH);
 103   WeakTrackingVH WVH_Recreated(BitcastV.get());
 104   BitcastV->replaceAllUsesWith(ConstantV);
 105   EXPECT_EQ(ConstantV, WVH);
 106   EXPECT_EQ(ConstantV, WVH_Copy);
 107   EXPECT_EQ(ConstantV, WVH_Recreated);
 108 }
 109
 110 TEST_F(ValueHandle, WeakTrackingVH_NullOnDeletion) {
 111   WeakTrackingVH WVH(BitcastV.get());
 112   WeakTrackingVH WVH_Copy(WVH);
 113   WeakTrackingVH WVH_Recreated(BitcastV.get());
 114   BitcastV.reset();
 115   Value *null_value = nullptr;
 116   EXPECT_EQ(null_value, WVH);
 117   EXPECT_EQ(null_value, WVH_Copy);
 118   EXPECT_EQ(null_value, WVH_Recreated);
 119 }
 120
 121
 122 TEST_F(ValueHandle, AssertingVH_BasicOperation) {
 123   AssertingVH<CastInst> AVH(BitcastV.get());
 124   CastInst *implicit_to_exact_type = AVH;
 125   (void)implicit_to_exact_type;  // Avoid warning.
 126
 127   AssertingVH<Value> GenericAVH(BitcastV.get());
 128   EXPECT_EQ(BitcastV.get(), GenericAVH);
 129   GenericAVH = ConstantV;
 130   EXPECT_EQ(ConstantV, GenericAVH);
 131
 132   // Make sure I can call a method on the underlying CastInst.  It
 133   // doesn't matter which method.
 134   EXPECT_FALSE(AVH->mayWriteToMemory());
 135   EXPECT_FALSE((*AVH).mayWriteToMemory());
 136 }
 137
 138 TEST_F(ValueHandle, AssertingVH_Const) {
 139   const CastInst *ConstBitcast = BitcastV.get();
 140   AssertingVH<const CastInst> AVH(ConstBitcast);
 141   const CastInst *implicit_to_exact_type = AVH;
 142   (void)implicit_to_exact_type;  // Avoid warning.
 143 }
 144
 145 TEST_F(ValueHandle, AssertingVH_Comparisons) {
 146   AssertingVH<Value> BitcastAVH(BitcastV.get());
 147   AssertingVH<Value> ConstantAVH(ConstantV);
 148
 149   EXPECT_TRUE(BitcastAVH == BitcastAVH);
 150   EXPECT_TRUE(BitcastV.get() == BitcastAVH);
 151   EXPECT_TRUE(BitcastAVH == BitcastV.get());
 152   EXPECT_FALSE(BitcastAVH == ConstantAVH);
 153
 154   EXPECT_TRUE(BitcastAVH != ConstantAVH);
 155   EXPECT_TRUE(BitcastV.get() != ConstantAVH);
 156   EXPECT_TRUE(BitcastAVH != ConstantV);
 157   EXPECT_FALSE(BitcastAVH != BitcastAVH);
 158
 159   // Cast to Value* so comparisons work.
 160   Value *BV = BitcastV.get();
 161   Value *CV = ConstantV;
 162   EXPECT_EQ(BV < CV, BitcastAVH < ConstantAVH);
 163   EXPECT_EQ(BV <= CV, BitcastAVH <= ConstantAVH);
 164   EXPECT_EQ(BV > CV, BitcastAVH > ConstantAVH);
 165   EXPECT_EQ(BV >= CV, BitcastAVH >= ConstantAVH);
 166
 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   EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantAVH);
 171
 172   EXPECT_EQ(BV < CV, BitcastAVH < ConstantV);
 173   EXPECT_EQ(BV <= CV, BitcastAVH <= ConstantV);
 174   EXPECT_EQ(BV > CV, BitcastAVH > ConstantV);
 175   EXPECT_EQ(BV >= CV, BitcastAVH >= ConstantV);
 176 }
 177
 178 TEST_F(ValueHandle, AssertingVH_DoesNotFollowRAUW) {
 179   AssertingVH<Value> AVH(BitcastV.get());
 180   BitcastV->replaceAllUsesWith(ConstantV);
 181   EXPECT_EQ(BitcastV.get(), AVH);
 182 }
 183
 184 #ifdef NDEBUG
 185
 186 TEST_F(ValueHandle, AssertingVH_ReducesToPointer) {
 187   EXPECT_EQ(sizeof(CastInst *), sizeof(AssertingVH<CastInst>));
 188 }
 189
 190 #else  // !NDEBUG
 191
 192 #ifdef GTEST_HAS_DEATH_TEST
 193
 194 TEST_F(ValueHandle, AssertingVH_Asserts) {
 195   AssertingVH<Value> AVH(BitcastV.get());
 196   EXPECT_DEATH({BitcastV.reset();},
 197                "An asserting value handle still pointed to this value!");
 198   AssertingVH<Value> Copy(AVH);
 199   AVH = nullptr;
 200   EXPECT_DEATH({BitcastV.reset();},
 201                "An asserting value handle still pointed to this value!");
 202   Copy = nullptr;
 203   BitcastV.reset();
 204 }
 205
 206 #endif  // GTEST_HAS_DEATH_TEST
 207
 208 #endif  // NDEBUG
 209
 210 TEST_F(ValueHandle, CallbackVH_BasicOperation) {
 211   ConcreteCallbackVH CVH(BitcastV.get());
 212   EXPECT_EQ(BitcastV.get(), CVH);
 213   CVH = ConstantV;
 214   EXPECT_EQ(ConstantV, CVH);
 215
 216   // Make sure I can call a method on the underlying Value.  It
 217   // doesn't matter which method.
 218   EXPECT_EQ(Type::getInt32Ty(Context), CVH->getType());
 219   EXPECT_EQ(Type::getInt32Ty(Context), (*CVH).getType());
 220 }
 221
 222 TEST_F(ValueHandle, CallbackVH_Comparisons) {
 223   ConcreteCallbackVH BitcastCVH(BitcastV.get());
 224   ConcreteCallbackVH ConstantCVH(ConstantV);
 225
 226   EXPECT_TRUE(BitcastCVH == BitcastCVH);
 227   EXPECT_TRUE(BitcastV.get() == BitcastCVH);
 228   EXPECT_TRUE(BitcastCVH == BitcastV.get());
 229   EXPECT_FALSE(BitcastCVH == ConstantCVH);
 230
 231   EXPECT_TRUE(BitcastCVH != ConstantCVH);
 232   EXPECT_TRUE(BitcastV.get() != ConstantCVH);
 233   EXPECT_TRUE(BitcastCVH != ConstantV);
 234   EXPECT_FALSE(BitcastCVH != BitcastCVH);
 235
 236   // Cast to Value* so comparisons work.
 237   Value *BV = BitcastV.get();
 238   Value *CV = ConstantV;
 239   EXPECT_EQ(BV < CV, BitcastCVH < ConstantCVH);
 240   EXPECT_EQ(BV <= CV, BitcastCVH <= ConstantCVH);
 241   EXPECT_EQ(BV > CV, BitcastCVH > ConstantCVH);
 242   EXPECT_EQ(BV >= CV, BitcastCVH >= ConstantCVH);
 243
 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   EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantCVH);
 248
 249   EXPECT_EQ(BV < CV, BitcastCVH < ConstantV);
 250   EXPECT_EQ(BV <= CV, BitcastCVH <= ConstantV);
 251   EXPECT_EQ(BV > CV, BitcastCVH > ConstantV);
 252   EXPECT_EQ(BV >= CV, BitcastCVH >= ConstantV);
 253 }
 254
 255 TEST_F(ValueHandle, CallbackVH_CallbackOnDeletion) {
 256   class RecordingVH final : public CallbackVH {
 257   public:
 258     int DeletedCalls;
 259     int AURWCalls;
 260
 261     RecordingVH() : DeletedCalls(0), AURWCalls(0) {}
 262     RecordingVH(Value *V) : CallbackVH(V), DeletedCalls(0), AURWCalls(0) {}
 263
 264   private:
 265     void deleted() override {
 266       DeletedCalls++;
 267       CallbackVH::deleted();
 268     }
 269     void allUsesReplacedWith(Value *) override { AURWCalls++; }
 270   };
 271
 272   RecordingVH RVH;
 273   RVH = BitcastV.get();
 274   EXPECT_EQ(0, RVH.DeletedCalls);
 275   EXPECT_EQ(0, RVH.AURWCalls);
 276   BitcastV.reset();
 277   EXPECT_EQ(1, RVH.DeletedCalls);
 278   EXPECT_EQ(0, RVH.AURWCalls);
 279 }
 280
 281 TEST_F(ValueHandle, CallbackVH_CallbackOnRAUW) {
 282   class RecordingVH final : public CallbackVH {
 283   public:
 284     int DeletedCalls;
 285     Value *AURWArgument;
 286
 287     RecordingVH() : DeletedCalls(0), AURWArgument(nullptr) {}
 288     RecordingVH(Value *V)
 289       : CallbackVH(V), DeletedCalls(0), AURWArgument(nullptr) {}
 290
 291   private:
 292     void deleted() override {
 293       DeletedCalls++;
 294       CallbackVH::deleted();
 295     }
 296     void allUsesReplacedWith(Value *new_value) override {
 297       EXPECT_EQ(nullptr, AURWArgument);
 298       AURWArgument = new_value;
 299     }
 300   };
 301
 302   RecordingVH RVH;
 303   RVH = BitcastV.get();
 304   EXPECT_EQ(0, RVH.DeletedCalls);
 305   EXPECT_EQ(nullptr, RVH.AURWArgument);
 306   BitcastV->replaceAllUsesWith(ConstantV);
 307   EXPECT_EQ(0, RVH.DeletedCalls);
 308   EXPECT_EQ(ConstantV, RVH.AURWArgument);
 309 }
 310
 311 TEST_F(ValueHandle, CallbackVH_DeletionCanRAUW) {
 312   class RecoveringVH final : public CallbackVH {
 313   public:
 314     int DeletedCalls;
 315     Value *AURWArgument;
 316     LLVMContext *Context;
 317
 318     RecoveringVH(LLVMContext &TheContext)
 319         : DeletedCalls(0), AURWArgument(nullptr), Context(&TheContext) {}
 320
 321     RecoveringVH(LLVMContext &TheContext, Value *V)
 322         : CallbackVH(V), DeletedCalls(0), AURWArgument(nullptr),
 323           Context(&TheContext) {}
 324
 325   private:
 326     void deleted() override {
 327       getValPtr()->replaceAllUsesWith(
 328           Constant::getNullValue(Type::getInt32Ty(*Context)));
 329       setValPtr(nullptr);
 330     }
 331     void allUsesReplacedWith(Value *new_value) override {
 332       ASSERT_TRUE(nullptr != getValPtr());
 333       EXPECT_EQ(1U, getValPtr()->getNumUses());
 334       EXPECT_EQ(nullptr, AURWArgument);
 335       AURWArgument = new_value;
 336     }
 337   };
 338
 339   // Normally, if a value has uses, deleting it will crash.  However, we can use
 340   // a CallbackVH to remove the uses before the check for no uses.
 341   RecoveringVH RVH(Context);
 342   RVH = RecoveringVH(Context, BitcastV.get());
 343   std::unique_ptr<BinaryOperator> BitcastUser(BinaryOperator::CreateAdd(
 344       RVH, Constant::getNullValue(Type::getInt32Ty(Context))));
 345   EXPECT_EQ(BitcastV.get(), BitcastUser->getOperand(0));
 346   BitcastV.reset();  // Would crash without the ValueHandler.
 347   EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(Context)),
 348             RVH.AURWArgument);
 349   EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(Context)),
 350             BitcastUser->getOperand(0));
 351 }
 352
 353 TEST_F(ValueHandle, DestroyingOtherVHOnSameValueDoesntBreakIteration) {
 354   // When a CallbackVH modifies other ValueHandles in its callbacks,
 355   // that shouldn't interfere with non-modified ValueHandles receiving
 356   // their appropriate callbacks.
 357   //
 358   // We create the active CallbackVH in the middle of a palindromic
 359   // arrangement of other VHs so that the bad behavior would be
 360   // triggered in whichever order callbacks run.
 361
 362   class DestroyingVH final : public CallbackVH {
 363   public:
 364     std::unique_ptr<WeakTrackingVH> ToClear[2];
 365     DestroyingVH(Value *V) {
 366       ToClear[0].reset(new WeakTrackingVH(V));
 367       setValPtr(V);
 368       ToClear[1].reset(new WeakTrackingVH(V));
 369     }
 370     void deleted() override {
 371       ToClear[0].reset();
 372       ToClear[1].reset();
 373       CallbackVH::deleted();
 374     }
 375     void allUsesReplacedWith(Value *) override {
 376       ToClear[0].reset();
 377       ToClear[1].reset();
 378     }
 379   };
 380
 381   {
 382     WeakTrackingVH ShouldBeVisited1(BitcastV.get());
 383     DestroyingVH C(BitcastV.get());
 384     WeakTrackingVH ShouldBeVisited2(BitcastV.get());
 385
 386     BitcastV->replaceAllUsesWith(ConstantV);
 387     EXPECT_EQ(ConstantV, static_cast<Value*>(ShouldBeVisited1));
 388     EXPECT_EQ(ConstantV, static_cast<Value*>(ShouldBeVisited2));
 389   }
 390
 391   {
 392     WeakTrackingVH ShouldBeVisited1(BitcastV.get());
 393     DestroyingVH C(BitcastV.get());
 394     WeakTrackingVH ShouldBeVisited2(BitcastV.get());
 395
 396     BitcastV.reset();
 397     EXPECT_EQ(nullptr, static_cast<Value*>(ShouldBeVisited1));
 398     EXPECT_EQ(nullptr, static_cast<Value*>(ShouldBeVisited2));
 399   }
 400 }
 401
 402 TEST_F(ValueHandle, AssertingVHCheckedLast) {
 403   // If a CallbackVH exists to clear out a group of AssertingVHs on
 404   // Value deletion, the CallbackVH should get a chance to do so
 405   // before the AssertingVHs assert.
 406
 407   class ClearingVH final : public CallbackVH {
 408   public:
 409     AssertingVH<Value> *ToClear[2];
 410     ClearingVH(Value *V,
 411                AssertingVH<Value> &A0, AssertingVH<Value> &A1)
 412       : CallbackVH(V) {
 413       ToClear[0] = &A0;
 414       ToClear[1] = &A1;
 415     }
 416
 417     void deleted() override {
 418       *ToClear[0] = nullptr;
 419       *ToClear[1] = nullptr;
 420       CallbackVH::deleted();
 421     }
 422   };
 423
 424   AssertingVH<Value> A1, A2;
 425   A1 = BitcastV.get();
 426   ClearingVH C(BitcastV.get(), A1, A2);
 427   A2 = BitcastV.get();
 428   // C.deleted() should run first, clearing the two AssertingVHs,
 429   // which should prevent them from asserting.
 430   BitcastV.reset();
 431 }
 432
 433 TEST_F(ValueHandle, PoisoningVH_BasicOperation) {
 434   PoisoningVH<CastInst> VH(BitcastV.get());
 435   CastInst *implicit_to_exact_type = VH;
 436   (void)implicit_to_exact_type; // Avoid warning.
 437
 438   PoisoningVH<Value> GenericVH(BitcastV.get());
 439   EXPECT_EQ(BitcastV.get(), GenericVH);
 440   GenericVH = ConstantV;
 441   EXPECT_EQ(ConstantV, GenericVH);
 442
 443   // Make sure I can call a method on the underlying CastInst.  It
 444   // doesn't matter which method.
 445   EXPECT_FALSE(VH->mayWriteToMemory());
 446   EXPECT_FALSE((*VH).mayWriteToMemory());
 447 }
 448
 449 TEST_F(ValueHandle, PoisoningVH_Const) {
 450   const CastInst *ConstBitcast = BitcastV.get();
 451   PoisoningVH<const CastInst> VH(ConstBitcast);
 452   const CastInst *implicit_to_exact_type = VH;
 453   (void)implicit_to_exact_type; // Avoid warning.
 454 }
 455
 456 TEST_F(ValueHandle, PoisoningVH_Comparisons) {
 457   PoisoningVH<Value> BitcastVH(BitcastV.get());
 458   PoisoningVH<Value> ConstantVH(ConstantV);
 459
 460   EXPECT_TRUE(BitcastVH == BitcastVH);
 461   EXPECT_TRUE(BitcastV.get() == BitcastVH);
 462   EXPECT_TRUE(BitcastVH == BitcastV.get());
 463   EXPECT_FALSE(BitcastVH == ConstantVH);
 464
 465   EXPECT_TRUE(BitcastVH != ConstantVH);
 466   EXPECT_TRUE(BitcastV.get() != ConstantVH);
 467   EXPECT_TRUE(BitcastVH != ConstantV);
 468   EXPECT_FALSE(BitcastVH != BitcastVH);
 469
 470   // Cast to Value* so comparisons work.
 471   Value *BV = BitcastV.get();
 472   Value *CV = ConstantV;
 473   EXPECT_EQ(BV < CV, BitcastVH < ConstantVH);
 474   EXPECT_EQ(BV <= CV, BitcastVH <= ConstantVH);
 475   EXPECT_EQ(BV > CV, BitcastVH > ConstantVH);
 476   EXPECT_EQ(BV >= CV, BitcastVH >= ConstantVH);
 477
 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   EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantVH);
 482
 483   EXPECT_EQ(BV < CV, BitcastVH < ConstantV);
 484   EXPECT_EQ(BV <= CV, BitcastVH <= ConstantV);
 485   EXPECT_EQ(BV > CV, BitcastVH > ConstantV);
 486   EXPECT_EQ(BV >= CV, BitcastVH >= ConstantV);
 487 }
 488
 489 TEST_F(ValueHandle, PoisoningVH_DoesNotFollowRAUW) {
 490   PoisoningVH<Value> VH(BitcastV.get());
 491   BitcastV->replaceAllUsesWith(ConstantV);
 492   EXPECT_TRUE(DenseMapInfo<PoisoningVH<Value>>::isEqual(VH, BitcastV.get()));
 493 }
 494
 495 #ifdef NDEBUG
 496
 497 TEST_F(ValueHandle, PoisoningVH_ReducesToPointer) {
 498   EXPECT_EQ(sizeof(CastInst *), sizeof(PoisoningVH<CastInst>));
 499 }
 500
 501 #else // !NDEBUG
 502
 503 TEST_F(ValueHandle, TrackingVH_Tracks) {
 504   TrackingVH<Value> VH(BitcastV.get());
 505   BitcastV->replaceAllUsesWith(ConstantV);
 506   EXPECT_EQ(VH, ConstantV);
 507 }
 508
 509 #ifdef GTEST_HAS_DEATH_TEST
 510
 511 TEST_F(ValueHandle, PoisoningVH_Asserts) {
 512   PoisoningVH<Value> VH(BitcastV.get());
 513
 514   // The poisoned handle shouldn't assert when the value is deleted.
 515   BitcastV.reset(new BitCastInst(ConstantV, Type::getInt32Ty(Context)));
 516   // But should when we access the handle.
 517   EXPECT_DEATH((void)*VH, "Accessed a poisoned value handle!");
 518
 519   // Now check that poison catches RAUW.
 520   VH = BitcastV.get();
 521   // The replace doesn't trigger anything immediately.
 522   BitcastV->replaceAllUsesWith(ConstantV);
 523   // But a use does.
 524   EXPECT_DEATH((void)*VH, "Accessed a poisoned value handle!");
 525
 526   // Don't clear anything out here as destroying the handles should be fine.
 527 }
 528
 529 TEST_F(ValueHandle, TrackingVH_Asserts) {
 530   {
 531     TrackingVH<Value> VH(BitcastV.get());
 532
 533     // The tracking handle shouldn't assert when the value is deleted.
 534     BitcastV.reset(new BitCastInst(ConstantV, Type::getInt32Ty(Context)));
 535     // But should when we access the handle.
 536     EXPECT_DEATH((void)*VH,
 537                  "TrackingVH must be non-null and valid on dereference!");
 538   }
 539
 540   {
 541     TrackingVH<Instruction> VH(BitcastV.get());
 542
 543     BitcastV->replaceAllUsesWith(ConstantV);
 544     EXPECT_DEATH((void)*VH,
 545                  "Tracked Value was replaced by one with an invalid type!");
 546   }
 547 }
 548
 549 #endif // GTEST_HAS_DEATH_TEST
 550
 551 #endif // NDEBUG
 552 }