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"
MayAutorelease(const CallBase & CB,unsigned Depth=0)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
OptimizeBB(BasicBlock * BB)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
ObjCARCAPElim()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
createObjCARCAPElimPass()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));
runOnModule(Module & M)171
172 if (!Retain || GetBasicARCInstKind(Retain) != ARCInstKind::Retain ||
173 GetArgRCIdentityRoot(Retain) != Arg)
174 return false;
175
176 Changed = true;
run(Module & M,ModuleAnalysisManager & AM)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