blob: 48437c795fa9d0ac597bf814327f0a05ccad5762 [file] [log] [blame]
//===--- TransUnbridgedCasts.cpp - Tranformations to ARC mode -------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// rewriteUnbridgedCasts:
//
// A cast of non-objc pointer to an objc one is checked. If the non-objc pointer
// is from a file-level variable, __bridge cast is used to convert it.
// For the result of a function call that we know is +1/+0,
// __bridge/__bridge_transfer is used.
//
// NSString *str = (NSString *)kUTTypePlainText;
// str = b ? kUTTypeRTF : kUTTypePlainText;
// NSString *_uuidString = (NSString *)CFUUIDCreateString(kCFAllocatorDefault,
// _uuid);
// ---->
// NSString *str = (__bridge NSString *)kUTTypePlainText;
// str = (__bridge NSString *)(b ? kUTTypeRTF : kUTTypePlainText);
// NSString *_uuidString = (__bridge_transfer NSString *)
// CFUUIDCreateString(kCFAllocatorDefault, _uuid);
//
// For a C pointer to ObjC, for casting 'self', __bridge is used.
//
// CFStringRef str = (CFStringRef)self;
// ---->
// CFStringRef str = (__bridge CFStringRef)self;
//
//===----------------------------------------------------------------------===//
#include "Transforms.h"
#include "Internals.h"
#include "clang/Analysis/DomainSpecific/CocoaConventions.h"
#include "clang/Sema/SemaDiagnostic.h"
#include "clang/AST/ParentMap.h"
#include "clang/Basic/SourceManager.h"
#include "llvm/ADT/SmallString.h"
using namespace clang;
using namespace arcmt;
using namespace trans;
namespace {
class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter>{
MigrationPass &Pass;
IdentifierInfo *SelfII;
OwningPtr<ParentMap> StmtMap;
public:
UnbridgedCastRewriter(MigrationPass &pass) : Pass(pass) {
SelfII = &Pass.Ctx.Idents.get("self");
}
void transformBody(Stmt *body) {
StmtMap.reset(new ParentMap(body));
TraverseStmt(body);
}
bool VisitCastExpr(CastExpr *E) {
if (E->getCastKind() != CK_CPointerToObjCPointerCast
&& E->getCastKind() != CK_BitCast)
return true;
QualType castType = E->getType();
Expr *castExpr = E->getSubExpr();
QualType castExprType = castExpr->getType();
if (castType->isObjCObjectPointerType() &&
castExprType->isObjCObjectPointerType())
return true;
if (!castType->isObjCObjectPointerType() &&
!castExprType->isObjCObjectPointerType())
return true;
bool exprRetainable = castExprType->isObjCIndirectLifetimeType();
bool castRetainable = castType->isObjCIndirectLifetimeType();
if (exprRetainable == castRetainable) return true;
if (castExpr->isNullPointerConstant(Pass.Ctx,
Expr::NPC_ValueDependentIsNull))
return true;
SourceLocation loc = castExpr->getExprLoc();
if (loc.isValid() && Pass.Ctx.getSourceManager().isInSystemHeader(loc))
return true;
if (castType->isObjCObjectPointerType())
transformNonObjCToObjCCast(E);
else
transformObjCToNonObjCCast(E);
return true;
}
private:
void transformNonObjCToObjCCast(CastExpr *E) {
if (!E) return;
// Global vars are assumed that are cast as unretained.
if (isGlobalVar(E))
if (E->getSubExpr()->getType()->isPointerType()) {
castToObjCObject(E, /*retained=*/false);
return;
}
// If the cast is directly over the result of a Core Foundation function
// try to figure out whether it should be cast as retained or unretained.
Expr *inner = E->IgnoreParenCasts();
if (CallExpr *callE = dyn_cast<CallExpr>(inner)) {
if (FunctionDecl *FD = callE->getDirectCallee()) {
if (FD->getAttr<CFReturnsRetainedAttr>()) {
castToObjCObject(E, /*retained=*/true);
return;
}
if (FD->getAttr<CFReturnsNotRetainedAttr>()) {
castToObjCObject(E, /*retained=*/false);
return;
}
if (FD->isGlobal() &&
FD->getIdentifier() &&
ento::cocoa::isRefType(E->getSubExpr()->getType(), "CF",
FD->getIdentifier()->getName())) {
StringRef fname = FD->getIdentifier()->getName();
if (fname.endswith("Retain") ||
fname.find("Create") != StringRef::npos ||
fname.find("Copy") != StringRef::npos) {
// Do not migrate to couple of bridge transfer casts which
// cancel each other out. Leave it unchanged so error gets user
// attention instead.
if (FD->getName() == "CFRetain" &&
FD->getNumParams() == 1 &&
FD->getParent()->isTranslationUnit() &&
FD->getLinkage() == ExternalLinkage) {
Expr *Arg = callE->getArg(0);
if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
const Expr *sub = ICE->getSubExpr();
QualType T = sub->getType();
if (T->isObjCObjectPointerType())
return;
}
}
castToObjCObject(E, /*retained=*/true);
return;
}
if (fname.find("Get") != StringRef::npos) {
castToObjCObject(E, /*retained=*/false);
return;
}
}
}
}
}
void castToObjCObject(CastExpr *E, bool retained) {
rewriteToBridgedCast(E, retained ? OBC_BridgeTransfer : OBC_Bridge);
}
void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind) {
Transaction Trans(Pass.TA);
rewriteToBridgedCast(E, Kind, Trans);
}
void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind,
Transaction &Trans) {
TransformActions &TA = Pass.TA;
// We will remove the compiler diagnostic.
if (!TA.hasDiagnostic(diag::err_arc_mismatched_cast,
diag::err_arc_cast_requires_bridge,
E->getLocStart())) {
Trans.abort();
return;
}
StringRef bridge;
switch(Kind) {
case OBC_Bridge:
bridge = "__bridge "; break;
case OBC_BridgeTransfer:
bridge = "__bridge_transfer "; break;
case OBC_BridgeRetained:
bridge = "__bridge_retained "; break;
}
TA.clearDiagnostic(diag::err_arc_mismatched_cast,
diag::err_arc_cast_requires_bridge,
E->getLocStart());
if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(E)) {
TA.insertAfterToken(CCE->getLParenLoc(), bridge);
} else {
SourceLocation insertLoc = E->getSubExpr()->getLocStart();
SmallString<128> newCast;
newCast += '(';
newCast += bridge;
newCast += E->getType().getAsString(Pass.Ctx.getPrintingPolicy());
newCast += ')';
if (isa<ParenExpr>(E->getSubExpr())) {
TA.insert(insertLoc, newCast.str());
} else {
newCast += '(';
TA.insert(insertLoc, newCast.str());
TA.insertAfterToken(E->getLocEnd(), ")");
}
}
}
void rewriteCastForCFRetain(CastExpr *castE, CallExpr *callE) {
Transaction Trans(Pass.TA);
Pass.TA.replace(callE->getSourceRange(), callE->getArg(0)->getSourceRange());
rewriteToBridgedCast(castE, OBC_BridgeRetained, Trans);
}
void transformObjCToNonObjCCast(CastExpr *E) {
if (isSelf(E->getSubExpr()))
return rewriteToBridgedCast(E, OBC_Bridge);
CallExpr *callE;
if (isPassedToCFRetain(E, callE))
return rewriteCastForCFRetain(E, callE);
ObjCMethodFamily family = getFamilyOfMessage(E->getSubExpr());
if (family == OMF_retain)
return rewriteToBridgedCast(E, OBC_BridgeRetained);
if (family == OMF_autorelease || family == OMF_release) {
std::string err = "it is not safe to cast to '";
err += E->getType().getAsString(Pass.Ctx.getPrintingPolicy());
err += "' the result of '";
err += family == OMF_autorelease ? "autorelease" : "release";
err += "' message; a __bridge cast may result in a pointer to a "
"destroyed object and a __bridge_retained may leak the object";
Pass.TA.reportError(err, E->getLocStart(),
E->getSubExpr()->getSourceRange());
Stmt *parent = E;
do {
parent = StmtMap->getParentIgnoreParenImpCasts(parent);
} while (parent && isa<ExprWithCleanups>(parent));
if (ReturnStmt *retS = dyn_cast_or_null<ReturnStmt>(parent)) {
std::string note = "remove the cast and change return type of function "
"to '";
note += E->getSubExpr()->getType().getAsString(Pass.Ctx.getPrintingPolicy());
note += "' to have the object automatically autoreleased";
Pass.TA.reportNote(note, retS->getLocStart());
}
}
Expr *subExpr = E->getSubExpr();
// Look through pseudo-object expressions.
if (PseudoObjectExpr *pseudo = dyn_cast<PseudoObjectExpr>(subExpr)) {
subExpr = pseudo->getResultExpr();
assert(subExpr && "no result for pseudo-object of non-void type?");
}
if (ImplicitCastExpr *implCE = dyn_cast<ImplicitCastExpr>(subExpr)) {
if (implCE->getCastKind() == CK_ARCConsumeObject)
return rewriteToBridgedCast(E, OBC_BridgeRetained);
if (implCE->getCastKind() == CK_ARCReclaimReturnedObject)
return rewriteToBridgedCast(E, OBC_Bridge);
}
bool isConsumed = false;
if (isPassedToCParamWithKnownOwnership(E, isConsumed))
return rewriteToBridgedCast(E, isConsumed ? OBC_BridgeRetained
: OBC_Bridge);
}
static ObjCMethodFamily getFamilyOfMessage(Expr *E) {
E = E->IgnoreParenCasts();
if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E))
return ME->getMethodFamily();
return OMF_None;
}
bool isPassedToCFRetain(Expr *E, CallExpr *&callE) const {
if ((callE = dyn_cast_or_null<CallExpr>(
StmtMap->getParentIgnoreParenImpCasts(E))))
if (FunctionDecl *
FD = dyn_cast_or_null<FunctionDecl>(callE->getCalleeDecl()))
if (FD->getName() == "CFRetain" && FD->getNumParams() == 1 &&
FD->getParent()->isTranslationUnit() &&
FD->getLinkage() == ExternalLinkage)
return true;
return false;
}
bool isPassedToCParamWithKnownOwnership(Expr *E, bool &isConsumed) const {
if (CallExpr *callE = dyn_cast_or_null<CallExpr>(
StmtMap->getParentIgnoreParenImpCasts(E)))
if (FunctionDecl *
FD = dyn_cast_or_null<FunctionDecl>(callE->getCalleeDecl())) {
unsigned i = 0;
for (unsigned e = callE->getNumArgs(); i != e; ++i) {
Expr *arg = callE->getArg(i);
if (arg == E || arg->IgnoreParenImpCasts() == E)
break;
}
if (i < callE->getNumArgs()) {
ParmVarDecl *PD = FD->getParamDecl(i);
if (PD->getAttr<CFConsumedAttr>()) {
isConsumed = true;
return true;
}
}
}
return false;
}
bool isSelf(Expr *E) const {
E = E->IgnoreParenLValueCasts();
if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
if (ImplicitParamDecl *IPD = dyn_cast<ImplicitParamDecl>(DRE->getDecl()))
if (IPD->getIdentifier() == SelfII)
return true;
return false;
}
};
} // end anonymous namespace
void trans::rewriteUnbridgedCasts(MigrationPass &pass) {
BodyTransform<UnbridgedCastRewriter> trans(pass);
trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
}