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