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::NullPtr:
172     ID = PREDEF_TYPE_NULLPTR_ID;
173     break;
174   case BuiltinType::Char8:
175     ID = PREDEF_TYPE_CHAR8_ID;
176     break;
177   case BuiltinType::Char16:
178     ID = PREDEF_TYPE_CHAR16_ID;
179     break;
180   case BuiltinType::Char32:
181     ID = PREDEF_TYPE_CHAR32_ID;
182     break;
183   case BuiltinType::Overload:
184     ID = PREDEF_TYPE_OVERLOAD_ID;
185     break;
186   case BuiltinType::BoundMember:
187     ID = PREDEF_TYPE_BOUND_MEMBER;
188     break;
189   case BuiltinType::PseudoObject:
190     ID = PREDEF_TYPE_PSEUDO_OBJECT;
191     break;
192   case BuiltinType::Dependent:
193     ID = PREDEF_TYPE_DEPENDENT_ID;
194     break;
195   case BuiltinType::UnknownAny:
196     ID = PREDEF_TYPE_UNKNOWN_ANY;
197     break;
198   case BuiltinType::ARCUnbridgedCast:
199     ID = PREDEF_TYPE_ARC_UNBRIDGED_CAST;
200     break;
201   case BuiltinType::ObjCId:
202     ID = PREDEF_TYPE_OBJC_ID;
203     break;
204   case BuiltinType::ObjCClass:
205     ID = PREDEF_TYPE_OBJC_CLASS;
206     break;
207   case BuiltinType::ObjCSel:
208     ID = PREDEF_TYPE_OBJC_SEL;
209     break;
210 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
211   case BuiltinType::Id: \
212     ID = PREDEF_TYPE_##Id##_ID; \
213     break;
214 #include "clang/Basic/OpenCLImageTypes.def"
215 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
216   case BuiltinType::Id: \
217     ID = PREDEF_TYPE_##Id##_ID; \
218     break;
219 #include "clang/Basic/OpenCLExtensionTypes.def"
220   case BuiltinType::OCLSampler:
221     ID = PREDEF_TYPE_SAMPLER_ID;
222     break;
223   case BuiltinType::OCLEvent:
224     ID = PREDEF_TYPE_EVENT_ID;
225     break;
226   case BuiltinType::OCLClkEvent:
227     ID = PREDEF_TYPE_CLK_EVENT_ID;
228     break;
229   case BuiltinType::OCLQueue:
230     ID = PREDEF_TYPE_QUEUE_ID;
231     break;
232   case BuiltinType::OCLReserveID:
233     ID = PREDEF_TYPE_RESERVE_ID_ID;
234     break;
235 #define SVE_TYPE(Name, Id, SingletonId) \
236   case BuiltinType::Id: \
237     ID = PREDEF_TYPE_##Id##_ID; \
238     break;
239 #include "clang/Basic/AArch64SVEACLETypes.def"
240   case BuiltinType::BuiltinFn:
241     ID = PREDEF_TYPE_BUILTIN_FN;
242     break;
243   case BuiltinType::OMPArraySection:
244     ID = PREDEF_TYPE_OMP_ARRAY_SECTION;
245     break;
246   }
247 
248   return TypeIdx(ID);
249 }
250 
251 unsigned serialization::ComputeHash(Selector Sel) {
252   unsigned N = Sel.getNumArgs();
253   if (N == 0)
254     ++N;
255   unsigned R = 5381;
256   for (unsigned I = 0; I != N; ++I)
257     if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(I))
258       R = llvm::djbHash(II->getName(), R);
259   return R;
260 }
261 
262 const DeclContext *
263 serialization::getDefinitiveDeclContext(const DeclContext *DC) {
264   switch (DC->getDeclKind()) {
265   // These entities may have multiple definitions.
266   case Decl::TranslationUnit:
267   case Decl::ExternCContext:
268   case Decl::Namespace:
269   case Decl::LinkageSpec:
270   case Decl::Export:
271     return nullptr;
272 
273   // C/C++ tag types can only be defined in one place.
274   case Decl::Enum:
275   case Decl::Record:
276     if (const TagDecl *Def = cast<TagDecl>(DC)->getDefinition())
277       return Def;
278     return nullptr;
279 
280   // FIXME: These can be defined in one place... except special member
281   // functions and out-of-line definitions.
282   case Decl::CXXRecord:
283   case Decl::ClassTemplateSpecialization:
284   case Decl::ClassTemplatePartialSpecialization:
285     return nullptr;
286 
287   // Each function, method, and block declaration is its own DeclContext.
288   case Decl::Function:
289   case Decl::CXXMethod:
290   case Decl::CXXConstructor:
291   case Decl::CXXDestructor:
292   case Decl::CXXConversion:
293   case Decl::ObjCMethod:
294   case Decl::Block:
295   case Decl::Captured:
296     // Objective C categories, category implementations, and class
297     // implementations can only be defined in one place.
298   case Decl::ObjCCategory:
299   case Decl::ObjCCategoryImpl:
300   case Decl::ObjCImplementation:
301     return DC;
302 
303   case Decl::ObjCProtocol:
304     if (const ObjCProtocolDecl *Def
305           = cast<ObjCProtocolDecl>(DC)->getDefinition())
306       return Def;
307     return nullptr;
308 
309   // FIXME: These are defined in one place, but properties in class extensions
310   // end up being back-patched into the main interface. See
311   // Sema::HandlePropertyInClassExtension for the offending code.
312   case Decl::ObjCInterface:
313     return nullptr;
314 
315   default:
316     llvm_unreachable("Unhandled DeclContext in AST reader");
317   }
318 
319   llvm_unreachable("Unhandled decl kind");
320 }
321 
322 bool serialization::isRedeclarableDeclKind(unsigned Kind) {
323   switch (static_cast<Decl::Kind>(Kind)) {
324   case Decl::TranslationUnit:
325   case Decl::ExternCContext:
326     // Special case of a "merged" declaration.
327     return true;
328 
329   case Decl::Namespace:
330   case Decl::NamespaceAlias:
331   case Decl::Typedef:
332   case Decl::TypeAlias:
333   case Decl::Enum:
334   case Decl::Record:
335   case Decl::CXXRecord:
336   case Decl::ClassTemplateSpecialization:
337   case Decl::ClassTemplatePartialSpecialization:
338   case Decl::VarTemplateSpecialization:
339   case Decl::VarTemplatePartialSpecialization:
340   case Decl::Function:
341   case Decl::CXXDeductionGuide:
342   case Decl::CXXMethod:
343   case Decl::CXXConstructor:
344   case Decl::CXXDestructor:
345   case Decl::CXXConversion:
346   case Decl::UsingShadow:
347   case Decl::ConstructorUsingShadow:
348   case Decl::Var:
349   case Decl::FunctionTemplate:
350   case Decl::ClassTemplate:
351   case Decl::VarTemplate:
352   case Decl::TypeAliasTemplate:
353   case Decl::ObjCProtocol:
354   case Decl::ObjCInterface:
355   case Decl::Empty:
356     return true;
357 
358   // Never redeclarable.
359   case Decl::UsingDirective:
360   case Decl::Label:
361   case Decl::UnresolvedUsingTypename:
362   case Decl::TemplateTypeParm:
363   case Decl::EnumConstant:
364   case Decl::UnresolvedUsingValue:
365   case Decl::IndirectField:
366   case Decl::Field:
367   case Decl::MSProperty:
368   case Decl::ObjCIvar:
369   case Decl::ObjCAtDefsField:
370   case Decl::NonTypeTemplateParm:
371   case Decl::TemplateTemplateParm:
372   case Decl::Using:
373   case Decl::UsingPack:
374   case Decl::ObjCMethod:
375   case Decl::ObjCCategory:
376   case Decl::ObjCCategoryImpl:
377   case Decl::ObjCImplementation:
378   case Decl::ObjCProperty:
379   case Decl::ObjCCompatibleAlias:
380   case Decl::LinkageSpec:
381   case Decl::Export:
382   case Decl::ObjCPropertyImpl:
383   case Decl::PragmaComment:
384   case Decl::PragmaDetectMismatch:
385   case Decl::FileScopeAsm:
386   case Decl::AccessSpec:
387   case Decl::Friend:
388   case Decl::FriendTemplate:
389   case Decl::StaticAssert:
390   case Decl::Block:
391   case Decl::Captured:
392   case Decl::ClassScopeFunctionSpecialization:
393   case Decl::Import:
394   case Decl::OMPThreadPrivate:
395   case Decl::OMPAllocate:
396   case Decl::OMPRequires:
397   case Decl::OMPCapturedExpr:
398   case Decl::OMPDeclareReduction:
399   case Decl::OMPDeclareMapper:
400   case Decl::BuiltinTemplate:
401   case Decl::Decomposition:
402   case Decl::Binding:
403   case Decl::Concept:
404   case Decl::LifetimeExtendedTemporary:
405   case Decl::RequiresExprBody:
406     return false;
407 
408   // These indirectly derive from Redeclarable<T> but are not actually
409   // redeclarable.
410   case Decl::ImplicitParam:
411   case Decl::ParmVar:
412   case Decl::ObjCTypeParam:
413     return false;
414   }
415 
416   llvm_unreachable("Unhandled declaration kind");
417 }
418 
419 bool serialization::needsAnonymousDeclarationNumber(const NamedDecl *D) {
420   // Friend declarations in dependent contexts aren't anonymous in the usual
421   // sense, but they cannot be found by name lookup in their semantic context
422   // (or indeed in any context), so we treat them as anonymous.
423   //
424   // This doesn't apply to friend tag decls; Sema makes those available to name
425   // lookup in the surrounding context.
426   if (D->getFriendObjectKind() &&
427       D->getLexicalDeclContext()->isDependentContext() && !isa<TagDecl>(D)) {
428     // For function templates and class templates, the template is numbered and
429     // not its pattern.
430     if (auto *FD = dyn_cast<FunctionDecl>(D))
431       return !FD->getDescribedFunctionTemplate();
432     if (auto *RD = dyn_cast<CXXRecordDecl>(D))
433       return !RD->getDescribedClassTemplate();
434     return true;
435   }
436 
437   // At block scope, we number everything that we need to deduplicate, since we
438   // can't just use name matching to keep things lined up.
439   // FIXME: This is only necessary for an inline function or a template or
440   // similar.
441   if (D->getLexicalDeclContext()->isFunctionOrMethod()) {
442     if (auto *VD = dyn_cast<VarDecl>(D))
443       return VD->isStaticLocal();
444     // FIXME: What about CapturedDecls (and declarations nested within them)?
445     return isa<TagDecl>(D) || isa<BlockDecl>(D);
446   }
447 
448   // Otherwise, we only care about anonymous class members / block-scope decls.
449   // FIXME: We need to handle lambdas and blocks within inline / templated
450   // variables too.
451   if (D->getDeclName() || !isa<CXXRecordDecl>(D->getLexicalDeclContext()))
452     return false;
453   return isa<TagDecl>(D) || isa<FieldDecl>(D);
454 }
455