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