1 //===--- TransZeroOutPropsInDealloc.cpp - Transformations to ARC mode -----===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // removeZeroOutPropsInDealloc:
12 // Removes zero'ing out "strong" @synthesized properties in a -dealloc method.
14 //===----------------------------------------------------------------------===//
16 #include "Transforms.h"
17 #include "Internals.h"
18 #include "clang/AST/ASTContext.h"
20 using namespace clang;
21 using namespace arcmt;
22 using namespace trans;
26 class ZeroOutInDeallocRemover :
27 public RecursiveASTVisitor<ZeroOutInDeallocRemover> {
28 typedef RecursiveASTVisitor<ZeroOutInDeallocRemover> base;
32 llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*> SynthesizedProperties;
33 ImplicitParamDecl *SelfD;
38 ZeroOutInDeallocRemover(MigrationPass &pass) : Pass(pass), SelfD(0) {
40 Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("finalize"));
43 bool VisitObjCMessageExpr(ObjCMessageExpr *ME) {
44 ASTContext &Ctx = Pass.Ctx;
45 TransformActions &TA = Pass.TA;
47 if (ME->getReceiverKind() != ObjCMessageExpr::Instance)
49 Expr *receiver = ME->getInstanceReceiver();
53 DeclRefExpr *refE = dyn_cast<DeclRefExpr>(receiver->IgnoreParenCasts());
54 if (!refE || refE->getDecl() != SelfD)
57 bool BackedBySynthesizeSetter = false;
58 for (llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*>::iterator
59 P = SynthesizedProperties.begin(),
60 E = SynthesizedProperties.end(); P != E; ++P) {
61 ObjCPropertyDecl *PropDecl = P->first;
62 if (PropDecl->getSetterName() == ME->getSelector()) {
63 BackedBySynthesizeSetter = true;
67 if (!BackedBySynthesizeSetter)
70 // Remove the setter message if RHS is null
71 Transaction Trans(TA);
72 Expr *RHS = ME->getArg(0);
74 RHS->isNullPointerConstant(Ctx,
75 Expr::NPC_ValueDependentIsNull);
76 if (RHSIsNull && isRemovable(ME))
82 bool VisitPseudoObjectExpr(PseudoObjectExpr *POE) {
83 if (isZeroingPropIvar(POE) && isRemovable(POE)) {
84 Transaction Trans(Pass.TA);
85 Pass.TA.removeStmt(POE);
91 bool VisitBinaryOperator(BinaryOperator *BOE) {
92 if (isZeroingPropIvar(BOE) && isRemovable(BOE)) {
93 Transaction Trans(Pass.TA);
94 Pass.TA.removeStmt(BOE);
100 bool TraverseObjCMethodDecl(ObjCMethodDecl *D) {
101 if (D->getMethodFamily() != OMF_dealloc &&
102 !(D->isInstanceMethod() && D->getSelector() == FinalizeSel))
107 ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(D->getDeclContext());
111 SelfD = D->getSelfDecl();
112 collectRemovables(D->getBody(), Removables);
114 // For a 'dealloc' method use, find all property implementations in
115 // this class implementation.
116 for (ObjCImplDecl::propimpl_iterator
117 I = IMD->propimpl_begin(), EI = IMD->propimpl_end(); I != EI; ++I) {
118 ObjCPropertyImplDecl *PID = *I;
119 if (PID->getPropertyImplementation() ==
120 ObjCPropertyImplDecl::Synthesize) {
121 ObjCPropertyDecl *PD = PID->getPropertyDecl();
122 ObjCMethodDecl *setterM = PD->getSetterMethodDecl();
123 if (!(setterM && setterM->isDefined())) {
124 ObjCPropertyDecl::PropertyAttributeKind AttrKind =
125 PD->getPropertyAttributes();
127 (ObjCPropertyDecl::OBJC_PR_retain |
128 ObjCPropertyDecl::OBJC_PR_copy |
129 ObjCPropertyDecl::OBJC_PR_strong))
130 SynthesizedProperties[PD] = PID;
135 // Now, remove all zeroing of ivars etc.
136 base::TraverseObjCMethodDecl(D);
138 // clear out for next method.
139 SynthesizedProperties.clear();
145 bool TraverseFunctionDecl(FunctionDecl *D) { return true; }
146 bool TraverseBlockDecl(BlockDecl *block) { return true; }
147 bool TraverseBlockExpr(BlockExpr *block) { return true; }
150 bool isRemovable(Expr *E) const {
151 return Removables.count(E);
154 bool isZeroingPropIvar(Expr *E) {
155 E = E->IgnoreParens();
156 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E))
157 return isZeroingPropIvar(BO);
158 if (PseudoObjectExpr *PO = dyn_cast<PseudoObjectExpr>(E))
159 return isZeroingPropIvar(PO);
163 bool isZeroingPropIvar(BinaryOperator *BOE) {
164 if (BOE->getOpcode() == BO_Comma)
165 return isZeroingPropIvar(BOE->getLHS()) &&
166 isZeroingPropIvar(BOE->getRHS());
168 if (BOE->getOpcode() != BO_Assign)
171 Expr *LHS = BOE->getLHS();
172 if (ObjCIvarRefExpr *IV = dyn_cast<ObjCIvarRefExpr>(LHS)) {
173 ObjCIvarDecl *IVDecl = IV->getDecl();
174 if (!IVDecl->getType()->isObjCObjectPointerType())
176 bool IvarBacksPropertySynthesis = false;
177 for (llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*>::iterator
178 P = SynthesizedProperties.begin(),
179 E = SynthesizedProperties.end(); P != E; ++P) {
180 ObjCPropertyImplDecl *PropImpDecl = P->second;
181 if (PropImpDecl && PropImpDecl->getPropertyIvarDecl() == IVDecl) {
182 IvarBacksPropertySynthesis = true;
186 if (!IvarBacksPropertySynthesis)
192 return isZero(BOE->getRHS());
195 bool isZeroingPropIvar(PseudoObjectExpr *PO) {
196 BinaryOperator *BO = dyn_cast<BinaryOperator>(PO->getSyntacticForm());
197 if (!BO) return false;
198 if (BO->getOpcode() != BO_Assign) return false;
200 ObjCPropertyRefExpr *PropRefExp =
201 dyn_cast<ObjCPropertyRefExpr>(BO->getLHS()->IgnoreParens());
202 if (!PropRefExp) return false;
204 // TODO: Using implicit property decl.
205 if (PropRefExp->isImplicitProperty())
208 if (ObjCPropertyDecl *PDecl = PropRefExp->getExplicitProperty()) {
209 if (!SynthesizedProperties.count(PDecl))
213 return isZero(cast<OpaqueValueExpr>(BO->getRHS())->getSourceExpr());
216 bool isZero(Expr *E) {
217 if (E->isNullPointerConstant(Pass.Ctx, Expr::NPC_ValueDependentIsNull))
220 return isZeroingPropIvar(E);
224 } // anonymous namespace
226 void trans::removeZeroOutPropsInDeallocFinalize(MigrationPass &pass) {
227 ZeroOutInDeallocRemover trans(pass);
228 trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());