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