1 //===--- TransUnbridgedCasts.cpp - Transformations to ARC mode ------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // rewriteUnbridgedCasts:
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.
17 // NSString *str = (NSString *)kUTTypePlainText;
18 // str = b ? kUTTypeRTF : kUTTypePlainText;
19 // NSString *_uuidString = (NSString *)CFUUIDCreateString(kCFAllocatorDefault,
22 // NSString *str = (__bridge NSString *)kUTTypePlainText;
23 // str = (__bridge NSString *)(b ? kUTTypeRTF : kUTTypePlainText);
24 // NSString *_uuidString = (NSString *)
25 // CFBridgingRelease(CFUUIDCreateString(kCFAllocatorDefault, _uuid));
27 // For a C pointer to ObjC, for casting 'self', __bridge is used.
29 // CFStringRef str = (CFStringRef)self;
31 // CFStringRef str = (__bridge CFStringRef)self;
33 // Uses of Block_copy/Block_release macros are rewritten:
41 //===----------------------------------------------------------------------===//
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"
54 using namespace clang;
55 using namespace arcmt;
56 using namespace trans;
60 class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter>{
62 IdentifierInfo *SelfII;
63 std::unique_ptr<ParentMap> StmtMap;
66 mutable std::unique_ptr<ExprSet> Removables;
69 UnbridgedCastRewriter(MigrationPass &pass)
70 : Pass(pass), ParentD(nullptr), Body(nullptr) {
71 SelfII = &Pass.Ctx.Idents.get("self");
74 void transformBody(Stmt *body, Decl *ParentD) {
75 this->ParentD = ParentD;
77 StmtMap.reset(new ParentMap(body));
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);
88 bool VisitCastExpr(CastExpr *E) {
89 if (E->getCastKind() != CK_CPointerToObjCPointerCast &&
90 E->getCastKind() != CK_BitCast &&
91 E->getCastKind() != CK_AnyPointerToBlockPointerCast)
94 QualType castType = E->getType();
95 Expr *castExpr = E->getSubExpr();
96 QualType castExprType = castExpr->getType();
98 if (castType->isObjCRetainableType() == castExprType->isObjCRetainableType())
101 bool exprRetainable = castExprType->isObjCIndirectLifetimeType();
102 bool castRetainable = castType->isObjCIndirectLifetimeType();
103 if (exprRetainable == castRetainable) return true;
105 if (castExpr->isNullPointerConstant(Pass.Ctx,
106 Expr::NPC_ValueDependentIsNull))
109 SourceLocation loc = castExpr->getExprLoc();
110 if (loc.isValid() && Pass.Ctx.getSourceManager().isInSystemHeader(loc))
113 if (castType->isObjCRetainableType())
114 transformNonObjCToObjCCast(E);
116 transformObjCToNonObjCCast(E);
122 void transformNonObjCToObjCCast(CastExpr *E) {
125 // Global vars are assumed that are cast as unretained.
127 if (E->getSubExpr()->getType()->isPointerType()) {
128 castToObjCObject(E, /*retained=*/false);
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);
141 if (FD->hasAttr<CFReturnsNotRetainedAttr>()) {
142 castToObjCObject(E, /*retained=*/false);
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())
168 castToObjCObject(E, /*retained=*/true);
172 if (fname.find("Get") != StringRef::npos) {
173 castToObjCObject(E, /*retained=*/false);
180 // If returning an ivar or a member of an ivar from a +0 method, use
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);
196 void castToObjCObject(CastExpr *E, bool retained) {
197 rewriteToBridgedCast(E, retained ? OBC_BridgeTransfer : OBC_Bridge);
200 void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind) {
201 Transaction Trans(Pass.TA);
202 rewriteToBridgedCast(E, Kind, Trans);
205 void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind,
206 Transaction &Trans) {
207 TransformActions &TA = Pass.TA;
209 // We will remove the compiler diagnostic.
210 if (!TA.hasDiagnostic(diag::err_arc_mismatched_cast,
211 diag::err_arc_cast_requires_bridge,
220 bridge = "__bridge "; break;
221 case OBC_BridgeTransfer:
222 bridge = "__bridge_transfer "; break;
223 case OBC_BridgeRetained:
224 bridge = "__bridge_retained "; break;
227 TA.clearDiagnostic(diag::err_arc_mismatched_cast,
228 diag::err_arc_cast_requires_bridge,
230 if (Kind == OBC_Bridge || !Pass.CFBridgingFunctionsDefined()) {
231 if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(E)) {
232 TA.insertAfterToken(CCE->getLParenLoc(), bridge);
234 SourceLocation insertLoc = E->getSubExpr()->getLocStart();
235 SmallString<128> newCast;
238 newCast += E->getType().getAsString(Pass.Ctx.getPrintingPolicy());
241 if (isa<ParenExpr>(E->getSubExpr())) {
242 TA.insert(insertLoc, newCast.str());
245 TA.insert(insertLoc, newCast.str());
246 TA.insertAfterToken(E->getLocEnd(), ")");
250 assert(Kind == OBC_BridgeTransfer || Kind == OBC_BridgeRetained);
251 SmallString<32> BridgeCall;
253 Expr *WrapE = E->getSubExpr();
254 SourceLocation InsertLoc = WrapE->getLocStart();
256 SourceManager &SM = Pass.Ctx.getSourceManager();
257 char PrevChar = *SM.getCharacterData(InsertLoc.getLocWithOffset(-1));
258 if (Lexer::isIdentifierBodyChar(PrevChar, Pass.Ctx.getLangOpts()))
261 if (Kind == OBC_BridgeTransfer)
262 BridgeCall += "CFBridgingRelease";
264 BridgeCall += "CFBridgingRetain";
266 if (isa<ParenExpr>(WrapE)) {
267 TA.insert(InsertLoc, BridgeCall);
270 TA.insert(InsertLoc, BridgeCall);
271 TA.insertAfterToken(WrapE->getLocEnd(), ")");
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);
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());
292 Outer = SourceRange(MacroBegin, MacroEnd);
293 Inner = SourceRange(InnerBegin, InnerEnd);
296 void rewriteBlockCopyMacro(CastExpr *E) {
297 SourceRange OuterRange, InnerRange;
298 getBlockMacroRanges(E, OuterRange, InnerRange);
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,
309 void removeBlockReleaseMacro(CastExpr *E) {
310 SourceRange OuterRange, InnerRange;
311 getBlockMacroRanges(E, OuterRange, InnerRange);
313 Transaction Trans(Pass.TA);
314 Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast,
315 diag::err_arc_cast_requires_bridge,
317 if (!hasSideEffects(E, Pass.Ctx)) {
318 if (tryRemoving(cast<Expr>(StmtMap->getParentIgnoreParenCasts(E))))
321 Pass.TA.replace(OuterRange, InnerRange);
324 bool tryRemoving(Expr *E) const {
326 Removables.reset(new ExprSet);
327 collectRemovables(Body, *Removables);
330 if (Removables->count(E)) {
331 Pass.TA.removeStmt(E);
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);
348 if (MacroName == "Block_release") {
349 removeBlockReleaseMacro(E);
354 if (isSelf(E->getSubExpr()))
355 return rewriteToBridgedCast(E, OBC_Bridge);
358 if (isPassedToCFRetain(E, callE))
359 return rewriteCastForCFRetain(E, callE);
361 ObjCMethodFamily family = getFamilyOfMessage(E->getSubExpr());
362 if (family == OMF_retain)
363 return rewriteToBridgedCast(E, OBC_BridgeRetained);
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());
376 parent = StmtMap->getParentIgnoreParenImpCasts(parent);
377 } while (parent && isa<ExprWithCleanups>(parent));
379 if (ReturnStmt *retS = dyn_cast_or_null<ReturnStmt>(parent)) {
380 std::string note = "remove the cast and change return type of function "
382 note += E->getSubExpr()->getType().getAsString(Pass.Ctx.getPrintingPolicy());
383 note += "' to have the object automatically autoreleased";
384 Pass.TA.reportNote(note, retS->getLocStart());
388 Expr *subExpr = E->getSubExpr();
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?");
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);
403 bool isConsumed = false;
404 if (isPassedToCParamWithKnownOwnership(E, isConsumed))
405 return rewriteToBridgedCast(E, isConsumed ? OBC_BridgeRetained
409 static ObjCMethodFamily getFamilyOfMessage(Expr *E) {
410 E = E->IgnoreParenCasts();
411 if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E))
412 return ME->getMethodFamily();
417 bool isPassedToCFRetain(Expr *E, CallExpr *&callE) const {
418 if ((callE = dyn_cast_or_null<CallExpr>(
419 StmtMap->getParentIgnoreParenImpCasts(E))))
421 FD = dyn_cast_or_null<FunctionDecl>(callE->getCalleeDecl()))
422 if (FD->getName() == "CFRetain" && FD->getNumParams() == 1 &&
423 FD->getParent()->isTranslationUnit() &&
424 FD->isExternallyVisible())
430 bool isPassedToCParamWithKnownOwnership(Expr *E, bool &isConsumed) const {
431 if (CallExpr *callE = dyn_cast_or_null<CallExpr>(
432 StmtMap->getParentIgnoreParenImpCasts(E)))
434 FD = dyn_cast_or_null<FunctionDecl>(callE->getCalleeDecl())) {
436 for (unsigned e = callE->getNumArgs(); i != e; ++i) {
437 Expr *arg = callE->getArg(i);
438 if (arg == E || arg->IgnoreParenImpCasts() == E)
441 if (i < callE->getNumArgs() && i < FD->getNumParams()) {
442 ParmVarDecl *PD = FD->getParamDecl(i);
443 if (PD->hasAttr<CFConsumedAttr>()) {
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)
464 } // end anonymous namespace
466 void trans::rewriteUnbridgedCasts(MigrationPass &pass) {
467 BodyTransform<UnbridgedCastRewriter> trans(pass);
468 trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());