1 //===--- TransGCAttrs.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 #include "Transforms.h"
11 #include "Internals.h"
12 #include "clang/AST/ASTContext.h"
13 #include "clang/Basic/SourceManager.h"
14 #include "clang/Lex/Lexer.h"
15 #include "clang/Sema/SemaDiagnostic.h"
16 #include "llvm/ADT/SmallString.h"
17 #include "llvm/ADT/TinyPtrVector.h"
18 #include "llvm/Support/SaveAndRestore.h"
19 
20 using namespace clang;
21 using namespace arcmt;
22 using namespace trans;
23 
24 namespace {
25 
26 /// \brief Collects all the places where GC attributes __strong/__weak occur.
27 class GCAttrsCollector : public RecursiveASTVisitor<GCAttrsCollector> {
28   MigrationContext &MigrateCtx;
29   bool FullyMigratable;
30   std::vector<ObjCPropertyDecl *> &AllProps;
31 
32   typedef RecursiveASTVisitor<GCAttrsCollector> base;
33 public:
GCAttrsCollector(MigrationContext & ctx,std::vector<ObjCPropertyDecl * > & AllProps)34   GCAttrsCollector(MigrationContext &ctx,
35                    std::vector<ObjCPropertyDecl *> &AllProps)
36     : MigrateCtx(ctx), FullyMigratable(false),
37       AllProps(AllProps) { }
38 
shouldWalkTypesOfTypeLocs() const39   bool shouldWalkTypesOfTypeLocs() const { return false; }
40 
VisitAttributedTypeLoc(AttributedTypeLoc TL)41   bool VisitAttributedTypeLoc(AttributedTypeLoc TL) {
42     handleAttr(TL);
43     return true;
44   }
45 
TraverseDecl(Decl * D)46   bool TraverseDecl(Decl *D) {
47     if (!D || D->isImplicit())
48       return true;
49 
50     SaveAndRestore<bool> Save(FullyMigratable, isMigratable(D));
51 
52     if (ObjCPropertyDecl *PropD = dyn_cast<ObjCPropertyDecl>(D)) {
53       lookForAttribute(PropD, PropD->getTypeSourceInfo());
54       AllProps.push_back(PropD);
55     } else if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
56       lookForAttribute(DD, DD->getTypeSourceInfo());
57     }
58     return base::TraverseDecl(D);
59   }
60 
lookForAttribute(Decl * D,TypeSourceInfo * TInfo)61   void lookForAttribute(Decl *D, TypeSourceInfo *TInfo) {
62     if (!TInfo)
63       return;
64     TypeLoc TL = TInfo->getTypeLoc();
65     while (TL) {
66       if (QualifiedTypeLoc QL = TL.getAs<QualifiedTypeLoc>()) {
67         TL = QL.getUnqualifiedLoc();
68       } else if (AttributedTypeLoc Attr = TL.getAs<AttributedTypeLoc>()) {
69         if (handleAttr(Attr, D))
70           break;
71         TL = Attr.getModifiedLoc();
72       } else if (ArrayTypeLoc Arr = TL.getAs<ArrayTypeLoc>()) {
73         TL = Arr.getElementLoc();
74       } else if (PointerTypeLoc PT = TL.getAs<PointerTypeLoc>()) {
75         TL = PT.getPointeeLoc();
76       } else if (ReferenceTypeLoc RT = TL.getAs<ReferenceTypeLoc>())
77         TL = RT.getPointeeLoc();
78       else
79         break;
80     }
81   }
82 
handleAttr(AttributedTypeLoc TL,Decl * D=nullptr)83   bool handleAttr(AttributedTypeLoc TL, Decl *D = nullptr) {
84     if (TL.getAttrKind() != AttributedType::attr_objc_ownership)
85       return false;
86 
87     SourceLocation Loc = TL.getAttrNameLoc();
88     unsigned RawLoc = Loc.getRawEncoding();
89     if (MigrateCtx.AttrSet.count(RawLoc))
90       return true;
91 
92     ASTContext &Ctx = MigrateCtx.Pass.Ctx;
93     SourceManager &SM = Ctx.getSourceManager();
94     if (Loc.isMacroID())
95       Loc = SM.getImmediateExpansionRange(Loc).first;
96     SmallString<32> Buf;
97     bool Invalid = false;
98     StringRef Spell = Lexer::getSpelling(
99                                   SM.getSpellingLoc(TL.getAttrEnumOperandLoc()),
100                                   Buf, SM, Ctx.getLangOpts(), &Invalid);
101     if (Invalid)
102       return false;
103     MigrationContext::GCAttrOccurrence::AttrKind Kind;
104     if (Spell == "strong")
105       Kind = MigrationContext::GCAttrOccurrence::Strong;
106     else if (Spell == "weak")
107       Kind = MigrationContext::GCAttrOccurrence::Weak;
108     else
109       return false;
110 
111     MigrateCtx.AttrSet.insert(RawLoc);
112     MigrateCtx.GCAttrs.push_back(MigrationContext::GCAttrOccurrence());
113     MigrationContext::GCAttrOccurrence &Attr = MigrateCtx.GCAttrs.back();
114 
115     Attr.Kind = Kind;
116     Attr.Loc = Loc;
117     Attr.ModifiedType = TL.getModifiedLoc().getType();
118     Attr.Dcl = D;
119     Attr.FullyMigratable = FullyMigratable;
120     return true;
121   }
122 
isMigratable(Decl * D)123   bool isMigratable(Decl *D) {
124     if (isa<TranslationUnitDecl>(D))
125       return false;
126 
127     if (isInMainFile(D))
128       return true;
129 
130     if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
131       return FD->hasBody();
132 
133     if (ObjCContainerDecl *ContD = dyn_cast<ObjCContainerDecl>(D))
134       return hasObjCImpl(ContD);
135 
136     if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
137       for (const auto *MI : RD->methods()) {
138         if (MI->isOutOfLine())
139           return true;
140       }
141       return false;
142     }
143 
144     return isMigratable(cast<Decl>(D->getDeclContext()));
145   }
146 
hasObjCImpl(Decl * D)147   static bool hasObjCImpl(Decl *D) {
148     if (!D)
149       return false;
150     if (ObjCContainerDecl *ContD = dyn_cast<ObjCContainerDecl>(D)) {
151       if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(ContD))
152         return ID->getImplementation() != nullptr;
153       if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(ContD))
154         return CD->getImplementation() != nullptr;
155       return isa<ObjCImplDecl>(ContD);
156     }
157     return false;
158   }
159 
isInMainFile(Decl * D)160   bool isInMainFile(Decl *D) {
161     if (!D)
162       return false;
163 
164     for (auto I : D->redecls())
165       if (!isInMainFile(I->getLocation()))
166         return false;
167 
168     return true;
169   }
170 
isInMainFile(SourceLocation Loc)171   bool isInMainFile(SourceLocation Loc) {
172     if (Loc.isInvalid())
173       return false;
174 
175     SourceManager &SM = MigrateCtx.Pass.Ctx.getSourceManager();
176     return SM.isInFileID(SM.getExpansionLoc(Loc), SM.getMainFileID());
177   }
178 };
179 
180 } // anonymous namespace
181 
errorForGCAttrsOnNonObjC(MigrationContext & MigrateCtx)182 static void errorForGCAttrsOnNonObjC(MigrationContext &MigrateCtx) {
183   TransformActions &TA = MigrateCtx.Pass.TA;
184 
185   for (unsigned i = 0, e = MigrateCtx.GCAttrs.size(); i != e; ++i) {
186     MigrationContext::GCAttrOccurrence &Attr = MigrateCtx.GCAttrs[i];
187     if (Attr.FullyMigratable && Attr.Dcl) {
188       if (Attr.ModifiedType.isNull())
189         continue;
190       if (!Attr.ModifiedType->isObjCRetainableType()) {
191         TA.reportError("GC managed memory will become unmanaged in ARC",
192                        Attr.Loc);
193       }
194     }
195   }
196 }
197 
checkWeakGCAttrs(MigrationContext & MigrateCtx)198 static void checkWeakGCAttrs(MigrationContext &MigrateCtx) {
199   TransformActions &TA = MigrateCtx.Pass.TA;
200 
201   for (unsigned i = 0, e = MigrateCtx.GCAttrs.size(); i != e; ++i) {
202     MigrationContext::GCAttrOccurrence &Attr = MigrateCtx.GCAttrs[i];
203     if (Attr.Kind == MigrationContext::GCAttrOccurrence::Weak) {
204       if (Attr.ModifiedType.isNull() ||
205           !Attr.ModifiedType->isObjCRetainableType())
206         continue;
207       if (!canApplyWeak(MigrateCtx.Pass.Ctx, Attr.ModifiedType,
208                         /*AllowOnUnknownClass=*/true)) {
209         Transaction Trans(TA);
210         if (!MigrateCtx.RemovedAttrSet.count(Attr.Loc.getRawEncoding()))
211           TA.replaceText(Attr.Loc, "__weak", "__unsafe_unretained");
212         TA.clearDiagnostic(diag::err_arc_weak_no_runtime,
213                            diag::err_arc_unsupported_weak_class,
214                            Attr.Loc);
215       }
216     }
217   }
218 }
219 
220 typedef llvm::TinyPtrVector<ObjCPropertyDecl *> IndivPropsTy;
221 
checkAllAtProps(MigrationContext & MigrateCtx,SourceLocation AtLoc,IndivPropsTy & IndProps)222 static void checkAllAtProps(MigrationContext &MigrateCtx,
223                             SourceLocation AtLoc,
224                             IndivPropsTy &IndProps) {
225   if (IndProps.empty())
226     return;
227 
228   for (IndivPropsTy::iterator
229          PI = IndProps.begin(), PE = IndProps.end(); PI != PE; ++PI) {
230     QualType T = (*PI)->getType();
231     if (T.isNull() || !T->isObjCRetainableType())
232       return;
233   }
234 
235   SmallVector<std::pair<AttributedTypeLoc, ObjCPropertyDecl *>, 4> ATLs;
236   bool hasWeak = false, hasStrong = false;
237   ObjCPropertyDecl::PropertyAttributeKind
238     Attrs = ObjCPropertyDecl::OBJC_PR_noattr;
239   for (IndivPropsTy::iterator
240          PI = IndProps.begin(), PE = IndProps.end(); PI != PE; ++PI) {
241     ObjCPropertyDecl *PD = *PI;
242     Attrs = PD->getPropertyAttributesAsWritten();
243     TypeSourceInfo *TInfo = PD->getTypeSourceInfo();
244     if (!TInfo)
245       return;
246     TypeLoc TL = TInfo->getTypeLoc();
247     if (AttributedTypeLoc ATL =
248             TL.getAs<AttributedTypeLoc>()) {
249       ATLs.push_back(std::make_pair(ATL, PD));
250       if (TInfo->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
251         hasWeak = true;
252       } else if (TInfo->getType().getObjCLifetime() == Qualifiers::OCL_Strong)
253         hasStrong = true;
254       else
255         return;
256     }
257   }
258   if (ATLs.empty())
259     return;
260   if (hasWeak && hasStrong)
261     return;
262 
263   TransformActions &TA = MigrateCtx.Pass.TA;
264   Transaction Trans(TA);
265 
266   if (GCAttrsCollector::hasObjCImpl(
267                               cast<Decl>(IndProps.front()->getDeclContext()))) {
268     if (hasWeak)
269       MigrateCtx.AtPropsWeak.insert(AtLoc.getRawEncoding());
270 
271   } else {
272     StringRef toAttr = "strong";
273     if (hasWeak) {
274       if (canApplyWeak(MigrateCtx.Pass.Ctx, IndProps.front()->getType(),
275                        /*AllowOnUnkwownClass=*/true))
276         toAttr = "weak";
277       else
278         toAttr = "unsafe_unretained";
279     }
280     if (Attrs & ObjCPropertyDecl::OBJC_PR_assign)
281       MigrateCtx.rewritePropertyAttribute("assign", toAttr, AtLoc);
282     else
283       MigrateCtx.addPropertyAttribute(toAttr, AtLoc);
284   }
285 
286   for (unsigned i = 0, e = ATLs.size(); i != e; ++i) {
287     SourceLocation Loc = ATLs[i].first.getAttrNameLoc();
288     if (Loc.isMacroID())
289       Loc = MigrateCtx.Pass.Ctx.getSourceManager()
290                                          .getImmediateExpansionRange(Loc).first;
291     TA.remove(Loc);
292     TA.clearDiagnostic(diag::err_objc_property_attr_mutually_exclusive, AtLoc);
293     TA.clearDiagnostic(diag::err_arc_inconsistent_property_ownership,
294                        ATLs[i].second->getLocation());
295     MigrateCtx.RemovedAttrSet.insert(Loc.getRawEncoding());
296   }
297 }
298 
checkAllProps(MigrationContext & MigrateCtx,std::vector<ObjCPropertyDecl * > & AllProps)299 static void checkAllProps(MigrationContext &MigrateCtx,
300                           std::vector<ObjCPropertyDecl *> &AllProps) {
301   typedef llvm::TinyPtrVector<ObjCPropertyDecl *> IndivPropsTy;
302   llvm::DenseMap<unsigned, IndivPropsTy> AtProps;
303 
304   for (unsigned i = 0, e = AllProps.size(); i != e; ++i) {
305     ObjCPropertyDecl *PD = AllProps[i];
306     if (PD->getPropertyAttributesAsWritten() &
307           (ObjCPropertyDecl::OBJC_PR_assign |
308            ObjCPropertyDecl::OBJC_PR_readonly)) {
309       SourceLocation AtLoc = PD->getAtLoc();
310       if (AtLoc.isInvalid())
311         continue;
312       unsigned RawAt = AtLoc.getRawEncoding();
313       AtProps[RawAt].push_back(PD);
314     }
315   }
316 
317   for (llvm::DenseMap<unsigned, IndivPropsTy>::iterator
318          I = AtProps.begin(), E = AtProps.end(); I != E; ++I) {
319     SourceLocation AtLoc = SourceLocation::getFromRawEncoding(I->first);
320     IndivPropsTy &IndProps = I->second;
321     checkAllAtProps(MigrateCtx, AtLoc, IndProps);
322   }
323 }
324 
traverseTU(MigrationContext & MigrateCtx)325 void GCAttrsTraverser::traverseTU(MigrationContext &MigrateCtx) {
326   std::vector<ObjCPropertyDecl *> AllProps;
327   GCAttrsCollector(MigrateCtx, AllProps).TraverseDecl(
328                                   MigrateCtx.Pass.Ctx.getTranslationUnitDecl());
329 
330   errorForGCAttrsOnNonObjC(MigrateCtx);
331   checkAllProps(MigrateCtx, AllProps);
332   checkWeakGCAttrs(MigrateCtx);
333 }
334 
dumpGCAttrs()335 void MigrationContext::dumpGCAttrs() {
336   llvm::errs() << "\n################\n";
337   for (unsigned i = 0, e = GCAttrs.size(); i != e; ++i) {
338     GCAttrOccurrence &Attr = GCAttrs[i];
339     llvm::errs() << "KIND: "
340         << (Attr.Kind == GCAttrOccurrence::Strong ? "strong" : "weak");
341     llvm::errs() << "\nLOC: ";
342     Attr.Loc.dump(Pass.Ctx.getSourceManager());
343     llvm::errs() << "\nTYPE: ";
344     Attr.ModifiedType.dump();
345     if (Attr.Dcl) {
346       llvm::errs() << "DECL:\n";
347       Attr.Dcl->dump();
348     } else {
349       llvm::errs() << "DECL: NONE";
350     }
351     llvm::errs() << "\nMIGRATABLE: " << Attr.FullyMigratable;
352     llvm::errs() << "\n----------------\n";
353   }
354   llvm::errs() << "\n################\n";
355 }
356