unittests/Support/ValueHandleTest.cpp

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