1 //===--- TransZeroOutPropsInDealloc.cpp - Transformations to ARC mode -----===//
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
7 //===----------------------------------------------------------------------===//
9 // removeZeroOutPropsInDealloc:
11 // Removes zero'ing out "strong" @synthesized properties in a -dealloc method.
13 //===----------------------------------------------------------------------===//
15 #include "Transforms.h"
16 #include "Internals.h"
17 #include "clang/AST/ASTContext.h"
19 using namespace clang;
20 using namespace arcmt;
21 using namespace trans;
25 class ZeroOutInDeallocRemover :
26 public RecursiveASTVisitor<ZeroOutInDeallocRemover> {
27 typedef RecursiveASTVisitor<ZeroOutInDeallocRemover> base;
31 llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*> SynthesizedProperties;
32 ImplicitParamDecl *SelfD;
37 ZeroOutInDeallocRemover(MigrationPass &pass) : Pass(pass), SelfD(nullptr) {
39 Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("finalize"));
42 bool VisitObjCMessageExpr(ObjCMessageExpr *ME) {
43 ASTContext &Ctx = Pass.Ctx;
44 TransformActions &TA = Pass.TA;
46 if (ME->getReceiverKind() != ObjCMessageExpr::Instance)
48 Expr *receiver = ME->getInstanceReceiver();
52 DeclRefExpr *refE = dyn_cast<DeclRefExpr>(receiver->IgnoreParenCasts());
53 if (!refE || refE->getDecl() != SelfD)
56 bool BackedBySynthesizeSetter = false;
57 for (llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*>::iterator
58 P = SynthesizedProperties.begin(),
59 E = SynthesizedProperties.end(); P != E; ++P) {
60 ObjCPropertyDecl *PropDecl = P->first;
61 if (PropDecl->getSetterName() == ME->getSelector()) {
62 BackedBySynthesizeSetter = true;
66 if (!BackedBySynthesizeSetter)
69 // Remove the setter message if RHS is null
70 Transaction Trans(TA);
71 Expr *RHS = ME->getArg(0);
73 RHS->isNullPointerConstant(Ctx,
74 Expr::NPC_ValueDependentIsNull);
75 if (RHSIsNull && isRemovable(ME))
81 bool VisitPseudoObjectExpr(PseudoObjectExpr *POE) {
82 if (isZeroingPropIvar(POE) && isRemovable(POE)) {
83 Transaction Trans(Pass.TA);
84 Pass.TA.removeStmt(POE);
90 bool VisitBinaryOperator(BinaryOperator *BOE) {
91 if (isZeroingPropIvar(BOE) && isRemovable(BOE)) {
92 Transaction Trans(Pass.TA);
93 Pass.TA.removeStmt(BOE);
99 bool TraverseObjCMethodDecl(ObjCMethodDecl *D) {
100 if (D->getMethodFamily() != OMF_dealloc &&
101 !(D->isInstanceMethod() && D->getSelector() == FinalizeSel))
106 ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(D->getDeclContext());
110 SelfD = D->getSelfDecl();
111 collectRemovables(D->getBody(), Removables);
113 // For a 'dealloc' method use, find all property implementations in
114 // this class implementation.
115 for (auto *PID : IMD->property_impls()) {
116 if (PID->getPropertyImplementation() ==
117 ObjCPropertyImplDecl::Synthesize) {
118 ObjCPropertyDecl *PD = PID->getPropertyDecl();
119 ObjCMethodDecl *setterM = PD->getSetterMethodDecl();
120 if (!(setterM && setterM->isDefined())) {
121 ObjCPropertyDecl::PropertyAttributeKind AttrKind =
122 PD->getPropertyAttributes();
124 (ObjCPropertyDecl::OBJC_PR_retain |
125 ObjCPropertyDecl::OBJC_PR_copy |
126 ObjCPropertyDecl::OBJC_PR_strong))
127 SynthesizedProperties[PD] = PID;
132 // Now, remove all zeroing of ivars etc.
133 base::TraverseObjCMethodDecl(D);
135 // clear out for next method.
136 SynthesizedProperties.clear();
142 bool TraverseFunctionDecl(FunctionDecl *D) { return true; }
143 bool TraverseBlockDecl(BlockDecl *block) { return true; }
144 bool TraverseBlockExpr(BlockExpr *block) { return true; }
147 bool isRemovable(Expr *E) const {
148 return Removables.count(E);
151 bool isZeroingPropIvar(Expr *E) {
152 E = E->IgnoreParens();
153 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E))
154 return isZeroingPropIvar(BO);
155 if (PseudoObjectExpr *PO = dyn_cast<PseudoObjectExpr>(E))
156 return isZeroingPropIvar(PO);
160 bool isZeroingPropIvar(BinaryOperator *BOE) {
161 if (BOE->getOpcode() == BO_Comma)
162 return isZeroingPropIvar(BOE->getLHS()) &&
163 isZeroingPropIvar(BOE->getRHS());
165 if (BOE->getOpcode() != BO_Assign)
168 Expr *LHS = BOE->getLHS();
169 if (ObjCIvarRefExpr *IV = dyn_cast<ObjCIvarRefExpr>(LHS)) {
170 ObjCIvarDecl *IVDecl = IV->getDecl();
171 if (!IVDecl->getType()->isObjCObjectPointerType())
173 bool IvarBacksPropertySynthesis = false;
174 for (llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*>::iterator
175 P = SynthesizedProperties.begin(),
176 E = SynthesizedProperties.end(); P != E; ++P) {
177 ObjCPropertyImplDecl *PropImpDecl = P->second;
178 if (PropImpDecl && PropImpDecl->getPropertyIvarDecl() == IVDecl) {
179 IvarBacksPropertySynthesis = true;
183 if (!IvarBacksPropertySynthesis)
189 return isZero(BOE->getRHS());
192 bool isZeroingPropIvar(PseudoObjectExpr *PO) {
193 BinaryOperator *BO = dyn_cast<BinaryOperator>(PO->getSyntacticForm());
194 if (!BO) return false;
195 if (BO->getOpcode() != BO_Assign) return false;
197 ObjCPropertyRefExpr *PropRefExp =
198 dyn_cast<ObjCPropertyRefExpr>(BO->getLHS()->IgnoreParens());
199 if (!PropRefExp) return false;
201 // TODO: Using implicit property decl.
202 if (PropRefExp->isImplicitProperty())
205 if (ObjCPropertyDecl *PDecl = PropRefExp->getExplicitProperty()) {
206 if (!SynthesizedProperties.count(PDecl))
210 return isZero(cast<OpaqueValueExpr>(BO->getRHS())->getSourceExpr());
213 bool isZero(Expr *E) {
214 if (E->isNullPointerConstant(Pass.Ctx, Expr::NPC_ValueDependentIsNull))
217 return isZeroingPropIvar(E);
221 } // anonymous namespace
223 void trans::removeZeroOutPropsInDeallocFinalize(MigrationPass &pass) {
224 ZeroOutInDeallocRemover trans(pass);
225 trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());