clang  8.0.0svn
ODRHash.cpp
Go to the documentation of this file.
1 //===-- ODRHash.cpp - Hashing to diagnose ODR failures ----------*- 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 /// \file
11 /// This file implements the ODRHash class, which calculates a hash based
12 /// on AST nodes, which is stable across different runs.
13 ///
14 //===----------------------------------------------------------------------===//
15 
16 #include "clang/AST/ODRHash.h"
17 
18 #include "clang/AST/DeclVisitor.h"
20 #include "clang/AST/StmtVisitor.h"
21 #include "clang/AST/TypeVisitor.h"
22 
23 using namespace clang;
24 
25 void ODRHash::AddStmt(const Stmt *S) {
26  assert(S && "Expecting non-null pointer.");
27  S->ProcessODRHash(ID, *this);
28 }
29 
31  assert(II && "Expecting non-null pointer.");
32  ID.AddString(II->getName());
33 }
34 
35 void ODRHash::AddDeclarationName(DeclarationName Name, bool TreatAsDecl) {
36  if (TreatAsDecl)
37  // Matches the NamedDecl check in AddDecl
38  AddBoolean(true);
39 
40  AddDeclarationNameImpl(Name);
41 
42  if (TreatAsDecl)
43  // Matches the ClassTemplateSpecializationDecl check in AddDecl
44  AddBoolean(false);
45 }
46 
47 void ODRHash::AddDeclarationNameImpl(DeclarationName Name) {
48  // Index all DeclarationName and use index numbers to refer to them.
49  auto Result = DeclNameMap.insert(std::make_pair(Name, DeclNameMap.size()));
50  ID.AddInteger(Result.first->second);
51  if (!Result.second) {
52  // If found in map, the the DeclarationName has previously been processed.
53  return;
54  }
55 
56  // First time processing each DeclarationName, also process its details.
57  AddBoolean(Name.isEmpty());
58  if (Name.isEmpty())
59  return;
60 
61  auto Kind = Name.getNameKind();
62  ID.AddInteger(Kind);
63  switch (Kind) {
66  break;
70  Selector S = Name.getObjCSelector();
71  AddBoolean(S.isNull());
74  unsigned NumArgs = S.getNumArgs();
75  for (unsigned i = 0; i < NumArgs; ++i) {
77  }
78  break;
79  }
83  break;
85  ID.AddInteger(Name.getCXXOverloadedOperator());
86  break;
89  break;
92  break;
94  break;
96  auto *Template = Name.getCXXDeductionGuideTemplate();
97  AddBoolean(Template);
98  if (Template) {
99  AddDecl(Template);
100  }
101  }
102  }
103 }
104 
106  assert(NNS && "Expecting non-null pointer.");
107  const auto *Prefix = NNS->getPrefix();
108  AddBoolean(Prefix);
109  if (Prefix) {
110  AddNestedNameSpecifier(Prefix);
111  }
112  auto Kind = NNS->getKind();
113  ID.AddInteger(Kind);
114  switch (Kind) {
117  break;
119  AddDecl(NNS->getAsNamespace());
120  break;
123  break;
126  AddType(NNS->getAsType());
127  break;
130  break;
131  }
132 }
133 
135  auto Kind = Name.getKind();
136  ID.AddInteger(Kind);
137 
138  switch (Kind) {
140  AddDecl(Name.getAsTemplateDecl());
141  break;
142  // TODO: Support these cases.
148  break;
149  }
150 }
151 
153  const auto Kind = TA.getKind();
154  ID.AddInteger(Kind);
155 
156  switch (Kind) {
158  llvm_unreachable("Expected valid TemplateArgument");
160  AddQualType(TA.getAsType());
161  break;
163  AddDecl(TA.getAsDecl());
164  break;
167  break;
171  break;
173  AddStmt(TA.getAsExpr());
174  break;
176  ID.AddInteger(TA.pack_size());
177  for (auto SubTA : TA.pack_elements()) {
178  AddTemplateArgument(SubTA);
179  }
180  break;
181  }
182 }
183 
185  assert(TPL && "Expecting non-null pointer.");
186 
187  ID.AddInteger(TPL->size());
188  for (auto *ND : TPL->asArray()) {
189  AddSubDecl(ND);
190  }
191 }
192 
194  DeclNameMap.clear();
195  Bools.clear();
196  ID.clear();
197 }
198 
200  // Append the bools to the end of the data segment backwards. This allows
201  // for the bools data to be compressed 32 times smaller compared to using
202  // ID.AddBoolean
203  const unsigned unsigned_bits = sizeof(unsigned) * CHAR_BIT;
204  const unsigned size = Bools.size();
205  const unsigned remainder = size % unsigned_bits;
206  const unsigned loops = size / unsigned_bits;
207  auto I = Bools.rbegin();
208  unsigned value = 0;
209  for (unsigned i = 0; i < remainder; ++i) {
210  value <<= 1;
211  value |= *I;
212  ++I;
213  }
214  ID.AddInteger(value);
215 
216  for (unsigned i = 0; i < loops; ++i) {
217  value = 0;
218  for (unsigned j = 0; j < unsigned_bits; ++j) {
219  value <<= 1;
220  value |= *I;
221  ++I;
222  }
223  ID.AddInteger(value);
224  }
225 
226  assert(I == Bools.rend());
227  Bools.clear();
228  return ID.ComputeHash();
229 }
230 
231 namespace {
232 // Process a Decl pointer. Add* methods call back into ODRHash while Visit*
233 // methods process the relevant parts of the Decl.
234 class ODRDeclVisitor : public ConstDeclVisitor<ODRDeclVisitor> {
235  typedef ConstDeclVisitor<ODRDeclVisitor> Inherited;
236  llvm::FoldingSetNodeID &ID;
237  ODRHash &Hash;
238 
239 public:
240  ODRDeclVisitor(llvm::FoldingSetNodeID &ID, ODRHash &Hash)
241  : ID(ID), Hash(Hash) {}
242 
243  void AddStmt(const Stmt *S) {
244  Hash.AddBoolean(S);
245  if (S) {
246  Hash.AddStmt(S);
247  }
248  }
249 
250  void AddIdentifierInfo(const IdentifierInfo *II) {
251  Hash.AddBoolean(II);
252  if (II) {
253  Hash.AddIdentifierInfo(II);
254  }
255  }
256 
257  void AddQualType(QualType T) {
258  Hash.AddQualType(T);
259  }
260 
261  void AddDecl(const Decl *D) {
262  Hash.AddBoolean(D);
263  if (D) {
264  Hash.AddDecl(D);
265  }
266  }
267 
269  Hash.AddTemplateArgument(TA);
270  }
271 
272  void Visit(const Decl *D) {
273  ID.AddInteger(D->getKind());
274  Inherited::Visit(D);
275  }
276 
277  void VisitNamedDecl(const NamedDecl *D) {
278  Hash.AddDeclarationName(D->getDeclName());
279  Inherited::VisitNamedDecl(D);
280  }
281 
282  void VisitValueDecl(const ValueDecl *D) {
283  if (!isa<FunctionDecl>(D)) {
284  AddQualType(D->getType());
285  }
286  Inherited::VisitValueDecl(D);
287  }
288 
289  void VisitVarDecl(const VarDecl *D) {
290  Hash.AddBoolean(D->isStaticLocal());
291  Hash.AddBoolean(D->isConstexpr());
292  const bool HasInit = D->hasInit();
293  Hash.AddBoolean(HasInit);
294  if (HasInit) {
295  AddStmt(D->getInit());
296  }
297  Inherited::VisitVarDecl(D);
298  }
299 
300  void VisitParmVarDecl(const ParmVarDecl *D) {
301  // TODO: Handle default arguments.
302  Inherited::VisitParmVarDecl(D);
303  }
304 
305  void VisitAccessSpecDecl(const AccessSpecDecl *D) {
306  ID.AddInteger(D->getAccess());
307  Inherited::VisitAccessSpecDecl(D);
308  }
309 
310  void VisitStaticAssertDecl(const StaticAssertDecl *D) {
311  AddStmt(D->getAssertExpr());
312  AddStmt(D->getMessage());
313 
314  Inherited::VisitStaticAssertDecl(D);
315  }
316 
317  void VisitFieldDecl(const FieldDecl *D) {
318  const bool IsBitfield = D->isBitField();
319  Hash.AddBoolean(IsBitfield);
320 
321  if (IsBitfield) {
322  AddStmt(D->getBitWidth());
323  }
324 
325  Hash.AddBoolean(D->isMutable());
327 
328  Inherited::VisitFieldDecl(D);
329  }
330 
331  void VisitFunctionDecl(const FunctionDecl *D) {
332  // Handled by the ODRHash for FunctionDecl
333  ID.AddInteger(D->getODRHash());
334 
335  Inherited::VisitFunctionDecl(D);
336  }
337 
338  void VisitCXXMethodDecl(const CXXMethodDecl *D) {
339  // Handled by the ODRHash for FunctionDecl
340 
341  Inherited::VisitCXXMethodDecl(D);
342  }
343 
344  void VisitTypedefNameDecl(const TypedefNameDecl *D) {
346 
347  Inherited::VisitTypedefNameDecl(D);
348  }
349 
350  void VisitTypedefDecl(const TypedefDecl *D) {
351  Inherited::VisitTypedefDecl(D);
352  }
353 
354  void VisitTypeAliasDecl(const TypeAliasDecl *D) {
355  Inherited::VisitTypeAliasDecl(D);
356  }
357 
358  void VisitFriendDecl(const FriendDecl *D) {
359  TypeSourceInfo *TSI = D->getFriendType();
360  Hash.AddBoolean(TSI);
361  if (TSI) {
362  AddQualType(TSI->getType());
363  } else {
364  AddDecl(D->getFriendDecl());
365  }
366  }
367 
368  void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
369  // Only care about default arguments as part of the definition.
370  const bool hasDefaultArgument =
372  Hash.AddBoolean(hasDefaultArgument);
373  if (hasDefaultArgument) {
375  }
376  Hash.AddBoolean(D->isParameterPack());
377 
378  Inherited::VisitTemplateTypeParmDecl(D);
379  }
380 
381  void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
382  // Only care about default arguments as part of the definition.
383  const bool hasDefaultArgument =
385  Hash.AddBoolean(hasDefaultArgument);
386  if (hasDefaultArgument) {
388  }
389  Hash.AddBoolean(D->isParameterPack());
390 
391  Inherited::VisitNonTypeTemplateParmDecl(D);
392  }
393 
394  void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) {
395  // Only care about default arguments as part of the definition.
396  const bool hasDefaultArgument =
398  Hash.AddBoolean(hasDefaultArgument);
399  if (hasDefaultArgument) {
401  }
402  Hash.AddBoolean(D->isParameterPack());
403 
404  Inherited::VisitTemplateTemplateParmDecl(D);
405  }
406 
407  void VisitTemplateDecl(const TemplateDecl *D) {
409 
410  Inherited::VisitTemplateDecl(D);
411  }
412 
413  void VisitRedeclarableTemplateDecl(const RedeclarableTemplateDecl *D) {
415  Inherited::VisitRedeclarableTemplateDecl(D);
416  }
417 
418  void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
420  ID.AddInteger(D->getTemplatedDecl()->getODRHash());
421  Inherited::VisitFunctionTemplateDecl(D);
422  }
423 
424  void VisitEnumConstantDecl(const EnumConstantDecl *D) {
425  AddStmt(D->getInitExpr());
426  Inherited::VisitEnumConstantDecl(D);
427  }
428 };
429 } // namespace
430 
431 // Only allow a small portion of Decl's to be processed. Remove this once
432 // all Decl's can be handled.
434  if (D->isImplicit()) return false;
435  if (D->getDeclContext() != Parent) return false;
436 
437  switch (D->getKind()) {
438  default:
439  return false;
440  case Decl::AccessSpec:
441  case Decl::CXXConstructor:
442  case Decl::CXXDestructor:
443  case Decl::CXXMethod:
444  case Decl::EnumConstant: // Only found in EnumDecl's.
445  case Decl::Field:
446  case Decl::Friend:
447  case Decl::FunctionTemplate:
448  case Decl::StaticAssert:
449  case Decl::TypeAlias:
450  case Decl::Typedef:
451  case Decl::Var:
452  return true;
453  }
454 }
455 
456 void ODRHash::AddSubDecl(const Decl *D) {
457  assert(D && "Expecting non-null pointer.");
458 
459  ODRDeclVisitor(ID, *this).Visit(D);
460 }
461 
463  assert(Record && Record->hasDefinition() &&
464  "Expected non-null record to be a definition.");
465 
466  const DeclContext *DC = Record;
467  while (DC) {
468  if (isa<ClassTemplateSpecializationDecl>(DC)) {
469  return;
470  }
471  DC = DC->getParent();
472  }
473 
474  AddDecl(Record);
475 
476  // Filter out sub-Decls which will not be processed in order to get an
477  // accurate count of Decl's.
479  for (Decl *SubDecl : Record->decls()) {
480  if (isWhitelistedDecl(SubDecl, Record)) {
481  Decls.push_back(SubDecl);
482  if (auto *Function = dyn_cast<FunctionDecl>(SubDecl)) {
483  // Compute/Preload ODRHash into FunctionDecl.
484  Function->getODRHash();
485  }
486  }
487  }
488 
489  ID.AddInteger(Decls.size());
490  for (auto SubDecl : Decls) {
491  AddSubDecl(SubDecl);
492  }
493 
494  const ClassTemplateDecl *TD = Record->getDescribedClassTemplate();
495  AddBoolean(TD);
496  if (TD) {
498  }
499 
500  ID.AddInteger(Record->getNumBases());
501  auto Bases = Record->bases();
502  for (auto Base : Bases) {
503  AddQualType(Base.getType());
504  ID.AddInteger(Base.isVirtual());
505  ID.AddInteger(Base.getAccessSpecifierAsWritten());
506  }
507 }
508 
510  bool SkipBody) {
511  assert(Function && "Expecting non-null pointer.");
512 
513  // Skip functions that are specializations or in specialization context.
514  const DeclContext *DC = Function;
515  while (DC) {
516  if (isa<ClassTemplateSpecializationDecl>(DC)) return;
517  if (auto *F = dyn_cast<FunctionDecl>(DC)) {
518  if (F->isFunctionTemplateSpecialization()) {
519  if (!isa<CXXMethodDecl>(DC)) return;
520  if (DC->getLexicalParent()->isFileContext()) return;
521  // Inline method specializations are the only supported
522  // specialization for now.
523  }
524  }
525  DC = DC->getParent();
526  }
527 
528  ID.AddInteger(Function->getDeclKind());
529 
530  const auto *SpecializationArgs = Function->getTemplateSpecializationArgs();
531  AddBoolean(SpecializationArgs);
532  if (SpecializationArgs) {
533  ID.AddInteger(SpecializationArgs->size());
534  for (const TemplateArgument &TA : SpecializationArgs->asArray()) {
536  }
537  }
538 
539  if (const auto *Method = dyn_cast<CXXMethodDecl>(Function)) {
540  AddBoolean(Method->isConst());
541  AddBoolean(Method->isVolatile());
542  }
543 
544  ID.AddInteger(Function->getStorageClass());
545  AddBoolean(Function->isInlineSpecified());
546  AddBoolean(Function->isVirtualAsWritten());
547  AddBoolean(Function->isPure());
548  AddBoolean(Function->isDeletedAsWritten());
549  AddBoolean(Function->isExplicitlyDefaulted());
550 
551  AddDecl(Function);
552 
553  AddQualType(Function->getReturnType());
554 
555  ID.AddInteger(Function->param_size());
556  for (auto Param : Function->parameters())
557  AddSubDecl(Param);
558 
559  if (SkipBody) {
560  AddBoolean(false);
561  return;
562  }
563 
564  const bool HasBody = Function->isThisDeclarationADefinition() &&
565  !Function->isDefaulted() && !Function->isDeleted() &&
566  !Function->isLateTemplateParsed();
567  AddBoolean(HasBody);
568  if (!HasBody) {
569  return;
570  }
571 
572  auto *Body = Function->getBody();
573  AddBoolean(Body);
574  if (Body)
575  AddStmt(Body);
576 
577  // Filter out sub-Decls which will not be processed in order to get an
578  // accurate count of Decl's.
580  for (Decl *SubDecl : Function->decls()) {
581  if (isWhitelistedDecl(SubDecl, Function)) {
582  Decls.push_back(SubDecl);
583  }
584  }
585 
586  ID.AddInteger(Decls.size());
587  for (auto SubDecl : Decls) {
588  AddSubDecl(SubDecl);
589  }
590 }
591 
592 void ODRHash::AddEnumDecl(const EnumDecl *Enum) {
593  assert(Enum);
595 
596  AddBoolean(Enum->isScoped());
597  if (Enum->isScoped())
599 
600  if (Enum->getIntegerTypeSourceInfo())
601  AddQualType(Enum->getIntegerType());
602 
603  // Filter out sub-Decls which will not be processed in order to get an
604  // accurate count of Decl's.
606  for (Decl *SubDecl : Enum->decls()) {
607  if (isWhitelistedDecl(SubDecl, Enum)) {
608  assert(isa<EnumConstantDecl>(SubDecl) && "Unexpected Decl");
609  Decls.push_back(SubDecl);
610  }
611  }
612 
613  ID.AddInteger(Decls.size());
614  for (auto SubDecl : Decls) {
615  AddSubDecl(SubDecl);
616  }
617 
618 }
619 
620 void ODRHash::AddDecl(const Decl *D) {
621  assert(D && "Expecting non-null pointer.");
622  D = D->getCanonicalDecl();
623 
624  const NamedDecl *ND = dyn_cast<NamedDecl>(D);
625  AddBoolean(ND);
626  if (!ND) {
627  ID.AddInteger(D->getKind());
628  return;
629  }
630 
632 
633  const auto *Specialization =
634  dyn_cast<ClassTemplateSpecializationDecl>(D);
635  AddBoolean(Specialization);
636  if (Specialization) {
637  const TemplateArgumentList &List = Specialization->getTemplateArgs();
638  ID.AddInteger(List.size());
639  for (const TemplateArgument &TA : List.asArray())
641  }
642 }
643 
644 namespace {
645 // Process a Type pointer. Add* methods call back into ODRHash while Visit*
646 // methods process the relevant parts of the Type.
647 class ODRTypeVisitor : public TypeVisitor<ODRTypeVisitor> {
648  typedef TypeVisitor<ODRTypeVisitor> Inherited;
649  llvm::FoldingSetNodeID &ID;
650  ODRHash &Hash;
651 
652 public:
653  ODRTypeVisitor(llvm::FoldingSetNodeID &ID, ODRHash &Hash)
654  : ID(ID), Hash(Hash) {}
655 
656  void AddStmt(Stmt *S) {
657  Hash.AddBoolean(S);
658  if (S) {
659  Hash.AddStmt(S);
660  }
661  }
662 
663  void AddDecl(Decl *D) {
664  Hash.AddBoolean(D);
665  if (D) {
666  Hash.AddDecl(D);
667  }
668  }
669 
670  void AddQualType(QualType T) {
671  Hash.AddQualType(T);
672  }
673 
674  void AddType(const Type *T) {
675  Hash.AddBoolean(T);
676  if (T) {
677  Hash.AddType(T);
678  }
679  }
680 
682  Hash.AddBoolean(NNS);
683  if (NNS) {
684  Hash.AddNestedNameSpecifier(NNS);
685  }
686  }
687 
688  void AddIdentifierInfo(const IdentifierInfo *II) {
689  Hash.AddBoolean(II);
690  if (II) {
691  Hash.AddIdentifierInfo(II);
692  }
693  }
694 
695  void VisitQualifiers(Qualifiers Quals) {
696  ID.AddInteger(Quals.getAsOpaqueValue());
697  }
698 
699  void Visit(const Type *T) {
700  ID.AddInteger(T->getTypeClass());
701  Inherited::Visit(T);
702  }
703 
704  void VisitType(const Type *T) {}
705 
706  void VisitAdjustedType(const AdjustedType *T) {
709  VisitType(T);
710  }
711 
712  void VisitDecayedType(const DecayedType *T) {
715  VisitAdjustedType(T);
716  }
717 
718  void VisitArrayType(const ArrayType *T) {
720  ID.AddInteger(T->getSizeModifier());
721  VisitQualifiers(T->getIndexTypeQualifiers());
722  VisitType(T);
723  }
724  void VisitConstantArrayType(const ConstantArrayType *T) {
725  T->getSize().Profile(ID);
726  VisitArrayType(T);
727  }
728 
729  void VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
730  AddStmt(T->getSizeExpr());
731  VisitArrayType(T);
732  }
733 
734  void VisitIncompleteArrayType(const IncompleteArrayType *T) {
735  VisitArrayType(T);
736  }
737 
738  void VisitVariableArrayType(const VariableArrayType *T) {
739  AddStmt(T->getSizeExpr());
740  VisitArrayType(T);
741  }
742 
743  void VisitAttributedType(const AttributedType *T) {
744  ID.AddInteger(T->getAttrKind());
747 
748  VisitType(T);
749  }
750 
751  void VisitBlockPointerType(const BlockPointerType *T) {
753  VisitType(T);
754  }
755 
756  void VisitBuiltinType(const BuiltinType *T) {
757  ID.AddInteger(T->getKind());
758  VisitType(T);
759  }
760 
761  void VisitComplexType(const ComplexType *T) {
763  VisitType(T);
764  }
765 
766  void VisitDecltypeType(const DecltypeType *T) {
769  VisitType(T);
770  }
771 
772  void VisitDependentDecltypeType(const DependentDecltypeType *T) {
773  VisitDecltypeType(T);
774  }
775 
776  void VisitDeducedType(const DeducedType *T) {
778  VisitType(T);
779  }
780 
781  void VisitAutoType(const AutoType *T) {
782  ID.AddInteger((unsigned)T->getKeyword());
783  VisitDeducedType(T);
784  }
785 
786  void VisitDeducedTemplateSpecializationType(
788  Hash.AddTemplateName(T->getTemplateName());
789  VisitDeducedType(T);
790  }
791 
792  void VisitDependentAddressSpaceType(const DependentAddressSpaceType *T) {
795  VisitType(T);
796  }
797 
798  void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T) {
800  AddStmt(T->getSizeExpr());
801  VisitType(T);
802  }
803 
804  void VisitFunctionType(const FunctionType *T) {
806  T->getExtInfo().Profile(ID);
807  Hash.AddBoolean(T->isConst());
808  Hash.AddBoolean(T->isVolatile());
809  Hash.AddBoolean(T->isRestrict());
810  VisitType(T);
811  }
812 
813  void VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
814  VisitFunctionType(T);
815  }
816 
817  void VisitFunctionProtoType(const FunctionProtoType *T) {
818  ID.AddInteger(T->getNumParams());
819  for (auto ParamType : T->getParamTypes())
820  AddQualType(ParamType);
821 
822  VisitFunctionType(T);
823  }
824 
825  void VisitInjectedClassNameType(const InjectedClassNameType *T) {
826  AddDecl(T->getDecl());
827  VisitType(T);
828  }
829 
830  void VisitMemberPointerType(const MemberPointerType *T) {
832  AddType(T->getClass());
833  VisitType(T);
834  }
835 
836  void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
838  VisitType(T);
839  }
840 
841  void VisitObjCObjectType(const ObjCObjectType *T) {
842  AddDecl(T->getInterface());
843 
844  auto TypeArgs = T->getTypeArgsAsWritten();
845  ID.AddInteger(TypeArgs.size());
846  for (auto Arg : TypeArgs) {
847  AddQualType(Arg);
848  }
849 
850  auto Protocols = T->getProtocols();
851  ID.AddInteger(Protocols.size());
852  for (auto Protocol : Protocols) {
853  AddDecl(Protocol);
854  }
855 
856  Hash.AddBoolean(T->isKindOfType());
857 
858  VisitType(T);
859  }
860 
861  void VisitObjCInterfaceType(const ObjCInterfaceType *T) {
862  // This type is handled by the parent type ObjCObjectType.
863  VisitObjCObjectType(T);
864  }
865 
866  void VisitObjCTypeParamType(const ObjCTypeParamType *T) {
867  AddDecl(T->getDecl());
868  auto Protocols = T->getProtocols();
869  ID.AddInteger(Protocols.size());
870  for (auto Protocol : Protocols) {
871  AddDecl(Protocol);
872  }
873 
874  VisitType(T);
875  }
876 
877  void VisitPackExpansionType(const PackExpansionType *T) {
878  AddQualType(T->getPattern());
879  VisitType(T);
880  }
881 
882  void VisitParenType(const ParenType *T) {
884  VisitType(T);
885  }
886 
887  void VisitPipeType(const PipeType *T) {
889  Hash.AddBoolean(T->isReadOnly());
890  VisitType(T);
891  }
892 
893  void VisitPointerType(const PointerType *T) {
895  VisitType(T);
896  }
897 
898  void VisitReferenceType(const ReferenceType *T) {
900  VisitType(T);
901  }
902 
903  void VisitLValueReferenceType(const LValueReferenceType *T) {
904  VisitReferenceType(T);
905  }
906 
907  void VisitRValueReferenceType(const RValueReferenceType *T) {
908  VisitReferenceType(T);
909  }
910 
911  void
912  VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) {
915  VisitType(T);
916  }
917 
918  void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
921  VisitType(T);
922  }
923 
924  void VisitTagType(const TagType *T) {
925  AddDecl(T->getDecl());
926  VisitType(T);
927  }
928 
929  void VisitRecordType(const RecordType *T) { VisitTagType(T); }
930  void VisitEnumType(const EnumType *T) { VisitTagType(T); }
931 
932  void VisitTemplateSpecializationType(const TemplateSpecializationType *T) {
933  ID.AddInteger(T->getNumArgs());
934  for (const auto &TA : T->template_arguments()) {
935  Hash.AddTemplateArgument(TA);
936  }
937  Hash.AddTemplateName(T->getTemplateName());
938  VisitType(T);
939  }
940 
941  void VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
942  ID.AddInteger(T->getDepth());
943  ID.AddInteger(T->getIndex());
944  Hash.AddBoolean(T->isParameterPack());
945  AddDecl(T->getDecl());
946  }
947 
948  void VisitTypedefType(const TypedefType *T) {
949  AddDecl(T->getDecl());
950  QualType UnderlyingType = T->getDecl()->getUnderlyingType();
951  VisitQualifiers(UnderlyingType.getQualifiers());
952  while (true) {
953  if (const TypedefType *Underlying =
954  dyn_cast<TypedefType>(UnderlyingType.getTypePtr())) {
955  UnderlyingType = Underlying->getDecl()->getUnderlyingType();
956  continue;
957  }
958  if (const ElaboratedType *Underlying =
959  dyn_cast<ElaboratedType>(UnderlyingType.getTypePtr())) {
960  UnderlyingType = Underlying->getNamedType();
961  continue;
962  }
963 
964  break;
965  }
966  AddType(UnderlyingType.getTypePtr());
967  VisitType(T);
968  }
969 
970  void VisitTypeOfExprType(const TypeOfExprType *T) {
972  Hash.AddBoolean(T->isSugared());
973  if (T->isSugared())
974  AddQualType(T->desugar());
975 
976  VisitType(T);
977  }
978  void VisitTypeOfType(const TypeOfType *T) {
980  VisitType(T);
981  }
982 
983  void VisitTypeWithKeyword(const TypeWithKeyword *T) {
984  ID.AddInteger(T->getKeyword());
985  VisitType(T);
986  };
987 
988  void VisitDependentNameType(const DependentNameType *T) {
991  VisitTypeWithKeyword(T);
992  }
993 
994  void VisitDependentTemplateSpecializationType(
998  ID.AddInteger(T->getNumArgs());
999  for (const auto &TA : T->template_arguments()) {
1000  Hash.AddTemplateArgument(TA);
1001  }
1002  VisitTypeWithKeyword(T);
1003  }
1004 
1005  void VisitElaboratedType(const ElaboratedType *T) {
1007  AddQualType(T->getNamedType());
1008  VisitTypeWithKeyword(T);
1009  }
1010 
1011  void VisitUnaryTransformType(const UnaryTransformType *T) {
1013  AddQualType(T->getBaseType());
1014  VisitType(T);
1015  }
1016 
1017  void VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
1018  AddDecl(T->getDecl());
1019  VisitType(T);
1020  }
1021 
1022  void VisitVectorType(const VectorType *T) {
1024  ID.AddInteger(T->getNumElements());
1025  ID.AddInteger(T->getVectorKind());
1026  VisitType(T);
1027  }
1028 
1029  void VisitExtVectorType(const ExtVectorType * T) {
1030  VisitVectorType(T);
1031  }
1032 };
1033 } // namespace
1034 
1035 void ODRHash::AddType(const Type *T) {
1036  assert(T && "Expecting non-null pointer.");
1037  ODRTypeVisitor(ID, *this).Visit(T);
1038 }
1039 
1041  AddBoolean(T.isNull());
1042  if (T.isNull())
1043  return;
1044  SplitQualType split = T.split();
1045  ID.AddInteger(split.Quals.getAsOpaqueValue());
1046  AddType(split.Ty);
1047 }
1048 
1050  Bools.push_back(Value);
1051 }
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
Definition: Type.h:5257
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it&#39;s either not been deduced or was deduce...
Definition: Type.h:4618
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Definition: Type.h:5010
const Type * Ty
The locally-unqualified type.
Definition: Type.h:583
Represents a function declaration or definition.
Definition: Decl.h:1717
Smart pointer class that efficiently represents Objective-C method names.
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2511
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments of this object type as they were written.
Definition: Type.h:5530
QualType getElementType() const
Definition: Type.h:5897
QualType getPointeeType() const
Definition: Type.h:2524
Represents the dependent type named by a dependently-scoped typename using declaration, e.g.
Definition: Type.h:4004
A (possibly-)qualified type.
Definition: Type.h:642
base_class_range bases()
Definition: DeclCXX.h:823
void AddBoolean(bool value)
Definition: ODRHash.cpp:1049
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:817
void AddDeclarationName(DeclarationName Name, bool TreatAsDecl=false)
Definition: ODRHash.cpp:35
QualType getDecayedType() const
Definition: Type.h:2603
This file contains the declaration of the ODRHash class, which calculates a hash based on AST nodes...
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: Type.h:3463
Expr * getUnderlyingExpr() const
Definition: Type.h:4139
Stmt - This represents one statement.
Definition: Stmt.h:66
Expr * getBitWidth() const
Definition: Decl.h:2645
void AddQualType(QualType T)
Definition: ODRHash.cpp:1040
Kind getKind() const
Definition: Type.h:2392
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3329
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2763
Represents the declaration of a typedef-name via the &#39;typedef&#39; type specifier.
Definition: Decl.h:2995
Microsoft&#39;s &#39;__super&#39; specifier, stored as a CXXRecordDecl* of the class it appeared in...
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:5093
The template argument is an expression, and we&#39;ve not resolved it to one of the other forms yet...
Definition: TemplateBase.h:87
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:270
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:5112
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
TagDecl * getDecl() const
Definition: Type.cpp:3137
ArrayRef< NamedDecl * > asArray()
Definition: DeclTemplate.h:126
Selector getObjCSelector() const
getObjCSelector - Get the Objective-C selector stored in this declaration name.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:4632
The base class of the type hierarchy.
Definition: Type.h:1415
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2786
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:64
A container of type source information.
Definition: Decl.h:86
bool isEmpty() const
Evaluates true when this declaration name is empty.
TemplateTypeParmDecl * getDecl() const
Definition: Type.h:4452
A template template parameter that has been substituted for some other template name.
Definition: TemplateName.h:206
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Definition: Decl.h:1979
size_t param_size() const
Definition: Decl.h:2247
QualType getElementType() const
Definition: Type.h:2821
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
TemplateName getTemplateName() const
Retrieve the name of the template that we are deducing.
Definition: Type.h:4686
An identifier, stored as an IdentifierInfo*.
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:54
Represents a variable declaration or definition.
Definition: Decl.h:812
Declaration of a redeclarable template.
Definition: DeclTemplate.h:737
ArrayRef< ObjCProtocolDecl * > getProtocols() const
Retrieve all of the protocol qualifiers.
Definition: Type.h:5338
QualType getReturnType() const
Definition: Decl.h:2271
unsigned getNumParams() const
Definition: Type.h:3786
QualType getCXXNameType() const
getCXXNameType - If this name is one of the C++ names (of a constructor, destructor, or conversion function), return the type associated with that name.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:57
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:2009
Represents a C++17 deduced template specialization type.
Definition: Type.h:4668
A namespace, stored as a NamespaceDecl*.
bool isConst() const
Definition: Type.h:3495
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
void AddTemplateArgument(TemplateArgument TA)
Definition: ODRHash.cpp:152
bool hasDefinition() const
Definition: DeclCXX.h:776
Represents a parameter to a function.
Definition: Decl.h:1536
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4486
The collection of all-type qualifiers we support.
Definition: Type.h:141
void clear()
Definition: ODRHash.cpp:193
PipeType - OpenCL20.
Definition: Type.h:5883
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
QualType getOriginalType() const
Definition: Type.h:2575
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists...
Definition: Decl.h:3473
Represents a class template specialization, which refers to a class template with a given set of temp...
One of these records is kept for each identifier that is lexed.
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
Definition: DeclFriend.h:124
StringLiteral * getMessage()
Definition: DeclCXX.h:3763
Represents a class type in Objective C.
Definition: Type.h:5419
QualType getPointeeType() const
Definition: Type.h:2628
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:330
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3793
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:72
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
Represents a member of a struct/union/class.
Definition: Decl.h:2556
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:4787
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
An operation on a type.
Definition: TypeVisitor.h:65
NamedDecl * getFriendDecl() const
If this friend declaration doesn&#39;t name a type, return the inner declaration.
Definition: DeclFriend.h:139
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:4542
void AddTemplateParameterList(const TemplateParameterList *TPL)
Definition: ODRHash.cpp:184
Represents an access specifier followed by colon &#39;:&#39;.
Definition: DeclCXX.h:132
TemplateDecl * getCXXDeductionGuideTemplate() const
If this name is the name of a C++ deduction guide, return the template associated with that name...
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2231
bool isUnarySelector() const
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2712
UnresolvedUsingTypenameDecl * getDecl() const
Definition: Type.h:4015
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2634
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
A qualified template name, where the qualification is kept to describe the source code as written...
Definition: TemplateName.h:198
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:2710
void AddDecl(const Decl *D)
Definition: ODRHash.cpp:620
void AddFunctionDecl(const FunctionDecl *Function, bool SkipBody=false)
Definition: ODRHash.cpp:509
#define CHAR_BIT
Definition: limits.h:79
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
Definition: DeclTemplate.h:879
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:4059
const Type * getClass() const
Definition: Type.h:2764
CXXRecordDecl * getDecl() const
Definition: Type.cpp:3216
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1381
#define remainder(__x, __y)
Definition: tgmath.h:1106
QualType getPointeeType() const
Definition: Type.h:6678
Expr * getSizeExpr() const
Definition: Type.h:2965
const Expr * getInitExpr() const
Definition: Decl.h:2782
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:5654
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
Expr * getSizeExpr() const
Definition: Type.h:3022
QualType getPointeeTypeAsWritten() const
Definition: Type.h:2666
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:875
QualType getElementType() const
Definition: Type.h:3118
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:3102
void AddTemplateName(TemplateName Name)
Definition: ODRHash.cpp:134
Represents a K&R-style &#39;int foo()&#39; function, which has no information available about its arguments...
Definition: Type.h:3515
Expr * getAddrSpaceExpr() const
Definition: Type.h:3073
NodeId Parent
Definition: ASTDiff.cpp:192
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3015
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3550
A dependent template name that has not been resolved to a template (or set of templates).
Definition: TemplateName.h:202
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
ObjCTypeParamDecl * getDecl() const
Definition: Type.h:5388
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:264
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:3000
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:432
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
Definition: DeclBase.h:1780
QualType getElementType() const
Definition: Type.h:2464
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2319
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:5180
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:636
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:2013
unsigned getAsOpaqueValue() const
Definition: Type.h:254
bool isScopedUsingClassTag() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3500
Declaration of a template type parameter.
unsigned getIndex() const
Definition: Type.h:4449
Internal representation of canonical, dependent decltype(expr) types.
Definition: Type.h:4157
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:68
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
Definition: Decl.h:1962
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:552
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3453
bool isFileContext() const
Definition: DeclBase.h:1830
DeclContext * getDeclContext()
Definition: DeclBase.h:426
QualType getBaseType() const
Definition: Type.h:4198
const IdentifierInfo * getIdentifier() const
Retrieve the type named by the typename specifier as an identifier.
Definition: Type.h:5119
void ProcessODRHash(llvm::FoldingSetNodeID &ID, ODRHash &Hash) const
Calculate a unique representation for a statement that is stable across compiler invocations.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2308
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:264
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
Represents the type decltype(expr) (C++11).
Definition: Type.h:4129
A namespace alias, stored as a NamespaceAliasDecl*.
IdentifierInfo * getAsIdentifierInfo() const
getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in this declaration name, or NULL if this declaration name isn&#39;t a simple identifier.
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition: Type.h:581
QualType desugar() const
Remove a single level of sugar.
Definition: Type.cpp:3067
A unary type transform, which is a type constructed from another.
Definition: Type.h:4172
Qualifiers Quals
The local qualifiers.
Definition: Type.h:586
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1764
A helper class for Type nodes having an ElaboratedTypeKeyword.
Definition: Type.h:4959
Represents a GCC generic vector type.
Definition: Type.h:3142
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2823
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2694
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
unsigned getNumArgs() const
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Definition: Type.h:4592
The result type of a method or function.
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:707
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
Expr * getUnderlyingExpr() const
Definition: Type.h:4068
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition: Type.h:5961
A template template parameter pack that has been substituted for a template template argument pack...
Definition: TemplateName.h:211
Decl::Kind getDeclKind() const
Definition: DeclBase.h:1757
IdentifierInfo * getCXXLiteralIdentifier() const
getCXXLiteralIdentifier - If this name is the name of a literal operator, retrieve the identifier ass...
Kind
ElaboratedTypeKeyword getKeyword() const
Definition: Type.h:4971
IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
bool isParameterPack() const
Returns whether this is a parameter pack.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Sugar for parentheses used when specifying types.
Definition: Type.h:2481
QualType getAdjustedType() const
Definition: Type.h:2576
QualType getReturnType() const
Definition: Type.h:3483
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:1988
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4279
Represents typeof(type), a GCC extension.
Definition: Type.h:4102
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5619
void AddType(const Type *T)
Definition: ODRHash.cpp:1035
TemplateArgument getArgumentPack() const
Definition: Type.cpp:3233
void AddIdentifierInfo(const IdentifierInfo *II)
Definition: ODRHash.cpp:30
QualType getElementType() const
Definition: Type.h:3177
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set...
Definition: Decl.h:2698
bool isRestrict() const
Definition: Type.h:3497
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2043
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool isParameterPack() const
Definition: Type.h:4450
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:360
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4560
QualType getEquivalentType() const
Definition: Type.h:4334
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3497
QualType getInnerType() const
Definition: Type.h:2494
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:5047
unsigned getODRHash()
Returns ODRHash of the function.
Definition: Decl.cpp:3719
AutoTypeKeyword getKeyword() const
Definition: Type.h:4647
Qualifiers getIndexTypeQualifiers() const
Definition: Type.h:2827
TypeClass getTypeClass() const
Definition: Type.h:1796
void AddNestedNameSpecifier(const NestedNameSpecifier *NNS)
Definition: ODRHash.cpp:105
ArrayRef< TemplateArgument > template_arguments() const
Definition: Type.h:5186
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted per C++0x.
Definition: Decl.h:2018
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3737
void AddSubDecl(const Decl *D)
Definition: ODRHash.cpp:456
void AddEnumDecl(const EnumDecl *Enum)
Definition: ODRHash.cpp:592
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2596
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4859
QualType getPointeeType() const
Definition: Type.h:3074
Represents a pack expansion of types.
Definition: Type.h:5236
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
Definition: TemplateBase.h:354
StringRef getName() const
Return the actual identifier string.
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2893
Represents a template argument.
Definition: TemplateBase.h:51
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons...
Definition: Type.h:2559
Dataflow Directional Tag Classes.
ExtInfo getExtInfo() const
Definition: Type.h:3494
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:499
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
Definition: Decl.h:1992
NestedNameSpecifier * getQualifier() const
Definition: Type.h:5171
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1267
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:80
QualType getUnderlyingType() const
Definition: Decl.h:2948
AccessSpecifier getAccess() const
Definition: DeclBase.h:461
const Expr * getInit() const
Definition: Decl.h:1217
QualType getUnderlyingType() const
Definition: Type.h:4140
void AddCXXRecordDecl(const CXXRecordDecl *Record)
Definition: ODRHash.cpp:462
DeclarationName - The name of a declaration.
VectorKind getVectorKind() const
Definition: Type.h:3187
Kind getKind() const
Definition: DeclBase.h:420
bool isKeywordSelector() const
bool isKindOfType() const
Whether this ia a "__kindof" type (semantically).
Definition: Type.cpp:674
Represents an enum.
Definition: Decl.h:3303
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2730
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
A type that was preceded by the &#39;template&#39; keyword, stored as a Type*.
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4501
QualType getUnderlyingType() const
Definition: Type.h:4197
QualType getModifiedType() const
Definition: Type.h:4333
Represents a pointer to an Objective C object.
Definition: Type.h:5675
Pointer to a block type.
Definition: Type.h:2613
bool isSugared() const
Returns whether this type directly provides sugar.
Definition: Type.cpp:3063
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4253
Complex values, per C99 6.2.5p11.
Definition: Type.h:2451
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:4795
const llvm::APInt & getSize() const
Definition: Type.h:2864
Kind getAttrKind() const
Definition: Type.h:4329
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:1057
ExtVectorType - Extended vector type.
Definition: Type.h:3261
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2647
bool isVolatile() const
Definition: Type.h:3496
unsigned CalculateHash()
Definition: ODRHash.cpp:199
The template argument is a type.
Definition: TemplateBase.h:60
QualType getUnderlyingType() const
Definition: Type.h:4117
The template argument is actually a parameter pack.
Definition: TemplateBase.h:91
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
A template argument list.
Definition: DeclTemplate.h:210
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1596
TypedefNameDecl * getDecl() const
Definition: Type.h:4050
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:235
unsigned getDepth() const
Definition: Type.h:4448
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:4308
Represents a type parameter type in Objective C.
Definition: Type.h:5345
bool isMutable() const
Determines whether this field is mutable (C++ only).
Definition: Decl.h:2631
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:5145
ArrayRef< TemplateArgument > template_arguments() const
Definition: Type.h:4803
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:76
Represents a C array with an unspecified size.
Definition: Type.h:2900
QualType getNamedType() const
Retrieve the type named by the qualified-id.
Definition: Type.h:5050
bool isNull() const
Determine whether this is the empty selector.
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
Definition: Type.h:4507
Declaration of a class template.
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2368
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
Definition: Decl.h:3457
void AddStmt(const Stmt *S)
Definition: ODRHash.cpp:25
NameKind getKind() const
unsigned getNumElements() const
Definition: Type.h:3178
bool isReadOnly() const
Definition: Type.h:5916
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:257
Represents an extended address space qualifier where the input address space value is dependent...
Definition: Type.h:3060
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4724
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2115
static bool isWhitelistedDecl(const Decl *D, const DeclContext *Parent)
Definition: ODRHash.cpp:433
QualType getDefaultArgument() const
Retrieve the default argument, if any.
QualType getType() const
Definition: Decl.h:647
A set of overloaded template declarations.
Definition: TemplateName.h:194
This represents a decl that may have a name.
Definition: Decl.h:248
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2945
A simple visitor class that helps create declaration visitors.
Definition: DeclVisitor.h:77
The global specifier &#39;::&#39;. There is no stored value.
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion, return the pattern as a template name.
Definition: TemplateBase.h:288
bool hasInit() const
Definition: Decl.cpp:2154
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2846
Declaration of a template function.
Definition: DeclTemplate.h:968
bool isDeletedAsWritten() const
Definition: Decl.h:2119
QualType getPointeeType() const
Definition: Type.h:2750
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
A single template declaration.
Definition: TemplateName.h:191
const IdentifierInfo * getIdentifier() const
Definition: Type.h:5172
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5691