Home | History | Annotate | Download | only in ARCMigrate 
      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:
     37   ZeroOutInDeallocRemover(MigrationPass &pass) : Pass(pass), SelfD(0) {
     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 
     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 
     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 (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 
    144   bool TraverseFunctionDecl(FunctionDecl *D) { return true; }
    145   bool TraverseBlockDecl(BlockDecl *block) { return true; }
    146   bool TraverseBlockExpr(BlockExpr *block) { return true; }
    147 
    148 private:
    149   bool isRemovable(Expr *E) const {
    150     return Removables.count(E);
    151   }
    152 
    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 
    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 
    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 
    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 
    225 void trans::removeZeroOutPropsInDeallocFinalize(MigrationPass &pass) {
    226   ZeroOutInDeallocRemover trans(pass);
    227   trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
    228 }
    229