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"
19 #include "clang/AST/NestedNameSpecifier.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 
30 void ODRHash::AddIdentifierInfo(const IdentifierInfo *II) {
31   assert(II && "Expecting non-null pointer.");
32   ID.AddString(II->getName());
33 }
34 
35 void ODRHash::AddDeclarationName(DeclarationName Name) {
36   AddBoolean(Name.isEmpty());
37   if (Name.isEmpty())
38     return;
39 
40   auto Kind = Name.getNameKind();
41   ID.AddInteger(Kind);
42   switch (Kind) {
43   case DeclarationName::Identifier:
44     AddIdentifierInfo(Name.getAsIdentifierInfo());
45     break;
46   case DeclarationName::ObjCZeroArgSelector:
47   case DeclarationName::ObjCOneArgSelector:
48   case DeclarationName::ObjCMultiArgSelector: {
49     Selector S = Name.getObjCSelector();
50     AddBoolean(S.isNull());
51     AddBoolean(S.isKeywordSelector());
52     AddBoolean(S.isUnarySelector());
53     unsigned NumArgs = S.getNumArgs();
54     for (unsigned i = 0; i < NumArgs; ++i) {
55       AddIdentifierInfo(S.getIdentifierInfoForSlot(i));
56     }
57     break;
58   }
59   case DeclarationName::CXXConstructorName:
60   case DeclarationName::CXXDestructorName:
61     AddQualType(Name.getCXXNameType());
62     break;
63   case DeclarationName::CXXOperatorName:
64     ID.AddInteger(Name.getCXXOverloadedOperator());
65     break;
66   case DeclarationName::CXXLiteralOperatorName:
67     AddIdentifierInfo(Name.getCXXLiteralIdentifier());
68     break;
69   case DeclarationName::CXXConversionFunctionName:
70     AddQualType(Name.getCXXNameType());
71     break;
72   case DeclarationName::CXXUsingDirective:
73     break;
74   case DeclarationName::CXXDeductionGuideName: {
75     auto *Template = Name.getCXXDeductionGuideTemplate();
76     AddBoolean(Template);
77     if (Template) {
78       AddDecl(Template);
79     }
80   }
81   }
82 }
83 
84 void ODRHash::AddNestedNameSpecifier(const NestedNameSpecifier *NNS) {
85   assert(NNS && "Expecting non-null pointer.");
86   const auto *Prefix = NNS->getPrefix();
87   AddBoolean(Prefix);
88   if (Prefix) {
89     AddNestedNameSpecifier(Prefix);
90   }
91   auto Kind = NNS->getKind();
92   ID.AddInteger(Kind);
93   switch (Kind) {
94   case NestedNameSpecifier::Identifier:
95     AddIdentifierInfo(NNS->getAsIdentifier());
96     break;
97   case NestedNameSpecifier::Namespace:
98     AddDecl(NNS->getAsNamespace());
99     break;
100   case NestedNameSpecifier::NamespaceAlias:
101     AddDecl(NNS->getAsNamespaceAlias());
102     break;
103   case NestedNameSpecifier::TypeSpec:
104   case NestedNameSpecifier::TypeSpecWithTemplate:
105     AddType(NNS->getAsType());
106     break;
107   case NestedNameSpecifier::Global:
108   case NestedNameSpecifier::Super:
109     break;
110   }
111 }
112 
113 void ODRHash::AddTemplateName(TemplateName Name) {
114   auto Kind = Name.getKind();
115   ID.AddInteger(Kind);
116 
117   switch (Kind) {
118   case TemplateName::Template:
119     AddDecl(Name.getAsTemplateDecl());
120     break;
121   // TODO: Support these cases.
122   case TemplateName::OverloadedTemplate:
123   case TemplateName::QualifiedTemplate:
124   case TemplateName::DependentTemplate:
125   case TemplateName::SubstTemplateTemplateParm:
126   case TemplateName::SubstTemplateTemplateParmPack:
127     break;
128   }
129 }
130 
131 void ODRHash::AddTemplateArgument(TemplateArgument TA) {
132   const auto Kind = TA.getKind();
133   ID.AddInteger(Kind);
134 
135   switch (Kind) {
136     case TemplateArgument::Null:
137       llvm_unreachable("Expected valid TemplateArgument");
138     case TemplateArgument::Type:
139       AddQualType(TA.getAsType());
140       break;
141     case TemplateArgument::Declaration:
142     case TemplateArgument::NullPtr:
143     case TemplateArgument::Integral:
144       break;
145     case TemplateArgument::Template:
146     case TemplateArgument::TemplateExpansion:
147       AddTemplateName(TA.getAsTemplateOrTemplatePattern());
148       break;
149     case TemplateArgument::Expression:
150       AddStmt(TA.getAsExpr());
151       break;
152     case TemplateArgument::Pack:
153       ID.AddInteger(TA.pack_size());
154       for (auto SubTA : TA.pack_elements()) {
155         AddTemplateArgument(SubTA);
156       }
157       break;
158   }
159 }
160 
161 void ODRHash::AddTemplateParameterList(const TemplateParameterList *TPL) {
162   assert(TPL && "Expecting non-null pointer.");
163 
164   ID.AddInteger(TPL->size());
165   for (auto *ND : TPL->asArray()) {
166     AddSubDecl(ND);
167   }
168 }
169 
170 void ODRHash::clear() {
171   DeclMap.clear();
172   TypeMap.clear();
173   Bools.clear();
174   ID.clear();
175 }
176 
177 unsigned ODRHash::CalculateHash() {
178   // Append the bools to the end of the data segment backwards.  This allows
179   // for the bools data to be compressed 32 times smaller compared to using
180   // ID.AddBoolean
181   const unsigned unsigned_bits = sizeof(unsigned) * CHAR_BIT;
182   const unsigned size = Bools.size();
183   const unsigned remainder = size % unsigned_bits;
184   const unsigned loops = size / unsigned_bits;
185   auto I = Bools.rbegin();
186   unsigned value = 0;
187   for (unsigned i = 0; i < remainder; ++i) {
188     value <<= 1;
189     value |= *I;
190     ++I;
191   }
192   ID.AddInteger(value);
193 
194   for (unsigned i = 0; i < loops; ++i) {
195     value = 0;
196     for (unsigned j = 0; j < unsigned_bits; ++j) {
197       value <<= 1;
198       value |= *I;
199       ++I;
200     }
201     ID.AddInteger(value);
202   }
203 
204   assert(I == Bools.rend());
205   Bools.clear();
206   return ID.ComputeHash();
207 }
208 
209 namespace {
210 // Process a Decl pointer.  Add* methods call back into ODRHash while Visit*
211 // methods process the relevant parts of the Decl.
212 class ODRDeclVisitor : public ConstDeclVisitor<ODRDeclVisitor> {
213   typedef ConstDeclVisitor<ODRDeclVisitor> Inherited;
214   llvm::FoldingSetNodeID &ID;
215   ODRHash &Hash;
216 
217 public:
218   ODRDeclVisitor(llvm::FoldingSetNodeID &ID, ODRHash &Hash)
219       : ID(ID), Hash(Hash) {}
220 
221   void AddStmt(const Stmt *S) {
222     Hash.AddBoolean(S);
223     if (S) {
224       Hash.AddStmt(S);
225     }
226   }
227 
228   void AddIdentifierInfo(const IdentifierInfo *II) {
229     Hash.AddBoolean(II);
230     if (II) {
231       Hash.AddIdentifierInfo(II);
232     }
233   }
234 
235   void AddQualType(QualType T) {
236     Hash.AddQualType(T);
237   }
238 
239   void AddDecl(const Decl *D) {
240     Hash.AddBoolean(D);
241     if (D) {
242       Hash.AddDecl(D);
243     }
244   }
245 
246   void AddTemplateArgument(TemplateArgument TA) {
247     Hash.AddTemplateArgument(TA);
248   }
249 
250   void Visit(const Decl *D) {
251     ID.AddInteger(D->getKind());
252     Inherited::Visit(D);
253   }
254 
255   void VisitNamedDecl(const NamedDecl *D) {
256     Hash.AddDeclarationName(D->getDeclName());
257     Inherited::VisitNamedDecl(D);
258   }
259 
260   void VisitValueDecl(const ValueDecl *D) {
261     if (!isa<FunctionDecl>(D)) {
262       AddQualType(D->getType());
263     }
264     Inherited::VisitValueDecl(D);
265   }
266 
267   void VisitVarDecl(const VarDecl *D) {
268     Hash.AddBoolean(D->isStaticLocal());
269     Hash.AddBoolean(D->isConstexpr());
270     const bool HasInit = D->hasInit();
271     Hash.AddBoolean(HasInit);
272     if (HasInit) {
273       AddStmt(D->getInit());
274     }
275     Inherited::VisitVarDecl(D);
276   }
277 
278   void VisitParmVarDecl(const ParmVarDecl *D) {
279     // TODO: Handle default arguments.
280     Inherited::VisitParmVarDecl(D);
281   }
282 
283   void VisitAccessSpecDecl(const AccessSpecDecl *D) {
284     ID.AddInteger(D->getAccess());
285     Inherited::VisitAccessSpecDecl(D);
286   }
287 
288   void VisitStaticAssertDecl(const StaticAssertDecl *D) {
289     AddStmt(D->getAssertExpr());
290     AddStmt(D->getMessage());
291 
292     Inherited::VisitStaticAssertDecl(D);
293   }
294 
295   void VisitFieldDecl(const FieldDecl *D) {
296     const bool IsBitfield = D->isBitField();
297     Hash.AddBoolean(IsBitfield);
298 
299     if (IsBitfield) {
300       AddStmt(D->getBitWidth());
301     }
302 
303     Hash.AddBoolean(D->isMutable());
304     AddStmt(D->getInClassInitializer());
305 
306     Inherited::VisitFieldDecl(D);
307   }
308 
309   void VisitFunctionDecl(const FunctionDecl *D) {
310     ID.AddInteger(D->getStorageClass());
311     Hash.AddBoolean(D->isInlineSpecified());
312     Hash.AddBoolean(D->isVirtualAsWritten());
313     Hash.AddBoolean(D->isPure());
314     Hash.AddBoolean(D->isDeletedAsWritten());
315 
316     ID.AddInteger(D->param_size());
317 
318     for (auto *Param : D->parameters()) {
319       Hash.AddSubDecl(Param);
320     }
321 
322     AddQualType(D->getReturnType());
323 
324     Inherited::VisitFunctionDecl(D);
325   }
326 
327   void VisitCXXMethodDecl(const CXXMethodDecl *D) {
328     Hash.AddBoolean(D->isConst());
329     Hash.AddBoolean(D->isVolatile());
330 
331     Inherited::VisitCXXMethodDecl(D);
332   }
333 
334   void VisitTypedefNameDecl(const TypedefNameDecl *D) {
335     AddQualType(D->getUnderlyingType());
336 
337     Inherited::VisitTypedefNameDecl(D);
338   }
339 
340   void VisitTypedefDecl(const TypedefDecl *D) {
341     Inherited::VisitTypedefDecl(D);
342   }
343 
344   void VisitTypeAliasDecl(const TypeAliasDecl *D) {
345     Inherited::VisitTypeAliasDecl(D);
346   }
347 
348   void VisitFriendDecl(const FriendDecl *D) {
349     TypeSourceInfo *TSI = D->getFriendType();
350     Hash.AddBoolean(TSI);
351     if (TSI) {
352       AddQualType(TSI->getType());
353     } else {
354       AddDecl(D->getFriendDecl());
355     }
356   }
357 
358   void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
359     // Only care about default arguments as part of the definition.
360     const bool hasDefaultArgument =
361         D->hasDefaultArgument() && !D->defaultArgumentWasInherited();
362     Hash.AddBoolean(hasDefaultArgument);
363     if (hasDefaultArgument) {
364       AddTemplateArgument(D->getDefaultArgument());
365     }
366 
367     Inherited::VisitTemplateTypeParmDecl(D);
368   }
369 
370   void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
371     // Only care about default arguments as part of the definition.
372     const bool hasDefaultArgument =
373         D->hasDefaultArgument() && !D->defaultArgumentWasInherited();
374     Hash.AddBoolean(hasDefaultArgument);
375     if (hasDefaultArgument) {
376       AddStmt(D->getDefaultArgument());
377     }
378 
379     Inherited::VisitNonTypeTemplateParmDecl(D);
380   }
381 
382   void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) {
383     // Only care about default arguments as part of the definition.
384     const bool hasDefaultArgument =
385         D->hasDefaultArgument() && !D->defaultArgumentWasInherited();
386     Hash.AddBoolean(hasDefaultArgument);
387     if (hasDefaultArgument) {
388       AddTemplateArgument(D->getDefaultArgument().getArgument());
389     }
390 
391     Inherited::VisitTemplateTemplateParmDecl(D);
392   }
393 };
394 } // namespace
395 
396 // Only allow a small portion of Decl's to be processed.  Remove this once
397 // all Decl's can be handled.
398 bool ODRHash::isWhitelistedDecl(const Decl *D, const CXXRecordDecl *Parent) {
399   if (D->isImplicit()) return false;
400   if (D->getDeclContext() != Parent) return false;
401 
402   switch (D->getKind()) {
403     default:
404       return false;
405     case Decl::AccessSpec:
406     case Decl::CXXConstructor:
407     case Decl::CXXDestructor:
408     case Decl::CXXMethod:
409     case Decl::Field:
410     case Decl::Friend:
411     case Decl::StaticAssert:
412     case Decl::TypeAlias:
413     case Decl::Typedef:
414     case Decl::Var:
415       return true;
416   }
417 }
418 
419 void ODRHash::AddSubDecl(const Decl *D) {
420   assert(D && "Expecting non-null pointer.");
421   AddDecl(D);
422 
423   ODRDeclVisitor(ID, *this).Visit(D);
424 }
425 
426 void ODRHash::AddCXXRecordDecl(const CXXRecordDecl *Record) {
427   assert(Record && Record->hasDefinition() &&
428          "Expected non-null record to be a definition.");
429 
430   const DeclContext *DC = Record;
431   while (DC) {
432     if (isa<ClassTemplateSpecializationDecl>(DC)) {
433       return;
434     }
435     DC = DC->getParent();
436   }
437 
438   AddDecl(Record);
439 
440   // Filter out sub-Decls which will not be processed in order to get an
441   // accurate count of Decl's.
442   llvm::SmallVector<const Decl *, 16> Decls;
443   for (const Decl *SubDecl : Record->decls()) {
444     if (isWhitelistedDecl(SubDecl, Record)) {
445       Decls.push_back(SubDecl);
446     }
447   }
448 
449   ID.AddInteger(Decls.size());
450   for (auto SubDecl : Decls) {
451     AddSubDecl(SubDecl);
452   }
453 
454   const ClassTemplateDecl *TD = Record->getDescribedClassTemplate();
455   AddBoolean(TD);
456   if (TD) {
457     AddTemplateParameterList(TD->getTemplateParameters());
458   }
459 
460   ID.AddInteger(Record->getNumBases());
461   auto Bases = Record->bases();
462   for (auto Base : Bases) {
463     AddQualType(Base.getType());
464     ID.AddInteger(Base.isVirtual());
465     ID.AddInteger(Base.getAccessSpecifierAsWritten());
466   }
467 }
468 
469 void ODRHash::AddFunctionDecl(const FunctionDecl *Function) {
470   assert(Function && "Expecting non-null pointer.");
471 
472   // Skip hashing these kinds of function.
473   if (Function->isImplicit()) return;
474   if (Function->isDefaulted()) return;
475   if (Function->isDeleted()) return;
476   if (!Function->hasBody()) return;
477   if (!Function->getBody()) return;
478 
479   // TODO: Fix hashing for class methods.
480   if (isa<CXXMethodDecl>(Function)) return;
481   // And friend functions.
482   if (Function->getFriendObjectKind()) return;
483 
484   // Skip functions that are specializations or in specialization context.
485   const DeclContext *DC = Function;
486   while (DC) {
487     if (isa<ClassTemplateSpecializationDecl>(DC)) return;
488     if (auto *F = dyn_cast<FunctionDecl>(DC))
489       if (F->isFunctionTemplateSpecialization()) return;
490     DC = DC->getParent();
491   }
492 
493   AddDecl(Function);
494 
495   AddQualType(Function->getReturnType());
496 
497   ID.AddInteger(Function->param_size());
498   for (auto Param : Function->parameters())
499     AddSubDecl(Param);
500 
501   AddStmt(Function->getBody());
502 }
503 
504 void ODRHash::AddDecl(const Decl *D) {
505   assert(D && "Expecting non-null pointer.");
506   D = D->getCanonicalDecl();
507   auto Result = DeclMap.insert(std::make_pair(D, DeclMap.size()));
508   ID.AddInteger(Result.first->second);
509   // On first encounter of a Decl pointer, process it.  Every time afterwards,
510   // only the index value is needed.
511   if (!Result.second) {
512     return;
513   }
514 
515   ID.AddInteger(D->getKind());
516 
517   if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
518     AddDeclarationName(ND->getDeclName());
519   }
520 }
521 
522 namespace {
523 // Process a Type pointer.  Add* methods call back into ODRHash while Visit*
524 // methods process the relevant parts of the Type.
525 class ODRTypeVisitor : public TypeVisitor<ODRTypeVisitor> {
526   typedef TypeVisitor<ODRTypeVisitor> Inherited;
527   llvm::FoldingSetNodeID &ID;
528   ODRHash &Hash;
529 
530 public:
531   ODRTypeVisitor(llvm::FoldingSetNodeID &ID, ODRHash &Hash)
532       : ID(ID), Hash(Hash) {}
533 
534   void AddStmt(Stmt *S) {
535     Hash.AddBoolean(S);
536     if (S) {
537       Hash.AddStmt(S);
538     }
539   }
540 
541   void AddDecl(Decl *D) {
542     Hash.AddBoolean(D);
543     if (D) {
544       Hash.AddDecl(D);
545     }
546   }
547 
548   void AddQualType(QualType T) {
549     Hash.AddQualType(T);
550   }
551 
552   void AddType(const Type *T) {
553     Hash.AddBoolean(T);
554     if (T) {
555       Hash.AddType(T);
556     }
557   }
558 
559   void AddNestedNameSpecifier(const NestedNameSpecifier *NNS) {
560     Hash.AddBoolean(NNS);
561     if (NNS) {
562       Hash.AddNestedNameSpecifier(NNS);
563     }
564   }
565 
566   void AddIdentifierInfo(const IdentifierInfo *II) {
567     Hash.AddBoolean(II);
568     if (II) {
569       Hash.AddIdentifierInfo(II);
570     }
571   }
572 
573   void VisitQualifiers(Qualifiers Quals) {
574     ID.AddInteger(Quals.getAsOpaqueValue());
575   }
576 
577   void Visit(const Type *T) {
578     ID.AddInteger(T->getTypeClass());
579     Inherited::Visit(T);
580   }
581 
582   void VisitType(const Type *T) {}
583 
584   void VisitAdjustedType(const AdjustedType *T) {
585     AddQualType(T->getOriginalType());
586     AddQualType(T->getAdjustedType());
587     VisitType(T);
588   }
589 
590   void VisitDecayedType(const DecayedType *T) {
591     AddQualType(T->getDecayedType());
592     AddQualType(T->getPointeeType());
593     VisitAdjustedType(T);
594   }
595 
596   void VisitArrayType(const ArrayType *T) {
597     AddQualType(T->getElementType());
598     ID.AddInteger(T->getSizeModifier());
599     VisitQualifiers(T->getIndexTypeQualifiers());
600     VisitType(T);
601   }
602   void VisitConstantArrayType(const ConstantArrayType *T) {
603     T->getSize().Profile(ID);
604     VisitArrayType(T);
605   }
606 
607   void VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
608     AddStmt(T->getSizeExpr());
609     VisitArrayType(T);
610   }
611 
612   void VisitIncompleteArrayType(const IncompleteArrayType *T) {
613     VisitArrayType(T);
614   }
615 
616   void VisitVariableArrayType(const VariableArrayType *T) {
617     AddStmt(T->getSizeExpr());
618     VisitArrayType(T);
619   }
620 
621   void VisitBuiltinType(const BuiltinType *T) {
622     ID.AddInteger(T->getKind());
623     VisitType(T);
624   }
625 
626   void VisitFunctionType(const FunctionType *T) {
627     AddQualType(T->getReturnType());
628     T->getExtInfo().Profile(ID);
629     Hash.AddBoolean(T->isConst());
630     Hash.AddBoolean(T->isVolatile());
631     Hash.AddBoolean(T->isRestrict());
632     VisitType(T);
633   }
634 
635   void VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
636     VisitFunctionType(T);
637   }
638 
639   void VisitFunctionProtoType(const FunctionProtoType *T) {
640     ID.AddInteger(T->getNumParams());
641     for (auto ParamType : T->getParamTypes())
642       AddQualType(ParamType);
643 
644     VisitFunctionType(T);
645   }
646 
647   void VisitTypedefType(const TypedefType *T) {
648     AddDecl(T->getDecl());
649     QualType UnderlyingType = T->getDecl()->getUnderlyingType();
650     VisitQualifiers(UnderlyingType.getQualifiers());
651     while (const TypedefType *Underlying =
652                dyn_cast<TypedefType>(UnderlyingType.getTypePtr())) {
653       UnderlyingType = Underlying->getDecl()->getUnderlyingType();
654     }
655     AddType(UnderlyingType.getTypePtr());
656     VisitType(T);
657   }
658 
659   void VisitTagType(const TagType *T) {
660     AddDecl(T->getDecl());
661     VisitType(T);
662   }
663 
664   void VisitRecordType(const RecordType *T) { VisitTagType(T); }
665   void VisitEnumType(const EnumType *T) { VisitTagType(T); }
666 
667   void VisitTypeWithKeyword(const TypeWithKeyword *T) {
668     ID.AddInteger(T->getKeyword());
669     VisitType(T);
670   };
671 
672   void VisitDependentNameType(const DependentNameType *T) {
673     AddNestedNameSpecifier(T->getQualifier());
674     AddIdentifierInfo(T->getIdentifier());
675     VisitTypeWithKeyword(T);
676   }
677 
678   void VisitDependentTemplateSpecializationType(
679       const DependentTemplateSpecializationType *T) {
680     AddIdentifierInfo(T->getIdentifier());
681     AddNestedNameSpecifier(T->getQualifier());
682     ID.AddInteger(T->getNumArgs());
683     for (const auto &TA : T->template_arguments()) {
684       Hash.AddTemplateArgument(TA);
685     }
686     VisitTypeWithKeyword(T);
687   }
688 
689   void VisitElaboratedType(const ElaboratedType *T) {
690     AddNestedNameSpecifier(T->getQualifier());
691     AddQualType(T->getNamedType());
692     VisitTypeWithKeyword(T);
693   }
694 
695   void VisitTemplateSpecializationType(const TemplateSpecializationType *T) {
696     ID.AddInteger(T->getNumArgs());
697     for (const auto &TA : T->template_arguments()) {
698       Hash.AddTemplateArgument(TA);
699     }
700     Hash.AddTemplateName(T->getTemplateName());
701     VisitType(T);
702   }
703 
704   void VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
705     ID.AddInteger(T->getDepth());
706     ID.AddInteger(T->getIndex());
707     Hash.AddBoolean(T->isParameterPack());
708     AddDecl(T->getDecl());
709   }
710 };
711 } // namespace
712 
713 void ODRHash::AddType(const Type *T) {
714   assert(T && "Expecting non-null pointer.");
715   auto Result = TypeMap.insert(std::make_pair(T, TypeMap.size()));
716   ID.AddInteger(Result.first->second);
717   // On first encounter of a Type pointer, process it.  Every time afterwards,
718   // only the index value is needed.
719   if (!Result.second) {
720     return;
721   }
722 
723   ODRTypeVisitor(ID, *this).Visit(T);
724 }
725 
726 void ODRHash::AddQualType(QualType T) {
727   AddBoolean(T.isNull());
728   if (T.isNull())
729     return;
730   SplitQualType split = T.split();
731   ID.AddInteger(split.Quals.getAsOpaqueValue());
732   AddType(split.Ty);
733 }
734 
735 void ODRHash::AddBoolean(bool Value) {
736   Bools.push_back(Value);
737 }
738