clang/lib/Serialization/ASTCommon.cpp

   1 //===--- ASTCommon.cpp - Common stuff for ASTReader/ASTWriter----*- C++ -*-===//
   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 //  This file defines common functions that both ASTReader and ASTWriter use.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "ASTCommon.h"
  14 #include "clang/AST/DeclCXX.h"
  15 #include "clang/AST/DeclObjC.h"
  16 #include "clang/Basic/IdentifierTable.h"
  17 #include "clang/Serialization/ASTDeserializationListener.h"
  18 #include "llvm/Support/DJB.h"
  19
  20 using namespace clang;
  21
  22 // Give ASTDeserializationListener's VTable a home.
  23 ASTDeserializationListener::~ASTDeserializationListener() { }
  24
  25 serialization::TypeIdx
  26 serialization::TypeIdxFromBuiltin(const BuiltinType *BT) {
  27   unsigned ID = 0;
  28   switch (BT->getKind()) {
  29   case BuiltinType::Void:
  30     ID = PREDEF_TYPE_VOID_ID;
  31     break;
  32   case BuiltinType::Bool:
  33     ID = PREDEF_TYPE_BOOL_ID;
  34     break;
  35   case BuiltinType::Char_U:
  36     ID = PREDEF_TYPE_CHAR_U_ID;
  37     break;
  38   case BuiltinType::UChar:
  39     ID = PREDEF_TYPE_UCHAR_ID;
  40     break;
  41   case BuiltinType::UShort:
  42     ID = PREDEF_TYPE_USHORT_ID;
  43     break;
  44   case BuiltinType::UInt:
  45     ID = PREDEF_TYPE_UINT_ID;
  46     break;
  47   case BuiltinType::ULong:
  48     ID = PREDEF_TYPE_ULONG_ID;
  49     break;
  50   case BuiltinType::ULongLong:
  51     ID = PREDEF_TYPE_ULONGLONG_ID;
  52     break;
  53   case BuiltinType::UInt128:
  54     ID = PREDEF_TYPE_UINT128_ID;
  55     break;
  56   case BuiltinType::Char_S:
  57     ID = PREDEF_TYPE_CHAR_S_ID;
  58     break;
  59   case BuiltinType::SChar:
  60     ID = PREDEF_TYPE_SCHAR_ID;
  61     break;
  62   case BuiltinType::WChar_S:
  63   case BuiltinType::WChar_U:
  64     ID = PREDEF_TYPE_WCHAR_ID;
  65     break;
  66   case BuiltinType::Short:
  67     ID = PREDEF_TYPE_SHORT_ID;
  68     break;
  69   case BuiltinType::Int:
  70     ID = PREDEF_TYPE_INT_ID;
  71     break;
  72   case BuiltinType::Long:
  73     ID = PREDEF_TYPE_LONG_ID;
  74     break;
  75   case BuiltinType::LongLong:
  76     ID = PREDEF_TYPE_LONGLONG_ID;
  77     break;
  78   case BuiltinType::Int128:
  79     ID = PREDEF_TYPE_INT128_ID;
  80     break;
  81   case BuiltinType::Half:
  82     ID = PREDEF_TYPE_HALF_ID;
  83     break;
  84   case BuiltinType::Float:
  85     ID = PREDEF_TYPE_FLOAT_ID;
  86     break;
  87   case BuiltinType::Double:
  88     ID = PREDEF_TYPE_DOUBLE_ID;
  89     break;
  90   case BuiltinType::LongDouble:
  91     ID = PREDEF_TYPE_LONGDOUBLE_ID;
  92     break;
  93   case BuiltinType::ShortAccum:
  94     ID = PREDEF_TYPE_SHORT_ACCUM_ID;
  95     break;
  96   case BuiltinType::Accum:
  97     ID = PREDEF_TYPE_ACCUM_ID;
  98     break;
  99   case BuiltinType::LongAccum:
 100     ID = PREDEF_TYPE_LONG_ACCUM_ID;
 101     break;
 102   case BuiltinType::UShortAccum:
 103     ID = PREDEF_TYPE_USHORT_ACCUM_ID;
 104     break;
 105   case BuiltinType::UAccum:
 106     ID = PREDEF_TYPE_UACCUM_ID;
 107     break;
 108   case BuiltinType::ULongAccum:
 109     ID = PREDEF_TYPE_ULONG_ACCUM_ID;
 110     break;
 111   case BuiltinType::ShortFract:
 112     ID = PREDEF_TYPE_SHORT_FRACT_ID;
 113     break;
 114   case BuiltinType::Fract:
 115     ID = PREDEF_TYPE_FRACT_ID;
 116     break;
 117   case BuiltinType::LongFract:
 118     ID = PREDEF_TYPE_LONG_FRACT_ID;
 119     break;
 120   case BuiltinType::UShortFract:
 121     ID = PREDEF_TYPE_USHORT_FRACT_ID;
 122     break;
 123   case BuiltinType::UFract:
 124     ID = PREDEF_TYPE_UFRACT_ID;
 125     break;
 126   case BuiltinType::ULongFract:
 127     ID = PREDEF_TYPE_ULONG_FRACT_ID;
 128     break;
 129   case BuiltinType::SatShortAccum:
 130     ID = PREDEF_TYPE_SAT_SHORT_ACCUM_ID;
 131     break;
 132   case BuiltinType::SatAccum:
 133     ID = PREDEF_TYPE_SAT_ACCUM_ID;
 134     break;
 135   case BuiltinType::SatLongAccum:
 136     ID = PREDEF_TYPE_SAT_LONG_ACCUM_ID;
 137     break;
 138   case BuiltinType::SatUShortAccum:
 139     ID = PREDEF_TYPE_SAT_USHORT_ACCUM_ID;
 140     break;
 141   case BuiltinType::SatUAccum:
 142     ID = PREDEF_TYPE_SAT_UACCUM_ID;
 143     break;
 144   case BuiltinType::SatULongAccum:
 145     ID = PREDEF_TYPE_SAT_ULONG_ACCUM_ID;
 146     break;
 147   case BuiltinType::SatShortFract:
 148     ID = PREDEF_TYPE_SAT_SHORT_FRACT_ID;
 149     break;
 150   case BuiltinType::SatFract:
 151     ID = PREDEF_TYPE_SAT_FRACT_ID;
 152     break;
 153   case BuiltinType::SatLongFract:
 154     ID = PREDEF_TYPE_SAT_LONG_FRACT_ID;
 155     break;
 156   case BuiltinType::SatUShortFract:
 157     ID = PREDEF_TYPE_SAT_USHORT_FRACT_ID;
 158     break;
 159   case BuiltinType::SatUFract:
 160     ID = PREDEF_TYPE_SAT_UFRACT_ID;
 161     break;
 162   case BuiltinType::SatULongFract:
 163     ID = PREDEF_TYPE_SAT_ULONG_FRACT_ID;
 164     break;
 165   case BuiltinType::Float16:
 166     ID = PREDEF_TYPE_FLOAT16_ID;
 167     break;
 168   case BuiltinType::Float128:
 169     ID = PREDEF_TYPE_FLOAT128_ID;
 170     break;
 171   case BuiltinType::Ibm128:
 172     ID = PREDEF_TYPE_IBM128_ID;
 173     break;
 174   case BuiltinType::NullPtr:
 175     ID = PREDEF_TYPE_NULLPTR_ID;
 176     break;
 177   case BuiltinType::Char8:
 178     ID = PREDEF_TYPE_CHAR8_ID;
 179     break;
 180   case BuiltinType::Char16:
 181     ID = PREDEF_TYPE_CHAR16_ID;
 182     break;
 183   case BuiltinType::Char32:
 184     ID = PREDEF_TYPE_CHAR32_ID;
 185     break;
 186   case BuiltinType::Overload:
 187     ID = PREDEF_TYPE_OVERLOAD_ID;
 188     break;
 189   case BuiltinType::BoundMember:
 190     ID = PREDEF_TYPE_BOUND_MEMBER;
 191     break;
 192   case BuiltinType::PseudoObject:
 193     ID = PREDEF_TYPE_PSEUDO_OBJECT;
 194     break;
 195   case BuiltinType::Dependent:
 196     ID = PREDEF_TYPE_DEPENDENT_ID;
 197     break;
 198   case BuiltinType::UnknownAny:
 199     ID = PREDEF_TYPE_UNKNOWN_ANY;
 200     break;
 201   case BuiltinType::ARCUnbridgedCast:
 202     ID = PREDEF_TYPE_ARC_UNBRIDGED_CAST;
 203     break;
 204   case BuiltinType::ObjCId:
 205     ID = PREDEF_TYPE_OBJC_ID;
 206     break;
 207   case BuiltinType::ObjCClass:
 208     ID = PREDEF_TYPE_OBJC_CLASS;
 209     break;
 210   case BuiltinType::ObjCSel:
 211     ID = PREDEF_TYPE_OBJC_SEL;
 212     break;
 213 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
 214   case BuiltinType::Id: \
 215     ID = PREDEF_TYPE_##Id##_ID; \
 216     break;
 217 #include "clang/Basic/OpenCLImageTypes.def"
 218 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
 219   case BuiltinType::Id: \
 220     ID = PREDEF_TYPE_##Id##_ID; \
 221     break;
 222 #include "clang/Basic/OpenCLExtensionTypes.def"
 223   case BuiltinType::OCLSampler:
 224     ID = PREDEF_TYPE_SAMPLER_ID;
 225     break;
 226   case BuiltinType::OCLEvent:
 227     ID = PREDEF_TYPE_EVENT_ID;
 228     break;
 229   case BuiltinType::OCLClkEvent:
 230     ID = PREDEF_TYPE_CLK_EVENT_ID;
 231     break;
 232   case BuiltinType::OCLQueue:
 233     ID = PREDEF_TYPE_QUEUE_ID;
 234     break;
 235   case BuiltinType::OCLReserveID:
 236     ID = PREDEF_TYPE_RESERVE_ID_ID;
 237     break;
 238 #define SVE_TYPE(Name, Id, SingletonId) \
 239   case BuiltinType::Id: \
 240     ID = PREDEF_TYPE_##Id##_ID; \
 241     break;
 242 #include "clang/Basic/AArch64SVEACLETypes.def"
 243 #define PPC_VECTOR_TYPE(Name, Id, Size) \
 244   case BuiltinType::Id: \
 245     ID = PREDEF_TYPE_##Id##_ID; \
 246     break;
 247 #include "clang/Basic/PPCTypes.def"
 248 #define RVV_TYPE(Name, Id, SingletonId)                                        \
 249   case BuiltinType::Id:                                                        \
 250     ID = PREDEF_TYPE_##Id##_ID;                                                \
 251     break;
 252 #include "clang/Basic/RISCVVTypes.def"
 253   case BuiltinType::BuiltinFn:
 254     ID = PREDEF_TYPE_BUILTIN_FN;
 255     break;
 256   case BuiltinType::IncompleteMatrixIdx:
 257     ID = PREDEF_TYPE_INCOMPLETE_MATRIX_IDX;
 258     break;
 259   case BuiltinType::OMPArraySection:
 260     ID = PREDEF_TYPE_OMP_ARRAY_SECTION;
 261     break;
 262   case BuiltinType::OMPArrayShaping:
 263     ID = PREDEF_TYPE_OMP_ARRAY_SHAPING;
 264     break;
 265   case BuiltinType::OMPIterator:
 266     ID = PREDEF_TYPE_OMP_ITERATOR;
 267     break;
 268   case BuiltinType::BFloat16:
 269     ID = PREDEF_TYPE_BFLOAT16_ID;
 270     break;
 271   }
 272
 273   return TypeIdx(ID);
 274 }
 275
 276 unsigned serialization::ComputeHash(Selector Sel) {
 277   unsigned N = Sel.getNumArgs();
 278   if (N == 0)
 279     ++N;
 280   unsigned R = 5381;
 281   for (unsigned I = 0; I != N; ++I)
 282     if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(I))
 283       R = llvm::djbHash(II->getName(), R);
 284   return R;
 285 }
 286
 287 const DeclContext *
 288 serialization::getDefinitiveDeclContext(const DeclContext *DC) {
 289   switch (DC->getDeclKind()) {
 290   // These entities may have multiple definitions.
 291   case Decl::TranslationUnit:
 292   case Decl::ExternCContext:
 293   case Decl::Namespace:
 294   case Decl::LinkageSpec:
 295   case Decl::Export:
 296     return nullptr;
 297
 298   // C/C++ tag types can only be defined in one place.
 299   case Decl::Enum:
 300   case Decl::Record:
 301     if (const TagDecl *Def = cast<TagDecl>(DC)->getDefinition())
 302       return Def;
 303     return nullptr;
 304
 305   // FIXME: These can be defined in one place... except special member
 306   // functions and out-of-line definitions.
 307   case Decl::CXXRecord:
 308   case Decl::ClassTemplateSpecialization:
 309   case Decl::ClassTemplatePartialSpecialization:
 310     return nullptr;
 311
 312   // Each function, method, and block declaration is its own DeclContext.
 313   case Decl::Function:
 314   case Decl::CXXMethod:
 315   case Decl::CXXConstructor:
 316   case Decl::CXXDestructor:
 317   case Decl::CXXConversion:
 318   case Decl::ObjCMethod:
 319   case Decl::Block:
 320   case Decl::Captured:
 321     // Objective C categories, category implementations, and class
 322     // implementations can only be defined in one place.
 323   case Decl::ObjCCategory:
 324   case Decl::ObjCCategoryImpl:
 325   case Decl::ObjCImplementation:
 326     return DC;
 327
 328   case Decl::ObjCProtocol:
 329     if (const ObjCProtocolDecl *Def
 330           = cast<ObjCProtocolDecl>(DC)->getDefinition())
 331       return Def;
 332     return nullptr;
 333
 334   // FIXME: These are defined in one place, but properties in class extensions
 335   // end up being back-patched into the main interface. See
 336   // Sema::HandlePropertyInClassExtension for the offending code.
 337   case Decl::ObjCInterface:
 338     return nullptr;
 339
 340   default:
 341     llvm_unreachable("Unhandled DeclContext in AST reader");
 342   }
 343
 344   llvm_unreachable("Unhandled decl kind");
 345 }
 346
 347 bool serialization::isRedeclarableDeclKind(unsigned Kind) {
 348   switch (static_cast<Decl::Kind>(Kind)) {
 349   case Decl::TranslationUnit:
 350   case Decl::ExternCContext:
 351     // Special case of a "merged" declaration.
 352     return true;
 353
 354   case Decl::Namespace:
 355   case Decl::NamespaceAlias:
 356   case Decl::Typedef:
 357   case Decl::TypeAlias:
 358   case Decl::Enum:
 359   case Decl::Record:
 360   case Decl::CXXRecord:
 361   case Decl::ClassTemplateSpecialization:
 362   case Decl::ClassTemplatePartialSpecialization:
 363   case Decl::VarTemplateSpecialization:
 364   case Decl::VarTemplatePartialSpecialization:
 365   case Decl::Function:
 366   case Decl::CXXDeductionGuide:
 367   case Decl::CXXMethod:
 368   case Decl::CXXConstructor:
 369   case Decl::CXXDestructor:
 370   case Decl::CXXConversion:
 371   case Decl::UsingShadow:
 372   case Decl::ConstructorUsingShadow:
 373   case Decl::Var:
 374   case Decl::FunctionTemplate:
 375   case Decl::ClassTemplate:
 376   case Decl::VarTemplate:
 377   case Decl::TypeAliasTemplate:
 378   case Decl::ObjCProtocol:
 379   case Decl::ObjCInterface:
 380   case Decl::Empty:
 381     return true;
 382
 383   // Never redeclarable.
 384   case Decl::UsingDirective:
 385   case Decl::Label:
 386   case Decl::UnresolvedUsingTypename:
 387   case Decl::TemplateTypeParm:
 388   case Decl::EnumConstant:
 389   case Decl::UnresolvedUsingValue:
 390   case Decl::IndirectField:
 391   case Decl::Field:
 392   case Decl::MSProperty:
 393   case Decl::MSGuid:
 394   case Decl::UnnamedGlobalConstant:
 395   case Decl::TemplateParamObject:
 396   case Decl::ObjCIvar:
 397   case Decl::ObjCAtDefsField:
 398   case Decl::NonTypeTemplateParm:
 399   case Decl::TemplateTemplateParm:
 400   case Decl::Using:
 401   case Decl::UsingEnum:
 402   case Decl::UsingPack:
 403   case Decl::ObjCMethod:
 404   case Decl::ObjCCategory:
 405   case Decl::ObjCCategoryImpl:
 406   case Decl::ObjCImplementation:
 407   case Decl::ObjCProperty:
 408   case Decl::ObjCCompatibleAlias:
 409   case Decl::LinkageSpec:
 410   case Decl::Export:
 411   case Decl::ObjCPropertyImpl:
 412   case Decl::PragmaComment:
 413   case Decl::PragmaDetectMismatch:
 414   case Decl::FileScopeAsm:
 415   case Decl::AccessSpec:
 416   case Decl::Friend:
 417   case Decl::FriendTemplate:
 418   case Decl::StaticAssert:
 419   case Decl::Block:
 420   case Decl::Captured:
 421   case Decl::ClassScopeFunctionSpecialization:
 422   case Decl::Import:
 423   case Decl::OMPThreadPrivate:
 424   case Decl::OMPAllocate:
 425   case Decl::OMPRequires:
 426   case Decl::OMPCapturedExpr:
 427   case Decl::OMPDeclareReduction:
 428   case Decl::OMPDeclareMapper:
 429   case Decl::BuiltinTemplate:
 430   case Decl::Decomposition:
 431   case Decl::Binding:
 432   case Decl::Concept:
 433   case Decl::LifetimeExtendedTemporary:
 434   case Decl::RequiresExprBody:
 435   case Decl::UnresolvedUsingIfExists:
 436     return false;
 437
 438   // These indirectly derive from Redeclarable<T> but are not actually
 439   // redeclarable.
 440   case Decl::ImplicitParam:
 441   case Decl::ParmVar:
 442   case Decl::ObjCTypeParam:
 443     return false;
 444   }
 445
 446   llvm_unreachable("Unhandled declaration kind");
 447 }
 448
 449 bool serialization::needsAnonymousDeclarationNumber(const NamedDecl *D) {
 450   // Friend declarations in dependent contexts aren't anonymous in the usual
 451   // sense, but they cannot be found by name lookup in their semantic context
 452   // (or indeed in any context), so we treat them as anonymous.
 453   //
 454   // This doesn't apply to friend tag decls; Sema makes those available to name
 455   // lookup in the surrounding context.
 456   if (D->getFriendObjectKind() &&
 457       D->getLexicalDeclContext()->isDependentContext() && !isa<TagDecl>(D)) {
 458     // For function templates and class templates, the template is numbered and
 459     // not its pattern.
 460     if (auto *FD = dyn_cast<FunctionDecl>(D))
 461       return !FD->getDescribedFunctionTemplate();
 462     if (auto *RD = dyn_cast<CXXRecordDecl>(D))
 463       return !RD->getDescribedClassTemplate();
 464     return true;
 465   }
 466
 467   // At block scope, we number everything that we need to deduplicate, since we
 468   // can't just use name matching to keep things lined up.
 469   // FIXME: This is only necessary for an inline function or a template or
 470   // similar.
 471   if (D->getLexicalDeclContext()->isFunctionOrMethod()) {
 472     if (auto *VD = dyn_cast<VarDecl>(D))
 473       return VD->isStaticLocal();
 474     // FIXME: What about CapturedDecls (and declarations nested within them)?
 475     return isa<TagDecl>(D) || isa<BlockDecl>(D);
 476   }
 477
 478   // Otherwise, we only care about anonymous class members / block-scope decls.
 479   // FIXME: We need to handle lambdas and blocks within inline / templated
 480   // variables too.
 481   if (D->getDeclName())
 482     return false;
 483   if (!isa<RecordDecl, ObjCInterfaceDecl>(D->getLexicalDeclContext()))
 484     return false;
 485   return isa<TagDecl>(D) || isa<FieldDecl>(D);
 486 }