1 //===--- TransBlockObjCVariable.cpp - Tranformations 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 // rewriteBlockObjCVariable: 11 // 12 // Adding __block to an obj-c variable could be either because the the variable 13 // is used for output storage or the user wanted to break a retain cycle. 14 // This transformation checks whether a reference of the variable for the block 15 // is actually needed (it is assigned to or its address is taken) or not. 16 // If the reference is not needed it will assume __block was added to break a 17 // cycle so it will remove '__block' and add __weak/__unsafe_unretained. 18 // e.g 19 // 20 // __block Foo *x; 21 // bar(^ { [x cake]; }); 22 // ----> 23 // __weak Foo *x; 24 // bar(^ { [x cake]; }); 25 // 26 //===----------------------------------------------------------------------===// 27 28 #include "Transforms.h" 29 #include "Internals.h" 30 #include "clang/Basic/SourceManager.h" 31 32 using namespace clang; 33 using namespace arcmt; 34 using namespace trans; 35 36 namespace { 37 38 class RootBlockObjCVarRewriter : 39 public RecursiveASTVisitor<RootBlockObjCVarRewriter> { 40 MigrationPass &Pass; 41 llvm::DenseSet<VarDecl *> CheckedVars; 42 43 class BlockVarChecker : public RecursiveASTVisitor<BlockVarChecker> { 44 VarDecl *Var; 45 46 typedef RecursiveASTVisitor<BlockVarChecker> base; 47 public: 48 BlockVarChecker(VarDecl *var) : Var(var) { } 49 50 bool TraverseImplicitCastExpr(ImplicitCastExpr *castE) { 51 if (BlockDeclRefExpr * 52 ref = dyn_cast<BlockDeclRefExpr>(castE->getSubExpr())) { 53 if (ref->getDecl() == Var) { 54 if (castE->getCastKind() == CK_LValueToRValue) 55 return true; // Using the value of the variable. 56 if (castE->getCastKind() == CK_NoOp && castE->isLValue() && 57 Var->getASTContext().getLangOptions().CPlusPlus) 58 return true; // Binding to const C++ reference. 59 } 60 } 61 62 return base::TraverseImplicitCastExpr(castE); 63 } 64 65 bool VisitBlockDeclRefExpr(BlockDeclRefExpr *E) { 66 if (E->getDecl() == Var) 67 return false; // The reference of the variable, and not just its value, 68 // is needed. 69 return true; 70 } 71 }; 72 73 public: 74 RootBlockObjCVarRewriter(MigrationPass &pass) : Pass(pass) { } 75 76 bool VisitBlockDecl(BlockDecl *block) { 77 SmallVector<VarDecl *, 4> BlockVars; 78 79 for (BlockDecl::capture_iterator 80 I = block->capture_begin(), E = block->capture_end(); I != E; ++I) { 81 VarDecl *var = I->getVariable(); 82 if (I->isByRef() && 83 !isAlreadyChecked(var) && 84 var->getType()->isObjCObjectPointerType() && 85 isImplicitStrong(var->getType())) { 86 BlockVars.push_back(var); 87 } 88 } 89 90 for (unsigned i = 0, e = BlockVars.size(); i != e; ++i) { 91 VarDecl *var = BlockVars[i]; 92 CheckedVars.insert(var); 93 94 BlockVarChecker checker(var); 95 bool onlyValueOfVarIsNeeded = checker.TraverseStmt(block->getBody()); 96 if (onlyValueOfVarIsNeeded) { 97 BlocksAttr *attr = var->getAttr<BlocksAttr>(); 98 if(!attr) 99 continue; 100 bool useWeak = canApplyWeak(Pass.Ctx, var->getType()); 101 SourceManager &SM = Pass.Ctx.getSourceManager(); 102 Transaction Trans(Pass.TA); 103 Pass.TA.replaceText(SM.getExpansionLoc(attr->getLocation()), 104 "__block", 105 useWeak ? "__weak" : "__unsafe_unretained"); 106 } 107 108 } 109 110 return true; 111 } 112 113 private: 114 bool isAlreadyChecked(VarDecl *VD) { 115 return CheckedVars.count(VD); 116 } 117 118 bool isImplicitStrong(QualType ty) { 119 if (isa<AttributedType>(ty.getTypePtr())) 120 return false; 121 return ty.getLocalQualifiers().getObjCLifetime() == Qualifiers::OCL_Strong; 122 } 123 }; 124 125 class BlockObjCVarRewriter : public RecursiveASTVisitor<BlockObjCVarRewriter> { 126 MigrationPass &Pass; 127 128 public: 129 BlockObjCVarRewriter(MigrationPass &pass) : Pass(pass) { } 130 131 bool TraverseBlockDecl(BlockDecl *block) { 132 RootBlockObjCVarRewriter(Pass).TraverseDecl(block); 133 return true; 134 } 135 }; 136 137 } // anonymous namespace 138 139 void trans::rewriteBlockObjCVariable(MigrationPass &pass) { 140 BlockObjCVarRewriter trans(pass); 141 trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl()); 142 } 143