ASTReader.cpp revision 8df5c9b5d65beec807e4e77dae2813dd193f77dd 
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
1384  // Otherwise we have a PCH. It's considered to be "imported" at the first
1385  // location of its includer.
1386  if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1387    // Main file is the importer. We assume that it is the first entry in the
1388    // entry table. We can't ask the manager, because at the time of PCH loading
1389    // the main file entry doesn't exist yet.
1390    // The very first entry is the invalid instantiation loc, which takes up
1391    // offsets 0 and 1.
1392    return SourceLocation::getFromRawEncoding(2U);
1393  }
1394  //return F->Loaders[0]->FirstLoc;
1395  return F->ImportedBy[0]->FirstLoc;
1396}
1397
1398/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1399/// specified cursor.  Read the abbreviations that are at the top of the block
1400/// and then leave the cursor pointing into the block.
1401bool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor,
1402                                 unsigned BlockID) {
1403  if (Cursor.EnterSubBlock(BlockID)) {
1404    Error("malformed block record in AST file");
1405    return Failure;
1406  }
1407
1408  while (true) {
1409    uint64_t Offset = Cursor.GetCurrentBitNo();
1410    unsigned Code = Cursor.ReadCode();
1411
1412    // We expect all abbrevs to be at the start of the block.
1413    if (Code != llvm::bitc::DEFINE_ABBREV) {
1414      Cursor.JumpToBit(Offset);
1415      return false;
1416    }
1417    Cursor.ReadAbbrevRecord();
1418  }
1419}
1420
1421PreprocessedEntity *ASTReader::ReadMacroRecord(Module &F, uint64_t Offset) {
1422  assert(PP && "Forgot to set Preprocessor ?");
1423  llvm::BitstreamCursor &Stream = F.MacroCursor;
1424
1425  // Keep track of where we are in the stream, then jump back there
1426  // after reading this macro.
1427  SavedStreamPosition SavedPosition(Stream);
1428
1429  Stream.JumpToBit(Offset);
1430  RecordData Record;
1431  SmallVector<IdentifierInfo*, 16> MacroArgs;
1432  MacroInfo *Macro = 0;
1433
1434  while (true) {
1435    unsigned Code = Stream.ReadCode();
1436    switch (Code) {
1437    case llvm::bitc::END_BLOCK:
1438      return 0;
1439
1440    case llvm::bitc::ENTER_SUBBLOCK:
1441      // No known subblocks, always skip them.
1442      Stream.ReadSubBlockID();
1443      if (Stream.SkipBlock()) {
1444        Error("malformed block record in AST file");
1445        return 0;
1446      }
1447      continue;
1448
1449    case llvm::bitc::DEFINE_ABBREV:
1450      Stream.ReadAbbrevRecord();
1451      continue;
1452    default: break;
1453    }
1454
1455    // Read a record.
1456    const char *BlobStart = 0;
1457    unsigned BlobLen = 0;
1458    Record.clear();
1459    PreprocessorRecordTypes RecType =
1460      (PreprocessorRecordTypes)Stream.ReadRecord(Code, Record, BlobStart,
1461                                                 BlobLen);
1462    switch (RecType) {
1463    case PP_MACRO_OBJECT_LIKE:
1464    case PP_MACRO_FUNCTION_LIKE: {
1465      // If we already have a macro, that means that we've hit the end
1466      // of the definition of the macro we were looking for. We're
1467      // done.
1468      if (Macro)
1469        return 0;
1470
1471      IdentifierInfo *II = getLocalIdentifier(F, Record[0]);
1472      if (II == 0) {
1473        Error("macro must have a name in AST file");
1474        return 0;
1475      }
1476      SourceLocation Loc = ReadSourceLocation(F, Record[1]);
1477      bool isUsed = Record[2];
1478
1479      MacroInfo *MI = PP->AllocateMacroInfo(Loc);
1480      MI->setIsUsed(isUsed);
1481      MI->setIsFromAST();
1482
1483      unsigned NextIndex = 3;
1484      if (RecType == PP_MACRO_FUNCTION_LIKE) {
1485        // Decode function-like macro info.
1486        bool isC99VarArgs = Record[3];
1487        bool isGNUVarArgs = Record[4];
1488        MacroArgs.clear();
1489        unsigned NumArgs = Record[5];
1490        NextIndex = 6 + NumArgs;
1491        for (unsigned i = 0; i != NumArgs; ++i)
1492          MacroArgs.push_back(getLocalIdentifier(F, Record[6+i]));
1493
1494        // Install function-like macro info.
1495        MI->setIsFunctionLike();
1496        if (isC99VarArgs) MI->setIsC99Varargs();
1497        if (isGNUVarArgs) MI->setIsGNUVarargs();
1498        MI->setArgumentList(MacroArgs.data(), MacroArgs.size(),
1499                            PP->getPreprocessorAllocator());
1500      }
1501
1502      // Finally, install the macro.
1503      PP->setMacroInfo(II, MI);
1504
1505      // Remember that we saw this macro last so that we add the tokens that
1506      // form its body to it.
1507      Macro = MI;
1508
1509      if (NextIndex + 1 == Record.size() && PP->getPreprocessingRecord()) {
1510        // We have a macro definition. Load it now.
1511        PP->getPreprocessingRecord()->RegisterMacroDefinition(Macro,
1512              getLocalMacroDefinition(F, Record[NextIndex]));
1513      }
1514
1515      ++NumMacrosRead;
1516      break;
1517    }
1518
1519    case PP_TOKEN: {
1520      // If we see a TOKEN before a PP_MACRO_*, then the file is
1521      // erroneous, just pretend we didn't see this.
1522      if (Macro == 0) break;
1523
1524      Token Tok;
1525      Tok.startToken();
1526      Tok.setLocation(ReadSourceLocation(F, Record[0]));
1527      Tok.setLength(Record[1]);
1528      if (IdentifierInfo *II = getLocalIdentifier(F, Record[2]))
1529        Tok.setIdentifierInfo(II);
1530      Tok.setKind((tok::TokenKind)Record[3]);
1531      Tok.setFlag((Token::TokenFlags)Record[4]);
1532      Macro->AddTokenToBody(Tok);
1533      break;
1534    }
1535  }
1536  }
1537
1538  return 0;
1539}
1540
1541PreprocessedEntity *ASTReader::LoadPreprocessedEntity(Module &F) {
1542  assert(PP && "Forgot to set Preprocessor ?");
1543  unsigned Code = F.PreprocessorDetailCursor.ReadCode();
1544  switch (Code) {
1545  case llvm::bitc::END_BLOCK:
1546    return 0;
1547
1548  case llvm::bitc::ENTER_SUBBLOCK:
1549    Error("unexpected subblock record in preprocessor detail block");
1550    return 0;
1551
1552  case llvm::bitc::DEFINE_ABBREV:
1553    Error("unexpected abbrevation record in preprocessor detail block");
1554    return 0;
1555
1556  default:
1557    break;
1558  }
1559
1560  if (!PP->getPreprocessingRecord()) {
1561    Error("no preprocessing record");
1562    return 0;
1563  }
1564
1565  // Read the record.
1566  PreprocessingRecord &PPRec = *PP->getPreprocessingRecord();
1567  const char *BlobStart = 0;
1568  unsigned BlobLen = 0;
1569  RecordData Record;
1570  PreprocessorDetailRecordTypes RecType =
1571    (PreprocessorDetailRecordTypes)F.PreprocessorDetailCursor.ReadRecord(
1572                                             Code, Record, BlobStart, BlobLen);
1573  switch (RecType) {
1574  case PPD_MACRO_EXPANSION: {
1575    PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]);
1576    if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID))
1577      return PE;
1578
1579    MacroExpansion *ME =
1580      new (PPRec) MacroExpansion(getLocalIdentifier(F, Record[3]),
1581                                 SourceRange(ReadSourceLocation(F, Record[1]),
1582                                             ReadSourceLocation(F, Record[2])),
1583                                 getLocalMacroDefinition(F, Record[4]));
1584    PPRec.setLoadedPreallocatedEntity(GlobalID, ME);
1585    return ME;
1586  }
1587
1588  case PPD_MACRO_DEFINITION: {
1589    PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]);
1590    if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID))
1591      return PE;
1592
1593    unsigned MacroDefID = getGlobalMacroDefinitionID(F, Record[1]);
1594    if (MacroDefID > MacroDefinitionsLoaded.size()) {
1595      Error("out-of-bounds macro definition record");
1596      return 0;
1597    }
1598
1599    // Decode the identifier info and then check again; if the macro is
1600    // still defined and associated with the identifier,
1601    IdentifierInfo *II = getLocalIdentifier(F, Record[4]);
1602    if (!MacroDefinitionsLoaded[MacroDefID - 1]) {
1603      MacroDefinition *MD
1604        = new (PPRec) MacroDefinition(II,
1605                                      ReadSourceLocation(F, Record[5]),
1606                                      SourceRange(
1607                                            ReadSourceLocation(F, Record[2]),
1608                                            ReadSourceLocation(F, Record[3])));
1609
1610      PPRec.setLoadedPreallocatedEntity(GlobalID, MD);
1611      MacroDefinitionsLoaded[MacroDefID - 1] = MD;
1612
1613      if (DeserializationListener)
1614        DeserializationListener->MacroDefinitionRead(MacroDefID, MD);
1615    }
1616
1617    return MacroDefinitionsLoaded[MacroDefID - 1];
1618  }
1619
1620  case PPD_INCLUSION_DIRECTIVE: {
1621    PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]);
1622    if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID))
1623      return PE;
1624
1625    const char *FullFileNameStart = BlobStart + Record[3];
1626    const FileEntry *File
1627      = PP->getFileManager().getFile(StringRef(FullFileNameStart,
1628                                               BlobLen - Record[3]));
1629
1630    // FIXME: Stable encoding
1631    InclusionDirective::InclusionKind Kind
1632      = static_cast<InclusionDirective::InclusionKind>(Record[5]);
1633    InclusionDirective *ID
1634      = new (PPRec) InclusionDirective(PPRec, Kind,
1635                                       StringRef(BlobStart, Record[3]),
1636                                       Record[4],
1637                                       File,
1638                                 SourceRange(ReadSourceLocation(F, Record[1]),
1639                                             ReadSourceLocation(F, Record[2])));
1640    PPRec.setLoadedPreallocatedEntity(GlobalID, ID);
1641    return ID;
1642  }
1643  }
1644
1645  Error("invalid offset in preprocessor detail block");
1646  return 0;
1647}
1648
1649PreprocessedEntityID
1650ASTReader::getGlobalPreprocessedEntityID(Module &M, unsigned LocalID) {
1651  // FIXME: Local-to-global mapping
1652  return LocalID;
1653}
1654
1655namespace {
1656  /// \brief Trait class used to search the on-disk hash table containing all of
1657  /// the header search information.
1658  ///
1659  /// The on-disk hash table contains a mapping from each header path to
1660  /// information about that header (how many times it has been included, its
1661  /// controlling macro, etc.). Note that we actually hash based on the
1662  /// filename, and support "deep" comparisons of file names based on current
1663  /// inode numbers, so that the search can cope with non-normalized path names
1664  /// and symlinks.
1665  class HeaderFileInfoTrait {
1666    ASTReader &Reader;
1667    Module &M;
1668    HeaderSearch *HS;
1669    const char *FrameworkStrings;
1670    const char *SearchPath;
1671    struct stat SearchPathStatBuf;
1672    llvm::Optional<int> SearchPathStatResult;
1673
1674    int StatSimpleCache(const char *Path, struct stat *StatBuf) {
1675      if (Path == SearchPath) {
1676        if (!SearchPathStatResult)
1677          SearchPathStatResult = stat(Path, &SearchPathStatBuf);
1678
1679        *StatBuf = SearchPathStatBuf;
1680        return *SearchPathStatResult;
1681      }
1682
1683      return stat(Path, StatBuf);
1684    }
1685
1686  public:
1687    typedef const char *external_key_type;
1688    typedef const char *internal_key_type;
1689
1690    typedef HeaderFileInfo data_type;
1691
1692    HeaderFileInfoTrait(ASTReader &Reader, Module &M, HeaderSearch *HS,
1693                        const char *FrameworkStrings,
1694                        const char *SearchPath = 0)
1695      : Reader(Reader), M(M), HS(HS), FrameworkStrings(FrameworkStrings),
1696        SearchPath(SearchPath) { }
1697
1698    static unsigned ComputeHash(const char *path) {
1699      return llvm::HashString(llvm::sys::path::filename(path));
1700    }
1701
1702    static internal_key_type GetInternalKey(const char *path) { return path; }
1703
1704    bool EqualKey(internal_key_type a, internal_key_type b) {
1705      if (strcmp(a, b) == 0)
1706        return true;
1707
1708      if (llvm::sys::path::filename(a) != llvm::sys::path::filename(b))
1709        return false;
1710
1711      // The file names match, but the path names don't. stat() the files to
1712      // see if they are the same.
1713      struct stat StatBufA, StatBufB;
1714      if (StatSimpleCache(a, &StatBufA) || StatSimpleCache(b, &StatBufB))
1715        return false;
1716
1717      return StatBufA.st_ino == StatBufB.st_ino;
1718    }
1719
1720    static std::pair<unsigned, unsigned>
1721    ReadKeyDataLength(const unsigned char*& d) {
1722      unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
1723      unsigned DataLen = (unsigned) *d++;
1724      return std::make_pair(KeyLen + 1, DataLen);
1725    }
1726
1727    static internal_key_type ReadKey(const unsigned char *d, unsigned) {
1728      return (const char *)d;
1729    }
1730
1731    data_type ReadData(const internal_key_type, const unsigned char *d,
1732                       unsigned DataLen) {
1733      const unsigned char *End = d + DataLen;
1734      using namespace clang::io;
1735      HeaderFileInfo HFI;
1736      unsigned Flags = *d++;
1737      HFI.isImport = (Flags >> 5) & 0x01;
1738      HFI.isPragmaOnce = (Flags >> 4) & 0x01;
1739      HFI.DirInfo = (Flags >> 2) & 0x03;
1740      HFI.Resolved = (Flags >> 1) & 0x01;
1741      HFI.IndexHeaderMapHeader = Flags & 0x01;
1742      HFI.NumIncludes = ReadUnalignedLE16(d);
1743      HFI.ControllingMacroID = Reader.getGlobalDeclID(M, ReadUnalignedLE32(d));
1744      if (unsigned FrameworkOffset = ReadUnalignedLE32(d)) {
1745        // The framework offset is 1 greater than the actual offset,
1746        // since 0 is used as an indicator for "no framework name".
1747        StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1748        HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1749      }
1750
1751      assert(End == d && "Wrong data length in HeaderFileInfo deserialization");
1752      (void)End;
1753
1754      // This HeaderFileInfo was externally loaded.
1755      HFI.External = true;
1756      return HFI;
1757    }
1758  };
1759}
1760
1761/// \brief The on-disk hash table used for the global method pool.
1762typedef OnDiskChainedHashTable<HeaderFileInfoTrait>
1763  HeaderFileInfoLookupTable;
1764
1765void ASTReader::SetIdentifierIsMacro(IdentifierInfo *II, Module &F,
1766                                     uint64_t LocalOffset) {
1767  // Note that this identifier has a macro definition.
1768  II->setHasMacroDefinition(true);
1769
1770  // Adjust the offset to a global offset.
1771  UnreadMacroRecordOffsets[II] = F.GlobalBitOffset + LocalOffset;
1772}
1773
1774void ASTReader::ReadDefinedMacros() {
1775  for (ModuleReverseIterator I = ModuleMgr.rbegin(),
1776      E = ModuleMgr.rend(); I != E; ++I) {
1777    llvm::BitstreamCursor &MacroCursor = (*I)->MacroCursor;
1778
1779    // If there was no preprocessor block, skip this file.
1780    if (!MacroCursor.getBitStreamReader())
1781      continue;
1782
1783    llvm::BitstreamCursor Cursor = MacroCursor;
1784    Cursor.JumpToBit((*I)->MacroStartOffset);
1785
1786    RecordData Record;
1787    while (true) {
1788      unsigned Code = Cursor.ReadCode();
1789      if (Code == llvm::bitc::END_BLOCK)
1790        break;
1791
1792      if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1793        // No known subblocks, always skip them.
1794        Cursor.ReadSubBlockID();
1795        if (Cursor.SkipBlock()) {
1796          Error("malformed block record in AST file");
1797          return;
1798        }
1799        continue;
1800      }
1801
1802      if (Code == llvm::bitc::DEFINE_ABBREV) {
1803        Cursor.ReadAbbrevRecord();
1804        continue;
1805      }
1806
1807      // Read a record.
1808      const char *BlobStart;
1809      unsigned BlobLen;
1810      Record.clear();
1811      switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1812      default:  // Default behavior: ignore.
1813        break;
1814
1815      case PP_MACRO_OBJECT_LIKE:
1816      case PP_MACRO_FUNCTION_LIKE:
1817        getLocalIdentifier(**I, Record[0]);
1818        break;
1819
1820      case PP_TOKEN:
1821        // Ignore tokens.
1822        break;
1823      }
1824    }
1825  }
1826
1827  // Drain the unread macro-record offsets map.
1828  while (!UnreadMacroRecordOffsets.empty())
1829    LoadMacroDefinition(UnreadMacroRecordOffsets.begin());
1830}
1831
1832void ASTReader::LoadMacroDefinition(
1833                     llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos) {
1834  assert(Pos != UnreadMacroRecordOffsets.end() && "Unknown macro definition");
1835  uint64_t Offset = Pos->second;
1836  UnreadMacroRecordOffsets.erase(Pos);
1837
1838  RecordLocation Loc = getLocalBitOffset(Offset);
1839  ReadMacroRecord(*Loc.F, Loc.Offset);
1840}
1841
1842void ASTReader::LoadMacroDefinition(IdentifierInfo *II) {
1843  llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos
1844    = UnreadMacroRecordOffsets.find(II);
1845  LoadMacroDefinition(Pos);
1846}
1847
1848MacroDefinition *ASTReader::getMacroDefinition(MacroID ID) {
1849  if (ID == 0 || ID > MacroDefinitionsLoaded.size())
1850    return 0;
1851
1852  if (!MacroDefinitionsLoaded[ID - 1]) {
1853    GlobalMacroDefinitionMapType::iterator I =GlobalMacroDefinitionMap.find(ID);
1854    assert(I != GlobalMacroDefinitionMap.end() &&
1855           "Corrupted global macro definition map");
1856    Module &M = *I->second;
1857    unsigned Index = ID - 1 - M.BaseMacroDefinitionID;
1858    SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
1859    M.PreprocessorDetailCursor.JumpToBit(M.MacroDefinitionOffsets[Index]);
1860    LoadPreprocessedEntity(M);
1861  }
1862
1863  return MacroDefinitionsLoaded[ID - 1];
1864}
1865
1866const FileEntry *ASTReader::getFileEntry(StringRef filenameStrRef) {
1867  std::string Filename = filenameStrRef;
1868  MaybeAddSystemRootToFilename(Filename);
1869  const FileEntry *File = FileMgr.getFile(Filename);
1870  if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() &&
1871      OriginalDir != CurrentDir) {
1872    std::string resolved = resolveFileRelativeToOriginalDir(Filename,
1873                                                            OriginalDir,
1874                                                            CurrentDir);
1875    if (!resolved.empty())
1876      File = FileMgr.getFile(resolved);
1877  }
1878
1879  return File;
1880}
1881
1882MacroID ASTReader::getGlobalMacroDefinitionID(Module &M, unsigned LocalID) {
1883  // FIXME: Local-to-global mapping
1884  return LocalID;
1885}
1886
1887/// \brief If we are loading a relocatable PCH file, and the filename is
1888/// not an absolute path, add the system root to the beginning of the file
1889/// name.
1890void ASTReader::MaybeAddSystemRootToFilename(std::string &Filename) {
1891  // If this is not a relocatable PCH file, there's nothing to do.
1892  if (!RelocatablePCH)
1893    return;
1894
1895  if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
1896    return;
1897
1898  if (isysroot.empty()) {
1899    // If no system root was given, default to '/'
1900    Filename.insert(Filename.begin(), '/');
1901    return;
1902  }
1903
1904  unsigned Length = isysroot.size();
1905  if (isysroot[Length - 1] != '/')
1906    Filename.insert(Filename.begin(), '/');
1907
1908  Filename.insert(Filename.begin(), isysroot.begin(), isysroot.end());
1909}
1910
1911ASTReader::ASTReadResult
1912ASTReader::ReadASTBlock(Module &F) {
1913  llvm::BitstreamCursor &Stream = F.Stream;
1914
1915  if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
1916    Error("malformed block record in AST file");
1917    return Failure;
1918  }
1919
1920  // Read all of the records and blocks for the ASt file.
1921  RecordData Record;
1922  bool First = true;
1923  while (!Stream.AtEndOfStream()) {
1924    unsigned Code = Stream.ReadCode();
1925    if (Code == llvm::bitc::END_BLOCK) {
1926      if (Stream.ReadBlockEnd()) {
1927        Error("error at end of module block in AST file");
1928        return Failure;
1929      }
1930
1931      return Success;
1932    }
1933
1934    if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1935      switch (Stream.ReadSubBlockID()) {
1936      case DECLTYPES_BLOCK_ID:
1937        // We lazily load the decls block, but we want to set up the
1938        // DeclsCursor cursor to point into it.  Clone our current bitcode
1939        // cursor to it, enter the block and read the abbrevs in that block.
1940        // With the main cursor, we just skip over it.
1941        F.DeclsCursor = Stream;
1942        if (Stream.SkipBlock() ||  // Skip with the main cursor.
1943            // Read the abbrevs.
1944            ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
1945          Error("malformed block record in AST file");
1946          return Failure;
1947        }
1948        break;
1949
1950      case DECL_UPDATES_BLOCK_ID:
1951        if (Stream.SkipBlock()) {
1952          Error("malformed block record in AST file");
1953          return Failure;
1954        }
1955        break;
1956
1957      case PREPROCESSOR_BLOCK_ID:
1958        F.MacroCursor = Stream;
1959        if (PP)
1960          PP->setExternalSource(this);
1961
1962        if (Stream.SkipBlock() ||
1963            ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
1964          Error("malformed block record in AST file");
1965          return Failure;
1966        }
1967        F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
1968        break;
1969
1970      case PREPROCESSOR_DETAIL_BLOCK_ID:
1971        F.PreprocessorDetailCursor = Stream;
1972        if (Stream.SkipBlock() ||
1973            ReadBlockAbbrevs(F.PreprocessorDetailCursor,
1974                             PREPROCESSOR_DETAIL_BLOCK_ID)) {
1975          Error("malformed preprocessor detail record in AST file");
1976          return Failure;
1977        }
1978        F.PreprocessorDetailStartOffset
1979          = F.PreprocessorDetailCursor.GetCurrentBitNo();
1980        break;
1981
1982      case SOURCE_MANAGER_BLOCK_ID:
1983        switch (ReadSourceManagerBlock(F)) {
1984        case Success:
1985          break;
1986
1987        case Failure:
1988          Error("malformed source manager block in AST file");
1989          return Failure;
1990
1991        case IgnorePCH:
1992          return IgnorePCH;
1993        }
1994        break;
1995      }
1996      First = false;
1997      continue;
1998    }
1999
2000    if (Code == llvm::bitc::DEFINE_ABBREV) {
2001      Stream.ReadAbbrevRecord();
2002      continue;
2003    }
2004
2005    // Read and process a record.
2006    Record.clear();
2007    const char *BlobStart = 0;
2008    unsigned BlobLen = 0;
2009    switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record,
2010                                              &BlobStart, &BlobLen)) {
2011    default:  // Default behavior: ignore.
2012      break;
2013
2014    case METADATA: {
2015      if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2016        Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old
2017                                           : diag::warn_pch_version_too_new);
2018        return IgnorePCH;
2019      }
2020
2021      RelocatablePCH = Record[4];
2022      if (Listener) {
2023        std::string TargetTriple(BlobStart, BlobLen);
2024        if (Listener->ReadTargetTriple(TargetTriple))
2025          return IgnorePCH;
2026      }
2027      break;
2028    }
2029
2030    case CHAINED_METADATA: {
2031      if (!First) {
2032        Error("CHAINED_METADATA is not first record in block");
2033        return Failure;
2034      }
2035      if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2036        Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old
2037                                           : diag::warn_pch_version_too_new);
2038        return IgnorePCH;
2039      }
2040
2041      // Load the chained file, which is always a PCH file.
2042      // FIXME: This could end up being a module.
2043      switch(ReadASTCore(StringRef(BlobStart, BlobLen), MK_PCH)) {
2044      case Failure: return Failure;
2045        // If we have to ignore the dependency, we'll have to ignore this too.
2046      case IgnorePCH: return IgnorePCH;
2047      case Success: break;
2048      }
2049      break;
2050    }
2051
2052    case TYPE_OFFSET:
2053      if (F.LocalNumTypes != 0) {
2054        Error("duplicate TYPE_OFFSET record in AST file");
2055        return Failure;
2056      }
2057      F.TypeOffsets = (const uint32_t *)BlobStart;
2058      F.LocalNumTypes = Record[0];
2059      F.BaseTypeID = getTotalNumTypes();
2060
2061      // Introduce the global -> local mapping for types within this
2062      // AST file.
2063      GlobalTypeMap.insert(std::make_pair(getTotalNumTypes() + 1, &F));
2064      TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
2065      break;
2066
2067    case DECL_OFFSET:
2068      if (F.LocalNumDecls != 0) {
2069        Error("duplicate DECL_OFFSET record in AST file");
2070        return Failure;
2071      }
2072      F.DeclOffsets = (const uint32_t *)BlobStart;
2073      F.LocalNumDecls = Record[0];
2074      F.BaseDeclID = getTotalNumDecls();
2075
2076      // Introduce the global -> local mapping for declarations within this
2077      // AST file.
2078      GlobalDeclMap.insert(std::make_pair(getTotalNumDecls() + 1, &F));
2079      DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2080      break;
2081
2082    case TU_UPDATE_LEXICAL: {
2083      DeclContextInfo Info = {
2084        &F,
2085        /* No visible information */ 0,
2086        reinterpret_cast<const KindDeclIDPair *>(BlobStart),
2087        static_cast<unsigned int>(BlobLen / sizeof(KindDeclIDPair))
2088      };
2089      DeclContextOffsets[Context ? Context->getTranslationUnitDecl() : 0]
2090        .push_back(Info);
2091      break;
2092    }
2093
2094    case UPDATE_VISIBLE: {
2095      serialization::DeclID ID = Record[0];
2096      void *Table = ASTDeclContextNameLookupTable::Create(
2097                        (const unsigned char *)BlobStart + Record[1],
2098                        (const unsigned char *)BlobStart,
2099                        ASTDeclContextNameLookupTrait(*this, F));
2100      if (ID == 1 && Context) { // Is it the TU?
2101        DeclContextInfo Info = {
2102          &F, Table, /* No lexical inforamtion */ 0, 0
2103        };
2104        DeclContextOffsets[Context->getTranslationUnitDecl()].push_back(Info);
2105      } else
2106        PendingVisibleUpdates[ID].push_back(Table);
2107      break;
2108    }
2109
2110    case REDECLS_UPDATE_LATEST: {
2111      assert(Record.size() % 2 == 0 && "Expected pairs of DeclIDs");
2112      for (unsigned i = 0, e = Record.size(); i < e; i += 2) {
2113        DeclID First = Record[i], Latest = Record[i+1];
2114        assert((FirstLatestDeclIDs.find(First) == FirstLatestDeclIDs.end() ||
2115                Latest > FirstLatestDeclIDs[First]) &&
2116               "The new latest is supposed to come after the previous latest");
2117        FirstLatestDeclIDs[First] = Latest;
2118      }
2119      break;
2120    }
2121
2122    case LANGUAGE_OPTIONS:
2123      if (ParseLanguageOptions(Record) && !DisableValidation)
2124        return IgnorePCH;
2125      break;
2126
2127    case IDENTIFIER_TABLE:
2128      F.IdentifierTableData = BlobStart;
2129      if (Record[0]) {
2130        F.IdentifierLookupTable
2131          = ASTIdentifierLookupTable::Create(
2132                       (const unsigned char *)F.IdentifierTableData + Record[0],
2133                       (const unsigned char *)F.IdentifierTableData,
2134                       ASTIdentifierLookupTrait(*this, F));
2135        if (PP) {
2136          PP->getIdentifierTable().setExternalIdentifierLookup(this);
2137          PP->getHeaderSearchInfo().SetExternalLookup(this);
2138        }
2139      }
2140      break;
2141
2142    case IDENTIFIER_OFFSET:
2143      if (F.LocalNumIdentifiers != 0) {
2144        Error("duplicate IDENTIFIER_OFFSET record in AST file");
2145        return Failure;
2146      }
2147      F.IdentifierOffsets = (const uint32_t *)BlobStart;
2148      F.LocalNumIdentifiers = Record[0];
2149      F.BaseIdentifierID = getTotalNumIdentifiers();
2150
2151      // Introduce the global -> local mapping for identifiers within this AST
2152      // file
2153      GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2154                                                &F));
2155      IdentifiersLoaded.resize(IdentifiersLoaded.size() +F.LocalNumIdentifiers);
2156      break;
2157
2158    case EXTERNAL_DEFINITIONS:
2159      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2160        ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I]));
2161      break;
2162
2163    case SPECIAL_TYPES:
2164      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2165        SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2166      break;
2167
2168    case STATISTICS:
2169      TotalNumStatements += Record[0];
2170      TotalNumMacros += Record[1];
2171      TotalLexicalDeclContexts += Record[2];
2172      TotalVisibleDeclContexts += Record[3];
2173      break;
2174
2175    case UNUSED_FILESCOPED_DECLS:
2176      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2177        UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2178      break;
2179
2180    case DELEGATING_CTORS:
2181      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2182        DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
2183      break;
2184
2185    case WEAK_UNDECLARED_IDENTIFIERS:
2186      if (Record.size() % 4 != 0) {
2187        Error("invalid weak identifiers record");
2188        return Failure;
2189      }
2190
2191      // FIXME: Ignore weak undeclared identifiers from non-original PCH
2192      // files. This isn't the way to do it :)
2193      WeakUndeclaredIdentifiers.clear();
2194
2195      // Translate the weak, undeclared identifiers into global IDs.
2196      for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
2197        WeakUndeclaredIdentifiers.push_back(
2198          getGlobalIdentifierID(F, Record[I++]));
2199        WeakUndeclaredIdentifiers.push_back(
2200          getGlobalIdentifierID(F, Record[I++]));
2201        WeakUndeclaredIdentifiers.push_back(
2202          ReadSourceLocation(F, Record, I).getRawEncoding());
2203        WeakUndeclaredIdentifiers.push_back(Record[I++]);
2204      }
2205      break;
2206
2207    case LOCALLY_SCOPED_EXTERNAL_DECLS:
2208      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2209        LocallyScopedExternalDecls.push_back(getGlobalDeclID(F, Record[I]));
2210      break;
2211
2212    case SELECTOR_OFFSETS:
2213      F.SelectorOffsets = (const uint32_t *)BlobStart;
2214      F.LocalNumSelectors = Record[0];
2215      F.BaseSelectorID = getTotalNumSelectors();
2216
2217      // Introduce the global -> local mapping for identifiers within this AST
2218      // file
2219      GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors() + 1, &F));
2220      SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
2221      break;
2222
2223    case METHOD_POOL:
2224      F.SelectorLookupTableData = (const unsigned char *)BlobStart;
2225      if (Record[0])
2226        F.SelectorLookupTable
2227          = ASTSelectorLookupTable::Create(
2228                        F.SelectorLookupTableData + Record[0],
2229                        F.SelectorLookupTableData,
2230                        ASTSelectorLookupTrait(*this, F));
2231      TotalNumMethodPoolEntries += Record[1];
2232      break;
2233
2234    case REFERENCED_SELECTOR_POOL:
2235      if (!Record.empty()) {
2236        for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
2237          ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
2238                                                                Record[Idx++]));
2239          ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
2240                                              getRawEncoding());
2241        }
2242      }
2243      break;
2244
2245    case PP_COUNTER_VALUE:
2246      if (!Record.empty() && Listener)
2247        Listener->ReadCounter(Record[0]);
2248      break;
2249
2250    case SOURCE_LOCATION_OFFSETS: {
2251      F.SLocEntryOffsets = (const uint32_t *)BlobStart;
2252      F.LocalNumSLocEntries = Record[0];
2253      llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
2254          SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries, Record[1]);
2255      // Make our entry in the range map. BaseID is negative and growing, so
2256      // we invert it. Because we invert it, though, we need the other end of
2257      // the range.
2258      unsigned RangeStart =
2259          unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
2260      GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
2261      F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
2262
2263      // Initialize the remapping table.
2264      // Invalid stays invalid.
2265      F.SLocRemap.insert(std::make_pair(0U, 0));
2266      // This module. Base was 2 when being compiled.
2267      F.SLocRemap.insert(std::make_pair(2U,
2268                                  static_cast<int>(F.SLocEntryBaseOffset - 2)));
2269
2270      TotalNumSLocEntries += F.LocalNumSLocEntries;
2271      break;
2272    }
2273
2274    case MODULE_OFFSET_MAP: {
2275      // Additional remapping information.
2276      const unsigned char *Data = (const unsigned char*)BlobStart;
2277      const unsigned char *DataEnd = Data + BlobLen;
2278
2279      // Continuous range maps we may be updating in our module.
2280      ContinuousRangeMap<uint32_t, int, 2>::Builder SLocRemap(F.SLocRemap);
2281
2282      while(Data < DataEnd) {
2283        uint16_t Len = io::ReadUnalignedLE16(Data);
2284        StringRef Name = StringRef((const char*)Data, Len);
2285        Data += Len;
2286        Module *OM = ModuleMgr.lookup(Name);
2287        if (!OM) {
2288          Error("SourceLocation remap refers to unknown module");
2289          return Failure;
2290        }
2291
2292        uint32_t SLocOffset = io::ReadUnalignedLE32(Data);
2293        uint32_t IdentifierIDOffset = io::ReadUnalignedLE32(Data);
2294        uint32_t PreprocessedEntityIDOffset = io::ReadUnalignedLE32(Data);
2295        uint32_t MacroDefinitionIDOffset = io::ReadUnalignedLE32(Data);
2296        uint32_t SelectorIDOffset = io::ReadUnalignedLE32(Data);
2297        uint32_t DeclIDOffset = io::ReadUnalignedLE32(Data);
2298        uint32_t CXXBaseSpecifiersIDOffset = io::ReadUnalignedLE32(Data);
2299        uint32_t TypeIDOffset = io::ReadUnalignedLE32(Data);
2300
2301        // Source location offset is mapped to OM->SLocEntryBaseOffset.
2302        SLocRemap.insert(std::make_pair(SLocOffset,
2303          static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset)));
2304
2305        // FIXME: Map other locations
2306        (void)IdentifierIDOffset;
2307        (void)PreprocessedEntityIDOffset;
2308        (void)MacroDefinitionIDOffset;
2309        (void)SelectorIDOffset;
2310        (void)DeclIDOffset;
2311        (void)CXXBaseSpecifiersIDOffset;
2312        (void)TypeIDOffset;
2313      }
2314      break;
2315    }
2316
2317    case SOURCE_MANAGER_LINE_TABLE:
2318      if (ParseLineTable(F, Record))
2319        return Failure;
2320      break;
2321
2322    case FILE_SOURCE_LOCATION_OFFSETS:
2323      F.SLocFileOffsets = (const uint32_t *)BlobStart;
2324      F.LocalNumSLocFileEntries = Record[0];
2325      break;
2326
2327    case SOURCE_LOCATION_PRELOADS: {
2328      // Need to transform from the local view (1-based IDs) to the global view,
2329      // which is based off F.SLocEntryBaseID.
2330      PreloadSLocEntries.reserve(PreloadSLocEntries.size() + Record.size());
2331      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2332        PreloadSLocEntries.push_back(int(Record[I] - 1) + F.SLocEntryBaseID);
2333      break;
2334    }
2335
2336    case STAT_CACHE: {
2337      if (!DisableStatCache) {
2338        ASTStatCache *MyStatCache =
2339          new ASTStatCache((const unsigned char *)BlobStart + Record[0],
2340                           (const unsigned char *)BlobStart,
2341                           NumStatHits, NumStatMisses);
2342        FileMgr.addStatCache(MyStatCache);
2343        F.StatCache = MyStatCache;
2344      }
2345      break;
2346    }
2347
2348    case EXT_VECTOR_DECLS:
2349      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2350        ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
2351      break;
2352
2353    case VTABLE_USES:
2354      if (Record.size() % 3 != 0) {
2355        Error("Invalid VTABLE_USES record");
2356        return Failure;
2357      }
2358
2359      // Later tables overwrite earlier ones.
2360      // FIXME: Modules will have some trouble with this. This is clearly not
2361      // the right way to do this.
2362      VTableUses.clear();
2363
2364      for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
2365        VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
2366        VTableUses.push_back(
2367          ReadSourceLocation(F, Record, Idx).getRawEncoding());
2368        VTableUses.push_back(Record[Idx++]);
2369      }
2370      break;
2371
2372    case DYNAMIC_CLASSES:
2373      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2374        DynamicClasses.push_back(getGlobalDeclID(F, Record[I]));
2375      break;
2376
2377    case PENDING_IMPLICIT_INSTANTIATIONS:
2378      if (PendingInstantiations.size() % 2 != 0) {
2379        Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
2380        return Failure;
2381      }
2382
2383      // Later lists of pending instantiations overwrite earlier ones.
2384      // FIXME: This is most certainly wrong for modules.
2385      PendingInstantiations.clear();
2386      for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
2387        PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
2388        PendingInstantiations.push_back(
2389          ReadSourceLocation(F, Record, I).getRawEncoding());
2390      }
2391      break;
2392
2393    case SEMA_DECL_REFS:
2394      // Later tables overwrite earlier ones.
2395      // FIXME: Modules will have some trouble with this.
2396      SemaDeclRefs.clear();
2397      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2398        SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
2399      break;
2400
2401    case ORIGINAL_FILE_NAME:
2402      // The primary AST will be the last to get here, so it will be the one
2403      // that's used.
2404      ActualOriginalFileName.assign(BlobStart, BlobLen);
2405      OriginalFileName = ActualOriginalFileName;
2406      MaybeAddSystemRootToFilename(OriginalFileName);
2407      break;
2408
2409    case ORIGINAL_FILE_ID:
2410      OriginalFileID = FileID::get(Record[0]);
2411      break;
2412
2413    case ORIGINAL_PCH_DIR:
2414      // The primary AST will be the last to get here, so it will be the one
2415      // that's used.
2416      OriginalDir.assign(BlobStart, BlobLen);
2417      break;
2418
2419    case VERSION_CONTROL_BRANCH_REVISION: {
2420      const std::string &CurBranch = getClangFullRepositoryVersion();
2421      StringRef ASTBranch(BlobStart, BlobLen);
2422      if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2423        Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch;
2424        return IgnorePCH;
2425      }
2426      break;
2427    }
2428
2429    case MACRO_DEFINITION_OFFSETS: {
2430      F.MacroDefinitionOffsets = (const uint32_t *)BlobStart;
2431      F.NumPreallocatedPreprocessingEntities = Record[0];
2432      F.LocalNumMacroDefinitions = Record[1];
2433
2434      // Introduce the global -> local mapping for preprocessed entities within
2435      // this AST file.
2436      unsigned StartingID;
2437      if (PP) {
2438        if (!PP->getPreprocessingRecord())
2439          PP->createPreprocessingRecord(true);
2440        if (!PP->getPreprocessingRecord()->getExternalSource())
2441          PP->getPreprocessingRecord()->SetExternalSource(*this);
2442        StartingID
2443          = PP->getPreprocessingRecord()
2444              ->allocateLoadedEntities(F.NumPreallocatedPreprocessingEntities);
2445      } else {
2446        // FIXME: We'll eventually want to kill this path, since it assumes
2447        // a particular allocation strategy in the preprocessing record.
2448        StartingID = getTotalNumPreprocessedEntities();
2449      }
2450
2451      F.BaseMacroDefinitionID = getTotalNumMacroDefinitions();
2452      F.BasePreprocessedEntityID = StartingID;
2453
2454      // Introduce the global -> local mapping for macro definitions within
2455      // this AST file.
2456      GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
2457      GlobalMacroDefinitionMap.insert(
2458        std::make_pair(getTotalNumMacroDefinitions() + 1, &F));
2459      MacroDefinitionsLoaded.resize(
2460                    MacroDefinitionsLoaded.size() + F.LocalNumMacroDefinitions);
2461      break;
2462    }
2463
2464    case DECL_UPDATE_OFFSETS: {
2465      if (Record.size() % 2 != 0) {
2466        Error("invalid DECL_UPDATE_OFFSETS block in AST file");
2467        return Failure;
2468      }
2469      for (unsigned I = 0, N = Record.size(); I != N; I += 2)
2470        DeclUpdateOffsets[static_cast<DeclID>(Record[I])]
2471            .push_back(std::make_pair(&F, Record[I+1]));
2472      break;
2473    }
2474
2475    case DECL_REPLACEMENTS: {
2476      if (Record.size() % 2 != 0) {
2477        Error("invalid DECL_REPLACEMENTS block in AST file");
2478        return Failure;
2479      }
2480      for (unsigned I = 0, N = Record.size(); I != N; I += 2)
2481        ReplacedDecls[static_cast<DeclID>(Record[I])] =
2482            std::make_pair(&F, Record[I+1]);
2483      break;
2484    }
2485
2486    case CXX_BASE_SPECIFIER_OFFSETS: {
2487      if (F.LocalNumCXXBaseSpecifiers != 0) {
2488        Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file");
2489        return Failure;
2490      }
2491
2492      F.LocalNumCXXBaseSpecifiers = Record[0];
2493      F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart;
2494      F.BaseCXXBaseSpecifiersID = getTotalNumCXXBaseSpecifiers();
2495      GlobalCXXBaseSpecifiersMap.insert(
2496        std::make_pair(getTotalNumCXXBaseSpecifiers() + 1, &F));
2497
2498      NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers;
2499      break;
2500    }
2501
2502    case DIAG_PRAGMA_MAPPINGS:
2503      if (Record.size() % 2 != 0) {
2504        Error("invalid DIAG_USER_MAPPINGS block in AST file");
2505        return Failure;
2506      }
2507
2508      if (F.PragmaDiagMappings.empty())
2509        F.PragmaDiagMappings.swap(Record);
2510      else
2511        F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(),
2512                                    Record.begin(), Record.end());
2513      break;
2514
2515    case CUDA_SPECIAL_DECL_REFS:
2516      // Later tables overwrite earlier ones.
2517      // FIXME: Modules will have trouble with this.
2518      CUDASpecialDeclRefs.clear();
2519      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2520        CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
2521      break;
2522
2523    case HEADER_SEARCH_TABLE: {
2524      F.HeaderFileInfoTableData = BlobStart;
2525      F.LocalNumHeaderFileInfos = Record[1];
2526      F.HeaderFileFrameworkStrings = BlobStart + Record[2];
2527      if (Record[0]) {
2528        F.HeaderFileInfoTable
2529          = HeaderFileInfoLookupTable::Create(
2530                   (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
2531                   (const unsigned char *)F.HeaderFileInfoTableData,
2532                   HeaderFileInfoTrait(*this, F,
2533                                       PP? &PP->getHeaderSearchInfo() : 0,
2534                                       BlobStart + Record[2]));
2535        if (PP)
2536          PP->getHeaderSearchInfo().SetExternalSource(this);
2537      }
2538      break;
2539    }
2540
2541    case FP_PRAGMA_OPTIONS:
2542      // Later tables overwrite earlier ones.
2543      FPPragmaOptions.swap(Record);
2544      break;
2545
2546    case OPENCL_EXTENSIONS:
2547      // Later tables overwrite earlier ones.
2548      OpenCLExtensions.swap(Record);
2549      break;
2550
2551    case TENTATIVE_DEFINITIONS:
2552      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2553        TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
2554      break;
2555
2556    case KNOWN_NAMESPACES:
2557      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2558        KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
2559      break;
2560    }
2561    First = false;
2562  }
2563  Error("premature end of bitstream in AST file");
2564  return Failure;
2565}
2566
2567ASTReader::ASTReadResult ASTReader::validateFileEntries() {
2568  for (ModuleIterator I = ModuleMgr.begin(),
2569      E = ModuleMgr.end(); I != E; ++I) {
2570    Module *F = *I;
2571    llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
2572
2573    for (unsigned i = 0, e = F->LocalNumSLocFileEntries; i != e; ++i) {
2574      SLocEntryCursor.JumpToBit(F->SLocFileOffsets[i]);
2575      unsigned Code = SLocEntryCursor.ReadCode();
2576      if (Code == llvm::bitc::END_BLOCK ||
2577          Code == llvm::bitc::ENTER_SUBBLOCK ||
2578          Code == llvm::bitc::DEFINE_ABBREV) {
2579        Error("incorrectly-formatted source location entry in AST file");
2580        return Failure;
2581      }
2582
2583      RecordData Record;
2584      const char *BlobStart;
2585      unsigned BlobLen;
2586      switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
2587      default:
2588        Error("incorrectly-formatted source location entry in AST file");
2589        return Failure;
2590
2591      case SM_SLOC_FILE_ENTRY: {
2592        StringRef Filename(BlobStart, BlobLen);
2593        const FileEntry *File = getFileEntry(Filename);
2594
2595        if (File == 0) {
2596          std::string ErrorStr = "could not find file '";
2597          ErrorStr += Filename;
2598          ErrorStr += "' referenced by AST file";
2599          Error(ErrorStr.c_str());
2600          return IgnorePCH;
2601        }
2602
2603        if (Record.size() < 6) {
2604          Error("source location entry is incorrect");
2605          return Failure;
2606        }
2607
2608        // The stat info from the FileEntry came from the cached stat
2609        // info of the PCH, so we cannot trust it.
2610        struct stat StatBuf;
2611        if (::stat(File->getName(), &StatBuf) != 0) {
2612          StatBuf.st_size = File->getSize();
2613          StatBuf.st_mtime = File->getModificationTime();
2614        }
2615
2616        if (((off_t)Record[4] != StatBuf.st_size
2617#if !defined(LLVM_ON_WIN32)
2618            // In our regression testing, the Windows file system seems to
2619            // have inconsistent modification times that sometimes
2620            // erroneously trigger this error-handling path.
2621             || (time_t)Record[5] != StatBuf.st_mtime
2622#endif
2623            )) {
2624          Error(diag::err_fe_pch_file_modified, Filename);
2625          return IgnorePCH;
2626        }
2627
2628        break;
2629      }
2630      }
2631    }
2632  }
2633
2634  return Success;
2635}
2636
2637ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName,
2638                                            ModuleKind Type) {
2639  switch(ReadASTCore(FileName, Type)) {
2640  case Failure: return Failure;
2641  case IgnorePCH: return IgnorePCH;
2642  case Success: break;
2643  }
2644
2645  // Here comes stuff that we only do once the entire chain is loaded.
2646
2647  if (!DisableValidation) {
2648    switch(validateFileEntries()) {
2649    case Failure: return Failure;
2650    case IgnorePCH: return IgnorePCH;
2651    case Success: break;
2652    }
2653  }
2654
2655  // Preload SLocEntries.
2656  for (unsigned I = 0, N = PreloadSLocEntries.size(); I != N; ++I) {
2657    ASTReadResult Result = ReadSLocEntryRecord(PreloadSLocEntries[I]);
2658    if (Result != Success)
2659      return Failure;
2660  }
2661  PreloadSLocEntries.clear();
2662
2663  // Check the predefines buffers.
2664  if (!DisableValidation && Type != MK_Module && CheckPredefinesBuffers())
2665    return IgnorePCH;
2666
2667  if (PP) {
2668    // Initialization of keywords and pragmas occurs before the
2669    // AST file is read, so there may be some identifiers that were
2670    // loaded into the IdentifierTable before we intercepted the
2671    // creation of identifiers. Iterate through the list of known
2672    // identifiers and determine whether we have to establish
2673    // preprocessor definitions or top-level identifier declaration
2674    // chains for those identifiers.
2675    //
2676    // We copy the IdentifierInfo pointers to a small vector first,
2677    // since de-serializing declarations or macro definitions can add
2678    // new entries into the identifier table, invalidating the
2679    // iterators.
2680    //
2681    // FIXME: We need a lazier way to load this information, e.g., by marking
2682    // the identifier data as 'dirty', so that it will be looked up in the
2683    // AST file(s) if it is uttered in the source. This could save us some
2684    // module load time.
2685    SmallVector<IdentifierInfo *, 128> Identifiers;
2686    for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(),
2687                                IdEnd = PP->getIdentifierTable().end();
2688         Id != IdEnd; ++Id)
2689      Identifiers.push_back(Id->second);
2690    // We need to search the tables in all files.
2691    for (ModuleIterator J = ModuleMgr.begin(),
2692        M = ModuleMgr.end(); J != M; ++J) {
2693      ASTIdentifierLookupTable *IdTable
2694        = (ASTIdentifierLookupTable *)(*J)->IdentifierLookupTable;
2695      // Not all AST files necessarily have identifier tables, only the useful
2696      // ones.
2697      if (!IdTable)
2698        continue;
2699      for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) {
2700        IdentifierInfo *II = Identifiers[I];
2701        // Look in the on-disk hash tables for an entry for this identifier
2702        ASTIdentifierLookupTrait Info(*this, *(*J), II);
2703        std::pair<const char*,unsigned> Key(II->getNameStart(),II->getLength());
2704        ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info);
2705        if (Pos == IdTable->end())
2706          continue;
2707
2708        // Dereferencing the iterator has the effect of populating the
2709        // IdentifierInfo node with the various declarations it needs.
2710        (void)*Pos;
2711      }
2712    }
2713  }
2714
2715  if (Context)
2716    InitializeContext(*Context);
2717
2718  if (DeserializationListener)
2719    DeserializationListener->ReaderInitialized(this);
2720
2721  // If this AST file is a precompiled preamble, then set the main file ID of
2722  // the source manager to the file source file from which the preamble was
2723  // built. This is the only valid way to use a precompiled preamble.
2724  if (Type == MK_Preamble) {
2725    if (OriginalFileID.isInvalid()) {
2726      SourceLocation Loc
2727        = SourceMgr.getLocation(FileMgr.getFile(getOriginalSourceFile()), 1, 1);
2728      if (Loc.isValid())
2729        OriginalFileID = SourceMgr.getDecomposedLoc(Loc).first;
2730    }
2731    else {
2732      OriginalFileID = FileID::get(ModuleMgr.getPrimaryModule().SLocEntryBaseID
2733                                        + OriginalFileID.getOpaqueValue() - 1);
2734    }
2735
2736    if (!OriginalFileID.isInvalid())
2737      SourceMgr.SetPreambleFileID(OriginalFileID);
2738  }
2739
2740  return Success;
2741}
2742
2743ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName,
2744                                                ModuleKind Type) {
2745  Module &F = ModuleMgr.addModule(FileName, Type);
2746
2747  if (FileName != "-") {
2748    CurrentDir = llvm::sys::path::parent_path(FileName);
2749    if (CurrentDir.empty()) CurrentDir = ".";
2750  }
2751
2752  if (!ASTBuffers.empty()) {
2753    F.Buffer.reset(ASTBuffers.back());
2754    ASTBuffers.pop_back();
2755    assert(F.Buffer && "Passed null buffer");
2756  } else {
2757    // Open the AST file.
2758    //
2759    // FIXME: This shouldn't be here, we should just take a raw_ostream.
2760    std::string ErrStr;
2761    llvm::error_code ec;
2762    if (FileName == "-") {
2763      ec = llvm::MemoryBuffer::getSTDIN(F.Buffer);
2764      if (ec)
2765        ErrStr = ec.message();
2766    } else
2767      F.Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrStr));
2768    if (!F.Buffer) {
2769      Error(ErrStr.c_str());
2770      return IgnorePCH;
2771    }
2772  }
2773
2774  // Initialize the stream
2775  F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(),
2776                    (const unsigned char *)F.Buffer->getBufferEnd());
2777  llvm::BitstreamCursor &Stream = F.Stream;
2778  Stream.init(F.StreamFile);
2779  F.SizeInBits = F.Buffer->getBufferSize() * 8;
2780
2781  // Sniff for the signature.
2782  if (Stream.Read(8) != 'C' ||
2783      Stream.Read(8) != 'P' ||
2784      Stream.Read(8) != 'C' ||
2785      Stream.Read(8) != 'H') {
2786    Diag(diag::err_not_a_pch_file) << FileName;
2787    return Failure;
2788  }
2789
2790  while (!Stream.AtEndOfStream()) {
2791    unsigned Code = Stream.ReadCode();
2792
2793    if (Code != llvm::bitc::ENTER_SUBBLOCK) {
2794      Error("invalid record at top-level of AST file");
2795      return Failure;
2796    }
2797
2798    unsigned BlockID = Stream.ReadSubBlockID();
2799
2800    // We only know the AST subblock ID.
2801    switch (BlockID) {
2802    case llvm::bitc::BLOCKINFO_BLOCK_ID:
2803      if (Stream.ReadBlockInfoBlock()) {
2804        Error("malformed BlockInfoBlock in AST file");
2805        return Failure;
2806      }
2807      break;
2808    case AST_BLOCK_ID:
2809      switch (ReadASTBlock(F)) {
2810      case Success:
2811        break;
2812
2813      case Failure:
2814        return Failure;
2815
2816      case IgnorePCH:
2817        // FIXME: We could consider reading through to the end of this
2818        // AST block, skipping subblocks, to see if there are other
2819        // AST blocks elsewhere.
2820
2821        // FIXME: We can't clear loaded slocentries anymore.
2822        //SourceMgr.ClearPreallocatedSLocEntries();
2823
2824        // Remove the stat cache.
2825        if (F.StatCache)
2826          FileMgr.removeStatCache((ASTStatCache*)F.StatCache);
2827
2828        return IgnorePCH;
2829      }
2830      break;
2831    default:
2832      if (Stream.SkipBlock()) {
2833        Error("malformed block record in AST file");
2834        return Failure;
2835      }
2836      break;
2837    }
2838  }
2839
2840  // Once read, set the Module bit base offset and update the size in
2841  // bits of all files we've seen.
2842  F.GlobalBitOffset = TotalModulesSizeInBits;
2843  TotalModulesSizeInBits += F.SizeInBits;
2844  GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
2845  return Success;
2846}
2847
2848void ASTReader::setPreprocessor(Preprocessor &pp) {
2849  PP = &pp;
2850
2851  if (unsigned N = getTotalNumPreprocessedEntities()) {
2852    if (!PP->getPreprocessingRecord())
2853      PP->createPreprocessingRecord(true);
2854    PP->getPreprocessingRecord()->SetExternalSource(*this);
2855    PP->getPreprocessingRecord()->allocateLoadedEntities(N);
2856  }
2857
2858  PP->getHeaderSearchInfo().SetExternalLookup(this);
2859  PP->getHeaderSearchInfo().SetExternalSource(this);
2860}
2861
2862void ASTReader::InitializeContext(ASTContext &Ctx) {
2863  Context = &Ctx;
2864  assert(Context && "Passed null context!");
2865
2866  assert(PP && "Forgot to set Preprocessor ?");
2867  PP->getIdentifierTable().setExternalIdentifierLookup(this);
2868  PP->setExternalSource(this);
2869
2870  // If we have an update block for the TU waiting, we have to add it before
2871  // deserializing the decl.
2872  DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0);
2873  if (DCU != DeclContextOffsets.end()) {
2874    // Insertion could invalidate map, so grab vector.
2875    DeclContextInfos T;
2876    T.swap(DCU->second);
2877    DeclContextOffsets.erase(DCU);
2878    DeclContextOffsets[Ctx.getTranslationUnitDecl()].swap(T);
2879  }
2880
2881  // Load the translation unit declaration
2882  GetTranslationUnitDecl();
2883
2884  // Load the special types.
2885  Context->setBuiltinVaListType(
2886    GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST]));
2887  if (unsigned Id = SpecialTypes[SPECIAL_TYPE_OBJC_ID])
2888    Context->setObjCIdType(GetType(Id));
2889  if (unsigned Sel = SpecialTypes[SPECIAL_TYPE_OBJC_SELECTOR])
2890    Context->setObjCSelType(GetType(Sel));
2891  if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL])
2892    Context->setObjCProtoType(GetType(Proto));
2893  if (unsigned Class = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS])
2894    Context->setObjCClassType(GetType(Class));
2895
2896  if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING])
2897    Context->setCFConstantStringType(GetType(String));
2898  if (unsigned FastEnum
2899        = SpecialTypes[SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE])
2900    Context->setObjCFastEnumerationStateType(GetType(FastEnum));
2901  if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
2902    QualType FileType = GetType(File);
2903    if (FileType.isNull()) {
2904      Error("FILE type is NULL");
2905      return;
2906    }
2907    if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
2908      Context->setFILEDecl(Typedef->getDecl());
2909    else {
2910      const TagType *Tag = FileType->getAs<TagType>();
2911      if (!Tag) {
2912        Error("Invalid FILE type in AST file");
2913        return;
2914      }
2915      Context->setFILEDecl(Tag->getDecl());
2916    }
2917  }
2918  if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) {
2919    QualType Jmp_bufType = GetType(Jmp_buf);
2920    if (Jmp_bufType.isNull()) {
2921      Error("jmp_bug type is NULL");
2922      return;
2923    }
2924    if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
2925      Context->setjmp_bufDecl(Typedef->getDecl());
2926    else {
2927      const TagType *Tag = Jmp_bufType->getAs<TagType>();
2928      if (!Tag) {
2929        Error("Invalid jmp_buf type in AST file");
2930        return;
2931      }
2932      Context->setjmp_bufDecl(Tag->getDecl());
2933    }
2934  }
2935  if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) {
2936    QualType Sigjmp_bufType = GetType(Sigjmp_buf);
2937    if (Sigjmp_bufType.isNull()) {
2938      Error("sigjmp_buf type is NULL");
2939      return;
2940    }
2941    if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
2942      Context->setsigjmp_bufDecl(Typedef->getDecl());
2943    else {
2944      const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
2945      assert(Tag && "Invalid sigjmp_buf type in AST file");
2946      Context->setsigjmp_bufDecl(Tag->getDecl());
2947    }
2948  }
2949  if (unsigned ObjCIdRedef
2950        = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION])
2951    Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef);
2952  if (unsigned ObjCClassRedef
2953      = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION])
2954    Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef);
2955  if (unsigned String = SpecialTypes[SPECIAL_TYPE_BLOCK_DESCRIPTOR])
2956    Context->setBlockDescriptorType(GetType(String));
2957  if (unsigned String
2958      = SpecialTypes[SPECIAL_TYPE_BLOCK_EXTENDED_DESCRIPTOR])
2959    Context->setBlockDescriptorExtendedType(GetType(String));
2960  if (unsigned ObjCSelRedef
2961      = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION])
2962    Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef);
2963  if (unsigned String = SpecialTypes[SPECIAL_TYPE_NS_CONSTANT_STRING])
2964    Context->setNSConstantStringType(GetType(String));
2965
2966  if (SpecialTypes[SPECIAL_TYPE_INT128_INSTALLED])
2967    Context->setInt128Installed();
2968
2969  if (unsigned AutoDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_DEDUCT])
2970    Context->AutoDeductTy = GetType(AutoDeduct);
2971  if (unsigned AutoRRefDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_RREF_DEDUCT])
2972    Context->AutoRRefDeductTy = GetType(AutoRRefDeduct);
2973
2974  ReadPragmaDiagnosticMappings(Context->getDiagnostics());
2975
2976  // If there were any CUDA special declarations, deserialize them.
2977  if (!CUDASpecialDeclRefs.empty()) {
2978    assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
2979    Context->setcudaConfigureCallDecl(
2980                           cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
2981  }
2982}
2983
2984/// \brief Retrieve the name of the original source file name
2985/// directly from the AST file, without actually loading the AST
2986/// file.
2987std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
2988                                             FileManager &FileMgr,
2989                                             Diagnostic &Diags) {
2990  // Open the AST file.
2991  std::string ErrStr;
2992  llvm::OwningPtr<llvm::MemoryBuffer> Buffer;
2993  Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr));
2994  if (!Buffer) {
2995    Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr;
2996    return std::string();
2997  }
2998
2999  // Initialize the stream
3000  llvm::BitstreamReader StreamFile;
3001  llvm::BitstreamCursor Stream;
3002  StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
3003                  (const unsigned char *)Buffer->getBufferEnd());
3004  Stream.init(StreamFile);
3005
3006  // Sniff for the signature.
3007  if (Stream.Read(8) != 'C' ||
3008      Stream.Read(8) != 'P' ||
3009      Stream.Read(8) != 'C' ||
3010      Stream.Read(8) != 'H') {
3011    Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
3012    return std::string();
3013  }
3014
3015  RecordData Record;
3016  while (!Stream.AtEndOfStream()) {
3017    unsigned Code = Stream.ReadCode();
3018
3019    if (Code == llvm::bitc::ENTER_SUBBLOCK) {
3020      unsigned BlockID = Stream.ReadSubBlockID();
3021
3022      // We only know the AST subblock ID.
3023      switch (BlockID) {
3024      case AST_BLOCK_ID:
3025        if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
3026          Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
3027          return std::string();
3028        }
3029        break;
3030
3031      default:
3032        if (Stream.SkipBlock()) {
3033          Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
3034          return std::string();
3035        }
3036        break;
3037      }
3038      continue;
3039    }
3040
3041    if (Code == llvm::bitc::END_BLOCK) {
3042      if (Stream.ReadBlockEnd()) {
3043        Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName;
3044        return std::string();
3045      }
3046      continue;
3047    }
3048
3049    if (Code == llvm::bitc::DEFINE_ABBREV) {
3050      Stream.ReadAbbrevRecord();
3051      continue;
3052    }
3053
3054    Record.clear();
3055    const char *BlobStart = 0;
3056    unsigned BlobLen = 0;
3057    if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)
3058          == ORIGINAL_FILE_NAME)
3059      return std::string(BlobStart, BlobLen);
3060  }
3061
3062  return std::string();
3063}
3064
3065/// \brief Parse the record that corresponds to a LangOptions data
3066/// structure.
3067///
3068/// This routine parses the language options from the AST file and then gives
3069/// them to the AST listener if one is set.
3070///
3071/// \returns true if the listener deems the file unacceptable, false otherwise.
3072bool ASTReader::ParseLanguageOptions(
3073                             const SmallVectorImpl<uint64_t> &Record) {
3074  if (Listener) {
3075    LangOptions LangOpts;
3076
3077  #define PARSE_LANGOPT(Option)                  \
3078      LangOpts.Option = Record[Idx];             \
3079      ++Idx
3080
3081    unsigned Idx = 0;
3082    PARSE_LANGOPT(Trigraphs);
3083    PARSE_LANGOPT(BCPLComment);
3084    PARSE_LANGOPT(DollarIdents);
3085    PARSE_LANGOPT(AsmPreprocessor);
3086    PARSE_LANGOPT(GNUMode);
3087    PARSE_LANGOPT(GNUKeywords);
3088    PARSE_LANGOPT(ImplicitInt);
3089    PARSE_LANGOPT(Digraphs);
3090    PARSE_LANGOPT(HexFloats);
3091    PARSE_LANGOPT(C99);
3092    PARSE_LANGOPT(C1X);
3093    PARSE_LANGOPT(Microsoft);
3094    PARSE_LANGOPT(CPlusPlus);
3095    PARSE_LANGOPT(CPlusPlus0x);
3096    PARSE_LANGOPT(CXXOperatorNames);
3097    PARSE_LANGOPT(ObjC1);
3098    PARSE_LANGOPT(ObjC2);
3099    PARSE_LANGOPT(ObjCNonFragileABI);
3100    PARSE_LANGOPT(ObjCNonFragileABI2);
3101    PARSE_LANGOPT(AppleKext);
3102    PARSE_LANGOPT(ObjCDefaultSynthProperties);
3103    PARSE_LANGOPT(ObjCInferRelatedResultType);
3104    PARSE_LANGOPT(NoConstantCFStrings);
3105    PARSE_LANGOPT(PascalStrings);
3106    PARSE_LANGOPT(WritableStrings);
3107    PARSE_LANGOPT(LaxVectorConversions);
3108    PARSE_LANGOPT(AltiVec);
3109    PARSE_LANGOPT(Exceptions);
3110    PARSE_LANGOPT(ObjCExceptions);
3111    PARSE_LANGOPT(CXXExceptions);
3112    PARSE_LANGOPT(SjLjExceptions);
3113    PARSE_LANGOPT(MSBitfields);
3114    PARSE_LANGOPT(NeXTRuntime);
3115    PARSE_LANGOPT(Freestanding);
3116    PARSE_LANGOPT(NoBuiltin);
3117    PARSE_LANGOPT(ThreadsafeStatics);
3118    PARSE_LANGOPT(POSIXThreads);
3119    PARSE_LANGOPT(Blocks);
3120    PARSE_LANGOPT(EmitAllDecls);
3121    PARSE_LANGOPT(MathErrno);
3122    LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy)
3123                                       Record[Idx++]);
3124    PARSE_LANGOPT(HeinousExtensions);
3125    PARSE_LANGOPT(Optimize);
3126    PARSE_LANGOPT(OptimizeSize);
3127    PARSE_LANGOPT(Static);
3128    PARSE_LANGOPT(PICLevel);
3129    PARSE_LANGOPT(GNUInline);
3130    PARSE_LANGOPT(NoInline);
3131    PARSE_LANGOPT(Deprecated);
3132    PARSE_LANGOPT(AccessControl);
3133    PARSE_LANGOPT(CharIsSigned);
3134    PARSE_LANGOPT(ShortWChar);
3135    PARSE_LANGOPT(ShortEnums);
3136    LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]);
3137    LangOpts.setVisibilityMode((Visibility)Record[Idx++]);
3138    LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode)
3139                                   Record[Idx++]);
3140    PARSE_LANGOPT(InstantiationDepth);
3141    PARSE_LANGOPT(OpenCL);
3142    PARSE_LANGOPT(CUDA);
3143    PARSE_LANGOPT(CatchUndefined);
3144    PARSE_LANGOPT(DefaultFPContract);
3145    PARSE_LANGOPT(ElideConstructors);
3146    PARSE_LANGOPT(SpellChecking);
3147    PARSE_LANGOPT(MRTD);
3148    PARSE_LANGOPT(ObjCAutoRefCount);
3149  #undef PARSE_LANGOPT
3150
3151    return Listener->ReadLanguageOptions(LangOpts);
3152  }
3153
3154  return false;
3155}
3156
3157void ASTReader::ReadPreprocessedEntities() {
3158  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3159    Module &F = *(*I);
3160    if (!F.PreprocessorDetailCursor.getBitStreamReader())
3161      continue;
3162
3163    SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor);
3164    F.PreprocessorDetailCursor.JumpToBit(F.PreprocessorDetailStartOffset);
3165    while (LoadPreprocessedEntity(F)) { }
3166  }
3167}
3168
3169PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) {
3170  RecordLocation Loc = getLocalBitOffset(Offset);
3171
3172  // Keep track of where we are in the stream, then jump back there
3173  // after reading this entity.
3174  SavedStreamPosition SavedPosition(Loc.F->PreprocessorDetailCursor);
3175  Loc.F->PreprocessorDetailCursor.JumpToBit(Loc.Offset);
3176  return LoadPreprocessedEntity(*Loc.F);
3177}
3178
3179HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
3180  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3181    Module &F = *(*I);
3182
3183    HeaderFileInfoTrait Trait(*this, F, &PP->getHeaderSearchInfo(),
3184                              F.HeaderFileFrameworkStrings,
3185                              FE->getName());
3186
3187    HeaderFileInfoLookupTable *Table
3188      = static_cast<HeaderFileInfoLookupTable *>(F.HeaderFileInfoTable);
3189    if (!Table)
3190      continue;
3191
3192    // Look in the on-disk hash table for an entry for this file name.
3193    HeaderFileInfoLookupTable::iterator Pos = Table->find(FE->getName(),
3194                                                          &Trait);
3195    if (Pos == Table->end())
3196      continue;
3197
3198    HeaderFileInfo HFI = *Pos;
3199    if (Listener)
3200      Listener->ReadHeaderFileInfo(HFI, FE->getUID());
3201
3202    return HFI;
3203  }
3204
3205  return HeaderFileInfo();
3206}
3207
3208void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) {
3209  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3210    Module &F = *(*I);
3211    unsigned Idx = 0;
3212    while (Idx < F.PragmaDiagMappings.size()) {
3213      SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
3214      while (1) {
3215        assert(Idx < F.PragmaDiagMappings.size() &&
3216               "Invalid data, didn't find '-1' marking end of diag/map pairs");
3217        if (Idx >= F.PragmaDiagMappings.size()) {
3218          break; // Something is messed up but at least avoid infinite loop in
3219                 // release build.
3220        }
3221        unsigned DiagID = F.PragmaDiagMappings[Idx++];
3222        if (DiagID == (unsigned)-1) {
3223          break; // no more diag/map pairs for this location.
3224        }
3225        diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++];
3226        Diag.setDiagnosticMapping(DiagID, Map, Loc);
3227      }
3228    }
3229  }
3230}
3231
3232/// \brief Get the correct cursor and offset for loading a type.
3233ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
3234  GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index+1);
3235  assert(I != GlobalTypeMap.end() && "Corrupted global type map");
3236  Module *M = I->second;
3237  return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeID]);
3238}
3239
3240/// \brief Read and return the type with the given index..
3241///
3242/// The index is the type ID, shifted and minus the number of predefs. This
3243/// routine actually reads the record corresponding to the type at the given
3244/// location. It is a helper routine for GetType, which deals with reading type
3245/// IDs.
3246QualType ASTReader::readTypeRecord(unsigned Index) {
3247  RecordLocation Loc = TypeCursorForIndex(Index);
3248  llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
3249
3250  // Keep track of where we are in the stream, then jump back there
3251  // after reading this type.
3252  SavedStreamPosition SavedPosition(DeclsCursor);
3253
3254  ReadingKindTracker ReadingKind(Read_Type, *this);
3255
3256  // Note that we are loading a type record.
3257  Deserializing AType(this);
3258
3259  unsigned Idx = 0;
3260  DeclsCursor.JumpToBit(Loc.Offset);
3261  RecordData Record;
3262  unsigned Code = DeclsCursor.ReadCode();
3263  switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) {
3264  case TYPE_EXT_QUAL: {
3265    if (Record.size() != 2) {
3266      Error("Incorrect encoding of extended qualifier type");
3267      return QualType();
3268    }
3269    QualType Base = readType(*Loc.F, Record, Idx);
3270    Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
3271    return Context->getQualifiedType(Base, Quals);
3272  }
3273
3274  case TYPE_COMPLEX: {
3275    if (Record.size() != 1) {
3276      Error("Incorrect encoding of complex type");
3277      return QualType();
3278    }
3279    QualType ElemType = readType(*Loc.F, Record, Idx);
3280    return Context->getComplexType(ElemType);
3281  }
3282
3283  case TYPE_POINTER: {
3284    if (Record.size() != 1) {
3285      Error("Incorrect encoding of pointer type");
3286      return QualType();
3287    }
3288    QualType PointeeType = readType(*Loc.F, Record, Idx);
3289    return Context->getPointerType(PointeeType);
3290  }
3291
3292  case TYPE_BLOCK_POINTER: {
3293    if (Record.size() != 1) {
3294      Error("Incorrect encoding of block pointer type");
3295      return QualType();
3296    }
3297    QualType PointeeType = readType(*Loc.F, Record, Idx);
3298    return Context->getBlockPointerType(PointeeType);
3299  }
3300
3301  case TYPE_LVALUE_REFERENCE: {
3302    if (Record.size() != 2) {
3303      Error("Incorrect encoding of lvalue reference type");
3304      return QualType();
3305    }
3306    QualType PointeeType = readType(*Loc.F, Record, Idx);
3307    return Context->getLValueReferenceType(PointeeType, Record[1]);
3308  }
3309
3310  case TYPE_RVALUE_REFERENCE: {
3311    if (Record.size() != 1) {
3312      Error("Incorrect encoding of rvalue reference type");
3313      return QualType();
3314    }
3315    QualType PointeeType = readType(*Loc.F, Record, Idx);
3316    return Context->getRValueReferenceType(PointeeType);
3317  }
3318
3319  case TYPE_MEMBER_POINTER: {
3320    if (Record.size() != 2) {
3321      Error("Incorrect encoding of member pointer type");
3322      return QualType();
3323    }
3324    QualType PointeeType = readType(*Loc.F, Record, Idx);
3325    QualType ClassType = readType(*Loc.F, Record, Idx);
3326    if (PointeeType.isNull() || ClassType.isNull())
3327      return QualType();
3328
3329    return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr());
3330  }
3331
3332  case TYPE_CONSTANT_ARRAY: {
3333    QualType ElementType = readType(*Loc.F, Record, Idx);
3334    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3335    unsigned IndexTypeQuals = Record[2];
3336    unsigned Idx = 3;
3337    llvm::APInt Size = ReadAPInt(Record, Idx);
3338    return Context->getConstantArrayType(ElementType, Size,
3339                                         ASM, IndexTypeQuals);
3340  }
3341
3342  case TYPE_INCOMPLETE_ARRAY: {
3343    QualType ElementType = readType(*Loc.F, Record, Idx);
3344    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3345    unsigned IndexTypeQuals = Record[2];
3346    return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
3347  }
3348
3349  case TYPE_VARIABLE_ARRAY: {
3350    QualType ElementType = readType(*Loc.F, Record, Idx);
3351    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3352    unsigned IndexTypeQuals = Record[2];
3353    SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
3354    SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
3355    return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F),
3356                                         ASM, IndexTypeQuals,
3357                                         SourceRange(LBLoc, RBLoc));
3358  }
3359
3360  case TYPE_VECTOR: {
3361    if (Record.size() != 3) {
3362      Error("incorrect encoding of vector type in AST file");
3363      return QualType();
3364    }
3365
3366    QualType ElementType = readType(*Loc.F, Record, Idx);
3367    unsigned NumElements = Record[1];
3368    unsigned VecKind = Record[2];
3369    return Context->getVectorType(ElementType, NumElements,
3370                                  (VectorType::VectorKind)VecKind);
3371  }
3372
3373  case TYPE_EXT_VECTOR: {
3374    if (Record.size() != 3) {
3375      Error("incorrect encoding of extended vector type in AST file");
3376      return QualType();
3377    }
3378
3379    QualType ElementType = readType(*Loc.F, Record, Idx);
3380    unsigned NumElements = Record[1];
3381    return Context->getExtVectorType(ElementType, NumElements);
3382  }
3383
3384  case TYPE_FUNCTION_NO_PROTO: {
3385    if (Record.size() != 6) {
3386      Error("incorrect encoding of no-proto function type");
3387      return QualType();
3388    }
3389    QualType ResultType = readType(*Loc.F, Record, Idx);
3390    FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
3391                               (CallingConv)Record[4], Record[5]);
3392    return Context->getFunctionNoProtoType(ResultType, Info);
3393  }
3394
3395  case TYPE_FUNCTION_PROTO: {
3396    QualType ResultType = readType(*Loc.F, Record, Idx);
3397
3398    FunctionProtoType::ExtProtoInfo EPI;
3399    EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
3400                                        /*hasregparm*/ Record[2],
3401                                        /*regparm*/ Record[3],
3402                                        static_cast<CallingConv>(Record[4]),
3403                                        /*produces*/ Record[5]);
3404
3405    unsigned Idx = 6;
3406    unsigned NumParams = Record[Idx++];
3407    SmallVector<QualType, 16> ParamTypes;
3408    for (unsigned I = 0; I != NumParams; ++I)
3409      ParamTypes.push_back(readType(*Loc.F, Record, Idx));
3410
3411    EPI.Variadic = Record[Idx++];
3412    EPI.TypeQuals = Record[Idx++];
3413    EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
3414    ExceptionSpecificationType EST =
3415        static_cast<ExceptionSpecificationType>(Record[Idx++]);
3416    EPI.ExceptionSpecType = EST;
3417    if (EST == EST_Dynamic) {
3418      EPI.NumExceptions = Record[Idx++];
3419      SmallVector<QualType, 2> Exceptions;
3420      for (unsigned I = 0; I != EPI.NumExceptions; ++I)
3421        Exceptions.push_back(readType(*Loc.F, Record, Idx));
3422      EPI.Exceptions = Exceptions.data();
3423    } else if (EST == EST_ComputedNoexcept) {
3424      EPI.NoexceptExpr = ReadExpr(*Loc.F);
3425    }
3426    return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams,
3427                                    EPI);
3428  }
3429
3430  case TYPE_UNRESOLVED_USING: {
3431    unsigned Idx = 0;
3432    return Context->getTypeDeclType(
3433                  ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
3434  }
3435
3436  case TYPE_TYPEDEF: {
3437    if (Record.size() != 2) {
3438      Error("incorrect encoding of typedef type");
3439      return QualType();
3440    }
3441    unsigned Idx = 0;
3442    TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
3443    QualType Canonical = readType(*Loc.F, Record, Idx);
3444    if (!Canonical.isNull())
3445      Canonical = Context->getCanonicalType(Canonical);
3446    return Context->getTypedefType(Decl, Canonical);
3447  }
3448
3449  case TYPE_TYPEOF_EXPR:
3450    return Context->getTypeOfExprType(ReadExpr(*Loc.F));
3451
3452  case TYPE_TYPEOF: {
3453    if (Record.size() != 1) {
3454      Error("incorrect encoding of typeof(type) in AST file");
3455      return QualType();
3456    }
3457    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3458    return Context->getTypeOfType(UnderlyingType);
3459  }
3460
3461  case TYPE_DECLTYPE:
3462    return Context->getDecltypeType(ReadExpr(*Loc.F));
3463
3464  case TYPE_UNARY_TRANSFORM: {
3465    QualType BaseType = readType(*Loc.F, Record, Idx);
3466    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3467    UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
3468    return Context->getUnaryTransformType(BaseType, UnderlyingType, UKind);
3469  }
3470
3471  case TYPE_AUTO:
3472    return Context->getAutoType(readType(*Loc.F, Record, Idx));
3473
3474  case TYPE_RECORD: {
3475    if (Record.size() != 2) {
3476      Error("incorrect encoding of record type");
3477      return QualType();
3478    }
3479    unsigned Idx = 0;
3480    bool IsDependent = Record[Idx++];
3481    QualType T
3482      = Context->getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx));
3483    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3484    return T;
3485  }
3486
3487  case TYPE_ENUM: {
3488    if (Record.size() != 2) {
3489      Error("incorrect encoding of enum type");
3490      return QualType();
3491    }
3492    unsigned Idx = 0;
3493    bool IsDependent = Record[Idx++];
3494    QualType T
3495      = Context->getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
3496    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3497    return T;
3498  }
3499
3500  case TYPE_ATTRIBUTED: {
3501    if (Record.size() != 3) {
3502      Error("incorrect encoding of attributed type");
3503      return QualType();
3504    }
3505    QualType modifiedType = readType(*Loc.F, Record, Idx);
3506    QualType equivalentType = readType(*Loc.F, Record, Idx);
3507    AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
3508    return Context->getAttributedType(kind, modifiedType, equivalentType);
3509  }
3510
3511  case TYPE_PAREN: {
3512    if (Record.size() != 1) {
3513      Error("incorrect encoding of paren type");
3514      return QualType();
3515    }
3516    QualType InnerType = readType(*Loc.F, Record, Idx);
3517    return Context->getParenType(InnerType);
3518  }
3519
3520  case TYPE_PACK_EXPANSION: {
3521    if (Record.size() != 2) {
3522      Error("incorrect encoding of pack expansion type");
3523      return QualType();
3524    }
3525    QualType Pattern = readType(*Loc.F, Record, Idx);
3526    if (Pattern.isNull())
3527      return QualType();
3528    llvm::Optional<unsigned> NumExpansions;
3529    if (Record[1])
3530      NumExpansions = Record[1] - 1;
3531    return Context->getPackExpansionType(Pattern, NumExpansions);
3532  }
3533
3534  case TYPE_ELABORATED: {
3535    unsigned Idx = 0;
3536    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3537    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3538    QualType NamedType = readType(*Loc.F, Record, Idx);
3539    return Context->getElaboratedType(Keyword, NNS, NamedType);
3540  }
3541
3542  case TYPE_OBJC_INTERFACE: {
3543    unsigned Idx = 0;
3544    ObjCInterfaceDecl *ItfD
3545      = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
3546    return Context->getObjCInterfaceType(ItfD);
3547  }
3548
3549  case TYPE_OBJC_OBJECT: {
3550    unsigned Idx = 0;
3551    QualType Base = readType(*Loc.F, Record, Idx);
3552    unsigned NumProtos = Record[Idx++];
3553    SmallVector<ObjCProtocolDecl*, 4> Protos;
3554    for (unsigned I = 0; I != NumProtos; ++I)
3555      Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
3556    return Context->getObjCObjectType(Base, Protos.data(), NumProtos);
3557  }
3558
3559  case TYPE_OBJC_OBJECT_POINTER: {
3560    unsigned Idx = 0;
3561    QualType Pointee = readType(*Loc.F, Record, Idx);
3562    return Context->getObjCObjectPointerType(Pointee);
3563  }
3564
3565  case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
3566    unsigned Idx = 0;
3567    QualType Parm = readType(*Loc.F, Record, Idx);
3568    QualType Replacement = readType(*Loc.F, Record, Idx);
3569    return
3570      Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm),
3571                                            Replacement);
3572  }
3573
3574  case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
3575    unsigned Idx = 0;
3576    QualType Parm = readType(*Loc.F, Record, Idx);
3577    TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
3578    return Context->getSubstTemplateTypeParmPackType(
3579                                               cast<TemplateTypeParmType>(Parm),
3580                                                     ArgPack);
3581  }
3582
3583  case TYPE_INJECTED_CLASS_NAME: {
3584    CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
3585    QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
3586    // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
3587    // for AST reading, too much interdependencies.
3588    return
3589      QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0);
3590  }
3591
3592  case TYPE_TEMPLATE_TYPE_PARM: {
3593    unsigned Idx = 0;
3594    unsigned Depth = Record[Idx++];
3595    unsigned Index = Record[Idx++];
3596    bool Pack = Record[Idx++];
3597    TemplateTypeParmDecl *D
3598      = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
3599    return Context->getTemplateTypeParmType(Depth, Index, Pack, D);
3600  }
3601
3602  case TYPE_DEPENDENT_NAME: {
3603    unsigned Idx = 0;
3604    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3605    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3606    const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
3607    QualType Canon = readType(*Loc.F, Record, Idx);
3608    if (!Canon.isNull())
3609      Canon = Context->getCanonicalType(Canon);
3610    return Context->getDependentNameType(Keyword, NNS, Name, Canon);
3611  }
3612
3613  case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
3614    unsigned Idx = 0;
3615    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3616    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3617    const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
3618    unsigned NumArgs = Record[Idx++];
3619    SmallVector<TemplateArgument, 8> Args;
3620    Args.reserve(NumArgs);
3621    while (NumArgs--)
3622      Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
3623    return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name,
3624                                                      Args.size(), Args.data());
3625  }
3626
3627  case TYPE_DEPENDENT_SIZED_ARRAY: {
3628    unsigned Idx = 0;
3629
3630    // ArrayType
3631    QualType ElementType = readType(*Loc.F, Record, Idx);
3632    ArrayType::ArraySizeModifier ASM
3633      = (ArrayType::ArraySizeModifier)Record[Idx++];
3634    unsigned IndexTypeQuals = Record[Idx++];
3635
3636    // DependentSizedArrayType
3637    Expr *NumElts = ReadExpr(*Loc.F);
3638    SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
3639
3640    return Context->getDependentSizedArrayType(ElementType, NumElts, ASM,
3641                                               IndexTypeQuals, Brackets);
3642  }
3643
3644  case TYPE_TEMPLATE_SPECIALIZATION: {
3645    unsigned Idx = 0;
3646    bool IsDependent = Record[Idx++];
3647    TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
3648    SmallVector<TemplateArgument, 8> Args;
3649    ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
3650    QualType Underlying = readType(*Loc.F, Record, Idx);
3651    QualType T;
3652    if (Underlying.isNull())
3653      T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(),
3654                                                          Args.size());
3655    else
3656      T = Context->getTemplateSpecializationType(Name, Args.data(),
3657                                                 Args.size(), Underlying);
3658    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3659    return T;
3660  }
3661  }
3662  // Suppress a GCC warning
3663  return QualType();
3664}
3665
3666class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
3667  ASTReader &Reader;
3668  Module &F;
3669  llvm::BitstreamCursor &DeclsCursor;
3670  const ASTReader::RecordData &Record;
3671  unsigned &Idx;
3672
3673  SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
3674                                    unsigned &I) {
3675    return Reader.ReadSourceLocation(F, R, I);
3676  }
3677
3678  template<typename T>
3679  T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
3680    return Reader.ReadDeclAs<T>(F, Record, Idx);
3681  }
3682
3683public:
3684  TypeLocReader(ASTReader &Reader, Module &F,
3685                const ASTReader::RecordData &Record, unsigned &Idx)
3686    : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx)
3687  { }
3688
3689  // We want compile-time assurance that we've enumerated all of
3690  // these, so unfortunately we have to declare them first, then
3691  // define them out-of-line.
3692#define ABSTRACT_TYPELOC(CLASS, PARENT)
3693#define TYPELOC(CLASS, PARENT) \
3694  void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
3695#include "clang/AST/TypeLocNodes.def"
3696
3697  void VisitFunctionTypeLoc(FunctionTypeLoc);
3698  void VisitArrayTypeLoc(ArrayTypeLoc);
3699};
3700
3701void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
3702  // nothing to do
3703}
3704void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
3705  TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
3706  if (TL.needsExtraLocalData()) {
3707    TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
3708    TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
3709    TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
3710    TL.setModeAttr(Record[Idx++]);
3711  }
3712}
3713void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
3714  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3715}
3716void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
3717  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3718}
3719void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
3720  TL.setCaretLoc(ReadSourceLocation(Record, Idx));
3721}
3722void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
3723  TL.setAmpLoc(ReadSourceLocation(Record, Idx));
3724}
3725void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
3726  TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
3727}
3728void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
3729  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3730  TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3731}
3732void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
3733  TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
3734  TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
3735  if (Record[Idx++])
3736    TL.setSizeExpr(Reader.ReadExpr(F));
3737  else
3738    TL.setSizeExpr(0);
3739}
3740void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
3741  VisitArrayTypeLoc(TL);
3742}
3743void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
3744  VisitArrayTypeLoc(TL);
3745}
3746void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
3747  VisitArrayTypeLoc(TL);
3748}
3749void TypeLocReader::VisitDependentSizedArrayTypeLoc(
3750                                            DependentSizedArrayTypeLoc TL) {
3751  VisitArrayTypeLoc(TL);
3752}
3753void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
3754                                        DependentSizedExtVectorTypeLoc TL) {
3755  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3756}
3757void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
3758  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3759}
3760void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
3761  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3762}
3763void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
3764  TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
3765  TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
3766  TL.setTrailingReturn(Record[Idx++]);
3767  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
3768    TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
3769  }
3770}
3771void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
3772  VisitFunctionTypeLoc(TL);
3773}
3774void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
3775  VisitFunctionTypeLoc(TL);
3776}
3777void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
3778  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3779}
3780void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
3781  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3782}
3783void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
3784  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3785  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3786  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3787}
3788void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
3789  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3790  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3791  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3792  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3793}
3794void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
3795  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3796}
3797void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
3798  TL.setKWLoc(ReadSourceLocation(Record, Idx));
3799  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3800  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3801  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3802}
3803void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
3804  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3805}
3806void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
3807  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3808}
3809void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
3810  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3811}
3812void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
3813  TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
3814  if (TL.hasAttrOperand()) {
3815    SourceRange range;
3816    range.setBegin(ReadSourceLocation(Record, Idx));
3817    range.setEnd(ReadSourceLocation(Record, Idx));
3818    TL.setAttrOperandParensRange(range);
3819  }
3820  if (TL.hasAttrExprOperand()) {
3821    if (Record[Idx++])
3822      TL.setAttrExprOperand(Reader.ReadExpr(F));
3823    else
3824      TL.setAttrExprOperand(0);
3825  } else if (TL.hasAttrEnumOperand())
3826    TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
3827}
3828void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
3829  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3830}
3831void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
3832                                            SubstTemplateTypeParmTypeLoc TL) {
3833  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3834}
3835void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
3836                                          SubstTemplateTypeParmPackTypeLoc TL) {
3837  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3838}
3839void TypeLocReader::VisitTemplateSpecializationTypeLoc(
3840                                           TemplateSpecializationTypeLoc TL) {
3841  TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
3842  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3843  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3844  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3845    TL.setArgLocInfo(i,
3846        Reader.GetTemplateArgumentLocInfo(F,
3847                                          TL.getTypePtr()->getArg(i).getKind(),
3848                                          Record, Idx));
3849}
3850void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
3851  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3852  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3853}
3854void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
3855  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3856  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3857}
3858void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
3859  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3860}
3861void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
3862  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3863  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3864  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3865}
3866void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
3867       DependentTemplateSpecializationTypeLoc TL) {
3868  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3869  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3870  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3871  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3872  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3873  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
3874    TL.setArgLocInfo(I,
3875        Reader.GetTemplateArgumentLocInfo(F,
3876                                          TL.getTypePtr()->getArg(I).getKind(),
3877                                          Record, Idx));
3878}
3879void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
3880  TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
3881}
3882void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
3883  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3884}
3885void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
3886  TL.setHasBaseTypeAsWritten(Record[Idx++]);
3887  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3888  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3889  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
3890    TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
3891}
3892void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
3893  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3894}
3895
3896TypeSourceInfo *ASTReader::GetTypeSourceInfo(Module &F,
3897                                             const RecordData &Record,
3898                                             unsigned &Idx) {
3899  QualType InfoTy = readType(F, Record, Idx);
3900  if (InfoTy.isNull())
3901    return 0;
3902
3903  TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy);
3904  TypeLocReader TLR(*this, F, Record, Idx);
3905  for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
3906    TLR.Visit(TL);
3907  return TInfo;
3908}
3909
3910QualType ASTReader::GetType(TypeID ID) {
3911  unsigned FastQuals = ID & Qualifiers::FastMask;
3912  unsigned Index = ID >> Qualifiers::FastWidth;
3913
3914  if (Index < NUM_PREDEF_TYPE_IDS) {
3915    QualType T;
3916    switch ((PredefinedTypeIDs)Index) {
3917    case PREDEF_TYPE_NULL_ID: return QualType();
3918    case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break;
3919    case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break;
3920
3921    case PREDEF_TYPE_CHAR_U_ID:
3922    case PREDEF_TYPE_CHAR_S_ID:
3923      // FIXME: Check that the signedness of CharTy is correct!
3924      T = Context->CharTy;
3925      break;
3926
3927    case PREDEF_TYPE_UCHAR_ID:      T = Context->UnsignedCharTy;     break;
3928    case PREDEF_TYPE_USHORT_ID:     T = Context->UnsignedShortTy;    break;
3929    case PREDEF_TYPE_UINT_ID:       T = Context->UnsignedIntTy;      break;
3930    case PREDEF_TYPE_ULONG_ID:      T = Context->UnsignedLongTy;     break;
3931    case PREDEF_TYPE_ULONGLONG_ID:  T = Context->UnsignedLongLongTy; break;
3932    case PREDEF_TYPE_UINT128_ID:    T = Context->UnsignedInt128Ty;   break;
3933    case PREDEF_TYPE_SCHAR_ID:      T = Context->SignedCharTy;       break;
3934    case PREDEF_TYPE_WCHAR_ID:      T = Context->WCharTy;            break;
3935    case PREDEF_TYPE_SHORT_ID:      T = Context->ShortTy;            break;
3936    case PREDEF_TYPE_INT_ID:        T = Context->IntTy;              break;
3937    case PREDEF_TYPE_LONG_ID:       T = Context->LongTy;             break;
3938    case PREDEF_TYPE_LONGLONG_ID:   T = Context->LongLongTy;         break;
3939    case PREDEF_TYPE_INT128_ID:     T = Context->Int128Ty;           break;
3940    case PREDEF_TYPE_FLOAT_ID:      T = Context->FloatTy;            break;
3941    case PREDEF_TYPE_DOUBLE_ID:     T = Context->DoubleTy;           break;
3942    case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy;       break;
3943    case PREDEF_TYPE_OVERLOAD_ID:   T = Context->OverloadTy;         break;
3944    case PREDEF_TYPE_BOUND_MEMBER:  T = Context->BoundMemberTy;      break;
3945    case PREDEF_TYPE_DEPENDENT_ID:  T = Context->DependentTy;        break;
3946    case PREDEF_TYPE_UNKNOWN_ANY:   T = Context->UnknownAnyTy;       break;
3947    case PREDEF_TYPE_NULLPTR_ID:    T = Context->NullPtrTy;          break;
3948    case PREDEF_TYPE_CHAR16_ID:     T = Context->Char16Ty;           break;
3949    case PREDEF_TYPE_CHAR32_ID:     T = Context->Char32Ty;           break;
3950    case PREDEF_TYPE_OBJC_ID:       T = Context->ObjCBuiltinIdTy;    break;
3951    case PREDEF_TYPE_OBJC_CLASS:    T = Context->ObjCBuiltinClassTy; break;
3952    case PREDEF_TYPE_OBJC_SEL:      T = Context->ObjCBuiltinSelTy;   break;
3953    }
3954
3955    assert(!T.isNull() && "Unknown predefined type");
3956    return T.withFastQualifiers(FastQuals);
3957  }
3958
3959  Index -= NUM_PREDEF_TYPE_IDS;
3960  assert(Index < TypesLoaded.size() && "Type index out-of-range");
3961  if (TypesLoaded[Index].isNull()) {
3962    TypesLoaded[Index] = readTypeRecord(Index);
3963    if (TypesLoaded[Index].isNull())
3964      return QualType();
3965
3966    TypesLoaded[Index]->setFromAST();
3967    TypeIdxs[TypesLoaded[Index]] = TypeIdx::fromTypeID(ID);
3968    if (DeserializationListener)
3969      DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
3970                                        TypesLoaded[Index]);
3971  }
3972
3973  return TypesLoaded[Index].withFastQualifiers(FastQuals);
3974}
3975
3976QualType ASTReader::getLocalType(Module &F, unsigned LocalID) {
3977  return GetType(getGlobalTypeID(F, LocalID));
3978}
3979
3980serialization::TypeID
3981ASTReader::getGlobalTypeID(Module &F, unsigned LocalID) const {
3982  // FIXME: Map from local type ID to global type ID.
3983  return LocalID;
3984}
3985
3986TypeID ASTReader::GetTypeID(QualType T) const {
3987  return MakeTypeID(T,
3988              std::bind1st(std::mem_fun(&ASTReader::GetTypeIdx), this));
3989}
3990
3991TypeIdx ASTReader::GetTypeIdx(QualType T) const {
3992  if (T.isNull())
3993    return TypeIdx();
3994  assert(!T.getLocalFastQualifiers());
3995
3996  TypeIdxMap::const_iterator I = TypeIdxs.find(T);
3997  // GetTypeIdx is mostly used for computing the hash of DeclarationNames and
3998  // comparing keys of ASTDeclContextNameLookupTable.
3999  // If the type didn't come from the AST file use a specially marked index
4000  // so that any hash/key comparison fail since no such index is stored
4001  // in a AST file.
4002  if (I == TypeIdxs.end())
4003    return TypeIdx(-1);
4004  return I->second;
4005}
4006
4007TemplateArgumentLocInfo
4008ASTReader::GetTemplateArgumentLocInfo(Module &F,
4009                                      TemplateArgument::ArgKind Kind,
4010                                      const RecordData &Record,
4011                                      unsigned &Index) {
4012  switch (Kind) {
4013  case TemplateArgument::Expression:
4014    return ReadExpr(F);
4015  case TemplateArgument::Type:
4016    return GetTypeSourceInfo(F, Record, Index);
4017  case TemplateArgument::Template: {
4018    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
4019                                                                     Index);
4020    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
4021    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
4022                                   SourceLocation());
4023  }
4024  case TemplateArgument::TemplateExpansion: {
4025    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
4026                                                                     Index);
4027    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
4028    SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
4029    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
4030                                   EllipsisLoc);
4031  }
4032  case TemplateArgument::Null:
4033  case TemplateArgument::Integral:
4034  case TemplateArgument::Declaration:
4035  case TemplateArgument::Pack:
4036    return TemplateArgumentLocInfo();
4037  }
4038  llvm_unreachable("unexpected template argument loc");
4039  return TemplateArgumentLocInfo();
4040}
4041
4042TemplateArgumentLoc
4043ASTReader::ReadTemplateArgumentLoc(Module &F,
4044                                   const RecordData &Record, unsigned &Index) {
4045  TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
4046
4047  if (Arg.getKind() == TemplateArgument::Expression) {
4048    if (Record[Index++]) // bool InfoHasSameExpr.
4049      return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
4050  }
4051  return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
4052                                                             Record, Index));
4053}
4054
4055Decl *ASTReader::GetExternalDecl(uint32_t ID) {
4056  return GetDecl(ID);
4057}
4058
4059uint64_t
4060ASTReader::GetCXXBaseSpecifiersOffset(serialization::CXXBaseSpecifiersID ID) {
4061  if (ID == 0)
4062    return 0;
4063
4064  GlobalCXXBaseSpecifiersMapType::iterator I =
4065      GlobalCXXBaseSpecifiersMap.find(ID);
4066
4067  assert (I != GlobalCXXBaseSpecifiersMap.end() &&
4068                                    "Corrupted global CXX base specifiers map");
4069
4070  Module *M = I->second;
4071  return M->CXXBaseSpecifiersOffsets[ID - 1 - M->BaseCXXBaseSpecifiersID] +
4072    M->GlobalBitOffset;
4073}
4074
4075CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
4076  RecordLocation Loc = getLocalBitOffset(Offset);
4077  llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor;
4078  SavedStreamPosition SavedPosition(Cursor);
4079  Cursor.JumpToBit(Loc.Offset);
4080  ReadingKindTracker ReadingKind(Read_Decl, *this);
4081  RecordData Record;
4082  unsigned Code = Cursor.ReadCode();
4083  unsigned RecCode = Cursor.ReadRecord(Code, Record);
4084  if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
4085    Error("Malformed AST file: missing C++ base specifiers");
4086    return 0;
4087  }
4088
4089  unsigned Idx = 0;
4090  unsigned NumBases = Record[Idx++];
4091  void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases);
4092  CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
4093  for (unsigned I = 0; I != NumBases; ++I)
4094    Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
4095  return Bases;
4096}
4097
4098TranslationUnitDecl *ASTReader::GetTranslationUnitDecl() {
4099  if (!DeclsLoaded[0]) {
4100    ReadDeclRecord(0, 1);
4101    if (DeserializationListener)
4102      DeserializationListener->DeclRead(1, DeclsLoaded[0]);
4103  }
4104
4105  return cast<TranslationUnitDecl>(DeclsLoaded[0]);
4106}
4107
4108serialization::DeclID
4109ASTReader::getGlobalDeclID(Module &F, unsigned LocalID) const {
4110  // FIXME: Perform local -> global remapping for declarations.
4111  return LocalID;
4112}
4113
4114Decl *ASTReader::GetDecl(DeclID ID) {
4115  if (ID == 0)
4116    return 0;
4117
4118  if (ID > DeclsLoaded.size()) {
4119    Error("declaration ID out-of-range for AST file");
4120    return 0;
4121  }
4122
4123  unsigned Index = ID - 1;
4124  if (!DeclsLoaded[Index]) {
4125    ReadDeclRecord(Index, ID);
4126    if (DeserializationListener)
4127      DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
4128  }
4129
4130  return DeclsLoaded[Index];
4131}
4132
4133serialization::DeclID ASTReader::ReadDeclID(Module &F,
4134                                            const RecordData &Record,
4135                                            unsigned &Idx) {
4136  if (Idx >= Record.size()) {
4137    Error("Corrupted AST file");
4138    return 0;
4139  }
4140
4141  return getGlobalDeclID(F, Record[Idx++]);
4142}
4143
4144/// \brief Resolve the offset of a statement into a statement.
4145///
4146/// This operation will read a new statement from the external
4147/// source each time it is called, and is meant to be used via a
4148/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
4149Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
4150  // Switch case IDs are per Decl.
4151  ClearSwitchCaseIDs();
4152
4153  // Offset here is a global offset across the entire chain.
4154  RecordLocation Loc = getLocalBitOffset(Offset);
4155  Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
4156  return ReadStmtFromStream(*Loc.F);
4157}
4158
4159ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
4160                                         bool (*isKindWeWant)(Decl::Kind),
4161                                         SmallVectorImpl<Decl*> &Decls) {
4162  // There might be lexical decls in multiple parts of the chain, for the TU
4163  // at least.
4164  // DeclContextOffsets might reallocate as we load additional decls below,
4165  // so make a copy of the vector.
4166  DeclContextInfos Infos = DeclContextOffsets[DC];
4167  for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
4168       I != E; ++I) {
4169    // IDs can be 0 if this context doesn't contain declarations.
4170    if (!I->LexicalDecls)
4171      continue;
4172
4173    // Load all of the declaration IDs
4174    for (const KindDeclIDPair *ID = I->LexicalDecls,
4175                              *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) {
4176      if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first))
4177        continue;
4178
4179      Decl *D = GetLocalDecl(*I->F, ID->second);
4180      assert(D && "Null decl in lexical decls");
4181      Decls.push_back(D);
4182    }
4183  }
4184
4185  ++NumLexicalDeclContextsRead;
4186  return ELR_Success;
4187}
4188
4189DeclContext::lookup_result
4190ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
4191                                          DeclarationName Name) {
4192  assert(DC->hasExternalVisibleStorage() &&
4193         "DeclContext has no visible decls in storage");
4194  if (!Name)
4195    return DeclContext::lookup_result(DeclContext::lookup_iterator(0),
4196                                      DeclContext::lookup_iterator(0));
4197
4198  SmallVector<NamedDecl *, 64> Decls;
4199  // There might be visible decls in multiple parts of the chain, for the TU
4200  // and namespaces. For any given name, the last available results replace
4201  // all earlier ones. For this reason, we walk in reverse.
4202  DeclContextInfos &Infos = DeclContextOffsets[DC];
4203  for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend();
4204       I != E; ++I) {
4205    if (!I->NameLookupTableData)
4206      continue;
4207
4208    ASTDeclContextNameLookupTable *LookupTable =
4209        (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
4210    ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name);
4211    if (Pos == LookupTable->end())
4212      continue;
4213
4214    ASTDeclContextNameLookupTrait::data_type Data = *Pos;
4215    for (; Data.first != Data.second; ++Data.first)
4216      Decls.push_back(GetLocalDeclAs<NamedDecl>(*I->F, *Data.first));
4217    break;
4218  }
4219
4220  ++NumVisibleDeclContextsRead;
4221
4222  SetExternalVisibleDeclsForName(DC, Name, Decls);
4223  return const_cast<DeclContext*>(DC)->lookup(Name);
4224}
4225
4226void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) {
4227  assert(DC->hasExternalVisibleStorage() &&
4228         "DeclContext has no visible decls in storage");
4229
4230  SmallVector<NamedDecl *, 64> Decls;
4231  // There might be visible decls in multiple parts of the chain, for the TU
4232  // and namespaces.
4233  DeclContextInfos &Infos = DeclContextOffsets[DC];
4234  for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
4235       I != E; ++I) {
4236    if (!I->NameLookupTableData)
4237      continue;
4238
4239    ASTDeclContextNameLookupTable *LookupTable =
4240        (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
4241    for (ASTDeclContextNameLookupTable::item_iterator
4242           ItemI = LookupTable->item_begin(),
4243           ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) {
4244      ASTDeclContextNameLookupTable::item_iterator::value_type Val
4245          = *ItemI;
4246      ASTDeclContextNameLookupTrait::data_type Data = Val.second;
4247      Decls.clear();
4248      for (; Data.first != Data.second; ++Data.first)
4249        Decls.push_back(GetLocalDeclAs<NamedDecl>(*I->F, *Data.first));
4250      MaterializeVisibleDeclsForName(DC, Val.first, Decls);
4251    }
4252  }
4253}
4254
4255void ASTReader::PassInterestingDeclsToConsumer() {
4256  assert(Consumer);
4257  while (!InterestingDecls.empty()) {
4258    DeclGroupRef DG(InterestingDecls.front());
4259    InterestingDecls.pop_front();
4260    Consumer->HandleInterestingDecl(DG);
4261  }
4262}
4263
4264void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
4265  this->Consumer = Consumer;
4266
4267  if (!Consumer)
4268    return;
4269
4270  for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
4271    // Force deserialization of this decl, which will cause it to be queued for
4272    // passing to the consumer.
4273    GetDecl(ExternalDefinitions[I]);
4274  }
4275
4276  PassInterestingDeclsToConsumer();
4277}
4278
4279void ASTReader::PrintStats() {
4280  std::fprintf(stderr, "*** AST File Statistics:\n");
4281
4282  unsigned NumTypesLoaded
4283    = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
4284                                      QualType());
4285  unsigned NumDeclsLoaded
4286    = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
4287                                      (Decl *)0);
4288  unsigned NumIdentifiersLoaded
4289    = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
4290                                            IdentifiersLoaded.end(),
4291                                            (IdentifierInfo *)0);
4292  unsigned NumSelectorsLoaded
4293    = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
4294                                          SelectorsLoaded.end(),
4295                                          Selector());
4296
4297  std::fprintf(stderr, "  %u stat cache hits\n", NumStatHits);
4298  std::fprintf(stderr, "  %u stat cache misses\n", NumStatMisses);
4299  if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
4300    std::fprintf(stderr, "  %u/%u source location entries read (%f%%)\n",
4301                 NumSLocEntriesRead, TotalNumSLocEntries,
4302                 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
4303  if (!TypesLoaded.empty())
4304    std::fprintf(stderr, "  %u/%u types read (%f%%)\n",
4305                 NumTypesLoaded, (unsigned)TypesLoaded.size(),
4306                 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
4307  if (!DeclsLoaded.empty())
4308    std::fprintf(stderr, "  %u/%u declarations read (%f%%)\n",
4309                 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
4310                 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
4311  if (!IdentifiersLoaded.empty())
4312    std::fprintf(stderr, "  %u/%u identifiers read (%f%%)\n",
4313                 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
4314                 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
4315  if (!SelectorsLoaded.empty())
4316    std::fprintf(stderr, "  %u/%u selectors read (%f%%)\n",
4317                 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
4318                 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
4319  if (TotalNumStatements)
4320    std::fprintf(stderr, "  %u/%u statements read (%f%%)\n",
4321                 NumStatementsRead, TotalNumStatements,
4322                 ((float)NumStatementsRead/TotalNumStatements * 100));
4323  if (TotalNumMacros)
4324    std::fprintf(stderr, "  %u/%u macros read (%f%%)\n",
4325                 NumMacrosRead, TotalNumMacros,
4326                 ((float)NumMacrosRead/TotalNumMacros * 100));
4327  if (TotalLexicalDeclContexts)
4328    std::fprintf(stderr, "  %u/%u lexical declcontexts read (%f%%)\n",
4329                 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
4330                 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
4331                  * 100));
4332  if (TotalVisibleDeclContexts)
4333    std::fprintf(stderr, "  %u/%u visible declcontexts read (%f%%)\n",
4334                 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
4335                 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
4336                  * 100));
4337  if (TotalNumMethodPoolEntries) {
4338    std::fprintf(stderr, "  %u/%u method pool entries read (%f%%)\n",
4339                 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
4340                 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
4341                  * 100));
4342    std::fprintf(stderr, "  %u method pool misses\n", NumMethodPoolMisses);
4343  }
4344  std::fprintf(stderr, "\n");
4345  dump();
4346  std::fprintf(stderr, "\n");
4347}
4348
4349template<typename Key, typename Module, unsigned InitialCapacity>
4350static void
4351dumpModuleIDMap(StringRef Name,
4352                const ContinuousRangeMap<Key, Module *,
4353                                         InitialCapacity> &Map) {
4354  if (Map.begin() == Map.end())
4355    return;
4356
4357  typedef ContinuousRangeMap<Key, Module *, InitialCapacity> MapType;
4358  llvm::errs() << Name << ":\n";
4359  for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
4360       I != IEnd; ++I) {
4361    llvm::errs() << "  " << I->first << " -> " << I->second->FileName
4362      << "\n";
4363  }
4364}
4365
4366void ASTReader::dump() {
4367  llvm::errs() << "*** PCH/Module Remappings:\n";
4368  dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
4369  dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
4370  dumpModuleIDMap("Global type map", GlobalTypeMap);
4371  dumpModuleIDMap("Global declaration map", GlobalDeclMap);
4372  dumpModuleIDMap("Global C++ base specifiers map", GlobalCXXBaseSpecifiersMap);
4373  dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
4374  dumpModuleIDMap("Global selector map", GlobalSelectorMap);
4375  dumpModuleIDMap("Global macro definition map", GlobalMacroDefinitionMap);
4376  dumpModuleIDMap("Global preprocessed entity map",
4377                  GlobalPreprocessedEntityMap);
4378
4379  llvm::errs() << "\n*** PCH/Modules Loaded:";
4380  for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(),
4381                                       MEnd = ModuleMgr.end();
4382       M != MEnd; ++M)
4383    (*M)->dump();
4384}
4385
4386/// Return the amount of memory used by memory buffers, breaking down
4387/// by heap-backed versus mmap'ed memory.
4388void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
4389  for (ModuleConstIterator I = ModuleMgr.begin(),
4390      E = ModuleMgr.end(); I != E; ++I) {
4391    if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
4392      size_t bytes = buf->getBufferSize();
4393      switch (buf->getBufferKind()) {
4394        case llvm::MemoryBuffer::MemoryBuffer_Malloc:
4395          sizes.malloc_bytes += bytes;
4396          break;
4397        case llvm::MemoryBuffer::MemoryBuffer_MMap:
4398          sizes.mmap_bytes += bytes;
4399          break;
4400      }
4401    }
4402  }
4403}
4404
4405void ASTReader::InitializeSema(Sema &S) {
4406  SemaObj = &S;
4407  S.ExternalSource = this;
4408
4409  // Makes sure any declarations that were deserialized "too early"
4410  // still get added to the identifier's declaration chains.
4411  for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
4412    if (SemaObj->TUScope)
4413      SemaObj->TUScope->AddDecl(PreloadedDecls[I]);
4414
4415    SemaObj->IdResolver.AddDecl(PreloadedDecls[I]);
4416  }
4417  PreloadedDecls.clear();
4418
4419  // Load the offsets of the declarations that Sema references.
4420  // They will be lazily deserialized when needed.
4421  if (!SemaDeclRefs.empty()) {
4422    assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
4423    if (!SemaObj->StdNamespace)
4424      SemaObj->StdNamespace = SemaDeclRefs[0];
4425    if (!SemaObj->StdBadAlloc)
4426      SemaObj->StdBadAlloc = SemaDeclRefs[1];
4427  }
4428
4429  if (!FPPragmaOptions.empty()) {
4430    assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
4431    SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
4432  }
4433
4434  if (!OpenCLExtensions.empty()) {
4435    unsigned I = 0;
4436#define OPENCLEXT(nm)  SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
4437#include "clang/Basic/OpenCLExtensions.def"
4438
4439    assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
4440  }
4441}
4442
4443IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
4444  // Try to find this name within our on-disk hash tables. We start with the
4445  // most recent one, since that one contains the most up-to-date info.
4446  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
4447    ASTIdentifierLookupTable *IdTable
4448        = (ASTIdentifierLookupTable *)(*I)->IdentifierLookupTable;
4449    if (!IdTable)
4450      continue;
4451    std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart);
4452    ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key);
4453    if (Pos == IdTable->end())
4454      continue;
4455
4456    // Dereferencing the iterator has the effect of building the
4457    // IdentifierInfo node and populating it with the various
4458    // declarations it needs.
4459    return *Pos;
4460  }
4461  return 0;
4462}
4463
4464namespace clang {
4465  /// \brief An identifier-lookup iterator that enumerates all of the
4466  /// identifiers stored within a set of AST files.
4467  class ASTIdentifierIterator : public IdentifierIterator {
4468    /// \brief The AST reader whose identifiers are being enumerated.
4469    const ASTReader &Reader;
4470
4471    /// \brief The current index into the chain of AST files stored in
4472    /// the AST reader.
4473    unsigned Index;
4474
4475    /// \brief The current position within the identifier lookup table
4476    /// of the current AST file.
4477    ASTIdentifierLookupTable::key_iterator Current;
4478
4479    /// \brief The end position within the identifier lookup table of
4480    /// the current AST file.
4481    ASTIdentifierLookupTable::key_iterator End;
4482
4483  public:
4484    explicit ASTIdentifierIterator(const ASTReader &Reader);
4485
4486    virtual StringRef Next();
4487  };
4488}
4489
4490ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
4491  : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
4492  ASTIdentifierLookupTable *IdTable
4493    = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
4494  Current = IdTable->key_begin();
4495  End = IdTable->key_end();
4496}
4497
4498StringRef ASTIdentifierIterator::Next() {
4499  while (Current == End) {
4500    // If we have exhausted all of our AST files, we're done.
4501    if (Index == 0)
4502      return StringRef();
4503
4504    --Index;
4505    ASTIdentifierLookupTable *IdTable
4506      = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
4507        IdentifierLookupTable;
4508    Current = IdTable->key_begin();
4509    End = IdTable->key_end();
4510  }
4511
4512  // We have any identifiers remaining in the current AST file; return
4513  // the next one.
4514  std::pair<const char*, unsigned> Key = *Current;
4515  ++Current;
4516  return StringRef(Key.first, Key.second);
4517}
4518
4519IdentifierIterator *ASTReader::getIdentifiers() const {
4520  return new ASTIdentifierIterator(*this);
4521}
4522
4523std::pair<ObjCMethodList, ObjCMethodList>
4524ASTReader::ReadMethodPool(Selector Sel) {
4525  // Find this selector in a hash table. We want to find the most recent entry.
4526  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
4527    Module &F = *(*I);
4528    if (!F.SelectorLookupTable)
4529      continue;
4530
4531    ASTSelectorLookupTable *PoolTable
4532      = (ASTSelectorLookupTable*)F.SelectorLookupTable;
4533    ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
4534    if (Pos != PoolTable->end()) {
4535      ++NumSelectorsRead;
4536      // FIXME: Not quite happy with the statistics here. We probably should
4537      // disable this tracking when called via LoadSelector.
4538      // Also, should entries without methods count as misses?
4539      ++NumMethodPoolEntriesRead;
4540      ASTSelectorLookupTrait::data_type Data = *Pos;
4541      if (DeserializationListener)
4542        DeserializationListener->SelectorRead(Data.ID, Sel);
4543      return std::make_pair(Data.Instance, Data.Factory);
4544    }
4545  }
4546
4547  ++NumMethodPoolMisses;
4548  return std::pair<ObjCMethodList, ObjCMethodList>();
4549}
4550
4551void ASTReader::ReadKnownNamespaces(
4552                          SmallVectorImpl<NamespaceDecl *> &Namespaces) {
4553  Namespaces.clear();
4554
4555  for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
4556    if (NamespaceDecl *Namespace
4557                = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
4558      Namespaces.push_back(Namespace);
4559  }
4560}
4561
4562void ASTReader::ReadTentativeDefinitions(
4563                  SmallVectorImpl<VarDecl *> &TentativeDefs) {
4564  for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
4565    VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
4566    if (Var)
4567      TentativeDefs.push_back(Var);
4568  }
4569  TentativeDefinitions.clear();
4570}
4571
4572void ASTReader::ReadUnusedFileScopedDecls(
4573                               SmallVectorImpl<const DeclaratorDecl *> &Decls) {
4574  for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
4575    DeclaratorDecl *D
4576      = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
4577    if (D)
4578      Decls.push_back(D);
4579  }
4580  UnusedFileScopedDecls.clear();
4581}
4582
4583void ASTReader::ReadDelegatingConstructors(
4584                                 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
4585  for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
4586    CXXConstructorDecl *D
4587      = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
4588    if (D)
4589      Decls.push_back(D);
4590  }
4591  DelegatingCtorDecls.clear();
4592}
4593
4594void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
4595  for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
4596    TypedefNameDecl *D
4597      = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
4598    if (D)
4599      Decls.push_back(D);
4600  }
4601  ExtVectorDecls.clear();
4602}
4603
4604void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) {
4605  for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) {
4606    CXXRecordDecl *D
4607      = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I]));
4608    if (D)
4609      Decls.push_back(D);
4610  }
4611  DynamicClasses.clear();
4612}
4613
4614void
4615ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) {
4616  for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
4617    NamedDecl *D
4618      = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
4619    if (D)
4620      Decls.push_back(D);
4621  }
4622  LocallyScopedExternalDecls.clear();
4623}
4624
4625void ASTReader::ReadReferencedSelectors(
4626       SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
4627  if (ReferencedSelectorsData.empty())
4628    return;
4629
4630  // If there are @selector references added them to its pool. This is for
4631  // implementation of -Wselector.
4632  unsigned int DataSize = ReferencedSelectorsData.size()-1;
4633  unsigned I = 0;
4634  while (I < DataSize) {
4635    Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
4636    SourceLocation SelLoc
4637      = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
4638    Sels.push_back(std::make_pair(Sel, SelLoc));
4639  }
4640  ReferencedSelectorsData.clear();
4641}
4642
4643void ASTReader::ReadWeakUndeclaredIdentifiers(
4644       SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
4645  if (WeakUndeclaredIdentifiers.empty())
4646    return;
4647
4648  for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
4649    IdentifierInfo *WeakId
4650      = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
4651    IdentifierInfo *AliasId
4652      = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
4653    SourceLocation Loc
4654      = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
4655    bool Used = WeakUndeclaredIdentifiers[I++];
4656    WeakInfo WI(AliasId, Loc);
4657    WI.setUsed(Used);
4658    WeakIDs.push_back(std::make_pair(WeakId, WI));
4659  }
4660  WeakUndeclaredIdentifiers.clear();
4661}
4662
4663void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
4664  for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
4665    ExternalVTableUse VT;
4666    VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
4667    VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
4668    VT.DefinitionRequired = VTableUses[Idx++];
4669    VTables.push_back(VT);
4670  }
4671
4672  VTableUses.clear();
4673}
4674
4675void ASTReader::ReadPendingInstantiations(
4676       SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
4677  for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
4678    ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
4679    SourceLocation Loc
4680      = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
4681    Pending.push_back(std::make_pair(D, Loc));
4682  }
4683  PendingInstantiations.clear();
4684}
4685
4686void ASTReader::LoadSelector(Selector Sel) {
4687  // It would be complicated to avoid reading the methods anyway. So don't.
4688  ReadMethodPool(Sel);
4689}
4690
4691void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
4692  assert(ID && "Non-zero identifier ID required");
4693  assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
4694  IdentifiersLoaded[ID - 1] = II;
4695  if (DeserializationListener)
4696    DeserializationListener->IdentifierRead(ID, II);
4697}
4698
4699/// \brief Set the globally-visible declarations associated with the given
4700/// identifier.
4701///
4702/// If the AST reader is currently in a state where the given declaration IDs
4703/// cannot safely be resolved, they are queued until it is safe to resolve
4704/// them.
4705///
4706/// \param II an IdentifierInfo that refers to one or more globally-visible
4707/// declarations.
4708///
4709/// \param DeclIDs the set of declaration IDs with the name @p II that are
4710/// visible at global scope.
4711///
4712/// \param Nonrecursive should be true to indicate that the caller knows that
4713/// this call is non-recursive, and therefore the globally-visible declarations
4714/// will not be placed onto the pending queue.
4715void
4716ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
4717                              const SmallVectorImpl<uint32_t> &DeclIDs,
4718                                   bool Nonrecursive) {
4719  if (NumCurrentElementsDeserializing && !Nonrecursive) {
4720    PendingIdentifierInfos.push_back(PendingIdentifierInfo());
4721    PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
4722    PII.II = II;
4723    PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end());
4724    return;
4725  }
4726
4727  for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
4728    NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
4729    if (SemaObj) {
4730      if (SemaObj->TUScope) {
4731        // Introduce this declaration into the translation-unit scope
4732        // and add it to the declaration chain for this identifier, so
4733        // that (unqualified) name lookup will find it.
4734        SemaObj->TUScope->AddDecl(D);
4735      }
4736      SemaObj->IdResolver.AddDeclToIdentifierChain(II, D);
4737    } else {
4738      // Queue this declaration so that it will be added to the
4739      // translation unit scope and identifier's declaration chain
4740      // once a Sema object is known.
4741      PreloadedDecls.push_back(D);
4742    }
4743  }
4744}
4745
4746IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
4747  if (ID == 0)
4748    return 0;
4749
4750  if (IdentifiersLoaded.empty()) {
4751    Error("no identifier table in AST file");
4752    return 0;
4753  }
4754
4755  assert(PP && "Forgot to set Preprocessor ?");
4756  ID -= 1;
4757  if (!IdentifiersLoaded[ID]) {
4758    GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
4759    assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
4760    Module *M = I->second;
4761    unsigned Index = ID - M->BaseIdentifierID;
4762    const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
4763
4764    // All of the strings in the AST file are preceded by a 16-bit length.
4765    // Extract that 16-bit length to avoid having to execute strlen().
4766    // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
4767    //  unsigned integers.  This is important to avoid integer overflow when
4768    //  we cast them to 'unsigned'.
4769    const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
4770    unsigned StrLen = (((unsigned) StrLenPtr[0])
4771                       | (((unsigned) StrLenPtr[1]) << 8)) - 1;
4772    IdentifiersLoaded[ID]
4773      = &PP->getIdentifierTable().get(StringRef(Str, StrLen));
4774    if (DeserializationListener)
4775      DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
4776  }
4777
4778  return IdentifiersLoaded[ID];
4779}
4780
4781IdentifierInfo *ASTReader::getLocalIdentifier(Module &M, unsigned LocalID) {
4782  return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
4783}
4784
4785IdentifierID ASTReader::getGlobalIdentifierID(Module &M, unsigned LocalID) {
4786  // FIXME: Perform local-to-global remapping
4787  return LocalID;
4788}
4789
4790bool ASTReader::ReadSLocEntry(int ID) {
4791  return ReadSLocEntryRecord(ID) != Success;
4792}
4793
4794Selector ASTReader::getLocalSelector(Module &M, unsigned LocalID) {
4795  return DecodeSelector(getGlobalSelectorID(M, LocalID));
4796}
4797
4798Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
4799  if (ID == 0)
4800    return Selector();
4801
4802  if (ID > SelectorsLoaded.size()) {
4803    Error("selector ID out of range in AST file");
4804    return Selector();
4805  }
4806
4807  if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
4808    // Load this selector from the selector table.
4809    GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
4810    assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
4811    Module &M = *I->second;
4812    ASTSelectorLookupTrait Trait(*this, M);
4813    unsigned Idx = ID - 1 - M.BaseSelectorID;
4814    SelectorsLoaded[ID - 1] =
4815      Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
4816    if (DeserializationListener)
4817      DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
4818  }
4819
4820  return SelectorsLoaded[ID - 1];
4821}
4822
4823Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
4824  return DecodeSelector(ID);
4825}
4826
4827uint32_t ASTReader::GetNumExternalSelectors() {
4828  // ID 0 (the null selector) is considered an external selector.
4829  return getTotalNumSelectors() + 1;
4830}
4831
4832serialization::SelectorID
4833ASTReader::getGlobalSelectorID(Module &F, unsigned LocalID) const {
4834  // FIXME: Perform local -> global remapping
4835  return LocalID;
4836}
4837
4838DeclarationName
4839ASTReader::ReadDeclarationName(Module &F,
4840                               const RecordData &Record, unsigned &Idx) {
4841  DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
4842  switch (Kind) {
4843  case DeclarationName::Identifier:
4844    return DeclarationName(GetIdentifierInfo(F, Record, Idx));
4845
4846  case DeclarationName::ObjCZeroArgSelector:
4847  case DeclarationName::ObjCOneArgSelector:
4848  case DeclarationName::ObjCMultiArgSelector:
4849    return DeclarationName(ReadSelector(F, Record, Idx));
4850
4851  case DeclarationName::CXXConstructorName:
4852    return Context->DeclarationNames.getCXXConstructorName(
4853                          Context->getCanonicalType(readType(F, Record, Idx)));
4854
4855  case DeclarationName::CXXDestructorName:
4856    return Context->DeclarationNames.getCXXDestructorName(
4857                          Context->getCanonicalType(readType(F, Record, Idx)));
4858
4859  case DeclarationName::CXXConversionFunctionName:
4860    return Context->DeclarationNames.getCXXConversionFunctionName(
4861                          Context->getCanonicalType(readType(F, Record, Idx)));
4862
4863  case DeclarationName::CXXOperatorName:
4864    return Context->DeclarationNames.getCXXOperatorName(
4865                                       (OverloadedOperatorKind)Record[Idx++]);
4866
4867  case DeclarationName::CXXLiteralOperatorName:
4868    return Context->DeclarationNames.getCXXLiteralOperatorName(
4869                                       GetIdentifierInfo(F, Record, Idx));
4870
4871  case DeclarationName::CXXUsingDirective:
4872    return DeclarationName::getUsingDirectiveName();
4873  }
4874
4875  // Required to silence GCC warning
4876  return DeclarationName();
4877}
4878
4879void ASTReader::ReadDeclarationNameLoc(Module &F,
4880                                       DeclarationNameLoc &DNLoc,
4881                                       DeclarationName Name,
4882                                      const RecordData &Record, unsigned &Idx) {
4883  switch (Name.getNameKind()) {
4884  case DeclarationName::CXXConstructorName:
4885  case DeclarationName::CXXDestructorName:
4886  case DeclarationName::CXXConversionFunctionName:
4887    DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
4888    break;
4889
4890  case DeclarationName::CXXOperatorName:
4891    DNLoc.CXXOperatorName.BeginOpNameLoc
4892        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4893    DNLoc.CXXOperatorName.EndOpNameLoc
4894        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4895    break;
4896
4897  case DeclarationName::CXXLiteralOperatorName:
4898    DNLoc.CXXLiteralOperatorName.OpNameLoc
4899        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4900    break;
4901
4902  case DeclarationName::Identifier:
4903  case DeclarationName::ObjCZeroArgSelector:
4904  case DeclarationName::ObjCOneArgSelector:
4905  case DeclarationName::ObjCMultiArgSelector:
4906  case DeclarationName::CXXUsingDirective:
4907    break;
4908  }
4909}
4910
4911void ASTReader::ReadDeclarationNameInfo(Module &F,
4912                                        DeclarationNameInfo &NameInfo,
4913                                      const RecordData &Record, unsigned &Idx) {
4914  NameInfo.setName(ReadDeclarationName(F, Record, Idx));
4915  NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
4916  DeclarationNameLoc DNLoc;
4917  ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
4918  NameInfo.setInfo(DNLoc);
4919}
4920
4921void ASTReader::ReadQualifierInfo(Module &F, QualifierInfo &Info,
4922                                  const RecordData &Record, unsigned &Idx) {
4923  Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
4924  unsigned NumTPLists = Record[Idx++];
4925  Info.NumTemplParamLists = NumTPLists;
4926  if (NumTPLists) {
4927    Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists];
4928    for (unsigned i=0; i != NumTPLists; ++i)
4929      Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
4930  }
4931}
4932
4933TemplateName
4934ASTReader::ReadTemplateName(Module &F, const RecordData &Record,
4935                            unsigned &Idx) {
4936  TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
4937  switch (Kind) {
4938  case TemplateName::Template:
4939      return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
4940
4941  case TemplateName::OverloadedTemplate: {
4942    unsigned size = Record[Idx++];
4943    UnresolvedSet<8> Decls;
4944    while (size--)
4945      Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
4946
4947    return Context->getOverloadedTemplateName(Decls.begin(), Decls.end());
4948  }
4949
4950  case TemplateName::QualifiedTemplate: {
4951    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
4952    bool hasTemplKeyword = Record[Idx++];
4953    TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
4954    return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
4955  }
4956
4957  case TemplateName::DependentTemplate: {
4958    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
4959    if (Record[Idx++])  // isIdentifier
4960      return Context->getDependentTemplateName(NNS,
4961                                               GetIdentifierInfo(F, Record,
4962                                                                 Idx));
4963    return Context->getDependentTemplateName(NNS,
4964                                         (OverloadedOperatorKind)Record[Idx++]);
4965  }
4966
4967  case TemplateName::SubstTemplateTemplateParm: {
4968    TemplateTemplateParmDecl *param
4969      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
4970    if (!param) return TemplateName();
4971    TemplateName replacement = ReadTemplateName(F, Record, Idx);
4972    return Context->getSubstTemplateTemplateParm(param, replacement);
4973  }
4974
4975  case TemplateName::SubstTemplateTemplateParmPack: {
4976    TemplateTemplateParmDecl *Param
4977      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
4978    if (!Param)
4979      return TemplateName();
4980
4981    TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
4982    if (ArgPack.getKind() != TemplateArgument::Pack)
4983      return TemplateName();
4984
4985    return Context->getSubstTemplateTemplateParmPack(Param, ArgPack);
4986  }
4987  }
4988
4989  assert(0 && "Unhandled template name kind!");
4990  return TemplateName();
4991}
4992
4993TemplateArgument
4994ASTReader::ReadTemplateArgument(Module &F,
4995                                const RecordData &Record, unsigned &Idx) {
4996  TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
4997  switch (Kind) {
4998  case TemplateArgument::Null:
4999    return TemplateArgument();
5000  case TemplateArgument::Type:
5001    return TemplateArgument(readType(F, Record, Idx));
5002  case TemplateArgument::Declaration:
5003    return TemplateArgument(ReadDecl(F, Record, Idx));
5004  case TemplateArgument::Integral: {
5005    llvm::APSInt Value = ReadAPSInt(Record, Idx);
5006    QualType T = readType(F, Record, Idx);
5007    return TemplateArgument(Value, T);
5008  }
5009  case TemplateArgument::Template:
5010    return TemplateArgument(ReadTemplateName(F, Record, Idx));
5011  case TemplateArgument::TemplateExpansion: {
5012    TemplateName Name = ReadTemplateName(F, Record, Idx);
5013    llvm::Optional<unsigned> NumTemplateExpansions;
5014    if (unsigned NumExpansions = Record[Idx++])
5015      NumTemplateExpansions = NumExpansions - 1;
5016    return TemplateArgument(Name, NumTemplateExpansions);
5017  }
5018  case TemplateArgument::Expression:
5019    return TemplateArgument(ReadExpr(F));
5020  case TemplateArgument::Pack: {
5021    unsigned NumArgs = Record[Idx++];
5022    TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs];
5023    for (unsigned I = 0; I != NumArgs; ++I)
5024      Args[I] = ReadTemplateArgument(F, Record, Idx);
5025    return TemplateArgument(Args, NumArgs);
5026  }
5027  }
5028
5029  assert(0 && "Unhandled template argument kind!");
5030  return TemplateArgument();
5031}
5032
5033TemplateParameterList *
5034ASTReader::ReadTemplateParameterList(Module &F,
5035                                     const RecordData &Record, unsigned &Idx) {
5036  SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
5037  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
5038  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
5039
5040  unsigned NumParams = Record[Idx++];
5041  SmallVector<NamedDecl *, 16> Params;
5042  Params.reserve(NumParams);
5043  while (NumParams--)
5044    Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
5045
5046  TemplateParameterList* TemplateParams =
5047    TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc,
5048                                  Params.data(), Params.size(), RAngleLoc);
5049  return TemplateParams;
5050}
5051
5052void
5053ASTReader::
5054ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs,
5055                         Module &F, const RecordData &Record,
5056                         unsigned &Idx) {
5057  unsigned NumTemplateArgs = Record[Idx++];
5058  TemplArgs.reserve(NumTemplateArgs);
5059  while (NumTemplateArgs--)
5060    TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
5061}
5062
5063/// \brief Read a UnresolvedSet structure.
5064void ASTReader::ReadUnresolvedSet(Module &F, UnresolvedSetImpl &Set,
5065                                  const RecordData &Record, unsigned &Idx) {
5066  unsigned NumDecls = Record[Idx++];
5067  while (NumDecls--) {
5068    NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx);
5069    AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
5070    Set.addDecl(D, AS);
5071  }
5072}
5073
5074CXXBaseSpecifier
5075ASTReader::ReadCXXBaseSpecifier(Module &F,
5076                                const RecordData &Record, unsigned &Idx) {
5077  bool isVirtual = static_cast<bool>(Record[Idx++]);
5078  bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
5079  AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
5080  bool inheritConstructors = static_cast<bool>(Record[Idx++]);
5081  TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
5082  SourceRange Range = ReadSourceRange(F, Record, Idx);
5083  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
5084  CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
5085                          EllipsisLoc);
5086  Result.setInheritConstructors(inheritConstructors);
5087  return Result;
5088}
5089
5090std::pair<CXXCtorInitializer **, unsigned>
5091ASTReader::ReadCXXCtorInitializers(Module &F, const RecordData &Record,
5092                                   unsigned &Idx) {
5093  CXXCtorInitializer **CtorInitializers = 0;
5094  unsigned NumInitializers = Record[Idx++];
5095  if (NumInitializers) {
5096    ASTContext &C = *getContext();
5097
5098    CtorInitializers
5099        = new (C) CXXCtorInitializer*[NumInitializers];
5100    for (unsigned i=0; i != NumInitializers; ++i) {
5101      TypeSourceInfo *BaseClassInfo = 0;
5102      bool IsBaseVirtual = false;
5103      FieldDecl *Member = 0;
5104      IndirectFieldDecl *IndirectMember = 0;
5105      CXXConstructorDecl *Target = 0;
5106
5107      CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
5108      switch (Type) {
5109       case CTOR_INITIALIZER_BASE:
5110        BaseClassInfo = GetTypeSourceInfo(F, Record, Idx);
5111        IsBaseVirtual = Record[Idx++];
5112        break;
5113
5114       case CTOR_INITIALIZER_DELEGATING:
5115        Target = ReadDeclAs<CXXConstructorDecl>(F, Record, Idx);
5116        break;
5117
5118       case CTOR_INITIALIZER_MEMBER:
5119        Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
5120        break;
5121
5122       case CTOR_INITIALIZER_INDIRECT_MEMBER:
5123        IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
5124        break;
5125      }
5126
5127      SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
5128      Expr *Init = ReadExpr(F);
5129      SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
5130      SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
5131      bool IsWritten = Record[Idx++];
5132      unsigned SourceOrderOrNumArrayIndices;
5133      SmallVector<VarDecl *, 8> Indices;
5134      if (IsWritten) {
5135        SourceOrderOrNumArrayIndices = Record[Idx++];
5136      } else {
5137        SourceOrderOrNumArrayIndices = Record[Idx++];
5138        Indices.reserve(SourceOrderOrNumArrayIndices);
5139        for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
5140          Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
5141      }
5142
5143      CXXCtorInitializer *BOMInit;
5144      if (Type == CTOR_INITIALIZER_BASE) {
5145        BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual,
5146                                             LParenLoc, Init, RParenLoc,
5147                                             MemberOrEllipsisLoc);
5148      } else if (Type == CTOR_INITIALIZER_DELEGATING) {
5149        BOMInit = new (C) CXXCtorInitializer(C, MemberOrEllipsisLoc, LParenLoc,
5150                                             Target, Init, RParenLoc);
5151      } else if (IsWritten) {
5152        if (Member)
5153          BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc,
5154                                               LParenLoc, Init, RParenLoc);
5155        else
5156          BOMInit = new (C) CXXCtorInitializer(C, IndirectMember,
5157                                               MemberOrEllipsisLoc, LParenLoc,
5158                                               Init, RParenLoc);
5159      } else {
5160        BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc,
5161                                             LParenLoc, Init, RParenLoc,
5162                                             Indices.data(), Indices.size());
5163      }
5164
5165      if (IsWritten)
5166        BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
5167      CtorInitializers[i] = BOMInit;
5168    }
5169  }
5170
5171  return std::make_pair(CtorInitializers, NumInitializers);
5172}
5173
5174NestedNameSpecifier *
5175ASTReader::ReadNestedNameSpecifier(Module &F,
5176                                   const RecordData &Record, unsigned &Idx) {
5177  unsigned N = Record[Idx++];
5178  NestedNameSpecifier *NNS = 0, *Prev = 0;
5179  for (unsigned I = 0; I != N; ++I) {
5180    NestedNameSpecifier::SpecifierKind Kind
5181      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5182    switch (Kind) {
5183    case NestedNameSpecifier::Identifier: {
5184      IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
5185      NNS = NestedNameSpecifier::Create(*Context, Prev, II);
5186      break;
5187    }
5188
5189    case NestedNameSpecifier::Namespace: {
5190      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
5191      NNS = NestedNameSpecifier::Create(*Context, Prev, NS);
5192      break;
5193    }
5194
5195    case NestedNameSpecifier::NamespaceAlias: {
5196      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
5197      NNS = NestedNameSpecifier::Create(*Context, Prev, Alias);
5198      break;
5199    }
5200
5201    case NestedNameSpecifier::TypeSpec:
5202    case NestedNameSpecifier::TypeSpecWithTemplate: {
5203      const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
5204      if (!T)
5205        return 0;
5206
5207      bool Template = Record[Idx++];
5208      NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T);
5209      break;
5210    }
5211
5212    case NestedNameSpecifier::Global: {
5213      NNS = NestedNameSpecifier::GlobalSpecifier(*Context);
5214      // No associated value, and there can't be a prefix.
5215      break;
5216    }
5217    }
5218    Prev = NNS;
5219  }
5220  return NNS;
5221}
5222
5223NestedNameSpecifierLoc
5224ASTReader::ReadNestedNameSpecifierLoc(Module &F, const RecordData &Record,
5225                                      unsigned &Idx) {
5226  unsigned N = Record[Idx++];
5227  NestedNameSpecifierLocBuilder Builder;
5228  for (unsigned I = 0; I != N; ++I) {
5229    NestedNameSpecifier::SpecifierKind Kind
5230      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5231    switch (Kind) {
5232    case NestedNameSpecifier::Identifier: {
5233      IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
5234      SourceRange Range = ReadSourceRange(F, Record, Idx);
5235      Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd());
5236      break;
5237    }
5238
5239    case NestedNameSpecifier::Namespace: {
5240      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
5241      SourceRange Range = ReadSourceRange(F, Record, Idx);
5242      Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd());
5243      break;
5244    }
5245
5246    case NestedNameSpecifier::NamespaceAlias: {
5247      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
5248      SourceRange Range = ReadSourceRange(F, Record, Idx);
5249      Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd());
5250      break;
5251    }
5252
5253    case NestedNameSpecifier::TypeSpec:
5254    case NestedNameSpecifier::TypeSpecWithTemplate: {
5255      bool Template = Record[Idx++];
5256      TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
5257      if (!T)
5258        return NestedNameSpecifierLoc();
5259      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5260
5261      // FIXME: 'template' keyword location not saved anywhere, so we fake it.
5262      Builder.Extend(*Context,
5263                     Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
5264                     T->getTypeLoc(), ColonColonLoc);
5265      break;
5266    }
5267
5268    case NestedNameSpecifier::Global: {
5269      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5270      Builder.MakeGlobal(*Context, ColonColonLoc);
5271      break;
5272    }
5273    }
5274  }
5275
5276  return Builder.getWithLocInContext(*Context);
5277}
5278
5279SourceRange
5280ASTReader::ReadSourceRange(Module &F, const RecordData &Record,
5281                           unsigned &Idx) {
5282  SourceLocation beg = ReadSourceLocation(F, Record, Idx);
5283  SourceLocation end = ReadSourceLocation(F, Record, Idx);
5284  return SourceRange(beg, end);
5285}
5286
5287/// \brief Read an integral value
5288llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
5289  unsigned BitWidth = Record[Idx++];
5290  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
5291  llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
5292  Idx += NumWords;
5293  return Result;
5294}
5295
5296/// \brief Read a signed integral value
5297llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
5298  bool isUnsigned = Record[Idx++];
5299  return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
5300}
5301
5302/// \brief Read a floating-point value
5303llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
5304  return llvm::APFloat(ReadAPInt(Record, Idx));
5305}
5306
5307// \brief Read a string
5308std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
5309  unsigned Len = Record[Idx++];
5310  std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
5311  Idx += Len;
5312  return Result;
5313}
5314
5315VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
5316                                         unsigned &Idx) {
5317  unsigned Major = Record[Idx++];
5318  unsigned Minor = Record[Idx++];
5319  unsigned Subminor = Record[Idx++];
5320  if (Minor == 0)
5321    return VersionTuple(Major);
5322  if (Subminor == 0)
5323    return VersionTuple(Major, Minor - 1);
5324  return VersionTuple(Major, Minor - 1, Subminor - 1);
5325}
5326
5327CXXTemporary *ASTReader::ReadCXXTemporary(Module &F,
5328                                          const RecordData &Record,
5329                                          unsigned &Idx) {
5330  CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
5331  return CXXTemporary::Create(*Context, Decl);
5332}
5333
5334DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
5335  return Diag(SourceLocation(), DiagID);
5336}
5337
5338DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
5339  return Diags.Report(Loc, DiagID);
5340}
5341
5342/// \brief Retrieve the identifier table associated with the
5343/// preprocessor.
5344IdentifierTable &ASTReader::getIdentifierTable() {
5345  assert(PP && "Forgot to set Preprocessor ?");
5346  return PP->getIdentifierTable();
5347}
5348
5349/// \brief Record that the given ID maps to the given switch-case
5350/// statement.
5351void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
5352  assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
5353  SwitchCaseStmts[ID] = SC;
5354}
5355
5356/// \brief Retrieve the switch-case statement with the given ID.
5357SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
5358  assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
5359  return SwitchCaseStmts[ID];
5360}
5361
5362void ASTReader::ClearSwitchCaseIDs() {
5363  SwitchCaseStmts.clear();
5364}
5365
5366void ASTReader::FinishedDeserializing() {
5367  assert(NumCurrentElementsDeserializing &&
5368         "FinishedDeserializing not paired with StartedDeserializing");
5369  if (NumCurrentElementsDeserializing == 1) {
5370    // If any identifiers with corresponding top-level declarations have
5371    // been loaded, load those declarations now.
5372    while (!PendingIdentifierInfos.empty()) {
5373      SetGloballyVisibleDecls(PendingIdentifierInfos.front().II,
5374                              PendingIdentifierInfos.front().DeclIDs, true);
5375      PendingIdentifierInfos.pop_front();
5376    }
5377
5378    // Ready to load previous declarations of Decls that were delayed.
5379    while (!PendingPreviousDecls.empty()) {
5380      loadAndAttachPreviousDecl(PendingPreviousDecls.front().first,
5381                                PendingPreviousDecls.front().second);
5382      PendingPreviousDecls.pop_front();
5383    }
5384
5385    // We are not in recursive loading, so it's safe to pass the "interesting"
5386    // decls to the consumer.
5387    if (Consumer)
5388      PassInterestingDeclsToConsumer();
5389
5390    assert(PendingForwardRefs.size() == 0 &&
5391           "Some forward refs did not get linked to the definition!");
5392  }
5393  --NumCurrentElementsDeserializing;
5394}
5395
5396ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context,
5397                     StringRef isysroot, bool DisableValidation,
5398                     bool DisableStatCache)
5399  : Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
5400    SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
5401    Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context),
5402    Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
5403    RelocatablePCH(false), isysroot(isysroot),
5404    DisableValidation(DisableValidation),
5405    DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
5406    NumSLocEntriesRead(0), TotalNumSLocEntries(0),
5407    NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
5408    TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
5409    NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0),
5410    NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
5411    NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
5412    TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
5413    NumCXXBaseSpecifiersLoaded(0)
5414{
5415  SourceMgr.setExternalSLocEntrySource(this);
5416}
5417
5418ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr,
5419                     Diagnostic &Diags, StringRef isysroot,
5420                     bool DisableValidation, bool DisableStatCache)
5421  : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr),
5422    Diags(Diags), SemaObj(0), PP(0), Context(0),
5423    Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
5424    RelocatablePCH(false), isysroot(isysroot),
5425    DisableValidation(DisableValidation), DisableStatCache(DisableStatCache),
5426    NumStatHits(0), NumStatMisses(0), NumSLocEntriesRead(0),
5427    TotalNumSLocEntries(0), NumStatementsRead(0),
5428    TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0),
5429    NumSelectorsRead(0), NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0),
5430    TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0),
5431    TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0),
5432    TotalVisibleDeclContexts(0), TotalModulesSizeInBits(0),
5433    NumCurrentElementsDeserializing(0), NumCXXBaseSpecifiersLoaded(0)
5434{
5435  SourceMgr.setExternalSLocEntrySource(this);
5436}
5437
5438ASTReader::~ASTReader() {
5439  // Delete all visible decl lookup tables
5440  for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(),
5441                                       E = DeclContextOffsets.end();
5442       I != E; ++I) {
5443    for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end();
5444         J != F; ++J) {
5445      if (J->NameLookupTableData)
5446        delete static_cast<ASTDeclContextNameLookupTable*>(
5447            J->NameLookupTableData);
5448    }
5449  }
5450  for (DeclContextVisibleUpdatesPending::iterator
5451           I = PendingVisibleUpdates.begin(),
5452           E = PendingVisibleUpdates.end();
5453       I != E; ++I) {
5454    for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
5455                                             F = I->second.end();
5456         J != F; ++J)
5457      delete static_cast<ASTDeclContextNameLookupTable*>(*J);
5458  }
5459}
5460
5461Module::Module(ModuleKind Kind)
5462  : Kind(Kind), SizeInBits(0), LocalNumSLocEntries(0), SLocEntryBaseID(0),
5463    SLocEntryBaseOffset(0), SLocEntryOffsets(0),
5464    SLocFileOffsets(0), LocalNumIdentifiers(0),
5465    IdentifierOffsets(0), BaseIdentifierID(0), IdentifierTableData(0),
5466    IdentifierLookupTable(0), BasePreprocessedEntityID(0),
5467    LocalNumMacroDefinitions(0), MacroDefinitionOffsets(0),
5468    BaseMacroDefinitionID(0), LocalNumHeaderFileInfos(0),
5469    HeaderFileInfoTableData(0), HeaderFileInfoTable(0),
5470    HeaderFileFrameworkStrings(0),
5471    LocalNumSelectors(0), SelectorOffsets(0), BaseSelectorID(0),
5472    SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0),
5473    DeclOffsets(0), BaseDeclID(0),
5474    LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0),
5475    BaseCXXBaseSpecifiersID(0),
5476    LocalNumTypes(0), TypeOffsets(0), BaseTypeID(0), StatCache(0),
5477    NumPreallocatedPreprocessingEntities(0)
5478{}
5479
5480Module::~Module() {
5481  delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable);
5482  delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable);
5483  delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable);
5484}
5485
5486template<typename Key, typename Offset, unsigned InitialCapacity>
5487static void
5488dumpLocalRemap(StringRef Name,
5489               const ContinuousRangeMap<Key, Offset, InitialCapacity> &Map) {
5490  if (Map.begin() == Map.end())
5491    return;
5492
5493  typedef ContinuousRangeMap<Key, Offset, InitialCapacity> MapType;
5494  llvm::errs() << "  " << Name << ":\n";
5495  for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
5496       I != IEnd; ++I) {
5497    llvm::errs() << "    " << I->first << " -> " << I->second
5498    << "\n";
5499  }
5500}
5501
5502void Module::dump() {
5503  llvm::errs() << "\nModule: " << FileName << "\n";
5504  if (!Imports.empty()) {
5505    llvm::errs() << "  Imports: ";
5506    for (unsigned I = 0, N = Imports.size(); I != N; ++I) {
5507      if (I)
5508        llvm::errs() << ", ";
5509      llvm::errs() << Imports[I]->FileName;
5510    }
5511    llvm::errs() << "\n";
5512  }
5513
5514  // Remapping tables.
5515  llvm::errs() << "  Base source location offset: " << SLocEntryBaseOffset
5516               << '\n';
5517  dumpLocalRemap("Source location offset map", SLocRemap);
5518}
5519
5520Module *ModuleManager::lookup(StringRef Name) {
5521  const FileEntry *Entry = FileMgr.getFile(Name);
5522  return Modules[Entry];
5523}
5524
5525/// \brief Creates a new module and adds it to the list of known modules
5526Module &ModuleManager::addModule(StringRef FileName, ModuleKind Type) {
5527  Module *Prev = !size() ? 0 : &getLastModule();
5528  Module *Current = new Module(Type);
5529
5530  Current->FileName = FileName.str();
5531
5532  Chain.push_back(Current);
5533  const FileEntry *Entry = FileMgr.getFile(FileName);
5534  Modules[Entry] = Current;
5535
5536  if (Prev) {
5537    Current->ImportedBy.insert(Prev);
5538    Prev->Imports.insert(Current);
5539  }
5540
5541  return *Current;
5542}
5543
5544/// \brief Exports the list of loaded modules with their corresponding names
5545void ModuleManager::exportLookup(SmallVector<ModuleOffset, 16> &Target) {
5546  Target.reserve(size());
5547  for (ModuleConstIterator I = Chain.begin(), E = Chain.end();
5548       I != E; ++I) {
5549    Target.push_back(ModuleOffset((*I)->SLocEntryBaseOffset,
5550                                  (*I)->FileName));
5551  }
5552  std::sort(Target.begin(), Target.end());
5553}
5554
5555ModuleManager::ModuleManager(const FileSystemOptions &FSO) : FileMgr(FSO) { }
5556
5557ModuleManager::~ModuleManager() {
5558  for (unsigned i = 0, e = Chain.size(); i != e; ++i)
5559    delete Chain[e - i - 1];
5560}
5561