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 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 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(getGlobalContext()), WVH->getType()); 46 EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), (*WVH).getType()); 47 } 48 49 TEST_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 82 TEST_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 92 TEST_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 104 TEST_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 120 TEST_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 127 TEST_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 160 TEST_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 168 TEST_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 176 TEST_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 192 TEST_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 204 TEST_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 237 TEST_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 263 TEST_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 293 TEST_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 333 TEST_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 382 TEST_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