1 //===--- TransAutoreleasePool.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 // rewriteAutoreleasePool: 10 // 11 // Calls to NSAutoreleasePools will be rewritten as an @autorelease scope. 12 // 13 // NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; 14 // ... 15 // [pool release]; 16 // ----> 17 // @autorelease { 18 // ... 19 // } 20 // 21 // An NSAutoreleasePool will not be touched if: 22 // - There is not a corresponding -release/-drain in the same scope 23 // - Not all references of the NSAutoreleasePool variable can be removed 24 // - There is a variable that is declared inside the intended @autorelease scope 25 // which is also used outside it. 26 // 27 //===----------------------------------------------------------------------===// 28 29 #include "Transforms.h" 30 #include "Internals.h" 31 #include "clang/AST/ASTContext.h" 32 #include "clang/Basic/SourceManager.h" 33 #include "clang/Sema/SemaDiagnostic.h" 34 #include <map> 35 36 using namespace clang; 37 using namespace arcmt; 38 using namespace trans; 39 40 namespace { 41 42 class ReleaseCollector : public RecursiveASTVisitor<ReleaseCollector> { 43 Decl *Dcl; 44 SmallVectorImpl<ObjCMessageExpr *> &Releases; 45 46 public: 47 ReleaseCollector(Decl *D, SmallVectorImpl<ObjCMessageExpr *> &releases) 48 : Dcl(D), Releases(releases) { } 49 50 bool VisitObjCMessageExpr(ObjCMessageExpr *E) { 51 if (!E->isInstanceMessage()) 52 return true; 53 if (E->getMethodFamily() != OMF_release) 54 return true; 55 Expr *instance = E->getInstanceReceiver()->IgnoreParenCasts(); 56 if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(instance)) { 57 if (DE->getDecl() == Dcl) 58 Releases.push_back(E); 59 } 60 return true; 61 } 62 }; 63 64 } 65 66 namespace { 67 68 class AutoreleasePoolRewriter 69 : public RecursiveASTVisitor<AutoreleasePoolRewriter> { 70 public: 71 AutoreleasePoolRewriter(MigrationPass &pass) 72 : Body(nullptr), Pass(pass) { 73 PoolII = &pass.Ctx.Idents.get("NSAutoreleasePool"); 74 DrainSel = pass.Ctx.Selectors.getNullarySelector( 75 &pass.Ctx.Idents.get("drain")); 76 } 77 78 void transformBody(Stmt *body, Decl *ParentD) { 79 Body = body; 80 TraverseStmt(body); 81 } 82 83 ~AutoreleasePoolRewriter() { 84 SmallVector<VarDecl *, 8> VarsToHandle; 85 86 for (std::map<VarDecl *, PoolVarInfo>::iterator 87 I = PoolVars.begin(), E = PoolVars.end(); I != E; ++I) { 88 VarDecl *var = I->first; 89 PoolVarInfo &info = I->second; 90 91 // Check that we can handle/rewrite all references of the pool. 92 93 clearRefsIn(info.Dcl, info.Refs); 94 for (SmallVectorImpl<PoolScope>::iterator 95 scpI = info.Scopes.begin(), 96 scpE = info.Scopes.end(); scpI != scpE; ++scpI) { 97 PoolScope &scope = *scpI; 98 clearRefsIn(*scope.Begin, info.Refs); 99 clearRefsIn(*scope.End, info.Refs); 100 clearRefsIn(scope.Releases.begin(), scope.Releases.end(), info.Refs); 101 } 102 103 // Even if one reference is not handled we will not do anything about that 104 // pool variable. 105 if (info.Refs.empty()) 106 VarsToHandle.push_back(var); 107 } 108 109 for (unsigned i = 0, e = VarsToHandle.size(); i != e; ++i) { 110 PoolVarInfo &info = PoolVars[VarsToHandle[i]]; 111 112 Transaction Trans(Pass.TA); 113 114 clearUnavailableDiags(info.Dcl); 115 Pass.TA.removeStmt(info.Dcl); 116 117 // Add "@autoreleasepool { }" 118 for (SmallVectorImpl<PoolScope>::iterator 119 scpI = info.Scopes.begin(), 120 scpE = info.Scopes.end(); scpI != scpE; ++scpI) { 121 PoolScope &scope = *scpI; 122 clearUnavailableDiags(*scope.Begin); 123 clearUnavailableDiags(*scope.End); 124 if (scope.IsFollowedBySimpleReturnStmt) { 125 // Include the return in the scope. 126 Pass.TA.replaceStmt(*scope.Begin, "@autoreleasepool {"); 127 Pass.TA.removeStmt(*scope.End); 128 Stmt::child_iterator retI = scope.End; 129 ++retI; 130 SourceLocation afterSemi = 131 findLocationAfterSemi((*retI)->getEndLoc(), Pass.Ctx); 132 assert(afterSemi.isValid() && 133 "Didn't we check before setting IsFollowedBySimpleReturnStmt " 134 "to true?"); 135 Pass.TA.insertAfterToken(afterSemi, "\n}"); 136 Pass.TA.increaseIndentation( 137 SourceRange(scope.getIndentedRange().getBegin(), 138 (*retI)->getEndLoc()), 139 scope.CompoundParent->getBeginLoc()); 140 } else { 141 Pass.TA.replaceStmt(*scope.Begin, "@autoreleasepool {"); 142 Pass.TA.replaceStmt(*scope.End, "}"); 143 Pass.TA.increaseIndentation(scope.getIndentedRange(), 144 scope.CompoundParent->getBeginLoc()); 145 } 146 } 147 148 // Remove rest of pool var references. 149 for (SmallVectorImpl<PoolScope>::iterator 150 scpI = info.Scopes.begin(), 151 scpE = info.Scopes.end(); scpI != scpE; ++scpI) { 152 PoolScope &scope = *scpI; 153 for (SmallVectorImpl<ObjCMessageExpr *>::iterator 154 relI = scope.Releases.begin(), 155 relE = scope.Releases.end(); relI != relE; ++relI) { 156 clearUnavailableDiags(*relI); 157 Pass.TA.removeStmt(*relI); 158 } 159 } 160 } 161 } 162 163 bool VisitCompoundStmt(CompoundStmt *S) { 164 SmallVector<PoolScope, 4> Scopes; 165 166 for (Stmt::child_iterator 167 I = S->body_begin(), E = S->body_end(); I != E; ++I) { 168 Stmt *child = getEssential(*I); 169 if (DeclStmt *DclS = dyn_cast<DeclStmt>(child)) { 170 if (DclS->isSingleDecl()) { 171 if (VarDecl *VD = dyn_cast<VarDecl>(DclS->getSingleDecl())) { 172 if (isNSAutoreleasePool(VD->getType())) { 173 PoolVarInfo &info = PoolVars[VD]; 174 info.Dcl = DclS; 175 collectRefs(VD, S, info.Refs); 176 // Does this statement follow the pattern: 177 // NSAutoreleasePool * pool = [NSAutoreleasePool new]; 178 if (isPoolCreation(VD->getInit())) { 179 Scopes.push_back(PoolScope()); 180 Scopes.back().PoolVar = VD; 181 Scopes.back().CompoundParent = S; 182 Scopes.back().Begin = I; 183 } 184 } 185 } 186 } 187 } else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(child)) { 188 if (DeclRefExpr *dref = dyn_cast<DeclRefExpr>(bop->getLHS())) { 189 if (VarDecl *VD = dyn_cast<VarDecl>(dref->getDecl())) { 190 // Does this statement follow the pattern: 191 // pool = [NSAutoreleasePool new]; 192 if (isNSAutoreleasePool(VD->getType()) && 193 isPoolCreation(bop->getRHS())) { 194 Scopes.push_back(PoolScope()); 195 Scopes.back().PoolVar = VD; 196 Scopes.back().CompoundParent = S; 197 Scopes.back().Begin = I; 198 } 199 } 200 } 201 } 202 203 if (Scopes.empty()) 204 continue; 205 206 if (isPoolDrain(Scopes.back().PoolVar, child)) { 207 PoolScope &scope = Scopes.back(); 208 scope.End = I; 209 handlePoolScope(scope, S); 210 Scopes.pop_back(); 211 } 212 } 213 return true; 214 } 215 216 private: 217 void clearUnavailableDiags(Stmt *S) { 218 if (S) 219 Pass.TA.clearDiagnostic(diag::err_unavailable, 220 diag::err_unavailable_message, 221 S->getSourceRange()); 222 } 223 224 struct PoolScope { 225 VarDecl *PoolVar; 226 CompoundStmt *CompoundParent; 227 Stmt::child_iterator Begin; 228 Stmt::child_iterator End; 229 bool IsFollowedBySimpleReturnStmt; 230 SmallVector<ObjCMessageExpr *, 4> Releases; 231 232 PoolScope() 233 : PoolVar(nullptr), CompoundParent(nullptr), 234 IsFollowedBySimpleReturnStmt(false) {} 235 236 SourceRange getIndentedRange() const { 237 Stmt::child_iterator rangeS = Begin; 238 ++rangeS; 239 if (rangeS == End) 240 return SourceRange(); 241 Stmt::child_iterator rangeE = Begin; 242 for (Stmt::child_iterator I = rangeS; I != End; ++I) 243 ++rangeE; 244 return SourceRange((*rangeS)->getBeginLoc(), (*rangeE)->getEndLoc()); 245 } 246 }; 247 248 class NameReferenceChecker : public RecursiveASTVisitor<NameReferenceChecker>{ 249 ASTContext &Ctx; 250 SourceRange ScopeRange; 251 SourceLocation &referenceLoc, &declarationLoc; 252 253 public: 254 NameReferenceChecker(ASTContext &ctx, PoolScope &scope, 255 SourceLocation &referenceLoc, 256 SourceLocation &declarationLoc) 257 : Ctx(ctx), referenceLoc(referenceLoc), 258 declarationLoc(declarationLoc) { 259 ScopeRange = SourceRange((*scope.Begin)->getBeginLoc(), 260 (*scope.End)->getBeginLoc()); 261 } 262 263 bool VisitDeclRefExpr(DeclRefExpr *E) { 264 return checkRef(E->getLocation(), E->getDecl()->getLocation()); 265 } 266 267 bool VisitTypedefTypeLoc(TypedefTypeLoc TL) { 268 return checkRef(TL.getBeginLoc(), TL.getTypedefNameDecl()->getLocation()); 269 } 270 271 bool VisitTagTypeLoc(TagTypeLoc TL) { 272 return checkRef(TL.getBeginLoc(), TL.getDecl()->getLocation()); 273 } 274 275 private: 276 bool checkRef(SourceLocation refLoc, SourceLocation declLoc) { 277 if (isInScope(declLoc)) { 278 referenceLoc = refLoc; 279 declarationLoc = declLoc; 280 return false; 281 } 282 return true; 283 } 284 285 bool isInScope(SourceLocation loc) { 286 if (loc.isInvalid()) 287 return false; 288 289 SourceManager &SM = Ctx.getSourceManager(); 290 if (SM.isBeforeInTranslationUnit(loc, ScopeRange.getBegin())) 291 return false; 292 return SM.isBeforeInTranslationUnit(loc, ScopeRange.getEnd()); 293 } 294 }; 295 296 void handlePoolScope(PoolScope &scope, CompoundStmt *compoundS) { 297 // Check that all names declared inside the scope are not used 298 // outside the scope. 299 { 300 bool nameUsedOutsideScope = false; 301 SourceLocation referenceLoc, declarationLoc; 302 Stmt::child_iterator SI = scope.End, SE = compoundS->body_end(); 303 ++SI; 304 // Check if the autoreleasepool scope is followed by a simple return 305 // statement, in which case we will include the return in the scope. 306 if (SI != SE) 307 if (ReturnStmt *retS = dyn_cast<ReturnStmt>(*SI)) 308 if ((retS->getRetValue() == nullptr || 309 isa<DeclRefExpr>(retS->getRetValue()->IgnoreParenCasts())) && 310 findLocationAfterSemi(retS->getEndLoc(), Pass.Ctx).isValid()) { 311 scope.IsFollowedBySimpleReturnStmt = true; 312 ++SI; // the return will be included in scope, don't check it. 313 } 314 315 for (; SI != SE; ++SI) { 316 nameUsedOutsideScope = !NameReferenceChecker(Pass.Ctx, scope, 317 referenceLoc, 318 declarationLoc).TraverseStmt(*SI); 319 if (nameUsedOutsideScope) 320 break; 321 } 322 323 // If not all references were cleared it means some variables/typenames/etc 324 // declared inside the pool scope are used outside of it. 325 // We won't try to rewrite the pool. 326 if (nameUsedOutsideScope) { 327 Pass.TA.reportError("a name is referenced outside the " 328 "NSAutoreleasePool scope that it was declared in", referenceLoc); 329 Pass.TA.reportNote("name declared here", declarationLoc); 330 Pass.TA.reportNote("intended @autoreleasepool scope begins here", 331 (*scope.Begin)->getBeginLoc()); 332 Pass.TA.reportNote("intended @autoreleasepool scope ends here", 333 (*scope.End)->getBeginLoc()); 334 return; 335 } 336 } 337 338 // Collect all releases of the pool; they will be removed. 339 { 340 ReleaseCollector releaseColl(scope.PoolVar, scope.Releases); 341 Stmt::child_iterator I = scope.Begin; 342 ++I; 343 for (; I != scope.End; ++I) 344 releaseColl.TraverseStmt(*I); 345 } 346 347 PoolVars[scope.PoolVar].Scopes.push_back(scope); 348 } 349 350 bool isPoolCreation(Expr *E) { 351 if (!E) return false; 352 E = getEssential(E); 353 ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E); 354 if (!ME) return false; 355 if (ME->getMethodFamily() == OMF_new && 356 ME->getReceiverKind() == ObjCMessageExpr::Class && 357 isNSAutoreleasePool(ME->getReceiverInterface())) 358 return true; 359 if (ME->getReceiverKind() == ObjCMessageExpr::Instance && 360 ME->getMethodFamily() == OMF_init) { 361 Expr *rec = getEssential(ME->getInstanceReceiver()); 362 if (ObjCMessageExpr *recME = dyn_cast_or_null<ObjCMessageExpr>(rec)) { 363 if (recME->getMethodFamily() == OMF_alloc && 364 recME->getReceiverKind() == ObjCMessageExpr::Class && 365 isNSAutoreleasePool(recME->getReceiverInterface())) 366 return true; 367 } 368 } 369 370 return false; 371 } 372 373 bool isPoolDrain(VarDecl *poolVar, Stmt *S) { 374 if (!S) return false; 375 S = getEssential(S); 376 ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(S); 377 if (!ME) return false; 378 if (ME->getReceiverKind() == ObjCMessageExpr::Instance) { 379 Expr *rec = getEssential(ME->getInstanceReceiver()); 380 if (DeclRefExpr *dref = dyn_cast<DeclRefExpr>(rec)) 381 if (dref->getDecl() == poolVar) 382 return ME->getMethodFamily() == OMF_release || 383 ME->getSelector() == DrainSel; 384 } 385 386 return false; 387 } 388 389 bool isNSAutoreleasePool(ObjCInterfaceDecl *IDecl) { 390 return IDecl && IDecl->getIdentifier() == PoolII; 391 } 392 393 bool isNSAutoreleasePool(QualType Ty) { 394 QualType pointee = Ty->getPointeeType(); 395 if (pointee.isNull()) 396 return false; 397 if (const ObjCInterfaceType *interT = pointee->getAs<ObjCInterfaceType>()) 398 return isNSAutoreleasePool(interT->getDecl()); 399 return false; 400 } 401 402 static Expr *getEssential(Expr *E) { 403 return cast<Expr>(getEssential((Stmt*)E)); 404 } 405 static Stmt *getEssential(Stmt *S) { 406 if (FullExpr *FE = dyn_cast<FullExpr>(S)) 407 S = FE->getSubExpr(); 408 if (Expr *E = dyn_cast<Expr>(S)) 409 S = E->IgnoreParenCasts(); 410 return S; 411 } 412 413 Stmt *Body; 414 MigrationPass &Pass; 415 416 IdentifierInfo *PoolII; 417 Selector DrainSel; 418 419 struct PoolVarInfo { 420 DeclStmt *Dcl; 421 ExprSet Refs; 422 SmallVector<PoolScope, 2> Scopes; 423 424 PoolVarInfo() : Dcl(nullptr) { } 425 }; 426 427 std::map<VarDecl *, PoolVarInfo> PoolVars; 428 }; 429 430 } // anonymous namespace 431 432 void trans::rewriteAutoreleasePool(MigrationPass &pass) { 433 BodyTransform<AutoreleasePoolRewriter> trans(pass); 434 trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl()); 435 } 436