1 //===--- TransZeroOutPropsInDealloc.cpp - Tranformations to ARC mode ------===//
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 // removeZeroOutPropsInDealloc:
11 //
12 // Removes zero'ing out "strong" @synthesized properties in a -dealloc method.
13 //
14 //===----------------------------------------------------------------------===//
15
16 #include "Transforms.h"
17 #include "Internals.h"
18
19 using namespace clang;
20 using namespace arcmt;
21 using namespace trans;
22
23 namespace {
24
25 class ZeroOutInDeallocRemover :
26 public RecursiveASTVisitor<ZeroOutInDeallocRemover> {
27 typedef RecursiveASTVisitor<ZeroOutInDeallocRemover> base;
28
29 MigrationPass &Pass;
30
31 llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*> SynthesizedProperties;
32 ImplicitParamDecl *SelfD;
33 ExprSet Removables;
34 Selector FinalizeSel;
35
36 public:
ZeroOutInDeallocRemover(MigrationPass & pass)37 ZeroOutInDeallocRemover(MigrationPass &pass) : Pass(pass), SelfD(0) {
38 FinalizeSel =
39 Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("finalize"));
40 }
41
VisitObjCMessageExpr(ObjCMessageExpr * ME)42 bool VisitObjCMessageExpr(ObjCMessageExpr *ME) {
43 ASTContext &Ctx = Pass.Ctx;
44 TransformActions &TA = Pass.TA;
45
46 if (ME->getReceiverKind() != ObjCMessageExpr::Instance)
47 return true;
48 Expr *receiver = ME->getInstanceReceiver();
49 if (!receiver)
50 return true;
51
52 DeclRefExpr *refE = dyn_cast<DeclRefExpr>(receiver->IgnoreParenCasts());
53 if (!refE || refE->getDecl() != SelfD)
54 return true;
55
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;
63 break;
64 }
65 }
66 if (!BackedBySynthesizeSetter)
67 return true;
68
69 // Remove the setter message if RHS is null
70 Transaction Trans(TA);
71 Expr *RHS = ME->getArg(0);
72 bool RHSIsNull =
73 RHS->isNullPointerConstant(Ctx,
74 Expr::NPC_ValueDependentIsNull);
75 if (RHSIsNull && isRemovable(ME))
76 TA.removeStmt(ME);
77
78 return true;
79 }
80
VisitPseudoObjectExpr(PseudoObjectExpr * POE)81 bool VisitPseudoObjectExpr(PseudoObjectExpr *POE) {
82 if (isZeroingPropIvar(POE) && isRemovable(POE)) {
83 Transaction Trans(Pass.TA);
84 Pass.TA.removeStmt(POE);
85 }
86
87 return true;
88 }
89
VisitBinaryOperator(BinaryOperator * BOE)90 bool VisitBinaryOperator(BinaryOperator *BOE) {
91 if (isZeroingPropIvar(BOE) && isRemovable(BOE)) {
92 Transaction Trans(Pass.TA);
93 Pass.TA.removeStmt(BOE);
94 }
95
96 return true;
97 }
98
TraverseObjCMethodDecl(ObjCMethodDecl * D)99 bool TraverseObjCMethodDecl(ObjCMethodDecl *D) {
100 if (D->getMethodFamily() != OMF_dealloc &&
101 !(D->isInstanceMethod() && D->getSelector() == FinalizeSel))
102 return true;
103 if (!D->hasBody())
104 return true;
105
106 ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(D->getDeclContext());
107 if (!IMD)
108 return true;
109
110 SelfD = D->getSelfDecl();
111 collectRemovables(D->getBody(), Removables);
112
113 // For a 'dealloc' method use, find all property implementations in
114 // this class implementation.
115 for (ObjCImplDecl::propimpl_iterator
116 I = IMD->propimpl_begin(), EI = IMD->propimpl_end(); I != EI; ++I) {
117 ObjCPropertyImplDecl *PID = *I;
118 if (PID->getPropertyImplementation() ==
119 ObjCPropertyImplDecl::Synthesize) {
120 ObjCPropertyDecl *PD = PID->getPropertyDecl();
121 ObjCMethodDecl *setterM = PD->getSetterMethodDecl();
122 if (!(setterM && setterM->isDefined())) {
123 ObjCPropertyDecl::PropertyAttributeKind AttrKind =
124 PD->getPropertyAttributes();
125 if (AttrKind &
126 (ObjCPropertyDecl::OBJC_PR_retain |
127 ObjCPropertyDecl::OBJC_PR_copy |
128 ObjCPropertyDecl::OBJC_PR_strong))
129 SynthesizedProperties[PD] = PID;
130 }
131 }
132 }
133
134 // Now, remove all zeroing of ivars etc.
135 base::TraverseObjCMethodDecl(D);
136
137 // clear out for next method.
138 SynthesizedProperties.clear();
139 SelfD = 0;
140 Removables.clear();
141 return true;
142 }
143
TraverseFunctionDecl(FunctionDecl * D)144 bool TraverseFunctionDecl(FunctionDecl *D) { return true; }
TraverseBlockDecl(BlockDecl * block)145 bool TraverseBlockDecl(BlockDecl *block) { return true; }
TraverseBlockExpr(BlockExpr * block)146 bool TraverseBlockExpr(BlockExpr *block) { return true; }
147
148 private:
isRemovable(Expr * E) const149 bool isRemovable(Expr *E) const {
150 return Removables.count(E);
151 }
152
isZeroingPropIvar(Expr * E)153 bool isZeroingPropIvar(Expr *E) {
154 E = E->IgnoreParens();
155 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E))
156 return isZeroingPropIvar(BO);
157 if (PseudoObjectExpr *PO = dyn_cast<PseudoObjectExpr>(E))
158 return isZeroingPropIvar(PO);
159 return false;
160 }
161
isZeroingPropIvar(BinaryOperator * BOE)162 bool isZeroingPropIvar(BinaryOperator *BOE) {
163 if (BOE->getOpcode() == BO_Comma)
164 return isZeroingPropIvar(BOE->getLHS()) &&
165 isZeroingPropIvar(BOE->getRHS());
166
167 if (BOE->getOpcode() != BO_Assign)
168 return false;
169
170 Expr *LHS = BOE->getLHS();
171 if (ObjCIvarRefExpr *IV = dyn_cast<ObjCIvarRefExpr>(LHS)) {
172 ObjCIvarDecl *IVDecl = IV->getDecl();
173 if (!IVDecl->getType()->isObjCObjectPointerType())
174 return false;
175 bool IvarBacksPropertySynthesis = false;
176 for (llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*>::iterator
177 P = SynthesizedProperties.begin(),
178 E = SynthesizedProperties.end(); P != E; ++P) {
179 ObjCPropertyImplDecl *PropImpDecl = P->second;
180 if (PropImpDecl && PropImpDecl->getPropertyIvarDecl() == IVDecl) {
181 IvarBacksPropertySynthesis = true;
182 break;
183 }
184 }
185 if (!IvarBacksPropertySynthesis)
186 return false;
187 }
188 else
189 return false;
190
191 return isZero(BOE->getRHS());
192 }
193
isZeroingPropIvar(PseudoObjectExpr * PO)194 bool isZeroingPropIvar(PseudoObjectExpr *PO) {
195 BinaryOperator *BO = dyn_cast<BinaryOperator>(PO->getSyntacticForm());
196 if (!BO) return false;
197 if (BO->getOpcode() != BO_Assign) return false;
198
199 ObjCPropertyRefExpr *PropRefExp =
200 dyn_cast<ObjCPropertyRefExpr>(BO->getLHS()->IgnoreParens());
201 if (!PropRefExp) return false;
202
203 // TODO: Using implicit property decl.
204 if (PropRefExp->isImplicitProperty())
205 return false;
206
207 if (ObjCPropertyDecl *PDecl = PropRefExp->getExplicitProperty()) {
208 if (!SynthesizedProperties.count(PDecl))
209 return false;
210 }
211
212 return isZero(cast<OpaqueValueExpr>(BO->getRHS())->getSourceExpr());
213 }
214
isZero(Expr * E)215 bool isZero(Expr *E) {
216 if (E->isNullPointerConstant(Pass.Ctx, Expr::NPC_ValueDependentIsNull))
217 return true;
218
219 return isZeroingPropIvar(E);
220 }
221 };
222
223 } // anonymous namespace
224
removeZeroOutPropsInDeallocFinalize(MigrationPass & pass)225 void trans::removeZeroOutPropsInDeallocFinalize(MigrationPass &pass) {
226 ZeroOutInDeallocRemover trans(pass);
227 trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
228 }
229