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