ASTReaderDecl.cpp revision 243830 
1//===--- ASTReaderDecl.cpp - Decl Deserialization ---------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the ASTReader::ReadDeclRecord method, which is the
11// entrypoint for loading a decl.
12//
13//===----------------------------------------------------------------------===//
14
15#include "ASTCommon.h"
16#include "ASTReaderInternals.h"
17#include "clang/Serialization/ASTReader.h"
18#include "clang/Sema/IdentifierResolver.h"
19#include "clang/Sema/Sema.h"
20#include "clang/Sema/SemaDiagnostic.h"
21#include "clang/AST/ASTConsumer.h"
22#include "clang/AST/ASTContext.h"
23#include "clang/AST/DeclVisitor.h"
24#include "clang/AST/DeclGroup.h"
25#include "clang/AST/DeclCXX.h"
26#include "clang/AST/DeclTemplate.h"
27#include "clang/AST/Expr.h"
28#include "llvm/Support/SaveAndRestore.h"
29using namespace clang;
30using namespace clang::serialization;
31
32//===----------------------------------------------------------------------===//
33// Declaration deserialization
34//===----------------------------------------------------------------------===//
35
36namespace clang {
37  class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
38    ASTReader &Reader;
39    ModuleFile &F;
40    const DeclID ThisDeclID;
41    const unsigned RawLocation;
42    typedef ASTReader::RecordData RecordData;
43    const RecordData &Record;
44    unsigned &Idx;
45    TypeID TypeIDForTypeDecl;
46
47    DeclID DeclContextIDForTemplateParmDecl;
48    DeclID LexicalDeclContextIDForTemplateParmDecl;
49
50    bool HasPendingBody;
51
52    uint64_t GetCurrentCursorOffset();
53
54    SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
55      return Reader.ReadSourceLocation(F, R, I);
56    }
57
58    SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
59      return Reader.ReadSourceRange(F, R, I);
60    }
61
62    TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
63      return Reader.GetTypeSourceInfo(F, R, I);
64    }
65
66    serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
67      return Reader.ReadDeclID(F, R, I);
68    }
69
70    Decl *ReadDecl(const RecordData &R, unsigned &I) {
71      return Reader.ReadDecl(F, R, I);
72    }
73
74    template<typename T>
75    T *ReadDeclAs(const RecordData &R, unsigned &I) {
76      return Reader.ReadDeclAs<T>(F, R, I);
77    }
78
79    void ReadQualifierInfo(QualifierInfo &Info,
80                           const RecordData &R, unsigned &I) {
81      Reader.ReadQualifierInfo(F, Info, R, I);
82    }
83
84    void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
85                                const RecordData &R, unsigned &I) {
86      Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
87    }
88
89    void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
90                                const RecordData &R, unsigned &I) {
91      Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
92    }
93
94    serialization::SubmoduleID readSubmoduleID(const RecordData &R,
95                                               unsigned &I) {
96      if (I >= R.size())
97        return 0;
98
99      return Reader.getGlobalSubmoduleID(F, R[I++]);
100    }
101
102    Module *readModule(const RecordData &R, unsigned &I) {
103      return Reader.getSubmodule(readSubmoduleID(R, I));
104    }
105
106    void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
107                               const RecordData &R, unsigned &I);
108
109    /// \brief RAII class used to capture the first ID within a redeclaration
110    /// chain and to introduce it into the list of pending redeclaration chains
111    /// on destruction.
112    ///
113    /// The caller can choose not to introduce this ID into the redeclaration
114    /// chain by calling \c suppress().
115    class RedeclarableResult {
116      ASTReader &Reader;
117      GlobalDeclID FirstID;
118      mutable bool Owning;
119
120      void operator=(RedeclarableResult &) LLVM_DELETED_FUNCTION;
121
122    public:
123      RedeclarableResult(ASTReader &Reader, GlobalDeclID FirstID)
124        : Reader(Reader), FirstID(FirstID), Owning(true) { }
125
126      RedeclarableResult(const RedeclarableResult &Other)
127        : Reader(Other.Reader), FirstID(Other.FirstID), Owning(Other.Owning)
128      {
129        Other.Owning = false;
130      }
131
132      ~RedeclarableResult() {
133        // FIXME: We want to suppress this when the declaration is local to
134        // a function, since there's no reason to search other AST files
135        // for redeclarations (they can't exist). However, this is hard to
136        // do locally because the declaration hasn't necessarily loaded its
137        // declaration context yet. Also, local externs still have the function
138        // as their (semantic) declaration context, which is wrong and would
139        // break this optimize.
140
141        if (FirstID && Owning && Reader.PendingDeclChainsKnown.insert(FirstID))
142          Reader.PendingDeclChains.push_back(FirstID);
143      }
144
145      /// \brief Retrieve the first ID.
146      GlobalDeclID getFirstID() const { return FirstID; }
147
148      /// \brief Do not introduce this declaration ID into the set of pending
149      /// declaration chains.
150      void suppress() {
151        Owning = false;
152      }
153    };
154
155    /// \brief Class used to capture the result of searching for an existing
156    /// declaration of a specific kind and name, along with the ability
157    /// to update the place where this result was found (the declaration
158    /// chain hanging off an identifier or the DeclContext we searched in)
159    /// if requested.
160    class FindExistingResult {
161      ASTReader &Reader;
162      NamedDecl *New;
163      NamedDecl *Existing;
164      mutable bool AddResult;
165
166      void operator=(FindExistingResult&) LLVM_DELETED_FUNCTION;
167
168    public:
169      FindExistingResult(ASTReader &Reader)
170        : Reader(Reader), New(0), Existing(0), AddResult(false) { }
171
172      FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing)
173        : Reader(Reader), New(New), Existing(Existing), AddResult(true) { }
174
175      FindExistingResult(const FindExistingResult &Other)
176        : Reader(Other.Reader), New(Other.New), Existing(Other.Existing),
177          AddResult(Other.AddResult)
178      {
179        Other.AddResult = false;
180      }
181
182      ~FindExistingResult();
183
184      /// \brief Suppress the addition of this result into the known set of
185      /// names.
186      void suppress() { AddResult = false; }
187
188      operator NamedDecl*() const { return Existing; }
189
190      template<typename T>
191      operator T*() const { return dyn_cast_or_null<T>(Existing); }
192    };
193
194    FindExistingResult findExisting(NamedDecl *D);
195
196  public:
197    ASTDeclReader(ASTReader &Reader, ModuleFile &F,
198                  DeclID thisDeclID,
199                  unsigned RawLocation,
200                  const RecordData &Record, unsigned &Idx)
201      : Reader(Reader), F(F), ThisDeclID(thisDeclID),
202        RawLocation(RawLocation), Record(Record), Idx(Idx),
203        TypeIDForTypeDecl(0), HasPendingBody(false) { }
204
205    static void attachPreviousDecl(Decl *D, Decl *previous);
206    static void attachLatestDecl(Decl *D, Decl *latest);
207
208    /// \brief Determine whether this declaration has a pending body.
209    bool hasPendingBody() const { return HasPendingBody; }
210
211    void Visit(Decl *D);
212
213    void UpdateDecl(Decl *D, ModuleFile &ModuleFile,
214                    const RecordData &Record);
215
216    static void setNextObjCCategory(ObjCCategoryDecl *Cat,
217                                    ObjCCategoryDecl *Next) {
218      Cat->NextClassCategory = Next;
219    }
220
221    void VisitDecl(Decl *D);
222    void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
223    void VisitNamedDecl(NamedDecl *ND);
224    void VisitLabelDecl(LabelDecl *LD);
225    void VisitNamespaceDecl(NamespaceDecl *D);
226    void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
227    void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
228    void VisitTypeDecl(TypeDecl *TD);
229    void VisitTypedefNameDecl(TypedefNameDecl *TD);
230    void VisitTypedefDecl(TypedefDecl *TD);
231    void VisitTypeAliasDecl(TypeAliasDecl *TD);
232    void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
233    void VisitTagDecl(TagDecl *TD);
234    void VisitEnumDecl(EnumDecl *ED);
235    void VisitRecordDecl(RecordDecl *RD);
236    void VisitCXXRecordDecl(CXXRecordDecl *D);
237    void VisitClassTemplateSpecializationDecl(
238                                            ClassTemplateSpecializationDecl *D);
239    void VisitClassTemplatePartialSpecializationDecl(
240                                     ClassTemplatePartialSpecializationDecl *D);
241    void VisitClassScopeFunctionSpecializationDecl(
242                                       ClassScopeFunctionSpecializationDecl *D);
243    void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
244    void VisitValueDecl(ValueDecl *VD);
245    void VisitEnumConstantDecl(EnumConstantDecl *ECD);
246    void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
247    void VisitDeclaratorDecl(DeclaratorDecl *DD);
248    void VisitFunctionDecl(FunctionDecl *FD);
249    void VisitCXXMethodDecl(CXXMethodDecl *D);
250    void VisitCXXConstructorDecl(CXXConstructorDecl *D);
251    void VisitCXXDestructorDecl(CXXDestructorDecl *D);
252    void VisitCXXConversionDecl(CXXConversionDecl *D);
253    void VisitFieldDecl(FieldDecl *FD);
254    void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
255    void VisitVarDecl(VarDecl *VD);
256    void VisitImplicitParamDecl(ImplicitParamDecl *PD);
257    void VisitParmVarDecl(ParmVarDecl *PD);
258    void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
259    void VisitTemplateDecl(TemplateDecl *D);
260    RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
261    void VisitClassTemplateDecl(ClassTemplateDecl *D);
262    void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
263    void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
264    void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
265    void VisitUsingDecl(UsingDecl *D);
266    void VisitUsingShadowDecl(UsingShadowDecl *D);
267    void VisitLinkageSpecDecl(LinkageSpecDecl *D);
268    void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
269    void VisitImportDecl(ImportDecl *D);
270    void VisitAccessSpecDecl(AccessSpecDecl *D);
271    void VisitFriendDecl(FriendDecl *D);
272    void VisitFriendTemplateDecl(FriendTemplateDecl *D);
273    void VisitStaticAssertDecl(StaticAssertDecl *D);
274    void VisitBlockDecl(BlockDecl *BD);
275
276    std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
277
278    template<typename T>
279    RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
280
281    template<typename T>
282    void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl);
283
284    // FIXME: Reorder according to DeclNodes.td?
285    void VisitObjCMethodDecl(ObjCMethodDecl *D);
286    void VisitObjCContainerDecl(ObjCContainerDecl *D);
287    void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
288    void VisitObjCIvarDecl(ObjCIvarDecl *D);
289    void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
290    void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
291    void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
292    void VisitObjCImplDecl(ObjCImplDecl *D);
293    void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
294    void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
295    void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
296    void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
297    void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
298  };
299}
300
301uint64_t ASTDeclReader::GetCurrentCursorOffset() {
302  return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset;
303}
304
305void ASTDeclReader::Visit(Decl *D) {
306  DeclVisitor<ASTDeclReader, void>::Visit(D);
307
308  if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
309    if (DD->DeclInfo) {
310      DeclaratorDecl::ExtInfo *Info =
311          DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>();
312      Info->TInfo =
313          GetTypeSourceInfo(Record, Idx);
314    }
315    else {
316      DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
317    }
318  }
319
320  if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
321    // if we have a fully initialized TypeDecl, we can safely read its type now.
322    TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull());
323  } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
324    // if we have a fully initialized TypeDecl, we can safely read its type now.
325    ID->TypeForDecl = Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull();
326  } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
327    // FunctionDecl's body was written last after all other Stmts/Exprs.
328    // We only read it if FD doesn't already have a body (e.g., from another
329    // module).
330    // FIXME: Also consider = default and = delete.
331    // FIXME: Can we diagnose ODR violations somehow?
332    if (Record[Idx++]) {
333      Reader.PendingBodies[FD] = GetCurrentCursorOffset();
334      HasPendingBody = true;
335    }
336  } else if (D->isTemplateParameter()) {
337    // If we have a fully initialized template parameter, we can now
338    // set its DeclContext.
339    DeclContext *SemaDC = cast<DeclContext>(
340                              Reader.GetDecl(DeclContextIDForTemplateParmDecl));
341    DeclContext *LexicalDC = cast<DeclContext>(
342                       Reader.GetDecl(LexicalDeclContextIDForTemplateParmDecl));
343    D->setDeclContextsImpl(SemaDC, LexicalDC, Reader.getContext());
344  }
345}
346
347void ASTDeclReader::VisitDecl(Decl *D) {
348  if (D->isTemplateParameter()) {
349    // We don't want to deserialize the DeclContext of a template
350    // parameter immediately, because the template parameter might be
351    // used in the formulation of its DeclContext. Use the translation
352    // unit DeclContext as a placeholder.
353    DeclContextIDForTemplateParmDecl = ReadDeclID(Record, Idx);
354    LexicalDeclContextIDForTemplateParmDecl = ReadDeclID(Record, Idx);
355    D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
356  } else {
357    DeclContext *SemaDC = ReadDeclAs<DeclContext>(Record, Idx);
358    DeclContext *LexicalDC = ReadDeclAs<DeclContext>(Record, Idx);
359    // Avoid calling setLexicalDeclContext() directly because it uses
360    // Decl::getASTContext() internally which is unsafe during derialization.
361    D->setDeclContextsImpl(SemaDC, LexicalDC, Reader.getContext());
362  }
363  D->setLocation(Reader.ReadSourceLocation(F, RawLocation));
364  D->setInvalidDecl(Record[Idx++]);
365  if (Record[Idx++]) { // hasAttrs
366    AttrVec Attrs;
367    Reader.ReadAttributes(F, Attrs, Record, Idx);
368    // Avoid calling setAttrs() directly because it uses Decl::getASTContext()
369    // internally which is unsafe during derialization.
370    D->setAttrsImpl(Attrs, Reader.getContext());
371  }
372  D->setImplicit(Record[Idx++]);
373  D->setUsed(Record[Idx++]);
374  D->setReferenced(Record[Idx++]);
375  D->setTopLevelDeclInObjCContainer(Record[Idx++]);
376  D->setAccess((AccessSpecifier)Record[Idx++]);
377  D->FromASTFile = true;
378  D->setModulePrivate(Record[Idx++]);
379  D->Hidden = D->isModulePrivate();
380
381  // Determine whether this declaration is part of a (sub)module. If so, it
382  // may not yet be visible.
383  if (unsigned SubmoduleID = readSubmoduleID(Record, Idx)) {
384    // Store the owning submodule ID in the declaration.
385    D->setOwningModuleID(SubmoduleID);
386
387    // Module-private declarations are never visible, so there is no work to do.
388    if (!D->isModulePrivate()) {
389      if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {
390        if (Owner->NameVisibility != Module::AllVisible) {
391          // The owning module is not visible. Mark this declaration as hidden.
392          D->Hidden = true;
393
394          // Note that this declaration was hidden because its owning module is
395          // not yet visible.
396          Reader.HiddenNamesMap[Owner].push_back(D);
397        }
398      }
399    }
400  }
401}
402
403void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
404  llvm_unreachable("Translation units are not serialized");
405}
406
407void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
408  VisitDecl(ND);
409  ND->setDeclName(Reader.ReadDeclarationName(F, Record, Idx));
410}
411
412void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
413  VisitNamedDecl(TD);
414  TD->setLocStart(ReadSourceLocation(Record, Idx));
415  // Delay type reading until after we have fully initialized the decl.
416  TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
417}
418
419void ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) {
420  RedeclarableResult Redecl = VisitRedeclarable(TD);
421  VisitTypeDecl(TD);
422
423  TD->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
424  mergeRedeclarable(TD, Redecl);
425}
426
427void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
428  VisitTypedefNameDecl(TD);
429}
430
431void ASTDeclReader::VisitTypeAliasDecl(TypeAliasDecl *TD) {
432  VisitTypedefNameDecl(TD);
433}
434
435void ASTDeclReader::VisitTagDecl(TagDecl *TD) {
436  RedeclarableResult Redecl = VisitRedeclarable(TD);
437  VisitTypeDecl(TD);
438
439  TD->IdentifierNamespace = Record[Idx++];
440  TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
441  TD->setCompleteDefinition(Record[Idx++]);
442  TD->setEmbeddedInDeclarator(Record[Idx++]);
443  TD->setFreeStanding(Record[Idx++]);
444  TD->setRBraceLoc(ReadSourceLocation(Record, Idx));
445
446  if (Record[Idx++]) { // hasExtInfo
447    TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo();
448    ReadQualifierInfo(*Info, Record, Idx);
449    TD->TypedefNameDeclOrQualifier = Info;
450  } else
451    TD->setTypedefNameForAnonDecl(ReadDeclAs<TypedefNameDecl>(Record, Idx));
452
453  mergeRedeclarable(TD, Redecl);
454}
455
456void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
457  VisitTagDecl(ED);
458  if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
459    ED->setIntegerTypeSourceInfo(TI);
460  else
461    ED->setIntegerType(Reader.readType(F, Record, Idx));
462  ED->setPromotionType(Reader.readType(F, Record, Idx));
463  ED->setNumPositiveBits(Record[Idx++]);
464  ED->setNumNegativeBits(Record[Idx++]);
465  ED->IsScoped = Record[Idx++];
466  ED->IsScopedUsingClassTag = Record[Idx++];
467  ED->IsFixed = Record[Idx++];
468
469  if (EnumDecl *InstED = ReadDeclAs<EnumDecl>(Record, Idx)) {
470    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
471    SourceLocation POI = ReadSourceLocation(Record, Idx);
472    ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
473    ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
474  }
475}
476
477void ASTDeclReader::VisitRecordDecl(RecordDecl *RD) {
478  VisitTagDecl(RD);
479  RD->setHasFlexibleArrayMember(Record[Idx++]);
480  RD->setAnonymousStructOrUnion(Record[Idx++]);
481  RD->setHasObjectMember(Record[Idx++]);
482}
483
484void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
485  VisitNamedDecl(VD);
486  VD->setType(Reader.readType(F, Record, Idx));
487}
488
489void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
490  VisitValueDecl(ECD);
491  if (Record[Idx++])
492    ECD->setInitExpr(Reader.ReadExpr(F));
493  ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
494}
495
496void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
497  VisitValueDecl(DD);
498  DD->setInnerLocStart(ReadSourceLocation(Record, Idx));
499  if (Record[Idx++]) { // hasExtInfo
500    DeclaratorDecl::ExtInfo *Info
501        = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
502    ReadQualifierInfo(*Info, Record, Idx);
503    DD->DeclInfo = Info;
504  }
505}
506
507void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
508  RedeclarableResult Redecl = VisitRedeclarable(FD);
509  VisitDeclaratorDecl(FD);
510
511  ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
512  FD->IdentifierNamespace = Record[Idx++];
513
514  // FunctionDecl's body is handled last at ASTDeclReader::Visit,
515  // after everything else is read.
516
517  FD->SClass = (StorageClass)Record[Idx++];
518  FD->SClassAsWritten = (StorageClass)Record[Idx++];
519  FD->IsInline = Record[Idx++];
520  FD->IsInlineSpecified = Record[Idx++];
521  FD->IsVirtualAsWritten = Record[Idx++];
522  FD->IsPure = Record[Idx++];
523  FD->HasInheritedPrototype = Record[Idx++];
524  FD->HasWrittenPrototype = Record[Idx++];
525  FD->IsDeleted = Record[Idx++];
526  FD->IsTrivial = Record[Idx++];
527  FD->IsDefaulted = Record[Idx++];
528  FD->IsExplicitlyDefaulted = Record[Idx++];
529  FD->HasImplicitReturnZero = Record[Idx++];
530  FD->IsConstexpr = Record[Idx++];
531  FD->EndRangeLoc = ReadSourceLocation(Record, Idx);
532
533  switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
534  case FunctionDecl::TK_NonTemplate:
535    mergeRedeclarable(FD, Redecl);
536    break;
537  case FunctionDecl::TK_FunctionTemplate:
538    FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record,
539                                                                      Idx));
540    break;
541  case FunctionDecl::TK_MemberSpecialization: {
542    FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>(Record, Idx);
543    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
544    SourceLocation POI = ReadSourceLocation(Record, Idx);
545    FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
546    FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
547    break;
548  }
549  case FunctionDecl::TK_FunctionTemplateSpecialization: {
550    FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record,
551                                                                      Idx);
552    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
553
554    // Template arguments.
555    SmallVector<TemplateArgument, 8> TemplArgs;
556    Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
557
558    // Template args as written.
559    SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
560    SourceLocation LAngleLoc, RAngleLoc;
561    bool HasTemplateArgumentsAsWritten = Record[Idx++];
562    if (HasTemplateArgumentsAsWritten) {
563      unsigned NumTemplateArgLocs = Record[Idx++];
564      TemplArgLocs.reserve(NumTemplateArgLocs);
565      for (unsigned i=0; i != NumTemplateArgLocs; ++i)
566        TemplArgLocs.push_back(
567            Reader.ReadTemplateArgumentLoc(F, Record, Idx));
568
569      LAngleLoc = ReadSourceLocation(Record, Idx);
570      RAngleLoc = ReadSourceLocation(Record, Idx);
571    }
572
573    SourceLocation POI = ReadSourceLocation(Record, Idx);
574
575    ASTContext &C = Reader.getContext();
576    TemplateArgumentList *TemplArgList
577      = TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
578    TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
579    for (unsigned i=0, e = TemplArgLocs.size(); i != e; ++i)
580      TemplArgsInfo.addArgument(TemplArgLocs[i]);
581    FunctionTemplateSpecializationInfo *FTInfo
582        = FunctionTemplateSpecializationInfo::Create(C, FD, Template, TSK,
583                                                     TemplArgList,
584                             HasTemplateArgumentsAsWritten ? &TemplArgsInfo : 0,
585                                                     POI);
586    FD->TemplateOrSpecialization = FTInfo;
587
588    if (FD->isCanonicalDecl()) { // if canonical add to template's set.
589      // The template that contains the specializations set. It's not safe to
590      // use getCanonicalDecl on Template since it may still be initializing.
591      FunctionTemplateDecl *CanonTemplate
592        = ReadDeclAs<FunctionTemplateDecl>(Record, Idx);
593      // Get the InsertPos by FindNodeOrInsertPos() instead of calling
594      // InsertNode(FTInfo) directly to avoid the getASTContext() call in
595      // FunctionTemplateSpecializationInfo's Profile().
596      // We avoid getASTContext because a decl in the parent hierarchy may
597      // be initializing.
598      llvm::FoldingSetNodeID ID;
599      FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs.data(),
600                                                  TemplArgs.size(), C);
601      void *InsertPos = 0;
602      CanonTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos);
603      if (InsertPos)
604        CanonTemplate->getSpecializations().InsertNode(FTInfo, InsertPos);
605      else
606        assert(0 && "Another specialization already inserted!");
607    }
608    break;
609  }
610  case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
611    // Templates.
612    UnresolvedSet<8> TemplDecls;
613    unsigned NumTemplates = Record[Idx++];
614    while (NumTemplates--)
615      TemplDecls.addDecl(ReadDeclAs<NamedDecl>(Record, Idx));
616
617    // Templates args.
618    TemplateArgumentListInfo TemplArgs;
619    unsigned NumArgs = Record[Idx++];
620    while (NumArgs--)
621      TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx));
622    TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx));
623    TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx));
624
625    FD->setDependentTemplateSpecialization(Reader.getContext(),
626                                           TemplDecls, TemplArgs);
627    break;
628  }
629  }
630
631  // Read in the parameters.
632  unsigned NumParams = Record[Idx++];
633  SmallVector<ParmVarDecl *, 16> Params;
634  Params.reserve(NumParams);
635  for (unsigned I = 0; I != NumParams; ++I)
636    Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
637  FD->setParams(Reader.getContext(), Params);
638}
639
640void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
641  VisitNamedDecl(MD);
642  if (Record[Idx++]) {
643    // Load the body on-demand. Most clients won't care, because method
644    // definitions rarely show up in headers.
645    Reader.PendingBodies[MD] = GetCurrentCursorOffset();
646    HasPendingBody = true;
647    MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
648    MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
649  }
650  MD->setInstanceMethod(Record[Idx++]);
651  MD->setVariadic(Record[Idx++]);
652  MD->setPropertyAccessor(Record[Idx++]);
653  MD->setDefined(Record[Idx++]);
654  MD->IsOverriding = Record[Idx++];
655
656  MD->IsRedeclaration = Record[Idx++];
657  MD->HasRedeclaration = Record[Idx++];
658  if (MD->HasRedeclaration)
659    Reader.getContext().setObjCMethodRedeclaration(MD,
660                                       ReadDeclAs<ObjCMethodDecl>(Record, Idx));
661
662  MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
663  MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
664  MD->SetRelatedResultType(Record[Idx++]);
665  MD->setResultType(Reader.readType(F, Record, Idx));
666  MD->setResultTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
667  MD->DeclEndLoc = ReadSourceLocation(Record, Idx);
668  unsigned NumParams = Record[Idx++];
669  SmallVector<ParmVarDecl *, 16> Params;
670  Params.reserve(NumParams);
671  for (unsigned I = 0; I != NumParams; ++I)
672    Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
673
674  MD->SelLocsKind = Record[Idx++];
675  unsigned NumStoredSelLocs = Record[Idx++];
676  SmallVector<SourceLocation, 16> SelLocs;
677  SelLocs.reserve(NumStoredSelLocs);
678  for (unsigned i = 0; i != NumStoredSelLocs; ++i)
679    SelLocs.push_back(ReadSourceLocation(Record, Idx));
680
681  MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
682}
683
684void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
685  VisitNamedDecl(CD);
686  CD->setAtStartLoc(ReadSourceLocation(Record, Idx));
687  CD->setAtEndRange(ReadSourceRange(Record, Idx));
688}
689
690void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
691  RedeclarableResult Redecl = VisitRedeclarable(ID);
692  VisitObjCContainerDecl(ID);
693  TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
694  mergeRedeclarable(ID, Redecl);
695
696  if (Record[Idx++]) {
697    // Read the definition.
698    ID->allocateDefinitionData();
699
700    // Set the definition data of the canonical declaration, so other
701    // redeclarations will see it.
702    ID->getCanonicalDecl()->Data = ID->Data;
703
704    ObjCInterfaceDecl::DefinitionData &Data = ID->data();
705
706    // Read the superclass.
707    Data.SuperClass = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
708    Data.SuperClassLoc = ReadSourceLocation(Record, Idx);
709
710    Data.EndLoc = ReadSourceLocation(Record, Idx);
711
712    // Read the directly referenced protocols and their SourceLocations.
713    unsigned NumProtocols = Record[Idx++];
714    SmallVector<ObjCProtocolDecl *, 16> Protocols;
715    Protocols.reserve(NumProtocols);
716    for (unsigned I = 0; I != NumProtocols; ++I)
717      Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
718    SmallVector<SourceLocation, 16> ProtoLocs;
719    ProtoLocs.reserve(NumProtocols);
720    for (unsigned I = 0; I != NumProtocols; ++I)
721      ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
722    ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
723                        Reader.getContext());
724
725    // Read the transitive closure of protocols referenced by this class.
726    NumProtocols = Record[Idx++];
727    Protocols.clear();
728    Protocols.reserve(NumProtocols);
729    for (unsigned I = 0; I != NumProtocols; ++I)
730      Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
731    ID->data().AllReferencedProtocols.set(Protocols.data(), NumProtocols,
732                                          Reader.getContext());
733
734    // We will rebuild this list lazily.
735    ID->setIvarList(0);
736
737    // Note that we have deserialized a definition.
738    Reader.PendingDefinitions.insert(ID);
739
740    // Note that we've loaded this Objective-C class.
741    Reader.ObjCClassesLoaded.push_back(ID);
742  } else {
743    ID->Data = ID->getCanonicalDecl()->Data;
744  }
745}
746
747void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
748  VisitFieldDecl(IVD);
749  IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
750  // This field will be built lazily.
751  IVD->setNextIvar(0);
752  bool synth = Record[Idx++];
753  IVD->setSynthesize(synth);
754}
755
756void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
757  RedeclarableResult Redecl = VisitRedeclarable(PD);
758  VisitObjCContainerDecl(PD);
759  mergeRedeclarable(PD, Redecl);
760
761  if (Record[Idx++]) {
762    // Read the definition.
763    PD->allocateDefinitionData();
764
765    // Set the definition data of the canonical declaration, so other
766    // redeclarations will see it.
767    PD->getCanonicalDecl()->Data = PD->Data;
768
769    unsigned NumProtoRefs = Record[Idx++];
770    SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
771    ProtoRefs.reserve(NumProtoRefs);
772    for (unsigned I = 0; I != NumProtoRefs; ++I)
773      ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
774    SmallVector<SourceLocation, 16> ProtoLocs;
775    ProtoLocs.reserve(NumProtoRefs);
776    for (unsigned I = 0; I != NumProtoRefs; ++I)
777      ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
778    PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
779                        Reader.getContext());
780
781    // Note that we have deserialized a definition.
782    Reader.PendingDefinitions.insert(PD);
783  } else {
784    PD->Data = PD->getCanonicalDecl()->Data;
785  }
786}
787
788void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
789  VisitFieldDecl(FD);
790}
791
792void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
793  VisitObjCContainerDecl(CD);
794  CD->setCategoryNameLoc(ReadSourceLocation(Record, Idx));
795  CD->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
796  CD->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
797
798  // Note that this category has been deserialized. We do this before
799  // deserializing the interface declaration, so that it will consider this
800  /// category.
801  Reader.CategoriesDeserialized.insert(CD);
802
803  CD->ClassInterface = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
804  unsigned NumProtoRefs = Record[Idx++];
805  SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
806  ProtoRefs.reserve(NumProtoRefs);
807  for (unsigned I = 0; I != NumProtoRefs; ++I)
808    ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
809  SmallVector<SourceLocation, 16> ProtoLocs;
810  ProtoLocs.reserve(NumProtoRefs);
811  for (unsigned I = 0; I != NumProtoRefs; ++I)
812    ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
813  CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
814                      Reader.getContext());
815}
816
817void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
818  VisitNamedDecl(CAD);
819  CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
820}
821
822void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
823  VisitNamedDecl(D);
824  D->setAtLoc(ReadSourceLocation(Record, Idx));
825  D->setLParenLoc(ReadSourceLocation(Record, Idx));
826  D->setType(GetTypeSourceInfo(Record, Idx));
827  // FIXME: stable encoding
828  D->setPropertyAttributes(
829                      (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
830  D->setPropertyAttributesAsWritten(
831                      (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
832  // FIXME: stable encoding
833  D->setPropertyImplementation(
834                            (ObjCPropertyDecl::PropertyControl)Record[Idx++]);
835  D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
836  D->setSetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
837  D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
838  D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
839  D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
840}
841
842void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
843  VisitObjCContainerDecl(D);
844  D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
845}
846
847void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
848  VisitObjCImplDecl(D);
849  D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx));
850  D->CategoryNameLoc = ReadSourceLocation(Record, Idx);
851}
852
853void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
854  VisitObjCImplDecl(D);
855  D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
856  D->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
857  D->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
858  D->setHasNonZeroConstructors(Record[Idx++]);
859  D->setHasDestructors(Record[Idx++]);
860  llvm::tie(D->IvarInitializers, D->NumIvarInitializers)
861      = Reader.ReadCXXCtorInitializers(F, Record, Idx);
862}
863
864
865void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
866  VisitDecl(D);
867  D->setAtLoc(ReadSourceLocation(Record, Idx));
868  D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>(Record, Idx));
869  D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>(Record, Idx);
870  D->IvarLoc = ReadSourceLocation(Record, Idx);
871  D->setGetterCXXConstructor(Reader.ReadExpr(F));
872  D->setSetterCXXAssignment(Reader.ReadExpr(F));
873}
874
875void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
876  VisitDeclaratorDecl(FD);
877  FD->Mutable = Record[Idx++];
878  if (int BitWidthOrInitializer = Record[Idx++]) {
879    FD->InitializerOrBitWidth.setInt(BitWidthOrInitializer - 1);
880    FD->InitializerOrBitWidth.setPointer(Reader.ReadExpr(F));
881  }
882  if (!FD->getDeclName()) {
883    if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx))
884      Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
885  }
886}
887
888void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
889  VisitValueDecl(FD);
890
891  FD->ChainingSize = Record[Idx++];
892  assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
893  FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
894
895  for (unsigned I = 0; I != FD->ChainingSize; ++I)
896    FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx);
897}
898
899void ASTDeclReader::VisitVarDecl(VarDecl *VD) {
900  RedeclarableResult Redecl = VisitRedeclarable(VD);
901  VisitDeclaratorDecl(VD);
902
903  VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
904  VD->VarDeclBits.SClassAsWritten = (StorageClass)Record[Idx++];
905  VD->VarDeclBits.ThreadSpecified = Record[Idx++];
906  VD->VarDeclBits.InitStyle = Record[Idx++];
907  VD->VarDeclBits.ExceptionVar = Record[Idx++];
908  VD->VarDeclBits.NRVOVariable = Record[Idx++];
909  VD->VarDeclBits.CXXForRangeDecl = Record[Idx++];
910  VD->VarDeclBits.ARCPseudoStrong = Record[Idx++];
911  VD->VarDeclBits.IsConstexpr = Record[Idx++];
912
913  // Only true variables (not parameters or implicit parameters) can be merged.
914  if (VD->getKind() == Decl::Var)
915    mergeRedeclarable(VD, Redecl);
916
917  if (uint64_t Val = Record[Idx++]) {
918    VD->setInit(Reader.ReadExpr(F));
919    if (Val > 1) {
920      EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
921      Eval->CheckedICE = true;
922      Eval->IsICE = Val == 3;
923    }
924  }
925
926  if (Record[Idx++]) { // HasMemberSpecializationInfo.
927    VarDecl *Tmpl = ReadDeclAs<VarDecl>(Record, Idx);
928    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
929    SourceLocation POI = ReadSourceLocation(Record, Idx);
930    Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
931  }
932}
933
934void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
935  VisitVarDecl(PD);
936}
937
938void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
939  VisitVarDecl(PD);
940  unsigned isObjCMethodParam = Record[Idx++];
941  unsigned scopeDepth = Record[Idx++];
942  unsigned scopeIndex = Record[Idx++];
943  unsigned declQualifier = Record[Idx++];
944  if (isObjCMethodParam) {
945    assert(scopeDepth == 0);
946    PD->setObjCMethodScopeInfo(scopeIndex);
947    PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
948  } else {
949    PD->setScopeInfo(scopeDepth, scopeIndex);
950  }
951  PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
952  PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
953  if (Record[Idx++]) // hasUninstantiatedDefaultArg.
954    PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
955}
956
957void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
958  VisitDecl(AD);
959  AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
960  AD->setRParenLoc(ReadSourceLocation(Record, Idx));
961}
962
963void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
964  VisitDecl(BD);
965  BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F)));
966  BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx));
967  unsigned NumParams = Record[Idx++];
968  SmallVector<ParmVarDecl *, 16> Params;
969  Params.reserve(NumParams);
970  for (unsigned I = 0; I != NumParams; ++I)
971    Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
972  BD->setParams(Params);
973
974  BD->setIsVariadic(Record[Idx++]);
975  BD->setBlockMissingReturnType(Record[Idx++]);
976  BD->setIsConversionFromLambda(Record[Idx++]);
977
978  bool capturesCXXThis = Record[Idx++];
979  unsigned numCaptures = Record[Idx++];
980  SmallVector<BlockDecl::Capture, 16> captures;
981  captures.reserve(numCaptures);
982  for (unsigned i = 0; i != numCaptures; ++i) {
983    VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx);
984    unsigned flags = Record[Idx++];
985    bool byRef = (flags & 1);
986    bool nested = (flags & 2);
987    Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : 0);
988
989    captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
990  }
991  BD->setCaptures(Reader.getContext(), captures.begin(),
992                  captures.end(), capturesCXXThis);
993}
994
995void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
996  VisitDecl(D);
997  D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
998  D->setExternLoc(ReadSourceLocation(Record, Idx));
999  D->setRBraceLoc(ReadSourceLocation(Record, Idx));
1000}
1001
1002void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
1003  VisitNamedDecl(D);
1004  D->setLocStart(ReadSourceLocation(Record, Idx));
1005}
1006
1007
1008void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
1009  RedeclarableResult Redecl = VisitRedeclarable(D);
1010  VisitNamedDecl(D);
1011  D->setInline(Record[Idx++]);
1012  D->LocStart = ReadSourceLocation(Record, Idx);
1013  D->RBraceLoc = ReadSourceLocation(Record, Idx);
1014  mergeRedeclarable(D, Redecl);
1015
1016  if (Redecl.getFirstID() == ThisDeclID) {
1017    // Each module has its own anonymous namespace, which is disjoint from
1018    // any other module's anonymous namespaces, so don't attach the anonymous
1019    // namespace at all.
1020    NamespaceDecl *Anon = ReadDeclAs<NamespaceDecl>(Record, Idx);
1021    if (F.Kind != MK_Module)
1022      D->setAnonymousNamespace(Anon);
1023  } else {
1024    // Link this namespace back to the first declaration, which has already
1025    // been deserialized.
1026    D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDeclaration());
1027  }
1028}
1029
1030void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1031  VisitNamedDecl(D);
1032  D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1033  D->IdentLoc = ReadSourceLocation(Record, Idx);
1034  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1035  D->Namespace = ReadDeclAs<NamedDecl>(Record, Idx);
1036}
1037
1038void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
1039  VisitNamedDecl(D);
1040  D->setUsingLocation(ReadSourceLocation(Record, Idx));
1041  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1042  ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1043  D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>(Record, Idx));
1044  D->setTypeName(Record[Idx++]);
1045  if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>(Record, Idx))
1046    Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
1047}
1048
1049void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
1050  VisitNamedDecl(D);
1051  D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx));
1052  D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx);
1053  UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx);
1054  if (Pattern)
1055    Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
1056}
1057
1058void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1059  VisitNamedDecl(D);
1060  D->UsingLoc = ReadSourceLocation(Record, Idx);
1061  D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1062  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1063  D->NominatedNamespace = ReadDeclAs<NamedDecl>(Record, Idx);
1064  D->CommonAncestor = ReadDeclAs<DeclContext>(Record, Idx);
1065}
1066
1067void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1068  VisitValueDecl(D);
1069  D->setUsingLoc(ReadSourceLocation(Record, Idx));
1070  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1071  ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1072}
1073
1074void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
1075                                               UnresolvedUsingTypenameDecl *D) {
1076  VisitTypeDecl(D);
1077  D->TypenameLocation = ReadSourceLocation(Record, Idx);
1078  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1079}
1080
1081void ASTDeclReader::ReadCXXDefinitionData(
1082                                   struct CXXRecordDecl::DefinitionData &Data,
1083                                   const RecordData &Record, unsigned &Idx) {
1084  // Note: the caller has deserialized the IsLambda bit already.
1085  Data.UserDeclaredConstructor = Record[Idx++];
1086  Data.UserDeclaredCopyConstructor = Record[Idx++];
1087  Data.UserDeclaredMoveConstructor = Record[Idx++];
1088  Data.UserDeclaredCopyAssignment = Record[Idx++];
1089  Data.UserDeclaredMoveAssignment = Record[Idx++];
1090  Data.UserDeclaredDestructor = Record[Idx++];
1091  Data.Aggregate = Record[Idx++];
1092  Data.PlainOldData = Record[Idx++];
1093  Data.Empty = Record[Idx++];
1094  Data.Polymorphic = Record[Idx++];
1095  Data.Abstract = Record[Idx++];
1096  Data.IsStandardLayout = Record[Idx++];
1097  Data.HasNoNonEmptyBases = Record[Idx++];
1098  Data.HasPrivateFields = Record[Idx++];
1099  Data.HasProtectedFields = Record[Idx++];
1100  Data.HasPublicFields = Record[Idx++];
1101  Data.HasMutableFields = Record[Idx++];
1102  Data.HasOnlyCMembers = Record[Idx++];
1103  Data.HasInClassInitializer = Record[Idx++];
1104  Data.HasTrivialDefaultConstructor = Record[Idx++];
1105  Data.HasConstexprNonCopyMoveConstructor = Record[Idx++];
1106  Data.DefaultedDefaultConstructorIsConstexpr = Record[Idx++];
1107  Data.HasConstexprDefaultConstructor = Record[Idx++];
1108  Data.HasTrivialCopyConstructor = Record[Idx++];
1109  Data.HasTrivialMoveConstructor = Record[Idx++];
1110  Data.HasTrivialCopyAssignment = Record[Idx++];
1111  Data.HasTrivialMoveAssignment = Record[Idx++];
1112  Data.HasTrivialDestructor = Record[Idx++];
1113  Data.HasIrrelevantDestructor = Record[Idx++];
1114  Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++];
1115  Data.ComputedVisibleConversions = Record[Idx++];
1116  Data.UserProvidedDefaultConstructor = Record[Idx++];
1117  Data.DeclaredDefaultConstructor = Record[Idx++];
1118  Data.DeclaredCopyConstructor = Record[Idx++];
1119  Data.DeclaredMoveConstructor = Record[Idx++];
1120  Data.DeclaredCopyAssignment = Record[Idx++];
1121  Data.DeclaredMoveAssignment = Record[Idx++];
1122  Data.DeclaredDestructor = Record[Idx++];
1123  Data.FailedImplicitMoveConstructor = Record[Idx++];
1124  Data.FailedImplicitMoveAssignment = Record[Idx++];
1125
1126  Data.NumBases = Record[Idx++];
1127  if (Data.NumBases)
1128    Data.Bases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1129  Data.NumVBases = Record[Idx++];
1130  if (Data.NumVBases)
1131    Data.VBases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1132
1133  Reader.ReadUnresolvedSet(F, Data.Conversions, Record, Idx);
1134  Reader.ReadUnresolvedSet(F, Data.VisibleConversions, Record, Idx);
1135  assert(Data.Definition && "Data.Definition should be already set!");
1136  Data.FirstFriend = ReadDeclAs<FriendDecl>(Record, Idx);
1137
1138  if (Data.IsLambda) {
1139    typedef LambdaExpr::Capture Capture;
1140    CXXRecordDecl::LambdaDefinitionData &Lambda
1141      = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
1142    Lambda.Dependent = Record[Idx++];
1143    Lambda.NumCaptures = Record[Idx++];
1144    Lambda.NumExplicitCaptures = Record[Idx++];
1145    Lambda.ManglingNumber = Record[Idx++];
1146    Lambda.ContextDecl = ReadDecl(Record, Idx);
1147    Lambda.Captures
1148      = (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures);
1149    Capture *ToCapture = Lambda.Captures;
1150    Lambda.MethodTyInfo = GetTypeSourceInfo(Record, Idx);
1151    for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
1152      SourceLocation Loc = ReadSourceLocation(Record, Idx);
1153      bool IsImplicit = Record[Idx++];
1154      LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]);
1155      VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
1156      SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
1157      *ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
1158    }
1159  }
1160}
1161
1162void ASTDeclReader::VisitCXXRecordDecl(CXXRecordDecl *D) {
1163  VisitRecordDecl(D);
1164
1165  ASTContext &C = Reader.getContext();
1166  if (Record[Idx++]) {
1167    // Determine whether this is a lambda closure type, so that we can
1168    // allocate the appropriate DefinitionData structure.
1169    bool IsLambda = Record[Idx++];
1170    if (IsLambda)
1171      D->DefinitionData = new (C) CXXRecordDecl::LambdaDefinitionData(D, 0,
1172                                                                      false);
1173    else
1174      D->DefinitionData = new (C) struct CXXRecordDecl::DefinitionData(D);
1175
1176    // Propagate the DefinitionData pointer to the canonical declaration, so
1177    // that all other deserialized declarations will see it.
1178    // FIXME: Complain if there already is a DefinitionData!
1179    D->getCanonicalDecl()->DefinitionData = D->DefinitionData;
1180
1181    ReadCXXDefinitionData(*D->DefinitionData, Record, Idx);
1182
1183    // Note that we have deserialized a definition. Any declarations
1184    // deserialized before this one will be be given the DefinitionData pointer
1185    // at the end.
1186    Reader.PendingDefinitions.insert(D);
1187  } else {
1188    // Propagate DefinitionData pointer from the canonical declaration.
1189    D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
1190  }
1191
1192  enum CXXRecKind {
1193    CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1194  };
1195  switch ((CXXRecKind)Record[Idx++]) {
1196  case CXXRecNotTemplate:
1197    break;
1198  case CXXRecTemplate:
1199    D->TemplateOrInstantiation = ReadDeclAs<ClassTemplateDecl>(Record, Idx);
1200    break;
1201  case CXXRecMemberSpecialization: {
1202    CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1203    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
1204    SourceLocation POI = ReadSourceLocation(Record, Idx);
1205    MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
1206    MSI->setPointOfInstantiation(POI);
1207    D->TemplateOrInstantiation = MSI;
1208    break;
1209  }
1210  }
1211
1212  // Load the key function to avoid deserializing every method so we can
1213  // compute it.
1214  if (D->IsCompleteDefinition) {
1215    if (CXXMethodDecl *Key = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1216      C.KeyFunctions[D] = Key;
1217  }
1218}
1219
1220void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
1221  VisitFunctionDecl(D);
1222  unsigned NumOverridenMethods = Record[Idx++];
1223  while (NumOverridenMethods--) {
1224    // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
1225    // MD may be initializing.
1226    if (CXXMethodDecl *MD = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1227      Reader.getContext().addOverriddenMethod(D, MD);
1228  }
1229}
1230
1231void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1232  VisitCXXMethodDecl(D);
1233
1234  D->IsExplicitSpecified = Record[Idx++];
1235  D->ImplicitlyDefined = Record[Idx++];
1236  llvm::tie(D->CtorInitializers, D->NumCtorInitializers)
1237      = Reader.ReadCXXCtorInitializers(F, Record, Idx);
1238}
1239
1240void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1241  VisitCXXMethodDecl(D);
1242
1243  D->ImplicitlyDefined = Record[Idx++];
1244  D->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1245}
1246
1247void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
1248  VisitCXXMethodDecl(D);
1249  D->IsExplicitSpecified = Record[Idx++];
1250}
1251
1252void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
1253  VisitDecl(D);
1254  D->ImportedAndComplete.setPointer(readModule(Record, Idx));
1255  D->ImportedAndComplete.setInt(Record[Idx++]);
1256  SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(D + 1);
1257  for (unsigned I = 0, N = Record.back(); I != N; ++I)
1258    StoredLocs[I] = ReadSourceLocation(Record, Idx);
1259  ++Idx; // The number of stored source locations.
1260}
1261
1262void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
1263  VisitDecl(D);
1264  D->setColonLoc(ReadSourceLocation(Record, Idx));
1265}
1266
1267void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
1268  VisitDecl(D);
1269  if (Record[Idx++])
1270    D->Friend = GetTypeSourceInfo(Record, Idx);
1271  else
1272    D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1273  D->NextFriend = Record[Idx++];
1274  D->UnsupportedFriend = (Record[Idx++] != 0);
1275  D->FriendLoc = ReadSourceLocation(Record, Idx);
1276}
1277
1278void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1279  VisitDecl(D);
1280  unsigned NumParams = Record[Idx++];
1281  D->NumParams = NumParams;
1282  D->Params = new TemplateParameterList*[NumParams];
1283  for (unsigned i = 0; i != NumParams; ++i)
1284    D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
1285  if (Record[Idx++]) // HasFriendDecl
1286    D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1287  else
1288    D->Friend = GetTypeSourceInfo(Record, Idx);
1289  D->FriendLoc = ReadSourceLocation(Record, Idx);
1290}
1291
1292void ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
1293  VisitNamedDecl(D);
1294
1295  NamedDecl *TemplatedDecl = ReadDeclAs<NamedDecl>(Record, Idx);
1296  TemplateParameterList* TemplateParams
1297      = Reader.ReadTemplateParameterList(F, Record, Idx);
1298  D->init(TemplatedDecl, TemplateParams);
1299}
1300
1301ASTDeclReader::RedeclarableResult
1302ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1303  RedeclarableResult Redecl = VisitRedeclarable(D);
1304
1305  // Make sure we've allocated the Common pointer first. We do this before
1306  // VisitTemplateDecl so that getCommonPtr() can be used during initialization.
1307  RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();
1308  if (!CanonD->Common) {
1309    CanonD->Common = CanonD->newCommon(Reader.getContext());
1310    Reader.PendingDefinitions.insert(CanonD);
1311  }
1312  D->Common = CanonD->Common;
1313
1314  // If this is the first declaration of the template, fill in the information
1315  // for the 'common' pointer.
1316  if (ThisDeclID == Redecl.getFirstID()) {
1317    if (RedeclarableTemplateDecl *RTD
1318          = ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx)) {
1319      assert(RTD->getKind() == D->getKind() &&
1320             "InstantiatedFromMemberTemplate kind mismatch");
1321      D->setInstantiatedFromMemberTemplate(RTD);
1322      if (Record[Idx++])
1323        D->setMemberSpecialization();
1324    }
1325  }
1326
1327  VisitTemplateDecl(D);
1328  D->IdentifierNamespace = Record[Idx++];
1329
1330  mergeRedeclarable(D, Redecl);
1331
1332  return Redecl;
1333}
1334
1335void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1336  RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1337
1338  if (ThisDeclID == Redecl.getFirstID()) {
1339    // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
1340    // the specializations.
1341    SmallVector<serialization::DeclID, 2> SpecIDs;
1342    SpecIDs.push_back(0);
1343
1344    // Specializations.
1345    unsigned Size = Record[Idx++];
1346    SpecIDs[0] += Size;
1347    for (unsigned I = 0; I != Size; ++I)
1348      SpecIDs.push_back(ReadDeclID(Record, Idx));
1349
1350    // Partial specializations.
1351    Size = Record[Idx++];
1352    SpecIDs[0] += Size;
1353    for (unsigned I = 0; I != Size; ++I)
1354      SpecIDs.push_back(ReadDeclID(Record, Idx));
1355
1356    ClassTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1357    if (SpecIDs[0]) {
1358      typedef serialization::DeclID DeclID;
1359
1360      // FIXME: Append specializations!
1361      CommonPtr->LazySpecializations
1362        = new (Reader.getContext()) DeclID [SpecIDs.size()];
1363      memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
1364             SpecIDs.size() * sizeof(DeclID));
1365    }
1366
1367    CommonPtr->InjectedClassNameType = Reader.readType(F, Record, Idx);
1368  }
1369}
1370
1371void ASTDeclReader::VisitClassTemplateSpecializationDecl(
1372                                           ClassTemplateSpecializationDecl *D) {
1373  VisitCXXRecordDecl(D);
1374
1375  ASTContext &C = Reader.getContext();
1376  if (Decl *InstD = ReadDecl(Record, Idx)) {
1377    if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
1378      D->SpecializedTemplate = CTD;
1379    } else {
1380      SmallVector<TemplateArgument, 8> TemplArgs;
1381      Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1382      TemplateArgumentList *ArgList
1383        = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1384                                           TemplArgs.size());
1385      ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
1386          = new (C) ClassTemplateSpecializationDecl::
1387                                             SpecializedPartialSpecialization();
1388      PS->PartialSpecialization
1389          = cast<ClassTemplatePartialSpecializationDecl>(InstD);
1390      PS->TemplateArgs = ArgList;
1391      D->SpecializedTemplate = PS;
1392    }
1393  }
1394
1395  // Explicit info.
1396  if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
1397    ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
1398        = new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
1399    ExplicitInfo->TypeAsWritten = TyInfo;
1400    ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
1401    ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
1402    D->ExplicitInfo = ExplicitInfo;
1403  }
1404
1405  SmallVector<TemplateArgument, 8> TemplArgs;
1406  Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1407  D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1408                                                     TemplArgs.size());
1409  D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
1410  D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
1411
1412  bool writtenAsCanonicalDecl = Record[Idx++];
1413  if (writtenAsCanonicalDecl) {
1414    ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx);
1415    if (D->isCanonicalDecl()) { // It's kept in the folding set.
1416      if (ClassTemplatePartialSpecializationDecl *Partial
1417                        = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
1418  CanonPattern->getCommonPtr()->PartialSpecializations.GetOrInsertNode(Partial);
1419      } else {
1420        CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
1421      }
1422    }
1423  }
1424}
1425
1426void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
1427                                    ClassTemplatePartialSpecializationDecl *D) {
1428  VisitClassTemplateSpecializationDecl(D);
1429
1430  ASTContext &C = Reader.getContext();
1431  D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
1432
1433  unsigned NumArgs = Record[Idx++];
1434  if (NumArgs) {
1435    D->NumArgsAsWritten = NumArgs;
1436    D->ArgsAsWritten = new (C) TemplateArgumentLoc[NumArgs];
1437    for (unsigned i=0; i != NumArgs; ++i)
1438      D->ArgsAsWritten[i] = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
1439  }
1440
1441  D->SequenceNumber = Record[Idx++];
1442
1443  // These are read/set from/to the first declaration.
1444  if (D->getPreviousDecl() == 0) {
1445    D->InstantiatedFromMember.setPointer(
1446      ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx));
1447    D->InstantiatedFromMember.setInt(Record[Idx++]);
1448  }
1449}
1450
1451void ASTDeclReader::VisitClassScopeFunctionSpecializationDecl(
1452                                    ClassScopeFunctionSpecializationDecl *D) {
1453  VisitDecl(D);
1454  D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx);
1455}
1456
1457void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1458  RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1459
1460  if (ThisDeclID == Redecl.getFirstID()) {
1461    // This FunctionTemplateDecl owns a CommonPtr; read it.
1462
1463    // Read the function specialization declarations.
1464    // FunctionTemplateDecl's FunctionTemplateSpecializationInfos are filled
1465    // when reading the specialized FunctionDecl.
1466    unsigned NumSpecs = Record[Idx++];
1467    while (NumSpecs--)
1468      (void)ReadDecl(Record, Idx);
1469  }
1470}
1471
1472void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1473  VisitTypeDecl(D);
1474
1475  D->setDeclaredWithTypename(Record[Idx++]);
1476
1477  bool Inherited = Record[Idx++];
1478  TypeSourceInfo *DefArg = GetTypeSourceInfo(Record, Idx);
1479  D->setDefaultArgument(DefArg, Inherited);
1480}
1481
1482void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1483  VisitDeclaratorDecl(D);
1484  // TemplateParmPosition.
1485  D->setDepth(Record[Idx++]);
1486  D->setPosition(Record[Idx++]);
1487  if (D->isExpandedParameterPack()) {
1488    void **Data = reinterpret_cast<void **>(D + 1);
1489    for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1490      Data[2*I] = Reader.readType(F, Record, Idx).getAsOpaquePtr();
1491      Data[2*I + 1] = GetTypeSourceInfo(Record, Idx);
1492    }
1493  } else {
1494    // Rest of NonTypeTemplateParmDecl.
1495    D->ParameterPack = Record[Idx++];
1496    if (Record[Idx++]) {
1497      Expr *DefArg = Reader.ReadExpr(F);
1498      bool Inherited = Record[Idx++];
1499      D->setDefaultArgument(DefArg, Inherited);
1500   }
1501  }
1502}
1503
1504void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1505  VisitTemplateDecl(D);
1506  // TemplateParmPosition.
1507  D->setDepth(Record[Idx++]);
1508  D->setPosition(Record[Idx++]);
1509  if (D->isExpandedParameterPack()) {
1510    void **Data = reinterpret_cast<void **>(D + 1);
1511    for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1512         I != N; ++I)
1513      Data[I] = Reader.ReadTemplateParameterList(F, Record, Idx);
1514  } else {
1515    // Rest of TemplateTemplateParmDecl.
1516    TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
1517    bool IsInherited = Record[Idx++];
1518    D->setDefaultArgument(Arg, IsInherited);
1519    D->ParameterPack = Record[Idx++];
1520  }
1521}
1522
1523void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1524  VisitRedeclarableTemplateDecl(D);
1525}
1526
1527void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
1528  VisitDecl(D);
1529  D->AssertExprAndFailed.setPointer(Reader.ReadExpr(F));
1530  D->AssertExprAndFailed.setInt(Record[Idx++]);
1531  D->Message = cast<StringLiteral>(Reader.ReadExpr(F));
1532  D->RParenLoc = ReadSourceLocation(Record, Idx);
1533}
1534
1535std::pair<uint64_t, uint64_t>
1536ASTDeclReader::VisitDeclContext(DeclContext *DC) {
1537  uint64_t LexicalOffset = Record[Idx++];
1538  uint64_t VisibleOffset = Record[Idx++];
1539  return std::make_pair(LexicalOffset, VisibleOffset);
1540}
1541
1542template <typename T>
1543ASTDeclReader::RedeclarableResult
1544ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
1545  DeclID FirstDeclID = ReadDeclID(Record, Idx);
1546
1547  // 0 indicates that this declaration was the only declaration of its entity,
1548  // and is used for space optimization.
1549  if (FirstDeclID == 0)
1550    FirstDeclID = ThisDeclID;
1551
1552  T *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
1553  if (FirstDecl != D) {
1554    // We delay loading of the redeclaration chain to avoid deeply nested calls.
1555    // We temporarily set the first (canonical) declaration as the previous one
1556    // which is the one that matters and mark the real previous DeclID to be
1557    // loaded & attached later on.
1558    D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
1559  }
1560
1561  // Note that this declaration has been deserialized.
1562  Reader.RedeclsDeserialized.insert(static_cast<T *>(D));
1563
1564  // The result structure takes care to note that we need to load the
1565  // other declaration chains for this ID.
1566  return RedeclarableResult(Reader, FirstDeclID);
1567}
1568
1569/// \brief Attempts to merge the given declaration (D) with another declaration
1570/// of the same entity.
1571template<typename T>
1572void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *D,
1573                                      RedeclarableResult &Redecl) {
1574  // If modules are not available, there is no reason to perform this merge.
1575  if (!Reader.getContext().getLangOpts().Modules)
1576    return;
1577
1578  if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D))) {
1579    if (T *Existing = ExistingRes) {
1580      T *ExistingCanon = Existing->getCanonicalDecl();
1581      T *DCanon = static_cast<T*>(D)->getCanonicalDecl();
1582      if (ExistingCanon != DCanon) {
1583        // Have our redeclaration link point back at the canonical declaration
1584        // of the existing declaration, so that this declaration has the
1585        // appropriate canonical declaration.
1586        D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
1587
1588        // When we merge a namespace, update its pointer to the first namespace.
1589        if (NamespaceDecl *Namespace
1590              = dyn_cast<NamespaceDecl>(static_cast<T*>(D))) {
1591          Namespace->AnonOrFirstNamespaceAndInline.setPointer(
1592            static_cast<NamespaceDecl *>(static_cast<void*>(ExistingCanon)));
1593        }
1594
1595        // Don't introduce DCanon into the set of pending declaration chains.
1596        Redecl.suppress();
1597
1598        // Introduce ExistingCanon into the set of pending declaration chains,
1599        // if in fact it came from a module file.
1600        if (ExistingCanon->isFromASTFile()) {
1601          GlobalDeclID ExistingCanonID = ExistingCanon->getGlobalID();
1602          assert(ExistingCanonID && "Unrecorded canonical declaration ID?");
1603          if (Reader.PendingDeclChainsKnown.insert(ExistingCanonID))
1604            Reader.PendingDeclChains.push_back(ExistingCanonID);
1605        }
1606
1607        // If this declaration was the canonical declaration, make a note of
1608        // that. We accept the linear algorithm here because the number of
1609        // unique canonical declarations of an entity should always be tiny.
1610        if (DCanon == static_cast<T*>(D)) {
1611          SmallVectorImpl<DeclID> &Merged = Reader.MergedDecls[ExistingCanon];
1612          if (std::find(Merged.begin(), Merged.end(), Redecl.getFirstID())
1613                == Merged.end())
1614            Merged.push_back(Redecl.getFirstID());
1615
1616          // If ExistingCanon did not come from a module file, introduce the
1617          // first declaration that *does* come from a module file to the
1618          // set of pending declaration chains, so that we merge this
1619          // declaration.
1620          if (!ExistingCanon->isFromASTFile() &&
1621              Reader.PendingDeclChainsKnown.insert(Redecl.getFirstID()))
1622            Reader.PendingDeclChains.push_back(Merged[0]);
1623        }
1624      }
1625    }
1626  }
1627}
1628
1629//===----------------------------------------------------------------------===//
1630// Attribute Reading
1631//===----------------------------------------------------------------------===//
1632
1633/// \brief Reads attributes from the current stream position.
1634void ASTReader::ReadAttributes(ModuleFile &F, AttrVec &Attrs,
1635                               const RecordData &Record, unsigned &Idx) {
1636  for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) {
1637    Attr *New = 0;
1638    attr::Kind Kind = (attr::Kind)Record[Idx++];
1639    SourceRange Range = ReadSourceRange(F, Record, Idx);
1640
1641#include "clang/Serialization/AttrPCHRead.inc"
1642
1643    assert(New && "Unable to decode attribute?");
1644    Attrs.push_back(New);
1645  }
1646}
1647
1648//===----------------------------------------------------------------------===//
1649// ASTReader Implementation
1650//===----------------------------------------------------------------------===//
1651
1652/// \brief Note that we have loaded the declaration with the given
1653/// Index.
1654///
1655/// This routine notes that this declaration has already been loaded,
1656/// so that future GetDecl calls will return this declaration rather
1657/// than trying to load a new declaration.
1658inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
1659  assert(!DeclsLoaded[Index] && "Decl loaded twice?");
1660  DeclsLoaded[Index] = D;
1661}
1662
1663
1664/// \brief Determine whether the consumer will be interested in seeing
1665/// this declaration (via HandleTopLevelDecl).
1666///
1667/// This routine should return true for anything that might affect
1668/// code generation, e.g., inline function definitions, Objective-C
1669/// declarations with metadata, etc.
1670static bool isConsumerInterestedIn(Decl *D, bool HasBody) {
1671  // An ObjCMethodDecl is never considered as "interesting" because its
1672  // implementation container always is.
1673
1674  if (isa<FileScopeAsmDecl>(D) ||
1675      isa<ObjCProtocolDecl>(D) ||
1676      isa<ObjCImplDecl>(D))
1677    return true;
1678  if (VarDecl *Var = dyn_cast<VarDecl>(D))
1679    return Var->isFileVarDecl() &&
1680           Var->isThisDeclarationADefinition() == VarDecl::Definition;
1681  if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
1682    return Func->doesThisDeclarationHaveABody() || HasBody;
1683
1684  return false;
1685}
1686
1687/// \brief Get the correct cursor and offset for loading a declaration.
1688ASTReader::RecordLocation
1689ASTReader::DeclCursorForID(DeclID ID, unsigned &RawLocation) {
1690  // See if there's an override.
1691  DeclReplacementMap::iterator It = ReplacedDecls.find(ID);
1692  if (It != ReplacedDecls.end()) {
1693    RawLocation = It->second.RawLoc;
1694    return RecordLocation(It->second.Mod, It->second.Offset);
1695  }
1696
1697  GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID);
1698  assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
1699  ModuleFile *M = I->second;
1700  const DeclOffset &
1701    DOffs =  M->DeclOffsets[ID - M->BaseDeclID - NUM_PREDEF_DECL_IDS];
1702  RawLocation = DOffs.Loc;
1703  return RecordLocation(M, DOffs.BitOffset);
1704}
1705
1706ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
1707  ContinuousRangeMap<uint64_t, ModuleFile*, 4>::iterator I
1708    = GlobalBitOffsetsMap.find(GlobalOffset);
1709
1710  assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
1711  return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
1712}
1713
1714uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint32_t LocalOffset) {
1715  return LocalOffset + M.GlobalBitOffset;
1716}
1717
1718/// \brief Determine whether the two declarations refer to the same entity.
1719static bool isSameEntity(NamedDecl *X, NamedDecl *Y) {
1720  assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!");
1721
1722  if (X == Y)
1723    return true;
1724
1725  // Must be in the same context.
1726  if (!X->getDeclContext()->getRedeclContext()->Equals(
1727         Y->getDeclContext()->getRedeclContext()))
1728    return false;
1729
1730  // Two typedefs refer to the same entity if they have the same underlying
1731  // type.
1732  if (TypedefNameDecl *TypedefX = dyn_cast<TypedefNameDecl>(X))
1733    if (TypedefNameDecl *TypedefY = dyn_cast<TypedefNameDecl>(Y))
1734      return X->getASTContext().hasSameType(TypedefX->getUnderlyingType(),
1735                                            TypedefY->getUnderlyingType());
1736
1737  // Must have the same kind.
1738  if (X->getKind() != Y->getKind())
1739    return false;
1740
1741  // Objective-C classes and protocols with the same name always match.
1742  if (isa<ObjCInterfaceDecl>(X) || isa<ObjCProtocolDecl>(X))
1743    return true;
1744
1745  // Compatible tags match.
1746  if (TagDecl *TagX = dyn_cast<TagDecl>(X)) {
1747    TagDecl *TagY = cast<TagDecl>(Y);
1748    return (TagX->getTagKind() == TagY->getTagKind()) ||
1749      ((TagX->getTagKind() == TTK_Struct || TagX->getTagKind() == TTK_Class ||
1750        TagX->getTagKind() == TTK_Interface) &&
1751       (TagY->getTagKind() == TTK_Struct || TagY->getTagKind() == TTK_Class ||
1752        TagY->getTagKind() == TTK_Interface));
1753  }
1754
1755  // Functions with the same type and linkage match.
1756  // FIXME: This needs to cope with function templates, merging of
1757  //prototyped/non-prototyped functions, etc.
1758  if (FunctionDecl *FuncX = dyn_cast<FunctionDecl>(X)) {
1759    FunctionDecl *FuncY = cast<FunctionDecl>(Y);
1760    return (FuncX->getLinkage() == FuncY->getLinkage()) &&
1761      FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType());
1762  }
1763
1764  // Variables with the same type and linkage match.
1765  if (VarDecl *VarX = dyn_cast<VarDecl>(X)) {
1766    VarDecl *VarY = cast<VarDecl>(Y);
1767    return (VarX->getLinkage() == VarY->getLinkage()) &&
1768      VarX->getASTContext().hasSameType(VarX->getType(), VarY->getType());
1769  }
1770
1771  // Namespaces with the same name and inlinedness match.
1772  if (NamespaceDecl *NamespaceX = dyn_cast<NamespaceDecl>(X)) {
1773    NamespaceDecl *NamespaceY = cast<NamespaceDecl>(Y);
1774    return NamespaceX->isInline() == NamespaceY->isInline();
1775  }
1776
1777  // Identical template names and kinds match.
1778  if (isa<TemplateDecl>(X))
1779    return true;
1780
1781  // FIXME: Many other cases to implement.
1782  return false;
1783}
1784
1785ASTDeclReader::FindExistingResult::~FindExistingResult() {
1786  if (!AddResult || Existing)
1787    return;
1788
1789  if (New->getDeclContext()->getRedeclContext()->isTranslationUnit()
1790      && Reader.SemaObj) {
1791    Reader.SemaObj->IdResolver.tryAddTopLevelDecl(New, New->getDeclName());
1792  } else {
1793    DeclContext *DC = New->getLexicalDeclContext();
1794    if (DC->isNamespace())
1795      DC->addDecl(New);
1796  }
1797}
1798
1799ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
1800  DeclarationName Name = D->getDeclName();
1801  if (!Name) {
1802    // Don't bother trying to find unnamed declarations.
1803    FindExistingResult Result(Reader, D, /*Existing=*/0);
1804    Result.suppress();
1805    return Result;
1806  }
1807
1808  DeclContext *DC = D->getDeclContext()->getRedeclContext();
1809  if (!DC->isFileContext())
1810    return FindExistingResult(Reader);
1811
1812  if (DC->isTranslationUnit() && Reader.SemaObj) {
1813    IdentifierResolver &IdResolver = Reader.SemaObj->IdResolver;
1814    for (IdentifierResolver::iterator I = IdResolver.begin(Name),
1815                                   IEnd = IdResolver.end();
1816         I != IEnd; ++I) {
1817      if (isSameEntity(*I, D))
1818        return FindExistingResult(Reader, D, *I);
1819    }
1820  }
1821
1822  if (DC->isNamespace()) {
1823    for (DeclContext::lookup_result R = DC->lookup(Name);
1824         R.first != R.second; ++R.first) {
1825      if (isSameEntity(*R.first, D))
1826        return FindExistingResult(Reader, D, *R.first);
1827    }
1828  }
1829
1830  return FindExistingResult(Reader, D, /*Existing=*/0);
1831}
1832
1833void ASTDeclReader::attachPreviousDecl(Decl *D, Decl *previous) {
1834  assert(D && previous);
1835  if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
1836    TD->RedeclLink.setNext(cast<TagDecl>(previous));
1837  } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1838    FD->RedeclLink.setNext(cast<FunctionDecl>(previous));
1839  } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
1840    VD->RedeclLink.setNext(cast<VarDecl>(previous));
1841  } else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
1842    TD->RedeclLink.setNext(cast<TypedefNameDecl>(previous));
1843  } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
1844    ID->RedeclLink.setNext(cast<ObjCInterfaceDecl>(previous));
1845  } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
1846    PD->RedeclLink.setNext(cast<ObjCProtocolDecl>(previous));
1847  } else if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D)) {
1848    ND->RedeclLink.setNext(cast<NamespaceDecl>(previous));
1849  } else {
1850    RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D);
1851    TD->RedeclLink.setNext(cast<RedeclarableTemplateDecl>(previous));
1852  }
1853}
1854
1855void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) {
1856  assert(D && Latest);
1857  if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
1858    TD->RedeclLink
1859      = Redeclarable<TagDecl>::LatestDeclLink(cast<TagDecl>(Latest));
1860  } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1861    FD->RedeclLink
1862      = Redeclarable<FunctionDecl>::LatestDeclLink(cast<FunctionDecl>(Latest));
1863  } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
1864    VD->RedeclLink
1865      = Redeclarable<VarDecl>::LatestDeclLink(cast<VarDecl>(Latest));
1866  } else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
1867    TD->RedeclLink
1868      = Redeclarable<TypedefNameDecl>::LatestDeclLink(
1869                                                cast<TypedefNameDecl>(Latest));
1870  } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
1871    ID->RedeclLink
1872      = Redeclarable<ObjCInterfaceDecl>::LatestDeclLink(
1873                                              cast<ObjCInterfaceDecl>(Latest));
1874  } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
1875    PD->RedeclLink
1876      = Redeclarable<ObjCProtocolDecl>::LatestDeclLink(
1877                                                cast<ObjCProtocolDecl>(Latest));
1878  } else if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D)) {
1879    ND->RedeclLink
1880      = Redeclarable<NamespaceDecl>::LatestDeclLink(
1881                                                   cast<NamespaceDecl>(Latest));
1882  } else {
1883    RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D);
1884    TD->RedeclLink
1885      = Redeclarable<RedeclarableTemplateDecl>::LatestDeclLink(
1886                                        cast<RedeclarableTemplateDecl>(Latest));
1887  }
1888}
1889
1890ASTReader::MergedDeclsMap::iterator
1891ASTReader::combineStoredMergedDecls(Decl *Canon, GlobalDeclID CanonID) {
1892  // If we don't have any stored merged declarations, just look in the
1893  // merged declarations set.
1894  StoredMergedDeclsMap::iterator StoredPos = StoredMergedDecls.find(CanonID);
1895  if (StoredPos == StoredMergedDecls.end())
1896    return MergedDecls.find(Canon);
1897
1898  // Append the stored merged declarations to the merged declarations set.
1899  MergedDeclsMap::iterator Pos = MergedDecls.find(Canon);
1900  if (Pos == MergedDecls.end())
1901    Pos = MergedDecls.insert(std::make_pair(Canon,
1902                                            SmallVector<DeclID, 2>())).first;
1903  Pos->second.append(StoredPos->second.begin(), StoredPos->second.end());
1904  StoredMergedDecls.erase(StoredPos);
1905
1906  // Sort and uniquify the set of merged declarations.
1907  llvm::array_pod_sort(Pos->second.begin(), Pos->second.end());
1908  Pos->second.erase(std::unique(Pos->second.begin(), Pos->second.end()),
1909                    Pos->second.end());
1910  return Pos;
1911}
1912
1913void ASTReader::loadAndAttachPreviousDecl(Decl *D, serialization::DeclID ID) {
1914  Decl *previous = GetDecl(ID);
1915  ASTDeclReader::attachPreviousDecl(D, previous);
1916}
1917
1918/// \brief Read the declaration at the given offset from the AST file.
1919Decl *ASTReader::ReadDeclRecord(DeclID ID) {
1920  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
1921  unsigned RawLocation = 0;
1922  RecordLocation Loc = DeclCursorForID(ID, RawLocation);
1923  llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
1924  // Keep track of where we are in the stream, then jump back there
1925  // after reading this declaration.
1926  SavedStreamPosition SavedPosition(DeclsCursor);
1927
1928  ReadingKindTracker ReadingKind(Read_Decl, *this);
1929
1930  // Note that we are loading a declaration record.
1931  Deserializing ADecl(this);
1932
1933  DeclsCursor.JumpToBit(Loc.Offset);
1934  RecordData Record;
1935  unsigned Code = DeclsCursor.ReadCode();
1936  unsigned Idx = 0;
1937  ASTDeclReader Reader(*this, *Loc.F, ID, RawLocation, Record,Idx);
1938
1939  Decl *D = 0;
1940  switch ((DeclCode)DeclsCursor.ReadRecord(Code, Record)) {
1941  case DECL_CONTEXT_LEXICAL:
1942  case DECL_CONTEXT_VISIBLE:
1943    llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
1944  case DECL_TYPEDEF:
1945    D = TypedefDecl::CreateDeserialized(Context, ID);
1946    break;
1947  case DECL_TYPEALIAS:
1948    D = TypeAliasDecl::CreateDeserialized(Context, ID);
1949    break;
1950  case DECL_ENUM:
1951    D = EnumDecl::CreateDeserialized(Context, ID);
1952    break;
1953  case DECL_RECORD:
1954    D = RecordDecl::CreateDeserialized(Context, ID);
1955    break;
1956  case DECL_ENUM_CONSTANT:
1957    D = EnumConstantDecl::CreateDeserialized(Context, ID);
1958    break;
1959  case DECL_FUNCTION:
1960    D = FunctionDecl::CreateDeserialized(Context, ID);
1961    break;
1962  case DECL_LINKAGE_SPEC:
1963    D = LinkageSpecDecl::CreateDeserialized(Context, ID);
1964    break;
1965  case DECL_LABEL:
1966    D = LabelDecl::CreateDeserialized(Context, ID);
1967    break;
1968  case DECL_NAMESPACE:
1969    D = NamespaceDecl::CreateDeserialized(Context, ID);
1970    break;
1971  case DECL_NAMESPACE_ALIAS:
1972    D = NamespaceAliasDecl::CreateDeserialized(Context, ID);
1973    break;
1974  case DECL_USING:
1975    D = UsingDecl::CreateDeserialized(Context, ID);
1976    break;
1977  case DECL_USING_SHADOW:
1978    D = UsingShadowDecl::CreateDeserialized(Context, ID);
1979    break;
1980  case DECL_USING_DIRECTIVE:
1981    D = UsingDirectiveDecl::CreateDeserialized(Context, ID);
1982    break;
1983  case DECL_UNRESOLVED_USING_VALUE:
1984    D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);
1985    break;
1986  case DECL_UNRESOLVED_USING_TYPENAME:
1987    D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);
1988    break;
1989  case DECL_CXX_RECORD:
1990    D = CXXRecordDecl::CreateDeserialized(Context, ID);
1991    break;
1992  case DECL_CXX_METHOD:
1993    D = CXXMethodDecl::CreateDeserialized(Context, ID);
1994    break;
1995  case DECL_CXX_CONSTRUCTOR:
1996    D = CXXConstructorDecl::CreateDeserialized(Context, ID);
1997    break;
1998  case DECL_CXX_DESTRUCTOR:
1999    D = CXXDestructorDecl::CreateDeserialized(Context, ID);
2000    break;
2001  case DECL_CXX_CONVERSION:
2002    D = CXXConversionDecl::CreateDeserialized(Context, ID);
2003    break;
2004  case DECL_ACCESS_SPEC:
2005    D = AccessSpecDecl::CreateDeserialized(Context, ID);
2006    break;
2007  case DECL_FRIEND:
2008    D = FriendDecl::CreateDeserialized(Context, ID);
2009    break;
2010  case DECL_FRIEND_TEMPLATE:
2011    D = FriendTemplateDecl::CreateDeserialized(Context, ID);
2012    break;
2013  case DECL_CLASS_TEMPLATE:
2014    D = ClassTemplateDecl::CreateDeserialized(Context, ID);
2015    break;
2016  case DECL_CLASS_TEMPLATE_SPECIALIZATION:
2017    D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID);
2018    break;
2019  case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
2020    D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
2021    break;
2022  case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
2023    D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
2024    break;
2025  case DECL_FUNCTION_TEMPLATE:
2026    D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
2027    break;
2028  case DECL_TEMPLATE_TYPE_PARM:
2029    D = TemplateTypeParmDecl::CreateDeserialized(Context, ID);
2030    break;
2031  case DECL_NON_TYPE_TEMPLATE_PARM:
2032    D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
2033    break;
2034  case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
2035    D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]);
2036    break;
2037  case DECL_TEMPLATE_TEMPLATE_PARM:
2038    D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
2039    break;
2040  case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:
2041    D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,
2042                                                     Record[Idx++]);
2043    break;
2044  case DECL_TYPE_ALIAS_TEMPLATE:
2045    D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
2046    break;
2047  case DECL_STATIC_ASSERT:
2048    D = StaticAssertDecl::CreateDeserialized(Context, ID);
2049    break;
2050  case DECL_OBJC_METHOD:
2051    D = ObjCMethodDecl::CreateDeserialized(Context, ID);
2052    break;
2053  case DECL_OBJC_INTERFACE:
2054    D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);
2055    break;
2056  case DECL_OBJC_IVAR:
2057    D = ObjCIvarDecl::CreateDeserialized(Context, ID);
2058    break;
2059  case DECL_OBJC_PROTOCOL:
2060    D = ObjCProtocolDecl::CreateDeserialized(Context, ID);
2061    break;
2062  case DECL_OBJC_AT_DEFS_FIELD:
2063    D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID);
2064    break;
2065  case DECL_OBJC_CATEGORY:
2066    D = ObjCCategoryDecl::CreateDeserialized(Context, ID);
2067    break;
2068  case DECL_OBJC_CATEGORY_IMPL:
2069    D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID);
2070    break;
2071  case DECL_OBJC_IMPLEMENTATION:
2072    D = ObjCImplementationDecl::CreateDeserialized(Context, ID);
2073    break;
2074  case DECL_OBJC_COMPATIBLE_ALIAS:
2075    D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID);
2076    break;
2077  case DECL_OBJC_PROPERTY:
2078    D = ObjCPropertyDecl::CreateDeserialized(Context, ID);
2079    break;
2080  case DECL_OBJC_PROPERTY_IMPL:
2081    D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID);
2082    break;
2083  case DECL_FIELD:
2084    D = FieldDecl::CreateDeserialized(Context, ID);
2085    break;
2086  case DECL_INDIRECTFIELD:
2087    D = IndirectFieldDecl::CreateDeserialized(Context, ID);
2088    break;
2089  case DECL_VAR:
2090    D = VarDecl::CreateDeserialized(Context, ID);
2091    break;
2092  case DECL_IMPLICIT_PARAM:
2093    D = ImplicitParamDecl::CreateDeserialized(Context, ID);
2094    break;
2095  case DECL_PARM_VAR:
2096    D = ParmVarDecl::CreateDeserialized(Context, ID);
2097    break;
2098  case DECL_FILE_SCOPE_ASM:
2099    D = FileScopeAsmDecl::CreateDeserialized(Context, ID);
2100    break;
2101  case DECL_BLOCK:
2102    D = BlockDecl::CreateDeserialized(Context, ID);
2103    break;
2104  case DECL_CXX_BASE_SPECIFIERS:
2105    Error("attempt to read a C++ base-specifier record as a declaration");
2106    return 0;
2107  case DECL_IMPORT:
2108    // Note: last entry of the ImportDecl record is the number of stored source
2109    // locations.
2110    D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
2111    break;
2112  }
2113
2114  assert(D && "Unknown declaration reading AST file");
2115  LoadedDecl(Index, D);
2116  // Set the DeclContext before doing any deserialization, to make sure internal
2117  // calls to Decl::getASTContext() by Decl's methods will find the
2118  // TranslationUnitDecl without crashing.
2119  D->setDeclContext(Context.getTranslationUnitDecl());
2120  Reader.Visit(D);
2121
2122  // If this declaration is also a declaration context, get the
2123  // offsets for its tables of lexical and visible declarations.
2124  if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
2125    std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
2126    if (Offsets.first || Offsets.second) {
2127      if (Offsets.first != 0)
2128        DC->setHasExternalLexicalStorage(true);
2129      if (Offsets.second != 0)
2130        DC->setHasExternalVisibleStorage(true);
2131      if (ReadDeclContextStorage(*Loc.F, DeclsCursor, Offsets,
2132                                 Loc.F->DeclContextInfos[DC]))
2133        return 0;
2134    }
2135
2136    // Now add the pending visible updates for this decl context, if it has any.
2137    DeclContextVisibleUpdatesPending::iterator I =
2138        PendingVisibleUpdates.find(ID);
2139    if (I != PendingVisibleUpdates.end()) {
2140      // There are updates. This means the context has external visible
2141      // storage, even if the original stored version didn't.
2142      DC->setHasExternalVisibleStorage(true);
2143      DeclContextVisibleUpdates &U = I->second;
2144      for (DeclContextVisibleUpdates::iterator UI = U.begin(), UE = U.end();
2145           UI != UE; ++UI) {
2146        DeclContextInfo &Info = UI->second->DeclContextInfos[DC];
2147        delete Info.NameLookupTableData;
2148        Info.NameLookupTableData = UI->first;
2149      }
2150      PendingVisibleUpdates.erase(I);
2151    }
2152
2153    if (!DC->hasExternalVisibleStorage() && DC->hasExternalLexicalStorage())
2154      DC->setMustBuildLookupTable();
2155  }
2156  assert(Idx == Record.size());
2157
2158  // Load any relevant update records.
2159  loadDeclUpdateRecords(ID, D);
2160
2161  // Load the categories after recursive loading is finished.
2162  if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D))
2163    if (Class->isThisDeclarationADefinition())
2164      loadObjCCategories(ID, Class);
2165
2166  // If we have deserialized a declaration that has a definition the
2167  // AST consumer might need to know about, queue it.
2168  // We don't pass it to the consumer immediately because we may be in recursive
2169  // loading, and some declarations may still be initializing.
2170  if (isConsumerInterestedIn(D, Reader.hasPendingBody()))
2171    InterestingDecls.push_back(D);
2172
2173  return D;
2174}
2175
2176void ASTReader::loadDeclUpdateRecords(serialization::DeclID ID, Decl *D) {
2177  // The declaration may have been modified by files later in the chain.
2178  // If this is the case, read the record containing the updates from each file
2179  // and pass it to ASTDeclReader to make the modifications.
2180  DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
2181  if (UpdI != DeclUpdateOffsets.end()) {
2182    FileOffsetsTy &UpdateOffsets = UpdI->second;
2183    for (FileOffsetsTy::iterator
2184         I = UpdateOffsets.begin(), E = UpdateOffsets.end(); I != E; ++I) {
2185      ModuleFile *F = I->first;
2186      uint64_t Offset = I->second;
2187      llvm::BitstreamCursor &Cursor = F->DeclsCursor;
2188      SavedStreamPosition SavedPosition(Cursor);
2189      Cursor.JumpToBit(Offset);
2190      RecordData Record;
2191      unsigned Code = Cursor.ReadCode();
2192      unsigned RecCode = Cursor.ReadRecord(Code, Record);
2193      (void)RecCode;
2194      assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
2195
2196      unsigned Idx = 0;
2197      ASTDeclReader Reader(*this, *F, ID, 0, Record, Idx);
2198      Reader.UpdateDecl(D, *F, Record);
2199    }
2200  }
2201}
2202
2203namespace {
2204  struct CompareLocalRedeclarationsInfoToID {
2205    bool operator()(const LocalRedeclarationsInfo &X, DeclID Y) {
2206      return X.FirstID < Y;
2207    }
2208
2209    bool operator()(DeclID X, const LocalRedeclarationsInfo &Y) {
2210      return X < Y.FirstID;
2211    }
2212
2213    bool operator()(const LocalRedeclarationsInfo &X,
2214                    const LocalRedeclarationsInfo &Y) {
2215      return X.FirstID < Y.FirstID;
2216    }
2217    bool operator()(DeclID X, DeclID Y) {
2218      return X < Y;
2219    }
2220  };
2221
2222  /// \brief Module visitor class that finds all of the redeclarations of a
2223  ///
2224  class RedeclChainVisitor {
2225    ASTReader &Reader;
2226    SmallVectorImpl<DeclID> &SearchDecls;
2227    llvm::SmallPtrSet<Decl *, 16> &Deserialized;
2228    GlobalDeclID CanonID;
2229    llvm::SmallVector<Decl *, 4> Chain;
2230
2231  public:
2232    RedeclChainVisitor(ASTReader &Reader, SmallVectorImpl<DeclID> &SearchDecls,
2233                       llvm::SmallPtrSet<Decl *, 16> &Deserialized,
2234                       GlobalDeclID CanonID)
2235      : Reader(Reader), SearchDecls(SearchDecls), Deserialized(Deserialized),
2236        CanonID(CanonID) {
2237      for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
2238        addToChain(Reader.GetDecl(SearchDecls[I]));
2239    }
2240
2241    static bool visit(ModuleFile &M, bool Preorder, void *UserData) {
2242      if (Preorder)
2243        return false;
2244
2245      return static_cast<RedeclChainVisitor *>(UserData)->visit(M);
2246    }
2247
2248    void addToChain(Decl *D) {
2249      if (!D)
2250        return;
2251
2252      if (Deserialized.erase(D))
2253        Chain.push_back(D);
2254    }
2255
2256    void searchForID(ModuleFile &M, GlobalDeclID GlobalID) {
2257      // Map global ID of the first declaration down to the local ID
2258      // used in this module file.
2259      DeclID ID = Reader.mapGlobalIDToModuleFileGlobalID(M, GlobalID);
2260      if (!ID)
2261        return;
2262
2263      // Perform a binary search to find the local redeclarations for this
2264      // declaration (if any).
2265      const LocalRedeclarationsInfo *Result
2266        = std::lower_bound(M.RedeclarationsMap,
2267                           M.RedeclarationsMap + M.LocalNumRedeclarationsInMap,
2268                           ID, CompareLocalRedeclarationsInfoToID());
2269      if (Result == M.RedeclarationsMap + M.LocalNumRedeclarationsInMap ||
2270          Result->FirstID != ID) {
2271        // If we have a previously-canonical singleton declaration that was
2272        // merged into another redeclaration chain, create a trivial chain
2273        // for this single declaration so that it will get wired into the
2274        // complete redeclaration chain.
2275        if (GlobalID != CanonID &&
2276            GlobalID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
2277            GlobalID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls) {
2278          addToChain(Reader.GetDecl(GlobalID));
2279        }
2280
2281        return;
2282      }
2283
2284      // Dig out all of the redeclarations.
2285      unsigned Offset = Result->Offset;
2286      unsigned N = M.RedeclarationChains[Offset];
2287      M.RedeclarationChains[Offset++] = 0; // Don't try to deserialize again
2288      for (unsigned I = 0; I != N; ++I)
2289        addToChain(Reader.GetLocalDecl(M, M.RedeclarationChains[Offset++]));
2290    }
2291
2292    bool visit(ModuleFile &M) {
2293      // Visit each of the declarations.
2294      for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
2295        searchForID(M, SearchDecls[I]);
2296      return false;
2297    }
2298
2299    ArrayRef<Decl *> getChain() const {
2300      return Chain;
2301    }
2302  };
2303}
2304
2305void ASTReader::loadPendingDeclChain(serialization::GlobalDeclID ID) {
2306  Decl *D = GetDecl(ID);
2307  Decl *CanonDecl = D->getCanonicalDecl();
2308
2309  // Determine the set of declaration IDs we'll be searching for.
2310  llvm::SmallVector<DeclID, 1> SearchDecls;
2311  GlobalDeclID CanonID = 0;
2312  if (D == CanonDecl) {
2313    SearchDecls.push_back(ID); // Always first.
2314    CanonID = ID;
2315  }
2316  MergedDeclsMap::iterator MergedPos = combineStoredMergedDecls(CanonDecl, ID);
2317  if (MergedPos != MergedDecls.end())
2318    SearchDecls.append(MergedPos->second.begin(), MergedPos->second.end());
2319
2320  // Build up the list of redeclarations.
2321  RedeclChainVisitor Visitor(*this, SearchDecls, RedeclsDeserialized, CanonID);
2322  ModuleMgr.visitDepthFirst(&RedeclChainVisitor::visit, &Visitor);
2323
2324  // Retrieve the chains.
2325  ArrayRef<Decl *> Chain = Visitor.getChain();
2326  if (Chain.empty())
2327    return;
2328
2329  // Hook up the chains.
2330  Decl *MostRecent = CanonDecl->getMostRecentDecl();
2331  for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
2332    if (Chain[I] == CanonDecl)
2333      continue;
2334
2335    ASTDeclReader::attachPreviousDecl(Chain[I], MostRecent);
2336    MostRecent = Chain[I];
2337  }
2338
2339  ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);
2340}
2341
2342namespace {
2343  struct CompareObjCCategoriesInfo {
2344    bool operator()(const ObjCCategoriesInfo &X, DeclID Y) {
2345      return X.DefinitionID < Y;
2346    }
2347
2348    bool operator()(DeclID X, const ObjCCategoriesInfo &Y) {
2349      return X < Y.DefinitionID;
2350    }
2351
2352    bool operator()(const ObjCCategoriesInfo &X,
2353                    const ObjCCategoriesInfo &Y) {
2354      return X.DefinitionID < Y.DefinitionID;
2355    }
2356    bool operator()(DeclID X, DeclID Y) {
2357      return X < Y;
2358    }
2359  };
2360
2361  /// \brief Given an ObjC interface, goes through the modules and links to the
2362  /// interface all the categories for it.
2363  class ObjCCategoriesVisitor {
2364    ASTReader &Reader;
2365    serialization::GlobalDeclID InterfaceID;
2366    ObjCInterfaceDecl *Interface;
2367    llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized;
2368    unsigned PreviousGeneration;
2369    ObjCCategoryDecl *Tail;
2370    llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
2371
2372    void add(ObjCCategoryDecl *Cat) {
2373      // Only process each category once.
2374      if (!Deserialized.erase(Cat))
2375        return;
2376
2377      // Check for duplicate categories.
2378      if (Cat->getDeclName()) {
2379        ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
2380        if (Existing &&
2381            Reader.getOwningModuleFile(Existing)
2382                                          != Reader.getOwningModuleFile(Cat)) {
2383          // FIXME: We should not warn for duplicates in diamond:
2384          //
2385          //   MT     //
2386          //  /  \    //
2387          // ML  MR   //
2388          //  \  /    //
2389          //   MB     //
2390          //
2391          // If there are duplicates in ML/MR, there will be warning when
2392          // creating MB *and* when importing MB. We should not warn when
2393          // importing.
2394          Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
2395            << Interface->getDeclName() << Cat->getDeclName();
2396          Reader.Diag(Existing->getLocation(), diag::note_previous_definition);
2397        } else if (!Existing) {
2398          // Record this category.
2399          Existing = Cat;
2400        }
2401      }
2402
2403      // Add this category to the end of the chain.
2404      if (Tail)
2405        ASTDeclReader::setNextObjCCategory(Tail, Cat);
2406      else
2407        Interface->setCategoryList(Cat);
2408      Tail = Cat;
2409    }
2410
2411  public:
2412    ObjCCategoriesVisitor(ASTReader &Reader,
2413                          serialization::GlobalDeclID InterfaceID,
2414                          ObjCInterfaceDecl *Interface,
2415                        llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized,
2416                          unsigned PreviousGeneration)
2417      : Reader(Reader), InterfaceID(InterfaceID), Interface(Interface),
2418        Deserialized(Deserialized), PreviousGeneration(PreviousGeneration),
2419        Tail(0)
2420    {
2421      // Populate the name -> category map with the set of known categories.
2422      for (ObjCCategoryDecl *Cat = Interface->getCategoryList(); Cat;
2423           Cat = Cat->getNextClassCategory()) {
2424        if (Cat->getDeclName())
2425          NameCategoryMap[Cat->getDeclName()] = Cat;
2426
2427        // Keep track of the tail of the category list.
2428        Tail = Cat;
2429      }
2430    }
2431
2432    static bool visit(ModuleFile &M, void *UserData) {
2433      return static_cast<ObjCCategoriesVisitor *>(UserData)->visit(M);
2434    }
2435
2436    bool visit(ModuleFile &M) {
2437      // If we've loaded all of the category information we care about from
2438      // this module file, we're done.
2439      if (M.Generation <= PreviousGeneration)
2440        return true;
2441
2442      // Map global ID of the definition down to the local ID used in this
2443      // module file. If there is no such mapping, we'll find nothing here
2444      // (or in any module it imports).
2445      DeclID LocalID = Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);
2446      if (!LocalID)
2447        return true;
2448
2449      // Perform a binary search to find the local redeclarations for this
2450      // declaration (if any).
2451      const ObjCCategoriesInfo *Result
2452        = std::lower_bound(M.ObjCCategoriesMap,
2453                           M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap,
2454                           LocalID, CompareObjCCategoriesInfo());
2455      if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
2456          Result->DefinitionID != LocalID) {
2457        // We didn't find anything. If the class definition is in this module
2458        // file, then the module files it depends on cannot have any categories,
2459        // so suppress further lookup.
2460        return Reader.isDeclIDFromModule(InterfaceID, M);
2461      }
2462
2463      // We found something. Dig out all of the categories.
2464      unsigned Offset = Result->Offset;
2465      unsigned N = M.ObjCCategories[Offset];
2466      M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
2467      for (unsigned I = 0; I != N; ++I)
2468        add(cast_or_null<ObjCCategoryDecl>(
2469              Reader.GetLocalDecl(M, M.ObjCCategories[Offset++])));
2470      return true;
2471    }
2472  };
2473}
2474
2475void ASTReader::loadObjCCategories(serialization::GlobalDeclID ID,
2476                                   ObjCInterfaceDecl *D,
2477                                   unsigned PreviousGeneration) {
2478  ObjCCategoriesVisitor Visitor(*this, ID, D, CategoriesDeserialized,
2479                                PreviousGeneration);
2480  ModuleMgr.visit(ObjCCategoriesVisitor::visit, &Visitor);
2481}
2482
2483void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile,
2484                               const RecordData &Record) {
2485  unsigned Idx = 0;
2486  while (Idx < Record.size()) {
2487    switch ((DeclUpdateKind)Record[Idx++]) {
2488    case UPD_CXX_ADDED_IMPLICIT_MEMBER:
2489      cast<CXXRecordDecl>(D)->addedMember(Reader.ReadDecl(ModuleFile, Record, Idx));
2490      break;
2491
2492    case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
2493      // It will be added to the template's specializations set when loaded.
2494      (void)Reader.ReadDecl(ModuleFile, Record, Idx);
2495      break;
2496
2497    case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
2498      NamespaceDecl *Anon
2499        = Reader.ReadDeclAs<NamespaceDecl>(ModuleFile, Record, Idx);
2500
2501      // Each module has its own anonymous namespace, which is disjoint from
2502      // any other module's anonymous namespaces, so don't attach the anonymous
2503      // namespace at all.
2504      if (ModuleFile.Kind != MK_Module) {
2505        if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D))
2506          TU->setAnonymousNamespace(Anon);
2507        else
2508          cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
2509      }
2510      break;
2511    }
2512
2513    case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
2514      cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation(
2515          Reader.ReadSourceLocation(ModuleFile, Record, Idx));
2516      break;
2517    }
2518  }
2519}
2520