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