1 //===--- TransUnbridgedCasts.cpp - Transformations 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 // rewriteUnbridgedCasts: 11 // 12 // A cast of non-objc pointer to an objc one is checked. If the non-objc pointer 13 // is from a file-level variable, __bridge cast is used to convert it. 14 // For the result of a function call that we know is +1/+0, 15 // __bridge/CFBridgingRelease is used. 16 // 17 // NSString *str = (NSString *)kUTTypePlainText; 18 // str = b ? kUTTypeRTF : kUTTypePlainText; 19 // NSString *_uuidString = (NSString *)CFUUIDCreateString(kCFAllocatorDefault, 20 // _uuid); 21 // ----> 22 // NSString *str = (__bridge NSString *)kUTTypePlainText; 23 // str = (__bridge NSString *)(b ? kUTTypeRTF : kUTTypePlainText); 24 // NSString *_uuidString = (NSString *) 25 // CFBridgingRelease(CFUUIDCreateString(kCFAllocatorDefault, _uuid)); 26 // 27 // For a C pointer to ObjC, for casting 'self', __bridge is used. 28 // 29 // CFStringRef str = (CFStringRef)self; 30 // ----> 31 // CFStringRef str = (__bridge CFStringRef)self; 32 // 33 // Uses of Block_copy/Block_release macros are rewritten: 34 // 35 // c = Block_copy(b); 36 // Block_release(c); 37 // ----> 38 // c = [b copy]; 39 // <removed> 40 // 41 //===----------------------------------------------------------------------===// 42 43 #include "Transforms.h" 44 #include "Internals.h" 45 #include "clang/AST/ASTContext.h" 46 #include "clang/AST/Attr.h" 47 #include "clang/AST/ParentMap.h" 48 #include "clang/Analysis/DomainSpecific/CocoaConventions.h" 49 #include "clang/Basic/SourceManager.h" 50 #include "clang/Lex/Lexer.h" 51 #include "clang/Sema/SemaDiagnostic.h" 52 #include "llvm/ADT/SmallString.h" 53 54 using namespace clang; 55 using namespace arcmt; 56 using namespace trans; 57 58 namespace { 59 60 class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter>{ 61 MigrationPass &Pass; 62 IdentifierInfo *SelfII; 63 OwningPtr<ParentMap> StmtMap; 64 Decl *ParentD; 65 Stmt *Body; 66 mutable OwningPtr<ExprSet> Removables; 67 68 public: 69 UnbridgedCastRewriter(MigrationPass &pass) : Pass(pass), ParentD(0), Body(0) { 70 SelfII = &Pass.Ctx.Idents.get("self"); 71 } 72 73 void transformBody(Stmt *body, Decl *ParentD) { 74 this->ParentD = ParentD; 75 Body = body; 76 StmtMap.reset(new ParentMap(body)); 77 TraverseStmt(body); 78 } 79 80 bool VisitCastExpr(CastExpr *E) { 81 if (E->getCastKind() != CK_CPointerToObjCPointerCast && 82 E->getCastKind() != CK_BitCast && 83 E->getCastKind() != CK_AnyPointerToBlockPointerCast) 84 return true; 85 86 QualType castType = E->getType(); 87 Expr *castExpr = E->getSubExpr(); 88 QualType castExprType = castExpr->getType(); 89 90 if (castType->isObjCRetainableType() == castExprType->isObjCRetainableType()) 91 return true; 92 93 bool exprRetainable = castExprType->isObjCIndirectLifetimeType(); 94 bool castRetainable = castType->isObjCIndirectLifetimeType(); 95 if (exprRetainable == castRetainable) return true; 96 97 if (castExpr->isNullPointerConstant(Pass.Ctx, 98 Expr::NPC_ValueDependentIsNull)) 99 return true; 100 101 SourceLocation loc = castExpr->getExprLoc(); 102 if (loc.isValid() && Pass.Ctx.getSourceManager().isInSystemHeader(loc)) 103 return true; 104 105 if (castType->isObjCRetainableType()) 106 transformNonObjCToObjCCast(E); 107 else 108 transformObjCToNonObjCCast(E); 109 110 return true; 111 } 112 113 private: 114 void transformNonObjCToObjCCast(CastExpr *E) { 115 if (!E) return; 116 117 // Global vars are assumed that are cast as unretained. 118 if (isGlobalVar(E)) 119 if (E->getSubExpr()->getType()->isPointerType()) { 120 castToObjCObject(E, /*retained=*/false); 121 return; 122 } 123 124 // If the cast is directly over the result of a Core Foundation function 125 // try to figure out whether it should be cast as retained or unretained. 126 Expr *inner = E->IgnoreParenCasts(); 127 if (CallExpr *callE = dyn_cast<CallExpr>(inner)) { 128 if (FunctionDecl *FD = callE->getDirectCallee()) { 129 if (FD->getAttr<CFReturnsRetainedAttr>()) { 130 castToObjCObject(E, /*retained=*/true); 131 return; 132 } 133 if (FD->getAttr<CFReturnsNotRetainedAttr>()) { 134 castToObjCObject(E, /*retained=*/false); 135 return; 136 } 137 if (FD->isGlobal() && 138 FD->getIdentifier() && 139 ento::cocoa::isRefType(E->getSubExpr()->getType(), "CF", 140 FD->getIdentifier()->getName())) { 141 StringRef fname = FD->getIdentifier()->getName(); 142 if (fname.endswith("Retain") || 143 fname.find("Create") != StringRef::npos || 144 fname.find("Copy") != StringRef::npos) { 145 // Do not migrate to couple of bridge transfer casts which 146 // cancel each other out. Leave it unchanged so error gets user 147 // attention instead. 148 if (FD->getName() == "CFRetain" && 149 FD->getNumParams() == 1 && 150 FD->getParent()->isTranslationUnit() && 151 FD->hasExternalLinkage()) { 152 Expr *Arg = callE->getArg(0); 153 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) { 154 const Expr *sub = ICE->getSubExpr(); 155 QualType T = sub->getType(); 156 if (T->isObjCObjectPointerType()) 157 return; 158 } 159 } 160 castToObjCObject(E, /*retained=*/true); 161 return; 162 } 163 164 if (fname.find("Get") != StringRef::npos) { 165 castToObjCObject(E, /*retained=*/false); 166 return; 167 } 168 } 169 } 170 } 171 172 // If returning an ivar or a member of an ivar from a +0 method, use 173 // a __bridge cast. 174 Expr *base = inner->IgnoreParenImpCasts(); 175 while (isa<MemberExpr>(base)) 176 base = cast<MemberExpr>(base)->getBase()->IgnoreParenImpCasts(); 177 if (isa<ObjCIvarRefExpr>(base) && 178 isa<ReturnStmt>(StmtMap->getParentIgnoreParenCasts(E))) { 179 if (ObjCMethodDecl *method = dyn_cast_or_null<ObjCMethodDecl>(ParentD)) { 180 if (!method->hasAttr<NSReturnsRetainedAttr>()) { 181 castToObjCObject(E, /*retained=*/false); 182 return; 183 } 184 } 185 } 186 } 187 188 void castToObjCObject(CastExpr *E, bool retained) { 189 rewriteToBridgedCast(E, retained ? OBC_BridgeTransfer : OBC_Bridge); 190 } 191 192 void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind) { 193 Transaction Trans(Pass.TA); 194 rewriteToBridgedCast(E, Kind, Trans); 195 } 196 197 void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind, 198 Transaction &Trans) { 199 TransformActions &TA = Pass.TA; 200 201 // We will remove the compiler diagnostic. 202 if (!TA.hasDiagnostic(diag::err_arc_mismatched_cast, 203 diag::err_arc_cast_requires_bridge, 204 E->getLocStart())) { 205 Trans.abort(); 206 return; 207 } 208 209 StringRef bridge; 210 switch(Kind) { 211 case OBC_Bridge: 212 bridge = "__bridge "; break; 213 case OBC_BridgeTransfer: 214 bridge = "__bridge_transfer "; break; 215 case OBC_BridgeRetained: 216 bridge = "__bridge_retained "; break; 217 } 218 219 TA.clearDiagnostic(diag::err_arc_mismatched_cast, 220 diag::err_arc_cast_requires_bridge, 221 E->getLocStart()); 222 if (Kind == OBC_Bridge || !Pass.CFBridgingFunctionsDefined()) { 223 if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(E)) { 224 TA.insertAfterToken(CCE->getLParenLoc(), bridge); 225 } else { 226 SourceLocation insertLoc = E->getSubExpr()->getLocStart(); 227 SmallString<128> newCast; 228 newCast += '('; 229 newCast += bridge; 230 newCast += E->getType().getAsString(Pass.Ctx.getPrintingPolicy()); 231 newCast += ')'; 232 233 if (isa<ParenExpr>(E->getSubExpr())) { 234 TA.insert(insertLoc, newCast.str()); 235 } else { 236 newCast += '('; 237 TA.insert(insertLoc, newCast.str()); 238 TA.insertAfterToken(E->getLocEnd(), ")"); 239 } 240 } 241 } else { 242 assert(Kind == OBC_BridgeTransfer || Kind == OBC_BridgeRetained); 243 SmallString<32> BridgeCall; 244 245 Expr *WrapE = E->getSubExpr(); 246 SourceLocation InsertLoc = WrapE->getLocStart(); 247 248 SourceManager &SM = Pass.Ctx.getSourceManager(); 249 char PrevChar = *SM.getCharacterData(InsertLoc.getLocWithOffset(-1)); 250 if (Lexer::isIdentifierBodyChar(PrevChar, Pass.Ctx.getLangOpts())) 251 BridgeCall += ' '; 252 253 if (Kind == OBC_BridgeTransfer) 254 BridgeCall += "CFBridgingRelease"; 255 else 256 BridgeCall += "CFBridgingRetain"; 257 258 if (isa<ParenExpr>(WrapE)) { 259 TA.insert(InsertLoc, BridgeCall); 260 } else { 261 BridgeCall += '('; 262 TA.insert(InsertLoc, BridgeCall); 263 TA.insertAfterToken(WrapE->getLocEnd(), ")"); 264 } 265 } 266 } 267 268 void rewriteCastForCFRetain(CastExpr *castE, CallExpr *callE) { 269 Transaction Trans(Pass.TA); 270 Pass.TA.replace(callE->getSourceRange(), callE->getArg(0)->getSourceRange()); 271 rewriteToBridgedCast(castE, OBC_BridgeRetained, Trans); 272 } 273 274 void getBlockMacroRanges(CastExpr *E, SourceRange &Outer, SourceRange &Inner) { 275 SourceManager &SM = Pass.Ctx.getSourceManager(); 276 SourceLocation Loc = E->getExprLoc(); 277 assert(Loc.isMacroID()); 278 SourceLocation MacroBegin, MacroEnd; 279 llvm::tie(MacroBegin, MacroEnd) = SM.getImmediateExpansionRange(Loc); 280 SourceRange SubRange = E->getSubExpr()->IgnoreParenImpCasts()->getSourceRange(); 281 SourceLocation InnerBegin = SM.getImmediateMacroCallerLoc(SubRange.getBegin()); 282 SourceLocation InnerEnd = SM.getImmediateMacroCallerLoc(SubRange.getEnd()); 283 284 Outer = SourceRange(MacroBegin, MacroEnd); 285 Inner = SourceRange(InnerBegin, InnerEnd); 286 } 287 288 void rewriteBlockCopyMacro(CastExpr *E) { 289 SourceRange OuterRange, InnerRange; 290 getBlockMacroRanges(E, OuterRange, InnerRange); 291 292 Transaction Trans(Pass.TA); 293 Pass.TA.replace(OuterRange, InnerRange); 294 Pass.TA.insert(InnerRange.getBegin(), "["); 295 Pass.TA.insertAfterToken(InnerRange.getEnd(), " copy]"); 296 Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast, 297 diag::err_arc_cast_requires_bridge, 298 OuterRange); 299 } 300 301 void removeBlockReleaseMacro(CastExpr *E) { 302 SourceRange OuterRange, InnerRange; 303 getBlockMacroRanges(E, OuterRange, InnerRange); 304 305 Transaction Trans(Pass.TA); 306 Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast, 307 diag::err_arc_cast_requires_bridge, 308 OuterRange); 309 if (!hasSideEffects(E, Pass.Ctx)) { 310 if (tryRemoving(cast<Expr>(StmtMap->getParentIgnoreParenCasts(E)))) 311 return; 312 } 313 Pass.TA.replace(OuterRange, InnerRange); 314 } 315 316 bool tryRemoving(Expr *E) const { 317 if (!Removables) { 318 Removables.reset(new ExprSet); 319 collectRemovables(Body, *Removables); 320 } 321 322 if (Removables->count(E)) { 323 Pass.TA.removeStmt(E); 324 return true; 325 } 326 327 return false; 328 } 329 330 void transformObjCToNonObjCCast(CastExpr *E) { 331 SourceLocation CastLoc = E->getExprLoc(); 332 if (CastLoc.isMacroID()) { 333 StringRef MacroName = Lexer::getImmediateMacroName(CastLoc, 334 Pass.Ctx.getSourceManager(), 335 Pass.Ctx.getLangOpts()); 336 if (MacroName == "Block_copy") { 337 rewriteBlockCopyMacro(E); 338 return; 339 } 340 if (MacroName == "Block_release") { 341 removeBlockReleaseMacro(E); 342 return; 343 } 344 } 345 346 if (isSelf(E->getSubExpr())) 347 return rewriteToBridgedCast(E, OBC_Bridge); 348 349 CallExpr *callE; 350 if (isPassedToCFRetain(E, callE)) 351 return rewriteCastForCFRetain(E, callE); 352 353 ObjCMethodFamily family = getFamilyOfMessage(E->getSubExpr()); 354 if (family == OMF_retain) 355 return rewriteToBridgedCast(E, OBC_BridgeRetained); 356 357 if (family == OMF_autorelease || family == OMF_release) { 358 std::string err = "it is not safe to cast to '"; 359 err += E->getType().getAsString(Pass.Ctx.getPrintingPolicy()); 360 err += "' the result of '"; 361 err += family == OMF_autorelease ? "autorelease" : "release"; 362 err += "' message; a __bridge cast may result in a pointer to a " 363 "destroyed object and a __bridge_retained may leak the object"; 364 Pass.TA.reportError(err, E->getLocStart(), 365 E->getSubExpr()->getSourceRange()); 366 Stmt *parent = E; 367 do { 368 parent = StmtMap->getParentIgnoreParenImpCasts(parent); 369 } while (parent && isa<ExprWithCleanups>(parent)); 370 371 if (ReturnStmt *retS = dyn_cast_or_null<ReturnStmt>(parent)) { 372 std::string note = "remove the cast and change return type of function " 373 "to '"; 374 note += E->getSubExpr()->getType().getAsString(Pass.Ctx.getPrintingPolicy()); 375 note += "' to have the object automatically autoreleased"; 376 Pass.TA.reportNote(note, retS->getLocStart()); 377 } 378 } 379 380 Expr *subExpr = E->getSubExpr(); 381 382 // Look through pseudo-object expressions. 383 if (PseudoObjectExpr *pseudo = dyn_cast<PseudoObjectExpr>(subExpr)) { 384 subExpr = pseudo->getResultExpr(); 385 assert(subExpr && "no result for pseudo-object of non-void type?"); 386 } 387 388 if (ImplicitCastExpr *implCE = dyn_cast<ImplicitCastExpr>(subExpr)) { 389 if (implCE->getCastKind() == CK_ARCConsumeObject) 390 return rewriteToBridgedCast(E, OBC_BridgeRetained); 391 if (implCE->getCastKind() == CK_ARCReclaimReturnedObject) 392 return rewriteToBridgedCast(E, OBC_Bridge); 393 } 394 395 bool isConsumed = false; 396 if (isPassedToCParamWithKnownOwnership(E, isConsumed)) 397 return rewriteToBridgedCast(E, isConsumed ? OBC_BridgeRetained 398 : OBC_Bridge); 399 } 400 401 static ObjCMethodFamily getFamilyOfMessage(Expr *E) { 402 E = E->IgnoreParenCasts(); 403 if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) 404 return ME->getMethodFamily(); 405 406 return OMF_None; 407 } 408 409 bool isPassedToCFRetain(Expr *E, CallExpr *&callE) const { 410 if ((callE = dyn_cast_or_null<CallExpr>( 411 StmtMap->getParentIgnoreParenImpCasts(E)))) 412 if (FunctionDecl * 413 FD = dyn_cast_or_null<FunctionDecl>(callE->getCalleeDecl())) 414 if (FD->getName() == "CFRetain" && FD->getNumParams() == 1 && 415 FD->getParent()->isTranslationUnit() && 416 FD->hasExternalLinkage()) 417 return true; 418 419 return false; 420 } 421 422 bool isPassedToCParamWithKnownOwnership(Expr *E, bool &isConsumed) const { 423 if (CallExpr *callE = dyn_cast_or_null<CallExpr>( 424 StmtMap->getParentIgnoreParenImpCasts(E))) 425 if (FunctionDecl * 426 FD = dyn_cast_or_null<FunctionDecl>(callE->getCalleeDecl())) { 427 unsigned i = 0; 428 for (unsigned e = callE->getNumArgs(); i != e; ++i) { 429 Expr *arg = callE->getArg(i); 430 if (arg == E || arg->IgnoreParenImpCasts() == E) 431 break; 432 } 433 if (i < callE->getNumArgs() && i < FD->getNumParams()) { 434 ParmVarDecl *PD = FD->getParamDecl(i); 435 if (PD->getAttr<CFConsumedAttr>()) { 436 isConsumed = true; 437 return true; 438 } 439 } 440 } 441 442 return false; 443 } 444 445 bool isSelf(Expr *E) const { 446 E = E->IgnoreParenLValueCasts(); 447 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 448 if (ImplicitParamDecl *IPD = dyn_cast<ImplicitParamDecl>(DRE->getDecl())) 449 if (IPD->getIdentifier() == SelfII) 450 return true; 451 452 return false; 453 } 454 }; 455 456 } // end anonymous namespace 457 458 void trans::rewriteUnbridgedCasts(MigrationPass &pass) { 459 BodyTransform<UnbridgedCastRewriter> trans(pass); 460 trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl()); 461 } 462
