1 //===--- ASTCommon.cpp - Common stuff for ASTReader/ASTWriter----*- C++ -*-===// 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 // This file defines common functions that both ASTReader and ASTWriter use. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "ASTCommon.h" 15 #include "clang/AST/DeclCXX.h" 16 #include "clang/AST/DeclObjC.h" 17 #include "clang/Basic/IdentifierTable.h" 18 #include "clang/Serialization/ASTDeserializationListener.h" 19 #include "llvm/ADT/StringExtras.h" 20 21 using namespace clang; 22 23 // Give ASTDeserializationListener's VTable a home. 24 ASTDeserializationListener::~ASTDeserializationListener() { } 25 26 serialization::TypeIdx 27 serialization::TypeIdxFromBuiltin(const BuiltinType *BT) { 28 unsigned ID = 0; 29 switch (BT->getKind()) { 30 case BuiltinType::Void: 31 ID = PREDEF_TYPE_VOID_ID; 32 break; 33 case BuiltinType::Bool: 34 ID = PREDEF_TYPE_BOOL_ID; 35 break; 36 case BuiltinType::Char_U: 37 ID = PREDEF_TYPE_CHAR_U_ID; 38 break; 39 case BuiltinType::UChar: 40 ID = PREDEF_TYPE_UCHAR_ID; 41 break; 42 case BuiltinType::UShort: 43 ID = PREDEF_TYPE_USHORT_ID; 44 break; 45 case BuiltinType::UInt: 46 ID = PREDEF_TYPE_UINT_ID; 47 break; 48 case BuiltinType::ULong: 49 ID = PREDEF_TYPE_ULONG_ID; 50 break; 51 case BuiltinType::ULongLong: 52 ID = PREDEF_TYPE_ULONGLONG_ID; 53 break; 54 case BuiltinType::UInt128: 55 ID = PREDEF_TYPE_UINT128_ID; 56 break; 57 case BuiltinType::Char_S: 58 ID = PREDEF_TYPE_CHAR_S_ID; 59 break; 60 case BuiltinType::SChar: 61 ID = PREDEF_TYPE_SCHAR_ID; 62 break; 63 case BuiltinType::WChar_S: 64 case BuiltinType::WChar_U: 65 ID = PREDEF_TYPE_WCHAR_ID; 66 break; 67 case BuiltinType::Short: 68 ID = PREDEF_TYPE_SHORT_ID; 69 break; 70 case BuiltinType::Int: 71 ID = PREDEF_TYPE_INT_ID; 72 break; 73 case BuiltinType::Long: 74 ID = PREDEF_TYPE_LONG_ID; 75 break; 76 case BuiltinType::LongLong: 77 ID = PREDEF_TYPE_LONGLONG_ID; 78 break; 79 case BuiltinType::Int128: 80 ID = PREDEF_TYPE_INT128_ID; 81 break; 82 case BuiltinType::Half: 83 ID = PREDEF_TYPE_HALF_ID; 84 break; 85 case BuiltinType::Float: 86 ID = PREDEF_TYPE_FLOAT_ID; 87 break; 88 case BuiltinType::Double: 89 ID = PREDEF_TYPE_DOUBLE_ID; 90 break; 91 case BuiltinType::LongDouble: 92 ID = PREDEF_TYPE_LONGDOUBLE_ID; 93 break; 94 case BuiltinType::Float128: 95 ID = PREDEF_TYPE_FLOAT128_ID; 96 break; 97 case BuiltinType::NullPtr: 98 ID = PREDEF_TYPE_NULLPTR_ID; 99 break; 100 case BuiltinType::Char16: 101 ID = PREDEF_TYPE_CHAR16_ID; 102 break; 103 case BuiltinType::Char32: 104 ID = PREDEF_TYPE_CHAR32_ID; 105 break; 106 case BuiltinType::Overload: 107 ID = PREDEF_TYPE_OVERLOAD_ID; 108 break; 109 case BuiltinType::BoundMember: 110 ID = PREDEF_TYPE_BOUND_MEMBER; 111 break; 112 case BuiltinType::PseudoObject: 113 ID = PREDEF_TYPE_PSEUDO_OBJECT; 114 break; 115 case BuiltinType::Dependent: 116 ID = PREDEF_TYPE_DEPENDENT_ID; 117 break; 118 case BuiltinType::UnknownAny: 119 ID = PREDEF_TYPE_UNKNOWN_ANY; 120 break; 121 case BuiltinType::ARCUnbridgedCast: 122 ID = PREDEF_TYPE_ARC_UNBRIDGED_CAST; 123 break; 124 case BuiltinType::ObjCId: 125 ID = PREDEF_TYPE_OBJC_ID; 126 break; 127 case BuiltinType::ObjCClass: 128 ID = PREDEF_TYPE_OBJC_CLASS; 129 break; 130 case BuiltinType::ObjCSel: 131 ID = PREDEF_TYPE_OBJC_SEL; 132 break; 133 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 134 case BuiltinType::Id: \ 135 ID = PREDEF_TYPE_##Id##_ID; \ 136 break; 137 #include "clang/Basic/OpenCLImageTypes.def" 138 case BuiltinType::OCLSampler: 139 ID = PREDEF_TYPE_SAMPLER_ID; 140 break; 141 case BuiltinType::OCLEvent: 142 ID = PREDEF_TYPE_EVENT_ID; 143 break; 144 case BuiltinType::OCLClkEvent: 145 ID = PREDEF_TYPE_CLK_EVENT_ID; 146 break; 147 case BuiltinType::OCLQueue: 148 ID = PREDEF_TYPE_QUEUE_ID; 149 break; 150 case BuiltinType::OCLNDRange: 151 ID = PREDEF_TYPE_NDRANGE_ID; 152 break; 153 case BuiltinType::OCLReserveID: 154 ID = PREDEF_TYPE_RESERVE_ID_ID; 155 break; 156 case BuiltinType::BuiltinFn: 157 ID = PREDEF_TYPE_BUILTIN_FN; 158 break; 159 case BuiltinType::OMPArraySection: 160 ID = PREDEF_TYPE_OMP_ARRAY_SECTION; 161 break; 162 } 163 164 return TypeIdx(ID); 165 } 166 167 unsigned serialization::ComputeHash(Selector Sel) { 168 unsigned N = Sel.getNumArgs(); 169 if (N == 0) 170 ++N; 171 unsigned R = 5381; 172 for (unsigned I = 0; I != N; ++I) 173 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(I)) 174 R = llvm::HashString(II->getName(), R); 175 return R; 176 } 177 178 const DeclContext * 179 serialization::getDefinitiveDeclContext(const DeclContext *DC) { 180 switch (DC->getDeclKind()) { 181 // These entities may have multiple definitions. 182 case Decl::TranslationUnit: 183 case Decl::ExternCContext: 184 case Decl::Namespace: 185 case Decl::LinkageSpec: 186 case Decl::Export: 187 return nullptr; 188 189 // C/C++ tag types can only be defined in one place. 190 case Decl::Enum: 191 case Decl::Record: 192 if (const TagDecl *Def = cast<TagDecl>(DC)->getDefinition()) 193 return Def; 194 return nullptr; 195 196 // FIXME: These can be defined in one place... except special member 197 // functions and out-of-line definitions. 198 case Decl::CXXRecord: 199 case Decl::ClassTemplateSpecialization: 200 case Decl::ClassTemplatePartialSpecialization: 201 return nullptr; 202 203 // Each function, method, and block declaration is its own DeclContext. 204 case Decl::Function: 205 case Decl::CXXMethod: 206 case Decl::CXXConstructor: 207 case Decl::CXXDestructor: 208 case Decl::CXXConversion: 209 case Decl::ObjCMethod: 210 case Decl::Block: 211 case Decl::Captured: 212 // Objective C categories, category implementations, and class 213 // implementations can only be defined in one place. 214 case Decl::ObjCCategory: 215 case Decl::ObjCCategoryImpl: 216 case Decl::ObjCImplementation: 217 return DC; 218 219 case Decl::ObjCProtocol: 220 if (const ObjCProtocolDecl *Def 221 = cast<ObjCProtocolDecl>(DC)->getDefinition()) 222 return Def; 223 return nullptr; 224 225 // FIXME: These are defined in one place, but properties in class extensions 226 // end up being back-patched into the main interface. See 227 // Sema::HandlePropertyInClassExtension for the offending code. 228 case Decl::ObjCInterface: 229 return nullptr; 230 231 default: 232 llvm_unreachable("Unhandled DeclContext in AST reader"); 233 } 234 235 llvm_unreachable("Unhandled decl kind"); 236 } 237 238 bool serialization::isRedeclarableDeclKind(unsigned Kind) { 239 switch (static_cast<Decl::Kind>(Kind)) { 240 case Decl::TranslationUnit: 241 case Decl::ExternCContext: 242 // Special case of a "merged" declaration. 243 return true; 244 245 case Decl::Namespace: 246 case Decl::NamespaceAlias: 247 case Decl::Typedef: 248 case Decl::TypeAlias: 249 case Decl::Enum: 250 case Decl::Record: 251 case Decl::CXXRecord: 252 case Decl::ClassTemplateSpecialization: 253 case Decl::ClassTemplatePartialSpecialization: 254 case Decl::VarTemplateSpecialization: 255 case Decl::VarTemplatePartialSpecialization: 256 case Decl::Function: 257 case Decl::CXXMethod: 258 case Decl::CXXConstructor: 259 case Decl::CXXDestructor: 260 case Decl::CXXConversion: 261 case Decl::UsingShadow: 262 case Decl::ConstructorUsingShadow: 263 case Decl::Var: 264 case Decl::FunctionTemplate: 265 case Decl::ClassTemplate: 266 case Decl::VarTemplate: 267 case Decl::TypeAliasTemplate: 268 case Decl::ObjCProtocol: 269 case Decl::ObjCInterface: 270 case Decl::Empty: 271 return true; 272 273 // Never redeclarable. 274 case Decl::UsingDirective: 275 case Decl::Label: 276 case Decl::UnresolvedUsingTypename: 277 case Decl::TemplateTypeParm: 278 case Decl::EnumConstant: 279 case Decl::UnresolvedUsingValue: 280 case Decl::IndirectField: 281 case Decl::Field: 282 case Decl::MSProperty: 283 case Decl::ObjCIvar: 284 case Decl::ObjCAtDefsField: 285 case Decl::NonTypeTemplateParm: 286 case Decl::TemplateTemplateParm: 287 case Decl::Using: 288 case Decl::ObjCMethod: 289 case Decl::ObjCCategory: 290 case Decl::ObjCCategoryImpl: 291 case Decl::ObjCImplementation: 292 case Decl::ObjCProperty: 293 case Decl::ObjCCompatibleAlias: 294 case Decl::LinkageSpec: 295 case Decl::Export: 296 case Decl::ObjCPropertyImpl: 297 case Decl::PragmaComment: 298 case Decl::PragmaDetectMismatch: 299 case Decl::FileScopeAsm: 300 case Decl::AccessSpec: 301 case Decl::Friend: 302 case Decl::FriendTemplate: 303 case Decl::StaticAssert: 304 case Decl::Block: 305 case Decl::Captured: 306 case Decl::ClassScopeFunctionSpecialization: 307 case Decl::Import: 308 case Decl::OMPThreadPrivate: 309 case Decl::OMPCapturedExpr: 310 case Decl::OMPDeclareReduction: 311 case Decl::BuiltinTemplate: 312 case Decl::Decomposition: 313 case Decl::Binding: 314 return false; 315 316 // These indirectly derive from Redeclarable<T> but are not actually 317 // redeclarable. 318 case Decl::ImplicitParam: 319 case Decl::ParmVar: 320 case Decl::ObjCTypeParam: 321 return false; 322 } 323 324 llvm_unreachable("Unhandled declaration kind"); 325 } 326 327 bool serialization::needsAnonymousDeclarationNumber(const NamedDecl *D) { 328 // Friend declarations in dependent contexts aren't anonymous in the usual 329 // sense, but they cannot be found by name lookup in their semantic context 330 // (or indeed in any context), so we treat them as anonymous. 331 // 332 // This doesn't apply to friend tag decls; Sema makes those available to name 333 // lookup in the surrounding context. 334 if (D->getFriendObjectKind() && 335 D->getLexicalDeclContext()->isDependentContext() && !isa<TagDecl>(D)) { 336 // For function templates and class templates, the template is numbered and 337 // not its pattern. 338 if (auto *FD = dyn_cast<FunctionDecl>(D)) 339 return !FD->getDescribedFunctionTemplate(); 340 if (auto *RD = dyn_cast<CXXRecordDecl>(D)) 341 return !RD->getDescribedClassTemplate(); 342 return true; 343 } 344 345 // Otherwise, we only care about anonymous class members. 346 if (D->getDeclName() || !isa<CXXRecordDecl>(D->getLexicalDeclContext())) 347 return false; 348 return isa<TagDecl>(D) || isa<FieldDecl>(D); 349 } 350 351