1 //===- ObjCARCContract.cpp - ObjC ARC Optimization ------------------------===// 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 /// \file 9 /// This file defines late ObjC ARC optimizations. ARC stands for Automatic 10 /// Reference Counting and is a system for managing reference counts for objects 11 /// in Objective C. 12 /// 13 /// This specific file mainly deals with ``contracting'' multiple lower level 14 /// operations into singular higher level operations through pattern matching. 15 /// 16 /// WARNING: This file knows about certain library functions. It recognizes them 17 /// by name, and hardwires knowledge of their semantics. 18 /// 19 /// WARNING: This file knows about how certain Objective-C library functions are 20 /// used. Naive LLVM IR transformations which would otherwise be 21 /// behavior-preserving may break these assumptions. 22 /// 23 //===----------------------------------------------------------------------===// 24 25 // TODO: ObjCARCContract could insert PHI nodes when uses aren't 26 // dominated by single calls. 27 28 #include "ARCRuntimeEntryPoints.h" 29 #include "DependencyAnalysis.h" 30 #include "ObjCARC.h" 31 #include "ProvenanceAnalysis.h" 32 #include "llvm/ADT/Statistic.h" 33 #include "llvm/Analysis/AliasAnalysis.h" 34 #include "llvm/Analysis/EHPersonalities.h" 35 #include "llvm/Analysis/ObjCARCUtil.h" 36 #include "llvm/IR/Dominators.h" 37 #include "llvm/IR/InlineAsm.h" 38 #include "llvm/IR/InstIterator.h" 39 #include "llvm/IR/Operator.h" 40 #include "llvm/IR/PassManager.h" 41 #include "llvm/InitializePasses.h" 42 #include "llvm/Support/CommandLine.h" 43 #include "llvm/Support/Debug.h" 44 #include "llvm/Support/raw_ostream.h" 45 #include "llvm/Transforms/ObjCARC.h" 46 47 using namespace llvm; 48 using namespace llvm::objcarc; 49 50 #define DEBUG_TYPE "objc-arc-contract" 51 52 STATISTIC(NumPeeps, "Number of calls peephole-optimized"); 53 STATISTIC(NumStoreStrongs, "Number objc_storeStrong calls formed"); 54 55 //===----------------------------------------------------------------------===// 56 // Declarations 57 //===----------------------------------------------------------------------===// 58 59 namespace { 60 /// Late ARC optimizations 61 /// 62 /// These change the IR in a way that makes it difficult to be analyzed by 63 /// ObjCARCOpt, so it's run late. 64 65 class ObjCARCContract { 66 bool Changed; 67 bool CFGChanged; 68 AAResults *AA; 69 DominatorTree *DT; 70 ProvenanceAnalysis PA; 71 ARCRuntimeEntryPoints EP; 72 BundledRetainClaimRVs *BundledInsts = nullptr; 73 74 /// The inline asm string to insert between calls and RetainRV calls to make 75 /// the optimization work on targets which need it. 76 const MDString *RVInstMarker; 77 78 /// The set of inserted objc_storeStrong calls. If at the end of walking the 79 /// function we have found no alloca instructions, these calls can be marked 80 /// "tail". 81 SmallPtrSet<CallInst *, 8> StoreStrongCalls; 82 83 /// Returns true if we eliminated Inst. 84 bool tryToPeepholeInstruction( 85 Function &F, Instruction *Inst, inst_iterator &Iter, 86 bool &TailOkForStoreStrong, 87 const DenseMap<BasicBlock *, ColorVector> &BlockColors); 88 89 bool optimizeRetainCall(Function &F, Instruction *Retain); 90 91 bool contractAutorelease(Function &F, Instruction *Autorelease, 92 ARCInstKind Class); 93 94 void tryToContractReleaseIntoStoreStrong( 95 Instruction *Release, inst_iterator &Iter, 96 const DenseMap<BasicBlock *, ColorVector> &BlockColors); 97 98 public: 99 bool init(Module &M); 100 bool run(Function &F, AAResults *AA, DominatorTree *DT); 101 bool hasCFGChanged() const { return CFGChanged; } 102 }; 103 104 class ObjCARCContractLegacyPass : public FunctionPass { 105 ObjCARCContract OCARCC; 106 107 public: 108 void getAnalysisUsage(AnalysisUsage &AU) const override; 109 bool doInitialization(Module &M) override; 110 bool runOnFunction(Function &F) override; 111 112 static char ID; 113 ObjCARCContractLegacyPass() : FunctionPass(ID) { 114 initializeObjCARCContractLegacyPassPass(*PassRegistry::getPassRegistry()); 115 } 116 }; 117 } 118 119 //===----------------------------------------------------------------------===// 120 // Implementation 121 //===----------------------------------------------------------------------===// 122 123 /// Turn objc_retain into objc_retainAutoreleasedReturnValue if the operand is a 124 /// return value. We do this late so we do not disrupt the dataflow analysis in 125 /// ObjCARCOpt. 126 bool ObjCARCContract::optimizeRetainCall(Function &F, Instruction *Retain) { 127 const auto *Call = dyn_cast<CallBase>(GetArgRCIdentityRoot(Retain)); 128 if (!Call) 129 return false; 130 if (Call->getParent() != Retain->getParent()) 131 return false; 132 133 // Check that the call is next to the retain. 134 BasicBlock::const_iterator I = ++Call->getIterator(); 135 while (IsNoopInstruction(&*I)) 136 ++I; 137 if (&*I != Retain) 138 return false; 139 140 // Turn it to an objc_retainAutoreleasedReturnValue. 141 Changed = true; 142 ++NumPeeps; 143 144 LLVM_DEBUG( 145 dbgs() << "Transforming objc_retain => " 146 "objc_retainAutoreleasedReturnValue since the operand is a " 147 "return value.\nOld: " 148 << *Retain << "\n"); 149 150 // We do not have to worry about tail calls/does not throw since 151 // retain/retainRV have the same properties. 152 Function *Decl = EP.get(ARCRuntimeEntryPointKind::RetainRV); 153 cast<CallInst>(Retain)->setCalledFunction(Decl); 154 155 LLVM_DEBUG(dbgs() << "New: " << *Retain << "\n"); 156 return true; 157 } 158 159 /// Merge an autorelease with a retain into a fused call. 160 bool ObjCARCContract::contractAutorelease(Function &F, Instruction *Autorelease, 161 ARCInstKind Class) { 162 const Value *Arg = GetArgRCIdentityRoot(Autorelease); 163 164 // Check that there are no instructions between the retain and the autorelease 165 // (such as an autorelease_pop) which may change the count. 166 DependenceKind DK = Class == ARCInstKind::AutoreleaseRV 167 ? RetainAutoreleaseRVDep 168 : RetainAutoreleaseDep; 169 auto *Retain = dyn_cast_or_null<CallInst>( 170 findSingleDependency(DK, Arg, Autorelease->getParent(), Autorelease, PA)); 171 172 if (!Retain || GetBasicARCInstKind(Retain) != ARCInstKind::Retain || 173 GetArgRCIdentityRoot(Retain) != Arg) 174 return false; 175 176 Changed = true; 177 ++NumPeeps; 178 179 LLVM_DEBUG(dbgs() << " Fusing retain/autorelease!\n" 180 " Autorelease:" 181 << *Autorelease 182 << "\n" 183 " Retain: " 184 << *Retain << "\n"); 185 186 Function *Decl = EP.get(Class == ARCInstKind::AutoreleaseRV 187 ? ARCRuntimeEntryPointKind::RetainAutoreleaseRV 188 : ARCRuntimeEntryPointKind::RetainAutorelease); 189 Retain->setCalledFunction(Decl); 190 191 LLVM_DEBUG(dbgs() << " New RetainAutorelease: " << *Retain << "\n"); 192 193 EraseInstruction(Autorelease); 194 return true; 195 } 196 197 static StoreInst *findSafeStoreForStoreStrongContraction(LoadInst *Load, 198 Instruction *Release, 199 ProvenanceAnalysis &PA, 200 AAResults *AA) { 201 StoreInst *Store = nullptr; 202 bool SawRelease = false; 203 204 // Get the location associated with Load. 205 MemoryLocation Loc = MemoryLocation::get(Load); 206 auto *LocPtr = Loc.Ptr->stripPointerCasts(); 207 208 // Walk down to find the store and the release, which may be in either order. 209 for (auto I = std::next(BasicBlock::iterator(Load)), 210 E = Load->getParent()->end(); 211 I != E; ++I) { 212 // If we found the store we were looking for and saw the release, 213 // break. There is no more work to be done. 214 if (Store && SawRelease) 215 break; 216 217 // Now we know that we have not seen either the store or the release. If I 218 // is the release, mark that we saw the release and continue. 219 Instruction *Inst = &*I; 220 if (Inst == Release) { 221 SawRelease = true; 222 continue; 223 } 224 225 // Otherwise, we check if Inst is a "good" store. Grab the instruction class 226 // of Inst. 227 ARCInstKind Class = GetBasicARCInstKind(Inst); 228 229 // If Inst is an unrelated retain, we don't care about it. 230 // 231 // TODO: This is one area where the optimization could be made more 232 // aggressive. 233 if (IsRetain(Class)) 234 continue; 235 236 // If we have seen the store, but not the release... 237 if (Store) { 238 // We need to make sure that it is safe to move the release from its 239 // current position to the store. This implies proving that any 240 // instruction in between Store and the Release conservatively can not use 241 // the RCIdentityRoot of Release. If we can prove we can ignore Inst, so 242 // continue... 243 if (!CanUse(Inst, Load, PA, Class)) { 244 continue; 245 } 246 247 // Otherwise, be conservative and return nullptr. 248 return nullptr; 249 } 250 251 // Ok, now we know we have not seen a store yet. See if Inst can write to 252 // our load location, if it can not, just ignore the instruction. 253 if (!isModSet(AA->getModRefInfo(Inst, Loc))) 254 continue; 255 256 Store = dyn_cast<StoreInst>(Inst); 257 258 // If Inst can, then check if Inst is a simple store. If Inst is not a 259 // store or a store that is not simple, then we have some we do not 260 // understand writing to this memory implying we can not move the load 261 // over the write to any subsequent store that we may find. 262 if (!Store || !Store->isSimple()) 263 return nullptr; 264 265 // Then make sure that the pointer we are storing to is Ptr. If so, we 266 // found our Store! 267 if (Store->getPointerOperand()->stripPointerCasts() == LocPtr) 268 continue; 269 270 // Otherwise, we have an unknown store to some other ptr that clobbers 271 // Loc.Ptr. Bail! 272 return nullptr; 273 } 274 275 // If we did not find the store or did not see the release, fail. 276 if (!Store || !SawRelease) 277 return nullptr; 278 279 // We succeeded! 280 return Store; 281 } 282 283 static Instruction * 284 findRetainForStoreStrongContraction(Value *New, StoreInst *Store, 285 Instruction *Release, 286 ProvenanceAnalysis &PA) { 287 // Walk up from the Store to find the retain. 288 BasicBlock::iterator I = Store->getIterator(); 289 BasicBlock::iterator Begin = Store->getParent()->begin(); 290 while (I != Begin && GetBasicARCInstKind(&*I) != ARCInstKind::Retain) { 291 Instruction *Inst = &*I; 292 293 // It is only safe to move the retain to the store if we can prove 294 // conservatively that nothing besides the release can decrement reference 295 // counts in between the retain and the store. 296 if (CanDecrementRefCount(Inst, New, PA) && Inst != Release) 297 return nullptr; 298 --I; 299 } 300 Instruction *Retain = &*I; 301 if (GetBasicARCInstKind(Retain) != ARCInstKind::Retain) 302 return nullptr; 303 if (GetArgRCIdentityRoot(Retain) != New) 304 return nullptr; 305 return Retain; 306 } 307 308 /// Attempt to merge an objc_release with a store, load, and objc_retain to form 309 /// an objc_storeStrong. An objc_storeStrong: 310 /// 311 /// objc_storeStrong(i8** %old_ptr, i8* new_value) 312 /// 313 /// is equivalent to the following IR sequence: 314 /// 315 /// ; Load old value. 316 /// %old_value = load i8** %old_ptr (1) 317 /// 318 /// ; Increment the new value and then release the old value. This must occur 319 /// ; in order in case old_value releases new_value in its destructor causing 320 /// ; us to potentially have a dangling ptr. 321 /// tail call i8* @objc_retain(i8* %new_value) (2) 322 /// tail call void @objc_release(i8* %old_value) (3) 323 /// 324 /// ; Store the new_value into old_ptr 325 /// store i8* %new_value, i8** %old_ptr (4) 326 /// 327 /// The safety of this optimization is based around the following 328 /// considerations: 329 /// 330 /// 1. We are forming the store strong at the store. Thus to perform this 331 /// optimization it must be safe to move the retain, load, and release to 332 /// (4). 333 /// 2. We need to make sure that any re-orderings of (1), (2), (3), (4) are 334 /// safe. 335 void ObjCARCContract::tryToContractReleaseIntoStoreStrong( 336 Instruction *Release, inst_iterator &Iter, 337 const DenseMap<BasicBlock *, ColorVector> &BlockColors) { 338 // See if we are releasing something that we just loaded. 339 auto *Load = dyn_cast<LoadInst>(GetArgRCIdentityRoot(Release)); 340 if (!Load || !Load->isSimple()) 341 return; 342 343 // For now, require everything to be in one basic block. 344 BasicBlock *BB = Release->getParent(); 345 if (Load->getParent() != BB) 346 return; 347 348 // First scan down the BB from Load, looking for a store of the RCIdentityRoot 349 // of Load's 350 StoreInst *Store = 351 findSafeStoreForStoreStrongContraction(Load, Release, PA, AA); 352 // If we fail, bail. 353 if (!Store) 354 return; 355 356 // Then find what new_value's RCIdentity Root is. 357 Value *New = GetRCIdentityRoot(Store->getValueOperand()); 358 359 // Then walk up the BB and look for a retain on New without any intervening 360 // instructions which conservatively might decrement ref counts. 361 Instruction *Retain = 362 findRetainForStoreStrongContraction(New, Store, Release, PA); 363 364 // If we fail, bail. 365 if (!Retain) 366 return; 367 368 Changed = true; 369 ++NumStoreStrongs; 370 371 LLVM_DEBUG( 372 llvm::dbgs() << " Contracting retain, release into objc_storeStrong.\n" 373 << " Old:\n" 374 << " Store: " << *Store << "\n" 375 << " Release: " << *Release << "\n" 376 << " Retain: " << *Retain << "\n" 377 << " Load: " << *Load << "\n"); 378 379 LLVMContext &C = Release->getContext(); 380 Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C)); 381 Type *I8XX = PointerType::getUnqual(I8X); 382 383 Value *Args[] = { Load->getPointerOperand(), New }; 384 if (Args[0]->getType() != I8XX) 385 Args[0] = new BitCastInst(Args[0], I8XX, "", Store); 386 if (Args[1]->getType() != I8X) 387 Args[1] = new BitCastInst(Args[1], I8X, "", Store); 388 Function *Decl = EP.get(ARCRuntimeEntryPointKind::StoreStrong); 389 CallInst *StoreStrong = 390 objcarc::createCallInstWithColors(Decl, Args, "", Store, BlockColors); 391 StoreStrong->setDoesNotThrow(); 392 StoreStrong->setDebugLoc(Store->getDebugLoc()); 393 394 // We can't set the tail flag yet, because we haven't yet determined 395 // whether there are any escaping allocas. Remember this call, so that 396 // we can set the tail flag once we know it's safe. 397 StoreStrongCalls.insert(StoreStrong); 398 399 LLVM_DEBUG(llvm::dbgs() << " New Store Strong: " << *StoreStrong 400 << "\n"); 401 402 if (&*Iter == Retain) ++Iter; 403 if (&*Iter == Store) ++Iter; 404 Store->eraseFromParent(); 405 Release->eraseFromParent(); 406 EraseInstruction(Retain); 407 if (Load->use_empty()) 408 Load->eraseFromParent(); 409 } 410 411 bool ObjCARCContract::tryToPeepholeInstruction( 412 Function &F, Instruction *Inst, inst_iterator &Iter, 413 bool &TailOkForStoreStrongs, 414 const DenseMap<BasicBlock *, ColorVector> &BlockColors) { 415 // Only these library routines return their argument. In particular, 416 // objc_retainBlock does not necessarily return its argument. 417 ARCInstKind Class = GetBasicARCInstKind(Inst); 418 switch (Class) { 419 case ARCInstKind::FusedRetainAutorelease: 420 case ARCInstKind::FusedRetainAutoreleaseRV: 421 return false; 422 case ARCInstKind::Autorelease: 423 case ARCInstKind::AutoreleaseRV: 424 return contractAutorelease(F, Inst, Class); 425 case ARCInstKind::Retain: 426 // Attempt to convert retains to retainrvs if they are next to function 427 // calls. 428 if (!optimizeRetainCall(F, Inst)) 429 return false; 430 // If we succeed in our optimization, fall through. 431 LLVM_FALLTHROUGH; 432 case ARCInstKind::RetainRV: 433 case ARCInstKind::ClaimRV: { 434 // If we're compiling for a target which needs a special inline-asm 435 // marker to do the return value optimization and the retainRV/claimRV call 436 // wasn't bundled with a call, insert the marker now. 437 if (!RVInstMarker) 438 return false; 439 440 if (BundledInsts->contains(Inst)) 441 return false; 442 443 BasicBlock::iterator BBI = Inst->getIterator(); 444 BasicBlock *InstParent = Inst->getParent(); 445 446 // Step up to see if the call immediately precedes the RV call. 447 // If it's an invoke, we have to cross a block boundary. And we have 448 // to carefully dodge no-op instructions. 449 do { 450 if (BBI == InstParent->begin()) { 451 BasicBlock *Pred = InstParent->getSinglePredecessor(); 452 if (!Pred) 453 goto decline_rv_optimization; 454 BBI = Pred->getTerminator()->getIterator(); 455 break; 456 } 457 --BBI; 458 } while (IsNoopInstruction(&*BBI)); 459 460 if (GetRCIdentityRoot(&*BBI) == GetArgRCIdentityRoot(Inst)) { 461 LLVM_DEBUG(dbgs() << "Adding inline asm marker for the return value " 462 "optimization.\n"); 463 Changed = true; 464 InlineAsm *IA = 465 InlineAsm::get(FunctionType::get(Type::getVoidTy(Inst->getContext()), 466 /*isVarArg=*/false), 467 RVInstMarker->getString(), 468 /*Constraints=*/"", /*hasSideEffects=*/true); 469 470 objcarc::createCallInstWithColors(IA, None, "", Inst, BlockColors); 471 } 472 decline_rv_optimization: 473 return false; 474 } 475 case ARCInstKind::InitWeak: { 476 // objc_initWeak(p, null) => *p = null 477 CallInst *CI = cast<CallInst>(Inst); 478 if (IsNullOrUndef(CI->getArgOperand(1))) { 479 Value *Null = ConstantPointerNull::get(cast<PointerType>(CI->getType())); 480 Changed = true; 481 new StoreInst(Null, CI->getArgOperand(0), CI); 482 483 LLVM_DEBUG(dbgs() << "OBJCARCContract: Old = " << *CI << "\n" 484 << " New = " << *Null << "\n"); 485 486 CI->replaceAllUsesWith(Null); 487 CI->eraseFromParent(); 488 } 489 return true; 490 } 491 case ARCInstKind::Release: 492 // Try to form an objc store strong from our release. If we fail, there is 493 // nothing further to do below, so continue. 494 tryToContractReleaseIntoStoreStrong(Inst, Iter, BlockColors); 495 return true; 496 case ARCInstKind::User: 497 // Be conservative if the function has any alloca instructions. 498 // Technically we only care about escaping alloca instructions, 499 // but this is sufficient to handle some interesting cases. 500 if (isa<AllocaInst>(Inst)) 501 TailOkForStoreStrongs = false; 502 return true; 503 case ARCInstKind::IntrinsicUser: 504 // Remove calls to @llvm.objc.clang.arc.use(...). 505 Changed = true; 506 Inst->eraseFromParent(); 507 return true; 508 default: 509 if (auto *CI = dyn_cast<CallInst>(Inst)) 510 if (CI->getIntrinsicID() == Intrinsic::objc_clang_arc_noop_use) { 511 // Remove calls to @llvm.objc.clang.arc.noop.use(...). 512 Changed = true; 513 CI->eraseFromParent(); 514 } 515 return true; 516 } 517 } 518 519 //===----------------------------------------------------------------------===// 520 // Top Level Driver 521 //===----------------------------------------------------------------------===// 522 523 bool ObjCARCContract::init(Module &M) { 524 EP.init(&M); 525 526 // Initialize RVInstMarker. 527 RVInstMarker = getRVInstMarker(M); 528 529 return false; 530 } 531 532 bool ObjCARCContract::run(Function &F, AAResults *A, DominatorTree *D) { 533 if (!EnableARCOpts) 534 return false; 535 536 Changed = CFGChanged = false; 537 AA = A; 538 DT = D; 539 PA.setAA(A); 540 BundledRetainClaimRVs BRV(EP, true); 541 BundledInsts = &BRV; 542 543 std::pair<bool, bool> R = BundledInsts->insertAfterInvokes(F, DT); 544 Changed |= R.first; 545 CFGChanged |= R.second; 546 547 DenseMap<BasicBlock *, ColorVector> BlockColors; 548 if (F.hasPersonalityFn() && 549 isScopedEHPersonality(classifyEHPersonality(F.getPersonalityFn()))) 550 BlockColors = colorEHFunclets(F); 551 552 LLVM_DEBUG(llvm::dbgs() << "**** ObjCARC Contract ****\n"); 553 554 // Track whether it's ok to mark objc_storeStrong calls with the "tail" 555 // keyword. Be conservative if the function has variadic arguments. 556 // It seems that functions which "return twice" are also unsafe for the 557 // "tail" argument, because they are setjmp, which could need to 558 // return to an earlier stack state. 559 bool TailOkForStoreStrongs = 560 !F.isVarArg() && !F.callsFunctionThatReturnsTwice(); 561 562 // For ObjC library calls which return their argument, replace uses of the 563 // argument with uses of the call return value, if it dominates the use. This 564 // reduces register pressure. 565 for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E;) { 566 Instruction *Inst = &*I++; 567 568 LLVM_DEBUG(dbgs() << "Visiting: " << *Inst << "\n"); 569 570 if (auto *CI = dyn_cast<CallInst>(Inst)) 571 if (objcarc::hasAttachedCallOpBundle(CI)) { 572 BundledInsts->insertRVCallWithColors(&*I, CI, BlockColors); 573 --I; 574 Changed = true; 575 } 576 577 // First try to peephole Inst. If there is nothing further we can do in 578 // terms of undoing objc-arc-expand, process the next inst. 579 if (tryToPeepholeInstruction(F, Inst, I, TailOkForStoreStrongs, 580 BlockColors)) 581 continue; 582 583 // Otherwise, try to undo objc-arc-expand. 584 585 // Don't use GetArgRCIdentityRoot because we don't want to look through bitcasts 586 // and such; to do the replacement, the argument must have type i8*. 587 588 // Function for replacing uses of Arg dominated by Inst. 589 auto ReplaceArgUses = [Inst, this](Value *Arg) { 590 // If we're compiling bugpointed code, don't get in trouble. 591 if (!isa<Instruction>(Arg) && !isa<Argument>(Arg)) 592 return; 593 594 // Look through the uses of the pointer. 595 for (Value::use_iterator UI = Arg->use_begin(), UE = Arg->use_end(); 596 UI != UE; ) { 597 // Increment UI now, because we may unlink its element. 598 Use &U = *UI++; 599 unsigned OperandNo = U.getOperandNo(); 600 601 // If the call's return value dominates a use of the call's argument 602 // value, rewrite the use to use the return value. We check for 603 // reachability here because an unreachable call is considered to 604 // trivially dominate itself, which would lead us to rewriting its 605 // argument in terms of its return value, which would lead to 606 // infinite loops in GetArgRCIdentityRoot. 607 if (!DT->isReachableFromEntry(U) || !DT->dominates(Inst, U)) 608 continue; 609 610 Changed = true; 611 Instruction *Replacement = Inst; 612 Type *UseTy = U.get()->getType(); 613 if (PHINode *PHI = dyn_cast<PHINode>(U.getUser())) { 614 // For PHI nodes, insert the bitcast in the predecessor block. 615 unsigned ValNo = PHINode::getIncomingValueNumForOperand(OperandNo); 616 BasicBlock *IncomingBB = PHI->getIncomingBlock(ValNo); 617 if (Replacement->getType() != UseTy) { 618 // A catchswitch is both a pad and a terminator, meaning a basic 619 // block with a catchswitch has no insertion point. Keep going up 620 // the dominator tree until we find a non-catchswitch. 621 BasicBlock *InsertBB = IncomingBB; 622 while (isa<CatchSwitchInst>(InsertBB->getFirstNonPHI())) { 623 InsertBB = DT->getNode(InsertBB)->getIDom()->getBlock(); 624 } 625 626 assert(DT->dominates(Inst, &InsertBB->back()) && 627 "Invalid insertion point for bitcast"); 628 Replacement = 629 new BitCastInst(Replacement, UseTy, "", &InsertBB->back()); 630 } 631 632 // While we're here, rewrite all edges for this PHI, rather 633 // than just one use at a time, to minimize the number of 634 // bitcasts we emit. 635 for (unsigned i = 0, e = PHI->getNumIncomingValues(); i != e; ++i) 636 if (PHI->getIncomingBlock(i) == IncomingBB) { 637 // Keep the UI iterator valid. 638 if (UI != UE && 639 &PHI->getOperandUse( 640 PHINode::getOperandNumForIncomingValue(i)) == &*UI) 641 ++UI; 642 PHI->setIncomingValue(i, Replacement); 643 } 644 } else { 645 if (Replacement->getType() != UseTy) 646 Replacement = new BitCastInst(Replacement, UseTy, "", 647 cast<Instruction>(U.getUser())); 648 U.set(Replacement); 649 } 650 } 651 }; 652 653 Value *Arg = cast<CallInst>(Inst)->getArgOperand(0); 654 Value *OrigArg = Arg; 655 656 // TODO: Change this to a do-while. 657 for (;;) { 658 ReplaceArgUses(Arg); 659 660 // If Arg is a no-op casted pointer, strip one level of casts and iterate. 661 if (const BitCastInst *BI = dyn_cast<BitCastInst>(Arg)) 662 Arg = BI->getOperand(0); 663 else if (isa<GEPOperator>(Arg) && 664 cast<GEPOperator>(Arg)->hasAllZeroIndices()) 665 Arg = cast<GEPOperator>(Arg)->getPointerOperand(); 666 else if (isa<GlobalAlias>(Arg) && 667 !cast<GlobalAlias>(Arg)->isInterposable()) 668 Arg = cast<GlobalAlias>(Arg)->getAliasee(); 669 else { 670 // If Arg is a PHI node, get PHIs that are equivalent to it and replace 671 // their uses. 672 if (PHINode *PN = dyn_cast<PHINode>(Arg)) { 673 SmallVector<Value *, 1> PHIList; 674 getEquivalentPHIs(*PN, PHIList); 675 for (Value *PHI : PHIList) 676 ReplaceArgUses(PHI); 677 } 678 break; 679 } 680 } 681 682 // Replace bitcast users of Arg that are dominated by Inst. 683 SmallVector<BitCastInst *, 2> BitCastUsers; 684 685 // Add all bitcast users of the function argument first. 686 for (User *U : OrigArg->users()) 687 if (auto *BC = dyn_cast<BitCastInst>(U)) 688 BitCastUsers.push_back(BC); 689 690 // Replace the bitcasts with the call return. Iterate until list is empty. 691 while (!BitCastUsers.empty()) { 692 auto *BC = BitCastUsers.pop_back_val(); 693 for (User *U : BC->users()) 694 if (auto *B = dyn_cast<BitCastInst>(U)) 695 BitCastUsers.push_back(B); 696 697 ReplaceArgUses(BC); 698 } 699 } 700 701 // If this function has no escaping allocas or suspicious vararg usage, 702 // objc_storeStrong calls can be marked with the "tail" keyword. 703 if (TailOkForStoreStrongs) 704 for (CallInst *CI : StoreStrongCalls) 705 CI->setTailCall(); 706 StoreStrongCalls.clear(); 707 708 return Changed; 709 } 710 711 //===----------------------------------------------------------------------===// 712 // Misc Pass Manager 713 //===----------------------------------------------------------------------===// 714 715 char ObjCARCContractLegacyPass::ID = 0; 716 INITIALIZE_PASS_BEGIN(ObjCARCContractLegacyPass, "objc-arc-contract", 717 "ObjC ARC contraction", false, false) 718 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass) 719 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) 720 INITIALIZE_PASS_END(ObjCARCContractLegacyPass, "objc-arc-contract", 721 "ObjC ARC contraction", false, false) 722 723 void ObjCARCContractLegacyPass::getAnalysisUsage(AnalysisUsage &AU) const { 724 AU.addRequired<AAResultsWrapperPass>(); 725 AU.addRequired<DominatorTreeWrapperPass>(); 726 } 727 728 Pass *llvm::createObjCARCContractPass() { 729 return new ObjCARCContractLegacyPass(); 730 } 731 732 bool ObjCARCContractLegacyPass::doInitialization(Module &M) { 733 return OCARCC.init(M); 734 } 735 736 bool ObjCARCContractLegacyPass::runOnFunction(Function &F) { 737 auto *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults(); 738 auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); 739 return OCARCC.run(F, AA, DT); 740 } 741 742 PreservedAnalyses ObjCARCContractPass::run(Function &F, 743 FunctionAnalysisManager &AM) { 744 ObjCARCContract OCAC; 745 OCAC.init(*F.getParent()); 746 747 bool Changed = OCAC.run(F, &AM.getResult<AAManager>(F), 748 &AM.getResult<DominatorTreeAnalysis>(F)); 749 bool CFGChanged = OCAC.hasCFGChanged(); 750 if (Changed) { 751 PreservedAnalyses PA; 752 if (!CFGChanged) 753 PA.preserveSet<CFGAnalyses>(); 754 return PA; 755 } 756 return PreservedAnalyses::all(); 757 } 758