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