contrib/llvm/tools/clang/lib/ARCMigrate/TransUnbridgedCasts.cpp

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