xref: /freebsd/contrib/llvm-project/clang/lib/ARCMigrate/TransUnbridgedCasts.cpp (revision 43a5ec4eb41567cc92586503212743d89686d78f) 
1 //===--- TransUnbridgedCasts.cpp - Transformations to ARC mode ------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // rewriteUnbridgedCasts:
10 //
11 // A cast of non-objc pointer to an objc one is checked. If the non-objc pointer
12 // is from a file-level variable, __bridge cast is used to convert it.
13 // For the result of a function call that we know is +1/+0,
14 // __bridge/CFBridgingRelease is used.
15 //
16 //  NSString *str = (NSString *)kUTTypePlainText;
17 //  str = b ? kUTTypeRTF : kUTTypePlainText;
18 //  NSString *_uuidString = (NSString *)CFUUIDCreateString(kCFAllocatorDefault,
19 //                                                         _uuid);
20 // ---->
21 //  NSString *str = (__bridge NSString *)kUTTypePlainText;
22 //  str = (__bridge NSString *)(b ? kUTTypeRTF : kUTTypePlainText);
23 // NSString *_uuidString = (NSString *)
24 //            CFBridgingRelease(CFUUIDCreateString(kCFAllocatorDefault, _uuid));
25 //
26 // For a C pointer to ObjC, for casting 'self', __bridge is used.
27 //
28 //  CFStringRef str = (CFStringRef)self;
29 // ---->
30 //  CFStringRef str = (__bridge CFStringRef)self;
31 //
32 // Uses of Block_copy/Block_release macros are rewritten:
33 //
34 //  c = Block_copy(b);
35 //  Block_release(c);
36 // ---->
37 //  c = [b copy];
38 //  <removed>
39 //
40 //===----------------------------------------------------------------------===//
41 
42 #include "Transforms.h"
43 #include "Internals.h"
44 #include "clang/AST/ASTContext.h"
45 #include "clang/AST/Attr.h"
46 #include "clang/AST/ParentMap.h"
47 #include "clang/Analysis/DomainSpecific/CocoaConventions.h"
48 #include "clang/Basic/SourceManager.h"
49 #include "clang/Lex/Lexer.h"
50 #include "clang/Sema/SemaDiagnostic.h"
51 #include "llvm/ADT/SmallString.h"
52 
53 using namespace clang;
54 using namespace arcmt;
55 using namespace trans;
56 
57 namespace {
58 
59 class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter>{
60   MigrationPass &Pass;
61   IdentifierInfo *SelfII;
62   std::unique_ptr<ParentMap> StmtMap;
63   Decl *ParentD;
64   Stmt *Body;
65   mutable std::unique_ptr<ExprSet> Removables;
66 
67 public:
68   UnbridgedCastRewriter(MigrationPass &pass)
69     : Pass(pass), ParentD(nullptr), Body(nullptr) {
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 
120 private:
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->getBeginLoc())) {
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, E->getBeginLoc());
228     if (Kind == OBC_Bridge || !Pass.CFBridgingFunctionsDefined()) {
229       if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(E)) {
230         TA.insertAfterToken(CCE->getLParenLoc(), bridge);
231       } else {
232         SourceLocation insertLoc = E->getSubExpr()->getBeginLoc();
233         SmallString<128> newCast;
234         newCast += '(';
235         newCast += bridge;
236         newCast += E->getType().getAsString(Pass.Ctx.getPrintingPolicy());
237         newCast += ')';
238 
239         if (isa<ParenExpr>(E->getSubExpr())) {
240           TA.insert(insertLoc, newCast.str());
241         } else {
242           newCast += '(';
243           TA.insert(insertLoc, newCast.str());
244           TA.insertAfterToken(E->getEndLoc(), ")");
245         }
246       }
247     } else {
248       assert(Kind == OBC_BridgeTransfer || Kind == OBC_BridgeRetained);
249       SmallString<32> BridgeCall;
250 
251       Expr *WrapE = E->getSubExpr();
252       SourceLocation InsertLoc = WrapE->getBeginLoc();
253 
254       SourceManager &SM = Pass.Ctx.getSourceManager();
255       char PrevChar = *SM.getCharacterData(InsertLoc.getLocWithOffset(-1));
256       if (Lexer::isIdentifierBodyChar(PrevChar, Pass.Ctx.getLangOpts()))
257         BridgeCall += ' ';
258 
259       if (Kind == OBC_BridgeTransfer)
260         BridgeCall += "CFBridgingRelease";
261       else
262         BridgeCall += "CFBridgingRetain";
263 
264       if (isa<ParenExpr>(WrapE)) {
265         TA.insert(InsertLoc, BridgeCall);
266       } else {
267         BridgeCall += '(';
268         TA.insert(InsertLoc, BridgeCall);
269         TA.insertAfterToken(WrapE->getEndLoc(), ")");
270       }
271     }
272   }
273 
274   void rewriteCastForCFRetain(CastExpr *castE, CallExpr *callE) {
275     Transaction Trans(Pass.TA);
276     Pass.TA.replace(callE->getSourceRange(), callE->getArg(0)->getSourceRange());
277     rewriteToBridgedCast(castE, OBC_BridgeRetained, Trans);
278   }
279 
280   void getBlockMacroRanges(CastExpr *E, SourceRange &Outer, SourceRange &Inner) {
281     SourceManager &SM = Pass.Ctx.getSourceManager();
282     SourceLocation Loc = E->getExprLoc();
283     assert(Loc.isMacroID());
284     CharSourceRange MacroRange = SM.getImmediateExpansionRange(Loc);
285     SourceRange SubRange = E->getSubExpr()->IgnoreParenImpCasts()->getSourceRange();
286     SourceLocation InnerBegin = SM.getImmediateMacroCallerLoc(SubRange.getBegin());
287     SourceLocation InnerEnd = SM.getImmediateMacroCallerLoc(SubRange.getEnd());
288 
289     Outer = MacroRange.getAsRange();
290     Inner = SourceRange(InnerBegin, InnerEnd);
291   }
292 
293   void rewriteBlockCopyMacro(CastExpr *E) {
294     SourceRange OuterRange, InnerRange;
295     getBlockMacroRanges(E, OuterRange, InnerRange);
296 
297     Transaction Trans(Pass.TA);
298     Pass.TA.replace(OuterRange, InnerRange);
299     Pass.TA.insert(InnerRange.getBegin(), "[");
300     Pass.TA.insertAfterToken(InnerRange.getEnd(), " copy]");
301     Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast,
302                             diag::err_arc_cast_requires_bridge,
303                             OuterRange);
304   }
305 
306   void removeBlockReleaseMacro(CastExpr *E) {
307     SourceRange OuterRange, InnerRange;
308     getBlockMacroRanges(E, OuterRange, InnerRange);
309 
310     Transaction Trans(Pass.TA);
311     Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast,
312                             diag::err_arc_cast_requires_bridge,
313                             OuterRange);
314     if (!hasSideEffects(E, Pass.Ctx)) {
315       if (tryRemoving(cast<Expr>(StmtMap->getParentIgnoreParenCasts(E))))
316         return;
317     }
318     Pass.TA.replace(OuterRange, InnerRange);
319   }
320 
321   bool tryRemoving(Expr *E) const {
322     if (!Removables) {
323       Removables.reset(new ExprSet);
324       collectRemovables(Body, *Removables);
325     }
326 
327     if (Removables->count(E)) {
328       Pass.TA.removeStmt(E);
329       return true;
330     }
331 
332     return false;
333   }
334 
335   void transformObjCToNonObjCCast(CastExpr *E) {
336     SourceLocation CastLoc = E->getExprLoc();
337     if (CastLoc.isMacroID()) {
338       StringRef MacroName = Lexer::getImmediateMacroName(CastLoc,
339                                                     Pass.Ctx.getSourceManager(),
340                                                     Pass.Ctx.getLangOpts());
341       if (MacroName == "Block_copy") {
342         rewriteBlockCopyMacro(E);
343         return;
344       }
345       if (MacroName == "Block_release") {
346         removeBlockReleaseMacro(E);
347         return;
348       }
349     }
350 
351     if (isSelf(E->getSubExpr()))
352       return rewriteToBridgedCast(E, OBC_Bridge);
353 
354     CallExpr *callE;
355     if (isPassedToCFRetain(E, callE))
356       return rewriteCastForCFRetain(E, callE);
357 
358     ObjCMethodFamily family = getFamilyOfMessage(E->getSubExpr());
359     if (family == OMF_retain)
360       return rewriteToBridgedCast(E, OBC_BridgeRetained);
361 
362     if (family == OMF_autorelease || family == OMF_release) {
363       std::string err = "it is not safe to cast to '";
364       err += E->getType().getAsString(Pass.Ctx.getPrintingPolicy());
365       err += "' the result of '";
366       err += family == OMF_autorelease ? "autorelease" : "release";
367       err += "' message; a __bridge cast may result in a pointer to a "
368           "destroyed object and a __bridge_retained may leak the object";
369       Pass.TA.reportError(err, E->getBeginLoc(),
370                           E->getSubExpr()->getSourceRange());
371       Stmt *parent = E;
372       do {
373         parent = StmtMap->getParentIgnoreParenImpCasts(parent);
374       } while (parent && isa<FullExpr>(parent));
375 
376       if (ReturnStmt *retS = dyn_cast_or_null<ReturnStmt>(parent)) {
377         std::string note = "remove the cast and change return type of function "
378             "to '";
379         note += E->getSubExpr()->getType().getAsString(Pass.Ctx.getPrintingPolicy());
380         note += "' to have the object automatically autoreleased";
381         Pass.TA.reportNote(note, retS->getBeginLoc());
382       }
383     }
384 
385     Expr *subExpr = E->getSubExpr();
386 
387     // Look through pseudo-object expressions.
388     if (PseudoObjectExpr *pseudo = dyn_cast<PseudoObjectExpr>(subExpr)) {
389       subExpr = pseudo->getResultExpr();
390       assert(subExpr && "no result for pseudo-object of non-void type?");
391     }
392 
393     if (ImplicitCastExpr *implCE = dyn_cast<ImplicitCastExpr>(subExpr)) {
394       if (implCE->getCastKind() == CK_ARCConsumeObject)
395         return rewriteToBridgedCast(E, OBC_BridgeRetained);
396       if (implCE->getCastKind() == CK_ARCReclaimReturnedObject)
397         return rewriteToBridgedCast(E, OBC_Bridge);
398     }
399 
400     bool isConsumed = false;
401     if (isPassedToCParamWithKnownOwnership(E, isConsumed))
402       return rewriteToBridgedCast(E, isConsumed ? OBC_BridgeRetained
403                                                 : OBC_Bridge);
404   }
405 
406   static ObjCMethodFamily getFamilyOfMessage(Expr *E) {
407     E = E->IgnoreParenCasts();
408     if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E))
409       return ME->getMethodFamily();
410 
411     return OMF_None;
412   }
413 
414   bool isPassedToCFRetain(Expr *E, CallExpr *&callE) const {
415     if ((callE = dyn_cast_or_null<CallExpr>(
416                                      StmtMap->getParentIgnoreParenImpCasts(E))))
417       if (FunctionDecl *
418             FD = dyn_cast_or_null<FunctionDecl>(callE->getCalleeDecl()))
419         if (FD->getName() == "CFRetain" && FD->getNumParams() == 1 &&
420             FD->getParent()->isTranslationUnit() &&
421             FD->isExternallyVisible())
422           return true;
423 
424     return false;
425   }
426 
427   bool isPassedToCParamWithKnownOwnership(Expr *E, bool &isConsumed) const {
428     if (CallExpr *callE = dyn_cast_or_null<CallExpr>(
429                                      StmtMap->getParentIgnoreParenImpCasts(E)))
430       if (FunctionDecl *
431             FD = dyn_cast_or_null<FunctionDecl>(callE->getCalleeDecl())) {
432         unsigned i = 0;
433         for (unsigned e = callE->getNumArgs(); i != e; ++i) {
434           Expr *arg = callE->getArg(i);
435           if (arg == E || arg->IgnoreParenImpCasts() == E)
436             break;
437         }
438         if (i < callE->getNumArgs() && i < FD->getNumParams()) {
439           ParmVarDecl *PD = FD->getParamDecl(i);
440           if (PD->hasAttr<CFConsumedAttr>()) {
441             isConsumed = true;
442             return true;
443           }
444         }
445       }
446 
447     return false;
448   }
449 
450   bool isSelf(Expr *E) const {
451     E = E->IgnoreParenLValueCasts();
452     if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
453       if (ImplicitParamDecl *IPD = dyn_cast<ImplicitParamDecl>(DRE->getDecl()))
454         if (IPD->getIdentifier() == SelfII)
455           return true;
456 
457     return false;
458   }
459 };
460 
461 } // end anonymous namespace
462 
463 void trans::rewriteUnbridgedCasts(MigrationPass &pass) {
464   BodyTransform<UnbridgedCastRewriter> trans(pass);
465   trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
466 }
467