clang  9.0.0svn
TransZeroOutPropsInDealloc.cpp
Go to the documentation of this file.
1 //===--- TransZeroOutPropsInDealloc.cpp - Transformations to ARC mode -----===//
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 //
9 // removeZeroOutPropsInDealloc:
10 //
11 // Removes zero'ing out "strong" @synthesized properties in a -dealloc method.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "Transforms.h"
16 #include "Internals.h"
17 #include "clang/AST/ASTContext.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> {
28 
29  MigrationPass &Pass;
30 
31  llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*> SynthesizedProperties;
32  ImplicitParamDecl *SelfD;
33  ExprSet Removables;
34  Selector FinalizeSel;
35 
36 public:
37  ZeroOutInDeallocRemover(MigrationPass &pass) : Pass(pass), SelfD(nullptr) {
38  FinalizeSel =
39  Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("finalize"));
40  }
41 
42  bool VisitObjCMessageExpr(ObjCMessageExpr *ME) {
43  ASTContext &Ctx = Pass.Ctx;
44  TransformActions &TA = Pass.TA;
45 
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,
75  if (RHSIsNull && isRemovable(ME))
76  TA.removeStmt(ME);
77 
78  return true;
79  }
80 
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 
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 
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 (auto *PID : IMD->property_impls()) {
116  if (PID->getPropertyImplementation() ==
118  ObjCPropertyDecl *PD = PID->getPropertyDecl();
119  ObjCMethodDecl *setterM = PD->getSetterMethodDecl();
120  if (!(setterM && setterM->isDefined())) {
122  PD->getPropertyAttributes();
123  if (AttrKind &
127  SynthesizedProperties[PD] = PID;
128  }
129  }
130  }
131 
132  // Now, remove all zeroing of ivars etc.
133  base::TraverseObjCMethodDecl(D);
134 
135  // clear out for next method.
136  SynthesizedProperties.clear();
137  SelfD = nullptr;
138  Removables.clear();
139  return true;
140  }
141 
142  bool TraverseFunctionDecl(FunctionDecl *D) { return true; }
143  bool TraverseBlockDecl(BlockDecl *block) { return true; }
144  bool TraverseBlockExpr(BlockExpr *block) { return true; }
145 
146 private:
147  bool isRemovable(Expr *E) const {
148  return Removables.count(E);
149  }
150 
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);
157  return false;
158  }
159 
160  bool isZeroingPropIvar(BinaryOperator *BOE) {
161  if (BOE->getOpcode() == BO_Comma)
162  return isZeroingPropIvar(BOE->getLHS()) &&
163  isZeroingPropIvar(BOE->getRHS());
164 
165  if (BOE->getOpcode() != BO_Assign)
166  return false;
167 
168  Expr *LHS = BOE->getLHS();
169  if (ObjCIvarRefExpr *IV = dyn_cast<ObjCIvarRefExpr>(LHS)) {
170  ObjCIvarDecl *IVDecl = IV->getDecl();
171  if (!IVDecl->getType()->isObjCObjectPointerType())
172  return false;
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;
180  break;
181  }
182  }
183  if (!IvarBacksPropertySynthesis)
184  return false;
185  }
186  else
187  return false;
188 
189  return isZero(BOE->getRHS());
190  }
191 
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;
196 
197  ObjCPropertyRefExpr *PropRefExp =
198  dyn_cast<ObjCPropertyRefExpr>(BO->getLHS()->IgnoreParens());
199  if (!PropRefExp) return false;
200 
201  // TODO: Using implicit property decl.
202  if (PropRefExp->isImplicitProperty())
203  return false;
204 
205  if (ObjCPropertyDecl *PDecl = PropRefExp->getExplicitProperty()) {
206  if (!SynthesizedProperties.count(PDecl))
207  return false;
208  }
209 
210  return isZero(cast<OpaqueValueExpr>(BO->getRHS())->getSourceExpr());
211  }
212 
213  bool isZero(Expr *E) {
215  return true;
216 
217  return isZeroingPropIvar(E);
218  }
219 };
220 
221 } // anonymous namespace
222 
224  ZeroOutInDeallocRemover trans(pass);
225  trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
226 }
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:614
Defines the clang::ASTContext interface.
Represents a function declaration or definition.
Definition: Decl.h:1748
The receiver is an object instance.
Definition: ExprObjC.h:1101
Expr * getSyntacticForm()
Return the syntactic form of this expression, i.e.
Definition: Expr.h:5707
Smart pointer class that efficiently represents Objective-C method names.
Selector getSelector() const
Definition: ExprObjC.cpp:337
ObjCIvarDecl * getPropertyIvarDecl() const
Definition: DeclObjC.h:2826
Opcode getOpcode() const
Definition: Expr.h:3440
StringRef P
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:138
ObjCPropertyDecl * getExplicitProperty() const
Definition: ExprObjC.h:707
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
bool isDefined() const
Definition: DeclObjC.h:439
ObjCMethodDecl * getSetterMethodDecl() const
Definition: DeclObjC.h:924
IdentifierTable & Idents
Definition: ASTContext.h:569
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
Definition: DeclObjC.cpp:985
Selector getNullarySelector(IdentifierInfo *ID)
PropertyAttributeKind getPropertyAttributes() const
Definition: DeclObjC.h:839
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3405
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2947
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition: DeclObjC.h:2758
void collectRemovables(Stmt *S, ExprSet &exprs)
Definition: Transforms.cpp:308
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:3915
This represents one expression.
Definition: Expr.h:108
Selector getSetterName() const
Definition: DeclObjC.h:913
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5541
DeclContext * getDeclContext()
Definition: DeclBase.h:438
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
Definition: Expr.h:733
propimpl_range property_impls() const
Definition: DeclObjC.h:2466
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:950
bool isInstanceMethod() const
Definition: DeclObjC.h:421
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1234
ValueDecl * getDecl()
Definition: Expr.h:1217
Selector getSelector() const
Definition: DeclObjC.h:320
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:413
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: ExprObjC.h:1395
SelectorTable & Selectors
Definition: ASTContext.h:570
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:5663
bool isImplicitProperty() const
Definition: ExprObjC.h:704
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant...
Definition: Expr.cpp:3658
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
Stmt * getBody() const override
Retrieve the body of this method, if it has one.
Definition: DeclObjC.cpp:851
bool isObjCObjectPointerType() const
Definition: Type.h:6488
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:728
Expr * getLHS() const
Definition: Expr.h:3445
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
Definition: ExprObjC.h:1260
Dataflow Directional Tag Classes.
bool hasBody() const override
Determine whether this method has a body.
Definition: DeclObjC.h:503
void removeZeroOutPropsInDeallocFinalize(MigrationPass &pass)
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:546
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1007
TransformActions & TA
Definition: Internals.h:150
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1944
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1141
Expr * getRHS() const
Definition: Expr.h:3447
QualType getType() const
Definition: Decl.h:647
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2938