ASTReader.cpp revision 7d5e81bf24dbfd334a7c62a7ae51043c79a69aa9 
1//===--- ASTReader.cpp - AST File Reader ------------------------*- 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 defines the ASTReader class, which reads AST files.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Serialization/ASTReader.h"
15#include "clang/Serialization/ASTDeserializationListener.h"
16#include "clang/Serialization/ModuleManager.h"
17#include "ASTCommon.h"
18#include "ASTReaderInternals.h"
19#include "clang/Frontend/FrontendDiagnostic.h"
20#include "clang/Frontend/Utils.h"
21#include "clang/Sema/Sema.h"
22#include "clang/Sema/Scope.h"
23#include "clang/AST/ASTConsumer.h"
24#include "clang/AST/ASTContext.h"
25#include "clang/AST/DeclTemplate.h"
26#include "clang/AST/Expr.h"
27#include "clang/AST/ExprCXX.h"
28#include "clang/AST/NestedNameSpecifier.h"
29#include "clang/AST/Type.h"
30#include "clang/AST/TypeLocVisitor.h"
31#include "clang/Lex/MacroInfo.h"
32#include "clang/Lex/PreprocessingRecord.h"
33#include "clang/Lex/Preprocessor.h"
34#include "clang/Lex/HeaderSearch.h"
35#include "clang/Basic/OnDiskHashTable.h"
36#include "clang/Basic/SourceManager.h"
37#include "clang/Basic/SourceManagerInternals.h"
38#include "clang/Basic/FileManager.h"
39#include "clang/Basic/FileSystemStatCache.h"
40#include "clang/Basic/TargetInfo.h"
41#include "clang/Basic/Version.h"
42#include "clang/Basic/VersionTuple.h"
43#include "llvm/ADT/StringExtras.h"
44#include "llvm/Bitcode/BitstreamReader.h"
45#include "llvm/Support/MemoryBuffer.h"
46#include "llvm/Support/ErrorHandling.h"
47#include "llvm/Support/FileSystem.h"
48#include "llvm/Support/Path.h"
49#include "llvm/Support/system_error.h"
50#include <algorithm>
51#include <iterator>
52#include <cstdio>
53#include <sys/stat.h>
54
55using namespace clang;
56using namespace clang::serialization;
57using namespace clang::serialization::reader;
58
59//===----------------------------------------------------------------------===//
60// PCH validator implementation
61//===----------------------------------------------------------------------===//
62
63ASTReaderListener::~ASTReaderListener() {}
64
65bool
66PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) {
67  const LangOptions &PPLangOpts = PP.getLangOptions();
68
69#define LANGOPT(Name, Bits, Default, Description)         \
70  if (PPLangOpts.Name != LangOpts.Name) {                 \
71    Reader.Diag(diag::err_pch_langopt_mismatch)           \
72      << Description << LangOpts.Name << PPLangOpts.Name; \
73    return true;                                          \
74  }
75
76#define VALUE_LANGOPT(Name, Bits, Default, Description) \
77  if (PPLangOpts.Name != LangOpts.Name) {               \
78    Reader.Diag(diag::err_pch_langopt_value_mismatch)   \
79      << Description;                                   \
80  return true;                                          \
81}
82
83#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
84  if (PPLangOpts.get##Name() != LangOpts.get##Name()) {      \
85    Reader.Diag(diag::err_pch_langopt_value_mismatch)        \
86      << Description;                                        \
87    return true;                                             \
88  }
89
90#define BENIGN_LANGOPT(Name, Bits, Default, Description)
91#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
92#include "clang/Basic/LangOptions.def"
93
94  return false;
95}
96
97bool PCHValidator::ReadTargetTriple(StringRef Triple) {
98  if (Triple == PP.getTargetInfo().getTriple().str())
99    return false;
100
101  Reader.Diag(diag::warn_pch_target_triple)
102    << Triple << PP.getTargetInfo().getTriple().str();
103  return true;
104}
105
106namespace {
107  struct EmptyStringRef {
108    bool operator ()(StringRef r) const { return r.empty(); }
109  };
110  struct EmptyBlock {
111    bool operator ()(const PCHPredefinesBlock &r) const {return r.Data.empty();}
112  };
113}
114
115static bool EqualConcatenations(SmallVector<StringRef, 2> L,
116                                PCHPredefinesBlocks R) {
117  // First, sum up the lengths.
118  unsigned LL = 0, RL = 0;
119  for (unsigned I = 0, N = L.size(); I != N; ++I) {
120    LL += L[I].size();
121  }
122  for (unsigned I = 0, N = R.size(); I != N; ++I) {
123    RL += R[I].Data.size();
124  }
125  if (LL != RL)
126    return false;
127  if (LL == 0 && RL == 0)
128    return true;
129
130  // Kick out empty parts, they confuse the algorithm below.
131  L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end());
132  R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end());
133
134  // Do it the hard way. At this point, both vectors must be non-empty.
135  StringRef LR = L[0], RR = R[0].Data;
136  unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size();
137  (void) RN;
138  for (;;) {
139    // Compare the current pieces.
140    if (LR.size() == RR.size()) {
141      // If they're the same length, it's pretty easy.
142      if (LR != RR)
143        return false;
144      // Both pieces are done, advance.
145      ++LI;
146      ++RI;
147      // If either string is done, they're both done, since they're the same
148      // length.
149      if (LI == LN) {
150        assert(RI == RN && "Strings not the same length after all?");
151        return true;
152      }
153      LR = L[LI];
154      RR = R[RI].Data;
155    } else if (LR.size() < RR.size()) {
156      // Right piece is longer.
157      if (!RR.startswith(LR))
158        return false;
159      ++LI;
160      assert(LI != LN && "Strings not the same length after all?");
161      RR = RR.substr(LR.size());
162      LR = L[LI];
163    } else {
164      // Left piece is longer.
165      if (!LR.startswith(RR))
166        return false;
167      ++RI;
168      assert(RI != RN && "Strings not the same length after all?");
169      LR = LR.substr(RR.size());
170      RR = R[RI].Data;
171    }
172  }
173}
174
175static std::pair<FileID, StringRef::size_type>
176FindMacro(const PCHPredefinesBlocks &Buffers, StringRef MacroDef) {
177  std::pair<FileID, StringRef::size_type> Res;
178  for (unsigned I = 0, N = Buffers.size(); I != N; ++I) {
179    Res.second = Buffers[I].Data.find(MacroDef);
180    if (Res.second != StringRef::npos) {
181      Res.first = Buffers[I].BufferID;
182      break;
183    }
184  }
185  return Res;
186}
187
188bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers,
189                                        StringRef OriginalFileName,
190                                        std::string &SuggestedPredefines,
191                                        FileManager &FileMgr) {
192  // We are in the context of an implicit include, so the predefines buffer will
193  // have a #include entry for the PCH file itself (as normalized by the
194  // preprocessor initialization). Find it and skip over it in the checking
195  // below.
196  llvm::SmallString<256> PCHInclude;
197  PCHInclude += "#include \"";
198  PCHInclude += NormalizeDashIncludePath(OriginalFileName, FileMgr);
199  PCHInclude += "\"\n";
200  std::pair<StringRef,StringRef> Split =
201    StringRef(PP.getPredefines()).split(PCHInclude.str());
202  StringRef Left =  Split.first, Right = Split.second;
203  if (Left == PP.getPredefines()) {
204    Error("Missing PCH include entry!");
205    return true;
206  }
207
208  // If the concatenation of all the PCH buffers is equal to the adjusted
209  // command line, we're done.
210  SmallVector<StringRef, 2> CommandLine;
211  CommandLine.push_back(Left);
212  CommandLine.push_back(Right);
213  if (EqualConcatenations(CommandLine, Buffers))
214    return false;
215
216  SourceManager &SourceMgr = PP.getSourceManager();
217
218  // The predefines buffers are different. Determine what the differences are,
219  // and whether they require us to reject the PCH file.
220  SmallVector<StringRef, 8> PCHLines;
221  for (unsigned I = 0, N = Buffers.size(); I != N; ++I)
222    Buffers[I].Data.split(PCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
223
224  SmallVector<StringRef, 8> CmdLineLines;
225  Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
226
227  // Pick out implicit #includes after the PCH and don't consider them for
228  // validation; we will insert them into SuggestedPredefines so that the
229  // preprocessor includes them.
230  std::string IncludesAfterPCH;
231  SmallVector<StringRef, 8> AfterPCHLines;
232  Right.split(AfterPCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
233  for (unsigned i = 0, e = AfterPCHLines.size(); i != e; ++i) {
234    if (AfterPCHLines[i].startswith("#include ")) {
235      IncludesAfterPCH += AfterPCHLines[i];
236      IncludesAfterPCH += '\n';
237    } else {
238      CmdLineLines.push_back(AfterPCHLines[i]);
239    }
240  }
241
242  // Make sure we add the includes last into SuggestedPredefines before we
243  // exit this function.
244  struct AddIncludesRAII {
245    std::string &SuggestedPredefines;
246    std::string &IncludesAfterPCH;
247
248    AddIncludesRAII(std::string &SuggestedPredefines,
249                    std::string &IncludesAfterPCH)
250      : SuggestedPredefines(SuggestedPredefines),
251        IncludesAfterPCH(IncludesAfterPCH) { }
252    ~AddIncludesRAII() {
253      SuggestedPredefines += IncludesAfterPCH;
254    }
255  } AddIncludes(SuggestedPredefines, IncludesAfterPCH);
256
257  // Sort both sets of predefined buffer lines, since we allow some extra
258  // definitions and they may appear at any point in the output.
259  std::sort(CmdLineLines.begin(), CmdLineLines.end());
260  std::sort(PCHLines.begin(), PCHLines.end());
261
262  // Determine which predefines that were used to build the PCH file are missing
263  // from the command line.
264  std::vector<StringRef> MissingPredefines;
265  std::set_difference(PCHLines.begin(), PCHLines.end(),
266                      CmdLineLines.begin(), CmdLineLines.end(),
267                      std::back_inserter(MissingPredefines));
268
269  bool MissingDefines = false;
270  bool ConflictingDefines = false;
271  for (unsigned I = 0, N = MissingPredefines.size(); I != N; ++I) {
272    StringRef Missing = MissingPredefines[I];
273    if (Missing.startswith("#include ")) {
274      // An -include was specified when generating the PCH; it is included in
275      // the PCH, just ignore it.
276      continue;
277    }
278    if (!Missing.startswith("#define ")) {
279      Reader.Diag(diag::warn_pch_compiler_options_mismatch);
280      return true;
281    }
282
283    // This is a macro definition. Determine the name of the macro we're
284    // defining.
285    std::string::size_type StartOfMacroName = strlen("#define ");
286    std::string::size_type EndOfMacroName
287      = Missing.find_first_of("( \n\r", StartOfMacroName);
288    assert(EndOfMacroName != std::string::npos &&
289           "Couldn't find the end of the macro name");
290    StringRef MacroName = Missing.slice(StartOfMacroName, EndOfMacroName);
291
292    // Determine whether this macro was given a different definition on the
293    // command line.
294    std::string MacroDefStart = "#define " + MacroName.str();
295    std::string::size_type MacroDefLen = MacroDefStart.size();
296    SmallVector<StringRef, 8>::iterator ConflictPos
297      = std::lower_bound(CmdLineLines.begin(), CmdLineLines.end(),
298                         MacroDefStart);
299    for (; ConflictPos != CmdLineLines.end(); ++ConflictPos) {
300      if (!ConflictPos->startswith(MacroDefStart)) {
301        // Different macro; we're done.
302        ConflictPos = CmdLineLines.end();
303        break;
304      }
305
306      assert(ConflictPos->size() > MacroDefLen &&
307             "Invalid #define in predefines buffer?");
308      if ((*ConflictPos)[MacroDefLen] != ' ' &&
309          (*ConflictPos)[MacroDefLen] != '(')
310        continue; // Longer macro name; keep trying.
311
312      // We found a conflicting macro definition.
313      break;
314    }
315
316    if (ConflictPos != CmdLineLines.end()) {
317      Reader.Diag(diag::warn_cmdline_conflicting_macro_def)
318          << MacroName;
319
320      // Show the definition of this macro within the PCH file.
321      std::pair<FileID, StringRef::size_type> MacroLoc =
322          FindMacro(Buffers, Missing);
323      assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!");
324      SourceLocation PCHMissingLoc =
325          SourceMgr.getLocForStartOfFile(MacroLoc.first)
326            .getFileLocWithOffset(MacroLoc.second);
327      Reader.Diag(PCHMissingLoc, diag::note_pch_macro_defined_as) << MacroName;
328
329      ConflictingDefines = true;
330      continue;
331    }
332
333    // If the macro doesn't conflict, then we'll just pick up the macro
334    // definition from the PCH file. Warn the user that they made a mistake.
335    if (ConflictingDefines)
336      continue; // Don't complain if there are already conflicting defs
337
338    if (!MissingDefines) {
339      Reader.Diag(diag::warn_cmdline_missing_macro_defs);
340      MissingDefines = true;
341    }
342
343    // Show the definition of this macro within the PCH file.
344    std::pair<FileID, StringRef::size_type> MacroLoc =
345        FindMacro(Buffers, Missing);
346    assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!");
347    SourceLocation PCHMissingLoc =
348        SourceMgr.getLocForStartOfFile(MacroLoc.first)
349          .getFileLocWithOffset(MacroLoc.second);
350    Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch);
351  }
352
353  if (ConflictingDefines)
354    return true;
355
356  // Determine what predefines were introduced based on command-line
357  // parameters that were not present when building the PCH
358  // file. Extra #defines are okay, so long as the identifiers being
359  // defined were not used within the precompiled header.
360  std::vector<StringRef> ExtraPredefines;
361  std::set_difference(CmdLineLines.begin(), CmdLineLines.end(),
362                      PCHLines.begin(), PCHLines.end(),
363                      std::back_inserter(ExtraPredefines));
364  for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) {
365    StringRef &Extra = ExtraPredefines[I];
366    if (!Extra.startswith("#define ")) {
367      Reader.Diag(diag::warn_pch_compiler_options_mismatch);
368      return true;
369    }
370
371    // This is an extra macro definition. Determine the name of the
372    // macro we're defining.
373    std::string::size_type StartOfMacroName = strlen("#define ");
374    std::string::size_type EndOfMacroName
375      = Extra.find_first_of("( \n\r", StartOfMacroName);
376    assert(EndOfMacroName != std::string::npos &&
377           "Couldn't find the end of the macro name");
378    StringRef MacroName = Extra.slice(StartOfMacroName, EndOfMacroName);
379
380    // Check whether this name was used somewhere in the PCH file. If
381    // so, defining it as a macro could change behavior, so we reject
382    // the PCH file.
383    if (IdentifierInfo *II = Reader.get(MacroName)) {
384      Reader.Diag(diag::warn_macro_name_used_in_pch) << II;
385      return true;
386    }
387
388    // Add this definition to the suggested predefines buffer.
389    SuggestedPredefines += Extra;
390    SuggestedPredefines += '\n';
391  }
392
393  // If we get here, it's because the predefines buffer had compatible
394  // contents. Accept the PCH file.
395  return false;
396}
397
398void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI,
399                                      unsigned ID) {
400  PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID);
401  ++NumHeaderInfos;
402}
403
404void PCHValidator::ReadCounter(unsigned Value) {
405  PP.setCounterValue(Value);
406}
407
408//===----------------------------------------------------------------------===//
409// AST reader implementation
410//===----------------------------------------------------------------------===//
411
412void
413ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) {
414  DeserializationListener = Listener;
415}
416
417
418
419unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
420  return serialization::ComputeHash(Sel);
421}
422
423
424std::pair<unsigned, unsigned>
425ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
426  using namespace clang::io;
427  unsigned KeyLen = ReadUnalignedLE16(d);
428  unsigned DataLen = ReadUnalignedLE16(d);
429  return std::make_pair(KeyLen, DataLen);
430}
431
432ASTSelectorLookupTrait::internal_key_type
433ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
434  using namespace clang::io;
435  SelectorTable &SelTable = Reader.getContext().Selectors;
436  unsigned N = ReadUnalignedLE16(d);
437  IdentifierInfo *FirstII
438    = Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
439  if (N == 0)
440    return SelTable.getNullarySelector(FirstII);
441  else if (N == 1)
442    return SelTable.getUnarySelector(FirstII);
443
444  SmallVector<IdentifierInfo *, 16> Args;
445  Args.push_back(FirstII);
446  for (unsigned I = 1; I != N; ++I)
447    Args.push_back(Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)));
448
449  return SelTable.getSelector(N, Args.data());
450}
451
452ASTSelectorLookupTrait::data_type
453ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
454                                 unsigned DataLen) {
455  using namespace clang::io;
456
457  data_type Result;
458
459  Result.ID = Reader.getGlobalSelectorID(F, ReadUnalignedLE32(d));
460  unsigned NumInstanceMethods = ReadUnalignedLE16(d);
461  unsigned NumFactoryMethods = ReadUnalignedLE16(d);
462
463  // Load instance methods
464  for (unsigned I = 0; I != NumInstanceMethods; ++I) {
465    if (ObjCMethodDecl *Method
466          = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d)))
467      Result.Instance.push_back(Method);
468  }
469
470  // Load factory methods
471  for (unsigned I = 0; I != NumFactoryMethods; ++I) {
472    if (ObjCMethodDecl *Method
473          = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d)))
474      Result.Factory.push_back(Method);
475  }
476
477  return Result;
478}
479
480unsigned ASTIdentifierLookupTrait::ComputeHash(const internal_key_type& a) {
481  return llvm::HashString(StringRef(a.first, a.second));
482}
483
484std::pair<unsigned, unsigned>
485ASTIdentifierLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
486  using namespace clang::io;
487  unsigned DataLen = ReadUnalignedLE16(d);
488  unsigned KeyLen = ReadUnalignedLE16(d);
489  return std::make_pair(KeyLen, DataLen);
490}
491
492std::pair<const char*, unsigned>
493ASTIdentifierLookupTrait::ReadKey(const unsigned char* d, unsigned n) {
494  assert(n >= 2 && d[n-1] == '\0');
495  return std::make_pair((const char*) d, n-1);
496}
497
498IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
499                                                   const unsigned char* d,
500                                                   unsigned DataLen) {
501  using namespace clang::io;
502  unsigned RawID = ReadUnalignedLE32(d);
503  bool IsInteresting = RawID & 0x01;
504
505  // Wipe out the "is interesting" bit.
506  RawID = RawID >> 1;
507
508  IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
509  if (!IsInteresting) {
510    // For uninteresting identifiers, just build the IdentifierInfo
511    // and associate it with the persistent ID.
512    IdentifierInfo *II = KnownII;
513    if (!II)
514      II = &Reader.getIdentifierTable().getOwn(StringRef(k.first, k.second));
515    Reader.SetIdentifierInfo(ID, II);
516    II->setIsFromAST();
517    return II;
518  }
519
520  unsigned Bits = ReadUnalignedLE16(d);
521  bool CPlusPlusOperatorKeyword = Bits & 0x01;
522  Bits >>= 1;
523  bool HasRevertedTokenIDToIdentifier = Bits & 0x01;
524  Bits >>= 1;
525  bool Poisoned = Bits & 0x01;
526  Bits >>= 1;
527  bool ExtensionToken = Bits & 0x01;
528  Bits >>= 1;
529  bool hasMacroDefinition = Bits & 0x01;
530  Bits >>= 1;
531  unsigned ObjCOrBuiltinID = Bits & 0x3FF;
532  Bits >>= 10;
533
534  assert(Bits == 0 && "Extra bits in the identifier?");
535  DataLen -= 6;
536
537  // Build the IdentifierInfo itself and link the identifier ID with
538  // the new IdentifierInfo.
539  IdentifierInfo *II = KnownII;
540  if (!II)
541    II = &Reader.getIdentifierTable().getOwn(StringRef(k.first, k.second));
542  Reader.SetIdentifierInfo(ID, II);
543
544  // Set or check the various bits in the IdentifierInfo structure.
545  // Token IDs are read-only.
546  if (HasRevertedTokenIDToIdentifier)
547    II->RevertTokenIDToIdentifier();
548  II->setObjCOrBuiltinID(ObjCOrBuiltinID);
549  assert(II->isExtensionToken() == ExtensionToken &&
550         "Incorrect extension token flag");
551  (void)ExtensionToken;
552  if (Poisoned)
553    II->setIsPoisoned(true);
554  assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
555         "Incorrect C++ operator keyword flag");
556  (void)CPlusPlusOperatorKeyword;
557
558  // If this identifier is a macro, deserialize the macro
559  // definition.
560  if (hasMacroDefinition) {
561    // FIXME: Check for conflicts?
562    uint32_t Offset = ReadUnalignedLE32(d);
563    Reader.SetIdentifierIsMacro(II, F, Offset);
564    DataLen -= 4;
565  }
566
567  // Read all of the declarations visible at global scope with this
568  // name.
569  if (DataLen > 0) {
570    SmallVector<uint32_t, 4> DeclIDs;
571    for (; DataLen > 0; DataLen -= 4)
572      DeclIDs.push_back(Reader.getGlobalDeclID(F, ReadUnalignedLE32(d)));
573    Reader.SetGloballyVisibleDecls(II, DeclIDs);
574  }
575
576  II->setIsFromAST();
577  return II;
578}
579
580unsigned
581ASTDeclContextNameLookupTrait::ComputeHash(const DeclNameKey &Key) const {
582  llvm::FoldingSetNodeID ID;
583  ID.AddInteger(Key.Kind);
584
585  switch (Key.Kind) {
586  case DeclarationName::Identifier:
587  case DeclarationName::CXXLiteralOperatorName:
588    ID.AddString(((IdentifierInfo*)Key.Data)->getName());
589    break;
590  case DeclarationName::ObjCZeroArgSelector:
591  case DeclarationName::ObjCOneArgSelector:
592  case DeclarationName::ObjCMultiArgSelector:
593    ID.AddInteger(serialization::ComputeHash(Selector(Key.Data)));
594    break;
595  case DeclarationName::CXXOperatorName:
596    ID.AddInteger((OverloadedOperatorKind)Key.Data);
597    break;
598  case DeclarationName::CXXConstructorName:
599  case DeclarationName::CXXDestructorName:
600  case DeclarationName::CXXConversionFunctionName:
601  case DeclarationName::CXXUsingDirective:
602    break;
603  }
604
605  return ID.ComputeHash();
606}
607
608ASTDeclContextNameLookupTrait::internal_key_type
609ASTDeclContextNameLookupTrait::GetInternalKey(
610                                          const external_key_type& Name) const {
611  DeclNameKey Key;
612  Key.Kind = Name.getNameKind();
613  switch (Name.getNameKind()) {
614  case DeclarationName::Identifier:
615    Key.Data = (uint64_t)Name.getAsIdentifierInfo();
616    break;
617  case DeclarationName::ObjCZeroArgSelector:
618  case DeclarationName::ObjCOneArgSelector:
619  case DeclarationName::ObjCMultiArgSelector:
620    Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
621    break;
622  case DeclarationName::CXXOperatorName:
623    Key.Data = Name.getCXXOverloadedOperator();
624    break;
625  case DeclarationName::CXXLiteralOperatorName:
626    Key.Data = (uint64_t)Name.getCXXLiteralIdentifier();
627    break;
628  case DeclarationName::CXXConstructorName:
629  case DeclarationName::CXXDestructorName:
630  case DeclarationName::CXXConversionFunctionName:
631  case DeclarationName::CXXUsingDirective:
632    Key.Data = 0;
633    break;
634  }
635
636  return Key;
637}
638
639ASTDeclContextNameLookupTrait::external_key_type
640ASTDeclContextNameLookupTrait::GetExternalKey(
641                                          const internal_key_type& Key) const {
642  ASTContext &Context = Reader.getContext();
643  switch (Key.Kind) {
644  case DeclarationName::Identifier:
645    return DeclarationName((IdentifierInfo*)Key.Data);
646
647  case DeclarationName::ObjCZeroArgSelector:
648  case DeclarationName::ObjCOneArgSelector:
649  case DeclarationName::ObjCMultiArgSelector:
650    return DeclarationName(Selector(Key.Data));
651
652  case DeclarationName::CXXConstructorName:
653    return Context.DeclarationNames.getCXXConstructorName(
654             Context.getCanonicalType(Reader.getLocalType(F, Key.Data)));
655
656  case DeclarationName::CXXDestructorName:
657    return Context.DeclarationNames.getCXXDestructorName(
658             Context.getCanonicalType(Reader.getLocalType(F, Key.Data)));
659
660  case DeclarationName::CXXConversionFunctionName:
661    return Context.DeclarationNames.getCXXConversionFunctionName(
662             Context.getCanonicalType(Reader.getLocalType(F, Key.Data)));
663
664  case DeclarationName::CXXOperatorName:
665    return Context.DeclarationNames.getCXXOperatorName(
666                                       (OverloadedOperatorKind)Key.Data);
667
668  case DeclarationName::CXXLiteralOperatorName:
669    return Context.DeclarationNames.getCXXLiteralOperatorName(
670                                                   (IdentifierInfo*)Key.Data);
671
672  case DeclarationName::CXXUsingDirective:
673    return DeclarationName::getUsingDirectiveName();
674  }
675
676  llvm_unreachable("Invalid Name Kind ?");
677}
678
679std::pair<unsigned, unsigned>
680ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
681  using namespace clang::io;
682  unsigned KeyLen = ReadUnalignedLE16(d);
683  unsigned DataLen = ReadUnalignedLE16(d);
684  return std::make_pair(KeyLen, DataLen);
685}
686
687ASTDeclContextNameLookupTrait::internal_key_type
688ASTDeclContextNameLookupTrait::ReadKey(const unsigned char* d, unsigned) {
689  using namespace clang::io;
690
691  DeclNameKey Key;
692  Key.Kind = (DeclarationName::NameKind)*d++;
693  switch (Key.Kind) {
694  case DeclarationName::Identifier:
695    Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
696    break;
697  case DeclarationName::ObjCZeroArgSelector:
698  case DeclarationName::ObjCOneArgSelector:
699  case DeclarationName::ObjCMultiArgSelector:
700    Key.Data =
701       (uint64_t)Reader.getLocalSelector(F, ReadUnalignedLE32(d))
702                   .getAsOpaquePtr();
703    break;
704  case DeclarationName::CXXOperatorName:
705    Key.Data = *d++; // OverloadedOperatorKind
706    break;
707  case DeclarationName::CXXLiteralOperatorName:
708    Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
709    break;
710  case DeclarationName::CXXConstructorName:
711  case DeclarationName::CXXDestructorName:
712  case DeclarationName::CXXConversionFunctionName:
713  case DeclarationName::CXXUsingDirective:
714    Key.Data = 0;
715    break;
716  }
717
718  return Key;
719}
720
721ASTDeclContextNameLookupTrait::data_type
722ASTDeclContextNameLookupTrait::ReadData(internal_key_type,
723                                        const unsigned char* d,
724                                      unsigned DataLen) {
725  using namespace clang::io;
726  unsigned NumDecls = ReadUnalignedLE16(d);
727  DeclID *Start = (DeclID *)d;
728  return std::make_pair(Start, Start + NumDecls);
729}
730
731bool ASTReader::ReadDeclContextStorage(Module &M,
732                                       llvm::BitstreamCursor &Cursor,
733                                   const std::pair<uint64_t, uint64_t> &Offsets,
734                                       DeclContextInfo &Info) {
735  SavedStreamPosition SavedPosition(Cursor);
736  // First the lexical decls.
737  if (Offsets.first != 0) {
738    Cursor.JumpToBit(Offsets.first);
739
740    RecordData Record;
741    const char *Blob;
742    unsigned BlobLen;
743    unsigned Code = Cursor.ReadCode();
744    unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
745    if (RecCode != DECL_CONTEXT_LEXICAL) {
746      Error("Expected lexical block");
747      return true;
748    }
749
750    Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob);
751    Info.NumLexicalDecls = BlobLen / sizeof(KindDeclIDPair);
752  }
753
754  // Now the lookup table.
755  if (Offsets.second != 0) {
756    Cursor.JumpToBit(Offsets.second);
757
758    RecordData Record;
759    const char *Blob;
760    unsigned BlobLen;
761    unsigned Code = Cursor.ReadCode();
762    unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
763    if (RecCode != DECL_CONTEXT_VISIBLE) {
764      Error("Expected visible lookup table block");
765      return true;
766    }
767    Info.NameLookupTableData
768      = ASTDeclContextNameLookupTable::Create(
769                    (const unsigned char *)Blob + Record[0],
770                    (const unsigned char *)Blob,
771                    ASTDeclContextNameLookupTrait(*this, M));
772  }
773
774  return false;
775}
776
777void ASTReader::Error(StringRef Msg) {
778  Error(diag::err_fe_pch_malformed, Msg);
779}
780
781void ASTReader::Error(unsigned DiagID,
782                      StringRef Arg1, StringRef Arg2) {
783  if (Diags.isDiagnosticInFlight())
784    Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
785  else
786    Diag(DiagID) << Arg1 << Arg2;
787}
788
789/// \brief Tell the AST listener about the predefines buffers in the chain.
790bool ASTReader::CheckPredefinesBuffers() {
791  if (Listener)
792    return Listener->ReadPredefinesBuffer(PCHPredefinesBuffers,
793                                          ActualOriginalFileName,
794                                          SuggestedPredefines,
795                                          FileMgr);
796  return false;
797}
798
799//===----------------------------------------------------------------------===//
800// Source Manager Deserialization
801//===----------------------------------------------------------------------===//
802
803/// \brief Read the line table in the source manager block.
804/// \returns true if there was an error.
805bool ASTReader::ParseLineTable(Module &F,
806                               SmallVectorImpl<uint64_t> &Record) {
807  unsigned Idx = 0;
808  LineTableInfo &LineTable = SourceMgr.getLineTable();
809
810  // Parse the file names
811  std::map<int, int> FileIDs;
812  for (int I = 0, N = Record[Idx++]; I != N; ++I) {
813    // Extract the file name
814    unsigned FilenameLen = Record[Idx++];
815    std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen);
816    Idx += FilenameLen;
817    MaybeAddSystemRootToFilename(Filename);
818    FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
819  }
820
821  // Parse the line entries
822  std::vector<LineEntry> Entries;
823  while (Idx < Record.size()) {
824    int FID = Record[Idx++];
825    assert(FID >= 0 && "Serialized line entries for non-local file.");
826    // Remap FileID from 1-based old view.
827    FID += F.SLocEntryBaseID - 1;
828
829    // Extract the line entries
830    unsigned NumEntries = Record[Idx++];
831    assert(NumEntries && "Numentries is 00000");
832    Entries.clear();
833    Entries.reserve(NumEntries);
834    for (unsigned I = 0; I != NumEntries; ++I) {
835      unsigned FileOffset = Record[Idx++];
836      unsigned LineNo = Record[Idx++];
837      int FilenameID = FileIDs[Record[Idx++]];
838      SrcMgr::CharacteristicKind FileKind
839        = (SrcMgr::CharacteristicKind)Record[Idx++];
840      unsigned IncludeOffset = Record[Idx++];
841      Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
842                                       FileKind, IncludeOffset));
843    }
844    LineTable.AddEntry(FID, Entries);
845  }
846
847  return false;
848}
849
850namespace {
851
852class ASTStatData {
853public:
854  const ino_t ino;
855  const dev_t dev;
856  const mode_t mode;
857  const time_t mtime;
858  const off_t size;
859
860  ASTStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s)
861    : ino(i), dev(d), mode(mo), mtime(m), size(s) {}
862};
863
864class ASTStatLookupTrait {
865 public:
866  typedef const char *external_key_type;
867  typedef const char *internal_key_type;
868
869  typedef ASTStatData data_type;
870
871  static unsigned ComputeHash(const char *path) {
872    return llvm::HashString(path);
873  }
874
875  static internal_key_type GetInternalKey(const char *path) { return path; }
876
877  static bool EqualKey(internal_key_type a, internal_key_type b) {
878    return strcmp(a, b) == 0;
879  }
880
881  static std::pair<unsigned, unsigned>
882  ReadKeyDataLength(const unsigned char*& d) {
883    unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
884    unsigned DataLen = (unsigned) *d++;
885    return std::make_pair(KeyLen + 1, DataLen);
886  }
887
888  static internal_key_type ReadKey(const unsigned char *d, unsigned) {
889    return (const char *)d;
890  }
891
892  static data_type ReadData(const internal_key_type, const unsigned char *d,
893                            unsigned /*DataLen*/) {
894    using namespace clang::io;
895
896    ino_t ino = (ino_t) ReadUnalignedLE32(d);
897    dev_t dev = (dev_t) ReadUnalignedLE32(d);
898    mode_t mode = (mode_t) ReadUnalignedLE16(d);
899    time_t mtime = (time_t) ReadUnalignedLE64(d);
900    off_t size = (off_t) ReadUnalignedLE64(d);
901    return data_type(ino, dev, mode, mtime, size);
902  }
903};
904
905/// \brief stat() cache for precompiled headers.
906///
907/// This cache is very similar to the stat cache used by pretokenized
908/// headers.
909class ASTStatCache : public FileSystemStatCache {
910  typedef OnDiskChainedHashTable<ASTStatLookupTrait> CacheTy;
911  CacheTy *Cache;
912
913  unsigned &NumStatHits, &NumStatMisses;
914public:
915  ASTStatCache(const unsigned char *Buckets, const unsigned char *Base,
916               unsigned &NumStatHits, unsigned &NumStatMisses)
917    : Cache(0), NumStatHits(NumStatHits), NumStatMisses(NumStatMisses) {
918    Cache = CacheTy::Create(Buckets, Base);
919  }
920
921  ~ASTStatCache() { delete Cache; }
922
923  LookupResult getStat(const char *Path, struct stat &StatBuf,
924                       int *FileDescriptor) {
925    // Do the lookup for the file's data in the AST file.
926    CacheTy::iterator I = Cache->find(Path);
927
928    // If we don't get a hit in the AST file just forward to 'stat'.
929    if (I == Cache->end()) {
930      ++NumStatMisses;
931      return statChained(Path, StatBuf, FileDescriptor);
932    }
933
934    ++NumStatHits;
935    ASTStatData Data = *I;
936
937    StatBuf.st_ino = Data.ino;
938    StatBuf.st_dev = Data.dev;
939    StatBuf.st_mtime = Data.mtime;
940    StatBuf.st_mode = Data.mode;
941    StatBuf.st_size = Data.size;
942    return CacheExists;
943  }
944};
945} // end anonymous namespace
946
947
948/// \brief Read a source manager block
949ASTReader::ASTReadResult ASTReader::ReadSourceManagerBlock(Module &F) {
950  using namespace SrcMgr;
951
952  llvm::BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
953
954  // Set the source-location entry cursor to the current position in
955  // the stream. This cursor will be used to read the contents of the
956  // source manager block initially, and then lazily read
957  // source-location entries as needed.
958  SLocEntryCursor = F.Stream;
959
960  // The stream itself is going to skip over the source manager block.
961  if (F.Stream.SkipBlock()) {
962    Error("malformed block record in AST file");
963    return Failure;
964  }
965
966  // Enter the source manager block.
967  if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
968    Error("malformed source manager block record in AST file");
969    return Failure;
970  }
971
972  RecordData Record;
973  while (true) {
974    unsigned Code = SLocEntryCursor.ReadCode();
975    if (Code == llvm::bitc::END_BLOCK) {
976      if (SLocEntryCursor.ReadBlockEnd()) {
977        Error("error at end of Source Manager block in AST file");
978        return Failure;
979      }
980      return Success;
981    }
982
983    if (Code == llvm::bitc::ENTER_SUBBLOCK) {
984      // No known subblocks, always skip them.
985      SLocEntryCursor.ReadSubBlockID();
986      if (SLocEntryCursor.SkipBlock()) {
987        Error("malformed block record in AST file");
988        return Failure;
989      }
990      continue;
991    }
992
993    if (Code == llvm::bitc::DEFINE_ABBREV) {
994      SLocEntryCursor.ReadAbbrevRecord();
995      continue;
996    }
997
998    // Read a record.
999    const char *BlobStart;
1000    unsigned BlobLen;
1001    Record.clear();
1002    switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1003    default:  // Default behavior: ignore.
1004      break;
1005
1006    case SM_SLOC_FILE_ENTRY:
1007    case SM_SLOC_BUFFER_ENTRY:
1008    case SM_SLOC_EXPANSION_ENTRY:
1009      // Once we hit one of the source location entries, we're done.
1010      return Success;
1011    }
1012  }
1013}
1014
1015/// \brief If a header file is not found at the path that we expect it to be
1016/// and the PCH file was moved from its original location, try to resolve the
1017/// file by assuming that header+PCH were moved together and the header is in
1018/// the same place relative to the PCH.
1019static std::string
1020resolveFileRelativeToOriginalDir(const std::string &Filename,
1021                                 const std::string &OriginalDir,
1022                                 const std::string &CurrDir) {
1023  assert(OriginalDir != CurrDir &&
1024         "No point trying to resolve the file if the PCH dir didn't change");
1025  using namespace llvm::sys;
1026  llvm::SmallString<128> filePath(Filename);
1027  fs::make_absolute(filePath);
1028  assert(path::is_absolute(OriginalDir));
1029  llvm::SmallString<128> currPCHPath(CurrDir);
1030
1031  path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1032                       fileDirE = path::end(path::parent_path(filePath));
1033  path::const_iterator origDirI = path::begin(OriginalDir),
1034                       origDirE = path::end(OriginalDir);
1035  // Skip the common path components from filePath and OriginalDir.
1036  while (fileDirI != fileDirE && origDirI != origDirE &&
1037         *fileDirI == *origDirI) {
1038    ++fileDirI;
1039    ++origDirI;
1040  }
1041  for (; origDirI != origDirE; ++origDirI)
1042    path::append(currPCHPath, "..");
1043  path::append(currPCHPath, fileDirI, fileDirE);
1044  path::append(currPCHPath, path::filename(Filename));
1045  return currPCHPath.str();
1046}
1047
1048/// \brief Read in the source location entry with the given ID.
1049ASTReader::ASTReadResult ASTReader::ReadSLocEntryRecord(int ID) {
1050  if (ID == 0)
1051    return Success;
1052
1053  if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1054    Error("source location entry ID out-of-range for AST file");
1055    return Failure;
1056  }
1057
1058  Module *F = GlobalSLocEntryMap.find(-ID)->second;
1059  F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
1060  llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1061  unsigned BaseOffset = F->SLocEntryBaseOffset;
1062
1063  ++NumSLocEntriesRead;
1064  unsigned Code = SLocEntryCursor.ReadCode();
1065  if (Code == llvm::bitc::END_BLOCK ||
1066      Code == llvm::bitc::ENTER_SUBBLOCK ||
1067      Code == llvm::bitc::DEFINE_ABBREV) {
1068    Error("incorrectly-formatted source location entry in AST file");
1069    return Failure;
1070  }
1071
1072  RecordData Record;
1073  const char *BlobStart;
1074  unsigned BlobLen;
1075  switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1076  default:
1077    Error("incorrectly-formatted source location entry in AST file");
1078    return Failure;
1079
1080  case SM_SLOC_FILE_ENTRY: {
1081    std::string Filename(BlobStart, BlobStart + BlobLen);
1082    MaybeAddSystemRootToFilename(Filename);
1083    const FileEntry *File = FileMgr.getFile(Filename);
1084    if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() &&
1085        OriginalDir != CurrentDir) {
1086      std::string resolved = resolveFileRelativeToOriginalDir(Filename,
1087                                                              OriginalDir,
1088                                                              CurrentDir);
1089      if (!resolved.empty())
1090        File = FileMgr.getFile(resolved);
1091    }
1092    if (File == 0)
1093      File = FileMgr.getVirtualFile(Filename, (off_t)Record[4],
1094                                    (time_t)Record[5]);
1095    if (File == 0) {
1096      std::string ErrorStr = "could not find file '";
1097      ErrorStr += Filename;
1098      ErrorStr += "' referenced by AST file";
1099      Error(ErrorStr.c_str());
1100      return Failure;
1101    }
1102
1103    if (Record.size() < 6) {
1104      Error("source location entry is incorrect");
1105      return Failure;
1106    }
1107
1108    if (!DisableValidation &&
1109        ((off_t)Record[4] != File->getSize()
1110#if !defined(LLVM_ON_WIN32)
1111        // In our regression testing, the Windows file system seems to
1112        // have inconsistent modification times that sometimes
1113        // erroneously trigger this error-handling path.
1114         || (time_t)Record[5] != File->getModificationTime()
1115#endif
1116        )) {
1117      Error(diag::err_fe_pch_file_modified, Filename);
1118      return Failure;
1119    }
1120
1121    SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1122    if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1123      // This is the module's main file.
1124      IncludeLoc = getImportLocation(F);
1125    }
1126    FileID FID = SourceMgr.createFileID(File, IncludeLoc,
1127                                        (SrcMgr::CharacteristicKind)Record[2],
1128                                        ID, BaseOffset + Record[0]);
1129    SrcMgr::FileInfo &FileInfo =
1130          const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1131    FileInfo.NumCreatedFIDs = Record[6];
1132    if (Record[3])
1133      FileInfo.setHasLineDirectives();
1134
1135    break;
1136  }
1137
1138  case SM_SLOC_BUFFER_ENTRY: {
1139    const char *Name = BlobStart;
1140    unsigned Offset = Record[0];
1141    unsigned Code = SLocEntryCursor.ReadCode();
1142    Record.clear();
1143    unsigned RecCode
1144      = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen);
1145
1146    if (RecCode != SM_SLOC_BUFFER_BLOB) {
1147      Error("AST record has invalid code");
1148      return Failure;
1149    }
1150
1151    llvm::MemoryBuffer *Buffer
1152    = llvm::MemoryBuffer::getMemBuffer(StringRef(BlobStart, BlobLen - 1),
1153                                       Name);
1154    FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID,
1155                                                         BaseOffset + Offset);
1156
1157    if (strcmp(Name, "<built-in>") == 0) {
1158      PCHPredefinesBlock Block = {
1159        BufferID,
1160        StringRef(BlobStart, BlobLen - 1)
1161      };
1162      PCHPredefinesBuffers.push_back(Block);
1163    }
1164
1165    break;
1166  }
1167
1168  case SM_SLOC_EXPANSION_ENTRY: {
1169    SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1170    SourceMgr.createExpansionLoc(SpellingLoc,
1171                                     ReadSourceLocation(*F, Record[2]),
1172                                     ReadSourceLocation(*F, Record[3]),
1173                                     Record[4],
1174                                     ID,
1175                                     BaseOffset + Record[0]);
1176    break;
1177  }
1178  }
1179
1180  return Success;
1181}
1182
1183/// \brief Find the location where the module F is imported.
1184SourceLocation ASTReader::getImportLocation(Module *F) {
1185  if (F->ImportLoc.isValid())
1186    return F->ImportLoc;
1187
1188  // Otherwise we have a PCH. It's considered to be "imported" at the first
1189  // location of its includer.
1190  if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1191    // Main file is the importer. We assume that it is the first entry in the
1192    // entry table. We can't ask the manager, because at the time of PCH loading
1193    // the main file entry doesn't exist yet.
1194    // The very first entry is the invalid instantiation loc, which takes up
1195    // offsets 0 and 1.
1196    return SourceLocation::getFromRawEncoding(2U);
1197  }
1198  //return F->Loaders[0]->FirstLoc;
1199  return F->ImportedBy[0]->FirstLoc;
1200}
1201
1202/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1203/// specified cursor.  Read the abbreviations that are at the top of the block
1204/// and then leave the cursor pointing into the block.
1205bool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor,
1206                                 unsigned BlockID) {
1207  if (Cursor.EnterSubBlock(BlockID)) {
1208    Error("malformed block record in AST file");
1209    return Failure;
1210  }
1211
1212  while (true) {
1213    uint64_t Offset = Cursor.GetCurrentBitNo();
1214    unsigned Code = Cursor.ReadCode();
1215
1216    // We expect all abbrevs to be at the start of the block.
1217    if (Code != llvm::bitc::DEFINE_ABBREV) {
1218      Cursor.JumpToBit(Offset);
1219      return false;
1220    }
1221    Cursor.ReadAbbrevRecord();
1222  }
1223}
1224
1225void ASTReader::ReadMacroRecord(Module &F, uint64_t Offset) {
1226  llvm::BitstreamCursor &Stream = F.MacroCursor;
1227
1228  // Keep track of where we are in the stream, then jump back there
1229  // after reading this macro.
1230  SavedStreamPosition SavedPosition(Stream);
1231
1232  Stream.JumpToBit(Offset);
1233  RecordData Record;
1234  SmallVector<IdentifierInfo*, 16> MacroArgs;
1235  MacroInfo *Macro = 0;
1236
1237  while (true) {
1238    unsigned Code = Stream.ReadCode();
1239    switch (Code) {
1240    case llvm::bitc::END_BLOCK:
1241      return;
1242
1243    case llvm::bitc::ENTER_SUBBLOCK:
1244      // No known subblocks, always skip them.
1245      Stream.ReadSubBlockID();
1246      if (Stream.SkipBlock()) {
1247        Error("malformed block record in AST file");
1248        return;
1249      }
1250      continue;
1251
1252    case llvm::bitc::DEFINE_ABBREV:
1253      Stream.ReadAbbrevRecord();
1254      continue;
1255    default: break;
1256    }
1257
1258    // Read a record.
1259    const char *BlobStart = 0;
1260    unsigned BlobLen = 0;
1261    Record.clear();
1262    PreprocessorRecordTypes RecType =
1263      (PreprocessorRecordTypes)Stream.ReadRecord(Code, Record, BlobStart,
1264                                                 BlobLen);
1265    switch (RecType) {
1266    case PP_MACRO_OBJECT_LIKE:
1267    case PP_MACRO_FUNCTION_LIKE: {
1268      // If we already have a macro, that means that we've hit the end
1269      // of the definition of the macro we were looking for. We're
1270      // done.
1271      if (Macro)
1272        return;
1273
1274      IdentifierInfo *II = getLocalIdentifier(F, Record[0]);
1275      if (II == 0) {
1276        Error("macro must have a name in AST file");
1277        return;
1278      }
1279      SourceLocation Loc = ReadSourceLocation(F, Record[1]);
1280      bool isUsed = Record[2];
1281
1282      MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1283      MI->setIsUsed(isUsed);
1284      MI->setIsFromAST();
1285
1286      unsigned NextIndex = 3;
1287      MI->setExportLocation(ReadSourceLocation(F, Record, NextIndex));
1288
1289      if (RecType == PP_MACRO_FUNCTION_LIKE) {
1290        // Decode function-like macro info.
1291        bool isC99VarArgs = Record[NextIndex++];
1292        bool isGNUVarArgs = Record[NextIndex++];
1293        MacroArgs.clear();
1294        unsigned NumArgs = Record[NextIndex++];
1295        for (unsigned i = 0; i != NumArgs; ++i)
1296          MacroArgs.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1297
1298        // Install function-like macro info.
1299        MI->setIsFunctionLike();
1300        if (isC99VarArgs) MI->setIsC99Varargs();
1301        if (isGNUVarArgs) MI->setIsGNUVarargs();
1302        MI->setArgumentList(MacroArgs.data(), MacroArgs.size(),
1303                            PP.getPreprocessorAllocator());
1304      }
1305
1306      // Finally, install the macro.
1307      PP.setMacroInfo(II, MI);
1308
1309      // Remember that we saw this macro last so that we add the tokens that
1310      // form its body to it.
1311      Macro = MI;
1312
1313      if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord()) {
1314        // We have a macro definition. Load it now.
1315        PP.getPreprocessingRecord()->RegisterMacroDefinition(Macro,
1316              getLocalMacroDefinition(F, Record[NextIndex]));
1317      }
1318
1319      ++NumMacrosRead;
1320      break;
1321    }
1322
1323    case PP_TOKEN: {
1324      // If we see a TOKEN before a PP_MACRO_*, then the file is
1325      // erroneous, just pretend we didn't see this.
1326      if (Macro == 0) break;
1327
1328      Token Tok;
1329      Tok.startToken();
1330      Tok.setLocation(ReadSourceLocation(F, Record[0]));
1331      Tok.setLength(Record[1]);
1332      if (IdentifierInfo *II = getLocalIdentifier(F, Record[2]))
1333        Tok.setIdentifierInfo(II);
1334      Tok.setKind((tok::TokenKind)Record[3]);
1335      Tok.setFlag((Token::TokenFlags)Record[4]);
1336      Macro->AddTokenToBody(Tok);
1337      break;
1338    }
1339  }
1340  }
1341
1342  return;
1343}
1344
1345PreprocessedEntity *ASTReader::LoadPreprocessedEntity(Module &F) {
1346  unsigned Code = F.PreprocessorDetailCursor.ReadCode();
1347  switch (Code) {
1348  case llvm::bitc::END_BLOCK:
1349    return 0;
1350
1351  case llvm::bitc::ENTER_SUBBLOCK:
1352    Error("unexpected subblock record in preprocessor detail block");
1353    return 0;
1354
1355  case llvm::bitc::DEFINE_ABBREV:
1356    Error("unexpected abbrevation record in preprocessor detail block");
1357    return 0;
1358
1359  default:
1360    break;
1361  }
1362
1363  if (!PP.getPreprocessingRecord()) {
1364    Error("no preprocessing record");
1365    return 0;
1366  }
1367
1368  // Read the record.
1369  PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1370  const char *BlobStart = 0;
1371  unsigned BlobLen = 0;
1372  RecordData Record;
1373  PreprocessorDetailRecordTypes RecType =
1374    (PreprocessorDetailRecordTypes)F.PreprocessorDetailCursor.ReadRecord(
1375                                             Code, Record, BlobStart, BlobLen);
1376  switch (RecType) {
1377  case PPD_MACRO_EXPANSION: {
1378    PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]);
1379    if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID-1))
1380      return PE;
1381
1382    bool isBuiltin = Record[3];
1383    MacroExpansion *ME;
1384    if (isBuiltin)
1385      ME = new (PPRec) MacroExpansion(getLocalIdentifier(F, Record[4]),
1386                                 SourceRange(ReadSourceLocation(F, Record[1]),
1387                                             ReadSourceLocation(F, Record[2])));
1388    else
1389      ME = new (PPRec) MacroExpansion(getLocalMacroDefinition(F, Record[4]),
1390                                 SourceRange(ReadSourceLocation(F, Record[1]),
1391                                             ReadSourceLocation(F, Record[2])));
1392    PPRec.setLoadedPreallocatedEntity(GlobalID - 1, ME);
1393    return ME;
1394  }
1395
1396  case PPD_MACRO_DEFINITION: {
1397    PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]);
1398    if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID-1))
1399      return PE;
1400
1401    unsigned MacroDefID = getGlobalMacroDefinitionID(F, Record[1]);
1402    if (MacroDefID > MacroDefinitionsLoaded.size()) {
1403      Error("out-of-bounds macro definition record");
1404      return 0;
1405    }
1406
1407    // Decode the identifier info and then check again; if the macro is
1408    // still defined and associated with the identifier,
1409    IdentifierInfo *II = getLocalIdentifier(F, Record[4]);
1410    if (!MacroDefinitionsLoaded[MacroDefID - 1]) {
1411      MacroDefinition *MD
1412        = new (PPRec) MacroDefinition(II,
1413                                      ReadSourceLocation(F, Record[5]),
1414                                      SourceRange(
1415                                            ReadSourceLocation(F, Record[2]),
1416                                            ReadSourceLocation(F, Record[3])));
1417
1418      PPRec.setLoadedPreallocatedEntity(GlobalID - 1, MD);
1419      MacroDefinitionsLoaded[MacroDefID - 1] = MD;
1420
1421      if (DeserializationListener)
1422        DeserializationListener->MacroDefinitionRead(MacroDefID, MD);
1423    }
1424
1425    return MacroDefinitionsLoaded[MacroDefID - 1];
1426  }
1427
1428  case PPD_INCLUSION_DIRECTIVE: {
1429    PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]);
1430    if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID-1))
1431      return PE;
1432
1433    const char *FullFileNameStart = BlobStart + Record[3];
1434    const FileEntry *File
1435      = PP.getFileManager().getFile(StringRef(FullFileNameStart,
1436                                               BlobLen - Record[3]));
1437
1438    // FIXME: Stable encoding
1439    InclusionDirective::InclusionKind Kind
1440      = static_cast<InclusionDirective::InclusionKind>(Record[5]);
1441    InclusionDirective *ID
1442      = new (PPRec) InclusionDirective(PPRec, Kind,
1443                                       StringRef(BlobStart, Record[3]),
1444                                       Record[4],
1445                                       File,
1446                                 SourceRange(ReadSourceLocation(F, Record[1]),
1447                                             ReadSourceLocation(F, Record[2])));
1448    PPRec.setLoadedPreallocatedEntity(GlobalID - 1, ID);
1449    return ID;
1450  }
1451  }
1452
1453  Error("invalid offset in preprocessor detail block");
1454  return 0;
1455}
1456
1457PreprocessedEntityID
1458ASTReader::getGlobalPreprocessedEntityID(Module &M, unsigned LocalID) {
1459  ContinuousRangeMap<uint32_t, int, 2>::iterator
1460    I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1461  assert(I != M.PreprocessedEntityRemap.end()
1462         && "Invalid index into preprocessed entity index remap");
1463
1464  return LocalID + I->second;
1465}
1466
1467unsigned HeaderFileInfoTrait::ComputeHash(const char *path) {
1468  return llvm::HashString(llvm::sys::path::filename(path));
1469}
1470
1471HeaderFileInfoTrait::internal_key_type
1472HeaderFileInfoTrait::GetInternalKey(const char *path) { return path; }
1473
1474bool HeaderFileInfoTrait::EqualKey(internal_key_type a, internal_key_type b) {
1475  if (strcmp(a, b) == 0)
1476    return true;
1477
1478  if (llvm::sys::path::filename(a) != llvm::sys::path::filename(b))
1479    return false;
1480
1481  // The file names match, but the path names don't. stat() the files to
1482  // see if they are the same.
1483  struct stat StatBufA, StatBufB;
1484  if (StatSimpleCache(a, &StatBufA) || StatSimpleCache(b, &StatBufB))
1485    return false;
1486
1487  return StatBufA.st_ino == StatBufB.st_ino;
1488}
1489
1490std::pair<unsigned, unsigned>
1491HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1492  unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
1493  unsigned DataLen = (unsigned) *d++;
1494  return std::make_pair(KeyLen + 1, DataLen);
1495}
1496
1497HeaderFileInfoTrait::data_type
1498HeaderFileInfoTrait::ReadData(const internal_key_type, const unsigned char *d,
1499                              unsigned DataLen) {
1500  const unsigned char *End = d + DataLen;
1501  using namespace clang::io;
1502  HeaderFileInfo HFI;
1503  unsigned Flags = *d++;
1504  HFI.isImport = (Flags >> 5) & 0x01;
1505  HFI.isPragmaOnce = (Flags >> 4) & 0x01;
1506  HFI.DirInfo = (Flags >> 2) & 0x03;
1507  HFI.Resolved = (Flags >> 1) & 0x01;
1508  HFI.IndexHeaderMapHeader = Flags & 0x01;
1509  HFI.NumIncludes = ReadUnalignedLE16(d);
1510  HFI.ControllingMacroID = Reader.getGlobalDeclID(M, ReadUnalignedLE32(d));
1511  if (unsigned FrameworkOffset = ReadUnalignedLE32(d)) {
1512    // The framework offset is 1 greater than the actual offset,
1513    // since 0 is used as an indicator for "no framework name".
1514    StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1515    HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1516  }
1517
1518  assert(End == d && "Wrong data length in HeaderFileInfo deserialization");
1519  (void)End;
1520
1521  // This HeaderFileInfo was externally loaded.
1522  HFI.External = true;
1523  return HFI;
1524}
1525
1526void ASTReader::SetIdentifierIsMacro(IdentifierInfo *II, Module &F,
1527                                     uint64_t LocalOffset) {
1528  // Note that this identifier has a macro definition.
1529  II->setHasMacroDefinition(true);
1530
1531  // Adjust the offset to a global offset.
1532  UnreadMacroRecordOffsets[II] = F.GlobalBitOffset + LocalOffset;
1533}
1534
1535void ASTReader::ReadDefinedMacros() {
1536  for (ModuleReverseIterator I = ModuleMgr.rbegin(),
1537      E = ModuleMgr.rend(); I != E; ++I) {
1538    llvm::BitstreamCursor &MacroCursor = (*I)->MacroCursor;
1539
1540    // If there was no preprocessor block, skip this file.
1541    if (!MacroCursor.getBitStreamReader())
1542      continue;
1543
1544    llvm::BitstreamCursor Cursor = MacroCursor;
1545    Cursor.JumpToBit((*I)->MacroStartOffset);
1546
1547    RecordData Record;
1548    while (true) {
1549      unsigned Code = Cursor.ReadCode();
1550      if (Code == llvm::bitc::END_BLOCK)
1551        break;
1552
1553      if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1554        // No known subblocks, always skip them.
1555        Cursor.ReadSubBlockID();
1556        if (Cursor.SkipBlock()) {
1557          Error("malformed block record in AST file");
1558          return;
1559        }
1560        continue;
1561      }
1562
1563      if (Code == llvm::bitc::DEFINE_ABBREV) {
1564        Cursor.ReadAbbrevRecord();
1565        continue;
1566      }
1567
1568      // Read a record.
1569      const char *BlobStart;
1570      unsigned BlobLen;
1571      Record.clear();
1572      switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1573      default:  // Default behavior: ignore.
1574        break;
1575
1576      case PP_MACRO_OBJECT_LIKE:
1577      case PP_MACRO_FUNCTION_LIKE:
1578        getLocalIdentifier(**I, Record[0]);
1579        break;
1580
1581      case PP_TOKEN:
1582        // Ignore tokens.
1583        break;
1584      }
1585    }
1586  }
1587
1588  // Drain the unread macro-record offsets map.
1589  while (!UnreadMacroRecordOffsets.empty())
1590    LoadMacroDefinition(UnreadMacroRecordOffsets.begin());
1591}
1592
1593void ASTReader::LoadMacroDefinition(
1594                     llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos) {
1595  assert(Pos != UnreadMacroRecordOffsets.end() && "Unknown macro definition");
1596  uint64_t Offset = Pos->second;
1597  UnreadMacroRecordOffsets.erase(Pos);
1598
1599  RecordLocation Loc = getLocalBitOffset(Offset);
1600  ReadMacroRecord(*Loc.F, Loc.Offset);
1601}
1602
1603void ASTReader::LoadMacroDefinition(IdentifierInfo *II) {
1604  llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos
1605    = UnreadMacroRecordOffsets.find(II);
1606  LoadMacroDefinition(Pos);
1607}
1608
1609MacroDefinition *ASTReader::getMacroDefinition(MacroID ID) {
1610  if (ID == 0 || ID > MacroDefinitionsLoaded.size())
1611    return 0;
1612
1613  if (!MacroDefinitionsLoaded[ID - 1]) {
1614    GlobalMacroDefinitionMapType::iterator I =GlobalMacroDefinitionMap.find(ID);
1615    assert(I != GlobalMacroDefinitionMap.end() &&
1616           "Corrupted global macro definition map");
1617    Module &M = *I->second;
1618    unsigned Index = ID - 1 - M.BaseMacroDefinitionID;
1619    SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
1620    M.PreprocessorDetailCursor.JumpToBit(M.MacroDefinitionOffsets[Index]);
1621    LoadPreprocessedEntity(M);
1622  }
1623
1624  return MacroDefinitionsLoaded[ID - 1];
1625}
1626
1627const FileEntry *ASTReader::getFileEntry(StringRef filenameStrRef) {
1628  std::string Filename = filenameStrRef;
1629  MaybeAddSystemRootToFilename(Filename);
1630  const FileEntry *File = FileMgr.getFile(Filename);
1631  if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() &&
1632      OriginalDir != CurrentDir) {
1633    std::string resolved = resolveFileRelativeToOriginalDir(Filename,
1634                                                            OriginalDir,
1635                                                            CurrentDir);
1636    if (!resolved.empty())
1637      File = FileMgr.getFile(resolved);
1638  }
1639
1640  return File;
1641}
1642
1643MacroID ASTReader::getGlobalMacroDefinitionID(Module &M, unsigned LocalID) {
1644  if (LocalID < NUM_PREDEF_MACRO_IDS)
1645    return LocalID;
1646
1647  ContinuousRangeMap<uint32_t, int, 2>::iterator I
1648    = M.MacroDefinitionRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
1649  assert(I != M.MacroDefinitionRemap.end() &&
1650         "Invalid index into macro definition ID remap");
1651
1652  return LocalID + I->second;
1653}
1654
1655/// \brief If we are loading a relocatable PCH file, and the filename is
1656/// not an absolute path, add the system root to the beginning of the file
1657/// name.
1658void ASTReader::MaybeAddSystemRootToFilename(std::string &Filename) {
1659  // If this is not a relocatable PCH file, there's nothing to do.
1660  if (!RelocatablePCH)
1661    return;
1662
1663  if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
1664    return;
1665
1666  if (isysroot.empty()) {
1667    // If no system root was given, default to '/'
1668    Filename.insert(Filename.begin(), '/');
1669    return;
1670  }
1671
1672  unsigned Length = isysroot.size();
1673  if (isysroot[Length - 1] != '/')
1674    Filename.insert(Filename.begin(), '/');
1675
1676  Filename.insert(Filename.begin(), isysroot.begin(), isysroot.end());
1677}
1678
1679ASTReader::ASTReadResult
1680ASTReader::ReadASTBlock(Module &F) {
1681  llvm::BitstreamCursor &Stream = F.Stream;
1682
1683  if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
1684    Error("malformed block record in AST file");
1685    return Failure;
1686  }
1687
1688  // Read all of the records and blocks for the ASt file.
1689  RecordData Record;
1690  while (!Stream.AtEndOfStream()) {
1691    unsigned Code = Stream.ReadCode();
1692    if (Code == llvm::bitc::END_BLOCK) {
1693      if (Stream.ReadBlockEnd()) {
1694        Error("error at end of module block in AST file");
1695        return Failure;
1696      }
1697
1698      return Success;
1699    }
1700
1701    if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1702      switch (Stream.ReadSubBlockID()) {
1703      case DECLTYPES_BLOCK_ID:
1704        // We lazily load the decls block, but we want to set up the
1705        // DeclsCursor cursor to point into it.  Clone our current bitcode
1706        // cursor to it, enter the block and read the abbrevs in that block.
1707        // With the main cursor, we just skip over it.
1708        F.DeclsCursor = Stream;
1709        if (Stream.SkipBlock() ||  // Skip with the main cursor.
1710            // Read the abbrevs.
1711            ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
1712          Error("malformed block record in AST file");
1713          return Failure;
1714        }
1715        break;
1716
1717      case DECL_UPDATES_BLOCK_ID:
1718        if (Stream.SkipBlock()) {
1719          Error("malformed block record in AST file");
1720          return Failure;
1721        }
1722        break;
1723
1724      case PREPROCESSOR_BLOCK_ID:
1725        F.MacroCursor = Stream;
1726        if (!PP.getExternalSource())
1727          PP.setExternalSource(this);
1728
1729        if (Stream.SkipBlock() ||
1730            ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
1731          Error("malformed block record in AST file");
1732          return Failure;
1733        }
1734        F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
1735        break;
1736
1737      case PREPROCESSOR_DETAIL_BLOCK_ID:
1738        F.PreprocessorDetailCursor = Stream;
1739        if (Stream.SkipBlock() ||
1740            ReadBlockAbbrevs(F.PreprocessorDetailCursor,
1741                             PREPROCESSOR_DETAIL_BLOCK_ID)) {
1742          Error("malformed preprocessor detail record in AST file");
1743          return Failure;
1744        }
1745        F.PreprocessorDetailStartOffset
1746          = F.PreprocessorDetailCursor.GetCurrentBitNo();
1747
1748        if (!PP.getPreprocessingRecord())
1749          PP.createPreprocessingRecord(true);
1750        if (!PP.getPreprocessingRecord()->getExternalSource())
1751          PP.getPreprocessingRecord()->SetExternalSource(*this);
1752        break;
1753
1754      case SOURCE_MANAGER_BLOCK_ID:
1755        switch (ReadSourceManagerBlock(F)) {
1756        case Success:
1757          break;
1758
1759        case Failure:
1760          Error("malformed source manager block in AST file");
1761          return Failure;
1762
1763        case IgnorePCH:
1764          return IgnorePCH;
1765        }
1766        break;
1767      }
1768      continue;
1769    }
1770
1771    if (Code == llvm::bitc::DEFINE_ABBREV) {
1772      Stream.ReadAbbrevRecord();
1773      continue;
1774    }
1775
1776    // Read and process a record.
1777    Record.clear();
1778    const char *BlobStart = 0;
1779    unsigned BlobLen = 0;
1780    switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record,
1781                                              &BlobStart, &BlobLen)) {
1782    default:  // Default behavior: ignore.
1783      break;
1784
1785    case METADATA: {
1786      if (Record[0] != VERSION_MAJOR && !DisableValidation) {
1787        Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old
1788                                           : diag::warn_pch_version_too_new);
1789        return IgnorePCH;
1790      }
1791
1792      RelocatablePCH = Record[4];
1793      if (Listener) {
1794        std::string TargetTriple(BlobStart, BlobLen);
1795        if (Listener->ReadTargetTriple(TargetTriple))
1796          return IgnorePCH;
1797      }
1798      break;
1799    }
1800
1801    case IMPORTS: {
1802      // Load each of the imported PCH files.
1803      unsigned Idx = 0, N = Record.size();
1804      while (Idx < N) {
1805        // Read information about the AST file.
1806        ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
1807        unsigned Length = Record[Idx++];
1808        llvm::SmallString<128> ImportedFile(Record.begin() + Idx,
1809                                            Record.begin() + Idx + Length);
1810        Idx += Length;
1811
1812        // Load the AST file.
1813        switch(ReadASTCore(ImportedFile, ImportedKind, &F)) {
1814        case Failure: return Failure;
1815          // If we have to ignore the dependency, we'll have to ignore this too.
1816        case IgnorePCH: return IgnorePCH;
1817        case Success: break;
1818        }
1819      }
1820      break;
1821    }
1822
1823    case TYPE_OFFSET: {
1824      if (F.LocalNumTypes != 0) {
1825        Error("duplicate TYPE_OFFSET record in AST file");
1826        return Failure;
1827      }
1828      F.TypeOffsets = (const uint32_t *)BlobStart;
1829      F.LocalNumTypes = Record[0];
1830      unsigned LocalBaseTypeIndex = Record[1];
1831      F.BaseTypeIndex = getTotalNumTypes();
1832
1833      if (F.LocalNumTypes > 0) {
1834        // Introduce the global -> local mapping for types within this module.
1835        GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
1836
1837        // Introduce the local -> global mapping for types within this module.
1838        F.TypeRemap.insert(std::make_pair(LocalBaseTypeIndex,
1839                             F.BaseTypeIndex - LocalBaseTypeIndex));
1840
1841        TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
1842      }
1843      break;
1844    }
1845
1846    case DECL_OFFSET: {
1847      if (F.LocalNumDecls != 0) {
1848        Error("duplicate DECL_OFFSET record in AST file");
1849        return Failure;
1850      }
1851      F.DeclOffsets = (const uint32_t *)BlobStart;
1852      F.LocalNumDecls = Record[0];
1853      unsigned LocalBaseDeclID = Record[1];
1854      F.BaseDeclID = getTotalNumDecls();
1855
1856      if (F.LocalNumDecls > 0) {
1857        // Introduce the global -> local mapping for declarations within this
1858        // module.
1859        GlobalDeclMap.insert(
1860          std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
1861
1862        // Introduce the local -> global mapping for declarations within this
1863        // module.
1864        F.DeclRemap.insert(std::make_pair(LocalBaseDeclID,
1865                                          F.BaseDeclID - LocalBaseDeclID));
1866
1867        DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
1868      }
1869      break;
1870    }
1871
1872    case TU_UPDATE_LEXICAL: {
1873      DeclContext *TU = Context.getTranslationUnitDecl();
1874      DeclContextInfo &Info = F.DeclContextInfos[TU];
1875      Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair *>(BlobStart);
1876      Info.NumLexicalDecls
1877        = static_cast<unsigned int>(BlobLen / sizeof(KindDeclIDPair));
1878      TU->setHasExternalLexicalStorage(true);
1879      break;
1880    }
1881
1882    case UPDATE_VISIBLE: {
1883      unsigned Idx = 0;
1884      serialization::DeclID ID = ReadDeclID(F, Record, Idx);
1885      void *Table = ASTDeclContextNameLookupTable::Create(
1886                        (const unsigned char *)BlobStart + Record[Idx++],
1887                        (const unsigned char *)BlobStart,
1888                        ASTDeclContextNameLookupTrait(*this, F));
1889      if (ID == PREDEF_DECL_TRANSLATION_UNIT_ID) { // Is it the TU?
1890        DeclContext *TU = Context.getTranslationUnitDecl();
1891        F.DeclContextInfos[TU].NameLookupTableData = Table;
1892        TU->setHasExternalVisibleStorage(true);
1893      } else
1894        PendingVisibleUpdates[ID].push_back(std::make_pair(Table, &F));
1895      break;
1896    }
1897
1898    case REDECLS_UPDATE_LATEST: {
1899      assert(Record.size() % 2 == 0 && "Expected pairs of DeclIDs");
1900      for (unsigned i = 0, e = Record.size(); i < e; /* in loop */) {
1901        DeclID First = ReadDeclID(F, Record, i);
1902        DeclID Latest = ReadDeclID(F, Record, i);
1903        FirstLatestDeclIDs[First] = Latest;
1904      }
1905      break;
1906    }
1907
1908    case LANGUAGE_OPTIONS:
1909      if (ParseLanguageOptions(Record) && !DisableValidation)
1910        return IgnorePCH;
1911      break;
1912
1913    case IDENTIFIER_TABLE:
1914      F.IdentifierTableData = BlobStart;
1915      if (Record[0]) {
1916        F.IdentifierLookupTable
1917          = ASTIdentifierLookupTable::Create(
1918                       (const unsigned char *)F.IdentifierTableData + Record[0],
1919                       (const unsigned char *)F.IdentifierTableData,
1920                       ASTIdentifierLookupTrait(*this, F));
1921
1922        PP.getIdentifierTable().setExternalIdentifierLookup(this);
1923      }
1924      break;
1925
1926    case IDENTIFIER_OFFSET: {
1927      if (F.LocalNumIdentifiers != 0) {
1928        Error("duplicate IDENTIFIER_OFFSET record in AST file");
1929        return Failure;
1930      }
1931      F.IdentifierOffsets = (const uint32_t *)BlobStart;
1932      F.LocalNumIdentifiers = Record[0];
1933      unsigned LocalBaseIdentifierID = Record[1];
1934      F.BaseIdentifierID = getTotalNumIdentifiers();
1935
1936      if (F.LocalNumIdentifiers > 0) {
1937        // Introduce the global -> local mapping for identifiers within this
1938        // module.
1939        GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
1940                                                  &F));
1941
1942        // Introduce the local -> global mapping for identifiers within this
1943        // module.
1944        F.IdentifierRemap.insert(
1945                            std::make_pair(LocalBaseIdentifierID,
1946                              F.BaseIdentifierID - LocalBaseIdentifierID));
1947
1948        IdentifiersLoaded.resize(IdentifiersLoaded.size()
1949                                 + F.LocalNumIdentifiers);
1950      }
1951      break;
1952    }
1953
1954    case EXTERNAL_DEFINITIONS:
1955      for (unsigned I = 0, N = Record.size(); I != N; ++I)
1956        ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I]));
1957      break;
1958
1959    case SPECIAL_TYPES:
1960      for (unsigned I = 0, N = Record.size(); I != N; ++I)
1961        SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
1962      break;
1963
1964    case STATISTICS:
1965      TotalNumStatements += Record[0];
1966      TotalNumMacros += Record[1];
1967      TotalLexicalDeclContexts += Record[2];
1968      TotalVisibleDeclContexts += Record[3];
1969      break;
1970
1971    case UNUSED_FILESCOPED_DECLS:
1972      for (unsigned I = 0, N = Record.size(); I != N; ++I)
1973        UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
1974      break;
1975
1976    case DELEGATING_CTORS:
1977      for (unsigned I = 0, N = Record.size(); I != N; ++I)
1978        DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
1979      break;
1980
1981    case WEAK_UNDECLARED_IDENTIFIERS:
1982      if (Record.size() % 4 != 0) {
1983        Error("invalid weak identifiers record");
1984        return Failure;
1985      }
1986
1987      // FIXME: Ignore weak undeclared identifiers from non-original PCH
1988      // files. This isn't the way to do it :)
1989      WeakUndeclaredIdentifiers.clear();
1990
1991      // Translate the weak, undeclared identifiers into global IDs.
1992      for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
1993        WeakUndeclaredIdentifiers.push_back(
1994          getGlobalIdentifierID(F, Record[I++]));
1995        WeakUndeclaredIdentifiers.push_back(
1996          getGlobalIdentifierID(F, Record[I++]));
1997        WeakUndeclaredIdentifiers.push_back(
1998          ReadSourceLocation(F, Record, I).getRawEncoding());
1999        WeakUndeclaredIdentifiers.push_back(Record[I++]);
2000      }
2001      break;
2002
2003    case LOCALLY_SCOPED_EXTERNAL_DECLS:
2004      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2005        LocallyScopedExternalDecls.push_back(getGlobalDeclID(F, Record[I]));
2006      break;
2007
2008    case SELECTOR_OFFSETS: {
2009      F.SelectorOffsets = (const uint32_t *)BlobStart;
2010      F.LocalNumSelectors = Record[0];
2011      unsigned LocalBaseSelectorID = Record[1];
2012      F.BaseSelectorID = getTotalNumSelectors();
2013
2014      if (F.LocalNumSelectors > 0) {
2015        // Introduce the global -> local mapping for selectors within this
2016        // module.
2017        GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
2018
2019        // Introduce the local -> global mapping for selectors within this
2020        // module.
2021        F.SelectorRemap.insert(std::make_pair(LocalBaseSelectorID,
2022                                 F.BaseSelectorID - LocalBaseSelectorID));
2023
2024        SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
2025      }
2026      break;
2027    }
2028
2029    case METHOD_POOL:
2030      F.SelectorLookupTableData = (const unsigned char *)BlobStart;
2031      if (Record[0])
2032        F.SelectorLookupTable
2033          = ASTSelectorLookupTable::Create(
2034                        F.SelectorLookupTableData + Record[0],
2035                        F.SelectorLookupTableData,
2036                        ASTSelectorLookupTrait(*this, F));
2037      TotalNumMethodPoolEntries += Record[1];
2038      break;
2039
2040    case REFERENCED_SELECTOR_POOL:
2041      if (!Record.empty()) {
2042        for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
2043          ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
2044                                                                Record[Idx++]));
2045          ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
2046                                              getRawEncoding());
2047        }
2048      }
2049      break;
2050
2051    case PP_COUNTER_VALUE:
2052      if (!Record.empty() && Listener)
2053        Listener->ReadCounter(Record[0]);
2054      break;
2055
2056    case SOURCE_LOCATION_OFFSETS: {
2057      F.SLocEntryOffsets = (const uint32_t *)BlobStart;
2058      F.LocalNumSLocEntries = Record[0];
2059      llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
2060          SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries, Record[1]);
2061      // Make our entry in the range map. BaseID is negative and growing, so
2062      // we invert it. Because we invert it, though, we need the other end of
2063      // the range.
2064      unsigned RangeStart =
2065          unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
2066      GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
2067      F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
2068
2069      // Initialize the remapping table.
2070      // Invalid stays invalid.
2071      F.SLocRemap.insert(std::make_pair(0U, 0));
2072      // This module. Base was 2 when being compiled.
2073      F.SLocRemap.insert(std::make_pair(2U,
2074                                  static_cast<int>(F.SLocEntryBaseOffset - 2)));
2075
2076      TotalNumSLocEntries += F.LocalNumSLocEntries;
2077      break;
2078    }
2079
2080    case MODULE_OFFSET_MAP: {
2081      // Additional remapping information.
2082      const unsigned char *Data = (const unsigned char*)BlobStart;
2083      const unsigned char *DataEnd = Data + BlobLen;
2084
2085      // Continuous range maps we may be updating in our module.
2086      ContinuousRangeMap<uint32_t, int, 2>::Builder SLocRemap(F.SLocRemap);
2087      ContinuousRangeMap<uint32_t, int, 2>::Builder
2088        IdentifierRemap(F.IdentifierRemap);
2089      ContinuousRangeMap<uint32_t, int, 2>::Builder
2090        PreprocessedEntityRemap(F.PreprocessedEntityRemap);
2091      ContinuousRangeMap<uint32_t, int, 2>::Builder
2092        MacroDefinitionRemap(F.MacroDefinitionRemap);
2093      ContinuousRangeMap<uint32_t, int, 2>::Builder
2094        SelectorRemap(F.SelectorRemap);
2095      ContinuousRangeMap<uint32_t, int, 2>::Builder DeclRemap(F.DeclRemap);
2096      ContinuousRangeMap<uint32_t, int, 2>::Builder TypeRemap(F.TypeRemap);
2097
2098      while(Data < DataEnd) {
2099        uint16_t Len = io::ReadUnalignedLE16(Data);
2100        StringRef Name = StringRef((const char*)Data, Len);
2101        Data += Len;
2102        Module *OM = ModuleMgr.lookup(Name);
2103        if (!OM) {
2104          Error("SourceLocation remap refers to unknown module");
2105          return Failure;
2106        }
2107
2108        uint32_t SLocOffset = io::ReadUnalignedLE32(Data);
2109        uint32_t IdentifierIDOffset = io::ReadUnalignedLE32(Data);
2110        uint32_t PreprocessedEntityIDOffset = io::ReadUnalignedLE32(Data);
2111        uint32_t MacroDefinitionIDOffset = io::ReadUnalignedLE32(Data);
2112        uint32_t SelectorIDOffset = io::ReadUnalignedLE32(Data);
2113        uint32_t DeclIDOffset = io::ReadUnalignedLE32(Data);
2114        uint32_t TypeIndexOffset = io::ReadUnalignedLE32(Data);
2115
2116        // Source location offset is mapped to OM->SLocEntryBaseOffset.
2117        SLocRemap.insert(std::make_pair(SLocOffset,
2118          static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset)));
2119        IdentifierRemap.insert(
2120          std::make_pair(IdentifierIDOffset,
2121                         OM->BaseIdentifierID - IdentifierIDOffset));
2122        PreprocessedEntityRemap.insert(
2123          std::make_pair(PreprocessedEntityIDOffset,
2124            OM->BasePreprocessedEntityID - PreprocessedEntityIDOffset));
2125        MacroDefinitionRemap.insert(
2126          std::make_pair(MacroDefinitionIDOffset,
2127                         OM->BaseMacroDefinitionID - MacroDefinitionIDOffset));
2128        SelectorRemap.insert(std::make_pair(SelectorIDOffset,
2129                               OM->BaseSelectorID - SelectorIDOffset));
2130        DeclRemap.insert(std::make_pair(DeclIDOffset,
2131                                        OM->BaseDeclID - DeclIDOffset));
2132
2133        TypeRemap.insert(std::make_pair(TypeIndexOffset,
2134                                    OM->BaseTypeIndex - TypeIndexOffset));
2135      }
2136      break;
2137    }
2138
2139    case SOURCE_MANAGER_LINE_TABLE:
2140      if (ParseLineTable(F, Record))
2141        return Failure;
2142      break;
2143
2144    case FILE_SOURCE_LOCATION_OFFSETS:
2145      F.SLocFileOffsets = (const uint32_t *)BlobStart;
2146      F.LocalNumSLocFileEntries = Record[0];
2147      break;
2148
2149    case SOURCE_LOCATION_PRELOADS: {
2150      // Need to transform from the local view (1-based IDs) to the global view,
2151      // which is based off F.SLocEntryBaseID.
2152      if (!F.PreloadSLocEntries.empty()) {
2153        Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
2154        return Failure;
2155      }
2156
2157      F.PreloadSLocEntries.swap(Record);
2158      break;
2159    }
2160
2161    case STAT_CACHE: {
2162      if (!DisableStatCache) {
2163        ASTStatCache *MyStatCache =
2164          new ASTStatCache((const unsigned char *)BlobStart + Record[0],
2165                           (const unsigned char *)BlobStart,
2166                           NumStatHits, NumStatMisses);
2167        FileMgr.addStatCache(MyStatCache);
2168        F.StatCache = MyStatCache;
2169      }
2170      break;
2171    }
2172
2173    case EXT_VECTOR_DECLS:
2174      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2175        ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
2176      break;
2177
2178    case VTABLE_USES:
2179      if (Record.size() % 3 != 0) {
2180        Error("Invalid VTABLE_USES record");
2181        return Failure;
2182      }
2183
2184      // Later tables overwrite earlier ones.
2185      // FIXME: Modules will have some trouble with this. This is clearly not
2186      // the right way to do this.
2187      VTableUses.clear();
2188
2189      for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
2190        VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
2191        VTableUses.push_back(
2192          ReadSourceLocation(F, Record, Idx).getRawEncoding());
2193        VTableUses.push_back(Record[Idx++]);
2194      }
2195      break;
2196
2197    case DYNAMIC_CLASSES:
2198      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2199        DynamicClasses.push_back(getGlobalDeclID(F, Record[I]));
2200      break;
2201
2202    case PENDING_IMPLICIT_INSTANTIATIONS:
2203      if (PendingInstantiations.size() % 2 != 0) {
2204        Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
2205        return Failure;
2206      }
2207
2208      // Later lists of pending instantiations overwrite earlier ones.
2209      // FIXME: This is most certainly wrong for modules.
2210      PendingInstantiations.clear();
2211      for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
2212        PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
2213        PendingInstantiations.push_back(
2214          ReadSourceLocation(F, Record, I).getRawEncoding());
2215      }
2216      break;
2217
2218    case SEMA_DECL_REFS:
2219      // Later tables overwrite earlier ones.
2220      // FIXME: Modules will have some trouble with this.
2221      SemaDeclRefs.clear();
2222      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2223        SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
2224      break;
2225
2226    case ORIGINAL_FILE_NAME:
2227      // The primary AST will be the last to get here, so it will be the one
2228      // that's used.
2229      ActualOriginalFileName.assign(BlobStart, BlobLen);
2230      OriginalFileName = ActualOriginalFileName;
2231      MaybeAddSystemRootToFilename(OriginalFileName);
2232      break;
2233
2234    case ORIGINAL_FILE_ID:
2235      OriginalFileID = FileID::get(Record[0]);
2236      break;
2237
2238    case ORIGINAL_PCH_DIR:
2239      // The primary AST will be the last to get here, so it will be the one
2240      // that's used.
2241      OriginalDir.assign(BlobStart, BlobLen);
2242      break;
2243
2244    case VERSION_CONTROL_BRANCH_REVISION: {
2245      const std::string &CurBranch = getClangFullRepositoryVersion();
2246      StringRef ASTBranch(BlobStart, BlobLen);
2247      if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2248        Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch;
2249        return IgnorePCH;
2250      }
2251      break;
2252    }
2253
2254    case MACRO_DEFINITION_OFFSETS: {
2255      F.MacroDefinitionOffsets = (const uint32_t *)BlobStart;
2256      F.NumPreallocatedPreprocessingEntities = Record[0];
2257      unsigned LocalBasePreprocessedEntityID = Record[1];
2258      F.LocalNumMacroDefinitions = Record[2];
2259      unsigned LocalBaseMacroID = Record[3];
2260
2261      unsigned StartingID;
2262      if (!PP.getPreprocessingRecord())
2263        PP.createPreprocessingRecord(true);
2264      if (!PP.getPreprocessingRecord()->getExternalSource())
2265        PP.getPreprocessingRecord()->SetExternalSource(*this);
2266      StartingID
2267        = PP.getPreprocessingRecord()
2268            ->allocateLoadedEntities(F.NumPreallocatedPreprocessingEntities);
2269      F.BaseMacroDefinitionID = getTotalNumMacroDefinitions();
2270      F.BasePreprocessedEntityID = StartingID;
2271
2272      if (F.NumPreallocatedPreprocessingEntities > 0) {
2273        // Introduce the global -> local mapping for preprocessed entities in
2274        // this module.
2275        GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
2276
2277        // Introduce the local -> global mapping for preprocessed entities in
2278        // this module.
2279        F.PreprocessedEntityRemap.insert(
2280          std::make_pair(LocalBasePreprocessedEntityID,
2281            F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
2282      }
2283
2284
2285      if (F.LocalNumMacroDefinitions > 0) {
2286        // Introduce the global -> local mapping for macro definitions within
2287        // this module.
2288        GlobalMacroDefinitionMap.insert(
2289          std::make_pair(getTotalNumMacroDefinitions() + 1, &F));
2290
2291        // Introduce the local -> global mapping for macro definitions within
2292        // this module.
2293        F.MacroDefinitionRemap.insert(
2294          std::make_pair(LocalBaseMacroID,
2295                         F.BaseMacroDefinitionID - LocalBaseMacroID));
2296
2297        MacroDefinitionsLoaded.resize(
2298                    MacroDefinitionsLoaded.size() + F.LocalNumMacroDefinitions);
2299      }
2300
2301      break;
2302    }
2303
2304    case DECL_UPDATE_OFFSETS: {
2305      if (Record.size() % 2 != 0) {
2306        Error("invalid DECL_UPDATE_OFFSETS block in AST file");
2307        return Failure;
2308      }
2309      for (unsigned I = 0, N = Record.size(); I != N; I += 2)
2310        DeclUpdateOffsets[getGlobalDeclID(F, Record[I])]
2311          .push_back(std::make_pair(&F, Record[I+1]));
2312      break;
2313    }
2314
2315    case DECL_REPLACEMENTS: {
2316      if (Record.size() % 2 != 0) {
2317        Error("invalid DECL_REPLACEMENTS block in AST file");
2318        return Failure;
2319      }
2320      for (unsigned I = 0, N = Record.size(); I != N; I += 2)
2321        ReplacedDecls[getGlobalDeclID(F, Record[I])]
2322          = std::make_pair(&F, Record[I+1]);
2323      break;
2324    }
2325
2326    case OBJC_CHAINED_CATEGORIES: {
2327      if (Record.size() % 3 != 0) {
2328        Error("invalid OBJC_CHAINED_CATEGORIES block in AST file");
2329        return Failure;
2330      }
2331      for (unsigned I = 0, N = Record.size(); I != N; I += 3) {
2332        serialization::GlobalDeclID GlobID = getGlobalDeclID(F, Record[I]);
2333        F.ChainedObjCCategories[GlobID] = std::make_pair(Record[I+1],
2334                                                         Record[I+2]);
2335        ObjCChainedCategoriesInterfaces.insert(GlobID);
2336      }
2337      break;
2338    }
2339
2340    case CXX_BASE_SPECIFIER_OFFSETS: {
2341      if (F.LocalNumCXXBaseSpecifiers != 0) {
2342        Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file");
2343        return Failure;
2344      }
2345
2346      F.LocalNumCXXBaseSpecifiers = Record[0];
2347      F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart;
2348      NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers;
2349      break;
2350    }
2351
2352    case DIAG_PRAGMA_MAPPINGS:
2353      if (Record.size() % 2 != 0) {
2354        Error("invalid DIAG_USER_MAPPINGS block in AST file");
2355        return Failure;
2356      }
2357
2358      if (F.PragmaDiagMappings.empty())
2359        F.PragmaDiagMappings.swap(Record);
2360      else
2361        F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(),
2362                                    Record.begin(), Record.end());
2363      break;
2364
2365    case CUDA_SPECIAL_DECL_REFS:
2366      // Later tables overwrite earlier ones.
2367      // FIXME: Modules will have trouble with this.
2368      CUDASpecialDeclRefs.clear();
2369      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2370        CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
2371      break;
2372
2373    case HEADER_SEARCH_TABLE: {
2374      F.HeaderFileInfoTableData = BlobStart;
2375      F.LocalNumHeaderFileInfos = Record[1];
2376      F.HeaderFileFrameworkStrings = BlobStart + Record[2];
2377      if (Record[0]) {
2378        F.HeaderFileInfoTable
2379          = HeaderFileInfoLookupTable::Create(
2380                   (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
2381                   (const unsigned char *)F.HeaderFileInfoTableData,
2382                   HeaderFileInfoTrait(*this, F,
2383                                       &PP.getHeaderSearchInfo(),
2384                                       BlobStart + Record[2]));
2385
2386        PP.getHeaderSearchInfo().SetExternalSource(this);
2387        if (!PP.getHeaderSearchInfo().getExternalLookup())
2388          PP.getHeaderSearchInfo().SetExternalLookup(this);
2389      }
2390      break;
2391    }
2392
2393    case FP_PRAGMA_OPTIONS:
2394      // Later tables overwrite earlier ones.
2395      FPPragmaOptions.swap(Record);
2396      break;
2397
2398    case OPENCL_EXTENSIONS:
2399      // Later tables overwrite earlier ones.
2400      OpenCLExtensions.swap(Record);
2401      break;
2402
2403    case TENTATIVE_DEFINITIONS:
2404      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2405        TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
2406      break;
2407
2408    case KNOWN_NAMESPACES:
2409      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2410        KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
2411      break;
2412    }
2413  }
2414  Error("premature end of bitstream in AST file");
2415  return Failure;
2416}
2417
2418ASTReader::ASTReadResult ASTReader::validateFileEntries(Module &M) {
2419  llvm::BitstreamCursor &SLocEntryCursor = M.SLocEntryCursor;
2420
2421  for (unsigned i = 0, e = M.LocalNumSLocFileEntries; i != e; ++i) {
2422    SLocEntryCursor.JumpToBit(M.SLocFileOffsets[i]);
2423    unsigned Code = SLocEntryCursor.ReadCode();
2424    if (Code == llvm::bitc::END_BLOCK ||
2425        Code == llvm::bitc::ENTER_SUBBLOCK ||
2426        Code == llvm::bitc::DEFINE_ABBREV) {
2427      Error("incorrectly-formatted source location entry in AST file");
2428      return Failure;
2429    }
2430
2431    RecordData Record;
2432    const char *BlobStart;
2433    unsigned BlobLen;
2434    switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
2435    default:
2436      Error("incorrectly-formatted source location entry in AST file");
2437      return Failure;
2438
2439    case SM_SLOC_FILE_ENTRY: {
2440      StringRef Filename(BlobStart, BlobLen);
2441      const FileEntry *File = getFileEntry(Filename);
2442
2443      if (File == 0) {
2444        std::string ErrorStr = "could not find file '";
2445        ErrorStr += Filename;
2446        ErrorStr += "' referenced by AST file";
2447        Error(ErrorStr.c_str());
2448        return IgnorePCH;
2449      }
2450
2451      if (Record.size() < 6) {
2452        Error("source location entry is incorrect");
2453        return Failure;
2454      }
2455
2456      // The stat info from the FileEntry came from the cached stat
2457      // info of the PCH, so we cannot trust it.
2458      struct stat StatBuf;
2459      if (::stat(File->getName(), &StatBuf) != 0) {
2460        StatBuf.st_size = File->getSize();
2461        StatBuf.st_mtime = File->getModificationTime();
2462      }
2463
2464      if (((off_t)Record[4] != StatBuf.st_size
2465#if !defined(LLVM_ON_WIN32)
2466          // In our regression testing, the Windows file system seems to
2467          // have inconsistent modification times that sometimes
2468          // erroneously trigger this error-handling path.
2469           || (time_t)Record[5] != StatBuf.st_mtime
2470#endif
2471          )) {
2472        Error(diag::err_fe_pch_file_modified, Filename);
2473        return IgnorePCH;
2474      }
2475
2476      break;
2477    }
2478    }
2479  }
2480
2481  return Success;
2482}
2483
2484namespace {
2485  /// \brief Visitor class used to look up identifirs in an AST file.
2486  class IdentifierLookupVisitor {
2487    StringRef Name;
2488    IdentifierInfo *Found;
2489  public:
2490    explicit IdentifierLookupVisitor(StringRef Name) : Name(Name), Found() { }
2491
2492    static bool visit(Module &M, void *UserData) {
2493      IdentifierLookupVisitor *This
2494      = static_cast<IdentifierLookupVisitor *>(UserData);
2495
2496      ASTIdentifierLookupTable *IdTable
2497        = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
2498      if (!IdTable)
2499        return false;
2500
2501      std::pair<const char*, unsigned> Key(This->Name.begin(),
2502                                           This->Name.size());
2503      ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key);
2504      if (Pos == IdTable->end())
2505        return false;
2506
2507      // Dereferencing the iterator has the effect of building the
2508      // IdentifierInfo node and populating it with the various
2509      // declarations it needs.
2510      This->Found = *Pos;
2511      return true;
2512    }
2513
2514    // \brief Retrieve the identifier info found within the module
2515    // files.
2516    IdentifierInfo *getIdentifierInfo() const { return Found; }
2517  };
2518}
2519
2520
2521ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName,
2522                                            ModuleKind Type) {
2523  switch(ReadASTCore(FileName, Type, /*ImportedBy=*/0)) {
2524  case Failure: return Failure;
2525  case IgnorePCH: return IgnorePCH;
2526  case Success: break;
2527  }
2528
2529  // Here comes stuff that we only do once the entire chain is loaded.
2530
2531  // Check the predefines buffers.
2532  if (!DisableValidation && Type != MK_Module && Type != MK_Preamble &&
2533      // FIXME: CheckPredefinesBuffers also sets the SuggestedPredefines;
2534      // if DisableValidation is true, defines that were set on command-line
2535      // but not in the PCH file will not be added to SuggestedPredefines.
2536      CheckPredefinesBuffers())
2537    return IgnorePCH;
2538
2539  // Initialization of keywords and pragmas occurs before the
2540  // AST file is read, so there may be some identifiers that were
2541  // loaded into the IdentifierTable before we intercepted the
2542  // creation of identifiers. Iterate through the list of known
2543  // identifiers and determine whether we have to establish
2544  // preprocessor definitions or top-level identifier declaration
2545  // chains for those identifiers.
2546  //
2547  // We copy the IdentifierInfo pointers to a small vector first,
2548  // since de-serializing declarations or macro definitions can add
2549  // new entries into the identifier table, invalidating the
2550  // iterators.
2551  //
2552  // FIXME: We need a lazier way to load this information, e.g., by marking
2553  // the identifier data as 'dirty', so that it will be looked up in the
2554  // AST file(s) if it is uttered in the source. This could save us some
2555  // module load time.
2556  SmallVector<IdentifierInfo *, 128> Identifiers;
2557  for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
2558                              IdEnd = PP.getIdentifierTable().end();
2559       Id != IdEnd; ++Id)
2560    Identifiers.push_back(Id->second);
2561
2562  for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) {
2563    IdentifierLookupVisitor Visitor(Identifiers[I]->getName());
2564    ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor);
2565  }
2566
2567  InitializeContext();
2568
2569  if (DeserializationListener)
2570    DeserializationListener->ReaderInitialized(this);
2571
2572  // If this AST file is a precompiled preamble, then set the main file ID of
2573  // the source manager to the file source file from which the preamble was
2574  // built. This is the only valid way to use a precompiled preamble.
2575  if (Type == MK_Preamble) {
2576    if (OriginalFileID.isInvalid()) {
2577      SourceLocation Loc
2578        = SourceMgr.getLocation(FileMgr.getFile(getOriginalSourceFile()), 1, 1);
2579      if (Loc.isValid())
2580        OriginalFileID = SourceMgr.getDecomposedLoc(Loc).first;
2581    }
2582    else {
2583      OriginalFileID = FileID::get(ModuleMgr.getPrimaryModule().SLocEntryBaseID
2584                                        + OriginalFileID.getOpaqueValue() - 1);
2585    }
2586
2587    if (!OriginalFileID.isInvalid())
2588      SourceMgr.SetPreambleFileID(OriginalFileID);
2589  }
2590
2591  return Success;
2592}
2593
2594ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName,
2595                                                ModuleKind Type,
2596                                                Module *ImportedBy) {
2597  Module *M;
2598  bool NewModule;
2599  std::string ErrorStr;
2600  llvm::tie(M, NewModule) = ModuleMgr.addModule(FileName, Type, ImportedBy,
2601                                                ErrorStr);
2602
2603  if (!M) {
2604    // We couldn't load the module.
2605    std::string Msg = "Unable to load module \"" + FileName.str() + "\": "
2606      + ErrorStr;
2607    Error(Msg);
2608    return Failure;
2609  }
2610
2611  if (!NewModule) {
2612    // We've already loaded this module.
2613    return Success;
2614  }
2615
2616  // FIXME: This seems rather a hack. Should CurrentDir be part of the
2617  // module?
2618  if (FileName != "-") {
2619    CurrentDir = llvm::sys::path::parent_path(FileName);
2620    if (CurrentDir.empty()) CurrentDir = ".";
2621  }
2622
2623  Module &F = *M;
2624  llvm::BitstreamCursor &Stream = F.Stream;
2625  Stream.init(F.StreamFile);
2626  F.SizeInBits = F.Buffer->getBufferSize() * 8;
2627
2628  // Sniff for the signature.
2629  if (Stream.Read(8) != 'C' ||
2630      Stream.Read(8) != 'P' ||
2631      Stream.Read(8) != 'C' ||
2632      Stream.Read(8) != 'H') {
2633    Diag(diag::err_not_a_pch_file) << FileName;
2634    return Failure;
2635  }
2636
2637  while (!Stream.AtEndOfStream()) {
2638    unsigned Code = Stream.ReadCode();
2639
2640    if (Code != llvm::bitc::ENTER_SUBBLOCK) {
2641      Error("invalid record at top-level of AST file");
2642      return Failure;
2643    }
2644
2645    unsigned BlockID = Stream.ReadSubBlockID();
2646
2647    // We only know the AST subblock ID.
2648    switch (BlockID) {
2649    case llvm::bitc::BLOCKINFO_BLOCK_ID:
2650      if (Stream.ReadBlockInfoBlock()) {
2651        Error("malformed BlockInfoBlock in AST file");
2652        return Failure;
2653      }
2654      break;
2655    case AST_BLOCK_ID:
2656      switch (ReadASTBlock(F)) {
2657      case Success:
2658        break;
2659
2660      case Failure:
2661        return Failure;
2662
2663      case IgnorePCH:
2664        // FIXME: We could consider reading through to the end of this
2665        // AST block, skipping subblocks, to see if there are other
2666        // AST blocks elsewhere.
2667
2668        // FIXME: We can't clear loaded slocentries anymore.
2669        //SourceMgr.ClearPreallocatedSLocEntries();
2670
2671        // Remove the stat cache.
2672        if (F.StatCache)
2673          FileMgr.removeStatCache((ASTStatCache*)F.StatCache);
2674
2675        return IgnorePCH;
2676      }
2677      break;
2678    default:
2679      if (Stream.SkipBlock()) {
2680        Error("malformed block record in AST file");
2681        return Failure;
2682      }
2683      break;
2684    }
2685  }
2686
2687  // Once read, set the Module bit base offset and update the size in
2688  // bits of all files we've seen.
2689  F.GlobalBitOffset = TotalModulesSizeInBits;
2690  TotalModulesSizeInBits += F.SizeInBits;
2691  GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
2692
2693  // Make sure that the files this module was built against are still available.
2694  if (!DisableValidation) {
2695    switch(validateFileEntries(*M)) {
2696    case Failure: return Failure;
2697    case IgnorePCH: return IgnorePCH;
2698    case Success: break;
2699    }
2700  }
2701
2702  // Preload SLocEntries.
2703  for (unsigned I = 0, N = M->PreloadSLocEntries.size(); I != N; ++I) {
2704    int Index = int(M->PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
2705    ASTReadResult Result = ReadSLocEntryRecord(Index);
2706    if (Result != Success)
2707      return Failure;
2708  }
2709
2710
2711  return Success;
2712}
2713
2714void ASTReader::InitializeContext() {
2715  // If there's a listener, notify them that we "read" the translation unit.
2716  if (DeserializationListener)
2717    DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
2718                                      Context.getTranslationUnitDecl());
2719
2720  // Make sure we load the declaration update records for the translation unit,
2721  // if there are any.
2722  loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID,
2723                        Context.getTranslationUnitDecl());
2724
2725  // FIXME: Find a better way to deal with collisions between these
2726  // built-in types. Right now, we just ignore the problem.
2727
2728  // Load the special types.
2729  if (SpecialTypes.size() > NumSpecialTypeIDs) {
2730    if (Context.getBuiltinVaListType().isNull()) {
2731      Context.setBuiltinVaListType(
2732        GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST]));
2733    }
2734
2735    if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) {
2736      if (Context.ObjCProtoType.isNull())
2737        Context.ObjCProtoType = GetType(Proto);
2738    }
2739
2740    if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
2741      if (!Context.CFConstantStringTypeDecl)
2742        Context.setCFConstantStringType(GetType(String));
2743    }
2744
2745    if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
2746      QualType FileType = GetType(File);
2747      if (FileType.isNull()) {
2748        Error("FILE type is NULL");
2749        return;
2750      }
2751
2752      if (!Context.FILEDecl) {
2753        if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
2754          Context.setFILEDecl(Typedef->getDecl());
2755        else {
2756          const TagType *Tag = FileType->getAs<TagType>();
2757          if (!Tag) {
2758            Error("Invalid FILE type in AST file");
2759            return;
2760          }
2761          Context.setFILEDecl(Tag->getDecl());
2762        }
2763      }
2764    }
2765
2766    if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) {
2767      QualType Jmp_bufType = GetType(Jmp_buf);
2768      if (Jmp_bufType.isNull()) {
2769        Error("jmp_buf type is NULL");
2770        return;
2771      }
2772
2773      if (!Context.jmp_bufDecl) {
2774        if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
2775          Context.setjmp_bufDecl(Typedef->getDecl());
2776        else {
2777          const TagType *Tag = Jmp_bufType->getAs<TagType>();
2778          if (!Tag) {
2779            Error("Invalid jmp_buf type in AST file");
2780            return;
2781          }
2782          Context.setjmp_bufDecl(Tag->getDecl());
2783        }
2784      }
2785    }
2786
2787    if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) {
2788      QualType Sigjmp_bufType = GetType(Sigjmp_buf);
2789      if (Sigjmp_bufType.isNull()) {
2790        Error("sigjmp_buf type is NULL");
2791        return;
2792      }
2793
2794      if (!Context.sigjmp_bufDecl) {
2795        if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
2796          Context.setsigjmp_bufDecl(Typedef->getDecl());
2797        else {
2798          const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
2799          assert(Tag && "Invalid sigjmp_buf type in AST file");
2800          Context.setsigjmp_bufDecl(Tag->getDecl());
2801        }
2802      }
2803    }
2804
2805    if (unsigned ObjCIdRedef
2806          = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
2807      if (Context.ObjCIdRedefinitionType.isNull())
2808        Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
2809    }
2810
2811    if (unsigned ObjCClassRedef
2812          = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
2813      if (Context.ObjCClassRedefinitionType.isNull())
2814        Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
2815    }
2816
2817    if (unsigned ObjCSelRedef
2818          = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
2819      if (Context.ObjCSelRedefinitionType.isNull())
2820        Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
2821    }
2822  }
2823
2824  ReadPragmaDiagnosticMappings(Context.getDiagnostics());
2825
2826  // If there were any CUDA special declarations, deserialize them.
2827  if (!CUDASpecialDeclRefs.empty()) {
2828    assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
2829    Context.setcudaConfigureCallDecl(
2830                           cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
2831  }
2832}
2833
2834/// \brief Retrieve the name of the original source file name
2835/// directly from the AST file, without actually loading the AST
2836/// file.
2837std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
2838                                             FileManager &FileMgr,
2839                                             Diagnostic &Diags) {
2840  // Open the AST file.
2841  std::string ErrStr;
2842  llvm::OwningPtr<llvm::MemoryBuffer> Buffer;
2843  Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr));
2844  if (!Buffer) {
2845    Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr;
2846    return std::string();
2847  }
2848
2849  // Initialize the stream
2850  llvm::BitstreamReader StreamFile;
2851  llvm::BitstreamCursor Stream;
2852  StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
2853                  (const unsigned char *)Buffer->getBufferEnd());
2854  Stream.init(StreamFile);
2855
2856  // Sniff for the signature.
2857  if (Stream.Read(8) != 'C' ||
2858      Stream.Read(8) != 'P' ||
2859      Stream.Read(8) != 'C' ||
2860      Stream.Read(8) != 'H') {
2861    Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
2862    return std::string();
2863  }
2864
2865  RecordData Record;
2866  while (!Stream.AtEndOfStream()) {
2867    unsigned Code = Stream.ReadCode();
2868
2869    if (Code == llvm::bitc::ENTER_SUBBLOCK) {
2870      unsigned BlockID = Stream.ReadSubBlockID();
2871
2872      // We only know the AST subblock ID.
2873      switch (BlockID) {
2874      case AST_BLOCK_ID:
2875        if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2876          Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
2877          return std::string();
2878        }
2879        break;
2880
2881      default:
2882        if (Stream.SkipBlock()) {
2883          Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
2884          return std::string();
2885        }
2886        break;
2887      }
2888      continue;
2889    }
2890
2891    if (Code == llvm::bitc::END_BLOCK) {
2892      if (Stream.ReadBlockEnd()) {
2893        Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName;
2894        return std::string();
2895      }
2896      continue;
2897    }
2898
2899    if (Code == llvm::bitc::DEFINE_ABBREV) {
2900      Stream.ReadAbbrevRecord();
2901      continue;
2902    }
2903
2904    Record.clear();
2905    const char *BlobStart = 0;
2906    unsigned BlobLen = 0;
2907    if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)
2908          == ORIGINAL_FILE_NAME)
2909      return std::string(BlobStart, BlobLen);
2910  }
2911
2912  return std::string();
2913}
2914
2915/// \brief Parse the record that corresponds to a LangOptions data
2916/// structure.
2917///
2918/// This routine parses the language options from the AST file and then gives
2919/// them to the AST listener if one is set.
2920///
2921/// \returns true if the listener deems the file unacceptable, false otherwise.
2922bool ASTReader::ParseLanguageOptions(
2923                             const SmallVectorImpl<uint64_t> &Record) {
2924  if (Listener) {
2925    LangOptions LangOpts;
2926    unsigned Idx = 0;
2927#define LANGOPT(Name, Bits, Default, Description) \
2928  LangOpts.Name = Record[Idx++];
2929#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
2930  LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
2931#include "clang/Basic/LangOptions.def"
2932
2933    return Listener->ReadLanguageOptions(LangOpts);
2934  }
2935
2936  return false;
2937}
2938
2939namespace {
2940  /// \brief Visitor used by ASTReader::ReadPreprocessedEntities() to load
2941  /// all of the preprocessed entities within a module.
2942  class ReadPreprocessedEntitiesVisitor {
2943    ASTReader &Reader;
2944
2945  public:
2946    explicit ReadPreprocessedEntitiesVisitor(ASTReader &Reader)
2947      : Reader(Reader) { }
2948
2949    static bool visit(Module &M, bool Preorder, void *UserData) {
2950      if (Preorder)
2951        return false;
2952
2953      ReadPreprocessedEntitiesVisitor *This
2954        = static_cast<ReadPreprocessedEntitiesVisitor *>(UserData);
2955
2956      if (!M.PreprocessorDetailCursor.getBitStreamReader())
2957        return false;
2958
2959      SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
2960      M.PreprocessorDetailCursor.JumpToBit(M.PreprocessorDetailStartOffset);
2961      while (This->Reader.LoadPreprocessedEntity(M)) { }
2962      return false;
2963    }
2964  };
2965}
2966
2967void ASTReader::ReadPreprocessedEntities() {
2968  ReadPreprocessedEntitiesVisitor Visitor(*this);
2969  ModuleMgr.visitDepthFirst(&ReadPreprocessedEntitiesVisitor::visit, &Visitor);
2970}
2971
2972PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) {
2973  RecordLocation Loc = getLocalBitOffset(Offset);
2974
2975  // Keep track of where we are in the stream, then jump back there
2976  // after reading this entity.
2977  SavedStreamPosition SavedPosition(Loc.F->PreprocessorDetailCursor);
2978  Loc.F->PreprocessorDetailCursor.JumpToBit(Loc.Offset);
2979  return LoadPreprocessedEntity(*Loc.F);
2980}
2981
2982namespace {
2983  /// \brief Visitor used to search for information about a header file.
2984  class HeaderFileInfoVisitor {
2985    ASTReader &Reader;
2986    const FileEntry *FE;
2987
2988    llvm::Optional<HeaderFileInfo> HFI;
2989
2990  public:
2991    HeaderFileInfoVisitor(ASTReader &Reader, const FileEntry *FE)
2992      : Reader(Reader), FE(FE) { }
2993
2994    static bool visit(Module &M, void *UserData) {
2995      HeaderFileInfoVisitor *This
2996        = static_cast<HeaderFileInfoVisitor *>(UserData);
2997
2998      HeaderFileInfoTrait Trait(This->Reader, M,
2999                                &This->Reader.getPreprocessor().getHeaderSearchInfo(),
3000                                M.HeaderFileFrameworkStrings,
3001                                This->FE->getName());
3002
3003      HeaderFileInfoLookupTable *Table
3004        = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
3005      if (!Table)
3006        return false;
3007
3008      // Look in the on-disk hash table for an entry for this file name.
3009      HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE->getName(),
3010                                                            &Trait);
3011      if (Pos == Table->end())
3012        return false;
3013
3014      This->HFI = *Pos;
3015      return true;
3016    }
3017
3018    llvm::Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
3019  };
3020}
3021
3022HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
3023  HeaderFileInfoVisitor Visitor(*this, FE);
3024  ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor);
3025  if (llvm::Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) {
3026    if (Listener)
3027      Listener->ReadHeaderFileInfo(*HFI, FE->getUID());
3028    return *HFI;
3029  }
3030
3031  return HeaderFileInfo();
3032}
3033
3034void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) {
3035  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3036    Module &F = *(*I);
3037    unsigned Idx = 0;
3038    while (Idx < F.PragmaDiagMappings.size()) {
3039      SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
3040      while (1) {
3041        assert(Idx < F.PragmaDiagMappings.size() &&
3042               "Invalid data, didn't find '-1' marking end of diag/map pairs");
3043        if (Idx >= F.PragmaDiagMappings.size()) {
3044          break; // Something is messed up but at least avoid infinite loop in
3045                 // release build.
3046        }
3047        unsigned DiagID = F.PragmaDiagMappings[Idx++];
3048        if (DiagID == (unsigned)-1) {
3049          break; // no more diag/map pairs for this location.
3050        }
3051        diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++];
3052        Diag.setDiagnosticMapping(DiagID, Map, Loc);
3053      }
3054    }
3055  }
3056}
3057
3058/// \brief Get the correct cursor and offset for loading a type.
3059ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
3060  GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
3061  assert(I != GlobalTypeMap.end() && "Corrupted global type map");
3062  Module *M = I->second;
3063  return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
3064}
3065
3066/// \brief Read and return the type with the given index..
3067///
3068/// The index is the type ID, shifted and minus the number of predefs. This
3069/// routine actually reads the record corresponding to the type at the given
3070/// location. It is a helper routine for GetType, which deals with reading type
3071/// IDs.
3072QualType ASTReader::readTypeRecord(unsigned Index) {
3073  RecordLocation Loc = TypeCursorForIndex(Index);
3074  llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
3075
3076  // Keep track of where we are in the stream, then jump back there
3077  // after reading this type.
3078  SavedStreamPosition SavedPosition(DeclsCursor);
3079
3080  ReadingKindTracker ReadingKind(Read_Type, *this);
3081
3082  // Note that we are loading a type record.
3083  Deserializing AType(this);
3084
3085  unsigned Idx = 0;
3086  DeclsCursor.JumpToBit(Loc.Offset);
3087  RecordData Record;
3088  unsigned Code = DeclsCursor.ReadCode();
3089  switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) {
3090  case TYPE_EXT_QUAL: {
3091    if (Record.size() != 2) {
3092      Error("Incorrect encoding of extended qualifier type");
3093      return QualType();
3094    }
3095    QualType Base = readType(*Loc.F, Record, Idx);
3096    Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
3097    return Context.getQualifiedType(Base, Quals);
3098  }
3099
3100  case TYPE_COMPLEX: {
3101    if (Record.size() != 1) {
3102      Error("Incorrect encoding of complex type");
3103      return QualType();
3104    }
3105    QualType ElemType = readType(*Loc.F, Record, Idx);
3106    return Context.getComplexType(ElemType);
3107  }
3108
3109  case TYPE_POINTER: {
3110    if (Record.size() != 1) {
3111      Error("Incorrect encoding of pointer type");
3112      return QualType();
3113    }
3114    QualType PointeeType = readType(*Loc.F, Record, Idx);
3115    return Context.getPointerType(PointeeType);
3116  }
3117
3118  case TYPE_BLOCK_POINTER: {
3119    if (Record.size() != 1) {
3120      Error("Incorrect encoding of block pointer type");
3121      return QualType();
3122    }
3123    QualType PointeeType = readType(*Loc.F, Record, Idx);
3124    return Context.getBlockPointerType(PointeeType);
3125  }
3126
3127  case TYPE_LVALUE_REFERENCE: {
3128    if (Record.size() != 2) {
3129      Error("Incorrect encoding of lvalue reference type");
3130      return QualType();
3131    }
3132    QualType PointeeType = readType(*Loc.F, Record, Idx);
3133    return Context.getLValueReferenceType(PointeeType, Record[1]);
3134  }
3135
3136  case TYPE_RVALUE_REFERENCE: {
3137    if (Record.size() != 1) {
3138      Error("Incorrect encoding of rvalue reference type");
3139      return QualType();
3140    }
3141    QualType PointeeType = readType(*Loc.F, Record, Idx);
3142    return Context.getRValueReferenceType(PointeeType);
3143  }
3144
3145  case TYPE_MEMBER_POINTER: {
3146    if (Record.size() != 2) {
3147      Error("Incorrect encoding of member pointer type");
3148      return QualType();
3149    }
3150    QualType PointeeType = readType(*Loc.F, Record, Idx);
3151    QualType ClassType = readType(*Loc.F, Record, Idx);
3152    if (PointeeType.isNull() || ClassType.isNull())
3153      return QualType();
3154
3155    return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
3156  }
3157
3158  case TYPE_CONSTANT_ARRAY: {
3159    QualType ElementType = readType(*Loc.F, Record, Idx);
3160    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3161    unsigned IndexTypeQuals = Record[2];
3162    unsigned Idx = 3;
3163    llvm::APInt Size = ReadAPInt(Record, Idx);
3164    return Context.getConstantArrayType(ElementType, Size,
3165                                         ASM, IndexTypeQuals);
3166  }
3167
3168  case TYPE_INCOMPLETE_ARRAY: {
3169    QualType ElementType = readType(*Loc.F, Record, Idx);
3170    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3171    unsigned IndexTypeQuals = Record[2];
3172    return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
3173  }
3174
3175  case TYPE_VARIABLE_ARRAY: {
3176    QualType ElementType = readType(*Loc.F, Record, Idx);
3177    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3178    unsigned IndexTypeQuals = Record[2];
3179    SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
3180    SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
3181    return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
3182                                         ASM, IndexTypeQuals,
3183                                         SourceRange(LBLoc, RBLoc));
3184  }
3185
3186  case TYPE_VECTOR: {
3187    if (Record.size() != 3) {
3188      Error("incorrect encoding of vector type in AST file");
3189      return QualType();
3190    }
3191
3192    QualType ElementType = readType(*Loc.F, Record, Idx);
3193    unsigned NumElements = Record[1];
3194    unsigned VecKind = Record[2];
3195    return Context.getVectorType(ElementType, NumElements,
3196                                  (VectorType::VectorKind)VecKind);
3197  }
3198
3199  case TYPE_EXT_VECTOR: {
3200    if (Record.size() != 3) {
3201      Error("incorrect encoding of extended vector type in AST file");
3202      return QualType();
3203    }
3204
3205    QualType ElementType = readType(*Loc.F, Record, Idx);
3206    unsigned NumElements = Record[1];
3207    return Context.getExtVectorType(ElementType, NumElements);
3208  }
3209
3210  case TYPE_FUNCTION_NO_PROTO: {
3211    if (Record.size() != 6) {
3212      Error("incorrect encoding of no-proto function type");
3213      return QualType();
3214    }
3215    QualType ResultType = readType(*Loc.F, Record, Idx);
3216    FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
3217                               (CallingConv)Record[4], Record[5]);
3218    return Context.getFunctionNoProtoType(ResultType, Info);
3219  }
3220
3221  case TYPE_FUNCTION_PROTO: {
3222    QualType ResultType = readType(*Loc.F, Record, Idx);
3223
3224    FunctionProtoType::ExtProtoInfo EPI;
3225    EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
3226                                        /*hasregparm*/ Record[2],
3227                                        /*regparm*/ Record[3],
3228                                        static_cast<CallingConv>(Record[4]),
3229                                        /*produces*/ Record[5]);
3230
3231    unsigned Idx = 6;
3232    unsigned NumParams = Record[Idx++];
3233    SmallVector<QualType, 16> ParamTypes;
3234    for (unsigned I = 0; I != NumParams; ++I)
3235      ParamTypes.push_back(readType(*Loc.F, Record, Idx));
3236
3237    EPI.Variadic = Record[Idx++];
3238    EPI.TypeQuals = Record[Idx++];
3239    EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
3240    ExceptionSpecificationType EST =
3241        static_cast<ExceptionSpecificationType>(Record[Idx++]);
3242    EPI.ExceptionSpecType = EST;
3243    if (EST == EST_Dynamic) {
3244      EPI.NumExceptions = Record[Idx++];
3245      SmallVector<QualType, 2> Exceptions;
3246      for (unsigned I = 0; I != EPI.NumExceptions; ++I)
3247        Exceptions.push_back(readType(*Loc.F, Record, Idx));
3248      EPI.Exceptions = Exceptions.data();
3249    } else if (EST == EST_ComputedNoexcept) {
3250      EPI.NoexceptExpr = ReadExpr(*Loc.F);
3251    }
3252    return Context.getFunctionType(ResultType, ParamTypes.data(), NumParams,
3253                                    EPI);
3254  }
3255
3256  case TYPE_UNRESOLVED_USING: {
3257    unsigned Idx = 0;
3258    return Context.getTypeDeclType(
3259                  ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
3260  }
3261
3262  case TYPE_TYPEDEF: {
3263    if (Record.size() != 2) {
3264      Error("incorrect encoding of typedef type");
3265      return QualType();
3266    }
3267    unsigned Idx = 0;
3268    TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
3269    QualType Canonical = readType(*Loc.F, Record, Idx);
3270    if (!Canonical.isNull())
3271      Canonical = Context.getCanonicalType(Canonical);
3272    return Context.getTypedefType(Decl, Canonical);
3273  }
3274
3275  case TYPE_TYPEOF_EXPR:
3276    return Context.getTypeOfExprType(ReadExpr(*Loc.F));
3277
3278  case TYPE_TYPEOF: {
3279    if (Record.size() != 1) {
3280      Error("incorrect encoding of typeof(type) in AST file");
3281      return QualType();
3282    }
3283    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3284    return Context.getTypeOfType(UnderlyingType);
3285  }
3286
3287  case TYPE_DECLTYPE:
3288    return Context.getDecltypeType(ReadExpr(*Loc.F));
3289
3290  case TYPE_UNARY_TRANSFORM: {
3291    QualType BaseType = readType(*Loc.F, Record, Idx);
3292    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3293    UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
3294    return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
3295  }
3296
3297  case TYPE_AUTO:
3298    return Context.getAutoType(readType(*Loc.F, Record, Idx));
3299
3300  case TYPE_RECORD: {
3301    if (Record.size() != 2) {
3302      Error("incorrect encoding of record type");
3303      return QualType();
3304    }
3305    unsigned Idx = 0;
3306    bool IsDependent = Record[Idx++];
3307    QualType T
3308      = Context.getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx));
3309    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3310    return T;
3311  }
3312
3313  case TYPE_ENUM: {
3314    if (Record.size() != 2) {
3315      Error("incorrect encoding of enum type");
3316      return QualType();
3317    }
3318    unsigned Idx = 0;
3319    bool IsDependent = Record[Idx++];
3320    QualType T
3321      = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
3322    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3323    return T;
3324  }
3325
3326  case TYPE_ATTRIBUTED: {
3327    if (Record.size() != 3) {
3328      Error("incorrect encoding of attributed type");
3329      return QualType();
3330    }
3331    QualType modifiedType = readType(*Loc.F, Record, Idx);
3332    QualType equivalentType = readType(*Loc.F, Record, Idx);
3333    AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
3334    return Context.getAttributedType(kind, modifiedType, equivalentType);
3335  }
3336
3337  case TYPE_PAREN: {
3338    if (Record.size() != 1) {
3339      Error("incorrect encoding of paren type");
3340      return QualType();
3341    }
3342    QualType InnerType = readType(*Loc.F, Record, Idx);
3343    return Context.getParenType(InnerType);
3344  }
3345
3346  case TYPE_PACK_EXPANSION: {
3347    if (Record.size() != 2) {
3348      Error("incorrect encoding of pack expansion type");
3349      return QualType();
3350    }
3351    QualType Pattern = readType(*Loc.F, Record, Idx);
3352    if (Pattern.isNull())
3353      return QualType();
3354    llvm::Optional<unsigned> NumExpansions;
3355    if (Record[1])
3356      NumExpansions = Record[1] - 1;
3357    return Context.getPackExpansionType(Pattern, NumExpansions);
3358  }
3359
3360  case TYPE_ELABORATED: {
3361    unsigned Idx = 0;
3362    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3363    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3364    QualType NamedType = readType(*Loc.F, Record, Idx);
3365    return Context.getElaboratedType(Keyword, NNS, NamedType);
3366  }
3367
3368  case TYPE_OBJC_INTERFACE: {
3369    unsigned Idx = 0;
3370    ObjCInterfaceDecl *ItfD
3371      = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
3372    return Context.getObjCInterfaceType(ItfD);
3373  }
3374
3375  case TYPE_OBJC_OBJECT: {
3376    unsigned Idx = 0;
3377    QualType Base = readType(*Loc.F, Record, Idx);
3378    unsigned NumProtos = Record[Idx++];
3379    SmallVector<ObjCProtocolDecl*, 4> Protos;
3380    for (unsigned I = 0; I != NumProtos; ++I)
3381      Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
3382    return Context.getObjCObjectType(Base, Protos.data(), NumProtos);
3383  }
3384
3385  case TYPE_OBJC_OBJECT_POINTER: {
3386    unsigned Idx = 0;
3387    QualType Pointee = readType(*Loc.F, Record, Idx);
3388    return Context.getObjCObjectPointerType(Pointee);
3389  }
3390
3391  case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
3392    unsigned Idx = 0;
3393    QualType Parm = readType(*Loc.F, Record, Idx);
3394    QualType Replacement = readType(*Loc.F, Record, Idx);
3395    return
3396      Context.getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm),
3397                                            Replacement);
3398  }
3399
3400  case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
3401    unsigned Idx = 0;
3402    QualType Parm = readType(*Loc.F, Record, Idx);
3403    TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
3404    return Context.getSubstTemplateTypeParmPackType(
3405                                               cast<TemplateTypeParmType>(Parm),
3406                                                     ArgPack);
3407  }
3408
3409  case TYPE_INJECTED_CLASS_NAME: {
3410    CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
3411    QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
3412    // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
3413    // for AST reading, too much interdependencies.
3414    return
3415      QualType(new (Context, TypeAlignment) InjectedClassNameType(D, TST), 0);
3416  }
3417
3418  case TYPE_TEMPLATE_TYPE_PARM: {
3419    unsigned Idx = 0;
3420    unsigned Depth = Record[Idx++];
3421    unsigned Index = Record[Idx++];
3422    bool Pack = Record[Idx++];
3423    TemplateTypeParmDecl *D
3424      = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
3425    return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
3426  }
3427
3428  case TYPE_DEPENDENT_NAME: {
3429    unsigned Idx = 0;
3430    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3431    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3432    const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
3433    QualType Canon = readType(*Loc.F, Record, Idx);
3434    if (!Canon.isNull())
3435      Canon = Context.getCanonicalType(Canon);
3436    return Context.getDependentNameType(Keyword, NNS, Name, Canon);
3437  }
3438
3439  case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
3440    unsigned Idx = 0;
3441    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3442    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3443    const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
3444    unsigned NumArgs = Record[Idx++];
3445    SmallVector<TemplateArgument, 8> Args;
3446    Args.reserve(NumArgs);
3447    while (NumArgs--)
3448      Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
3449    return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
3450                                                      Args.size(), Args.data());
3451  }
3452
3453  case TYPE_DEPENDENT_SIZED_ARRAY: {
3454    unsigned Idx = 0;
3455
3456    // ArrayType
3457    QualType ElementType = readType(*Loc.F, Record, Idx);
3458    ArrayType::ArraySizeModifier ASM
3459      = (ArrayType::ArraySizeModifier)Record[Idx++];
3460    unsigned IndexTypeQuals = Record[Idx++];
3461
3462    // DependentSizedArrayType
3463    Expr *NumElts = ReadExpr(*Loc.F);
3464    SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
3465
3466    return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
3467                                               IndexTypeQuals, Brackets);
3468  }
3469
3470  case TYPE_TEMPLATE_SPECIALIZATION: {
3471    unsigned Idx = 0;
3472    bool IsDependent = Record[Idx++];
3473    TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
3474    SmallVector<TemplateArgument, 8> Args;
3475    ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
3476    QualType Underlying = readType(*Loc.F, Record, Idx);
3477    QualType T;
3478    if (Underlying.isNull())
3479      T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(),
3480                                                          Args.size());
3481    else
3482      T = Context.getTemplateSpecializationType(Name, Args.data(),
3483                                                 Args.size(), Underlying);
3484    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3485    return T;
3486  }
3487  }
3488  // Suppress a GCC warning
3489  return QualType();
3490}
3491
3492class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
3493  ASTReader &Reader;
3494  Module &F;
3495  llvm::BitstreamCursor &DeclsCursor;
3496  const ASTReader::RecordData &Record;
3497  unsigned &Idx;
3498
3499  SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
3500                                    unsigned &I) {
3501    return Reader.ReadSourceLocation(F, R, I);
3502  }
3503
3504  template<typename T>
3505  T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
3506    return Reader.ReadDeclAs<T>(F, Record, Idx);
3507  }
3508
3509public:
3510  TypeLocReader(ASTReader &Reader, Module &F,
3511                const ASTReader::RecordData &Record, unsigned &Idx)
3512    : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx)
3513  { }
3514
3515  // We want compile-time assurance that we've enumerated all of
3516  // these, so unfortunately we have to declare them first, then
3517  // define them out-of-line.
3518#define ABSTRACT_TYPELOC(CLASS, PARENT)
3519#define TYPELOC(CLASS, PARENT) \
3520  void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
3521#include "clang/AST/TypeLocNodes.def"
3522
3523  void VisitFunctionTypeLoc(FunctionTypeLoc);
3524  void VisitArrayTypeLoc(ArrayTypeLoc);
3525};
3526
3527void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
3528  // nothing to do
3529}
3530void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
3531  TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
3532  if (TL.needsExtraLocalData()) {
3533    TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
3534    TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
3535    TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
3536    TL.setModeAttr(Record[Idx++]);
3537  }
3538}
3539void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
3540  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3541}
3542void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
3543  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3544}
3545void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
3546  TL.setCaretLoc(ReadSourceLocation(Record, Idx));
3547}
3548void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
3549  TL.setAmpLoc(ReadSourceLocation(Record, Idx));
3550}
3551void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
3552  TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
3553}
3554void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
3555  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3556  TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3557}
3558void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
3559  TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
3560  TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
3561  if (Record[Idx++])
3562    TL.setSizeExpr(Reader.ReadExpr(F));
3563  else
3564    TL.setSizeExpr(0);
3565}
3566void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
3567  VisitArrayTypeLoc(TL);
3568}
3569void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
3570  VisitArrayTypeLoc(TL);
3571}
3572void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
3573  VisitArrayTypeLoc(TL);
3574}
3575void TypeLocReader::VisitDependentSizedArrayTypeLoc(
3576                                            DependentSizedArrayTypeLoc TL) {
3577  VisitArrayTypeLoc(TL);
3578}
3579void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
3580                                        DependentSizedExtVectorTypeLoc TL) {
3581  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3582}
3583void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
3584  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3585}
3586void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
3587  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3588}
3589void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
3590  TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
3591  TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
3592  TL.setTrailingReturn(Record[Idx++]);
3593  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
3594    TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
3595  }
3596}
3597void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
3598  VisitFunctionTypeLoc(TL);
3599}
3600void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
3601  VisitFunctionTypeLoc(TL);
3602}
3603void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
3604  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3605}
3606void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
3607  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3608}
3609void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
3610  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3611  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3612  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3613}
3614void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
3615  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3616  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3617  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3618  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3619}
3620void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
3621  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3622}
3623void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
3624  TL.setKWLoc(ReadSourceLocation(Record, Idx));
3625  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3626  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3627  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3628}
3629void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
3630  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3631}
3632void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
3633  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3634}
3635void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
3636  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3637}
3638void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
3639  TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
3640  if (TL.hasAttrOperand()) {
3641    SourceRange range;
3642    range.setBegin(ReadSourceLocation(Record, Idx));
3643    range.setEnd(ReadSourceLocation(Record, Idx));
3644    TL.setAttrOperandParensRange(range);
3645  }
3646  if (TL.hasAttrExprOperand()) {
3647    if (Record[Idx++])
3648      TL.setAttrExprOperand(Reader.ReadExpr(F));
3649    else
3650      TL.setAttrExprOperand(0);
3651  } else if (TL.hasAttrEnumOperand())
3652    TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
3653}
3654void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
3655  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3656}
3657void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
3658                                            SubstTemplateTypeParmTypeLoc TL) {
3659  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3660}
3661void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
3662                                          SubstTemplateTypeParmPackTypeLoc TL) {
3663  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3664}
3665void TypeLocReader::VisitTemplateSpecializationTypeLoc(
3666                                           TemplateSpecializationTypeLoc TL) {
3667  TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
3668  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3669  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3670  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3671    TL.setArgLocInfo(i,
3672        Reader.GetTemplateArgumentLocInfo(F,
3673                                          TL.getTypePtr()->getArg(i).getKind(),
3674                                          Record, Idx));
3675}
3676void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
3677  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3678  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3679}
3680void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
3681  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3682  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3683}
3684void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
3685  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3686}
3687void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
3688  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3689  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3690  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3691}
3692void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
3693       DependentTemplateSpecializationTypeLoc TL) {
3694  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3695  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3696  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3697  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3698  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3699  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
3700    TL.setArgLocInfo(I,
3701        Reader.GetTemplateArgumentLocInfo(F,
3702                                          TL.getTypePtr()->getArg(I).getKind(),
3703                                          Record, Idx));
3704}
3705void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
3706  TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
3707}
3708void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
3709  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3710}
3711void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
3712  TL.setHasBaseTypeAsWritten(Record[Idx++]);
3713  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3714  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3715  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
3716    TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
3717}
3718void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
3719  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3720}
3721
3722TypeSourceInfo *ASTReader::GetTypeSourceInfo(Module &F,
3723                                             const RecordData &Record,
3724                                             unsigned &Idx) {
3725  QualType InfoTy = readType(F, Record, Idx);
3726  if (InfoTy.isNull())
3727    return 0;
3728
3729  TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
3730  TypeLocReader TLR(*this, F, Record, Idx);
3731  for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
3732    TLR.Visit(TL);
3733  return TInfo;
3734}
3735
3736QualType ASTReader::GetType(TypeID ID) {
3737  unsigned FastQuals = ID & Qualifiers::FastMask;
3738  unsigned Index = ID >> Qualifiers::FastWidth;
3739
3740  if (Index < NUM_PREDEF_TYPE_IDS) {
3741    QualType T;
3742    switch ((PredefinedTypeIDs)Index) {
3743    case PREDEF_TYPE_NULL_ID: return QualType();
3744    case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break;
3745    case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break;
3746
3747    case PREDEF_TYPE_CHAR_U_ID:
3748    case PREDEF_TYPE_CHAR_S_ID:
3749      // FIXME: Check that the signedness of CharTy is correct!
3750      T = Context.CharTy;
3751      break;
3752
3753    case PREDEF_TYPE_UCHAR_ID:      T = Context.UnsignedCharTy;     break;
3754    case PREDEF_TYPE_USHORT_ID:     T = Context.UnsignedShortTy;    break;
3755    case PREDEF_TYPE_UINT_ID:       T = Context.UnsignedIntTy;      break;
3756    case PREDEF_TYPE_ULONG_ID:      T = Context.UnsignedLongTy;     break;
3757    case PREDEF_TYPE_ULONGLONG_ID:  T = Context.UnsignedLongLongTy; break;
3758    case PREDEF_TYPE_UINT128_ID:    T = Context.UnsignedInt128Ty;   break;
3759    case PREDEF_TYPE_SCHAR_ID:      T = Context.SignedCharTy;       break;
3760    case PREDEF_TYPE_WCHAR_ID:      T = Context.WCharTy;            break;
3761    case PREDEF_TYPE_SHORT_ID:      T = Context.ShortTy;            break;
3762    case PREDEF_TYPE_INT_ID:        T = Context.IntTy;              break;
3763    case PREDEF_TYPE_LONG_ID:       T = Context.LongTy;             break;
3764    case PREDEF_TYPE_LONGLONG_ID:   T = Context.LongLongTy;         break;
3765    case PREDEF_TYPE_INT128_ID:     T = Context.Int128Ty;           break;
3766    case PREDEF_TYPE_FLOAT_ID:      T = Context.FloatTy;            break;
3767    case PREDEF_TYPE_DOUBLE_ID:     T = Context.DoubleTy;           break;
3768    case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy;       break;
3769    case PREDEF_TYPE_OVERLOAD_ID:   T = Context.OverloadTy;         break;
3770    case PREDEF_TYPE_BOUND_MEMBER:  T = Context.BoundMemberTy;      break;
3771    case PREDEF_TYPE_DEPENDENT_ID:  T = Context.DependentTy;        break;
3772    case PREDEF_TYPE_UNKNOWN_ANY:   T = Context.UnknownAnyTy;       break;
3773    case PREDEF_TYPE_NULLPTR_ID:    T = Context.NullPtrTy;          break;
3774    case PREDEF_TYPE_CHAR16_ID:     T = Context.Char16Ty;           break;
3775    case PREDEF_TYPE_CHAR32_ID:     T = Context.Char32Ty;           break;
3776    case PREDEF_TYPE_OBJC_ID:       T = Context.ObjCBuiltinIdTy;    break;
3777    case PREDEF_TYPE_OBJC_CLASS:    T = Context.ObjCBuiltinClassTy; break;
3778    case PREDEF_TYPE_OBJC_SEL:      T = Context.ObjCBuiltinSelTy;   break;
3779    case PREDEF_TYPE_AUTO_DEDUCT:   T = Context.getAutoDeductType(); break;
3780
3781    case PREDEF_TYPE_AUTO_RREF_DEDUCT:
3782      T = Context.getAutoRRefDeductType();
3783      break;
3784    }
3785
3786    assert(!T.isNull() && "Unknown predefined type");
3787    return T.withFastQualifiers(FastQuals);
3788  }
3789
3790  Index -= NUM_PREDEF_TYPE_IDS;
3791  assert(Index < TypesLoaded.size() && "Type index out-of-range");
3792  if (TypesLoaded[Index].isNull()) {
3793    TypesLoaded[Index] = readTypeRecord(Index);
3794    if (TypesLoaded[Index].isNull())
3795      return QualType();
3796
3797    TypesLoaded[Index]->setFromAST();
3798    if (DeserializationListener)
3799      DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
3800                                        TypesLoaded[Index]);
3801  }
3802
3803  return TypesLoaded[Index].withFastQualifiers(FastQuals);
3804}
3805
3806QualType ASTReader::getLocalType(Module &F, unsigned LocalID) {
3807  return GetType(getGlobalTypeID(F, LocalID));
3808}
3809
3810serialization::TypeID
3811ASTReader::getGlobalTypeID(Module &F, unsigned LocalID) const {
3812  unsigned FastQuals = LocalID & Qualifiers::FastMask;
3813  unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
3814
3815  if (LocalIndex < NUM_PREDEF_TYPE_IDS)
3816    return LocalID;
3817
3818  ContinuousRangeMap<uint32_t, int, 2>::iterator I
3819    = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
3820  assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
3821
3822  unsigned GlobalIndex = LocalIndex + I->second;
3823  return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
3824}
3825
3826TemplateArgumentLocInfo
3827ASTReader::GetTemplateArgumentLocInfo(Module &F,
3828                                      TemplateArgument::ArgKind Kind,
3829                                      const RecordData &Record,
3830                                      unsigned &Index) {
3831  switch (Kind) {
3832  case TemplateArgument::Expression:
3833    return ReadExpr(F);
3834  case TemplateArgument::Type:
3835    return GetTypeSourceInfo(F, Record, Index);
3836  case TemplateArgument::Template: {
3837    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
3838                                                                     Index);
3839    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
3840    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
3841                                   SourceLocation());
3842  }
3843  case TemplateArgument::TemplateExpansion: {
3844    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
3845                                                                     Index);
3846    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
3847    SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
3848    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
3849                                   EllipsisLoc);
3850  }
3851  case TemplateArgument::Null:
3852  case TemplateArgument::Integral:
3853  case TemplateArgument::Declaration:
3854  case TemplateArgument::Pack:
3855    return TemplateArgumentLocInfo();
3856  }
3857  llvm_unreachable("unexpected template argument loc");
3858  return TemplateArgumentLocInfo();
3859}
3860
3861TemplateArgumentLoc
3862ASTReader::ReadTemplateArgumentLoc(Module &F,
3863                                   const RecordData &Record, unsigned &Index) {
3864  TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
3865
3866  if (Arg.getKind() == TemplateArgument::Expression) {
3867    if (Record[Index++]) // bool InfoHasSameExpr.
3868      return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
3869  }
3870  return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
3871                                                             Record, Index));
3872}
3873
3874Decl *ASTReader::GetExternalDecl(uint32_t ID) {
3875  return GetDecl(ID);
3876}
3877
3878uint64_t ASTReader::readCXXBaseSpecifiers(Module &M, const RecordData &Record,
3879                                          unsigned &Idx){
3880  if (Idx >= Record.size())
3881    return 0;
3882
3883  unsigned LocalID = Record[Idx++];
3884  return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]);
3885}
3886
3887CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
3888  RecordLocation Loc = getLocalBitOffset(Offset);
3889  llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor;
3890  SavedStreamPosition SavedPosition(Cursor);
3891  Cursor.JumpToBit(Loc.Offset);
3892  ReadingKindTracker ReadingKind(Read_Decl, *this);
3893  RecordData Record;
3894  unsigned Code = Cursor.ReadCode();
3895  unsigned RecCode = Cursor.ReadRecord(Code, Record);
3896  if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
3897    Error("Malformed AST file: missing C++ base specifiers");
3898    return 0;
3899  }
3900
3901  unsigned Idx = 0;
3902  unsigned NumBases = Record[Idx++];
3903  void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
3904  CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
3905  for (unsigned I = 0; I != NumBases; ++I)
3906    Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
3907  return Bases;
3908}
3909
3910serialization::DeclID
3911ASTReader::getGlobalDeclID(Module &F, unsigned LocalID) const {
3912  if (LocalID < NUM_PREDEF_DECL_IDS)
3913    return LocalID;
3914
3915  ContinuousRangeMap<uint32_t, int, 2>::iterator I
3916    = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
3917  assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
3918
3919  return LocalID + I->second;
3920}
3921
3922bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
3923                                   Module &M) const {
3924  GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID);
3925  assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
3926  return &M == I->second;
3927}
3928
3929Decl *ASTReader::GetDecl(DeclID ID) {
3930  if (ID < NUM_PREDEF_DECL_IDS) {
3931    switch ((PredefinedDeclIDs)ID) {
3932    case PREDEF_DECL_NULL_ID:
3933      return 0;
3934
3935    case PREDEF_DECL_TRANSLATION_UNIT_ID:
3936      return Context.getTranslationUnitDecl();
3937
3938    case PREDEF_DECL_OBJC_ID_ID:
3939      return Context.getObjCIdDecl();
3940
3941    case PREDEF_DECL_OBJC_SEL_ID:
3942      return Context.getObjCSelDecl();
3943
3944    case PREDEF_DECL_OBJC_CLASS_ID:
3945      return Context.getObjCClassDecl();
3946
3947    case PREDEF_DECL_INT_128_ID:
3948      return Context.getInt128Decl();
3949
3950    case PREDEF_DECL_UNSIGNED_INT_128_ID:
3951      return Context.getUInt128Decl();
3952
3953    case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
3954      return Context.getObjCInstanceTypeDecl();
3955    }
3956
3957    return 0;
3958  }
3959
3960  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
3961
3962  if (Index > DeclsLoaded.size()) {
3963    Error("declaration ID out-of-range for AST file");
3964    return 0;
3965  }
3966
3967if (!DeclsLoaded[Index]) {
3968    ReadDeclRecord(ID);
3969    if (DeserializationListener)
3970      DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
3971  }
3972
3973  return DeclsLoaded[Index];
3974}
3975
3976serialization::DeclID ASTReader::ReadDeclID(Module &F,
3977                                            const RecordData &Record,
3978                                            unsigned &Idx) {
3979  if (Idx >= Record.size()) {
3980    Error("Corrupted AST file");
3981    return 0;
3982  }
3983
3984  return getGlobalDeclID(F, Record[Idx++]);
3985}
3986
3987/// \brief Resolve the offset of a statement into a statement.
3988///
3989/// This operation will read a new statement from the external
3990/// source each time it is called, and is meant to be used via a
3991/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
3992Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
3993  // Switch case IDs are per Decl.
3994  ClearSwitchCaseIDs();
3995
3996  // Offset here is a global offset across the entire chain.
3997  RecordLocation Loc = getLocalBitOffset(Offset);
3998  Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
3999  return ReadStmtFromStream(*Loc.F);
4000}
4001
4002namespace {
4003  class FindExternalLexicalDeclsVisitor {
4004    ASTReader &Reader;
4005    const DeclContext *DC;
4006    bool (*isKindWeWant)(Decl::Kind);
4007
4008    SmallVectorImpl<Decl*> &Decls;
4009    bool PredefsVisited[NUM_PREDEF_DECL_IDS];
4010
4011  public:
4012    FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC,
4013                                    bool (*isKindWeWant)(Decl::Kind),
4014                                    SmallVectorImpl<Decl*> &Decls)
4015      : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls)
4016    {
4017      for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I)
4018        PredefsVisited[I] = false;
4019    }
4020
4021    static bool visit(Module &M, bool Preorder, void *UserData) {
4022      if (Preorder)
4023        return false;
4024
4025      FindExternalLexicalDeclsVisitor *This
4026        = static_cast<FindExternalLexicalDeclsVisitor *>(UserData);
4027
4028      Module::DeclContextInfosMap::iterator Info
4029        = M.DeclContextInfos.find(This->DC);
4030      if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls)
4031        return false;
4032
4033      // Load all of the declaration IDs
4034      for (const KindDeclIDPair *ID = Info->second.LexicalDecls,
4035                               *IDE = ID + Info->second.NumLexicalDecls;
4036           ID != IDE; ++ID) {
4037        if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first))
4038          continue;
4039
4040        // Don't add predefined declarations to the lexical context more
4041        // than once.
4042        if (ID->second < NUM_PREDEF_DECL_IDS) {
4043          if (This->PredefsVisited[ID->second])
4044            continue;
4045
4046          This->PredefsVisited[ID->second] = true;
4047        }
4048
4049        if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) {
4050          if (!This->DC->isDeclInLexicalTraversal(D))
4051            This->Decls.push_back(D);
4052        }
4053      }
4054
4055      return false;
4056    }
4057  };
4058}
4059
4060ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
4061                                         bool (*isKindWeWant)(Decl::Kind),
4062                                         SmallVectorImpl<Decl*> &Decls) {
4063  // There might be lexical decls in multiple modules, for the TU at
4064  // least. Walk all of the modules in the order they were loaded.
4065  FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls);
4066  ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor);
4067  ++NumLexicalDeclContextsRead;
4068  return ELR_Success;
4069}
4070
4071namespace {
4072  /// \brief Module visitor used to perform name lookup into a
4073  /// declaration context.
4074  class DeclContextNameLookupVisitor {
4075    ASTReader &Reader;
4076    const DeclContext *DC;
4077    DeclarationName Name;
4078    SmallVectorImpl<NamedDecl *> &Decls;
4079
4080  public:
4081    DeclContextNameLookupVisitor(ASTReader &Reader,
4082                                 const DeclContext *DC, DeclarationName Name,
4083                                 SmallVectorImpl<NamedDecl *> &Decls)
4084      : Reader(Reader), DC(DC), Name(Name), Decls(Decls) { }
4085
4086    static bool visit(Module &M, void *UserData) {
4087      DeclContextNameLookupVisitor *This
4088        = static_cast<DeclContextNameLookupVisitor *>(UserData);
4089
4090      // Check whether we have any visible declaration information for
4091      // this context in this module.
4092      Module::DeclContextInfosMap::iterator Info
4093        = M.DeclContextInfos.find(This->DC);
4094      if (Info == M.DeclContextInfos.end() || !Info->second.NameLookupTableData)
4095        return false;
4096
4097      // Look for this name within this module.
4098      ASTDeclContextNameLookupTable *LookupTable =
4099        (ASTDeclContextNameLookupTable*)Info->second.NameLookupTableData;
4100      ASTDeclContextNameLookupTable::iterator Pos
4101        = LookupTable->find(This->Name);
4102      if (Pos == LookupTable->end())
4103        return false;
4104
4105      bool FoundAnything = false;
4106      ASTDeclContextNameLookupTrait::data_type Data = *Pos;
4107      for (; Data.first != Data.second; ++Data.first) {
4108        NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first);
4109        if (!ND)
4110          continue;
4111
4112        if (ND->getDeclName() != This->Name) {
4113          assert(!This->Name.getCXXNameType().isNull() &&
4114                 "Name mismatch without a type");
4115          continue;
4116        }
4117
4118        // Record this declaration.
4119        FoundAnything = true;
4120        This->Decls.push_back(ND);
4121      }
4122
4123      return FoundAnything;
4124    }
4125  };
4126}
4127
4128DeclContext::lookup_result
4129ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
4130                                          DeclarationName Name) {
4131  assert(DC->hasExternalVisibleStorage() &&
4132         "DeclContext has no visible decls in storage");
4133  if (!Name)
4134    return DeclContext::lookup_result(DeclContext::lookup_iterator(0),
4135                                      DeclContext::lookup_iterator(0));
4136
4137  SmallVector<NamedDecl *, 64> Decls;
4138  DeclContextNameLookupVisitor Visitor(*this, DC, Name, Decls);
4139  ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor);
4140  ++NumVisibleDeclContextsRead;
4141  SetExternalVisibleDeclsForName(DC, Name, Decls);
4142  return const_cast<DeclContext*>(DC)->lookup(Name);
4143}
4144
4145void ASTReader::PassInterestingDeclsToConsumer() {
4146  assert(Consumer);
4147  while (!InterestingDecls.empty()) {
4148    DeclGroupRef DG(InterestingDecls.front());
4149    InterestingDecls.pop_front();
4150    Consumer->HandleInterestingDecl(DG);
4151  }
4152}
4153
4154void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
4155  this->Consumer = Consumer;
4156
4157  if (!Consumer)
4158    return;
4159
4160  for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
4161    // Force deserialization of this decl, which will cause it to be queued for
4162    // passing to the consumer.
4163    GetDecl(ExternalDefinitions[I]);
4164  }
4165
4166  PassInterestingDeclsToConsumer();
4167}
4168
4169void ASTReader::PrintStats() {
4170  std::fprintf(stderr, "*** AST File Statistics:\n");
4171
4172  unsigned NumTypesLoaded
4173    = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
4174                                      QualType());
4175  unsigned NumDeclsLoaded
4176    = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
4177                                      (Decl *)0);
4178  unsigned NumIdentifiersLoaded
4179    = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
4180                                            IdentifiersLoaded.end(),
4181                                            (IdentifierInfo *)0);
4182  unsigned NumSelectorsLoaded
4183    = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
4184                                          SelectorsLoaded.end(),
4185                                          Selector());
4186
4187  std::fprintf(stderr, "  %u stat cache hits\n", NumStatHits);
4188  std::fprintf(stderr, "  %u stat cache misses\n", NumStatMisses);
4189  if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
4190    std::fprintf(stderr, "  %u/%u source location entries read (%f%%)\n",
4191                 NumSLocEntriesRead, TotalNumSLocEntries,
4192                 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
4193  if (!TypesLoaded.empty())
4194    std::fprintf(stderr, "  %u/%u types read (%f%%)\n",
4195                 NumTypesLoaded, (unsigned)TypesLoaded.size(),
4196                 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
4197  if (!DeclsLoaded.empty())
4198    std::fprintf(stderr, "  %u/%u declarations read (%f%%)\n",
4199                 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
4200                 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
4201  if (!IdentifiersLoaded.empty())
4202    std::fprintf(stderr, "  %u/%u identifiers read (%f%%)\n",
4203                 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
4204                 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
4205  if (!SelectorsLoaded.empty())
4206    std::fprintf(stderr, "  %u/%u selectors read (%f%%)\n",
4207                 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
4208                 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
4209  if (TotalNumStatements)
4210    std::fprintf(stderr, "  %u/%u statements read (%f%%)\n",
4211                 NumStatementsRead, TotalNumStatements,
4212                 ((float)NumStatementsRead/TotalNumStatements * 100));
4213  if (TotalNumMacros)
4214    std::fprintf(stderr, "  %u/%u macros read (%f%%)\n",
4215                 NumMacrosRead, TotalNumMacros,
4216                 ((float)NumMacrosRead/TotalNumMacros * 100));
4217  if (TotalLexicalDeclContexts)
4218    std::fprintf(stderr, "  %u/%u lexical declcontexts read (%f%%)\n",
4219                 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
4220                 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
4221                  * 100));
4222  if (TotalVisibleDeclContexts)
4223    std::fprintf(stderr, "  %u/%u visible declcontexts read (%f%%)\n",
4224                 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
4225                 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
4226                  * 100));
4227  if (TotalNumMethodPoolEntries) {
4228    std::fprintf(stderr, "  %u/%u method pool entries read (%f%%)\n",
4229                 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
4230                 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
4231                  * 100));
4232    std::fprintf(stderr, "  %u method pool misses\n", NumMethodPoolMisses);
4233  }
4234  std::fprintf(stderr, "\n");
4235  dump();
4236  std::fprintf(stderr, "\n");
4237}
4238
4239template<typename Key, typename Module, unsigned InitialCapacity>
4240static void
4241dumpModuleIDMap(StringRef Name,
4242                const ContinuousRangeMap<Key, Module *,
4243                                         InitialCapacity> &Map) {
4244  if (Map.begin() == Map.end())
4245    return;
4246
4247  typedef ContinuousRangeMap<Key, Module *, InitialCapacity> MapType;
4248  llvm::errs() << Name << ":\n";
4249  for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
4250       I != IEnd; ++I) {
4251    llvm::errs() << "  " << I->first << " -> " << I->second->FileName
4252      << "\n";
4253  }
4254}
4255
4256void ASTReader::dump() {
4257  llvm::errs() << "*** PCH/Module Remappings:\n";
4258  dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
4259  dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
4260  dumpModuleIDMap("Global type map", GlobalTypeMap);
4261  dumpModuleIDMap("Global declaration map", GlobalDeclMap);
4262  dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
4263  dumpModuleIDMap("Global selector map", GlobalSelectorMap);
4264  dumpModuleIDMap("Global macro definition map", GlobalMacroDefinitionMap);
4265  dumpModuleIDMap("Global preprocessed entity map",
4266                  GlobalPreprocessedEntityMap);
4267
4268  llvm::errs() << "\n*** PCH/Modules Loaded:";
4269  for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(),
4270                                       MEnd = ModuleMgr.end();
4271       M != MEnd; ++M)
4272    (*M)->dump();
4273}
4274
4275/// Return the amount of memory used by memory buffers, breaking down
4276/// by heap-backed versus mmap'ed memory.
4277void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
4278  for (ModuleConstIterator I = ModuleMgr.begin(),
4279      E = ModuleMgr.end(); I != E; ++I) {
4280    if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
4281      size_t bytes = buf->getBufferSize();
4282      switch (buf->getBufferKind()) {
4283        case llvm::MemoryBuffer::MemoryBuffer_Malloc:
4284          sizes.malloc_bytes += bytes;
4285          break;
4286        case llvm::MemoryBuffer::MemoryBuffer_MMap:
4287          sizes.mmap_bytes += bytes;
4288          break;
4289      }
4290    }
4291  }
4292}
4293
4294void ASTReader::InitializeSema(Sema &S) {
4295  SemaObj = &S;
4296  S.ExternalSource = this;
4297
4298  // Makes sure any declarations that were deserialized "too early"
4299  // still get added to the identifier's declaration chains.
4300  for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
4301    if (SemaObj->TUScope)
4302      SemaObj->TUScope->AddDecl(PreloadedDecls[I]);
4303
4304    SemaObj->IdResolver.AddDecl(PreloadedDecls[I]);
4305  }
4306  PreloadedDecls.clear();
4307
4308  // Load the offsets of the declarations that Sema references.
4309  // They will be lazily deserialized when needed.
4310  if (!SemaDeclRefs.empty()) {
4311    assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
4312    if (!SemaObj->StdNamespace)
4313      SemaObj->StdNamespace = SemaDeclRefs[0];
4314    if (!SemaObj->StdBadAlloc)
4315      SemaObj->StdBadAlloc = SemaDeclRefs[1];
4316  }
4317
4318  if (!FPPragmaOptions.empty()) {
4319    assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
4320    SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
4321  }
4322
4323  if (!OpenCLExtensions.empty()) {
4324    unsigned I = 0;
4325#define OPENCLEXT(nm)  SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
4326#include "clang/Basic/OpenCLExtensions.def"
4327
4328    assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
4329  }
4330}
4331
4332IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
4333  IdentifierLookupVisitor Visitor(StringRef(NameStart, NameEnd - NameStart));
4334  ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor);
4335  return Visitor.getIdentifierInfo();
4336}
4337
4338namespace clang {
4339  /// \brief An identifier-lookup iterator that enumerates all of the
4340  /// identifiers stored within a set of AST files.
4341  class ASTIdentifierIterator : public IdentifierIterator {
4342    /// \brief The AST reader whose identifiers are being enumerated.
4343    const ASTReader &Reader;
4344
4345    /// \brief The current index into the chain of AST files stored in
4346    /// the AST reader.
4347    unsigned Index;
4348
4349    /// \brief The current position within the identifier lookup table
4350    /// of the current AST file.
4351    ASTIdentifierLookupTable::key_iterator Current;
4352
4353    /// \brief The end position within the identifier lookup table of
4354    /// the current AST file.
4355    ASTIdentifierLookupTable::key_iterator End;
4356
4357  public:
4358    explicit ASTIdentifierIterator(const ASTReader &Reader);
4359
4360    virtual StringRef Next();
4361  };
4362}
4363
4364ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
4365  : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
4366  ASTIdentifierLookupTable *IdTable
4367    = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
4368  Current = IdTable->key_begin();
4369  End = IdTable->key_end();
4370}
4371
4372StringRef ASTIdentifierIterator::Next() {
4373  while (Current == End) {
4374    // If we have exhausted all of our AST files, we're done.
4375    if (Index == 0)
4376      return StringRef();
4377
4378    --Index;
4379    ASTIdentifierLookupTable *IdTable
4380      = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
4381        IdentifierLookupTable;
4382    Current = IdTable->key_begin();
4383    End = IdTable->key_end();
4384  }
4385
4386  // We have any identifiers remaining in the current AST file; return
4387  // the next one.
4388  std::pair<const char*, unsigned> Key = *Current;
4389  ++Current;
4390  return StringRef(Key.first, Key.second);
4391}
4392
4393IdentifierIterator *ASTReader::getIdentifiers() const {
4394  return new ASTIdentifierIterator(*this);
4395}
4396
4397namespace clang { namespace serialization {
4398  class ReadMethodPoolVisitor {
4399    ASTReader &Reader;
4400    Selector Sel;
4401    llvm::SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
4402    llvm::SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
4403
4404    /// \brief Build an ObjCMethodList from a vector of Objective-C method
4405    /// declarations.
4406    ObjCMethodList
4407    buildObjCMethodList(const SmallVectorImpl<ObjCMethodDecl *> &Vec) const
4408    {
4409      ObjCMethodList List;
4410      ObjCMethodList *Prev = 0;
4411      for (unsigned I = 0, N = Vec.size(); I != N; ++I) {
4412        if (!List.Method) {
4413          // This is the first method, which is the easy case.
4414          List.Method = Vec[I];
4415          Prev = &List;
4416          continue;
4417        }
4418
4419        ObjCMethodList *Mem =
4420          Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>();
4421        Prev->Next = new (Mem) ObjCMethodList(Vec[I], 0);
4422        Prev = Prev->Next;
4423      }
4424
4425      return List;
4426    }
4427
4428  public:
4429    ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel)
4430      : Reader(Reader), Sel(Sel) { }
4431
4432    static bool visit(Module &M, void *UserData) {
4433      ReadMethodPoolVisitor *This
4434        = static_cast<ReadMethodPoolVisitor *>(UserData);
4435
4436      if (!M.SelectorLookupTable)
4437        return false;
4438
4439      ASTSelectorLookupTable *PoolTable
4440        = (ASTSelectorLookupTable*)M.SelectorLookupTable;
4441      ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel);
4442      if (Pos == PoolTable->end())
4443        return false;
4444
4445      ++This->Reader.NumSelectorsRead;
4446      // FIXME: Not quite happy with the statistics here. We probably should
4447      // disable this tracking when called via LoadSelector.
4448      // Also, should entries without methods count as misses?
4449      ++This->Reader.NumMethodPoolEntriesRead;
4450      ASTSelectorLookupTrait::data_type Data = *Pos;
4451      if (This->Reader.DeserializationListener)
4452        This->Reader.DeserializationListener->SelectorRead(Data.ID,
4453                                                           This->Sel);
4454
4455      This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
4456      This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
4457      return true;
4458    }
4459
4460    /// \brief Retrieve the instance methods found by this visitor.
4461    ObjCMethodList getInstanceMethods() const {
4462      return buildObjCMethodList(InstanceMethods);
4463    }
4464
4465    /// \brief Retrieve the instance methods found by this visitor.
4466    ObjCMethodList getFactoryMethods() const {
4467      return buildObjCMethodList(FactoryMethods);
4468    }
4469  };
4470} } // end namespace clang::serialization
4471
4472std::pair<ObjCMethodList, ObjCMethodList>
4473ASTReader::ReadMethodPool(Selector Sel) {
4474  ReadMethodPoolVisitor Visitor(*this, Sel);
4475  ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor);
4476  std::pair<ObjCMethodList, ObjCMethodList> Result;
4477  Result.first = Visitor.getInstanceMethods();
4478  Result.second = Visitor.getFactoryMethods();
4479
4480  if (!Result.first.Method && !Result.second.Method)
4481    ++NumMethodPoolMisses;
4482  return Result;
4483}
4484
4485void ASTReader::ReadKnownNamespaces(
4486                          SmallVectorImpl<NamespaceDecl *> &Namespaces) {
4487  Namespaces.clear();
4488
4489  for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
4490    if (NamespaceDecl *Namespace
4491                = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
4492      Namespaces.push_back(Namespace);
4493  }
4494}
4495
4496void ASTReader::ReadTentativeDefinitions(
4497                  SmallVectorImpl<VarDecl *> &TentativeDefs) {
4498  for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
4499    VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
4500    if (Var)
4501      TentativeDefs.push_back(Var);
4502  }
4503  TentativeDefinitions.clear();
4504}
4505
4506void ASTReader::ReadUnusedFileScopedDecls(
4507                               SmallVectorImpl<const DeclaratorDecl *> &Decls) {
4508  for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
4509    DeclaratorDecl *D
4510      = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
4511    if (D)
4512      Decls.push_back(D);
4513  }
4514  UnusedFileScopedDecls.clear();
4515}
4516
4517void ASTReader::ReadDelegatingConstructors(
4518                                 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
4519  for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
4520    CXXConstructorDecl *D
4521      = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
4522    if (D)
4523      Decls.push_back(D);
4524  }
4525  DelegatingCtorDecls.clear();
4526}
4527
4528void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
4529  for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
4530    TypedefNameDecl *D
4531      = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
4532    if (D)
4533      Decls.push_back(D);
4534  }
4535  ExtVectorDecls.clear();
4536}
4537
4538void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) {
4539  for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) {
4540    CXXRecordDecl *D
4541      = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I]));
4542    if (D)
4543      Decls.push_back(D);
4544  }
4545  DynamicClasses.clear();
4546}
4547
4548void
4549ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) {
4550  for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
4551    NamedDecl *D
4552      = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
4553    if (D)
4554      Decls.push_back(D);
4555  }
4556  LocallyScopedExternalDecls.clear();
4557}
4558
4559void ASTReader::ReadReferencedSelectors(
4560       SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
4561  if (ReferencedSelectorsData.empty())
4562    return;
4563
4564  // If there are @selector references added them to its pool. This is for
4565  // implementation of -Wselector.
4566  unsigned int DataSize = ReferencedSelectorsData.size()-1;
4567  unsigned I = 0;
4568  while (I < DataSize) {
4569    Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
4570    SourceLocation SelLoc
4571      = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
4572    Sels.push_back(std::make_pair(Sel, SelLoc));
4573  }
4574  ReferencedSelectorsData.clear();
4575}
4576
4577void ASTReader::ReadWeakUndeclaredIdentifiers(
4578       SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
4579  if (WeakUndeclaredIdentifiers.empty())
4580    return;
4581
4582  for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
4583    IdentifierInfo *WeakId
4584      = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
4585    IdentifierInfo *AliasId
4586      = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
4587    SourceLocation Loc
4588      = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
4589    bool Used = WeakUndeclaredIdentifiers[I++];
4590    WeakInfo WI(AliasId, Loc);
4591    WI.setUsed(Used);
4592    WeakIDs.push_back(std::make_pair(WeakId, WI));
4593  }
4594  WeakUndeclaredIdentifiers.clear();
4595}
4596
4597void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
4598  for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
4599    ExternalVTableUse VT;
4600    VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
4601    VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
4602    VT.DefinitionRequired = VTableUses[Idx++];
4603    VTables.push_back(VT);
4604  }
4605
4606  VTableUses.clear();
4607}
4608
4609void ASTReader::ReadPendingInstantiations(
4610       SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
4611  for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
4612    ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
4613    SourceLocation Loc
4614      = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
4615    Pending.push_back(std::make_pair(D, Loc));
4616  }
4617  PendingInstantiations.clear();
4618}
4619
4620void ASTReader::LoadSelector(Selector Sel) {
4621  // It would be complicated to avoid reading the methods anyway. So don't.
4622  ReadMethodPool(Sel);
4623}
4624
4625void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
4626  assert(ID && "Non-zero identifier ID required");
4627  assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
4628  IdentifiersLoaded[ID - 1] = II;
4629  if (DeserializationListener)
4630    DeserializationListener->IdentifierRead(ID, II);
4631}
4632
4633/// \brief Set the globally-visible declarations associated with the given
4634/// identifier.
4635///
4636/// If the AST reader is currently in a state where the given declaration IDs
4637/// cannot safely be resolved, they are queued until it is safe to resolve
4638/// them.
4639///
4640/// \param II an IdentifierInfo that refers to one or more globally-visible
4641/// declarations.
4642///
4643/// \param DeclIDs the set of declaration IDs with the name @p II that are
4644/// visible at global scope.
4645///
4646/// \param Nonrecursive should be true to indicate that the caller knows that
4647/// this call is non-recursive, and therefore the globally-visible declarations
4648/// will not be placed onto the pending queue.
4649void
4650ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
4651                              const SmallVectorImpl<uint32_t> &DeclIDs,
4652                                   bool Nonrecursive) {
4653  if (NumCurrentElementsDeserializing && !Nonrecursive) {
4654    PendingIdentifierInfos.push_back(PendingIdentifierInfo());
4655    PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
4656    PII.II = II;
4657    PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end());
4658    return;
4659  }
4660
4661  for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
4662    NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
4663    if (SemaObj) {
4664      if (SemaObj->TUScope) {
4665        // Introduce this declaration into the translation-unit scope
4666        // and add it to the declaration chain for this identifier, so
4667        // that (unqualified) name lookup will find it.
4668        SemaObj->TUScope->AddDecl(D);
4669      }
4670      SemaObj->IdResolver.AddDeclToIdentifierChain(II, D);
4671    } else {
4672      // Queue this declaration so that it will be added to the
4673      // translation unit scope and identifier's declaration chain
4674      // once a Sema object is known.
4675      PreloadedDecls.push_back(D);
4676    }
4677  }
4678}
4679
4680IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
4681  if (ID == 0)
4682    return 0;
4683
4684  if (IdentifiersLoaded.empty()) {
4685    Error("no identifier table in AST file");
4686    return 0;
4687  }
4688
4689  ID -= 1;
4690  if (!IdentifiersLoaded[ID]) {
4691    GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
4692    assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
4693    Module *M = I->second;
4694    unsigned Index = ID - M->BaseIdentifierID;
4695    const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
4696
4697    // All of the strings in the AST file are preceded by a 16-bit length.
4698    // Extract that 16-bit length to avoid having to execute strlen().
4699    // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
4700    //  unsigned integers.  This is important to avoid integer overflow when
4701    //  we cast them to 'unsigned'.
4702    const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
4703    unsigned StrLen = (((unsigned) StrLenPtr[0])
4704                       | (((unsigned) StrLenPtr[1]) << 8)) - 1;
4705    IdentifiersLoaded[ID]
4706      = &PP.getIdentifierTable().get(StringRef(Str, StrLen));
4707    if (DeserializationListener)
4708      DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
4709  }
4710
4711  return IdentifiersLoaded[ID];
4712}
4713
4714IdentifierInfo *ASTReader::getLocalIdentifier(Module &M, unsigned LocalID) {
4715  return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
4716}
4717
4718IdentifierID ASTReader::getGlobalIdentifierID(Module &M, unsigned LocalID) {
4719  if (LocalID < NUM_PREDEF_IDENT_IDS)
4720    return LocalID;
4721
4722  ContinuousRangeMap<uint32_t, int, 2>::iterator I
4723    = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
4724  assert(I != M.IdentifierRemap.end()
4725         && "Invalid index into identifier index remap");
4726
4727  return LocalID + I->second;
4728}
4729
4730bool ASTReader::ReadSLocEntry(int ID) {
4731  return ReadSLocEntryRecord(ID) != Success;
4732}
4733
4734Selector ASTReader::getLocalSelector(Module &M, unsigned LocalID) {
4735  return DecodeSelector(getGlobalSelectorID(M, LocalID));
4736}
4737
4738Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
4739  if (ID == 0)
4740    return Selector();
4741
4742  if (ID > SelectorsLoaded.size()) {
4743    Error("selector ID out of range in AST file");
4744    return Selector();
4745  }
4746
4747  if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
4748    // Load this selector from the selector table.
4749    GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
4750    assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
4751    Module &M = *I->second;
4752    ASTSelectorLookupTrait Trait(*this, M);
4753    unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
4754    SelectorsLoaded[ID - 1] =
4755      Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
4756    if (DeserializationListener)
4757      DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
4758  }
4759
4760  return SelectorsLoaded[ID - 1];
4761}
4762
4763Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
4764  return DecodeSelector(ID);
4765}
4766
4767uint32_t ASTReader::GetNumExternalSelectors() {
4768  // ID 0 (the null selector) is considered an external selector.
4769  return getTotalNumSelectors() + 1;
4770}
4771
4772serialization::SelectorID
4773ASTReader::getGlobalSelectorID(Module &M, unsigned LocalID) const {
4774  if (LocalID < NUM_PREDEF_SELECTOR_IDS)
4775    return LocalID;
4776
4777  ContinuousRangeMap<uint32_t, int, 2>::iterator I
4778    = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
4779  assert(I != M.SelectorRemap.end()
4780         && "Invalid index into identifier index remap");
4781
4782  return LocalID + I->second;
4783}
4784
4785DeclarationName
4786ASTReader::ReadDeclarationName(Module &F,
4787                               const RecordData &Record, unsigned &Idx) {
4788  DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
4789  switch (Kind) {
4790  case DeclarationName::Identifier:
4791    return DeclarationName(GetIdentifierInfo(F, Record, Idx));
4792
4793  case DeclarationName::ObjCZeroArgSelector:
4794  case DeclarationName::ObjCOneArgSelector:
4795  case DeclarationName::ObjCMultiArgSelector:
4796    return DeclarationName(ReadSelector(F, Record, Idx));
4797
4798  case DeclarationName::CXXConstructorName:
4799    return Context.DeclarationNames.getCXXConstructorName(
4800                          Context.getCanonicalType(readType(F, Record, Idx)));
4801
4802  case DeclarationName::CXXDestructorName:
4803    return Context.DeclarationNames.getCXXDestructorName(
4804                          Context.getCanonicalType(readType(F, Record, Idx)));
4805
4806  case DeclarationName::CXXConversionFunctionName:
4807    return Context.DeclarationNames.getCXXConversionFunctionName(
4808                          Context.getCanonicalType(readType(F, Record, Idx)));
4809
4810  case DeclarationName::CXXOperatorName:
4811    return Context.DeclarationNames.getCXXOperatorName(
4812                                       (OverloadedOperatorKind)Record[Idx++]);
4813
4814  case DeclarationName::CXXLiteralOperatorName:
4815    return Context.DeclarationNames.getCXXLiteralOperatorName(
4816                                       GetIdentifierInfo(F, Record, Idx));
4817
4818  case DeclarationName::CXXUsingDirective:
4819    return DeclarationName::getUsingDirectiveName();
4820  }
4821
4822  // Required to silence GCC warning
4823  return DeclarationName();
4824}
4825
4826void ASTReader::ReadDeclarationNameLoc(Module &F,
4827                                       DeclarationNameLoc &DNLoc,
4828                                       DeclarationName Name,
4829                                      const RecordData &Record, unsigned &Idx) {
4830  switch (Name.getNameKind()) {
4831  case DeclarationName::CXXConstructorName:
4832  case DeclarationName::CXXDestructorName:
4833  case DeclarationName::CXXConversionFunctionName:
4834    DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
4835    break;
4836
4837  case DeclarationName::CXXOperatorName:
4838    DNLoc.CXXOperatorName.BeginOpNameLoc
4839        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4840    DNLoc.CXXOperatorName.EndOpNameLoc
4841        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4842    break;
4843
4844  case DeclarationName::CXXLiteralOperatorName:
4845    DNLoc.CXXLiteralOperatorName.OpNameLoc
4846        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4847    break;
4848
4849  case DeclarationName::Identifier:
4850  case DeclarationName::ObjCZeroArgSelector:
4851  case DeclarationName::ObjCOneArgSelector:
4852  case DeclarationName::ObjCMultiArgSelector:
4853  case DeclarationName::CXXUsingDirective:
4854    break;
4855  }
4856}
4857
4858void ASTReader::ReadDeclarationNameInfo(Module &F,
4859                                        DeclarationNameInfo &NameInfo,
4860                                      const RecordData &Record, unsigned &Idx) {
4861  NameInfo.setName(ReadDeclarationName(F, Record, Idx));
4862  NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
4863  DeclarationNameLoc DNLoc;
4864  ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
4865  NameInfo.setInfo(DNLoc);
4866}
4867
4868void ASTReader::ReadQualifierInfo(Module &F, QualifierInfo &Info,
4869                                  const RecordData &Record, unsigned &Idx) {
4870  Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
4871  unsigned NumTPLists = Record[Idx++];
4872  Info.NumTemplParamLists = NumTPLists;
4873  if (NumTPLists) {
4874    Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists];
4875    for (unsigned i=0; i != NumTPLists; ++i)
4876      Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
4877  }
4878}
4879
4880TemplateName
4881ASTReader::ReadTemplateName(Module &F, const RecordData &Record,
4882                            unsigned &Idx) {
4883  TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
4884  switch (Kind) {
4885  case TemplateName::Template:
4886      return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
4887
4888  case TemplateName::OverloadedTemplate: {
4889    unsigned size = Record[Idx++];
4890    UnresolvedSet<8> Decls;
4891    while (size--)
4892      Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
4893
4894    return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
4895  }
4896
4897  case TemplateName::QualifiedTemplate: {
4898    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
4899    bool hasTemplKeyword = Record[Idx++];
4900    TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
4901    return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
4902  }
4903
4904  case TemplateName::DependentTemplate: {
4905    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
4906    if (Record[Idx++])  // isIdentifier
4907      return Context.getDependentTemplateName(NNS,
4908                                               GetIdentifierInfo(F, Record,
4909                                                                 Idx));
4910    return Context.getDependentTemplateName(NNS,
4911                                         (OverloadedOperatorKind)Record[Idx++]);
4912  }
4913
4914  case TemplateName::SubstTemplateTemplateParm: {
4915    TemplateTemplateParmDecl *param
4916      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
4917    if (!param) return TemplateName();
4918    TemplateName replacement = ReadTemplateName(F, Record, Idx);
4919    return Context.getSubstTemplateTemplateParm(param, replacement);
4920  }
4921
4922  case TemplateName::SubstTemplateTemplateParmPack: {
4923    TemplateTemplateParmDecl *Param
4924      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
4925    if (!Param)
4926      return TemplateName();
4927
4928    TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
4929    if (ArgPack.getKind() != TemplateArgument::Pack)
4930      return TemplateName();
4931
4932    return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
4933  }
4934  }
4935
4936  assert(0 && "Unhandled template name kind!");
4937  return TemplateName();
4938}
4939
4940TemplateArgument
4941ASTReader::ReadTemplateArgument(Module &F,
4942                                const RecordData &Record, unsigned &Idx) {
4943  TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
4944  switch (Kind) {
4945  case TemplateArgument::Null:
4946    return TemplateArgument();
4947  case TemplateArgument::Type:
4948    return TemplateArgument(readType(F, Record, Idx));
4949  case TemplateArgument::Declaration:
4950    return TemplateArgument(ReadDecl(F, Record, Idx));
4951  case TemplateArgument::Integral: {
4952    llvm::APSInt Value = ReadAPSInt(Record, Idx);
4953    QualType T = readType(F, Record, Idx);
4954    return TemplateArgument(Value, T);
4955  }
4956  case TemplateArgument::Template:
4957    return TemplateArgument(ReadTemplateName(F, Record, Idx));
4958  case TemplateArgument::TemplateExpansion: {
4959    TemplateName Name = ReadTemplateName(F, Record, Idx);
4960    llvm::Optional<unsigned> NumTemplateExpansions;
4961    if (unsigned NumExpansions = Record[Idx++])
4962      NumTemplateExpansions = NumExpansions - 1;
4963    return TemplateArgument(Name, NumTemplateExpansions);
4964  }
4965  case TemplateArgument::Expression:
4966    return TemplateArgument(ReadExpr(F));
4967  case TemplateArgument::Pack: {
4968    unsigned NumArgs = Record[Idx++];
4969    TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
4970    for (unsigned I = 0; I != NumArgs; ++I)
4971      Args[I] = ReadTemplateArgument(F, Record, Idx);
4972    return TemplateArgument(Args, NumArgs);
4973  }
4974  }
4975
4976  assert(0 && "Unhandled template argument kind!");
4977  return TemplateArgument();
4978}
4979
4980TemplateParameterList *
4981ASTReader::ReadTemplateParameterList(Module &F,
4982                                     const RecordData &Record, unsigned &Idx) {
4983  SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
4984  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
4985  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
4986
4987  unsigned NumParams = Record[Idx++];
4988  SmallVector<NamedDecl *, 16> Params;
4989  Params.reserve(NumParams);
4990  while (NumParams--)
4991    Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
4992
4993  TemplateParameterList* TemplateParams =
4994    TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc,
4995                                  Params.data(), Params.size(), RAngleLoc);
4996  return TemplateParams;
4997}
4998
4999void
5000ASTReader::
5001ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs,
5002                         Module &F, const RecordData &Record,
5003                         unsigned &Idx) {
5004  unsigned NumTemplateArgs = Record[Idx++];
5005  TemplArgs.reserve(NumTemplateArgs);
5006  while (NumTemplateArgs--)
5007    TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
5008}
5009
5010/// \brief Read a UnresolvedSet structure.
5011void ASTReader::ReadUnresolvedSet(Module &F, UnresolvedSetImpl &Set,
5012                                  const RecordData &Record, unsigned &Idx) {
5013  unsigned NumDecls = Record[Idx++];
5014  while (NumDecls--) {
5015    NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx);
5016    AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
5017    Set.addDecl(D, AS);
5018  }
5019}
5020
5021CXXBaseSpecifier
5022ASTReader::ReadCXXBaseSpecifier(Module &F,
5023                                const RecordData &Record, unsigned &Idx) {
5024  bool isVirtual = static_cast<bool>(Record[Idx++]);
5025  bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
5026  AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
5027  bool inheritConstructors = static_cast<bool>(Record[Idx++]);
5028  TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
5029  SourceRange Range = ReadSourceRange(F, Record, Idx);
5030  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
5031  CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
5032                          EllipsisLoc);
5033  Result.setInheritConstructors(inheritConstructors);
5034  return Result;
5035}
5036
5037std::pair<CXXCtorInitializer **, unsigned>
5038ASTReader::ReadCXXCtorInitializers(Module &F, const RecordData &Record,
5039                                   unsigned &Idx) {
5040  CXXCtorInitializer **CtorInitializers = 0;
5041  unsigned NumInitializers = Record[Idx++];
5042  if (NumInitializers) {
5043    CtorInitializers
5044        = new (Context) CXXCtorInitializer*[NumInitializers];
5045    for (unsigned i=0; i != NumInitializers; ++i) {
5046      TypeSourceInfo *BaseClassInfo = 0;
5047      bool IsBaseVirtual = false;
5048      FieldDecl *Member = 0;
5049      IndirectFieldDecl *IndirectMember = 0;
5050      CXXConstructorDecl *Target = 0;
5051
5052      CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
5053      switch (Type) {
5054       case CTOR_INITIALIZER_BASE:
5055        BaseClassInfo = GetTypeSourceInfo(F, Record, Idx);
5056        IsBaseVirtual = Record[Idx++];
5057        break;
5058
5059       case CTOR_INITIALIZER_DELEGATING:
5060        Target = ReadDeclAs<CXXConstructorDecl>(F, Record, Idx);
5061        break;
5062
5063       case CTOR_INITIALIZER_MEMBER:
5064        Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
5065        break;
5066
5067       case CTOR_INITIALIZER_INDIRECT_MEMBER:
5068        IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
5069        break;
5070      }
5071
5072      SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
5073      Expr *Init = ReadExpr(F);
5074      SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
5075      SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
5076      bool IsWritten = Record[Idx++];
5077      unsigned SourceOrderOrNumArrayIndices;
5078      SmallVector<VarDecl *, 8> Indices;
5079      if (IsWritten) {
5080        SourceOrderOrNumArrayIndices = Record[Idx++];
5081      } else {
5082        SourceOrderOrNumArrayIndices = Record[Idx++];
5083        Indices.reserve(SourceOrderOrNumArrayIndices);
5084        for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
5085          Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
5086      }
5087
5088      CXXCtorInitializer *BOMInit;
5089      if (Type == CTOR_INITIALIZER_BASE) {
5090        BOMInit = new (Context) CXXCtorInitializer(Context, BaseClassInfo, IsBaseVirtual,
5091                                             LParenLoc, Init, RParenLoc,
5092                                             MemberOrEllipsisLoc);
5093      } else if (Type == CTOR_INITIALIZER_DELEGATING) {
5094        BOMInit = new (Context) CXXCtorInitializer(Context, MemberOrEllipsisLoc, LParenLoc,
5095                                             Target, Init, RParenLoc);
5096      } else if (IsWritten) {
5097        if (Member)
5098          BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc,
5099                                               LParenLoc, Init, RParenLoc);
5100        else
5101          BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember,
5102                                               MemberOrEllipsisLoc, LParenLoc,
5103                                               Init, RParenLoc);
5104      } else {
5105        BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc,
5106                                             LParenLoc, Init, RParenLoc,
5107                                             Indices.data(), Indices.size());
5108      }
5109
5110      if (IsWritten)
5111        BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
5112      CtorInitializers[i] = BOMInit;
5113    }
5114  }
5115
5116  return std::make_pair(CtorInitializers, NumInitializers);
5117}
5118
5119NestedNameSpecifier *
5120ASTReader::ReadNestedNameSpecifier(Module &F,
5121                                   const RecordData &Record, unsigned &Idx) {
5122  unsigned N = Record[Idx++];
5123  NestedNameSpecifier *NNS = 0, *Prev = 0;
5124  for (unsigned I = 0; I != N; ++I) {
5125    NestedNameSpecifier::SpecifierKind Kind
5126      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5127    switch (Kind) {
5128    case NestedNameSpecifier::Identifier: {
5129      IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
5130      NNS = NestedNameSpecifier::Create(Context, Prev, II);
5131      break;
5132    }
5133
5134    case NestedNameSpecifier::Namespace: {
5135      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
5136      NNS = NestedNameSpecifier::Create(Context, Prev, NS);
5137      break;
5138    }
5139
5140    case NestedNameSpecifier::NamespaceAlias: {
5141      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
5142      NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
5143      break;
5144    }
5145
5146    case NestedNameSpecifier::TypeSpec:
5147    case NestedNameSpecifier::TypeSpecWithTemplate: {
5148      const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
5149      if (!T)
5150        return 0;
5151
5152      bool Template = Record[Idx++];
5153      NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
5154      break;
5155    }
5156
5157    case NestedNameSpecifier::Global: {
5158      NNS = NestedNameSpecifier::GlobalSpecifier(Context);
5159      // No associated value, and there can't be a prefix.
5160      break;
5161    }
5162    }
5163    Prev = NNS;
5164  }
5165  return NNS;
5166}
5167
5168NestedNameSpecifierLoc
5169ASTReader::ReadNestedNameSpecifierLoc(Module &F, const RecordData &Record,
5170                                      unsigned &Idx) {
5171  unsigned N = Record[Idx++];
5172  NestedNameSpecifierLocBuilder Builder;
5173  for (unsigned I = 0; I != N; ++I) {
5174    NestedNameSpecifier::SpecifierKind Kind
5175      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5176    switch (Kind) {
5177    case NestedNameSpecifier::Identifier: {
5178      IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
5179      SourceRange Range = ReadSourceRange(F, Record, Idx);
5180      Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
5181      break;
5182    }
5183
5184    case NestedNameSpecifier::Namespace: {
5185      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
5186      SourceRange Range = ReadSourceRange(F, Record, Idx);
5187      Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
5188      break;
5189    }
5190
5191    case NestedNameSpecifier::NamespaceAlias: {
5192      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
5193      SourceRange Range = ReadSourceRange(F, Record, Idx);
5194      Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
5195      break;
5196    }
5197
5198    case NestedNameSpecifier::TypeSpec:
5199    case NestedNameSpecifier::TypeSpecWithTemplate: {
5200      bool Template = Record[Idx++];
5201      TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
5202      if (!T)
5203        return NestedNameSpecifierLoc();
5204      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5205
5206      // FIXME: 'template' keyword location not saved anywhere, so we fake it.
5207      Builder.Extend(Context,
5208                     Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
5209                     T->getTypeLoc(), ColonColonLoc);
5210      break;
5211    }
5212
5213    case NestedNameSpecifier::Global: {
5214      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5215      Builder.MakeGlobal(Context, ColonColonLoc);
5216      break;
5217    }
5218    }
5219  }
5220
5221  return Builder.getWithLocInContext(Context);
5222}
5223
5224SourceRange
5225ASTReader::ReadSourceRange(Module &F, const RecordData &Record,
5226                           unsigned &Idx) {
5227  SourceLocation beg = ReadSourceLocation(F, Record, Idx);
5228  SourceLocation end = ReadSourceLocation(F, Record, Idx);
5229  return SourceRange(beg, end);
5230}
5231
5232/// \brief Read an integral value
5233llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
5234  unsigned BitWidth = Record[Idx++];
5235  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
5236  llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
5237  Idx += NumWords;
5238  return Result;
5239}
5240
5241/// \brief Read a signed integral value
5242llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
5243  bool isUnsigned = Record[Idx++];
5244  return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
5245}
5246
5247/// \brief Read a floating-point value
5248llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
5249  return llvm::APFloat(ReadAPInt(Record, Idx));
5250}
5251
5252// \brief Read a string
5253std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
5254  unsigned Len = Record[Idx++];
5255  std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
5256  Idx += Len;
5257  return Result;
5258}
5259
5260VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
5261                                         unsigned &Idx) {
5262  unsigned Major = Record[Idx++];
5263  unsigned Minor = Record[Idx++];
5264  unsigned Subminor = Record[Idx++];
5265  if (Minor == 0)
5266    return VersionTuple(Major);
5267  if (Subminor == 0)
5268    return VersionTuple(Major, Minor - 1);
5269  return VersionTuple(Major, Minor - 1, Subminor - 1);
5270}
5271
5272CXXTemporary *ASTReader::ReadCXXTemporary(Module &F,
5273                                          const RecordData &Record,
5274                                          unsigned &Idx) {
5275  CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
5276  return CXXTemporary::Create(Context, Decl);
5277}
5278
5279DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
5280  return Diag(SourceLocation(), DiagID);
5281}
5282
5283DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
5284  return Diags.Report(Loc, DiagID);
5285}
5286
5287/// \brief Retrieve the identifier table associated with the
5288/// preprocessor.
5289IdentifierTable &ASTReader::getIdentifierTable() {
5290  return PP.getIdentifierTable();
5291}
5292
5293/// \brief Record that the given ID maps to the given switch-case
5294/// statement.
5295void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
5296  assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
5297  SwitchCaseStmts[ID] = SC;
5298}
5299
5300/// \brief Retrieve the switch-case statement with the given ID.
5301SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
5302  assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
5303  return SwitchCaseStmts[ID];
5304}
5305
5306void ASTReader::ClearSwitchCaseIDs() {
5307  SwitchCaseStmts.clear();
5308}
5309
5310void ASTReader::FinishedDeserializing() {
5311  assert(NumCurrentElementsDeserializing &&
5312         "FinishedDeserializing not paired with StartedDeserializing");
5313  if (NumCurrentElementsDeserializing == 1) {
5314    // If any identifiers with corresponding top-level declarations have
5315    // been loaded, load those declarations now.
5316    while (!PendingIdentifierInfos.empty()) {
5317      SetGloballyVisibleDecls(PendingIdentifierInfos.front().II,
5318                              PendingIdentifierInfos.front().DeclIDs, true);
5319      PendingIdentifierInfos.pop_front();
5320    }
5321
5322    // Ready to load previous declarations of Decls that were delayed.
5323    while (!PendingPreviousDecls.empty()) {
5324      loadAndAttachPreviousDecl(PendingPreviousDecls.front().first,
5325                                PendingPreviousDecls.front().second);
5326      PendingPreviousDecls.pop_front();
5327    }
5328
5329    // We are not in recursive loading, so it's safe to pass the "interesting"
5330    // decls to the consumer.
5331    if (Consumer)
5332      PassInterestingDeclsToConsumer();
5333
5334    assert(PendingForwardRefs.size() == 0 &&
5335           "Some forward refs did not get linked to the definition!");
5336  }
5337  --NumCurrentElementsDeserializing;
5338}
5339
5340ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context,
5341                     StringRef isysroot, bool DisableValidation,
5342                     bool DisableStatCache)
5343  : Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
5344    SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
5345    Diags(PP.getDiagnostics()), SemaObj(0), PP(PP), Context(Context),
5346    Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
5347    RelocatablePCH(false), isysroot(isysroot),
5348    DisableValidation(DisableValidation),
5349    DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
5350    NumSLocEntriesRead(0), TotalNumSLocEntries(0),
5351    NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
5352    TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
5353    NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0),
5354    NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
5355    NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
5356    TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
5357    NumCXXBaseSpecifiersLoaded(0)
5358{
5359  SourceMgr.setExternalSLocEntrySource(this);
5360}
5361
5362ASTReader::~ASTReader() {
5363  for (DeclContextVisibleUpdatesPending::iterator
5364           I = PendingVisibleUpdates.begin(),
5365           E = PendingVisibleUpdates.end();
5366       I != E; ++I) {
5367    for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
5368                                             F = I->second.end();
5369         J != F; ++J)
5370      delete static_cast<ASTDeclContextNameLookupTable*>(J->first);
5371  }
5372}
5373