contrib/llvm/tools/clang/lib/ARCMigrate/TransRetainReleaseDealloc.cpp

   1 //===--- TransRetainReleaseDealloc.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 // removeRetainReleaseDealloc:
  11 //
  12 // Removes retain/release/autorelease/dealloc messages.
  13 //
  14 //  return [[foo retain] autorelease];
  15 // ---->
  16 //  return foo;
  17 //
  18 //===----------------------------------------------------------------------===//
  19
  20 #include "Transforms.h"
  21 #include "Internals.h"
  22 #include "clang/AST/ASTContext.h"
  23 #include "clang/AST/ParentMap.h"
  24 #include "clang/Basic/SourceManager.h"
  25 #include "clang/Lex/Lexer.h"
  26 #include "clang/Sema/SemaDiagnostic.h"
  27
  28 using namespace clang;
  29 using namespace arcmt;
  30 using namespace trans;
  31
  32 namespace {
  33
  34 class RetainReleaseDeallocRemover :
  35                        public RecursiveASTVisitor<RetainReleaseDeallocRemover> {
  36   Stmt *Body;
  37   MigrationPass &Pass;
  38
  39   ExprSet Removables;
  40   OwningPtr<ParentMap> StmtMap;
  41
  42   Selector DelegateSel, FinalizeSel;
  43
  44 public:
  45   RetainReleaseDeallocRemover(MigrationPass &pass)
  46     : Body(0), Pass(pass) {
  47     DelegateSel =
  48         Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("delegate"));
  49     FinalizeSel =
  50         Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("finalize"));
  51   }
  52
  53   void transformBody(Stmt *body, Decl *ParentD) {
  54     Body = body;
  55     collectRemovables(body, Removables);
  56     StmtMap.reset(new ParentMap(body));
  57     TraverseStmt(body);
  58   }
  59
  60   bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
  61     switch (E->getMethodFamily()) {
  62     default:
  63       if (E->isInstanceMessage() && E->getSelector() == FinalizeSel)
  64         break;
  65       return true;
  66     case OMF_autorelease:
  67       if (isRemovable(E)) {
  68         if (!isCommonUnusedAutorelease(E)) {
  69           // An unused autorelease is badness. If we remove it the receiver
  70           // will likely die immediately while previously it was kept alive
  71           // by the autorelease pool. This is bad practice in general, leave it
  72           // and emit an error to force the user to restructure his code.
  73           Pass.TA.reportError("it is not safe to remove an unused 'autorelease' "
  74               "message; its receiver may be destroyed immediately",
  75               E->getLocStart(), E->getSourceRange());
  76           return true;
  77         }
  78       }
  79       // Pass through.
  80     case OMF_retain:
  81     case OMF_release:
  82       if (E->getReceiverKind() == ObjCMessageExpr::Instance)
  83         if (Expr *rec = E->getInstanceReceiver()) {
  84           rec = rec->IgnoreParenImpCasts();
  85           if (rec->getType().getObjCLifetime() == Qualifiers::OCL_ExplicitNone &&
  86               (E->getMethodFamily() != OMF_retain || isRemovable(E))) {
  87             std::string err = "it is not safe to remove '";
  88             err += E->getSelector().getAsString() + "' message on "
  89                 "an __unsafe_unretained type";
  90             Pass.TA.reportError(err, rec->getLocStart());
  91             return true;
  92           }
  93
  94           if (isGlobalVar(rec) &&
  95               (E->getMethodFamily() != OMF_retain || isRemovable(E))) {
  96             std::string err = "it is not safe to remove '";
  97             err += E->getSelector().getAsString() + "' message on "
  98                 "a global variable";
  99             Pass.TA.reportError(err, rec->getLocStart());
 100             return true;
 101           }
 102
 103           if (E->getMethodFamily() == OMF_release && isDelegateMessage(rec)) {
 104             Pass.TA.reportError("it is not safe to remove 'retain' "
 105                 "message on the result of a 'delegate' message; "
 106                 "the object that was passed to 'setDelegate:' may not be "
 107                 "properly retained", rec->getLocStart());
 108             return true;
 109           }
 110         }
 111     case OMF_dealloc:
 112       break;
 113     }
 114
 115     switch (E->getReceiverKind()) {
 116     default:
 117       return true;
 118     case ObjCMessageExpr::SuperInstance: {
 119       Transaction Trans(Pass.TA);
 120       clearDiagnostics(E->getSuperLoc());
 121       if (tryRemoving(E))
 122         return true;
 123       Pass.TA.replace(E->getSourceRange(), "self");
 124       return true;
 125     }
 126     case ObjCMessageExpr::Instance:
 127       break;
 128     }
 129
 130     Expr *rec = E->getInstanceReceiver();
 131     if (!rec) return true;
 132
 133     Transaction Trans(Pass.TA);
 134     clearDiagnostics(rec->getExprLoc());
 135
 136     ObjCMessageExpr *Msg = E;
 137     Expr *RecContainer = Msg;
 138     SourceRange RecRange = rec->getSourceRange();
 139     checkForGCDOrXPC(Msg, RecContainer, rec, RecRange);
 140
 141     if (Msg->getMethodFamily() == OMF_release &&
 142         isRemovable(RecContainer) && isInAtFinally(RecContainer)) {
 143       // Change the -release to "receiver = nil" in a finally to avoid a leak
 144       // when an exception is thrown.
 145       Pass.TA.replace(RecContainer->getSourceRange(), RecRange);
 146       std::string str = " = ";
 147       str += getNilString(Pass.Ctx);
 148       Pass.TA.insertAfterToken(RecRange.getEnd(), str);
 149       return true;
 150     }
 151
 152     if (!hasSideEffects(rec, Pass.Ctx)) {
 153       if (tryRemoving(RecContainer))
 154         return true;
 155     }
 156     Pass.TA.replace(RecContainer->getSourceRange(), RecRange);
 157
 158     return true;
 159   }
 160
 161 private:
 162   /// \brief Checks for idioms where an unused -autorelease is common.
 163   ///
 164   /// Currently only returns true for this idiom which is common in property
 165   /// setters:
 166   ///
 167   ///   [backingValue autorelease];
 168   ///   backingValue = [newValue retain]; // in general a +1 assign
 169   ///
 170   bool isCommonUnusedAutorelease(ObjCMessageExpr *E) {
 171     Expr *Rec = E->getInstanceReceiver();
 172     if (!Rec)
 173       return false;
 174
 175     Decl *RefD = getReferencedDecl(Rec);
 176     if (!RefD)
 177       return false;
 178
 179     Stmt *OuterS = E, *InnerS;
 180     do {
 181       InnerS = OuterS;
 182       OuterS = StmtMap->getParent(InnerS);
 183     }
 184     while (OuterS && (isa<ParenExpr>(OuterS) ||
 185                       isa<CastExpr>(OuterS) ||
 186                       isa<ExprWithCleanups>(OuterS)));
 187
 188     if (!OuterS)
 189       return false;
 190
 191     // Find next statement after the -autorelease.
 192
 193     Stmt::child_iterator currChildS = OuterS->child_begin();
 194     Stmt::child_iterator childE = OuterS->child_end();
 195     for (; currChildS != childE; ++currChildS) {
 196       if (*currChildS == InnerS)
 197         break;
 198     }
 199     if (currChildS == childE)
 200       return false;
 201     ++currChildS;
 202     if (currChildS == childE)
 203       return false;
 204
 205     Stmt *nextStmt = *currChildS;
 206     if (!nextStmt)
 207       return false;
 208     nextStmt = nextStmt->IgnoreImplicit();
 209
 210     // Check for "RefD = [+1 retained object];".
 211
 212     if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(nextStmt)) {
 213       if (RefD != getReferencedDecl(Bop->getLHS()))
 214         return false;
 215       if (isPlusOneAssign(Bop))
 216         return true;
 217     }
 218     return false;
 219   }
 220
 221   Decl *getReferencedDecl(Expr *E) {
 222     if (!E)
 223       return 0;
 224
 225     E = E->IgnoreParenCasts();
 226     if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
 227       return DRE->getDecl();
 228     if (MemberExpr *ME = dyn_cast<MemberExpr>(E))
 229       return ME->getMemberDecl();
 230     if (ObjCIvarRefExpr *IRE = dyn_cast<ObjCIvarRefExpr>(E))
 231       return IRE->getDecl();
 232
 233     return 0;
 234   }
 235
 236   /// \brief Check if the retain/release is due to a GCD/XPC macro that are
 237   /// defined as:
 238   ///
 239   /// #define dispatch_retain(object) ({ dispatch_object_t _o = (object); _dispatch_object_validate(_o); (void)[_o retain]; })
 240   /// #define dispatch_release(object) ({ dispatch_object_t _o = (object); _dispatch_object_validate(_o); [_o release]; })
 241   /// #define xpc_retain(object) ({ xpc_object_t _o = (object); _xpc_object_validate(_o); [_o retain]; })
 242   /// #define xpc_release(object) ({ xpc_object_t _o = (object); _xpc_object_validate(_o); [_o release]; })
 243   ///
 244   /// and return the top container which is the StmtExpr and the macro argument
 245   /// expression.
 246   void checkForGCDOrXPC(ObjCMessageExpr *Msg, Expr *&RecContainer,
 247                         Expr *&Rec, SourceRange &RecRange) {
 248     SourceLocation Loc = Msg->getExprLoc();
 249     if (!Loc.isMacroID())
 250       return;
 251     SourceManager &SM = Pass.Ctx.getSourceManager();
 252     StringRef MacroName = Lexer::getImmediateMacroName(Loc, SM,
 253                                                      Pass.Ctx.getLangOpts());
 254     bool isGCDOrXPC = llvm::StringSwitch<bool>(MacroName)
 255         .Case("dispatch_retain", true)
 256         .Case("dispatch_release", true)
 257         .Case("xpc_retain", true)
 258         .Case("xpc_release", true)
 259         .Default(false);
 260     if (!isGCDOrXPC)
 261       return;
 262
 263     StmtExpr *StmtE = 0;
 264     Stmt *S = Msg;
 265     while (S) {
 266       if (StmtExpr *SE = dyn_cast<StmtExpr>(S)) {
 267         StmtE = SE;
 268         break;
 269       }
 270       S = StmtMap->getParent(S);
 271     }
 272
 273     if (!StmtE)
 274       return;
 275
 276     Stmt::child_range StmtExprChild = StmtE->children();
 277     if (!StmtExprChild)
 278       return;
 279     CompoundStmt *CompS = dyn_cast_or_null<CompoundStmt>(*StmtExprChild);
 280     if (!CompS)
 281       return;
 282
 283     Stmt::child_range CompStmtChild = CompS->children();
 284     if (!CompStmtChild)
 285       return;
 286     DeclStmt *DeclS = dyn_cast_or_null<DeclStmt>(*CompStmtChild);
 287     if (!DeclS)
 288       return;
 289     if (!DeclS->isSingleDecl())
 290       return;
 291     VarDecl *VD = dyn_cast_or_null<VarDecl>(DeclS->getSingleDecl());
 292     if (!VD)
 293       return;
 294     Expr *Init = VD->getInit();
 295     if (!Init)
 296       return;
 297
 298     RecContainer = StmtE;
 299     Rec = Init->IgnoreParenImpCasts();
 300     if (ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(Rec))
 301       Rec = EWC->getSubExpr()->IgnoreParenImpCasts();
 302     RecRange = Rec->getSourceRange();
 303     if (SM.isMacroArgExpansion(RecRange.getBegin()))
 304       RecRange.setBegin(SM.getImmediateSpellingLoc(RecRange.getBegin()));
 305     if (SM.isMacroArgExpansion(RecRange.getEnd()))
 306       RecRange.setEnd(SM.getImmediateSpellingLoc(RecRange.getEnd()));
 307   }
 308
 309   void clearDiagnostics(SourceLocation loc) const {
 310     Pass.TA.clearDiagnostic(diag::err_arc_illegal_explicit_message,
 311                             diag::err_unavailable,
 312                             diag::err_unavailable_message,
 313                             loc);
 314   }
 315
 316   bool isDelegateMessage(Expr *E) const {
 317     if (!E) return false;
 318
 319     E = E->IgnoreParenCasts();
 320
 321     // Also look through property-getter sugar.
 322     if (PseudoObjectExpr *pseudoOp = dyn_cast<PseudoObjectExpr>(E))
 323       E = pseudoOp->getResultExpr()->IgnoreImplicit();
 324
 325     if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E))
 326       return (ME->isInstanceMessage() && ME->getSelector() == DelegateSel);
 327
 328     return false;
 329   }
 330
 331   bool isInAtFinally(Expr *E) const {
 332     assert(E);
 333     Stmt *S = E;
 334     while (S) {
 335       if (isa<ObjCAtFinallyStmt>(S))
 336         return true;
 337       S = StmtMap->getParent(S);
 338     }
 339
 340     return false;
 341   }
 342
 343   bool isRemovable(Expr *E) const {
 344     return Removables.count(E);
 345   }
 346
 347   bool tryRemoving(Expr *E) const {
 348     if (isRemovable(E)) {
 349       Pass.TA.removeStmt(E);
 350       return true;
 351     }
 352
 353     Stmt *parent = StmtMap->getParent(E);
 354
 355     if (ImplicitCastExpr *castE = dyn_cast_or_null<ImplicitCastExpr>(parent))
 356       return tryRemoving(castE);
 357
 358     if (ParenExpr *parenE = dyn_cast_or_null<ParenExpr>(parent))
 359       return tryRemoving(parenE);
 360
 361     if (BinaryOperator *
 362           bopE = dyn_cast_or_null<BinaryOperator>(parent)) {
 363       if (bopE->getOpcode() == BO_Comma && bopE->getLHS() == E &&
 364           isRemovable(bopE)) {
 365         Pass.TA.replace(bopE->getSourceRange(), bopE->getRHS()->getSourceRange());
 366         return true;
 367       }
 368     }
 369
 370     return false;
 371   }
 372
 373 };
 374
 375 } // anonymous namespace
 376
 377 void trans::removeRetainReleaseDeallocFinalize(MigrationPass &pass) {
 378   BodyTransform<RetainReleaseDeallocRemover> trans(pass);
 379   trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
 380 }