| //===--- TransZeroOutPropsInDealloc.cpp - Transformations to ARC mode -----===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // removeZeroOutPropsInDealloc: |
| // |
| // Removes zero'ing out "strong" @synthesized properties in a -dealloc method. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "Transforms.h" |
| #include "Internals.h" |
| #include "clang/AST/ASTContext.h" |
| |
| using namespace clang; |
| using namespace arcmt; |
| using namespace trans; |
| |
| namespace { |
| |
| class ZeroOutInDeallocRemover : |
| public RecursiveASTVisitor<ZeroOutInDeallocRemover> { |
| typedef RecursiveASTVisitor<ZeroOutInDeallocRemover> base; |
| |
| MigrationPass &Pass; |
| |
| llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*> SynthesizedProperties; |
| ImplicitParamDecl *SelfD; |
| ExprSet Removables; |
| Selector FinalizeSel; |
| |
| public: |
| ZeroOutInDeallocRemover(MigrationPass &pass) : Pass(pass), SelfD(nullptr) { |
| FinalizeSel = |
| Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("finalize")); |
| } |
| |
| bool VisitObjCMessageExpr(ObjCMessageExpr *ME) { |
| ASTContext &Ctx = Pass.Ctx; |
| TransformActions &TA = Pass.TA; |
| |
| if (ME->getReceiverKind() != ObjCMessageExpr::Instance) |
| return true; |
| Expr *receiver = ME->getInstanceReceiver(); |
| if (!receiver) |
| return true; |
| |
| DeclRefExpr *refE = dyn_cast<DeclRefExpr>(receiver->IgnoreParenCasts()); |
| if (!refE || refE->getDecl() != SelfD) |
| return true; |
| |
| bool BackedBySynthesizeSetter = false; |
| for (llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*>::iterator |
| P = SynthesizedProperties.begin(), |
| E = SynthesizedProperties.end(); P != E; ++P) { |
| ObjCPropertyDecl *PropDecl = P->first; |
| if (PropDecl->getSetterName() == ME->getSelector()) { |
| BackedBySynthesizeSetter = true; |
| break; |
| } |
| } |
| if (!BackedBySynthesizeSetter) |
| return true; |
| |
| // Remove the setter message if RHS is null |
| Transaction Trans(TA); |
| Expr *RHS = ME->getArg(0); |
| bool RHSIsNull = |
| RHS->isNullPointerConstant(Ctx, |
| Expr::NPC_ValueDependentIsNull); |
| if (RHSIsNull && isRemovable(ME)) |
| TA.removeStmt(ME); |
| |
| return true; |
| } |
| |
| bool VisitPseudoObjectExpr(PseudoObjectExpr *POE) { |
| if (isZeroingPropIvar(POE) && isRemovable(POE)) { |
| Transaction Trans(Pass.TA); |
| Pass.TA.removeStmt(POE); |
| } |
| |
| return true; |
| } |
| |
| bool VisitBinaryOperator(BinaryOperator *BOE) { |
| if (isZeroingPropIvar(BOE) && isRemovable(BOE)) { |
| Transaction Trans(Pass.TA); |
| Pass.TA.removeStmt(BOE); |
| } |
| |
| return true; |
| } |
| |
| bool TraverseObjCMethodDecl(ObjCMethodDecl *D) { |
| if (D->getMethodFamily() != OMF_dealloc && |
| !(D->isInstanceMethod() && D->getSelector() == FinalizeSel)) |
| return true; |
| if (!D->hasBody()) |
| return true; |
| |
| ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(D->getDeclContext()); |
| if (!IMD) |
| return true; |
| |
| SelfD = D->getSelfDecl(); |
| collectRemovables(D->getBody(), Removables); |
| |
| // For a 'dealloc' method use, find all property implementations in |
| // this class implementation. |
| for (auto *PID : IMD->property_impls()) { |
| if (PID->getPropertyImplementation() == |
| ObjCPropertyImplDecl::Synthesize) { |
| ObjCPropertyDecl *PD = PID->getPropertyDecl(); |
| ObjCMethodDecl *setterM = PD->getSetterMethodDecl(); |
| if (!(setterM && setterM->isDefined())) { |
| ObjCPropertyDecl::PropertyAttributeKind AttrKind = |
| PD->getPropertyAttributes(); |
| if (AttrKind & |
| (ObjCPropertyDecl::OBJC_PR_retain | |
| ObjCPropertyDecl::OBJC_PR_copy | |
| ObjCPropertyDecl::OBJC_PR_strong)) |
| SynthesizedProperties[PD] = PID; |
| } |
| } |
| } |
| |
| // Now, remove all zeroing of ivars etc. |
| base::TraverseObjCMethodDecl(D); |
| |
| // clear out for next method. |
| SynthesizedProperties.clear(); |
| SelfD = nullptr; |
| Removables.clear(); |
| return true; |
| } |
| |
| bool TraverseFunctionDecl(FunctionDecl *D) { return true; } |
| bool TraverseBlockDecl(BlockDecl *block) { return true; } |
| bool TraverseBlockExpr(BlockExpr *block) { return true; } |
| |
| private: |
| bool isRemovable(Expr *E) const { |
| return Removables.count(E); |
| } |
| |
| bool isZeroingPropIvar(Expr *E) { |
| E = E->IgnoreParens(); |
| if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) |
| return isZeroingPropIvar(BO); |
| if (PseudoObjectExpr *PO = dyn_cast<PseudoObjectExpr>(E)) |
| return isZeroingPropIvar(PO); |
| return false; |
| } |
| |
| bool isZeroingPropIvar(BinaryOperator *BOE) { |
| if (BOE->getOpcode() == BO_Comma) |
| return isZeroingPropIvar(BOE->getLHS()) && |
| isZeroingPropIvar(BOE->getRHS()); |
| |
| if (BOE->getOpcode() != BO_Assign) |
| return false; |
| |
| Expr *LHS = BOE->getLHS(); |
| if (ObjCIvarRefExpr *IV = dyn_cast<ObjCIvarRefExpr>(LHS)) { |
| ObjCIvarDecl *IVDecl = IV->getDecl(); |
| if (!IVDecl->getType()->isObjCObjectPointerType()) |
| return false; |
| bool IvarBacksPropertySynthesis = false; |
| for (llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*>::iterator |
| P = SynthesizedProperties.begin(), |
| E = SynthesizedProperties.end(); P != E; ++P) { |
| ObjCPropertyImplDecl *PropImpDecl = P->second; |
| if (PropImpDecl && PropImpDecl->getPropertyIvarDecl() == IVDecl) { |
| IvarBacksPropertySynthesis = true; |
| break; |
| } |
| } |
| if (!IvarBacksPropertySynthesis) |
| return false; |
| } |
| else |
| return false; |
| |
| return isZero(BOE->getRHS()); |
| } |
| |
| bool isZeroingPropIvar(PseudoObjectExpr *PO) { |
| BinaryOperator *BO = dyn_cast<BinaryOperator>(PO->getSyntacticForm()); |
| if (!BO) return false; |
| if (BO->getOpcode() != BO_Assign) return false; |
| |
| ObjCPropertyRefExpr *PropRefExp = |
| dyn_cast<ObjCPropertyRefExpr>(BO->getLHS()->IgnoreParens()); |
| if (!PropRefExp) return false; |
| |
| // TODO: Using implicit property decl. |
| if (PropRefExp->isImplicitProperty()) |
| return false; |
| |
| if (ObjCPropertyDecl *PDecl = PropRefExp->getExplicitProperty()) { |
| if (!SynthesizedProperties.count(PDecl)) |
| return false; |
| } |
| |
| return isZero(cast<OpaqueValueExpr>(BO->getRHS())->getSourceExpr()); |
| } |
| |
| bool isZero(Expr *E) { |
| if (E->isNullPointerConstant(Pass.Ctx, Expr::NPC_ValueDependentIsNull)) |
| return true; |
| |
| return isZeroingPropIvar(E); |
| } |
| }; |
| |
| } // anonymous namespace |
| |
| void trans::removeZeroOutPropsInDeallocFinalize(MigrationPass &pass) { |
| ZeroOutInDeallocRemover trans(pass); |
| trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl()); |
| } |