1 //===--- TransRetainReleaseDealloc.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 // removeRetainReleaseDealloc: 10 // 11 // Removes retain/release/autorelease/dealloc messages. 12 // 13 // return [[foo retain] autorelease]; 14 // ----> 15 // return foo; 16 // 17 //===----------------------------------------------------------------------===// 18 19 #include "Transforms.h" 20 #include "Internals.h" 21 #include "clang/AST/ASTContext.h" 22 #include "clang/AST/ParentMap.h" 23 #include "clang/Basic/SourceManager.h" 24 #include "clang/Lex/Lexer.h" 25 #include "clang/Sema/SemaDiagnostic.h" 26 #include "llvm/ADT/StringSwitch.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 std::unique_ptr<ParentMap> StmtMap; 41 42 Selector DelegateSel, FinalizeSel; 43 44 public: 45 RetainReleaseDeallocRemover(MigrationPass &pass) 46 : Body(nullptr), 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 their code. 73 Pass.TA.reportError( 74 "it is not safe to remove an unused 'autorelease' " 75 "message; its receiver may be destroyed immediately", 76 E->getBeginLoc(), E->getSourceRange()); 77 return true; 78 } 79 } 80 // Pass through. 81 LLVM_FALLTHROUGH; 82 case OMF_retain: 83 case OMF_release: 84 if (E->getReceiverKind() == ObjCMessageExpr::Instance) 85 if (Expr *rec = E->getInstanceReceiver()) { 86 rec = rec->IgnoreParenImpCasts(); 87 if (rec->getType().getObjCLifetime() == Qualifiers::OCL_ExplicitNone && 88 (E->getMethodFamily() != OMF_retain || isRemovable(E))) { 89 std::string err = "it is not safe to remove '"; 90 err += E->getSelector().getAsString() + "' message on " 91 "an __unsafe_unretained type"; 92 Pass.TA.reportError(err, rec->getBeginLoc()); 93 return true; 94 } 95 96 if (isGlobalVar(rec) && 97 (E->getMethodFamily() != OMF_retain || isRemovable(E))) { 98 std::string err = "it is not safe to remove '"; 99 err += E->getSelector().getAsString() + "' message on " 100 "a global variable"; 101 Pass.TA.reportError(err, rec->getBeginLoc()); 102 return true; 103 } 104 105 if (E->getMethodFamily() == OMF_release && isDelegateMessage(rec)) { 106 Pass.TA.reportError( 107 "it is not safe to remove 'retain' " 108 "message on the result of a 'delegate' message; " 109 "the object that was passed to 'setDelegate:' may not be " 110 "properly retained", 111 rec->getBeginLoc()); 112 return true; 113 } 114 } 115 break; 116 case OMF_dealloc: 117 break; 118 } 119 120 switch (E->getReceiverKind()) { 121 default: 122 return true; 123 case ObjCMessageExpr::SuperInstance: { 124 Transaction Trans(Pass.TA); 125 clearDiagnostics(E->getSelectorLoc(0)); 126 if (tryRemoving(E)) 127 return true; 128 Pass.TA.replace(E->getSourceRange(), "self"); 129 return true; 130 } 131 case ObjCMessageExpr::Instance: 132 break; 133 } 134 135 Expr *rec = E->getInstanceReceiver(); 136 if (!rec) return true; 137 138 Transaction Trans(Pass.TA); 139 clearDiagnostics(E->getSelectorLoc(0)); 140 141 ObjCMessageExpr *Msg = E; 142 Expr *RecContainer = Msg; 143 SourceRange RecRange = rec->getSourceRange(); 144 checkForGCDOrXPC(Msg, RecContainer, rec, RecRange); 145 146 if (Msg->getMethodFamily() == OMF_release && 147 isRemovable(RecContainer) && isInAtFinally(RecContainer)) { 148 // Change the -release to "receiver = nil" in a finally to avoid a leak 149 // when an exception is thrown. 150 Pass.TA.replace(RecContainer->getSourceRange(), RecRange); 151 std::string str = " = "; 152 str += getNilString(Pass); 153 Pass.TA.insertAfterToken(RecRange.getEnd(), str); 154 return true; 155 } 156 157 if (hasSideEffects(rec, Pass.Ctx) || !tryRemoving(RecContainer)) 158 Pass.TA.replace(RecContainer->getSourceRange(), RecRange); 159 160 return true; 161 } 162 163 private: 164 /// Checks for idioms where an unused -autorelease is common. 165 /// 166 /// Returns true for this idiom which is common in property 167 /// setters: 168 /// 169 /// [backingValue autorelease]; 170 /// backingValue = [newValue retain]; // in general a +1 assign 171 /// 172 /// For these as well: 173 /// 174 /// [[var retain] autorelease]; 175 /// return var; 176 /// 177 bool isCommonUnusedAutorelease(ObjCMessageExpr *E) { 178 return isPlusOneAssignBeforeOrAfterAutorelease(E) || 179 isReturnedAfterAutorelease(E); 180 } 181 182 bool isReturnedAfterAutorelease(ObjCMessageExpr *E) { 183 Expr *Rec = E->getInstanceReceiver(); 184 if (!Rec) 185 return false; 186 187 Decl *RefD = getReferencedDecl(Rec); 188 if (!RefD) 189 return false; 190 191 Stmt *nextStmt = getNextStmt(E); 192 if (!nextStmt) 193 return false; 194 195 // Check for "return <variable>;". 196 197 if (ReturnStmt *RetS = dyn_cast<ReturnStmt>(nextStmt)) 198 return RefD == getReferencedDecl(RetS->getRetValue()); 199 200 return false; 201 } 202 203 bool isPlusOneAssignBeforeOrAfterAutorelease(ObjCMessageExpr *E) { 204 Expr *Rec = E->getInstanceReceiver(); 205 if (!Rec) 206 return false; 207 208 Decl *RefD = getReferencedDecl(Rec); 209 if (!RefD) 210 return false; 211 212 Stmt *prevStmt, *nextStmt; 213 std::tie(prevStmt, nextStmt) = getPreviousAndNextStmt(E); 214 215 return isPlusOneAssignToVar(prevStmt, RefD) || 216 isPlusOneAssignToVar(nextStmt, RefD); 217 } 218 219 bool isPlusOneAssignToVar(Stmt *S, Decl *RefD) { 220 if (!S) 221 return false; 222 223 // Check for "RefD = [+1 retained object];". 224 225 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(S)) { 226 return (RefD == getReferencedDecl(Bop->getLHS())) && isPlusOneAssign(Bop); 227 } 228 229 if (DeclStmt *DS = dyn_cast<DeclStmt>(S)) { 230 if (DS->isSingleDecl() && DS->getSingleDecl() == RefD) { 231 if (VarDecl *VD = dyn_cast<VarDecl>(RefD)) 232 return isPlusOne(VD->getInit()); 233 } 234 return false; 235 } 236 237 return false; 238 } 239 240 Stmt *getNextStmt(Expr *E) { 241 return getPreviousAndNextStmt(E).second; 242 } 243 244 std::pair<Stmt *, Stmt *> getPreviousAndNextStmt(Expr *E) { 245 Stmt *prevStmt = nullptr, *nextStmt = nullptr; 246 if (!E) 247 return std::make_pair(prevStmt, nextStmt); 248 249 Stmt *OuterS = E, *InnerS; 250 do { 251 InnerS = OuterS; 252 OuterS = StmtMap->getParent(InnerS); 253 } 254 while (OuterS && (isa<ParenExpr>(OuterS) || 255 isa<CastExpr>(OuterS) || 256 isa<FullExpr>(OuterS))); 257 258 if (!OuterS) 259 return std::make_pair(prevStmt, nextStmt); 260 261 Stmt::child_iterator currChildS = OuterS->child_begin(); 262 Stmt::child_iterator childE = OuterS->child_end(); 263 Stmt::child_iterator prevChildS = childE; 264 for (; currChildS != childE; ++currChildS) { 265 if (*currChildS == InnerS) 266 break; 267 prevChildS = currChildS; 268 } 269 270 if (prevChildS != childE) { 271 prevStmt = *prevChildS; 272 if (auto *E = dyn_cast_or_null<Expr>(prevStmt)) 273 prevStmt = E->IgnoreImplicit(); 274 } 275 276 if (currChildS == childE) 277 return std::make_pair(prevStmt, nextStmt); 278 ++currChildS; 279 if (currChildS == childE) 280 return std::make_pair(prevStmt, nextStmt); 281 282 nextStmt = *currChildS; 283 if (auto *E = dyn_cast_or_null<Expr>(nextStmt)) 284 nextStmt = E->IgnoreImplicit(); 285 286 return std::make_pair(prevStmt, nextStmt); 287 } 288 289 Decl *getReferencedDecl(Expr *E) { 290 if (!E) 291 return nullptr; 292 293 E = E->IgnoreParenCasts(); 294 if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) { 295 switch (ME->getMethodFamily()) { 296 case OMF_copy: 297 case OMF_autorelease: 298 case OMF_release: 299 case OMF_retain: 300 return getReferencedDecl(ME->getInstanceReceiver()); 301 default: 302 return nullptr; 303 } 304 } 305 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 306 return DRE->getDecl(); 307 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) 308 return ME->getMemberDecl(); 309 if (ObjCIvarRefExpr *IRE = dyn_cast<ObjCIvarRefExpr>(E)) 310 return IRE->getDecl(); 311 312 return nullptr; 313 } 314 315 /// Check if the retain/release is due to a GCD/XPC macro that are 316 /// defined as: 317 /// 318 /// #define dispatch_retain(object) ({ dispatch_object_t _o = (object); _dispatch_object_validate(_o); (void)[_o retain]; }) 319 /// #define dispatch_release(object) ({ dispatch_object_t _o = (object); _dispatch_object_validate(_o); [_o release]; }) 320 /// #define xpc_retain(object) ({ xpc_object_t _o = (object); _xpc_object_validate(_o); [_o retain]; }) 321 /// #define xpc_release(object) ({ xpc_object_t _o = (object); _xpc_object_validate(_o); [_o release]; }) 322 /// 323 /// and return the top container which is the StmtExpr and the macro argument 324 /// expression. 325 void checkForGCDOrXPC(ObjCMessageExpr *Msg, Expr *&RecContainer, 326 Expr *&Rec, SourceRange &RecRange) { 327 SourceLocation Loc = Msg->getExprLoc(); 328 if (!Loc.isMacroID()) 329 return; 330 SourceManager &SM = Pass.Ctx.getSourceManager(); 331 StringRef MacroName = Lexer::getImmediateMacroName(Loc, SM, 332 Pass.Ctx.getLangOpts()); 333 bool isGCDOrXPC = llvm::StringSwitch<bool>(MacroName) 334 .Case("dispatch_retain", true) 335 .Case("dispatch_release", true) 336 .Case("xpc_retain", true) 337 .Case("xpc_release", true) 338 .Default(false); 339 if (!isGCDOrXPC) 340 return; 341 342 StmtExpr *StmtE = nullptr; 343 Stmt *S = Msg; 344 while (S) { 345 if (StmtExpr *SE = dyn_cast<StmtExpr>(S)) { 346 StmtE = SE; 347 break; 348 } 349 S = StmtMap->getParent(S); 350 } 351 352 if (!StmtE) 353 return; 354 355 Stmt::child_range StmtExprChild = StmtE->children(); 356 if (StmtExprChild.begin() == StmtExprChild.end()) 357 return; 358 auto *CompS = dyn_cast_or_null<CompoundStmt>(*StmtExprChild.begin()); 359 if (!CompS) 360 return; 361 362 Stmt::child_range CompStmtChild = CompS->children(); 363 if (CompStmtChild.begin() == CompStmtChild.end()) 364 return; 365 auto *DeclS = dyn_cast_or_null<DeclStmt>(*CompStmtChild.begin()); 366 if (!DeclS) 367 return; 368 if (!DeclS->isSingleDecl()) 369 return; 370 VarDecl *VD = dyn_cast_or_null<VarDecl>(DeclS->getSingleDecl()); 371 if (!VD) 372 return; 373 Expr *Init = VD->getInit(); 374 if (!Init) 375 return; 376 377 RecContainer = StmtE; 378 Rec = Init->IgnoreParenImpCasts(); 379 if (FullExpr *FE = dyn_cast<FullExpr>(Rec)) 380 Rec = FE->getSubExpr()->IgnoreParenImpCasts(); 381 RecRange = Rec->getSourceRange(); 382 if (SM.isMacroArgExpansion(RecRange.getBegin())) 383 RecRange.setBegin(SM.getImmediateSpellingLoc(RecRange.getBegin())); 384 if (SM.isMacroArgExpansion(RecRange.getEnd())) 385 RecRange.setEnd(SM.getImmediateSpellingLoc(RecRange.getEnd())); 386 } 387 388 void clearDiagnostics(SourceLocation loc) const { 389 Pass.TA.clearDiagnostic(diag::err_arc_illegal_explicit_message, 390 diag::err_unavailable, 391 diag::err_unavailable_message, 392 loc); 393 } 394 395 bool isDelegateMessage(Expr *E) const { 396 if (!E) return false; 397 398 E = E->IgnoreParenCasts(); 399 400 // Also look through property-getter sugar. 401 if (PseudoObjectExpr *pseudoOp = dyn_cast<PseudoObjectExpr>(E)) 402 E = pseudoOp->getResultExpr()->IgnoreImplicit(); 403 404 if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) 405 return (ME->isInstanceMessage() && ME->getSelector() == DelegateSel); 406 407 return false; 408 } 409 410 bool isInAtFinally(Expr *E) const { 411 assert(E); 412 Stmt *S = E; 413 while (S) { 414 if (isa<ObjCAtFinallyStmt>(S)) 415 return true; 416 S = StmtMap->getParent(S); 417 } 418 419 return false; 420 } 421 422 bool isRemovable(Expr *E) const { 423 return Removables.count(E); 424 } 425 426 bool tryRemoving(Expr *E) const { 427 if (isRemovable(E)) { 428 Pass.TA.removeStmt(E); 429 return true; 430 } 431 432 Stmt *parent = StmtMap->getParent(E); 433 434 if (ImplicitCastExpr *castE = dyn_cast_or_null<ImplicitCastExpr>(parent)) 435 return tryRemoving(castE); 436 437 if (ParenExpr *parenE = dyn_cast_or_null<ParenExpr>(parent)) 438 return tryRemoving(parenE); 439 440 if (BinaryOperator * 441 bopE = dyn_cast_or_null<BinaryOperator>(parent)) { 442 if (bopE->getOpcode() == BO_Comma && bopE->getLHS() == E && 443 isRemovable(bopE)) { 444 Pass.TA.replace(bopE->getSourceRange(), bopE->getRHS()->getSourceRange()); 445 return true; 446 } 447 } 448 449 return false; 450 } 451 452 }; 453 454 } // anonymous namespace 455 456 void trans::removeRetainReleaseDeallocFinalize(MigrationPass &pass) { 457 BodyTransform<RetainReleaseDeallocRemover> trans(pass); 458 trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl()); 459 } 460